Hello everyone! Welcome to the third article in the “Python from Zero to Mastery” series. Today, we will explore one of the most fundamental and important concepts in Python programming—variables and data types.

Python is known for its concise and elegant syntax, and the variable system is a prime example of this elegance. Unlike many other languages, Python’s variable system is both flexible and powerful, allowing us to express rich logic with minimal code.

What is a Variable

Basic Concept of Variables

In programming, a variable is a named container used to store data. It can hold different types of values, such as integers, strings, lists, etc., and you can use variables in your program to reference these values. Through variables, we can access and modify data in different parts of the program.

Data Storage: Variables are used to store various types of data in a program (numbers, text, boolean values, etc.)

Named Reference: You can access and manipulate stored data through the variable name

Mutability: Most variables can change the value they store during program execution (all variables in Python are mutable)

Variable Naming Rules

• Variable names must start with a letter or an underscore (<span>_</span>), and subsequent characters can be letters, numbers, or underscores.

• Variable names are case-sensitive; for example, <span>age</span> and <span>Age</span> are different variables.

• Python’s reserved words (such as <span>class</span>, <span>def</span>, <span>if</span>, etc.) cannot be used as variable names.

Characteristics of Variables

1. Dynamic Typing: Python variables do not need to declare their type in advance; the type is determined at assignment

x = 10      # Integer
x = "hello" # Now it becomes a string

2. Reference Semantics: Python variables are actually references to objects

a = [1, 2, 3]
b = a       # b and a reference the same list object

3. Naming Rules:

• Cannot start with a number

• Can include letters, numbers, and underscores

• Case-sensitive

• Cannot use Python keywords (like if, for, while, etc.)

Basic Operations with Variables

# Assignment
counter = 0
name = "Alice"
price = 19.99
is_active = True

# Access
print(name)  # Output: Alice

# Reassignment
counter = counter + 1

# Multiple Assignment
x, y, z = 1, 2, 3

# Variable Swap
a, b = 10, 20
a, b = b, a  # Swap values of a and b

Variables and Memory

When a variable is created, Python will:

1. Create an object in memory to store the data

2. Associate the variable name with that object

3. Manage memory through reference counting (automatically reclaim memory when the reference count is 0)

Variables are the foundation of programming, and understanding them is crucial for learning any programming language. In Python, the flexibility and ease of use of variables make it an ideal choice for beginners.

Dynamic Typing: The Flexibility of Python

What is Dynamic Typing

In Python, variables do not need to declare their type in advance. When you write

x = 42

, Python automatically recognizes<span>42</span> as an integer and binds<span>x</span> to this integer object. Even more remarkably, you can change the variable’s type at any time:

x = 42      # Now x is an integer
x = "hello" # Now x becomes a string
x = 3.14    # Now x becomes a float

This feature is calleddynamic typing, and it is a significant source of Python’s flexibility.

Variables are Labels, Not Boxes

The key to understanding Python variables is to realize that variables are not containers for storing data, but labels pointing to objects.

a = [1, 2, 3]
b = a
b.append(4)
print(a)  # What does it output?

The answer is<span>[1, 2, 3, 4]</span>, because<span>a</span> and<span>b</span> point to the same list object.

Advantages and Pitfalls of Dynamic Typing

Advantages:

• Code is more concise, and development is faster
• More flexible programming paradigms
• Suitable for rapid prototyping

Pitfalls:

• Type-related errors may only be discovered at runtime
• Requires more testing to ensure type safety
• May affect code readability (if not commented)

Type Annotations: Adding a Safety Belt to Dynamic Typing

Type annotations in Python (introduced in Python 3.5+) are used to add type hints for variables, function parameters, and return values. These annotations do not affect the runtime behavior of the program but can help static type checking tools (like mypy) discover potential type errors, improving code readability and maintainability.

Basic Type Annotations

name: str = "Alice"
age: int = 30
height: float = 1.75
is_student: bool = True

Container Type Annotations

from typing import List, Dict, Tuple, Set
# List
numbers: List[int] = [1, 2, 3]
# Dictionary
person: Dict[str, str] = {"name": "Bob", "email": "[email protected]"}
# Tuple (fixed length and type)
point: Tuple[float, float] = (1.5, 2.5)
# Set
unique_numbers: Set[int] = {1, 2, 3}

Any Type

from typing import Any
data: Any = some_untyped_function()  # Can be any type

Optional Type (can be None)

from typing import Optional
middle_name: Optional[str] = None  # Can be str or None

Union Type

from typing import Union
id: Union[int, str] = 100  # Can be int or str
id = "ABC123"  # This is also valid

Custom Type

from typing import NewType
UserId = NewType('UserId', int)
user_id = UserId(42)

Practical Type Checking

Install the type checking tool<span>mypy</span>:

pip install mypy

Create a Python file<span>example.py</span>:

def add(a: int, b: int) -> int:    return a + b
result = add(3, "5")  # There's a problem here!

Run type checking:

mypy example.py

You will see an error like this:

example.py:4: error: Argument 2 to "add" has incompatible type "str"; expected "int"
Found 1 error in 1 file (checked 1 source file)

Overview of Python Data Types

Python has a rich set of built-in data types, let’s take a quick look:

1. Numeric Types:

• <span>int</span>: Integers of arbitrary size
• <span>float</span>: Double-precision floating-point numbers
• <span>complex</span>: Complex numbers
• <span>bool</span>: Boolean values (True/False)

Sequence Types:

• <span>str</span>: Strings
• <span>list</span>: Mutable sequences
• <span>tuple</span>: Immutable sequences

Mapping Types:

• <span>dict</span>: A collection of key-value pairs

Set Types:

• <span>set</span>: Mutable unordered collection of unique elements
• <span>frozenset</span>: Immutable set

Others:

• <span>bytes</span>: Immutable byte sequences
• <span>bytearray</span>: Mutable byte sequences
• <span>NoneType</span>: None value

Best Practices and Tips

1. Variable Naming:

• Use descriptive names
• Follow PEP 8 style guidelines (lowercase with underscores)
• Avoid using<span>l</span>, <span>O</span>, and other easily confused characters

Type Annotations:

• Start simple and gradually add
• Prioritize adding annotations to public interfaces
• Use<span>Any</span> type as an escape hatch

Type Checking:

• Incorporate type checking into CI/CD processes
• Use<span># type: ignore</span> to cautiously ignore specific errors
• Consider using<span>typing.cast</span> for type conversion

Python’s dynamic typing system gives it great flexibility, while type annotations provide the necessary safety net. As the Zen of Python states, “Readability counts,” we can find the perfect balance between flexibility and rigor in Python.

In the next article, we will delve into operators and expressions. Stay tuned!

Thought Question: Where in your projects would it be most appropriate to introduce type annotations? Why? Feel free to share your thoughts in the comments!