User Tools

Site Tools


operatii-de-baza

Operații de bază

Funcții

Python are funcții, la fel ca majoritatea celorlaltor limbaje de programare. În continuare vom discuta despre particularitățile modului în care sunt create și utilizate funcțiile în Python.

Definirea unei funcții

O funcție se declară folosind cuvântul cheie def astfel:

def fibonacci(n):

Documentarea unei funcții se face printr-un doc string:

def fibonacci(n):
  """Afiseaza seria fibonacci pana la n."""

Corpul unei funcții se scrie indentat.

>>> def fibonacci(n):
        """Afiseaza seria Fibonacci pana la n."""
        a, b = 1, 1
        while a < n:
            print a
            a, b = b, a + b
>>> fibonacci
<function fibonacci at 0x0000000001ECBAC8>
>>> fibonacci(5)
1
1
2
3
>>> 

Definirea funcțiilor trebuie să se facă înainte ca acestea să fie folosite. Dacă o funcție este apelată înainte să fie definită, interpretorul va da o eroare de tipul NameError.

>>> suma()
 
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    fibonacci()
NameError: name 'suma' is not defined
>>> 

Funcțiile pot să returneze și o valoare. Mai jos este un exemplu cu afișarea șirului Fibonacci în mod recursiv.

>>> def fibonacci2(n):
        """Afiseaza al n-lea numar Fibonacci, în mod recursiv."""
        if n > 2:
            return fibonacci2(n-1) + fibonacci2(n-2)
        return 1
 
>>> fibonacci2
<function fibonacci2 at 0x0000000002CF7DD8>
>>> fibonacci2(5)
8
>>> 

Observații:

  • Funcțiile care deși nu folosesc return pentru a întoarce o valoare, întorc totuși valoarea None.
  • Dacă se folosește doar return, este întoarsă tot valoarea None.

Exemplu:

>>> print fibonacci(0)
None

Funcțiile pot fi folosite în orice expresie (cum am văzut în exemplul anterior), sau apelate dintr-o altă funcție:

>>> def print_fibonacci(n):
	print "Al", n, "-lea numar Fibonacci este", fibonacci2(n)
 
 
>>> print_fibonacci(5)
Al 5 -lea numar Fibonacci este 5
>>>

Domeniul de vizibilitate al variabilelor

Să pornim de la următorul exemplu:

>>> x = 0
>>> y = 0
>>> def inc(x):
	y = x + 1
	return y
 
>>> inc(5)
6
>>> print x, y
0 0
>>> 

Variabilele declarate sau modificate într-o funcție, inclusiv argumentele funcției, sunt numite variabile locale funcției. Variabilele definite la nivel global sunt numite variabile globale. Într-o funcție, putem să folosim valorile variabilelor globale:

>>> pi = 3.14
>>> def aria_cercului(r):
	return pi * r * r
 
>>> aria_cercului(1)
3.14
>>> 

Variabilele globale pot fi modificate la nivel global. Însă, pentru a putea fi modificate într-o funcție, ele trebuie declarate folosind cuvântul cheie global:

>>> numar_apeluri = 0
>>> def patrat(x):
	global numar_apeluri
	numar_apeluri = numar_apeluri + 1
	return x * x
 
>>> patrat(4)
16
>>> numar_apeluri
1
>>> 

Argumente

După cum am văzut în exemplele anterioare, funcțiile pot primi argumente. Pentru funcția fibonacci(n), n este un argument. Mai jos sunt câteva exemple de funcții fără argumente, sau cu mai multe argumente.

>>> def printeaza_fara_argument():
	print "Aceasta functie nu primeste argumente."
 
>>> printeaza_fara_argument()
Aceasta functie nu primeste argumente.
>>> 
>>> def printeaza_trei_argumente(arg1, arg2, arg3):
	print "Argumentele pe care functia le-a primit, sunt in ordine: ", arg1, arg2, arg3
 
>>> printeaza_trei_argumente(1, "al doilea", 1 + 2)
Argumentele pe care functia le-a primit, sunt in ordine:  1 al doilea 3
>>> 

Argumente opționale și cu nume

Funcțiile pot fi apelate folosind numele argumentului din declarația funcției.

Exemplu:

>>> def scadere(x, y):
	return x - y
 
>>> scadere(5, 3)
2
>>> scadere(x=5, y=3)
2
>>> scadere(y=3, x=5)
2
>>> scadere(5, y=3)
2
>>> 

Observație

  • Dacă apelăm funcția cu cel puțin un argument căruia nu-i specificăm numele, acesta trebuie să se afle pe poziția corespunzătoare argumentului respectiv din declarația funcției. Astfel, un apel ca cel din exemplul de mai jos nu este permis:
    >>> scadere(y=2, 5)
    SyntaxError: non-keyword arg after keyword arg
    >>>

Unele argumentele pot să aibă și valori default. Acest lucru le face practic opționale, deoarece Python va folosi valoarea default în interiorul funcției.

>>> def inc(x, cu_cat=1):
	return x + cu_cat
 
>>> inc(10)
11
>>> inc(10, 5)
15
>>> inc(10, cu_cat=2)
12
>>> 

Argumentele *args și **kwargs

*args și **kwargs ne permit să trimitem un număr variabil de parametri unei funcții. În acest context, variabil înseamnă că nu știm dinainte numărul de argumente pe care le va primi funcția.

Exemplu:

>>> def printeaza_argumente_variabile(arg1, *args):
    print "primul argument: ", arg1
    for arg in args:    # ia pe rand fiecare valoare din vectorul args; vom explora aceasta constructie in sectiunea Iteratori
        print "un alt argument din *args: ", arg
 
>>> printeaza_argumente_variabile(1, "ana", "are", "mere")
primul argument:  1
un alt argument din *args:  ana
un alt argument din *args:  are
un alt argument din *args:  mere
>>>
>>> # Sau folosind o lista cu argumente:
>>> args = ["arg2", 3, 4]
>>> printeaza_argumente_variabile("argumentul 1", *args)
primul argument:  argumentul 1
un alt argument din *args:  arg2
un alt argument din *args:  3
un alt argument din *args:  4

*args este practic lista de argumente suplimentare ale funcției.

**kwargs ne permite să transmitem un număr variabil de parametrii cu nume unei funcții. Dacă *args se comportă ca o listă de argumente, **kwargs este ca un dicționar, unde numele argumentului este cheia, iar valoarea argumentului este valoarea asociată cheii în dicționar:

>>> def printeaza_argumente_variabile(**kwargs):
	if kwargs is not None:
		for key, value in kwargs.iteritems():
			print key, " == ", value
 
>>> printeaza_argumente_variabile(prenume="Ion", nume="Popescu")
nume  ==  Popescu
prenume  ==  Ion
>>>
>>> # Sau folosind un dictionar:
>>> kwargs = {"nume": "Popescu", "prenume": "Ion", "localitate": "Bucuresti"}
>>> printeaza_argumente_variabile(**kwargs)
nume  ==  Popescu
localitate  ==  Bucuresti
prenume  ==  Ion
>>> 

Alte exemple și detalii online aici și aici.

Funcții built-in

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ă. Un alt exemplu online unde sunt tratate funcțiile gata-oferite de Python este Dive Into Python .

Funcția pentru conversie

str

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(["ana", 1, {2:"hello"}])
"['ana', 1, {2: 'hello'}]"
>>> 1 == 1
True
>>> str(1 == 1)
'True'
>>> str(1 * 2) + " mere"
'2mere' 
>>> str(None)
'None'
>>>

int

Convertește un număr sau string primit ca argument într-un întreg, sau întoarce 0 în caz că nu a primit niciun argument. Al doilea argument e opțional și specifică baza în care se află primul argument. Dacă baza e specificată, primul argument trebuie să fie string. Baza default este 10.

>>> int(10.2)
10
>>> int(-5.6)
-5
>>> int("34")
34
>>> int("10", 16)
16
>>> 

float

Convertește un string sau un număr într-un număr real (floating point).

>>> float()
0.0
>>> float(4)
4.0
>>> float("5.32")
5.32
>>> float("inf")
inf
>>> float("-3.123")
-3.123
>>> 

bool

Convertește o valoare la un Boolean (True sau False), folosing procedura de testare standard.

>>> bool('')
False
>>> bool('ana')
True
>>> bool(None)
False
>>> bool(0)
False
>>> bool(123)
True
>>> bool(1.0 == 1)
True
>>> 

Funcția type

Funcția type returnează tipul unui obiect.

>>> type(2)
<type 'int'>
>>> type([])
<type 'list'>
>>> type({"string": [1, 2]})
<type 'dict'>
>>> type(fibonacci)
<type 'function'>
>>> 

Funcții matematice

pow

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.

sum

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 default a start este 0. Pentru o listă de string-uri, este preferată folosirea ''.join(sequence).

abs

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.

range și xrange

range și xrange sunt folosite pentru a genera o listă de numere întregi. De cele mai multe ori ele își găsesc utilitatea în for-uri.

>>> for i in range (5):
	print(i)
 
0
1
2
3
4
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

Pentru o explicație mai detaliată asupra diferenței dintre cele două funcții, consultați acest articol.

Input și output

Documentația oficială Python descrie câteva tehnici 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

Input

Python folosește două funcții pentru a primi date de la utilizator: input() și raw_input().

raw_input

raw_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
>>> 

input

input folosește raw_input pentru a citi un string de date, după care încearcă să îl evalueze ca și cum ar fi un program Python, și apoi returnează valoarea rezultată.

>>> a = input()
[1, 2, 3, 4, 5]
>>> a
[1, 2, 3, 4, 5]
>>> a[2]
3
>>> x = input('Care sunt primele 10 numere patrate perfecte? ')
Care sunt primele 10 numere patrate perfecte? [i*i for i in range(10)]
>>> print x
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> 

Output

print

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

stdout și stderr

Când folosim print, rezultatul acesteia este afișat la stdout; în schimb, când obținem o eroare, aceasta este afișată la stderr. În consola Python, acestea sunt practic afișate pe ecran, în același mod.

>>> for i in range(3):
	print 'python'
 
python
python
python
>>> import sys
>>> for i in range(3):
	sys.stdout.write('python')
 
pythonpythonpython
>>> for i in range(3):
	sys.stderr.write('python')
 
pythonpythonpython
>>> 

Observație:

  • stdout și stderr se află sub modulul sys, de aceea acesta trebuie importat înainte de a le putea accesa.

Lucrul cu fișiere

Deschiderea fișierelor

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 prim argument numele fișierului și modul în care acesta e deschis. Cele mai importante modurile de deschidere sunt:

  • r pentru citire (read)
  • w pentru scriere (write)
  • a pentru scriere la sfârșitul fișierului (append)
  • r+ pentru citire și scriere

Modul de deschidere este opțional, valoarea default este 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

Observație:

  • Fișierele sunt închise automat în momentul în care obiectul de tip file asociat iese din scop, deci nu este nevoie să le închidem în mod explicit, dar este considerată o practică bună.

Citirea din fișier

Cea mai simplă modalitate pentru a citi din fisier este iterația peste liniile din fișier:

>>> f = open('test.txt', 'r')
>>> for line in f:
	print line,
 
linia 1
aceasta linie este mai lunga
ultima linie
>>> 

De asemenea, se poate folosi funcția read asociată obiectului file:

>>> f = open('test.txt', 'r')
>>> c = f.read(1)
>>> while len(c) > 0:
	if len(c.strip()) > 0: # c.strip() sterge spatiile goale din string-ul c
		print c,
	c = f.read(1)
 
l i n i a 1 a c e a s t a l i n i e e s t e m a i l u n g a u l t i m a l i n i e
>>> 

Pentru a ne poziționa în fișier se folosește funcția seek:

>>> f.seek(9)
>>> f.read(13)
'aceasta linie'
>>> f.seek(17)
>>> f.read(5)
'linie'
>>> 

Scrierea în fișier

Cea mai ușoară modalitate de a scrie într-un fișier este prin intermediul instrucțiunii print și folosind operatorul de redirectare >>:

>>> f = open('test.txt', 'w')
>>> for i in range(10):
 
	print >>f, i
 
 
>>> f.close()
>>> 

O altă metodă este prin folosirea metodei write asociată obiectului file.

>>> f = open('test.txt', 'w')
>>> for i in range(10):
	f.write(str(i))
 
 
>>> f.close()
>>> 

Exerciții

1. Scrieți o funcție care primește oricâte numere și întoarce suma lor:

mysum(1) # 1
mysum(1, 2) # 3
mysum(1, 2, 3, 4, 5) # 15
  • Soluție
    >>> def my_sum(arg1, *args):
    	sum = arg1
    	for arg in args:
    		sum = sum + arg
    	return sum
     
    >>> my_sum(1,2,3,4,5)
    15
    >>> 

2. Scrieti o functie care primeste ca parametru o lista si intoarce lista inversata.

  • Soluție
    >>> def inverse(list):
    	result = []
    	for element in list:
    		result.insert(0,element) # inserez mereu pe primul loc
    	return result
     
    >>> inverse([1,2,3,4,5])
    [5, 4, 3, 2, 1]
    >>> 

3. Scrieti o functie care primeste ca parametri doua siruri de caractere si verifica daca al doilea sir se gaseste in primul. Daca se gaseste, functia intoarce pozitia in cadrul primului sir. In caz contrar, intoarce -1.

  • Soluție
    def contains(str1, str2):
        index = 0
        while (len(str1) - index) >= len(str2):
            found = True 
            for i in xrange(len(str2)):
                if str1[index + i] != str2[i]:
                    found = False
                    break
            if found == True:
                return index
            index = index + 1
        return -1
     
    >>> contains('anamaria', 'ana')
    0
    >>> contains('mariaana', 'ana')
    5
    >>> contains('mariaana', 'anap')
    -1
    >>> 

4. Scrieți o funcție care întoarce True dacă un string este palindrom și False în caz contrar.

  • Soluție
    def is_palindrom(sir):
        i = 0
        j = len(sir) - 1
        result = True
        while i < j:
            if sir[i] != sir[j]:
                result = False
                break
        return result
     
     
    >>> is_palindrom("masina")
    False
    >>> is_palindrom("capac")
    True
    >>> 

5. Scrieți o funcție care să sorteze o listă de numere întregi. Algoritmul folosit este la alegere.

  • Soluție
    def sort(mylist):
        length = len(mylist)
        for i in xrange(length):
            for j in xrange(length-1):
                if mylist[i] < mylist[j]:
                    mylist[i], mylist[j] = mylist[j], mylist[i]
     
        return mylist
     
    >>> sort([4, 1, 3, 5, 456, 345, 4566, 123, 55])
    [1, 3, 4, 5, 55, 123, 345, 456, 4566]

6. Scrieți o funcție care interclasează două liste ordonate primite ca parametri și întoarce lista rezultat.

  • Soluție
    def merge(l1, l2):
        result = []
        i = j = 0
        while i < len(l1) and j < len(l2):
            if l1[i] < l2[j]:
                result.append(l1[i])
                i += 1
            else:
                result.append(l2[j])
                j += 1
        if len(l1):
            result.extend(l1[i:])
        if len(l2):
            result.extend(l2[j:])
     
        return result
     
     
    >>> merge([1, 2, 3, 5, 7, 10], [2, 4, 6, 8, 9, 12, 13, 16])
    [1, 2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 16]
    >>> merge([1, 2, 3, 5, 7, 10], [])
    [1, 2, 3, 5, 7, 10]

7. Scrieți un program care adaugă două numere primite de la utilizator (de la consolă). Prima dată îl scrieți simplu, apoi cu verificare de erori.

  • Varianta simplă: apelați funcția input de 2 ori și adăugați numerele introduse de la tastatură.
  • Varianta cu verificare de erori: Scrieți codul astfel încât să ceara utilizatorului un număr întreg și apoi verifică dacă ce a introdus utilizatorul e un număr valid. Afișează un mesaj de eroare în caz că numărul nu e valid și continuă afișarea mesajului ce promptează utilizatorul să introducă un număr până când introduce unul valid. Hint: Folosiți raw_input pentru a citi numărul ca un șir de caractere și apoi folosiți o buclă while pentru a verifica că fiecare caracter este o cifră. Realizați același lucru și pentru al doilea număr și apoi adunați-le.
  • Soluție variantă simplă
    def simple_add():
        nr1 = input("Please enter your first number: ")
        nr2 = input("Please enter your second number: ")
     
        total = nr1 + nr2
        return 'Sum is %s' % total
     
    >>> simple_add()
    Please enter your first number: 12
    Please enter your second number: 45
    'Sum is 57'
    >>>
  • Soluție variantă cu verificare de erori
    def get_input_number(message="Please enter your number"):
        given = True
        while given:
            s = raw_input(message)
            if s.isdigit():
                given = False
            else:
                print 'Error while introducing your number. Try again!'
     
        return int(s)
     
    def check_and_add():
        nr1 = get_input_number('Please enter your first number: ')
        nr2 = get_input_number('Please enter your second number: ')
        total = nr1 + nr2
        return 'Sum is %s' % total
     
    >>> check_and_add()
    Please enter your first number: 4gwv3
    Error while introducing your number. Try again!
    Please enter your first number: 30r9v8jrv899o
    Error while introducing your number. Try again!
    Please enter your first number: d209ispc2=vv-v=-$&*@*RUJ
    Error while introducing your number. Try again!
    Please enter your first number: 45
    Please enter your second number: CIOEJVIOI
    Error while introducing your number. Try again!
    Please enter your second number: 3f0ov
    Error while introducing your number. Try again!
    Please enter your second number: 90
    'Sum is 135'

8. Scrieți un program care să citească un fișier ce conține un text. Programul va crea și va afișa pe ecran un dicționar în care vor fi stocate cuvintele și numărul de apariții ale acestora în textul din fișier.

  • Folosind fișierul de test:
    Once upon a time there lived on the borders of a great forest a woodman and his wife who had one little daughter a sweet kind child whom every one loved She was the joy of her mother's heart and to please her the good woman made her a little scarlet cloak and hood and the child looked so pretty in it that everybody called her Little Red Riding-Hood
  • Soluție
    def count_words(filename):
        with open(filename) as f:
            data = f.read()
            frequencies = {}
            for word in data.split(' '):
                if word in frequencies:
                    frequencies[word.strip()] += 1
                else:
                    frequencies[word.strip()] = 1
     
        return frequencies
     
    >>> count_words('story')
    {'and': 4, 'heart': 1, 'Little': 1, 'sweet': 1, 'it': 1, 'one': 2, 'scarlet': 1, 'his': 1, 'in': 1, 'hood': 1, 'everybody': 1, 'Riding-Hood': 1, 'little': 2, 'her': 4, 'to': 1, 'there': 1, 'had': 1, 'cloak': 1, 'whom': 1, 'that': 1, 'forest': 1, 'pretty': 1, 'borders': 1, 'was': 1, 'Red': 1, 'woodman': 1, 'lived': 1, 'loved': 1, 'joy': 1, 'who': 1, 'upon': 1, 'kind': 1, 'woman': 1, 'please': 1, 'every': 1, 'She': 1, 'child': 2, 'Once': 1, 'a': 5, 'on': 1, 'great': 1, 'made': 1, 'daughter': 1, 'wife': 1, 'of': 2, "mother's": 1, 'looked': 1, 'good': 1, 'so': 1, 'time': 1, 'the': 4, 'called': 1}

9. Userul va furniza un numar intre 1 si 100. Calculatorul va trebui sa ghiceasca numarul cu ajutorul unor indicii de la utilizator de “Too high”, “Too low”, “Right”, din minim de pasi. Exemplu rulare:

Enter a number between 1 and 100: 62
(Computer) I guess 50
(You) 'Too low'
Too low
(Computer) I guess 75
(You) 'Too high'
Too high
(Computer) I guess 62
(You) 'Right'
Right

Awesome, I got it in 3 guesses.
  • Soluție
    def guess():
        min, max = 1, 100
        i = 1
     
        input('Enter a number between 1 and 100: ')
     
        while True:
            guess = (min + max)/2
            print '(Computer) I guess %i' % guess
     
            txt = input('(You) ')
            print(txt)
            if txt == 'Too low':
                min = guess + 1
            elif txt == 'Too high':
                max = guess - 1
            elif txt == 'Right':
                print '\nAwesome, I got it in %i guesses.' % i
                break
            else:
                print 'I don\'t understand your input. Let\'s try again.'
            i = i + 1

Materiale suplimentare

operatii-de-baza.txt · Last modified: 2014/05/10 10:43 by alexef