Getting Started With Operators and Expressions

In programming, anoperator is usually a symbol or combination of symbols that allows you to perform a specific operation. This operation can act on one or moreoperands. If the operation involves a single operand, then the operator isunary. If the operator involves two operands, then the operator isbinary.

For example, in Python, you can use the minus sign (-) as a unary operator to declare a negative number. You can also use it to subtract two numbers:

>>>-273.15-273.15>>>5-23

In this code snippet, the minus sign (-) in the first example is a unary operator, and the number273.15 is the operand. In the second example, the same symbol is a binary operator, and the numbers5 and2 are its left and right operands.

Programming languages typically have operators built in as part of their syntax. In many languages, including Python, you can also create your own operator or modify the behavior of existing ones, which is a powerful and advanced feature to have.

In practice, operators provide a quick shortcut for you to manipulate data, perform mathematical calculations, compare values, runBoolean tests, assign values to variables, and more. In Python, an operator may be a symbol, a combination of symbols, or akeyword, depending on the type of operator that you’re dealing with.

For example, you’ve already seen the subtraction operator, which is represented with a single minus sign (-). The equality operator is a double equal sign (==). So, it’s a combination of symbols:

>>>42==42True

In this example, you use the Python equality operator (==) to compare two numbers. As a result, you getTrue, which is one of Python’s Boolean values.

Speaking of Boolean values, the Boolean or logical operators in Python are keywords rather than signs, as you’ll learn in the section aboutBoolean operators and expressions. So, instead of the odd signs like||,&&, and! that many other programming languages use, Python usesor,and, andnot.

Using keywords instead of odd signs is a really cool design decision that’s consistent with the fact that Python loves and encouragescode’s readability.

You’ll find several categories or groups of operators in Python. Here’s a quick list of those categories:

• Assignment operators
• Arithmetic operators
• Comparison operators
• Boolean or logical operators
• Identity operators
• Membership operators
• Concatenation andrepetition operators
• Bitwise operators

All these types of operators take care of specific types of computations and data-processing tasks. You’ll learn more about these categories throughout this tutorial. However, before jumping into more practical discussions, you need to know that the most elementary goal of an operator is to be part of anexpression. Operators by themselves don’t do much:

>>>-  File"<input>", line1-^SyntaxError:incomplete input>>>==  File"<input>", line1==^^SyntaxError:incomplete input>>>or  File"<input>", line1or^^SyntaxError:incomplete input

As you can see in this code snippet, if you use an operator without the required operands, then you’ll get asyntax error. So, operators must be part of expressions, which you can build using Python objects as operands.

So, what is an expression anyway? Python hassimple andcompound statements. A simple statement is a construct that occupies a singlelogical line, like an assignment statement. A compound statement is a construct that occupies multiple logical lines, such as afor loop or aconditional statement. Anexpression is a simple statement that produces and returns a value.

You’ll find operators in many expressions. Here are a few examples:

>>>7+512>>>42/221.0>>>5==5True

In the first two examples, you use the addition and division operators to construct two arithmetic expressions whose operands are integer numbers. In the last example, you use the equality operator to create a comparison expression. In all cases, you get a specific value after executing the expression.

Note that not all expressions use operators. For example, a barefunction call is an expression that doesn’t require any operator:

>>>abs(-7)7>>>pow(2,8)256>>>print("Hello, World!")Hello, World!

In the first example, you call the built-inabs() function to get theabsolute value of-7. Then, you compute2 to the power of8 using the built-inpow() function. These function calls occupy a single logical line and return a value. So, they’re expressions.

Finally, the call to the built-inprint() function is another expression. This time, the function doesn’treturn a fruitful value, but it still returnsNone, which is the Pythonnull type. So, the call is technically an expression.

Even though all expressions are statements, not all statements are expressions. For example, pureassignment statements don’t return any value, as you’ll learn in a moment. Therefore, they’re not expressions. The assignment operator is a special operator that doesn’t create an expression but a statement.

Okay! That was a quick introduction to operators and expressions in Python. Now it’s time to dive deeper into the topic. To kick things off, you’ll start with the assignment operator and statements.

The Assignment Operator and Statements

Theassignment operator is one of the most frequently used operators in Python. The operator consists of a single equal sign (=), and it operates on two operands. The left-hand operand is typically avariable, while the right-hand operand is an expression.

The assignment operator allows you toassign values to variables. Strictly speaking, in Python, this operator makes variables or names refer to specific objects in your computer’s memory. In other words, an assignment creates a reference to a concrete object and attaches that reference to the target variable.

For example, all the statements below create new variables that hold references to specific objects:

>>>number=42>>>day="Friday">>>digits=(0,1,2,3,4,5,6,7,8,9)>>>letters=["a","b","c"]

In the first statement, you create thenumber variable, which holds a reference to thenumber42 in your computer’s memory. You can also say that the namenumberpoints to42, which is a concrete object.

In the rest of the examples, you create other variables that point to other types of objects, such as astring,tuple, andlist, respectively.

You’ll use the assignment operator in many of the examples that you’ll write throughout this tutorial. More importantly, you’ll use this operator many times in your own code. It’ll be your forever friend. Now you can dive into other Python operators!

Arithmetic Operators and Expressions in Python

Arithmetic operators are those operators that allow you to performarithmetic operations on numeric values. Yes, they come from math, and in most cases, you’ll represent them with the usual math signs. The following table lists the arithmetic operators that Python currently supports:

Note thata andb in theSample Expression column represent numeric values, such asinteger,floating-point,complex,rational, anddecimal numbers.

Here are some examples of these operators in use:

>>>a=5>>>b=2>>>+a5>>>-b-2>>>a+b7>>>a-b3>>>a*b10>>>a/b2.5>>>a%b1>>>a//b2>>>a**b25

In this code snippet, you first create two new variables,a andb, holding5 and2, respectively. Then you use these variables to create different arithmetic expressions using a specific operator in each expression.

Again, the standard division operator (/) always returns a floating-point number, even if the dividend is evenly divisible by the divisor:

>>>10/52.0>>>10.0/52.0

In the first example,10 is evenly divisible by5. Therefore, this operation could return the integer2. However, it returns the floating-point number2.0. In the second example,10.0 is a floating-point number, and5 is an integer. In this case, Python internally promotes5 to5.0 and runs the division. The result is a floating-point number too.

>>>10/5j-2j

Finally, consider the following examples of using the floor division (//) operator:

>>>10//42>>>-10//-42>>>10//-4-3>>>-10//4-3

Floor division alwaysrounds down. This means that the result is the greatest integer that’s smaller than or equal to the quotient. For positive numbers, it’s as though the fractional portion is truncated, leaving only the integer portion.

Comparison Operators and Expressions in Python

The Pythoncomparison operators allow you tocompare numerical values and any other objects that support them. The table below lists all the currently available comparison operators in Python:

The comparison operators are all binary. This means that they require left and right operands. These operators always return a Boolean value (True orFalse) that depends on thetruth value of the comparison at hand.

Note that comparisons between objects of different data types often don’t make sense and sometimes aren’t allowed in Python. For example, you can compare a number and a string for equality with the== operator. However, you’ll getFalse as a result:

>>>2=="2"False

The integer2 isn’t equal to the string"2". Therefore, you getFalse as a result. You can also use the!= operator in the above expression, in which case you’ll getTrue as a result.

Non-equality comparisons between operands of different data types raise aTypeError exception:

>>>5<"7"Traceback (most recent call last):...TypeError:'<' not supported between instances of 'int' and 'str'

In this example, Python raises aTypeError exception because a less than comparison (<) doesn’t make sense between an integer and a string. So, the operation isn’t allowed.

It’s important to note that in the context of comparisons, integer and floating-point values are compatible, and you can compare them.

You’ll typically use and find comparison operators in Boolean contexts likeconditional statements andwhile loops. They allow you to make decisions and define a program’scontrol flow.

The comparison operators work on several types of operands, such as numbers, strings, tuples, and lists. In the following sections, you’ll explore the differences.

>>>a=10>>>b=20>>>a==bFalse>>>a!=bTrue>>>a<bTrue>>>a<=bTrue>>>a>bFalse>>>a>=bFalse>>>x=30>>>y=30>>>x==yTrue>>>x!=yFalse>>>x<yFalse>>>x<=yTrue>>>x>yFalse>>>x>=yTrue

>>>x=1.1+2.2>>>x==3.3False>>>1.1+2.23.3000000000000003

>>>frommathimportisclose>>>x=1.1+2.2>>>isclose(x,3.3)True

>>>ord("A")65>>>ord("a")97>>>"A"=="a"False>>>"A">"a"False>>>"A"<"a"True

>>>"Hello">"HellO"True>>>ord("o")111>>>ord("O")79

>>>"Hello">"Hello, World!"False

>>>[2,3]==[2,3]True>>>(2,3)==(2,3)True>>>[5,6,7]<[7,5,6]True>>>(5,6,7)<(7,5,6)True>>>[4,3,2]<[4,3,2]False>>>(4,3,2)<(4,3,2)False

>>>[2,3]==(2,3)False>>>[2,3]!=(2,3)True>>>[2,3]>(2,3)Traceback (most recent call last):...TypeError:'>' not supported between instances of 'list' and 'tuple'>>>[2,3]<=(2,3)Traceback (most recent call last):...TypeError:'<=' not supported between instances of 'list' and 'tuple'

>>>[5,6,7]<[8]True>>>(5,6,7)<(8,)True>>>[5,6,7]==[5]False>>>(5,6,7)==(5,)False>>>[5,6,7]>[5]True>>>(5,6,7)>(5,)True

Boolean Operators and Expressions in Python

Python has three Boolean or logical operators:and,or, andnot. They define a set of operations denoted by the generic operatorsAND,OR, andNOT. With these operators, you can create compound conditions.

In the following sections, you’ll learn how the Python Boolean operators work. Especially, you’ll learn that some of them behave differently when you use them with Boolean values or with regular objects as operands.

>>>age=20>>>is_adult=age>18>>>is_adultTrue>>>type(is_adult)<class 'bool'>

>>>number=42>>>validation_conditions=(...isinstance(number,int),...number%2==0,...)>>>all(validation_conditions)True>>>callable(number)False>>>callable(print)True

>>>5<7and3==3True>>>5<7and3!=3False>>>5>7and3==3False>>>5>7and3!=3False

>>>5<7or3==3True>>>5<7or3!=3True>>>5>7or3==3True>>>5>7or3!=3False

>>>5<7True>>>not5<7False

>>>bool(0),bool(0.0),bool(0.0+0j)(False, False, False)>>>bool(-3),bool(3.14159),bool(1.0+1j)(True, True, True)

>>>bool("")False>>>bool(" ")True>>>bool("Hello")True

>>>bool([])False>>>bool([1,2,3])True>>>bool(())False>>>bool(("John",25,"Python Dev"))True>>>bool(set())False>>>bool({"square","circle","triangle"})True>>>bool({})False>>>bool({"name":"John","age":25,"job":"Python Dev"})True

>>>3and44>>>0and40>>>3and00

>>>3or43>>>0or44>>>3or03

>>>0or[][]

>>>not3False>>>not0True

x1orx2orx3or...orxn

>>>deff(arg):...print(f"-> f({arg}) ={arg}")...returnarg...>>>f(0)-> f(0) = 00>>>f(False)-> f(False) = FalseFalse>>>f(1.5)-> f(1.5) = 1.51.5

>>>f(0)orf(False)orf(1)orf(2)orf(3)-> f(0) = 0-> f(False) = False-> f(1) = 11

x1andx2andx3and...andxn

>>>f(1)andf(False)andf(2)andf(3)-> f(1) = 1-> f(False) = FalseFalse>>>f(1)andf(0.0)andf(2)andf(3)-> f(1) = 1-> f(0.0) = 0.00.0

>>>f(1)andf(2.2)andf("Hello")-> f(1) = 1-> f(2.2) = 2.2-> f(Hello) = Hello'Hello'>>>f(1)andf(2.2)andf(0)-> f(1) = 1-> f(2.2) = 2.2-> f(0) = 00

>>>a=3>>>b=1>>>(b/a)>0True

>>>a=0>>>b=1>>>(b/a)>0Traceback (most recent call last):...ZeroDivisionError:division by zero

>>>a=0>>>b=1>>>a!=0and(b/a)>0False

defis_divisible(a,b):returnb!=0anda%b==0

>>>country="Canada">>>default_country="United States">>>countryordefault_country'Canada'>>>country="">>>countryordefault_country'United States'

data_is_cleanorclean_data(data)

data_is_updatedandprocess_data(data)

>>>number=5>>>number>=0andnumber<=10True>>>number=42>>>number>=0andnumber<=10False

>>>number=5>>>0<=number<=10True

Conditional Expressions or the Ternary Operator

Python has what it callsconditional expressions. These kinds of expressions are inspired by theternary operator that looks likea ? b : c and is used in other programming languages. This construct evaluates tob if the value ofa is true, and otherwise evaluates toc. Because of this, sometimes the equivalent Python syntax is also known as the ternary operator.

However, in Python, the expression looks more readable:

variable=expression_1ifconditionelseexpression_2

This expression returnsexpression_1 if the condition is true andexpression_2 otherwise. Note that this expression is equivalent to a regular conditional like the following:

ifcondition:variable=expression_1else:variable=expression_2

So, why does Python need this syntax?PEP 308 introduced conditional expressions as an effort to avoid the prevalence of error-prone attempts to achieve the same effect of a traditional ternary operator using theand andor operators in an expression like the following:

variable=conditionandexpression_1orexpression_2

However, this expression doesn’t work as expected, returningexpression_2 whenexpression_1 is falsy.

Some Python developers would avoid the syntax of conditional expressions in favor of a regular conditional statement. In any case, this syntax can be handy in some situations because it provides a concise tool for writing two-way conditionals.

Here’s an example of how to use the conditional expression syntax in your code:

>>>day="Sunday">>>open_time="11AM"ifday=="Sunday"else"9AM">>>open_time'11AM'>>>day="Monday">>>open_time="11AM"ifday=="Sunday"else"9AM">>>open_time'9AM'

Whenday is equal to"Sunday", the condition is true and you get the first expression,"11AM", as a result. If the condition is false, then you get the second expression,"9AM". Note that similarly to theand andor operators, the conditional expression returns the value of one of its expressions rather than a Boolean value.

Identity Operators and Expressions in Python

Python provides two operators,is andis not, that allow you to determine whether two operands have the sameidentity. In other words, they let you check if the operands refer to the same object. Note that identity isn’t the same thing as equality. The latter aims to check whether two operands contain the same data.

Here’s a summary of Python’s identity operators. Note thatx andy are variables that point to objects:

These two Python operators are keywords instead of odd symbols. This is part of Python’s goal of favoring readability in its syntax.

Here’s an example of two variables,x andy, that refer to objects that are equal but not identical:

>>>x=1001>>>y=1001>>>x==yTrue>>>xisyFalse

In this example,x andy refer to objects whose value is1001. So, they’re equal. However, they don’t reference the same object. That’s why theis operator returnsFalse. You can check an object’s identity using the built-inid() function:

>>>id(x)4417772080>>>id(y)4417766416

As you can conclude from theid() output,x andy don’t have the same identity. So, they’re different objects, and because of that, the expressionx is y returnsFalse. In other words, you getFalse because you have two different instances of1001 stored in your computer’s memory.

When you make an assignment likey = x, Python creates a second reference to the same object. Again, you can confirm that with theid() function or theis operator:

>>>a="Hello, Pythonista!">>>b=a>>>id(a)4417651936>>>id(b)4417651936>>>aisbTrue

In this example,a andb hold references to the same object, the string"Hello, Pythonista!". Therefore, theid() function returns the same identity when you call it witha andb. Similarly, theis operator returnsTrue.

Finally, theis not operator is the opposite ofis. So, you can useis not to determine if two namesdon’t refer to the same object:

>>>x=1001>>>y=1001>>>xisnotyTrue>>>a="Hello, Pythonista!">>>b=a>>>aisnotbFalse

In the first example, becausex andy point to different objects in your computer’s memory, theis not operator returnsTrue. In the second example, becausea andb are references to the same object, theis not operator returnsFalse.

Again, theis not operator highlights Python’s readability goals. In general, both identity operators allow you to write checks that read as plain English.

Membership Operators and Expressions in Python

Sometimes you need to determine whether a value is present in a container data type, such as a list, tuple, or set. In other words, you may need to check if a given valueis oris not amember of a collection of values. Python calls this kind of check amembership test.

Membership tests are quite common and useful in programming. As with many other common operations, Python has dedicated operators for membership tests. The table below lists themembership operators in Python:

As usual, Python favors readability by using English words as operators instead of potentially confusing symbols or combinations of symbols.

The Pythonin andnot in operators are binary. This means that you can create membership expressions by connecting two operands with either operator. However, the operands in a membership expression have particular characteristics:

• Left operand: The value that you want to look for in a collection of values
• Right operand: The collection of values where the target value may be found

To better understand thein operator, below you have two demonstrative examples consisting of determining whether a value is in a list:

>>>5in[2,3,5,9,7]True>>>8in[2,3,5,9,7]False

The first expression returnsTrue because5 is in the list of numbers. The second expression returnsFalse because8 isn’t in the list.

Thenot in membership operator runs the opposite test as thein operator. It allows you to check whether an integer valueis not in a collection of values:

>>>5notin[2,3,5,9,7]False>>>8notin[2,3,5,9,7]True

In the first example, you getFalse because5 is in the target list. In the second example, you getTrue because8 isn’t in the list of values. This may sound like a tongue twister because of the negative logic. To avoid confusion, remember that you’re trying to determine if the valueis not part of a given collection of values.

Concatenation and Repetition Operators and Expressions

There are two operators in Python that acquire a slightly different meaning when you use them with sequence data types, such as lists, tuples, and strings. With these types of operands, the+ operator defines aconcatenation operator, and the* operator represents therepetition operator:

Both operators are binary. The concatenation operator takes two sequences as operands and returns a new sequence of the same type. The repetition operator takes a sequence and an integer number as operands. Like in regular multiplication, the order of the operands doesn’t alter the repetition’s result.

Here are some examples of how the concatenation operator works in practice:

>>>"Hello, "+"World!"'Hello, World!'>>>("A","B","C")+("D","E","F")('A', 'B', 'C', 'D', 'E', 'F')>>>[0,1,2,3]+[4,5,6][0, 1, 2, 3, 4, 5, 6]

In the first example, you use the concatenation operator (+) to join two strings together. The operator returns a completely new string object that combines the two original strings.

In the second example, you concatenate two tuples of letters together. Again, the operator returns a new tuple object containing all the items from the original operands. In the final example, you do something similar but this time with two lists.

When it comes to the repetition operator, the idea is to repeat the content of a given sequence a certain number of times. Here are a few examples:

>>>"Hello"*3'HelloHelloHello'>>>3*"World!"'World!World!World!'>>>("A","B","C")*3('A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C')>>>3*[1,2,3][1, 2, 3, 1, 2, 3, 1, 2, 3]

In the first example, you use the repetition operator (*) to repeat the"Hello" string three times. In the second example, you change the order of the operands by placing the integer number on the left and the target string on the right. This example shows that the order of the operands doesn’t affect the result.

The next examples use the repetition operators with a tuple and a list, respectively. In both cases, you get a new object of the same type containing the items in the original sequence repeated three times.

The Walrus Operator and Assignment Expressions

Regular assignment statements with the= operator don’t have a return value, as you already learned. Instead, the assignment operator creates or updates variables. Because of this, the operator can’t be part of an expression.

SincePython 3.8, you have access to a new operator that allows for a new type of assignment. This new assignment is calledassignment expression ornamed expression. The new operator is called thewalrus operator, and it’s the combination of a colon and an equal sign (:=).

Unlike regular assignments, assignment expressions do have a return value, which is why they’reexpressions. So, the operator accomplishes two tasks:

1. Returns the expression’s result
2. Assigns the result to a variable

The walrus operator is also a binary operator. Its left-hand operand must be a variable name, and its right-hand operand can be any Python expression. The operator will evaluate the expression, assign its value to the target variable, and return the value.

The general syntax of an assignment expression is as follows:

(variable:=expression)

This expression looks like a regular assignment. However, instead of using the assignment operator (=), it uses the walrus operator (:=). For the expression to work correctly, the enclosing parentheses are required in most use cases. However, in certain situations, you won’t need them. Either way, they won’t hurt you, so it’s safe to use them.

Assignment expressions come in handy when you want to reuse the result of an expression or part of an expression without using a dedicated assignment to grab this value beforehand. It’s particularly useful in the context of a conditional statement. To illustrate, the example below shows a toy function that checks the length of a string object:

>>>defvalidate_length(string):...if(n:=len(string))<8:...print(f"Length{n} is too short, needs at least 8")...else:...print(f"Length{n} is okay!")...>>>validate_length("Pythonista")Length 10 is okay!>>>validate_length("Python")Length 6 is too short, needs at least 8

In this example, you use a conditional statement to check whether the input string has fewer than8 characters.

The assignment expression,(n := len(string)), computes the string length and assigns it ton. Then it returns the value that results from callinglen(), which finally gets compared with8. This way, you guarantee that you have a reference to the string length to use in further operations.

Bitwise Operators and Expressions in Python

Bitwise operators treat operands as sequences ofbinary digits and operate on them bit by bit. Currently, Python supports the following bitwise operators:

As you can see in this table, most bitwise operators are binary, which means that they expect two operands. The bitwise NOT operator (~) is the only unary operator because it expects a single operand, which should always appear at the right side of the expression.

You can use Python’s bitwise operators to manipulate your data at its most granular level, the bits. These operators are commonly useful when you want to write low-level algorithms, such as compression, encryption, and others.

Here are some examples that illustrate how some of the bitwise operators work in practice:

>>># Bitwise AND>>>#   0b1100    12>>># & 0b1010    10>>># -------->>># = 0b1000     8>>>bin(0b1100&0b1010)'0b1000'>>>12&108>>># Bitwise OR>>>#   0b1100    12>>># | 0b1010    10>>># -------->>># = 0b1110    14>>>bin(0b1100|0b1010)'0b1110'>>>12|1014

In the first example, you use the bitwise AND operator. The commented lines begin with# and provide a visual representation of what happens at the bit level. Note how each bit in the result is the logical AND of the bits in the corresponding position of the operands.

The second example shows how the bitwise OR operator works. In this case, the resulting bits are the logical OR test of the corresponding bits in the operands.

In all the examples, you’ve used the built-inbin() function to display the result as a binary object. If you don’t wrap the expression in a call tobin(), then you’ll get the integer representation of the output.

Operator Precedence in Python

Up to this point, you’ve coded sample expressions that mostly use one or two different types of operators. However, what if you need to create compound expressions that use several different types of operators, such as comparison, arithmetic, Boolean, and others? How does Python decide which operation runs first?

Consider the following math expression:

>>>20+4*1060

There might be ambiguity in this expression. Should Python perform the addition20 + 4 first and then multiply the result by10? Should Python run the multiplication4 * 10 first, and the addition second?

Because the result is60, you can conclude that Python has chosen the latter approach. If it had chosen the former, then the result would be240. This follows a standard algebraic rule that you’ll find in virtually all programming languages.

All operators that Python supports have aprecedence compared to other operators. This precedence defines the order in which Python runs the operators in a compound expression.

In an expression, Python runs the operators of highest precedence first. After obtaining those results, Python runs the operators of the next highest precedence. This process continues until the expression is fully evaluated. Any operators of equal precedence are performed in left-to-right order.

Here’s the order of precedence of the Python operators that you’ve seen so far, from highest to lowest:

Operators at the top of the table have the highest precedence, and those at the bottom of the table have the lowest precedence. Any operators in the same row of the table have equal precedence.

Getting back to your initial example, Python runs the multiplication because the multiplication operator has a higher precedence than the addition one.

Here’s another illustrative example:

>>>2*3**4*5810

In the example above, Python first raises3 to the power of4, which equals81. Then, it carries out the multiplications in order from left to right:2 * 81 = 162 and162 * 5 = 810.

You can override the default operator precedence using parentheses to group terms as you do in math. The subexpressions in parentheses will run before expressions that aren’t in parentheses.

Here are some examples that show how a pair of parentheses can affect the result of an expression:

>>>(20+4)*10240>>>2*3**(4*5)6973568802

In the first example, Python computes the expression20 + 4 first because it’s wrapped in parentheses. Then Python multiplies the result by10, and the expression returns240. This result is completely different from what you got at the beginning of this section.

In the second example, Python evaluates4 * 5 first. Then it raises3 to the power of the resulting value. Finally, Python multiplies the result by2, returning6973568802.

There’s nothing wrong with making liberal use of parentheses, even when they aren’t necessary to change the order of evaluation. Sometimes it’s a good practice to use parentheses because they can improve your code’s readability and relieve the reader from having to recall operator precedence from memory.

Consider the following example:

(a<10)and(b>30)

Here the parentheses are unnecessary, as the comparison operators have higher precedence thanand. However, some might find the parenthesized version clearer than the version without parentheses:

a<10andb>30

On the other hand, some developers might prefer this latter version of the expression. It’s a matter of personal preference. The point is that you can always use parentheses if you feel that they make your code more readable, even if they aren’t necessary to change the order of evaluation.

Augmented Assignment Operators and Expressions

So far, you’ve learned that a single equal sign (=) represents the assignment operator and allows you to assign a value to a variable. Having a right-hand operand that contains other variables is perfectly valid, as you’ve also learned. In particular, the expression to the right of the assignment operator can include the same variable that’s on the left of the operand.

That last sentence may sound confusing, so here’s an example that clarifies the point:

>>>total=10>>>total=total+5>>>total15

In this example,total is anaccumulator variable that you use toaccumulate successive values. You should read this example astotal is equal to the current value oftotal plus5. This expression effectively increases the value oftotal, which is now15.

Note that this type of assignment only makes sense if the variable in question already has a value. If you try the assignment with an undefined variable, then you get an error:

>>>count=count+1Traceback (most recent call last):...NameError:name 'count' is not defined. Did you mean: 'round'?

In this example, thecount variable isn’t defined before the assignment, so it doesn’t have a current value. In consequence, Python raises aNameError exception to let you know about the issue.

This type of assignment helps you create accumulators and counter variables, for example. Therefore, it’s quite a common task in programming. As in many similar cases, Python offers a more convenient solution. It supports a shorthand syntax calledaugmented assignment:

>>>total=10>>>total+=5>>>total15

In the highlighted line, you use the augmented addition operator (+=). With this operator, you create an assignment that’s fully equivalent tototal = total + 5.

Python supports many augmented assignment operators. In general, the syntax for this type of assignment looks something like this:

variable$=expression

Note that the dollar sign ($) isn’t a valid Python operator. In this example, it’s a placeholder for a generic operator. The above statement works as follows:

1. Evaluateexpression to produce a value.
2. Run the operation defined by the operator that prefixes the assignment operator (=), using the current value ofvariable and the return value ofexpression as operands.
3. Assign the resulting value back tovariable.

The table below shows a summary of the augmented operators for arithmetic operations:

As you can conclude from this table, all the arithmetic operators have an augmented version in Python. You can use these augmented operators as a shortcut when creating accumulators, counters, and similar objects.

Did the augmented arithmetic operators look neat and useful to you? The good news is that there are more. You also have augmented bitwise operators in Python:

Finally, the concatenation and repetition operators have augmented variations too. These variations behave differently with mutable and immutable data types:

Note that the augmentedconcatenation operator works on two sequences, while the augmentedrepetition operator works on a sequence and an integer number.

Conclusion

Now you know whatoperators Python supports and how to use them. Operators are symbols, combinations of symbols, or keywords that you can use along with Python objects to build different types ofexpressions and perform computations in your code.

In this tutorial, you’ve learned:

• What Python’sarithmetic operators are and how to use them inarithmetic expressions
• What Python’scomparison,Boolean,identity,membership operators are
• How to writeexpressions using comparison, Boolean, identity, and membership operators
• Whichbitwise operators Python supports and how to use them
• How to combine and repeat sequences using theconcatenation andrepetition operators
• What theaugmented assignment operators are and how they work

In other words, you’ve covered an awful lot of ground! If you’d like a handy cheat sheet that can jog your memory on all that you’ve learned, then click the link below:

With all this knowledge about operators, you’re better prepared as a Python developer. You’ll be able to write better and more robust expressions in your code.

Take the Quiz: Test your knowledge with our interactive “Python Operators and Expressions” quiz. You’ll receive a score upon completion to help you track your learning progress:

---

Interactive Quiz

Python Operators and Expressions

Test your understanding of Python operators and expressions.

Frequently Asked Questions

Now that you have some experience with Python operators, you can use the questions and answers below to check your understanding and recap what you’ve learned.

These FAQs are related to the most important concepts you’ve covered in this tutorial. Click theShow/Hide toggle beside each question to reveal the answer.