Rezumat
Rezumat
Rezumat
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).
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
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
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 î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)
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
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ț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)
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
Pentru citire din fișiere text se folosesc funcțiile read_csv() și read_table(). Principalii parametrii
ai acestor funcții sunt:
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.
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
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
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ț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ă
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.
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
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])
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")
Joncțiuni
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})
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
marker - tipul de punct. De regulă apare în grafice scatter. Dacă apare în graficele line va determina
afișarea punctelor conform markerului.
Grafice puncte
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.
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:
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.
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().
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"},...)
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
Metode:
current(newindex=None)
get() - întoarce valoarea curentă
set(value) - stabilește valoarea curentă