python assignment expression invalid syntax

Python Enhancement Proposals

• Python »
• PEP Index »

PEP 572 – Assignment Expressions

The importance of real code, exceptional cases, scope of the target, relative precedence of :=, change to evaluation order, differences between assignment expressions and assignment statements, specification changes during implementation, _pydecimal.py, datetime.py, sysconfig.py, simplifying list comprehensions, capturing condition values, changing the scope rules for comprehensions, alternative spellings, special-casing conditional statements, special-casing comprehensions, lowering operator precedence, allowing commas to the right, always requiring parentheses, why not just turn existing assignment into an expression, with assignment expressions, why bother with assignment statements, why not use a sublocal scope and prevent namespace pollution, style guide recommendations, acknowledgements, a numeric example, appendix b: rough code translations for comprehensions, appendix c: no changes to scope semantics.

This is a proposal for creating a way to assign to variables within an expression using the notation NAME := expr .

As part of this change, there is also an update to dictionary comprehension evaluation order to ensure key expressions are executed before value expressions (allowing the key to be bound to a name and then re-used as part of calculating the corresponding value).

During discussion of this PEP, the operator became informally known as “the walrus operator”. The construct’s formal name is “Assignment Expressions” (as per the PEP title), but they may also be referred to as “Named Expressions” (e.g. the CPython reference implementation uses that name internally).

Naming the result of an expression is an important part of programming, allowing a descriptive name to be used in place of a longer expression, and permitting reuse. Currently, this feature is available only in statement form, making it unavailable in list comprehensions and other expression contexts.

Additionally, naming sub-parts of a large expression can assist an interactive debugger, providing useful display hooks and partial results. Without a way to capture sub-expressions inline, this would require refactoring of the original code; with assignment expressions, this merely requires the insertion of a few name := markers. Removing the need to refactor reduces the likelihood that the code be inadvertently changed as part of debugging (a common cause of Heisenbugs), and is easier to dictate to another programmer.

During the development of this PEP many people (supporters and critics both) have had a tendency to focus on toy examples on the one hand, and on overly complex examples on the other.

The danger of toy examples is twofold: they are often too abstract to make anyone go “ooh, that’s compelling”, and they are easily refuted with “I would never write it that way anyway”.

The danger of overly complex examples is that they provide a convenient strawman for critics of the proposal to shoot down (“that’s obfuscated”).

Yet there is some use for both extremely simple and extremely complex examples: they are helpful to clarify the intended semantics. Therefore, there will be some of each below.

However, in order to be compelling , examples should be rooted in real code, i.e. code that was written without any thought of this PEP, as part of a useful application, however large or small. Tim Peters has been extremely helpful by going over his own personal code repository and picking examples of code he had written that (in his view) would have been clearer if rewritten with (sparing) use of assignment expressions. His conclusion: the current proposal would have allowed a modest but clear improvement in quite a few bits of code.

Another use of real code is to observe indirectly how much value programmers place on compactness. Guido van Rossum searched through a Dropbox code base and discovered some evidence that programmers value writing fewer lines over shorter lines.

Case in point: Guido found several examples where a programmer repeated a subexpression, slowing down the program, in order to save one line of code, e.g. instead of writing:

they would write:

Another example illustrates that programmers sometimes do more work to save an extra level of indentation:

This code tries to match pattern2 even if pattern1 has a match (in which case the match on pattern2 is never used). The more efficient rewrite would have been:

Syntax and semantics

In most contexts where arbitrary Python expressions can be used, a named expression can appear. This is of the form NAME := expr where expr is any valid Python expression other than an unparenthesized tuple, and NAME is an identifier.

The value of such a named expression is the same as the incorporated expression, with the additional side-effect that the target is assigned that value:

There are a few places where assignment expressions are not allowed, in order to avoid ambiguities or user confusion:

This rule is included to simplify the choice for the user between an assignment statement and an assignment expression – there is no syntactic position where both are valid.

Again, this rule is included to avoid two visually similar ways of saying the same thing.

This rule is included to disallow excessively confusing code, and because parsing keyword arguments is complex enough already.

This rule is included to discourage side effects in a position whose exact semantics are already confusing to many users (cf. the common style recommendation against mutable default values), and also to echo the similar prohibition in calls (the previous bullet).

The reasoning here is similar to the two previous cases; this ungrouped assortment of symbols and operators composed of : and = is hard to read correctly.

This allows lambda to always bind less tightly than := ; having a name binding at the top level inside a lambda function is unlikely to be of value, as there is no way to make use of it. In cases where the name will be used more than once, the expression is likely to need parenthesizing anyway, so this prohibition will rarely affect code.

This shows that what looks like an assignment operator in an f-string is not always an assignment operator. The f-string parser uses : to indicate formatting options. To preserve backwards compatibility, assignment operator usage inside of f-strings must be parenthesized. As noted above, this usage of the assignment operator is not recommended.

An assignment expression does not introduce a new scope. In most cases the scope in which the target will be bound is self-explanatory: it is the current scope. If this scope contains a nonlocal or global declaration for the target, the assignment expression honors that. A lambda (being an explicit, if anonymous, function definition) counts as a scope for this purpose.

There is one special case: an assignment expression occurring in a list, set or dict comprehension or in a generator expression (below collectively referred to as “comprehensions”) binds the target in the containing scope, honoring a nonlocal or global declaration for the target in that scope, if one exists. For the purpose of this rule the containing scope of a nested comprehension is the scope that contains the outermost comprehension. A lambda counts as a containing scope.

The motivation for this special case is twofold. First, it allows us to conveniently capture a “witness” for an any() expression, or a counterexample for all() , for example:

Second, it allows a compact way of updating mutable state from a comprehension, for example:

However, an assignment expression target name cannot be the same as a for -target name appearing in any comprehension containing the assignment expression. The latter names are local to the comprehension in which they appear, so it would be contradictory for a contained use of the same name to refer to the scope containing the outermost comprehension instead.

For example, [i := i+1 for i in range(5)] is invalid: the for i part establishes that i is local to the comprehension, but the i := part insists that i is not local to the comprehension. The same reason makes these examples invalid too:

While it’s technically possible to assign consistent semantics to these cases, it’s difficult to determine whether those semantics actually make sense in the absence of real use cases. Accordingly, the reference implementation [1] will ensure that such cases raise SyntaxError , rather than executing with implementation defined behaviour.

This restriction applies even if the assignment expression is never executed:

For the comprehension body (the part before the first “for” keyword) and the filter expression (the part after “if” and before any nested “for”), this restriction applies solely to target names that are also used as iteration variables in the comprehension. Lambda expressions appearing in these positions introduce a new explicit function scope, and hence may use assignment expressions with no additional restrictions.

Due to design constraints in the reference implementation (the symbol table analyser cannot easily detect when names are re-used between the leftmost comprehension iterable expression and the rest of the comprehension), named expressions are disallowed entirely as part of comprehension iterable expressions (the part after each “in”, and before any subsequent “if” or “for” keyword):

A further exception applies when an assignment expression occurs in a comprehension whose containing scope is a class scope. If the rules above were to result in the target being assigned in that class’s scope, the assignment expression is expressly invalid. This case also raises SyntaxError :

(The reason for the latter exception is the implicit function scope created for comprehensions – there is currently no runtime mechanism for a function to refer to a variable in the containing class scope, and we do not want to add such a mechanism. If this issue ever gets resolved this special case may be removed from the specification of assignment expressions. Note that the problem already exists for using a variable defined in the class scope from a comprehension.)

See Appendix B for some examples of how the rules for targets in comprehensions translate to equivalent code.

The := operator groups more tightly than a comma in all syntactic positions where it is legal, but less tightly than all other operators, including or , and , not , and conditional expressions ( A if C else B ). As follows from section “Exceptional cases” above, it is never allowed at the same level as = . In case a different grouping is desired, parentheses should be used.

The := operator may be used directly in a positional function call argument; however it is invalid directly in a keyword argument.

Some examples to clarify what’s technically valid or invalid:

Most of the “valid” examples above are not recommended, since human readers of Python source code who are quickly glancing at some code may miss the distinction. But simple cases are not objectionable:

This PEP recommends always putting spaces around := , similar to PEP 8 ’s recommendation for = when used for assignment, whereas the latter disallows spaces around = used for keyword arguments.)

In order to have precisely defined semantics, the proposal requires evaluation order to be well-defined. This is technically not a new requirement, as function calls may already have side effects. Python already has a rule that subexpressions are generally evaluated from left to right. However, assignment expressions make these side effects more visible, and we propose a single change to the current evaluation order:

• In a dict comprehension {X: Y for ...} , Y is currently evaluated before X . We propose to change this so that X is evaluated before Y . (In a dict display like {X: Y} this is already the case, and also in dict((X, Y) for ...) which should clearly be equivalent to the dict comprehension.)

Most importantly, since := is an expression, it can be used in contexts where statements are illegal, including lambda functions and comprehensions.

Conversely, assignment expressions don’t support the advanced features found in assignment statements:

• Multiple targets are not directly supported: x = y = z = 0 # Equivalent: (z := (y := (x := 0)))
• Single assignment targets other than a single NAME are not supported: # No equivalent a [ i ] = x self . rest = []
• Priority around commas is different: x = 1 , 2 # Sets x to (1, 2) ( x := 1 , 2 ) # Sets x to 1
• Iterable packing and unpacking (both regular or extended forms) are not supported: # Equivalent needs extra parentheses loc = x , y # Use (loc := (x, y)) info = name , phone , * rest # Use (info := (name, phone, *rest)) # No equivalent px , py , pz = position name , phone , email , * other_info = contact
• Inline type annotations are not supported: # Closest equivalent is "p: Optional[int]" as a separate declaration p : Optional [ int ] = None
• Augmented assignment is not supported: total += tax # Equivalent: (total := total + tax)

The following changes have been made based on implementation experience and additional review after the PEP was first accepted and before Python 3.8 was released:

• for consistency with other similar exceptions, and to avoid locking in an exception name that is not necessarily going to improve clarity for end users, the originally proposed TargetScopeError subclass of SyntaxError was dropped in favour of just raising SyntaxError directly. [3]
• due to a limitation in CPython’s symbol table analysis process, the reference implementation raises SyntaxError for all uses of named expressions inside comprehension iterable expressions, rather than only raising them when the named expression target conflicts with one of the iteration variables in the comprehension. This could be revisited given sufficiently compelling examples, but the extra complexity needed to implement the more selective restriction doesn’t seem worthwhile for purely hypothetical use cases.

Examples from the Python standard library

env_base is only used on these lines, putting its assignment on the if moves it as the “header” of the block.

• Current: env_base = os . environ . get ( "PYTHONUSERBASE" , None ) if env_base : return env_base
• Improved: if env_base := os . environ . get ( "PYTHONUSERBASE" , None ): return env_base

Avoid nested if and remove one indentation level.

• Current: if self . _is_special : ans = self . _check_nans ( context = context ) if ans : return ans
• Improved: if self . _is_special and ( ans := self . _check_nans ( context = context )): return ans

Code looks more regular and avoid multiple nested if. (See Appendix A for the origin of this example.)

• Current: reductor = dispatch_table . get ( cls ) if reductor : rv = reductor ( x ) else : reductor = getattr ( x , "__reduce_ex__" , None ) if reductor : rv = reductor ( 4 ) else : reductor = getattr ( x , "__reduce__" , None ) if reductor : rv = reductor () else : raise Error ( "un(deep)copyable object of type %s " % cls )
• Improved: if reductor := dispatch_table . get ( cls ): rv = reductor ( x ) elif reductor := getattr ( x , "__reduce_ex__" , None ): rv = reductor ( 4 ) elif reductor := getattr ( x , "__reduce__" , None ): rv = reductor () else : raise Error ( "un(deep)copyable object of type %s " % cls )

tz is only used for s += tz , moving its assignment inside the if helps to show its scope.

• Current: s = _format_time ( self . _hour , self . _minute , self . _second , self . _microsecond , timespec ) tz = self . _tzstr () if tz : s += tz return s
• Improved: s = _format_time ( self . _hour , self . _minute , self . _second , self . _microsecond , timespec ) if tz := self . _tzstr (): s += tz return s

Calling fp.readline() in the while condition and calling .match() on the if lines make the code more compact without making it harder to understand.

• Current: while True : line = fp . readline () if not line : break m = define_rx . match ( line ) if m : n , v = m . group ( 1 , 2 ) try : v = int ( v ) except ValueError : pass vars [ n ] = v else : m = undef_rx . match ( line ) if m : vars [ m . group ( 1 )] = 0
• Improved: while line := fp . readline (): if m := define_rx . match ( line ): n , v = m . group ( 1 , 2 ) try : v = int ( v ) except ValueError : pass vars [ n ] = v elif m := undef_rx . match ( line ): vars [ m . group ( 1 )] = 0

A list comprehension can map and filter efficiently by capturing the condition:

Similarly, a subexpression can be reused within the main expression, by giving it a name on first use:

Note that in both cases the variable y is bound in the containing scope (i.e. at the same level as results or stuff ).

Assignment expressions can be used to good effect in the header of an if or while statement:

Particularly with the while loop, this can remove the need to have an infinite loop, an assignment, and a condition. It also creates a smooth parallel between a loop which simply uses a function call as its condition, and one which uses that as its condition but also uses the actual value.

An example from the low-level UNIX world:

Rejected alternative proposals

Proposals broadly similar to this one have come up frequently on python-ideas. Below are a number of alternative syntaxes, some of them specific to comprehensions, which have been rejected in favour of the one given above.

A previous version of this PEP proposed subtle changes to the scope rules for comprehensions, to make them more usable in class scope and to unify the scope of the “outermost iterable” and the rest of the comprehension. However, this part of the proposal would have caused backwards incompatibilities, and has been withdrawn so the PEP can focus on assignment expressions.

Broadly the same semantics as the current proposal, but spelled differently.

Since EXPR as NAME already has meaning in import , except and with statements (with different semantics), this would create unnecessary confusion or require special-casing (e.g. to forbid assignment within the headers of these statements).

(Note that with EXPR as VAR does not simply assign the value of EXPR to VAR – it calls EXPR.__enter__() and assigns the result of that to VAR .)

Additional reasons to prefer := over this spelling include:

• In if f(x) as y the assignment target doesn’t jump out at you – it just reads like if f x blah blah and it is too similar visually to if f(x) and y .
• import foo as bar
• except Exc as var
• with ctxmgr() as var

To the contrary, the assignment expression does not belong to the if or while that starts the line, and we intentionally allow assignment expressions in other contexts as well.

• NAME = EXPR
• if NAME := EXPR

reinforces the visual recognition of assignment expressions.

This syntax is inspired by languages such as R and Haskell, and some programmable calculators. (Note that a left-facing arrow y <- f(x) is not possible in Python, as it would be interpreted as less-than and unary minus.) This syntax has a slight advantage over ‘as’ in that it does not conflict with with , except and import , but otherwise is equivalent. But it is entirely unrelated to Python’s other use of -> (function return type annotations), and compared to := (which dates back to Algol-58) it has a much weaker tradition.

This has the advantage that leaked usage can be readily detected, removing some forms of syntactic ambiguity. However, this would be the only place in Python where a variable’s scope is encoded into its name, making refactoring harder.

Execution order is inverted (the indented body is performed first, followed by the “header”). This requires a new keyword, unless an existing keyword is repurposed (most likely with: ). See PEP 3150 for prior discussion on this subject (with the proposed keyword being given: ).

This syntax has fewer conflicts than as does (conflicting only with the raise Exc from Exc notation), but is otherwise comparable to it. Instead of paralleling with expr as target: (which can be useful but can also be confusing), this has no parallels, but is evocative.

One of the most popular use-cases is if and while statements. Instead of a more general solution, this proposal enhances the syntax of these two statements to add a means of capturing the compared value:

This works beautifully if and ONLY if the desired condition is based on the truthiness of the captured value. It is thus effective for specific use-cases (regex matches, socket reads that return '' when done), and completely useless in more complicated cases (e.g. where the condition is f(x) < 0 and you want to capture the value of f(x) ). It also has no benefit to list comprehensions.

Advantages: No syntactic ambiguities. Disadvantages: Answers only a fraction of possible use-cases, even in if / while statements.

Another common use-case is comprehensions (list/set/dict, and genexps). As above, proposals have been made for comprehension-specific solutions.

This brings the subexpression to a location in between the ‘for’ loop and the expression. It introduces an additional language keyword, which creates conflicts. Of the three, where reads the most cleanly, but also has the greatest potential for conflict (e.g. SQLAlchemy and numpy have where methods, as does tkinter.dnd.Icon in the standard library).

As above, but reusing the with keyword. Doesn’t read too badly, and needs no additional language keyword. Is restricted to comprehensions, though, and cannot as easily be transformed into “longhand” for-loop syntax. Has the C problem that an equals sign in an expression can now create a name binding, rather than performing a comparison. Would raise the question of why “with NAME = EXPR:” cannot be used as a statement on its own.

As per option 2, but using as rather than an equals sign. Aligns syntactically with other uses of as for name binding, but a simple transformation to for-loop longhand would create drastically different semantics; the meaning of with inside a comprehension would be completely different from the meaning as a stand-alone statement, while retaining identical syntax.

Regardless of the spelling chosen, this introduces a stark difference between comprehensions and the equivalent unrolled long-hand form of the loop. It is no longer possible to unwrap the loop into statement form without reworking any name bindings. The only keyword that can be repurposed to this task is with , thus giving it sneakily different semantics in a comprehension than in a statement; alternatively, a new keyword is needed, with all the costs therein.

There are two logical precedences for the := operator. Either it should bind as loosely as possible, as does statement-assignment; or it should bind more tightly than comparison operators. Placing its precedence between the comparison and arithmetic operators (to be precise: just lower than bitwise OR) allows most uses inside while and if conditions to be spelled without parentheses, as it is most likely that you wish to capture the value of something, then perform a comparison on it:

Once find() returns -1, the loop terminates. If := binds as loosely as = does, this would capture the result of the comparison (generally either True or False ), which is less useful.

While this behaviour would be convenient in many situations, it is also harder to explain than “the := operator behaves just like the assignment statement”, and as such, the precedence for := has been made as close as possible to that of = (with the exception that it binds tighter than comma).

Some critics have claimed that the assignment expressions should allow unparenthesized tuples on the right, so that these two would be equivalent:

(With the current version of the proposal, the latter would be equivalent to ((point := x), y) .)

However, adopting this stance would logically lead to the conclusion that when used in a function call, assignment expressions also bind less tight than comma, so we’d have the following confusing equivalence:

The less confusing option is to make := bind more tightly than comma.

It’s been proposed to just always require parentheses around an assignment expression. This would resolve many ambiguities, and indeed parentheses will frequently be needed to extract the desired subexpression. But in the following cases the extra parentheses feel redundant:

Frequently Raised Objections

C and its derivatives define the = operator as an expression, rather than a statement as is Python’s way. This allows assignments in more contexts, including contexts where comparisons are more common. The syntactic similarity between if (x == y) and if (x = y) belies their drastically different semantics. Thus this proposal uses := to clarify the distinction.

The two forms have different flexibilities. The := operator can be used inside a larger expression; the = statement can be augmented to += and its friends, can be chained, and can assign to attributes and subscripts.

Previous revisions of this proposal involved sublocal scope (restricted to a single statement), preventing name leakage and namespace pollution. While a definite advantage in a number of situations, this increases complexity in many others, and the costs are not justified by the benefits. In the interests of language simplicity, the name bindings created here are exactly equivalent to any other name bindings, including that usage at class or module scope will create externally-visible names. This is no different from for loops or other constructs, and can be solved the same way: del the name once it is no longer needed, or prefix it with an underscore.

(The author wishes to thank Guido van Rossum and Christoph Groth for their suggestions to move the proposal in this direction. [2] )

As expression assignments can sometimes be used equivalently to statement assignments, the question of which should be preferred will arise. For the benefit of style guides such as PEP 8 , two recommendations are suggested.

• If either assignment statements or assignment expressions can be used, prefer statements; they are a clear declaration of intent.
• If using assignment expressions would lead to ambiguity about execution order, restructure it to use statements instead.

The authors wish to thank Alyssa Coghlan and Steven D’Aprano for their considerable contributions to this proposal, and members of the core-mentorship mailing list for assistance with implementation.

Appendix A: Tim Peters’s findings

Here’s a brief essay Tim Peters wrote on the topic.

I dislike “busy” lines of code, and also dislike putting conceptually unrelated logic on a single line. So, for example, instead of:

instead. So I suspected I’d find few places I’d want to use assignment expressions. I didn’t even consider them for lines already stretching halfway across the screen. In other cases, “unrelated” ruled:

is a vast improvement over the briefer:

The original two statements are doing entirely different conceptual things, and slamming them together is conceptually insane.

In other cases, combining related logic made it harder to understand, such as rewriting:

as the briefer:

The while test there is too subtle, crucially relying on strict left-to-right evaluation in a non-short-circuiting or method-chaining context. My brain isn’t wired that way.

But cases like that were rare. Name binding is very frequent, and “sparse is better than dense” does not mean “almost empty is better than sparse”. For example, I have many functions that return None or 0 to communicate “I have nothing useful to return in this case, but since that’s expected often I’m not going to annoy you with an exception”. This is essentially the same as regular expression search functions returning None when there is no match. So there was lots of code of the form:

I find that clearer, and certainly a bit less typing and pattern-matching reading, as:

It’s also nice to trade away a small amount of horizontal whitespace to get another _line_ of surrounding code on screen. I didn’t give much weight to this at first, but it was so very frequent it added up, and I soon enough became annoyed that I couldn’t actually run the briefer code. That surprised me!

There are other cases where assignment expressions really shine. Rather than pick another from my code, Kirill Balunov gave a lovely example from the standard library’s copy() function in copy.py :

The ever-increasing indentation is semantically misleading: the logic is conceptually flat, “the first test that succeeds wins”:

Using easy assignment expressions allows the visual structure of the code to emphasize the conceptual flatness of the logic; ever-increasing indentation obscured it.

A smaller example from my code delighted me, both allowing to put inherently related logic in a single line, and allowing to remove an annoying “artificial” indentation level:

That if is about as long as I want my lines to get, but remains easy to follow.

So, in all, in most lines binding a name, I wouldn’t use assignment expressions, but because that construct is so very frequent, that leaves many places I would. In most of the latter, I found a small win that adds up due to how often it occurs, and in the rest I found a moderate to major win. I’d certainly use it more often than ternary if , but significantly less often than augmented assignment.

I have another example that quite impressed me at the time.

Where all variables are positive integers, and a is at least as large as the n’th root of x, this algorithm returns the floor of the n’th root of x (and roughly doubling the number of accurate bits per iteration):

It’s not obvious why that works, but is no more obvious in the “loop and a half” form. It’s hard to prove correctness without building on the right insight (the “arithmetic mean - geometric mean inequality”), and knowing some non-trivial things about how nested floor functions behave. That is, the challenges are in the math, not really in the coding.

If you do know all that, then the assignment-expression form is easily read as “while the current guess is too large, get a smaller guess”, where the “too large?” test and the new guess share an expensive sub-expression.

To my eyes, the original form is harder to understand:

This appendix attempts to clarify (though not specify) the rules when a target occurs in a comprehension or in a generator expression. For a number of illustrative examples we show the original code, containing a comprehension, and the translation, where the comprehension has been replaced by an equivalent generator function plus some scaffolding.

Since [x for ...] is equivalent to list(x for ...) these examples all use list comprehensions without loss of generality. And since these examples are meant to clarify edge cases of the rules, they aren’t trying to look like real code.

Note: comprehensions are already implemented via synthesizing nested generator functions like those in this appendix. The new part is adding appropriate declarations to establish the intended scope of assignment expression targets (the same scope they resolve to as if the assignment were performed in the block containing the outermost comprehension). For type inference purposes, these illustrative expansions do not imply that assignment expression targets are always Optional (but they do indicate the target binding scope).

Let’s start with a reminder of what code is generated for a generator expression without assignment expression.

• Original code (EXPR usually references VAR): def f (): a = [ EXPR for VAR in ITERABLE ]
• Translation (let’s not worry about name conflicts): def f (): def genexpr ( iterator ): for VAR in iterator : yield EXPR a = list ( genexpr ( iter ( ITERABLE )))

Let’s add a simple assignment expression.

• Original code: def f (): a = [ TARGET := EXPR for VAR in ITERABLE ]
• Translation: def f (): if False : TARGET = None # Dead code to ensure TARGET is a local variable def genexpr ( iterator ): nonlocal TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Let’s add a global TARGET declaration in f() .

• Original code: def f (): global TARGET a = [ TARGET := EXPR for VAR in ITERABLE ]
• Translation: def f (): global TARGET def genexpr ( iterator ): global TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Or instead let’s add a nonlocal TARGET declaration in f() .

• Original code: def g (): TARGET = ... def f (): nonlocal TARGET a = [ TARGET := EXPR for VAR in ITERABLE ]
• Translation: def g (): TARGET = ... def f (): nonlocal TARGET def genexpr ( iterator ): nonlocal TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Finally, let’s nest two comprehensions.

• Original code: def f (): a = [[ TARGET := i for i in range ( 3 )] for j in range ( 2 )] # I.e., a = [[0, 1, 2], [0, 1, 2]] print ( TARGET ) # prints 2
• Translation: def f (): if False : TARGET = None def outer_genexpr ( outer_iterator ): nonlocal TARGET def inner_generator ( inner_iterator ): nonlocal TARGET for i in inner_iterator : TARGET = i yield i for j in outer_iterator : yield list ( inner_generator ( range ( 3 ))) a = list ( outer_genexpr ( range ( 2 ))) print ( TARGET )

Because it has been a point of confusion, note that nothing about Python’s scoping semantics is changed. Function-local scopes continue to be resolved at compile time, and to have indefinite temporal extent at run time (“full closures”). Example:

This document has been placed in the public domain.

Source: https://github.com/python/peps/blob/main/peps/pep-0572.rst

Last modified: 2023-10-11 12:05:51 GMT

• SyntaxError: cannot assign to expression here. Maybe you meant '==' instead of '='?

Last updated: Apr 8, 2024 Reading time · 6 min

# Table of Contents

• SyntaxError: cannot assign to literal here (Python)

Note: If you got the error: "SyntaxError: cannot assign to literal here" , click on the second subheading.

# SyntaxError: cannot assign to expression here. Maybe you meant '==' instead of '='?

The Python "SyntaxError: cannot assign to expression here. Maybe you meant '==' instead of '='?" occurs when we have an expression on the left-hand side of an assignment.

To solve the error, specify the variable name on the left and the expression on the right-hand side.

Here is an example of how the error occurs.

# Don't use hyphens in variable names

If this is how you got the error, use an underscore instead of a hyphen.

The name of a variable must start with a letter or an underscore.

A variable name can contain alpha-numeric characters ( a-z , A-Z , 0-9 ) and underscores _ .

Variable names cannot contain any other characters than the aforementioned.

# Don't use expressions on the left-hand side of an assignment

Here is another example of how the error occurs.

We have an expression on the left-hand side which is not allowed.

The variable name has to be specified on the left-hand side, and the expression on the right-hand side.

Now that the division is moved to the right-hand side, the error is resolved.

# Use double equals (==) when comparing values

If you mean to compare two values, use the double equals (==) sign.

Notice that we use double equals == when comparing two values and a single equal = sign for assignment.

Double equals (==) is used for comparison and single equals (=) is used for assignment.

If you use a single equal (=) sign when comparing values, the error is raised.

# Declaring a dictionary

If you get the error when declaring a variable that stores a dictionary, use the following syntax.

Notice that each key and value are separated by a colon and each key-value pair is separated by a comma.

The error is sometimes raised if you have a missing comma between the key-value pairs of a dictionary.

# SyntaxError: cannot assign to literal here (Python)

The Python "SyntaxError: cannot assign to literal here. Maybe you meant '==' instead of '='?" occurs when we try to assign to a literal (e.g. a string or a number).

To solve the error, specify the variable name on the left and the value on the right-hand side of the assignment.

Here are 2 examples of how the error occurs.

Literal values are strings, integers, booleans and floating-point numbers.

# Variable names on the left and values on the right-hand side

When declaring a variable make sure the variable name is on the left-hand side and the value is on the right-hand side of the assignment ( = ).

Notice that variable names should be wrapped in quotes as that is a string literal.

The string "name" is always going to be equal to the string "name" , and the number 100 is always going to be equal to the number 100 , so we cannot assign a value to a literal.

# A variable is a container that stores a specific value

You can think of a variable as a container that stores a specific value.

Variable names should not be wrapped in quotes.

# Declaring multiple variables on the same line

If you got the error while declaring multiple variables on the same line, use the following syntax.

The variable names are still on the left, and the values are on the right-hand side.

You can also use a semicolon to declare multiple variables on the same line.

However, this is uncommon and unnecessary.

# Performing an equality comparison

If you meant to perform an equality comparison, use double equals.

We use double equals == for comparison and single equals = for assignment.

If you need to check if a value is less than or equal to another, use <= .

Similarly, if you need to check if a value is greater than or equal to another, use >= operator.

Make sure you don't use a single equals = sign to compare values because single equals = is used for assignment and not for comparison.

# Assigning to a literal in a for loop

The error also occurs if you try to assign a value to a literal in a for loop by mistake.

Notice that we wrapped the item variable in quotes which makes it a string literal.

Instead, remove the quotes to declare the variable correctly.

Now we declared an item variable that gets set to the current list item on each iteration.

# Using a dictionary

If you meant to declare a dictionary, use curly braces.

A dictionary is a mapping of key-value pairs.

You can use square brackets if you need to add a key-value pair to a dictionary.

If you need to iterate over a dictionary, use a for loop with dict.items() .

The dict.items method returns a new view of the dictionary's items ((key, value) pairs).

# Valid variable names in Python

Note that variable names cannot start with numbers or be wrapped in quotes.

Variable names in Python are case-sensitive.

The 2 variables in the example are completely different and are stored in different locations in memory.

# Additional Resources

You can learn more about the related topics by checking out the following tutorials:

• SyntaxError: cannot assign to function call here in Python

Borislav Hadzhiev

Web Developer

Copyright © 2024 Borislav Hadzhiev

Explore your training options in 10 minutes Get Started

• Graduate Stories
• Partner Spotlights
• Bootcamp Prep
• Bootcamp Admissions
• University Bootcamps
• Coding Tools
• Software Engineering
• Web Development
• Data Science
• Tech Guides
• Tech Resources
• Career Advice
• Online Learning
• Internships
• Apprenticeships
• Tech Salaries
• Associate Degree
• Bachelor's Degree
• Master's Degree
• University Admissions
• Best Schools
• Certifications
• Bootcamp Financing
• Higher Ed Financing
• Scholarships
• Financial Aid
• Best Coding Bootcamps
• Best Online Bootcamps
• Best Web Design Bootcamps
• Best Data Science Bootcamps
• Best Technology Sales Bootcamps
• Best Data Analytics Bootcamps
• Best Cybersecurity Bootcamps
• Best Digital Marketing Bootcamps
• Los Angeles
• San Francisco
• Browse All Locations
• Digital Marketing
• Machine Learning
• See All Subjects
• Bootcamps 101
• Full-Stack Development
• Career Changes
• View all Career Discussions
• Mobile App Development
• Cybersecurity
• Product Management
• UX/UI Design
• What is a Coding Bootcamp?
• Are Coding Bootcamps Worth It?
• How to Choose a Coding Bootcamp
• Best Online Coding Bootcamps and Courses
• Best Free Bootcamps and Coding Training
• Coding Bootcamp vs. Community College
• Coding Bootcamp vs. Self-Learning
• Bootcamps vs. Certifications: Compared
• What Is a Coding Bootcamp Job Guarantee?
• How to Pay for Coding Bootcamp
• Ultimate Guide to Coding Bootcamp Loans
• Best Coding Bootcamp Scholarships and Grants
• Education Stipends for Coding Bootcamps
• Get Your Coding Bootcamp Sponsored by Your Employer
• GI Bill and Coding Bootcamps
• Tech Intevriews
• Our Enterprise Solution
• Connect With Us
• Publication
• Reskill America
• Partner With Us

• Resource Center
• Bachelor’s Degree
• Master’s Degree

Python SyntaxError: cannot assign to operator Solution

You cannot assign the result of a calculation to a mathematical operator. If you perform a calculation before an assignment operator appears on a line of code, you’ll encounter the SyntaxError: cannot assign to operator error.

In this guide, we discuss what this error means and why you may run into it in your programs. We’ll walk through an example of this error so you can learn how to solve it in your code.

Find your bootcamp match

Syntaxerror: cannot assign to operator.

The assignment operator (=) lets you set a value for a variable. Calculations can only appear on the right-hand side of the operator. Consider this line of code:

Our program sets the result of evaluating 1 * 3 to the variable “a”. We can now access the result of our calculation at any time in our program by referring to the value “a”.

The name of the variable to which we want to assign a value comes first. Then, we specify an equals sign. This equals sign denotes we want to assign a value to a variable. Following the equals sign, we specify a calculation.

If you want to assign the result of a sum to a variable, you must use this format. You should not try to evaluate a problem on the left side of an assignment operator.

An Example Scenario

We’re going to write a program that calculates the profits a cafe has made on the coffee orders placed in the last day. To start, let’s define a list . This list will contain all of the purchases customers have made on their range of coffees:

We’re going to declare and assign a placeholder value to a variable called “profits” which tracks the cumulative profits made on all of the drinks:

For now, “profits” is equal to 0. To calculate the value of profits, we are going to subtract $2.00 from the cost of every coffee. This is approximately how much it costs to produce any coffee at the cafe. To do this, we’re going to use a for loop :

This code iterates through all of the coffees in our list. We subtract $2.00 from the value of each coffee. We then use the addition assignment operator (+=) to add the value we calculate to the variable “profits”.

Finally, let’s print out a message to the console that informs us how much the cafe has earned in profit over the last day from their coffee sales:

Let’s run our code and see what happens:

Our code returns an error.

The Solution

We’ve tried to evaluate a sum before an assignment operator.

This is invalid syntax. We must specify a variable name, and then an assignment operator, followed by the sum we want to evaluate.

Python is programmed to interpret the statement before an assignment operator as a variable name. Written in English, Python tries to read our code as:

This doesn’t make sense. We want to subtract 2.00 from the value “o” and then add the result of our sum to the variable “profits”.

To fix this error, we need to swap around the “profits” and sum statements in our code:

Python will read this code as “Evaluate o – 2.00 and add the result of that sum to the “profits’ variable”. This is what we want our program to accomplish.

Let’s run our code:

Our program successfully calculates how much the cafe has earned in profit. The cafe, after subtracting 2.00 from the value of each order, has earned a profit of $2.40 in the last day from coffee sales.

The SyntaxError: cannot assign to operator error is raised when you try to evaluate a mathematical statement before an assignment operator.

To fix this error, make sure all your variable names appear on the left hand side of an assignment operator and all your mathematical statements appear on the right.

Now you have the knowledge you need to fix this error like a professional developer!

About us: Career Karma is a platform designed to help job seekers find, research, and connect with job training programs to advance their careers. Learn about the CK publication .

What's Next?

Get matched with top bootcamps

Ask a question to our community, take our careers quiz.

I was wondering if you could show an example? That’d be great, thanks!

Kind regards Jules

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

• Fundamentals
• All Articles

[Solved] SyntaxError: cannot assign to expression here in Python

Python raises “SyntaxError: cannot assign to expression here. Maybe you meant ‘==’ instead of ‘=’?” when you assign a value to an expression. On the other hand, this error occurs if an expression is the left-hand side operand in an assignment statement.

Additionally, Python provides you a hint, assuming you meant to use the equality operator ( == ):

Psssst! Do you want to learn web development in 2023?

• How to become a web developer when you have no degree
• How to learn to code without a technical background
• How much do web developers make in the US?

But what's a expression? You may ask. 

🎧 Debugging Jam

Calling all coders in need of a rhythm boost! Tune in to our 24/7 Lofi Coding Radio on YouTube, and let's code to the beat – subscribe for the ultimate coding groove!" Let the bug-hunting begin! 🎵💻🚀

The term "expression" refers to values or combination of values (operands) and operators that result in a value. That said, all the following items are expressions:

• 'someValue'
• 4 * (5 + 2)
• 'someText' + 'anotherText'

Most of the time, the cause of the "SyntaxError: cannot assign to expression here" error is a typo in your code - usually a missing = or invalid identifiers in assignment statements.

How to fix "SyntaxError: cannot assign to expression here"

The long error "SyntaxError: cannot assign to expression here. Maybe you meant '==' instead of '='?" occurs under various scenarios:

• Using an invalid name (identifier) in an assignment statement
• Using = instead of == in a comparison statement

Let's see some examples.

Using an invalid name (identifier) in an assignment statement:  Assignment statements bind names to values. (e.g., total_price = 49.99 )

 Based on Python syntax and semantics , the left-hand side of the assignment operator ( = ) should always be an identifier, not an expression or a literal.

Identifiers (a.k.a names) are arbitrary names you use for definitions in the source code, such as variable names, function names, and class names. For instance, in the statement age = 25 , age is the identifier.

Python identifiers  are based on the  Unicode standard annex UAX-31 , which describes the specifications for using Unicode in identifiers.

That said, you can only use alphanumeric characters and underscores for names. Otherwise, you'll get a SyntaxError. For instance, 2 + 2 = a is a syntax error because the left-hand side operator isn't a valid identifier - it's a Python expression.

A common mistake which results in the "SyntaxError: cannot assign to expression here. Maybe you meant '==' instead of '='?" error is using hyphens ( - ) in your variable names.

Hyphens are only valid in expressions like 45.54 - 12.12 . If you have a '-' in your variable name, Python's interpreter would assume it's an expression:

In the above code, Python's interpreter assumes you're trying to subtract a variable name price from another variable named total .

And since you can't have an expression as a left-hand side operand in an assignment statement, you'll get this SyntaxError.

So if your code looks like the above, you need to replace the hyphen ( - ) with an underscore ( _ ):

That's much better!

Invalid comparison statement :  Another cause of "SyntaxError: cannot assign to expression here" is using an invalid sequence of comparison operators while comparing values .

This one is more of a syntax-related mistake and rarely finds its way to the runtime, but it's worth watching.

Imagine you want to test if a number is an even number. As you probably know, if we divide a number by 2 , and the remainder is 0 , that number is even.

In Python, we use the modulo operator ( % ) to get the remainder of a division:

In the above code, once Python encounters the assignment operator ( = ), it assumes we're trying to assign 0 to x % 2 ! No wonder the response is "SyntaxError: cannot assign to expression here. Maybe you meant '==' instead of '='?".

But once we use the equality operator ( == ), the misconception goes away:

Problem solved!

Alright, I think it does it. I hope this quick guide helped you solve your problem.

Thanks for reading.

Reza Lavarian Hey 👋 I'm a software engineer, an author, and an open-source contributor. I enjoy helping people (including myself) decode the complex side of technology. I share my findings on Twitter: @rezalavarian

❤️ You might be also interested in:

• [Solved] SyntaxError: cannot assign to literal here in Python
• SyntaxError: cannot assign to function call here in Python (Solved)
• SyntaxError: invalid decimal literal in Python (Solved)
• How to learn any programming language in a short time
• Your master sword: a programming language

Never miss a guide like this!

Disclaimer: This post may contain affiliate links . I might receive a commission if a purchase is made. However, it doesn’t change the cost you’ll pay.

• Privacy Policy

• 2.1. Syntax Assignment Expression

2.1. Syntax Assignment Expression 

Since Python 3.8: PEP 572 -- Assignment Expressions

Also known as "Walrus operator"

Also known as "Named expression"

Python's assignment expression is a feature introduced in Python 3.8. It allows you to assign a value to a variable as part of a larger expression. The syntax for the assignment expression is as follows:

The expression is evaluated and the result is assigned to the variable on the left-hand side of the := operator. The variable can then be used in the rest of the expression.

During discussion of this PEP, the operator became informally known as "the walrus operator". The construct's formal name is "Assignment Expressions" (as per the PEP title), but they may also be referred to as "Named Expressions". The CPython reference implementation uses that name internally). [ 1 ]

Guido van Rossum stepped down after accepting PEP 572 -- Assignment Expressions:

2.1.1. Syntax 

Comprehension:

2.1.2. Value of the Expression 

First defines identifier with value

Then returns the value from the identifier

Both operations in the same line

2.1.3. Assign in the Expression 

2.1.4. assignment and evaluation .

Assignment Expression assigns and immediately evaluates expression:

2.1.5. What Assignment Expression is? 

Is equivalent to:

2.1.6. What Assignment Expression is not? 

It's not substitution for equals

2.1.7. Checking Match 

In order to find username in email address we need to define regular expression pattern:

Let's search for username in email address:

This works well when username is valid and is indeed in email. What if, the username is invalid:

This is because re.search() returns an optional value re.Match | None . Therefore, regular expression matches requires to check if the value is not None before using it further:

Assignment expressions allows to merge two independent lines into one coherent statement to unpack and process an optional:

2.1.8. Processing Streams 

Processing steams in chunks

Imagine we have a temperature sensor, and this sensor stream values. We have a process which receives values from string and appends them to the file. Let's simulate the process by adding temperature measurements to the file:

Note, that all values have fixed length of 4 bytes plus space (5th byte). We cannot open and read whole file to the memory, like we normally do. This file may be huge, much larger than RAM in our computer.

We will process file reading 5 bytes of data (one measurement) at a time:

As you can see we have two places where we define number of bytes, read and cleanup data. First file.read() is needed to enter the loop. Second file.read() is needed to process the file further until the end. Using assignment expression we can write code which is far better:

Imagine if this is not a 5 bytes of data, but a chunk of data for processing (for example a ten megabytes at once). This construct make more sense then.

Always remember to close the file at the end:

2.1.9. Variables in comprehensions 

2.1.10. comprehensions .

Let's define data:

Typical comprehension would require calling str.split() multiple times:

Assignment expressions allows definition of a variable which can be used in the comprehension. It is not only more clear and readable, but also saves time and memory, especially if the function call would take a lot of resources:

You can define multiple assignment expressions if needed.

2.1.11. Assignment vs Assignment Expression 

2.1.12. use case - 0x01 .

Reusing Results

2.1.13. Use Case - 0x02 

We want to convert:

Using loop:

Using comprehension:

Using comprehension with assignment expression:

Using comprehension with multiple assignment expression:

2.1.14. Use Case - 0x03 

Note, that the generator expression will not return values, but create an object which execution will get values. This is the reason why this solution is such drastically fast.

2.1.15. Use Case - 0x04 

2.1.16. use case - 0x05 .

One assignment expression:

Many assignment expressions:

In all cases result is the same:

2.1.17. Use Case - 0x07 

In the following example dataclasses are used to automatically generate __init__() method based on the attributes:

2.1.18. Use Case - 0x09 

Procedural approach:

Conditional statement requires to perform match twice in order to get results:

Assignment expressions allows to defile a variable and reuse it:

2.1.19. Use Case - 0x0A 

2.1.20. references , 2.1.21. assignments .

• DigitalOcean
• Sign up for:

How To Use Assignment Expressions in Python

DavidMuller and Kathryn Hancox

The author selected the COVID-19 Relief Fund to receive a donation as part of the Write for DOnations program.

Introduction

Python 3.8 , released in October 2019, adds assignment expressions to Python via the := syntax. The assignment expression syntax is also sometimes called “the walrus operator” because := vaguely resembles a walrus with tusks.

Assignment expressions allow variable assignments to occur inside of larger expressions. While assignment expressions are never strictly necessary to write correct Python code, they can help make existing Python code more concise. For example, assignment expressions using the := syntax allow variables to be assigned inside of if statements , which can often produce shorter and more compact sections of Python code by eliminating variable assignments in lines preceding or following the if statement.

In this tutorial, you will use assignment expressions in several examples to produce concise sections of code.

Prerequisites

To get the most out of this tutorial, you will need:

Python 3.8 or above. Assignment expressions are a new feature added starting in Python 3.8. You can view the How To Install Python 3 and Set Up a Programming Environment on an Ubuntu 18.04 Server tutorial for help installing and upgrading Python.

The Python Interactive Console. If you would like to try out the example code in this tutorial you can use the How To Work with the Python Interactive Console tutorial.

Some familiarity with while loops, if statements, list comprehensions, and functions in Python 3 is useful, but not necessary. You can review our How To Code in Python 3 tutorial series for background knowledge.

Using Assignment Expressions in if Statements

Let’s start with an example of how you can use assignment expressions in an if statement.

Consider the following code that checks the length of a list and prints a statement:

If you run the previous code, you will receive the following output:

You initialize a list named some_list that contains three elements. Then, the if statement uses the assignment expression ((list_length := len(some_list)) to bind the variable named list_length to the length of some_list . The if statement evaluates to True because list_length is greater than 2 . You print a string using the list_length variable, which you bound initially with the assignment expression, indicating the the three-element list is too long.

Note: Assignment expressions are a new feature introduced in Python 3.8 . To run the examples in this tutorial, you will need to use Python 3.8 or higher.

Had we not used assignment expression, our code might have been slightly longer. For example:

This code sample is equivalent to the first example, but this code requires one extra standalone line to bind the value of list_length to len(some_list) .

Another equivalent code sample might just compute len(some_list) twice: once in the if statement and once in the print statement. This would avoid incurring the extra line required to bind a variable to the value of len(some_list) :

Assignment expressions help avoid the extra line or the double calculation.

Note: Assignment expressions are a helpful tool, but are not strictly necessary. Use your judgement and add assignment expressions to your code when it significantly improves the readability of a passage.

In the next section, we’ll explore using assignment expressions inside of while loops.

Using Assignment Expressions in while Loops

Assignment expressions often work well in while loops because they allow us to fold more context into the loop condition.

Consider the following example that embeds a user input function inside the while loop condition:

If you run this code, Python will continually prompt you for text input from your keyboard until you type the word stop . One example session might look like:

The assignment expression (directive := input("Enter text: ")) binds the value of directive to the value retrieved from the user via the input function. You bind the return value to the variable directive , which you print out in the body of the while loop. The while loop exits whenever the you type stop .

Had you not used an assignment expression, you might have written an equivalent input loop like:

This code is functionally identical to the one with assignment expressions, but requires four total lines (as opposed to two lines). It also duplicates the input("Enter text: ") call in two places. Certainly, there are many ways to write an equivalent while loop, but the assignment expression variant introduced earlier is compact and captures the program’s intention well.

So far, you’ve used assignment expression in if statements and while loops. In the next section, you’ll use an assignment expression inside of a list comprehension.

Using Assignment Expressions in List Comprehensions

We can also use assignment expressions in list comprehensions . List comprehensions allow you to build lists succinctly by iterating over a sequence and potentially adding elements to the list that satisfy some condition. Like list comprehensions, we can use assignment expressions to improve readability and make our code more concise.

Consider the following example that uses a list comprehension and an assignment expression to build a list of multiplied integers:

If you run the previous code, you will receive the following:

You define a function named slow_calculation that multiplies the given number x with itself. A list comprehension then iterates through 0 , 1 , and 2 returned by range(3) . An assignment expression binds the value result to the return of slow_calculation with i . You add the result to the newly built list as long as it is greater than 0. In this example, 0 , 1 , and 2 are all multiplied with themselves, but only the results 1 ( 1 * 1 ) and 4 ( 2 * 2 ) satisfy the greater than 0 condition and become part of the final list [1, 4] .

The slow_calculation function isn’t necessarily slow in absolute terms, but is meant to illustrate an important point about effeciency. Consider an alternate implementation of the previous example without assignment expressions:

Running this, you will receive the following output:

In this variant of the previous code, you use no assignment expressions. Instead, you call slow_calculation up to two times: once to ensure slow_calculation(i) is greater than 0 , and potentially a second time to add the result of the calculation to the final list. 0 is only multiplied with itself once because 0 * 0 is not greater than 0 . The other results, however, are doubly calculated because they satisfy the greater than 0 condition, and then have their results recalculated to become part of the final list [1, 4] .

You’ve now combined assignment expressions with list comprehensions to create blocks of code that are both efficient and concise.

In this tutorial, you used assignment expressions to make compact sections of Python code that assign values to variables inside of if statements, while loops, and list comprehensions.

For more information on other assignment expressions, you can view PEP 572 —the document that initially proposed adding assignment expressions to Python.

You may also want to check out our other Python content on our topic page .

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Learn more about our products

Author of Intuitive Python

Check out Intuitive Python: Productive Development for Projects that Last

https://pragprog.com/titles/dmpython/intuitive-python/

Still looking for an answer?

This textbox defaults to using Markdown to format your answer.

You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!

Try DigitalOcean for free

Click below to sign up and get $200 of credit to try our products over 60 days!

Popular Topics

• Linux Basics
• All tutorials
• Talk to an expert

Join the Tech Talk

Please complete your information!

Featured on Community

Get our biweekly newsletter

Sign up for Infrastructure as a Newsletter.

Hollie's Hub for Good

Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.

Become a contributor

Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

Featured Tutorials

Digitalocean products, welcome to the developer cloud.

DigitalOcean makes it simple to launch in the cloud and scale up as you grow — whether you're running one virtual machine or ten thousand.

Understanding and Avoiding Syntax Errors in Python Dictionaries

In Python, there are three main types of errors: Syntax errors, Runtime errors, and Logical errors. Syntax errors can include system errors and name errors. System errors occur when the interpreter encounters extraneous tabs and spaces, given that proper indentation is essential for separating blocks of code in Python. Name errors arise when variables are misspelled, and the interpreter can’t find the specified variable within the code’s scope.

Syntax errors are raised when the Python interpreter fails to understand the given commands by the programmer. In other words, when you make any spelling mistake or typos in your code, it will most definitely raise a syntax error.

It can also be raised when defining data types. For example, if you miss the last curly bracket, “}” when defining a dictionary or capitalize the “P” while trying to print an output, it will inevitably raise a syntax error or an exception.

In this article, we will take a look at one of the most common syntax errors. When trying to define dictionaries, there shouldn’t be any assignment operator, i.e., “=” between keys and values. Instead, you should put a colon , “:” between the two.

Let’s look at the root of the above problem followed by it’s solution.

Similar: Syntax Error: EOL while scanning string literal.

Causes of Syntax Errors in Python Dictionaries

Python’s syntax errors can happen for many reasons, like using tabs and spaces incorrectly, spelling variables wrong, using operators the wrong way, or declaring things incorrectly. One common mistake is defining dictionaries wrongly by using “=” instead of “:” between keys and values. Fixing these issues usually means double-checking that everything is spelled right and that you are using things like colons, semicolons, and underscores properly.

There can be numerous reasons why you might encounter a syntax error in python. Some of them are:

• When a keyword is misspelled.
• If there are missing parenthesis when using functions, print statements, or when colons are missing at the end of for or while loops and other characters such as missing underscores(__) from def __innit__() functions.
• Wrong operators that might be present at the wrong place.
• When the variable declared is wrong or misspelled.

Differentiating between ‘=’ and ‘==’ in context of Python Dictionaries

In Python and many other programming languages, the single equals sign “=” denotes assignment, where a variable is given a specific value. In contrast, the double equals sign “==” is used to check for equality between two values or variables.

For example, if there are two variables, namely. ‘a’ and ‘b’ in your code, and you want to assign the integer values of 10 and 20 to each, respectively. In this case, you’ll need to use the assignment operator, that is, a single equal to sign(=) in your code in the following way:

But instead, if we want to check whether the values assigned to ‘a’ and ‘b’ are equal using an “if” statement, we will use the double equal to sign (==) such as,

Syntax Rules for Python Dictionaries

In Python, dictionaries are a unique type of data-storing variables. They are ordered and mutable in nature unlike lists. They are assigned in pairs, in the form of keys and values. Each element in a dictionary is indexed by its’ keys. Each value is accessed by keeping track of its respective key. There should be a colon”:” separating the value from its respective key. They are represented by curly braces ‘{}’. Each key and value pair can be separated from one another with commas ‘,’.

They can be assigned in the following manner:

our_dictionary= {"key1": "value1", "key2":"value2", "key3":"value3",....}

Do check out: [SOLVED] ‘Unexpected Keyword Argument’ TypeError in Python .

Reproducing the Syntax Error: expression cannot contain assignment, perhaps you meant “==”?

In this case, the problem might arise when instead of using a colon “:”, the interpreter encounters an assignment operator. There is a built in function in Python that can explicitly convert data into dictionaries called dict(). But this function might also cause this problem when the identifier is wrong or when there are other syntax mistakes in the code, such as missing parenthesis at the end of a statement.

The error is shown below:

Mitigating Syntax Errors in Python Dictionaries

The only straight forward solution to this problem is making sure you spell the keywords and in built functions correctly and remember to use the identifiers such as colons, semicolons and underscores properly.

Try to avoid using the dict() function for creating dictionaries. Instead, use curly braces as much as possible. If using the function is a necessity, make sure you don’t use the assignment operator incorrectly and use parentheses where necessary.

In the following code, there are no exceptions raised because the syntax is correct and the variable has been assigned correctly.

Nowadays, there are built in syntax detectors in IDEs and editors which can highlight syntax errors like this one. You can also use a debugger if necessary.

Key Takeaways: Avoiding Syntax Errors in Python Dictionaries

Having dived into the causes and solutions of Python’s syntax errors, we hope this equips you to write more efficient, error-free code. The intricacies of Python dictionaries need not be a source of worry. With the right practices, you can avoid these errors, optimizing your code and enriching your programming journey.

How will this knowledge influence your approach to using Python dictionaries in future projects?

sethserver  /  Python

Python's Walrus Operator: Simplifying Assignment Expressions

In the ever-evolving landscape of programming languages, Python has consistently stood out for its simplicity and readability. With each new version, the language introduces features that aim to make developers' lives easier and code more expressive. One such addition that stirred up quite a bit of discussion in the Python community is the walrus operator (:=), introduced in Python 3.8. This seemingly small syntactical addition has the potential to significantly impact how we write Python code, offering new ways to make our expressions more concise and our logic more streamlined.

In this post, we'll dive deep into the walrus operator, exploring its syntax, use cases, and how it can potentially improve your Python code. We'll also touch on some of the controversies surrounding its introduction and discuss when it's appropriate to use this new feature.

What is the Walrus Operator?

The walrus operator, officially known as the "assignment expression" operator, allows you to assign values to variables as part of a larger expression. Its name comes from its appearance - if you tilt your head slightly, the := symbol generally resembles a walrus with its tusks. Personally, I voted for the beavor operator but lost out. Maybe next time.

Before we delve into the specifics, let's look at a simple example to illustrate the difference between a standard assignment and an assignment expression:

In the first case, we assign 5 to x and then print x. In the second case, we assign 5 to y and print it in a single line. While this simple example doesn't showcase the full power of the walrus operator, it does illustrate its basic functionality.

Syntax and Usage

The syntax for the walrus operator is straightforward:

The parentheses are often necessary to avoid ambiguity in complex expressions. The variable on the left side of := is assigned the value of the expression on the right side, and the entire expression evaluates to that value.

It's important to note that the walrus operator doesn't create a new scope. The variable assigned using := is available in the surrounding scope, just like a regular assignment would be.

Common Use Cases

Now that we understand the basic syntax, let's explore some common scenarios where the walrus operator can be particularly useful.

1. Simplifying While Loops

One of the most straightforward applications of the walrus operator is in while loops. Consider this example:

In the second version, we use the walrus operator to assign the input to user_input and check if it's 'q' in a single line. This eliminates the need for the if statement and makes the code more concise.

2. Enhancing List Comprehensions

The walrus operator can make list comprehensions more powerful by allowing you to use the result of an expression multiple times without repeating the computation:

In this example, we compute the square of each number only once, using it both in the condition and in the output expression.

3. Simplifying If Statements

The walrus operator can be particularly useful in if statements when you need to use the result of a computation in both the condition and the body of the statement:

Here, we avoid calling re.search twice and make the code more readable by using the walrus operator.

4. Improving Function Calls

When calling functions with complex arguments, the walrus operator can help avoid repetition:

This approach can be particularly useful when dealing with functions that have side effects or are computationally expensive.

Potential Pitfalls and Best Practices

While the walrus operator can indeed make code more concise, it's important to use it judiciously. Here are some potential pitfalls to be aware of:

1. Overuse Leading to Reduced Readability

While the walrus operator can make code more concise, overusing it can lead to reduced readability. Consider this example:

2. Unexpected Scoping Behavior

Remember that the walrus operator doesn't create a new scope. This can lead to unexpected behavior if you're not careful:

Here, x retains its value from the last iteration of the list comprehension, which might not be what you expect.

3. Confusion with Other Operators

In some contexts, the walrus operator can be confused with other operators, particularly when used without parentheses:

To avoid confusion, it's often best to use parentheses when using the walrus operator in complex expressions.

Best Practices

To make the most of the walrus operator while avoiding its pitfalls, consider these best practices:

• Use it to Reduce Repetition: The walrus operator is most useful when it helps you avoid repeating an expression.
• Prioritize Readability: If using the walrus operator makes your code harder to understand, it's probably better to stick with traditional assignment.
• Use Parentheses: When in doubt, use parentheses to make the order of operations clear.
• Be Mindful of Scope: Remember that variables assigned with the walrus operator are in the surrounding scope.

The Controversy

The introduction of the walrus operator was not without controversy in the Python community. Some developers felt that it went against Python's philosophy of having one obvious way to do things. Others were concerned that it could lead to less readable code if overused.

Guido van Rossum, the creator of Python, even temporarily stepped down as the "Benevolent Dictator For Life" of Python due to the heated debates surrounding this feature. However, after much discussion and refinement, the walrus operator was ultimately included in Python 3.8.

Despite the initial controversy, many Python developers have come to appreciate the walrus operator for its ability to simplify certain types of code. Like any powerful feature, its value lies in how judiciously it is used.

Real-World Applications

To truly appreciate the walrus operator, let's look at some real-world scenarios where it can be particularly useful:

1. Data Processing Pipelines

When working with data processing pipelines, the walrus operator can help streamline operations:

Here, we process the data and check its validity in a single line, making the code more efficient and readable.

2. Web Scraping

In web scraping scenarios, the walrus operator can be useful for conditional extractions:

This example demonstrates how the walrus operator can be used to handle both the HTTP request and the parsing of the response in a more streamlined manner.

3. Game Development

In game development, the walrus operator can be useful for handling events or state changes:

In this example, we use the walrus operator to capture the mouse button state and use it in multiple conditions, reducing redundant calls to pygame.mouse.get_pressed().

The walrus operator, despite its initial controversy, has proven to be a valuable addition to Python's syntax. When used appropriately, it can lead to more concise and readable code, particularly in scenarios involving complex conditions or repeated computations.

However, like any powerful feature, it should be used judiciously. The key is to strike a balance between conciseness and readability. When in doubt, it's often better to err on the side of clarity rather than cleverness.

As you continue your Python journey, experiment with the walrus operator in your own code. You may find that it opens up new ways of expressing your logic more elegantly. Remember, the goal is not just to write code that works, but code that clearly communicates your intent to other developers (including your future self).

The introduction of features like the walrus operator demonstrates Python's ongoing evolution as a language. It's a reminder that even a mature and widely-used language can still find ways to innovate and improve. As Python continues to grow and adapt, it's exciting to think about what new features and capabilities future versions might bring.

So, the next time you find yourself repeating an expression or wrestling with a complex condition, consider whether the walrus operator might help simplify your code. You might just find that this quirky little operator becomes a valuable tool in your Python toolkit.

More Essays & Articles

• Python Course
• Python Basics
• Interview Questions
• Python Quiz
• Popular Packages
• Python Projects
• Practice Python
• AI With Python
• Learn Python3
• Python Automation
• Python Web Dev
• DSA with Python
• Python OOPs
• Dictionaries

Assignment Operators in Python

The Python Operators are used to perform operations on values and variables. These are the special symbols that carry out arithmetic, logical, and bitwise computations. The value the operator operates on is known as the Operand. Here, we will cover Different Assignment operators in Python .

Here are the Assignment Operators in Python with examples.

Assignment Operator

Assignment Operators are used to assign values to variables. This operator is used to assign the value of the right side of the expression to the left side operand.

Addition Assignment Operator

The Addition Assignment Operator is used to add the right-hand side operand with the left-hand side operand and then assigning the result to the left operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the addition assignment operator which will first perform the addition operation and then assign the result to the variable on the left-hand side.

S ubtraction Assignment Operator

The Subtraction Assignment Operator is used to subtract the right-hand side operand from the left-hand side operand and then assigning the result to the left-hand side operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the subtraction assignment operator which will first perform the subtraction operation and then assign the result to the variable on the left-hand side.

M ultiplication Assignment Operator

The Multiplication Assignment Operator is used to multiply the right-hand side operand with the left-hand side operand and then assigning the result to the left-hand side operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the multiplication assignment operator which will first perform the multiplication operation and then assign the result to the variable on the left-hand side.

D ivision Assignment Operator

The Division Assignment Operator is used to divide the left-hand side operand with the right-hand side operand and then assigning the result to the left operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the division assignment operator which will first perform the division operation and then assign the result to the variable on the left-hand side.

M odulus Assignment Operator

The Modulus Assignment Operator is used to take the modulus, that is, it first divides the operands and then takes the remainder and assigns it to the left operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the modulus assignment operator which will first perform the modulus operation and then assign the result to the variable on the left-hand side.

F loor Division Assignment Operator

The Floor Division Assignment Operator is used to divide the left operand with the right operand and then assigs the result(floor value) to the left operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the floor division assignment operator which will first perform the floor division operation and then assign the result to the variable on the left-hand side.

Exponentiation Assignment Operator

The Exponentiation Assignment Operator is used to calculate the exponent(raise power) value using operands and then assigning the result to the left operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the exponentiation assignment operator which will first perform exponent operation and then assign the result to the variable on the left-hand side.

Bitwise AND Assignment Operator

The Bitwise AND Assignment Operator is used to perform Bitwise AND operation on both operands and then assigning the result to the left operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the bitwise AND assignment operator which will first perform Bitwise AND operation and then assign the result to the variable on the left-hand side.

Bitwise OR Assignment Operator

The Bitwise OR Assignment Operator is used to perform Bitwise OR operation on the operands and then assigning result to the left operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the bitwise OR assignment operator which will first perform bitwise OR operation and then assign the result to the variable on the left-hand side.

Bitwise XOR Assignment Operator 

The Bitwise XOR Assignment Operator is used to perform Bitwise XOR operation on the operands and then assigning result to the left operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the bitwise XOR assignment operator which will first perform bitwise XOR operation and then assign the result to the variable on the left-hand side.

Bitwise Right Shift Assignment Operator

The Bitwise Right Shift Assignment Operator is used to perform Bitwise Right Shift Operation on the operands and then assign result to the left operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the bitwise right shift assignment operator which will first perform bitwise right shift operation and then assign the result to the variable on the left-hand side.

Bitwise Left Shift Assignment Operator

The Bitwise Left Shift Assignment Operator is used to perform Bitwise Left Shift Opertator on the operands and then assign result to the left operand.

Example: In this code we have two variables ‘a’ and ‘b’ and assigned them with some integer value. Then we have used the bitwise left shift assignment operator which will first perform bitwise left shift operation and then assign the result to the variable on the left-hand side.

Walrus Operator

The Walrus Operator in Python is a new assignment operator which is introduced in Python version 3.8 and higher. This operator is used to assign a value to a variable within an expression.

Example: In this code, we have a Python list of integers. We have used Python Walrus assignment operator within the Python while loop . The operator will solve the expression on the right-hand side and assign the value to the left-hand side operand ‘x’ and then execute the remaining code.

Assignment Operators in Python – FAQs

What are assignment operators in python.

Assignment operators in Python are used to assign values to variables. These operators can also perform additional operations during the assignment. The basic assignment operator is = , which simply assigns the value of the right-hand operand to the left-hand operand. Other common assignment operators include += , -= , *= , /= , %= , and more, which perform an operation on the variable and then assign the result back to the variable.

What is the := Operator in Python?

The := operator, introduced in Python 3.8, is known as the “walrus operator”. It is an assignment expression, which means that it assigns values to variables as part of a larger expression. Its main benefit is that it allows you to assign values to variables within expressions, including within conditions of loops and if statements, thereby reducing the need for additional lines of code. Here’s an example: # Example of using the walrus operator in a while loop while (n := int(input("Enter a number (0 to stop): "))) != 0: print(f"You entered: {n}") This loop continues to prompt the user for input and immediately uses that input in both the condition check and the loop body.

What is the Assignment Operator in Structure?

In programming languages that use structures (like C or C++), the assignment operator = is used to copy values from one structure variable to another. Each member of the structure is copied from the source structure to the destination structure. Python, however, does not have a built-in concept of ‘structures’ as in C or C++; instead, similar functionality is achieved through classes or dictionaries.

What is the Assignment Operator in Python Dictionary?

In Python dictionaries, the assignment operator = is used to assign a new key-value pair to the dictionary or update the value of an existing key. Here’s how you might use it: my_dict = {} # Create an empty dictionary my_dict['key1'] = 'value1' # Assign a new key-value pair my_dict['key1'] = 'updated value' # Update the value of an existing key print(my_dict) # Output: {'key1': 'updated value'}

What is += and -= in Python?

The += and -= operators in Python are compound assignment operators. += adds the right-hand operand to the left-hand operand and assigns the result to the left-hand operand. Conversely, -= subtracts the right-hand operand from the left-hand operand and assigns the result to the left-hand operand. Here are examples of both: # Example of using += a = 5 a += 3 # Equivalent to a = a + 3 print(a) # Output: 8 # Example of using -= b = 10 b -= 4 # Equivalent to b = b - 4 print(b) # Output: 6 These operators make code more concise and are commonly used in loops and iterative data processing.

Similar Reads

• Python-Operators

Please Login to comment...

• Best Free Workout Apps in 2024: Top-Rated Fitness and Exercise Apps for Home and Gym
• Top 10 Xfinity Alternatives & Competitors in 2024
• Top VMware Alternatives 2024
• Top Airbnb Alternatives in 2024
• GeeksforGeeks Practice - Leading Online Coding Platform

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

• Python »
• 3.12.7 Documentation »
• The Python Language Reference »
• 7. Simple statements
• Theme Auto Light Dark |

7. Simple statements ¶

A simple statement is comprised within a single logical line. Several simple statements may occur on a single line separated by semicolons. The syntax for simple statements is:

7.1. Expression statements ¶

Expression statements are used (mostly interactively) to compute and write a value, or (usually) to call a procedure (a function that returns no meaningful result; in Python, procedures return the value None ). Other uses of expression statements are allowed and occasionally useful. The syntax for an expression statement is:

An expression statement evaluates the expression list (which may be a single expression).

In interactive mode, if the value is not None , it is converted to a string using the built-in repr() function and the resulting string is written to standard output on a line by itself (except if the result is None , so that procedure calls do not cause any output.)

7.2. Assignment statements ¶

Assignment statements are used to (re)bind names to values and to modify attributes or items of mutable objects:

(See section Primaries for the syntax definitions for attributeref , subscription , and slicing .)

An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right.

Assignment is defined recursively depending on the form of the target (list). When a target is part of a mutable object (an attribute reference, subscription or slicing), the mutable object must ultimately perform the assignment and decide about its validity, and may raise an exception if the assignment is unacceptable. The rules observed by various types and the exceptions raised are given with the definition of the object types (see section The standard type hierarchy ).

Assignment of an object to a target list, optionally enclosed in parentheses or square brackets, is recursively defined as follows.

If the target list is a single target with no trailing comma, optionally in parentheses, the object is assigned to that target.

If the target list contains one target prefixed with an asterisk, called a “starred” target: The object must be an iterable with at least as many items as there are targets in the target list, minus one. The first items of the iterable are assigned, from left to right, to the targets before the starred target. The final items of the iterable are assigned to the targets after the starred target. A list of the remaining items in the iterable is then assigned to the starred target (the list can be empty).

Else: The object must be an iterable with the same number of items as there are targets in the target list, and the items are assigned, from left to right, to the corresponding targets.

Assignment of an object to a single target is recursively defined as follows.

If the target is an identifier (name):

If the name does not occur in a global or nonlocal statement in the current code block: the name is bound to the object in the current local namespace.

Otherwise: the name is bound to the object in the global namespace or the outer namespace determined by nonlocal , respectively.

The name is rebound if it was already bound. This may cause the reference count for the object previously bound to the name to reach zero, causing the object to be deallocated and its destructor (if it has one) to be called.

If the target is an attribute reference: The primary expression in the reference is evaluated. It should yield an object with assignable attributes; if this is not the case, TypeError is raised. That object is then asked to assign the assigned object to the given attribute; if it cannot perform the assignment, it raises an exception (usually but not necessarily AttributeError ).

Note: If the object is a class instance and the attribute reference occurs on both sides of the assignment operator, the right-hand side expression, a.x can access either an instance attribute or (if no instance attribute exists) a class attribute. The left-hand side target a.x is always set as an instance attribute, creating it if necessary. Thus, the two occurrences of a.x do not necessarily refer to the same attribute: if the right-hand side expression refers to a class attribute, the left-hand side creates a new instance attribute as the target of the assignment:

This description does not necessarily apply to descriptor attributes, such as properties created with property() .

If the target is a subscription: The primary expression in the reference is evaluated. It should yield either a mutable sequence object (such as a list) or a mapping object (such as a dictionary). Next, the subscript expression is evaluated.

If the primary is a mutable sequence object (such as a list), the subscript must yield an integer. If it is negative, the sequence’s length is added to it. The resulting value must be a nonnegative integer less than the sequence’s length, and the sequence is asked to assign the assigned object to its item with that index. If the index is out of range, IndexError is raised (assignment to a subscripted sequence cannot add new items to a list).

If the primary is a mapping object (such as a dictionary), the subscript must have a type compatible with the mapping’s key type, and the mapping is then asked to create a key/value pair which maps the subscript to the assigned object. This can either replace an existing key/value pair with the same key value, or insert a new key/value pair (if no key with the same value existed).

For user-defined objects, the __setitem__() method is called with appropriate arguments.

If the target is a slicing: The primary expression in the reference is evaluated. It should yield a mutable sequence object (such as a list). The assigned object should be a sequence object of the same type. Next, the lower and upper bound expressions are evaluated, insofar they are present; defaults are zero and the sequence’s length. The bounds should evaluate to integers. If either bound is negative, the sequence’s length is added to it. The resulting bounds are clipped to lie between zero and the sequence’s length, inclusive. Finally, the sequence object is asked to replace the slice with the items of the assigned sequence. The length of the slice may be different from the length of the assigned sequence, thus changing the length of the target sequence, if the target sequence allows it.

CPython implementation detail: In the current implementation, the syntax for targets is taken to be the same as for expressions, and invalid syntax is rejected during the code generation phase, causing less detailed error messages.

Although the definition of assignment implies that overlaps between the left-hand side and the right-hand side are ‘simultaneous’ (for example a, b = b, a swaps two variables), overlaps within the collection of assigned-to variables occur left-to-right, sometimes resulting in confusion. For instance, the following program prints [0, 2] :

The specification for the *target feature.

7.2.1. Augmented assignment statements ¶

Augmented assignment is the combination, in a single statement, of a binary operation and an assignment statement:

(See section Primaries for the syntax definitions of the last three symbols.)

An augmented assignment evaluates the target (which, unlike normal assignment statements, cannot be an unpacking) and the expression list, performs the binary operation specific to the type of assignment on the two operands, and assigns the result to the original target. The target is only evaluated once.

An augmented assignment statement like x += 1 can be rewritten as x = x + 1 to achieve a similar, but not exactly equal effect. In the augmented version, x is only evaluated once. Also, when possible, the actual operation is performed in-place , meaning that rather than creating a new object and assigning that to the target, the old object is modified instead.

Unlike normal assignments, augmented assignments evaluate the left-hand side before evaluating the right-hand side. For example, a[i] += f(x) first looks-up a[i] , then it evaluates f(x) and performs the addition, and lastly, it writes the result back to a[i] .

With the exception of assigning to tuples and multiple targets in a single statement, the assignment done by augmented assignment statements is handled the same way as normal assignments. Similarly, with the exception of the possible in-place behavior, the binary operation performed by augmented assignment is the same as the normal binary operations.

For targets which are attribute references, the same caveat about class and instance attributes applies as for regular assignments.

7.2.2. Annotated assignment statements ¶

Annotation assignment is the combination, in a single statement, of a variable or attribute annotation and an optional assignment statement:

The difference from normal Assignment statements is that only a single target is allowed.

The assignment target is considered “simple” if it consists of a single name that is not enclosed in parentheses. For simple assignment targets, if in class or module scope, the annotations are evaluated and stored in a special class or module attribute __annotations__ that is a dictionary mapping from variable names (mangled if private) to evaluated annotations. This attribute is writable and is automatically created at the start of class or module body execution, if annotations are found statically.

If the assignment target is not simple (an attribute, subscript node, or parenthesized name), the annotation is evaluated if in class or module scope, but not stored.

If a name is annotated in a function scope, then this name is local for that scope. Annotations are never evaluated and stored in function scopes.

If the right hand side is present, an annotated assignment performs the actual assignment before evaluating annotations (where applicable). If the right hand side is not present for an expression target, then the interpreter evaluates the target except for the last __setitem__() or __setattr__() call.

The proposal that added syntax for annotating the types of variables (including class variables and instance variables), instead of expressing them through comments.

The proposal that added the typing module to provide a standard syntax for type annotations that can be used in static analysis tools and IDEs.

Changed in version 3.8: Now annotated assignments allow the same expressions in the right hand side as regular assignments. Previously, some expressions (like un-parenthesized tuple expressions) caused a syntax error.

7.3. The assert statement ¶

Assert statements are a convenient way to insert debugging assertions into a program:

The simple form, assert expression , is equivalent to

The extended form, assert expression1, expression2 , is equivalent to

These equivalences assume that __debug__ and AssertionError refer to the built-in variables with those names. In the current implementation, the built-in variable __debug__ is True under normal circumstances, False when optimization is requested (command line option -O ). The current code generator emits no code for an assert statement when optimization is requested at compile time. Note that it is unnecessary to include the source code for the expression that failed in the error message; it will be displayed as part of the stack trace.

Assignments to __debug__ are illegal. The value for the built-in variable is determined when the interpreter starts.

7.4. The pass statement ¶

pass is a null operation — when it is executed, nothing happens. It is useful as a placeholder when a statement is required syntactically, but no code needs to be executed, for example:

7.5. The del statement ¶

Deletion is recursively defined very similar to the way assignment is defined. Rather than spelling it out in full details, here are some hints.

Deletion of a target list recursively deletes each target, from left to right.

Deletion of a name removes the binding of that name from the local or global namespace, depending on whether the name occurs in a global statement in the same code block. If the name is unbound, a NameError exception will be raised.

Deletion of attribute references, subscriptions and slicings is passed to the primary object involved; deletion of a slicing is in general equivalent to assignment of an empty slice of the right type (but even this is determined by the sliced object).

Changed in version 3.2: Previously it was illegal to delete a name from the local namespace if it occurs as a free variable in a nested block.

7.6. The return statement ¶

return may only occur syntactically nested in a function definition, not within a nested class definition.

If an expression list is present, it is evaluated, else None is substituted.

return leaves the current function call with the expression list (or None ) as return value.

When return passes control out of a try statement with a finally clause, that finally clause is executed before really leaving the function.

In a generator function, the return statement indicates that the generator is done and will cause StopIteration to be raised. The returned value (if any) is used as an argument to construct StopIteration and becomes the StopIteration.value attribute.

In an asynchronous generator function, an empty return statement indicates that the asynchronous generator is done and will cause StopAsyncIteration to be raised. A non-empty return statement is a syntax error in an asynchronous generator function.

7.7. The yield statement ¶

A yield statement is semantically equivalent to a yield expression . The yield statement can be used to omit the parentheses that would otherwise be required in the equivalent yield expression statement. For example, the yield statements

are equivalent to the yield expression statements

Yield expressions and statements are only used when defining a generator function, and are only used in the body of the generator function. Using yield in a function definition is sufficient to cause that definition to create a generator function instead of a normal function.

For full details of yield semantics, refer to the Yield expressions section.

7.8. The raise statement ¶

If no expressions are present, raise re-raises the exception that is currently being handled, which is also known as the active exception . If there isn’t currently an active exception, a RuntimeError exception is raised indicating that this is an error.

Otherwise, raise evaluates the first expression as the exception object. It must be either a subclass or an instance of BaseException . If it is a class, the exception instance will be obtained when needed by instantiating the class with no arguments.

The type of the exception is the exception instance’s class, the value is the instance itself.

A traceback object is normally created automatically when an exception is raised and attached to it as the __traceback__ attribute. You can create an exception and set your own traceback in one step using the with_traceback() exception method (which returns the same exception instance, with its traceback set to its argument), like so:

The from clause is used for exception chaining: if given, the second expression must be another exception class or instance. If the second expression is an exception instance, it will be attached to the raised exception as the __cause__ attribute (which is writable). If the expression is an exception class, the class will be instantiated and the resulting exception instance will be attached to the raised exception as the __cause__ attribute. If the raised exception is not handled, both exceptions will be printed:

A similar mechanism works implicitly if a new exception is raised when an exception is already being handled. An exception may be handled when an except or finally clause, or a with statement, is used. The previous exception is then attached as the new exception’s __context__ attribute:

Exception chaining can be explicitly suppressed by specifying None in the from clause:

Additional information on exceptions can be found in section Exceptions , and information about handling exceptions is in section The try statement .

Changed in version 3.3: None is now permitted as Y in raise X from Y .

Added the __suppress_context__ attribute to suppress automatic display of the exception context.

Changed in version 3.11: If the traceback of the active exception is modified in an except clause, a subsequent raise statement re-raises the exception with the modified traceback. Previously, the exception was re-raised with the traceback it had when it was caught.

7.9. The break statement ¶

break may only occur syntactically nested in a for or while loop, but not nested in a function or class definition within that loop.

It terminates the nearest enclosing loop, skipping the optional else clause if the loop has one.

If a for loop is terminated by break , the loop control target keeps its current value.

When break passes control out of a try statement with a finally clause, that finally clause is executed before really leaving the loop.

7.10. The continue statement ¶

continue may only occur syntactically nested in a for or while loop, but not nested in a function or class definition within that loop. It continues with the next cycle of the nearest enclosing loop.

When continue passes control out of a try statement with a finally clause, that finally clause is executed before really starting the next loop cycle.

7.11. The import statement ¶

The basic import statement (no from clause) is executed in two steps:

find a module, loading and initializing it if necessary

define a name or names in the local namespace for the scope where the import statement occurs.

When the statement contains multiple clauses (separated by commas) the two steps are carried out separately for each clause, just as though the clauses had been separated out into individual import statements.

The details of the first step, finding and loading modules, are described in greater detail in the section on the import system , which also describes the various types of packages and modules that can be imported, as well as all the hooks that can be used to customize the import system. Note that failures in this step may indicate either that the module could not be located, or that an error occurred while initializing the module, which includes execution of the module’s code.

If the requested module is retrieved successfully, it will be made available in the local namespace in one of three ways:

If the module name is followed by as , then the name following as is bound directly to the imported module.

If no other name is specified, and the module being imported is a top level module, the module’s name is bound in the local namespace as a reference to the imported module

If the module being imported is not a top level module, then the name of the top level package that contains the module is bound in the local namespace as a reference to the top level package. The imported module must be accessed using its full qualified name rather than directly

The from form uses a slightly more complex process:

find the module specified in the from clause, loading and initializing it if necessary;

for each of the identifiers specified in the import clauses:

check if the imported module has an attribute by that name

if not, attempt to import a submodule with that name and then check the imported module again for that attribute

if the attribute is not found, ImportError is raised.

otherwise, a reference to that value is stored in the local namespace, using the name in the as clause if it is present, otherwise using the attribute name

If the list of identifiers is replaced by a star ( '*' ), all public names defined in the module are bound in the local namespace for the scope where the import statement occurs.

The public names defined by a module are determined by checking the module’s namespace for a variable named __all__ ; if defined, it must be a sequence of strings which are names defined or imported by that module. The names given in __all__ are all considered public and are required to exist. If __all__ is not defined, the set of public names includes all names found in the module’s namespace which do not begin with an underscore character ( '_' ). __all__ should contain the entire public API. It is intended to avoid accidentally exporting items that are not part of the API (such as library modules which were imported and used within the module).

The wild card form of import — from module import * — is only allowed at the module level. Attempting to use it in class or function definitions will raise a SyntaxError .

When specifying what module to import you do not have to specify the absolute name of the module. When a module or package is contained within another package it is possible to make a relative import within the same top package without having to mention the package name. By using leading dots in the specified module or package after from you can specify how high to traverse up the current package hierarchy without specifying exact names. One leading dot means the current package where the module making the import exists. Two dots means up one package level. Three dots is up two levels, etc. So if you execute from . import mod from a module in the pkg package then you will end up importing pkg.mod . If you execute from ..subpkg2 import mod from within pkg.subpkg1 you will import pkg.subpkg2.mod . The specification for relative imports is contained in the Package Relative Imports section.

importlib.import_module() is provided to support applications that determine dynamically the modules to be loaded.

Raises an auditing event import with arguments module , filename , sys.path , sys.meta_path , sys.path_hooks .

7.11.1. Future statements ¶

A future statement is a directive to the compiler that a particular module should be compiled using syntax or semantics that will be available in a specified future release of Python where the feature becomes standard.

The future statement is intended to ease migration to future versions of Python that introduce incompatible changes to the language. It allows use of the new features on a per-module basis before the release in which the feature becomes standard.

A future statement must appear near the top of the module. The only lines that can appear before a future statement are:

the module docstring (if any),

blank lines, and

other future statements.

The only feature that requires using the future statement is annotations (see PEP 563 ).

All historical features enabled by the future statement are still recognized by Python 3. The list includes absolute_import , division , generators , generator_stop , unicode_literals , print_function , nested_scopes and with_statement . They are all redundant because they are always enabled, and only kept for backwards compatibility.

A future statement is recognized and treated specially at compile time: Changes to the semantics of core constructs are often implemented by generating different code. It may even be the case that a new feature introduces new incompatible syntax (such as a new reserved word), in which case the compiler may need to parse the module differently. Such decisions cannot be pushed off until runtime.

For any given release, the compiler knows which feature names have been defined, and raises a compile-time error if a future statement contains a feature not known to it.

The direct runtime semantics are the same as for any import statement: there is a standard module __future__ , described later, and it will be imported in the usual way at the time the future statement is executed.

The interesting runtime semantics depend on the specific feature enabled by the future statement.

Note that there is nothing special about the statement:

That is not a future statement; it’s an ordinary import statement with no special semantics or syntax restrictions.

Code compiled by calls to the built-in functions exec() and compile() that occur in a module M containing a future statement will, by default, use the new syntax or semantics associated with the future statement. This can be controlled by optional arguments to compile() — see the documentation of that function for details.

A future statement typed at an interactive interpreter prompt will take effect for the rest of the interpreter session. If an interpreter is started with the -i option, is passed a script name to execute, and the script includes a future statement, it will be in effect in the interactive session started after the script is executed.

The original proposal for the __future__ mechanism.

7.12. The global statement ¶

The global statement is a declaration which holds for the entire current code block. It means that the listed identifiers are to be interpreted as globals. It would be impossible to assign to a global variable without global , although free variables may refer to globals without being declared global.

Names listed in a global statement must not be used in the same code block textually preceding that global statement.

Names listed in a global statement must not be defined as formal parameters, or as targets in with statements or except clauses, or in a for target list, class definition, function definition, import statement, or variable annotation.

CPython implementation detail: The current implementation does not enforce some of these restrictions, but programs should not abuse this freedom, as future implementations may enforce them or silently change the meaning of the program.

Programmer’s note: global is a directive to the parser. It applies only to code parsed at the same time as the global statement. In particular, a global statement contained in a string or code object supplied to the built-in exec() function does not affect the code block containing the function call, and code contained in such a string is unaffected by global statements in the code containing the function call. The same applies to the eval() and compile() functions.

7.13. The nonlocal statement ¶

When the definition of a function or class is nested (enclosed) within the definitions of other functions, its nonlocal scopes are the local scopes of the enclosing functions. The nonlocal statement causes the listed identifiers to refer to names previously bound in nonlocal scopes. It allows encapsulated code to rebind such nonlocal identifiers. If a name is bound in more than one nonlocal scope, the nearest binding is used. If a name is not bound in any nonlocal scope, or if there is no nonlocal scope, a SyntaxError is raised.

The nonlocal statement applies to the entire scope of a function or class body. A SyntaxError is raised if a variable is used or assigned to prior to its nonlocal declaration in the scope.

The specification for the nonlocal statement.

Programmer’s note: nonlocal is a directive to the parser and applies only to code parsed along with it. See the note for the global statement.

7.14. The type statement ¶

The type statement declares a type alias, which is an instance of typing.TypeAliasType .

For example, the following statement creates a type alias:

This code is roughly equivalent to:

annotation-def indicates an annotation scope , which behaves mostly like a function, but with several small differences.

The value of the type alias is evaluated in the annotation scope. It is not evaluated when the type alias is created, but only when the value is accessed through the type alias’s __value__ attribute (see Lazy evaluation ). This allows the type alias to refer to names that are not yet defined.

Type aliases may be made generic by adding a type parameter list after the name. See Generic type aliases for more.

type is a soft keyword .

Added in version 3.12.

Introduced the type statement and syntax for generic classes and functions.

Table of Contents

• 7.1. Expression statements
• 7.2.1. Augmented assignment statements
• 7.2.2. Annotated assignment statements
• 7.3. The assert statement
• 7.4. The pass statement
• 7.5. The del statement
• 7.6. The return statement
• 7.7. The yield statement
• 7.8. The raise statement
• 7.9. The break statement
• 7.10. The continue statement
• 7.11.1. Future statements
• 7.12. The global statement
• 7.13. The nonlocal statement
• 7.14. The type statement

Previous topic

6. Expressions

8. Compound statements

• Report a Bug
• Show Source

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Why do I get "SyntaxError: invalid syntax" in a line with perfectly valid syntax?

This is the line of code:

Pmin , Pmax , w , fi1 and fi2 have all been assigned finite values at this point, so why is there an error?

When I remove that line from the code, the same error appears at the next line of code, again for no apparent reason.

• syntax-error

• 2 I found the error, there was a missing bracket in one of the previous lines. Thanks for the help –  Pearl Philip Commented Jun 16, 2014 at 5:47
• 1 Starting with Python 3.10, we get better error messages for this kind of thing. In this case, SyntaxError: '(' was never closed , and there's an arrow that points to the opening parenthesis. –  wjandrea Commented Mar 3, 2023 at 4:53
• I changed my mind and reopened stackoverflow.com/questions/10239668 . It's distinct enough that it shouldn't be considered a duplicate here. –  Karl Knechtel Commented Dec 7, 2023 at 12:11

4 Answers 4

For earlier versions of Python (1) , an error may be reported on a line that appears to be correct. In that case, you should try commenting out the line where the error appears to be. If the error moves to the next line, there are two possibilities:

• Either both lines have a problem (and the second was hidden by the first); or
• The previous line has a problem which is being carried forward.

The latter is more likely , especially if commenting out the new offending line causes the error to move again.

For example, consider code like the following, saved as prog.py :

Python 3.8.10 will report an error on line 2, even though the problem is clearly caused by line 1:

The code in your question has a similar problem: the code on the previous line to the reported error has unbalanced parentheses.

Annotated to make it clearer:

There isn't really a general solution for this - the code needs to be analyzed and understood , in order to determine how the parentheses should be altered.

(1) For what it's worth, the new PEG parser introduced in Python 3.9 paved the way for much improved error messages (gradually improving from 3.10 thru 3.12). This includes correctly identifying in the source code where the error is:

• It turns out that an analogous issue can be caused by omitting the except (or finally ) block from a try . This causes IndentationError on the next line, because that unindented line isn't inside the try block nor the expected except block. Newer Python versions report an explicit SyntaxError calling out the missing block. Note that IndentationError is a subclass of SyntaxError . –  Karl Knechtel Commented Nov 25, 2023 at 0:54

You're missing a close paren in this line:

There are three ( and only two ) .

• My case was categorized as "the previous line has a problem which is being carried forward" according to paxdiablo . What I did to find the error was by commenting line by line upward the code until the Syntax Error disappeared temporary. The last line that I gave comment mark was the one who cause error. –  Santosa Sandy Commented Mar 28, 2017 at 8:00

I encountered a similar problem, with a syntax error that I knew should not be a syntax error. In my case it turned out that a Python 2 interpreter was trying to run Python 3 code, or vice versa; I think that my shell had a PYTHONPATH with a mixture of Python 2 and Python 3.

I noticed that invalid syntax error for no apparent reason can be caused by using space in:

Python IDLE seems to jump and highlight a part of the first line for some reason (even if the first line happens to be a comment), which is misleading.

• 3 f-string-invalid-syntax-in-python-3-5: stackoverflow.com/questions/55182209/… –  davesave Commented Jun 24, 2021 at 12:50
• Does Python's error show the wrong line, or is this only an IDLE thing? Either way, this is a different issue than the one OP's experiencing, if you read their code. –  wjandrea Commented Mar 3, 2023 at 5:14
• While it makes sense here to have answers that show problems caused by other kinds of valid syntax, this is an example where the version of Python used causes the syntax not to be valid. This question, fundamentally, is about code becoming invalid because of other parts of the code . –  Karl Knechtel Commented Nov 25, 2023 at 1:01

Not the answer you're looking for? Browse other questions tagged python syntax-error or ask your own question .

• The Overflow Blog
• Ongoing community data protection
• A developer works to balance the data center boom with his climate change battle
• Featured on Meta
• Preventing unauthorized automated access to the network
• Feedback Requested: How do you use the tagged questions page?
• Proposed designs to update the homepage for logged-in users

Hot Network Questions

• Clockwise (counterclockwise) order of points in simple polygon
• Is there a reason the LED current is being limited this way?
• Is set of integers closed under the operation of subtraction?
• Liability for bicycle group ride members and optional organizers
• What are the naming schemes used for geographical features in other planets/moons?
• This housing tech can rapidly "print" its own interior environments with an invisible 3D-printing swarm. Why isn't this tech everywhere?
• Do any hobbits ever use "Sie" in German translations of The Hobbit or The Lord of the Rings?
• Solving the unsolvable 15 puzzle
• How to expressing a chain of OR where the member constraint carry a continuous variable?
• FindInstance is not able to find a solution that can be found easily by random substitution
• Deuteronomy 28:68
• Stacking n amount of objects on top of each other in a specific order using geometry nodes
• Front (white) and rear (red) lights for train Lego 60336
• Is "tasting" shallow or decisive in Hebrews 6:4?
• Simulating Near Sine Wave PWM
• Global entry not approved in portal 2 weeks after verbal approval by CBP offers at enrollment on arrival interview
• Did Steven Pinker test (or propose testing) if ADHD patients could sit still for 5 minutes while in front of "6 legos and an over turned lamp"?
• "I’m not sure that I’ll go, but I may do." — Why does "may do" sound unnatural here in American English?
• Splitting token lists on underscores
• Prevent line break when using pmatrix within an equation
• Can you prove polynomial irreducibility via substitution to a quadratic polynomial?
• Is it okay to have kitchen base cabinet be less than 3.5" off the floor?
• Top is right, the rest is left
• Who has "decision-authority" about paper content: First author or the co-author with the higher academic rank?

Assignment Expressions: The Walrus Operator

• Discussion (8)

In this lesson, you’ll learn about the biggest change in Python 3.8: the introduction of assignment expressions . Assignment expression are written with a new notation (:=) .This operator is often called the walrus operator as it resembles the eyes and tusks of a walrus on its side.

Assignment expressions allow you to assign and return a value in the same expression. For example, if you want to assign to a variable and print its value, then you typically do something like this:

In Python 3.8, you’re allowed to combine these two statements into one, using the walrus operator:

The assignment expression allows you to assign True to walrus , and immediately print the value. But keep in mind that the walrus operator does not do anything that isn’t possible without it. It only makes certain constructs more convenient, and can sometimes communicate the intent of your code more clearly.

One pattern that shows some of the strengths of the walrus operator is while loops where you need to initialize and update a variable. For example, the following code asks the user for input until they type quit :

This code is less than ideal. You’re repeating the input() statement, and somehow you need to add current to the list before asking the user for it. A better solution is to set up an infinite while loop, and use break to stop the loop:

This code is equivalent to the code above, but avoids the repetition and somehow keeps the lines in a more logical order. If you use an assignment expression, then you can simplify this loop further:

This moves the test back to the while line, where it should be. However, there are now several things happening at that line, so it takes a bit more effort to read it properly. Use your best judgement about when the walrus operator helps make your code more readable.

PEP 572 describes all the details of assignment expressions, including some of the rationale for introducing them into the language, as well as several examples of how the walrus operator can be used. The Python 3.8 documentation also includes some good examples of assignment expressions.

Here are a few resources for more info on using bpython, the REPL (Read–Eval–Print Loop) tool used in most of these videos:

• Discover bpython: A Python REPL With IDE-Like Features
• A better Python REPL: bpython vs python
• bpython Homepage
• bpython Docs

00:00 In this video, you’ll learn about what’s being called the walrus operator. One of the biggest changes in Python 3.8 is the introduction of these assignment expressions. So, what does it do?

00:12 Well, it allows the assignment and the return of a value in the same expression, using a new notation. On the left side, you’d have the name of the object that you’re assigning, and then you have the operator, a colon and an equal sign ( := ), affectionately known as the walrus operator as it resembles the eyes and tusks of a walrus on its side.

00:32 And it’s assigning this expression on the right side, so it’s assigning and returning the value in the same expression. Let me have you practice with this operator with some code.

00:44 Throughout this tutorial, when I use a REPL, I’m going to be using this custom REPL called bpython . I’ll include links on how to install bpython below this video.

00:53 So, how do you use this assignment operator? Let me have you start with a small example. You could have an object named walrus and assign it the value of False , and then you could print it. In Python 3.8, you can combine those two statements and do a single statement using the walrus operator. So inside of print() , you could say walrus , the new object, and use the operator, the assignment expression := , and a space, and then say True . That’s going to do two things. Most notably, in reverse order, it returned the value True . And then it also assigned the value to walrus , and of course the type of 'bool' .

01:38 Keep in mind, the walrus operator doesn’t do anything that isn’t possible without it. It only makes certain constructs a bit more convenient, and can sometimes communicate the intent of your code more clearly.

01:48 Let me show you another example. It’s a pattern that shows some of the strengths of the walrus operator inside of while loops, where you need to initialize and update a variable. For example, create a new file, and name it write_something.py . Here’s write_something.py .

02:09 It starts with inputs , which will be a list. So create a list called inputs .

02:16 Into an object named current , use an input() statement. The input() statement is going to provide a prompt and read a string in from standard input. The prompt will be this, "Write something: " .

02:28 So when the user inputs that, that’ll go into current . So while current != "quit" — if the person has not typed quit yet— you’re going to take inputs and append the current value.

02:44 And then here, you’re asking to "Write something: " again.

02:50 Down here at my terminal, after saving—let’s see, make sure you’re saved. Okay. Now that’s saved.

03:00 So here, I could say, Hello , Welcome , and then finally quit , which then would quit it. So, this code isn’t ideal.

03:08 You’re repeating the input() statement twice, and somehow you need to add current to the list before asking the user for it. So a better solution is going to be to set up maybe an infinite while loop, and then use a break to stop the loop. How would that look?

03:22 You’re going to rearrange this a little bit. Move the while loop up, and say while True:

03:35 and here say if current == "quit": then break . Otherwise, go ahead and append it. So, a little different here, but this is a while loop that’s going to continue as long as it doesn’t get broken out of by someone typing quit . Okay.

03:53 Running it again. And there, you can see it breaking out. Nice. So, that code avoids the repetition and kind of keeps things in a more logical order, but there’s a way to simplify this to use that new assignment expression, the walrus operator. In that case, you’re going to modify this quite a bit.

04:17 Here you’re going to say while , current and then use that assignment operator ( := ) to create current .

04:23 But also, while doing that, check to see that it’s not equal to "quit" . So here, each time that assigns the value to current and it’s returned, so the value can be checked.

04:35 So while , current , assigning the value from the input() , and then if it’s not equal to "quit" , you’re going to append current . Make sure to save.

04:42 Run the code one more time.

04:47 And it works the same. This moves that test all the way back to the while line, where it should be. However, there’s a couple of things now happening all in one line, and that might take a little more effort to read what’s happening and to understand it properly.

05:00 There are a handful of other examples that you could look into to learn a little more about assignment expressions. I’ll include a link to PEP 572, and also a link to the Python docs for version 3.8, both of which include more code examples.

05:14 So you need to use your best judgment as to when this operator’s going to make your code more readable and more useful. In the next video, you’ll learn about the new feature of positional-only arguments.

rajeshboyalla on Dec. 4, 2019

Why do you use list() to initialize a list rather than using [] ?

Geir Arne Hjelle RP Team on Dec. 4, 2019

My two cents about list() vs [] (I wrote the original article this video series is based on):

• I find spelling out list() to be more readable and easier to notice and interpret than []
• [] is several times faster than list() , but we’re still talking nanoseconds. On my computer [] takes about 15ns, while list() runs in 60ns. Typically, lists are initiated once, so this does not cause any meaningful slowdown of code.

That said, if I’m initializing a list with existing elements, I usually use [elem1, elem2, ...] , since list(...) has different–and sometimes surprising–semantics.

Jason on April 3, 2020

Sorry for my ignorance, did the the standard assignment = operator work in this way? I don’t understand what has been gained from adding the := operator. If anything I think it will allow people to write more obfuscated code. But minds better than mine have been working on this, so I’ll have to take their word it is an improvement.

As for the discussion on whether [] is more readable than list(). I’d never seen list() before, so to me [] is better. I’ve only just come over from the dark 2.7 side so maybe it’s an old python programmer thing?

Oh I checked the operation on the assignment operator. I was obviously wrong. lol Still I think the existing operator could’ve been tweaked to do the same thing as := … I’m still on the fence about that one.

gedece on April 3, 2020

you are right in that the existing operator could have worked, but it can lead to something unexpected.

if you do something like

if (newvar = somevar): it gives a traceback, because you are supposed to use == for comparations.

So if you use the normal operator for this, then that expression is valid and you’ll be hard pressed to realize the mistake.

It then makes complete sense to use a different operator as that helps to clarify intent in code.

Jason on April 6, 2020

Yes, I’ve accidentaly done that in other languages before and it can be a difficult to “see” bug.

varelaautumn on Sept. 26, 2020

I watched this earlier today and now tonight I just can’t stop myself from throwing these walrus operators everywhere.

(I’m new and learning so these are just personal fooling around programs)

For example I have this function which cycles through a bunch of other very simple parsing functions that check if my input string is valid in the context of the game state. If the string doesn’t pass one of these parsers it returns a string with an error message such as “Input must be less than 5 characters”. And then the parse_input function returns that error string.

I mean it’s not a huge change, but it saves an extra call of the function, and I feel like it makes it much more readable.

I’m not sure if this other case might be considered abuse of the walrus operator, but I decided to use it twice in one line.

This function repeatedly asks for input. If the input does not pass the parser functions, then the error will be returned and printed out in the while loop. Otherwise the input was valid and it gets returned.

I’m able to pass my input into a function and check the result of that function all while retaining my input and the return of the function as their own variables to be used in the next line.

I think the walrus operator helped me put all the relevant details on the three lines. Like if you just read the first words of each line, it basically says “while error, print error, else return input_string.” I don’t see how I could have done that without this cool walrus operator so I’m really appreciative for this video you made! I’ve been converted to a strong believer in the walrus operator.

Geir Arne Hjelle RP Team on Sept. 26, 2020

@varelaautumn Nice examples, thanks for sharing!

I agree that the walrus operator will not revolutionize your code, but it can bring these sorts of small improvements that add up in the long run.

Become a Member to join the conversation.