Introduction
Bienvenue dans le laboratoire sur les fonctions intégrées (built-in functions) de Python. L'interpréteur Python fournit un ensemble riche de fonctions et de types toujours disponibles, sans nécessiter aucune importation (import). Ces fonctions sont les éléments fondamentaux pour effectuer des tâches courantes, allant de la manipulation de données aux opérations d'entrée/sortie (I/O).
Dans ce laboratoire, vous acquerrez une expérience pratique avec certaines des fonctions intégrées les plus essentielles, classées en groupes logiques. À la fin de ce laboratoire, vous maîtriserez l'utilisation de ces fonctions pour écrire un code Python plus efficace et plus lisible.
Conversion et Inspection des Types de Données
Dans cette étape, vous apprendrez à effectuer des conversions entre différents types de données et à inspecter des objets en utilisant des fonctions telles que int(), str(), list(), dict(), type() et isinstance(). Ces fonctions sont fondamentales pour la manipulation des données en Python.
Note: Si vous n'êtes pas familier avec l'utilisation de l'environnement WebIDE (similaire à VS Code), veuillez vous familiariser avec celui-ci en suivant ce laboratoire.
Tout d'abord, ouvrez le fichier step1_conversion.py depuis l'explorateur de fichiers situé à gauche. Nous allons écrire notre code dans ce fichier.
Ajoutez le code suivant dans step1_conversion.py. Ce code démontre comment convertir une chaîne de caractères (string) en entier (integer), un tuple en liste (list), et une liste de paires en dictionnaire (dictionary). Il montre également comment vérifier le type d'un objet.
## step1_conversion.py
## int(): Retourne un objet entier à partir d'un nombre ou d'une chaîne de caractères.
num_str = "123"
num_int = int(num_str)
print(f"Chaîne '{num_str}' convertie en entier : {num_int}")
## str(): Retourne la version chaîne de caractères d'un objet.
int_val = 456
str_val = str(int_val)
print(f"Entier {int_val} converti en chaîne : '{str_val}'")
## list(): Crée une nouvelle liste à partir d'un itérable.
my_tuple = ('a', 'b', 'c')
my_list = list(my_tuple)
print(f"Tuple {my_tuple} converti en liste : {my_list}")
## dict(): Crée un nouveau dictionnaire.
my_pairs = [('x', 1), ('y', 2)]
my_dict = dict(my_pairs)
print(f"Liste de paires {my_pairs} convertie en dict : {my_dict}")
## type(): Retourne le type d'un objet.
print(f"Type de num_int : {type(num_int)}")
## isinstance(): Retourne True si l'objet est une instance d'une classe spécifiée.
is_list = isinstance(my_list, list)
print(f"my_list est-il une instance de list ? {is_list}")
Maintenant, enregistrez le fichier et exécutez-le depuis le terminal.
python3 step1_conversion.py
Vous devriez voir la sortie suivante, qui confirme que les conversions et les inspections de types de données ont réussi.
String '123' as integer: 123
Integer 456 as string: '456'
Tuple ('a', 'b', 'c') as list: ['a', 'b', 'c']
List of pairs [('x', 1), ('y', 2)] as dict: {'x': 1, 'y': 2}
Type of num_int: <class 'int'>
Is my_list an instance of list? True
Opérations Mathématiques et Numériques
Dans cette étape, vous effectuerez des calculs mathématiques courants en utilisant des fonctions intégrées. Nous couvrirons abs(), sum(), min(), max(), round() et pow().
Ouvrez le fichier step2_math.py dans l'explorateur de fichiers.
Ajoutez le code suivant à step2_math.py. Ce script démontre comment appliquer diverses fonctions mathématiques à des nombres et à des listes de nombres.
## step2_math.py
numbers = [5, -10, 15, -2, 8]
## abs(): Retourne la valeur absolue d'un nombre.
print(f"Absolute value of -10: {abs(-10)}")
## sum(): Calcule la somme des éléments d'un itérable.
print(f"Sum of numbers {numbers}: {sum(numbers)}")
## min(): Retourne l'élément le plus petit dans un itérable.
print(f"Minimum of numbers: {min(numbers)}")
## max(): Retourne l'élément le plus grand dans un itérable.
print(f"Maximum of numbers: {max(numbers)}")
## round(): Retourne un nombre arrondi à une précision donnée.
pi_approx = 3.14159
print(f"Rounding {pi_approx} to 2 decimal places: {round(pi_approx, 2)}")
## pow(): Retourne la base élevée à la puissance de l'exposant (base ** exp).
print(f"2 to the power of 3: {pow(2, 3)}")
Enregistrez le fichier et exécutez-le dans le terminal.
python3 step2_math.py
La sortie devrait afficher les résultats de chaque opération mathématique.
Absolute value of -10: 10
Sum of numbers [5, -10, 15, -2, 8]: 16
Minimum of numbers: -10
Maximum of numbers: 15
Rounding 3.14159 to 2 decimal places: 3.14
2 to the power of 3: 8
Manipulation des Séquences et des Itérables
Dans cette étape, vous apprendrez à manipuler et à traiter des séquences telles que les listes (lists) et les tuples. Nous couvrirons len(), sorted(), reversed(), enumerate(), map(), filter() et zip(). Beaucoup de ces fonctions retournent des itérateurs (iterators), qui sont des objets efficaces économisant de la mémoire.
Ouvrez le fichier step3_sequences.py.
Ajoutez le code suivant à step3_sequences.py. Ce script démontrera comment obtenir la longueur d'une liste, la trier, l'inverser, et effectuer des transformations plus complexes en utilisant map, filter et zip.
## step3_sequences.py
my_list = [3, 1, 4, 1, 5, 9]
print(f"Original list: {my_list}")
## len(): Retourne la longueur (le nombre d'éléments) d'un objet.
print(f"Length of the list: {len(my_list)}")
## sorted(): Retourne une nouvelle liste triée à partir des éléments de l'itérable.
print(f"Sorted list: {sorted(my_list)}")
## reversed(): Retourne un itérateur inversé. Nous le convertissons en liste pour l'afficher.
print(f"Reversed list: {list(reversed(my_list))}")
## enumerate(): Retourne un objet énuméré (itérateur de paires index, valeur).
print(f"Enumerated list: {list(enumerate(my_list))}")
## map(): Retourne un itérateur qui applique une fonction à chaque élément de l'itérable.
squared_numbers = map(lambda x: x*x, my_list)
print(f"Squared numbers (map): {list(squared_numbers)}")
## filter(): Construit un itérateur à partir des éléments de l'itérable pour lesquels une fonction retourne vrai.
even_numbers = filter(lambda x: x % 2 == 0, my_list)
print(f"Even numbers (filter): {list(even_numbers)}")
## zip(): Itère sur plusieurs itérables en parallèle.
list_a = ['a', 'b', 'c']
list_b = [1, 2, 3]
zipped = zip(list_a, list_b)
print(f"Zipped lists: {list(zipped)}")
Enregistrez le fichier et exécutez-le.
python3 step3_sequences.py
Vous verrez la sortie des différentes opérations sur les séquences. Notez comment les fonctions comme reversed, map, filter et zip retournent des itérateurs, que nous convertissons en listes en utilisant list() pour afficher leur contenu.
Original list: [3, 1, 4, 1, 5, 9]
Length of the list: 6
Sorted list: [1, 1, 3, 4, 5, 9]
Reversed list: [9, 5, 1, 4, 1, 3]
Enumerated list: [(0, 3), (1, 1), (2, 4), (3, 1), (4, 5), (5, 9)]
Squared numbers (map): [9, 1, 16, 1, 25, 81]
Even numbers (filter): [4]
Zipped lists: [('a', 1), ('b', 2), ('c', 3)]
Entrée/Sortie et Représentation d'Objets
Dans cette étape, vous allez gérer les opérations de base d'entrée/sortie (Input/Output - I/O) et contrôler comment les objets sont représentés sous forme de chaînes de caractères (strings). Nous nous concentrerons sur print(), open(), repr() et format(). Nous mentionnerons brièvement input().
Ouvrez le fichier step4_io.py.
La fonction input() lit une ligne depuis la console, la convertit en chaîne de caractères et la retourne. Par exemple : name = input("Enter your name: "). Nous ne l'utiliserons pas dans notre script pour éviter de suspendre l'exécution, mais c'est une fonction cruciale à connaître.
Maintenant, ajoutez le code suivant à step4_io.py. Ce script écrira dans un fichier, lira à partir de celui-ci, et démontrera différentes manières de représenter et de formater des objets sous forme de chaînes.
## step4_io.py
import datetime
## open(): Ouvre un fichier et retourne un objet fichier correspondant.
## Nous utilisons une instruction 'with' pour garantir que le fichier est automatiquement fermé.
file_path = "/home/labex/project/my_file.txt"
with open(file_path, "w") as f:
f.write("Hello, LabEx!\n")
f.write("This is a test file.")
print(f"Successfully wrote to {file_path}")
## Lecture depuis le fichier
with open(file_path, "r") as f:
content = f.read()
print("--- File Content ---")
print(content)
print("--------------------")
## repr(): Retourne une chaîne contenant une représentation imprimable et non ambiguë d'un objet.
now = datetime.datetime(2023, 10, 27, 10, 30, 0)
print(f"str(now): {str(now)}")
print(f"repr(now): {repr(now)}")
## format(): Convertit une valeur en une représentation "formatée".
formatted_string = format(123.4567, ".2f")
print(f"Formatted number (123.4567 to .2f): {formatted_string}")
Enregistrez le fichier et exécutez-le depuis le terminal.
python3 step4_io.py
Le script créera et écrira dans my_file.txt, le lira à nouveau, et affichera le contenu. Il montre également la différence entre str() et repr() pour un objet datetime et démontre le formatage des nombres.
Successfully wrote to /home/labex/project/my_file.txt
--- File Content ---
Hello, LabEx!
This is a test file.
--------------------
str(now): 2023-10-27 10:30:00
repr(now): datetime.datetime(2023, 10, 27, 10, 30)
Formatted number (123.4567 to .2f): 123.46
Introspection et Métaprogrammation d'Objets
Dans cette dernière étape, vous explorerez des fonctions avancées pour interagir avec les attributs et les espaces de noms (namespaces) des objets. Ceci est souvent appelé introspection ou réflexion (reflection). Nous utiliserons getattr(), hasattr(), setattr(), dir(), globals() et locals().
Ouvrez le fichier step5_introspection.py.
Nous allons définir une classe simple, puis utiliser les fonctions d'introspection pour inspecter et modifier dynamiquement ses instances. Ajoutez le code suivant à step5_introspection.py.
## step5_introspection.py
class Person:
species = "Homo sapiens"
def __init__(self, name, age):
self.name = name
self.age = age
p = Person("Alice", 30)
## hasattr(): Retourne True si l'objet possède l'attribut nommé.
print(f"Does person have 'name' attribute? {hasattr(p, 'name')}")
print(f"Does person have 'height' attribute? {hasattr(p, 'height')}")
## setattr(): C'est l'équivalent de getattr(). Il définit un attribut sur un objet.
print("Setting attribute 'height' to 175...")
setattr(p, 'height', 175)
print(f"Does person have 'height' attribute now? {hasattr(p, 'height')}")
## getattr(): Retourne la valeur de l'attribut nommé d'un objet.
print(f"Person's name: {getattr(p, 'name')}")
print(f"Person's height: {getattr(p, 'height')}")
## dir(): Retourne la liste des noms dans la portée locale actuelle ou les attributs d'un objet.
## Nous vérifions si 'height' est maintenant dans la liste des attributs.
print(f"Is 'height' in dir(p)? {'height' in dir(p)}")
## globals(): Retourne un dictionnaire de la table des symboles globale actuelle.
## Nous allons vérifier si notre classe 'Person' est dans globals.
print(f"Is 'Person' in globals? {'Person' in globals().keys()}")
## locals(): Retourne un dictionnaire de la table des symboles locale actuelle.
def a_func():
x = 10
print(f"Is 'x' in locals()? {'x' in locals().keys()}")
a_func()
Enregistrez le fichier et exécutez-le.
python3 step5_introspection.py
La sortie démontre comment vous pouvez vérifier, définir et obtenir dynamiquement les attributs d'un objet en utilisant leurs noms sous forme de chaînes de caractères. Elle montre également comment inspecter les attributs d'un objet et les variables disponibles dans les portées globale et locale.
Does person have 'name' attribute? True
Does person have 'height' attribute? False
Setting attribute 'height' to 175...
Does person have 'height' attribute now? True
Person's name: Alice
Person's height: 175
Is 'height' in dir(p)? True
Is 'Person' in globals? True
Is 'x' in locals()? True
Résumé
Félicitations pour avoir terminé ce laboratoire ! Vous avez acquis une expérience pratique avec un large éventail de fonctions intégrées (built-in functions) essentielles de Python.
Dans ce laboratoire, vous avez appris à :
- Convertir entre les types de données et inspecter les objets (
int,str,type,isinstance). - Effectuer des opérations mathématiques courantes (
abs,sum,min,max,round). - Manipuler et traiter les séquences et les itérables (
len,sorted,map,filter,zip). - Gérer les opérations de base d'entrée/sortie de fichiers (I/O) et la représentation des objets sous forme de chaînes (
open,repr,format). - Inspecter et modifier dynamiquement les objets et les espaces de noms (
hasattr,getattr,setattr,dir).
Ces fonctions sont fondamentales dans la programmation Python quotidienne. Les maîtriser améliorera considérablement l'efficacité et la lisibilité de votre code. Continuez à explorer d'autres fonctions intégrées et entraînez-vous à les utiliser dans vos propres projets.
