Python Language
Tuple

Wprowadzenie

Składnia

• (1, a, „hello”) # a musi być zmienną

• () # pusta krotka

• (1,) # krotka 1-elementowa. (1) nie jest krotką.

• 1, 2, 3 # krotka 3-elementowa (1, 2, 3)

Uwagi

Indeksowanie krotek

x = (1, 2, 3)
x[0]  # 1
x[1]  # 2
x[2]  # 3
x[3]  # IndexError: tuple index out of range

Indeksowanie liczbami ujemnymi rozpocznie się od ostatniego elementu jako -1:

x[-1] # 3
x[-2] # 2
x[-3] # 1
x[-4] # IndexError: tuple index out of range

Indeksowanie zakresu elementów

print(x[:-1])   # (1, 2)
print(x[-1:])   # (3,)
print(x[1:3])   # (2, 3)

Krotki są niezmienne

Jedną z głównych różnic między list s i tuple s w Pythonie jest to, że krotki są niezmienne, to znaczy, nie można dodawać lub modyfikować elementy raz krotka jest inicjowany. Na przykład:

>>> t = (1, 4, 9)
>>> t[0] = 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Podobnie krotki nie mają metod .append i .extend , podobnie jak list . Używanie += jest możliwe, ale zmienia wiązanie zmiennej, a nie samej krotki:

>>> t = (1, 2)
>>> q = t
>>> t += (3, 4)
>>> t
(1, 2, 3, 4)
>>> q
(1, 2)

Zachowaj ostrożność, umieszczając zmienne obiekty, takie jak lists , w krotkach. Może to prowadzić do bardzo mylących wyników przy ich zmianie. Na przykład:

>>> t = (1, 2, 3, [1, 2, 3])
(1, 2, 3, [1, 2, 3])
>>> t[3] += [4, 5]

Będą zarówno podnieść błąd i zmienić zawartość listy w krotce:

TypeError: 'tuple' object does not support item assignment
>>> t
(1, 2, 3, [1, 2, 3, 4, 5])

Za pomocą operatora += można „dołączyć” do krotki - działa to poprzez utworzenie nowej krotki z nowym elementem, który „dopisałeś” i przypisanie jej do bieżącej zmiennej; stara krotka nie została zmieniona, ale zastąpiona!

Pozwala to uniknąć konwersji do i z listy, ale jest to powolne i jest złą praktyką, szczególnie jeśli zamierzasz dołączyć wiele razy.

Krotki są elementarne haszowalne i równe

hash( (1, 2) )  # ok
hash( ([], {"hello"})  # not ok, since lists and sets are not hashabe

W ten sposób krotka może być umieszczona w set lub jako klucz w dict tylko wtedy, gdy każdy z jej elementów może.

{ (1, 2) } #  ok
{ ([], {"hello"}) ) # not ok

Tuple

Składniowo krotka to lista wartości oddzielona przecinkami:

t = 'a', 'b', 'c', 'd', 'e'

Chociaż nie jest to konieczne, często krotki umieszcza się w nawiasach:

t = ('a', 'b', 'c', 'd', 'e')

Utwórz pustą krotkę z nawiasami:

t0 = ()
type(t0)            # <type 'tuple'>

Aby utworzyć krotkę z jednym elementem, musisz dołączyć końcowy przecinek:

t1 = 'a',
type(t1)              # <type 'tuple'>

Zauważ, że pojedyncza wartość w nawiasach nie jest krotką:

t2 = ('a')
type(t2)              # <type 'str'>

Aby utworzyć krotkę singletonową, trzeba mieć przecinek końcowy.

t2 = ('a',)
type(t2)              # <type 'tuple'>

Zauważ, że dla krotek singletonowych zaleca się (patrz PEP8 na przecinkach końcowych ) stosowanie nawiasów. Ponadto, brak spacji po przecinku końcowym (patrz PEP8 na białych znakach )

t2 = ('a',)           # PEP8-compliant
t2 = 'a',             # this notation is not recommended by PEP8
t2 = ('a', )          # this notation is not recommended by PEP8

Innym sposobem utworzenia krotki jest wbudowana funkcja tuple .

t = tuple('lupins')
print(t)              # ('l', 'u', 'p', 'i', 'n', 's')
t = tuple(range(3))
print(t)              # (0, 1, 2)

Przykłady te oparte są na materiale z książki Think Python Allena B. Downeya .

Pakowanie i rozpakowywanie krotek

Krotki w Pythonie to wartości oddzielone przecinkami. Dołączanie nawiasów do wprowadzania krotek jest opcjonalne, więc dwa przypisania

a = 1, 2, 3   # a is the tuple (1, 2, 3)

i

a = (1, 2, 3) # a is the tuple (1, 2, 3)

są równoważne. Przypisanie a = 1, 2, 3 nazywa się również pakowaniem, ponieważ łączy wartości razem w krotkę.

Zauważ, że krotka o jednej wartości jest również krotką. Aby powiedzieć Pythonowi, że zmienna jest krotką, a nie pojedynczą wartością, możesz użyć przecinka końcowego

a = 1  # a is the value 1
a = 1, # a is the tuple (1,)

Przecinek jest potrzebny także w przypadku nawiasów

a = (1,) # a is the tuple (1,)
a = (1)  # a is the value 1 and not a tuple

Aby rozpakować wartości z krotki i wykonać wiele zadań, użyj

# unpacking AKA multiple assignment
x, y, z = (1, 2, 3) 
# x == 1
# y == 2
# z == 3

Symbol _ może być użyty jako nazwa zmiennej jednorazowego użytku, jeśli potrzebne są tylko niektóre elementy krotki działające jako symbol zastępczy:

a = 1, 2, 3, 4
_, x, y, _ = a
# x == 2
# y == 3

Krotki jednoelementowe:

x, = 1,  # x is the value 1
x  = 1,  # x is the tuple (1,)

W Pythonie 3 zmienna docelowa z przedrostkiem * może być używana jako zmienna typu catch-all (zobacz Rozpakowywanie Iterables ):

first, *more, last = (1, 2, 3, 4, 5)
# first == 1
# more == [2, 3, 4]
# last == 5

Elementy cofania

Odwróć elementy w krotce

colors = "red", "green", "blue"
rev = colors[::-1]
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

Lub używając odwróconego (odwrócony daje iterowalność, która jest konwertowana na krotkę):

rev = tuple(reversed(colors))
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

Wbudowane funkcje krotkowe

Krotki obsługują następujące funkcje wbudowane

Porównanie

Jeśli elementy są tego samego typu, Python dokonuje porównania i zwraca wynik. Jeśli elementy są różnych typów, sprawdza, czy są to liczby.

• Jeśli liczby, wykonaj porównanie.
• Jeśli jeden z elementów jest liczbą, drugi element jest zwracany.
• W przeciwnym razie typy są sortowane alfabetycznie.

Jeśli doszliśmy do końca jednej z list, dłuższa lista jest „większa”. Jeśli obie listy są takie same, zwraca 0.

tuple1 = ('a', 'b', 'c', 'd', 'e')
tuple2 = ('1','2','3')
tuple3 = ('a', 'b', 'c', 'd', 'e')

cmp(tuple1, tuple2)
Out: 1

cmp(tuple2, tuple1)
Out: -1

cmp(tuple1, tuple3)
Out: 0

Długość krotki

Funkcja len zwraca całkowitą długość krotki

len(tuple1)
Out: 5

Max krotkę

Funkcja max zwraca element z krotki o maksymalnej wartości

max(tuple1)
Out: 'e'

max(tuple2)
Out: '3'

Min krotek

Funkcja min zwraca element z krotki o wartości min

min(tuple1)
Out: 'a'

min(tuple2)
Out: '1'

Konwertuj listę na krotkę

Wbudowana funkcja tuple przekształca listę w krotkę.

list = [1,2,3,4,5]
tuple(list)
Out: (1, 2, 3, 4, 5)

Łączenie krotek

Użyj + aby połączyć dwie krotki

tuple1 + tuple2
Out: ('a', 'b', 'c', 'd', 'e', '1', '2', '3')