129 lines
4.6 KiB
Org Mode
129 lines
4.6 KiB
Org Mode
:PROPERTIES:
|
|
:ID: b9f392bd-bd45-4e9e-94ec-b19caedff86f
|
|
:mtime: 20220501143116
|
|
:ctime: 20220430122532
|
|
:END:
|
|
#+title: List vs tuple
|
|
#+filetags: :Optimisation:Python:
|
|
|
|
* Points communs
|
|
/list/ et /tuple/ sont des données de type /sequence/ :
|
|
* L'ordre d'insertion des données est conservé (/ordered sets/),
|
|
* Support des fonctions de concaténation, répétition, indexation et /slicing/,
|
|
* Stockage de données hétérogèes (généralement homogènes)/
|
|
|
|
* Différences
|
|
* Syntaxe ([] pour /list/, () pour /tuple/),
|
|
* La /list/ est /mutable/, le /tuple/ /immutable/ (ne peut être modifié une fois créé),
|
|
|
|
** Empreinte RAM
|
|
* Le /tuple/ requiert moins de RAM :
|
|
|
|
#+BEGIN_SRC python :results output
|
|
from sys import getsizeof
|
|
from typing import List, Tuple
|
|
|
|
|
|
def print_list_tuple_comparison(list_: List, tuple_: Tuple) -> None:
|
|
list_size = getsizeof(list_)
|
|
tuple_size = getsizeof(tuple_)
|
|
diff = list_size - tuple_size
|
|
print(f"Number of elements: {len(list_)}, list size: {list_size:<3}, tuple size: {tuple_size:<3}, diff: {diff} bytes ({diff/list_size*100:.2f}%)")
|
|
|
|
|
|
def print_list_tuple_ram_footprint(elements_nb: int) -> None:
|
|
list_ = []
|
|
tuple_ = ()
|
|
|
|
print_list_tuple_comparison(list_, tuple_)
|
|
|
|
for i in range(1, elements_nb + 1):
|
|
list_.append(i)
|
|
tuple_ = tuple(range(1, i + 1))
|
|
|
|
print_list_tuple_comparison(list_, tuple_)
|
|
|
|
|
|
print_list_tuple_ram_footprint(10)
|
|
#+END_SRC
|
|
#+RESULTS:
|
|
: Number of elements: 0, list size: 56 , tuple size: 40 , diff: 16 bytes (28.57%)
|
|
: Number of elements: 1, list size: 88 , tuple size: 48 , diff: 40 bytes (45.45%)
|
|
: Number of elements: 2, list size: 88 , tuple size: 56 , diff: 32 bytes (36.36%)
|
|
: Number of elements: 3, list size: 88 , tuple size: 64 , diff: 24 bytes (27.27%)
|
|
: Number of elements: 4, list size: 88 , tuple size: 72 , diff: 16 bytes (18.18%)
|
|
: Number of elements: 5, list size: 120, tuple size: 80 , diff: 40 bytes (33.33%)
|
|
: Number of elements: 6, list size: 120, tuple size: 88 , diff: 32 bytes (26.67%)
|
|
: Number of elements: 7, list size: 120, tuple size: 96 , diff: 24 bytes (20.00%)
|
|
: Number of elements: 8, list size: 120, tuple size: 104, diff: 16 bytes (13.33%)
|
|
: Number of elements: 9, list size: 184, tuple size: 112, diff: 72 bytes (39.13%)
|
|
: Number of elements: 10, list size: 184, tuple size: 120, diff: 64 bytes (34.78%)
|
|
|
|
** Temps de création
|
|
Le /tuple/ est plus rapide à créé que la /list/:
|
|
#+BEGIN_SRC python :results output
|
|
from timeit import timeit
|
|
|
|
tuple_elapsed_time = timeit("(1,2,3,4,5,6,7,8,9,10)", number=10_000_000)
|
|
list_elapsed_time = timeit("[1,2,3,4,5,6,7,8,9,10]", number=10_000_000)
|
|
|
|
print(f'Time needed to create a list of 10 ints 10_000_000 times: {list_elapsed_time}')
|
|
print(f'Time needed to create a tuple of 10 ints 10_000_000 times: {tuple_elapsed_time} ({(list_elapsed_time - tuple_elapsed_time) / list_elapsed_time * 100:.2f}% faster)')
|
|
#+END_SRC
|
|
|
|
#+RESULTS:
|
|
: Time needed to create a list of 10 ints 10_000_000 times: 0.6825288010004442
|
|
: Time needed to create a tuple of 10 ints 10_000_000 times: 0.0716032920172438 (89.51% faster)
|
|
|
|
*** Création d'une liste et accès à un de ses membres
|
|
#+BEGIN_SRC python :results output
|
|
from dis import dis
|
|
|
|
def my_list():
|
|
x = [10, 20, 30, 'abc']
|
|
y = x[0]
|
|
|
|
dis(my_list)
|
|
#+END_SRC
|
|
|
|
#+RESULTS:
|
|
: 4 0 LOAD_CONST 1 (10)
|
|
: 2 LOAD_CONST 2 (20)
|
|
: 4 LOAD_CONST 3 (30)
|
|
: 6 LOAD_CONST 4 ('abc')
|
|
: 8 BUILD_LIST 4
|
|
: 10 STORE_FAST 0 (x)
|
|
:
|
|
: 5 12 LOAD_FAST 0 (x)
|
|
: 14 LOAD_CONST 5 (0)
|
|
: 16 BINARY_SUBSCR
|
|
: 18 STORE_FAST 1 (y)
|
|
: 20 LOAD_CONST 0 (None)
|
|
: 22 RETURN_VALUE
|
|
|
|
*** Création d'un tuple et accès à un de ses membres
|
|
#+BEGIN_SRC python :results output
|
|
from dis import dis
|
|
|
|
def my_tuple():
|
|
x = (10, 20, 30, 'abc')
|
|
y = x[0]
|
|
|
|
dis(my_tuple)
|
|
#+END_SRC
|
|
#+RESULTS:
|
|
: 4 0 LOAD_CONST 1 ((10, 20, 30, 'abc'))
|
|
: 2 STORE_FAST 0 (x)
|
|
:
|
|
: 5 4 LOAD_FAST 0 (x)
|
|
: 6 LOAD_CONST 2 (0)
|
|
: 8 BINARY_SUBSCR
|
|
: 10 STORE_FAST 1 (y)
|
|
: 12 LOAD_CONST 0 (None)
|
|
: 14 RETURN_VALUE
|
|
|
|
La création d'un /tuple/ est plus rapide du fait de la [[id:26e1fdfb-1f8e-4c62-a08f-468a56ab03c8][Python peephole optimization]].
|
|
|
|
* Références
|
|
* [[https://pub.towardsai.net/python-list-vs-tuple-an-in-depth-comparison-42c59348d8a8][Python List Vs. Tuple: An In-Depth Comparison - Medium]]
|