CURS 4

Tkinter.
Biblioteca Pygame
POO
 MODULE DIN BIBLIOTECA STANDARD
 Math contine functii si constante
matematice: sqrt(), pow(), factorial(),
sin(), cos(), tan(),pi, e, tau etc..
 Random contine functii pentru
generarea de numere/secvente pseudo-
aleatoare pentru diferite distributii:
randint (), choice(lista/secventa),
shuffle(lista/secventa), sample(lista,
nr_componente).
 Time contine functii legate de timp:
strftime(), gmtime().
https://docs.python.org/3/library/math.htm
l?highlight=math#module-math
TURTLE

 Contine functii care permit realizarea de

elemente grafice simple, miscare, controlul
ecranului, culori, vizibilitate.
from turtle import *
while True:
forward(200)
left(170)
if abs(pos()) < 1:
break
 https://docs.python.org/3/library/turtle.html?highl
ight=turtle#module-turtle
 Exemplu cu eveniment.
TKINTER
Contine functii care permit realizarea de elemente
grafice si interactiune.
Pentru a realiza astfel de aplicatii:
 Se importa modulul Tkinter.
 Se creeaza fereastra principală a aplicației.
 Se adauga una sau mai multe elemente grafice.
 Se adauga evenimente de tastatura sau mouse.
TKINTER – EXEMPLUL 1
import tkinter
fr = tkinter.Tk()
panza = tkinter.Canvas(fr, height = 300, width = 300)
panza.pack()
cap = panza.create_oval(100, 100, 200, 200, outline =
'black', fill = 'yellow')
ochi1 = panza.create_oval(120, 120, 140, 140, outline =
'black', fill = 'white')
ochi2 = panza.create_oval(160, 120, 180, 140, outline =
'black', fill = 'white')
gura = panza.create_oval(130, 160, 170, 170, outline =
'black', fill = 'white')
TKINTER – EXEMPLUL 2
import tkinter
fr = tkinter.Tk()
panza = tkinter.Canvas(fr, height = 300, widt = 300)
panza.pack()
cerc = panza.create_oval(10, 10, 30, 30, outline = 'black', fill = 'red')
def muta(event):
Funcția mută execută mutarea
tasta = event.keysym
cercului desenat în funcție de
if tasta == "Up": tasta acționată: Up (mută sus),
panza.move(cerc,0,-1) Down (mută jos), Left (mută la
elif tasta =="Down": stânga), Right (mută la dreapta).
panza.move(cerc,0,1) event.keysym - detectează tasta
elif tasta =="Right": acționată.
panza.move(cerc,1,0)
elif tasta =="Left":
Face legătura dintre tasta acționată
panza.move(cerc,-1,0) și funcția mută(). Când este
panza.bind_all('<Key>', muta) acționată o tasta acesta apelează
funcția.
 CREAREA UNEI APLICATII
 Importul bibliotecii: import pygame
 Inițializarea modulelor importate: pygame.init()
 Desenarea ferestrei aplicației: screen =
pygame.display.set_mode((ct1, ct2))
 Bucla de execuție (principală):
executare= True
while executare :
# procesare evenimente utilizator
# verificare eveniment de ieșire
if eveniment_iesire():
executare = False
# modificare stare curentă a jocului
# desenare stare curentă a jocului modificată la pasul anterior
pygame.display.flip()
pygame.quit()
POO – NOTIUNI DE BAZA
 POO reprezintă o metodă de proiectare şi dezvoltare a programelor ce
presupune abstractizarea datelor prin combinarea acestora cu funcții
(cunoscute ca metode) într-o singură entitate numită obiect.
 Python este un limbaj de programare orientat obiect.
 O clasă este ca un constructor de obiecte sau un "model" pentru
crearea obiectelor. O clasă creează un nou tip de date, iar obiectele
sunt instanțe ale unei clase.
Principii de bază în programarea orientată pe obiecte:

Abstractizarea Încapsularea Moștenirea Polimorfismul

Gruparea Combinarea Procesul prin Posibilitatea
datelor și datelor și care o clasă de a rescrie
metodelor metodelor și moștenește metodele unei
specifice unui definirea datele și clase derivate.
obiect. modului de metodele
acces la date altei clase.
(ascunderea
datelor).
CLASA
Forma generală:
class NumeClasa:
<statement 1>
….
<statement n>,

unde statement i reprezintă definiții de funcții (metode) sau

alte instrucțiuni. Când se introduce o definiție de clasă, se
creează un nou spațiu de nume și se utilizează ca domeniu de
aplicare local.
Clasele acceptă două tipuri de operații:
 accesarea atributelor și metodelor:
NumeClasa.NumeAtribut, NumeClasa.NumeMetodă(..)
 instanțiere (crearea de obiecte): NumeObiect =
NumeClasa(..).
 OBIECT
 o colecție de date (atribute) și funcții (metode) care operează cu aceste
date. Obiectul este o instanță a unei clase. Pentru a crea un obiect se
folosește construcția:
NumeObiect = NumeClasă(), obiectul nou creat are tipul clasei asociate
 Fiecare obiect are propriul spațiu de nume care conține datele și
metodele.
La nivelul clasei se poate defini metoda specială __init__() care este
automat apelată la momentul instanțierii și care inițializează atributele
obiectului. Forma generală:
class NumeClasa:
def __init__(self):
self.atribut= valoare
 self se folosește pentru a referi instanța curentă. Metoda __init__ poate
avea și alți parametrii în afară de self. Clasa poate avea un singur
constructor, pentru a simula mai mulți contructori se folosesc parametri
default.
Un obiect poate fi șters: del NumeObiect.
ATRIBUTE
 Datele înglobate în clase poartă denumirea de atribute sau
câmpuri. Ele pot fi:
atribute ale obiectului (instanței) – valorile sunt unice
pentru fiecare obiect (instanță). Se pot accesa prin construcția:
NumeObiect.NumeAtribut
 atribute de clasă (statice) – valoarea este comună
tuturor obiectelor clasei (instanțelor clasei). Se pot accesa
prin construcția: NumeClasa.NumeAtribut sau
NumeObiect.NumeAtribut (după instanțiere).
 Programatorul poate să stabilească modalitatea de accesare a
datelor din afara clasei. Astfel atributele pot fi publice (pot fi
accesate din afara clasei) sau private (nu pot fi accesate decât
prin intermediul metodelor).
 Atribute private
class student: class student:
School='Harvard'
def __init__(self, num,v,m):
self.__name = num
self.__age = v
self.__message = m
def __getname__(self):
return self.__name
def __getage__(self):
return self.__age
def __getmessage__(self):
return self.__message
Atribute publice
School= 'Harvard '
def name(self, num):
self.name = num
print('Name: ',self.name)
def age(self, v):
self.age = v
print('Age:', self.age)
def message(self, mess):
return mess
 METODE
 funcții definite în cadrul clasei care operează cu valorile atributelor unei
instanțe.
Se pot defini:
- metode de clasă (care nu operează cu instanța), accesarea lor se face
prin constucția: NumeClasa.NumeMetodă(). Sunt metode statice pentru
a marca acest lucru se folosește decoratorul @staticmethod.
- metode ale instanței clasei accesarea lor se face prin constucția:
NumeObiect.NumeMetodă()
Metodele instanței au ca prin argument self, obiectul curent. Denumirea
este o convenție se poate folosi si altă denumire.
Clasele pot avea metode de tip constructor (__init__()) și destructor
__del__()).
De asemenea, se pot defini metode speciale pentru:
supraîncărcarea operatorilor: obiect.__add__(self, other),
obiect.__sub__(self, other), obiect.__mul__(self,other)
obiect.__mod__(self, other) etc.
 conversii ale obiectelor la diferite tipuri de date:obiect.__int__(self),
obiect.__str__(self), obiect.__float__(self))
 EXEMPLU – CLASA SI INSTANTIERE
class dreptunghi:
nr = 0
def __init__(self, l, L):
self.lat = l
self.lung = L
dreptunghi.nr+=1
def aria(self):
return self.lat*self.lung
def perimetrul(self):
return 2*(self.lat+self.lung)
@staticmethod
def nr_instante():
return dreptunghi.nr
f = dreptunghi(10,20)
g = dreptunghi(15,25)
nrins= dreptunghi.nr_instante()
print('Numarul de instante
create: ', nrins)
print('Aria si perimetrul
instantei f: ', f.aria(),
f.perimetrul())
print('Aria si perimetrul
instantei g: ', g.aria(),
g.perimetrul())
class rational:
def __init__(self, a, b):
self.__nr = a
self.__nm = b
def getnr(self):
return self.__nr
def getnm(self):
return self.__nm
def setnr(self, a):
self.__nr = a
def setnm(self,b):
self.__nm = b

fr = rational(2,5)
print(fr.__nr)
print(fr.getnr())
fr.__nr = 10
fr.setnr(10)
print(fr.getnr())