Typing in Python: A Guide

Python is one of the most popular programming languages in the world, known for its simplicity and convenience. Like C, C#, Java, and others, Python is a typed language. Typing in Python helps developers create more reliable, user-friendly programs, providing improved optimization, performance, and code security.

Each typed language was created for specific purposes, which is why programming languages differ in their typing methods. Typing in Python is both dynamic and strong.

Dynamic Typing in Python

Dynamic typing allows for determining and modifying variable types during program execution, unlike static typing, where data types are defined at compile time and cannot be changed. Dynamic typing reduces code complexity but increases the risk of errors related to incorrect data types.

x = 7
x = "Hostman"
x = [1, 2, 3]

In this example, the variable x is initialized as an integer (int), then redefined as a string (str), and later as a list (list).

Strong Typing in Python

Strong typing ensures adherence to necessary rules when interacting with different data types. Operations between different data types are usually prohibited or require explicit type conversion.

x = 7
y = "Hostman"
result = x + y

In this example, variable x is of type int, and variable y is of type str. Attempting to add variables of different types will result in a TypeError because Python enforces typing rules.

x = 7
y = 3.14
result = x + y

In this example, when adding the integer x and the float y, Python will automatically convert x to a float and perform the addition.

Although Python is a strongly typed language, it offers the flexibility of dynamic typing, allowing developers to convert data types using type conversion functions (int(), float(), etc.).

Python Data Types

Python uses built-in data types to define variable types:

• int: Used for representing whole numbers, both positive and negative.

• float: Numbers that can have a decimal part.

• str: Text information (strings).

• bool: Boolean values: True, False.

• list: Mutable ordered collections of elements (lists).

• tuple: Immutable ordered collections of elements (tuples).

• dict: Key-value pairs where each key is unique (dictionaries).

• bytes: Byte sequences, used for working with binary files.

Example of Basic Data Types

x = -10        # int
pi = 3.14      # float
name = "Anna"  # str
fruits = ["apple", "banana", "orange"]  # list
coordinates = (3, 4)  # tuple

Each of these data types has its characteristics. Python offers many built-in data types, but developers can create their own using the class keyword. Typing in Python classes is facilitated by type annotations.

Type Annotations

Type annotations allow developers to specify the expected data type of a variable, function argument, or function return value. They improve code readability without affecting program execution. Annotations are usually specified after the variable, argument, or function name, separated by a colon.

class Employee:
    def __init__(self, employee_id: str, salary: float):
        self.employee_id: str = employee_id
        self.salary: float = salary

In this example, type annotations for class attributes indicate that employee_id is expected to be a string, and salary a float.

class Circle:
    def __init__(self, radius: float):
        self.radius: float = radius

    def area(self) -> float:
        return 3.14159 * self.radius**2

Type annotations can also be applied to class methods. In this example, both the arguments and the return value are annotated as floats.

Type annotations can also be used to type functions in Python. In functions, you can annotate the function arguments, their return values, decorators, etc.

from typing import List

def find_max(numbers: List[int]) -> int:
    if not numbers:
        raise ValueError("List is empty")
    max_value: int = numbers[0]
    for num in numbers:
        if num > max_value:
            max_value = num
    return max_value

This example shows a function that takes a list annotated as int and returns the largest integer from the list, also annotated as int.

The typing Module

Besides type annotations, the built-in typing module provides additional tools for more precise and advanced typing. Here are some data structures from the typing module:

• Any: Represents an unspecified type, used when the variable type is unknown.

• Union: Allows specifying multiple possible types for a variable.

• Optional: Indicates that a variable can have a specific type or be None.
  

from typing import Union, Optional, Any

def process_data(data: Union[int, str, float, None]) -> Optional[Any]:
    if data is None:
        return None
    if isinstance(data, int):
        return f"Processed integer: {data * 2}"
    if isinstance(data, str):
        return f"Processed string: {data.upper()}"
    if isinstance(data, float):
        return f"Processed float: {round(data, 2)}"

# Examples of usage
print(process_data(42))
print(process_data("hello"))
print(process_data(3.1415926535))
print(process_data(None))

The process_data function takes an argument data that can be an integer, string, float, or None. The function returns either the processed value or None. For example, if data is an integer, it is multiplied by 2 and returned as a string with a message.

• TypeVar: Allows creating parameterized types.

• Generic: Allows creating generic classes and functions.

from typing import TypeVar, Generic

T = TypeVar('T')

class Box(Generic[T]):
    def __init__(self, item: T):
        self.item = item

    def get_item(self) -> T:
        return self.item

# Example of usage
string_box = Box("Hello, World!")
int_box = Box(42)

# Retrieving items from containers
string_value: str = string_box.get_item()
int_value: int = int_box.get_item()

print("String Box Value:", string_value)
print("Int Box Value:", int_value)

In this example, a generic class Box is created that can contain objects of any type. TypeVar is used to create a generic type variable T, which is then used as the argument type for the Box class. The Box class accepts and returns items of the specified type. Containers with different data types (string and integer) are used in the example.

Type Checking Tools

Using data annotations and the typing module improves code readability and helps static checking tools identify potential type errors early in the development process. Here are some popular type-checking tools:

• Mypy: Allows adding data annotations to code and checking their correctness, identifying potential type errors. Mypy supports various third-party libraries and frameworks, including NumPy, Django, and others.
• Pyright: Developed to support typing in Python through the use of data annotations and type comments. Pyright integrates directly into Visual Studio Code and provides real-time data structure suggestions and autocompletion.
• PyCharm: An integrated development environment (IDE) for Python that includes built-in support for type annotations and static type checking. PyCharm provides many tools for improving code typing, including quick fixes and automatic type annotation generation.

There are also several other tools and IDEs that offer static data structure checking capabilities and support type annotations.

These tools make it easier for developers to collaborate in teams, identifying type errors and providing code improvement suggestions.

Conclusion

Typing in Python is an important aspect of program code development. To work effectively, a developer should consider Python's strong dynamic typing, use type annotations and the typing module, remember the possibility of creating custom data structures, and not neglect type-checking tools. It's essential to understand that typing is a tool for improving code quality, and it's not always necessary to strive for absolute static typing, avoiding excessive complexity.