Il est courant de faire d'une liste un tuple et vice versa.
Une pratique courante consiste à utiliser les fonctions intégrées «list» et «tuple».
l = [0, 1, 2]
t = tuple(l)
print(t)
(0, 1, 2)
Cependant, si la liste est imbriquée, elle ne tapera que sur la hiérarchie la moins profonde.
l = [[0, 1, 2], [3, 4, 5, 6, 7], 8, 9]
t = tuple(l)
print(t) # ((0, 1, 2), (3, 4, 5, 6, 7), 8, 9)je veux que tu sois
([0, 1, 2], [3, 4, 5, 6, 7], 8, 9)
C'est tranchant.
Faisons-en un taple de niveau complet tout en l'appelant récursivement.
def list_to_tuple(l):
return tuple(list_to_tuple(e) if isinstance(e, list) else e for e in l)
l = [[0, 1, 2], [3, 4, 5, 6, 7], 8, 9]
t = list_to_tuple(l)
print(t)
((0, 1, 2), (3, 4, 5, 6, 7), 8, 9)
Je l'ai fait.
En fait, cet article est [ici](https://blog.ttk1.net/2016/05/20/python%E3%81%A7%E5%85%A5%E3%82%8C%E5%AD%90% E6% A7% 8B% E9% 80% A0% E3% 81% Liste AE% E3% 82% 92tuple% E3% 81% AB% E5% A4% 89% E6% 8F% 9B% E3% 81% 97% E3% 81% 9F% E3% 81% 84 /) Pakuri. ~~ N'êtes-vous pas gêné ~~
La différence est que la partie qui utilisait l'instruction for et l'opérateur d'affectation là-bas est désormais incluse.
Pour les déclarations qui se répètent honnêtement, la notation d'inclusion appelle un processus dédié, ce qui raccourcit le temps d'exécution (Référence).
def list_to_tuple_orig(_list):
t = ()
for e in _list:
if isinstance(e,list):
t += (list_to_tuple(e),)
else:
t += (e,)
return t
l = list(range(10000))
%timeit t = list_to_tuple_orig(l)
%timeit t = list_to_tuple(l)
%timeit t = tuple(l)
92.7 ms ± 576 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
877 µs ± 3.31 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
19.6 µs ± 47.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
C'est environ 100 fois plus rapide. C'est une grande défaite pour les fonctions intégrées.
Recommended Posts