Advanced Python Features
Decorators
Decorators are a powerful feature in Python that allow you to modify the
behavior of functions or classes without changing their source code. They are
essentially functions that take another function as an argument and return a
new function with enhanced functionality.
Common decorators include @staticmethod and @classmethod for class
methods, @property for computed attributes, and custom decorators for
logging, timing, or caching.
Example usage:
def my_decorator(func):
def wrapper(*args, **kwargs):
print("Before function call")
result = func(*args, **kwargs)
print("After function call")
return result
return wrapper
@my_decorator
def say_hello():
print("Hello!")
say_hello() # Will print before and after messages
Page 1
Advanced Python Features
Generators
Generators are a special type of iterator that allow you to iterate over a
sequence of values lazily, meaning values are generated on-the-fly and not
stored in memory all at once. This makes them memory-efficient for large
datasets.
Generators are defined using the yield keyword instead of return. When a
generator function is called, it returns a generator object that can be iterated
over.
Example:
def fibonacci_generator(n):
a, b = 0, 1
for _ in range(n):
yield a
a, b = b, a + b
for num in fibonacci_generator(10):
print(num)
Generators can also be created using generator expressions: (x**2 for x in
range(10))
Page 2
Advanced Python Features
Context Managers
Context managers provide a way to manage resources, such as file handles or
database connections, ensuring they are properly cleaned up even if an error
occurs. They are typically used with the with statement.
To create a context manager, you implement the __enter__ and __exit__
methods in a class, or use the @contextmanager decorator from the contextlib
module.
Example:
from contextlib import contextmanager
@contextmanager
def file_opener(filename):
file = open(filename, "w")
try:
yield file
finally:
[Link]()
with file_opener("[Link]") as f:
[Link]("Hello, World!")
Page 3
Advanced Python Features
Metaclasses
Metaclasses are classes that create classes. They allow you to customize class
creation, adding or modifying attributes and methods dynamically. This is an
advanced concept used in frameworks and libraries.
The most common metaclass is type, which is the default metaclass for all
classes in Python. You can create custom metaclasses by inheriting from type.
Example:
class MyMeta(type):
def __new__(cls, name, bases, attrs):
# Add a class attribute
attrs["created_by"] = "MyMeta"
return super().__new__(cls, name, bases, attrs)
class MyClass(metaclass=MyMeta):
pass
print(MyClass.created_by) # Output: MyMeta
Page 4
Advanced Python Features
Descriptors
Descriptors are objects that control the access to an attribute in a class. They
allow you to define custom behavior for getting, setting, or deleting attributes.
Descriptors are the mechanism behind properties, methods, and static
methods.
A descriptor class must implement at least one of __get__, __set__, or
__delete__ methods.
Example:
class Descriptor:
def __get__(self, obj, objtype=None):
return getattr(obj, "_value", None)
def __set__(self, obj, value):
setattr(obj, "_value", [Link]())
class MyClass:
attribute = Descriptor()
obj = MyClass()
[Link] = "hello"
print([Link]) # Output: HELLO
Page 5
Advanced Python Features
Coroutines
Coroutines are a generalization of subroutines for cooperative multitasking.
They allow a function to pause and resume execution, making asynchronous
programming possible. Python supports coroutines through the async and
await keywords.
Coroutines are defined with async def and called with await. They are
commonly used with libraries like asyncio for concurrent I/O operations.
Example:
import asyncio
async def hello():
print("Hello")
await [Link](1)
print("World")
[Link](hello())
Page 6
Advanced Python Features
Type Hints
Type hints allow you to specify the expected types of function arguments and
return values. This provides better code documentation and enables static type
checking with tools like mypy.
Type hints are imported from the typing module and include types like List,
Dict, Optional, Union, etc.
Example:
from typing import List, Dict
def process_data(data: List[Dict[str, int]]) -> Dict[str, float]:
result = {}
for item in data:
result[item["name"]] = item["value"] * 1.1
return result
This makes the code more readable and helps catch type-related bugs early.
Page 7
Advanced Python Features
Data Classes
Data classes automatically generate special methods like __init__, __repr__,
and __eq__ for classes that are primarily used to store data. They reduce
boilerplate code and make classes more concise.
Data classes are created using the @dataclass decorator from the dataclasses
module.
Example:
from dataclasses import dataclass
@dataclass
class Person:
name: str
age: int
email: str = ""
person = Person("John", 30, "john@[Link]")
print(person) # Output: Person(name='John', age=30,
email='john@[Link]')
Page 8
Advanced Python Features
Functools
The functools module provides higher-order functions and operations on
callable objects. It includes tools for functional programming and optimization.
Key functions include partial (for partial function application), lru_cache (for
memoization), and wraps (for decorator factories).
Example:
from functools import partial, lru_cache
@lru_cache(maxsize=128)
def fibonacci(n):
if n < 2:
return n
return fibonacci(n-1) + fibonacci(n-2)
add_five = partial(lambda x, y: x + y, 5)
print(add_five(10)) # Output: 15
Page 9
Advanced Python Features
Itertools
Itertools provides functions for creating and working with iterators. These
functions are memory-efficient and can handle large datasets without loading
everything into memory.
Common functions include combinations, permutations, cycle, chain, and
groupby.
Example:
import itertools
numbers = [1, 2, 3]
combinations = list([Link](numbers, 2))
print(combinations) # Output: [(1, 2), (1, 3), (2, 3)]
permutations = list([Link](numbers, 2))
print(permutations) # Output: [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]
Page 10
Advanced Python Features
Collections
The collections module provides specialized container datatypes beyond the
built-in types. These offer additional functionality and performance
optimizations.
Key classes include Counter (for counting hashable objects), defaultdict (dict
with default values), and namedtuple (tuple subclasses with named fields).
Example:
from collections import Counter, defaultdict, namedtuple
words = ["apple", "banana", "apple", "cherry"]
word_count = Counter(words)
print(word_count) # Output: Counter({'apple': 2, 'banana': 1, 'cherry': 1})
Point = namedtuple("Point", ["x", "y"])
p = Point(1, 2)
print(p.x, p.y) # Output: 1 2
Page 11
Advanced Python Features
Additional Advanced Features
Python offers many more advanced features that can enhance your
programming skills. Some notable ones include:
1. Multiple inheritance and method resolution order (MRO)
2. Duck typing and protocols
3. Monkey patching
4. Introspection with inspect module
5. Weak references with weakref module
6. Memory views for efficient array handling
To master these features, practice regularly and explore the Python
documentation. Consider contributing to open-source projects or reading
advanced Python books to deepen your understanding.
Page 12
Advanced Python Features
Page 13