Expression in Python

Arithmetic Expressions

Arithmetic expressions involve performing mathematical calculations using operators such as addition (+), subtraction (-), multiplication (*), division (/), modulo (%), exponentiation (**), & floor division (//).

Examples

# Addition

result = 5 + 3  # result = 8

# Subtraction

result = 10 - 4  # result = 6

# Multiplication

result = 2 * 6  # result = 12

# Division

result = 15 / 3  # result = 5.0

# Modulo

result = 17 % 5  # result = 2

# Exponentiation

result = 2 ** 3  # result = 8

# Floor division

result = 15 // 2  # result = 7

In these examples, the arithmetic expressions combine numeric values using different operators to perform calculations. The result of each expression is stored in the variable result.

Note: Arithmetic expressions follow the standard order of operations (PEMDAS - Parentheses, Exponentiation, Multiplication/Division, Addition/Subtraction) to determine the evaluation order.

Integral Expressions

Integral expressions involve integer values and produce integer results. They can include arithmetic operations such as addition, subtraction, multiplication, and floor division.

Examples

# Addition

result = 5 + 3  # result = 8

# Subtraction

result = 10 - 4  # result = 6

# Multiplication

result = 2 * 6  # result = 12

# Floor division

result = 15 // 2  # result = 7

In these examples, the integral expressions perform calculations using integer values. The results of these expressions are also integers.

Note: It's important to note that the result will be a floating-point number when performing division with two integers using the / operator. To obtain an integer result from division, you can use the floor division operator //, which discards the decimal part and returns the largest integer less than or equal to the result.

Floating Expressions

Floating expressions involve floating-point values and produce floating-point results. They can include arithmetic operations such as addition, subtraction, multiplication, and division.

Examples

# Addition

result = 3.14 + 2.5  # result = 5.64

# Subtraction

result = 10.7 - 4.2  # result = 6.5

# Multiplication

result = 2.3 * 6.8  # result = 15.64

# Division

result = 15.0 / 3.0  # result = 5.0

In these examples, the floating expressions perform calculations using floating-point values. The results of these expressions are also floating-point numbers.

When performing arithmetic operations with a combination of integer and floating-point values, Python automatically promotes the integer values to floating-point values to ensure precision in the calculations.

Note: It's important to be cautious of the potential precision limitations when working with floating-point numbers due to their representation in computer memory.

Relational Expressions

Relational expressions compare two values and return a boolean result (True or False) based on the comparison. Python provides several relational operators: equal to (==), not equal to (!=), greater than (>), less than (<), greater than or equal to (>=), and less than or equal to (<=).

Examples

x = 5
y = 3

# Equal to

result = x == y  # result = False

# Not equal to

result = x != y  # result = True

# Greater than

result = x > y  # result = True

# Less than

result = x < y  # result = False

# Greater than or equal to

result = x >= y  # result = True

# Less than or equal to

result = x <= y  # result = False

In these examples, the relational expressions compare x and y values using different relational operators. The results of these expressions are boolean values indicating whether the comparisons are true or false.

Note: Relational expressions are commonly used in conditional statements and loops to make decisions based on the comparison of values.

Logical Expressions

Logical expressions combine boolean values or relational expressions using logical operators: and, or, & not. They allow you to create more complex conditions by evaluating multiple expressions together.

Examples

x = 5
y = 3

# Logical AND

result = (x > 0) and (y < 10)  # result = True
result = (x < 0) and (y < 10)  # result = False

# Logical OR

result = (x > 0) or (y > 10)  # result = True
result = (x < 0) or (y > 10)  # result = False

# Logical NOT

result = not (x > 0)  # result = False
result = not (x < 0)  # result = True

In these examples, the logical expressions combine relational expressions using logical operators:

1. The and operator returns True if both operands are True, otherwise it returns False.
    
2. The or operator returns True if at least one of the operands is True, otherwise it returns False.
    
3. The not operator negates the boolean value, returning True if the operand is False, & vice versa.
    

Note: Logical expressions are often used in combination with relational expressions to create more sophisticated conditions for decision-making & control flow in Python programs.

Bitwise Expressions

Bitwise expressions perform operations on the binary representations of integer values. Python provides several bitwise operators: bitwise AND (&), bitwise OR (|), bitwise XOR (^), bitwise NOT (~), left shift (<<), & right shift (>>).

Examples

x = 10  # Binary: 1010
y = 6   # Binary: 0110

# Bitwise AND

result = x & y  # result = 2 (Binary: 0010)

# Bitwise OR

result = x | y  # result = 14 (Binary: 1110)

# Bitwise XOR

result = x ^ y  # result = 12 (Binary: 1100)

# Bitwise NOT

result = ~x  # result = -11 (Binary: -1011)

# Left shift

result = x << 2  # result = 40 (Binary: 101000)

# Right shift

result = x >> 2  # result = 2 (Binary: 0010)

In these examples, the bitwise expressions perform operations on the binary representations of the integer values x & y:

1. The bitwise AND operator & returns a 1 in each bit position for which the corresponding bits of both operands are 1.
    
2. The bitwise OR operator | returns a 1 in each bit position for which the corresponding bits of either or both operands are 1.
    
3. The bitwise XOR operator ^ returns a 1 in each bit position for which the corresponding bits of either but not both operands are 1.
    
4. The bitwise NOT operator ~ inverts all the bits, effectively changing each 1 to a 0 & each 0 to a 1.
    
5. The left shift operator << shifts the bits of the first operand left by the number of positions specified by the second operand, filling the vacated bits with 0s.
    
6. The right shift operator >> shifts the bits of the first operand right by the number of positions specified by the second operand, discarding the shifted bits.
    

Note: Bitwise expressions are commonly used for low-level operations, bit manipulation, & certain optimization techniques.

Combinational Expressions

Combinational expressions involve combining multiple expressions using parentheses to control the order of evaluation. By using parentheses, you can override the default operator precedence and specify the desired evaluation order.

Examples

x = 5
y = 3
z = 2

# Combinational expression with arithmetic operators

result = (x + y) * z  # result = 16

# Combinational expression with relational and logical operators

result = (x > y) and (y < z)  # result = False

# Combinational expression with bitwise operators

result = (x << 1) | (y >> 1)  # result = 11 (Binary: 1011)

In these examples, the combinational expressions use parentheses to group subexpressions and control the evaluation order:

1. In the first example, the subexpression (x + y) is evaluated first, and then the result is multiplied by z.
    
2. In the second example, the relational expressions (x > y) and (y < z) are evaluated separately, and then the logical AND operator and is applied to the results.
    
3. In the third example, the bitwise left shift (x << 1) and bitwise right shift (y >> 1) are evaluated separately, and then the bitwise OR operator | is applied to the results.
    

Note: Combinational expressions allow you to combine different types of expressions and create more complex calculations while maintaining control over the evaluation order.

Multiple Operators in Expression (Operator Precedence):

When an expression contains multiple operators, the order in which the operations are performed is determined by the operator precedence rules. Python follows a specific order of precedence to evaluate expressions.

The general order of precedence for operators in Python, from highest to lowest, is:

1. Parentheses: Expressions inside parentheses are evaluated first.
    
2. Exponentiation: The exponentiation operator ** has the highest precedence among arithmetic operators.
    
3. Unary operators: Unary operators, such as unary plus (+), unary minus (-), and bitwise NOT (~), have higher precedence than binary operators.
    
4. Multiplication, Division, Modulo, Floor Division: The *, /, %, and // operators have equal precedence and are evaluated from left to right.
    
5. Addition and Subtraction: The + and - operators have equal precedence and are evaluated from left to right.
    
6. Bitwise Shift: The left shift << and right shift >> operators have equal precedence and are evaluated from left to right.
    
7. Bitwise AND: The bitwise AND & operator.
    
8. Bitwise XOR: The bitwise XOR ^ operator.
    
9. Bitwise OR: The bitwise OR | operator.
    
10. Comparison operators: The comparison operators (==, !=, <, >, <=, >=) have equal precedence and are evaluated from left to right.
     
11. Logical NOT: The logical NOT not operator.
     
12. Logical AND: The logical AND and operator.
     
13. Logical OR: The logical OR or operator.

Examples

result = 2 + 3 * 4  # result = 14
result = (2 + 3) * 4  # result = 20
result = 2 ** 3 + 1  # result = 9
result = 5 > 3 and 2 < 4  # result = True

In these examples, the expressions are evaluated based on the operator precedence rules:

1. In the first example, the multiplication 3 * 4 is performed first, and then the result is added to 2.
    
2. In the second example, the addition 2 + 3 is performed first due to the parentheses, and then the result is multiplied by 4.
    
3. In the third example, the exponentiation 2 ** 3 is evaluated first, and then the result is added to 1.
    
4. In the fourth example, the comparison operators > and < are evaluated first, and then the logical AND and operator are applied to the results.
    

Note: Knowledge of operator precedence is crucial for writing correct and predictable expressions in Python. If you ever face any confusion, you can always use parentheses to explicitly specify the desired evaluation order.

Frequently Asked Questions

What happens if I don't follow operator precedence in my Python code?

Not adhering to operator precedence can lead to unexpected results, as Python will default to its built-in rules for the order of operations. This could potentially cause logical errors in your code.

Can I use parentheses to override default operator precedence in Python?

Yes, you can use parentheses to change the order in which operations are performed, allowing you to explicitly define how expressions should be evaluated, regardless of the default precedence rules.

Is it possible to mix different types of expressions in a single line of code?

Absolutely. Python allows you to combine various types of expressions, such as arithmetic, logical, and relational, in a single line. This flexibility helps in creating concise and powerful code.

Conclusion 

In this article, we explored different types of expressions in Python, including constant, arithmetic, relational, logical, bitwise, and more. We also discussed operator precedence with examples to show how expressions are evaluated. Mastering expressions is fundamental for writing efficient Python code and performing accurate calculations and comparisons. 

Recommended Readings:

• Python Regular Expression
• Python Operator Precedence
• Complex() Function in Python
• eval() Function in Python
• Character Class Operations in Python