Funcții

O funcție este un bloc de cod reutilizabil care efectuează o anumită operație. Funcțiile permit organizarea codului în unități logice și evită repetarea aceluiași cod.

Definirea funcțiilor

def nume_functie(parametri):
    """Docstring - descrierea funcției"""
    # corp funcție
    return rezultat

def - cuvântul cheie care începe definirea funcției
nume_functie - numele pe care îl dai funcției
parametri - valorile de intrare (opționale)
return - valoarea pe care funcția o returnează (opțional)

Funcție simplă

def salut():
    print("Salut!")

salut()  # apelare

Funcție cu parametri

Parametrii sunt variabile care primesc valori când apelezi funcția:

def salut(nume):
    print(f"Salut, {nume}!")

salut("Ana")   # Salut, Ana!
salut("Ion")   # Salut, Ion!

Funcție cu valoare returnată

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

rezultat = aduna(3, 5)
print(rezultat)  # 8

Parametri și argumente

Parametrii sunt variabilele din definirea funcției, argumentele sunt valorile pe care le trimiți când o apelezi.

Parametri poziționali

Ordinea argumentelor contează:

def prezentare(nume, varsta, oras):
    print(f"{nume}, {varsta} ani, din {oras}")

prezentare("Ana", 25, "București")

Parametri cu valori implicite

Poți defini valori default pentru parametri:

def salut(nume, mesaj="Bună ziua"):
    print(f"{mesaj}, {nume}!")

salut("Ana")                    # Bună ziua, Ana!
salut("Ion", "Salutare")        # Salutare, Ion!

Argumente keyword

Poți specifica explicit ce parametru primește ce valoare:

def prezentare(nume, varsta, oras):
    print(f"{nume}, {varsta} ani, din {oras}")

prezentare(oras="Cluj", nume="Ana", varsta=25)

`*args` - număr variabil de argumente

Când nu știi câte argumente vei primi:

def suma(*numere):
    total = 0
    for n in numere:
        total += n
    return total

print(suma(1, 2))           # 3
print(suma(1, 2, 3, 4, 5))  # 15

`**kwargs` - argumente keyword variabile

Pentru a primi oricâte argumente cu nume:

def afiseaza_info(**kwargs):
    for cheie, valoare in kwargs.items():
        print(f"{cheie}: {valoare}")

afiseaza_info(nume="Ana", varsta=25, oras="București")

Valoarea returnată

Return simplu

def patrat(x):
    return x ** 2

print(patrat(5))  # 25

Return multiplu (tuple)

Poți returna mai multe valori simultan:

def operatii(a, b):
    suma = a + b
    diferenta = a - b
    produs = a * b
    return suma, diferenta, produs

s, d, p = operatii(10, 3)
print(s, d, p)  # 13 7 30

Return condiționat

def valoare_absoluta(x):
    if x >= 0:
        return x
    else:
        return -x

Funcții fără return

Returnează implicit None:

def afiseaza(mesaj):
    print(mesaj)

rezultat = afiseaza("Test")
print(rezultat)  # None

Scope (domeniu de vizibilitate)

Scope-ul definește unde poți accesa o variabilă.

Variabile locale

Există doar în interiorul funcției:

def functie():
    x = 10  # variabilă locală
    print(x)

functie()
# print(x)  # Eroare! x nu există în afara funcției

Variabile globale

Definite în afara funcțiilor, accesibile peste tot:

x = 10  # variabilă globală

def functie():
    print(x)  # poate citi variabila globală

functie()  # 10

Modificarea variabilelor globale

Pentru a modifica o variabilă globală din interiorul unei funcții, folosești global:

x = 10

def functie():
    global x
    x = 20

functie()
print(x)  # 20

Funcții lambda

Funcții anonime (fără nume), scurte, definite pe o singură linie:

# Funcție normală
def patrat(x):
    return x ** 2

# Echivalent lambda
patrat = lambda x: x ** 2

print(patrat(5))  # 25

Utilizări comune ale lambda

# Sortare personalizată
elevi = [("Ana", 9), ("Ion", 7), ("Maria", 10)]
elevi_sortati = sorted(elevi, key=lambda x: x[1])
# [('Ion', 7), ('Ana', 9), ('Maria', 10)]

# Cu map - aplică funcția pe fiecare element
numere = [1, 2, 3, 4, 5]
patrate = list(map(lambda x: x**2, numere))
# [1, 4, 9, 16, 25]

# Cu filter - păstrează doar elementele care îndeplinesc condiția
pare = list(filter(lambda x: x % 2 == 0, numere))
# [2, 4]

Funcții recursive

O funcție recursivă este o funcție care se apelează pe sine. Orice funcție recursivă trebuie să aibă:

Un caz de bază - când se oprește recursivitatea
Un pas recursiv - apelul către ea însăși cu o problemă mai mică

Factorial

n! = n × (n-1) × (n-2) × ... × 1

def factorial(n):
    if n <= 1:        # caz de bază
        return 1
    return n * factorial(n - 1)  # pas recursiv

print(factorial(5))  # 120

Fibonacci

Fiecare termen este suma celor două anterioare: 0, 1, 1, 2, 3, 5, 8, 13...

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

print(fibonacci(10))  # 55

Sumă cifre

def suma_cifre(n):
    if n < 10:
        return n
    return n % 10 + suma_cifre(n // 10)

print(suma_cifre(12345))  # 15

Funcții built-in utile

Python vine cu multe funcții deja implementate:

Funcție	Descriere	Exemplu
`len()`	Lungime	`len([1,2,3])` → 3
`sum()`	Sumă	`sum([1,2,3])` → 6
`min()`	Minim	`min([3,1,2])` → 1
`max()`	Maxim	`max([3,1,2])` → 3
`abs()`	Valoare absolută	`abs(-5)` → 5
`round()`	Rotunjire	`round(3.7)` → 4
`sorted()`	Sortare	`sorted([3,1,2])` → [1,2,3]
`reversed()`	Inversare	`list(reversed([1,2,3]))` → [3,2,1]
`enumerate()`	Index + valoare	`list(enumerate(['a','b']))` → [(0,'a'),(1,'b')]
`zip()`	Combinare liste	`list(zip([1,2],['a','b']))` → [(1,'a'),(2,'b')]
`map()`	Aplicare funcție	`list(map(str, [1,2,3]))` → ['1','2','3']
`filter()`	Filtrare	`list(filter(lambda x: x>0, [-1,2,-3,4]))` → [2,4]

Documentarea funcțiilor

Folosești docstrings pentru a documenta ce face funcția:

def calculeaza_media(numere):
    """
    Calculează media aritmetică a unei liste de numere.

    Args:
        numere: Lista de numere pentru care se calculează media.

    Returns:
        Media aritmetică a numerelor sau None dacă lista e goală.

    Example:
        >>> calculeaza_media([1, 2, 3, 4, 5])
        3.0
    """
    if not numere:
        return None
    return sum(numere) / len(numere)

# Accesare documentație
print(calculeaza_media.__doc__)
help(calculeaza_media)

Aplicații practice

Validare input

def citeste_numar_pozitiv(mesaj):
    while True:
        try:
            n = int(input(mesaj))
            if n > 0:
                return n
            print("Numărul trebuie să fie pozitiv!")
        except ValueError:
            print("Introduceți un număr valid!")

varsta = citeste_numar_pozitiv("Vârsta: ")

Verificare număr prim

def este_prim(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

# Generare liste de numere prime
prime = [x for x in range(100) if este_prim(x)]

Calculator simplu

def calculator(a, b, operatie):
    operatii = {
        '+': lambda x, y: x + y,
        '-': lambda x, y: x - y,
        '*': lambda x, y: x * y,
        '/': lambda x, y: x / y if y != 0 else "Eroare: împărțire la zero"
    }
    if operatie in operatii:
        return operatii[operatie](a, b)
    return "Operație necunoscută"

print(calculator(10, 5, '+'))  # 15
print(calculator(10, 5, '/'))  # 2.0