Intermediate Python Concepts You Should Master

Python is a powerful language that allows developers to write efficient, readable, and scalable code. While beginners focus on syntax and basic data structures, intermediate Python developers must explore deeper concepts to write more Pythonic and optimized code. In this article, we’ll cover some essential intermediate-level topics to enhance your Python skills.

1. List Comprehensions & Generator Expressions

List comprehensions provide a concise way to create lists, while generator expressions help save memory.

Example:

# List comprehension
squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Generator expression
squares_gen = (x**2 for x in range(10))
print(next(squares_gen))  # 0        

List comprehensions create lists in memory, whereas generator expressions yield items lazily, reducing memory usage.

2. Lambda Functions & Functional Programming

Lambda functions are anonymous functions used for short, one-time operations.

Example:

double = lambda x: x * 2
print(double(5))  # 10        

Functional programming tools like map(), filter(), and reduce() make operations on iterables more concise:

from functools import reduce

nums = [1, 2, 3, 4]
doubled = list(map(lambda x: x * 2, nums))  # [2, 4, 6, 8]
even_numbers = list(filter(lambda x: x % 2 == 0, nums))  # [2, 4]
sum_all = reduce(lambda x, y: x + y, nums)  # 10        

3. Object-Oriented Programming (OOP)

OOP is a fundamental concept in Python that helps structure code using classes and objects.

Classes and Objects

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def details(self):
        return f"{self.brand} {self.model}"

my_car = Car("Tesla", "Model S")
print(my_car.details())  # Tesla Model S        

Encapsulation, Inheritance, and Polymorphism

Encapsulation hides details and ensures security:

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private attribute

    def deposit(self, amount):
        self.__balance += amount
        return self.__balance

account = BankAccount(1000)
print(account.deposit(500))  # 1500        

Inheritance allows a class to inherit methods from another class:

class Animal:
    def speak(self):
        return "Some sound"

class Dog(Animal):
    def speak(self):
        return "Bark"

dog = Dog()
print(dog.speak())  # Bark        

Polymorphism enables different classes to share method names but implement them differently:

class Cat:
    def speak(self):
        return "Meow"

animals = [Dog(), Cat()]
for animal in animals:
    print(animal.speak())        

4. Decorators: Enhancing Functions

Decorators allow us to modify functions dynamically without changing their structure.

Example:

def decorator_function(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@decorator_function
def say_hello():
    print("Hello!")

say_hello()        

Output:

Before function call
Hello!
After function call        

5. Context Managers (with Statement)

Context managers simplify resource management (e.g., opening files) and ensure proper cleanup.

Example:

with open("file.txt", "w") as f:
    f.write("Hello, world!")  # Automatically closes the file        

Custom context managers can be created using __enter__ and __exit__:

class CustomContext:
    def __enter__(self):
        print("Entering context")
        return self
    
    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting context")

with CustomContext() as ctx:
    print("Inside context")        

6. Handling Exceptions Properly

Python provides flexible exception handling with try-except blocks, including catching multiple exceptions.

Example:

try:
    x = 1 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")
finally:
    print("This block runs no matter what.")        

For custom exceptions:

class CustomError(Exception):
    pass

raise CustomError("Something went wrong!")        

7. Working with args and *kwargs

These allow functions to accept a flexible number of arguments.

Example:

def my_function(*args, **kwargs):
    print("Args:", args)
    print("Kwargs:", kwargs)

my_function(1, 2, 3, name="Nidhi", age=24)        

Output:

Args: (1, 2, 3)
Kwargs: {'name': 'Nidhi', 'age': 24}        

8. Using collections Module

Python’s collections module provides specialized data structures beyond built-in lists and dictionaries.

Example:

from collections import Counter, defaultdict, namedtuple

# Counter
counter = Counter("banana")
print(counter)  # {'b': 1, 'a': 3, 'n': 2}

# Defaultdict
default_dict = defaultdict(int)
default_dict["missing_key"] += 1
print(default_dict["missing_key"])  # 1

# Namedtuple
Person = namedtuple("Person", ["name", "age"])
p = Person("Alice", 30)
print(p.name, p.age)  # Alice 30        

Conclusion

Mastering these intermediate Python concepts will help you write cleaner, more efficient, and more scalable code. Keep practicing and exploring new features in Python to enhance your coding skills!

? Stay tuned for more insights in 'Code Chronicles by Nidhi'!