Funzioni in Python

Funzioni in Python

Funzioni in Python

Versione italiana

Le funzioni sono uno degli strumenti più potenti in Python per organizzare il codice, evitare ripetizioni e rendere il programma più modulare. Ecco una spiegazione dettagliata delle cose che hai menzionato:

---

Definizione e chiamata di funzioni (def)

1. Definizione:

   • Una funzione viene definita usando la parola chiave def, seguita dal nome della funzione e da parentesi tonde ().
   • Esempio:

     def saluta():
         print("Ciao, mondo!")
     

2. Chiamata:

   • Per eseguire una funzione, devi chiamarla usando il suo nome seguito da parentesi tonde ().
   • Esempio:

     saluta()  # Output: Ciao, mondo!
     

---

Parametri e argomenti

1. Parametri posizionali e keyword:

   • Parametri posizionali: gli argomenti vengono passati in base alla posizione.
   • Parametri keyword: gli argomenti vengono passati specificando il nome del parametro.

   Esempio:

   def somma(a, b):
       return a + b
   
   # Parametri posizionali
   risultato = somma(3, 5)  # Output: 8
   
   # Parametri keyword
   risultato = somma(b=5, a=3)  # Output: 8
   

2. Parametri predefiniti:

   • Puoi assegnare valori predefiniti ai parametri. Se non viene passato un argomento, viene usato il valore predefinito.
   • Esempio:

     def saluta(nome="Mario"):
         print(f"Ciao, {nome}!")
     
     saluta()           # Output: Ciao, Mario!
     saluta("Luigi")    # Output: Ciao, Luigi!
     

---

Valori di ritorno (return)

1. return:

   • Restituisce un valore dalla funzione. Se non viene specificato, la funzione restituisce None.
   • Esempio:

     def quadrato(x):
         return x * x
     
     risultato = quadrato(4)  # Output: 16
     

2. Funzioni senza return:

   • Se una funzione non ha un'istruzione return, restituisce implicitamente None.
   • Esempio:

     def saluta():
         print("Ciao!")
     
     risultato = saluta()  # Output: Ciao!
     print(risultato)      # Output: None
     

---

Funzioni lambda (anonime)

1. Funzioni lambda:

   • Sono funzioni anonime (senza nome) definite con la parola chiave lambda.
   • Sono utili per operazioni semplici e brevi.
   • Sintassi: lambda parametri: espressione

   Esempio:

   quadrato = lambda x: x * x
   print(quadrato(5))  # Output: 25
   

   Possono essere usate direttamente come argomenti di altre funzioni, ad esempio con map() o filter():

   numeri = [1, 2, 3, 4]
   quadrati = list(map(lambda x: x * x, numeri))
   print(quadrati)  # Output: [1, 4, 9, 16]
   

---

Scope delle variabili (locale, globale)

1. Variabili locali:

   • Sono definite all'interno di una funzione e non sono accessibili al di fuori di essa.
   • Esempio:

     def funzione():
         x = 10  # Variabile locale
         print(x)
     
     funzione()  # Output: 10
     # print(x)  # Errore: x non è definita fuori dalla funzione
     

2. Variabili globali:

   • Sono definite al di fuori di qualsiasi funzione e sono accessibili ovunque.
   • Per modificare una variabile globale all'interno di una funzione, devi usare la parola chiave global.
   • Esempio:

     x = 10  # Variabile globale
     
     def funzione():
         global x
         x = 20  # Modifica la variabile globale
     
     funzione()
     print(x)  # Output: 20
     

---

Decoratori (introduzione)

1. Decoratori:

   • Sono funzioni che modificano il comportamento di altre funzioni.
   • Sono spesso usati per aggiungere funzionalità (es. logging, controllo degli accessi) senza modificare il codice originale.
   • Un decoratore prende una funzione come argomento e restituisce una nuova funzione.

   Esempio:

   def mio_decoratore(func):
       def wrapper():
           print("Qualcosa prima della funzione")
           func()
           print("Qualcosa dopo la funzione")
       return wrapper
   
   @mio_decoratore
   def saluta():
       print("Ciao!")
   
   saluta()
   # Output:
   # Qualcosa prima della funzione
   # Ciao!
   # Qualcosa dopo la funzione
   

   In questo esempio, @mio_decoratore applica il decoratore alla funzione saluta.

English version

Functions in Python

Functions are one of the most powerful tools in Python to organize your code, avoid repetition, and make your program more modular. Here is a detailed explanation of the things you mentioned:

---

Defining and calling functions (def)

1. Definition:

• A function is defined using the keyword def, followed by the name of the function and parentheses ().
• Example:

def sayhello():
print("Hello, world!")

2. Call:

• To execute a function, you must call it using its name followed by parentheses ().
• Example:

sayhello() # Output: Hello, world!

---

Parameters and arguments

1. Positional parameters and keywords:

• Positional parameters: arguments are passed by position.
• Keyword parameters: arguments are passed by specifying the parameter name.

Example:

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

# Positional parameters
result = sum(3, 5) # Output: 8

# Keyword parameters
result = sum(b=5, a=3) # Output: 8

2. Default parameters:

• You can assign default values ​​to parameters. If no argument is given, the default value is used.
• Example:

def greet(name="Mario"):
print(f"Hello, {name}!")

greet() # Output: Hello, Mario!
greet("Luigi") # Output: Hello, Luigi!

---

Return Values ​​(return)

1. return:

• Returns a value from the function. If not specified, the function returns None.
• Example:

def square(x):
return x * x

result = square(4) # Output: 16

2. Functions without return:

• If a function does not have a return statement, it implicitly returns None.
• Example:

def greet():
print("Hello!")

result = greet() # Output: Hello!
print(result) # Output: None

---

Lambda Functions (Anonymous)

1. Lambda Functions:

• These are anonymous (unnamed) functions defined with the lambda keyword.
• They are useful for simple and short operations.
• Syntax: lambda parameters: expression

Example:

square = lambda x: x * x
print(square(5)) # Output: 25

They can be used directly as arguments to other functions, for example with map() or filter():

numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x * x, numbers))
print(squares) # Output: [1, 4, 9, 16]

---

Variable scope (local, global)

1. Local variables:

• They are defined inside a function and are not accessible outside it.
• Example:

def function():
x = 10 # Local variable
print(x)

function() # Output: 10
# print(x) # Error: x is not defined outside the function

2. Global variables:

• They are defined outside any function and are accessible everywhere.
• To modify a global variable inside a function, you must use the global keyword.
• Example:

x = 10 # Global variable

def function():
global x
x = 20 # Modify the global variable

function()
print(x) # Output: 20

---

Decorators (introduction)

1. Decorators:

• These are functions that modify the behavior of other functions.
• They are often used to add functionality (e.g. logging, access control) without modifying the original code.
• A decorator takes a function as an argument and returns a new function.

Example:

def my_decorator(func):
def wrapper():
print("Something before the function")
func()
print("Something after the function")
return wrapper

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

greet()
# Output:
# Something before the function
# Hello!
# Something after the function

In this example, @my_decorator applies the decorator to the function greet.