Python continues to serve as the backbone for artificial intelligence, web development, and automation in 2026. Maintaining a clear grasp of its evolving syntax is essential for writing efficient, readable code. This reference focuses on Python 3.10 through 3.13+ features, providing a condensed yet comprehensive look at the language's core capabilities.

1. Core Basics and Variable Handling

Python uses dynamic typing, meaning variables do not require an explicit declaration of type. However, understanding how types interact is crucial for memory management and bug prevention.

Variable Assignment

Variable names should follow the snake_case convention. Assignment is straightforward, but Python also supports multiple and augmented assignments.

# Basic assignment
x = 10
name = "Data Processor"

# Multiple assignment
a, b, c = 1, 2, 3

# Unpacking remaining values
head, *tail = [1, 2, 3, 4, 5]
# head = 1, tail = [2, 3, 4, 5]

# Augmented assignment
count = 0
count += 1

Type Identification and Conversion

Use type() for quick checks and isinstance() for logical branching based on type, which is generally preferred in production code.

value = 42.5
print(type(value))  # <class 'float'>

# Preferred type checking
if isinstance(value, (int, float)):
    print("Numeric value")

# Conversion functions
int("123")
float(5)
str(10.5)
bool(1)  # True
list("abc")  # ['a', 'b', 'c']

2. String Manipulation and Formatting

Strings in Python are immutable sequences of Unicode characters. Modern Python emphasizes the use of f-strings for efficiency and readability.

Modern F-Strings

F-strings (formatted string literals) allow embedding expressions inside string constants. As of recent versions, they support complex expressions and debugging features.

name = "Alice"
score = 95.567

# Basic interpolation
print(f"User: {name}")

# Formatting decimals
print(f"Score: {score:.2f}")

# Debugging shorthand (prints name='Alice')
print(f"{name=}")

# Multi-line f-strings
message = (
    f"Hello {name}, "
    f"your final score is {score}."
)

Essential String Methods

Methods like strip(), split(), and join() are fundamental for text processing.

raw_text = "  python programming  "
clean_text = raw_text.strip().capitalize()  # "Python programming"

# Splitting and Joining
data = "1,2,3,4"
parts = data.split(",")  # ['1', '2', '3', '4']
reconstructed = "-".join(parts)  # "1-2-3-4"

# Search and Replace
"hello world".replace("world", "python")
"filename.py".endswith(".py")

3. Advanced Collections

Python’s built-in containers are versatile. Choosing the right one impacts both performance and code clarity.

Lists (Mutable Sequences)

Lists are ideal for ordered data that changes over time.

items = [10, 20, 30]
items.append(40)
items.extend([50, 60])
items.insert(0, 5)  # Insert 5 at index 0

# Slicing: [start:stop:step]
nums = [0, 1, 2, 3, 4, 5]
subset = nums[1:4]     # [1, 2, 3]
reverse = nums[::-1]   # [5, 4, 3, 2, 1, 0]
even_idx = nums[::2]   # [0, 2, 4]

Dictionaries (Key-Value Pairs)

Dictionaries are optimized for fast lookups. Modern Python (3.9+) introduced new operators for merging.

user = {"id": 1, "name": "Bob"}

# Access with default value to avoid KeyError
role = user.get("role", "Guest")

# Modern Merge and Update
defaults = {"theme": "dark", "notify": True}
custom = {"notify": False, "user": "admin"}

# Union operator (creates new dict)
combined = defaults | custom

# In-place update
defaults |= custom

Sets (Unique Elements)

Sets are used for membership testing and eliminating duplicates.

unique_ids = {101, 102, 103, 101}
# unique_ids is {101, 102, 103}

# Set operations
a = {1, 2, 3}
b = {3, 4, 5}
print(a & b)  # Intersection: {3}
print(a | b)  # Union: {1, 2, 3, 4, 5}
print(a - b)  # Difference: {1, 2}

4. Control Flow and Pattern Matching

Beyond the standard if and while loops, Python now features powerful structural pattern matching.

Structural Pattern Matching (match-case)

Introduced in 3.10, this is a more powerful version of the switch statement found in other languages.

def handle_command(command):
    match command.split():
        case ["quit"]:
            print("Exiting...")
        case ["load", filename]:
            print(f"Loading {filename}")
        case ["move", x, y] if int(y) > 0:  # Guard clause
            print(f"Moving to {x}, {y}")
        case _:
            print("Unknown command")

Comprehensions

Comprehensions provide a concise way to create lists, dicts, and sets.

# List comprehension
squares = [x**2 for x in range(10) if x % 2 == 0]

# Dictionary comprehension
id_map = {f"ID_{x}": x for x in range(3)}

# Set comprehension
chars = {c.upper() for c in "abracadabra"}

5. Functions and Functional Patterns

Functions are first-class objects in Python. Modern development relies heavily on type hints to improve maintainability.

Function Definition with Type Hints

Type hints help IDEs and static checkers (like Mypy) identify potential bugs.

from typing import List, Optional

def process_scores(scores: List[float], factor: float = 1.0) -> List[float]:
    """Calculates adjusted scores."""
    return [s * factor for s in scores]

# Optional and Union types (Modern 3.10+ syntax)
def find_user(user_id: int) -> str | None:
    return "User Found" if user_id == 1 else None

Lambda and Functional Tools

Lambdas are useful for short-lived logic, often used with map, filter, or sorting.

points = [(1, 2), (3, 1), (5, 10)]
# Sort by the second element of the tuple
points.sort(key=lambda p: p[1])

# Map and Filter equivalents (often better as comprehensions)
incremented = list(map(lambda x: x + 1, [1, 2, 3]))

6. Object-Oriented Programming (OOP)

Python’s OOP is flexible, supporting multiple inheritance and powerful decorators.

Class Structure

Classes encapsulate data and behavior. The self parameter refers to the instance of the object.

class Document:
    def __init__(self, title: str, content: str):
        self.title = title
        self.content = content
        self._version = 1  # Protected attribute by convention

    def __repr__(self):
        return f"Document(title='{self.title}')"

    @property
    def word_count(self) -> int:
        return len(self.content.split())

class TechnicalDoc(Document):
    def __init__(self, title, content, language):
        super().__init__(title, content)
        self.language = language

Data Classes

For classes that primarily store data, dataclasses reduce boilerplate code.

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    quantity: int = 0

p1 = Product("Laptop", 1200.0, 5)
print(p1)  # Auto-generated __repr__

7. Exception Handling and Resource Management

Robust applications require careful error handling and resource cleanup.

Try-Except-Finally

Catching specific exceptions is better than a bare except clause.

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Logic error: {e}")
except (TypeError, ValueError):
    print("Input error")
else:
    print(f"Operation successful: {result}")
finally:
    print("Cleanup tasks here")

Context Managers (with statement)

Context managers ensure resources like files or database connections are closed properly.

with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()
# File is automatically closed here

8. Modern IO and System Operations

In contemporary Python development, the pathlib module is generally recommended over the older os.path for handling file paths.

Pathlib Usage

pathlib provides an object-oriented approach to filesystem paths.

from pathlib import Path

# Create a path object
base_dir = Path("project") / "data"
file_path = base_dir / "config.json"

# Checks
if file_path.exists():
    print(f"File name: {file_path.name}")
    print(f"Extension: {file_path.suffix}")

# Reading/Writing without explicit open()
text = file_path.read_text(encoding="utf-8")
file_path.write_text("New content")

9. Standard Library Highlights

Python’s "batteries included" philosophy provides powerful modules that should often be considered before reaching for third-party libraries.

Collections Module

Useful for specialized container types.

from collections import Counter, defaultdict, deque

# Count occurrences
c = Counter("mississippi")  # {'i': 4, 's': 4, 'p': 2, 'm': 1}

# Dictionary that never raises KeyError
d = defaultdict(list)
d["keys"].append("value")

# Double-ended queue for O(1) appends/pops from both ends
queue = deque([1, 2, 3])
queue.appendleft(0)

Itertools and Functools

For efficient looping and higher-order functions.

import itertools
import functools

# Infinite counting
for i in itertools.count(10):
    if i > 12: break
    print(i) # 10, 11, 12

# Chaining iterables
combined = itertools.chain([1, 2], [3, 4])

# Caching function results to improve performance
@functools.lru_cache(maxsize=128)
def heavy_computation(n):
    return n * n

Datetime and Timezones

Handling time is complex; the datetime module with timezone awareness is the standard.

from datetime import datetime, timezone, timedelta

# Current UTC time
now = datetime.now(timezone.utc)

# Formatting
print(now.strftime("%Y-%m-%d %H:%M:%S"))

# Arithmetic
tomorrow = now + timedelta(days=1)

10. Modern Asyncio and Concurrency

Asynchronous programming is vital for IO-bound applications such as web scrapers and API servers.

Async/Await Basics

Use async def to define a coroutine and await to pause execution until the coroutine completes.

import asyncio

async def fetch_data(id: int):
    print(f"Fetching data {id}...")
    await asyncio.sleep(1)  # Simulate non-blocking IO
    return {"data": id}

async def main():
    # Run multiple tasks concurrently
    results = await asyncio.gather(fetch_data(1), fetch_data(2))
    print(results)

# Entry point
if __name__ == "__main__":
    asyncio.run(main())

11. Environment and Execution

Managing your environment is as important as the code itself. Consider these common commands for local development.

Shell Commands

Run your scripts or modules effectively from the terminal.

# Run a script
python my_script.py

# Run a module as a script (e.g., venv, pip, http.server)
python -m venv .venv
python -m pip install requests
python -m http.server 8000

# Interactive mode with a script pre-loaded
python -i my_script.py

Main Guard

Always use the name guard to prevent code from running when the script is imported as a module.

def main():
    # Logic starts here
    pass

if __name__ == "__main__":
    main()

Summary Recommendation

When writing Python in 2026, prioritize code clarity and the use of the standard library. While external packages are powerful, the built-in tools like pathlib, bisect, heapq, and dataclasses often provide the most robust solutions with the least overhead. Regularly check for updates in the Python Enhancement Proposals (PEPs) to stay informed about new syntax that might simplify your specific use case. Consistent application of type hints and f-strings will ensure your code remains readable and maintainable for both peers and automated tools.