PYTHON

CURS 1
INTRODUCERE

Python este limbaj de

programare de ultimă Python rulează pe
Necesită mai puține
A fost inventat în generație, ușor de diferite sisteme de
linii de cod în
1991 de Guido van învățat, ca urmare a operare: Windows,
comparație cu alte
Rossum; sintaxei simple Mac, Linux, Raspberry
limbaje;
similare cu limba Pi etc.;
engleză;

Limbajul poate fi Conține o bibliotecă Poate gestiona

Python se poate
utilizat în mai multe vastă de pachete: volume mari de date
conecta la baze de
medii (IDE): Eclipse, numpy, pandas, (big data) și efectua
date. Citește și
PyCharm, Thonny, matplotlib, scikit- operații matematice
modifică fișiere;
Netbeans etc.; learn etc. complexe.
 ELEMENTE DE SINTAXA
• Spre deosebire de alte limbaje (R, C+
+, Java, Perl etc.) care utilizeaza
paranteze, Python utilizeaza
indentarea (tab sau spatii);

• Doua puncte (:) , denota necesitatea

unei indentari;

• Nu solicita punct si virgula (;), dar

trebuie folosita atunci cand utilizam
mai multe declaratii pe aceeasi linie;

• comentariu pe linie (#), pe mai multe

linii (’ ’ ’).
 TIPURI DE DATE
• int, float, complex. Functia type() verifica tipul de data;
• Specificarea tipului de dată pentru o variabilă: int(), float(), complex(),
str();
• Siruri de caractere marcate cu ‘ ’ sau “ ”;
• Extragerea elementelor dintr-un sir: sir[ ];
• Cateva metode pentru siruri de caractere: sir.strip(), sir.strip(‘separator’),
len(sir), sir.lower(), sir.upper(), sir.replace(“ ”, “”);
• Variabilele nu necesita declarare explicita si sunt case-sensitive.
 COLECTII DE DATE - LISTE
• Liste - colecții de date care pot fi neomogene, ordonate și modificate, permit elemente
identice si sunt reprezentate utilizând [ ];
• Modificare element: lista[index] = valoare  index incepe de la 0;
• Numar elemente: len(lista);
• Adaugare element la sfarsitul listei: lista.append(element);
• Adaugare element la un anumit index: lista.insert(index,element);
• Eliminare element:
- lista.remove(element)elimina primul element daca in lista exista mai multe
elemente identice;
- lista.pop(index)  elimina ultimul element daca nu se specifica indexul;
- del lista[index];
• Golire lista: lista.clear();
• Sterge lista: del lista.
ACCESARE LISTE
seq = [7, 2, 3, 7, 5, 6, 0, 1]
print(seq[1:5])
#[2, 3, 7, 5]
seq[3:4] = [6, 3]
print(seq)
#[7, 2, 3, 6, 3, 5, 6, 0, 1]
seq[3:]=[6, 3]
print(seq)
#[7, 2, 3, 6, 3]
print(seq[:3])
#[7, 2, 3]
print(seq[3:])
#[6, 3]
print(seq[-4:])
#[2, 3, 6, 3]
print(seq[-4:-2])
#[2, 3]
print(seq[::2])
#[7, 3, 3]
print(seq[::-1])
#[3, 6, 3, 2, 7]
 #Exemplu 1
b = ['saw', 'small', 'He', 'foxes',
'six']
Metoda Descriere b.sort(reverse = True)
print(b)
append Adaugă un element la sfârșitul listei b.sort(key=len)
() print(b)

clear() Elimină toate elementele listei #['small', 'six', 'saw', 'foxes', 'He’]
copy() Crează o copie a listei #['He', 'six', 'saw', 'small', 'foxes']

count() Returnează numărul de apariții al #Exemplu 2

import bisect as bi
elementului în listă b = ['saw', 'small', 'He', 'foxes',
extend( Adăugă elemente la sfârșitul unei liste 'six']
)index() Returnează indexul unui element b.sort()
print(bi.bisect(b,'sell'))
insert() Adaugă un element la poziția specificată bi.insort(b,'sell')
pop() Elimină elementul de la poziția print(b)

specificată #3
remove Elimină elementul specificat #['He', 'foxes', 'saw', 'sell', 'six',
'small']
()
reverse Inversează ordinea elementelor în listă
()
sort() Sortează lista
COLECTII DE DATE
LISTE METODE
FUNCTII BUILD-IN ENUMERATE
b = ['saw', 'small', 'He', 'foxes', 'six']
for i, value in enumerate(b,3):
print(i, value)

lista = list(enumerate(b,1))
print(lista)

dictionar = dict(enumerate(b,1))
print(dictionar)

'''3 saw
4 small
5 He
6 foxes
7 six

[(1, 'saw'), (2, 'small'), (3, 'He'), (4, 'foxes'), (5, 'six’)]

{1: 'saw', 2: 'small', 3: 'He', 4: 'foxes', 5: 'six'}'''

 FUNCTII BUILD-IN RANGE
#range([start], stop[, step]) print(list(reversed(range(10))))
print(list(range(18))) #[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
print(list(range(5,18)))
print(list(range(5,18,2)))
b = ['saw', 'small', 'He', 'foxes', 'six']
b_len = len(b)
for i in range(0, b_len):
print(b[i])
def frange(start, stop, step):
i = start
while i <= stop:
yield round(i,2)
i += step
for i in frange(0.5, 1, 0.1):
print(i)
''''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
[5, 7, 9, 11, 13, 15, 17]
saw
small
He
foxes
six
0.5
0.6
0.7
0.8
0.9
1.0'''
 FUNCTII BUILD-IN ZIP
#zip face perechi de elementele unor liste, tupluri sau secvente pentru a genera o lista de tupluri
#Exercitiu 1
seq1 = ['one', 'two', 'three']
seq2 = ['cat', 'dogs', 'mice']
zipped = zip(seq1, seq2)
print(list(zipped))
# [('one', 'cat'), ('two', 'dogs'), ('three', 'mice')]

#Exercitiu 2
seq3 = [False, True]
print(list(zip(seq1, seq2, seq3)))
#[('one', 'cat', False), ('two', 'dogs', True)]

#Exercitiu 3
for i, (a, b) in enumerate(zip(seq1, seq2)):
print('{0}: {1}, {2}'.format(i, a, b))
'''0: one, cat
1: two, dogs
2: three, mice'''

lista_tupluri = [('Popescu', 'Alexandru'), ('Constantinescu', 'Maria'), ('Stan', 'Gigel')]

nume, prenume = zip(*lista_tupluri)
print(nume)
#('Popescu', 'Constantinescu', 'Stan')
print(prenume)
#('Alexandru', 'Maria', 'Gigel')
 COLECTII DE DATE - TUPLURI
• Tupluri - colecții de date neomogene, ordonate și nemodificabile, permit
elemente identice si sunt reprezentate utilizând
t =( tuple(['four',
) [1, 2], True])

• Accesare element: tuplu[index] t = ((7,1), [1, 2], 'mar', False)

lista = list(t)
• Utilizand tuple, pot fi transformate liste in tupluri
gen = range(10)
• Utilizand list, pot fi transformate tupluri in listeprint(tuple(gen))
print(list(gen))
• Listele si tuplurile pot fi concatenate cu + t = tuple(['four', [1, 2], True])
gen =tuple(range(10))
Metoda Descriere print(t+gen)
count() Returnează numărul de apariții l = ['four', [1, 2], True]
al elementului în tuplu gen1 =list(range(10))
print(l+gen1)
index() Returnează poziția unui element
în tuplu l1 = ['four', [1, 2], True]
gen1 =list(range(10))
l1.extend(gen1)
print(l1)
 COLECTII DE DATE - DICTIONARE
• Dicționare – colecții de date neordonate, modificabile și indexate. Nu sunt admise elemente
duplicate. Dicționarele sunt reprezentate prin { }, având elemente cheie-valoare;
• Accesare si Modificare valoare: dictionar[cheie] = valoare noua.

Metoda Descriere
clear() Elimină toate elementele din dicționar
copy() Returnează o copie a dicționarului
fromkeys() Returnează un dicționar cu chei valori specificate
get() Returnează valoarea pentru o anumită cheie
items() Returnează o listă conținând un tuplu pentru fiecare pereche
cheie-valoare
keys() Returnează o listă conținând cheile dicționarului
pop() Elimină elementul având o anumită cheie specificată
popitem() Elimină ultima pereche adăugată cheie-valoare
setdefault() Returnează valoarea pentru o cheie specificată. Dacă cheia nu
există, o adaugă
update() Actualizează dicționarul cu perechile cheie-valoare specificate
values() Returnează o listă cu toate valorile dicționarului
Exemple dictionare
empty_dict = {}
print(empty_dict)
d1 = {'a' : 'some value', 'b' : [1, 2, 3, 4]}
print(d1)
#{'a': 'some value', 'b': [1, 2, 3, 4]}
d1[7] = 'an integer'
print(d1)
#{'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}
print(d1['b'])
#[1, 2, 3, 4]
print('b' in d1)
#True
d1[5] = 'some value'
print(d1)
#{'a': 'some value','b': [1, 2, 3, 4],7: 'an integer',5: 'some value'}
d1['dummy'] = 'another value'
print(d1)
#{'a': 'some value','b': [1, 2, 3, 4],7: 'an integer',5: 'some value','dummy': 'another value'}
del d1[5]
print(d1)
#{'a': 'some value','b': [1, 2, 3, 4],7: 'an integer','dummy': 'another value'}
ret = d1.pop('dummy')
print(ret)
#'another value'
print(d1)
#{'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}
list(d1.keys())
#['a', 'b', 7]
list(d1.values())
#['some value', [1, 2, 3, 4], 'an integer']
d1.update({'b' : 'four', 'c' : 12})
print(d1)
#{'a': 'some value', 'b': 'four', 7: 'an integer', 'c': 12}
Exemple dictionare

#Exercitiu 1
#dictionare = colectii formate din doua tupluri
col2tup=dict(zip((0,1,2,3,4),(4,3,2,1,0)))
print(col2tup)
#{0: 4, 1: 3, 2: 2, 3: 1, 4: 0}
col2tup = dict(zip(range(5), reversed(range(5))))
print(col2tup)
#{0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

#Exercitiu 2
#clasificare lista de cuvinte pornind de la prima litera formand un dictionar de de liste
words = ['dig','apple', 'bat', 'corn', 'dog', 'bar', 'atom', 'book', 'cat', 'cattle']
by_letter = {}
for word in words:
letter = word[0]
if letter not in by_letter:
by_letter[letter] = [word]
else:
by_letter[letter].append(word)
print(by_letter)
#{'d': ['dig', 'dog'], 'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book'], 'c': ['corn', 'cat',
'cattle']}
print(dict(sorted(by_letter.items())))
#{'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book'], 'c': ['corn', 'cat', 'cattle'], 'd':
['dig', 'dog']}
COLECTII DE DATE - SETURI
• Seturi – colecții de date neordonate și neindexate. Nu sunt acceptate elemente identice. Seturile sunt
reprezentate prin { }. Se aseamana cu dictionarele, numai ca elementele nu sunt cheie-valoare.

Metoda Descriere
add() Adaugă un element
clear() Elimină toate elementele setului
copy() Returnează o copie a setului
difference() Returnează un set reprezentând diferența dintre două sau
mai multe seturi
difference_update() Elimină elementele dintr-un set care sunt conținute și de un
alt set specificat
discard() Elimină un element specificat
intersection() Returnează un set reprezentând intersecția a două seturi
intersection_update() Elimină elementele dintr-un set care nu sunt în alt set
isdisjoint() Arată dacă două seturi se intersectează sau nu
issubset() Arată dacă un set este inclus într-un alt set sau nu
issuperset() Arată dacă un set conține un alt set sau nu
pop() Elimină un element
remove() Elimină elementul specificat
symmetric_difference() Returnează un set cu elemente necomune celor doua seturi
symmetric_difference_up Inserează intr-un set diferențele dintre două seturi
date
Exemple seturi

print(set([2, 2, 2, 1, 3, 3]))
#{1, 2, 3}
print({2, 2, 2, 1, 3, 3})
#{1, 2, 3}

a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7, 8}
print(a.union(b)); print(a | b)
#{1, 2, 3, 4, 5, 6, 7, 8}
print(a)
print(a.intersection(b)); print(a & b)
#{3, 4, 5}
print(a^b)
#{1, 2, 6, 7, 8}
print(a.symmetric_difference_update(b))
print(a)
#{1, 2, 6, 7, 8}

my_data1 = [1, 2, 3, 4]
my_data2 = [4, 5]
my_set = {tuple(my_data1), tuple(my_data2)}
print(my_set)
#{(4, 5), (1, 2, 3, 4)}
Prelucrari colectii
strings = ['a', 'as', 'bat', 'car', 'dove', 'python']

#[expr for val in collection if condition]

print([x.upper() for x in strings if len(x) > 2])

rezultat = []
for i in strings:
if len(i) > 2:
rezultat.append(i.upper())
print(rezultat)
#['BAT', 'CAR', 'DOVE', 'PYTHON']

#dict = {key-expr : value-expr for value in collection if condition}

dict = {val : index for index, val in enumerate(strings)}
print(dict)
#{'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4, 'python': 5}

#set = {expr for value in collection if condition}

unique_lengths = {len(x) for x in strings}
print(unique_lengths)
#{1, 2, 3, 4, 6}

#nested lists
nume = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]
result = [name for names in nume for name in names if name.count('a') >= 2]
print(result)
#['Maria', 'Natalia’]

numere = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]

print([x for tup in numere for x in tup])
#[1, 2, 3, 4, 5, 6, 7, 8, 9]

print([[x for x in tup] for tup in numere])

#[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 OPERATORI ARITMETICI, ATRIBUIRE,
COMPARATIE
Operator Denumire Exemplu
+ Adunare x+y Operator Exemplu Echivalent
- Scădere x-y
= x=5 x=5
* Înmulțire x*y
/ Împărțire x/y
+= x += 3 x=x+3
% Restul împărțirii x%y -= x -= 3 x=x-3
** Exponențial x ** y *= x *= 3 x=x*3
// Partea întreagă a x // y /= x /= 3 x=x/3
împărțirii %= x %= 3 x=x%3
//= x //= 3 x = x // 3
Operato Denumire Exemplu
**= x **= 3 x = x ** 3
r
== Egal x == y
!= Diferit x != y
> Mai mare x >y
< Mai mic x <y
>= Mai mare sau x >= y
egal
<= Mai mic sau egal x <= y
OPERATORI LOGICI, IDENTITATE,
APARTENENTA
Operato Descriere Exemplu
r
and Returnează True dacă ambele expresii sunt adevărate x < 5 and x <
10
or Returnează True dacă cel puțin o expresie este x < 5 or x < 4
adevărată
Operato
not Descriere
Negația, inversează rezultatul returnând False dacă Exemplu
not(x < 5 and x
r rezultatul este adevărat < 10)
is Returnează True dacă ambele variabile sunt același x is y
obiect
Operato
is not Descriere
Returnează True dacă ambele variabile nu sunt același Exemplu
x is not y
r obiect
in Returnează True dacă o secvență cu o valoare x in y
specificată este prezentă în obiect
not in Returnează True dacă o secvență cu o valoare x not in y
specificată nu este prezentă în obiect
 FUNCTII
def my_function(x, y, z=1.5):
if z > 1:
return z * (x + y)
else:
return z / (x + y)
print(my_function(1,2,3))
#9
print(my_function(1,2))
#4.5
print(my_function(z=5, y=6, x=7))
#65
print(my_function(y=6, x=5, z=7))
#77
print(my_function(y=6, x=7))
#19.5

def f():
a = 5
b = 6
c = 7
return a, b, c
print(f())
print(list(f()))
print(set(f()))

def f():
a = 5
b = 6
c = 7
return {'a' : a, 'b' : b, 'c' : c}
print(f())
import re
states = [' Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda','south carolina## ', 'West
virginia?']
def clean_strings(strings):
result = []
for value in strings:
value = value.strip()
value = re.sub('[!#?%*]', '', value)
value = value.title()
result.append(value)
return result

print(clean_strings(states))
#['Alabama', 'Georgia', 'Georgia', 'Georgia', 'Florida', 'South Carolina', 'West Virginia']

def add(a, b):

return a + b

#map(function, iterables)
x = map(add, (0, 1, 2), (2, 1, 0))
print(list(x))

#functia anonima sau lambda

def my_f(x):
return x * 2
echivalent = lambda x: x * 2

print(echivalent(5))

strings = ['curs', 'seminar', 'abba', 'mere', 'pachete',' ' , 'software']

strings.sort(key=lambda x: len(set(list(x))))
print(strings)

add_five = lambda x: add(x,5)

print(add_five(20))
 GENERATOARE
def squares(n=10):
print('Generating squares from 1 to {0}'.format(n ** 2))
for i in range(1, n + 1):
yield i ** 2
gen = squares()
for x in gen:
print(x)

#echivalent cu
gen = (x ** 2 for x in range(1,11))
print(list(gen))

#generatorul poate fi argumentul unei functii

print(sum(x ** 2 for x in range(1,11)))
#385
print(dict((i, i **2) for i in range(5)))
#{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

import itertools
first_letter = lambda x: x[0]
names = ['Alan', 'Adam', 'Wes', 'Will', 'Albert', 'Steven', 'Simona', 'Ana']
names = sorted(names, key = first_letter)
for letter, names in itertools.groupby(names, first_letter):
print(letter, list(names)) # names este un generator
'''A ['Alan', 'Adam', 'Albert', 'Ana']
S ['Steven', 'Simona']
W ['Wes', 'Will']'''
STRUCTURA ALTERNATIVA (IF)
x= 10

if x < 0:
print('It is negative')
elif x == 0:
print('Equal to zero')
elif 0 < x < 5:
print('Positive but smaller than 5')
else:
print('Positive and larger than or equal to 5')
STRUCTURI REPETITIVE (FOR)
sequence = [1, 2, None, 4, None, 5]
total = 0
for value in sequence:
if value is None:
continue
total += value
print(total)

sequence = [1, 2, 0, 4, 6, 5, 2, 1]
total_until_5 = 0
for value in sequence:
if value == 5:
break
total_until_5 += value
print(total_until_5)

for i in range(4):
for j in range(4):
if j > i:
break
print((i, j))
STRUCTURI REPETITIVE (WHILE)
i = 1
while i < 6:
print(i)
if i == 3:
break
i += 1

i = 0
while i < 6:
i += 1
if i == 3:
continue
print(i)
BIBLIOGRAFIE

• Python for Data Analysis, DATA WRANGLING WITH PANDAS, NUMPY, AND
IPYTHON, Wes McKinney, 2nd edition, 2012, Ed. O’REILLY
• Data Science from Scratch, FIRST PRINCIPLES WITH PYTHON, Joel Grus,
2015, Ed. O’REILLY
• Python Data Science Handbook, ESSENTIAL TOOLS FOR WORKING WITH
DATA, Jake VanderPlas, 2016, Ed. O’REILLY
• Fundamentals of Python®: Data Structures, Kenneth A. Lambert, Cengage
Learning PTR, 2014