Lista

Pentru a lucra cu seturi de date, Python oferă tipuri de date încorporate precum liste, tupluri și dicționare.

O listă (list) reprezintă un tip de date care stochează un set sau o secvență de elemente. În multe limbaje de programare, există o structură de date similară numită matrice.

Crearea unei liste

Pentru a crea o listă, se folosesc paranteze pătrate [], în interiorul cărora elementele listei sunt enumerate separate prin virgulă. De exemplu, să definim o listă de numere:

numbers = [1, 2, 3, 4, 5]

În mod similar, se pot defini liste cu date de alte tipuri, de exemplu, să definim o listă de șiruri de caractere:

people = ["Tom", "Sam", "Bob"]

De asemenea, pentru a crea o listă, se poate folosi funcția constructor list():

numbers1 = []
numbers2 = list()

Ambele definiții ale listei sunt echivalente - creează o listă goală.

O listă nu trebuie să conțină neapărat doar obiecte de același tip. Putem pune într-o singură listă simultan șiruri de caractere, numere, obiecte de alte tipuri de date:

objects = [1, 2.6, "Hello", True]

Pentru a verifica elementele unei liste, se poate folosi funcția standardă print, care afișează conținutul listei într-un mod ușor de citit:

numbers = [1, 2, 3, 4, 5]
people = ["Tom", "Sam", "Bob"]

print(numbers)  # [1, 2, 3, 4, 5]
print(people)   # ["Tom", "Sam", "Bob"]

Constructorul list poate primi un set de valori pe baza cărora se creează o listă:

numbers1 = [1, 2, 3, 4, 5]
numbers2 = list(numbers1)
print(numbers2)  # [1, 2, 3, 4, 5]

letters = list("Hello")
print(letters)      # ['H', 'e', 'l', 'l', 'o']

Dacă este necesar să creăm o listă în care aceeași valoare se repetă de mai multe ori, putem folosi simbolul asterisc *, adică aplicăm practic operația de înmulțire la o listă existentă:

numbers = [5] * 6   # 6 ori repetăm 5
print(numbers)      # [5, 5, 5, 5, 5, 5]

people = ["Tom"] * 3    # 3 ori repetăm "Tom"
print(people)           # ["Tom", "Tom", "Tom"]

students = ["Bob", "Sam"] * 2   # 2 ori repetăm "Bob", "Sam"
print(students)                 # ["Bob", "Sam", "Bob", "Sam"]

Accesarea elementelor din listă

Pentru a accesa elementele dintr-o listă, se folosesc indexuri, care reprezintă numărul elementului din listă. Indexurile încep de la zero. Adică primul element va avea indexul 0, al doilea element - indexul 1 și așa mai departe. Pentru a accesa elementele de la sfârșit, se pot folosi indexuri negative, începând de la -1. Adică ultimul element va avea indexul -1, penultimul - -2 și așa mai departe.

people = ["Tom", "Sam", "Bob"]
# obținerea elementelor de la începutul listei
print(people[0])   # Tom
print(people[1])   # Sam
print(people[2])   # Bob

# obținerea elementelor de la sfârșitul listei
print(people[-2])   # Sam
print(people[-1])   # Bob
print(people[-3])   # Tom

Pentru a modifica un element din listă, este suficient să îi atribuim o valoare nouă:

people = ["Tom", "Sam", "Bob"]

people[1] = "Mike"  # modificarea celui de-al doilea element
print(people[1])    # Mike
print(people)       # ["Tom", "Mike", "Bob"]

Descompunerea listei

Python permite descompunerea unei liste în elemente individuale:

people = ["Tom", "Bob", "Sam"]

tom, bob, sam = people

print(tom)      # Tom
print(bob)      # Bob
print(sam)      # Sam

În acest caz, variabilelor tom, bob și sam li se atribuie succesiv elementele din lista people. Cu toate acestea, trebuie să ținem cont că numărul variabilelor trebuie să fie egal cu numărul elementelor din lista atribuită.

Parcurgerea elementelor

Pentru a parcurge elementele, se pot folosi atât ciclul for, cât și ciclul while.

Parcurgerea folosind ciclul for:

people = ["Tom", "Sam", "Bob"]
for person in people:
   print(person)

Aici se va parcurge lista people, iar fiecare element al său va fi plasat în variabila person.

Parcurgerea se poate face și folosind ciclul while:

people = ["Tom", "Sam", "Bob"]
i = 0
while i < len(people):
   print(people[i])    # aplicăm indexul pentru a obține elementul
   i += 1

Pentru parcurgerea cu ajutorul funcției len(), obținem lungimea listei. Cu ajutorul contorului i, se afișează câte un element, până când valoarea contorului devine egală cu lungimea listei.

Compararea listelor

Două liste sunt considerate egale dacă conțin același set de elemente:

numbers1 = [1, 2, 3, 4, 5]
numbers2 = list([1, 2, 3, 4, 5])
if numbers1 == numbers2:
   print("numbers1 este egală cu numbers2")
else:
   print("numbers1 nu este egală cu numbers2")

În acest caz, ambele liste vor fi egale.

Obținerea unei părți a listei

Dacă este necesar să obținem o anumită parte a listei, putem aplica o sintaxă specială, care poate lua următoarele forme:

• list[:end]: prin parametrul end se transmite indexul elementului până la care trebuie copiată lista
• list[start:end]: parametrul start indică indexul elementului de la care trebuie să începem să copiem elementele
• list[start:end:step]: parametrul step indică pasul, prin care vor fi copiate elementele din listă. În mod implicit, acest parametru este egal cu 1

people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"]

slice_people1 = people[:3]   # de la 0 până la 3
print(slice_people1)   # ["Tom", "Bob", "Alice"]

slice_people2 = people[1:3]   # de la 1 până la 3
print(slice_people2)   # ["Bob", "Alice"]

slice_people3 = people[1:6:2]   # de la 1 până la 6 cu pasul 2
print(slice_people3)   # ["Bob", "Sam", "Bill"]

Se pot folosi indexuri negative, atunci numărătoarea va porni de la sfârșit, de exemplu, -1 - penultimul, -2 - al treilea de la sfârșit și așa mai departe.

people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"]

slice_people1 = people[:-1]   # de la penultimul până la primul
print(slice_people1)   # ["Tom", "Bob", "Alice", "Sam", "Tim"]

slice_people2 = people[-3:-1]   # de la al treilea de la sfârșit până la penultimul
print(slice_people2)   # ["Sam", "Tim"]

Metode și funcții pentru lucrul cu liste

Pentru gestionarea elementelor, listele au o serie de metode. Unele dintre ele sunt:

• append(item): adaugă elementul item la sfârșitul listei
• insert(index, item): adaugă elementul item în listă la indexul index
• extend(items): adaugă un set de elemente items la sfârșitul listei
• remove(item): elimină elementul item. Este eliminată doar prima apariție a elementului. Dacă elementul nu este găsit, generează o excepție ValueError
• clear(): elimină toate elementele din listă
• index(item): returnează indexul elementului item. Dacă elementul nu este găsit, generează o excepție ValueError
• pop([index]): elimină și returnează elementul de la indexul index. Dacă indexul nu este transmis, elimină pur și simplu ultimul element
• count(item): returnează numărul de apariții ale elementului item în listă
• sort([key]): sortează elementele. În mod implicit, sortează în ordine crescătoare. Dar cu ajutorul parametrului key, putem transmite o funcție de sortare
• reverse(): inversează ordinea elementelor din listă
• copy(): copiază lista

În plus, Python oferă o serie de funcții încorporate pentru lucrul cu liste:

• len(list): returnează lungimea listei
• sorted(list, [key]): returnează lista sortată
• min(list): returnează cel mai mic element din listă
• max(list): returnează cel mai mare element din listă

Adăugarea și eliminarea elementelor

Pentru adăugarea unui element, se folosesc metodele append(), extend și insert, iar pentru eliminare - metodele remove(), pop() și clear().

Utilizarea metodelor:

people = ["Tom", "Bob"]

# adăugăm la sfârșitul listei
people.append("Alice")  # ["Tom", "Bob", "Alice"]
# adăugăm pe a doua poziție
people.insert(1, "Bill")  # ["Tom", "Bill", "Bob", "Alice"]
# adăugăm setul de elemente ["Mike", "Sam"]
people.extend(["Mike", "Sam"])      # ["Tom", "Bill", "Bob", "Alice", "Mike", "Sam"]
# obținem indexul elementului
index_of_tom = people.index("Tom")
# eliminăm după acest index
removed_item = people.pop(index_of_tom)     # ["Bill", "Bob", "Alice", "Mike", "Sam"]
# eliminăm ultimul element
last_item = people.pop()     # ["Bill", "Bob", "Alice", "Mike"]
# eliminăm elementul "Alice"
people.remove("Alice")      # ["Bill", "Bob", "Mike"]
print(people)       # ["Bill", "Bob", "Mike"]
# eliminăm toate elementele
people.clear()
print(people)       # []

Verificarea existenței unui element

Dacă un anumit element nu este găsit, metodele remove și index generează o excepție. Pentru a evita această situație, înainte de a efectua o operație cu elementul, se poate verifica existența acestuia folosind cuvântul cheie in:

people = ["Tom", "Bob", "Alice", "Sam"]

if "Alice" in people:
   people.remove("Alice")
print(people)       # ["Tom", "Bob", "Sam"]

Expresia if "Alice" in people returnează True dacă elementul "Alice" există în lista people. Astfel, construcția if "Alice" in people poate executa blocul de instrucțiuni ulterior în funcție de existența elementului în listă.

Eliminarea cu ajutorul del

Python acceptă, de asemenea, un alt mod de a elimina elemente dintr-o listă - folosind operatorul del. Ca parametru, acest operator primește elementul eliminat sau un set de elemente:

people = ["Tom", "Bob", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[1] # eliminăm al doilea element print(people) # ["Tom", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[:3] # eliminăm până la al patrulea element, exclusiv print(people) # ["Bill", "Kate", "Mike"] del people[1:] # eliminăm de la al doilea element încolo print(people) # ["Bill"]

Modificarea unei subliste

Pentru a modifica o sublistă - un set de elemente dintr-o listă, se poate folosi sintaxa discutată anterior [start:end]:

nums = [10, 20, 30, 40, 50]
nums[1:4]=[11, 22]
print(nums)     # [10, 11, 22, 50]

Aici, expresia nums[1:4] se referă de fapt la sublista [20, 30, 40]. Atribuirea acestei subliste la lista [11, 22] permite înlocuirea elementelor de la indexul 1 la 4 inclusiv cu elementele [11, 22]. După modificare, obținem lista [10, 11, 22, 50].

Numărarea aparițiilor

Dacă este necesar să aflăm de câte ori este prezent un anumit element într-o listă, putem folosi metoda count():

people = ["Tom", "Bob", "Alice", "Tom", "Bill", "Tom"]

people_count = people.count("Tom")
print(people_count)      # 3

Sortarea

Pentru sortare în ordine crescătoare, se folosește metoda sort():

people = ["Tom", "Bob", "Alice", "Sam", "Bill"]

people.sort()
print(people)      # ["Alice", "Bill", "Bob", "Sam", "Tom"]

Dacă este necesar să sortăm datele în ordine inversă, putem aplica metoda reverse() după sortare:

people = ["Tom", "Bob", "Alice", "Sam", "Bill"]

people.sort()
people.reverse()
print(people)      # ["Tom", "Sam", "Bob", "Bill", "Alice"]

În timpul sortării, se compară practic două obiecte, iar cel care este "mai mic" este plasat înaintea celui care este "mai mare". Conceptele de "mai mare" și "mai mic" sunt destul de relative. Și dacă pentru numere totul este simplu - numerele sunt plasate în ordine crescătoare, pentru șiruri de caractere și alte obiecte situația este mai complicată.

În special, șirurile de caractere sunt evaluate pe baza primelor caractere. Dacă primele caractere sunt egale, sunt evaluate cele de-al doilea caractere și așa mai departe. În plus, un simbol numeric este considerat "mai mic" decât un simbol alfabetic cu majuscule, iar un simbol cu majuscule este considerat mai mic decât unul cu litere mici.

Astfel, dacă în listă se combină șiruri de caractere cu majuscule și minuscule, putem obține rezultate care nu sunt neapărat corecte, deoarece pentru noi șirul "bob" ar trebui să fie înaintea șirului "Tom". Și pentru a modifica comportamentul standard al sortării, putem transmite în metoda sort() o funcție ca parametru:

people = ["Tom", "bob", "alice", "Sam", "Bill"]

people.sort()       # sortare standard
print(people)      # ["Bill", "Sam", "Tom", "alice", "bob"]

people.sort(key=str.lower)  # sortare fără a ține cont de majuscule
print(people)      # ["alice", "Bill", "bob", "Sam", "Tom"]

Pe lângă metoda sort, putem folosi funcția încorporată sorted, care are două forme:

• sorted(list): sortează lista list
• sorted(list, key): sortează lista list, aplicând o funcție key elementelor

people = ["Tom", "bob", "alice", "Sam", "Bill"]

sorted_people = sorted(people, key=str.lower)
print(sorted_people)      # ["alice", "Bill", "bob", "Sam", "Tom"]

Când folosim această funcție, trebuie să avem în vedere că aceasta nu modifică lista sortată, ci toate elementele sortate sunt plasate într-o nouă listă, care este returnată ca rezultat.

Filtrarea listei

Pentru a filtra o listă, se folosește funcția filter(), căreia i se transmite o funcție-condiție și lista care trebuie filtrată:

filter(fun, iter)

Funcția acceptă doi parametri:

• fun: funcția-condiție, căreia i se transmite fiecare element al colecției și care returnează True dacă elementul îndeplinește condiția. Altfel, returnează False
• iter: colecția care urmează să fie filtrată

Ca rezultat, funcția returnează lista elementelor filtrate. De exemplu, obținem dintr-o listă de numere toate valorile mai mari de 1:

numbers = [-5, -4, -3 ,-2, -1, 0, 1, 2, 3, 4, 5]

def condition(number): return number > 1

result = filter(condition, numbers)

for n in result: print(n, end=" ")      # 2 3 4 5

Aici se filtrează lista numbers. Pentru filtrare, definim funcția condition, în care ca parametru se transmite fiecare element din lista numbers. Rezultatul funcției este True dacă numărul este mai mare de 1 sau False dacă numărul este mai mic de 2.

Rezultatul funcției filter este lista filtrată.

În loc să definim o funcție-condiție separată, dacă condiția este scurtă, este convenabil să folosim expresii lambda în astfel de cazuri:

numbers = [-5, -4, -3 ,-2, -1, 0, 1, 2, 3, 4, 5]

result = filter(lambda n: n > 1, numbers)

for n in result: print(n, end=" ")      # 2 3 4 5

În mod similar, putem filtra listele de obiecte mai complexe:

class Person:
   def __init__(self, name, age):
       self.name = name
       self.age = age

people = [ Person("Tom", 38), Person("Kate", 31), Person("Bob", 42),
       Person("Alice", 34),  Person("Sam", 25) ]

# filtrarea elementelor care au age > 33
view = filter(lambda p: p.age > 33, people)

for person in view:
   print(f"Name: {person.name} Age: {person.age}")

În acest caz, filtrăm lista de obiecte Person, așa că în funcția-condiție/expresia lambda se transmite ca parametru fiecare obiect Person din listă. Fiecare obiect Person stochează un nume (name) și o vârstă (age), iar aici selectăm toate persoanele care au vârsta mai mare de 33 de ani.

Proiecția listei

Pentru proiecția/conversia elementelor unei liste, se folosește funcția map(), căreia i se transmite o funcție-condiție și lista care trebuie filtrată:

map(fun, iter)

Funcția acceptă doi parametri:

• fun: funcția de conversie, căreia i se transmite fiecare element al colecției
• iter: colecția de elemente care trebuie parcursă

Ca rezultat, funcția returnează lista valorilor care au fost obținute după aplicarea funcției de conversie. De exemplu, transformăm o listă de numere într-o listă a pătratelor acestora:

numbers = [ 1, 2, 3, 4, 5]

def square(number): return number * number

result = map(square, numbers)

for n in result: print(n, end=" ")      # 1 4 9 16 25

Ca funcție de conversie aici, apare funcția square, căreia i se transmite un număr din listă și care returnează pătratul acestuia.

De asemenea, ca funcție de conversie, se pot folosi expresii lambda:

numbers = [ 1, 2, 3, 4, 5]

result = map(lambda n: n * n, numbers)

for n in result: print(n, end=" ")      # 1 4 9 16 25

În mod similar, putem transforma colecții de obiecte mai complexe:

class Person:
   def __init__(self, name, age):
       self.name = name
       self.age = age

people = [ Person("Tom", 38), Person("Kate", 31), Person("Bob", 42),
       Person("Alice", 34),  Person("Sam", 25) ]

# obținem din Person un șir cu numele
view = map(lambda p: p.name, people)

for person in view:
   print(person)

Aici, proiecția se aplică listei de obiecte Person. Funcția de conversie primește fiecare obiect Person și returnează valoarea atributului său name. Adică, lista rezultată va conține un set de șiruri de caractere (atributele name ale tuturor obiectelor Person). Afișare în consolă:

Tom
Kate
Bob
Alice
Sam

Valorile minime și maxime

Funcțiile încorporate Python min() și max() permit găsirea valorilor minime și maxime, respectiv:

numbers = [9, 21, 12, 1, 3, 15, 18]
print(min(numbers))     # 1
print(max(numbers))     # 21

Copierea listelor

Când copiem liste, trebuie să avem în vedere că listele reprezintă un tip mutabil, așa că dacă ambele variabile vor indica aceeași listă, modificarea unei variabile va afecta și cealaltă variabilă:

people1 = ["Tom", "Bob", "Alice"]
people2 = people1
people2.append("Sam")   # adăugăm un element în a doua listă
# people1 și people2 indică aceeași listă
print(people1)   # ["Tom", "Bob", "Alice", "Sam"]
print(people2)   # ["Tom", "Bob", "Alice", "Sam"]

Aceasta este așa-numita "copiere superficială" (shallow copy). Și, de regulă, un astfel de comportament nu este de dorit. Pentru a copia elementele, dar pentru ca variabilele să indice liste diferite, trebuie să facem o copiere profundă (deep copy). Pentru aceasta, putem folosi metoda copy():

people1 = ["Tom", "Bob", "Alice"]
people2 = people1.copy()    # copiem elementele din people1 în people2
people2.append("Sam")   # adăugăm un element DOAR în a doua listă
# people1 și people2 indică liste diferite
print(people1)   # ["Tom", "Bob", "Alice"]
print(people2)   # ["Tom", "Bob", "Alice", "Sam"]

Unirea listelor

Pentru unirea listelor se folosește operația de adunare +:

people1 = ["Tom", "Bob", "Alice"]
people2 = ["Tom", "Sam", "Tim", "Bill"]
people3 = people1 + people2
print(people3)   # ["Tom", "Bob", "Alice", "Tom", "Sam", "Tim", "Bill"]

Liste de liste

Listele, pe lângă datele standard de tip șiruri de caractere, numere, pot conține și alte liste. Astfel de liste pot fi asociate cu tabele, unde listele imbricate joacă rolul de rânduri. De exemplu:

people = [
   ["Tom", 29],
   ["Alice", 33],
   ["Bob", 27]
]

print(people[0])         # ["Tom", 29]
print(people[0][0])      # Tom
print(people[0][1])      # 29

Pentru a accesa un element dintr-o listă imbricată, este necesar să folosim o pereche de indici: people[0][1] - accesarea celui de-al doilea element al primei liste imbricate.

Adăugarea, eliminarea și modificarea unei liste generale, precum și a listelor imbricate, se face similar cu listele obișnuite (unidimensionale):

people = [["Tom", 29], ["Alice", 33], ["Bob", 27]]\n\n# crearea unei liste imbricate\nperson = list()\nperson.append("Bill")\nperson.append(41)\n# adăugarea listei imbricate\npeople.append(person)\n\nprint(people[-1])  # ["Bill", 41]\n\n# adăugarea unui element în lista imbricată\npeople[-1].append("+79876543210")\n\nprint(people[-1])  # ["Bill", 41, "+79876543210"]\n\n# eliminarea ultimului element din lista imbricată\npeople[-1].pop()\nprint(people[-1])  # ["Bill", 41]\n\n# eliminarea întregii liste imbricate\npeople.pop(-1)\n\n# modificarea primului element\npeople[0] = ["Sam", 18]\nprint(people)  # [["Sam", 18], ["Alice", 33], ["Bob", 27]]

Parcurgerea listelor imbricate:

people = [
   ["Tom", 29],
   ["Alice", 33],
   ["Bob", 27]
]

for person in people:
   for item in person:
       print(item, end=" | ")

Afișare în consolă:

Tom | 29 | Alice | 33 | Bob | 27 |