Jaka jest różnica między listami a krotkami?

Różnica między listą a krotką

1. Literal

   someTuple = (1,2)
   someList  = [1,2] 
   

2. Rozmiar

   a = tuple(range(1000))
   b = list(range(1000))
   
   a.__sizeof__() # 8024
   b.__sizeof__() # 9088
   

   Ze względu na mniejszy rozmiar operacji krotki, staje się ona nieco szybsza, ale nie ma o czym wspominać, dopóki nie ma ogromnej liczby elementów.

3. Dozwolone operacje

   b    = [1,2]   
   b[0] = 3       # [3, 2]
   
   a    = (1,2)
   a[0] = 3       # Error
   

   Oznacza to również, że nie można usunąć elementu ani posortować krotki. Możesz jednak dodać nowy element zarówno do listy, jak i krotki z tą tylko różnicą, że ponieważ krotka jest niezmienna, nie dodajesz naprawdę, ale tworzysz nową krotkę, więc identyfikator zmieni

   a     = (1,2)
   b     = [1,2]  
   
   id(a)          # 140230916716520
   id(b)          # 748527696
   
   a   += (3,)    # (1, 2, 3)
   b   += [3]     # [1, 2, 3]
   
   id(a)          # 140230916878160
   id(b)          # 748527696
   

4. Użycie

   Ponieważ lista jest zmienna, nie może być używana jako klucz w słowniku, podczas gdy krotka może być używana.

   a    = (1,2)
   b    = [1,2] 
   
   c = {a: 1}     # OK
   c = {b: 1}     # Error
   

Jeśli poszedłeś na spacer, możesz zanotować swoje współrzędne w każdej chwili (x,y) krotką.

Jeśli chcesz nagrać swoją podróż, możesz dołączać swoją lokalizację co kilka sekund do listy.

Zasadnicza różnica polega na tym, że krotki są niezmienne. Oznacza to, że nie można zmienić wartości krotki po jej utworzeniu.

Więc jeśli chcesz zmienić wartości użyj listy.

Korzyści dla krotek:

1. nieznaczna poprawa wydajności.
2. ponieważ krotka jest niezmienna, może być używana jako klucz w słowniku.
3. Jeśli nie możesz tego zmienić, ani nikt inny, czyli nie musisz się martwić o żadne funkcje API itp. zmiana krotki bez pytania.

Listy są zmienne, krotki nie.

Z docs.python.org/2/tutorial/datastructures.html

Krotki są niezmienne i zwykle zawierają heterogeniczny ciąg elementy, które są dostępne poprzez rozpakowanie (patrz dalej w tej sekcji) lub indeksowania (lub nawet przez atrybut w przypadku nazw). Listy są zmienne, a ich elementy są zwykle jednorodne i są Dostęp poprzez iterację listy.

Mówi się że różnica jest w dużej mierze semantyczna: ludzie oczekują, że krotka i lista reprezentują różne informacje. Ale to idzie dalej niż wytyczne; niektóre biblioteki faktycznie zachowują się inaczej na podstawie tego, co są przekazywane. Weźmy na przykład NumPy (skopiowany z innego posta gdzie proszę o więcej przykładów):

>>> import numpy as np
>>> a = np.arange(9).reshape(3,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> idx = (1,1)
>>> a[idx]
4
>>> idx = [1,1]
>>> a[idx]
array([[3, 4, 5],
       [3, 4, 5]])

Chodzi o to, że NumPy może nie być częścią biblioteki standardowej, ale jest główną biblioteką Pythona, a wewnątrz list NumPy a krotki to zupełnie inne rzeczy.

Listy służą do zapętlania, krotki do struktur, np. "%s %s" %tuple.

Listy są zwykle jednorodne, krotki są zwykle niejednorodne.

Listy są dla zmiennej długości, krotki dla stałej długości.

To jest przykład List Pythona:

my_list = [0,1,2,3,4]
top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"]

my_tuple = (a,b,c,d,e)
celebrity_tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead")

Listy i krotki Pythona są podobne, ponieważ obie są uporządkowanymi zbiorami wartości. Poza płytką różnicą, że listy są tworzone za pomocą nawiasów" [... , ... ] "oraz krotki za pomocą nawiasów "( ... , ... ) ", rdzeń techniczny" hard coded in Python syntax " różnica między nimi polega na tym, że elementy konkretnej krotki są niezmienne, podczas gdy listy są mutowalne (...więc tylko krotki są hashable i mogą być używane jako słownik / hash klucze!). Powoduje to różnice w sposobie ich używania (wymuszane a priori przez składnię) i różnice w sposobie, w jaki ludzie decydują się ich używać (zachęcani jako "najlepsze praktyki", a posteriori, tak robią Programiści smart {12]}). Główna różnica a posteriori w rozróżnianiu, kiedy krotki są używane, a kiedy listy są używane, polega na tym, co oznacza ludzie nadają kolejności elementów.

Dla krotki, 'kolejność' oznacza nic więcej niż tylko określoną 'strukturę' do przechowywania informacji. Wartości Znalezione w pierwszym polu można łatwo przełączać na drugie, ponieważ każde z nich dostarcza wartości w dwóch różnych wymiarach lub skalach. Dostarczają one odpowiedzi na różnego rodzaju pytania i zazwyczaj mają postać: jakie są jego atrybuty dla danego obiektu/przedmiotu? obiekt / obiekt pozostaje stały, atrybuty różnią się.

Dla list 'kolejność' oznacza Sekwencja lub kierunkowość. Drugi element musi pojawić się po pierwszym elemencie, ponieważ jest umieszczony na drugim miejscu w oparciu o określoną i wspólną skalę lub wymiar. Elementy są traktowane jako całość i najczęściej dostarczają odpowiedzi na pojedyncze pytanie typowo postaci, dla danego atrybutu, jak te obiekty/przedmioty porównują? atrybut pozostaje stały, obiekt / podmiot różni się.

Są niezliczone przykłady ludzi w kulturze popularnej i programiści, którzy nie zgadzają się z tymi różnicami i istnieje niezliczona ilość ludzi, którzy mogą użyć widelca do sałatki do ich dania głównego. Pod koniec dnia jest w porządku i oba Zwykle mogą wykonać zadanie.

Aby podsumować niektóre z drobniejszych szczegółów

Podobieństwa:

1. duplikaty - zarówno krotki, jak i listy pozwalają na duplikaty

2. indeksowanie, zaznaczanie i wycinanie - zarówno krotki, jak i listy indeksują za pomocą liczby całkowitej wartości Znalezione w nawiasach. Tak więc, jeśli chcesz mieć pierwsze 3 wartości z danej listy lub krotki, składnia będzie taka sama:

   >>> my_list[0:3]
   [0,1,2]
   >>> my_tuple[0:3]
   [a,b,c]
   

3. porównywanie i sortowanie - dwie krotki lub dwie listy są porównywane przez pierwszy element, a jeśli jest remis, to przez drugi element, i tak dalej. Nie zwraca się uwagi na kolejne elementy po tym, jak wcześniejsze elementy wykazują różnicę.

   >>> [0,2,0,0,0,0]>[0,0,0,0,0,500]
   True
   >>> (0,2,0,0,0,0)>(0,0,0,0,0,500)
   True
   

Różnice: - a priori, przez definicja

1. składnia - list use [], krotki use ()

2. zmienność - elementy w danej liście są zmienne, elementy w danej krotce nie są zmienne.

   # Lists are mutable:
   >>> top_rock_list
   ['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son']
   >>> top_rock_list[1]
   'Kashmir'
   >>> top_rock_list[1] = "Stairway to Heaven"
   >>> top_rock_list
   ['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son']
   
   # Tuples are NOT mutable:       
   >>> celebrity_tuple
   ('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead')
   >>> celebrity_tuple[5]
   'Dead'
   >>> celebrity_tuple[5]="Alive"
   Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   TypeError: 'tuple' object does not support item assignment
   

3. Hashtables (Słowniki) - ponieważ hashtables (słowniki) wymagają, aby jego klucze były hashable i dlatego niezmienne, tylko krotki mogą działać jako klucze słownikowe, a nie listy.

   #Lists CAN'T act as keys for hashtables(dictionaries)
   >>> my_dict = {[a,b,c]:"some value"}
   Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   TypeError: unhashable type: 'list'
   
   #Tuples CAN act as keys for hashtables(dictionaries)
   >>> my_dict = {("John","Wayne"): 90210}
   >>> my_dict
   {('John', 'Wayne'): 90210}
   

Różnice - a posteriori, w użycie

1. Homo a heterogeniczność elementów-generalnie obiekty listy są jednorodne, a obiekty krotki heterogeniczne. Oznacza to, że listy są używane dla obiektów / tematów tego samego typu (jak wszyscy kandydaci na prezydenta, lub wszystkie piosenki, lub wszyscy biegacze), podczas gdy chociaż nie jest wymuszony przez), podczas gdy krotki są bardziej dla obiektów heterogenicznych.

2. Looping vs. Structures-chociaż oba pozwalają na looping (dla x w my_list...), to tylko naprawdę ma sens, aby to zrobić na listę. Krotki są bardziej odpowiednie do strukturyzacji i prezentacji informacji (%S % S rezydujący w %s to % s, a obecnie % S % ("John","Wayne", 90210, "Actor", "Dead"))

Wartości z listy można zmienić w dowolnym momencie, ale wartości krotek nie można zmienić.

Zalety i wady zależą od zastosowania. Jeśli masz takie dane, których nigdy nie chcesz zmieniać, powinieneś użyć krotki, w przeciwnym razie lista jest najlepszą opcją.

Różnica między listą a krotką

Krotki i listy są pozornie podobnymi typami sekwencji w Pythonie.

1. Składnia literalna

   Używamy nawiasu () to construct tuples and square brackets [ ], aby uzyskać nową listę. Możemy również użyć wywołania odpowiedniego typu, aby uzyskać wymaganą strukturę-tuple lub list.

   someTuple = (4,6)
   someList  = [2,6] 
   

2. Zmienność

   Krotki są niezmienne, a listy zmienne. Ten punkt jest podstawą dla następujących.

3. Wykorzystanie pamięci

   Ze względu na zmienność, Potrzebujesz więcej pamięci dla list i mniej pamięci dla krotek.

4. Rozszerzenie

   Możesz dodać nowy element zarówno do krotek, jak i list z tą różnicą, że identyfikator krotki zostanie zmieniony (tzn. będziemy mieli nowy obiekt).

5. Hashing

   Krotki są hashowalne, a listy nie. Oznacza to, że można użyć krotki jako klucza w słownik. Lista nie może być używana jako klucz w słowniku, podczas gdy krotka może być używana

   tup      = (1,2)
   list_    = [1,2] 
   
   c = {tup   : 1}     # ok
   c = {list_ : 1}     # error
   

6. Semantyka

   Ten punkt jest bardziej o najlepszych praktykach. Krotki należy używać jako heterogenicznych struktur danych, podczas gdy listy są jednorodnymi sekwencjami.

Listy mają być jednorodnymi sekwencjami, podczas gdy krotki są heterogenicznymi strukturami danych.

Jak już tutaj ludzie odpowiedzieli, że tuples są niezmienne, podczas gdy lists są mutowalne, ale jest jeden ważny aspekt używania krotek, który musimy pamiętać

Jeśli tuple zawiera list lub dictionary wewnątrz niego, można je zmienić nawet jeśli tuple jest niezmienna.

Na przykład, załóżmy, że mamy krotkę, która zawiera listę i słownik jako

my_tuple = (10,20,30,[40,50],{ 'a' : 10})

Możemy zmienić zawartość listy jako

my_tuple[3][0] = 400
my_tuple[3][1] = 500

Który tworzy nową krotkę wygląda jak

(10, 20, 30, [400, 500], {'a': 10})

Możemy również zmienić słownik wewnątrz krotki jako

my_tuple[4]['a'] = 500

Które sprawią, że ogólna krotka będzie wyglądać jak

(10, 20, 30, [400, 500], {'a': 500})

Dzieje się tak, ponieważ list i dictionary są obiektami i obiekty te nie zmieniają się, ale ich zawartość wskazuje na.

Więc tuple pozostaje niezmienna bez wyjątku

Ponieważ ludzie już wspominali o różnicach, napiszę o tym, dlaczego krotki.

Dlaczego krotki są preferowane?

Optymalizacja alokacji dla małych krotek

Aby zmniejszyć fragmentację pamięci i przyspieszyć alokację, Python ponownie wykorzystuje stare krotki. Jeśli a krotka nie jest już potrzebna i ma mniej niż 20 pozycji zamiast usuwać na stałe przenosi go do wolnej listy.

Wolna lista jest podzielona na 20 grup, gdzie każda grupa reprezentuje lista krotek o długości n od 0 do 20. Każda grupa może przechowywać do do 2000 krotek. Pierwsza (zerowa) grupa zawiera tylko 1 element i reprezentuje pustą krotkę.

>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104

W powyższym przykładzie widzimy, że a i b mają ten sam IDENTYFIKATOR. To jest ponieważ od razu zajęliśmy zniszczoną krotkę, która była na darmowa lista.

Optymalizacja alokacji dla list

Ponieważ listy mogą być modyfikowane, Python nie używa taka sama optymalizacja jak w krotkach. Jednakże, Listy Pythona mają również wolną listę, ale jest ona używana tylko dla pustych obiektów. Jeśli pusta lista zostanie usunięta lub zebrana przez GC, może być ponownie użyty później.

>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792

Źródło: https://rushter.com/blog/python-lists-and-tuples/

Dlaczego krotki są wydajne niż listy? -> https://stackoverflow.com/a/22140115

PEP 484 -- Type Hints mówi, że typy elementów tuple mogą być wpisywane indywidualnie; tak, że można powiedzieć Tuple[str, int, float]; ale list, z List Klasa typowania może przyjmować tylko jeden parametr typu: List[str], który wskazuje, że różnica 2 naprawdę polega na tym, że pierwszy jest heterogeniczny, podczas gdy drugi jest wewnętrznie jednorodny.

Ponadto biblioteka standardowa najczęściej używa krotki jako wartości zwracanej z takich standardowych funkcji, w których C zwraca struct.

Najważniejszą różnicą jest czas ! Jeśli nie chcesz zmieniać danych wewnątrz listy lepiej użyć krotki ! Oto przykład, dlaczego warto używać krotki !

import timeit
print(timeit.timeit(stmt='[1,2,3,4,5,6,7,8,9,10]', number=1000000)) #created list
print(timeit.timeit(stmt='(1,2,3,4,5,6,7,8,9,10)', number=1000000)) # created tuple 

w tym przykładzie wykonaliśmy oba polecenia milion razy

Wyjście:

0.136621
0.013722200000000018

Każdy może wyraźnie zauważyć różnicę czasu.

Cytat kierunku z Dokumentacji na 5.3. Krotki i sekwencje :

Choć krotki mogą wydawać się podobne do list, są one często używane w różnych sytuacjach i do różnych celów. Krotki są niezmienne i zwykle zawierają heterogeniczny ciąg elementów, do których dostęp można uzyskać poprzez rozpakowanie (patrz dalej w tej sekcji) lub indeksowanie (lub nawet przez atrybut w przypadku nazw krotek). Listy są zmienne , oraz ich elementy są zwykle jednorodne i są dostępne przez iterację nad listą.

Po pierwsze, oba są obiektami nieskalarowymi (znanymi również jako obiekty złożone) w Pythonie.

• krotki, uporządkowane sekwencje elementów (które mogą zawierać dowolny obiekt bez problemu z aliasingiem)
  • Immutable (tuple, int, float, str)
  • konkatenacja za pomocą + (oczywiście powstanie nowa krotka)
  • indeksowanie
  • krojenie
  • Singleton (3,) # -> (3) zamiast (3) # -> 3
• List (tablica w innych językach), uporządkowany sekwencja wartości
  • Mutable
  • Singleton [3]
  • klonowanie new_array = origin_array[:]
  • zrozumienie listy [x**2 for x in range(1,7)] daje [1,4,9,16,25,36] (nie do odczytania)

Używanie listy może również powodować błąd aliasingu (dwie różne ścieżki wskazując na ten sam obiekt).

Listy są zmienne, A krotki niezmienne. Rozważ ten przykład.

a = ["1", "2", "ra", "sa"]    #list
b = ("1", "2", "ra", "sa")    #tuple

Teraz zmień wartości indeksu list i krotki.

a[2] = 1000
print a     #output : ['1', '2', 1000, 'sa']
b[2] = 1000
print b     #output : TypeError: 'tuple' object does not support item assignment.

Stąd udowodniono, że poniższy kod jest nieprawidłowy z krotką, ponieważ próbowaliśmy zaktualizować krotkę, co jest niedozwolone.

Wystarczy szybkie rozszerzenie do list vs tuple Odpowiedzi:

• Ze względu na dynamiczną naturę, list przydziela więcej bitów niż wymagana pamięć. Ma to na celu zapobieżenie kosztownej operacji realokacji w przypadku dołączenia dodatkowych elementów w przyszłości.

• Z drugiej strony, statyczny, lekki obiekt tuple nie rezerwuje dodatkowej pamięci wymaganej do ich przechowywania.

Lista jest zmienna, a krotki niezmienne. Główną różnicą między zmiennymi a niezmiennymi jest użycie pamięci podczas próby dodania elementu.

Podczas tworzenia zmiennej przypisywana jest pewna stała pamięć. Jeśli jest to lista, przydzielana jest więcej pamięci niż faktycznie używana. Np. jeśli bieżące przypisanie do pamięci wynosi 100 bajtów, to kiedy chcesz dodać 101 bajt, może zostanie przypisane kolejne 100 bajtów (w sumie 200 bajtów w tym przypadku).

Jednakże, jeśli wiesz że nie są często dodać nowe elementy, to należy użyć krotek. Krotki przypisują dokładnie rozmiar potrzebnej pamięci, a tym samym oszczędzają pamięć, zwłaszcza gdy używasz dużych bloków pamięci.