New in Python 3.8.0

1. New Features in Python 3.8.0

Python 3.8.0 introduces several new features and enhancements that make the language more powerful and efficient. These features aim to improve the developer experience and enable easier and more expressive code. In this article, we will explore some of the major updates in Python 3.8.0.

1.1 Assignment Expressions (The walrus operator)

One of the most anticipated features in Python 3.8.0 is the introduction of the assignment expressions, also known as the "walrus operator". This feature allows you to assign a value to a variable within an expression. Let's take a look at an example:

# Old way
while True:
    line = input()
    if line == 'quit':
        break
    else:
        print(line)

In the above code, we need to call the `input()` function twice - once to check if the line is 'quit' and then again to print the line. This can be quite repetitive. With the new assignment expressions, we can simplify the code:

# New way
while (line := input()) != 'quit':
    print(line)

Here, the expression `(line := input())` assigns the value of `input()` to `line` and also returns that value, allowing us to evaluate it in the `while` loop condition. This makes the code more concise and readable.

1.2 Positional-only Parameters

Python 3.8.0 introduces support for positional-only parameters in function definitions. This allows developers to specify that certain parameters can only be passed positionally and not by keyword. Let's see an example to understand this concept:

def calculate(x, y, /, operation='add'):
    if operation == 'add':
        return x + y
    elif operation == 'subtract':
        return x - y
    else:
        raise ValueError('Unsupported operation')
print(calculate(5, 3))  # Positional arguments
print(calculate(x=5, y=3))  # Raises a TypeError

In the above code, the slash `/` in the function definition indicates that the parameters before it (`x` and `y`) are positional-only. This means that they can only be passed through their position in the argument list, and not as keyword arguments. This helps prevent any accidental or incorrect use of keyword arguments.

1.3 f-strings support "=" for self-documenting expressions

Python 3.8.0 enhances f-strings by introducing the support for the `=` specifier in f-string expressions. This allows you to easily evaluate and display the result of an expression within an f-string. Let's see an example:

name = 'John'
age = 25
print(f'{name=}')  # Output: name='John'
print(f'{age=}')  # Output: age=25

In the above code, the `=` specifier within the f-string evaluates the expression `name` or `age` and includes the result in the string. This is particularly useful for debugging and self-documenting code.

2. Other Improvements

In addition to the major features mentioned above, Python 3.8.0 also includes several other improvements and optimizations. Some of them are:

2.1 Math module enhancements

Python 3.8.0 introduces several math-related enhancements, including the `math.prod()` function that calculates the product of a given iterable, and the `math.isqrt()` function that calculates the integer square root of a number.

2.2 Typing module improvements

The `typing` module in Python 3.8.0 has been improved with new features and enhancements. This module provides support for type hinting and annotations. Some notable improvements include the addition of `typing.final` and `typing.runtime_checkable` decorators, and the introduction of protocols (a new kind of structural typing).

2.3 Performance improvements

Python 3.8.0 includes several performance improvements, such as faster calls to functions marked as "hot" using the `__call__` method, faster attribute access using `__getattribute__`, and faster parsing of f-strings.

Conclusion

Python 3.8.0 introduces several exciting features and enhancements that make the language more powerful and efficient. The assignment expressions, positional-only parameters, and enhanced f-strings are just a few examples of the improvements that make the code more readable and expressive. Other enhancements, such as the math module improvements and typing module enhancements, further contribute to the overall improvement of Python. With Python 3.8.0, developers can expect a smoother and more efficient coding experience.