-
Notifications
You must be signed in to change notification settings - Fork 2
Operații de bază
Python are un set de funcții foarte folositoare pe care le pune la dispoziție în mod direct. Celelalte funcții sunt organizate în module, pentru a nu încărca limbajul de bază. Documentația oficială Python descrie toate funcțiile built-in pe care acesta le oferă.
Poate una dintre cele mai folositoare funcții, str convertește un obiect pe care îl primește ca argument într-un string. String-ul returnat poate fi folosit în orice altă expresie, ca un string normal.
>>> str(1 + 1)
'2'
>>> str(['hello', 1, {'world': 2}])
"['hello', 1, {'world': 2}]"
>>> str(1 == 1)
'True'
>>> str(1 * 3) + ' mere'
'3 mere'
Convertește un număr sau string primit ca argument într-un întreg, sau întoarce 0 în caz că nu a primit niciun argument. Dacă argumentul primit este un număr real, conversia îl va trunchia către 0. Primește și un argument opțional care specifică baza (implicit 10) în care se află primul argument.
>>> int(10.2)
10
>>> int(-5.7)
-5
>>> int('34')
34
>>> int('10', 2)
2
Convertește un string sau un număr într-un număr real (floating point).
>>> float()
0.0
>>> float('5.71')
5.71
>>> float('-3.2')
-3.2
>>> float('inf')
inf
>>> 5 / 2
2
>>> float(5) / 2
2.5
Convertește o valoare la un Boolean (True sau False), folosing procedura de testare standard.
>>> bool('')
False
>>> bool('hello')
True
>>> bool(None)
False
>>> bool([])
False
>>> bool(0)
False
>>> bool(7)
True
>>> bool(1.0 == 1)
True
Funcția type returnează tipul unui obiect.
>>> type(2)
<type 'int'>
>>> type([])
<type 'list'>
>>> type({'string': [1, 3]})
<type 'dict'>
>>> type(fibonacci)
<type 'function'>
Definiție: pow(x, y[, z])
Funcția pow returnează x la puterea y, modulo z, dacă al treilea argument este prezent. pow(x, y) este echivalentă operatorului putere: x**y.
Definiție: sum(iterable[, start])
Însumează începând cu start (inclusiv) elementele dintr-un iterable, de la stânga la dreapta, și returnează totalul. Valoarea implicită a start este 0. Pentru o listă de string-uri, este preferată folosirea ''.join(sequence).
Definiție: abs(x)
Returnează valoarea absolută a unui număr. Argumentul poate să fie un întreg, un număr real sau un număr complex.
Definiție: range(start=0, stop[, step])
range este folosit pentru a genera o listă de numere întregi. De cele mai multe ori își găsește utilitatea în for-uri.
>>> range(5)
[0, 1, 2, 3, 4]
>>> range(2, 5)
[2, 3, 4]
>>> range(2, 10, 2)
[2, 4, 6, 8]
xrange este similar cu range, cu diferența că returnează un obiect xrange, și nu o listă. Se recomandă folosirea xrange când se dorește optimizarea consumului de memorie. Pentru o explicație mai detaliată asupra diferenței dintre cele două funcții, consultați acest articol.
Documentația oficială Python descrie tehnicile de input și output, de la linia de comandă dar și din fișiere. Altă documentație online pe acest subiect găsiți aici și aici.
Python folosește funcția input() pentru a primi date de la utilizator.
input afișează un mesaj pe ecran (dacă primește argument), așteaptă de la utilizator un string terminat în newline și îl returnează programului.
>>> print(raw_input('Introduceti numele: '))
Introduceti numele: Ion Popescu # "Ion Popescu" a fost introdus de la tastatură
Ion Popescu
Dacă ne dorim și evaluarea expresiei introduse la tastatura putem să luăm rezultatul întors de funcția input și să îl evaluăm cu funcția eval.
>>> x = eval(input('Care sunt primele 10 numere patrate perfecte? '))
Care sunt primele 10 numere patrate perfecte? [i**2 for i in range(10)]
>>> print(x)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> x[3]
9
Cel mai ușor mod prin care se poate afișa ceva pe ecran este folosind print.
>>> print('Ana are mere')
Ana are mere
>>> print('Ana', 'are', 'mere')
Ana are mere
>>> print(1, 2, 0xff, (10+5j), -1.45, input, sys)
1 2 255 (10+5j) -1.45 <built-in function input> <module 'sys' (built-in)>
>>> for i in range(3):
... print(i)
0
1
2
>>> for i in range (3):
... print(i),
0 1 2
Python conține un tip de date built-in pentru lucrul cu fișiere: file. Fișierele se pot deschide folosind constructorul tipului, care primește ca argumente numele fișierului și modul în care acesta e deschis. Cele mai importante modurile de deschidere sunt:
-
rpentru citire (read) -
wpentru scriere (write) -
apentru scriere la sfârșitul fișierului (append) -
r+pentru citire și scriere
Modul de deschidere este opțional, valoarea default fiind r.
>>> f = file('test.txt', 'w')
O altă modalitate de deschidere a unui fișier este folosirea funcției open:
>>> f = open('test.txt', 'r')
>>> f.close() # pentru închiderea fișierului
Este recomandată folosirea construcției with pentru lucrul cu obiecte de tip file. Astfel, fișierul va fi închis după execuția blocului de cod, chiar dacă o excepție este aruncată în interiorul acestuia.
>>> with open('test.txt', 'r') as f:
... read_data = f.read()
>>> f.closed
True
Cea mai simplă modalitate pentru a citi din fisier este iterația peste liniile din fișier.
>>> with open('test.txt', 'r') as f:
... for line in f:
... print(line),
...
acesta este un fisier de test
contine 3 linii
ultima linie
Următoarele exemple presupun existența unui obiect de tip file f.
f.read(size) va întoarce tot conținutul fișierului dacă size nu este specificat, sau un număr de caractere <= size, dacă size este specificat. f.readlines() întoarce o listă cu liniile fișierului.
>>> f.read()
'acesta este un fisier de test\ncontine 3 linii\nultima linie\n'
>>> f.read(5)
'acest'
>>> f.readlines()
['acesta este un fisier de test\n', 'contine 3 linii\n', 'ultima linie\n']
Pentru poziționarea în fișier se folosește f.seek(offset).
>>> f.seek(15)
>>> f.read(6)
'fisier'
Pentru scrierea în fișier se folosește metoda write asociată unui obiect de tip file.
>>> with open('output.txt', 'w') as f:
... for i in range(10):
... f.write(str(i))
Python dispune de o bibliotecă de module standard, a căror descriere o puteți găsi în documentația limbajului.
Modulele Python au fost create pentru simplificarea procesului de programare și pentru minimizarea repetării unor porțiuni de cod. Acestea pot fi folosite doar după ce au fost importate:
>>> sys.ps1
NameError: name 'sys' is not defined
>>> import sys
>>> sys.ps1
'>>> '
Mai jos găsiți descrieri și exemple pentru câteva dintre cele mai folosite module din biblioteca standard.
Modulul re din biblioteca standard permite lucrul cu expresii regulate. Acesta include funcționalități precum: căutarea unui șablon într-un string, înlocuirea unei porțiuni dintr-un string, împărțirea unui string în mai multe stringuri având ca delimitator o expresie regulată.
Pentru folosirea aceleiași expresii regulate de mai multe ori în același program, se recomandă folosirea unui obiect RegexObject, care se creează cu ajutorul funcției compile.
>>> import re
>>> foo = re.compile(r'foo(.{,5})bar', re.I)
Funcția compile primește ca argumente:
- Expresia regulată; în cazul de mai sus, aceasta descrie șirurile de caractere care încep cu foo, continuă cu între 0 și 5 caractere aleatoare și se termină în bar, de exemplu: foobar, foo3s bar, foo#$%^*bar. Litera
rdinaintea expresiei regulate indică unraw string, ceea ce înseamnă căbackslash-urile vor fi interpretate literal și nu vor mai fi folosite pentru escapare. - Unul sau mai multe
flags; expresiile regulate folosesc diferiteflagscare le modifică comportamentul. Cel de mai sus indică faptul că expresia regulată ignoră diferențele între litere mari și mici. Pentru lista completă aflag-urilor consultați acest document.
Pentru a extrage o parte dintr-un string identificată de un regex sau a verifica existența acesteia în string se vor folosi funcțiile match sau search. Acestea sunt similare, singura diferență fiind că match va căuta o corespondență doar la începutul stringului, în timp ce search caută pe toată lungimea acestuia.
>>> import re
>>> foo = re.compile(r'foo(.{,5})bar', re.I)
>>> st1 = 'Foo, Bar, Baz'
>>> st2 = '2. foo is bar'
>>> search1 = foo.search(st1)
>>> search2 = foo.search(st2)
>>> match1 = foo.match(st1)
>>> match2 = foo.match(st2)
În exemplul de mai sus match2 va avea valoarea None, pentru că st2 nu începe cu șablonul folosit. Celelalte 3 rezultate vor fi obiecte de tip Match.
>>> search3 = re.search('oo.*ba', st1, re.I)
După cum se poate observa în exemplul anterior, o expresie regulată poate fi căutată și fără a fi compilată, dar compilatarea prezintă o serie de avantaje:
- poate fi folosită cu ușurință în mai multe căutări;
- unele metode ale modulului nu primesc
flagsca argumente, deci căutarea cuflagsse poate face doar folosing un regex compilat; - codul este mai curat;
Pentru găsirea tuturor aparițiilor unui pattern se pot folosi metodele findall (returnează o listă cu toate string-urile găsite) și finditer (returnează un iterator care, prin parcurgere, returnează obiecte Match).
>>> st3 = 'foo, Bar Foo. BAR FoO: bar'
>>> foo.findall(st3)
[', ', '. ', ': ']
>>> for match in foo.finditer(st3):
... match.group(0)
'foo, Bar'
'Foo. BAR'
'FoO: bar'
Obiectele Match au întotdeauna valoarea de adevăr True. Astfel, se poate verifica prezența unui pattern într-un string printr-o simplă expresie if:
>>> match = re.search(r'food?.{3}', 'foobar')
>>> if match:
... print('We have a match!')
În continuare vom exemplifica câteva metode ale obiectelor Match.
Obs. O expresie regulată poate conține așa-numite subgrupuri, marcate prin paranteze rotunde. De exemplu, expresia (\w+)@(?P<domain>\w+\.[a-z]{2,3}) conține două subgrupuri, dintre care unul are nume: domain.
>>> number_regex = re.compile('(\d+)\.(\d+)')
>>> search = number_regex.search('Result: 23.1765')
>>> search.group(0) # returnează tot textul care se potrivește șablonului
'23.1765'
>>> search.group(2) # returnează textul care se potrivește celui de-al doilea subgrup
'1765'
>>> search.group(0, 1) # returnează un tuplu format din: tot textul, primul subgrup
('23.1765', '23')
>>> search.groups() # returnează un tuplu cu toate subgrupurile
('23', '1765')
>>> search.start() # returnează poziția de start a textului găsit
8
>>> search.end() # returnează poziția de final a textului găsit
15
>>> search.start(1) # returnează poziția de start a primului subgrup
8
>>> search.end(1) # returnează poziția de final a primului subgrup
10
Modulul re permite și înlocuirea unei porțiuni dintr-un string cu alt string, prin intermediul funcției sub. Aceasta primește ca argumente: expresia regulată, textul cu care se înlocuiește, textul în care se înlocuiește și, opțional, numărul maxim de substituții. Returnează string-ul obținut în urma substituției. Similar poate fi folosită metoda cu același nume a unui obiect de tip RegexObject.
>>> import re
>>> mystring = 'This string has a q in it.'
>>> re.sub(r'(an? )(\w)', r"\1'\2'", mystring) # funcția sub() din modulul re
"This string has a 'q' in it."
>>> pattern = re.compile(r'(an? )(\w)')
>>> pattern.sub(r"\1'\2'", mystring) # metoda sub() a obiectului Regex
"This string has a 'q' in it."
O altă funcționalitate este împărțirea unui string în mai multe substring-uri folosing un pattern ca delimitator. Funcția split primește ca parametri: regex-ul, string-ul de împărțit și opțional numărul maxim de împărțiri.
>>> re.split(r'[\.,!\?]?\s?', 'Hello, Anne! How are you?')
['Hello', 'Anne', 'How', 'are', 'you', '']
>>> re.split(r'[\.,!\?]?\s?', 'Hello, Anne! How are you?', 2)
['Hello', 'Anne', 'How are you?']
Funcția escape toate caracterele non-alfanumerice dintr-un string. Este folositoare în cazul în care se dorește folosirea unui string care conține caractere speciale regex (ca ) sau .) ca expresie regulată.
>>> re.escape(r'Wow, <re> module is really _FUN_! :)')
'Wow\\,\\ \\<re\\>\\ module\\ is\\ really\\ \\_FUN\\_\\!\\ \\:\\)'
Modulul datetime pune la dispoziție o serie de tipuri de date folositoare în prelucrarea datelor temporale:
-
date- definește o dată; are ca atribute: anul, luna și ziua. -
time- definește un moment al zilei, independent de o zi calendaristică; are ca atribute: ora, minutul, secunda și microsecunda. -
datetime- combină cele două tipuri definite anterior. -
timedelta- diferența (în microsecunde) între două obiecte de tipdate,timesaudatetime.
Există mai multe modalități prin care se poate obține un obiect de tip date. Mai jos exemplificăm obținerea datei curente cu ajutorul metodelor today și fromtimestamp și folosirea constructorului clasei.
>>> import time
>>> from datetime import date
>>> date.today()
datetime.date(2014, 10, 1)
>>> date.fromtimestamp(time.time())
datetime.date(2014, 10, 1)
>>> date(2007, 3, 24) # constructorul primește ca parametri poziționali anul, luna și ziua
datetime.date(2007, 3, 24)
>>> date(month=3, day=24, year=2007) # dacă folosim numele parametrilor, le putem schimba ordinea
datetime.date(2007, 3, 24)
Pentru obiectele de tip datetime există metode similare. În plus, acestea pot fi obținute dintr-un șir de caractere care reprezintă o dată, conform unui format.
>>> from datetime import datetime
>>> datetime.now()
datetime.datetime(2014, 10, 1, 15, 31, 35, 341049)
>>> datetime.today()
datetime.datetime(2014, 10, 1, 15, 31, 50, 645113)
>>> datetime.fromtimestamp(time.time())
datetime.datetime(2014, 10, 1, 15, 32, 10, 650082)
>>> datetime(2012, 5, 21, 22, 17, 23) # argumente poziționale: an, lună, zi, oră, minut, secundă, microsecundă
datetime.datetime(2012, 5, 21, 22, 17, 23)
>>> datetime(2012, 5, 21) # doar primele 3 argumente sund obligatorii, celelalte având valoarea implicită 0
datetime.datetime(2012, 5, 21, 0, 0)
>>> datetime(second=20, minute=1, hour=18, year=2014, day=1, month=2)
datetime.datetime(2014, 2, 1, 18, 1, 20)
>>> datetime.strptime('1989-23-08 / 09:15', '%Y-%d-%m / %H:%M')
datetime.datetime(1989, 8, 23, 9, 15)
Diferența între două obiecte ce definesc o dată va fi un obiect timedelta. Exemplul de mai jos calculează timpul rămas până la Crăciun.
>>> today = date.today()
>>> christmas = date(2014, 12, 25)
>>> until_christmas = christmas - today
>>> until_christmas.days
85
>>> until_christmas.total_seconds()
7344000.0
La o dată se poate adăuga/scade o perioadă de timp (timedelta). Obiectele timedelta suportă, la rândul lor, operații de adunare/scădere cu alte obiecte timedelta și înmulțire/împărțire cu numere întregi.
>>> from datetime import timedelta
>>> from datetime import date
>>> week = timedelta(weeks=1)
>>> today = date.today()
>>> today + week
datetime.date(2014, 10, 8)
>>> today - week * 3
datetime.date(2014, 9, 10)
>>> week / 7
datetime.timedelta(1)
Obiectele ce definesc date pot fi comparate:
>>> john_birthday = date(1989, 3, 2)
>>> anne_birthday = date(1988, 4, 12)
>>> if john_birthday < anne_birthday:
... print('John is older')
... else:
... print('Anne is older')
...
Anne is older
Obiectele date, datetime și time suportă metoda strftime(format) care permite crearea unei reprezentări text a obiectului, conform unui format. Pentru mai multe detalii privitoare la opțiunile disponibile pentru a defini formatul, consultați această secțiune din documentație.
>>> from datetime import datetime
>>> now = datetime.now()
>>> print(now.strftime('Data: %Y/%m/%d; Ora: %H:%M:%S'))
Data: 2014/10/01; Ora: 16:13:36
>>> from datetime import time
>>> midnight = time()
>>> print(midnight.strftime('%H:%M %p'))
00:00 AM
>>> from datetime import date
>>> print(date.today().strftime('Anul: %Y\nSaptamana: %W\nZiua: %A'))
Anul: 2014
Saptamana: 39
Ziua: Wednesday
Modulul random oferă o serie de funcții care permit introducerea unui factorului aleator în programe. Pentru generarea de numere aleatoare au fost definite funcțiile:
-
randint(a, b)- returnează un număr întreg aleator cuprins întreașib(a <= N <= b); -
randrange(start, stop, step=1)- returnează un număr întreg mai mic decâtstopde formastart + x*step, undexeste un număr aleator; -
random()- generează un număr real din intervalul[0, 1); -
uniform(a, b)- generează un număr real cuprins întreașib;
Exemple:
>>> import random
>>> random.randint(1, 10)
6
>>> random.randrange(1, 20, 2)
13
>>> random.random()
0.3848754069329102
>>> random.uniform(7.1, 2)
5.7192835033359275
Pentru operații cu secvențe se pot folosi funcțiile:
-
choice(seq)- returnează un element random din secvențaseq; -
sample(seq, k)- returnează o listă dekelemente ale secvențeiseq, ordonate aleator; -
shuffle(seq)- schimbă ordinea elementelor din secvențaseq;
Exemple:
>>> random.choice(['blue', 'red', 'green'])
'red'
>>> random.choice('abcdefghijk')
'd'
>>> random.sample([1, 2, 3, 1, 3, 1], 3)
[3, 1, 3]
>>> random.sample('Hello world', 5)
[' ', 'o', 'w', 'e', 'l']
>>> my_list = [1, 2, 3, 4, 5, 6, 7]
>>> random.shuffle(my_list)
>>> my_list
[2, 4, 6, 3, 5, 7, 1]