Es ist üblich, eine Liste zu einem Tupel zu machen und umgekehrt.
Es ist üblich, die integrierten Funktionen "Liste" und "Tupel" zu verwenden.
l = [0, 1, 2]
t = tuple(l)
print(t)
(0, 1, 2)
Wenn die Liste jedoch verschachtelt ist, wird nur auf die flachste Hierarchie getippt.
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)Ich möchte, dass Du
([0, 1, 2], [3, 4, 5, 6, 7], 8, 9)
Es ist scharf.
Machen wir es zu einem Full-Level-Taple, während wir es rekursiv aufrufen.
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)
Ich habs gemacht.
Eigentlich ist dieser Artikel [hier](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% AElist% E3% 82% 92tuple% E3% 81% AB% E5% A4% 89% E6% 8F% 9B% E3% 81% 97% E3% 81% 9F% E3% 81% 84 /) Pakuri. ~~ Ist es dir nicht peinlich ~~
Der Unterschied besteht darin, dass der Teil, der die for-Anweisung und den Zuweisungsoperator dort verwendet hat, jetzt enthalten ist.
Für Aussagen, die sich ehrlich wiederholen, ruft die Einschlussnotation einen dedizierten Prozess auf, der die Ausführungszeit verkürzt (Referenz).
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)
Es ist ungefähr 100 mal schneller. Es ist eine große Niederlage für eingebaute Funktionen.
Recommended Posts