Cuprins

Elemente de bază ............................................................................................................................ 3

Structura programelor Python ..................................................................................................... 4
Operatori...................................................................................................................................... 4
Spații de nume ............................................................................................................................. 6
Variabile și obiecte ...................................................................................................................... 7
Funcții de bază ................................................................................................................................ 7
Tipuri și structuri de date ................................................................................................................ 8
Tipuri de date scalare .................................................................................................................. 8
Tipuri întregi ............................................................................................................................ 8
Tipul real.................................................................................................................................. 8
Șiruri ........................................................................................................................................ 9
Tipul dată................................................................................................................................... 10
Dicționare .................................................................................................................................. 11
Tupluri ....................................................................................................................................... 13
Liste ........................................................................................................................................... 14
Colecții - set și frozenset ........................................................................................................... 14
Intervale (range) ........................................................................................................................ 16
Structuri de control ....................................................................................................................... 16
Structura alternativă .................................................................................................................. 16
Structuri repetitive ..................................................................................................................... 17
Structura while ....................................................................................................................... 17
Structura for ........................................................................................................................... 17
Tratarea excepțiilor ................................................................................................................... 17
Funcții ........................................................................................................................................... 17
Lucrul cu fișiere ............................................................................................................................ 19
Funcții de bază pentru citirea datelor din fișiere ....................................................................... 19
Citirea datelor utilizând Pandas................................................................................................. 20
Prelucrare matriceală în NumPy.................................................................................................... 20
Masive multidimensionale - ndarray ........................................................................................ 20
Funcții de creare ........................................................................................................................ 21
Atribute ndarray........................................................................................................................ 22
Indexarea masivelor .................................................................................................................. 22
Specificarea dimensiunilor ........................................................................................................ 24
 Operații aritmetice și logice ...................................................................................................... 24
Funcții universale ...................................................................................................................... 25
Tipuri de date pentru masive ndarray........................................................................................ 26
Funcții statistice......................................................................................................................... 26
Funcții pentru inversare, sortare, căutare, selecție .................................................................... 27
Funcții matematice .................................................................................................................... 28
Algebră liniară ........................................................................................................................... 28
Diverse funcții ........................................................................................................................... 28
Structuri de date Pandas ................................................................................................................ 29
Serii (Series) .............................................................................................................................. 29
Tabele de date (DataFrame) ..................................................................................................... 30
Selecția................................................................................................................................... 32
Sortarea datelor ...................................................................................................................... 33
Agregarea datelor .................................................................................................................. 33
Joncțiuni................................................................................................................................. 35
Date de tip categorial................................................................................................................. 36
Clase utilitare ................................................................................................................................ 36
Clasa Counter ............................................................................................................................ 36
Elemente de grafică în Python ...................................................................................................... 37
Tipuri de grafice în matplotlib .................................................................................................. 38
Grafice linie - plot.................................................................................................................. 38
Grafice puncte ...................................................................................................................... 39
Tipuri de grafice în seaborn ...................................................................................................... 40
Grafice puncte - scatterplot ................................................................................................... 40
Grafice linie - lineplot............................................................................................................ 41
Grafice corelogramă - heatmap ............................................................................................. 41
Grafice pentru distribuții ........................................................................................................... 42
Histograme matplotlib ........................................................................................................... 42
Histograme pandas ................................................................................................................ 43
Histograme și grafice de distribuție Seaborn ........................................................................ 44
Reprezentări bivariate pentru distribuții .................................................................................... 44
Elemente de bază
Limbajul Python este un limbaj interpretativ. Interpretorul Python rulează un program prin
executarea acestuia instrucțiune cu instrucțiune. Rularea unui program Python se poate face în linie
de comandă prin apelul interpretorului, trimițând ca parametru numele fișierului Python care
conține codul programului.
De exemplu, pentru un program simplu cu o singură instrucțiune scris în fișierul simplu.py:
print("Salut!")
execuția se realizează în linie de comandă astfel:

Structurarea codului se face utilizând indentarea și caracterele tab și spațiu. Caracterul ; (punct și
virgulă) poate fi folosit pentru a despărți instrucțiuni scrise pe aceeași linie. Într-un bloc prima
instrucțiune de pe o linie trebuie să fie scrisă pe aceeași coloană.
În exemplu de mai jos avem patru blocuri scrise în patru coloane diferite:
for v in [2, 5, 89, 4, 45, 16]: #Bloc1
a = 2 #Bloc2
if v % 2 == 0: #Bloc2
a = 10 #Bloc3
print(v / a) #Bloc3
else:
print(v * a) #Bloc4
Execuția va genera rezultatul:
0.2
10
178
0.4
90
1.6
O caracteristică importantă a limbajului Python este tratarea ca obiecte atât a structurilor de date
cât și a funcțiilor. Fiecare obiect are un tip asociat și date interne.
În codul sursă de mai jos sunt create obiecte de tip clasă, funcție și obiect din clasă:
import math
class Point: #Definim clasa Point in modulul curent
def __init__(self, x=0, y=0):
self.x = x
self.y = y
obiectClasa = Point
obiectPunct = obiectClasa(3,4)
def distanta_la_origine(p):
return math.sqrt(p.x*p.x+p.y*p.y)
obiectFunctie = distanta_la_origine
print(type(obiectClasa),type(obiectPunct),type(obiectFunctie),sep="\n")
print(obiectFunctie(obiectPunct)) #Apelul functiei
La rulare se va afișa:
<class 'type'>
<class '__main__.Point'>
<class 'function'>
5.0
Funcția type din biblioteca standard furnizează tipul obiectului. __main__ indică modulul curent
(cel asociat fișierului sursă curent).

Structura programelor Python

Unitatea structurală de bază într-un program Python este modulul. Modulul corespunde unui fișier
sursa Python cu extensie .py. Numele modulului va fi numele fișierului. Un program Python este
de fapt o ierarhie de module dintre care unul este de nivelul cel mai înalt (top-level script file),
execuția programului constând în rularea acestui modul. Celelalte module sunt importate în
modulul de bază prin instrucțiuni import. Un pachet (package) este un director care conține un set
de module și un fișier numit __init__.py. Fișierul __init__.py poate conține orice cod Python. Acest
cod se va executa la importul pachetului într-un alt modul. Există o variabilă de tip listă cu un
nume predefinit, __all__, care poate fi definită în fișierul __init__.py și care specifică modulele
pachetului care pot fi importate în alte module. În exemplul următor este construit un pachet cu
numele pachet_test, care are două module. Pachetul este importat în modulul test_pachet.
pachet_test/
__init__.py
a.py
b.py
test_pachet.py
În fișierele a.py și b.py se află câte o funcție, astfel:
def functie_a(): #Modul a
print("Modul a")
def functie_b(): #Modul b
print("Modul b")
Conținutul fișierului __init__.py este:
print("__init__()")
__all__ = ["a", "b"]
iar al fișierului test_pachet.py este:
from pachet_test import *
a.functie_a()
b.functie_b()
La executarea modulului test_pachet se va afișa:
__init__()
Modul a
Modul b
Importul pachetelor și al modulelor se face prin instrucțiuni import. Forme ale instrucțiunii import
sunt:
import importable
import importable1, importable2, ..., importableN
import importable as preferred_name
from importable import object as preferred_name
from importable import object1, object2, ..., objectN
from importable import (object1, object2, ..., objectN)
from importable import *
unde importable, importableN pot fi module, pachete sau module din pachete.

Operatori
Operatorii sunt folosiți pentru a efectua operații cu variabile și valori. Principalele categorii de
operatori sunt:
Operatori aritmetici
Operator Nume Exemplu
+ Adunare x+y
- Scădere x-y
* Înmulțire x*y
/ Împărțire x/y
% Modulo x%y
** Putere x ** y
// Împărțire întreagă x // y

Operatori de atribuire
Operator Exemplu Echivalență
= x=5 x=5
+= x += 3 x=x+3
-= x -= 3 x=x-3
*= x *= 3 x=x*3
/= x /= 3 x=x/3
%= x %= 3 x=x%3
//= x //= 3 x = x // 3
**= x **= 3 x = x ** 3
&= x &= 3 x=x&3
|= x |= 3 x=x|3
^= x ^= 3 x=x^3
>>= x >>= 3 x = x >> 3
<<= x <<= 3 x = x << 3

Operatori de comparație
Operator Exemplu
== x == y
!= x != y
> x>y
< x<y
>= x >= y

<= x <= y

Operatori logici
Operator Descriere Exemplu
and x < 5 and x < 10
 or x < 5 or x < 4

not not(x < 5 and x < 10)

is Întoarce true dacă ambii operanzi sunt x is y

referințe la același obiect
is not Întoarce true dacă operanzii sunt x is not y
referințe la obiecte diferite
in Întoarce true dacă operandul 1 care este x in y
o valoare se află în operandul 2 care este
o secvență
not in Negarea operatorului anterior x not in y

Operatori pe biți
Operator Semnificație Descriere
& AND Și logic bit cu bit
| OR Sau logic bit cu bit
^ XOR Sau exclusiv bit cu bit

~ NOT Inversare biți

<< Zero fill left Shift stânga și completare cu 0 în
shift dreapta
>> Signed right Shift dreapta cu menținerea bitului
shift de semn

Spații de nume
Spațiul de nume (scope) reprezintă zona unui program în care un identificator (variabilă) poate
avea acces la valoarea asociată. Spațiile de nume stochează deci informații despre un identificator
și valoarea acestuia. Python are trei spații de nume: local, global și builtins. Spațiul local este
asociat unui bloc. Spre exemplu fiecărei funcții i se atribuie propriul spațiu local asociat blocului
de cod al funcției. Funcțiile nu pot utiliza identificatori definiți în alte funcții, pur și simplu nu sunt
"văzuți". Dacă o funcție încearcă să definească o variabilă definită anterior, se obține doar o nouă
variabilă care are același nume, dar o valoare diferită.
Dacă un identificator nu este definit local, Python va verifica dacă se află în spațiul de nume global.
Spațiul de nume global este diferit de cel local prin faptul că identificatorii globali pot fi folosiți
de alte funcții. Spațiul de nume global este asociat în general cu modulul.
Domeniul builtins este implementat ca un modul de bibliotecă standard numit chiar builtins în
Python 3. În acest modul sunt definite funcții de bază cum ar fi funcția print(). Investigarea
modulului se poate face importându-l explicit și apelând funcția dir:
import builtins
print(dir(builtins))
Dacă un identificator nu este definit local sau global, interpretorul Python va verifica dacă se află
în spațiul builtins.

Variabile și obiecte
Variabilele în Python sunt referințe la obiecte. Se creează prin atribuire în expresii:
a = 10
b = [1,2,3,4]
c = sum(b)
Atribuirile de tipul variabila2=variabila1 creează noi referințe la același obiect. Dacă la codul
anterior adăugăm:
d = b
d[1] = 100
print(b)
la rulare se va afișa:
[1, 100, 3, 4]
În Python variabilele nu au un tip predefinit. Asocierea tipului se face în funcție de tipul obiectului
referit. Obiectele Python au tipuri bine definite. Verificarea tipului se poate face dinamic prin
apelul funcției isinstance() din builtins:
isinstance(object, classinfo); #întoarce True sau False după cum object are sau nu unul din tipurile
specificate prin classinfo. object este obiectul verificat iar classinfo este un tip sau un tuplu de
tipuri asumate pentru obiect (vezi mai jos structura de tip tuplu). Dacă classinfo nu este un tip sau
un tuplu de tipuri, este aruncată o excepție TypeError.
Obiectele Python pot avea atât atribute (alte obiecte Python) cât și metode (funcții asociate unui
obiect care pot avea acces la datele interne ale obiectului). Ambele sunt accesate prin sintaxa
variabila.nume_atribut. Atributele și metodele pot fi furnizate și prin funcția getattr() din builtins:
getattr(object, name[, default]); #object este obiectul investigat, name este numele atributului iar
default este o valoare întoarsă atunci când nu există atributul specificat. Dacă nu există atributul
name și nici nu se specifică default atunci se aruncă o excepție AttributeError.

Funcții de bază
Funcțiile de bază sunt cele definite în spațiul builtins la care interpretorul Python are oricând acces.
În continuare sunt prezentate cele mai des folosite.

abs(x) - întoarce valoarea absolută a unui număr. Se aplică și obiectelor de tip ndarray (numpy) și
DataFrame (pandas) dacă au doar valori numerice.
all(iterable); #Întoarce True dacă toate elementele din iterable sunt True
any(iterable); #Întoarce True dacă există cel puțin un element True în iterable
dir([object]) #Întoarce structura unui obiect - proprietăți și metode - sub formă de listă
eval(expression[, globals[, locals]]); #Evaluarea expresiei specificate. Expresia este dată sub
formă de șir
exec(object[, globals[, locals]]); #Rulare dinamică de cod Python. object este de tip șir
len(s) - furnizează lungimea unui obiect. Aceasta depinde de obiect. De exemplu pentru un
DataFrame este numărul de rânduri.
reversed(seq) - întoarce un iterator pentru secvența inversă a lui seq
Codul următor:
print([i for i in reversed([1,2,3,4,5])])
va afișa:
[5, 4, 3, 2, 1]
range(stop)
range(start, stop[, step])
Funcția range creează un obiect range (vezi tipul range).

Tipuri și structuri de date

Tipuri de date scalare

Tipurile boolean, caracter, numeric și toate tipurile construite prin enumerare sunt scalare. Aceste
tipuri au întotdeauna un număr finit de elemente și există o relație de ordine totală pe ele grație
operatorilor de comparație (adică dintre două elemente unul e mai mare și celălalt mai mic).
Tipurile scalare de bază din Python sunt:
Tip Descriere
None Valoarea nulă - este echivalentul lui null în Python
str Șiruri de caractere Unicode (UTF8)
bytes Secvență immutable (care nu poate fi modificată) de
octeți în format ASCII
float Valoare reală în dublă precizie pe 64 biți
bool Valoare logică True sau False
int Valoare întreagă

Tipuri întregi
Sunt considerate tipuri întregi int și bool. Ambele sunt immutable (valorile nu pot fi modificate).
Prin atribuire se creează o nouă variabilă. Când sunt utilizate în expresiile logice, valorile 0 și
False sunt echivalente, la fel orice alt număr întreg și True. Literalii numerici întregi sunt scriși în
mod implicit în baza 10, dar pot fi scriși și în binar, octal și hexazecimal prin prefixare cu 0b, 0o
și 0x. Crearea unui obiect int se face prin inițializare sau folosind constructorul clasei int:
int([x])
int(x, base=10)
x poate fi un literal valid sau poate fi un șir. În cazul în care se specifică baza trebuie să fie șir.
base poate fi 2,8,10,16
Exemple:
a = int("111")
b = 0b1101111
c = 0o157
d = 0x6f
print(a,b,c,d)
Codul produce:
111 111 111 111

Tipul real
Încadrând la această categorie și tipul complex (deși este inversă incluziunea) în Python sunt trei
tipuri de valori în virgulă mobilă: tipurile float și complex din builtins și tipul decimal.Decimal din
pachetul decimal al bibliotecii standard Python. Literalii reali pot fi scriși și în format exponențial.
Crearea unui obiect float se face prin inițializare sau folosind constructorul clasei float:
float([x]); #x poate fi un literal valid sau un șir
Exemplu
import decimal
a = float(10)
b = 1.0e1
c = complex(1,1)
d= decimal.Decimal(10)
e = b
print(a,b,c,d,e)
print(type(a),type(b),type(c),type(d),type(e))
print(b is a,a==b,b is d,b is e)
Codul anterior produce outputul:
10.0 10.0 (1+1j) 10 10.0
<class 'float'> <class 'float'> <class 'complex'> <class 'decimal.Decimal'>
<class 'float'>
False True False True
Se poate observa efectul operatorilor == și is pentru tipul real. Operatorul is produce True doar
când operanzii sunt referințe șa același obiect.

Șiruri

Datele de tip șir de caractere sunt gestionate prin tipul str. Șirurile sunt delimitate de ghilimele
duble, simple sau triple. Obiectele str sunt immutable. Codificarea implicită este utf8. Alternanța
între ghilimele simple și duble permite inserarea ghilimelelor în literal.
Exemplu:
nume = 'Louis XIV "Sun King"'
Metode str
str.capitalize() - întoarce un șir nou care începe cu literă mare iar restul literelor sunt litere mici
str.casefold() - întoarce un nou șir scris cu litere mici
str.center(width[, fillchar]) - întoarce un șir centrat de lungime width. Dacă width este mai mic
decât lungimea șirului input, atunci va fi întors șirul input. Umplerea la stânga și la dreapta se va
face cu fillchar (dacă lipsește se umple cu spații).
str.count(sub[, start[, end]]) - întoarce numărul de apariții ale subșirului sub în str. Căutarea se
poate limita între indecșii start și end.
str.endswith(suffix[, start[, end]]) - verifică dacă șirul se termină cu suffix. Căutarea se poate limita
la str[start:end].
str.expandtabs(tabsize=8) - expandare tab la spații. Implicit este expandat la 8 spații.
str.find(sub[, start[, end]]) - furnizează indexul primei apariții a subșirului sub. Căutarea se poate
limita la str[start:end].
str.rfind(sub[, start[, end]] - întoarce indexul ultimei apariții a subșirului sub sau -1 dacă nu există.
Metodele index și rindex au aceeași funcționalitate ca metodele find și rfind, dar întorc excepție
ValueError dacă nu găsesc subșirul.
str.format(*args, **kwargs) - permite formatarea șirului. Șirul poate conține și elemente inserate
cu ajutorul acoladelor. Elementele sunt furnizate prin parametrii args.
Exemplu
nume = 'Ludovic al XIV-lea "Regele Soare"'
ani = (1643,1715)
print("Regele {0} a domnit intre anii {1} si {2}".format(nume,ani[0],ani[1]))
Secvența de cod precedentă produce outputul:
Regele Ludovic al XIV-lea "Regele Soare" a domnit intre anii 1643 si 1715
Sintaxa după care se inserează diverse valori în șir este următoarea:
"{" [field_name] ["!" conversion] [":" format_spec] "}"
unde:
field_name - este numele sau indexul parametrului inserat
conversion - indică o conversie înainte de inserție și poate fi: "r" - prin apelul funcției repr(), "s"
- prin apelul constructorului str(), "a" - apel ascii().
format_spec - este specificatorul de format.
Un specificator de format respectă sintaxa:
[[fill]align][sign][#][0][width][grouping_option][.precision][type]
unde:
fill - caracterul de umplere
align - caracter care stabilește alinierea. Poate fi: '<' - aliniere stânga, '>' - aliniere dreapta, '^' -
aliniere centru, '=' - aliniere dreapta cu umplere după semn
sign - stabilește afișarea semnului. Poate fi: '+' - forțează afișarea semnului, '-' - forțează afișarea
semnului pentru numere negative.
width - numărul de caractere afișate
precision - numărul de caractere la partea zecimală
grouping_option - caracter utilizat pentru formarea grupurilor. De exemplu caracterul ',' în cazul
valorilor numerice grupate câte trei la partea întreagă.
type - caracter care specifică tipul. Valori permise (selectiv):
type Semnificație
'b' Format binar. Outputul în baza 2.
'c' Format caracter
'd' Format întreg. Outputul în baza 10.
'o' Format octal. Outputul în baza 8.
'x' Format hexazecimal. Outputul în baza 16 cu litere mici.
'X' Format hexazecimal. Outputul în baza 16 cu litere mari.
'e' Format științific utilizând caracterul ‘e’ pentru exponent. Precizie implicită 6.
'E' Idem cu 'E' pentru exponent
'f' Format în virgulă fixă. Precizie 6
'F' Idem dar folosește NAN în loc de nan (Not A Number)
's' Format de tip string

În specificatorul de format pot intra și șabloane de descriere pentru tipul dată calendaristică (vezi
datetime)

Specificatorul de format poate fi utilizat și în cadrul funcției format:

format(value[, format_spec])
unde value este valoarea formatată.

Tipul dată
Tipul dată este implementat în modulul datetime din biblioteca standard. Principalele clase-tip
sunt:
datetime.date - pentru data curentă conform calendarului gregorian. Atribute: year, month, day
datetime.time - pentru ora curentă. Atribute: hour, minute, second, microsecond, tzinfo
datetime.datetime - pentru data și ora curentă. Atribute: year, month, day, hour, minute, second,
microsecond, tzinfo
datetime.timedelta- pentru diferențe între date până la nivel de microsecunde
tzinfo conține informații referitoare la zonă.
Constructori și metode
datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0,
weeks=0); #Se construiește un interval orar conform cu parametrii specificați
datetime.date(year, month, day)
datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None,
*, fold=0)
datetime.today();datetime.now(tz=None); #Data curentă
datetime.toordinal(); #Întoarce numărul de zile de la 1 ianuarie, anul 1
datetime.fromordinal(ordinal); #Întoarce data corespunzătoare valorii ordinal care reprezintă
număr de zile de la 1 ianuarie anul 1

Operații cu date:
Operație Rezultat
datetime2 = datetime1 + timedelta Se adaugă numărul de zile, minute etc. specificate
în timedelta la datetime1 și se crează datetime2
datetime2 = datetime1 - timedelta Idem scădere
timedelta = datetime1 - datetime2 Calcul diferență în timedelta
datetime1 < datetime2 Compară datele pe baza valorilor ordinal aferente

În specificatoarele de format, datele calendaristice pot fi descrise astfel:

%Y - Anul cu precizie 4
%y - Anul cu precizie 2
%m - Luna [01, 12]
%d - Ziua [01, 31]
%H - Ora (din 24 ore) [00, 23]
%I - Ora (din 12 ore) [01, 12]
%M - Minutul [00, 59]
%S - Secunda [00, 61]
%w - Săptămâna [0 (Duminică), 6]
%W - Săptămâna în an [00, 53 - cu lunea prima zi]
%F - prescurtare pentru %Y-%m-%d (exp. 2012-4-18)
%D - prescurtare pentru %m/%d/%y (exp. 04/18/12)

Dicționare

Sunt colecții neordonate de obiecte identificate prin chei. Sunt implementate intern ca tabele hash.
Inițializarea se face utilizând perechile de paranteze “{}”.
Exemple
dict1 = {}
print(type(dict1))
print(dict1)
note = {"Popescu Adrian":10,"Ionescu Florin":9.69}
print(type(note))
print(note)
Accesul la elemente se face prin cheie folosind paranteze pătrate [].
Exemplu:
print("Nota lui Popescu Adrian:",note["Popescu Adrian"])
Adăugarea de elemente se face folosind indexarea prin cheie:
nume_dict[valoare_cheie_noua]=valoare_noua
Exemplu:
note["Ionescu Diana"]=9.50
print(note)
Testul de existență a unei chei:
valoare_cheie in nume_dict
Exemplu:
cheie = "Ionescu Diana"
if cheie in note:
print(cheie,"are nota",note[cheie])
Obținerea cheilor și a notelor se face prin metodele keys() și values() ale clasei dict.
numele = note.keys()
print("Numele:")
for nume in numele:
print("\t",nume)
notele = note.values()
print("Notele:")
for nota in notele:
print("\t",nota)
Numărul de elemente din dicționar se obține cu funcția:
len(d)
unde d este numele dicționarului.
Ștergerea unui element din dicționar se realizează prin funcția:
del d[key]
unde d este dicționarul iar key este cheia. Funcția aruncă o excepție KeyError dacă nu există cheia
specificată.
Întoarcerea unei valori cu eliminarea ei din dicționar se face prin metoda pop:
pop(key[, default])
unde key este cheia specificată iar default este valoarea întoarsă când nu există cheia.
Crearea unei copii a dicționarului se realizează prin metoda copy:
copy()
Întoarcerea unei valori pe baza cheii sale:
get(key[, default])
unde key este cheia iar default este valoare returnată în cazul în care nu există cheia. Dacă lipsește
parametrul default și nu există cheia, va fi întoarsă valoarea None.
Ștergerea tuturor valorilor:
clear()
Extragerea unei perechi (cheie,valoare) se poate face prin metoda:
popitem()
Perechea este extrasă din dicționar după o disciplină LIFO, este furnizată sub forma unui tuplu și
este eliminată din dicționar.
Tupluri

Tuplurile sunt secvențe eterogene de date de tip immutable. La inițializare elementele sunt
delimitate prin virgulă. Un element poate fi referit prin indexul său folosind paranteze pătrate.
Inițializarea se poate face astfel:
1. Prin utilizarea parantezelor rotunde și a virgulelor. O pereche de paranteze delimitează un
element.
Exemplu. Secvența de cod:
note = (10,4,9),(5,6)
print("Note grupate:",note)
print(note[0])
produce outputul:
Note grupate: ((10, 4, 9), (5, 6))
(10, 4, 9)
2. Prin invocarea constructorului clasei sub forma:
tuple()
tuple(iterable)
unde iterable este o secvență iterabilă.
Exemplu. Secvența de cod:
nume = tuple("Popescu")
print(nume)
produce outputul:
('P', 'o', 'p', 'e', 's', 'c', 'u')
deoarece șirul "Popescu" este interpretat ca o secvență iterabilă de caractere.
Există posibilitatea descompunerii și atribuirii valorilor dintr-un tuplu unor variabile grupate în
concordanță cu structura tuplului (Unpacking tuples).
Exemplu. Codul:
note_afer,note_info=note
print("Note discipline AFER:",note_afer)
print("Note discipline informatica:",note_info)
va avea outputul:
Note discipline AFER: (10, 4, 9)
Note discipline informatica: (5, 6)
unde variabila note a fost inițializată într-unul din exemplele anterioare.
Frecvența unui element dintr-un tuplu este furnizată de metoda:
count(element)
Numărul de elemente din structură se obține prin funcția len (vezi dict).
Căutarea în tuplu se poate face prin metoda:
index(x[, i[, j]]); #Întoarce indexul primei apariții a lui x în tuplu. Se poate specifica intervalul de
căutare prin i și j
Tuplurile permit operațiunea de despachetare (unpack) prin care elementele componente pot fi
atribuite individual unor variabile.
Exemplu
a = (1,"alpha",3.14)
a1,a2,a3 = a
print(a1,a2,a3)
Liste

Clasa List definește o secvență de lungime variabilă. O listă se poate defini în felul următor:
1. Prin inițializare cu ajutorul parantezelor și virgulelor
2. Prin utilizarea constructorului clasei List
list()
list(iterable)
unde iterable este o secvență iterabilă.
3. Prin filtrarea elementelor unei colecții: x for x in iterable
Exemplu. Secvența de cod:
#initializare prin paranteze
grupe = [["Popescu Diana","Ionescu Dan"],["Pop Diana","Popa Adrian"]]
print("Numar de grupe:",len(grupe))
print("Grupa de index 1",grupe[1])
#initializare prin constructor
nume = list("Popescu")
print(nume)
#initializare prin filtrare
note = (10,10,8,4,9,4)
note_promovare = [x for x in note if x>4]
print("Note de promovare:",note_promovare)
va produce outputul:
Numar de grupe: 2
Grupa de index 1 ['Pop Diana', 'Popa Adrian']
['P', 'o', 'p', 'e', 's', 'c', 'u']
Note de promovare: [10, 10, 8, 9]
Sortarea listelor se poate realiza prin metoda sort() și prin funcția sorted(). Funția sorted este
aplicabilă tuturor secvențelor și întoarce o listă cu elementele sortate.
sort(*, key=None, reverse=False)
Sortarea se poate face în ordine crescătoare sau descrescătoare și modifică lista în sensul sortării.
key este o funcție care este folosită pentru a furniza o cheie utilizată în comparație pentru fiecare
element de listă
Adăugarea și ștergerea elementelor din listă se realizează prin metodele:
list.append(x)
list.extend(iterable)
list.insert(i, x); #inserare în poziția i
list.remove(x)
list.pop([i]); #Ștergere de la sfârșit sau din poziția i
list.clear()
Concatenarea listelor se poate face prin operatorul +.

Colecții - set și frozenset

Colecțiile sunt mulțimi de obiecte hashable distincte (care au asociate un cod unic de identificare
și sunt immutable). Nu au index și ordine. Colecțiile set sunt modificabile în timp ce frozenset sunt
immutable. Un obiect set nu poate intra în componența altuia fiind immutable.
Crearea unui obiect set se poate face prin inițializare sau prin constructorul clasei:
class set([iterable])
class frozenset([iterable])
unde iterable poate fi un obiect iterabil.
Exemple
note = {10,6,4,9,6,5}
print("Continut:",note,"Tip:",type(note))
nume = set(("Popa Adrian","Ionescu Dan"))
print(nume)

Operațiuni cu obiecte set

1. Determinare lungime prin funcția:
len(s)
s - obiectul set
2. Adăugare de elemente prin metoda add
add(elem)
3. Eliminare elemente
remove(elem)
Dacă elementul nu există este aruncată o excepție KeyError
discard(elem)
Este eliminat elementul dacă există.
pop()
Șterge un element în mod arbitrar ales. Acesta este întors ca valoare.
clear()
Ștergerea tuturor elementelor din set.
4. Teste de apartenență
x in s
x not in s
5. Actualizare, uniune, intersecție, diferență, copiere
update(*others), intersection_update(*others), difference_update(*others),
symmetric_difference_update(other), isdisjoint(other), issubset(other), issuperset(other),
union(*others), intersection(*others), difference(*others), symmetric_difference(other), copy()
other - alt set
*others - alte seturi
Exemple
set1 = {10, 8, 9, 7, 6}
print("set1:", set1)
if 4 in set1:
print("4 este in set")
else:
print("4 nu este in set")
set2 = {4, 5, 3, 6}
print("set2:",set2)
if set1.isdisjoint(set2):
print("Seturi diferite.")
else:
print("Seturi cu elemente comune.")
set3 = {8, 6, 7,77}
print("set3:",set3)
if set1.issuperset(set3):
print("set1 include set3")
else:
print("set1 nu include set3")
print("Uniunea intre ", set1,"si", set2, ":", set1.union(set2))
print("Intersectia intre", set1,"si", set2, "este", set1.intersection(set2))
print("Diferenta dintre", set1,"si", set2, "este", set1.difference(set2))
print("Diferenta simetrica dintre", set1,"si", set2, "este",
set1.symmetric_difference(set2))
set4 = set3.copy()
print("set3:",set3,"set4",set4)
set5 = {10,20,30}
set6 = {100,300,400,200}
print("set1",set1)
set7=set1.union(set5,set6)
print("set7",set7)
set1.update(set5,set6)
print("set1:",set1)

Intervale (range)

Intervalul este o secvență numerică dintr-un interval specificat. Un obiect range se creează
invocând constructorul clasei range.
class range(stop)
class range(start, stop[, step])
unde start, stop și step sunt limita inferioară, limita superioară și pasul secvenței.
În general intervalele sunt utilizate în iterații sau ca parametrii în constructorii de secvențe.
Exemplu. Secvența de cod:
for i in range(5):
print("Iteratie",i)
interval1 = set(range(10,20))
print(type(interval1),interval1)
interval2 = list(range(10,20))
print(type(interval2),interval2)
va produce outputul:
Iteratie 0
Iteratie 1
Iteratie 2
Iteratie 3
Iteratie 4
<class 'set'> {10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
<class 'list'> [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Structuri de control

Structura alternativă
Structura alternativă are sintaxa:
if boolean_expression1:
suite1
elif boolean_expression2:
suite2
...
elif boolean_expressionN:
 suiteN
else:
else_suite
unde suite... sunt blocuri de cod executate ca rezultat al evaluării expresiilor booleene.
În unele situații structura alternativă poate fi înlocuită cu expresia condițională:
expression1 if boolean_expression else expression2

Structuri repetitive

Structura while
while boolean_expression:
while_suite
else:
else_suite
Ramura else este opțională.

Structura for
for expression in iterable:
for_suite
else:
else_suite
Ramura else este opțională. iterable trebuie să fie un obiect iterabil.

Tratarea excepțiilor
În Python tratarea excepțiilor este opțională și se realizează prin instrucțiunea try:
try:
try_suite
except exception_group1 as variable1:
except_suite1
…
except exception_groupN as variableN:
except_suiteN
else:
else_suite
finally:
finally_suite
Obiectele excepție sunt captate în variabilele variable1,..., variableN. Blocul finally este opțional
și se execută la sfârșit indiferent de captarea vreunei excepții.

Funcții
Funcția este principala metodă de organizare și reutilizare a codului în orice limbaj. De asemenea,
funcțiile cresc lizibilitatea codului. Funcțiile de utilizator pot fi globale sau locale după cum sunt
definite în spațiul de nume global sau local. La funcțiile de utilizator se adaugă funcțiile din builtins
(vezi mai sus).
Sintaxa generală pentru definirea unei funcții este:
def functionName([par1[=valpar1],...,parN[=valparN]]):
suite
[return val1[,val2,...,valN]]
În Python funcțiile sunt tratate ca obiecte. La execuția instrucțiunii def se generează un nou obiect
funcție căruia i se atribuie numele funcției. Numele funcției devine o referință la obiectul funcție.
În mod opțional în codul funcției poate exista o ultimă instrucțiune return. Când return lipsește
funcția întoarce None. Când sunt întoarse valori multiple acestea trebuie recepționate într-un
număr egal de variabile sau într-o variabilă tuplu. Transmiterea parametrilor se face prin referință
și nu prin valoare. Modificările făcute în funcție se vor reflecta și în codul apelator. Parametrii
funcției pot fi inițializați caz în care se numesc parametrii default. Un parametru default nu mai
poate fi urmat decât de parametrii default. Deci parametrii non-default trebuie să fie grupați la
începutul listei de parametrii.
Exemplu
def calcule(x, y=20): #y este parametru default
return x + y, x * y, x - y
def initializare(x):
if isinstance(x, list):
for i in range(0, len(x)):
x[i] = 100
a, b, c = calcule(10.0, 20)
v = calcule(10) # Intoarcere rezultat in tuplu
print(a, b, c, "\n", v)
x = [1, 2, 3, 4]; y = 1
initializare(x); initializare(y)
print(x, "\n", y)
Ouputul generat va fi:
30.0 200.0 -10.0
(30, 200, -10)
[100, 100, 100, 100]
1
Apelul funcțiilor se poate face și specificând numele parametrilor. În cazul acesta nu mai este
necesară păstrarea ordinii parametrilor. Parametrii actuali (cei din apel) vor fi puși în
corespondență cu parametrii formali (cei din definiția funcției) pe baza numelui. Pa
O formă flexibilă, specifică Python, de a trimite parametrii este folosind parametrii formali
standard *nume sau **nume.
Exemplu
def functie1(**kwargs):
print(type(kwargs))
for k in kwargs.keys():
print(kwargs[k])
def functie2(*par):
print(type(par))
for p in par:
print(p)
functie1(a=10, b=11, c=[1, 2, 3, 4])
functie2(3,10,[1,2,3,3])
Codul va genera outputul:
<class 'dict'>
10
11
[1, 2, 3, 4]
<class 'tuple'>
3
10
[1, 2, 3, 3]
Se poate observa că **kwargs este interpretat ca un dicționar iar *par ca un tuplu.

Lucrul cu fișiere
Funcții de bază pentru citirea datelor din fișiere

Obiectele fișier sunt create prin funcția open:

open(file, mode='r', ...)
Dacă nu se poate crea fișierul este aruncată o excepție OSError.
Parametrul file este calea asociată fișierului.
Parametrul mode specifică modul în care va fi deschis fișierul:
Valoare Semnificație
'r' citire (implicit)
'w' scriere
'x' creare exclusivă cu eșuare dacă fișierul există
'a' deschidere pentru adăugare
'b' deschidere în mod binar
't' deschidere în mod text (implicit)
Exemplu. În secvența următoare de cod sunt citite și afișate liniile dintr-un fișier text.
f_input = open("f1.txt",'r')
print(type(f_input))
for linie in f_input:
print(linie,end="")
f_input.close()
Funcția open întoarce un obiect din clasa io.TextIOBase, în mod specific pentru un fișier text din
subclasa io.TextIOWrapper sau din clase precum io.BufferedIOBase, io.BufferedReader etc.
pentru fișiere binare. Aceste clase permit tratarea fișierelor ca fluxuri de intrare/ieșire (stream).
Pentru citirea liniilor din flux pentru un fișier text se folosesc metodele readline() și readlines().
Prima metodă întoarce șir vid dacă este întâlnit sfârșitul de fișier. Închiderea fluxului se realizează
prin metoda close().
Exemple
f_input.close()
f_input = open("f1.txt",'r')
linii = f_input.readlines()
for linie in linii:
print(linie,end="")
f_input.close()
f_input = open("f1.txt",'r')
linie = f_input.readline()
while linie:
print(linie,end="")
 linie=f_input.readline()
f_input.close()

Citirea datelor utilizând Pandas

Pentru citire din fișiere text se folosesc funcțiile read_csv() și read_table(). Principalii parametrii
ai acestor funcții sunt:

Parametru Tip valori Valoare Semnificație

implicită
filepath_or_buffer Cale fișier text
sep str ',' sau '\t' Separator coloane
header întreg ori listă de 'infer' Stabilește cum se citesc numele de
întregi coloae. infer sau 0- se citesc din prima
linie; None - vor fi etichetate de la 0 la
N; un întreg nenul indică linia din care se
citesc numele de coloane
names listă None Lista cu nume asociate coloanelor
index_col int Coloana care furnizează numele de
instanțe

Prelucrare matriceală în NumPy

NumPy este un pachet care permite lucrul cu masive multidimensionale. Sunt permise operațiile
fundamentale cu masive, calcul numeric (algebră liniară, generare numere aleatoare, transformate
Fourier etc.), operațiuni de citire/scriere din/în fișiere. Funcțiile și metodele sunt comprehensive,
la nivel de masiv fără a necesita scrierea de structuri repetitive. Calculele sunt rapide, NumPy
având bibliotecile de algoritmi scrise in C. NumPy asigură o bună interoperabilitate cu C (urmare
a scrierii bibliotecilor în C).

Masive multidimensionale - ndarray

Masivele de tip ndarray sunt folosite de structuri de date Python ca suport de tip container (de
exemplu DataFrame din pandas). Obiectele ndarray pot fi create utilizând constructorul sau prin
diverse funcții precum array, zeros, empty, full etc.

class numpy.ndarray(shape, dtype=float, buffer=None, offset=0, strides=None, order=None)

Exemplu
x = np.ndarray(shape=(2,1),dtype=int,buffer=
bytes([0,0,0,0,0,0,0,0,0,0]),offset=2)
print(x)
Output:
[[0]
[0]]
Funcții de creare

numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

numpy.zeros(shape, dtype=float, order='C')
numpy.empty(shape, dtype=float, order='C')
numpy.full(shape, fill_value, dtype=None, order='C')
numpy.ones(shape, dtype=None, order='C); #Masiv inițializat cu 1
shape – indică adimensionalitatea: număr de elemente pe prima dimensiune, a doua șamd. Este
furnizate sub formă de tuplu.
dtype - furnizează tipul. Pentru None, tipul este determinat prin analiza valorilor.
order - valorile sunt alocate pe linii (C - stilul C) sau pe coloane (F - stilul Fortran). Pentru array
mai sunt valorile K și A pentru păstrarea disciplinei din object.
buffer – obiect cu sursa datelor folosite pentru inițializarea masivului. Trebuie să fie o structură
care să furnizeze octeții necesari inițializării (alt ndarray sau bytes).
offset – offset folosit in buffer
stride – tuplu de incremenți pentru dimensiunile masivului
object - obiect compatibil ndarray
Exemple
x_int = np.array([i for i in range(10)],dtype=np.int64)
x_double = np.array([i for i in range(10)],dtype=np.double)
x_empty_int = np.empty(shape=(3,),dtype=np.int64)
x_empty_double = np.empty(shape=(3,),dtype=np.double)
x_str = np.empty(shape=(10,),dtype=str)
x_chararray = np.empty(shape=(10,),dtype=np.chararray)
x_str[0] = "Sir"
x_chararray[0] = "Sir"
x_zero_int = np.zeros(shape=(10,),dtype=np.int64)
x_zero_double = np.zeros(shape=(10,),dtype=np.double)
x_doi = np.full(shape=(10,),fill_value=2,dtype=np.double)
print(x_int,x_double,x_empty_int,x_empty_double,x_str,
x_chararray,x_zero_int,x_zero_double,x_doi,sep="\n")
Otputul produs de codul de mai sus este:
[0 1 2 3 4 5 6 7 8 9]
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
[28429440805568590 0 0]
[1.06810268e-306 2.55900640e-307 2.12202979e-312]
['S' '' '' '' '' '' '' '' '' '']
['Sir' None None None None None None None None None]
[0 0 0 0 0 0 0 0 0 0]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[2. 2. 2. 2. 2. 2. 2. 2. 2. 2.]
Se poate observa că la inițializarea unui vector de tip șir de caractere este corectă indicarea tipului
np.chararray care permite modificarea ulterioară a valorilor.
numpy.identity(n, dtype=None) ;creează o matrice identitate cu n linii/coloane
numpy.asarray(a, dtype=None, order=None) ;creare din alt obiect, a. Acesta poate
fi listă, listă de tupluri, tuplu, tuplu de tupluri, tuplu de liste.
numpy.arange([start, ]stop, [step, ]dtype=None) ;generare masiv unidimensional în intervalul
specificat
numpy.random.random(size=None) ;generare valori aleatoare după o distribuție uniformă în
intervalul [0,1]. Dacă size este un tuplu, valorile generate for grupate într-un ndarray de
dimensiunile specificate. Funcții asemănătoare pot fi folosite și pentru alte distribuții. De exemplu
pentru o distribuție normală avem:
numpy.random.normal(loc=0.0, scale=1.0, size=None) ;loc este media, scale este abaterea
standard.
Exemplu
import numpy as np
x = np.random.random((3,3))
y = np.random.normal(size=(3,3))
print('x:',x,sep='\n')
print('y:',y,sep='\n')
Posibil output:
x:
[[0.4990161 0.98840337 0.31075348]
[0.29552643 0.873924 0.44115962]
[0.23291045 0.49319993 0.69960656]]
y:
[[-0.6274206 -0.51708741 1.0099042 ]
[-0.16381457 -1.88115724 -0.78761556]
[-0.95566761 -0.44526572 -0.72777706]]
numpy.diag(v, k=0) ;Furnizează o matrice diagonală cu elementele din v daca v este
unidimensional sau diagonala lui v dacă v este matrice.
numpy.trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None) ;Furnizează urma
matricei a
numpy.tril(m, k=0) ;Furnizează matricea inferior diagonală a lui m
numpy.triu(m, k=0) ;Idem superior diagonală
numpy.tri(N, M=None, k=0, dtype=<class 'float'>) ;Furnizează o matrice cu valori 1 sub
diagonala și pe diagonală, restul fiind 0. N este numărul de linii iar M este numărul de coloane.
Daca nu este specificat M, acesta va fi N.

Atribute ndarray
shape - tuplu cu numărul de elemente pe fiecare dimensiune. Modificarea atributului shape se
poate face doar cu menținerea numărului de elemente.
ndim - număr de dimensiuni
size - număr de elemente
real, imag - parte reală/imaginară
T - transpusa
nbytes – numărul total de octeți
itemsize – numărul de octeți ai unui element

Indexarea masivelor

Referirea unui element se face prin indecși de linie, coloana șamd. Indecșii sunt trecuți între
paranteze pătrate sub forma:
[index_linie,index_coloana] sau [index_linie][ index_coloana]
Referirea unor părți întregi din masiv (feliere - slice) se face prin expresii de forma:
start:stop:step
inde start este indexul de început, stop este indexul de sfârșit iar step este pasul.
În acest interval indexul va avea valorile în intervalul [start,stop-step).
În felierea folosind indexarea prin duble paranteze [][] expresiile de feliere au sens doar pentru
ultima dimensiune.
Prin feliere se obține o viziune a masivului original. Datele nu sunt copiate în alt masiv.
Modificările făcute afectează masivul original.
Exemple
import numpy as np
x = np.array(np.arange(start=1,stop=4*5+1)).reshape(4,5)
print("x:",x)
print("Elementul de pe linia 3 si coloana 4:",x[2,3])
print("Elementul de pe linia 3 si coloana 4:",x[2][3])
print("Coloana 3:",x[:,2])
print("Linia 3:",x[2,:])
print("Linia 3:",x[2][:])
print("Submatrice:",x[1:3,1:3])
y = x[1:3,1:3]
y[:,:] = 0
print('z:',x)
Codul anterior va produce outputul:
x: [[ 1 2 3 4 5]
[ 6 7 8 9 10]
[11 12 13 14 15]
[16 17 18 19 20]]
Elementul de pe linia 3 si coloana 4: 14
Elementul de pe linia 3 si coloana 4: 14
Coloana 3: [ 3 8 13 18]
Linia 3: [11 12 13 14 15]
Linia 3: [11 12 13 14 15]
Submatrice: [[ 7 8]
[12 13]]
z: [[ 1 2 3 4 5]
[ 6 0 0 9 10]
[11 0 0 14 15]
[16 17 18 19 20]]

Numpy permite indexarea booleană. Indexarea masivelor se poate face folosind ca index un alt
masiv de tip boolean. Masivul-index trebuie să aibă aceleași dimensiuni cu masivul indexat. Prin
indexarea booleană sunt selectate valorile care corespund elementelor True din masivul-index.
Exemplu
import numpy as np
y = np.array(np.arange(1,16)).reshape((3,5))
print(y[y>7])
Output
[ 8 9 10 11 12 13 14 15]
Au fost selectate valorile mai mari decât 7 din y.

O altă modalitate flexibilă de indexare este prin masive numpy și prin tupluri. Indexarea prin
masive și tupluri. Dacă masivul-index este vector, elementele vectorului vor specifica elementele
primei dimensiuni din masivul indexat. Dacă masivul-index este o matrice, prin indexare se va
selecta un masiv tridimensional cu un număr de matrice egal cu numărul de linii al matricei-index,
fiecare matrice fiind construită de elementele din liniile matricei-index. La indexarea prin tuplu,
numărul de elemente din tuplu nu trebuie să depășească numărul de dimensiuni
Exemple

Specificarea dimensiunilor
La indexare dimensiunea este indicată de paranteze: [dimensiune1,dimensiune2,..] sau
[dimensiune1][dimensiune2]...
În funcții care implică efectuarea unor calcule la nivelul masivului, dimensiunile sunt specificate
prin axe care specifică sensul calculului:

Axis 2
Axis 1

Axis 1
Axis 0 Axis 0

Redimensionarea masivelor se face prin funcțiile:

ndarray.reshape(shape, order='C')
numpy.reshape(a, newshape, order='C')

Operații aritmetice și logice

Pot fi efectuate operații aritmetice la nivel de masiv, fără repetiții prin vectorizare. Acestea pot fi
efectuate utilizând operatorii clasici:
* ;înmulțire la nivel de element
/ ;împărțire
+,- ;adunare, scădere
@ ;înmulțire matriceală
** ;ridicare la putere
>,<,>=,<= ;comparații
Exemple
x = np.array([[1., 2., 3.], [4., 5., 6.]])
y = np.arange(9).reshape((3,3))
print("x:",x,"\ny:",y)
print("x+x:",x+x);print("x-x:",x-x);print("x*2:",x*2);print("x/2:",x/2)
print("x**0.5:",x**0.5);print("x@y:",x@y)
print("x<=3:",x<=3)
Codul precedent produce outputul:
x: [[1. 2. 3.]
[4. 5. 6.]]
y: [[0 1 2]
[3 4 5]
[6 7 8]]
x+x: [[ 2. 4. 6.]
[ 8. 10. 12.]]
x-x: [[0. 0. 0.]
[0. 0. 0.]]
x*2: [[ 2. 4. 6.]
[ 8. 10. 12.]]
x/2: [[0.5 1. 1.5]
[2. 2.5 3. ]]
x**0.5: [[1. 1.41421356 1.73205081]
[2. 2.23606798 2.44948974]]
x@y: [[24. 30. 36.]
[51. 66. 81.]]
x<=3: [[ True True True]
[False False False]]
Funcții universale
Sunt funcții generale care se pot executa și la nivel de simplii scalari. În numpy acestea sunt
executate prin vectorizare.

Funcție Descriere
abs fabs Valoare absolută
sqrt Radical
square Pătrat
exp Putere naturală
log log10 log2 log1p Logaritmi: e,10,2 log 𝑒 (1 + 𝑥)
sign Calculează semnul: 1 (pozitiv) 0 (zero) -1 (negativ)
ceil Cel mai mic întreg mai mare sau egal cu argumentul
floor Cel mai mare întreg mai mic sau egal cu argumentul
rint Rotunjire întreagă
modf Întoarce partea întreagă și fracționară în masive separate
isnan Întoarce masiv cu indicații booleene asupra valorii NaN
isfinite isinf Întoarce masiv cu indicații booleene asupra valorilor
finite/infinite
cos cosh sin sinh tan tanh Funcții trigonometrice normale și hiperbolice
arccos arccosh arcsin arcsinh Funcții trigonometrice inverse
arctan arctanh

Funcție Descriere
add Adunare scalară
subtract Scădere
multiply Înmulțire
divide floor_divide Împărțire
power Putere
maximum fmax Maxim
minimum fmin Minim
mod Modul
greater greater_equal less less_equal equal Comparații
not_equal
 logical_and logical_or logical_xor Operații logice

Tipuri de date pentru masive ndarray

Tipurile de date pentru elementele masivelor numpy sunt:

Tip Descriere
int8 uint8 Întreg cu/fără semn pe 1 byte
int16 uint16 Întreg cu/fără semn pe 2 bytes
int32 uint32 Întreg cu/fără semn pe 32 biți
int64 uint64 Întreg cu/fără semn pe 64 biți
float16 Real virgulă mobilă pe 16 biți
float32 Real virgulă mobilă pe 32 biți; compatibil cu float C
float64 Real virgulă mobilă pe 64 biți compatibil cu float C și
standard float Python
float128 Real virgulă mobilă pe 64 biți
complex64 Complex pe 32, 64 sau 128 biți
complex128
complex256
bool Boolean
object Tip object Python - o valoare care poate fi orice obiect
Python
string_ ASCII cod lungime fixă - 1 byte per caracter
unicode_ Unicode

Funcții statistice
Funcțiile statistice sunt implementate în manieră vectorizată la nivel de masiv/tabel de date sau de
linie/coloană.
numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>) ;Calcul medie.
Prin parametrul axis indică la ce nivel (dimensiune) se va face calculul. axis = 0 înseamnă prima
dimensiune, deci pentru o matrice asta înseamnă că se vor calcula mediile pe coloane.
Observație. In Python dimensiunile masivelor sunt văzute ca un sistem de axe. Axa 0 marchează
coloanele iar axa 1 marchează liniile.
numpy.std(a, axis=None, ddof=0, ...) ;Abatere standard. ddof este parametrul utilizat în
calculul gradelor de libertate: N- ddof, unde N este numărul elementelor.
numpy.var(a, axis=None, ddof=0, ...) ;Varianța
numpy.average(a, axis=None, weights=None, returned=False) ;Calcul medie ponderată.
Ponderile sunt furnizate prin parametrul weights.
numpy.corrcoef(x, y=None, rowvar=True, bias=<no value>, ddof=<no value>) ;Calcul
matrice de corelații Pearson. rowvar indică dispunerea variabilelor - pe linii (True) sau pe coloane.
 R xx R xy 
Dacă x și y sunt matrice se va calcula un tabel partiționat cu patru matrice de corelație:  
 R yx R yy 
, unde Ryy și Rxx sunt matricele de corelație ale lui x și y, Rxy și Ryx sunt matricele de corelație între
coloanele/liniile matricei x și cele ale matricei y.
numpy.cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None);
Calcul matrice covarianță. bias și ddof controlează gradele de libertate: bias=False, ddof=1
înseamnă N-1 grade de libertate, bias=True, ddof=0 înseamnă N grade de libertate. fweights și
aweights furnizează frecvențe și ponderi folosite în calcul. rowvar indică așezarea seriilor de date
pe linie (True) sau coloană (False)
În codul de mai jos este standardizată o matrice:
import numpy as np
x = np.asarray([[3,4,5],[1,1,1],[2,2,2]])
print("x:",x)
stdx = np.std(x,axis=0)
print("Abateri standard pe coloane:",stdx)
meanx = np.mean(x,axis=0)
print("Medii pe coloane:",meanx)
z = (x-meanx)/stdx
print("x standardizat:",z)
Rezultatul rulării este:
x: [[3 4 5]
[1 1 1]
[2 2 2]]
Abateri standard pe coloane: [0.81649658 1.24721913 1.69967317]
Medii pe coloane: [2. 2.33333333 2.66666667]
x standardizat: [[ 1.22474487 1.33630621 1.37281295]
[-1.22474487 -1.06904497 -0.98058068]
[ 0. -0.26726124 -0.39223227]]
numpy.histogram(a, bins=10, range=None, normed=None, weights=None, density=None); Calcul
histograme. Funcția întoarce frecvențele și intervalele.
a - masiv numpy sau orice obiect compatibil (listă, serie Pandas etc). Masivele multidimensionale
sunt liniarizate
bins - număr de grupe sau limite de grupe sau numele strategiei de grupare (ex. 'sturges')
range - limitele. Implicit: (a.min(), a.max())
weights - ponderi asociate valorilor
density - calcul și returnare frecvențe sub formă de probabilități, astfel:
p_i = n_i / (n * latime_interval_i),
unde p_i este probabilitatea calculată pentru grupa i, n_i este frecvența grupei i, n este numărul
total de elemente latime_interval_i este lățimea intervalului pentru grupa i (limita superioară -
limita inferioară). Implicit:False.

Funcții pentru inversare, sortare, căutare, selecție

numpy.sort(a, axis=-1, kind='quicksort', order=None) ;Întoarce o copie sortată a obiectului
(convertibil la masiv). axis poate fi None caz în care este sortat tot masivul liniarizat, -1 pentru
sortare după ultima axă sau poate specifica o axă de sortare. kind specifică algoritmul și poate fi:
quicksort’, ‘mergesort’, ‘heapsort’. order specifică în ce ordine sunt utilizate câmpurile în sortare
în cazul când un element din masiv are mai multe câmpuri.
numpy.argsort(a, axis=-1, kind='quicksort', order=None) ;Întoarce indicii elementelor sortate
numpy.flipud(m), numpy.fliplr(m); Inversează elementele unui masiv pe linii/coloane. ud ->
up/down (pe coloane), lr ->left/right (pe linii). Prima funcție este aplicată și pentru masive
unidimensionale și produce inversarea elementelor.
Funcții matematice

Funcțiile matematice implementează operații matematice de bază precum sume, produse, funcții
trigonometrice, logaritmice, exponențiale etc.
numpy.sum(a, axis=None,..., initial=<no value>) ;Calculează suma la nivel de masiv sau pe axe
(coloane sau linii pentru un masiv bidimensional). inițial este valoarea inițială a sumei.
numpy.prod(a, axis=None, ..., initial=<no value>) ;Idem produs
numpy.cumsum(a, axis=None, ...) ;Calculează sume cumulative (progresive) la nivel de masiv
sau pe dimensiuni
numpy.cumprod(a, axis=None, ...) ;Idem produse
numpy.transpose(a, axes=None); Calcul transpusă pentru masivul a. axes este o listă de întregi
reprezentând axele transpuse.

Algebră liniară

numpy.linalg.inv(a) ;Calculează inversa matricei a

numpy.matmul(a, b, out=None) ;Produsul a două matrice
numpy.linalg.eig(a) ;Calculează valorile proprii și vectorii proprii ai matricei a
numpy.linalg.svd(a, full_matrices=True, compute_uv=True) ;Efectuează descompunerea
în valori singulare pentru matricea a. compute_uv indică returnarea matricelor ortogonale.
full_matrices indică determinarea matricelor ortogonale în formă completă

Diverse funcții

Copiere
ndarray.copy(order='C')
numpy.copy(a, order='K')
Conversie la listă
ndarray.tolist()
Umplere cu o valoare
ndarray.fill(value)
Restructurare (reshape, resize). Întoarce un nou obiect în noua structură. Numărul de elemente
trebuie să rămână același.
ndarray.resize(new_shape, refcheck=True)
numpy.resize(a, new_shape)
Metoda resize modifică obiectul curent în timp ce funcția resize creează alt obiect.
Transpunerea
ndarray.transpose(*axes)
Întoarce o viziune transpusă a obiectului. Este similară proprietății T. Există și funcția identică.
axes - tuplu prin care se specifică axele
Poziționare
numpy.where(condition[, x, y]) ;Întoarce indecșii elementelor care îndeplinesc condițiile sub
formă de tuplu
numpy.take(a, indices, axis=None, out=None, mode='raise') ;Întoarce valorile din a
corespunzătoare indicilor
Exemplu poziționare. Eliminarea valorilor lipsă dintr-o matrice cu mediile pe coloane
medii = np.nanmean(X,axis=0)
k_nan = np.where(np.isnan(X))
X[k_nan]=np.take(medii,k_nan[1])
unde X este matricea cu valori lipsă
Alte funcții
numpy.isnan(x, out=None, ...) ;Întoarce un masiv ndarray sau un boolean simplu, cu valori True
sau False după cum sunt identificate valori lipsă (nan) în x. x este ndarray sau compatibil. out este
un output specificat pentru rezultat.

Structuri de date Pandas

Serii (Series)

Seriile sunt masive unidimensionale etichetate care operează cu date de orice tip (întregi, șiruri,
numere reale, obiecte Python, etc.). Etichetele axelor sunt denumite indici.
class pandas.Series(data=None, index=None, dtype=None, name=None, copy=False,
fastpath=False)
data - structura de date care va furniza conținutul. Poate fi orice este reductibil la masiv
unidimensional sau dict
index - furnizează etichetele și poate fi o structură reductibilă la masiv unidimensional. Trebuie să
aibă aceeași dimensiune cu data.
dtype - tipul de dată al elementelor din data. Poate fi str sau un tip numpy.
copy - indică dacă se creează structura data prin copierea sursei.
Exemplu
a = np.array([1,2,3])
s1 = pd.Series(data=a)
s2 = pd.Series(data=a,copy=True)
a[2] = 1000
print(s1,s2,sep="\n")
Output:
0 1
1 2
2 1000
dtype: int32
0 1
1 2
2 3
dtype: int32
Este o structură compatibilă cu ndarray din NumPy și dict, deci poate fi operată în același mod. În
operațiunile cu două serii vor fi identificate și operate elementele care au același index. În exemplul
de mai jos se va face media pe discipline pentru două serii care reprezintă note identificate prin
numele disciplinelor. Depinderea de textul enunțat.

Exemplu
import pandas as pd
import statistics as stt
#note semestrul 1
noteS1=
pd.Series(data={"Istorie":10,"Geografie":7,"Matematica":10,"Fizica":9})
print(noteS1["Matematica"],noteS1[2])
#note semestrul 2
noteS2=pd.Series(data={"Istorie":9,"Geografie":7,"Matematica":10,"Fizica":7})
medii = noteS1.combine(noteS2,func= lambda x1,x2:stt.mean([x1,x2]))
print(medii)
Codul anterior produce outputul:
10 10
Istorie 9
Geografie 7
Matematica 10
Fizica 8
dtype: int64

Tabele de date (DataFrame)

Un tabel de date reprezintă o structură de date bidimensională ce constă într-o colecție ordonată
de coloane, fiecare dintre acestea putând avea un tip de valoare diferit (numeric, șir, boolean, etc.).
Un DataFrame are atât indici de rând, cât și de coloană. Poate fi considerat ca un dicționar de serii.
class pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)
data - este o structură de tip dict, NumPy ndarray sau DataFrame
index - numele de rânduri
columns - numele de coloane
dtype - Tip de date aplicat întregului tabel. În caz de incompatibilitate este asumat tipul object.
copy - Indică copierea structurii de date. Parametrul se aplică doar în cazul masivelor numpy
bidimensionale.
Accesul la numele liniilor și coloanelor se face prin proprietățile index și columns. Aceste
proprietăți sunt din clasa pandas.Index. Elementele pot fi accesate prin funcția get_values() a clasei
Index. Indexul numeric al unei valori se poate obține prin metoda get_loc(valoare), unde valoare
este numele unei linii sau coloane.
Exemplu
import pandas as pd
note = pd.DataFrame({"Structuri de date":[5,4,6],
'Analiza datelor':[10,6,7],
'Algebra':[7,8,7]},
index=["Ionescu Dan","Popescu Diana",'Georgescu Radu'])
print(note)
print(note.index,note.columns,sep='\n')
print(note.index[0],note.columns[1])

Outputul generat va fi:

Structuri de date Analiza datelor Algebra
Ionescu Dan 5 10 7
Popescu Diana 4 6 8
Georgescu Radu 6 7 7
Index(['Ionescu Dan', 'Popescu Diana', 'Georgescu Radu'], dtype='object')
Index(['Structuri de date', 'Analiza datelor', 'Algebra'], dtype='object')
Ionescu Dan Analiza datelor
Numele de coloane este preluat în exemplul precedent din cheile dicționarului.
Selecția unor coloane se face specificând numele coloanelor între paranteze pătrate:
nume_frame[['coloana1',..,'coloanaK']]
Selecția liniilor se poate realiza prin expresii:
index_initial:index_final
unde indecșii sunt opționali (dacă lipsesc se selectează toate liniile).
Selecția se face de la index_initial la (index_final-1)
Selecția și felierea se poate face prin atributele loc și iloc, folosind numele de item (pentru loc) sau
indexul său (pentru iloc).
Exemple. Pentru tabelul de mai sus următorul cod:
print(note.loc["Popescu Diana","Algebra"])
print(note.loc["Popescu Diana"]["Algebra"])
print(note.loc["Popescu Diana",:"Algebra"])
print(note.loc["Popescu Diana"][:"Algebra"])
print(note.loc["Popescu Diana":,:"Algebra"])
print(note.loc["Popescu Diana":][:"Algebra"])
print(note.iloc[1,2])
print(note.iloc[1][2])
print(note.iloc[[1,2],2])
#print(note.iloc[[1,2]][2])#Gresit
print(note.iloc[1:,2])
#print(note.iloc[1:][2])#Gresit
print(note.iloc[[1,0],[1,2]])
print(note.iloc[1][[1,2]])
print(note.iloc[1,1:])
print(note.iloc[1][1:])
print(note.iloc[1:,1:])
va genera outputul:
8
8
Structuri de date 4
Analiza datelor 6
Algebra 8
Name: Popescu Diana, dtype: int64
Structuri de date 4
Analiza datelor 6
Algebra 8
Name: Popescu Diana, dtype: int64
Structuri de date Analiza datelor Algebra
Popescu Diana 4 6 8
Georgescu Radu 6 7 7
Structuri de date Analiza datelor Algebra
Popescu Diana 4 6 8
Georgescu Radu 6 7 7
8
8
Popescu Diana 8
Georgescu Radu 7
Name: Algebra, dtype: int64
Popescu Diana 8
Georgescu Radu 7
Name: Algebra, dtype: int64
Analiza datelor Algebra
Popescu Diana 6 8
Ionescu Dan 10 7
Analiza datelor 6
Algebra 8
Name: Popescu Diana, dtype: int64
Analiza datelor 6
Algebra 8
Name: Popescu Diana, dtype: int64
Analiza datelor 6
Algebra 8
Name: Popescu Diana, dtype: int64
Analiza datelor Algebra
Popescu Diana 6 8
Georgescu Radu 7 7
Modificarea valorilor dintr-o coloană se poate face prin atribuire directă:
nume_frame['nume_coloana']=valoare
Când atribuirea se face cu o listă sau un masiv, acestea trebuie să aibă un număr de elemente egal
cu numărul de itemi din DataFrame.
Ștergerea unei coloane se face prin comanda del:
del nume_frame['nume_coloana']
Inserarea unei coloane se face prin metoda insert:
DataFrame.insert(loc, column, value, allow_duplicates=False)
unde loc este indexul inserției, column este numele coloanei iar value este valoarea asociată
itemilor pentru coloana inserată.
O altă posibilitate de a șterge atât coloane cât și linii este prin metoda drop:
DataFrame.drop(self, labels=None, axis=0, index=None, columns=None, level=None,
inplace=False, errors='raise');
unde:
labels reprezintă o listă cu nume de linii sau coloane;
axis este 0 sau 1 după cum labels este interpretat ca nume de linii sau coloane;
columns este listă de coloane și este o alternativă la labels și axis=1;
inplace este un boolean care indică dacă modificarea se face cu înlocuirea obiectului curent (True)
sau se realizează și se returnează o copie modificată și nu se modifică obiectul curent.

Salvarea conținutului tabelului în fișier csv:

DataFrame.to_csv(path_or_buf=None, sep=', ', na_rep='', float_format=None, columns=None,
header=True, index=True, index_label=None, ... )
path_or_buf - este numele fișierului. Dacă nu este furnizat metoda întoarce string.

Selecția
Selecția se realizează prin facilitățile de indexare așa cum am văzut mai sus.
Exemplu. Pentru tabelul de mai jos vom extrage liniile care îndeplinesc o condiție legată de una
dintre coloane.
t2 = pd.DataFrame({
'c4': [1, 3, 5, 7, 9],
'c5': ["A", "B", "C", "D", "E"],
'c6': [100, 200, 300, 100, 400]},
index=['i1', 'i3', 'i5', 'i7', 'i9'])
t2_1 = t2[t2["c6"] >= 300]
t2_2 = t2[t2.iloc[:, 2] >= 300]
print(t2_1, t2_2, sep="\n")
Codul va genera următorul output:
c4 c5 c6
i5 5 C 300
i9 9 E 400
c4 c5 c6
i5 5 C 300
i9 9 E 400

Sortarea datelor
Sortarea tabelelor se poate face prin metoda sort_values:
DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort',
na_position='last')
by - reprezintă criteriul. Poate si un șir de caractere reprezentând numele coloanei sau o listă de
șiruri de caractere pentru o sortare multicriterială - ["nume1","nume2", ... ]
axis - reprezintă direcția de sortare - 0 sau ‘index’, 1 sau ‘columns’. Dacă se indică 1, atunci și
criteriile din by trebuie să fie nume de linii.
ascending - sensul sortării. Se furnizează precum criteriul, valoare logică sau listă de valori logice.
inplace - indică sortarea în același tabel
kind - metoda de sortare. Variante: {‘quicksort’, ‘mergesort’, ‘heapsort’}.
na_position - locul în care sunt puse liniile/coloanele care au NaN pentru criteriile de sortare.
Variante: {‘first’, ‘last’}.

Exemplu. Pentru tabelul de mai sus vom face o sortare după mediile notelor, astfel:
import numpy as np
# Se adauga o coloana cu mediile
note["Media"] = np.mean(note, axis=1)
note_sort = note.sort_values(by=["Media"], ascending=False)
print(note_sort)
Output:
Structuri de date Analiza datelor Algebra Media
Ionescu Dan 5 10 7 7.333333
Georgescu Radu 6 7 7 6.666667
Popescu Diana 4 6 8 6.000000

Agregarea datelor
Obiectele de tip DataFrame pot fi supuse unor operațiuni de agregare, transformare, filtrare. Prima
operațiune care se efectuează înainte de agregare, transformare sau filtrare este împărțirea datelor
în grupe după diverse criterii (split). Metoda groupby realizează acest lucru:
DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True,
squeeze=False, observed=False, **kwargs)
by - criteriul de grupare. Poate fi numele unei coloane sau o serie sau un vector sau o funcție care
să identifice grupele.
axis - axa de grupare (0 - grupare pe coloane)
as_index - indică folosirea cheilor de grupare ca index în rezultatul prelucrării, în cazul care
prelucrarea este o agregare
sort - sortarea automată după cheile criteriului de grupare
Rezultatul prelucrării îl constituie un obiect pandas.core.groupby.DataFrameGroupBy. Metodele
acestei clase permit operațiuni de agregare, transformare, filtrare.
Metode DataFrameGroupBy pentru sume, medii, numărare, varianță, abatere standard și produs:
GroupBy.sum(**kwargs)
GroupBy.mean(*args, **kwargs)
GroupBy.count()
GroupBy.var(ddof=1, *args, **kwargs)
GroupBy.std(ddof=1, *args, **kwargs)
GroupBy.prod(**kwargs)
Transformarea datelor se poate realiza prin funcția transform:
GroupBy.transform(func, *args, **kwargs)
func - este funcția aplicată. Se poate folosi operatorul lambda pentru transmiterea datelor grupului
pentru transformare.
Funcții care permit agregare particularizată a datelor sunt agg și apply:
GroupBy.apply(func, *args, **kwargs)
GroupBy.agg(arg, *args, **kwargs
func, arg sunt funcțiile aplicate grupurilor.
Exemple. În codul următor se efectuează agregare cu sumarizare, transformare și o agregare
particularizată pentru un tabel de date.
import pandas as pd
import pandas.core.groupby.groupby as gby
# Calculul ponderilor pe coloane
def ponderi(x):
return x / x.sum()
# Calculul sumelor patratelor ponderilor
def sume2(x):
p = x / x.sum()
p2 = p * p
return p2.sum()
t1 = pd.DataFrame({
'c1': [1, 1, 2, 1, 1, 2, 2, 2, 1],
'c2': [10, 20, 30, 10, 40, 110, 140, 125, 100],
'c3': [2.3, 2.6, 3, 0, 14, 10, 5.5, 11, 11.5]},
index=['i1', 'i2', 'i3', 'i4', 'i5', 'i6', 'i7', 'i8', 'i9'])
g = t1.groupby('c1')
assert isinstance(g, gby.DataFrameGroupBy)
print("Medii pe grupe:", g.mean(), sep="\n")
print("Ponderi pe grupe:", g.transform(func=lambda x: ponderi(x)), sep="\n")
print("Sume de patrate (apply):", g.apply(func=sume2), sep="\n")
print("Sume de patrate (agg):", g.agg(arg=sume2), sep="\n")

Exemplul produce outputul:

Medii pe grupe:
c2 c3
c1
a 20.0 5.433333
b 87.5 7.266667
Ponderi pe grupe:
c2 c3
i1 0.166667 0.141104
i2 0.038095 0.059633
i3 0.057143 0.068807
i4 0.166667 0.000000
i5 0.666667 0.858896
i6 0.209524 0.229358
i7 0.266667 0.126147
i8 0.238095 0.252294
i9 0.190476 0.263761
Sume de patrate (apply):
c1 c2 c3
c1
1 0.20 0.376543 0.368226
2 0.25 0.294010 0.299052
Sume de patrate (agg):
c2 c3
c1
1 0.376543 0.368226
2 0.294010 0.299052
Se poate observa că în cazul funcției apply, spre deosebire de agg, sumarizarea s-a aplicat inclusiv
coloanei care identifică grupurile (c1).

Joncțiuni

Joncțiunea tabelelor se poate realiza prin metoda merge:

DataFrame.merge(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)
right - celălalt tabel
how - metoda de joncționare. Implicit inner - pe chei comune.
on - numele coloanei după care se face joncțiunea. Trebuie să aparțină ambelor tabele.
left_on - numele coloanei după care se face joncțiunea în tabelul curent (considerat stânga)
right_on - numele coloanei după care se face joncțiunea în tabelul right
left_index, right_index - indică dacă joncțiunea se face prin index pentru tabelul curent sau right.
Dacă joncțiunea se face după index nu mai trebuie specificat nume de coloană on.
sort - indică sortarea după chei după joncțiune
suffixes - sufix inserat pentru coloanele cu nume comun în cele două tabele
Metoda întoarce tabelul nou cu rezultatele joncțiunii. Dacă joncțiunea se face după indecși, tabelul
rezultat va prelua indexul tabelelor, altfel tabelul rezultat nu va păstra nici un index.
Exemplu. În exemplul de mai jos se efectuează două joncțiuni cu și fără coloane de joncțiune.
t1 = pd.DataFrame({
'c1': [1, 2, 3, 4, 5, 6, 7, 8, 9],
'c2': [10, 20, 30, 10, 40, 110, 140, 125, 100],
'c3': [2.3, 2.6, 3, 0, 14, 10, 5.5, 11, 11.5]},
index=['i1', 'i2', 'i3', 'i4', 'i5', 'i6', 'i7', 'i8', 'i9'])
t2 = pd.DataFrame({
'c4': [1, 3, 5, 7, 9],
'c5': ["A", "B", "C", "D", "E"],
'c6': [100, 200, 300, 100, 400]},
index=['i1', 'i3', 'i5', 'i7', 'i9'])
t_1 = t1.merge(t2, left_index=True, right_index=True)
t_2 = t1.merge(t2, left_on="c1", right_on="c4")
print(t_1)
print(t_2)
Outputul generat este:
c1 c2 c3 c4 c5 c6
i1 1 10 2.3 1 A 100
i3 3 30 3.0 3 B 200
i5 5 40 14.0 5 C 300
i7 7 140 5.5 7 D 100
i9 9 100 11.5 9 E 400
c1 c2 c3 c4 c5 c6
0 1 10 2.3 1 A 100
1 3 30 3.0 3 B 200
2 5 40 14.0 5 C 300
3 7 140 5.5 7 D 100
4 9 100 11.5 9 E 400

Date de tip categorial

Datele de tip categorial sunt implementate în Pandas prin clasa Categorical.

class pandas.Categorical(values, categories=None, ordered=None, dtype=None, fastpath=False)
values - valorile seriei
categories - modalitățile seriei (categoriile). Valorile din serie care nu aparțin listei de categorii
vor fi înlocuite cu NaN (valoare lipsă).
ordered - stabilirea unei ordini în categorii
dtype - specifică subtipul, o instanță a clasei CategoricalDtype
Proprietățile codes (tip ndarray numeric) și categories (pandas.Index) conțin codurile numerice
ale valorilor și categoriile. Codul numeric reprezintă indexul categoriei în indexul de categorii.
Exemplu:
x = pd.Categorical(['a', 'b', 'b', 'a', 'c', 'a', 'a'])
coduri = x.codes
categorii = x.categories
print(type(coduri),coduri)
print(type(categorii),categorii)
print(categorii.get_values())
Output:
<class 'numpy.ndarray'> [0 1 1 0 2 0 0]
<class 'pandas.core.indexes.base.Index'> Index(['a', 'b', 'c'],
dtype='object')
['a' 'b' 'c']

Clase utilitare
Clasa Counter

Clasa Counter este o subclasă dicționar care memorează obiectele sub formă de chei și frecvența
lor sub formă de valori.
class collections.Counter([iterable-or-mapping])
Clasa moștenește metodele dict cum ar fi keys și values, care furnizează cheile și valorile.
Exemplu:
counter = collections.Counter(["a","b","c","c","a","a","c"])
print(list(counter.keys()))
print(list(counter.values()))
cu outputul:
['a', 'b', 'c']
[3, 1, 3]
Printre metodele specifice sunt:
most_common([n]) - furnizează sub formă de listă de tupluri cele mai frecvente n perechi
(cheie:valoare)
subtract([iterable-or-mapping]) - decrementează pentru cheile specificate valorile, cu valorile
specificate
Exemplu pentru obiectul counter din codul anterior:
print(counter.most_common(2))
counter.subtract({"a": 2})
print(counter)
Outputul furnizat:
[('a', 3), ('c', 3)]
Counter({'c': 3, 'a': 1, 'b': 1})

Elemente de grafică în Python

Vizualizarea informației este un proces important în analiza datelor. Una dintre cele mai populare
și utilizate biblioteci Python pentru vizualizări statice sau dinamice este cum ar fi matplotlib. Pe
matplotlib se bazează biblioteci adiționale cum ar fi seaborn sau modulul pandas.plotting din
pandas.
Construirea unei ferestre grafice interactive se face prin funcția figure.
matplotlib.pyplot.figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None,
frameon=True, FigureClass=<class 'matplotlib.figure.Figure'>, clear=False, **kwargs)
num - antetul ferestrei
figsize - dimensiunea figurii, lățime și înălțime în inches.
dpi - rezoluția
facecolor - culoarea fondului
edgecolor - culoarea bordurii
frameon - inhibă desenarea pentru valoarea False
clear - stabilește dacă se șterge fereastra cu același nume
Afișarea ferestrei se realizează prin funcția show().
Exemplu
from matplotlib import pyplot as plt
f = plt.figure("Fereastra test",figsize=[4,2],facecolor=(1,1,0.8))
plt.show()
Codul precedent va genera graficul:

Adăugarea de subgrafice la figură se realizează prin metoda clasei Figure:

figure.add_subplot(*args, **kwargs)
Prin args se va specifica structura figurii și poziția subgraficului astfel:
nrows, ncols, index - număr linii, număr coloane în figură și indexul subgraficului.
Funcția întoarce obiect pyplot.Axes.
Exemplu
f = plt.figure("Grafic linie",figsize=(10,9))
f1 = f.add_subplot(2,1,1)
f2 = f.add_subplot(2,1,2)
Parametrii kwargs: title - titlul, xlabel, ylabel - etichete axe.

Tipuri de grafice în matplotlib

Grafice linie - plot

matplotlib.pyplot.plot(*args, scalex=True, scaley=True, data=None, **kwargs)
args - argument de lungime variabilă format din triplete [x],y,[fmt], unde perechea de paranteze []
arată caracterul opțional al parametrului, x și y sunt vectori sau compatibili cu vectori iar fmt este
un șir cu formatul sintetic al afișării. fmt este de forma: '[color][marker][line]', parametrii de tip șir
din kwargs.
Exemplu. Dacă la codul anterior inserăm:
plt.plot(list(range(1990,1995)),[10,11,15,13,10],'r',
[1990,1995],[5,10],'y--',
[1992,1994,1996],[-11,0,5],'b-.')
outputul va deveni:

scalex, scaley - valorii logice care indică autoscalarea, adică adaptarea axelor la limitele datelor

kwargs - parametrii care reprezintă proprietăți ale graficului: culoare, format linie, grosime linie,
transparență, hașuri etc.
Dintre parametrii kwarks mai des utilizați sunt:
color - culoarea. Există următoarele abrevieri pentru culoare:
'b' blue
'g' green
'r' red
 'c' cyan
'm' magenta
'y' yellow
'k' black
'w' white

linestyle - tipul liniei. Poate avea una din valorile

'-' or 'solid' solid line
'--' or 'dashed' dashed line
'-.' or 'dashdot' dash-dotted line
':' or 'dotted' dotted line
'None' draw nothing
'' draw nothing
'' draw nothing

marker - tipul de punct. De regulă apare în grafice scatter. Dacă apare în graficele line va determina
afișarea punctelor conform markerului.

'.' point marker 's' square marker

'o' circle marker 'p' pentagon marker
'v' triangle_down marker '*' star marker
'^' triangle_up marker '+' plus marker
'<' triangle_left marker 'x' x marker
'>' triangle_right marker 'D' diamond marker
'1' tri_down marker 'd' thin_diamond marker
'2' tri_up marker '|' vline marker
'3' tri_left marker '_' hline marker
'4' tri_right marker

linewidth - lățimea liniei. Este o valoare reală.

label - Eticheta asociată liniei (sau punctelor) în legendă.

Grafice puncte

matplotlib.pyplot.scatter(x, y, s=None, c=None, marker=None, cmap=None, norm=None,

vmin=None, vmax=None, alpha=None, linewidths=None, verts=None, edgecolors=None, *,
data=None, **kwargs)
x,y - coordonatele punctelor
s - mărimea punctelor
c - culoarea. Poate fi o culoare, n culori pentru cele n puncte sau un vector cu n indecși în rampa
de culori asociată
cmap - rampă de culori asociată. O rampă poate fi specificată folosind un nume valid de rampă sau
construind una prin constructori de clase derivate din clasa Colormap (de exemplu
ListedColormap).
Nume valide de rampe:
['Greys', 'Purples', 'Blues', 'Greens', 'Oranges', 'Reds','YlOrBr', 'YlOrRd', 'OrRd', 'PuRd', 'RdPu',
'BuPu','GnBu', 'PuBu', 'YlGnBu', 'PuBuGn', 'BuGn', 'YlGn']
['binary', 'gist_yarg', 'gist_gray', 'gray', 'bone', 'pink','spring', 'summer', 'autumn', 'winter', 'cool',
'Wistia','hot', 'afmhot', 'gist_heat', 'copper']
['PiYG', 'PRGn', 'BrBG', 'PuOr', 'RdGy', 'RdBu','RdYlBu', 'RdYlGn', 'Spectral', 'coolwarm', 'bwr',
'seismic']
Clasele Colormap,ListedColormap sunt în modulul matplotlib.colors.
class matplotlib.colors.ListedColormap(colors, name='from_list', N=None)
colors - lista de culori folosită.
N- numărul de culori din rampă. Dacă N > len(colors), culorile se vor repeta, altfel vor fi reduse la
N.
Exemplu. Pentru definirea unei rampe roșu-galben-albastru cu 3 culori:
import matplotlib.colors as cl
myMap = cl.ListedColormap(['r', 'y', 'b'])
alpha - transparența punctelor între 0 (transparent) și 1 (opac)
linewidths - lățimea liniei conturului punctelor
edgecolors - culoarea conturului

Tipuri de grafice în seaborn

Grafice puncte - scatterplot

Funcția scatterplot din seaborn are avantajul față de aceeași funcție din matplotlib de a facilita
trasarea pentru date împărțite în grupe. Punctele care reprezintă instanțele din grupe diferite pot fi
afișate în culori și cu stiluri diferite.
seaborn.scatterplot(x=None, y=None, hue=None, style=None, size=None, data=None,
palette=None, ..., **kwargs)
Datele pot fi furnizate printr-un obiect DataFrame (parametrul data) sau direct prin vectori
folosind parametrii x și y.
x,y - coordonatele punctelor în cele două axe. Pot fi vectori sau pot fi nume de coloane din tabelul
de date transmis prin data.
hue - numele coloanei din tabelul de date care furnizează gruparea pentru trasarea în culori diferite
style - idem dar pentru trasarea în stiluri diferite (tip marker)
size - idem dar pentru trasarea cu mărimi diferite
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sb
t = pd.DataFrame(data={"grupa":['a','a','b','b','b','a','a','c','c','c','a'],
"V1":[10,20,23,45,12,78,45,56,24,12,66],
"V2": [1, 2.6, 2.3, -4.5, 12.7, -7, 5.5, -5.6, 0.24, 12, 6.6]})
nume_coloane = t.columns
sb.set()
g = sb.scatterplot(x=nume_coloane[1],y=nume_coloane[2],
hue=nume_coloane[0],style=nume_coloane[0],data=t)
for i in range(len(t)):
g.text(t.iloc[i,1],t.iloc[i,2],t.index[i])
plt.show()
Graficul generat va fi:
Funcția set este folosită pentru a seta parametrii de estetică pe valorile implicite.

Grafice linie - lineplot

seaborn.lineplot(x=None, y=None, hue=None, size=None, style=None, data=None, palette=None,
..., sort=True, ... , **kwargs)
Graficele linie sunt utilizate tot în scopul sintetizării legăturii dintre două variabile x și y ca și
graficele puncte.
Parametrul sort specifică dacă sunt sortate valorile x și y.

Grafice corelogramă - heatmap

Sunt folosite pentru reprezentarea color a unui tabel. De regulă sunt folosite pentru vizualizarea
matricelor de corelații.
seaborn.heatmap(data, vmin=None, vmax=None, cmap=None, center=None, robust=False,
annot=None, fmt='.2g', annot_kws=None, linewidths=0, linecolor='white', cbar=True,
cbar_kws=None, cbar_ax=None, square=False, xticklabels='auto', yticklabels='auto', mask=None,
ax=None, **kwargs)
data - tabel de date bidimensional cu datele pentru care se face reprezentarea. Poate fi un
DataFrame sau un ndarray. Pentru un DataFrame numele de linii și de coloane sunt folosite în
reprezentare pentru itemii de linie și de coloană.
vmin,vmax - valorile extreme folosite pentru maparea în rampa de culori
cmap - rampa de culori folosită (vezi mai sus scatter)
annot - adnotare cu text a celulelor. Poate fi True, False sau un masiv cu adnotările (trebuie să aibă
același shape ca data)
cbar - indică afișarea rampei
Exemplu
import matplotlib.pyplot as plt
import seaborn as sb
import pandas as pd
date =
pd.DataFrame({"PIB":[12000,17000,33000,4000,5000],"Populatie":[22,10.5,3,40,4
5],"Productivitate":[103,99,78,109,88]})
R = date.corr()
sb.heatmap(data=R,vmin=-1,vmax=1,cmap='bwr',annot=True)
plt.show()
Codul anterior va afișa graficul:

Grafice pentru distribuții

Histograme matplotlib

Histogramele pot fi construite în matplotlib utilizând funcția hist. Pe lângă trasare, funcția
calculează și întoarce informații legate de grupare în conformitate cu funcția numpy.histogram.
Aceste informații sunt frecvențele și intervalele.

matplotlib.pyplot.hist(x, bins=None, range=None, density=None, weights=None,

cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None,
log=False, color=None, label=None, stacked=False, normed=None, *, data=None, **kwargs)
x - masiv unidimensional sau secvență de masive unidimensionale sau compatibile
bins - poate fi un întreg reprezentând numărul de intervale, o secvență numerică reprezentând
limitele de intervale sau un șir reprezentând strategia de grupare (de exemplu 'sturges'). Numărul
implicit de grupe este 10 conform cu numpy.histogram. Când este furnizată secvență de limite de
intervale, primul interval și următoarele sunt închise la stânga iar ultimul este închis la ambele
capete.
range - tuplu cu valorile extreme. Implicit este (x.min(), x.max())
density - valoare logică ce indică returnarea frecvențelor ca probabilități. Implicit este False.
weights - ponderi asociate valorilor din x. Este un masiv având același shape cu x.
cumulative - calcul cumulativ al frecvențelor. Implicit: False
bottom - valoare sau set de valori folosite pentru incrementarea frecvențelor. De exemplu, dacă
bottom este 10 toate frecvențele pentru toate grupele sunt incrementate cu 10.
histtype - tipul de trasare pentru histogramă. Poate fi {'bar', 'barstacked', 'step', 'stepfilled'}. Implicit
este 'bar'.
align - indică felul în care sunt aliniate barele. Poate fi {'left', 'mid', 'right'}. Implicit: 'mid'.
orientation - orientarea: {'horizontal', 'vertical'}
rwidth - scalar cuprins între 0 și 1 care indică lățimea barelor ca proporție față de lățimea
intervalului. De exemplu pentru 0.9 va genera un spațiu de 10% între bare. Valoare implicită: 1
(fără spațiu).
log - indică utilizarea unei scări logaritmice pentru frecvențe. Implicit False.
color - specificare culoare sau set de culori (pentru mai multe secvențe)
label - specifică etichetele pentru secvențe. Sunt folosite în legendă.
stacked - stivuirea barelor în același interval. Implicit: False
kwargs - alți parametrii de trasare de tip matplotlib.patches.Patch cum ar fi de exemplu alpha
(pentru transparența barelor)

Histograme pandas

Trasarea histogramelor pe tabele DataFrame sau serii de date Series din pandas se poate face și
prin metode hist ale acestor clase.
DataFrame.hist(column=None, by=None, grid=True, xlabelsize=None, xrot=None,
ylabelsize=None, yrot=None, ax=None, sharex=False, sharey=False, figsize=None, layout=None,
bins=10, **kwds)
column - nume de coloană sau șir de nume de coloană la care se limitează trasarea. Dacă lipsește
va fi trasat câte un grafic pentru fiecare variabilă.
by - nume de coloană după care se poate face grupare și trasare pe grupe. Poate fi și un masiv
unidimensional după care să se poată face împărțire pe grupe a instanțelor. Va fi trasat câte un
grafic pentru fiecare grupă. Dacă sunt mai multe coloane trasarea acestora se va face în același
grafic pe grupe.
grid - indică trasarea hașurilor
xlabelsize - mărimea textului pentru etichete pe axa x. Poate fi un int.
xrot - unghiul de rotație al etichetelor pe axa x. Implicit: 0.
ylabelsize, yrot - idem pentru axa y
ax - obiect matplotlib.axes.Axes utilizat pentru partajarea unor elemente (de exemplu axele
graficului)
sharex, sharey - indică partajarea axelor
figsize - stabilește dimensiunea figurii (tuplu)
layout - stabilește dimensiunea graficului histogramă (tuplu)
bins - numărul de histograme. Poate fi furnizat un număr întreg sau o secvență de valori
reprezentând limitele de intervale.
kwds - alți parametrii de configurare din matplotlib.pyplot.hist (de exemplu rwidth pentru a stabili
o distanță între bare)
O cale simplificată de a trasa o histogramă pentru un DataFrame este metoda:
DataFrame.plot.hist(by=None, bins=10, **kwds)
Aceasta va trasa în același grafic histogramele pentru toate variabilele tabelului. kwds se referă la
parametrii adiționali din pandas.DataFrame.plot().

Histograme și grafice de distribuție Seaborn

Trasarea histogramelor și a graficului de tip line asociat se poate face prin funcția distplot:
seaborn.distplot(a, bins=None, hist=True, kde=True, rug=False, fit=None, hist_kws=None,
kde_kws=None, rug_kws=None, fit_kws=None, color=None, vertical=False, norm_hist=False,
axlabel=None, label=None, ax=None)
a - seria de date. Poate fi obiect Series, ndarray unidimensional sau list. În cazul unui obiect
Series, numele asociat va fi preluat ca etichetă de axă.
bins - specifică numărul de grupe sau limitele de intervale pentru grupare. Implicit calculează
histogramele după algoritmul Freedman-Diaconis
kde - indică trasarea graficului funcției de densitate de repartiție și calculul probabilităților în locul
frecvențelor absolute
rug - indică trasarea marcajelor pentru pozițiile instanțelor în intervale
hist_kws, kde_kws, rug_kws - se referă la parametrii grafici individualizați pe hist, kde și rug.
Parametrii sunt furnizați prin dicționare.
Exemplu
sns.distplot(..., rug_kws={"color": "g"}, kde_kws={"color": "k", "lw": 3, "label": "KDE"},
hist_kws={"histtype": "step", "linewidth": 3,"alpha": 1, "color": "g"},...)

Trasarea separată a distribuției de probabilitate se poate face prin funcția kdeplot.

seaborn.kdeplot(data, data2=None, shade=False, vertical=False, kernel='gau', bw='scott',
gridsize=100, cut=3, clip=None, legend=True, cumulative=False, shade_lowest=True,
cbar=False, cbar_ax=None, cbar_kws=None, ax=None, **kwargs)
data2 - a doua serie de date
shade - indică umplerea ariilor de densitate
vertical - axa densității este axa x. Nu are efect dacă există și data2.
kernel, bw - algoritmi utilizați pentru trasarea curbelor de densitate
shade_lowest - indică umplerea înafara ariilor curbelor de densitate. Setarea pe False este utilă
pentru trasarea unor densități multiple
cbar - indică adăugarea unei bare de culoare în cazul unui plot bivariat
kwargs - alți parametrii plt.plot(). Exemplu: cmap pentru o rampă de culori în cazul unui plot
bivariat.

Reprezentări bivariate pentru distribuții

Reprezentările bivariate sunt reprezentări bidimensionale ale densității de repartiție pentru două
variabile. Pot fi făcute prin funcțiile matplotlib.pyplot.hist2d și kdeplot din seaborn (vezi mai sus).
matplotlib.pyplot.hist2d(x, y, bins=10, range=None, normed=False, weights=None, cmin=None,
cmax=None, *, data=None, **kwargs)
x,y - masive unidimensionale sau compatibile
bins - număr de intervale. Se furnizează la fel ca în cazul unidimensional însă pe fiecare
dimensiune. Poate fi: int, [int,int], array, [array,array]
range - limitele pe fiecare dimensiune
cmin, cmax - valori extreme pentru rampa de culori

Elemente de interfață grafică în Python

Controale de tip ComboBox
Clasa:
class tkinter.ttk.Combobox
Parametrii în constructor:
textvariable - variabilă tkinter.StringVar utilizată pentru gestionarea conținutului
values - lista de valori din care se face selecția

Metode:
current(newindex=None)
get() - întoarce valoarea curentă
set(value) - stabilește valoarea curentă