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').
