Parametrii de lungime variabilă

• O formă flexibilă, specifică Python, de a trimite parametrii este folosind

parametrii formali standard *args, sau **kwargs

def functionName(*args, **):

suite
[return val1[,val2,...,valN]]

def functionName(**kwargs):
suite
[return val1[,val2,...,valN]]
args - este de tip tuplu și conține valoarea parametrilor
kwargs - este de tip dict și conține numele și valoarea parametrilor
(Exemplul 6)
 Decoratori

• Decoratorii sunt funcții care extind funcționalitatea unor alte funcții

• Funcția decorator primește ca argument referința la funcția a cărei funcționalitate
este extinsă și definește o funcție nouă, funcție internă, prin care este extinsă
funcționalitatea funcției primite. Decoratorul întoarce referința la funcția nou
definită.
• Decoratorii sunt marcați sintactic printr-o adnotare de forma:
@nume_decorator
unde nume_decorator este numele funcției decorator
• Adnotarea se face în fața funcției decorate (a cărei funcționalitate este extinsă)
(Exemplul 7)
 Funcții builtins
• abs(x)
• 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])
• 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
• getattr(object, name[, default]); #Întoarce valoarea atributului specificat prin
name
• 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
• print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False) #Afișare conținut
de tip string pentru diferite obiecte la consolă. Este interpretat ca obiect printabil
orice obiect trimis ca parametru, cu excepția parametrilor sep, end, file și flush.
Obiectele afișate sunt despărțite între ele prin sep iar la sfârșit este afișat end.
• class type(object) #Creare obiect type cu informații despre obiectul object
• class type(name, bases, dict) #Creare în mod dinamic a unei clase cu numele
name, superclase definite în tuplul bases și atribute în dicționarul dict
• zip(*iterables) #Crearea unui iterator prin agregarea mai multor structuri iterabile
într-una singură. Un element din structură este un tuplu format din câte un
element din fiecare structură.
(Exemplul 8)
• filter(function, iterable); #Construiește un iterator din acele elemente din iterable
pentru care function întoarce True
Exemplu. Codul următor va afișa elementele pare din lista v
• sorted(iterable, *, key=None, reverse=False); #Întoarce lista cu elementele din iterable
sortate. key este o funcție cu un singur argument, element din iterable, prin care se
poate specifica un criteriu de sortare. reverse indică sortarea descrescătoare.
Exemplu. În lista persoane din codul de mai jos avem numele și vârsta. Lista va fi sortată
după nume și vârstă.
• map(function, iterable, ...); # Construiește un iterator cu elemente din iterable pe
baza funcției function. Pot fi trimise mai multe obiecte iterable (...) caz în care
funcția de prelucrare trebuie să aibă atâtea argumente câte obiecte iterable sunt
prelucrate. Prelucrarea se face în paralel pe obiectele iterable, astfel încât
numărul de prelucrări este dat de obiectul iterable cu cele mai puține elemente.
 Lucrul cu fișiere
• Funcții de bază pentru citirea datelor din fișiere (funcții de nivel scăzut)
open(file, mode='r', ...)
unde file este numele fișierului și mode este modul de creare. Funcția întoarce
obiect io.TextIOBase
mode poate fi:
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)
• Citirea liniilor din fișierul text se va face prin metodele readline() și
readlines()
Exemplu. În secvența următoare de cod sunt citite și afișate liniile dintr-un fișier text.
• read(size=-1); #Citește și întoarce size caractere din fișier sub formă de str. Dacă
size este negativ sau None, citește până la sfârșit de fișier (EOF)
• write(s); #Scrie șirul s în fișier și întoarce numărul de caractere scrise
• seek(offset, whence=SEEK_SET); #Realizează poziționarea în fișier. offset indică
poziția. Comportamentul metodei depinde de valoarea parametrului whence, care
poate fi SEEK_SET sau 0, SEEK_CUR sau 1, SEEK_END sau 2. În prima
situație offset trebuie să fie 0, poziționare la început sau valoarea întoarsă de
metoda tell, fără schimbarea poziției. În a doua situație offset trebuie să fie 0 (fără
schimbarea poziției). În a treia situație offset trebuie să fie 0, poziționare la
sfârșit.
• tell(); #Întoarce numărul de octeți până la poziția curentă
În exemplul de mai jos este salvat și restaurat un vector în/din fișier binar
 Tipuri și structuri de date
• 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
• Crearea unui obiect int se face prin inițializare sau folosind constructorul clasei
int:
int([x])
int(x, base=10)
unde x poate fi un literal valid sau poate fi un șir iar base poate fi 2,8,10,16

Tipul real
• 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
• 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
Șiruri
• Datele de tip șir de caractere sunt gestionate prin tipul str
• Principalele 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.
Formatarea șirurilor
• Se realizează prin metoda format:
str.format(*args, **kwargs)
• Ș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 str(), "a" - apel ascii()
• format_spec - este specificatorul de format
• Odată cu standardul PEP 498 a fost introdus un nou mecanism de formatare a
șirurilor cunoscut sub numele de interpolare șir literal sau șiruri F
• Pentru a crea un șir F, este prefixat șirul cu litera 'f'. Șirul în sine poate fi formatat
în același mod în care se face cu funcția format ().
• Un specificator de format respectă sintaxa:
[[fill]align][sign][#][0][width][grouping_option][.precision][type]
• 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. Poate fi: ‘b’,’d’,’o’,’x’ –
binary/octal/zecimal/hexazecimal, ‘s’- șir, ‘e’ - științific, ‘f’ – virgulă fixă precizie
6, ‘c’ - caracter
Date calendaristice
• 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
• Constructori și metode pentru lucrul cu date calendaristice:
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 1ianuarie, 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

• Formate de dată în specificatoarele de format:
%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)

(Exemplul 9)
Tipurile binare
• Sunt reprezentate de clasele bytes și bytearray
• Obiectele bytes sunt secvențe nemodificabile (immutable) de octeți în timp ce
obiectele bytearray sunt modificabile
class bytes([source[, encoding[, errors]]])
class bytearray([source[, encoding[, errors]]])
• source - Obiectul sursă care este convertit la șir de octeți. Poate fi un literal binar, un literal șir
sau un întreg. Dacă este un număr întreg se va crea un obiect bytes cu numărul de octeți
specificat prin source, octeți cu valoare 0. Un literal binar este de forma: b'sir' sau B'sir' unde
sir poate conține numai caractere ASCII, octeții cu o valoare numerică de 128 sau mai mare
trebuie să fie precedați de '\'. Un literal șir este de forma: [r|u|R|U|f|F]'sir' sau
[r|u|R|U|f|F]"sir" sau [r|u|R|U|f|F]"""sir""". Prefixul r sau R se utilizează pentru șiruri care
nu pot conține caracterul de evitare. Prefixul u sau U pentru unicode, iar f sau F pentru șiruri
formatate.
• encoding - Nume de encodare în cazul în care sursa este literal șir
• errors - Modul de tratare a erorilor de conversie
• Adresarea elementelor se face prin index între paranteze pătrate []. Deoarece
obiectele bytes/bytearray sunt în fapt secvențe de numere întregi, pentru un
obiect b, b[0] va fi un număr întreg, în timp ce b[0:1] va fi un obiect de lungime
1. Un obiect bytes poate fi convertit la o listă de numere întregi folosind
inițializatorul de listă list(b)
• Pe obiectele bytearray pot fi făcute operațiuni de modificare a elementelor astfel:
s[i] = x; s[i:j] = t; del s[i:j]
unde s este un obiect bytearray, x este cod ascii, t este o listă de coduri ascii.
Metode ale claselor bytes și bytearray
• bytes.count(sub[, start[, end]]) - Întoarce numărul de apariții distincte ale de sub-
secvenței sub în intervalul [start, end]
• bytes.endswith(suffix[, start[, end]]); bytes.startswith(suffix[, start[, end]]) -
Returnează True dacă obiectul bytes se termină/începe cu sufixul specificat, altfel
returnează False. Căutarea se poate limita la intervalul [start,end].
• bytes.find(sub[, start[, end]]); bytes.rfind(sub[, start[, end]]) - Întoarce cel mai
mic/mare indice la care se găsește sub-secvența sub sau -1 dacă nu găsește sub-
secvența. Căutarea se poate limita la intervalul [start,end].
• bytes.index(sub[, start[, end]]); bytes.rindex(sub[, start[, end]]) - Idem find doar
că în cazul în care nu găsește sub-secvența aruncă excepție ValueError
• bytes.replace(old, new[, count]) - Returnează o copie a secvenței cu toate
aparițiile sub-secvenței old înlocuite cu new. Numărul de înlocuiri poate fi limitat
la count.
• bytes.lstrip([chars]); bytes.rstrip([chars]); bytes.strip([chars]); - Returnează un
nou obiect bytes cu octeții din chars eliminați din stânga/dreapta/stânga și dreapta.
Dacă chars lipsește sunt eliminate caracterele whitespace (spațiu, tab).
• bytes.split(sep=None, maxsplit=-1); bytes.rsplit(sep=None, maxsplit=-1);
Împarte obiectul bytes în obiecte de același tip, folosind sep ca separator. Dacă se
dă maxsplit, se fac cel mult maxsplit divizări, cele mai din dreapta în cazul lui
rsplit. Dacă sep nu este specificat sau este None, orice sub-secvență constând
exclusiv din caractere whitespace este un separator.
• bytes.ljust(width[, fillbyte]); bytes.rjust(width[, fillbyte]); bytes.center(width[,
fillbyte]); - Alinieri stânga/dreapta/centru pe lungime width folosind caracterul
fillbyte. Dacă fillbyte lipsește se consideră spațiu.
• bytes.isalnum();bytes.isalpha();bytes.isascii();bytes.isdigit();bytes.islower();bytes.
isspace();bytes.isupper();bytes.istitle(); - Teste pentru ascii, alfabetic, alfanumeric
etc.
• bytes.lower();bytes.upper();bytes.title(); - Transformări în litere mici, mari, titlu
Metode specifice bytearray
• Sunt metode specifice oricăror secvențe de tip muttable.
• bytearray.append(x); bytearray.remove(x); bytearray.insert(i,x); - Adăugare,
ștergere, inserare. x este un întreg reprezentând codul ascii al caracterului.

(Exemplul 10)
Tupluri
• Sunt secvențe eterogene de date de tip immutable
• Inițializarea se poate face astfel:
• Prin utilizarea parantezelor rotunde și a virgulelor. O pereche de paranteze
delimitează un element.
• Prin constructor
tuple()
tuple(iterable)
• Elementele pot fi accesate prin paranteze []
• Elementele de tip mutable din interior pot fi modificate
• Pot fi concatenate prin operatorul „+”
• Metode:
count(element); #Determină frecvența unui element
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
Liste

• Clasa list definește o secvență de lungime variabilă. O listă se poate defini în felul următor:
• Prin inițializare cu ajutorul parantezelor și virgulelor
• Prin utilizarea constructorului clasei List
list()
list(iterable)
unde iterable este o secvență iterabilă.
• Prin filtrarea elementelor unei colecții: x for x in iterable
• Adăugare și ștergere în liste:
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 +
• Sortarea listelor
list.sort(*, key=None, reverse=False); #key este o funcție care este folosită pentru
a furniza o cheie utilizată în comparație pentru fiecare element de listă. reverse
indică sensul sortării
• Selecția în liste se realizează prin expresii indiceale de forma: start:stop:step

(Exemplul 11)
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 “{}”
note = {"Popescu Adrian":10,"Ionescu Florin":9.69}
• Accesul la elemente se face prin cheie folosind paranteze pătrate []
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
note["Ionescu Diana"]=9.50
• 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
• Metode mai importante:
Ș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()
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
• 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.
Intervale
• 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