W tym przewodniku poznasz podobieństwa i różnice między krotkami i listami Pythona. Zrozumiesz również, kiedy powinieneś używać krotki.
List i krotki są wbudowanymi strukturami danych w Pythonie. Mogą służyć do przechowywania kolekcji elementów.
Od obsługi indeksowania i wycinania do zawierania heterogenicznych typów danych, krotki i listy mogą wydawać się mieć podobną funkcjonalność. Dlatego zrozumienie podobieństw i różnic między nimi może pomóc w podjęciu decyzji, której struktury danych użyć.
Zaczynajmy.
👩🏽💻 Możesz uruchomić Python REPL i postępować zgodnie z tym samouczkiem. Możesz także użyć internetowego edytora Python newsblog.pl do kodowania.
Spis treści:
Python Tuple vs List: Jakie są podobieństwa?
Zacznijmy od poznania podobieństw między listami i krotkami. Aby ułatwić lepszą naukę, przedstawiamy przykłady zarówno list, jak i krotek.
#1. Iterowalne w Pythonie
W Pythonie listy są ujęte w nawiasy kwadratowe, podczas gdy krotki są ujęte w nawiasy. Możesz również utworzyć krotkę jako zestaw wartości oddzielonych przecinkami — bez nawiasów.
Oba są iterowalne; więc możesz przejść przez nie za pomocą pętli for.
Poniższa komórka kodu pokazuje, jak iterować po liście.
nums = [2,6,7,10]
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'list'>
2
6
7
10
Jak wyjaśniono poniżej, możesz również iterować przez krotkę za pomocą pętli
nums = (2,6,7,10)
# Note: nums = 2,6,7,10 is a valid tuple as well. If needed, run a quick check!
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'tuple'>
2
6
7
10
#2. Wsparcie dla tworzenia z innych sekwencji
Kolejne podobieństwo między listami i krotkami polega na tym, że można je tworzyć z istniejących sekwencji, takich jak ciągi.
sample_str = "Coding!"
Poniższa komórka kodu pokazuje, w jaki sposób list(string) zwraca listę, której elementami listy są znaki w ciągu.
list_from_str = list(sample_str) print(list_from_str) # Output ['C', 'o', 'd', 'i', 'n', 'g', '!']
Podobnie krotka może być utworzona z ciągu lub innej sekwencji przy użyciu krotki(sekwencji). Poniższa komórka kodu pokazuje, jak możesz to zrobić.
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Output
('C', 'o', 'd', 'i', 'n', 'g', '!')
#3. Wsparcie dla indeksowania i krojenia
Python obsługuje indeksowanie zerowe, w którym pierwszy element ma indeks zero, drugi indeks jeden i tak dalej. Python obsługuje również indeksowanie ujemne, gdzie ostatni element znajduje się pod indeksem -1, przedostatni element jest pod indeksem -2 i tak dalej.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[1]) # o
Element o indeksie -2 to przedostatni element, „g”.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[-2])
# g
Możesz użyć wycinania, jeśli chcesz pracować z niewielką częścią listy lub krotką. lista[start:end] zwraca wycinek listy rozpoczynający się od początku indeksu i rozciągający się do końca – 1. Domyślną wartością początku jest 0, a koniec jest ostatnim elementem w iterowalnej.
Możesz kroić krotki przy użyciu tej samej składni. Stwórzmy wycinki listy i krotki, które utworzyliśmy wcześniej.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[0:5]) ['C', 'o', 'd', 'i', 'n']
Oprócz wartości początkowej i końcowej można również określić wartość kroku. krotka(początek:koniec:krok) zwraca wycinek krotki od początku do końca – 1, w krokach.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[::2])
('C', 'd', 'n', '!')
Tutaj ustawiamy wartość kroku na 2. Tak więc plasterek zawiera co drugi element.
#4. Zbiory wielu typów danych
W rozważanych przez nas przykładach wszystkie elementy na liście i krotki miały ten sam typ danych.
Możesz jednak przechowywać wartości różnych typów danych w ramach pojedynczej listy lub krotki.
Fragment kodu poniżej student_list zawiera imię i nazwisko ucznia jako ciąg, wiek jako liczbę całkowitą i znaki zabezpieczone jako zmiennoprzecinkowe.
student_list = ["John",22,96.5]
for item in student_list:
print(f"{item} is of type {type(item)}")
# Output
John is of type <class 'str'>
22 is of type <class 'int'>
96.5 is of type <class 'float'>
Możemy podać podobny przykład dla krotki.
student_tuple = ("Jane",23,99.5)
for item in student_tuple:
print(f"{item} is of type {type(item)}")
# Output
Jane is of type <class 'str'>
23 is of type <class 'int'>
99.5 is of type <class 'float'>
#5. Wsparcie dla testowania członkostwa
Zarówno listy, jak i krotki umożliwiają przeprowadzanie testów członkostwa pod kątem obecności określonych elementów. Jeśli chcesz sprawdzić, czy określony element znajduje się na liście lub krotce, możesz użyć operatora in.
Element wyrażenia w iterowalnym oblicza True, jeśli iterowalny zawiera element; inaczej, Fałsz.
"Alex" in student_list # False "Jane" in student_tuple # True
Do tej pory poznałeś podobieństwa między listami i krotkami w Pythonie. Następnie poznajmy kluczowe różnice między tymi dwiema strukturami danych.
Python Tuple a lista: jakie są różnice?
#1. Zmienność list i niezmienność krotek w Pythonie
Najważniejsza różnica między listą a krotką w Pythonie polega na tym, że krotka jest niezmienna. Oznacza to, że nie możesz modyfikować krotki w miejscu.
▶️ Oto przykład.
tuple1 = ("Java","Python","C++")
tuple1[0] = "Rust"
# Output
----> 2 tuple1[0] = "Rust"
TypeError: 'tuple' object does not support item assignment
Lista jest zmienną strukturą danych, więc możemy modyfikować listę, zmieniając element w określonym indeksie, jak w poniższej komórce kodu.
list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Output ['Rust', 'Python', 'C++']
#2. Listy o zmiennej długości a krotki o stałej długości
Lista Pythona jest strukturą danych o zmiennej długości.
Możesz wykonać następujące czynności:
- Dodaj pozycję na końcu listy
- Dodaj elementy z innej listy na koniec bieżącej listy
- Usuń pozycje z określonego indeksu z listy
list1 = [2,3,4,5] # add an item to the end list1.append(9) print(list1) # add items from list2 to the end of list1 list2 = [0,7] list1.extend(list2) print(list1) # remove an item from list1 list1.pop(0) print(list1)
▶️ Dane wyjściowe powyższego fragmentu kodu.
# Output [2, 3, 4, 5, 9] [2, 3, 4, 5, 9, 0, 7] [3, 4, 5, 9, 0, 7]
Krotki są strukturami danych o stałej długości. Nie możesz więc dodawać ani usuwać elementów z istniejącej krotki. Ale możesz przedefiniować krotkę, aby zawierała różne elementy.
tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Output (1, 8, 9)
#3. Rozmiar w pamięci
Będziemy teraz opierać się na tym, czego nauczyliśmy się w poprzedniej sekcji: lista jest strukturą danych o zmiennej długości.
Po początkowym zdefiniowaniu listy w pamięci przydzielany jest jej określony rozmiar. Teraz, gdy modyfikujesz listę za pomocą metod append() lub extend(), należy przydzielić dodatkową pamięć do przechowywania dodanych elementów. Ta alokacja jest prawie zawsze wykonywana więcej niż liczba dodanych pozycji.
Tak więc istnieje potrzeba śledzenia liczby pozycji na liście i przydzielonego miejsca. Ponadto, ponieważ listy mają zmienną długość, istnieje wskaźnik wskazujący adres elementów listy. W rezultacie listy o długości k zajmują więcej pamięci niż krotka z tymi samymi k elementami.
Oto prosta ilustracja.
Możesz użyć wbudowanej metody getsizeof() wbudowanego modułu sys na obiekcie Pythona, aby uzyskać rozmiar obiektu w pamięci.
import sys
list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"Size of list:{list_size}")
tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"Size of tuple:{tuple_size}")
Lista zajmuje więcej pamięci niż krotka dla tej samej liczby i wartości elementów, co zostało zweryfikowane w poniższym wyniku.
# Output Size of list:104 Size of tuple:88
Kiedy należy używać krotki Pythona?
Z różnic i podobieństw między listami i krotkami Pythona wiesz, że jeśli potrzebujesz mutowalnej kolekcji, powinieneś użyć listy.
Ale kiedy należy zamiast tego użyć krotki?
Omówimy to w tej sekcji.
#1. Kolekcja tylko do odczytu
Zawsze, gdy chcesz, aby kolekcja była niezmienna, powinieneś zdefiniować ją jako krotkę. Załóżmy, że kolor = (243,55,103) krotka zawierająca wartości RGB odpowiadające odcieniowi koloru. Zdefiniowanie koloru jako krotki zapewnia, że nie można go modyfikować.
Zasadniczo, gdy potrzebujesz kolekcji, która ma być tylko do odczytu: wartości nie powinny być modyfikowane podczas programu, powinieneś rozważyć użycie krotki. Zapobiegnie to niezamierzonej modyfikacji wartości.
#2. Klawisze słownika
Na przykład tworzysz słownik, używając elementów listy key_list jako kluczy. Możesz użyć metody dict.fromkeys(), aby utworzyć słownik z listy.
key_list = list("ABCD")
dict.fromkeys(key_list)
{'A': None, 'B': None, 'C': None, 'D': None}
Załóżmy, że modyfikujesz listę tak, aby zawierała „D” jako pierwszy element (indeks 0) — przed utworzeniem słownika.
Co się dzieje z kluczem słownika „A”?
Jeśli spróbujesz utworzyć słownik z key_list i uzyskasz dostęp do wartości odpowiadającej kluczowi „A”, natkniesz się na KeyError.
key_list[0] = 'D' dict.fromkeys(key_list)['A'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-31-c90392acc2cf> in <module>() ----> 1 dict.fromkeys(key_list)['A'] KeyError: 'A'
Klucze słownika powinny być unikalne. Więc nie możesz mieć drugiego „D” jako klucza.
dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A is no longer a key.
Jeśli zamiast tego użyjesz krotki, taka modyfikacja jest niemożliwa i prawdopodobieństwo wystąpienia błędów jest mniejsze. Dlatego powinieneś preferować tworzenie słownika przy użyciu elementów krotki jako kluczy.
key_tuple = tuple("ABCD")
dict.fromkeys(key_tuple)
{'A': None, 'B': None, 'C': None, 'D': None}
key_tuple[0] = 'D'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-2cecbefa7db2> in <module>()
----> 1 key_tuple[0] = 'D'
TypeError: 'tuple' object does not support item assignment
#3. Argumenty funkcji
Niezmienność krotek sprawia, że nadają się one również do przekazania jako argumentów funkcji.
Rozważmy następującą funkcję find_volume(), która zwraca objętość prostopadłościanu o podanych wymiarach: długość, szerokość i wysokość.
def find_volume(dimensions): l,b,h = dimensions return l*b*h
Załóżmy, że te wymiary są dostępne na liście zwanej wymiarami. Wywołanie find_volume() z wymiarami jako argumentem zwraca objętość.
dimensions = [2,8,5] find_volume(dimensions) 80
Zawsze możesz zmienić wymiary zapisane na liście.
dimensions = [20,8,5] find_volume(dimensions) 800
Czasami jednak będziesz potrzebować wartości, aby pozostały stałe i nie uległy modyfikacji. Właśnie wtedy powinieneś rozważyć przechowywanie argumentów jako krotki i użycie ich w wywołaniu funkcji.
#4. Zwracane wartości z funkcji
W Pythonie natkniesz się na krotki w wartościach zwracanych przez funkcje. Gdy zwracasz wiele wartości z funkcji, Python niejawnie zwraca je jako krotkę.
Rozważ następującą funkcję return_even():
def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)
- Jako argument przyjmuje liczbę
- Zwraca listę parzystych liczb w przedziale [0,num) and the length of that list.
Let’s set the value of num 20 and call the function.
num = 20
Calling return_even() returns the two values in a tuple. You can call the type() function with the function call as the verification argument.
type(return_even(num)) # <class 'tuple'>
You can print out the return value to verify that it’s a tuple containing the list of even numbers as the first item and the length of the list as the second item.
print(return_even(num)) ([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]10)
Ponieważ w krotce znajdują się dwa elementy, możesz je rozpakować na dwie zmienne, jak pokazano poniżej.
even_nums, count = return_even(num) print(even_nums) print(count) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10
Wniosek
Mam nadzieję, że ten samouczek dostarczył kompleksowego porównania krotki Pythona z listą.
Zakończmy samouczek krótkim podsumowaniem:
- Lista i krotki to wbudowane struktury danych w Pythonie.
- Podobieństwa: iterowalne, obsługa indeksowania, wycinania, różne typy danych i operator do testowania członkostwa.
- Kluczowa różnica: Listy są zmienne, a krotki są niezmienne.
- Inne różnice: Stała długość krotek i zmienna długość list, mniejszy rozmiar krotek w pamięci.
- Kiedy należy używać krotki? Dla niezmiennych kolekcji, kluczy słownikowych i argumentów funkcji.
Następnie sprawdź projekty Pythona, aby ćwiczyć i uczyć się. Lub poznaj metody usuwania zduplikowanych elementów z list Pythona. Miłej nauki! potem miłego kodowania!👩🏽💻