def — créer une fonction
Une fonction est un bloc de code réutilisable. On la définit avec def :
def saluer(nom):
print(f"Bonjour {nom} !")
saluer("Alice") # Bonjour Alice !
saluer("Bob") # Bonjour Bob !Le mot-clé return permet à la fonction de renvoyer une valeur :
def additionner(a, b):
return a + b
resultat = additionner(3, 5)
print(resultat) # 8Rappel : l'indentation (4 espaces) définit le corps de la fonction. Tout ce qui est indenté après def fait partie de la fonction.
Paramètres par défaut
On peut donner une valeur par défaut à un paramètre :
def saluer(nom, langue="fr"):
if langue == "fr":
print(f"Bonjour {nom} !")
else:
print(f"Hello {nom}!")
saluer("Alice") # Bonjour Alice !
saluer("Bob", "en") # Hello Bob!
saluer("Charlie", langue="en") # Hello Charlie!Les paramètres avec défaut doivent être après les paramètres obligatoires.
*args et **kwargs — paramètres flexibles
*args accepte un nombre variable d'arguments :
def moyenne(*notes):
return sum(notes) / len(notes)
print(moyenne(15, 12, 18)) # 15.0
print(moyenne(10, 20, 14, 16)) # 15.0**kwargs accepte des arguments nommés (comme un dictionnaire) :
def creer_profil(**infos):
for cle, valeur in infos.items():
print(f"{cle}: {valeur}")
creer_profil(nom="Alice", age=25, ville="Paris")Résultat :
nom: Alice
age: 25
ville: ParisFonctions lambda
Une lambda est une fonction anonyme en une ligne :
# Fonction classique
def doubler(x):
return x * 2
# Même chose en lambda
doubler = lambda x: x * 2
print(doubler(5)) # 10
# Utile pour le tri
utilisateurs = [("Alice", 25), ("Bob", 30), ("Charlie", 20)]
utilisateurs.sort(key=lambda u: u[1])
print(utilisateurs)
# [('Charlie', 20), ('Alice', 25), ('Bob', 30)]Fonctions built-in utiles
Python fournit des dizaines de fonctions prêtes à l'emploi :
# len, range, enumerate
fruits = ["pomme", "banane", "cerise"]
print(len(fruits)) # 3
for i, fruit in enumerate(fruits):
print(f"{i}: {fruit}")
# 0: pomme
# 1: banane
# 2: cerise
# zip — combiner des listes
noms = ["Alice", "Bob"]
ages = [25, 30]
for nom, age in zip(noms, ages):
print(f"{nom} a {age} ans")
# Alice a 25 ans
# Bob a 30 ans
# map et filter
nombres = [1, 2, 3, 4, 5]
doubles = list(map(lambda x: x * 2, nombres))
pairs = list(filter(lambda x: x % 2 == 0, nombres))
print(doubles) # [2, 4, 6, 8, 10]
print(pairs) # [2, 4]def — creating a function
A function is a reusable block of code. Define one with def:
def greet(name):
print(f"Hello {name}!")
greet("Alice") # Hello Alice!
greet("Bob") # Hello Bob!The return keyword lets the function send back a value:
def add(a, b):
return a + b
result = add(3, 5)
print(result) # 8Reminder: indentation (4 spaces) defines the function body. Everything indented after def is part of the function.
Default parameters
You can give a parameter a default value:
def greet(name, language="en"):
if language == "en":
print(f"Hello {name}!")
else:
print(f"Bonjour {name} !")
greet("Alice") # Hello Alice!
greet("Bob", "fr") # Bonjour Bob !
greet("Charlie", language="fr") # Bonjour Charlie !Parameters with defaults must come after required parameters.
*args and **kwargs — flexible parameters
*args accepts a variable number of arguments:
def average(*grades):
return sum(grades) / len(grades)
print(average(15, 12, 18)) # 15.0
print(average(10, 20, 14, 16)) # 15.0**kwargs accepts named arguments (like a dictionary):
def create_profile(**info):
for key, value in info.items():
print(f"{key}: {value}")
create_profile(name="Alice", age=25, city="Paris")Result:
name: Alice
age: 25
city: ParisLambda functions
A lambda is an anonymous one-line function:
# Regular function
def double(x):
return x * 2
# Same thing as lambda
double = lambda x: x * 2
print(double(5)) # 10
# Useful for sorting
users = [("Alice", 25), ("Bob", 30), ("Charlie", 20)]
users.sort(key=lambda u: u[1])
print(users)
# [('Charlie', 20), ('Alice', 25), ('Bob', 30)]Useful built-in functions
Python provides dozens of ready-to-use functions:
# len, range, enumerate
fruits = ["apple", "banana", "cherry"]
print(len(fruits)) # 3
for i, fruit in enumerate(fruits):
print(f"{i}: {fruit}")
# 0: apple
# 1: banana
# 2: cherry
# zip — combine lists
names = ["Alice", "Bob"]
ages = [25, 30]
for name, age in zip(names, ages):
print(f"{name} is {age} years old")
# Alice is 25 years old
# Bob is 30 years old
# map and filter
numbers = [1, 2, 3, 4, 5]
doubles = list(map(lambda x: x * 2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(doubles) # [2, 4, 6, 8, 10]
print(evens) # [2, 4]Copiez ce prompt dans Claude ou ChatGPT :
Écris une fonction Python qui prend une liste de nombres et renvoie un dictionnaire avec la moyenne, le minimum, le maximum et la médiane. Utilise *args pour accepter les nombres directement.
*args dans une définition de fonction ?enumerate(["a", "b", "c"]) ?