- À propos de sys.getsizeof()
- Connaître la taille d'un objet avec sys.getsizeof()
- Connaître la taille des nombres
- Connaître la taille des chaînes de caractères
- Connaître la taille des listes et des tuples
- Connaître la taille des dictionnaires et des ensembles
- Comparer la taille de plusieurs objets
- Comprendre les limites de sys.getsizeof()
- Calculer récursivement la taille d'un objet composé
- À retenir !
1. À propos de sys.getsizeof()
Le module sys fournit la fonction sys.getsizeof() qui permet d'obtenir la taille occupée en mémoire par un objet Python, exprimée en octets.
Cette fonction est utile pour étudier la représentation mémoire des objets Python, comparer certaines structures de données et mieux comprendre leur consommation de mémoire.
Le programme suivant calcule la taille d'une chaîne de caractères.
1 2 3 4 5 | import sys texte = "Python" taille = sys.getsizeof(texte) print(taille) |
Sortie possible :
1 | 47 |
La valeur exacte peut varier selon la version de Python, son implémentation, l'architecture de la machine et le type de l'objet. Il ne faut donc pas considérer les valeurs numériques présentées dans ce tutoriel comme universelles.
2. Connaître la taille d'un objet avec sys.getsizeof()
La syntaxe générale de sys.getsizeof() est simple : nous passons l'objet dont nous souhaitons connaître la taille en argument.
Le programme suivant calcule la taille de plusieurs objets simples.
1 2 3 4 5 6 7 8 9 | import sys a = 10 b = 3.14 c = True print("Entier :", sys.getsizeof(a)) print("Réel :", sys.getsizeof(b)) print("Booléen :", sys.getsizeof(c)) |
Sortie possible :
1 2 3 | Entier : 28 Réel : 24 Booléen : 28 |
La fonction sys.getsizeof() retourne un entier représentant une taille en octets.
Nous pouvons le vérifier avec la fonction type().
1 2 3 4 | import sys taille = sys.getsizeof("Python") print(type(taille)) |
Sortie :
1 | <class 'int'> |
3. Connaître la taille des nombres
Nous pouvons utiliser sys.getsizeof() pour étudier la taille des objets numériques. En Python, les entiers ne sont pas limités à une taille fixe comme dans de nombreux langages : leur représentation peut grandir lorsque leur valeur nécessite davantage de mémoire.
Le programme suivant compare plusieurs entiers.
1 2 3 4 5 6 7 8 9 | import sys a = 1 b = 1000 c = 10 ** 100 print("a :", sys.getsizeof(a), "octets") print("b :", sys.getsizeof(b), "octets") print("c :", sys.getsizeof(c), "octets") |
Sortie possible :
1 2 3 | a : 28 octets b : 28 octets c : 72 octets |
Nous constatons qu'un entier très grand peut nécessiter davantage de mémoire qu'un petit entier.
Le programme suivant compare maintenant différents types numériques.
1 2 3 4 5 6 7 8 9 | import sys entier = 25 reel = 25.0 complexe = 25 + 3j print("int :", sys.getsizeof(entier)) print("float :", sys.getsizeof(reel)) print("complex :", sys.getsizeof(complexe)) |
Sortie possible :
1 2 3 | int : 28 float : 24 complex : 32 |
Ces résultats correspondent à une implémentation et à un environnement donnés et peuvent donc différer sur une autre installation Python.
4. Connaître la taille des chaînes de caractères
La fonction sys.getsizeof() peut également mesurer la taille d'une chaîne de caractères. Cette taille ne correspond pas simplement au nombre de caractères de la chaîne.
Le programme suivant compare la longueur d'une chaîne avec sa taille en mémoire.
1 2 3 4 5 6 | import sys texte = "Python" print("Nombre de caractères :", len(texte)) print("Taille :", sys.getsizeof(texte), "octets") |
Sortie possible :
1 2 | Nombre de caractères : 6 Taille : 47 octets |
La fonction len() indique ici le nombre de caractères, tandis que sys.getsizeof() retourne la taille de l'objet Python en mémoire.
Nous pouvons comparer des chaînes de longueurs différentes.
1 2 3 4 5 6 7 8 9 | import sys a = "" b = "Python" c = "Python est un langage de programmation" print("a :", sys.getsizeof(a)) print("b :", sys.getsizeof(b)) print("c :", sys.getsizeof(c)) |
Sortie possible :
1 2 3 | a : 41 b : 47 c : 79 |
La taille dépend notamment du contenu de la chaîne et de la manière dont Python représente les caractères en mémoire.
5. Connaître la taille des listes et des tuples
La fonction sys.getsizeof() peut être utilisée sur des structures comme les listes et les tuples. Il faut cependant comprendre que la valeur retournée correspond directement à l'objet conteneur et ne représente pas nécessairement la somme de toute la mémoire utilisée par les objets qu'il référence.
Le programme suivant compare la taille d'une liste et d'un tuple contenant les mêmes références.
1 2 3 4 5 6 7 | import sys liste = [10, 20, 30, 40, 50] tuple_nombres = (10, 20, 30, 40, 50) print("Liste :", sys.getsizeof(liste), "octets") print("Tuple :", sys.getsizeof(tuple_nombres), "octets") |
Sortie possible :
1 2 | Liste : 104 octets Tuple : 80 octets |
Dans cet exemple, le tuple peut occuper moins d'espace directement que la liste. Les valeurs exactes dépendent toutefois de l'implémentation et de la version de Python.
Le programme suivant montre également que la taille directe d'une liste peut évoluer lorsque nous lui ajoutons des éléments.
1 2 3 4 5 6 7 8 9 10 11 | import sys liste = [] print("Liste vide :", sys.getsizeof(liste)) liste.append(10) print("1 élément :", sys.getsizeof(liste)) liste.append(20) print("2 éléments :", sys.getsizeof(liste)) |
Sortie possible :
1 2 3 | Liste vide : 56 1 élément : 88 2 éléments : 88 |
Une liste peut réserver de la capacité supplémentaire afin de permettre l'ajout efficace de nouveaux éléments. Sa taille ne grandit donc pas nécessairement à chaque appel à append().
6. Connaître la taille des dictionnaires et des ensembles
sys.getsizeof() fonctionne également avec les dictionnaires et les ensembles. Ces structures utilisent des organisations internes adaptées à la recherche rapide des éléments.
Le programme suivant calcule la taille directe d'un dictionnaire.
1 2 3 4 5 6 7 8 9 | import sys personne = { "nom": "Younes", "age": 30, "ville": "Oujda" } print("Taille :", sys.getsizeof(personne), "octets") |
Sortie possible :
1 | Taille : 184 octets |
Cette valeur correspond à la taille directe du dictionnaire. Elle ne doit pas être interprétée comme la somme de la mémoire de toutes ses clés et de toutes ses valeurs.
Nous pouvons également comparer directement un ensemble avec une liste contenant les mêmes valeurs.
1 2 3 4 5 6 7 | import sys liste = [1, 2, 3, 4, 5] ensemble = {1, 2, 3, 4, 5} print("Liste :", sys.getsizeof(liste)) print("Ensemble :", sys.getsizeof(ensemble)) |
Sortie possible :
1 2 | Liste : 104 Ensemble : 472 |
Il ne faut pas conclure uniquement à partir de cette taille qu'une structure est meilleure qu'une autre. Une liste et un set n'ont pas les mêmes propriétés ni les mêmes usages.
7. Comparer la taille de plusieurs objets
La fonction sys.getsizeof() permet de comparer rapidement la taille directe de différents objets Python dans un environnement donné.
Le programme suivant compare plusieurs objets vides.
1 2 3 4 5 6 7 8 9 10 11 12 13 | import sys objets = [ [], (), {}, set(), "", 0 ] for objet in objets: print(type(objet).__name__, ":", sys.getsizeof(objet), "octets") |
Sortie possible :
1 2 3 4 5 6 | list : 56 octets tuple : 40 octets dict : 64 octets set : 216 octets str : 41 octets int : 28 octets |
Ces mesures permettent d'observer que chaque type Python possède sa propre représentation interne et donc un certain coût mémoire.
Nous pouvons également comparer plusieurs collections contenant le même nombre de valeurs.
1 2 3 4 5 6 7 8 9 | import sys liste = [1, 2, 3, 4, 5] tuple_nombres = (1, 2, 3, 4, 5) ensemble = {1, 2, 3, 4, 5} print("list :", sys.getsizeof(liste)) print("tuple :", sys.getsizeof(tuple_nombres)) print("set :", sys.getsizeof(ensemble)) |
Sortie possible :
1 2 3 | list : 104 tuple : 80 set : 472 |
8. Comprendre les limites de sys.getsizeof()
Une limitation très importante de sys.getsizeof() est que cette fonction mesure la taille directe de l'objet passé en argument. Pour un conteneur, elle n'additionne pas automatiquement la taille de tous les objets référencés par ce conteneur.
Le programme suivant compare une liste contenant trois chaînes courtes avec une liste contenant trois chaînes beaucoup plus longues.
1 2 3 4 5 6 7 | import sys liste1 = ["a", "b", "c"] liste2 = ["Python" * 100, "Django" * 100, "Java" * 100] print("Liste 1 :", sys.getsizeof(liste1)) print("Liste 2 :", sys.getsizeof(liste2)) |
Sortie possible :
1 2 | Liste 1 : 88 Liste 2 : 88 |
Les deux listes peuvent avoir la même taille directe parce qu'elles contiennent le même nombre de références, même si les chaînes référencées n'occupent pas la même quantité de mémoire.
Pour constater la différence, nous pouvons additionner séparément la taille directe des chaînes contenues dans chaque liste.
1 2 3 4 5 6 7 8 9 10 | import sys liste1 = ["a", "b", "c"] liste2 = ["Python" * 100, "Django" * 100, "Java" * 100] taille1 = sys.getsizeof(liste1) + sum(sys.getsizeof(x) for x in liste1) taille2 = sys.getsizeof(liste2) + sum(sys.getsizeof(x) for x in liste2) print("Liste 1 :", taille1) print("Liste 2 :", taille2) |
Sortie possible :
1 2 | Liste 1 : 214 Liste 2 : 1711 |
Cette addition convient à cet exemple simple, mais elle ne constitue pas une méthode générale de calcul de la mémoire totale. Des objets peuvent être partagés, imbriqués ou contenir des références circulaires.
9. Calculer récursivement la taille d'un objet composé
Pour obtenir une estimation plus complète de la taille d'une structure composée, nous pouvons parcourir récursivement ses éléments. Il faut cependant éviter de compter plusieurs fois le même objet lorsqu'il est référencé à plusieurs endroits.
Le programme suivant définit une fonction taille_totale() qui traite quelques conteneurs courants et mémorise les objets déjà visités grâce à leur identifiant retourné par id().
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | import sys def taille_totale(objet, vus=None): if vus is None: vus = set() identifiant = id(objet) if identifiant in vus: return 0 vus.add(identifiant) taille = sys.getsizeof(objet) if isinstance(objet, dict): taille += sum(taille_totale(cle, vus) + taille_totale(valeur, vus) for cle, valeur in objet.items()) elif isinstance(objet, (list, tuple, set, frozenset)): taille += sum(taille_totale(element, vus) for element in objet) return taille donnees = [10, 20, 30] print("Taille directe :", sys.getsizeof(donnees)) print("Taille estimée :", taille_totale(donnees)) |
Sortie possible :
1 2 | Taille directe : 88 Taille estimée : 172 |
Cette fonction fournit une estimation récursive plus complète pour les types de conteneurs qu'elle prend en charge. Elle ne constitue cependant pas un outil universel de mesure de toute la mémoire réellement consommée par un programme Python.
Le même principe peut être appliqué à une structure imbriquée contenant plusieurs listes.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | import sys def taille_totale(objet, vus=None): if vus is None: vus = set() identifiant = id(objet) if identifiant in vus: return 0 vus.add(identifiant) taille = sys.getsizeof(objet) if isinstance(objet, dict): taille += sum(taille_totale(cle, vus) + taille_totale(valeur, vus) for cle, valeur in objet.items()) elif isinstance(objet, (list, tuple, set, frozenset)): taille += sum(taille_totale(element, vus) for element in objet) return taille donnees = [[1, 2, 3], [4, 5, 6]] print("Taille directe :", sys.getsizeof(donnees)) print("Taille estimée :", taille_totale(donnees)) |
Sortie possible :
1 2 | Taille directe : 72 Taille estimée : 416 |
10. À retenir !
La fonction sys.getsizeof() du module sys permet de connaître la taille directe d'un objet Python en mémoire, exprimée en octets. Elle constitue un outil simple pour observer et comparer la représentation mémoire de différents objets.
- sys.getsizeof(objet) retourne une taille en octets.
- La valeur retournée est un entier de type int.
- La taille d'un objet dépend de son type et de sa représentation interne.
- Les très grands entiers peuvent nécessiter davantage de mémoire que les petits entiers.
- La taille d'une chaîne n'est pas simplement égale au nombre de ses caractères.
- Les listes, tuples, dictionnaires et ensembles ont des représentations mémoire différentes.
- Pour un conteneur, sys.getsizeof() n'additionne pas automatiquement la taille de tous les objets qu'il référence.
- Deux conteneurs de même taille directe peuvent référencer des objets dont les tailles sont très différentes.
- Un parcours récursif peut fournir une estimation plus complète pour certaines structures imbriquées.
- Les valeurs retournées peuvent varier selon la version, l'implémentation de Python et l'architecture utilisée.
Le programme suivant compare la taille directe d'une liste avec la somme de sa taille et de celle de ses éléments. Il illustre la différence entre la taille du conteneur lui-même et une estimation simple incluant ses éléments.
1 2 3 4 5 6 7 8 9 10 | import sys liste = ["Python", "Django", "Java"] taille_liste = sys.getsizeof(liste) taille_elements = sum(sys.getsizeof(element) for element in liste) print("Liste :", taille_liste, "octets") print("Éléments :", taille_elements, "octets") print("Total estimé :", taille_liste + taille_elements, "octets") |
Sortie possible :
1 2 3 | Liste : 88 octets Éléments : 139 octets Total estimé : 227 octets |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
