Krotki

Tworzenie krotek

Niektórym nazwa ‘krotki’ nie podoba się i zastępują ją inną oznaczającą skończony ciąg elementów. Nie ma jednak innego, właściwego tłumaczenia słowa Tuple – typu danych podobnego do listy, ale innego. Krotki (słowo utworzone od słowa krotność) cechuje się tym, że wiele operacji zmieniających długość, wartości elementów lub właściwości krotek nie jest na nich wykonalnych. Stąd też większa szybkość programów działających na krotkach zamiast listach oraz większe bezpieczeństwo.

Krotki tworzone są jako zestaw elementów objętych nawiasami okrągłymi lub wcale bez nawiasów.

krot1=('a','b','e','c','a','d','ł','o')
krot2='a','b','e','c','a','d','ł','o'
print(krot1)
print(krot2)
print(krot1==krot2)

>>>	
('a', 'b', 'e', 'c', 'a', 'd', 'ł', 'o')
('a', 'b', 'e', 'c', 'a', 'd', 'ł', 'o')
True

Krotka może być także pusta lub jednoelementowa.

krot1=()
krot2=('a',)
krot3='a',
print(krot1,"\n",krot2,"\n",krot3)

>>>
() 
('a',) 
('a',)

Utworzenie krotki jednoelementowej wymaga postawienia przecinka przed końcowym nawiasem (o ile używany jest nawias). Nie dotyczy to krotek wieloargumentowych, choć przecinek na końcu nie przeszkadza.

Krotki mogą być zagnieżdżone.

krot1=(1,2,3,4,5)
krot2=('a', 'b', 'c', 'd')
krot3=(krot1, krot2)
print(krot3)

>>>
((1, 2, 3, 4, 5), ('a', 'b', 'c', 'd'))

Mogą istnieć listy krotek i krotki list.

krot1=(1,2,3,4,5)
krot2=('a', 'b', 'c', 'd')
lista=[krot1, krot2]
print(lista)

list1=[1,2,3,4,5]
list2=['a', 'b', 'c', 'd']
krotka=(list1, list2)
print(krotka)

>>>
[(1, 2, 3, 4, 5), ('a', 'b', 'c', 'd')]

>>>
([1, 2, 3, 4, 5], ['a', 'b', 'c', 'd'])

Odwołanie się do wybranych elementów krotek

Obiekty krotek można oglądać poprzez indeksy.

krot=1,2,3,4,5,6,7,8
print(krot[0])
print(krot[1:3])
print(krot[-3:-1])
print(krot[:5])

>>>
1
(2, 3)
(6, 7)
(1, 2, 3, 4, 5)

Edycja krotek

Próba edycji przez zmianę elementu wyciągniętego przez odwołanie, wywołuje błąd.

krot=1,2,3,4,5,6,7,8
krot[0]=10
print(krot)

>>>
Traceback (most recent call last):
    File "C:\Users\User\OneDrive\Pulpit\A.py", line 6, in
        krot[0]=10
TypeError: 'tuple' object does not support item assignment

Żeby edytować krotkę trzeba ją rozpakować na poszczególne elementy. Wygląda to następująco:

krotka=(1,2,3,4,5,6,7,8)
a0,a1,a2,a3,a4,a5,a6,a7 = krotka
a0=10
krotka= (a0,a1,a2,a3,a4, a5, a6)
print(krotka)

>>>
(10, 2, 3, 4, 5, 6, 7)

Można także zamienić krotkę na listę za pomocą funkcji ‘list()’, dokonać zamiany wartości wybranego elementu i zamienić listę na krotkę za pomoca funkcji ‘tuple()’.

krotka=(1,2,3,4,5,6,7,8)
lista=list(krotka)
lista[0]=10
krotka=tuple(lista)
print(krotka)

>>>
(10, 2, 3, 4, 5, 6, 7)

Wymaga to trochę pracy i raczej nie zrobi się tego przez przypadek.

Działania na krotkach

Operacje, które można wykonać na krotkach, to działania łączenia krotek znakiem + i ich powielanie znakiem *. Można w ten sposób zastępować krotkę wynikiem takiej operacji.

krot1=(0,1,2,3,4,5)
krot2=5,4,3,2,1,0
print(krot1 + krot2)
print(3*krot1)

>>>
(0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0)
(0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5)

Relacje między krotkami

Relacja ‘in’ sprawdza czy element z lewej strony należy do krotki.

krot=(0,1,2,3,4,5)
print(3 in krot)
print(7 in krot)

>>>
True
False

Relacja ‘==’ oraz ‘is’ sprawdzają czy krotki są identyczne. W nowych wersjach ‘is’ uznaje się za przestarzałe

krot1=krot2=(0,1,2,3,4,5)
krot3=(0,1,2,3,4)
print(krot1==krot2)
print(krot1==krot3)

>>>
True
False

Relacje ‘<‘, ‘<=’, ‘>’, ‘>=’ oceniają prawdziwość relacji dla pierwszej pary z tych samych pozycji, których elementy różnią się od siebie.

krot1=krot2=(0,1,2,3,4,5)
krot3=(0,1,2,3,4,6)
print(krot1<krot2, krot1<=krot2, krot1>krot2, krot1>=krot2)
print(krot1<krot3,krot1<=krot3,krot1>krot3,krot1>=krot3)

>>>
False True False True
True True False False

Metody działające na krotkach

Metodą ‘index’ możemy wykryć pozycję pierwszego pojawienia się w krotce określonego elementu. Gdy element ten nie istnieje generowany jest błąd. Dlatego lepiej jest najpierw sprawdzić za pomocą relacji ‘in’ czy jest on w krotce.

krot=(0,1,2,3,4,5,4,3,2,1,2,3,4,5)
n=krot.index(5)
print(n)

>>>
5

Metoda ‘count’ możemy policzyć ile razy w krotce występuje określony element.

krot=(0,1,2,3,4,5,4,3,2,1,2,3,4,5)
n=krot.count(5)
print(n)

>>>
2

Nie działają natomiast na krotki takie metody jak ‘append’, ‘insert’, ‘expand’ oraz wszystkie zmieniająca zawartość krotki. Ich zastosowanie wymaga zmiany krotki na listę, wykonanie działania i zamiany listy na krotkę.

krot=(0,1,2,3,4,5,4,3,2,1,2,3,4,5)
print(krot)
prot=list(krot)
prot.sort()
print(prot)
krot=tuple(prot)
print(krot)

>>>
(0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 2, 3, 4, 5)
[0, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5]
(0, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5)

To jedyny sposób by zmienić automatycznie kolejność elementów krotki.

Funkcje działające na krotkach

Funkcja ‘len()’ oblicza liczbę elementów krotki.

krot1=(0,1,2,3,4,5,4,3,2,1,2,3,4,5)
krot2=((0,1,2),(3,4,5),(4,3,2),(1,2,3,4,5))
print(len(krot1))
print(len(krot2))

>>>
14
4

Funkcja ‘list()’ zamienia krotkę na listę.

krot=(0,1,2,3,4,5,4,3,2,1,2,3,4,5)
print(list(krot))

>>>
[0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 2, 3, 4, 5]

Funkcja ‘tuple()’ zamienia listę na krotkę.

lista=[0,1,2,3,4,5,4,3,2,1,2,3,4,5]
print(tuple(lista))

>>>
(0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 2, 3, 4, 5)