Python Developer - Advanced Job Interview Questions and Tasks

Object Creation

List Comprehensions: Create a complete list in memory. This means all elements are generated at once and stored in memory.

Generator Expressions: Create a generator that produces elements on the fly, one by one, as needed. It does not create a complete list in memory.

Memory Management

List Comprehensions: May be less efficient if the list is large because the entire list is stored in memory.

Generator Expressions: More memory efficient because elements are generated 'lazily' (lazy evaluation) and not stored all at once in memory.

Execution Time

List Comprehensions: Tend to be faster if you need to process all elements because the entire list is available immediately.

Generator Expressions: May be slower in processing all elements because elements are generated on-demand, adding overhead for each 'next' operation.

When to Use

List Comprehensions: Ideal when you need access to all elements at once or when the resulting list will be used multiple times.

Generator Expressions: Better when working with large datasets or data streams that cannot be loaded entirely into memory or when you want to process elements only once.

Memory Allocation

When you create a new object (e.g., number, list, dictionary), Python automatically allocates memory for it. You don't have to worry about managing this memory manually.

Memory Deallocation

When an object is no longer needed (i.e., no variable refers to it), the memory it occupied should be freed so it can be used by other objects.

Garbage Collection

Garbage collection is a mechanism that automatically frees memory occupied by objects that are no longer in use. In Python, it works in two main ways.

import gc

# Function to create a cycle of references
def create_cycle():
    list_a = []
    list_b = [list_a]
    list_a.append(list_b)
    # After the end of the function, list_a and list_b still exist in memory as a cycle of references

create_cycle()

# Before running GC
print(f"Objects in memory: {len(gc.get_objects())}")
# Running GC manually
gc.collect()

# After running GC
print(f"Objects in memory: {len(gc.get_objects())}")

Logging and Monitoring

Enable tracking function calls, which is useful for debugging and monitoring application performance.

def simple_decorator(func):
def wrapper():
    print("Before running func")
    func()
    print("After running func")
return wrapper

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

say_hello()

Authorization and Authentication

Can check if the user has the appropriate permissions before executing a specific function.

def requires_auth(func):
    def wrapper(user, *args, **kwargs):
        if not user.get('is_authenticated'):
            raise PermissionError("User is not authenticated")
        return func(user, *args, **kwargs)
    return wrapper

@requires_auth
def access_secure_data(user):
    return "Secure Data"

user = {'is_authenticated': True}
print(access_secure_data(user))

user = {'is_authenticated': False}
try:
    print(access_secure_data(user))
except PermissionError as e:
    print(e)

Input/Output Modification

Allow modifying arguments passed to a function and results returned by the function.

def uppercase_output(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result.upper()
    return wrapper

@uppercase_output
def greet(name):
    return f"Hello, {name}"

print(greet("world"))

Caching Results

Speed up function execution by remembering results for already computed arguments.

def cache(func):
    storage = {}
    def wrapper(*args):
        if args in storage:
            return storage[args]
        result = func(*args)
        storage[args] = result
        return result
    return wrapper

@cache
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))

Access Control

Can restrict access to functions, e.g., based on time (call limits).

import time

def rate_limit(func):
    last_called = [0]  # We use a list to store a variable in a closure

    def wrapper(*args, **kwargs):
        now = time.time()
        if now - last_called[0] < 1:  # Limits calls to 1 per second
            raise RuntimeError("Function called too frequently")
        last_called[0] = now
        return func(*args, **kwargs)
    return wrapper

@rate_limit
def do_something():
    print("Function executed")

try:
    do_something()
    time.sleep(0.5)
    do_something()
except RuntimeError as e:
    print(e)

time.sleep(1)
do_something()

line_profiler

This tool profiles code line by line. It is particularly useful for precise analysis of the execution time of individual lines of code. With it, you can identify specific lines of code that are the most expensive in terms of execution time.

memory_profiler

Allows precise monitoring of memory usage during program execution, which is essential for identifying memory management issues and optimizing performance.

Py-Spy

Enables monitoring CPU usage by the application and identifying hotspots, i.e., code fragments that consume the most CPU resources. It is a useful tool for performance diagnostics and identifying bottlenecks in the application.

__getitem__(self, key)

This method is called when trying to access a container element using the indexing operator []. It accepts one argument, which is the key or index used to access the element.

class MyList:
    def __init__(self, data):
        self.data = data

    def __getitem__(self, index):
        return self.data[index]

my_list = MyList([1, 2, 3, 4, 5])
print(my_list[2])  # Displays: 3

__setitem__(self, key, value)

This method is called when trying to assign a value to a container element using the indexing operator []. It accepts two arguments: the key or index and the value to be assigned.

class MyList:
    def __init__(self, data):
        self.data = data

    def __setitem__(self, index, value):
        self.data[index] = value

my_list = MyList([1, 2, 3, 4, 5])
my_list[2] = 10
print(my_list.data)  # Displays: [1, 2, 10, 4, 5]

__delitem__(self, key)

This method is called when we try to remove an element from the container using the del operator and indexing []. It accepts only one argument: the key or index of the element we want to remove.

class MyList:
def __init__(self, data):
    self.data = data

def __delitem__(self, index):
    del self.data[index]

my_list = MyList([1, 2, 3, 4, 5])
del my_list[2]
print(my_list.data)  # Displays: [1, 2, 4, 5]

How do regular expressions work?

Regular expressions describe patterns of characters that are used to search and manipulate texts. They can contain special characters as well as ordinary characters that define what patterns are matched in the text.

Most commonly used functions in the re module

re.search(pattern, string, flags=0): Searches for the first match of the pattern in the entire text.

import re
result = re.search(r'is', 'This is a test string.')
print(result)
# <re.Match object; span=(2, 4), match='is'>

re.match(pattern, string, flags=0): Checks if the pattern matches the beginning of the text.

import re
result = re.match(r'This', 'This is a test string.')
print(result)
# <re.Match object; span=(0, 4), match='This'>

re.findall(pattern, string, flags=0): Finds all matches of the pattern in the text and returns a list of results.

import re
result = re.findall(r'd+', 'There are 10 apples and 20 oranges.')
print(result) # ['10', '20']

re.sub(pattern, repl, string, count=0, flags=0): Replaces all occurrences of the pattern in the text with a given string.

import re
result = re.sub(r's+', '_', 'This is a test string.')
print(result) # This_is_a_test_string.

Procedural approach

In the procedural approach, the program is structurally organized around procedures (functions) that perform specific tasks on data. The code is sequential and executed from top to bottom. The main features of the procedural approach are:

Procedures: The basic elements are procedures (functions) that perform specific tasks on data.

Global variables: Data is usually stored as global variables accessible to procedures.

Simple data structures: Simple data structures such as lists, tuples, dictionaries, etc., are used.

Simplicity: An approach that is easy to understand and apply in small projects.

def count_sum(a, b):
    return a + b

a = 10
b = 20
sum = count_sum(a, b)
print(sum)

Object-oriented approach

In the object-oriented approach, the program is organized around objects, which are instances of classes. These objects store data (attributes) and methods (functions) that can operate on these data. The main features of the object-oriented approach are:

Classes and objects: The code is organized around classes that define the structure and behavior of objects.

Encapsulation: Classes can hide their internal implementations, and access to data can be controlled through accessor methods (getter and setter).

Inheritance: Classes can inherit features and methods from other classes.

PolymorphismObjects of different classes can be treated uniformly, allowing the same operations to be performed on different types of data.

class Calculator:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def count_sum(self):
        return self.a + self.b

calculator = Calculator(10, 20)
sum = calculator.count_sum()
print(sum)

Functional approach

In the functional approach, the program is organized around functions that are treated as first-class objects. These functions can be passed as arguments to other functions, returned as values from functions, and stored as variables. The main features of the functional approach are:

First-class functions: Functions can be assigned to variables, passed as arguments, and returned as values.

Statelessness: Functions do not have an internal state and operate only on their arguments.

Avoiding side effects: Strives to avoid side effects, meaning functions should not modify data outside their scope.

Recursion: Often uses recursion for iteration and data processing.

Advantages of using @property

Access control: Allows controlling access to class attributes, enabling defining custom actions when reading and writing attribute values.

Encapsulation: Helps in encapsulating data, meaning that the internal implementation of attributes can be hidden, and safe access can be provided.

Interface customization: Enables defining the class interface in a more understandable and user-friendly way.

Easy to understand and maintain: Helps in creating more understandable and flexible code that is easier to maintain and extend in the future.

Some of the most commonly used functions from the itertools module

itertools.chain(*iterables): The chain function combines multiple iterable objects into one long iterator.

import itertools

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
chain = itertools.chain(list1, list2)

for element in chain:
    print(element)

itertools.cycle(iterable): The cycle function creates an infinite iterator that repeatedly cycles through elements from the given iterable object.

import itertools

cycle = itertools.cycle([1, 2, 3])

for _ in range(5):
    print(next(cycle))

itertools.count(start=0, step=1): The count function creates an infinite iterator that generates numbers starting from the start value with a specified step.

import itertools

counter = itertools.count(start=1, step=2)

for _ in range(5):
    print(next(counter))

itertools.product(*iterables, repeat=1): The product function creates an iterator containing Cartesian products of elements from the given iterable objects.

import itertools

products = itertools.product('AB', repeat=2)

for product in products:
    print(product)

itertools.permutations(iterable, r=None): The permutations function generates all possible permutations of elements from the given iterable object.

import itertools

perms = itertools.permutations([1, 2, 3], 2)

for perm in perms:
    print(perm)

itertools.groupby(iterable, key=None): The groupby function groups elements from a given iterable based on a key, which is a function that specifies the grouping key.

import itertools

data = [('a', 1), ('b', 2), ('a', 3), ('b', 4)]
groups = itertools.groupby(data, key=lambda x: x[0])

for key, group in groups:
    print(key, list(group))