2.7. Liste

O listă este o secvență de valori mutabilă și ordonată. Spre deosebire de șiruri și octeți, listele pot conține valori de orice tip, iar elementele pot fi modificate, adăugate sau eliminate pe loc.

2.7.1. Crearea listelor

Parantezele pătrate creează un literal de listă:

empty   = []
nums    = [1, 2, 3]
mixed   = [1, "two", 3.0, True, None]    # any types
nested  = [[1, 2], [3, 4], [5, 6]]       # lists of lists

Constructorul list construiește o listă dintr-un iterabil oarecare:

>>> list("abc")
['a', 'b', 'c']
>>> list(range(5))
[0, 1, 2, 3, 4]

2.7.2. Lungime, indexare și feliere

len() returnează numărul de elemente. Indexarea și felierea funcționează la fel ca la șiruri – pozițiile încep de la 0, indicii negativi se numără de la sfârșit, iar o felie din afara intervalului valid este trunchiată în tăcere, fără a declanșa o eroare:

>>> nums = [10, 20, 30, 40, 50]
>>> len(nums)
5
>>> nums[0]
10
>>> nums[-1]
50
>>> nums[1:4]
[20, 30, 40]

Indicii pozitivi se numără de la început; indicii negativi se numără de la sfârșit.

Sintaxa de feliere este o prescurtare pentru un obiect slice pe care Python îl construiește în culise. nums[1:4] este același lucru cu nums[slice(1, 4)]. Rareori construiești unul manual, dar slice() este uneori util pentru a stoca o felie ca valoare ce poate fi reutilizată:

head = slice(0, 3)
print(nums[head])             # [10, 20, 30]
print(letters[head])          # first three letters, same slice

2.7.3. Modificarea unei liste

Listele acceptă atribuirea indexată și pe felii, pe loc:

>>> nums = [10, 20, 30]
>>> nums[0] = 99
>>> nums
[99, 20, 30]
>>> nums[1:3] = [200, 300, 400]    # slice can change the length
>>> nums
[99, 200, 300, 400]

Cele mai comune metode pentru liste:

• list.append() – adaugă un singur element la sfârșit.

• list.extend() – adaugă fiecare element dintr-un iterabil.

• list.insert() – inserează la o poziție dată.

• list.remove() – șterge prima apariție a unei valori.

• list.pop() – elimină și returnează un element (ultimul în mod implicit).

• list.clear() – elimină fiecare element.

• list.sort() – sortează pe loc. Transmite reverse=True pentru ordine descrescătoare.

• list.reverse() – inversează pe loc.

>>> nums = []
>>> nums.append(1)
>>> nums.extend([2, 3])
>>> nums.insert(0, 99)
>>> nums
[99, 1, 2, 3]
>>> nums.pop()
3
>>> nums.sort()
>>> nums
[1, 2, 99]

Aceste metode modifică lista pe loc și returnează None. Scrierea

nums = nums.sort()    # nums is now None -- common bug

nu este aproape niciodată ceea ce îți dorești; lista originală nums a fost sortată, dar atribuirea suprascrie apoi numele cu valoarea returnată. Fie apelezi nums.sort() pe linia sa proprie, fie folosești funcția încorporată sorted() pentru a obține o nouă listă sortată, fără a o modifica pe cea originală.

2.7.4. Operatori

• + concatenează două liste într-o listă nouă.

• * repetă o listă.

• in testează apartenența.

>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> [0] * 5
[0, 0, 0, 0, 0]
>>> 3 in [1, 2, 3]
True

2.7.5. Iterarea peste o listă

O buclă for parcurge elementele în ordine:

for n in [10, 20, 30]:
    print(n)

2.7.6. Aliasing și modificare

O listă este o singură valoare în memorie; mai multe nume pot indica spre aceeași listă. Modificarea printr-un nume este vizibilă prin orice alt nume care indică spre aceeași listă.

a și b indică ambele spre aceeași listă. Modificarea prin oricare nume schimbă ceea ce vede orice alt nume.

>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]                # same object, change is visible

Pentru a face o copie independentă, feliază întreaga listă sau apelează constructorul list:

>>> c = a[:]                # or list(a)
>>> a.append(5)
>>> c
[1, 2, 3, 4]                # c is unaffected

Acest lucru copiază doar lista de la nivelul superior; listele imbricate sunt în continuare partajate între original și copie.