Contenu du cours

Techniques d'Optimisation en Python

1. Comprendre et Mesurer la Performance

Introduction à la Performance de Python Notions de Base sur le Chronométrage et le Benchmarking Mesurer la Performance des Fonctions Défi : Mise en Œuvre du Benchmarking

2. Utilisation Efficace des Structures de Données

Listes et Tableaux NumPy Ensembles et Tuples Défi : Choisir des Structures de Données Optimales Utilisation du Module Collections Défi : Gestion des Demandes des Clients

3. Améliorer les Performances avec des Outils Intégrés

Tirer Parti de map() et des Compréhensions de Liste Gestion des Fichiers Volumineux Maximiser l'Efficacité du Tri Opérations de Chaîne Efficaces

Ensembles et Tuples

Avant de passer aux ensembles et aux tuples, il est important de mentionner que nous ne discuterons pas des dictionnaires ici.

Ensemble

Un ensemble offre une complexité temporelle moyenne de O(1) pour les insertions, suppressions et recherches, ce qui signifie que ces opérations sont effectuées en temps constant, quelle que soit la taille de l'ensemble. Cela rend les ensembles beaucoup plus rapides que les listes pour les tests d'appartenance et les opérations comme l'ajout ou la suppression d'éléments, où les listes nécessitent une complexité temporelle de O(n) (le temps augmente linéairement avec la taille de la liste) dans le pire des cas.

Quand utiliser :

Vous avez besoin d'éléments uniques, garantissant qu'il n'y a pas de doublons dans votre collection ;
Un test d'appartenance rapide est requis, ce qui rend les ensembles idéaux pour des tâches comme vérifier l'existence d'un élément ;
Vous effectuez des opérations telles que unions, intersections ou différences d'ensembles, que les ensembles prennent en charge avec des méthodes optimisées ;
L'ordre n'a pas d'importance, car les ensembles sont intrinsèquement non ordonnés et il n'est pas nécessaire de maintenir l'ordre d'insertion.


              1234567891011121314151617181920
            
# Removing duplicates from a list using a set
numbers = [1, 3, 2, 3, 5, 4, 5]
unique_numbers = set(numbers)
print(f'Unique Numbers: {unique_numbers}')

# Fast membership testing
names = {'Alice', 'Bob', 'Charlie'}
print(f'Is Alice in the set? {"Alice" in names}')
print(f'Is Eve in the set? {"Eve" in names}')

# Set operations: union, intersection, and difference
set_a = {1, 4, 3, 2}
set_b = {3, 5, 4, 6}
print(f'Union: {set_a.union(set_b)}')
print(f'Intersection: {set_a.intersection(set_b)}')
print(f'Difference: {set_a.difference(set_b)}')

# Removing elements from a set safely with discard
names.discard('Alice')  # Safe removal, no error if the element doesn't exist
print(f'Names after removal: {names}')

Comparons maintenant les performances d'un ensemble à une liste dans le test d'appartenance :


              12345678910111213141516171819
            
import os
os.system('wget https://content-media-cdn.codefinity.com/courses/8d21890f-d960-4129-bc88-096e24211d53/section_1/chapter_3/decorators.py 2>/dev/null')
from decorators import timeit_decorator

# Create a large list and set with the same elements
large_list = list(range(10000000))
large_set = set(large_list)

# Test membership for an element at the end
element_to_find = 9999999

@timeit_decorator(number=50)
def test_membership(element, collection):
    return element in collection

print('List:')
print(test_membership(element_to_find, large_list))
print('Set:')
print(test_membership(element_to_find, large_set))

Tuple

Les tuples sont généralement utilisés lorsque vous devez vous assurer que les données ne peuvent pas être modifiées ou comme clé dans un dict ou élément dans un set (car les tuples sont hachables).

Mieux que les listes : lorsque vous avez besoin de données immuables, souhaitez utiliser la collection comme clé de dictionnaire ou élément de set, ou lorsque vous avez besoin d'un stockage mémoire efficace pour une collection d'éléments de taille fixe ;
Mieux que les tableaux NumPy : lorsque vos données sont non numériques ou lorsque l'immuabilité est cruciale. Bien que les tableaux NumPy soient conçus pour les calculs numériques et soient mutables par défaut, les tuples offrent une sécurité pour les données non numériques ou les petites collections structurées qui doivent rester constantes.


              12345678
            
# Each tuple in the list represents an immutable student record
students = [
    (1834, 'James', 'Johnson'),
    (2749, 'Alice', 'Smith'),
    (4923, 'Bob', 'Brown')
]
# Attempting to modify a tuple will raise a TypeError
students[0][1] = 'Fred'

Étant donné que la liste students contient des enregistrements d'étudiants (ID, prénom, nom de famille) qui doivent être en lecture seule, il est préférable d'utiliser des tuples pour chaque enregistrement au lieu de listes. De plus, comme mentionné ci-dessus, les tuples sont légèrement plus efficaces en mémoire par rapport aux listes.

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 2

Techniques d'Optimisation en Python

Ensembles et Tuples

Ensemble

Tuple

1. Lequel des scénarios suivants est le mieux adapté pour utiliser un ensemble au lieu d'une liste ?

2. Vous avez un ensemble de données avec des millions d'enregistrements et vous devez fréquemment vérifier si des valeurs spécifiques existent à l'intérieur. Quelle structure de données est la plus efficace pour cet objectif ?

3. Vous créez un enregistrement pour chaque étudiant qui inclut un identifiant unique, un prénom et un nom de famille. Les données ne doivent pas être modifiées une fois créées. Quelle structure de données serait la plus appropriée ?