Python Developer - zaawansowane pytania i zadania rekrutacyjne

Tworzenie Obiektów

List Comprehensions: Tworzą pełną listę w pamięci. Oznacza to, że wszystkie elementy są generowane od razu i przechowywane w pamięci.

Generator Expressions: Tworzą generator, który produkuje elementy na bieżąco, jeden po drugim, gdy są potrzebne. Nie tworzy pełnej listy w pamięci.

Zarządzanie Pamięcią

List Comprehensions: Może być mniej wydajne, jeśli lista jest duża, ponieważ cała lista jest przechowywana w pamięci.

Generator Expressions: Bardziej efektywne pamięciowo, ponieważ elementy są generowane 'leniwie' (lazy evaluation) i nie są przechowywane wszystkie naraz w pamięci.

Czas Wykonania

List Comprehensions: Mają tendencję do bycia szybszymi, jeśli potrzebujesz przetworzyć wszystkie elementy, ponieważ cała lista jest dostępna od razu.

Generator Expressions: Mogą być wolniejsze w przetwarzaniu wszystkich elementów, ponieważ elementy są generowane na żądanie, co dodaje narzut czasowy dla każdej operacji 'next'.

Kiedy wykorzystywać

List Comprehensions: Są idealne, gdy potrzebujesz dostępu do wszystkich elementów naraz lub gdy wynikowa lista ma być użyta wielokrotnie.

Generator Expressions: Są lepsze, gdy pracujesz z dużymi zbiorami danych lub strumieniami danych, których nie można załadować w całości do pamięci lub gdy chcesz przetworzyć elementy tylko raz.

Przydzielanie pamięci

Kiedy tworzysz nowy obiekt (np. liczbę, listę, słownik), Python automatycznie przydziela dla niego pamięć. Nie musisz się martwić o zarządzanie tą pamięcią ręcznie.

Zwalnianie pamięci

Gdy obiekt nie jest już potrzebny (czyli nie ma żadnej zmiennej, która by się do niego odwoływała), pamięć, którą zajmował, powinna być zwolniona, aby mogła być użyta przez inne obiekty.

Garbage Collection

Zbieranie Śmieci Garbage collection to mechanizm, który automatycznie zwalnia pamięć zajmowaną przez obiekty, które nie są już używane. W Pythonie działa to na dwa główne sposoby

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())}")

Logowanie i monitorowanie

Umożliwiają śledzenie wywołań funkcji, co jest przydatne przy debugowaniu i monitorowaniu działania aplikacji.

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()

Autoryzacja i uwierzytelnianie

Mogą sprawdzić, czy użytkownik ma odpowiednie uprawnienia przed wykonaniem określonej funkcji.

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)

Modyfikacja wejścia/wyjścia

Pozwalają na modyfikowanie argumentów przekazywanych do funkcji oraz wyników zwracanych przez funkcję.

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"))

Cachowanie wyników

Przyspieszają działanie funkcji przez zapamiętywanie wyników dla już obliczonych argumentów.

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))

Kontrola dostępu

Mogą ograniczać dostęp do funkcji, np. ze względu na czas (limity wywołań).

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

To narzędzie do profilowania kodu linia po linii. Jest to szczególnie przydatne narzędzie do dokładnej analizy czasu wykonania poszczególnych linii kodu. Dzięki niemu możesz zidentyfikować konkretne linie kodu, które są najbardziej kosztowne pod względem czasu wykonania.

memory_profiler

Pozwala dokładnie monitorować zużycie pamięci w trakcie wykonywania programu, co jest niezbędne do identyfikacji problemów związanych z zarządzaniem pamięcią i optymalizacją wydajności.

Py-Spy

Umożliwia monitorowanie zużycia procesora przez aplikację oraz identyfikowanie gorących punktów, czyli fragmentów kodu, które zużywają najwięcej zasobów procesora. Jest to przydatne narzędzie do diagnostyki wydajnościowej i identyfikacji wąskich gardeł w aplikacji.

__getitem__(self, key)

Metoda ta jest wywoływana, gdy próbujemy uzyskać dostęp do elementu kontenera za pomocą operatora indeksowania []. Akceptuje ona jeden argument, którym jest klucz lub indeks, za pomocą którego chcemy uzyskać dostęp do elementu.

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)

Metoda ta jest wywoływana, gdy próbujemy przypisać wartość do elementu kontenera za pomocą operatora indeksowania []. Akceptuje dwa argumenty: klucz lub indeks oraz wartość, którą chcemy przypisać.

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)

Metoda ta jest wywoływana, gdy próbujemy usunąć element z kontenera za pomocą operatora del i indeksowania []. Akceptuje tylko jeden argument: klucz lub indeks elementu, który chcemy usunąć.

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]

Jak działają wyrażenia regularne?

Wyrażenia regularne opisują wzorce znaków, które są używane do wyszukiwania i manipulowania tekstami. Mogą zawierać specjalne znaki oraz zwykłe znaki, które definiują, jakie wzorce są dopasowywane w tekście.

Najczęściej używane funkcje w module re

re.search(pattern, string, flags=0): Szuka pierwszego dopasowania wzorca w całym tekście.

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): Sprawdza, czy wzorzec pasuje do początku tekstu.

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): Znajduje wszystkie dopasowania wzorca w tekście i zwraca listę wyników.

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): Zastępuje wszystkie wystąpienia wzorca w tekście danym łańcuchem.

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

Podejście proceduralne

W podejściu proceduralnym program jest strukturalnie zorganizowany wokół procedur (funkcji), które wykonują konkretne zadania na danych. Kod jest sekwencyjny i wykonywany od góry do dołu. Główne cechy podejścia proceduralnego to:

Procedury: Podstawowymi elementami są procedury (funkcje), które wykonują konkretne zadania na danych.

Zmienne globalne: Dane są zwykle przechowywane jako zmienne globalne, do których procedury mają dostęp.

Proste struktury danych: Używane są proste struktury danych, takie jak listy, krotki, słowniki itp.

Prostota: Podejście, które jest łatwe do zrozumienia i stosowania w małych projektach.

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

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

Podejście obiektowe

W podejściu obiektowym program jest zorganizowany wokół obiektów, które są instancjami klas. Obiekty te przechowują dane (atrybuty) i metody (funkcje), które mogą operować na tych danych. Główne cechy podejścia obiektowego to:

Klasy i obiekty: Kod jest zorganizowany wokół klas, które definiują strukturę i zachowanie obiektów.

Hermetyzacja: Klasy mogą ukrywać swoje wewnętrzne implementacje, a dostęp do danych może być kontrolowany przez metody dostępowe (getter i setter).

Dziedziczenie: Klasy mogą dziedziczyć cechy i metody po innych klasach.

PolimorfizmObiekty różnych klas mogą być traktowane jednolicie, co umożliwia wykonywanie tych samych operacji na różnych typach danych.

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)

Podejście funkcyjne

W podejściu funkcyjnym program jest zorganizowany wokół funkcji, które są traktowane jako pierwszorzędne obiekty. Funkcje te mogą być przekazywane jako argumenty do innych funkcji, zwracane jako wartości z funkcji i przechowywane jako zmienne. Główne cechy podejścia funkcyjnego to:

Funkcje pierwszego rzędu: Funkcje mogą być przypisywane do zmiennych, przekazywane jako argumenty i zwracane jako wartości.

Bezstanowość: Funkcje nie mają stanu wewnętrznego i operują tylko na swoich argumentach.

Unikanie efektów ubocznych: Stara się unikać efektów ubocznych, co oznacza, że funkcje nie powinny modyfikować danych poza swoim zakresem.

Rekurencja: Często używa rekurencji do iteracji i przetwarzania danych.

Zalety używania @property

Kontrola dostępu: Pozwala na kontrolowanie dostępu do atrybutów klasy, umożliwiając definiowanie niestandardowych działań podczas odczytu i zapisu wartości atrybutu.

Enkapsulacja: Pomaga w enkapsulacji danych, co oznacza, że można ukryć wewnętrzną implementację atrybutów i zapewnić bezpieczny dostęp do nich.

Dostosowanie interfejsu: Umożliwia definiowanie interfejsu klasy w sposób bardziej zrozumiały i przyjazny dla użytkownika.

Łatwa do zrozumienia i utrzymania: Pomaga w tworzeniu bardziej zrozumiałego i elastycznego kodu, który jest łatwiejszy do utrzymania i rozszerzania w przyszłości.

Kilka najczęściej używanych funkcji z modułu itertools

itertools.chain(*iterables): Funkcja chain łączy wiele iterowalnych obiektów w jeden długi 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): Funkcja cycle tworzy nieskończony iterator, który cyklicznie powtarza elementy z danego iterowalnego obiektu.

import itertools

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

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

itertools.count(start=0, step=1): Funkcja count tworzy nieskończony iterator, który generuje liczby zaczynając od wartości start z określonym krokiem step.

import itertools

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

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

itertools.product(*iterables, repeat=1): Funkcja product tworzy iterator zawierający iloczyny kartezjańskie elementów z podanych iterowalnych obiektów.

import itertools

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

for product in products:
    print(product)

itertools.permutations(iterable, r=None): Funkcja permutations generuje wszystkie możliwe permutacje elementów z danego iterowalnego obiektu.

import itertools

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

for perm in perms:
    print(perm)

itertools.groupby(iterable, key=None): Funkcja groupby grupuje elementy z danego iterowalnego obiektu na podstawie klucza, który jest funkcją określającą klucz grupowania.

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))