Python Keywords | All 39 Reserved & Soft Explained +Code Examples

0 min read

Python's simplicity and readability have made it a favorite among both novice and experienced programmers. Central to its clear syntax are keywords, i.e., reserved words that serve as the building blocks of Python code. These reserved words, such as if, for, and class, are integral to writing clear and efficient code. Understanding Python keywords is not just about memorizing a list; it's about grasping how they control the flow, logic, and functionality of your programs.​

In this article, we will discuss the 35 official Python keywords, their categories, uses, and more with examples, enabling you to write more readable, maintainable, and effective code.

What Are Keywords In Python?

Python has a set of reserved words known as keywords that are integral to its syntax and structure.

• These keywords cannot be used as identifiers (such as variable names, function names, or class names) because they have predefined meanings that are integral to the language's functionality. 
• Attempting to use a keyword as an identifier will result in a syntax error.​

Analogy: Think of Python keywords like traffic signs on a road. Just as traffic signs direct the flow of vehicles and inform drivers of rules and regulations, Python keywords guide the flow of a program and define its structure. Ignoring or misusing traffic signs can lead to accidents or confusion; similarly, misusing Python keywords can lead to errors or unintended behavior in your code.​

Example: Consider the if keyword, which is used to implement conditional statements in Python. It allows the program to make decisions based on certain conditions.​

age = 20
if age >= 18:
    print("You are eligible to vote.")
else:
    print("You are not eligible to vote.")

In this example:

• The keyword if marks the statement to check whether the condition (age >= 18) is true.​
• If true, it executes the indented block under it, printing "You are eligible to vote."​
• If false, it executes the code under else, printing "You are not eligible to vote."​

Here, if and else are keywords that control the flow of the program based on the condition provided.​

List Of Python Keywords

As of Python 3.10, there are 35 standard keywords and 4 soft keywords. Below is a table listing each keyword, its syntax, a brief description, and an example demonstrating its usage:​

Soft Keywords (Introduced In Python 3.10)

These soft keywords are reserved in specific contexts and can be used as identifiers elsewhere in the code.

Types/Categories Of Python Keywords

Python programming language’s 35 keywords can be grouped based on their functionalities, making it easier to comprehend their roles within the language. This categorization aids in understanding how these keywords contribute to Python's syntax and control structures.​

Below is a table that categorizes Python keywords, outlining their purposes, typical usage contexts, and the specific keywords within each category.​

Understanding these categories provides a structured approach to learning Python keywords, allowing for more efficient coding and better comprehension of Python's syntax and capabilities. In the next section, we will look at each of these categories in detail and explore how the keywords work with the help of code examples.

Control Flow Keywords In Python

Control flow is the backbone of any programming language, dictating the order in which individual statements, instructions, or function calls are executed or evaluated. In Python, control flow is managed through conditional statements, loops, and control statements that alter the execution path based on specific conditions. This mechanism allows developers to write dynamic and responsive programs that can make decisions, repeat tasks, and handle different scenarios effectively.

Python's control flow constructs are designed to be intuitive and readable, adhering to the language's philosophy of simplicity and clarity. By mastering these keywords, you can control the logic of your programs with precision and write code that is both efficient and easy to understand.​ The table below provides a list of the control flow keywords, followed by a code example.

Code Example:

            for number in range(1, 6):
    if number == 3:
        print("Three encountered, skipping iteration.")
        continue
    elif number == 5:
        print("Five encountered, breaking the loop.")
        break
    else:
        print(f"Processing number: {number}")
else:
    print("Loop completed without encountering a break.")
          

Zm9yIG51bWJlciBpbiByYW5nZSgxLCA2KToKICAgIGlmIG51bWJlciA9PSAzOgogICAgICAgIHByaW50KCJUaHJlZSBlbmNvdW50ZXJlZCwgc2tpcHBpbmcgaXRlcmF0aW9uLiIpCiAgICAgICAgY29udGludWUKICAgIGVsaWYgbnVtYmVyID09IDU6CiAgICAgICAgcHJpbnQoIkZpdmUgZW5jb3VudGVyZWQsIGJyZWFraW5nIHRoZSBsb29wLiIpCiAgICAgICAgYnJlYWsKICAgIGVsc2U6CiAgICAgICAgcHJpbnQoZiJQcm9jZXNzaW5nIG51bWJlcjoge251bWJlcn0iKQplbHNlOgogICAgcHJpbnQoIkxvb3AgY29tcGxldGVkIHdpdGhvdXQgZW5jb3VudGVyaW5nIGEgYnJlYWsuIik=

Output:

Processing number: 1
Processing number: 2
Three encountered, skipping iteration.
Processing number: 4
Five encountered, breaking the loop.

Code Explanation:

• Here, we begin by defining a for loop, using for keyword. The loop iterates over numbers 1 through 5.​
• Inside, we use if-elif-else statements to define different scenarios:
• When the number is 3, the continue statement skips the rest of the loop's body and proceeds to the next iteration.​
• When the number is 5, the break statement exits the loop immediately.​
• For other numbers, the program uses the print() function to display a message–” Processing message:” with the number (using f-strings).​
• The else block associated with the loop would be implemented only if the loop wasn't terminated by a break statement.

This example demonstrates how control flow keywords can be used to manage the execution path of a program effectively.

Function & Class Definition Keywords

In Python, functions and classes are fundamental building blocks that promote code reusability and organization.​

• Functions allow you to encapsulate a sequence of statements that perform a specific task. They can accept input parameters and return outputs, making them essential for modular programming.​
• Classes enable object-oriented programming by allowing you to define custom data types with attributes (data) and methods (functions) that operate on the data. This approach helps in modeling real-world entities and behaviors.​

Python provides specific keywords to define functions and classes, as well as to handle special scenarios like anonymous functions and generators.​

Code Example:

            class Calculator:
    def __init__(self):
        self.history = []

    def add(self, x, y):
        result = x + y
        self.history.append(result)
        return result

    def get_history(self):
        return self.history

    def generator_example(self):
        for value in self.history:
            yield value

# Using lambda to create a simple function
multiply = lambda x, y: x * y

# Instantiate the Calculator class
calc = Calculator()

# Perform addition
sum_result = calc.add(5, 3)
print(f"Sum: {sum_result}")

# Use the lambda function
product_result = multiply(4, 2)
print(f"Product: {product_result}")

# Retrieve history using the generator
print("History:")
for item in calc.generator_example():
    print(item)
          

Y2xhc3MgQ2FsY3VsYXRvcjoKICAgIGRlZiBfX2luaXRfXyhzZWxmKToKICAgICAgICBzZWxmLmhpc3RvcnkgPSBbXQoKICAgIGRlZiBhZGQoc2VsZiwgeCwgeSk6CiAgICAgICAgcmVzdWx0ID0geCArIHkKICAgICAgICBzZWxmLmhpc3RvcnkuYXBwZW5kKHJlc3VsdCkKICAgICAgICByZXR1cm4gcmVzdWx0CgogICAgZGVmIGdldF9oaXN0b3J5KHNlbGYpOgogICAgICAgIHJldHVybiBzZWxmLmhpc3RvcnkKCiAgICBkZWYgZ2VuZXJhdG9yX2V4YW1wbGUoc2VsZik6CiAgICAgICAgZm9yIHZhbHVlIGluIHNlbGYuaGlzdG9yeToKICAgICAgICAgICAgeWllbGQgdmFsdWUKCiMgVXNpbmcgbGFtYmRhIHRvIGNyZWF0ZSBhIHNpbXBsZSBmdW5jdGlvbgptdWx0aXBseSA9IGxhbWJkYSB4LCB5OiB4ICogeQoKIyBJbnN0YW50aWF0ZSB0aGUgQ2FsY3VsYXRvciBjbGFzcwpjYWxjID0gQ2FsY3VsYXRvcigpCgojIFBlcmZvcm0gYWRkaXRpb24Kc3VtX3Jlc3VsdCA9IGNhbGMuYWRkKDUsIDMpCnByaW50KGYiU3VtOiB7c3VtX3Jlc3VsdH0iKQoKIyBVc2UgdGhlIGxhbWJkYSBmdW5jdGlvbgpwcm9kdWN0X3Jlc3VsdCA9IG11bHRpcGx5KDQsIDIpCnByaW50KGYiUHJvZHVjdDoge3Byb2R1Y3RfcmVzdWx0fSIpCgojIFJldHJpZXZlIGhpc3RvcnkgdXNpbmcgdGhlIGdlbmVyYXRvcgpwcmludCgiSGlzdG9yeToiKQpmb3IgaXRlbSBpbiBjYWxjLmdlbmVyYXRvcl9leGFtcGxlKCk6CiAgICBwcmludChpdGVtKQ==

Output:

Sum: 8
Product: 8
History:
8

Code Explanation:

• A Calculator class is defined with methods to add numbers and retrieve history.​ Here, we use the class and def keywords to define the class and methods, respectively.
• The add method uses the return keyword to return the sum of two numbers and stores the result in the history.​
• The generator_example method demonstrates the use of the yield keyword to create a generator that yields each item in the history.​
• A lambda function named multiply is defined as multiplying two numbers.​
• An instance of Calculator is created, and its methods are used to perform operations and display results.​

This example illustrates how function and class definition keywords work together to create organized and reusable code structures in Python.​

Exception Handling Keywords In Python

In Python, exceptions are events that disrupt the normal flow of a program's execution. They typically occur due to unforeseen errors, such as dividing by zero, accessing an invalid index in a list, or attempting to open a non-existent file. Python provides a robust exception-handling mechanism to manage these situations gracefully and prevent abrupt program termination.​

The core of this mechanism revolves around the try and except blocks, which are implemented using the Python keywords mentioned in the table below:

Understanding and effectively utilizing these keywords is essential for writing robust and error-resistant Python code.​

Code Example:

            def divide_numbers(a, b):
    try:
        result = a / b
    except ZeroDivisionError as e:
        print(f"Error: Cannot divide by zero. ({e})")
    else:
        print(f"Result: {result}")
    finally:
        print("Execution completed.")

# Using assert to ensure inputs are integers
def get_numbers():
    a = input("Enter first number: ")
    b = input("Enter second number: ")
    assert a.isdigit() and b.isdigit(), "Inputs must be numeric."
    return int(a), int(b)
try:
    num1, num2 = get_numbers()
    divide_numbers(num1, num2)
except AssertionError as error:
    print(f"Input Error: {error}")
          

ZGVmIGRpdmlkZV9udW1iZXJzKGEsIGIpOgogICAgdHJ5OgogICAgICAgIHJlc3VsdCA9IGEgLyBiCiAgICBleGNlcHQgWmVyb0RpdmlzaW9uRXJyb3IgYXMgZToKICAgICAgICBwcmludChmIkVycm9yOiBDYW5ub3QgZGl2aWRlIGJ5IHplcm8uICh7ZX0pIikKICAgIGVsc2U6CiAgICAgICAgcHJpbnQoZiJSZXN1bHQ6IHtyZXN1bHR9IikKICAgIGZpbmFsbHk6CiAgICAgICAgcHJpbnQoIkV4ZWN1dGlvbiBjb21wbGV0ZWQuIikKCiMgVXNpbmcgYXNzZXJ0IHRvIGVuc3VyZSBpbnB1dHMgYXJlIGludGVnZXJzCmRlZiBnZXRfbnVtYmVycygpOgogICAgYSA9IGlucHV0KCJFbnRlciBmaXJzdCBudW1iZXI6ICIpCiAgICBiID0gaW5wdXQoIkVudGVyIHNlY29uZCBudW1iZXI6ICIpCiAgICBhc3NlcnQgYS5pc2RpZ2l0KCkgYW5kIGIuaXNkaWdpdCgpLCAiSW5wdXRzIG11c3QgYmUgbnVtZXJpYy4iCiAgICByZXR1cm4gaW50KGEpLCBpbnQoYikKdHJ5OgogICAgbnVtMSwgbnVtMiA9IGdldF9udW1iZXJzKCkKICAgIGRpdmlkZV9udW1iZXJzKG51bTEsIG51bTIpCmV4Y2VwdCBBc3NlcnRpb25FcnJvciBhcyBlcnJvcjoKICAgIHByaW50KGYiSW5wdXQgRXJyb3I6IHtlcnJvcn0iKQ==

Output:

Enter first number: 10
Enter second number: 0
Error: Cannot divide by zero. (division by zero)
Execution completed.

Code Explanation:

• We define a function to divide numbers and use the try, except, else, and finally keywords to create an error-handling mechanism.
• try block: Attempts to perform the division operation.​
• except ZeroDivisionError: Catches the specific error when dividing by zero and prints an error message.​
• else block: Executes if no exceptions are raised in the try block, printing the result.
• finally block: Executes regardless of whether an exception occurred, indicating the end of execution.​
• Then, we also define another function to take input from a user and check if the numbers are numeric using assert and built-in Python functions.
• assert statement: Ensures that the user inputs are numeric; otherwise, raises an AssertionError.​
• Finally, we call for input; the block raises an error and handles everything gracefully, as shown in the output.

By understanding and utilizing these exception-handling keywords, you can write Python programs that are more resilient and capable of handling unexpected situations gracefully.

Quick Knowledge Check!

Variable Scope/Handling Python Keywords

In Python, understanding variable scope is essential for writing clean and efficient code. Scope determines the accessibility and lifespan of a variable within different parts of a program. Python provides specific keywords to manage variable scope and handle variables effectively: global, nonlocal, and del.

Code Example:

            # Using 'global' to modify a global variable inside a function
count = 0

def increment():
    global count
    count += 1
    print(f"Global count: {count}")

increment() # Output: Global count: 1

# Using 'nonlocal' to modify a variable in the enclosing scope
def outer():
    message = "Hello"

    def inner():
        nonlocal message
        message = "Hi"
        print(f"Inner message: {message}")

    inner()
        print(f"Outer message: {message}")

outer()
# Output:
# Inner message: Hi
# Outer message: Hi

# Using 'del' to delete a variable
x = 10
print(f"Value of x before deletion: {x}")
del x
# print(x) # This would raise a NameError as x is deleted
          

IyBVc2luZyAnZ2xvYmFsJyB0byBtb2RpZnkgYSBnbG9iYWwgdmFyaWFibGUgaW5zaWRlIGEgZnVuY3Rpb24KY291bnQgPSAwCgpkZWYgaW5jcmVtZW50KCk6CiAgICBnbG9iYWwgY291bnQKICAgIGNvdW50ICs9IDEKICAgIHByaW50KGYiR2xvYmFsIGNvdW50OiB7Y291bnR9IikKCmluY3JlbWVudCgpICMgT3V0cHV0OiBHbG9iYWwgY291bnQ6IDEKCiMgVXNpbmcgJ25vbmxvY2FsJyB0byBtb2RpZnkgYSB2YXJpYWJsZSBpbiB0aGUgZW5jbG9zaW5nIHNjb3BlCmRlZiBvdXRlcigpOgogICAgbWVzc2FnZSA9ICJIZWxsbyIKCiAgICBkZWYgaW5uZXIoKToKICAgICAgICBub25sb2NhbCBtZXNzYWdlCiAgICAgICAgbWVzc2FnZSA9ICJIaSIKICAgICAgICBwcmludChmIklubmVyIG1lc3NhZ2U6IHttZXNzYWdlfSIpCgogICAgaW5uZXIoKQogICAgICAgIHByaW50KGYiT3V0ZXIgbWVzc2FnZToge21lc3NhZ2V9IikKCm91dGVyKCkKIyBPdXRwdXQ6CiMgSW5uZXIgbWVzc2FnZTogSGkKIyBPdXRlciBtZXNzYWdlOiBIaQoKIyBVc2luZyAnZGVsJyB0byBkZWxldGUgYSB2YXJpYWJsZQp4ID0gMTAKcHJpbnQoZiJWYWx1ZSBvZiB4IGJlZm9yZSBkZWxldGlvbjoge3h9IikKZGVsIHgKIyBwcmludCh4KSAjIFRoaXMgd291bGQgcmFpc2UgYSBOYW1lRXJyb3IgYXMgeCBpcyBkZWxldGVk

Output:

Global count: 1
Inner message: Hi
Outer message: Hi
Value of x before deletion: 10

Code Explanation:

• global Keyword: In the increment function, the global keyword is used to indicate that the function intends to modify the global variable count. Without declaring count as global, assigning to it inside the function would create a new local variable, leaving the global count unchanged.​
• nonlocal Keyword: In the outer function, message is a variable in the enclosing scope of the nested inner function. By declaring message as nonlocal inside inner, we allow the nested function to modify the message variable from the enclosing outer function. This demonstrates how nonlocal enables inner functions to modify variables from their enclosing scopes.
• del Keyword: The del statement is used to delete variables. In the example, after assigning 10 to x, we delete it using del x. Attempting to access x after deletion would result in a NameError since x no longer exists in the namespace.​

By mastering these keywords, you can effectively manage variable scopes and lifecycles in Python, leading to more predictable and maintainable code.

Operator Keywords In Python (Logical & Membership)

In Python, certain keywords function as operators, enabling you to perform logical operations, test object identity, and check membership within collections. Unlike many programming languages that use symbols (e.g., &&, ||, !) for these operations, Python opts for English words, enhancing code readability and clarity.​

These operator keywords are integral to constructing expressions that control the flow of logic in your programs. They allow you to combine conditions, invert boolean values, and assess relationships between objects and collections.​

Code Example:

            x = 10
y = 20
z = [10, 20, 30]

# Logical AND
if x > 5 and y > 15:
    print("Both conditions are True.")

# Logical OR
if x < 5 or y > 15:
    print("At least one condition is True.")

# Logical NOT
if not x == y:
    print("x and y are not equal.")

# Membership test
if 20 in z:
    print("20 is in the list z.")

# Identity test
a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(a is b) # True, because b references the same object as a
print(a is c) # False, because c is a different object with the same content
          

eCA9IDEwCnkgPSAyMAp6ID0gWzEwLCAyMCwgMzBdCgojIExvZ2ljYWwgQU5ECmlmIHggPiA1IGFuZCB5ID4gMTU6CiAgICBwcmludCgiQm90aCBjb25kaXRpb25zIGFyZSBUcnVlLiIpCgojIExvZ2ljYWwgT1IKaWYgeCA8IDUgb3IgeSA+IDE1OgogICAgcHJpbnQoIkF0IGxlYXN0IG9uZSBjb25kaXRpb24gaXMgVHJ1ZS4iKQoKIyBMb2dpY2FsIE5PVAppZiBub3QgeCA9PSB5OgogICAgcHJpbnQoInggYW5kIHkgYXJlIG5vdCBlcXVhbC4iKQoKIyBNZW1iZXJzaGlwIHRlc3QKaWYgMjAgaW4gejoKICAgIHByaW50KCIyMCBpcyBpbiB0aGUgbGlzdCB6LiIpCgojIElkZW50aXR5IHRlc3QKYSA9IFsxLCAyLCAzXQpiID0gYQpjID0gWzEsIDIsIDNdCgpwcmludChhIGlzIGIpICMgVHJ1ZSwgYmVjYXVzZSBiIHJlZmVyZW5jZXMgdGhlIHNhbWUgb2JqZWN0IGFzIGEKcHJpbnQoYSBpcyBjKSAjIEZhbHNlLCBiZWNhdXNlIGMgaXMgYSBkaWZmZXJlbnQgb2JqZWN0IHdpdGggdGhlIHNhbWUgY29udGVudA==

Output:

Both conditions are True.
At least one condition is True.
x and y are not equal.
20 is in the list z.
True
False

Code Explanation:

• Logical AND (and): Evaluates to True only if both conditions are True.​
• Logical OR (or): Evaluates to True if at least one condition is True.​
• Logical NOT (not): Inverts the result of the condition.​
• Membership Test (in): Checks if a value exists within a collection.​
• Identity Test (is): Determines if two references point to the same object in memory.​
• Logical AND (and): The condition x > 5 and y > 15 checks if both x is greater than 5 and y is greater than 15. Since x is 10 and y is 20, both conditions are true, so the message "Both conditions are True." is printed.​
• Logical OR (or): The condition x < 5 or y > 15 evaluates whether at least one of the conditions is true. Here, x is not less than 5, but y is greater than 15, so the overall condition is true, resulting in the message "At least one condition is True." being printed.​
• Logical NOT (not): The statement not x == y inverts the result of x == y. Since x (10) is not equal to y (20), x == y is false; applying not makes it true, leading to the message "x and y are not equal." being printed.​
• Membership Test (in): The condition 20 in z checks if the value 20 exists within the Python list z. Since z contains [10, 20, 30], the condition is true, and "20 is in the list z." is printed.​
• Identity Test (is):
• a is b evaluates to true because both variables reference the same object.​
• a is c evaluates to false because, despite having identical contents, a and c are different objects in memory.​

By understanding and utilizing these operator keywords, you can write more expressive and readable Python code that effectively handles logical operations and object comparisons.

Quick Knowledge Check

Module & Import Management Keywords

In Python, modules are files containing Python code that define functions, classes, and variables. They promote code reusability and better organization. To utilize code from one module in another, Python provides specific keywords that facilitate the import process.

• The import keyword is used to bring in entire modules, making their contents accessible using dot notation. For instance, import math allows access to the math module's functions like math.sqrt().
• The from keyword enables importing specific attributes or functions from a module directly into the current namespace. For example, from math import sqrt allows direct use of sqrt() without the math. prefix.
• The as keyword allows aliasing modules or functions during import, which can simplify code and prevent naming conflicts. For instance, import numpy as np lets you use np as a shorthand for numpy.

These keywords are essential for managing dependencies and structuring Python programs effectively.​

Code Example:

            # Importing the entire math module
import math

# Using the sqrt function with the module name
print("Square root of 16 is:", math.sqrt(16))

# Importing only the sqrt function from math
from math import sqrt

# Using the sqrt function directly
print("Square root of 25 is:", sqrt(25))

# Importing the datetime module with an alias
import datetime as dt

# Getting the current date and time
now = dt.datetime.now()
print("Current date and time:", now)
          

IyBJbXBvcnRpbmcgdGhlIGVudGlyZSBtYXRoIG1vZHVsZQppbXBvcnQgbWF0aAoKIyBVc2luZyB0aGUgc3FydCBmdW5jdGlvbiB3aXRoIHRoZSBtb2R1bGUgbmFtZQpwcmludCgiU3F1YXJlIHJvb3Qgb2YgMTYgaXM6IiwgbWF0aC5zcXJ0KDE2KSkKCiMgSW1wb3J0aW5nIG9ubHkgdGhlIHNxcnQgZnVuY3Rpb24gZnJvbSBtYXRoCmZyb20gbWF0aCBpbXBvcnQgc3FydAoKIyBVc2luZyB0aGUgc3FydCBmdW5jdGlvbiBkaXJlY3RseQpwcmludCgiU3F1YXJlIHJvb3Qgb2YgMjUgaXM6Iiwgc3FydCgyNSkpCgojIEltcG9ydGluZyB0aGUgZGF0ZXRpbWUgbW9kdWxlIHdpdGggYW4gYWxpYXMKaW1wb3J0IGRhdGV0aW1lIGFzIGR0CgojIEdldHRpbmcgdGhlIGN1cnJlbnQgZGF0ZSBhbmQgdGltZQpub3cgPSBkdC5kYXRldGltZS5ub3coKQpwcmludCgiQ3VycmVudCBkYXRlIGFuZCB0aW1lOiIsIG5vdyk=

Output:

Square root of 16 is: 4.0
Square root of 25 is: 5.0
Current date and time: 2025-04-14 02:10:28.123456

Code Explanation:

• import math: Brings in the entire math module, allowing access to its functions using the math. prefix.​
• from math import sqrt: Imports only the sqrt function from the math module, enabling direct use without the module prefix.
• import datetime as dt: Imports the datetime module and assigns it the alias dt, simplifying references to its classes and functions.​

By understanding and utilizing these module and import management keywords, you can write more organized and maintainable Python code, effectively managing dependencies and namespaces.

Asynchronous Programming Keywords In Python

Asynchronous programming in Python allows for concurrent execution of tasks, enabling programs to handle operations like I/O-bound tasks more efficiently. This is particularly useful when dealing with tasks that might take an unpredictable amount of time, such as network requests or file operations.​

Python introduces two keywords to facilitate asynchronous programming:​

Code Example:

            import asyncio

async def fetch_data():
    print("Start fetching data...")
    await asyncio.sleep(2)  # Simulates a delay (e.g., network operation)
    print("Data fetched successfully.")
    return {"data": 123}

async def main():
    print("Program started.")
    result = await fetch_data()
    print(f"Result: {result}")

# Running the asynchronous main function
asyncio.run(main())
          

aW1wb3J0IGFzeW5jaW8KCmFzeW5jIGRlZiBmZXRjaF9kYXRhKCk6CiAgICBwcmludCgiU3RhcnQgZmV0Y2hpbmcgZGF0YS4uLiIpCiAgICBhd2FpdCBhc3luY2lvLnNsZWVwKDIpwqAgIyBTaW11bGF0ZXMgYSBkZWxheSAoZS5nLiwgbmV0d29yayBvcGVyYXRpb24pCiAgICBwcmludCgiRGF0YSBmZXRjaGVkIHN1Y2Nlc3NmdWxseS4iKQogICAgcmV0dXJuIHsiZGF0YSI6IDEyM30KCmFzeW5jIGRlZiBtYWluKCk6CiAgICBwcmludCgiUHJvZ3JhbSBzdGFydGVkLiIpCiAgICByZXN1bHQgPSBhd2FpdCBmZXRjaF9kYXRhKCkKICAgIHByaW50KGYiUmVzdWx0OiB7cmVzdWx0fSIpCgojIFJ1bm5pbmcgdGhlIGFzeW5jaHJvbm91cyBtYWluIGZ1bmN0aW9uCmFzeW5jaW8ucnVuKG1haW4oKSk=

Output:

Program started.
Start fetching data…
Data fetched successfully.
Result: {'data': 123}

Code Explanation:

• async def fetch_data(): Defines an asynchronous function that simulates data fetching.
• await asyncio.sleep(2): Pauses the coroutine for 2 seconds, simulating a delay (like a network request). During this pause, other tasks can run concurrently.
• async def main(): Defines the main coroutine that calls fetch_data() and awaits its result.​
• asyncio.run(main()): Executes the main() coroutine, managing the event loop automatically.​

By using async and await, Python allows for writing non-blocking code that can handle multiple operations concurrently, leading to more efficient and responsive programs.

Quick Knowledge Check

Context Management Keywords In Python

In Python, context management refers to the handling of resources such as files, network connections, or locks, ensuring they are acquired and released appropriately. This is particularly important for managing resources that require setup and teardown operations, like opening and closing files.​

Python's with statement simplifies exception handling and resource management by encapsulating the setup and teardown actions within a context manager. This approach ensures that resources are properly managed, even if errors occur within the block.​

Code Example:

            # Using with to manage file opening and closing
with open('example.txt', 'w') as file:
    file.write('Hello, world!')
    # No need to explicitly close the file; it's handled by the context manager

# Using with to acquire and release a lock
import threading
lock = threading.Lock()
with lock as acquired_lock:
    # Critical section of code
    # The lock is automatically acquired at this point
    # and released when the block is exited
    pass
          

IyBVc2luZyB3aXRoIHRvIG1hbmFnZSBmaWxlIG9wZW5pbmcgYW5kIGNsb3NpbmcKd2l0aCBvcGVuKCdleGFtcGxlLnR4dCcsICd3JykgYXMgZmlsZToKICAgIGZpbGUud3JpdGUoJ0hlbGxvLCB3b3JsZCEnKQogICAgIyBObyBuZWVkIHRvIGV4cGxpY2l0bHkgY2xvc2UgdGhlIGZpbGU7IGl0J3MgaGFuZGxlZCBieSB0aGUgY29udGV4dCBtYW5hZ2VyCgojIFVzaW5nIHdpdGggdG8gYWNxdWlyZSBhbmQgcmVsZWFzZSBhIGxvY2sKaW1wb3J0IHRocmVhZGluZwpsb2NrID0gdGhyZWFkaW5nLkxvY2soKQp3aXRoIGxvY2sgYXMgYWNxdWlyZWRfbG9jazoKICAgICMgQ3JpdGljYWwgc2VjdGlvbiBvZiBjb2RlCiAgICAjIFRoZSBsb2NrIGlzIGF1dG9tYXRpY2FsbHkgYWNxdWlyZWQgYXQgdGhpcyBwb2ludAogICAgIyBhbmQgcmVsZWFzZWQgd2hlbiB0aGUgYmxvY2sgaXMgZXhpdGVkCiAgICBwYXNz

Output (example.txt):

Hello, world!

Code Explanation:

• File Handling with with and as: The with statement is used to open a file in write mode. The file is automatically closed when the block is exited, even if exceptions occur within the block. The as keyword binds the opened file object to the variable file, allowing you to interact with it directly.​
• Lock Management with with and as: In multithreaded programming, the with statement is used to acquire a lock, ensuring that only one thread can execute the critical section at a time. The as keyword binds the acquired lock to the variable acquired_lock, though it's not used further in this example. The lock is automatically released when the block is exited using the pass statement.

By utilizing the with and as keywords, you can write cleaner and more reliable code for resource management, reducing the risk of errors and ensuring that resources are properly cleaned up after use.​

Boolean & Null Values In Python

In Python, Boolean and null values are fundamental for logic and control flow. They represent truth values and the absence of a value, respectively. Understanding these values and using these Python keywords is crucial for making decisions and handling conditions in your programs.​

Code Example:

            def check_value(value):
    if value is None:
        return "No value provided"
    elif value:
      return "Value is True"
    else:
      return "Value is False"

print(check_value(True))
print(check_value(None))
print(check_value(False))
          

ZGVmIGNoZWNrX3ZhbHVlKHZhbHVlKToKICAgIGlmIHZhbHVlIGlzIE5vbmU6CiAgICAgICAgcmV0dXJuICJObyB2YWx1ZSBwcm92aWRlZCIKICAgIGVsaWYgdmFsdWU6CiAgICAgIHJldHVybiAiVmFsdWUgaXMgVHJ1ZSIKICAgIGVsc2U6CiAgICAgIHJldHVybiAiVmFsdWUgaXMgRmFsc2UiCgpwcmludChjaGVja192YWx1ZShUcnVlKSkKcHJpbnQoY2hlY2tfdmFsdWUoTm9uZSkpCnByaW50KGNoZWNrX3ZhbHVlKEZhbHNlKSk=

Output:

Value is True
No value provided
Value is False

Code Explanation:

In this example, the function check_value takes an input and uses an if-elif-else statement to evaluate it as follows:​

• If value is None, it returns "No value provided".
• If value is truthy (not None and not False), it returns "Value is True".
• Otherwise, it returns "Value is False".​

This demonstrates how True, False, and None are used in conditional statements to control the flow of the program.​

Pattern Matching/Soft Python Keywords

Introduced in Python 3.10, pattern matching keywords allows for more readable and expressive code when dealing with complex data structures. It is particularly useful for matching and destructuring objects, lists, and other data types.​

Code Example:

            def handle_response(response):
    match response:
        case {"status": 200, "data": data}:
            return f"Success: {data}"
      case {"status": 404}:
            return "Error: Not Found"
        case _:
            return "Error: Unknown"

print(handle_response({"status": 200, "data": "OK"}))
print(handle_response({"status": 404}))
          

ZGVmIGhhbmRsZV9yZXNwb25zZShyZXNwb25zZSk6CiAgICBtYXRjaCByZXNwb25zZToKICAgICAgICBjYXNlIHsic3RhdHVzIjogMjAwLCAiZGF0YSI6IGRhdGF9OgogICAgICAgICAgICByZXR1cm4gZiJTdWNjZXNzOiB7ZGF0YX0iCiAgICAgIGNhc2UgeyJzdGF0dXMiOiA0MDR9OgogICAgICAgICAgICByZXR1cm4gIkVycm9yOiBOb3QgRm91bmQiCiAgICAgICAgY2FzZSBfOgogICAgICAgICAgICByZXR1cm4gIkVycm9yOiBVbmtub3duIgoKcHJpbnQoaGFuZGxlX3Jlc3BvbnNlKHsic3RhdHVzIjogMjAwLCAiZGF0YSI6ICJPSyJ9KSkKcHJpbnQoaGFuZGxlX3Jlc3BvbnNlKHsic3RhdHVzIjogNDA0fSkp

Output:

Success: OK
Error: Not Found

Code Explanation:

In this example, the function handle_response uses pattern matching to handle different types of responses:​

• The match keyword initiates the pattern matching block.
• Each case defines a pattern to match against the response.
• The _ wildcard pattern matches any case not explicitly handled.​

This approach of using the soft Python keywords provides a clear and concise way to handle various data structures.​

Type Alias Definitions Keyword In Python

Type aliases in Python allow you to define custom names for existing types, enhancing code readability and maintainability. They are particularly useful in complex type hinting scenarios.

Code Example:

            type Vector = list[float]
type Matrix = list[Vector]

def scale_vector(v: Vector, scalar: float) -> Vector:
    return [x * scalar for x in v]

print(scale_vector([1.0, 2.0, 3.0], 2))
          

dHlwZSBWZWN0b3IgPSBsaXN0W2Zsb2F0XQp0eXBlIE1hdHJpeCA9IGxpc3RbVmVjdG9yXQoKZGVmIHNjYWxlX3ZlY3Rvcih2OiBWZWN0b3IsIHNjYWxhcjogZmxvYXQpIC0+IFZlY3RvcjoKICAgIHJldHVybiBbeCAqIHNjYWxhciBmb3IgeCBpbiB2XQoKcHJpbnQoc2NhbGVfdmVjdG9yKFsxLjAsIDIuMCwgMy4wXSwgMikp

Output: 

[2.0, 4.0, 6.0]

Code Explanation:

In this example:​

• The type keyword is used to define Vector as a list of floats and Matrix as a list of Vector.
• The function scale_vector takes a Vector and a scalar, returning a new Vector with each element scaled by the scalar.
  

This demonstrates how type aliases can simplify complex type annotations and improve code clarity.

Conclusion

Python's keywords form the foundation of its syntax and programming paradigms. From controlling flow and managing exceptions to handling asynchronous operations and defining type aliases, these reserved words are integral to writing clear and efficient Python code. By understanding and effectively utilizing these keywords, you can enhance your coding proficiency and develop more robust applications.

Frequently Asked Questions

Q1: How many keywords are there in Python?

As of Python 3.13, there are 35 reserved keywords. These are predefined words that have special meanings and cannot be used as identifiers (like variable names).

Q2: What are soft keywords in Python?

Soft keywords are identifiers that act as keywords only in specific contexts. For example, match, case, type, and _ are soft keywords introduced in Python 3.10 for structural pattern matching. Outside their specific contexts, they can be used as regular identifiers. 

Q3: How can I get a list of all the keywords in Python?

You can use the built-in keyword module in Python:​

import keyword
print(keyword.kwlist)  # Lists all reserved keywords
print(keyword.softkwlist)  # Lists all soft keywords (Python 3.10+)

As mentioned in the code comments, the different functions provided in the keyword module list the keyword reserves in Python.

Q4: Can I use Python keywords as variable names?

No, Python keywords are reserved and cannot be used as identifiers such as variable names, function names, or any other identifiers. Attempting to do so will result in a SyntaxError. However, soft keywords can be used as identifiers when not in their special context.

Q5: Why are some keywords 'soft' in Python?

Soft keywords allow the introduction of new language features without breaking existing code. By reserving words only in specific contexts, Python maintains backward compatibility and flexibility.

This compiles our discussion on Python keywords. Here are a few more topics you must explore:

• Python Strings | Create, Format, Reassign & More (+Examples)
• Hello, World! Program In Python | 7 Easy Methods (With Examples)
• Python IDLE | The Ultimate Beginner's Guide With Images & Codes!
• How To Print Without Newline In Python? (Mulitple Ways + Examples)
• Python Libraries | Standard, Third-Party & More (Lists + Examples)
• Python String Manipulation | Handbook With Techniques & Examples