Python Fundamentals: Decorators, List Comprehensions, Generators, Exception Handling, Modules, Threading, Copying, Garbage Collection, *args/**kwargs, Closures, Methods, Process vs Thread, Database Differences, Data Structures, and API Testing

1. Python Decorators

Decorators are special functions that can modify the behavior of other functions without changing their source code.

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

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

say_hello()

2. List Comprehensions

List comprehensions provide a concise way to create lists with optional filtering.

# Create a list of squares from 0 to 9
squares = [x**2 for x in range(10)]
print(squares)  # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

3. Generators

Generators are special iterators defined with the yield keyword, allowing functions to produce a sequence of values lazily.

def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1

for number in count_up_to(5):
    print(number)

4. Exception Handling

Exception handling uses try and except blocks to catch and manage runtime errors gracefully.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("You can't divide by zero!")

5. Modules and Packages

Modules are single files containing Python definitions; packages are collections of modules organized in directories.

import math
from datetime import datetime
print(math.sqrt(16))  # Import entire math module
print(datetime.now())  # Import datetime class from datetime module

6. Multithreading

Multithreading enables concurrent execution of multiple threads within a single process.

import threading

def print_numbers():
    for i in range(5):
        print(i)

thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()

7. Shallow vs Deep Copy

Shallow copy duplicates only the top‑level objects, while deep copy recursively copies all nested objects.

import copy
original_list = [[1, 2], [3, 4]]
shallow_copy = copy.copy(original_list)
deep_copy = copy.deepcopy(original_list)
original_list[0][0] = 'X'
print(shallow_copy)  # Affected
print(deep_copy)     # Unaffected

8. Garbage Collection

Python automatically manages memory using reference counting and generational garbage collection, freeing objects that are no longer referenced.

9. *args and **kwargs

*args collects variable positional arguments; **kwargs collects variable keyword arguments.

def test_args_kwargs(arg1, *args, **kwargs):
    print("arg1:", arg1)
    print("*args:", args)
    print("**kwargs:", kwargs)

test_args_kwargs('one', 'two', 'three', key1='value1', key2='value2')

10. Closures

A closure combines a function with its surrounding lexical environment.

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

closure = outer_function(10)
print(closure(5))  # Output: 15

11. Instance, Class, and Static Methods

Instance methods operate on object instances, class methods on the class itself, and static methods are independent of both.

class MyClass:
    def instance_method(self):
        return "Instance method called", self

    @classmethod
    def class_method(cls):
        return "Class method called", cls

    @staticmethod
    def static_method():
        return "Static method called"

obj = MyClass()
print(obj.instance_method())
print(MyClass.class_method())
print(MyClass.static_method())

12. Process vs Thread

Processes have separate memory spaces and higher context‑switch overhead; threads share the same memory space and have lower overhead.

13. MySQL vs MongoDB

MySQL is a relational database using SQL; MongoDB is a NoSQL document store using JSON‑like documents, offering horizontal scalability.

14. Array vs Linked List

Arrays provide contiguous memory and random access; linked lists consist of nodes with pointers, offering efficient insertions/deletions but sequential access.

15. HTTP API vs Web Service Testing

HTTP API testing targets RESTful or similar endpoints using various data formats (JSON, XML, etc.), while Web Service testing focuses on standards‑based services (SOAP, WSDL) typically using XML and specialized tools.