PYTHON

CURS 1
INTRODUCERE
INTRODUCERE
De la începutul acestui mileniu, creșterea accelerată a soluțiilor software de tip open source a produs
proiecte remarcabile.

Specialiștilor în data science li s-au deschis astfel oportunități enorme pentru prelucrarea volumelor mari de
date.

Cel mai important rezultat al proiectelor open source în domeniu este Python.

Pyhon își are rădăcinile în domeniile științific și al tehnicii de calcul și are o sintaxă foarte compactă.

Ultimii ani au fost marcați de o intensificare a implementărilor în care sunt folosite combinat tehnologii
proprietare și open source.

Este important să găsim modalități de combinare a capacitățile acestor limbajelor comerciale și open source
pentru a se completa reciproc.
CARACTERISTICI

Python este limbaj de

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

Limbajul poate fi utilizat în Poate gestiona volume

Conține o bibliotecă vastă Python se poate conecta la
mai multe medii (IDE): mari de date (big data) și
de pachete: numpy, pandas, baze de date. Citește și
Eclipse, PyCharm, Spyder, efectua operații
matplotlib, scikit-learn etc. modifică fișiere;
Thonny, Netbeans etc.; matematice 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 sunt

necesare 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();
• Tipul Boolean este un subtip al tipului integer, cu valorile True și False. Într-un context
numeric, de exemplu, atunci când este folosit ca argument pentru operații aritmetice, se
comportă ca niște numere întregi cu valori 0 pentru False și 1 pentru True.
• Siruri de caractere marcate cu ‘ ’ sau “ ”;
• Extragerea elementelor dintr-un sir: sir[ ];
• Cateva metode pentru siruri de caractere: sir.strip(), sir.strip(‘caractere’), len(sir),
sir.lower(), sir.upper(), sir.replace(“ ”, “”);
 TIPURI DE DATE- PYTHON/SAS

Variabilele nu necesita declarare explicita si sunt case- Limbajului SAS nu este necesar să se declare variabile și tipurile
sensitive. de date asociate, deoarece sunt deduse din utilizarea lor.

Categorii generale de tipuri de date Python: a) Încorporate Limbajul SAS de bază nu face distincție între numere întregi și
în limbaj; b) Adăugate de terți; c) Create prin codul Python. float. Implementări mai noi, cum ar fi SAS Cloud Analytic
Services (CAS) definesc o gamă de tipuri de date numerice.
Permit manipularea unei mari varietăți de date și îi permit
să fie un limbaj de programare de nivel înalt (de uz general), Tipurile de date pentru SAS sunt fie numerice, fie de caractere.
pe lângă utilizarea sa ca limbaj de prelucrare a datelor. Intern, SAS reprezintă valorile numerice în virgulă mobilă.

Python permite operații aritmetice „mixte” – sunt permise Limbajul SAS efectuează multe procesări necesare pentru
în expresii tipuri de date diferite. conversia sau citirea datelor fără intervenția utilizatorului.
TIPURI DE DATE- PYTHON/SAS
 COLECTII DE DATE – LISTE (ARRAY)
• Colecții de date care pot fi neomogene, ordonate și modificabile, 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]
Index 0 1 2 3 4 5 6 7
-7 -6 -5 -4 -3 -2 -1 0
print(seq[1:5])
# Afiseaza elemente lista de la indexul 1 pana la 5 exclusiv [2, 3, 7, 5]
seq[3:4] = [6, 3]
print(seq)
# Modificare elemente de la pozitiile 3 si 4 [7, 2, 3, 6, 3, 5, 6, 0, 1]
seq[3:] = [6, 3]
print(seq)
# Inlocuirea tuturor elementelor incepand de la pozitia 3 a listei [7, 2, 3, 6, 3]
print(seq[:3])
# Afisare elemente lista pana la pozitia 3 exclusiv [7, 2, 3]
print(seq[3:])
# Afisare elemente lista incepand de la pozitia 3 [6, 3]
print(seq[-4:])
# Afisare elemente lista de la coada la cap pana la pozitia -4 exclusiv [2, 3, 6, 3]
print(seq[-4:-2])
# Afisare elemente lista de la coada la cap de la pozitia -2 la -4 exclusiv [2, 3]
print(seq[::2])
# Afisare elemente din 2 in 2 [7, 3, 3]
print(seq[::-1])
# Inversare elemente [3, 6, 3, 2, 7]
 Metoda Descriere #Exemplu 1
b = ['saw', 'small', 'He', 'foxes', 'six']
append() Adaugă un element la sfârșitul listei b.sort(reverse = True)
clear() Elimină toate elementele listei print(b)
b.sort(key=len)
copy() Crează o copie a listei print(b)
count() Returnează numărul de apariții al elementului în listă #['small', 'six', 'saw', 'foxes', 'He’]
extend() Adăugă elemente la sfârșitul unei liste #['He', 'six', 'saw', 'small', 'foxes']
Ex: seq = [7, 2, 3, 6, 3]; seq.extend([1,2,3]); print(seq)
#Exemplu 2
→ [7, 2, 3, 6, 3, 1, 2, 3] import bisect as bi
index() Returnează indexul unui element b = ['saw', 'small', 'He', 'foxes',
'six']
insert() Adaugă un element la poziția specificată b.sort()
pop() Elimină elementul de la poziția specificată print(bi.bisect(b,'sell'))
bi.insort(b,'sell')
remove() Elimină primul element specificat print(b)
reverse() Inversează ordinea elementelor în listă
#3
sort() Sortează lista #['He', 'foxes', 'saw', 'sell', 'six',
'small']

COLECTII DE DATE
LISTE METODE
 FUNCTII BUILD-IN ENUMERATE
b = ['saw', 'small', 'He', 'foxes', 'six']
for i, value in enumerate(b,3):
enumerate(iterable, start=0)
print(i, value)
permite parcurgerea unei colecții de
lista = list(enumerate(b,1)) elemente în timp ce păstrează indexul
print(lista) elementului curent într-o variabilă
contor. Parametri:
dictionar = dict(enumerate(b,1)) • iterable - o secvență, un iterator sau
print(dictionar) obiect care suportă iterație
• start (optional) - enumerate()
pornește numărarea de la acest număr.
'''3 saw
4 small
Implicit este 0.
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 (GENERARE LISTE)
#range([start], stop[, step])
print(list(range(18))) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
print(list(range(5,18))) [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
print(list(range(5,18,2))) [5, 7, 9, 11, 13, 15, 17]
print(list(reversed(range(10))))
#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

b = ['saw', 'small', 'He', 'foxes', 'six']

b_len = len(b)
for i in range(0, b_len):
print(b[i])
saw
small
He
foxes
six
FUNCTII BUILD-IN ZIP
#zip face perechi din elementele unor #Exercitiu 3
liste, tupluri sau secvente pentru a for i, (a, b) in enumerate(zip(seq1, seq2)):
genera o lista de tupluri print('{0}: {1}, {2}'.format(i, a, b))
#Exercitiu 1 '''0: one, cat
seq1 = ['one', 'two', 'three'] 1: two, dogs
seq2 = ['cat', 'dogs', 'mice'] 2: three, mice'''
zipped = zip(seq1, seq2)
print(list(zipped)) #Exercitiu 4
# [('one', 'cat'), ('two', 'dogs'), lista_tupluri = [('Popescu', 'Alexandru'),
('three', 'mice')] ('Constantinescu', 'Maria'), ('Stan', 'Gigel')]
nume, prenume = zip(*lista_tupluri)
#Exercitiu 2 print(nume)
seq3 = [False, True] #('Popescu', 'Constantinescu', 'Stan')
print(list(zip(seq1, seq2, seq3))) print(prenume)
#[('one', 'cat', False), ('two', 'dogs', #('Alexandru', 'Maria', 'Gigel')
True)]
 COLECTII DE DATE - 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 liste print(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 al l = ['four', [1, 2], True]

gen1 =list(range(10))
elementului în tuplu print(l+gen1)
index() Returnează poziția unui element în #l1 echivalent cu l
tuplu l1 = ['four', [1, 2], True]
gen1 =list(range(10))
l1.extend(gen1)
print(l1)
 COLECTII DE DATE - DICTIONARE
• 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() Creează un dicționar cu chei și 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
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]}; print(d1)
# Afiseaza d1 {'a': 'some value', 'b': [1, 2, 3, 4]}
d1[7] = 'an integer'
print(d1)
# Adauga un element la d1 {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer’}
print(d1['b'])
# Afiseaza valoarea pentru cheia respectiva [1, 2, 3, 4]
print('b' in d1)
# Verifica daca cheia respectiva face parte din dictionar True
d1[5] = 'some value’; d1['dummy'] = 'another value’ # Adauga noi elemente {'a': 'some
value','b': [1, 2, 3, 4],7: 'an integer',5: 'some value','dummy': 'another value’}
del d1[5] # Sterge elementul corespunzator {'a': 'some value','b': [1, 2, 3, 4],7: 'an
integer','dummy': 'another value’}
ret = d1.pop('dummy’); # Sterge {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer’}
list(d1.keys()) # Pune cheile intr-o lista ['a', 'b', 7]
list(d1.values()) # Pune valorile in lista ['some value', [1, 2, 3, 4], 'an integer’]
d1.update({'b' : 'four', 'c' : 12})
# Actualizeaza d1 {'a': 'some value', 'b': 'four', 7: 'an integer', 'c': 12}
Exemple dictionare
# 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}
# 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
• Colecții de date neordonate, nemodificabile ș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 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
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.intersection(b)); print(a & b)

#{3, 4, 5}

print(a.symmetric_difference(b)); 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
1) strings = ['a', 'as', 'bat', 'car', 'dove', 'python']

# Transformarea elementelor a caror lungime > 2 in litere mari

SINTAXA [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’]

2) Dictionar generat din lista

SINTAXA 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}

3) Afisare lungime elemente. SINTAXA set = {expr for value in collection if condition}
unique_lengths = {len(x) for x in strings}
print(unique_lengths)
#{1, 2, 3, 4, 6}

4) Afisare nume in care litera a apare de cel putin 2 ori #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’]
 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
#Exemplu 1 # Exemplu 5
x = 15.0 x=30
y = 15 print(1<x<100)
if (x == y):
print ("Adevarat. 'x' si 'y' sunt # Exemplu 6
egale") x=30
else: print(1<x<30)
print("Fals. 'x' and 'y' nu sunt
egale") # Exemplu 7
x=4
# Exemplu 2 y=5
x = 15.0 print(x!=y)
y = 15
print (x is y) # Exemplu 8 comparatie siruri
s1='Sir'
# Exemplu 3 s2='sir'
x = 15.0 print(s1==s2)
y = x
print (x is y) #Exemplu 9 operatori booleeni si de
apartenenta
# Exemplu 4 Teste booleene pentru s3 = 'Sir Lung'
siruri print('r' and " " in s3)
print(bool('')) #sir gol
print(bool(' ')) #spatiu
print(bool('Un sir'))
FUNCTII
#Exemplu 1 #Exemplu 2
def my_function(x, y, z=1.5): def f():
if z > 1: a = 5
return z * (x + y) b = 6
else: c = 7
return z / (x + y) return a, b, c
print(my_function(1,2,3)) print(f())
#9 print(list(f()))
print(my_function(1,2)) print(set(f()))
#4.5
print(my_function(z=5, y=6, x=7)) #Exemplu 3
#65 def f():
print(my_function(y=6, x=5, z=7)) a = 5
#77 b = 6
print(my_function(y=6, x=7)) c = 7
#19.5 return {'a' : a, 'b' : b, 'c' : c}
print(f())
#Exemplu 4 - curatare siruri din lista #Exemplu 5
import re
def add(a, b):
states = [' Alabama ', 'Georgia!',
'Georgia', 'georgia', 'FlOrIda','south return a + b
carolina## ', 'West virginia?'] #map(function, iterables)
def clean_strings(strings): x = map(add, (0, 1, 2), (2, 1, 0))
result = [] print(list(x)) #[2,2,2]
for value in strings:
value = value.strip() #Exemplu 6 Functia anonima sau lambda
value = re.sub('[!#?%*]', '', def my_f(x):
value) return x * 2
value = value.title() echivalent = lambda x: x * 2
result.append(value) print(echivalent(5))
return result

print(clean_strings(states)) #Exemplu 7 Sortare in functie de lungime

#['Alabama', 'Georgia', 'Georgia', strings = ['curs', 'seminar', 'abba',
'Georgia', 'Florida', 'South Carolina', 'mere', 'pachete',' ' , 'software']
'West Virginia'] strings.sort(key=lambda x: len(x))
print(strings)

#Exemplu 8 Apel functie add cu lambda

add_five = lambda x: add(x,5)
print(add_five(20)) #25
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 #12
for value in sequence:
if value is None:
continue
total += value
print(total) #13

sequence = [1, 2, 0, 4, 6, 5, 2, 1]
total_until_5 = 0
for value in sequence: (0, 0)
if value == 5: (1, 0)
break (1, 1)
total_until_5 += value (2, 0)
print(total_until_5) (2, 1)
(2, 2)
for i in range(4): (3, 0)
for j in range(4): (3, 1)
if j > i: (3, 2)
break (3, 3)
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)
 GENERATOARE (SUPLIMENTAR)
#Functie care calculeaza x**2 import itertools
def squares(n=10):
print('Generating squares from 1 to
{0}'.format(n ** 2)) first_letter = lambda x: x[0]
for i in range(1, n + 1):
yield i ** 2 names = ['Alan', 'Adam', 'Wes', 'Will',
gen = squares() 'Albert', 'Steven', 'Simona', 'Ana’]
for x in gen:
print(x) names = sorted(names, key = first_letter)
#echivalent cu
gen = (x ** 2 for x in range(1,11)) for letter, names in
print(list(gen)) itertools.groupby(names, first_letter):
#Generatorul poate fi argumentul unei print(letter, list(names))
functii
print(sum(x ** 2 for x in range(1,11))) '''A ['Alan', 'Adam', 'Albert', 'Ana']
#385 S ['Steven', 'Simona']
W ['Wes', 'Will']'''
#dictionar format din valoare – patratul
valorii
print(dict((i, i **2) for i in range(5)))
#{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
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
PYTHON

CURS 2
1
ACCESARE DATE DIN FISIERE (I)
Fișiere: .txt, .csv, xlsx, .json

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) 2
 ACCESARE DATE DIN FISIERE (II)
Fișiere comma separated values

import csv
with open('clienti_leasing.csv', 'r') as f:
reader = csv.reader(f)
for row in reader:
print (row)

import pandas as pd
df = pd.read_csv('clienti_leasing.csv')
print(df)

3
 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'] # one way to load a worksheet

#worksheet2 = wb.get_sheet_by_name('Sheet_names') # another way to load a worksheet
print(worksheet1['A4'].value)
worksheet1['A4'] = 'Corina'
print(worksheet1['A4'].value)
for row in worksheet1.iter_rows():
print(row[1].value)
4
 ACCESARE DATE DIN FISIERE (IV)
Fișiere .json
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)
5
 NUMPY
• NumPy prescurtarea pentru Numerical Python sau calcule numerice
Python.
• NumPy contine:
- Tipul de obiect multidimensional ndarray
- Functii pentru calcule cu vectori sau operatii matematice cu vectori
- Instrumente pentru citirea si scrierea seturilor de date bazate pe
vectori
- operatii din algebra liniara, transformata Fourier si generare de
numere aleatoare
- API pentru C sau C++

6
 MATPLOTLIB & SCIPY
• Matplotlib este cea mai populara biblioteca Python pentru realizarea reprezentarilor grafice
• SciPy reprezinta o colectie de pachete pentru rezolvarea unor probleme standard din diferite
domenii
- scipy.integrate: Ofera rutine pentru integrare numerica si calculul ecuatiilor diferentiale;
- scipy.linalg: Rutine din algebra relationala, prelucrarea avansata matricelor, fiind superior
pachetului numpy.linalg;
- scipy.optimize. Functii de optimizare (minimizare) si algoritmi de identificare a drumului
critic;
- scipy.signal. Instrumente de procesare a semnalului;
- scipy.sparse. Calcule cu matrice si sisteme de ecuatii liniare (sparse);
- scipy.special. O biblioteca Fortran pentru implementarea celor mai populare functii
matematice, cum ar fi functia gamma;
- scipy.stats. Distributii de probabilitati, teste statistice, statistici descriptive.

7
 SCIKIT-LEARN
• Instrumente pentru machine learning in Python, ce include submodule pentru diverse modele:
• Clasificare: SVM, nearest neighbors, random forest, logistic regression etc.
• Regresia: Lasso, ridge regression etc.
• Clustering: k-means, spectral clustering etc.
• Reducerea dimensionalitatii (Dimensionality reduction): PCA, feature selection, matrix
factorization etc.
• Selectie model: Grid search, cross-validation, metrics
• Preprocesare: Feature extraction, normalizare

8
 STATSMODELS
• In comparatie cu scikit-learn, statsmodels continue algoritmi clasici din statistica si
econometrie. Include submodule, cum ar fi:
• Regresie: liniara, modele liniare generalizate , modele liniare robuste, linear mixed effects
models etc.
• ANOVA
• Analize pe serii de timp: AR, ARMA, ARIMA,VAR etc.
• Nonparametric methods: Kernel density estimation, kernel regression
• rezultatele analizelor realizate cu statsmodels sunt axate pe indicatori statistici, p-values, in
timp ce rezultatele analizelor efectuate cu scikit-learn, se axeaza mai mult pe predictii.

9
PACHETUL PANDAS (I)
Reprezintă elementul
central pentru Oferă două structuri Detectarea și Operații ușoare de
înțelegerea Python în de date de tip masiv: manipularea ușoară a feliere și creare de
contextul prelucrării Series și Dataframe valorilor lipsă subseturi
datelor

Obiecte index
Încărcătoare pentru
Combinarea și automat pentru
intrare / ieșire
îmbinarea mai multor rânduri și coloane cu
acceptând o gamă
Dataframe mai multe niveluri /
largă de date tabelare
indexare ierarhică

10
PACHETUL PANDAS (II)
Contine structuri de date (Dataframe), orientate pe coloane,si instrumente pentru
manipularea datelor, proiectate pentru a realiza mai rapid si mai usor curatarea si
analiza datelor in Python;

Dataframe = container de vectori unidimensionali (Series);

Se utilizeaza deseori in tandem cu alte pachete de calcul numeric, cum ar fi NumPy

and SciPy, biblioteci analitice, cum ar fi statsmodels si scikit-learn, si instrumente
pentru vizualizarea datelor, cum ar fi matplotlib.

11
Pandas adaopta stilul de calcul bazat pe vectori,
in special functii pe vectori, specific NumPy,
precum si procesarea datelor in stil pythonian,
fara a utiliza structuri repetitive;

Care este cea mai mare diferenta dintre Pandas

si NumPy? Pandas lucreaza cu date tabelare,
eterogene, in timp ce NumPy este adecvat
pentru vectori de date numerice, omogene;
PACHETUL
PANDAS (III)
Pandas imbina posibilitatile specifice NumPy
de calcul la nivelul vectorilor cu manipularea
flexibila a datelor din spreadsheet-uri si baze
de date relationale, oferind functionalitati
sofisticate de indexare, care permit
rearanjarea, felierea, sectionarea, agregarea si
selectarea subseturilor de date.

12
DATAFRAME
▪ În multe situații, ca și structură și comportament, un Dataframe se comportă similar unui
set de date SAS.
▪ Există mai multe metode pentru a încărca valori într-un DataFrame dintr-o gamă largă de
surse de intrare, precum fișiere .csv, tabele DBMS, API-uri REST, seturi de date SAS
(.sas7bdat ) etc. Acestea sunt similare liniei de produse SAS/Access.
▪ Pentru vizualizarea stucturii unui DataFrame se folosesc: atributul shape și metoda info()
care oferă informații similare cu PROC CONTENTS din SAS

#%%DataFrame
#import din sursa locala Pandas SAS
import pandas as pd DataFrame Set de date
file_loc = "E:\\Date\\uk_accidents.csv" Rând Observație
#file_loc=r"E:\Date\uk_accidents.csv" Coloană Variabilă
df = pd.read_csv(file_loc)
#df = pd.read_csv("uk_accidents.csv")
Groupby By-Group
print(df.shape) NaN . (punct)
Felie Subset
(266776, 27)
13
 DATAFRAME – VIZUALIZARE ȘI PARSARE
#import din sursa web
import pandas as pd
df = pd.read_csv("https://raw.githubusercontent.com/AncaAndreescu/Date/main/uk_accidents.csv")
print(df.shape)
print(df.info())
#parsare data
import pandas as pd
file_loc = "E:\\Date\\uk_accidents.csv"
df = pd.read_csv(file_loc, parse_dates=['Date'])
print(df['Date'].dtype)

14
VALORI LIPSĂ
Pandas folosește două tipuri de obiecte pentru tratarea valorilor lipsă: obiectul None și obiectul NaN (not a
number).

La introducerea datelor folosim obiectul None pentru valori nule.

La afișarea datelor vor apărea None sau NaN în funcție de tipul de date.

#Construirea unui Dataframe cu valori lipsa

import pandas as pd
df2 = pd.DataFrame([['rece','incet', None, 2.7, 6.6, 3.1],
['cald', 'mediu', 4.2, 5.1, 7.9, 9.1],
['canicula', 'repede', 9.4, 11.0, None, 6.8],
['rece', None, None, None, 9.1, 8.9],
['rece', 'mediu', 6.1, 4.3, 12.2, 3.7],
[None, 'incet', None, 2.9, 3.3, 1.7],
[None, 'incet', None, 2.9, 3.3, 1.7]],
columns=['Temp', 'Viteza', 'Masura1', 'Masura2','Masura3', 'Masura4'])
print(df2)
#tipurile coloanelor
print(df2.dtypes) 15
VALORI LIPSĂ- REZULTATE
Temp Viteza Masura1 Masura2 Masura3 Masura4
0 rece incet NaN 2.7 6.6 3.1
1 cald mediu 4.2 5.1 7.9 9.1
2 canicula repede 9.4 11.0 NaN 6.8
3 rece None NaN NaN 9.1 8.9
4 rece mediu 6.1 4.3 12.2 3.7
5 None incet NaN 2.9 3.3 1.7
6 None incet NaN 2.9 3.3 1.7

Temp object
Viteza object
Masura1 float64
Masura2 float64
Masura3 float64
Masura4 float64

16
 FUNCȚII PENTRU LUCRUL CU
VALORI LIPSĂ
Funcție Acțiune
isnull( ) Generează o mască booleană care indică valorile lipsă
print(df2.isnull()) notnull( ) Are efect opus funcției isnull()
dropna( ) Returnează o copie filtrată a Dataframe-ului inițial
#elemente lipsa pe coloane fillna( ) Returnează o copie a Dataframe-ului inițial având valorile
for col_name in df2.columns: nule completate în funcție de opțiunile funcției.
print (col_name, end="---->")
print (sum(df2[col_name].isnull()))

# elemente lipsa pe coloane var2

print (df2.isnull().sum())

17
 OPERAȚII CU VALORI LIPSĂ
#operatia de adunare cu valori lipsa
• Într-un Datafame, comportamentul valorilor lipsă utilizate în operații și
df2['Sum_M3_M4'] = df2['Masura3'] + funcții matematice este similar cu comportamentul SAS.
df2['Masura4']
print(df2[['Masura3', 'Masura4', • În cazul Dataframe:
'Sum_M3_M4']])
– Într-o operație aritmetică la nivel de rând, valorile lipsă sunt propagate.
– Pentru metode și funcții, valorile lipsă sunt tratate ca fiind zero.
#functia sum() cu valori lipsa
print(df2['Sum_M3_M4'].sum()) – Dacă lipsesc toate valorile datelor, rezultatul unei metode sau funcții va fi zero.
#functia sum() cu valori lipsa cu skipna
print(df2['Sum_M3_M4'].sum(skipna=False)) • Parametrul skipna = False forțează sum () să returneze un NaN dacă o
valoare NaN este întâlnită în operație.
#functia sum() numai cu valori lipsa • Funcția sum() care primește ca intrare doar valori lipsă, returnează valoarea
df2['Masura5'] = None zero.
print(df2['Masura5'])
print(df2['Masura5'].sum())

18
PANDAS READERS (CITITORI)

• Cititorii pandas sunt o colecție de metode de intrare / ieșire pentru scrierea și încărcarea
valorilor în DataFrames.
• Facilitatea principală pandas pentru scrierea și citirea în/din DataFrames sunt cititorii, precum
read_csv (), read_json () și read_sql_table (), printre altele.
• Acești cititori folosesc o sintaxă similară. Primul argument este calea sau locația către țintă,
care poate fi nume de fișiere complet calificate, nume de fișiere relative (relativ la directorul de
lucru curent care execută Python), tabele din baze de date, adrese URL (inclusiv metode de
acces HTTPS, SFTP și S3) etc. În multe cazuri, valorile implicite pentru argumentele cititorilor
sunt suficiente pentru operațiile de citire / scriere.

19
METODELE CITITORULUI AU
ARGUMENTE DE SPECIFICAT:
• Locații de intrare și ieșire
• Locația și numele coloanei și indexului
• Reguli de parsare pentru gestionarea datelor primare
• Reguli pentru datele lipsă
• Manipularea datelor calendaristice
• Tratarea erorilor
• Reguli de citire
• Formate pentru fișiere

• Lista argumentelor: https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html

20
 ARGUMENTUL na_values
import pandas as pd
df = pd.read_csv('clienti_leasing_na.csv')
print(df.head())
lipsa = {'JOB' : ['NaN','-']}
df2 = pd.read_csv('clienti_leasing_na.csv', na_values=lipsa)
print(df2.head())

lipsa = {'JOB' : ['NaN','-']} creează obiectul lipsa ca o pereche cheie-valoare de tip dicționar
(dictionary): în care valoarea cheie JOB este numele coloanei DataFrame urmată de valorile 'NaN'și'-',
utilizate pentru a desemna ambele ca valori lipsă. Parametrul na_values = folosește acest dicționar lipsa pentru a
mapa valorile care sunt considerate lipsă atunci când sunt întâlnite în coloana JOB.

21
 READ_SAS
Organizațiile au adesea un număr mare de seturi de date SAS
permanente, stocate pe sistemul de fișiere. pandas oferă cititorul
read_sas () pentru crearea de DataFrame, citind seturi de date SAS
permanente. Seturile de date SAS permanente sunt adesea denumite
fișiere .sas7bdat (după extensia utilizată de SAS pentru denumirea
fișierelor de seturi de date din sistemele de fișiere Windows și Unix).

import pandas as pd
df = pd.read_sas('produse.sas7bdat', encoding = 'latin-1')
print(df.head())
print(df.info())
df.Cod = df.Cod.astype(int)
print(df.head())
print(df.info()) 22
INDEXARE (I)
Pandas creează automat o structură de tip index la momentul creării unui DataFrame, atât pentru
rânduri, cât și pentru coloane.

Obiectul RangeIndex este folosit ca index implicit de rând. Aceste obiecte index sunt responsabile
pentru păstrarea etichetelor asociate axelor, precum și a altor metadate.

Una sau mai multe coloane din DataFrame pot fi utilizate pentru a defini un index.

Un index în Pandas poate fi considerat ca un mijloc pentru etichetarea rândurilor dintr-un

DataFrame.

Sintaxa parțială definire index:

DataFrame.set_index(drop=True, inplace=False)
• drop – scoate coloana indexată din DataFrame (implicit este advărată)
• inplace – arată dacă se fac modificările pe DataFrame sau se generează altul nou (implicit
este falsă)
23
 INDEXARE (II)
#index implicit fara definire de coloane
import pandas as pd
df = pd.DataFrame([['0071', 'Patton' , 17, 27],
['1001', 'Joyner' , 13, 22],
['0091', 'Williams', 111, 121],
['0110', 'Jurat' , 51, 55],
['1106', 'Haskins', 51, 55],
['1189', 'Aden', 71, 70],
['1203', 'Tanner', 113, 122],
['1240', 'Jenkins', 99, 99]])
print(df)
print(' Index Rand: ', df.index, '\n', 'Index Coloana:', df.columns)

Index Rand: RangeIndex(start=0, stop=8, step=1)

Index Coloana: RangeIndex(start=0, stop=4, step=1)

24
 INDEXARE (III)
#indesci cu definire de coloane
import pandas as pd
df = pd.DataFrame([['0071', 'Patton' , 17, 27],
['1001', 'Joyner' , 13, 22],
['0091', 'Williams', 111, 121],
['0110', 'Jurat' , 51, 55],
['1106', 'Haskins', 51, 55],
['1189', 'Aden', 71, 70],
['1203', 'Tanner', 113, 122],
['1240', 'Jenkins', 99, 99]]
,columns = ['ID', 'Nume', 'Inainte', 'Dupa'])
print(' Index Rand: ', df.index, '\n', 'Index Coloana:', df.columns)
df.set_index('ID', inplace=True)
print(df)
print(' Index Rand: ', df.index, '\n', 'Index Coloana:', df.columns)

Index Rand: RangeIndex(start=0, stop=8, step=1)

Index Coloana: Index(['ID', 'Nume', 'Inainte', 'Dupa'], dtype='object’)
-------------
Index Rand: Index(['0071', '1001', '0091', '0110', '1106', '1189',
'1203', '1240'], dtype='object', name='ID')
Index Coloana: Index(['Nume', 'Inainte', 'Dupa'], dtype='object') 25
CREAREA DE SUBSETURI
• Crearea de subseturi de date prin selectarea de rânduri și/sau coloane este o activitate
esențială pentru orice formă de analiză a datelor.
• Pandas oferă trei opțiuni pentru selectarea de rânduri și/sau coloane:

1. Operatorul [] - permite selectarea de coloane sau de rânduri (unidimensională).

2. loc - folosește etichete de rânduri și coloane pentru generarea de subseturi. Eticheta unei coloane
reprezintă numele acesteia, iar etichetele rândurilor sunt atribuite de un index (fie indexul implicit de la
momentul creării DataFrame, fie cel creat cu metoda set_index (). Dacă nu există nume atribuite coloanelor,
atunci, conform indexului implicit, se etichetează coloanele începând de la 0.

3. iloc - folosește poziții reprezentate prin numere întregi (de la 0 la lungime axă - 1) pentru selectarea
rândurilor și coloanelor. Această metodă rămâne disponibilă chiar dacă este definit un index definit de
utilizator.

26
 OPERATORUL []
• Operatorul [] permite selectarea de linii sau coloane
• Selectarea coloanelor
▪ Folosește numele unei coloane sau o listă de nume de coloane( df[‘A’] sau df[[‘A’,’B’]])
▪ Poate folosi indexul implicit dacă nu au fost denumite coloanele (df[0] sau df[[0,1]])
• Selectarea înregistrărilor
• Sintaxa generală pentru felierea înregistrărilor folosind operatorul [] este: df [start: stop: step]
• Poziția de pornire este inclusă în ieșire, iar poziția de oprire nu este inclusă în ieșire (df[:3] sau
df[::2]).
• Pentru selectarea înregistrărilor pornind de la poziție sau valori se folosesc cu preponderență loc
și iloc deoarece oferă o gamă mult mai largă de opțiuni de selectare.
# Coloane:
df["Nume"] # coloana Nume
df[["Nume", "Inainte", "Dupa"]] # listă de coloane

# Inregistrari:
df[:4] # primele patru înregistrări
27
df[1::2] # înregistrările de pe poziții pare
ILOC (I)
Selectare cu iloc – selectare bazată pe poziție

• iloc folosește poziții întregi (de la 0 la lungime axă –1) pentru selectarea
rândurilor și coloanelor.
• Intrările permise pentru iloc sunt :
▪ un număr întreg, de exemplu, 12
▪ o listă Python de numere întregi [4, 2, 22]
▪ un domeniu de numere întregi 2:22 (în acest caz 2, este inclusiv, iar
poziția de oprire 22 este exclusivă)
• Absența selectării rândurilor se substituie prin caracterul “:”

28
ILOC (II)
• iloc integer-location based indexing: selecteaza linii si coloane dupa index/pozitie

# Selectie singulara cu iloc

# Inregistrari:
data.iloc[0] # prima inregistrare
data.iloc[1] # a doua inregistrare
data.iloc[-1] # ultima inregistrare a setului de date
# Coloane:
data.iloc[:,0] # prima coloana
data.iloc[:,1] # a doua coloana
data.iloc[:,-1] # ultima coloana a setului de date

# Selectie multipla cu iloc

data.iloc[0:5] # primele cinci inregistrari
data.iloc[:, 0:2] # primele doua coloane
data.iloc[[0,3,6,24], [0,5,6]] # inregistrarile 1, 4, 7, 25, coloanele 1, 6 si 7
data.iloc[0:5, 5:8] # primele cinci inregistrari si coloanele 6, 7 si 8).
29
DATAFRAME SI SERIES
Examinarea - activitatea de a afișa porțiuni din valorile incluse în DataFrame pentru a facilita
înțelegerea conținutului datelor.

În SAS, acest lucru se realizează cu funcții precum PROC PRINT și PROC SQL.

Funcțiile head () și tail () afișează în mod implicit primele cinci rânduri, respectiv ultimele cinci rânduri
ale unui DataFrame.

import pandas as pd

#setul de date de test poate fi gasit aici https://www.briandunning.com/sample-data/ si

contine date fictive
data = pd.read_csv('https://s3-eu-west-1.amazonaws.com/shanebucket/downloads/uk-500.csv’)

data.to_csv("output.csv")

print (type(data.head(3)))
print (type(data.iloc[:,1]))

<class 'pandas.core.frame.DataFrame'>
<class 'pandas.core.series.Series'> 30
LOC (I)
Selectare cu loc – selectare bazată pe etichete

• loc este o metodă utilizată în principal pentru returnarea rândurilor și coloanelor

folosind etichete.
• Intrările permise pentru loc sunt :
▪ o singură etichetă, cum ar fi 12 sau “Nume”. Rețineți că 12 este interpretat ca
eticheta rândului și nu ca locație întreagă de-a lungul indexului.
▪ o listă Python de etichete [‘A’, ‘B’, ‘C’].
▪ un domeniu de etichete ‘a’: ‘z’. În acest caz, atât limita ‘a’ cât și ‘z’ sunt inclusive
▪ evaluări condiționale
• Absența selectării rândurilor se substituie prin caracterul “:”
• Operatorul [] și iloc pot accesa rânduri folosind valoarea indexului implicit. Și loc poate
folosi valoarea indexului implicit, dar numai în absența unor alți indecși definiți pe linii
și/sau coloane.
• Pentru a permite selectarea în funcție de valorile datelor, loc necesită crearea unui
index definit de utilizator pentru a crea etichete la nivel de rând. 31
 LOC (II)
• loc : selecteaza linii si coloane dupa etichetă/valoare
import pandas as pd
data = pd.read_csv('https://s3-eu-west-1.amazonaws.com/shanebucket/downloads/uk-500.csv')
#fixarea indexului pe coloana first_name
data.set_index("first_name", inplace=True)
#selectarea inregistrarilor, fiind afisata doar inregistrarile corespunzatoare
print(data.loc["Antonio"])
print(data.loc[["Antonio", "Peter"]])

import pandas as pd
data = pd.read_csv('https://s3-eu-west-1.amazonaws.com/shanebucket/downloads/uk-500.csv')
#fixarea indexului pe coloana first_name
data.set_index("first_name", inplace=True)
#selectarea coloanelor, first_name este afisata implicit
print(data.loc[["Antonio", "Peter"],['last_name', 'address', 'city']])

import pandas as pd
data = pd.read_csv('https://s3-eu-west-1.amazonaws.com/shanebucket/downloads/uk-500.csv')
#fixarea indexului pe coloana first_name
data.set_index("last_name", inplace=True)
print(data.loc[['Andrade', 'Veness'], 'city':'email'])
print(data.loc['Andrade':'Veness', ['first_name', 'address', 'city']]) 32
 LOC (III)
• loc poate include expresii pentru selectarea conditionala a inregistrarilor.
• In expresiile conditionale se foloseste sintaxa: df[‘nume_coloana’]
• Nu este necesară indexarea

import pandas as pd
data = pd.read_csv('https://s3-eu-west-1.amazonaws.com/shanebucket/downloads/uk-500.csv')
print(data.loc[data['first_name'] == 'Antonio'])

import pandas as pd
data = pd.read_csv('https://s3-eu-west-1.amazonaws.com/shanebucket/downloads/uk-500.csv')

print(data.loc[data['first_name'] == 'Antonio', 'city':'email'])

print(data.loc[data['email'].str.endswith("hotmail.com"), 'phone1':'email'])

print(data.loc[data['first_name'].isin(['France', 'Tyisha', 'Eric'])])

print(data.loc[data['email'].str.endswith("gmail.com") & (data['first_name'] ==

'Antonio'), 'first_name':'email'])

print(data.loc[data['company_name'].apply(lambda x: len(x.split(' ')) == 1),

'company_name']) 33
 SELECTAREA COLOANELOR
import pandas as pd • Pot fi utilizate patru metode pentru selectarea coloanelor:
df = pd.read_csv('clienti_leasing.csv')
#variante echivalente pentru selectarea – df.nume_coloana
coloanelor
print(df.SEX) – df['nume_coloana’]
print(df["SEX"])
print(df.iloc[:,3])
– df.iloc[:, index_coloana]
print (df.loc[:,"SEX"]) – df.loc[:, 'nume_coloana’]
• Cand se selecteaza o coloana, rezulta un vector de date unidimensional
print(df.DEPOSIT_AMOUNT.mean()) pandas.Series cu care se pot realiza mai multe operatii de:
(.sum()), (.mean()), (.count()), (.median()), inlocuire valori nule
import pandas as pd (.fillna(new_value)).
df = pd.read_csv('clienti_leasing.csv')
print(df[['SEX', 'DEPOSIT_AMOUNT']]) • Prin selectarea mai multor coloane se defineste un nou set de date. Sintaxa
#printeaza coloanele SEX, AGE si pentru selectarea multipla a coloanelor este:
DEPOSIT_AMOUNT
print(df.iloc[:, [3,10,14]])
– df[['nume_coloana_1', 'nume_coloana_2']]
– df.iloc[:, [0,1,20,22]]

34
 SELECTAREA INREGISTRARILOR

• Se poate realiza metodele de selectare iloc/loc sau prin

selectori logici (selectare bazata pe valoarea unei
coloane sau variabile).
import pandas as pd
df = • Metodele de baza pentru selectarea inregistrarilor sunt:
pd.read_csv('clienti_leasing.csv')
print(df.iloc[0:10, :]) – df.iloc[0:10, :], selecteaza primele 10 inregistrari;
print(df.loc[44, :]) – df.loc[44, :], selecteaza inregistrarea 45
print(df.loc[[2, 44], :])
print(df[df["SEX"] == "m"]) – df[df[“SEX"] == “m"], selecteaza inregistrarile care
indeplinesc conditia.
– Simbolurile “, :” in metodele iloc si loc, pentru a specifica
selectarea tururor coloanelor, sunt opționale

35
 ACTUALIZAREA VALORILOR DIN SETUL DE DATE
import pandas
df = pandas.read_csv('clienti_leasing20.csv', nrows=6, usecols =
['NAME_CLIENT','VENIT_PER_YEAR'])
print(df)
df.loc[1,'VENIT_PER_YEAR'] = 1500
print(df.loc[1,'VENIT_PER_YEAR'])
print(df)

import pandas as pd
data = pd.read_csv('clienti_leasing.csv')

data.loc[data['VENIT_PER_YEAR'] > 10000, "PRESCORING"] = 7

print(data.loc[data['PRESCORING'] == 7,'NAME_CLIENT'])

data.loc[(data['VENIT_PER_YEAR'] > 10000) & (data['SEX'] == 'm'), "PRESCORING"] = 8

print(data.loc[data['PRESCORING'] == 8,'NAME_CLIENT'])

36
 STERGEREA COLOANELOR (DROP)
• Stergerea inregistrarilor sau a coloanelor dintr-un set de date se realizeaza prin functia drop.
• Pentru stergerea unei coloane sau a mai multor coloane, se utilizeaza numele coloanelor
specificand axis=I sau se utilizeaza parametrul ‘columns’ (nemaifiind necesar ‘axis’).
– Stergerea coloanei "Area" din set:
df = df.drop("Area", axis=1)
– Stergerea coloanei cu parametrul ‘columns’:
df = df.drop(columns=“Area")
• Stergerea unei coloane duce la crearea unui alt set de date. Pentru a modifica setul original
(curent), se utilizeaza parametrul inplace = True, nefiind returnata nicio valoare.
df.drop("Area", axis=1, inplace=True).
• Stergerea multipla a coloanelor
data = data.drop(["Y2001", "Y2002", "Y2003"], axis=1)

37
STERGEREA INREGISTRARILOR (DROP)
• Inregistrarile pot fi sterse utilizand functia drop si specificand axis=0.
import pandas as pd
df = pd.read_csv('clienti_leasing20.csv')
df.drop([1,2], axis = 0, inplace=True)
print(df)

• Drop() poate sterge inregistrarile pe baza unor expresii. Stergerea inregistrarilor care contin “ROL“.
In cazul stergerii bazate pe expresii, se va seta mai intai coloana indexata (CURRENCY) :
import pandas as pd
df = pd.read_csv('clienti_leasing.csv')
df = df.set_index("CURRENCY")
df = df.drop("ROL", axis=0)
print(df)
• Pentru a sterge inregistrarile in functie de pozitia sau indexul acestora, se utilizeaza iloc. Stergerea
primelor cinci inregistrari utilizand iloc
import pandas as pd
df = pd.read_csv('clienti_leasing20.csv')
df = df.iloc[5:,].drop
print(df) 38
 REDENUMIREA COLOANELOR (RENAME)
• Redenumirea coloanelor in pandas se realizeaza in doua moduri prin intermediul functiei rename.
• Redenumirea prin maparea denumilor vechi cu denumirile noi, astfel {“denumire_veche”:
“denumire_noua”, …}
import pandas as pd
df = pd.read_csv('clienti_leasing.csv')
df.rename(columns={"ID_CLIENT": "COD"}, inplace=True)
print(df)

import pandas as pd
df = pd.read_csv('clienti_leasing.csv')
df.rename(columns={"ID_CLIENT": "COD","AGE": "VARSTA"}, inplace=True)
print(df)
• Redenumirea printr-o functie care sa schimbe denumirile coloanelor si care se aplica pentru fiecare
coloana.
import pandas as pd
df = pd.read_csv('clienti_leasing.csv')
df = df.rename(columns=str.lower)
#df = df.rename(columns=lambda x: x.lower().replace(' ', '_'))
print(df) 39
 FUNCTII DE AGREGARE
import pandas as pd
df =
pd.read_csv('clienti_leasing.csv',usecols=['NAME_CLIENT','JOB','SEX','DEPOSIT
_AMOUNT','AGE’])

print('Suma depozitelor ', df['DEPOSIT_AMOUNT'].sum(), '\nMedia depozitelor',

df['DEPOSIT_AMOUNT'].mean())

print('Valoarea mediana ', df['DEPOSIT_AMOUNT'].median())

print('Valori unice ', df['DEPOSIT_AMOUNT'].nunique())

print('Venitul maxim ', df['DEPOSIT_AMOUNT'].max())

print('Numar observatii ', df['DEPOSIT_AMOUNT'].count())

40
 IMPUNERE (FILLNA)
Decât să renunțe la un întreg rând sau coloană, valorile lipsă pot fi înlocuite (impuse) folosind funcții
matematice și statistice.

Metoda fillna () returnează un DataFrame (sau None dacă inplace=True) prin înlocuirea valorilor lipsă cu
anumite valori sau cu valori derivate.

import pandas as pd
df =
pd.read_csv('clienti_leasing20.csv',usecols=['NAME_CLIENT','JOB','SEX','VENIT_PER_YEAR'])
print(df['VENIT_PER_YEAR'])
print(df['VENIT_PER_YEAR'].fillna(0))

import pandas as pd
df =
pd.read_csv('clienti_leasing20.csv',usecols=['NAME_CLIENT','JOB','SEX','VENIT_PER_YEAR'])
print(df['VENIT_PER_YEAR'])
v_m = df['VENIT_PER_YEAR'].mean()
print(df['VENIT_PER_YEAR'].fillna(value=v_m))
41
PRELUCRARE DATE TRADITIONAL VS. PANDAS
from pprint import pprint
import pandas as pd
df = pd.read_csv('clienti_daune.csv')
set_clienti=[]
for index, row in df.iterrows():
if row['VALOARE_DAUNA'] > 2000:
set_clienti.append(row['ID_CLIENT'])
pprint (set_clienti)

from pprint import pprint

import pandas as pd
df = pd.read_csv('clienti_daune.csv')
set_clienti=[]
for index, row in df.iterrows():
if row['VALOARE_DAUNA'] > 1000:
set_clienti.append(row)
pprint (set_clienti)
v_marca = input("Introduceti marca: ");
print ("Marca selectata este : ", v_marca)
total_daune=0
for row in set_clienti:
if str(row['MARCA']).find(v_marca.upper())!=-1:
total_daune=total_daune+row['VALOARE_DAUNA']
print ("Valoarea totala a daunelor pentru marca", v_marca, " este: ", total_daune)
/
print ("Valoarea totala a daunelor pentru marca", v_marca, " este: ",
df['VALOARE_DAUNA'][(df['MARCA'] == v_marca.upper()) & (df['VALOARE_DAUNA']
42
>1000)].sum())
 EXPORTUL (SALVAREA) SETURILOR PANDAS
• Functia to_csv pentru a salva un set de date intr-un fisier .csv
• Functia to_excel pentru a salva un set de date intr-un fisier Microsoft Excel
• Salvarea prelucrarilor intr-un fisier .csv
• Eliminarea indexului implicit Pandas la nivelul inregistrarilor, se realizeaza cu optiunea index=False.
• Pentru a Evita probleme de afisare a caracterelor, se poate utiliza optiunea encoding.
data.to_csv("output_filename.csv", index=False, encoding='utf8’)
• Salvarea prelucrarilor intr-un fisier Excel necesita instalarea pachetului “openpyxl” sau "xlsxwriter".
data.to_excel("output_excel_file.xlsx", sheet_name="Sheet 1", index=False)

43
 TO_CSV
from pprint import pprint
import pandas as pd
df = pd.read_csv('clienti_daune.csv')
set_clienti=[]
for index, row in df.iterrows():
if row['VALOARE_DAUNA'] > 2000:
set_clienti.append(row['ID_CLIENT'])
pprint (set_clienti)
df = pd.DataFrame(set_clienti)
df.to_csv("output_clienti.csv")

#Varianta pandas
df=df.loc[df['VALOARE_DAUNA']>2000,'ID_CLIENT']
print(df)
df.to_csv("output_clienti.csv")

44
 PRELUCRARE DATE PANDAS
from pprint import pprint
import pandas as pd
df = pd.read_csv('clienti_daune.csv')

pprint (df.loc[(df['AN_FABRICATIE'] < 2010) & (df['COMPONENTA'] =='BATTERY'), 'PRET_MANOPERA'])

df.loc[(df['AN_FABRICATIE'] < 2010) & (df['COMPONENTA'] =='BATTERY'), 'PRET_MANOPERA']=\

df.loc[(df['AN_FABRICATIE'] < 2010) & (df['COMPONENTA'] =='BATTERY'), 'PRET_MANOPERA']*1.10

pprint(df.loc[(df['AN_FABRICATIE'] < 2010) & (df['COMPONENTA'] =='BATTERY'), 'PRET_MANOPERA'])

df.to_csv('clienti_daune_mod.csv')

from pprint import pprint

import pandas as pd
df = pd.read_csv('clienti_daune.csv’)

#crearea unei coloane PROCENT_MANOPERA

df['PROCENT_MANOPERA'] =df['PRET_MANOPERA'] / df['VALOARE_DAUNA']*100
pprint (df)

df.to_csv('clienti_daune_mod.csv')
45
PYTHON

CURS 3
GRUPAREA SI AGREGAREA DATELOR (I)
• Pandas are un sistem de opțiuni care permite personalizarea unor aspecte ale comportamentului său. Cele mai
frecvente sunt opțiunile legate de afișare.
pandas.set_option (parametru, valoare)
• Exemplu: Setează numărul maxim de rânduri afișate. Variante: pd.set_option ("display.max_rows", 100)
sau pd.options.display.max_rows = 100

Prelucrări statistice simple

import pandas as pd
df = pd.read_csv('clienti_leasing.csv')
pd.set_option("display.max_columns",5)
print(df.head())
print('Numarul de clienti')
print(df['ID_CLIENT'].count())
print('Venit maxim')
print(df['VENIT_PER_YEAR'].max())
print('Suma venitului pentru persoanele de sex masculin')
print(df['VENIT_PER_YEAR'][df['SEX'] == 'm'].sum())
print('Numarul valorilor distincte din coloana starea civila')
print(df['MARITAL_STATUS'].value_counts())
print('Numarul total de valori distincte din coloana starea civila')
print(df['MARITAL_STATUS'].nunique())
GRUPAREA SI AGREGAREA DATELOR (II)
Statistici descriptive
count 18239
unique 126
top Muncitor necalificat import pandas as pd
freq 5086 df = pd.read_csv('clienti_leasing.csv')
Name: JOB, dtype: object pd.set_option("display.max_columns",5)
count 18239.000000 print('Statistici descriptive')
mean 8344.006629 print(df['JOB'].describe())
std 11234.428174 print(df['VENIT_PER_YEAR'].describe())
min 0.070000
25% 2500.000000
50% 5000.000000 • Funcția describe () este utilizată pentru a genera statistici
descriptive care rezumă tendința centrală, dispersia și forma
75% 10000.000000 distribuției unui set de date, excluzând valorile lipsă.
max 408560.000000 • Pentru coloanele de tip object se calculează alți indicatori decât
Name:VENIT_PER_YEAR, dtype: float64 pentru coloanele numerice.
• Implicit se calculează indicatori pentru toate coloanele numerice.
GRUPAREA SI AGREGAREA DATELOR (III)
Funcțiile max(), min(), mean(), first(), last() pot fi utilizate cu GroupBy
import pandas as pd
df = pd.read_csv('clienti_leasing.csv')
pd.set_option("display.max_columns",5)
df['DATA'] = pd.to_datetime(df['DATA'])
df['MONTH'] = pd.DatetimeIndex(df['DATA']).month
print('Prima inregistrare din coloana CURRENCY pe valori distincte')
print(df.groupby('CURRENCY').first())
print('Venitul anual insumat pentru fiecare luna')
print(df.groupby(pd.DatetimeIndex(df['DATA']).month)['VENIT_PER_YEAR'].sum())
print('Valoarea insumata a depozitului pentru ingineri pe sexe')
print(df[df['JOB'] == 'Inginer'].groupby('SEX')['VENIT_PER_YEAR'].sum())

• Când este importat un fișier CSV și se realizează un DataFrame, • Funcția groupby() împarte datele din DataFrame
obiectele Datetime din fișier sunt citite ca un obiect șir. Pe în diferite grupuri, în funcție de anumite criterii.
acestea este foarte greu să efectăm operații precum diferența de
timp. Metoda pandas to_datetime() ajută la convertirea șirului • Returnează un obiect de tip GroupBy.
în obiecte Python Datetime. • Funcții precum max(), min(), mean(), first(), last()
• pd.DatetimeIndex – permite efectuarea de operații complexe pot fi aplicate obiectului GroupBy pentru a obține
pe obiecte Datetime și conține metadate specifice acestora. statistici rezumative pentru fiecare grup.
GRUPAREA Grupări complexe
SI import pandas as pd
AGREGAREA df = pd.read_csv('clienti_daune.csv')
pd.options.display.max_rows = 999
D AT E LO R
(IV) print('Numarul de marci pentru fiecare
tara producatoare’)

print(df.groupby(['TARAPRODUCATOR',
'MARCA'])['MARCA'].count())
GRUPAREA
SI
AGREGAREA
D AT E LO R Sursa: https://www.shanelynn.ie/summarising-aggregation-and-grouping-data-in-
(V) python-pandas/

Gruparea și agregarea datelor cu agg – creare de noi coloane

import pandas as pd
df = pd.read_csv('clienti_daune.csv')
df[df['TARAPRODUCATOR']=='Canada'].groupby('MARCA').agg(
DAUNA_MAXIMA=pd.NamedAgg(column='VALOARE_DAUNA', aggfunc=max),
DAUNA_MINIMA=pd.NamedAgg(column='VALOARE_DAUNA', aggfunc=min),
DAUNA_TOTALA=pd.NamedAgg(column='VALOARE_DAUNA', aggfunc=sum)
)
GRUPAREA SI AGREGAREA DATELOR (VI)
Funcționalitatea de agregare oferită de funcția agg () permite calcularea mai multor
statistici pe grup într-un singur calcul.

Instrucțiunile pentru agregare sunt furnizate sub forma unui dicționar sau listă python.

Cheile dicționarului sunt utilizate pentru a specifica coloanele pe care se efectuează

operații, iar valorile dicționarului pentru a specifica funcția care se aplică.

Gruparea și agregarea datelor cu agg

import pandas as pd
df = pd.read_csv('clienti_daune.csv')
pd.options.display.max_rows = 999
print(df.groupby(['TARAPRODUCATOR','MARCA']).agg({'VALOARE_DAUNA':sum,
'ID_CLIENT': "count", 'MODEL': 'first'}))
df1 = df.groupby(['TARAPRODUCATOR','MARCA']).agg({'VALOARE_DAUNA':sum,
'ID_CLIENT': "count", 'MODEL': 'first'})
df1.to_csv('agregare.csv')
GRUPAREA SI AGREGAREA DATELOR (VII)

Pentru a aplica mai multe funcții unei singure coloane din datele grupate, se va specifica o
listă de funcții ca și valori ale dicționarului.

Aplicarea unor funcții multiple unei singure coloane din grup

import pandas as pd
df = pd.read_csv('clienti_daune.csv')
df['DATA_CERERE'] = pd.to_datetime(df['DATA_CERERE'])
print(df.groupby(['TARAPRODUCATOR', 'MARCA']).agg({'PRET_MANOPERA': [min,
max, sum], 'MODEL': "count", 'DATA_CERERE': [min, 'first', 'nunique']}))
GRUPAREA SI AGREGAREA DATELOR (IX)
import pandas as pd
pd.set_option('display.max_rows', None)
pd.set_option('display.max_columns', None)
df = pd.read_csv('clienti_daune.csv')
print('Grupare dupa MARCA, pentru fiecare marca afisam nr de modele')
print(df.groupby("MARCA")['MODEL'].count())
print("========================================")
print('Grupare dupa MARCA, pentru fiecare marca afisam nr de modele unice')
print(df.groupby("MARCA")['MODEL'].nunique())
print("========================================")
print('Afisam primele 5 marci cu cele mai multe modele')
print(df.groupby(['MARCA'])['MODEL'].count().nlargest(5))
print("========================================")
print('Grupare dupa MARCA, pentru fiecare marca afisam toate modelele')
print(df.groupby(["MARCA"])['MODEL'].apply(lambda x: ','.join(x)))
print("========================================")
• nunique – returnează numărul de observații distincte.
• nlargest - returnează primele n rânduri ordonate pe coloane în ordine descrescătoare.
• Se pot defini funcții inlinie folosind funcțiile „lambda” pentru a extrage statistici care nu sunt furnizate de opțiunile built-in.
• join () - returnează un șir prin unirea tuturor elementelor unui iterabil, separate printr-un separator de șiruri.
CONCAT, MERGE, JOIN
• Combinarea seturilor de date cu concat, merge / join dataframes
Concat – lipire seturi cu continut similar pe verticala sau pe orizontala
pd.concat([df_a, df_b])

pd.concat([df_a, df_b], axis=1)

CONCATENAREA

Biblioteca pandas implementează o metodă concat () similară în comportament cu

instrucțiunea SAS SET. Este folosit pentru a „lipi” DataFrames în funcție de rânduri sau de
coloane, similar declarației SAS MERGE.
Antetul metodei concat () este:
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None,
levels=None, names=None, verify_integrity=False, sort=None, copy=True)

• axis – axa pe care se realizează concatenarea {0-verticală, 1-orizontală}, implicit 0

• join – cum să se gestioneze indecșii pe axe {‘inner’, ‘outer’}, implicit ‘outer’

Sintaxa generala: https://pandas.pydata.org/docs/reference/api/pandas.concat.html

CONCAT()
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=[0, 1, 2, 3])
df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'],
'D': ['D2', 'D3', 'D6', 'D7'],
'F': ['F2', 'F3', 'F6', 'F7']},
index=[2, 3, 6, 7])
rezultat = pd.concat([df1, df4], axis=1, join='inner')
print(rezultat)
print("---------------")
rezultat_ = pd.concat([df1, df4], axis=0, join='inner')
print(rezultat_)
 INDEXAREA IERARHICĂ CU METODA
CONCAT()
• Metoda concat () permite construirea unui index ierarhic oferind argumentul keys= pentru a forma cel
mai exterior nivel.
import pandas as pd
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=[0, 1, 2, 3])
df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'],
'D': ['D2', 'D3', 'D6', 'D7'],
'F': ['F2', 'F3', 'F6', 'F7']},
index=[2, 3, 6, 7])
rezultat = pd.concat([df1,df4], keys=['df1', 'df4'])
print(rezultat)
print(rezultat.loc['df4’])

Având indexul ierarhic în poziție, putem identifica cu ușurință subseturi folosind indexatorul loc (). În acest
exemplu, loc () împarte acele rânduri care aparțin initial DataFrame-ului df4.
MERGE (I)
Antetul metodei merge () este:
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False,
right_index=False, sort=False. suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

• left, right – DataFrame plasat în stânga, respectiv dreapta

• how - definește tipul de combinare ('inner’ - implicit, alte opțiuni: 'outer', 'left’, și 'right’)
• on – după ce coloane sau indecși se face combinarea
• left_on și right_on - ce coloane sau indecși sunt prezenți doar în partea stângă sau dreaptă (implicit
None)
• sort – sortează cheile de joncțiune lexicografic în rezultat.
• indicator – dacă este True, adaugă o coloană la rezultat cu denumirea ''_merge'' sau o denumire
furnizată. Conține informații privind sursa fiecărui rând: ''left_only”/ ''right_only” / ''both''.
• validate – atunci când este specificat, verifică dacă se efectuează o combinare de un anumit tip:
''one_to_one'' sau ''1:1'', ''one_to_many'' sau ''1:m'', ''many_to_one'' or ''m:1''.
MERGE (II)
import pandas as pd
pd.options.display.max_columns = 10
df = pd.read_csv('clienti_leasing.csv')
df1 = pd.read_csv('clienti_daune.csv')
rezultat = pd.merge(df[['ID_CLIENT','NUME_CLIENT', 'PROFESIA',
'SEX','VENIT_ANUAL', 'VARSTA']],
df1[['ID_CLIENT', 'MARCA', 'PRET_MANOPERA',
'VALOARE_DAUNA']],
on='ID_CLIENT')
print(rezultat)
print('Structura fisier clienti_leasing.csv', df.shape)
print('Structura fisier clienti_daune.csv', df1.shape)
print(df['ID_CLIENT'].isin(df1['ID_CLIENT']).value_counts())

În cod se folosește argumentul on = „ID_CLIENT” pentru a indica folosirea coloanei ID_CLIENT ca o coloană cheie
găsită în ambele DataFrames. Argumentul on = ” ID_CLIENT” nu este necesar în acest exemplu, deoarece metoda
merge () detectează prezența unei coloane etichetate ID_CLIENT în ambele DataFrames și le atribuie automat ca și
coloană cheie. Argumentul how = efectuează implicit o joncțiune internă. Argumentul sort = este setat la False din
oficiu. Nu este surprinzător faptul că operațiile merge () pe DataFrames mari obțin îmbunătățiri substanțiale ale
performanței prin faptul că nu trebuie să returneze rândurile în ordine sortată.
MERGE (III)
#rez2 = pd.merge(df, df1, on='ID_CLIENT', how='outer', sort=False, validate="one_to_one" )
#rez2 = pd.merge(df, df1, on='ID_CLIENT', how='outer', sort=False, validate="one_to_many" )
#rez2 = pd.merge(df, df1, on='ID_CLIENT', how='inner', sort=False, validate="many_to_one" )
rez2 = pd.merge(df, df1, on='ID_CLIENT', how='outer', sort=False, validate="many_to_many" )
print(rez2)

În acest exemplu, argumentul validate = determină dacă îmbinarea are un tip specific de relație. Valorile
valide pentru validate = sunt:
• one_to_one sau 1: 1: Verifică dacă cheile sunt unice atât în DataFrame-ul din stânga, cât și în dreapta.
• one_to_many sau 1: m: Verifică dacă cheile sunt unice în Dataframe-ul din stânga.
• many_to_one sau m: 1: Verifică dacă cheile sunt unice în Dataframe-ul din dreapta.
• many_to_many sau m: m: Este permis, dar nu are ca rezultat o verificare.
Valoarea implicită este None. În acest exemplu, validate = ”one_to_one” generează o eroare
pandas.errors.MergeError și raportează că cheile, ID_CLIENT, nu sunt unice în setul de date din stânga sau
din dreapta.
MERGE (IV)
Data analytics pe clienti si daune
import pandas as pd
df = pd.read_csv('clienti_leasing.csv')
df1 = pd.read_csv('clienti_daune.csv')
result = pd.merge(df[['ID_CLIENT','NUME_CLIENT', 'PROFESIA', 'SEX','VENIT_ANUAL',
'VARSTA']],
df1[['ID_CLIENT', 'VIN','MARCA', 'PRET_MANOPERA', 'VALOARE_DAUNA']],
on='ID_CLIENT')
print('Grupare dupa Id_client si Marca, calcul min, max, suma pentru Valoare_dauna si
numar daune (VIN)')
print(result.groupby(['ID_CLIENT', 'MARCA']).agg({'VALOARE_DAUNA': [min, max, sum],
'VIN': "count"}))
print('Afisam primele 5 marci cu cele mai multe daune')
print(result.groupby(['MARCA'])['VALOARE_DAUNA'].count().nlargest(5))
print(result.groupby(['MARCA'])['VALOARE_DAUNA'].size().nlargest(5))
print('Afisam primii 15 clienti cu cele mai multe daune')
print(result.groupby(['ID_CLIENT'])['VIN'].count().nlargest(15))
print('Afisam primii 15 clienti cu cea mai mare valoare totala a daunelor')
print(result.groupby(['ID_CLIENT'])['VALOARE_DAUNA'].sum().nlargest(15))

size() include valorile lipsă, count() nu face acest lucru

MERGE (V)
Left merge
import pandas as pd
pd.options.display.max_columns = 10
df = pd.read_csv('clienti_leasing.csv')
df1 = pd.read_csv('clienti_daune.csv')
result = pd.merge(df[['ID_CLIENT','NUME_CLIENT', 'PROFESIA',
'SEX','VENIT_ANUAL', 'VARSTA']],
df1[['ID_CLIENT', 'MARCA', 'PRET_MANOPERA',
'VALOARE_DAUNA']],
on='ID_CLIENT',
how='left')
print(result)
print(result.shape)
print('Structura fisier clienti_leasing.csv', df.shape)
print('Structura fisier clienti_daune.csv', df1.shape)
print(df['ID_CLIENT'].isin(df1['ID_CLIENT']).value_counts())
MERGE (VI)
Right merge
import pandas as pd
pd.options.display.max_columns = 10
df = pd.read_csv('clienti_leasing.csv')
df1 = pd.read_csv('clienti_daune.csv')
result = pd.merge(df[['ID_CLIENT','NUME_CLIENT', 'PROFESIA',
'SEX','VENIT_ANUAL', 'VARSTA']],
df1[['ID_CLIENT', 'MARCA', 'PRET_MANOPERA',
'VALOARE_DAUNA']],
on='ID_CLIENT',
how='right')
print(result)
print(result.shape)
print('Structura fisier clienti_leasing.csv', df.shape)
print('Structura fisier clienti_daune.csv', df1.shape)
print(df['ID_CLIENT'].isin(df1['ID_CLIENT']).value_counts())
MERGE (VII)
Full outer merge
import pandas as pd
pd.options.display.max_columns = 10
df = pd.read_csv('clienti_leasing.csv')
df1 = pd.read_csv('clienti_daune.csv')
result = pd.merge(df[['ID_CLIENT','NUME_CLIENT', 'PROFESIA',
'SEX','VENIT_ANUAL', 'VARSTA']],
df1[['ID_CLIENT', 'MARCA', 'PRET_MANOPERA',
'VALOARE_DAUNA']],
on='ID_CLIENT',
how='outer')
print(result)
print(result.shape)
print('Structura fisier clienti_leasing.csv', df.shape)
print('Structura fisier clienti_daune.csv', df1.shape)
print(df['ID_CLIENT'].isin(df1['ID_CLIENT']).value_counts())
MERGE (VIII)
Full outer merge cu indicația _merge
import pandas as pd
pd.options.display.max_columns = 10
df = pd.read_csv('clienti_leasing.csv')
df1 = pd.read_csv('clienti_daune.csv')
result = pd.merge(df[['ID_CLIENT','NUME_CLIENT', 'PROFESIA',
'SEX','VENIT_ANUAL', 'VARSTA']],
df1[['ID_CLIENT', 'MARCA', 'PRET_MANOPERA',
'VALOARE_DAUNA']],
on='ID_CLIENT',
how='outer',
indicator=True)
print(result)
print(result.shape)
print('Structura fisier clienti_leasing.csv', df.shape)
print('Structura fisier clienti_daune.csv', df1.shape)
print(df['ID_CLIENT'].isin(df1['ID_CLIENT']).value_counts())
MERGE (IX)
Merge utilizând trei seturi de date
import pandas as pd
df = pd.read_csv('clienti_leasing.csv')
df1 = pd.read_csv('clienti_daune.csv')
df2 = pd.read_csv('cars.csv')
result = pd.merge(df[['ID_CLIENT','NUME_CLIENT', 'PROFESIA',
'SEX','VENIT_ANUAL', 'VARSTA']],
df1[['ID_CLIENT', 'MARCA', 'PRET_MANOPERA',
'VALOARE_DAUNA']],
on='ID_CLIENT',
how='outer')
df2.rename(columns={"Motor": "CAPACITATE_MOTOR"}, inplace=True)
result = pd.merge(result[['ID_CLIENT','NUME_CLIENT', 'MARCA']],
df2,
left_on='MARCA',
right_on='MARCA_CARS',
how='left')
print(result)
print(result.shape)
MATPLOTLIB (I)
Grafic cu gruparea și sortarea datelor cu matplotlib.pyplot
import pandas as pd
import matplotlib.pyplot as plt
df = pd.read_csv('clienti_leasing20_r.csv')
plot_data=df[df['SEX']=='m']
plot_data=plot_data.groupby('PROFESIA')['VENIT_ANUAL'].sum()
plot_data.sort_values().plot(kind='bar', color = 'lightpink')
plt.show()
 MATPLOTLIB (II)
Reprezentare grafică cu bare cu matplotlib.pyplot
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib import cm
df = pd.read_csv('clienti_leasing20.csv')
print(df['AGE'])
#all_colors = list(plt.cm.colors.cnames.keys())
colors = cm.hsv( df['AGE']/ float(max(df['AGE'])))
df['AGE'].plot(kind='bar',color=colors)
plt.xlabel('ID_CLIENT')
plt.ylabel('AGE')
plt.show()
 JOIN (I) - SUPLIMENTAR
Biblioteca pandas implementează metoda join () pentru a combina coloane, din două DataFrames indexate diferit, într-un
singur DataFrame. Metoda join () este o alternativă bună la apelarea metodei merge () în acele cazuri în care unui
DataFrame îi lipsește un index (altul decât RangeIndex implicit) sau în care coloanele cheie au nume diferite.

DataFrame-ul df1 este creat apelând metoda join () care face joncțiunea fie pe un index (ca în acest caz), fie pe
o coloană cheie desemnată.
În acest exemplu, apelul metodei join () efectuează implicit o joncțiune de stânga, cu argumentul how = ‘left’.
Indecșii din ambele coloane sunt păstrați pe noul DataFrame df1, în funcție de tipul de joncțiune numită.
Observați cum funcția print () afișează coloana index ca etichete de rând în df1.
import pandas as pd
left = pd.DataFrame(
{ 'Style' : ['S1', 'S2', 'S3', 'S4'],
'Size' : ['S', 'M', 'L', 'XL']},
index = ['01', '02', '03', '05'])
right = pd.DataFrame(
{ 'Color' : ['Red', 'Blue', 'White', 'Black'],
'Brand' : ['Polo', 'Motor', 'Zara', 'Bershka']},
index = ['01', '02', '03', '04'])
print(left)
print(right)
df1 = left.join(right, how='left')
print(df1)
#df1 = left.merge(right, how='left', left_index=True, right_index=True)
#print(df1)
JOIN (II)
Metoda join () prevede patru metode de joncțiune:

• Left: folosește indexul DataFrame apelant sau o coloană cheie, dacă este specificată. Aceasta este metoda
implicită pentru join ().

• Right: folosește celălalt index al DataFrame-ului.

• Outer: returnează uniunea de apelare a indexului DataFrame cu celălalt index DataFrame și sortează indexul.

• Inner: returnează intersecția indexului DataFrame apelant cu celălalt index DataFrame și păstrează ordinea
indexului DataFrame apelant.
JOIN (III)

df2 = left.join(right, how='outer')

print(df2)

df3 = left.join(right, how='inner')

print(df3)
 JONCȚIUNEA COLOANEI CHEIE CU UN
INDEX
• În acele cazuri în care un DataFrame nu este indexat, utilizați argumentul on = pentru a identifica coloana
cheie utilizată într-o operațiune de joncțiune. Observați în exercițiul următor că Dataframe-ul din stânga
nu are un index și că DataFrame-ul din dreapta are.
import pandas as pd
left = pd.DataFrame(
{ 'Style' : ['S1', 'S2', 'S3', 'S4'],
'Size' : ['S', 'M', 'L', 'XL'],
'id' : ['01', '02', '03', '05']})
right = pd.DataFrame(
{ 'Color' : ['Red', 'Blue', 'White', 'Black'],
'Brand' : ['Polo', 'Motor', 'Zara', 'Bershka']},
index = ['01', '02', '03', '04'])
print(left)
print(right)
df1 = left.join(right, on='id', how='outer')
print(df1)
df2 = pd.merge(left, right, left_on='id', how='outer',
right_index=True)
print(df2)
SURSE BIBLIOGRAFICE

• https://matplotlib.org/index.html
• https://www.shanelynn.ie/summarising-aggregation-and-grouping-data-in-python-pandas/
• https://www.shanelynn.ie/merge-join-dataframes-python-pandas-index-1/
• 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
• Betancourt, R. and Chen, S., Python for SAS Users, Apress, 2019.
PYTHON
CURS 4
CONECTAREA LA BAZE DE DATE ORACLE –
PACHETUL CX_ORACLE
• Pachetul cx_Oracle conține metode pentru realizarea unei conexiuni cu o bază de date
Oracle, pentru gestiunea interogărilor și a tranzacțiilor (comenzile
SELECT/INSERT/UPDATE/DELETE/MERGE și COMMIT/ROLLBACK).
• Pentru realizarea conexiunii cu o bază de date Oracle se precizează userul, parola,
serverul (host/ip) și denumirea bazei de date (service name/SID). De exemplu, pentru
realizarea conexiunii cu serverul oracle care rulează pe IP-ul 37.120.250.20 cu service_name
oracle, nume utilizator student_ps și parola oracle se inițializează conexiunea următoare:
• connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")
 • Pentru gestiunea interogărilor sau a tranzacțiilor este
necesară utilizarea unui cursor:
cursor = connection.cursor()
• Variabila de tip cursor dispune de toate metodele
CURSORUL necesare gestiunii tranzacțiilor și procesării interogărilor.
• Lista completă a metodelor acestuia este disponibilă aici:
https://cx-oracle.readthedocs.io/en/latest/cursor.html
 METODE ALE CURSORULUI
Metoda Explicații
cursor.execute(comanda SQL, Execută comanda SQL specificată împreună cu lista de parametrii. Ca rezultat,
parametri) în cazul SELECT, cursorul este încărcat cu înregistrările returnate;

cursor.close() Închide cursorul și eliberează zona de memorie alocată;

cursor.fetchone() Încarcă înregistrările din cursor în variabile locale Python (de obicei în liste de
cursor.fetchmany(n) tupluri);
cursor.fetchall()
cursor.prepare(comanda SQL) Transmite comanda SQL către cursor fără a o executa;
cursor.rowcount Returnează numărul de înregistrări parcurse din cursor, inițial este 0, iar pe
măsură ce se utilizează comanda fetch(), numărul crește.

cursor.bindarraysize Precizează dimensiunea cursorului, utilizată în special la comanda INSERT;

cursor.setinputsizes() Precizează tipul de date, utilizată în special la comanda INSERT.

REALIZAREA INTEROGĂRILOR
• Realizarea interogărilor
• Pentru exemplificare se utilizează tabelele T_CLIENTI_DAUNE și T_CLIENTI_LEASING din
schema utilizatorului STUDENT_PS. Acestea au fost create prin importul fișierelor .csv Clienti_daune
și Clienti_leasing.
• Instrucțiunile SELECT sunt executate în cadrul cursorului astfel: cursor.execute("""SELECT *
FROM t_clienti_leasing""")
• Cursorul este încărcat cu tuplurile returnate de interogare, parcurgerea sa se poate realiza în cadrul
unui for:
for rec in cursor:
print("Values:", rec)
• După prelucrarea cursorului se recomandă închiderea sa, iar la final închiderea conexiunii cu baza de
date:
cursor.close()
connection.close()
METODELE FETCH, INTEROGARI CU PARAMETRI

• Pentru prelucrarea unui cursor se pot utiliza listele de tupluri, înregistrările putând fi încărcate
cu ajutorul metodelor cursorului:
fetchone() – încarcă o singură înregistrare;
fetchmany(n) – încarcă n înregistrări;
fetchall() – încarcă toate înregistrările din cursor.
• Interogări cu parametri:
• Parametrii se pot specifica direct în cadrul metodei execute() (a se vedea exemplul 2);
• O altă variantă presupune utilizarea metodei prepare () pentru realizarea interogării cu
parametru (a se vedea exemplul 3).
 EXEMPLUL 1 INTEROGARI
Să se returneze numele, profesia, venitul anual și suma solicitată în cazul clienților care au solicitat mai mult de
5000 lei credit.
import cx_Oracle
from pprint import pprint

# Realizarea conexiunii cu serverul Oracle

# Conexiunea - user student_ps, parola oracle, host:37.120.250.20,
service_name oracle
connection = cx_Oracle.connect("student_ps", "oracle",
"37.120.250.20/oracle")
cursor = connection.cursor()
cursor.execute("""SELECT nume_client, profesia, venit_anual FROM
t_clienti_leasing WHERE suma_solicitata>5000""")
lista_clienti=cursor.fetchall()
# Inchidere cursor si conexiune
cursor.close()
connection.close()
# Afisare lista clienti
pprint (lista_clienti)
 EXEMPLUL 2 INTEROGARI
Să se returneze valoarea totală a daunelor înregistrate pentru o anumită marcă auto introdusă de utilizator de la
tastatură.
import cx_Oracle
from pprint import pprint

# Realizarea conexiunii cu serverul Oracle

#Conexiunea - user student_ps, parola oracle, host:37.120.250.20, service_name
oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")
cursor = connection.cursor()
v_marca = input("Introduceti marca: ");
cursor.execute("""SELECT marca, sum(valoare_dauna) Total_daune FROM
t_clienti_daune where lower(marca) like :p_marca group by marca""",
p_marca='%'+v_marca.lower()+'%')
lista_daune=cursor.fetchall()
#inchidere cursor si conexiune
cursor.close()
connection.close()
#afisare lista marci cu daune
pprint (lista_daune)
EXEMPLUL 3 INTEROGARI
Să se returneze valoarea totală a daunelor pe fiecare marcă auto, dacă această valoare este mai mare decât o anumită valoare
prag. De la tastatură se va introduce valoarea prag pentru 2 apeluri succesive.
import cx_Oracle
from pprint import pprint
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")
cursor = connection.cursor()
#pregatirea interogarii cu parametru
cursor.prepare("""SELECT marca, sum(valoare_dauna) Total_daune FROM t_clienti_daune
group by marca having sum(valoare_dauna)>:p_val""")
#primul apel
v_val = input("Introduceti valoarea: ")
cursor.execute(None, {'p_val': v_val})
lista_daune=cursor.fetchall()
#afisare lista marci cu daune
pprint (lista_daune)
#al doilea apel
v_val = input("Introduceti valoarea: ")
cursor.execute(None, {'p_val': v_val})
lista_daune=cursor.fetchall()
#afisare lista marci cu daune
pprint (lista_daune)
#inchidere cursor si conexiune
cursor.close()
connection.close()
CONTROLUL TRANZACTIILOR

• Operațiile de INSERT, UPDATE și DELETE sunt realizate tot prin intermediul unui cursor cu
ajutorul metodei execute().
• În cazul INSERT, se pot transmite mai multe înregistrări prin metoda executemany(). În acest caz
se recomandă să se precizeze numărul de înregistrări prin proprietatea bindarraysize și
tipul parametrilor prin metoda setinputsizes.
• Tranzacțiile se pot finaliza sau anula prin precizarea opțiunilor COMMIT sau ROLLBACK ale
conexiunii: connection.commit() sau connection.rollback()
EXEMPLUL 4 INSERT
Să se adauge o listă de tupluri în tabela CLIENTI_NOI care are următoarea structură: id_client number, nume_client varchar2(150),
profesia varchar2(150), sex varchar2(3), varsta number, stare_civila varchar2(1), suma_solicitata number. Să se finalizeze tranzacția și
apoi să se returneze înregistrările noi adăugate. Modificați secvența de cod și anulați tranzacția.
import cx_Oracle
from pprint import pprint
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")
lista_clienti_noi = [(100, "Popa Marcel", "Inginer", "m", 34, "C", 230),
(101, "Popa Vasilica", "Coafeza", "f", 32, "C", 200),
(102, "Popa Ion", "Instalator", "m", 64, "C", 120)]
cursor = connection.cursor()
#adaugarea listei de clienti noi in tabela
cursor.bindarraysize = 3
cursor.setinputsizes(int, 150, 150, 3, int, 1, float)
cursor.executemany("insert into clienti_noi(id_client, nume_client, profesia, sex, varsta,
stare_civila,suma_solicitata) values (:1, :2, :3, :4, :5, :6, :7)", lista_clienti_noi)
cursor.close()
#finalizarea tranzactiei
connection.commit()
#interogarea bazei de date pentru vizualizarea inregistrarilor noi adaugate
cursor2 = connection.cursor()
cursor2.execute("""SELECT * from clienti_noi where nume_client like 'Popa%'""")
lista_clienti=cursor2.fetchall()
pprint(lista_clienti)
cursor2.close()
connection.close()
E X E M P L U L 5 U P D AT E
Să se majoreze cu 10% suma solicitată de clienții al căror nume este introdus de utilizator de la tastatură.
Actualizările se vor realiza pe tabela CLIENTI_NOI. Să se finalizeze/anuleze tranzacția și să se re-deschidă un
cursor pentru verificarea rezultatelor tranzacției.
import cx_Oracle
from pprint import pprint
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle"
cursor = connection.cursor()
#adaugarea listei de clienti noi in tabela
statement="update clienti_noi set suma_solicitata=suma_solicitata*1.10 where
lower(nume_client) like :p_nume"
v_nume=input("Introduceti numele clientului:")
cursor.execute(statement,p_nume='%'+v_nume.lower()+'%')
cursor.close()
#finalizarea tranzactiei
connection.commit()
#interogarea bazei de date pentru vizualizarea inregistrarilor noi adaugate
cursor2 = connection.cursor()
cursor2.execute("""SELECT * from clienti_noi where lower(nume_client) like :p_nume""",
p_nume='%'+v_nume.lower()+'%')
lista_clienti=cursor2.fetchall()
pprint(lista_clienti)
cursor2.close()
connection.close()
EXEMPLUL 6 DELETE
Să se șteargă din tabela CLIENTI_NOI clienții cu numele de familie Popa. Să se finalizeze tranzacția.

import cx_Oracle

# Realizarea conexiunii cu serverul Oracle

#Conexiunea - user student_ps, parola oracle, host 37.120.250.20, service_name oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

cursor = connection.cursor()

#stergerea clientilor cu numele Popa

statement="delete from clienti_noi where nume_client like 'Popa%'"
cursor.execute(statement)
cursor.close()

#finalizarea tranzactiei
connection.commit()
connection.close()
EXEMPLUL 7 INCARCARE IN PANDAS
• Înregistrările returnate de o interogare SQL se pot încărca direct într-un DataFrame Pandas prin metoda
pandas.read_sql(comanda SQL, conexiunea, lista de parametri).
• În acest caz nu mai este necesară încărcarea înregistrărilor în cursor, acestea fiind gestionate automat de
către DataFrame.
Să se selecteze din tabela T_CLIENTI_DAUNE marca, modelul, anul de fabricație, componenta, prețul
manoperei și valoarea daunei pentru autoturismele mai noi de 2010.
import pandas as pd
import cx_Oracle
from pprint import pprint
# Connect to oracle.
connection = cx_Oracle.connect("student_ps", "oracle",
"37.120.250.20/oracle")
#incarcam in DataFrame inregistrarile returnate de SELECT
an=2010
query ="""Select marca, model, an_fabricatie, componenta, pret_manopera,
valoare_dauna
from t_clienti_daune
where an_fabricatie>:an"""
df = pd.read_sql(query, con=connection, params={'an': an})
pprint(df)
connection.close()
EXEMPLUL 8 PRELUCRARE IN PANDAS
Pornind de la exemplul anterior, în exemplul de mai sus să se adauge o nouă coloană în df pentru a calcula
ponderea manoperei din valoarea totală a daunei. Să se afișeze marca și componentele înlocuite în cazul în
care ponderea depășește 30% din valoarea daunei.
import pandas as pd
import cx_Oracle
from pprint import pprint
# Connect to oracle.
connection = cx_Oracle.connect("student_ps", "oracle",
"37.120.250.20/oracle")
#incarcam in DataFrame inregistrarile returnate de SELECT
an=2010
query ="""Select marca, model, an_fabricatie, componenta, pret_manopera,
valoare_dauna
from t_clienti_daune
where an_fabricatie>:an"""
df = pd.read_sql(query, con=connection, params={'an': an})
connection.close()

df["PROCENT"]=df["VALOARE_DAUNA"]/df["PRET_MANOPERA"]
pprint(df.loc[(df["PROCENT"]>30), ["MARCA","COMPONENTA"]])
 EXERCIȚII PROPUSE (I)
1. Să se returneze într-un df componenta, anul de fabricatie și pretul manoperei
pentru autoturismele Ford și Jeep. Pe setul din df, majorați cu 10% pretul
manoperei pentru autoturismele fabricate inainte de 2010 și care au
componenta BATTERY defectă. Salvați modificările într-un fișier .csv.
 EXERCIȚII PROPUSE (II)
2. Încărcați într-un df marca, modelul, valoarea medie și numărul de daune pe
fiecare model și marcă. Afișați numărul de autoturisme pentru care valoarea
medie depășește 400 lei. Reprezentați grafic modelele care au înregistrat mai
mult de 200 de daune.
 EXERCIȚII PROPUSE (III)
3. Încărcați într-un df numele, suma solicitată, suma din depozite și fidelitatea
clienților cu vârsta > 30 de ani care au solicitat un credit mai mare de 10.000 lei.
Verificați în df dacă suma din depozit este mai mare decât suma solicitată și
pentru acești clienți modificați fidelitatea în 5 (doar în df).
 EXERCIȚII PROPUSE (IV)
4. Încărcați într-un df profesia, venitul anual, suma din depozite și suma solicitată
pe fiecare profesie. În df adăugați o nouă coloană pentru a calcula gradul de
îndatorare pe fiecare profesie (suma_solicitata/(venit_anual+suma_depozit)*100).
 EXERCIȚII PROPUSE (V)
5. Încărcați într-un df starea civilă, profesia și suma totală solicitată grupată în
funcție de aceste atribute. Introduceți de la tastatură profesia și pentru aceasta
reprezentați grafic suma solicitată în funcție de starea civilă.
 • Using Python with Oracle Database 11g,
https://www.oracle.com/technetwork/articles/dsl/python-
091105.html
• Developing a Python Web Application with Oracle Database 11g,
SURSE https://www.oracle.com/webfolder/technetwork/tutorials/obe/db/
BIBLIOGRAFICE OOW11/python_django/python_django.htm
• https://learncodeshare.net/2015/06/26/insert-crud-using-
cx_oracle/