Liste și tablouri bidimensionale
Liste
O listă este o colecție ordonată și mutabilă de elemente. "Ordonată" înseamnă că elementele au o ordine fixă (primul, al doilea, etc.), iar "mutabilă" înseamnă că poți modifica lista după ce ai creat-o.
Listele se scriu între paranteze pătrate [] și pot conține elemente de orice tip:
Operații de bază cu liste
Dacă aduni două liste, obții concatenarea lor (lipirea):
[1,2] + [3,4]
[1, 2, 3, 4]
Dacă înmulțești o listă cu un număr n, obții o listă nouă în care șirul inițial se repetă de n ori:
[1,2] * 4
[1, 2, 1, 2, 1, 2, 1, 2]
Crearea listelor
Poți enumera elementele între paranteze drepte sau folosi constructorul list():
# Listă goală
lista_goala = []
lista_goala = list()
# Listă cu elemente
numere = [1, 2, 3, 4, 5]
fructe = ["măr", "pară", "banană"]
mixta = [1, "text", 3.14, True]
# Listă din range
numere = list(range(1, 6)) # [1, 2, 3, 4, 5]
# Listă din string
l1 = [1,2,3]
l2 = list("abc")
print(l1)
print(l2)
[1, 2, 3]
['a', 'b', 'c']
Întrucât toate variabilele în Python sunt obiecte, poți crea o listă cu variabile de tipuri diferite:
l = ['z', 1, "mac-mac", 3.14, []]
print(l)
['z', 1, 'mac-mac', 3.14, []]
Funcții pentru liste
Lungimea unei liste se calculează cu len(lista):
len([10,5,1])
3
Cel mai mare element dintr-o listă cu max(lista):
max([1, 10, 5])
10
Pentru șiruri de caractere, maximul este luat lexicografic (ordine alfabetică):
max(['ana', 'are', 'mere', 'și', 'pere'])
'și'
Cel mai mic element cu min(lista):
min([20, 2, 3, 10])
2
Suma elementelor dintr-o listă:
sum([20, 10, 3])
33
numere = [3, 1, 4, 1, 5, 9, 2, 6]
len(numere) # 8 (lungimea)
min(numere) # 1 (minimul)
max(numere) # 9 (maximul)
sum(numere) # 31 (suma)
sorted(numere) # [1, 1, 2, 3, 4, 5, 6, 9] (returnează listă nouă sortată)
Accesarea elementelor (Indicii)
Indexarea începe de la 0. Primul element e la indexul 0, al doilea la indexul 1, etc.
l = [10, 5, 1]
print('l[0] :', l[0])
print('l[2] :', l[2])
l[0] : 10
l[2] : 1
Poți folosi și indici negativi care numără de la sfârșit. -1 e ultimul element, -2 penultimul, etc.:
l = [10, 5, 1]
print('l[-1] :', l[-1])
print('l[-2] :', l[-2])
print('l[-3] :', l[-3])
l[-1] : 1
l[-2] : 5
l[-3] : 10
Verificări
numere = [1, 2, 3, 4, 5]
3 in numere # True
10 in numere # False
10 not in numere # True
Adăugarea elementelor într-o listă
La finalul listei - metoda append(element):
l = [10, 7, 3, 5]
l.append(2)
print(l)
[10, 7, 3, 5, 2]
La o poziție dată - metoda insert(indice, element):
l = [10, 7, 3, 5]
l.insert(1, 122)
print(l)
[10, 122, 7, 3, 5]
Ștergerea elementelor dintr-o listă
Pentru a șterge elementul de la o poziție: pop(indice). Fără argumente, șterge ultimul element:
l = [10, 7, 3, 5]
l.pop(2)
print(l)
[10, 7, 5]
Fără parametri:
l=[10,7,3,5]
l.pop()
print(l)
[10, 7, 3]
Pentru a șterge prima apariție a unui element: remove(element):
l = [10, 7, 3, 5]
l.remove(7)
print(l)
[10, 3, 5]
Metode utile
| Metodă | Descriere |
|---|---|
append(x) |
Adaugă x la final |
insert(i, x) |
Inserează x la indexul i |
extend(lista) |
Adaugă elementele din lista |
remove(x) |
Șterge prima apariție a lui x |
pop(i) |
Șterge și returnează elementul de la indexul i |
clear() |
Golește lista |
index(x) |
Returnează indexul primei apariții a lui x |
count(x) |
Numără aparițiile lui x |
sort() |
Sortează lista (modifică lista originală) |
reverse() |
Inversează lista (modifică lista originală) |
copy() |
Returnează o copie a listei |
Sortarea unei liste
Metoda sort() sortează lista:
l = [2, 1, 10, 4, 100, 17, 23]
l.sort()
print(l)
[1, 2, 4, 10, 17, 23, 100]
Sortarea implicită este crescătoare. Pentru sortare descrescătoare, folosești parametrul reverse:
l = [2, 1, 10, 4, 100, 17, 23]
l.sort(reverse = True)
print(l)
[100, 23, 17, 10, 4, 2, 1]
Poți sorta și după un criteriu personalizat folosind funcții lambda. De exemplu, sortare după ultima cifră:
l = [2, 1, 10, 4, 100, 17, 23]
l.sort(key = lambda x: x % 10)
print(l)
[10, 100, 1, 2, 23, 4, 17]
Citirea unei liste de numere
l = list(map(int, input().split()))
print(l)
3 4 5
[3, 4, 5]
Parcurgerea unei liste
Mai multe moduri de a parcurge o listă:
Cu operatorul in:
for elem in l:
print(elem)
10
5
1
Folosind indexul:
for i in range(len(l)):
print(l[i])
10
5
1
Cu enumerate() care returnează atât indexul cât și elementul:
for i, elem in enumerate(l):
print(i, elem)
0 3
1 4
2 5
Subliste (Slicing)
Pentru a obține o parte dintr-o listă, folosești notația l[start:stop] care returnează elementele de la start până la stop-1:
l = list(range(10))
l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l[2:8]
[2, 3, 4, 5, 6, 7]
Poți adăuga și un pas: l[start:stop:pas]:
l[2:8:2]
[2, 4, 6]
l[-1:-7:-1]
[9, 8, 7, 6, 5, 4]
l[8:2:-1]
[8, 7, 6, 5, 4, 3]
l[:5]
[0, 1, 2, 3, 4]
l[4:]
[4, 5, 6, 7, 8, 9]
l[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l[::-1] # lista inversată
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
Dacă vrei parcurgere de la dreapta la stânga, trebuie să folosești un pas negativ.
List comprehension
O metodă concisă de a crea liste.
Sintaxa de bază:
[expresie for element in obiect_iterabil]
sau cu condiție:
[expresie for element in obiect_iterabil if conditie]
Exemple:
# Pătratele numerelor de la 1 la 5
patrate = [x**2 for x in range(1, 6)] # [1, 4, 9, 16, 25]
# Numere pare de la 0 la 10
pare = [x for x in range(11) if x % 2 == 0] # [0, 2, 4, 6, 8, 10]
l = [i for i in range(1, 10)]
print(l)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
l = [i if i < 5 else i + 1 for i in range(1, 10) if i % 2 == 0]
print(l)
[2, 4, 7, 9]
Lista cu perechile de vecini din l:
l2 = [[l[i], l[i + 1]] for i in range(len(l) - 1)]
l2
[[2, 7], [7, 5], [5, 23], [23, 10]]
Lista produsului cartezian:
l = [2, 7, 5, 23, 10]
l3 = [[x, y] for x in l for y in l]
Lista elementelor pare:
l4 = [x for x in l if x % 2 == 0]
l4
[2, 10]
Tablouri bidimensionale (Matrice)
Un tablou bidimensional este o listă de liste. Se folosește pentru a reprezenta matrice, grile, tabele.
Crearea matricelor
# Matrice 3x3 definită explicit
matrice = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# Matrice 3x4 de zerouri
linii, coloane = 3, 4
matrice = [[0] * coloane for _ in range(linii)]
# Matrice din input
n, m = 3, 3
matrice = []
for i in range(n):
rand = list(map(int, input().split()))
matrice.append(rand)
Greșeala frecventă la crearea matricelor
Atenție, frecvent se greșește astfel:
l = [[0] * 5] * 10
print(l)
l[0][0] = 111
print(l)
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], ...]
[[111, 0, 0, 0, 0], [111, 0, 0, 0, 0], ...]
Observi cum s-a schimbat primul element în toate listele?
Când apelezi lista * n, se copiază referințele către acele obiecte. Practic ai avut [lista_de_0] * 10, care a dus la o listă cu 10 referințe către aceeași listă de 0-uri. Când modifici un element, modificarea apare în toate.
Varianta corectă:
l = [[0] * 5 for i in range(10)]
print(l)
l[0][0] = 111
print(l)
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], ...]
[[111, 0, 0, 0, 0], [0, 0, 0, 0, 0], ...]
Accesarea elementelor
matrice = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# Element de pe linia i, coloana j
print(matrice[0][0]) # 1 (colț stânga-sus)
print(matrice[1][2]) # 6 (linia 1, coloana 2)
print(matrice[2][2]) # 9 (colț dreapta-jos)
# Acces la o linie întreagă
print(matrice[1]) # [4, 5, 6]
Dimensiuni
matrice = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]
]
numar_linii = len(matrice) # 3
numar_coloane = len(matrice[0]) # 4
Parcurgerea matricelor
matrice = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
n = len(matrice)
m = len(matrice[0])
# Parcurgere pe linii și coloane
for i in range(n):
for j in range(m):
print(matrice[i][j], end=" ")
print()
# Parcurgere simplificată
for linie in matrice:
for element in linie:
print(element, end=" ")
print()
Elemente speciale
n = len(matrice)
# Diagonala principală (i == j)
for i in range(n):
print(matrice[i][i])
# Diagonala secundară (i + j == n - 1)
for i in range(n):
print(matrice[i][n - 1 - i])
# Deasupra diagonalei principale (i < j)
for i in range(n):
for j in range(i + 1, n):
print(matrice[i][j])
# Sub diagonala principală (i > j)
for i in range(n):
for j in range(i):
print(matrice[i][j])
Operații comune
Suma tuturor elementelor
total = sum(sum(linie) for linie in matrice)
Suma pe linii și coloane
# Suma pe fiecare linie
sume_linii = [sum(linie) for linie in matrice]
# Suma pe fiecare coloană
sume_coloane = [sum(matrice[i][j] for i in range(n)) for j in range(m)]
Transpusa matricei
Transpusa înseamnă schimbarea liniilor cu coloanele:
transpusa = [[matrice[j][i] for j in range(n)] for i in range(m)]
Rotire 90° în sensul acelor de ceasornic
rotita = [[matrice[n - 1 - j][i] for j in range(n)] for i in range(m)]
Aplicație practică
# Verificare dacă o matrice este simetrică
def este_simetrica(matrice):
n = len(matrice)
for i in range(n):
for j in range(i + 1, n):
if matrice[i][j] != matrice[j][i]:
return False
return True
matrice = [
[1, 2, 3],
[2, 4, 5],
[3, 5, 6]
]
print(este_simetrica(matrice)) # True
Reprezentarea unei table de joc
# Inițializare tablă X și 0
tabla = [[" " for _ in range(3)] for _ in range(3)]
# Plasare
tabla[0][0] = "X"
tabla[1][1] = "0"
# Afișare
for linie in tabla:
print("|".join(linie))
print("-" * 5)
Exerciții
Liste de bază
Operații pe liste
List comprehension
Rezolvă folosind list comprehension: