En Python 3, les modules sont des fichiers qui contiennent des fonctions et d’autres objets Python. Les modules peuvent être importés dans d’autres programmes pour réutiliser les fonctions et les objets qu’ils contiennent. Les modules sont utiles pour organiser et réutiliser le code dans des projets Python plus importants.

Voici un exemple simple de module qui contient une fonction pour calculer la factorielle d’un nombre :

# Module "factorial.py" 
def factorial(n): 
     if n == 0: 
         return 1 
else: 
     return n * factorial(n-1)

Dans cet exemple, le module « factorial.py » contient une fonction « factorial » qui calcule la factorielle d’un nombre. Pour utiliser cette fonction, vous pouvez importer le module et l’appeler avec un argument :

# Programme principal 
import factorial 
result = factorial.factorial(5) 
print(result) # Affiche 120 

Dans cet exemple, le module « factorial.py » est importé avec la commande « import factorial« . La fonction « factorial » est appelée avec l’argument 5, et le résultat est assigné à la variable « result« .

Les modules peuvent également être importés de manière sélective avec la commande « from … import« . Cette commande permet d’importer uniquement les objets spécifiques d’un module que vous souhaitez utiliser :

# Programme principal 
from factorial import factorial 
result = factorial(5) 
print(result) # Affiche 120

Dans cet exemple, seule la fonction « factorial » est importée du module « factorial.py » avec la commande « from factorial import factorial« . La fonction « factorial » est ensuite appelée avec l’argument 5, et le résultat est assigné à la variable « result« .

Voici quelques astuces et points clés à retenir sur les modules en Python 3 :

1. Les modules peuvent contenir des fonctions, des classes, des constantes et d’autres objets Python.
2. Les modules peuvent être importés dans d’autres programmes pour réutiliser les fonctions et les objets qu’ils contiennent.
3. Les modules peuvent être importés de manière sélective avec la commande « from … import« .
4. Les modules standard de Python sont stockés dans le répertoire d’installation de Python.
5. Les modules tiers peuvent être installés à l’aide du gestionnaire de paquets « pip« .

Voici quelques exemples d’utilisation de modules couramment utilisés en Python :

1. Le module « math » contient des fonctions mathématiques comme « sqrt() » pour calculer la racine carrée d’un nombre, « sin() » pour calculer le sinus d’un angle, etc.

import math 
# Utilisation de la fonction mathématique sqrt() pour calculer la racine carrée de 2 
result = math.sqrt(2) print(result) # Affiche 1.4142135623730951

2. Le module « os » permet d’interagir avec le système d’exploitation, par exemple pour accéder aux fichiers et dossiers, changer de répertoire, créer des fichiers, etc.

import os 
# Affichage du répertoire de travail courant 
print(os.getcwd()) 
# Changement de répertoire 
os.chdir("/path/to/new/directory") # Liste des fichiers dans un répertoire 
print(os.listdir("/path/to/directory")) # Création d'un dossier os

Dans cet exemple, le module « os » est importé avec la commande « import os« . L’appel à « os.getcwd() » permet d’obtenir le répertoire de travail courant. L’appel à « os.chdir() » permet de changer le répertoire de travail. L’appel à « os.listdir() » permet de lister les fichiers d’un répertoire. L’appel à « os.mkdir() » permet de créer un nouveau dossier.

3. Le module « socket » permet de créer des connexions de réseau entre des ordinateurs, par exemple pour communiquer via des sockets TCP ou UDP.

import socket 
# Création d'un socket TCP 
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
# Connexion à un serveur distant 
sock.connect(('localhost', 1234)) 
# Envoi de données 
sock.send(b"Hello, world!") 
# Réception de données 
data = sock.recv(1024) 
# Fermeture du socket 
sock.close()

Dans cet exemple, le module « socket » est importé avec la commande « import socket« . Un socket TCP est créé avec la commande « socket.socket()« . Une connexion est établie avec un serveur distant avec la commande « sock.connect()« . Des données sont envoyées avec la commande « sock.send()« . Des données sont reçues avec la commande « sock.recv()« . Enfin, le socket est fermé avec la commande « sock.close()« .

En somme, les modules en Python 3 sont des fichiers qui contiennent des fonctions et d’autres objets Python. Les modules peuvent être importés dans d’autres programmes pour réutiliser les fonctions et les objets qu’ils contiennent, et peuvent être importés de manière sélective avec la commande « from … import« . Les modules standard de Python sont stockés dans le répertoire d’installation de Python, et les modules tiers peuvent être installés à l’aide du gestionnaire de paquets « pip« . Les modules couramment utilisés en Python incluent « math » pour les fonctions mathématiques, « os » pour interagir avec le système d’exploitation, et « socket » pour créer des connexions de réseau.

L’article Python, importer des modules et les utiliser est apparu en premier sur La programmation sur le web.

En Python 3, les classes sont des modèles qui définissent la structure et le comportement d’un objet. Les classes permettent de regrouper des variables et des fonctions associées en un seul objet, ce qui facilite la réutilisation du code et la modularité.

Pour définir une classe en Python 3, on utilise le mot-clé class, suivi du nom de la classe. Par convention, le nom de la classe doit commencer par une majuscule. Voici un exemple simple de classe en Python 3 :

class Personne: 
      def __init__(self, nom, age): 
           self.nom = nom 
           self.age = age 
     def presenter(self): 
           print(f"Je m'appelle {self.nom} et j'ai {self.age} ans.")

Dans cet exemple, la classe Personne est définie avec deux attributs (nom et age) et une méthode (presenter). La méthode __init__ est un constructeur qui est appelé lorsqu’un nouvel objet est créé à partir de la classe. La méthode presenter est une méthode qui affiche une présentation de la personne.

Pour créer un objet à partir de la classe, on utilise l’opérateur new. Dans la plupart des cas, on utilise plutôt une notation plus simple pour créer un objet à partir d’une classe, en utilisant des parenthèses après le nom de la classe. Par exemple :

personne1 = Personne("Jean", 30) 
personne2 = Personne("Marie", 25)

Dans cet exemple, personne1 et personne2 sont des objets créés à partir de la classe Personne. L’opérateur self est utilisé pour se référer à l’objet courant dans la classe.

Pour accéder aux attributs d’un objet, on utilise la notation pointée. Par exemple :

print(personne1.nom) # affiche "Jean" 
print(personne2.age) # affiche 25

Pour appeler une méthode sur un objet, on utilise également la notation pointée. Par exemple :

1:	personne1.presenter() # affiche "Je m'appelle Jean et j'ai 30 ans." 
2:	personne2.presenter() # affiche "Je m'appelle Marie et j'ai 25 ans."

En somme, les classes en Python 3 permettent de définir des modèles de données et de comportement pour les objets. Les objets créés à partir d’une classe sont des instances spécifiques de cette classe, qui ont leurs propres attributs et méthodes. Les classes offrent des fonctionnalités avancées telles que l’héritage et le polymorphisme, qui permettent une réutilisation de code plus efficace et une meilleure modularité.

En Python 3, les classes offrent des fonctionnalités avancées telles que l’héritage et le polymorphisme. L’héritage permet à une classe d’hériter les attributs et les méthodes d’une classe parent, ce qui permet de réutiliser du code de manière efficace. Le polymorphisme permet de traiter des objets de classes différentes de manière interchangeable, ce qui facilite la modularité.

La notion d’héritage permet de définir une classe enfant qui hérite des attributs et des méthodes d’une classe parent. Pour définir une classe enfant, on utilise le mot-clé class, suivi du nom de la classe enfant, et entre parenthèses, le nom de la classe parent. Voici un exemple simple de classe enfant en Python 3 :

class Etudiant(Personne): 
     def __init__(self, nom, age, niveau): 
         super().__init__(nom, age) 
         self.niveau = niveau 
     def presenter(self): 
         print(f"Je m'appelle {self.nom}, j'ai {self.age} ans et je suis en {self.niveau} année.")

Dans cet exemple, la classe Etudiant est une classe enfant de la classe Personne. La méthode __init__ de la classe enfant utilise la méthode __init__ de la classe parent en utilisant la fonction super(). La méthode presenter de la classe enfant remplace la méthode presenter de la classe parent.

La portabilité des classes en Python 3 est un autre avantage. Les classes peuvent être facilement importées et exportées entre différents fichiers Python, ce qui facilite la modularité et la réutilisation du code. En utilisant des classes, les développeurs peuvent organiser leur code de manière plus structurée et lisible.

En somme, les classes en Python 3 permettent de définir des modèles de données et de comportement pour les objets, et offrent des fonctionnalités avancées telles que l’héritage et le polymorphisme. La portabilité des classes en Python 3 facilite la modularité et la réutilisation du code. Les classes en Python 3 sont un élément clé de la programmation orientée objet.

L’article Python, les classes et leur utilisation est apparu en premier sur La programmation sur le web.