PYTHON

C O L E C T I I D E D AT E – C U R S 1
 INTRODUCERE (I)
• A fost inventat în 1991 de Guido van Rossum;
• Python este limbaj de programare de ultimă generație, ușor de
învățat, ca urmare a sintaxei simple similare cu limba engleză;
• Necesită mai puține linii de cod în comparație cu alte limbaje;
• Python rulează pe diferite sisteme de operare: Windows, Mac,
Linux, Ubuntu, Raspbian etc.;
• Limbajul poate fi utilizat în mai multe medii (IDE): Eclipse,
PyCharm, Thonny, Netbeans, Spyder etc.;
• Conține o bibliotecă vastă de pachete: numpy, pandas,
matplotlib, seaborn, scikit-learn etc.;
• Python se poate conecta la baze de date. Citește și modifică
fișiere;
• Poate gestiona volume mari de date (big data) și efectua
operații matematice complexe.
INTRODUCERE (II)
o Numpy seturi de date omogene,
o Pandas seturi de date neomogene,
o Scipy, Scikit Learn machine learning, IA,
o Keras rețele neuronale, deep learning, IA,
o Matplotlib, Seaborn, Bokeh reprezentare grafică,
o PyPSA pachete specializate pe domenii de
activitate, de exemplu funcționarea optimă pe
principii de piața a generatoarelor electrice,
o BeautifulSoup web-scraping,
o Flask (API-uri) etc.
 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

folosit atunci cand utilizam mai multe declaratii
pe aceeasi linie;

• Comentariu pe linie (#), pe mai multe linii (’ ’

’).
 TIPURI DE DATE
• Numerice: int, float, complex. Functia type() indica tipul de data;
• Specificarea tipului de dată pentru o variabilă: int(), float(), complex(), str();
• Siruri de caractere marcate cu ‘ ’ sau “ ”;
• Extragere elemente din sir: sir[ ], prin intermediul indexului;
• Metode pentru siruri de caractere:
sir.strip(), sir.strip(‘separator’),
len(sir), sir.lower(), sir.upper(), sir.replace(“ ”, “”);
• Variabilele nu necesita declarare explicita, dar sunt case-sensitive.
 COLECTII DE DATE - LISTE
• Liste - pot fi neomogene, ordonate și modificate, permit elemente identice, [ ];
• 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
1) seq = [7, 2, 3, 7, 5, 6, 0, 1] 4) print(seq[:3])
print(seq[1:5]) #[7, 2, 3]
#[2, 3, 7, 5]

2) seq[3:4] = [6, 3] 5) print(seq[-4:])

print(seq) #[2, 3, 6, 3]
#[7, 2, 3, 6, 3, 5, 6, 0, 1]

3) seq[3:]=[6, 3] 6)print(seq[::2])
print(seq) #[7, 3, 3]
#[7, 2, 3, 6, 3]
7) print(seq[::-1])
#[3, 6, 3, 2, 7]
 Metoda Descriere
append() Adaugă un element la sfârșitul listei
clear() Elimină toate elementele listei #Exemplu 1
copy() Crează o copie a listei b = ['saw', 'small', 'He', 'foxes',
count() Returnează numărul de apariții al elementului în 'six']
b.sort(reverse = True)
listă print(b)
extend() Adăugă elemente la sfârșitul unei liste b.sort(key=len)
print(b)
index() Returnează indexul unui element
insert() Adaugă un element la poziția specificată #['small', 'six', 'saw', 'foxes', 'He’]
pop() Elimină elementul de la poziția specificată #['He', 'six', 'saw', 'small', 'foxes']

remove() Elimină elementul specificat

reverse() Inversează ordinea elementelor în listă
sort() Sortează lista

COLECTII DE DATE
LISTE METODE
 COLECTII DE DATE - TUPLURI
• Tupluri - neomogene, ordonate și nemodificabile, permit elemente identice, ( )
• Accesare element: tuplu[index]
t = tuple(['four', [1, 2], True])
• Utilizand tuple, pot fi transformate liste in tupluri
t = ((7,1), [1, 2], 'mar', False)
• Utilizand list, pot fi transformate tupluri in liste lista = list(t)
• Listele si tuplurile pot fi concatenate cu + gen = range(10)
print(tuple(gen))
Metoda Descriere print(list(gen))
count() Returnează numărul de apariții al
elementului în tuplu: t. count(1) t = tuple(['four', [1, 2], True])
index() Returnează poziția unui element în gen =tuple(range(10))
tuplu: t.index(1) print(t+gen)

l = ['four', [1, 2], True]

gen1 =list(range(10))
l1 = ['four', [1, 2], True] print(l+gen1)
gen1 =list(range(10))
l1.extend(gen1)
print(l1)
 COLECTII DE DATE - DICTIONARE
• Dicționare – neordonate, modificabile. Nu sunt admise elemente duplicat. { }, 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
d1 = {'a' : 'some value', 'b' :
[1, 2, 3, 4]} del d1[5]
# adaugare element print(d1)
d1[7] = 'an integer' #{'a': 'some value','b': [1, 2, 3, 4],7:
print(d1) 'an integer','dummy': 'another value'}
#{'a': 'some value', 'b': [1, 2, ret = d1.pop('dummy')
3, 4], 7: 'an integer'} print(ret)
print(d1['b']) #'another value'
#[1, 2, 3, 4] print(d1)
print('b' in d1) #{'a': 'some value', 'b': [1, 2, 3, 4], 7:
#True 'an integer'}
d1[5] = 'some value' list(d1.keys())
print(d1) #['a', 'b', 7]
#{'a': 'some value','b': [1, 2, 3, list(d1.values())
4],7: 'an integer',5: 'some #['some value', [1, 2, 3, 4], 'an
value'} integer']
d1['dummy'] = 'another value' d1.update({'b' : 'four', 'c' : 12})
print(d1) print(d1)
#{'a': 'some value','b': [1, 2, 3, #{'a': 'some value', 'b': 'four', 7: 'an
4],7: 'an integer',5: 'some integer', 'c': 12}
value','dummy': 'another value'}

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 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 – neordonate, neindexate. Nu sunt acceptate elemente identice. { }. Se aseamana cu dictionarele.

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_update() Inserează intr-un set diferențele dintre două seturi
union() Returnează un set reprezentând reuniunea a două seturi
update() Actualizează setul cu reuniunea dintre un set și altele
Exemple seturi
my_data1 = [1, 2, 3, 4]
print(set([2, 2, 2, 1, 3, 3])) my_data2 = [4, 5]
#{1, 2, 3} my_set = {tuple(my_data1),
print({2, 2, 2, 1, 3, 3}) tuple(my_data2)}
#{1, 2, 3} print(my_set)
#{(4, 5), (1, 2, 3, 4)}
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}
 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
Operator Denumire Exemplu **= x **= 3 x = x ** 3
== Egal x == y
!= Diferit x != y
> Mai mare x>y
< Mai mic x<y
>= Mai mare sau egal x >= y
<= Mai mic sau egal x <= y
OPERATORI LOGICI, IDENTITATE,
APARTENENTA
Operator Descriere Exemplu
and Returnează True dacă ambele expresii sunt adevărate x < 5 and x < 10
or Returnează True dacă cel puțin o expresie este adevărată x < 5 or x < 4
not Negația, inversează rezultatul returnând False dacă rezultatul este not(x < 5 and x < 10)
adevărat

Operator Descriere Exemplu

is Returnează True dacă ambele variabile sunt același obiect x is y
is not Returnează True dacă ambele variabile nu sunt același obiect x is not y

Operator Descriere Exemplu

in Returnează True dacă o secvență cu o valoare specificată este x in y
prezentă în obiect
not in Returnează True dacă o secvență cu o valoare specificată nu este x not in y
prezentă în obiect
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)
ACCESARE DATE DIN FISIERE (I)
Fișiere: .txt, .csv, .xlsx, .json, .sas7bdat

Fișiere text

Funcția open() returnează un obiect de tip fișier. f = open("C:\Data1.txt")

Metoda read() citește conținutul fișierului. print(f.read())
Funcția open()care doi parametri: numele fișierului sau calea și modul în care poate fi accesat:
"r" - Read - implicit. Deschide fișierul pentru citire, apare eroare dacă fișierul nu există.
"a" - Append - Deschide fișierul pentru adăugare, creează fișierul dacă nu există.
"w" - Write - Deschide fișierul pentru scriere, creează fișierul dacă nu există.
"x" - Create - creează fișierul, apare eroare dacă fișierul există.
Suplimentar, se pot specifica:
"t" - Text - Implicit. Modul text
"b" - Binary - Modul binar (de ex. imagine)

•Metoda readline()citește o singură linie

•Poate fi specificat numărul de caractere afișate: read(100)
ACCESARE DATE DIN FISIERE (II)
Fișiere comma separated values (.csv)

- In colecții de tip lista

import csv
with open('clienti_leasing.csv', 'r') as f:
reader = csv.reader(f)
for row in reader:
print (row)
- In DataFrame de tip Pandas
import pandas as pd
df = pd.read_csv('clienti_leasing.csv')
print(df)

Fișiere SAS (.sas7bdat)

df = pd.read_sas('sas_data.sas7bdat')
 ACCESARE DATE DIN FISIERE (III)
Fișiere .xlsx

from xlrd import open_workbook

book =
open_workbook('simple.xlsx',on_demand=True) import pandas as pd
for name in book.sheet_names(): df = pd.read_excel(io="simple.xlsx",
sheet = book.sheet_by_name(name) sheet_name="Sheet_names")
for cell in sheet.col(0): print(df.head(5))
print (cell.value)

from openpyxl import load_workbook

wb = load_workbook('simple.xlsx')
print (wb.get_sheet_names())

worksheet1 = wb['Sheet_names'] # prima varianta de deschidere a unui worksheet

#worksheet2 = wb.get_sheet_by_name('Sheet_names') # a doua varianta
print(worksheet1['A4'].value)
worksheet1['A4'] = 'Corina'
print(worksheet1['A4'].value)
for row in worksheet1.iter_rows():
print(row[1].value)
 ACCESARE DATE DIN FISIERE (IV)
Prelucrarea fișierelor .json. Implicit acestea sunt încărcate în colecții de tip dicționar
import json
from pprint import pprint
with open ('clienti_daune.json') as f:
data=json.load(f)
pprint(data)

import json
from pprint import pprint
json_data=open('clienti_daune.json').read()
data = json.loads(json_data)
pprint(data)

import json
import pandas as pd
with open("clienti_daune.json") as f:
data = json.load(f)
dataframe = pd.DataFrame(data)
print(dataframe)
FUNCTII
Functii predefinite:
range(), tuple(), list(), set(), dict(), zip(), int(), str(), complex(),
float(), filter(), map(), input(), max(), min(), sum(), open(),
round(), type() etc.
Functii definite de utilizator:
def nume_functie(lista parametri):
“documentation string of the function or docstring - descrie
functia”
[return …]
#definire functie suma
def suma(*nr):
"functie cu numar variabil de parametri"
return sum(nr)
#apel
print(suma(1,2,3))
Functii anonime: lambda [param1 [,param2,.....paramn]]: expresie
Exemple functii (I)
def my_function(x): def my_function(x = def my_function(x,
result = x**2 100): n):
print (result) result = x**2 result = x**n
return result print (result) print (result)
my_function() return result return result
TypeError: my_function() my_function(5) my_function(4,2)
missing 1 required   my_function(n=2,x=4)
positional argument: 'x'

FUNCTII
Exemple functii (II)
def plus(*nr):  
return sum(nr)
print(plus(1, 2, 5, 5, 6,
8))
print(plus(1,2,5,5,6,8))
tuplu = (1, 2, 5, 5, 6, 8)
print(sum(tuplu))
def plus(*args): double = lambda x: x*2
total = 0 double(5)
for i in args:
total += i suma = lambda x, y: x + y;
return total print(suma(1,2))
my_list = [1,2,3,4,5,6,7,8,9,10]
filtered_list = list(filter(lambda x: (x*2 > 10), my_list))
#[6, 7, 8, 9, 10]
FUNCTII
import pandas as pd
import matplotlib.pyplot as plt
pd.set_option("display.max_columns", 20)
df = pd.read_csv('clienti_leasing.csv')
df.boxplot(column = 'AGE', by = 'MARITAL_STATUS')
plt.show()
def discount(df,p_disc,p_age):
df['DISCOUNT']=df.loc[(df['AGE']>p_age),'VENIT_PER_YEAR']*p_disc
return df
print(discount(df,0.1,30))

FUNCTII
import pandas as pd
pd.set_option("display.max_columns",50)
pd.set_option("display.max_rows",100)

def calcul(den_f):
df = pd.read_csv(den_f)
print(df['value'].sum())
df['payment'] = 0.75*df['value']*1.05
df.loc[(df['hour'] >= 16)&(df['hour'] <23),
'payment'] = df['value']*1.25*0.95
df.sort_values(by=['day'])
print('Payment with ToU tariff')
print(df['payment'].sum())
print('Payment with flat tariff')
print(df['value'].sum())
procent = 100-
df['value'].sum()*100/df['payment'].sum()
print (procent)
print(df)

calcul(den_f='februarie_2010.csv')
 DE LUCRU (I)
1. Să se creeze o listă de numere întregi pozitive si negative de 10 elemente. Să se filtreze elementele
listei astfel incat acestea sa fie pozitive și să se afișeze lista ordonata crescător.

2. Se da lista de orase de mai jos. Să se realizeze un dictionar care sa grupeze orasele dupa lungimea
denumirii. Dictionarul va avea valorile si cheile ordonate in ordine crescatoare, respectiv alfabetica.
lista_o = ['Vaslui','Cluj', 'Iasi', 'Alba', 'Oradea', 'Arad', 'Craiova', 'Mehedinti', 'Bucuresti',
'Orastie’]

3. Se da o listă de liste cu denumiri de electrocasnice si electronice (televizor, frigider,

laptop_tip1,laptop_tip2), prețul și cantitatea acestora. Calculați valoarea fiecărui echipament, adăugați-o în
lista fiecarui produs și sortați în funcție de pret, utilizand functia lambda. Pentru produsele care au pretul
mai mare de 3000 si cantitatea mai mare de 5 produse, se va diminua pretul cu 10%.
lista = [['tv', 3500,9], ['frigider', 2500, 4], ['laptop_tip1',5000,5],['laptop_tip2',10000,6]]
 DE LUCRU (II)

4. Să dau două liste de liste: lista produse aflate pe stoc (lps cu denumire_produs si cantitate) și lista
produse comandate (lpc cu denumire_produs si cantitate). Să se afiseze numele produselor care nu au fost
comandate. Sa se calculeze diferenta dintre cantitatea aflata pe stoc si cantitatea comandata si sa se
actualizeze cantitatea aflata pe stoc. Daca cantitatea comandata este mai mare decat cantitatea aflata pe
stoc, aceasta va fi egala cu 0.
lps=[['tableta',13], ['tv',50], ['smart_phone',4],['laptop_tip1',41], ['desktop',60], ['tastatura',16],
['monitor32inch',28], ['flipchart',6], ['carioca',200]]
lpc=[['tv',52],['laptop_tip1',20], ['desktop',11], ['tastatura',3], ['monitor32inch',11], ['flipchart',1]]
DE LUCRU (III)
5. Să se creeze o listă de dicționare cu următoarele chei: id, denumire,
pret și cantitate pentru produsele: televizor, laptop, frigider.
lista = [{"id":1, "denumire":"tv", "pret":3500, "cantitate":30},
{"id":2, "denumire":"laptop", "pret":10000, "cantitate":65},
{"id":3, "denumire":"frigider", "pret":2500, "cantitate":48}]
Dacă produsele au pretul mai mare decât 5000 sau cantitatea este mai
mare decat 20, să se reduca pretul cu 5%.

6. Să se creeze o listă li1, formată din primele m numere naturale, apoi să

se realizeze o funcție prin care să se creeze o listă li2 formată din
numerele prime ale listei li1.

7. Sa se deschida fisierul csv clienti_leasing si sa se stocheze in 3 liste

valorile din coloanele name_client, venit_per_year_ron si description. Sa
se determine de cate ori apare produsul bancar 'CAMIN SUPER BCR -
TL dob. fixa 1 an - dob. referinta var. ulterior IND EUR' in coloana
descriere
SURSE
BIBLIOGRAFICE
• 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