Sunteți pe pagina 1din 99

CUPRINS / СОДЕРЖАНИЕ

CUPRINS .....................................................................................................................................1

------------------------------------------------------ATESTARE ~ 1 ~ --------------------------------------------------------

Tema 1. Operații matematice de bază. Variabile .........................................................................


Laboratuarul nr. 1 ...............................................................................................................2-9
Tema 2. Funcțiile print(), input(). Șiruri (formatare).................................................................9-11
Laboratuarul nr. 2...................................................................................................................11-16
Tema 3. Liste dictionare tuple seturi........................................................................................16-19
Laboratuarul nr. 3...................................................................................................................19-31
Tema 4. Expresii......................................................................................................................31-35
Tema 5.Funcții. Expresia Lambda. Introducere în bibliotecile NumPy și MatPlotLib.................35-40
Tema 6. Gestionarea fișierelor în Python.................................................................................40-45
Noutatile Python 3.10..(Engleza/Romana)..............................................................................45-52
MatPlotLib 5 Exemple.............................................................................................................53-57

------------------------------------------------------ATESTARE ~ 2 ~ --------------------------------------------------------

Laboratuarul nr. 4..................................................................................................................58-70


Laboratuarul nr. 5..................................................................................................................70-76
Modulul TURTLE....................................................................................................................77-82
Calculator in TKINTER............................................................................................................82-86
----------------------------------------------------------EXAMEN -------------------------------------------------------------
Laboratuarul nr. 6..................................................................................................................87-92
UTM LOGO................................................................................................................................93
3 Drapele..............................................................................................................................93-95
3 Drapele..............................................................................................................................96-98
Laboratuarul nr. 1
1.
a. Care va fi răspunsul obținut după rularea codului în fereastra de program IDLE:

Răspuns

b. Care va fi răspunsul obținut după rularea codului în fereastra de program IDLE:

Răspuns

2.

a. Care va fi răspunsul obținut după rularea codului în fereastra de program IDLE:

b. 2

2
Răspuns

c. Care va fi răspunsul obținut după rularea codului în fereastra de program IDLE:

Răspuns

d.Care va fi răspunsul obținut după rularea codului în fereastra de program IDLE:

Răspuns

e. Care va fi răspunsul obținut după rularea codului în fereastra de program IDLE:

Răspuns

3
f. Care va fi răspunsul obținut după rularea codului în fereastra de program IDLE:

Răspuns

3.
Scrieți codul pentru a determina aria și perimetrul unui dreptunghi dacă știm că lungimea este a =10 cm, iar lățimea b
= 4 cm. Aria: A = a x b iar Perimetrul: P = 2(a + b).

Răspuns

4
4.
Care va fi răspunsul obținut după rularea codului în fereastra de program IDLE:

Răspuns

5.
Scrieți un cod în care să verificați daca un număr este par sau impar.
Răspuns

6.
Scrieți un cod în care în primă fază să ridicați un număr la pătrar (exponentul 2) după care să extrage- ți rădăcina
pătrată din el ca să obțineți la răspuns numărul inițial.
Răspuns

5
7.
Scrieți codul pentru a determina Aria: A = 6a2 și Volumul: V=a3 unui cub cu latura a=20 cm.

Răspuns

8.
Scrieți un cod în 3 moduri diferite care să ne dea rezultatul când baza este 4 și exponentul este 3, 43=?
Răspuns

6
9.
Scrieți un cod care să rezolve următoarea ecuație: z = |x – y| * (x + y) dacă știm că x = 4,iar y = 6.
Răspuns

10.
Numele variabilelor. În acest exercițiu vom învăța să dăm nume corecte variabilelor. Reguli de bază pentru numele
variabilelor în Python:
 numele unei variabile poate să înceapă cu literă sau simbolul „_”. Exemple:
continent_ sau _continent
 numele unei variabile poate să conțină litere, cifre și simbolul „_”. Exemple:
martie_13 sau martie13
 numele unei variabile trebuie să conțină aceleași litere pe parcursul întregului cod: Martie2020 și martie2020
vor fi două variabile diferite în Python
 nu este permis de folosit „cuvinte-cheie” în numele unei variabile. Exemple de „cuvinte-cheie”:
 False, def, if, raise, None, del, import, return, True, elif, in, try, and, else, is, while, as, except, lambda, with,
assert, finally, nonlocal, yield, break, for, not.
 Analizați codul de mai jos, copiați-l în fereastra de program IDLE și încercați să rulați acest cod. O să apară
multe erori, sarcina dumneavoastră este să eliminați din cod și din funcția print ( ) toate variabilele care sunt
greșite astfel încât în final codul să poată fi rulat.

7
Răspuns

11.
Scrieți un cod care să transforme gradele Fahrenheit în grade Celsius și invers. Formula de transformare este: F =
9/5*C+32

Răspuns

8
12.
În ultimul exercițiu trebuie să transformați MPH (mile pe oră) în KMH (kilometri pe oră) și invers. Formulele de calcul
vor fi: MPH = 0.6214 * KMH și KMH = 1.6093 * MPH

Răspuns

TEMA 2. FUNCȚİİLE PRİNT(), İNPUT(). ȘİRURİ (FORMATARE)

1.

Răspuns

2.
6.

Răspuns

3.
7.

Răspuns
4.

8.
5.

9
15.

Răspuns

9.
16.

Răspuns

17.
10.

Răspuns

11. 18.

Răspuns

19.
12.

Răspuns

Răspuns

20.

13.

Răspuns

14.

10
21.

22.

Răspuns

Răspuns

Laboratuarul nr. 2
1.
Acest exercițiu l-am rezolvat și în capitolul 1 la Ex1_12 când am transformat MPH în KMH. Acum ne
propunem același lucru doar că valoare care vrem s-o transformăm să fie introdusă de utilizator, prin urmare
în codul nostru trebuie să fie prezentă și funcția input ( ). Scrieți codul astfel încât răspunsul obținut să
arate în felul următor:

x = int(input("Care este viteza in km/h?"))


print("Viteza exprimata in km/h este egala cu",x,"KM/H")
mph = x / 1.609344
print("Viteza exprimata in mph este egala cu?",round(mph,3),"MPH")

2.
Studiu individual. În acest exercițiu la răspuns trebuie să obținem calendarul pentru această lună. Drept
exemplu vom lua luna septembrie din anul 2021. Pentru a obține acest rezultat aveți nevoie de următorul
modul calendar, care trebuie importat în Python (Sugestie: calendar.month(anul, luna). Cum trebuie
să arate codul?, pentru ca la rezultat să obținem:

import calendar

print(calendar.month(2021, 9))

11
3.
Exercițiul curent este continuarea celui precedent, trebuie să modificăm codul astfel încât anul și luna
care ne interesează să fie introduse de către utilizator. Să presupunem că dorim să aflăm care a fost ziua
săptămânii în care ne-am născut. Eu am ales în acest exemplu anul și luna mea de naștere și din calendarul
apărut pot să aflu această informație.
Răspunsul trebuie să arate în felul următor:

import calendar
x = int(input("Care este anul care va intereseaza? [ex. 2007]"))
y = int(input("Care este luna care va intereseaza? [ex. 04]"))
print(calendar.month(x, y))
4.
În acest exercițiu simplu se cere ca utilizatorul să introducă variabilele a și b, iar la răspuns să obținem
rezultatul de la operațiile de adunare, scădere, înmulțire și împărțire. Rezultatul trebuie să arate în felul
următor (încercați să folosiți metode diferite de formatare a șirurilor):

a = int(input("Care este valoarea pentru nr. a? a ="))


b = int(input("Care este valoarea pentru nr. b? b ="))
print("\na + b = ", a+b, "a - b = ", a-b)
print("\na * b = ", a*b, "a : b = ", a/b)

5.
În acest exercițiu trebuie să cerem utilizatorului un număr oarecare, iar la răspuns să obținem doar
numărul introdus de utilizator, pătratul acestui număr și cubul acestui număr. Răspunsul trebuie să arate în
felul următor:

x = int(input("Care este valoarea pentru nr. a? a ="))


print("\n", x, x*x, x*x*x)

12
6.
În acest exercițiu trebuie să cerem de la utilizator care este temperatura în grade Celsius, iar la răspuns
să obținem cât este temperatura în grade Celsius și cât este această temperatură în grade Fahrenheit. Dacă ați
uitat relațiile de transformare revedeți Ex1_11 din Capitolul 1. Răspunsul trebuie să arate în felul următor:

x = int(input("Care este temperatura in grade Celsius?"))


f = (x*1.8) + 32
print("Temperatura in grade Celsius este", x, "grade C")
print("Temperatura in grade Fahrenheit este", round(f,3),"grade F")
7.
În acest exercițiu trebuie să scriem un cod care să ceară de la utilizator lungimea și lățimea unui
dreptunghi, și programul să calculeze aria și perimetrul dreptunghiului cu aceste valori. Răspunsul trebuie să
arate în felul următor:

print("*" * 12,"PROGRAM", "*" * 12)


print(" " * 7,"ARIA & PERIMETRUL")
print(" " * 10,"DREPTUNGHI")
a = int(input("Care este lungimea dreptungiului?"))
p = int(input("Care este latimea dreptungiului?"))
print("\nARIA =", a*p, ",PERIMETRUL",((a*2)+(p*2)))

8.
În acest exercițiu va trebui să scriem un cod care să ceară de la utilizator raza unui cerc și programul să
calculeze diametrul, lungimea circumferinței și aria cercului: D = 2R; L = 2𝜋𝜋R; A = 𝜋𝜋𝑅𝑅 . 2

Ca să nu ne complicăm putem aproxima 𝜋𝜋 ≅ 3.14. Dar in Python avem la dispoziție modulul math de
care trebuie să vă folosiți atunci când veți scrie codul pentru acest exercițiu.
Răspunsul trebuie să arate în felul următor:

import math
print("|" * 12,"PROGRAM", "|" * 12)
print(" " * 13,"CERCUL")
print(" " * 9,"LUNGIME & ARIA")
R = int(input("Care este raza cercului?"))
dia = 2*R
l = 2*math.pi*R
a = math.pi*(R*R)
print("\nDiametrul cercului este: ", dia)
print("Lungimea cercului este: ", l)
print("Aria cercului este", a)

13
9.
Analizați cu atenție codul și încercați să depistați care sunt erorile comise. La rularea acestui cod vor
apărea mesaje de eroare. Sarcina dumneavoastră este să înlăturați greșelile depistate astfel încât codul să
ruleze fără erori.

nume = "Andrei"
varsta = 37
angajat = True
print(nume, varsta, angajat)

10.
În acest exercițiu se cere să verificați corectitudinea codului și dacă depistați erori să le eliminați astfel
încât codul să ruleze fără erori.

x = 20
y = 4
print(x - y)

11.
În acest exercițiu trebuie să îl întrebați pe utilizator Ce planuri ai pentru diseară? cu ajutorul
funcției input ( ). Răspunsul tastat de utilizator trebuie să îl prezentați sub formă de listă cu ajutorul
comenzii split ( ). Un exemplu de răspuns:

x = input("Ce planuri ai pentru diseara?:").split()


print("Utilizatorul a introdus cuvintele:", x)
12.
În acest exercițiu trebuie să îl întrebați pe utilizator Care este mâncarea ta preferată? cu ajutorul
funcției input ( ). Răspunsul tastat de utilizator trebuie să îl prezentați doar cu litere majuscule cu ajutorul
comenzii upper ( ). Un exemplu de răspuns:

x = input("Care este mancarea ta preferata?:").upper()


print("Mancarea ta preferata este:", x)

13.
În acest exercițiu trebuie să îi cereți utilizatorului să introducă adresa sa de e-mail (în format
prenume.nume@utm.md), iar la răspuns să fie afișat doar numele său (sau ce este scris înaintea simbolului
@). Un exemplu de răspuns:

14
x=input("Introdu adresa de e-mail ?: ").split("@",1)
y=x[0]
print(y)
14.
Vom complica exemplul precedent Ex2_13. La fel vom cere utilizatorului să introducă adresa sa de email
(în format prenume.nume@utm.md) dar la răspuns să obținem mesajul Salut Prenume Nume. După cum
observați prenumele și numele sunt tastate cu litere mici, noi trebuie să obținem răspunsul cu prima literă
majusculă de la prenume și nume. Un exemplu de răspuns:

x=input("Introdu adresa de e-mail ?: ").split("@",1)


y=x[0].split(".",1)
print("Salut {} {}".format(y[0].capitalize(),y[1].capitalize()))

15.
În acest exercițiu cerem de la utilizator să introducă prenumele, numele și vârsta cu ajutorul funcției
input ( ). Răspunsul trebuie să arate în felul următor:

x=input("Introdu prenumele: ")


y=input("Introdu nume: ")
z=input("Introdu varsta: ")
print("Salut {} {} ai implinit {} ani!".format(x,y,z))

16.
În acest exercițiu trebuie să îi cereți utilizatorului să introducă adresa sa de e-mail (în format
prenume.nume@utm.md), iar la răspuns trebuie să obținem din câte caractere este format numele și
prenumele din adresa de e-mail. Sugestie: trebuie să folosiți comanda len ( ). Un exemplu de răspuns:

x=input("Introdu adresa de e-mail ?: ").split("@",1)


y=x[0]
c=len(y)
print("Prenumele si numele din adresa contin {} carectere".format(c))

15
17.
În acest exemplu să presupunem că avem definită variabila scriitor = 'Liviu Rebreanu'. La răspuns
vrem să apară doar prenumele Liviu. Din cele studiate până în prezent putem obține acest răspuns în două
moduri. Un exemplu de răspuns:

scriitor="Liviu Rebreanu"
x=scriitor.split(" ",1)
y=x[0]
print(y)

TEMA 3. LİSTE DİCTİONARE TUPLE SETURİ

7.
1.

Răspuns

Răspuns
8.

Răspuns
2.

3.

Răspuns
9.

4.
Răspuns

Răspuns
10.

5.
11.

6. Răspuns

Răspuns
12.

16
18.

Răspuns

13. Răspuns

19.

Răspuns

Răspuns

14.

20.

Răspuns
Răspuns

15.
21.

Răspuns

22.
Răspuns

16.
Răspuns

23.
Răspuns

17.

Răspuns

17
24.

Răspuns Răspuns

25. 31.

Răspuns

26. Răspuns

32.

Răspuns

27.
Răspuns

33.

Răspuns

28.

34.

Răspuns

Răspuns

29.

35.
Răspuns

30.

18
36.

Răspuns

LAB 3

1.
Dacă avem lista nume = ['Ion', 'Olga', 'Vicu', 'Ana', 'Eva', 'Vlad', 'Stas']. Scrieți codul care după rulare să ne
dea următorul răspuns:

Răspuns
nume=['Ion','Olga','Vicu','Ana','Eva','Vlad','Stas']
print(nume[0])
print(nume[1])
print(nume[-1])

Ion
Olga
Stas

2.
Dacă avem lista nume = ['Ion', 'Olga', 'Vicu', 'Ana', 'Eva', 'Vlad', 'Stas']. Scrieți codul care după rulare să ne
dea următorul răspuns:

Răspuns
nume=['Ion','Olga','Vicu','Ana','Eva','Vlad','Stas']
print("['",nume[0],"','",nume[1],"','",nume[-1],"']")
[' Ion ',' Olga ',' Stas ']

3.
Dacă avem lista nume = ['Ion', 'Olga', 'Vicu', 'Ana', 'Eva', 'Vlad', 'Stas']. Scrieți codul care după rulare să ne
dea următorul răspuns:

nume=['Ion','Olga','Vicu','Ana','Eva','Vlad','Stas']
print(nume)

Răspuns
['Ion', 'Olga', 'Vicu', 'Ana', 'Eva', 'Vlad', 'Stas']

19
nume=['Ion','Olga','Vicu','Ana','Eva','Vlad','Stas']
print(nume[1:4])

Răspuns
['Olga', 'Vicu', 'Ana']

nume=['Ion','Olga','Vicu','Ana','Eva','Vlad','Stas']
print(nume[:3])

Răspuns
['Ion', 'Olga', 'Vicu']

nume=['Ion','Olga','Vicu','Ana','Eva','Vlad','Stas']
print(nume[-3: ])

Răspuns

['Eva', 'Vlad', 'Stas']

nume=['Ion','Olga','Vicu','Ana','Eva','Vlad','Stas']
print(nume[ : :2])

Răspuns
['Ion', 'Vicu', 'Eva', 'Stas']

4.
Dacă avem lista lista_mea = ['Vera', ['Ion', 'Vlad', 'Petru'], 'Ana', 'Ala']. Scrieți codul care după rulare să ne
dea următorul răspuns:

lista_mea=['Vera',['Ion','Vlad','Petru'],'Ana','Ala']
print(lista_mea[1][2])

Răspuns
Petru

20
lista_mea=['Vera',['Ion','Vlad','Petru'],'Ana','Ala']
print(lista_mea[1])

Răspuns
['Ion', 'Vlad', 'Petru']

lista_mea=['Vera',['Ion','Vlad','Petru'],'Ana','Ala']
print(lista_mea[-1])

Răspuns

Ala

5.
Dacă avem lista lista_mea = ['Vera', ['Ion', 'Vlad', 'Petru'], 'Ana', 'Ala']. Scrieți codul care după rulare să ne
dea următorul răspuns:
a) Să obținem lungimea listei (numărul de elemente din listă) cu ajutorul, cu ajutorul funcției len();
lista_mea=['Vera',['Ion','Vlad','Petru'],'Ana','Ala']
x=len(lista_mea)
print(x)

Răspuns
4

b) Să adăugăm elementul 'Iulian' la sfârșitul listei. Răspunsul va arăta în felul următor:

lista_mea=['Vera',['Ion','Vlad','Petru'],'Ana','Ala']
lista_mea.append('Iulian')
print(lista_mea)

Răspuns
['Vera', ['Ion', 'Vlad', 'Petru'], 'Ana', 'Ala', 'Iulian']

c) Să adăugăm elementul 'Iulian' la începutul listei. Răspunsul va arăta în felul următor:

lista_mea=['Vera',['Ion','Vlad','Petru'],'Ana','Ala']
lista_mea.insert(0,'Iulian')
print(lista_mea)

Răspuns
['Iulian', 'Vera', ['Ion', 'Vlad', 'Petru'], 'Ana', 'Ala']

6.
Dacă avem lista lista_mea = ['Vera', ['Ion', 'Vlad', 'Petru'], 'Ana', 'Ala']. Scrieți codul în 3 moduri diferite
care după rulare să elimine elementul 'Ana' din listă. După rulare trebuie să obținem următorul răspuns:

Răspuns

21
['Vera', ['Ion', 'Vlad', 'Petru'], 'Ala']
a.
lista_mea=['Vera',['Ion','Vlad','Petru'],'Ana','Ala']
lista_mea.remove('Ana')
print(lista_mea)

b.
lista_mea=['Vera',['Ion','Vlad','Petru'],'Ana','Ala']
lista_mea.pop(-2)
print(lista_mea)

c.
lista_mea=['Vera',['Ion','Vlad','Petru'],'Ana','Ala']
del lista_mea [-2]
print(lista_mea)

7.
Dacă avem lista my_list = [77, 11, 22, 99, 33, 55]. Scrieți un cod care la răspuns să ne dea această listă
aranjată în ordine crescătoare, descrescătoare și inversată. Folosiți .sort() .reverse() și .sort(reverse =
True).
my_list=[77,11,22,99,33,55]
print(my_list)
my_list.reverse()
print(my_list)
my_list.sort()
print(my_list)
my_list.sort(reverse=True)
print(my_list)

Răspuns
[77, 11, 22, 99, 33, 55]
[55, 33, 99, 22, 11, 77]
[11, 22, 33, 55, 77, 99]
[99, 77, 55, 33, 22, 11]

8.
Dacă avem lista old_list = [[22, 44, 66], [11, 33, 55], [20, 30, 40]]. Scrieți un cod care să creeze o nouă listă
new_list care să cuprindă doar ultimul element din fiecare sub-listă, în cazul nostru [66, 55, 40]
old_list=[[22,44,66],[11,33,55],[20,30,40]]
new_list=[]
new_list.insert(0,old_list[0][2])
new_list.insert(1,old_list[1][2])
new_list.insert(2,old_list[2][2])
print(new_list)

22
Răspuns
[66, 55, 40]

9.
Dacă avem lista_mea = [1,2,3,4,5,6,7,8,9,10]. Scrieți un cod care să aranjeze într-un mod aleatoriu
elementele din listă. Studiu individual, ca sugestie trebuie să folosim (importăm) modulul random și să
folosim una din comenzile .randrange()
import random
lista_mea = random.sample(range(1, 11), 10)
print(lista_mea)
lista_mea.sort()
print(lista_mea)

Răspuns
[7, 10, 1, 4, 5, 3, 6, 9, 8, 2]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

10.
Trebuie să creați o listă care să conțină numele celor mai buni 5 prieteni, după care să aranjăm aceste
nume în ordine alfabetică.
lista_mea = ['Ana','Corina','Zafer','Andrei','Dani']
lista_mea.sort()
print(lista_mea)

Răspuns

['Ana', 'Andrei', 'Corina', 'Dani', 'Zafer']

11.
Trebuie să creați un dicționar care să cuprindă numele a trei prieteni (la cheie) și vârsta acestora (la
valoare). La răspuns trebuie să obținem doar vârsta prietenului celui de al doilea prieten din dicționar.
lista_mea = {'Ana':10,'Corina':15,'Zafer':16}
da = list(lista_mea.values())
print(da[1])

Răspuns
15

12.
Folosind dicționarul de la Ex3_11 trebuie să obținem la răspuns media vârstei celor trei prieteni.

lista_mea = {'Ana':10,'Corina':15,'Zafer':16}
da = list(lista_mea.values())
print((da[0]+da[1]+da[2])/3)

Răspuns
13.666666666666666

23
13.
Folosind dicționarul de la Ex_12 trebuie să mai adăugați 2 prieteni (la cheie) și vârsta lor (la valoare) după
care să determinați media vârstei celor 5 prieteni.
lista_mea = {'Ana':10,'Corina':15,'Zafer':16}
lista_mea['Boran']=16
lista_mea['Daniela']=16
da = list(lista_mea.values())
print((da[0]+da[1]+da[2])+da[3]+da[4]/5)

Răspuns
60.2

14.
Să presupunem că avem următorul dicționar. Continuați codul astfel încât la răspuns să obținem produsul
celor trei valori ale cheilor din dicționar.

culori = {'Verse':3,'Alb':4, 'Maro':5}


c = list(culori.values())
print((c[0]+c[1]+c[2])/3)

Răspuns

4.0

student_note =[ {'student_nr':1,'fizica':5, 'mate':7,'chimia':6},


{'student_nr':2,'fizica':8, 'mate':10,'chimia':6},
{'student_nr':3,'fizica':6, 'mate':7,'chimia':8}]
media1=sum(student_note[0].values())
x=(media1-1)/3
media2=sum(student_note[1].values())
y=(media2-2)/3
media3=sum(student_note[2].values())
z=(media3-3)/3
print(round(x,2))
print(round(y,2))
print(round(z,2))

Răspuns
6.0
8.0
7.0

15.
Să presupunem că avem următoarea listă:

24
După cum se observă lista noastră are 3 elemente care sunt dicționare. Trebuie să continuăm codul astfel
ca la răspuns să obținem o nouă listă în care elementele sunt dicționare care ne arată media la cele trei
discipline pentru fiecare student.
student_note = [
{"student_nr": 1, "fizica": 5, "mate": 7},
{"student_nr": 2, "fizica": 8, "mate": 10},
{"student_nr": 3, "fizica": 6, "mate": 7},
]
media1 = sum(student_note[0].values())
x = (media1 - 1) / 2
media2 = sum(student_note[1].values())
y = (media2 - 2) / 2
media3 = sum(student_note[2].values())
z = (media3 - 3) / 2
print(round(x, 2))
print(round(y, 2))
print(round(z, 2))
Răspuns
16.
Să presupunem că avem următoarea listă:

Trebuie să scriem un cod astfel încât în fiecare element din listă (fiecare dicționar) să mai apară un
element (cheie: valoare) care să conțină media și valoarea numerică a acestei medii.
student_note =[ {'student_nr':1,'fizica':5, 'mate':7},
{'student_nr':2,'fizica':8, 'mate':10},
{'student_nr':3,'fizica':6, 'mate':7}]
media1=sum(student_note[0].values())
x=(media1-1)/2
media2=sum(student_note[1].values())
y=(media2-2)/2
media3=sum(student_note[2].values())
z=(media3-3)/2
student_note[0].update( {'Media':x} )
student_note[1].update( {'Media':y} )
student_note[2].update( {'Media':z} )
print(student_note)

Răspuns
[{'student_nr': 1, 'fizica': 5, 'mate': 7, 'Media': 6.0},
{'student_nr': 2, 'fizica': 8, 'mate': 10, 'Media': 9.0},
{'student_nr': 3, 'fizica': 6, 'mate': 7, 'Media': 6.5}]

17.

25
my_dict = {'C1': [2,4,6], 'C2': [3,5,7]}

my_dict['C1'] = [my_dict['C1'][0]**2, my_dict['C1'][1]**2, my_dict['C1'][2]**2]


my_dict['C2'] = [my_dict['C2'][0]**2, my_dict['C2'][1]**2, my_dict['C2'][2]**2]
print(my_dict)
Răspuns
{'C1': [4, 16, 36], 'C2': [9, 25, 49]}

18.

salariu = {'Alex': 27, 'Petru': 29, 'Ion': 30}

nume = list(salariu.keys())
salariul = list(salariu.values())
suma = sum(salariu.values())

print(nume,'\n',salariul,'\n',suma)

Răspuns
['Alex', 'Petru', 'Ion']
[27, 29, 30]
86

19.

marfa = {'flori': 50, 'fructe': 40, 'legume': 42}


y = sorted(marfa.values())
length = len(marfa)
print(y, '\n', length)

Răspuns

26
[40, 42, 50]
3

20.

marfa = {'flori': 50, 'fructe': 40, 'legume': 42}


length = sorted(marfa.values())
for x in length:
if x>40:print(x)

Răspuns
42
50

21.

x = 32
y = 14

print(x < y)
print(x > y)
print(x != y)
print(x == y)

Răspuns
False
True
True
False

22.

d1 = {'a': 100 ,'b' :200 ,'c':300}

27
d2 = {'a': 300, 'b': 200, 'c': 100}

print(d1['b'] == d2['b'])

Răspuns
True
23.

t = ('Iulian', 41)
print('Salut',t[0]+',','ai implinit ',t[1],'de ani!')

Răspuns
Salut Iulian, ai implinit 41 de ani!

24.

tup = ('Zafer', 'Yasin','Daniela','Jane','Jonhy')


print (tup)
print (tup[:2])
print (tup[:3])
Răspuns

('Zafer', 'Yasin', 'Daniela', 'Jane', 'Jonhy')


('Zafer', 'Yasin')
('Zafer', 'Yasin', 'Daniela')

25.

t = ('Malcoci','Iulian', 41)

lenght = len(t)
res = list(map(type, t))

print(lenght)
print("The data types of tuple in order are : " + str(res))

Răspuns
3

28
The data types of tuple in order are : [<class 'str'>, <class 'str'>, <class 'int'>]

26.

t = ('Mai', [1,9,20], 'Iunie', (7,11,23))

test = t[1][2]
test2 = t[0]
test3 = t[1]
test4 = t[3]
print ('\n',test,'\n',test2,'\n',test3,'\n',test4)

Răspuns
20
Mai
[1, 9, 20]
(7, 11, 23)

27.

a)
t = (27, 7, 9, [11,20])
t[2] = 10
print(t)

b)
t = (27, 7, 9, [11,20])
t[3][0] = 10
print(t)

Răspuns

a)
TypeError: 'tuple' object does not support item assignment
Deoarece tuplurile sunt imuabile, nu au o metodă încorporată append().

b)
(27, 7, 9, [10, 20])

28.

29
a)
t = (27, 7, 9, [11,20])
del t[1]
print(t)

b)
t = (27, 7, 9, [11,20])
del t
print(t)

Răspuns
a)
TypeError: 'tuple' object doesn't support item deletion

Tuplurile sunt neschimbabile, așa că nu puteți elimina elemente din ele

b)
NameError: name 't' is not defined

Aceasta va genera o eroare deoarece tuplul nu mai există

29.

discipline = ('fizica','chimia','geografia')
for x in discipline:
if x == 'fizica':
print('este fizica')
elif x =='Fizica':
print("este Fizica")

Răspuns
este fizica

30.

30
lista1 = [3, '4', 7, 4, 3, '4',11]
lista2 = list(set(lista1))
print(lista2)

Răspuns

[3, '4', 4, 7, 11]

31.

setul_meu = {'ion', 'ana', 'ion', 'vera'}


setul_meu.add('vlad')
lista_mea = list(setul_meu)
print(lista_mea)

Răspuns

['vera', 'ion', 'vlad', 'ana']

32.

set_1 = {'mere', 'pere'}


if('banane' in set_1):
print('DA, bananele sunt in lista de cumparaturi!!!')
elif('banane' not in set_1):
print('NU, bananele nu sunt in lista de cumparaturi!!!')

Răspuns

NU, bananele nu sunt in lista de cumparaturi!!!

TEMA 4.
EXPRESİİ

1.

Răspuns

31
2.

Răspuns

6.

Răspuns

7.

3.

Răspuns
Răspuns

8.

4.

Răspuns
Răspuns

9.

5.

Răspuns

32
Răspuns

10.

Răspuns

15.

11. Răspuns

Răspuns

16.

12.
Răspuns

Răspuns

13.

Răspuns 17.

Răspuns

14.

33
Răspuns

24.

Răspuns
1

8.
25.

19.

Răspuns
Răspuns

20.

Răspuns

21.

Răspuns
26.

22.

Răspuns

23.

34
27.
29.

Răspuns

28.

Răspuns
Răspuns

Tema 5.Funcții. Expresia Lambda. Introducere în bibliotecile NumPy și MatPlotLib


1.
def nume_functie(arg1, arg2):
print(arg1, arg2)
return 0
x = nume_functie("abc", 207)

print(x)

Răspuns
abc 207
0
2.
def avertizare(mesaj):
""" Reda mesajul din parantezele rotunde
precedat de 10 simboluri / si
urmat din 10 simboluri \ """
print('/'*10, mesaj, '\\'*10)

avertizare('ATENTIE!!! DRUM CU DENIVELARI')

Răspuns
////////// ATENTIE!!! DRUM CU DENIVELARI \\\\\\\\\\

35
3.
def avertizare(mesaj):
""" Reda mesajul din parantezele rotunde
precedat de 10 simboluri / si
urmat din 10 simboluri \ """
print('/'*10, mesaj, '\'*10')

avertizare('ATENTIE!!! DRUM CU DENIVELARI')

Răspuns
////////// ATENTIE!!! DRUM CU DENIVELARI '*10

4.
def avertizare(mesaj):
""" Reda mesajul din parantezele rotunde
precedat de 10 simboluri / si
urmat din 10 simboluri \ """
print('/'*10, mesaj, '\\'*10)

avertizare('ATENTIE - COPII')

Răspuns
////////// ATENTIE - COPII \\\\\\\\\\

5.
def fun1():
global numar
print(numar)
def fun2():
numar = 17
print(numar)
numar = 25

print(numar)
fun1()
fun2()
print(numar)

Răspuns
25
25
17
25
6.
def operatia_scadere(a,b):
return a - b

x = operatia_scadere(2,8)
print(x)

36
Răspuns
-6

7.
def la_patrat(x):
return x ** 2

print(la_patrat(4))

a = lambda b: b ** 2
print(a(4))
Răspuns

16
16
8.
def operatii_matemaice(x,y,z):
return(x * y + z)
print(operatii_matemaice(12, 10, 4))

f = lambda a,b,c: a* b + c
print(f(12,10,4))
Răspuns
124
124

9.

def operatii_matemaice(x,y,z):
return(x / y + z)
print(operatii_matemaice(12, 10, 4))

f = lambda a,b,c: a / b + c
print(f(12,10,4))
Răspuns
5.2
5.2

10.
def operatii_matemaice(x,y,z):
return(x / y + z)
print(operatii_matemaice(20, 10, 4))

f = lambda a,b,c: a / b + c
print(f(20,10,4))

Răspuns
6.0
6.0
11.
lista = {23, 42, 27, 50, 32, 2, 7, 66}

37
lista1 = list(filter(lambda x: x % 2 == 1, lista))

print(lista)

Răspuns
{32, 2, 66, 7, 42, 50, 23, 27}

12.
lista = {23, 42, 27, 50, 32, 2, 7, 66}
lista1 = list(filter(lambda x: x % 2 == 1, lista))

print(lista1)

Răspuns
[7, 23, 27]

13.
from matplotlib.pyplot import *

x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y = [-12, -14, -7, -5, 0, -3, 1, 4, 6, 15]

plot(x,y)

xlabel('Timpul (h)')
ylabel('Temperatura grade Celsiu')

show()
Răspuns

14.
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import matplotlib.cbook as cbook

38
image_file = cbook.get_sample_data('grace_hopper.png')
image = plt.imread(image_file)

fig, ax = plt.subplots()
im = ax.imshow(image)
patch = patches.Circle((260, 200), radius=200, transform=ax.transData)
im.set_clip_path(patch)

ax.axis('off')
plt.show()

15.

import matplotlib.pyplot as plt

# Pie chart, where the slices will be ordered and plotted counter-clockwise:
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
sizes = [15, 30, 45, 10]
explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. 'Hogs')

fig1, ax1 = plt.subplots()


ax1.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%',
shadow=True, startangle=90)
ax1.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.

plt.show()

Răspuns

39
16.
import matplotlib.pyplot as plt

# Pie chart, where the slices will be ordered and plotted counter-clockwise:
labels = 'Nota 10', 'Nota 9', 'Nota 8', 'Nota 7'
sizes = [15, 30, 45, 10]
explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. 'Hogs')

fig1, ax1 = plt.subplots()


ax1.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%',
shadow=True, startangle=90)
ax1.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.

plt.show()
Răspuns

Tema 6. Gestionarea fișierelor în Python

1.

# Crerea fisierului txt


f = open('test.txt', 'w')
f.write('Test, testam, screm un documnet nou')
f.close()
# Citirea fisierului
f = open('test.txt', 'r')
print(f.read())
f.close()
Răspuns
Test, testam, screm un documnet nou

40
2.
# Crerea fisierului txt
f = open('test.txt', 'w')
f.write('Test, testam, screm un documnet nou')
f.close()
# Citirea fisierului
f = open('test.txt', 'r')
print(f.read())
f.close()

# Crerea fisierului txt


with open ('test.txt','w') as f:
f.write('Test, testam, screm un documnet no')
# Citim fisierul
with open('test.txt','w') as f:
print(f.read())

Răspuns
Test, testam, screm un documnet nou

3.
with open('Linia.txt','r') as f:
print(f.read())
Răspuns
Linia 1
Linia 2
Linia 3

4.
with open('Linia.txt','r') as f:
print(f.readline())
Răspuns
Linia 1

5.

# Adaugam un rand nou cu append - 'a'


with open('Linia.txt', 'a') as f:
f.write('\nRand Nou')
with open('Linia.txt','r') as f:
print(f.read())

Răspuns
Linia 1
Linia 2
Linia 3

Rand Nou

5.

41
# Adaugam un rand nou cu append - 'a'
with open('Linia.txt', 'a') as f:
f.write('Rand Nou')
with open('Linia.txt','r') as f:
print(f.read())
Răspuns
Linia 1
Linia 2
Linia 3

Rand NouRand Nou

6.

# Adaugam un rand nou cu append - 'a'


with open('Python1.txt', 'x') as f:
f.write('Eu studiez Grafica pe Calculaator in Python')
with open('Python1.txt','r') as f:
print(f.read())

Răspuns
Eu studiez Grafica pe Calculaator in Python

7.
from sys import argv

script, first, second, third = argv


print('Acest cod(program) este ',script)
print()
print('Prima variabila este',first)
print()
print('A doua variabila este', second)
print()
print('A treia variabila este', third)
Răspuns
Acest cod(program) este test.py
Prima variabila este Radu
A doua variabila este Andrei
A treia variabila este Ala

8.

from sys import argv

script, nume_prenume = argv


prompt = '>>>'

print(f'Salut, {nume_prenume}, Eu sunt codul {script}')


print('Vreau sa iti pun cateva intrebari!')

42
print(f'iti place sa programezi in Python, {nume_prenume}?')
raspuns1 = input(prompt)

print(f'Unde locuesti, {nume_prenume}?')


raspuns2 = input(prompt)

print(f'{nume_prenume}, ai PC sau Laptop?')


raspuns3 = input(prompt)

print('''
Prin urmare, tu ai raspuns {raspuns1} la inntrebarea daca iti place Python.
{nume_prenume} tu locuesti in {raspuns2}. Un loc frumos!!!
Poti sa programezi pe {raspuns3} fara probleme!!!
''')
Răspuns
Salut, akbiyik_zafer, Eu sunt codul test.py
Vreau sa iti pun cateva intrebari!
iti place sa programezi in Python, akbiyik_zafer?
>>>Da
Unde locuesti, akbiyik_zafer?
>>>Chisinau
akbiyik_zafer, ai PC sau Laptop?
>>>Laptop

Prin urmare, tu ai raspuns {raspuns1} la inntrebarea daca iti place Python.


{nume_prenume} tu locuesti in {raspuns2}. Un loc frumos!!!
Poti sa programezi pe {raspuns3} fara probleme!!!

9.

from sys import argv

script, filename = argv

txt = open(filename)

print(f'Continutul fişierului {filename}:')


print(txt.read())

Răspuns

Continutul fişierului zafer.txt:


1
2
3
4
5

43
10.

from sys import argv

script, filename = argv

print('Decshidem fişierul ...')


document = open(filename, 'w')

print('Golim documentul!!!')
document.truncate()

print('Acum va trebui sa scriem 3 randuri')

rand_1 = input('rand 1: ')


rand_2 = input('rand 2: ')
rand_3 = input('rand 3: ')

print('Introducem randurile in document.')

document.write(rand_1 + '\n')
document.write(rand_2 + '\n')
document.write(rand_3 + '\n')

print('Nu uitati sa inchideti fişierul!!!')


document.close()

Răspuns

Decshidem fişierul ...


Golim documentul!!!
Acum va trebui sa scriem 3 randuri
rand 1: Test1
rand 2: Test2
rand 3: Test3
Introducem randurile in document.
Nu uitati sa inchideti fişierul!!!

44
Python 3.10 Features
Pentru Limba Romana Pagina 49

Python 3.10, the latest release of Python is in its beta phase. This article explores the major changes and
updates to the previous version.
Precise Error Messages

Population Count
New Type Union Operator
Deprecation and Removal of Some Backward Compatibilities
Strict Zipping
Python is a very versatile, flexible, and interactive programming language. The application of Python
spreads across various fields of the tech industry, most notably, web development, machine learning,
artificial intelligence, and data science.
Python is a straightforward language that requires less time and resources to learn, making it widely
accessible compared to other high-level languages like Java or C++.
Recently, Python contributors switched to a yearly update cycle to introduce new features and improve
the existing ones. Python 3.10 is the latest release of Python and we’ll look at some of the most
important updates in this article.
All versions of Python below 3.6 are obsolete.

Structural Pattern Matching is the most anticipated feature of Python 3.10. This feature introduces a
switch/case-like feature as we have in other programming languages to Python. In addition to the
switch-like feature, Python 3.10 Structural Pattern Matching brings some extra features, making it even
more powerful than the usual switch conditional statement.
Python uses the match keyword instead of switch with the case keyword defining each different
scenario. Below is an example of the usage;

x=3+4

match x:

case 9:

return "That's too high..."

case 5:

return "You're two steps away ..."

case 6 | 8: # Combining multiple literals with `|`

return "Oops! That was so close!"

45
case 9:

return "Too small..."

case _:

return "That's too random!"

The example above is the basic usage of Python 3.10’s match/case conditional statement. Like we have
in “case 6”, Python allows you to compare multiple values in the same case statement using the
or | operator.
Python 3.10 also allows you to use wildcards (_) as we have in the last case statement that acts as a
default value, similar to what we have in other programming languages.
One of the extra features that make Python 3.10’s match/case conditional statement more powerful
than the switch statement in other programming languages is the ability to match complex patterns.
Here is an example:

def http_error(status):

match status:

case 400:

return "Bad request"

case 404:

return "Page not found"

case _:

return "Opps! I dont understand that"

http_error(500)

# Opps! I dont understand that

We used Python tuple to match complex parameters against each other using the match statement. As
we used in the first example, the wildcard (_) is also used to stand in for default value.
Another feature of Python 3.10 Structural Pattern Matching is Guards.

Guards enable you to follow the top pattern with a Guard, an if statement, which evaluates the
subsequent case statement if the Guard evaluates to true. Below is an example:

match input:

case [x, y] if x > MAX_INT and y > MAX_INT:

print("Got a pair of large numbers")

case x if x > MAX_INT:

46
print("Got a large number")

case [x, y] if x == y:

print("Got equal items")

case _:

print("Not an outstanding input")

Other Python 3.10 pattern matching features include classes, literals and variables, and nested patterns,
allowing you to create complex conditional statements.

Precise Error Messages


In previous versions of Python, debugging a code is pretty difficult due to poor error messages. Error
messages generated by the Parser from previous versions of Python are not specific.
Consider the code below:

print("Hello Reader"

print("Welcome to The Chief IO")

#The Error Message

File "<string>", line 2

print("Welcome to The Chief IO")

SyntaxError: invalid syntax

The error message generated points that the error is in line 2, whereas the actual error is in line 1. This
makes debugging hard.
Python 3.10 proposes a more accurate and line-precise error message, assisting you in figuring out
where the problem is from.
For the same example above, Python 3.10 will generate the following error message which is clearer;

File "<string>", line 1

print("Hello Reader")

SyntaxError: ‘(’ was never closed.

47
Population Count
A new method, bit_count, is introduced in Python 3.10. This method will return the number of ones
present in the binary representation of an integer.

This method is also known as Population Count (popcount) and it gives you a faster way of counting
non-zero bits in an integer.

New Type Union Operator


Python 3.10 also comes with an improved type union checking syntax that will help you write cleaner
codes. Instead of using typing.Union to compare two data types, python 3.10 enables you to use the or
(|) operator with type annotations and also functions like isinstance() and issubclass().
Here is an example of the old syntax;

def func(value: Union[int, float]) -> Union[int, float]:

return value

With the new | operator, we can write the same code like this;

def func(value: int | float) -> int | float:

return value

Here is an example of the usage with isinstance() function;

isinstance("hello", int | str)

# True

Deprecation and Removal of Some Backward Compatibilities


Some earliest support for abstract base classes and old import semantics will be dropped from Python
3.10 onwards.

Some of the deprecated syntax includes find_loader()/find_module, load_module and _load_attribute.


Support for Distutils is also discontinued and replaced with setuptools and packaging.

Strict Zipping
A new optional Keyword argument, strict is added to the zip function in Python 3.10. If you set the strict
keyword to true, the iterables that you are zipping must be of equal lengths, or else, an error value will
be raised.

48
Pentru Limba Romana

Python 3.10 , cele mai recente lansarea lui Python este în faza sa beta . Acest articol explorează cel
major modificări și actualizări la cel anterior versiunea .

Precis Eroare Mesaje


Populația Numara
Tip nou Uniune Operator

Deprecierea și eliminarea unora _ Înapoi Compatibilitati


Strict Fermoar
Python este foarte versatil , flexibil și interactiv programare limbaj . The aplicarea lui Python se
raspandeste peste variat câmpuri ale _ tehnologie industrie , majoritatea în special , dezvoltare web ,
mașină învăţare , artificială inteligență și date stiinta .
Python este un simplu limba acea cere mai putin timp si resurse la învață , făcându -l pe scară largă
accesibil comparat la alte nivel inalt limbi precum Java sau C++.
Recent , Python contribuabili comutat la un anual Actualizați ciclu la introduce nou caracteristici și
îmbunătățiți cel existent cele . Python 3.10 este cele mai recente lansarea lui Python și vom face uită - te
la unele dintre cel mai important actualizări în aceasta articol .
Toate versiuni de Python sub 3,6 sunt învechit .
Structural Model Potrivirea este _ cel mai anticipat caracteristica Python 3.10 . Acest caracteristică
introduce un comutator / case-like caracteristică ca noi au în altele programare limbi la Python . În plus
la cel ca un comutator caracteristică , Python 3.10 Structural Model Potrivire aduce niste suplimentar
caracteristici , făcându -l uniform Mai mult puternic decât cel ca de obicei intrerupator condiţional
declarație .
Piton utilizări cel Meci cuvânt cheie în loc de comutator cu cel caz cuvânt cheie definire fiecare diferit
scenariu . Mai jos este un exemplu de utilizare ;

X=3+4

potrivire x :

caz 9 :

întoarcere „ Asta e de asemenea mare ..."

caz 5 :

întoarcere „ Ești Două trepte departe ..."

49
caz 6 | 8 : # Combinarea multiplu literali cu `|`

întoarcere " Oops ! Asta a fost asa de aproape !"

caz 9 :

întoarcere „ De asemenea mic ..."

cazul _ :

întoarcere „ Asta e de asemenea aleatoriu !"

Exemplul de mai sus este de bază utilizarea potrivirii / cazului Python 3.10 _ condiţional declarație . Ca
noi au în „ cazul 6”, Python permite tu la comparaţie multiplu valorile în _ la fel caz afirmație folosind cel
sau | operator .
De asemenea, Python 3.10 permite tu la utilizare wildcards ( _ ) ca noi au în _ ultimul caz afirmație acea
acționează ca implicit valoare , asemănătoare la ce noi au în altele programare limbi .
Unul dintre suplimentar Caracteristici acea face Potrivire / caz pentru Python 3.10 condiţional afirmație
Mai mult puternic decât cel intrerupator declarație în altele programare limbile este _ capacitatea la
Meci complex modele . Iată un exemplu:

def http_error ( stare ):

Meci stare :

caz 400 :

întoarcere „ Rău cerere "

caz 404 :

întoarcere „ Pagina nu a fost găsită ”

cazul _ :

întoarcere " Ops ! Nu a intelege că "

http _error ( 500 )

# Opps ! eu nu a intelege acea

Noi folosit Piton tuplu la Meci complex parametrii împotriva fiecare alte folosind cel Meci declarație . Ca
si noi folosit în _ primul exemplu, cel wildcard ( _ ) este de asemenea folosit la inlocuieste _ _ Mod
implicit valoare .
Un alt caracteristica Python 3.10 Structural _ Model Potrivirea este Garzi .

gardieni permite tu la urma modelul de sus cu un gardian , un dacă declarație , care evaluează cel
ulterior caz afirmație dacă cel gardian evaluează la adevărat . Mai jos este un exemplu:

Meci intrare :

50
caz [ x , y ] dacă x > MAX_INT și y > MAX_INT :

print ( " Am o pereche de mari numere " )

cazul x dacă x > MAX_INT :

print ( " Am un mare număr " )

caz [ x , y ] dacă x == y :

print ( " Am egal articole " )

cazul _ :

print ( "Nu este un remarcabil intrare " )

Alte Model Python 3.10 potrivire Caracteristici include clase , literale și variabile și imbricate modele ,
permițând tu la crea complex condiţional declarații .

Precis Eroare Mesaje


În anterior versiuni de Python , depanarea unui cod este destul de bună dificil datorată la sărac eroare
mesaje . Eroare mesaje generate de cel Analizator din anterior versiuni de Python nu sunt specifice .
Considera cel cod mai jos :

print ( " Bună , cititor"

print ( " Bun venit la The Șef IO" )

#Mesajul de eroare

Fișier „< șir >” , linia 2

print ( " Bun venit la The Șef IO" )

SyntaxError : invalid sintaxă

The eroare mesaj generate puncte acea cel eroarea este în linia 2, în timp ce cel real eroarea este în linia 1.
Aceasta face depanare greu.

Python 3.10 propune un mai mult precise și precise la linie eroare mesaj , asistare tu în a închipui afară Unde
problema este de la .

Pentru cel același exemplu de mai sus , Python 3.10 va Genera cel ca urmare a eroare mesaj care este mai clar ;

Fișier „< șir >” , linia 1

tipăriți ( " Bună ziua cititorului" )

51
^

SyntaxError : ' ( ' a fost nu inchis .

Populația Numara
Un nou metoda , bit_count , este introdusă în Python 3.10. Acest metodă voi întoarcere cel număr de
unii prezent în _ binar reprezentarea unui număr întreg .
Acest metoda este de asemenea cunoscut sub numele de Populație Numărați ( popcount ) și dă tu un
mai rapid mod de a număra diferit de zero biți într-un număr întreg .

Tip nou Uniune Operator


De asemenea, Python 3.10 vine cu o îmbunătăţire tip uniune control sintaxă acea voi Ajutor tu scrie
curățător coduri . În loc de a folosi tastarea.Unirea la comparaţie două tipuri de date , python 3.10
activează tu la utilizare cel sau ( | ) operator cu tip adnotări și de asemenea funcții ca isinstance () și
issubclass () .
Iată un exemplu de vechi sintaxă ;

def func ( valoare : Unire [ int , plutește ]) -> Unire [ int , plutește ]:

întoarcere valoare

Cu cel nou | operator , putem scrie _ cel la fel cod ca aceasta ;

def func ( valoare : int | plutește ) -> int | plutire :

întoarcere valoare

Iată un exemplu de utilizare cu funcția isinstance ( ) ;

isinstance ( " salut " , int | str )

# Adevărat

Deprecierea și eliminarea unora _ Înapoi Compatibilitati


niste cel mai devreme a sustine pentru abstract baza clase si vechi import semantică va fi abandonat din
Python 3.10 înainte .
Unele dintre _ depreciat sintaxa include find_loader ( ) / find_module , load_module și _load_attribute .
A sustine pentru Distutils este de asemenea întrerupt și înlocuit cu setuptools și ambalaje .

Strict Fermoar
Un nou opțional Cuvânt cheie argument , se adaugă strict la cel fermoar funcție în Python 3.10. Dacă tu
ai setat strict cuvânt cheie la adevărat , _ iterabile acea tu sunteți fermoar trebuie să fie de egalitate
lungimi , sau altfel, o eroare valoare va fi ridicat .

52
MatPlotLib 5 Exemple
1.
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(15, 5, 45).reshape(1, -1)


y = np.linspace(-3, 5, 120).reshape(-1, 1)
z = np.cos(x) + np.sin(y)
x, y = x.flatten(), y.flatten()

fig1, ax1 = plt.subplots()


cs = ax1.contourf(x, y, z, hatches=['-', '/', '\\', '//'],
cmap='turbo', extend='neither', alpha=1)
fig1.colorbar(cs)

artists, labels = cs.legend_elements(str_format='{:2.1f}'.format)


ax1.legend(artists, labels, handleheight=2, framealpha=1)
plt.show()

53
2.
from matplotlib.colors import colorConverter
import matplotlib.pyplot as plt
import numpy as np
colorConverter = "Purples"
np.random.seed(19680801)
data = np.random.random((500, 500, 500))

fig, ax = plt.subplots()

for i in range(len(data)):
ax.cla()
ax.imshow(data[i])
plt.pause(0.1)

54
3.
from matplotlib import cbook
from matplotlib import cm
from matplotlib.colors import LightSource
import matplotlib.pyplot as plt
import numpy as np

dem = cbook.get_sample_data('jacksboro_fault_dem.npz', np_load=True)


z = dem['elevation']
nrows, ncols = z.shape
x = np.linspace(dem['xmin'], dem['xmax'], ncols)
y = np.linspace(dem['ymin'], dem['ymax'], nrows)
x, y = np.meshgrid(x, y)

region = np.s_[5:150, 5:150]


x, y, z = x[region], y[region], z[region]

fig, ax = plt.subplots(subplot_kw=dict(projection='3d'))

ls = LightSource(270, 500)
rgb = ls.shade(z, cmap=cm.gist_earth, vert_exag=0.1, blend_mode='overlay')
surf = ax.plot_surface(x, y, z, rstride=1, cstride=1, facecolors=rgb,
linewidth=0, antialiased=False, shade=True)

plt.show()

55
4.
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
np.random.seed(20680801)
def random_walk(num_steps, max_step=0.05):
"""Return a 3D random walk as (num_steps, 3) array."""
start_pos = np.random.random(5)
steps = np.random.uniform(-max_step, max_step, size=(num_steps, 5))
walk = start_pos + np.cumsum(steps, axis=0)
return walk
def update_lines(num, walks, lines):
for line, walk in zip(lines, walks):

line.set_data(walk[:num, :2].T)
line.set_3d_properties(walk[:num, 2])
return lines
num_steps = 50
walks = [random_walk(num_steps) for index in range(40)]

fig = plt.figure()
ax = fig.add_subplot(projection="3d")

lines = [ax.plot([], [], [])[0] for _ in walks]

ax.set(xlim3d=(0, 1), xlabel='X')


ax.set(ylim3d=(0, 1), ylabel='Y')
ax.set(zlim3d=(0, 1), zlabel='Z')

ani = animation.FuncAnimation(
fig, update_lines, num_steps, fargs=(walks, lines), interval=5)

plt.show()

56
5.
import matplotlib.pyplot as plt
import numpy as np

def midpoints(x):
sl = ()
for i in range(x.ndim):
x = (x[sl + np.index_exp[:-1]] + x[sl + np.index_exp[1:]]) / 2.0
sl += np.index_exp[:]
return x

r, g, b = np.indices((17, 17, 17)) / 16.0


rc = midpoints(r)
gc = midpoints(g)
bc = midpoints(b)

sphere = (rc - 1)**2 + (gc - 1)**2 + (bc - 0.5)**2 < 0.5**2

colors = np.zeros(sphere.shape + (3,))


colors[..., 1] = rc
colors[..., 1] = gc
colors[..., 0] = bc

ax = plt.figure().add_subplot(projection='3d')
ax.voxels(r, g, b, sphere,
facecolors=colors,
edgecolors=np.clip(5*colors - 200, 50, 1), # brighter
linewidth=0.1)
ax.set(xlabel='r', ylabel='g', zlabel='b')

plt.show()

57
Laboratuarul nr. 4

Ex4_1
Ce răspuns vom obține după rularea următorului cod?

Răspuns

False
True
False
False
True

Ex4_2
Ce răspuns vom obține după rularea următorului cod?

Răspuns

True
True
False
True
False
True

Ex4_3
Ce răspuns vom obține după rularea următorului cod?

Răspuns

False
True

58
True
True
False
True
Ex4_4
Să presupunem că avem următorul dicționar my_dict = {'key 1': 1, 'key 2': 7, 'key 3': 9}, trebuie
să creăm un cod care la răspuns să ne dea o listă cu valorile cheilor din dicționar care sunt mai mari decât
5.

my_dict = {'key 1' : 1, 'key2': 7, 'key 3' :9}


my_dict1 = dict((key,val) for key,val in my_dict.items()if val>5)
print(my_dict1)

{'key2': 7, 'key 3': 9}

Ex4_5
În acest exemplu trebuie să generați un număr aliator a între 1 și 100 (sugestie: importam modulul random
și folosim .randint(1,100) ), să cereți de la utilizator să introducă un număr b între 1 și 100, după care
să comparăm aceste două numere.

import random

r1 = random.randint(1, 100)
print('Random Numare',r1)

r2 = int(input('User Numare '))

print ('Este același număr', r1 == r2)


print ('random > user', r1 > r2)
print ('random < user', r1 < r2)

Răspuns

Random Numare 73
User Numare 40
Este același număr False
random > user True
random<userFalse
Ex4_6
În acest exemplu trebuie să scrieți un cod în care să cereți de la utilizator să introducă orice număr dorește,
iar la răspuns să obținem dacă numărul ales este pozitiv, negativ sau egal cu zero.
user = int(input('Intruduceti numarul '))

if user < 0:
print("Negativ")
if user > 0:
print("Pozitiv")
if user == 0:
print("Egal cu 0")

59
Răspuns

Intruduceti numarul 10
Pozitiv

Ex4_7
În acest exemplu trebuie să scrieți un cod în care să cereți de la utilizator să introducă un număr între 1 și
10000, după care să verificăm dacă acest număr este multiplul lui 5 dar nu și multiplul lui 3.

user = int(input('Intruduceti numarul'))

if (user > 1000) or (user < 1):


print('1 - 1000')

if user % 5 == 0 and user % 3 !=0:


print("True")

Intruduceti numarul20
True

Ex4_8
În acest exemplu trebuie să scrieți un cod în care să cereți de la utilizator să introducă un număr pozitiv,
iar la răspuns să obținem din câte cifre este format numărul ales de utilizator. De exemplu daca utilizatorul
a ales numărul 77 la răspuns trebuie să obținem: Nr ales de utilizator are 2 cifre.

user = int(input('Intruduceti numarul '))

if user < 0:
print(" 1 > ")

print('Nr ales de utilizator are',len(str(user)), 'cifre.')

Răspuns

Intruduceti numarul 40
Nr ales de utilizator are 2 cifre.

Ex4_9
În acest exemplu trebuie să scrieți un cod în care să cereți de la utilizator să introducă un număr oarecare,
iar la răspuns să obținem răspunsul dacă acest număr este par sau impar.

user = int(input('Intruduceti numarul '))

if user % 2 == 0:
print("Par")

elif user % 2 != 0:

60
print("Impar")

Răspuns

Intruduceti numarul 1
Impar

Ex4_10
Pentru dicționarul my_dict = {'Ana': 11, 'Mariana': 40, 'Iulian': 41} scrieți un cod care la răspuns
să nea dea o listă care să conțină doar valorile cheilor din dicționar care sunt mai mari de 25.

lst = {'Ana': 11, 'Mariana': 40, 'Iulian': 41}


lst2 = lst.values()
for i in lst2:
if i > 25:
print(i)

Răspuns

40
41
Ex4_11
Care va fi răspunsul după rularea următoarelor coduri:
a)

Răspuns

Ion
Salut
Ana
Salut
Maria
Salut

b)

Răspuns

Ion

61
Salut
Ana
Salut

c)

Răspuns

Ion
Ana
Maria
Salut

Ex4_12
Care va fi răspunsul după rularea următoarelor coduri:
a)

Răspuns

A
n
a

b)

Răspuns

Ana

Ex4_13
Care va fi răspunsul după rularea următorului cod:

62
from itertools import tee

lista_mea = ['nokia','samsung','google','iphone']

i = 0
while i < len(lista_mea)
telefoane = lista_mea[i]
i += 1

if telefoane == 'google':
continue

print(telefoane)

Răspuns

nokia
samsung
iphone

Ex4_14

Scrieți un cod folosind bucla for și al doilea cod folosind bucla while astfel încât la răspuns să obținem:
for i in range(1,8):
print(i)

a=0
while a<7:
a=a+1
print(a)

Ex4_15
Scrieți un cod folosind bucla for astfel încât la răspuns să obține 3 coloane, in prima coloană să fie
numerele de la 1 la 10, în a doua coloană să fie pătratul acestor numere, iar a treia coloană să fie cubul
acestor numere ca în exemplu:

63
a) b)

a)
for i in range(1, 11):
print(i, i ** 2, i ** 3)
print('end of loop')
F.join(map(str,range(x))).rjust(10)
b)
for i in range(1, 11):

number1 = str(i)
rg1 = number1.rjust(2)

number2 = str(i ** 2)
rg2 = number2.rjust(4)

number3 = str(i ** 3)
rg3 = number3.rjust(4)
print(rg1,rg2,rg3)

Ex4_16
Scrieți un cod care trebuie să simuleze aruncarea zarurilor cu ajutorul buclei while și modulului
random. Răspunsul trebuie să arate în felul următor:

import random
arunca_zarurile="y"

64
while arunca_zarurile=="y":
print("Se arunca zarurile: ")
print("Zarul 1 indica: ",random.randint(1,6))
print("Zarul 2 indica: ",random.randint(1,6))
arunca_zarurile=input("Apasa tasta 'y' pentru a arunca zarurile din nou !!!
")

Ex4_17
Trebuie să scriem un cod care să ceară de la utilizator să introducă un număr de la 1 până la 9, după care
folosind bucla for să obținem tabla înmulțirii cu acel număr ales de utilizator. Răspunsul trebuie să arate
în felul următor:

value = int(input('Intruduceti numarul '))


for i in range(1, 11):
print(value, 'x', i, '=', i * value)

Ex4_18
Trebuie să scriem un cad care să ceară de la utilizator o valoare minimă și una maximă, iar după rulare la
răspuns să apară doar numerele pare dintre aceste două valori alese de utilizator. Răspunsul trebuie să
arate în felul următor:

min = int(input('Intruduceti numarul minim '))


max = int(input('Intruduceti numarul maxim '))

for i in range(min, max):


if i % 2 == 0:
print(i)

Ex4_19

65
Ce răspuns vom obține dacă vom rula următorul cod:

Răspuns

D
c
i

Ex4_20
Trebuie să scriem un cod în care să cerem de la utilizator să introducă câteva valori separate prin spațiu
pentru temperatura în grade C sub formă de listă, după care această listă să o transformăm într-

o listă nouă care să ne arate aceste valori în grade F cu ajutorul buclei for. Răspunsul trebuie să arate în
felul următor:

lst = []
lst2 = []
for i in range(0, 4):
ele = int(input())

lst.append(ele)
print(lst)
for i in lst:
ele2 = (i * 9/5) +32
lst2.append(ele2)
print(lst2)

Ex4_21
Trebuie să scriem un cod în care utilizatorul să specifice lungimea parolei pe care calculatorul trebuie s-o
genereze în mod aleatoriu cu ajutorul modulului random și folosirea buclei for, iar caracterele să conțină
litere, numere și caractere speciale din modulul string.

După rulare vedem ce conține fiecare instrucțiune din modulul string:

După ce terminăm de scris codul care va genera o parolă în mod aleatoriu vom obține un răspuns care arată
în felul următor:

import string

66
import random

print('Numere', string.digits)
print('Litere', string.ascii_letters)
print('Simboluri', string.punctuation)

value = int(input('Introdu lungimea parolei '))

characters = string.ascii_letters + string.digits + string.punctuation


password = ''.join(random.choice(characters)
for i in range(value))
print("Aceasta este :", password)

Ex4_22
Trebuie să scriem un cod care să îl întrebe pe utilizator cum se numește și câți ani are, după care utilizând
comenzile .split(), .sort() și bucla for să sortăm cuvintele din propoziția introdusă de utilizator.
După rularea codului răspunsul trebuie să arate în felul următor:

value = input("Cum te numesti si ce varsta ai?: ").split()


test = sorted(value)
for i in test:
print(i)

Ex4_23
Având două liste culori = ['Alb', 'Negru', 'Oranj'] și auto = ['Duster', 'Logan',
'Dokker'] trebuie să scriem două coduri în care să folosim bucle imbricate pentru a obține următoarele
răspunsuri:
a)

culori = ['Alb', 'Negru', 'Oranj']


auto = ['Duster', 'Logan', 'Dokker']
test = len(culori)
for i in range(test):

67
print (auto[i] +' '+culori[0])
for i in range(test):
print (auto[i] +' '+culori[1])
for i in range(test):
print (auto[i] +' '+culori[2])

b)

culori = ['Alb', 'Negru', 'Oranj']


auto = ['Duster', 'Logan', 'Dokker']
lst = []
test = len(culori)
for i in range(test):
i = (auto[i] +' '+culori[0])
lst.append(i)
for i in range(test):
i = (auto[i] +' '+culori[1])
lst.append(i)
for i in range(test):
i = (auto[i] +' '+culori[2])
lst.append(i)

print(lst)

Ex4_24
Trebuie să scriem un cod care să ceară de la utilizator să introducă o propoziție, după care cu ajutorul
buclei for să obținem la răspuns nr. de litere mici și nr. de litere mari. Răspunsul trebuie să arate în felul
următor:

import time
value = input("Introdu o propozitie: ")
count = 0
count2 = 0
for i in value:
if (i.isupper()):
count = count + 1
if (i.islower()):
count2 = count2 + 1
print ("Numarul de litere mari este : " + str(count))
print ("Numarul de litere mici este : " + str(count2))

Ex4_25

68
Trebuie să scriem un cod în care să cerem de la utilizator să introducă limita de jos și limita de sus și limita
de jos intre 100 și 999. După care la răspuns să obținem o listă care să cuprindă o listă doar din numerele
care au toate cele trei cifre numere pare. Răspunsul trebuie să arate în felul următor:

min = int(input("Min"))
max = int(input("Max"))

lst = []
for i in range(0,6):
i = int(input("Value"))
if i < min or i > max:
print("False")
break
lst.append(i)

print(lst)

Ex4_26
În acest exercițiu vom folosi modulul time și comanda .sleep() pentru ca de exemplu răspunsul dorit de
noi să apară pe ecran să apară la fiecare 5 secunde. Vom întreba care este filmul preferat al utilizatorului.
După rulare la fiecare 5 secunde va apărea mesajul: Acest film este SUPER!!! După rulare vom obține:
Codul va rula la nesfârșit și la fiecare 5 secunde va apărea un nou mesaj Tunul de lemn este un film

SUPER!!! Dacă dorim să întrerupem rularea apăsăm tastele Ctrl + C.

import time
value = input("Care este filmul tau preferat?: ")
i = 0
while i <= 10:
time.sleep(5)
print(value,"este un film SUPER!!!")

Ex4_27
În acest exercițiu îi vom cere utilizatorului să introducă o parolă cu condițiile ca această parolă să fie
formată din 10 caractere, să conțină cel puțin o literă mare și cel puțin o cifră. Aici vom folosi cam tot ce
am învățat până acum și bucla while și bucla for și operatorul logic and și instrucțiunile condiționate
if și else. După rulare răspunsul poare arăta în felul următor:

69
import string

parola=string(input("Introdu parola: "))


def validate():
while True:
if len(parola)<10 :
print("Parola nu are 10 caractere, o cifra sau majuscula!!!")
elif not parola.isdigit():
print("Parola nu are 10 caractere, o cifra sau majuscula!!!")
elif not parola.isupper():
print("Parola nu are 10 caractere, o cifra sau majuscula!!!")
else:
print("Parola noua a fost salvata cu succes")
break
validate()

Laboratuarul nr. 5

Ex5_1
Trebuie să creăm o funcție care să redea pătratul oricărui număr, iar numărul respectiv să fie introdus de
către utilizator cu funcția input(). După rularea codului răspunsul trebuie să arate în felul următor:

import math
x=int(input('Introdu un numar:'))
y=pow(x,2)
print('Patratul numarului {} este {}'.format(x,y))

Ex5_2
Trebuie să creăm o funcție care să redea suma și produsul a două numere. Numerele trebuie să
fie introduse de utilizator. După rularea codul
ui răspunsul trebuie să arate în felul următor:

a=int(input('Introdu primul numar: a='))


b=int(input('Introdu al doilea numar: b='))
x=a+b
z=a*b
print('Suma a+b={}, Produsul a*b={}'.format(x,z))
print('Suma',a,'+',b,'=',x,',Produsul ',a,'*',b,'={}'.format(z))

70
Ex5_3
Trebuie să realizăm un cod care să redea suma și produsul a două numere folosindu-ne de expresia lambda.
Numerele trebuie să fie introduse de utilizator. După rularea codului răspunsul trebuie să arate în felul
următor:

a=int(input('Introdu primul numar: a='))


b=int(input('Introdu al doilea numar: b='))
ad = lambda a,b: a+b
im = lambda a,b: a*b
print('Suma a+b={}, Produsul a*b={}'.format(ad(a,b),im(a,b)))
print('Suma',a,'+',b,'=',ad(a,b),',Produsul ',a,'*',b,'={}'.format(im(a,b)))
Ex5_4

Trebuie să realizăm o funcție care să redea după rulare factorialul numărului 4, iar numărul 4 să fie
introdus de utilizator (4x3x2x1=24). După rularea codului răspunsul trebuie să arate în felul următor:

import math
x=int(input('Doriti sa determinati factorialul numarului: '))
y=math.factorial(x)
print('Factorialul lui {} este {} '.format(x,y))

Ex5_5
Presupunând că avem creată o listă cu funcția lista_mea = range(-7,8), trebuie să creăm un cod care
după rulare să redea o nouă listă în care toate elementele din lista inițială să fie ridicate la cub.

import math
lista_mea=range(-7,8)
list=[]
for i in lista_mea:
new=pow(i,3)
list.append(new)
print(list)
Ex5_6
Presupunând că avem deja scris următorul cod:

71
folosind expresia lambda trebuie să continuăm acest cod astfel ca la răspuns să obținem o listă care să
conțină toate elementele din variabila numere ridicate la pătrat. După rulare trebuie să obținem
următorul răspuns:

def patrat (x):


return lambda x: x*x
numere =range(-5,6)
list=[]
for i in numere:
list.append(numere[i])
list2=[]
print("Patratul listei")
print(list,'este')
for i in list:
new=patrat(i)
list2.append(new(i))
print(list2)
Ex5_7
Trebuie să creăm 3 funcții care să redea diametrul, lungimea și aria unui cerc la răspuns. Raza cercului
trebuie să fie introdusă de utilizator. După rulare trebuie să obținem următorul răspuns:

from cmath import pi


r=int(input('Care este raza cercului?: '))
print("Diametrul cercului = ",2*r)
print("Lungimea cercului = ",(2*pi)*r)
print("Aria cercului = ",pi*(r*r))
Ex5_8
Trebuie să creăm un cod în care să cerem de la utilizat limita minimă (număr negativ) și limita maximă,
din șirul de numere obținut să obținem la răspuns o listă care să cuprindă doar numerele pozitive și pare
(trebuie să folosim funcțiile range(), filter() și expresia lambda. După rulare trebuie să obținem
următorul răspuns:

x=int(input('Introdu limita minima (nr. negativ): '))


y=int(input('Introdu limita maxima (nr. poxitiv): '))
nr=range(x,y)
my_list=[]
for i in nr:
my_list.append(nr[i])
ras = list(filter(lambda x: (x % 2 == 0) and (x>0), my_list))
print(ras)

72
Ex5_9
Un exemplu asemănător cu cel precedent. Dacă avem lista numere = [-1, 2, 45, 20,-23,17, -3,
9, - 5, 6, 32, -14, 14, 17, 12, -20, 11, 8] trebuie să scriem un cod folosind funcția
filter() și expresia lambda astfel încât la răspuns să obținem două liste noi, prima listă să conțină doar
numerele negative și cele impare, iar a doua listă să conșină numerele mai mari decât - 20 și mai mici
decât 20. După rulare trebuie să obținem următorul răspuns:

my_list=[-1, 2, 45, 20,-23,17, -3, 9, - 5, 6, 32, -14, 14, 17, 12, -20, 11, 8]
negim = list(filter(lambda x: (x % 2 == 1) and (x<0), my_list))
list_negim=[]
list_negim.append(negim)
print('Nr negative \ impare :',list_negim)
douazeci = list(filter(lambda x: (x >-20) and (x<20), my_list))
list_douazeci=[]
list_douazeci.append(douazeci)
print('Nr intre -20 si 20 :',list_douazeci)

Ex5_10

Să presupunem că avem două matrice . Trebuie să creăm un cod în care să definim funcții
pentru adunarea (np.add(x,y)), scăderea(np.subtract(x,y)), înmulțirea (np.multiply(x,y)),
împărțirea (np.divide(x,y)), înmulțirea scalară (np.dot(x,y)) a matricelor x și y și funcția pentru
determinarea transpusei matricei x (x.T) și inversei matricei y (np.linalg.inv(y)). După rulare trebuie să
obținem următorul răspuns:

import numpy as np
y =np.array([[2, 3], [1, 7]])
x=np.array([[3, 9] ,[8, 5]])
print ('Suma matricelor x+y= ')
print(np.add(x,y));

73
print ('Diferenta matricelor x-y= ')
print(np.subtract(x,y))
print ('Produsul matricelor x*y= ')
print(np.multiply(x,y));
print ('Impartirea matricelor x/y= ')
print(np.divide(x,y));
print ('Transpusa matricei x= ')
print(x.transpose())
print ('Inversa matricei y= ')
print(np.linalg.inv(y));

Ex5_11
În acest exercițiu trebuie să analizați 2 coduri și fără a rula codurile trebuie să vă dați seama care va fi
răspunsul:
a) b)

a)
2
b) )
0
Ex5_12
În acest exercițiu trebuie să creăm un cod în care să cerem de la utilizator să introducă limita de jos și
limita de sus. Din acest șir de numere trebuie să cream o listă nouă lista_mea = [] în care să se
regăsească doar numerele multele cu 4 și non multiple cu 3. Deoarece suntem la tema despre funcții codul
creat trebuie să se bazeze pe o funcție creată de noi. La soluții vor fi date două răspunsuri a) cod care nu
se bazează pe funcție creată de programist b) cod care se bazează pe o funcție creată de programist. În
ambele cazuri după rularea codului trebuie să obținem următorul răspuns:

x=int(input('Introdu limita de jos: '))


y=int(input('Introdu limita de sus: '))
nr=range(x,y)
zz=[]
for i in nr:
zz.append(nr[i])
lista_mea = list(filter(lambda x: (x % 4 == 0) and (x % 3 == 1), zz))
print(lista_mea)

74
Ex5_13
Folosind bibliotecile NumPy și Matplotlib creați în aceeași figură graficele următoarelor funcții
Liniile celor trei grafice trebuie să fie diferite: culoare,
tip linie, grosime linie și marker linie.
După rularea codului un răspuns care putem să îl obținem poate arăta în felul următor:

import numpy as np
from cmath import pi
from matplotlib import pyplot as plt
x = np.arange(0, 3 * np.pi, 0.1)
y1 = 2 * (x*x) + x-4
y2 = 4 * (x*x) + (2*x)-1
y3= x*x + 4*x-2
plt.plot(x,y1, "y--s")
plt.plot(x,y2, "k--o")
plt.plot(x,y3, "r->")
plt.ylim(0, 350)
plt.xlim(-10, 10)
plt.show()

75
Ex5_14
Modificați codul din exemplul 5_13 astfel încât să obținem cele trei grafice ale ecuațiilor 𝑦=

în aceeași figură dar ca 3 sub figuri


distincte.După rulare trebuie să obținem următoarea reprezentare grafică:
import numpy as np
from cmath import pi
from matplotlib import pyplot as plt
x = np.arange(0, 3 * np.pi, 0.1)
y1 = 2 * (x*x) + x-4
y2 = 4 * (x*x) + (2*x)-1
y3= x*x + 4*x-2
plt.subplot(3,1,1)
plt.plot(x,y1, "y--s")
plt.legend("2 * (x*x) + x-4")
plt.subplot(3,1,2)
plt.plot(x,y2, "k--o")
plt.legend("4 * (x*x) + (2*x)-1")
plt.subplot(3,1,3)
plt.plot(x,y3, "r->")
plt.legend("x*x + 4*x-2")
plt.show()

76
Modulul TURTLE
1.

from turtle import Turtle, mainloop


from time import perf_counter as clock

def tree(plist, l, a, f):

if l > 5:
lst = []
for p in plist:
p.forward(l)
q = p.clone()
p.left(a)
q.right(a)
lst.append(p)
lst.append(q)
for x in tree(lst, l*f, a, f):
yield None

def maketree():
p = Turtle()
p.setundobuffer(None)
p.hideturtle()
p.speed(0)
p.getscreen().tracer(5,0)
p.left(90)
p.penup()
p.forward(-210)
p.pendown()
t = tree([p], 100, 5, 0.6375)
for x in t:
pass

def main():
a=clock()

77
maketree()
b=clock()
return "done: %.2f sec." % (b-a)

if __name__ == "__main__":
msg = main()
print(msg)
mainloop()

2.

from turtle import *


from datetime import datetime

def jump(distanz, winkel=0):


penup()
right(winkel)
forward(distanz)
left(winkel)
pendown()

def hand(laenge, spitze):


fd(laenge*1.15)
rt(90)
fd(spitze/2.0)
lt(120)
fd(spitze)
lt(120)
fd(spitze)
lt(120)
fd(spitze/2.0)

78
def make_hand_shape(name, laenge, spitze):
reset()
jump(-laenge*0.15)
begin_poly()
hand(laenge, spitze)
end_poly()
hand_form = get_poly()
register_shape(name, hand_form)

def clockface(radius):
reset()
pensize(7)
for i in range(60):
jump(radius)
if i % 5 == 0:
fd(25)
jump(-radius-25)
else:
dot(3)
jump(-radius)
rt(6)

def setup():
global second_hand, minute_hand, hour_hand, writer
mode("logo")
make_hand_shape("second_hand", 125, 25)
make_hand_shape("minute_hand", 130, 25)
make_hand_shape("hour_hand", 90, 25)
clockface(160)
second_hand = Turtle()
second_hand.shape("second_hand")
second_hand.color("pink", "pink")
minute_hand = Turtle()
minute_hand.shape("minute_hand")
minute_hand.color("red", "red")
hour_hand = Turtle()
hour_hand.shape("hour_hand")
hour_hand.color("yellow", "yellow")
for hand in second_hand, minute_hand, hour_hand:
hand.resizemode("user")
hand.shapesize(1, 1, 3)
hand.speed(0)
ht()
writer = Turtle()
#writer.mode("logo")
writer.ht()
writer.pu()
writer.bk(85)

def wochentag(t):
wochentag = ["Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday", "Sunday"]
return wochentag[t.weekday()]

79
def datum(z):
monat = ["Jan.", "Feb.", "Mar.", "Apr.", "May", "June",
"July", "Aug.", "Sep.", "Oct.", "Nov.", "Dec."]
j = z.year
m = monat[z.month - 1]
t = z.day
return "%s %d %d" % (m, t, j)

def tick():
t = datetime.today()
sekunde = t.second + t.microsecond*0.000001
minute = t.minute + sekunde/60.0
stunde = t.hour + minute/60.0
try:
tracer(False) # Terminator can occur here
writer.clear()
writer.home()
writer.forward(65)
writer.write(wochentag(t),
align="center", font=("Courier", 14, "italic"))
writer.back(150)
writer.write(datum(t),
align="center", font=("Courier", 14, "bold"))
writer.forward(85)
tracer(True)
second_hand.setheading(6*sekunde) # or here
minute_hand.setheading(6*minute)
hour_hand.setheading(30*stunde)
tracer(True)
ontimer(tick, 100)
except Terminator:
pass # turtledemo user pressed STOP

def main():
tracer(False)
setup()
tracer(True)
tick()
return "EVENTLOOP"

if __name__ == "__main__":
mode("logo")
msg = main()
print(msg)
mainloop()

80
3.

from turtle import *

class Disc(Turtle):
def __init__(self, n):
Turtle.__init__(self, shape="square", visible=False)
self.pu()
self.shapesize(3, n*3, 2) # square-->rectangle
self.fillcolor(n/6., 0, 1-n/6.)
self.st()

class Tower(list):
"Hanoi tower, a subclass of built-in type list"
def __init__(self, x):
"create an empty tower. x is x-position of peg"
self.x = x
def push(self, d):
d.setx(self.x)
d.sety(-15+34*len(self))
self.append(d)
def pop(self):
d = list.pop(self)
d.sety(150)
return d

def hanoi(n, from_, with_, to_):


if n > 0:
hanoi(n-1, from_, to_, with_)
to_.push(from_.pop())
hanoi(n-1, with_, from_, to_)

def play():
onkey(None,"space")
clear()
try:
hanoi(6, t1, t2, t3)
write("press STOP button to exit",
align="center", font=("Courier", 16, "bold"))

81
except Terminator:
pass # turtledemo user pressed STOP

def main():
global t1, t2, t3
ht(); penup(); goto(0, -25) # writer turtle
t1 = Tower(-25)
t2 = Tower(0)
t3 = Tower(25)
# make tower of 6 discs
for i in range(5,0,-1):
t1.push(Disc(i))
# prepare spartanic user interface ;-)
write("press spacebar to start game",
align="center", font=("Courier", 16, "bold"))
onkey(play, "space")
listen()
return "EVENTLOOP"

if __name__=="__main__":
msg = main()
print(msg)
mainloop()

Calculator in TKINTER

What has it ’s functions?


1. It can calculate multi process.
2. Program has + / - *.
3. Program has close function and clear memory.

82
try:
import Tkinter as tk
except ImportError:
import tkinter as tk

class Calculator:
def __init__(self):
self._stack = []
self._valid = [
'0','1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '-', '*', '/'
]

def add(self, text):


if text not in self._valid:
return ''
self._stack.append(text)
return text

def get(self):
return ''.join(self._stack)

def evaluate(self):
try:
result = eval(self.get())
except Exception as ex:
result = ex

return str(result)

def reset(self):
self._stack = []

class Window(tk.Tk):
is_reset = True

def __init__(self):
super().__init__()

self.calculator = Calculator()

self.geometry(self.get_geometry())
self.resizable(False, False)
self.title("Calculator")

self.result = tk.StringVar()
self.ent_result = tk.Entry(self, textvariable=self.result)
self.ent_result.place(relx=0.031, rely=0.031, relheight=0.266, relwidth=0.953)

83
self.ent_result.configure(background="white", font="TkFixedFont",
justify='right')

self.btn_7 = tk.Button(self)
self.btn_7.place(relx=0.031, rely=0.344, height=41, width=61)
self.btn_7.configure(text='7')

self.btn_8 = tk.Button(self)
self.btn_8.place(relx=0.281, rely=0.344, height=41, width=61)
self.btn_8.configure(text='8')

self.btn_9 = tk.Button(self)
self.btn_9.place(relx=0.531, rely=0.344, height=41, width=61)
self.btn_9.configure(text='9')

self.btn_add = tk.Button(self)
self.btn_add.place(relx=0.781, rely=0.344, height=41, width=61)
self.btn_add.configure(text='+')

self.btn_4 = tk.Button(self)
self.btn_4.place(relx=0.031, rely=0.5, height=41, width=61)
self.btn_4.configure(text='4')

self.btn_5 = tk.Button(self)
self.btn_5.place(relx=0.281, rely=0.5, height=41, width=61)
self.btn_5.configure(text='5')

self.btn_6 = tk.Button(self)
self.btn_6.place(relx=0.531, rely=0.5, height=41, width=61)
self.btn_6.configure(text='6')

self.btn_sub = tk.Button(self)
self.btn_sub.place(relx=0.781, rely=0.5, height=41, width=61)
self.btn_sub.configure(text='-')

self.btn_2 = tk.Button(self)
self.btn_2.place(relx=0.281, rely=0.656, height=41, width=61)
self.btn_2.configure(text='2')

self.btn_1 = tk.Button(self)
self.btn_1.place(relx=0.031, rely=0.656, height=41, width=61)
self.btn_1.configure(text='1')

self.btn_3 = tk.Button(self)
self.btn_3.place(relx=0.531, rely=0.656, height=41, width=61)
self.btn_3.configure(text='3')

self.btn_mul = tk.Button(self)
self.btn_mul.place(relx=0.781, rely=0.656, height=41, width=61)
self.btn_mul.configure(text='x')

84
self.btn_c = tk.Button(self)
self.btn_c.place(relx=0.031, rely=0.813, height=41, width=61)
self.btn_c.configure(text='C', activebackground='#FFF')

self.btn_0 = tk.Button(self)
self.btn_0.place(relx=0.281, rely=0.813, height=41, width=61)
self.btn_0.configure(text='0')

self.btn_eq = tk.Button(self)
self.btn_eq.place(relx=0.531, rely=0.813, height=41, width=61)
self.btn_eq.configure(text='=', activebackground='#456')

self.btn_div = tk.Button(self)
self.btn_div.place(relx=0.781, rely=0.813, height=41, width=61)
self.btn_div.configure(text='/')

self.init_events()

def init_events(self):
# butonlar
self.btn_0.bind('<Button-1>', func=lambda event: self.key_clicked('0'))
self.btn_1.bind('<Button-1>', func=lambda event: self.key_clicked('1'))
self.btn_2.bind('<Button-1>', func=lambda event: self.key_clicked('2'))
self.btn_3.bind('<Button-1>', func=lambda event: self.key_clicked('3'))
self.btn_4.bind('<Button-1>', func=lambda event: self.key_clicked('4'))
self.btn_5.bind('<Button-1>', func=lambda event: self.key_clicked('5'))
self.btn_6.bind('<Button-1>', func=lambda event: self.key_clicked('6'))
self.btn_7.bind('<Button-1>', func=lambda event: self.key_clicked('7'))
self.btn_8.bind('<Button-1>', func=lambda event: self.key_clicked('8'))
self.btn_9.bind('<Button-1>', func=lambda event: self.key_clicked('9'))

# operatörler
self.btn_add.bind('<Button-1>', func=lambda event: self.key_clicked('+'))
self.btn_sub.bind('<Button-1>', func=lambda event: self.key_clicked('-'))
self.btn_mul.bind('<Button-1>', func=lambda event: self.key_clicked('*'))
self.btn_div.bind('<Button-1>', func=lambda event: self.key_clicked('/'))
self.btn_c.bind('<Button-1>', func=lambda event: self.clear_clicked())
self.btn_eq.bind('<Button-1>', func=lambda event: self.enter_clicked())

self.bind('<Return>', func=lambda event: self.enter_clicked())


self.bind('<Key>', func=lambda event: self.key_clicked(event.char))

def key_clicked(self, key):


if self.is_reset:
self.result.set('')
self.is_reset = False

self.result.set(self.result.get() + self.calculator.add(key))

def enter_clicked(self):
self.result.set(self.result.get() + '=' + self.calculator.evaluate())

85
self.calculator.reset()
self.is_reset = True

def clear_clicked(self):
self.result.set('')
self.calculator.reset()

def get_geometry(self):
width = height = 320
x = (self.winfo_screenwidth() // 2) - (width // 2)
y = (self.winfo_screenheight() // 2) - (height // 2)
geometry = '{}x{}+{}+{}'.format(width, height, x, y)
return geometry

if __name__ == '__main__':
window = Window()
window.mainloop()

86
Laboratuarul nr. 6
1.

Creați un document în Notepad pe Descktop care să conțină o listă de fructe și legume ca în


exemplul de mai jos:

Să presupunem că ați creat documentul fructe.txt acum trebuie să scrieți un cod care să afișeze pe
ecran conținutul acestui document.
După rularea codului ar trebui să obținem afișat pe ecran:

87
Răspuns:
dosya = open("fructe.txt","r")
dizi = dosya.readlines()
print(dizi)

2.
Folosind fișierul creat în exemplul precedent fructe.txt trebuie să scriem un cod care să elimine din
document \n spațiile libere și caracterele speciale ! și %, iar la final să salvăm noul document sub
denumirea fructe_modificat.txt. Ca o sugestie va trebui să folosiți bucala for, instrucțiunea
condiționată if precum și comanda .strip() și funcția len() pentru a elimina elemente din listă. După
eliminarea tuturor elementelor și rularea codului vom obține următorul răspuns:

După crearea noului document fructe_modificat.txt îl putem accesa de pe Desktop:

Răspuns:

3.
Să presupunem că avem creat fișierul auto.txt ca în figură trebuie să scriem un cod care să elimine
rândurile care nu conțin denumiri de mărci germane în cazul nostru Toyota și Lexus, iar după rulare să
obținem un nou document auto1.txt care să conțină doar denumirile de mărci germane.

88
Răspuns:
a_file = open("auto.txt", "r")
lines = a_file.readlines()
a_file.close()
new_file = open("auto1.txt", "w")
for line in lines:
if line.strip("\n") != "Lexus" and line.strip("\n") != "Toyota":
new_file.write(line)

new_file.close()

4.
Să presupunem că avem o listă fructele_mele = ["Mere", "Pere", "Visine"] trebuie să
continuăm codul să citim documentul fructe.txt care îl avem deja creat în Notepad, după care să
eliminăm \n și să obținem o listă nouă care să conțină doar fructele care sunt comune pentru lista
fructele_mele și fructe.txt. După rulare vom obține elementele comune din cele liste pe care le
comparăm:

Răspuns:
fr = ["Mere", "Pere", "Visine"]

file = open("fructe.txt")

line = file.read().replace("\n", " ").split()


file.close()
text=line+fr dup = [x for i, x in enumerate(text) if x in text[:i]]
file = open("mele.txt", "w")

for i in dup:
file.write(str(i)+('\n'))
file.close()
print(dup)

89
5.
Trebuie să scriem un cod în care să cerem utilizatorului să introducă numele celor mai buni 5 prieteni.
După care să stocăm aceste nume într-un document nume_prieteni.txt. O mică sugestie va trebui să
folosim comanda .split() pentru a separa cele 5 nume introduse de utilizator. După rulare și după ce
utilizatorul introduce numele celor 5 prieteni ca în exemplu:

Trebuie să obținem noul document , care după ce îl deschidem să obținem:

Răspuns:
f=input("Introdu numele celor mai buni 5 prieteni: ").split("' '")
text_file = open("nume_prieteni.txt","w")
for x in f:
a=str(x)
text_file.write(a)

text_file.close()

6.
Avem documentul Registru1.csv pe Desktop.

Să presupunem că avem codul scris care deschide și citește acest document:

90
Trebuie să rulați codul și să explicați de ce obținem același rezultat.
Răspuns:
Noi in acest cod importam excelul adica “csv”, noi punem “r” adica citirea si
tabloul il punem in lista si primele 5 randuri spunem sa arate din “csvfile” =>
tabloul excel. Si iesim ca ca imagine vedem primele 5 randuri din excel alese pe
foaia lui

7.
Trebuie să scriem un cod în care cerem de la utilizator să introducă diferite cuvinte până nu introduce
cuvintele STOP. Toate cuvintele introduse te utilizator trebuie stocate într-un document nou cu denumirea
cuvinte.txt. Să presupunem că după rulare vom scrie următoarele cuvinte:

Pe Desktop va fi creat documentul cuvinte.txt. Dacă îl accesăm vom obține:

Răspuns:
file = open("test.txt", "w")
for i in range(1000):
i = input("Gir")
if i == 'STOP':
break

91
file.write((i)+(" "))
file.close()

8.
Studiu individual. În acest exercițiu trebuie să folosiți modulele fnmatch și os pentru a crea un cod
care să caute toate fișierele *.txt din calculatorul nostru. După rulare trebuie să obținem toate fișierele
*.txt
Răspuns:
import fnmatch
import os

for file in os.listdir('.'):


if fnmatch.fnmatch(file, '*.txt'):
print(file)

9.
Studiu individual. Iarăși trebuie să folosiți modulele fnmatch și os pentru a crea un cod care să
caute toate fișierele [*.jpg, *.jpeg, *.png] din calculatorul nostru. După rulare trebuie să obținem
toate fișierele *.jpg, *.jpeg, *.png

Răspuns:
import fnmatch
import os

for file in os.listdir('.'):


if fnmatch.fnmatch(file, '*.jpg'):
print(file)
if fnmatch.fnmatch(file, '*.jpeg'):
print(file)
if fnmatch.fnmatch(file,'*.png'):
print(file)

92
UTM LOGO

from tkinter import *


root = Tk()
root.title("UTM LOGO")
theLabel = Canvas(root, width=400,height=400,bg='black')
theLabel.pack()
theLabel.create_text(200, 355, text="Zafer AKBIYIK TI-211", fill="white",
font=('Helvetica 15 bold'))
theLabel.pack()
#
theLabel.create_rectangle(35,76,367,116, fill='yellow')
theLabel.create_rectangle(178,114,224,296, outline='yellow',fill='yellow')
theLabel.create_polygon(45,272,45,287,71,313,120,313,143,287,146,287,146,272,114,272
,105,281,86,281,77,272, fill='blue')
theLabel.create_rectangle(45,144,78,273, outline='blue',fill='blue')
theLabel.create_polygon([44,286,86,282], outline='blue',fill='blue')
theLabel.create_rectangle(114,144,145,271, outline='blue',fill='blue')
theLabel.create_polygon(251,144,251,313,284,313,284,249,302,296,319,249,319,313,352,
313,352,144,319,144,302,196,284,144, fill='red')
root.mainloop()

3 Drapele
UKRAINA
from tkinter import *
root = Tk()
root.title("Ukraina")
theLabel = Canvas(root, width=400,height=400,bg='black')
theLabel.pack()
theLabel.create_text(300, 275, text="Drapel", fill="Green", font=('Helvetica 15
bold'))
theLabel.create_text(300, 300, text="UKRAINA", fill="Red", font=('Helvetica 15
bold'))
theLabel.create_text(300, 325, text="Zafer AKBIYIK TI-211", fill="blue",
font=('Helvetica 15 bold'))
theLabel.pack()

93
theLabel.create_rectangle(20,20,40,380, fill='brown', outline='black')
theLabel.create_rectangle(40,30,200,75, fill='blue', outline='black')
theLabel.create_rectangle(40,75,200,125, fill='yellow', outline='black')
root.mainloop()

QATAR
from tkinter import *
root = Tk()
root.title("Qatar")
theLabel = Canvas(root, width=400,height=400,bg='black')
theLabel.pack()
theLabel.create_text(300, 275, text="Drapel", fill="Green", font=('Helvetica 15
bold'))
theLabel.create_text(300, 300, text="QATAR", fill="Red", font=('Helvetica 15 bold'))
theLabel.create_text(300, 325, text="Zafer AKBIYIK TI-211", fill="blue",
font=('Helvetica 15 bold'))
theLabel.pack()
theLabel.create_rectangle(20,20,40,380, fill='brown', outline='black')

theLabel.create_rectangle(40,30,100,125, fill='white', outline='black')


theLabel.create_rectangle(100,30,220,125, fill='maroon', outline='black')

theLabel.create_polygon([100,31,100,40.5,115,35.25],
outline='white',fill='white', width=2)
theLabel.create_polygon([100,40.5,100,51,115,45.75],
outline='white',fill='white', width=2)
theLabel.create_polygon([100,51,100,61.5,115,56.25],
outline='white',fill='white', width=2)
theLabel.create_polygon([100,61.5,100,72,115,66.75],
outline='white',fill='white', width=2)
theLabel.create_polygon([100,72,100,82.5,115,77.25],
outline='white',fill='white', width=2)
theLabel.create_polygon([100,82.5,100,93,115,87.75],
outline='white',fill='white', width=2)
theLabel.create_polygon([100,93,100,103.5,115,98.25],
outline='white',fill='white', width=2)
theLabel.create_polygon([100,103.5,100,114,115,108.75],
outline='white',fill='white', width=2)
theLabel.create_polygon([100,114,100,123.5,115,119.25],
outline='white',fill='white', width=2)
root.mainloop()

94
Sudan
from tkinter import *
root = Tk()
root.title("Sudan")
theLabel = Canvas(root, width=400,height=400,bg='black')
theLabel.pack()
theLabel.create_text(300, 275, text="Drapel", fill="Green", font=('Helvetica 15
bold'))
theLabel.create_text(300, 300, text="SUDAN", fill="Red", font=('Helvetica 15 bold'))
theLabel.create_text(300, 325, text="Zafer AKBIYIK TI-211", fill="blue",
font=('Helvetica 15 bold'))
theLabel.pack()
theLabel.create_rectangle(20,20,40,300, fill='brown', outline='black')

theLabel.create_rectangle(40,30,210,55, fill='Crimson', outline='white')

theLabel.create_rectangle(40,55,210,80, fill='white', outline='white')

theLabel.create_rectangle(40,80,210,115, fill='black', outline='white')


theLabel.create_polygon([40,30,40,115,100,67],outline='black', fill='#007229')
root.mainloop()

95
from tkinter import *
HEIGHT=650
WIDTH=550
window = Tk()
window.title('Doge Coin Wars')
panza=Canvas(window, width=WIDTH, height=HEIGHT, bg='white')
my_image=PhotoImage(file='doge.gif')
panza.create_image(30,30, anchor=NW, image=my_image)
panza.pack()

# Creăm nava cosmică și o fixăm în poziția inițială


nava = panza.create_polygon(25,0,0,25,25,50,50,25, fill='purple',
outline='DarkMagenta')
POZ_Y = (HEIGHT - 50)
POZ_X = WIDTH / 2
panza.move(nava, POZ_X, POZ_Y)

#Creăm mișcarea navei cosmice


PAS_MISCARE_PIXELI = 10
def nava_move(press):
if press.keysym == 'Left':
panza.move(nava, -PAS_MISCARE_PIXELI,0)
elif press.keysym == 'Right':
panza.move(nava, PAS_MISCARE_PIXELI,0)
elif press.keysym == 'Up':
make_shoot()
panza.bind_all('<Key>', nava_move)

#Creăm navele inamice


from random import randint
nava_inamica_nr = list()
nava_inamica_vit = list()
def nave_inamice():
y = 0
x = randint (40, WIDTH - 40)
vit = randint(2,5)
nr1 = panza.create_oval(x-20,y-20,x+20,y+20,
fill='green', outline='black')
nava_inamica_nr.append(nr1)
nava_inamica_vit.append(vit)

#Creăm mișcarea flotei de nave nave_inamice


def move_nave_inamice():
for i in range(len(nava_inamica_nr)):
panza.move(nava_inamica_nr[i],0,nava_inamica_vit[i])

#Creăm muniția pentru nava și evenimentul de lansare a muniției


shoot_nr = list()
shoot_vit = 12
def make_shoot():
if len(shoot_nr)<3:
pos = panza.coords(nava)
x = pos[0]
y = pos[1]
nr1 = panza.create_oval(x-6,y-6,x+6,y+6, fill='yellow',
outline='blue')
shoot_nr.append(nr1)

#Mișcăm muniția
def move_shoot():
for i in range(len(shoot_nr)):
panza.move(shoot_nr[i],0,-shoot_vit)

#Determinăm poziția muniției pe câmpul de joacă

96
def coords_shoot(nr_id):
pos = panza.coords(nr_id)
x = (pos[0]+pos[2])/2
y = (pos[1]+pos[3])/2
return x,y

# Ștergem muniția din câmpul de joacă și din listă


def del_shoot(i):
panza.delete(shoot_nr[i])
del shoot_nr[i]

#Ștergem muniția când depășeșete câmpul de joacă


def clean_shoot():
for i in range(len(shoot_nr)-1,-1,-1):
x,y = coords_shoot(shoot_nr[i])
if y < 0:
del_shoot(i)

#Determinarea coordonatelor navelor inamice


def coords_nava_inamica(nr_id):
pos = panza.coords(nr_id)
x = (pos[0]+pos[2])/2
y = (pos[1]+pos[3])/2
return x,y

#Ștergem navele inamice


def del_nava_inamica(i):
panza.delete(nava_inamica_nr[i])
del nava_inamica_nr[i]

#Ștergem navele inamice


def clean_nava_inamica():
for i in range(len(nava_inamica_nr)-1,-1,-1):
x,y = coords_nava_inamica(nava_inamica_nr[i])
if y > HEIGHT:
del_nava_inamica(i)

#Creăm funcția care va calcula distanța dinte nava inamică și proiectil


from math import sqrt
def distance(nr1,nr2):
x1,y1 = coords_nava_inamica(nr1)
x2,y2 = coords_shoot(nr2)
return sqrt((x2-x1)**2+(y2-y1)**2)

#Stergem corabia inamică și proiectilul care a nimerit în ea


def bumm():
for i in range(len(nava_inamica_nr)-1,-1,-1):
for n in range(len(shoot_nr)-1,-1,-1):
if distance(nava_inamica_nr[i],shoot_nr[n])<26:
del_nava_inamica(i)
del_shoot(n)

from time import sleep, time

while True:
if randint(1,40) == 1:
nave_inamice()
move_nave_inamice()
move_shoot()
clean_shoot()
clean_nava_inamica()
bumm()
window.update()
sleep(0.05)

97
98