Introducere în Python
Varianta rulabilă a fișierului curent poate fi accesată aici: Introducere în Python
Python este un limbaj de programare simplu. Nu folosim ; la final de instrucțiune, ci terminăm instrucțiunile la final de rând. Nu folosim {} pentru a secvenția bucăți de cod, ci le scriem după :. Ce este foarte important, în schimb, este indentarea. Pentru a declara că o bucată de cod se află în interiorul unei funcții, clase, instrucțiuni etc. aceasta trebuie să fie aliniată cu un tab în plus față de header:
if True:
print("Sunt într-un if!")
print("Sunt înafara if-ului!")
Output:
Sunt într-un if!
Sunt înafara if-ului!
Curs 1
Afișare “pe ecran”
Observați afișările de mai sus. Folosind funcția print putem afișa orice tip de date pus între paranteze. Nu este obligatoriu să afișăm o singură variabilă, putem afișa oricât de multe dacă punem , între ele:
print()
print('Ana are mere.')
Output: Ana are mere.
print(3, 6 + 2)
Output: 3 8
Variabile
Toate variabilele în Python sunt obiecte. Asta înseamnă că le puteți atribui orice valoare fără a preciza tipul de date, și chiar să actualizați valoarea unei variabile cu un tip de date diferit fără probleme:
x = 3
y = 2.15
print(x, y)
x = "abc"
print(x)
Output:
3 2.15
abc
Tipuri de date
Putem considera fiecare variabila o cutie. Cutia are un nume (x, y etc.) si un element inauntru (23, “doi” etc.). Putem vedea tipul de date folosind functia type:
x = 23
type(x)
Output: int
y = 6.3
type(y)
Output: float
z = "doi"
type(z)
Output: str
Cele mai simple tipuri de date sunt cele de mai sus:
- int (integer) = numar intreg (fara virgula)
- float (floating point) = numar cu virgula
- char (character) = orice caracter de pe tastatura. In Python nu exista explicit, dar il avem in alte limbaje de programare
- str (string) = sir de caractere. Un cuvant, un paragraf etc.
Operatii
x = 23
y = 12
print("x =", x)
print("y =", y)
print("x + y =", x + y)
print("x - y =", x - y)
print("x * y =", x * y)
Output:
x = 23
y = 12
x + y = 35
x - y = 11
x * y = 276
Catul impartirii lui x la y:
print("x // y =", x // y)
Output: x // y = 1
Restul impartirii lui x la y:
print("x % y =", x % y)
Output: x % y = 11
Putem folosi catul si restul impartirii la 10 (sau multipli de 10) pentru a selecta diferite cifre din numar. De exemplu:
x = 65273
print("Cifra unitatilor:", x % 10)
print("Ultimele 2 cifre:", x % 100)
print("Ultimele 3 cifre:", x % 1000)
Output:
Cifra unitatilor: 3
Ultimele 2 cifre: 73
Ultimele 3 cifre: 273
print("Numarul fara cifra unitatilor:", x // 10)
print("Fara ultimele 2 cifre:", x // 100)
print("Fara ultimele 3 cifre:", x // 1000)
Output:
Numarul fara cifra unitatilor: 6527
Fara ultimele 2 cifre: 652
Fara ultimele 3 cifre: 65
Conversie de tip
a = input("Scrie un numar: ")
print(a, type(a))
Output: 34 <class 'str'>
b = int(a)
print(b, type(b))
Output: 34 <class 'int'>
Citire “de la tastatura”
Folosim funcția input pentru a citi o linie de la tastatură. Fiecare linie e citită ca un element de tip string (un text), chiar dacă are doar numere. Pentru a putea manipula ce am citit ca orice alt tip de date va trebui să îi facem conversie de tip.
x = input()
print(x, 'are tipul', type(x))
Output: 2 are tipul <class 'str'>
x = input()
y = int(x)
print('x =', x, 'are tipul', type(x))
print('int(x) =', y, 'are tipul', type(y))
Output:
x = 3 are tipul <class 'str'>
int(x) = 3 are tipul <class 'int'>
Citirea mai multor numere “de la tastatura”
x = input()
print("input:", x)
x = x.split()
print("x.split():", x)
a = x[0]
b = x[1]
print("a =", a, ", b =", b)
print("a + b =", a + b)
a = int(a)
b = int(b)
print("a + b =", a + b)
Output:
input: 3 56
x.split(): ['3', '56']
a = 3 , b = 56
a + b = 356
a + b = 59
Exerciții
sum00, Urare, scadere2, asii, uciv
Temă
Curs 2
Exerciții
Ridicarea la putere:
x = 2
y = 5
print("x ** y =", x ** y)
Output: x ** y = 32
Exerciții
Tipul de date float (numere raționale)
type(123.45)
Output: float
Conversie la tipul float:
a = "123.45"
print(a, type(a))
b = float(a)
print(b, type(b))
Output:
123.45 <class 'str'>
123.45 <class 'float'>
Exerciții
Temă
Toate problemele medii de la Operatori și Expresii
Curs 3
Tipul de date boolean
print(3 == 4, 3 != 4)
Output: False True
type(True)
Output: bool
| a | b | a and b | a or b |
|---|---|---|---|
| True | True | True | True |
| True | False | False | True |
| False | True | False | True |
| False | False | False | False |
Structura de decizie
if True:
print("Adevărat")
if 4 == 4:
print("egale")
else:
print("diferite")
Output: egale
a = 9
b = 3
if a > b:
print("mai mare")
elif a < b:
print("mai mic")
else:
print("egale")
Exerciții
Citește un număr de la tastatură. Afișează-l pe ecran dacă este strict mai mare decât 10.
Afișează DA dacă un număr e multiplu de 3, NU altfel.
Problema paritate:
Citește un număr n de la tastatură. Afișează pe ecran mesajul n este par dacă este par, respectiv n este impar în caz contrar (în locul literei “n” va apărea valoarea numărului, ca în exemplu).
Problema max2:
Citește 2 numere de la tastatură și afișează-l pe cel mai mare dintre ele.
Problema Interval2:
Citește 3 numere de la tastatură (a b x). Afișează DA dacă numărul x aparține intervalului [a, b] (este mai mare sau egal cu a și mai mic sau egal cu b) și NU altfel.
Parametrul end
print(3)
print(4)
print(3, end=' ')
print(4, end=' ')
print()
print(3, end=' * ')
print(4, end='!')
Structuri repetitive
for i in range(1, 3):
print("Happy Birthday!")
Output:
Happy Birthday!
Happy Birthday!
for i in range(1, 10, 1):
print(i, end=' ')
Output: 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 2):
print(i, end=' ')
Output: 1 3 5 7 9
for i in range(10, 0, -1):
print(i, end=' ')
Output: 10 9 8 7 6 5 4 3 2 1
Exerciții
Curs 4
Listele sunt seturi ordonate de elemente și se enumeră între paranteze pătrate.
Dacă adunăm două liste obținem concatenarea lor:
[1,2] + [3,4]
Output: [1, 2, 3, 4]
Dacă înmulțim o listă cu un număr n, obținem o listă nouă în care se repetă șirul inițial de n ori:
[1,2] * 4
Output: [1, 2, 1, 2, 1, 2, 1, 2]
Crearea unei liste
Se enumeră elementele între paranteze drepte, sau se folosește constructorul list care primește un obiect prin care se poate itera (precum un sir de caractere):
l1 = [1,2,3]
l2 = list("abc")
print(l1)
print(l2)
Output:
[1, 2, 3]
['a', 'b', 'c']
Funcțiile unei liste
Lungimea unei liste se calculează cu len(lista):
len([10,5,1])
Output: 3
Putem afla cel mai mare element dintr-o listă cu max(lista):
max([1, 10, 5])
Output: 10
Pentru șiruri de caractere maximul este luat lexicografic:
max(['ana', 'are', 'mere', 'și', 'pere'])
Output: 'și'
Putem afla cel mai mic element dintr-o listă folosind funcția min(lista):
min([20, 2, 3, 10])
Output: 2
Asemănător calculăm suma elementelor dintr-o listă:
sum([20, 10, 3])
Output: 33
Exerciții
Temă
Indicii unei liste
Indicii unei liste încep de la 0:
l = [10, 5, 1]
print('l[0] :', l[0])
print('l[2] :', l[2])
Output:
l[0] : 10
l[2] : 1
Putem folosi și indici negativi. Indicii negativi îi putem considera pornind de la dreapta spre stânga începând cu -1, și tot avansând cu 1 spre stânga:
l = [10, 5, 1]
print('l[-1] :', l[-1])
print('l[-2] :', l[-2])
print('l[-3] :', l[-3])
Output:
l[-1] : 1
l[-2] : 5
l[-3] : 10
Adăugarea elementelor într-o listă
La finalul listei - metoda append(element):
l = [10, 7, 3, 5]
l.append(2)
print(l)
Output: [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)
Output: [10, 122, 7, 3, 5]
Ștergerea elementelor dintr-o listă
Pentru a șterge elementul de la poziția indice: pop(indice). Utilizarea fără argumente este echivalentă apelării cu indicele -1 (ultimul element):
l = [10, 7, 3, 5]
l.pop(2)
print(l)
Output: [10, 7, 5]
Fără parametri:
l=[10,7,3,5]
l.pop()
print(l)
Output: [10, 7, 3]
Putem șterge prima instanță a unui anumit element: remove(element):
l = [10, 7, 3, 5]
l.remove(7)
print(l)
Output: [10, 3, 5]
Sortarea unei liste
Sortarea unei liste se poate face simplu prin metoda sort():
l = [2, 1, 10, 4, 100, 17, 23]
l.sort()
print(l)
Output: [1, 2, 4, 10, 17, 23, 100]
Sortarea implicită este cea crescătoare. Pentru a sorta descrescător, putem folosi parametrul reverse al funcției sort cu valoarea True:
l = [2, 1, 10, 4, 100, 17, 23]
l.sort(reverse = True)
print(l)
Output: [100, 23, 17, 10, 4, 2, 1]
Putem sorta oricum dorim folosind aceeași funcție. De exemplu, pentru sortarea după ultima cifră a numerelor vom folosi funcția lambda:
l = [2, 1, 10, 4, 100, 17, 23]
l.sort(key = lambda x: x % 10)
print(l)
Output: [10, 100, 1, 2, 23, 4, 17]
Citirea unei liste de numere
l = list(map(int, input().split()))
print(l)
Output: [3, 4, 5]
Parcurgerea unei liste
Putem parcurge o listă în mai multe moduri. Operatorul in permite iterarea prin fiecare element al listei fără a cunoaște indicele elementului:
for elem in l:
print(elem)
Output:
10
5
1
Dacă ne interesează indicele elementului putem parcurge lista folosindu-ne de accesul direct al elementului prin indice:
for i in range(len(l)):
print(l[i])
Output:
10
5
1
Putem itera printr-o listă folosind enumerate(lista) care este un generator prin care obținem pe rând tupluri de forma (indice, lista[indice]) - indicele din listă și elementul corespunzător acestuia:
for i, elem in enumerate(l):
print(i, elem)
Output:
0 3
1 4
2 5
Exerciții
Curs 5
Subliste (sliceuri)
Pentru a obține o sublistă dintr-o listă putem folosi notația l[indiceStart:indiceFinal] care va oferi sublista cu elementele din lista inițială cuprinse între pozițiile indiceStart inclusiv și indiceFinal exclusiv.
Dacă dorim un mod de parcurgere a listei diferit de cel implicit, pentru a crea sublista, putem adăuga și parametrul de iterare: l[indiceStart:indiceFinal:iterator].
Astfel se va porni de la indicele de Start, punând elementul corespunzător în sublistă, si la indiceStart se va aduna apoi iteratorul, generând urmatorul element din sublistă. Procedeul se va repeta până se ajunge la un indice mai mare sau egal cu indicele final (pentru această ultimă valoare care depășește limita dată de indicele final nu se mai generează element în sublistă).
Oricare dintre cele trei argumente poate lipsi, caz în care se iau valorile implicite - indiceStart ia valoarea 0, indiceFinal ia lungimea listei și iteratorul devine 1.
Exemple:
l = list(range(10))
l
Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list(range(2, 8, 2))
Output: [2, 4, 6]
l[2:8]
Output: [2, 3, 4, 5, 6, 7]
l[2:8:2]
Output: [2, 4, 6]
l[-1:-7]
Output: []
l[-1:-7:-1]
Output: [9, 8, 7, 6, 5, 4]
l[8:2:-1]
Output: [8, 7, 6, 5, 4, 3]
l[:5]
Output: [0, 1, 2, 3, 4]
l[4:]
Output: [4, 5, 6, 7, 8, 9]
l[:]
Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Observați că putem folosi și indici negativi, dar dacă vrem o parcurgere de la dreapta la stânga, trebuie să folosim un iterator negativ.
Întrucât toate variabilele în Python sunt obiecte, puteți crea o listă cu variabile de tipuri diferite:
l = ['z', 1, "mac-mac", 3.14, []]
print(l)
Output: ['z', 1, 'mac-mac', 3.14, []]
Pentru următoarele exemple încercați să vă dați seama ce o să afișeze înainte de a le apela:
print(l[1:3])
print(l[3:])
print(l[:3])
print(l[1:9:2])
print(l[-2])
print(l[:-1])
Output:
[1, 'mac-mac']
[3.14, []]
['z', 1, 'mac-mac']
[1, 3.14]
3.14
['z', 1, 'mac-mac', 3.14]
Exerciții
Folosind doar slice-uri, afișează elementele listei date în ordine inversă.
Soluție:
# Soluție
l[::-1]
Output: [[], 3.14, 'mac-mac', 1, 'z']
List comprehension
Au sintaxa de forma:
[expresie for element in obiect_iterabil]
caz in care se va genera o listă cu același număr de elemente precum obiectul iterabil, sau:
[expresie for element in obiect_iterabil if conditie]
caz în care va avea în listă doar elementele din obiectul iterabil care îndeplinesc condiția.
Exemple:
l = [2, 7, 5, 23, 10]
Lista cu dublul elementelor lui l:
l = []
for i in range(1, 10):
l.append(i)
print(l)
Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]
l = list(range(1, 10))
print(l)
Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]
l = [i for i in range(1, 10)]
print(l)
Output: [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)
Output: [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
Output: [[2, 7], [7, 5], [5, 23], [23, 10]]
Lista produsului cartezian:
l3 = [[x, y] for x in l for y in l]
l3
Output:
[[2, 2], [2, 7], [2, 5], [2, 23], [2, 10],
[7, 2], [7, 7], [7, 5], [7, 23], [7, 10],
[5, 2], [5, 7], [5, 5], [5, 23], [5, 10],
[23, 2], [23, 7], [23, 5], [23, 23], [23, 10],
[10, 2], [10, 7], [10, 5], [10, 23], [10, 10]]
Lista elementelor pare:
l4 = [x for x in l if x % 2 == 0]
l4
Output: [2, 10]
Crearea unei matrici folosind comprehensions. Putem folosi un comprehension cu for dublu. De exemplu dacă dorim o matrice formată doar din 0-uri:
l = [[0] * 5 for _ in range(10)]
print(l)
Output: [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], ...]
Atenție, frecvent se face greșeala următoare:
l = [[0] * 5] * 10
print(l)
l[0][0] = 111
print(l)
Output:
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], ...]
[[111, 0, 0, 0, 0], [111, 0, 0, 0, 0], ...]
Observați cum s-a schimbat primul element în fiecare listă?
Atunci cand apelăm lista * n, unde n e un număr natural nenul, se copiază elemente din listă de n ori. Problema apare când avem o listă de obiecte, deoarece se copiază referențele către acele obiecte. Practic am avut [lista_de_0] * 10, care a dus la o listă cu 10 referințe către aceeași lista de 0-uri, deci când am schimbat primul element din prima listă am văzut modificarea în toate cele 10 liste fiindcă de fapt sunt toate același obiect.
Varianta corectă:
l = [[0] * 5 for i in range(10)]
print(l)
l[0][0] = 111
print(l)
Output:
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], ...]
[[111, 0, 0, 0, 0], [0, 0, 0, 0, 0], ...]
Exerciții
Rezolvă folosind list comprehension:
Curs 6
Mulțimi
Mulțimile reprezintă seturi de elemente neordonate care nu acceptă duplicate.
Crearea unei mulțimi:
multime_vida = set()
print(multime_vida)
Output: set()
multime = {2, 3, 10, 8}
print(multime)
Output: {8, 3, 10, 2}
Observați că nu s-a păstrat ordinea din inițializarea mulțimii, fiindcă mulțimile sunt neordonate.
Pentru a obține cardinalul unei mulțimi se folosește funcția len():
len({2, 4, 10})
Output: 3
Pentru a adăuga un element într-o mulțime se folosește funcția add:
multime_vida.add(5)
multime_vida.add(8)
print(multime_vida)
Output: {8, 5}
Pentru a reuni 2 mulțimi se folosește funcția union:
multime = multime.union(multime_vida)
print(multime)
Output: {2, 3, 5, 8, 10}
Mai multe funcții cu mulțimi găsiți aici.
my_set = set()
my_set.add(3)
print("My first set: ", my_set)
my_second_set = set([2, 6, 3, 2])
print("My second set: ", my_second_set)
print("Set union: ", my_set.union(my_second_set))
print("Set intersection: ", my_set.intersection(my_second_set))
Output:
My first set: {3}
My second set: {2, 3, 6}
Set union: {2, 3, 6}
Set intersection: {3}
Dicționare
Dicționarele reprezintă un set de perechi de chei și valori asociate. Cheile sunt unice în dicționar și trebuie să fie de tip immutable (pot fi stringuri, numere, tupluri etc., dar nu pot fi liste).
Pentru a crea un dicționar vid, folosim:
d = {}
Pentru a adăuga chei noi în dicționar, putem pur și simplu să le atribuim o valoare. Sintaxa este: dictionar[cheie] = valoare.
d["a"] = 100
d["b"] = 200
d["c"] = 300
print(d)
Output: {'a': 100, 'b': 200, 'c': 300}
Pentru a itera prin cheile unui dicționar putem folosi operatorul in:
for k in d:
print(k, d[k])
Output:
a 100
b 200
c 300
Pentru a verifica dacă o cheie se găsește într-un dicționar, putem folosi același operator:
print("a" in d)
print(100 in d)
Output:
True
False
sau să folosim metoda items() care returnează o listă cu tupluri de forma (cheie, valoare):
for k, v in d.items():
print(k, v)
Output:
a 100
b 200
c 300
Pentru a obține lista de chei putem folosi metoda keys() iar pentru lista de valori metoda values().
print(d.keys())
Output: dict_keys(['a', 'b', 'c'])
print(d.values())
Output: dict_values([100, 200, 300])
Mai multe funcții pe dicționare găsiți aici.
my_dict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print("My first dictionary: ", my_dict)
my_second_dict = dict(name = "John", age = 36)
print("My second dictionary: ", my_second_dict)
print()
my_second_dict["country"] = "Norway"
print("We can easily add new fields: ", my_second_dict)
my_second_dict["country"] = "Italy"
print("Or modify them: ", my_second_dict)
Output:
My first dictionary: {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}
My second dictionary: {'name': 'John', 'age': 36}
We can easily add new fields: {'name': 'John', 'age': 36, 'country': 'Norway'}
Or modify them: {'name': 'John', 'age': 36, 'country': 'Italy'}
Exerciții
Temă
Proiect
Scrie un meniu de cumparaturi. Pe ecran se va afisa o lista de produse si se va deschide un input in care utilizatorul va scrie ce produs isi doreste sa cumpere.
Pentru input gresit se va afisa mesaj de eroare.
Pentru input corect utilizatorul va fi intrebat cate produse isi doreste si va fi acceptat doar input numeric in intervalul 1-100.
Programul se va opri la citirea inputului “exit” si va afisa lista de cumparaturi si pretul total al acestora.