Tutorial Python - Liste şi Tuple

Liste

• Lista este un tip de dată compus.
• Este o colecţie de iteme.
• Itemele (elementele) pot fi de orice tip.
• Este un tip de dată mutable - poate fi modificat

Itemele listelor se pun intre paranteze pătrate. Listele se declară în felul următor:

>>> mylist = [1, 'a', '%', 2.57, 9+3j]
>>> mylist
[1, 'a', '%', 2.57, (9+3j)]

Stringurile (şirurile de caractere) în Python se declară cu ghilimele sau cu apostrofuri.
Obiectele listei sunt numerotate de la zero, deci primul element este mylist[0].
Lista păstrează ordinea elementelor. Un element poate apărea de mai multe ori într-o listă.
De asemenea, Python permite indici negativi cu semnificaţia

mylist[-n] == mylist[len(mylist) - n]

>>> mylist[0] # Primul item al listei
1
>>> mylist[-1] # Ultimul item al listei
(9+3j)
>>> mylist[4]  # Ultimul item al listei
(9+3j)
>>> mylist[5]
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    mylist[5]
IndexError: list index out of range

Dacă depăşiţi dimensiunea listei, Python va lansa eroarea IndexError.
Funcţia len(ob) returnează mărimea / dimensiunea obiectului ob (trebuie să fie o colecţie).

>>> len(mylist)
5

Putem tăia o listă, adică putem să extragem părţi dintr-o listă folosind sintaxa slice:

>>> mylist[1:3]
['a', '%']
>>> mylist[0:3]
[1, 'a', '%']
>>> mylist[:3]
[1, 'a', '%']
>>> mylist[3:]
[2.57, (9+3j)]
>>> mylist[:]
[1, 'a', '%', 2.57, (9+3j)]

Operatorul slice (:) returnează întotdeauna o listă nouă.
Sintaxa mylist[start:end] are semnificaţia: Returnează itemele din intervalul [start, end). Fără mylist[end].
Atunci când start lipseşte, Python ia în considerare valoarea implicită zero.
Iar când end lipseşte se ia considerare valoarea len(mylist).
În exemplu, mylist[:3] returnează toate itemele începând de la primul (0) până la al patrulea (3), dar fără acest element, iar mylist[3:] returnează toate elementele începând cu al patrulea (3) până la sfârşit.
Dacă ambele valori lipsesc, operatorul slice returnează o copie a listei.
Listele pot fi modificate. Putem adăuga elemente noi la listă cu operatorul de concatenare +.

>>> mylist = [3]
>>> mylist = mylist + ['1', 6.7]
>>> mylist
[3, '1', 6.7]

Operatorul + creează o nouă listă în memorie formată din concatenarea celor două liste, apoi atribuie noua listă variabilei mylist.
Dacă memoria este limitată atunci nu folosiţi această sintaxă. Folosiţi funcţiile append şi extend.

>>> mylist.append(True)
>>> mylist
[3, '1', 6.7, True]
>>> mylist.extend(['^', 7.0])
>>> mylist
[3, '1', 6.7, True, '^', 7.0]

Atenţie! Funcţia extend adaugă elementele argumentului (iterabil; are sau poate genera o secvenţă de iteme) la listă, în timp ce funcţia append adaugă argumentul la listă (chiar dacă este iterabil). Exemplu:

>>> mylist = [1, 2, 3, 4, 5]
>>> len(mylist)
5
>>> mylist.append(['one', 'two'])
>>> mylist
[1, 2, 3, 4, 5, ['one', 'two']]

Listele pot avea ca elemente alte liste, după cum vedeţi. Elementele acestor liste se accesează uşor:

>>> mylist[-1]
['one', 'two']
>>> mylist[-1][0]
'one'
>>> mylist[-1][1]
'two'

Elementele listei pot fi modificate.

>>> mylist = ['a', 'b', 5, 7]
>>> mylist[0] = False
>>> mylist
[False, 'b', 5, 7]

Putem verifica dacă un element se află în listă folosind operatorul in.

>>> 'b' in mylist
True
>>> 'a' in mylist
False

Putem afla de câte ori un element se află în listă.

>>> mylist = ['c', 'b', 's', 'ab', 'b', 'c']
>>> mylist.count('c')
2

Şi putem să aflăm index-ul unui item.

>>> mylist.index('ab')
3
>>> mylist.index('b')
1
>>> mylist.index('b', 2)
4
>>> mylist.index('abc')
Traceback (most recent call last):
  File "<pyshell#44>", line 1, in <module>
    mylist.index('abc')
ValueError: 'abc' is not in list

Funcţia index ia trei parametri: valoarea căutată, [start, [stop]] reprezentând capetele intervalului pe care se face căutarea: [start, stop).
Am pus parametrii între paranteze pătrate (aşa veţi întâlni şi-n documentaţiile Python) ca să subliniez faptul că sunt opţionali.
Când stop lipseşte se caută de la start până la sfârşit.
Dacă elementul nu există în listă, funcţia va genera eroarea ValueError.
Un alt mod de inserare a valorilor într-o listă este prin funcţia insert.

>>> mylist = [1, 2, 'a']
>>> mylist.insert(0, 'E')
>>> mylist
['E', 1, 2, 'a']
>>> mylist.insert(2, 'two')
>>> mylist
['E', 1, 'two', 2, 'a']

Aceasta ia doi parametri: primul reprezintă indexul unde va fi inserat elementul, iar al doilea reprezintă elementul inserat.
Funcţia insert inserează în faţă, elementele listei fiind deplasate la dreapta pentru a face loc itemului adăugat.
Ca să ştergem un element dintr-o listă putem folosi operatorul del.

>>> mylist = [-1, -2, ':)', ':(']
>>> mylist
[-1, -2, ':)', ':(']
>>> del mylist[-1]
>>> mylist
[-1, -2, ':)']
>>> del mylist[0]
>>> mylist
[-2, ':)']

Atunci când un element este eliminat dintr-o listă, celelalte elemente sunt mutate astfel încât să acopere "gaura" creată. Ordinea itemelor se păstrează.

>>> mylist[0]
-2
>>> mylist[-1]
':)'

Dacă nu cunoaşteţi poziţia unui item în listă, puteţi folosi funcţia remove.

>>> mylist = ['t', 'r', 4.5, True]
>>> mylist.remove('t')
>>> mylist
['r', 4.5, True]
>>> mylist.remove('t')
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    mylist.remove('t')
ValueError: list.remove(x): x not in list

Pe lângă remove mai există şi funcţia pop. Aceasta returnează elementul înainte de a-l elimina.

>>> mylist = ['a', 'b', 'patru', 'last']
>>> mylist.pop()
'last'
>>> mylist
['a', 'b', 'patru']
>>> mylist.pop(0)
'a'
>>> mylist
['b', 'patru']

Fără argument, pop returnează şi elimină ultimul element.
Se pot elimina iteme de pe alte poziţii dacă transmitem indicele corespunzător. Şi aici elementele vor fi mutate pentru a acoperi "gaura" creată.
Ca să eliminăm toate elementele dintr-o listă avem două opţiuni:

>>> mylist[:] = [] # [] este lista vida (fara elemente)

Sau cu funcţia clear.

>>> mylist.clear()
>>> mylist
[]

În contextele booleene listele nevide sunt True, iar cele vide sunt False.

>>> if []:
 print(True)
else:
 print(False)

 
False
>>> if [1]:
 print(True)
else:
 print(False)

 
True

În final nu uitaţi de >>> help('list'). Poate fi de mare ajutor atunci când uitaţi ceva.

Tuple

Un tuple (n-am găsit o traducere mai bună) este o listă immutable (imuabilă, care nu poate fi modificată). Se definesc ca listele numai că se folosesc paranteze rotunde.

>>> tupy = ('^_^', '©', 8, 9, 6)
>>> tupy
('^_^', '©', 8, 9, 6)
>>> tupy[0]
'^_^'
>>> tupy[-1]
6

Puteţi folosi operatorul slice, puteţi concatena (aceste operaţii creează tuple noi), puteţi verifica dacă un element se află într-un tuple, dar nu-l puteţi modifica.
Aşadar funcţiile append, extend, remove, pop, insert nu există într-un tuple.
Un tuple este mai rapid decât o listă atunci când aveţi o secvenţă şi vreţi doar să iteraţi prin ea.
Un tuple poate fi folosit la dicţionare pe post de key (asta dacă elementele pe care le conţine sunt immutable: stringuri, numere, tuple, etc.).
Ca să creaţi un tuple cu un singur element puneţi virgulă după acel element (altfel Python va crede că sunt doar două paranteze şi le va ignora).

>>> tupy = ('one',)
>>> tupy
('one',)  # Avem tuple :)
>>> tupy = ('one')
>>> tupy
'one'     # Oops! String!

La fel ca listele, un tuple vid este False, iar un tuple nevid este True (în contexte booleene).
Puteţi transforma un tuple într-o listă folosind funcţia list(ob) sau puteţi transforma o listă într-un tuple folosind funcţia tuple(ob).
Pentru mai multe detalii aveţi >>> help('tuple').