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

referințe la același obiect

x is y

is not Întoarce true dacă operanzii sunt

referințe la obiecte diferite

x is not y

in Întoarce true dacă operandul 1 care este

o valoare se află în operandul 2 care este

o secvență

x in y

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

Shift stânga și completare cu 0 în

dreapta

>> Signed right

shift

Shift dreapta cu menținerea bitului

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

implicită

Semnificație

filepath_or_buffer Cale fișier text

sep str ',' sau '\t' Separator coloane

header întreg ori listă de

întregi

'infer' Stabilește cum se citesc numele de

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:

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.]]

Axis 2

Axis 0 Axis 1

Axis 1

Axis 0

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

arctan arctanh

Funcții trigonometrice inverse

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

not_equal

Comparații

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

complex128

complex256

Complex pe 32, 64 sau 128 biți

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.

Dacă x și y sunt matrice se va calcula un tabel partiționat cu patru matrice de corelație:

yyyx

xyxx

RR

RR

, 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ă