Python offre une large gamme de fonctions intégrées comme print(), len(), type() ou encore sum(). Ces fonctions permettent de réaliser des opérations courantes sans définir de nouvelles fonctions.
Exemples:
Une fonction sans paramètre exécute toujours les mêmes instructions :
Une fonction avec paramètres peut être personnalisée selon les valeurs passées :
Les paramètres peuvent avoir des valeurs par défaut :
Les fonctions peuvent être assignées à des variables pour être utilisées plus tard :
Une fonction peut accepter un nombre variable d’arguments :
Les types immuables comme les nombres ou les chaînes ne peuvent pas être modifiés dans une fonction, alors que les types mutables comme les listes peuvent l’être.
Les fonctions anonymes, appelées “lambda” en Python, sont des fonctions définies sans utiliser le mot-clé def. Elles permettent de créer des fonctions courtes, généralement en une seule ligne.
Une fonction lambda suit cette syntaxe :
Exemple :
Les fonctions lambda sont souvent utilisées lorsqu’une fonction temporaire ou rapide est nécessaire. Voici quelques cas d’usage pratique :
map()La fonction map() applique une fonction donnée à chaque élément d’un itérable (comme une liste).
nombres = [1, 2, 3, 4, 5]
carres = list(map(lambda x: x ** 2, nombres))
print(carres) # Affiche : [1, 4, 9, 16, 25]filter()La fonction filter() retourne les éléments d’un itérable qui satisfont une condition.
nombres = [1, 2, 3, 4, 5]
nombres_pairs = list(filter(lambda x: x % 2 == 0, nombres))
print(nombres_pairs) # Affiche : [2, 4]sorted()Les fonctions lambda sont souvent utilisées pour trier des listes selon des critères spécifiques.
Les fonctions lambda sont utiles pour des cas simples, mais elles ne remplacent pas les fonctions définies avec def, surtout pour des tâches complexes.
def :lambda avec reduce()La fonction reduce() applique une fonction de cumul à une séquence, réduisant ainsi cette séquence à une seule valeur.
from functools import reduce
nombres = [1, 2, 3, 4]
somme = reduce(lambda x, y: x + y, nombres)
print(somme) # Affiche : 10Les fonctions lambda peuvent être utilisées dans des dictionnaires pour effectuer des calculs conditionnels.
def pour améliorer la lisibilité.map() pour calculer le carré de chaque élément d’une liste, puis la somme des carrés avec reduce().filter() pour trouver tous les mots contenant plus de 3 lettres dans une liste de mots.sorted() pour trier la liste par prix.Un module est un fichier contenant du code Python (fonctions, classes, variables) que vous pouvez réutiliser dans d’autres fichiers. L’utilisation de modules permet de structurer un projet et d’encapsuler des fonctionnalités spécifiques dans des fichiers distincts.
Exemple :
Créez un fichier nommé mon_module.py avec le contenu suivant :
Dans un autre fichier, vous pouvez importer et utiliser ce module :
Il existe plusieurs façons d’importer un module ou ses éléments :
Python fournit une bibliothèque standard riche avec des modules pour diverses tâches :
import datetime
aujourdhui = datetime.date.today()
print(aujourdhui) # Affiche la date d'aujourd'huiUn projet Python peut contenir plusieurs fichiers et répertoires pour organiser le code.
Structure d’exemple :
mon_projet/
|-- main.py
|-- utilitaires.py
|-- data/
|-- __init__.py
|-- traitement.pyDans le fichier main.py, vous pouvez importer les modules comme suit :
Un package est un répertoire contenant plusieurs modules, généralement accompagné d’un fichier __init__.py.
Exemple de structure de package :
mon_package/
|-- __init__.py
|-- module1.py
|-- module2.pyVous pouvez importer des éléments d’un package comme suit :
La programmation orientée objet (POO) est un paradigme de programmation basé sur le concept de “classes” et “objets”, qui permet de structurer le code de manière modulaire et réutilisable.
Voici un exemple de classe simple représentant une “Personne” :
class Personne:
def __init__(self, nom, age):
self.nom = nom
self.age = age
def se_presenter(self):
return f"Je m'appelle {self.nom} et j'ai {self.age} ans."
# Instanciation d'objets
personne1 = Personne("Alice", 30)
personne2 = Personne("Bob", 25)
# Utilisation
print(personne1.se_presenter()) # Affiche : Je m'appelle Alice et j'ai 30 ans.
print(personne2.se_presenter()) # Affiche : Je m'appelle Bob et j'ai 25 ans.Une classe peut contenir des attributs qui sont eux-mêmes des objets :
class Adresse:
def __init__(self, rue, ville):
self.rue = rue
self.ville = ville
class Personne:
def __init__(self, nom, age, adresse):
self.nom = nom
self.age = age
self.adresse = adresse
def afficher_adresse(self):
return f"{self.adresse.rue}, {self.adresse.ville}"
adresse = Adresse("123 Rue Principale", "Paris")
personne = Personne("Alice", 30, adresse)
print(personne.afficher_adresse()) # Affiche : 123 Rue Principale, ParisL’héritage permet à une classe d’hériter des attributs et des méthodes d’une autre classe. Cela favorise la réutilisation du code.
class Animal:
def __init__(self, nom):
self.nom = nom
def parler(self):
pass # Méthode à redéfinir
class Chien(Animal):
def parler(self):
return "Woof"
class Chat(Animal):
def parler(self):
return "Meow"
chien = Chien("Rex")
chat = Chat("Miaou")
print(chien.parler()) # Affiche : Woof
print(chat.parler()) # Affiche : MeowLe polymorphisme permet d’utiliser une même méthode définie dans plusieurs classes différentes.
L’encapsulation permet de contrôler l’accès et la modification des attributs d’une classe. Cela se fait généralement à l’aide des propriétés.
class CompteBancaire:
def __init__(self, titulaire, solde):
self.titulaire = titulaire
self.__solde = solde # Attribut privé
@property
def solde(self):
return self.__solde
@solde.setter
def solde(self, montant):
if montant >= 0:
self.__solde = montant
else:
raise ValueError("Le solde ne peut pas être négatif")
compte = CompteBancaire("Alice", 1000)
print(compte.solde) # Accès au solde
compte.solde = 2000 # Modification du solde
print(compte.solde) # Affiche : 2000L’abstraction consiste à définir des classes ou des méthodes génériques qui servent de base pour les classes spécifiques. Cela se fait avec des classes ou méthodes abstraites.
from abc import ABC, abstractmethod
class Forme(ABC):
@abstractmethod
def aire(self):
pass
class Rectangle(Forme):
def __init__(self, largeur, hauteur):
self.largeur = largeur
self.hauteur = hauteur
def aire(self):
return self.largeur * self.hauteur
rectangle = Rectangle(10, 5)
print(rectangle.aire()) # Affiche : 50Livre :
titre, auteur, pages.afficher_informations qui affiche les détails du livre.Bibliotheque :
Vehicule.Voiture, Moto avec des méthodes spécifiques comme afficher_type.Forme :
aire et perimetre.Cercle et Rectangle.