Seminarul de fațӑ ȋși propune familiarizarea studentului cu limbajul de programare Python, prin introducerea urmӑtoarelor noțiuni:

• Variabile
  • Variabile numerice
  • Variabile de tip string
• Structuri de date
  • Liste
  • Dicționare
• Operatori
  • Operatorii “and” și “or”
  • Operatorul “in”
  • Operatorul “is”
  • Operatorul “not”
• Structuri repetitive
  • For
  • While
  • Break și continue
• Funcții
• Clase și obiecte
• Python și matematica

Se va utiliza ȋn cadrul seminarului un interpretor de Python disponibil online:

• https://repl.it/languages/python- Interpretor de python
• Tutorials point : Studentul ȋși va crea un cont personal.

Sau se poate utiliza direct bash-ul, dupӑ cum este prezentat mai jos:

$ python
Python 2.4.3 (#1, Jan 16 2016, 9:15:43)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print "Bine ați venit la seminarul de Introducere ȋn Informaticӑ!"

De asemenea, se pot utiliza scripturi:

#!/usr/bin/python
 
print "Bine ați venit la seminarul de Introducere ȋn Informaticӑ!"

Alte resurse online de studiu:

• http://www.learnpython.org/
• https://www.codecademy.com/learn/python
• http://www.tutorialspoint.com/python/
• https://repl.it/languages/python

• Python este un limbaj de programare cu interpretare de uz-general, interactiv, orientat pe obiecte și de nivel ȋnalt.
• A fost creat de cӑtre olandezul Guido van Rossum, ȋn timpul anilor 1985 - 1990, la Institutul Național de Cercetare pentru Matematicӑ și Informaticӑ, fiind un derivat al mai multor limbaje de programare, printre care: ABC, Modula-3, C, C++, Unix shell.
• Asemenea limbajului Perl, codul sursӑ de Python este disponibil sub Licența Publicӑ Generalӑ (General Public License - GPL) GNU.

Python este un limbaj de programare ȋn totalitate orientat pe obiecte, și nu “tastat static”. Spre deosebire de alte limbaje de programare, nu trebuie sӑ declari variabilele sau tipul lor ȋnainte de a le utiliza. Fiecare variabilӑ ȋn Python este consideratӑ un obiect.

Putem spune cӑ un limbaj este tastat static dacӑ tipul unei variabile este deja cunoscut la momentul compilӑrii. Ȋn practicӑ, asta ȋnseamnӑ cӑ tu -ca programator- trebuie sӑ specifici ȋn codul sursӑ ce tip de variabile vei folosi. Exemple de astfel de limbaje: Java, C, C++. Avantajul principal ȋn acest caz este acela cӑ tot felul de verificӑri sunt fӑcute de cӑtre compilator, și astfel o multitudine de erori sunt depistate ȋntr-o fazӑ timpurie.

Putem spune cӑ un limbaj este tastat dinamic dacӑ tipul variabilelor este interpretat abia la rulare. Asta ȋnseamnӑ cӑ tu - ca programator - ai o vitezӑ mult mai bunӑ de codare, fӑrӑ a mai fi rӑspunzӑtor de atribuirea tipului fiecӑrei variabile declarate. Exemple de astfel de limbaje: Perl, Ruby, Python. Cele mai multe dintre limbajele de scripting au aceasta trӑsӑturӑ, fapt determinat de lipsa unui compilator. Majoritatea limbajelor tastate dinamic permit atribuirea de tipuri variabilelor, ȋnsӑ nu necesitӑ acest lucru.

Python suportӑ douӑ tipuri numerice - ȋntregi(int) și reale de virgulӑ mobilӑ(float). (De asemenea, suportӑ numere complexe, ȋnsӑ nu vom intra ȋn detalii.)

# Sintaxa aferentӑ declarӑrii unui numӑr ȋntreg - int
 
myInt = 7

# Sintaxa aferentӑ declarӑrii unui numӑr real de virgulӑ mobilӑ - float
 
myFloat = 7.0
myFloat = float(7)

String-urile se pot defini fie utilizȃnd apostrofuri, fie ghilimele.

myString = 'hello'
myString = "hello"

myString = 'Don't worry about apostrophes!'            <- AȘA NU!

myString = "Don't worry about apostrophes!"            <- AȘA DA!

myString = 'Don\'t worry about apostrophes!'           <- AȘA DA!

• Operații simple pot fi executate atȃt cu int-uri, cȃt și cu string-uri.
• Atribuirile se pot realiza la mai mult de o singurӑ variabilӑ “simultan”.
• Amestecarea operatorilor ȋntre numere și cuvinte nu este validӑ.

a, b = 1, 2             <- atribuire "simultanӑ"
suma = a  + b

hello = "hello"
world = "world"
message = hello + " " + world

# Asta nu va funcționa!
 
one = 1
two = 2
three = 3
hello = "hello"
 
print one + two + three + hello

one = 1
two = 2
three = 3
hello = "hello"
 
print str(one) + str(two) + str(three) + hello

Listele sunt similare vectorilor sau mulțimilor. Pot conține orice tip de variabilӑ/-e, iar numӑrul elementelor pe care ȋl conțin este variabil și nerestrictiv. Listele pot fi de asemenea iterate ȋntr-o manierӑ foarte simplӑ, dupӑ cum este prezentat ȋn exemplul de mai jos:

# Se declarӑ lista.
 
mylist = []
 
# Se insereazӑ elementele ȋn listӑ.
 
mylist.append(1)
mylist.append(2)
mylist.append(3)
 
# Se afișeazӑ element cu element conținutul listei.
 
print( mylist[0] )
print( mylist[1] )
print( mylist[2] )
 
# Outputul va arӑta cam așa:
1
2
3

# Se afișeazӑ element cu element conținutul listei, utilizȃnd o structurӑ repetitivӑ de tip "for".
 
for x in mylist:
    print x
 
# Outputul va arӑta cam așa:
1
2
3

• cmp( listName1, listName2) → Comparӑ elementele celor douӑ liste.
• len( listName ) → Returneazӑ numӑrul de elemente din listӑ.
• max( listName ) → Returneazӑ elementul din listӑ cu valoarea maximӑ.
• min( listName ) → Returneazӑ elementul din listӑ cu valoarea minimӑ.

• listName.append( element ) → Insereazӑ elementul la finalul listei.
• listName.count( element ) → Returneazӑ numӑrul de apariții al elementului ȋn listӑ.
• listName.index( element ) → Returneazӑ indexul primei apariții a elementului ȋn listӑ.
• listName.inser( index, element ) → Insereazӑ elementul la indexul indicat ȋn listӑ.
• listName.pop() → Eliminӑ și returneazӑ ultimul element din listӑ.
• listName.remove( element ) → Eliminӑ elementul indicat din listӑ.
• listName.reverse() → Inverseazӑ ordinea elementelor din listӑ.
• listName.sort( [function] ) → Sorteazӑ elementele din listӑ conform funcției indicate.

Un dicționar este o structurӑ de date, similarӑ vectorilor sau listelor, dar funcționeazӑ cu valori și chei ȋn loc de indici. Fiecare valoare stocatӑ ȋntr-un dicționar poate fi accestӑ folosind o cheie, reprezentatӑ prin orice tip de obiect ( un string, un numӑr, o listӑ, etc.), ȋn locul utilizӑrii unui index pentru adresarea acesteia.

De exemplu, dicționarele pot fi utile ȋn implementarea unor baze de date. Sӑ presupunem cӑ avem o bazӑ de date cu elevi și trebuie sӑ reținem la ce opțional a fost repartizat fiecare dintre aceștia.

Cum se declarӑ un dicționar?

optionalRepartizare = {}
 
optional["Ana"] = "Grafica inginereasca"
optional["Andrei"] = "Introducere in informatica"
optional["Radu"] = "Grafica inginereasca"
optional["Serban"] = "Mecanica"
optional["Roxana"] = "Introducere in informatica"

De asemenea:

optionalRepartizare = {
    "Ana" : "Grafica inginereasca",
    "Andrei" : "Introducere in informatica",
    "Radu" : "Grafica inginereasca",
    "Serban" : "Mecanica", 
    "Roxana" : "Introducere in informatica"
 
}

Cum se parcurg elementele unui dicționar?

Dicționarele pot fi iterate la fel ca listele. Cu toate acestea, spre deosebire de liste, dicționarele au o ordine aleatorie a valorilor stocate.

optionalRepartizare = {
    "Ana" : "Grafica inginereasca",
    "Andrei" : "Introducere in informatica",
    "Radu" : "Grafica inginereasca",
    "Serban" : "Mecanica", 
    "Roxana" : "Introducere in informatica"
 
}
 
for nume, optional in optionalRepartizare.iteritems():
    print "Optionalul la care a fost repartizat/-a %s este %s" % (nume, optional)

Cum se eliminӑ valori dintr-un dicționar?

del optionalRepartizare["Ana"]

optionalRepartizare.pop("Ana")

Proprietӑți ale cheilor din dicționar

Valorile din dicționar nu au nicio restricție, ȋnsӑ acest lucru nu este valabil și pentru chei.

Cheile sunt unice. Nu trebuie sӑ existe douӑ intrӑri ȋn dicționar care sӑ aibӑ aceeași cheie. Atunci cȃnd aceastӑ proprietate nu este respectatӑ, ultima ȋnregistrare va rӑmȃne validӑ.

De exemplu, pentru secvența urmӑtoare de cod:

varsta = {
    "Ana" : 14,
    "Ioana" : 13,
    "Ana" : 16,
    "Ioana" : 22,
    "Ana" : 11
 
}
 
print "Ana are (de) %d ani, iar Ioana are (de) %d ani." % (varsta["Ana"], varsta["Ioana"])

se va afișa mesajul urmӑtor: “Ana are 11 ani, iar Ioana are 22 de ani.” .

• cmp(dictionarUnu, dictionarDoi) → Comparӑ elementele celor douӑ dicționare.
• len(numeDictionar) - > Returneazӑ lungimea dicționarului/ numӑrul de elemente din dicționar.
• str(numeDictionar) → Produce o versiune afișabilӑ a dicționarului

• numeDictionar.clear() → Eliminӑ toate elementele din dicționar
• numeDictionar.copy() → Returneazӑ o copie a dicționarului
• numeDictionar.get(cheie, default=None) → Returneazӑ valoarea conținutӑ de dicționar ȋn compartimentul “cheie”, ȋn ipoteza cӑ existӑ ceva acolo, iar ȋn caz contrar, valoarea setatӑ ȋn mod implicit
• numeDictionar.has_key(cheie) → Returneazӑ valoarea “True”, dacӑ existӑ o ȋnregistrare ȋn dicționar cu cheia “cheie”, iar ȋn caz contrar, returneazӑ valoarea “False”
• numeDictionar.items() → Returneazӑ o listӑ cu toate perechile de tipul (cheie, valoare) din interiorul dicționarului
• numeDictionar.keys() → Returneazӑ o listӑ cu toate cheile dicționarului
• numeDictionar.setdefault(cheie, default=None) → Similarӑ funcției get(), verificӑ existența cheii “cheie” ȋn dicționar, iar ȋn lipsa acesteia, o introduce cu valoarea implicitӑ
• dictionar1.update(dictionar2) → Adaugӑ conținutul dicționarului “dictionar2” ȋn dicționarul “dictionar1”
• numeDictionar.values() → Returneazӑ o listӑ cu valorile regӑsite ȋn dicționar

nume = "Madalina"
varsta = 34
 
if nume == "Madalina" and varsta == 34:
    print "Numele tau este Madalina si ai 34 de ani."
 
if nume == "Madalina" or varsta == 34:
    print "Numele tau este Madalina sau ai 34 de ani."

Operatorul “in” funcționeazӑ ca un iterator ȋn interiorul listei, parcurgȃnd elementele acestuia.

nume = "Madalina"
 
if nume in ["Madalina", "Ioana", "Maria", "Alexandra", "Ruxandra", "Irina"]:
    print "Sigur esti fata."
else:
    print "Nu sunt sigur daca esti fata, dar sigur numele tau nu se regaseste in lista."

Spre deosebire de operatorul de egalitate ”==”, operatorul “is” nu comparӑ valorile efective ale variabilelor, ci instanțele acestora.

x = [ "Ana", "are", "mere", "probabil"]
y = [ "Ana", "are", "mere", "probabil"]
 
# Secvența urmӑtoare va afișa valoarea de adevӑr "True"
print x == y
 
# Secvența urmӑtoare va afișa valoarea de adevӑr "False"
print x is y

Operatorul “not” sau operatorul de negare inverseazӑ valoarea de adevӑr a expresiei sau a variabilei.

variabila = True
 
# Secvența urmӑtoare va afișa valoarea de adevӑr "False"
print not variabila
 
# Secvența urmӑtoare va afișa valoarea de adevӑr "True"
print not variabila == variabila
 

Ȋn general, declarațiile sunt executate secvențial: prima declarație dintr-o funcție este executatӑ prima, urmatӑ de a doua, și tot așa. Pot exista situații ȋn care este necesarӑ execuția unui bloc de instrucțiuni ȋn repetate rȃnduri. Limbajele de programare oferӑ variate structuri de control ce permit cai pentru execuția unor bucӑți mai complicate de cod.

Buclele permit execuția unor declarații sau unor grupuri de declarații de mai multe ori.

Python oferӑ urmӑtoarele tipuri de bucle/structuri repetitive:

Structura repetitivӑ “for” itereazӑ o secvențӑ datӑ. De exemplu, dorim sa parcurgem o listӑ de nume.

listaDeNume = ["Ana", "Maria", "Ioana", "Irina", "Andreea", "Cristina"]
 
for x in listaDeNume:
    print x

Un lucru atipic ȋn cadrul acestui tip de structurӑ repetitivӑ este faptul cӑ nu este vizibil indicele pasului la care ne aflӑm la un moment dat. Totuși existӑ o metodӑ de a contoriza pașii prin intermediul “funcției enumerate”, dupӑ cum este exemplificat mai jos:

# Alegem o listӑ cu o parte dintre materiile din anul 1
hobbies = [ "Algebra", "Analiza", "PL", "PC", "II", "Grafica", "USO"]
 
 
# Parcurgem aceastӑ listӑ, afișȃnd atȃt indicele la care se gӑsește acestӑ materie ȋn listӑ, cȃt și "valoarea" sa
for index, hobby in enumerate(hobbies):
    print index, hobby
 
# Outputul va arӑta cam așa:
0 Algebra
1 Analiza
2 PL
3 PC
4 II
5 Grafica
6 USO

Un alt utilitar pe care ȋl avem la dispoziție ȋn Python este zip. Acesta ne ajutӑ sӑ parcurgem simultan conținutul a douӑ liste. Fie date douӑ liste cu numere, avȃnd același numӑr de elemente, vom compara valorile aflate pe aceeași poziție, dupӑ cum urmeazӑ:

# Se dau listele urmӑtoare:
 
lista1 = [ 3, 9, 17, 15, 19]
lista2 = [ 2, 4, 30, 24, 3]
 
 
# Vom parcurge conținutul celor douӑ liste și vom compara valorile:
 
for a, b in zip( lista1, lista2 ):
    if a > b:
        print a
    else:
        print b
 
 
# Outputul va arӑta astfel:
 
3
9
30
24
19

Un lucru interesant la Python este cӑ putem aplica condiția de “else”, nu numai condiției “if”, dar și buclei “for”. Ȋn acest caz, ramura “else” va fi executatӑ dupӑ bucla “for”, dar doar dacӑ aceasta din urmӑ nu conține o declarație de oprire de tip “break”.

# Vom declara o listӑ de stringuri care conține fructe
 
listaDeFructe = [ "mar", "para", "ananas", "mango", "banana" ]
 
 
for i in listaDeFructe:
    print i
    if i == "mango":
        print "Nu imi place mango! Salata de fructe esuata..."
        break
else:
    print "Yummy!"
 
# Outputul secvenței de cod de mai sus va fi:
 
mar
para
ananas
mango
Nu imi place mango! Salata de fructe esuata...
 
 
# Dacӑ am executa urmӑtoarea secvețӑ de cod:
 
for i in listaDeFructe:
    print i
    if i == "mango":
        print "Nu imi place mango! Salata de fructe esuata..."
else:
    print "Asta e... O sa mananc si mango pana la urma."
 
 
# Outputul va fi:
 
mar
para
ananas
mango
Nu imi place mango! Salata de fructe esuata...
banana
Asta e... O sa mananc si mango pana la urma.

Structura repetitivӑ “while” se executӑ atȃt timp cȃt condiția indicatӑ este respectatӑ. Este similarӑ unei declarații de tip “if”, ȋnsӑ bucla “while” se va opri ȋn momentul ȋn care condiția enunțatӑ nu va mai fi ȋndeplinitӑ. Cu alte cuvinte, se va verifica “cȃt timp” este valabilӑ condiția respectivӑ, și nu “dacӑ” ea este validӑ. De exemplu, dorim sӑ afișӑm cifrele de la 0 la 9.

count = 0
 
while count < 10:
    print count
    count = count + 1

Un lucru interesant la Python este cӑ putem aplica condiția de “else”, nu numai condiției “if”, dar și buclei “while”, la fel ca și buclei “for”. Diferența dintre cele douӑ este aceea cӑ blocul “else” asociat buclei “while” se va exacuta oricȃnd condiția structurii repetitive va fi evaluatӑ ca fiind falsӑ. Cu alte cuvinte, aceasta se va executa atȃt dacӑ nu se va intra deloc ȋn buclӑ, cȃt și dupӑ ieșirea cu succes din aceasta.

print "Ghiceste numarul meu ales din intervalul [ 1, 10 ]"
 
numarulMeu = 7
numarulTau = 0
 
while numarulTau != numarulMeu:
    numarulTau = int( raw_input("Alege un numar. ") )
else:
    print "Felicitari! Ai ghicit."

Declarația “break” este utilizatӑ pentru a ieși dintr-o structurӑ repetitivӑ; este o alternativӑ la condiția de ieșire. De exemplu, dorim sӑ afișӑm cifrele de la 0 la 9.

count = 0
 
while True:
    print count
    count = count + 1
    if count > 10:
        break

Declarația “continue” este utilizatӑ pentru a sӑri peste un bloc de instrucțiuni. De exemplu, dorim sa afișӑm toate numerele pare din intervalul [0, 20].

number = 0
 
while number < 21:
    if number % 2 == 1
        continue
    print number

Ce sunt funcțiile?

Funcțiile sunt o metodӑ convenabilӑ de partiționare a codului ȋn blocuri organizate ce faciliteazӑ gestionarea acestuia.

Cum se declarӑ funcțiile?

Ȋn Python, funcțiile sunt definite folosind cuvȃntul cheie def, urmat de numele funcției ca denumire pentru blocul de instrucțiuni care urmeazӑ. De exemplu:

def functiaMea():
    print "Bine ati veni la cursul de introducere in informatica!"

De asemenea, o funcție poate primi argumente (variabile trimise ca parametru de cӑtre “apelant” funcției). Mai mult, funcțiile pot returna rezultate. Exemplul de mai jos reprezintӑ o funcție ce primește ca parametri douӑ numere și returneazӑ suma acestora.

def sumaNumerelor( a, b):
    return a + b

Cum se apeleazӑ o funcție?

Spre deosebire de C/C++, ȋn Python nu existӑ un “main”, astfel funcțiile pot fi declarate și apelate oriunde ȋn interiorul programului.

def functiaMea():
    print "Bine ati veni la cursul de introducere in informatica!"    
 
 
# Vom apela funcția declaratӑ anterior. Pentru cӑ funcția nu returneazӑ niciun rezultat, odatӑ apelatӑ va afișa direct ȋn consolӑ mesajul "Bine ati veni la cursul de introducere in informatica!"
 
functiaMea()

def sumaNumerelor( a, b):
    return a + b
 
unu = 13
doi = 12
sum = sumaNumerelor( unu, doi)
 
# Vom apela funcția declaratӑ anterior. Vom afișa rezultatul returnat direct ȋn consolӑ.
 
print sumaNumerelor( unu, doi)
 
# Vom apela funcția declaratӑ anterior. Vom afișa rezultatul reținut anterior in variabila "sum".
 
print sum

Ce sunt clasele? Ce sunt obiectele?

Obiectele sunt o incapsulare de variabile și funcții ȋntr-o singurӑ entitate. Obiectele ȋși procurӑ variabilele și funcțiile din clase. Clasele sunt ȋn esențӑ niște șabloane pentru crearea obiectelor.

Clasele și obiectele sunt o cale de combinare a tot felul de date care se referӑ la un singur lucru ȋntr-un singur loc și o cale de asociere a funcțiilor cu date. Pentru aprofundarea noțiunilor de clasӑ și obiect, puteți consulta urmӑtoarele surse: sursa_1 și sursa_2.

# Un exemplu clasic de clasӑ
 
class ClasaMea:
    var = "hello"
 
    def functie(self):
        print "Hello from the other side!"

Cum se asociazӑ o clasӑ unui obiect?

# Considerȃnd clasa declaratӑ mai sus: 
 
obiectulMeu = ClasaMea()

Acum, variabila “obiectulMeu” reține un obiect al clasei “clasaMea” ce conține atȃt variabilele, cȃt și funcțiile definite ȋn interiorul clasei numite.

Cum se acceseazӑ variabilele unui obiect?

# Considerȃnd clasa declaratӑ mai sus, putem accesa variabila "var", astfel:
 
obiectulMeu.var
 
 
# Cazul general de accesare a unei variabile: className**.**variableName
 
 
# Secvența de mai jos va afișa conținutul variabilei "var" 
 
print obiectulMeu.var

Se pot crea oricȃte obiecte diferite ȋn cadrul aceleiași clase, acestea dobȃndind toate “trӑsӑturile” clasei respective (variabile și funcții). Cu toate acestea, fiecare obiect ȋn parte conține copii independente ale variabilelor definite ȋn interiorul clasei. De pildӑ, daca am defini un alt obiect al clasei “clasaMea”, acesta ar “moșteni” tot ceea ce era deja definit ȋn interiorul clasei respective, ȋnsӑ ele pot fi modificate, fӑrӑ a strica definiția inițialӑ a clasei.

# Considerӑm clasa urmӑtoare:
 
class ClasaMea:
    var = "hello"
 
    def functie(self):
        print "Hello from the other side!" 
 
 
# Alegem douӑ obiecte pentru aceasta:
 
obiectulUnu = ClasaMea()
obiectulDoi = ClasaMea()
 
 
# Modificӑm valoarea variabilei "var" din al doilea obiect
 
obiectulDoi.var = "bye"
 
 
# Acum, putem verifica printr-o simplӑ afișare conținutul fiecӑrui obiect
 
print obiectulUnu.var 
print obiectulDoi.var
 
 
# Outputul va fi:
# hello
# bye

Cum se acceseazӑ funcțiile obiectelor?

Procedeul este similar accesӑrii de variabile: numeleObiectului.numeleFunctiei()

# Considerӑm clasa urmӑtoare:
 
class ClasaMea:
    var = "hello"
 
    def functie(self):
        print "Hello from the other side!" 
 
 
# Declarӑm un obiect aferent clasei
 
obiectulMeu = ClasaMea()
 
 
# Accesӑm funcția din obiect, care va afișa mesajul "Hello from the other side!"
 
obiectulMeu.functie()

Python poate fi utilizat și drept calculator științific, prin multitudinea de funcții pe care le oferӑ. Toate aceste funcții se regӑsesc in biblioteca math. Cȃteva dintre acestea vor fi enunțate mai jos și se va exemplifica modul de apelare.

import math

Funcțiile floor și ceil sunt uzuale ȋn matematicӑ. Funcția floor extrage partea ȋntreagӑ inferioarӑ a numӑrului indicat drept parametru, iar funcția ceil extrage partea ȋntreagӑ superioarӑ a numӑrului indicat drept parametru.

# Cosiderӑm exemplul urmӑtor:
 
n = 96.834
 
 
# Vom apela pe rȃnd cele douӑ funcții, dupӑ cum urmeazӑ:
 
print( math.floor(n) )
print( math.ceil(n) )
 
 
# Outputul va fi urmӑtorul:
 
96
97

Funcția abs este o funcție predefinitӑ și nu trebuie importatӑ din nicio bibliotecӑ auxiliarӑ. Aceasta returneazӑ valoarea absolutӑ a valorii trimise ca parametru.

# Cosiderӑm exemplul urmӑtor:
 
n = 96.834
m = -132
 
 
# Vom apela funcția "abs", dupӑ cum urmeazӑ:
 
print( abs(n) )
print( abs(m) )
 
 
# Outputul va fi urmӑtorul:
 
96.834
132

Funcția round primește unul sau douӑ argumente, cel din urmӑ fiind opțional, și returneazӑ valoarea rotunjitӑ a argumentului dat ca parametru funcției. Primul argument reprezintӑ o valoare ce urmeazӑ a fi prelucratӑ, iar cel de-al doilea argument reprezintӑ precizia cu care va fi rotunjitӑ valoarea respectiva, adicӑ numӑrul de zecimale de care se va ține cont.

# Cosiderӑm exemplul urmӑtor:
 
n = 243.23456
 
 
# Vom apela funcția "round", dupӑ cum urmeazӑ:
 
print( round(n) )
print( round( n, 0) )
print( round( n, 1) )
print( round( n, 2) )
print( round( n, 3) )
 
 
# Outputul va fi urmӑtorul:
 
243
243.0
243.2
243.23
243.235

Funcția sum este utilizatӑ la calculul de sume.

# Cosiderӑm exemplul urmӑtor:
 
valori = [ 0.234, 1, 2.34, 5, 89, 0.666]
 
 
# Vom apela funcția "sum", dupӑ cum urmeazӑ:
 
print( sum( valori ) )
 
 
# Outputul va fi urmӑtorul:
 
98.24

Funcția pow ridicӑ la o anumitӑ putere datӑ, o anumitӑ valoare precizatӑ. Funcția primește doi parametri: valoarea și puterea. Spre deosebire de operatorul de ridicare la putere, rezultatul returnat de funcție este mereu un numӑr real.

# Cosiderӑm exemplul urmӑtor:
 
a = 2
b = 5
 
 
# Vom apela funcția "pow", dupӑ cum urmeazӑ:
 
print( math.pow( a, b ) )
 
 
# Outputul va fi urmӑtorul:
 
32.0

Funcția sqrt extrage radicalul unui numӑr real, returnȃnd tot un numӑr real.

# Cosiderӑm exemplul urmӑtor:
 
a = 15
 
 
# Vom apela funcția "sqrt", dupӑ cum urmeazӑ:
 
print( math.sqrt( a, b ) )
 
 
# Outputul va fi urmӑtorul:
 
3.872983346207417

1. [15p] Creați cȃte o variabilă de tipul: string, int și float, după cum urmează:
   • Variabila de tip int va reține valoarea 20.
   • Variabila de tip float va reține valoarea 10.
   • Variabila de tip string reține valoarea “python”.
2. [15p] Utilizȃnd funcția type, determinați tipul următoarelor variabile:
   • restanta = 0
   • notaFinala = 10.0
   • laborator = “Introducere in informatica”
3. [15p] Creați o listă cu numele fetelor din grupa voastră (numele nu trebuie să fie distincte). Respectȃnd ordinea cerințelor rezolvați următoarele cerințe:
   • Sortați lista de nume.
   • Utilizȃnd o listă auxiliară, determinați numărul de apariții al fiecărui nume.
   • Determinați numele care apare de cele mai multe ori ȋn lista inițială.
   • Determinați numele care apare de cele mai puține ori ȋn lista inițială.
   • Revenind la lista inițială de nume, inversați ordinea elementelor.
4. [15p] Creați cu ajutorul unui dicționar o bază de date ȋn care să rețineți numerele de telefon ale colegilor de grupă.
5. [20p] Scrieți o secvență de cod care să afișeze ȋn consolă toate numerele pare divizibile cu 7 din intervalul [0, 3463]. Hint: utilizați funcția xrange. Ajustați codul astfel ȋncȃt la apariția primului multiplu al lui 666, algoritmul să se oprească.
6. [20p] Creați o clasă denumită “FamiliaMea”, iar obiectele asociate acesteia să corespundă membrilor familiei voastre. Clasa va conține variabilele “nume”, “prenume”, “vȃrstă”, o listă de pasiuni, denumită “pasiuni” și o funcție denumită “motto”, care să afișeze motto-ul familiei voastre.