Getting the Most from Keywords in Python

Be the Exception: raise, try, except, finally, assert

Python's exception system is a robust mechanism that helps manage all types of errors that your code might encounter. It ensures that you have full control over everything you write, providing stability, and reliability, and it's a significant time saver. Here's an example:

file = None
try:
    file = open('example.txt')
    content = file.read()
    print(content)  # e.g. Hello, world!
except FileNotFoundError as fnf_error:
    # No file found: [Errno 2] No such file or directory: 'example.txt'
    print(f'No file found: {fnf_error}')
except Exception as e:
    print(f'An error occurred: {e}')
else:
    print('File read successfully!')
finally:
    if file is not None:
        file.close()
        print('File closed.')
    print('Always executed.')

‍

In this example, we're using the exception-handling mechanism to its fullest. The try block attempts to open a file named 'example.txt'. If the file doesn't exist, it will throw an exception. The FileNotFoundError is caught in the except statement. Note that you are given a handy alias fnf_error for the exception. You can extract information from the fnf_error object and take control of it. In this case, we're just printing the object. If any other exception occurs, we will catch it with the except Exception as e block. Here, we also have full control over the exception. The else block is something that you might not expect to see. The else block is executed if no exceptions occur. Finally, the finally block! This block is always executed. If you have some unfinished business, or if you want to clean up your code, feel free to use the finally block.

‍

Note that else and finally blocks are optional; you can use both of them, only one of them, or none at all.

Another possibility is to use try/finally pair. Let's look at an example that demonstrates that the finally block always executes:

def foo():
    try:
        return True
    finally:
        return False
print(foo())

‍

What do you think is the result of the function? At first glance, you might think that it prints True or even None. That's a reasonable guess. However, remember that finally always executes! And it executes return False, so it prints False. It might look counterintuitive at first, but you need to understand that, unless there are some extraordinary circumstances, the finally block is always the last to execute!

‍

Exception handling has a newer syntax that allows you to handle multiple exceptions in groups. Let's look at an example from the documentation:

def f():
    raise ExceptionGroup(
        "group1",
        [
            OSError(1),
            SystemError(2),
            ExceptionGroup(
                "group2",
                [
                    OSError(3),
                    RecursionError(4)
                ]
            )
        ]
    )

try:
    f()
except OSError as e:
    print("There were OSErrors")
except SystemError as e:
    print("There were SystemErrors")

This is the output:

+ Exception Group Traceback (most recent call last):
|   File "main.py", line 18, in <module>
|     f()
|   File "main.py", line 2, in f
|     raise ExceptionGroup(
| ExceptionGroup: group1 (3 sub-exceptions)
+-+---------------- 1 ----------------
| OSError: 1
+---------------- 2 ----------------
| SystemError: 2
+---------------- 3 ----------------
| ExceptionGroup: group2 (2 sub-exceptions)
+-+---------------- 1 ----------------
   | OSError: 3
   +---------------- 2 ----------------
   | RecursionError: 4
   +------------------------------------

You can refer to the official documentation for a detailed explanation; this example serves as a syntax demonstration with the try/except keywords.

‍

Pro tip: try/except is a time saver. At first, it feels wrong when you do it, but handling some data validation inside of the try/except is a common Python practice and an idiom. Don't be shy, save your time with a try/except block.

‍

Another keyword that fits perfectly in this subsection is the raise statement. You might already guessed what it does - it raises exceptions! Whenever you encounter a situation where you feel it's appropriate to raise an exception, you should do so. Here's a simple example:

x = -1
if x < 0:
    raise Exception('Negative numbers are a lie!')

‍

In this case, you're implicitly raising the Exception. You can handle it right away, but is there a point in doing so?

As you can see, the syntax for this is simple. First, you use raise, then you specify the class of the Exception, and finally, you specify the message to the user. You can also use the single raise statement. It's used to re-raise the previous exception. If no exception occurs, you will get RuntimeError: No active exception to re-raise.

‍

Last but not least is the assert statement:

assert 0 == 1, 'Something is funny with this math'  
# AssertionError: Something is funny with this math

‍

The assert statement allows you to check if conditions evaluate to True at some crucial point in your code. assert statements are useful for debugging, and you should never use them in production code.

The syntax for that is as follows: first, the assert keyword, then the boolean expression. If the expression evaluates to False, it throws an AssertionError. The useful message is optional, and you can avoid it if you know what you're doing. Note, that as this is a boolean, you can mix any complex chain as you desire.

Create and control the loop: for, while, continue, break

The for loop is a crucial building block of the Python language. With a for loop, you can iterate over any sequence (lists, tuples, strings, ranges) or anything iterable.

Many languages have a for loop. The classic example of the for loop is something like this:

for i in range(len(arr)):
    print(f'Element #{i+1}: {arr[i]}')

‍

However, Python is not Python without cool syntactic sugar. As you remember, you can iterate over any iterable, so why not just iterate over a list?

for element in arr:
    print(element)

‍

If you want to keep counting, you can always enhance it with an enumerate function.

for count, element in enumerate(arr, start=1):
    print(f'Element #{count}: {element}')

‍

You can always break out of the loop with a break statement. Let's say your mission is to find an element in an array, and you don't want to waste CPU power on iterating the whole array if you've already found the magic element.

for i in range(10**255):
    print(i)
    if i == 5:
        break

‍

In this case, you will see numbers from 0 to 5 (inclusive) printed on your screen.

If you want, you can add an else clause! What? With the loop? You might ask. Yes! With a loop! The else clause is executed only if the whole iterable is exhausted. For example:

for i in range(10):
    print(i)
else:
    print('Hello')

‍

Since we went through all elements of an iterable, the message 'Hello' will be printed at the end. However, if you break and quit the loop before it's exhausted, no message will be printed.

The continue statement is used in the loop if you want to skip some specific position or element or for any other reason you might have in mind.

for i in range(10):
    if i == 5:
        continue
    print(i)

‍

In this case, the number 5 is not going to be printed.

The while loop is similar to the for loop, with the exception that it stops if the provided boolean expression is not true.

while (msg := input()) != 'stop':
    if msg == 'magic':
        print(f'With {msg!r}, you can take a break.')
        break
    print(f'I wrote {msg!r}, but I really need to stop.')
else:
    print('I stopped')

‍

Here's the output:

>>> hello, world
I wrote 'hello, world', but I really need to stop.
>>> 123
I wrote '123', but I really need to stop.
>>> magic
With 'magic', you can take a break.

‍

The else statement works similarly with while loops. The else clause is triggered if the loop exits because the boolean expression is False.

The pass statement

The pass statement is one of the simplest keywords; it acts as a no-op and can be added to any block of code. You can use it as a placeholder if you want to finish something later.

def bar():
    pass

‍

Note: The pass statement is a no-op operation. It doesn't act as break, continue, or return. After the interpreter reads it, it continues to read the next line, as if nothing happened. Indeed, nothing happened!

Working with functions: def, return, yield, lambda

Let's explore the world of functions a bit closer. We've seen some previous examples that used some of these words, for example, def. The def keyword is the syntax to define a function in your code. It serves this purpose and nothing else. To define a function, just write def followed by the name of the function, parentheses (zero or more arguments), and a colon. Don’t forget to pay attention to the indentation inside of the function body.

You might want to use pass if you don't know what the function is for and would like to come back to it later.

def foobar():
    pass

‍

The function is quite useless at the moment, so let's make another one that adds two numbers.

def add(x, y):
    return x + y
    print('You will never see me!')

‍

As you can see, we use the return statement to return the result of our mathematical expression.

In this example, return is the last statement that is processed in the function; nothing after that matters.

def foo(bar):
    if bar < 0:
        return 'negative'
    elif bar == 0:
        return 'zero'
    else:
        return 'positive'

‍

In such an example, the third return is unnecessary, since else is executed no matter what.

It may make a lot of sense to define your function like this instead:

def foo(bar):
    if bar < 0:
        return 'negative'
    elif bar == 0:
        return 'zero'
    return 'positive'

‍

Another way to return a value from the function is to use yield (yield from).

def foo(msg):
    yield from msg

text = foo('Hello there')
print(next(text))  # H
print(next(text))  # e
print(next(text))  # l
print(next(text))  # l
print(next(text))  # o

‍

Yield creates a generator from the function that makes it possible to retrieve a single value at a time.

The last thing about functions is that you can use the lambda keyword to create anonymous functions (the possibility to bind it to a name still exists tho).

text = (lambda msg: (yield from msg))('Hello there')

If we repeat print statements from the previous example, we will get the same result. Of course, this is not a definitive guide on functions, so if you want to learn more about it please refer to documentation or some external resources.

The class keyword

As you might have guessed, the keyword class is used to create your custom objects and enhance your code with an object-oriented style.

class MyClass:
    pass

‍

Here you go, using the keyword class and a name, we created a custom class for creating our objects. Unfortunately, this class does nothing. In some circumstances, you might need it, but let's enhance it just for now:

class MyClass:
    wow = 'Hello, world!'
    
    def greet(self):
        return 'Hello, world!'

mc = MyClass()
print(mc.wow)
print(mc.greet())

‍

As you can see, a single keyword opens the door to a whole new paradigm. To learn more about classes, you might refer to this documentation.

The world of asynchronous programming: async/await

These keywords are used for handling asynchronous programming, which is the concurrent execution of different subroutines. It may lead to increased performance, more efficient use of resources, etc. Here is a simple example:

import asyncio

async def main():
    print('hello')
    await asyncio.sleep(1)
    print('world')

asyncio.run(main())

‍

The async keyword is used to declare a function as a coroutine (you can learn more about it here), which makes it a special kind of function that you can't simply invoke. In this example, I use asyncio.run to invoke the function.

The await keyword is used inside an async function and waits until the completion of any awaitable object. In this example, we use the awaitable sleep method from asyncio and pause the function execution for 1 second. After that, the function continues its execution.

Choose your scope: global, nonlocal

These two keywords are used as helpers to decide which names to refer to in the current scope. Let's look at a simple example:

‍

x = 'global'

def outer():
    x = 'nonlocal'
    
    def inner():
        nonlocal x
        x = 'changed with nonlocal'
    
    inner()
    print(f'nonlocal: {x}')

outer()
print(f'global: {x}')
# nonlocal: changed with nonlocal
# global: global

‍

In this example, we have three variables named x, inside the inner function, we use nonlocal x to set the scope to a non-global scope. That's any scope 'above' the local and not global is treated as nonlocal. Hence the output, the global x is the same, and the non-global x has changed.

If you change nonlocal x to global x, then the opposite will happen; the only x that will be changed is global, and the non-global x (inside the outer function) will stay the same.

The mighty four: del, in, is, with

Ok, last but not least, the mighty four keywords that I couldn't group with any other. 😅

The del statement is used to delete objects. For example:

x = True
print(x)  # True
del x
print(x)  # NameError: name 'x' is not defined

‍

As you can see, it removes the whole variable, not just nullifies the value.

x = [1, 2, 3, 4, 5]
del x[2]
print(x)  # [1, 2, 4, 5]

‍

In this example, we remove the value at the 2nd index of the array x.

Probably one of the most useful examples is removing a key from a dictionary.

d = {'a': 1, 'b': 2, 'c': 3}
del d['b']
print(d)  # {'a': 1, 'c': 3}

‍

The in operator checks if the target value is in some collection. For example:

word = 'hello, world'
print('Is letter a in the string:', 'a' in word)
print('Is letter a not in the string:', 'a' not in word)

set_ = {1, 2, 3, 4, 5}
print('Is 3 in the set:', 3 in set_)

d = {'a': 1, 'b': 2, 'c': 3}
print('Is x in the dictionary:', 'x' in d)

‍

Output:

Is letter a in the string: False
Is letter a not in the string: True
Is 3 in the set: True
Is x in the dictionary: False

‍

As you can see, you can easily test for membership without writing a custom algorithm for that.

Quick quiz, what do you think? Is it a fast operation to check if some number is in the range or not, and why?

Test your intuition with this simple snippet

print(10 ** 555 // 2 in range(10 ** 555))

‍

The is operator tests for the objects' identity. It's equivalent to id(obj1) == id(obj2).

The preferred usage for is is with the None constant, as shown above in the part about None.

If you want to compare two values, use == instead of is.

a = [1]
b = [1]
print(a is b)  # False

print(None is None)  # True

a = [1, 2, 3]
b = a
print(a is b)  # True

‍

One may say that the with statement creates a context manager. That is, it delegates some functionality to a manager. It ensures that resources are acquired safely before entering the block and released reliably afterward, even if exceptions occur. One of the classic examples is reading a file. The old way is something like this:

file = open('example.txt')
content = file.read()
print(content)
file.close()

‍

In this example, we explicitly closed the file. However, with a context manager, files are closed automatically. It's also more readable and pleasant.

with open('example.txt') as file:
    print(file.read())

‍

To be able to use this with your custom classes, you need to define __enter__() and __exit__() magic methods for your class!

‍

That's it for the main keywords. Next on the menu are soft keywords.

‍

Soft keywords

In Python, soft keywords are something even more special. If you reassign them, they don't throw an exception as with regular keywords. Moreover, in daily life, most Python programmers use one of these as a name for their variable. So, let's begin.

The soft keyword that is often used as a throwaway variable is _. If you don't want to use some variable, you set the name as _.

for _ in range(5):
    print('Hello. Are you there?')

What makes it a soft keyword? The answer to this is context. In Python 3.10, Python introduced structural pattern matching, where three soft keywords are used. Let's take an example and try to explain what each one is doing.

The match statement

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

Here we see three of the keywords in use. It works similarly to Rust's pattern matching. The match statement operates on the matching subject (in this case it is status), trying to match it with one of the given cases. Based on the provided input, it should match with the correct block. If none are matched, the wildcard (_) block is executed. The whole topic is much more interesting and contains a handful of tools for your coding journey, so I recommend getting familiar with it.

Type statement

The last one, probably not that well-known at the moment, is the type statement. Attention: not the function, the statement. Here is an example:

type Point = tuple[float, float]
type ListOrSet[T] = list[T] | set[T]

‍

This is simply type aliases for more complex structures. It allows you to define a name before it appears in code. As you can see, it supports generic types as well. Remember value: int = 2? Well, now you can do point: Point before you even define this class!

If you want to learn more about type hints please refer to this pep.

‍

Wrap up

I hope you've gotten a hang of keywords and soft keywords. I tried to elaborate more on the ones that people make more mistakes with, and provided a shorter description for simpler or newer keywords. As no single article is complete (and no one wants to read 37 articles in one 🙃), I recommend you go deeper with a keyword that you're most interested in and learn more about it. Have you applied type aliases in your code yet? What about the match statement? It looks very promising.

Good luck on your coding journey and using new keywords in your code!