From 84453a645690736b09dcdd894ed6979f629630c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandru=20Tof=C4=83nel?= Date: Fri, 27 Mar 2026 21:15:27 +0200 Subject: [PATCH] =?UTF-8?q?Am=20adaugat=20materialele=20din=20s=C4=83pt=20?= =?UTF-8?q?trecute.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- python/curs/curs2_intro_sintaxa.py | 203 ++++++++++++ python/curs/curs3_functii.py | 131 ++++++++ python/curs/curs4_array.py | 214 +++++++++++++ python/curs/curs5_np_ndarray.py | 257 +++++++++++++++ python/curs/curs6_matrice.py | 294 ++++++++++++++++++ python/curs/notare | 4 + python/extra/bday_messages.py | 17 + python/extra/intro.py | 33 ++ python/extra/main.py | 15 + .../python_syntax/classes_and_methods.py | 0 .../python_syntax/random_module.py | 0 python/laborator/lab3.py | 42 +++ python/laborator/lab3_2.py | 95 ++++++ python/laborator/lab4/1.py | 7 + python/laborator/lab4/2.py | 26 ++ python/laborator/lab4/untitled2.py | 27 ++ python/laborator/lab4/untitled3.py | 39 +++ python/laborator/lab4/untitled4.py | 17 + python/laborator/lab4/untitled5.py | 16 + python/laborator/lab4/untitled6.py | 24 ++ python/laborator/lab4/untitled7.py | 41 +++ python/laborator/lab4/untitled8.py | 22 ++ python/laborator/lab5.py | 110 +++++++ 23 files changed, 1634 insertions(+) create mode 100644 python/curs/curs2_intro_sintaxa.py create mode 100644 python/curs/curs3_functii.py create mode 100644 python/curs/curs4_array.py create mode 100644 python/curs/curs5_np_ndarray.py create mode 100644 python/curs/curs6_matrice.py create mode 100644 python/curs/notare create mode 100644 python/extra/bday_messages.py create mode 100644 python/extra/intro.py create mode 100644 python/extra/main.py rename python/{ => extra}/python_syntax/classes_and_methods.py (100%) rename python/{ => extra}/python_syntax/random_module.py (100%) create mode 100644 python/laborator/lab3.py create mode 100644 python/laborator/lab3_2.py create mode 100644 python/laborator/lab4/1.py create mode 100644 python/laborator/lab4/2.py create mode 100644 python/laborator/lab4/untitled2.py create mode 100644 python/laborator/lab4/untitled3.py create mode 100644 python/laborator/lab4/untitled4.py create mode 100644 python/laborator/lab4/untitled5.py create mode 100644 python/laborator/lab4/untitled6.py create mode 100644 python/laborator/lab4/untitled7.py create mode 100644 python/laborator/lab4/untitled8.py create mode 100644 python/laborator/lab5.py diff --git a/python/curs/curs2_intro_sintaxa.py b/python/curs/curs2_intro_sintaxa.py new file mode 100644 index 0000000..6d000f2 --- /dev/null +++ b/python/curs/curs2_intro_sintaxa.py @@ -0,0 +1,203 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Feb 25 15:17:23 2026 + +@author: alex +""" + +import math + +luna = 13 +permis = 1 <= luna <=12 +print(permis) + +s1 = "Matematica" +s2 = "info" +s3 = """Prima +linie""" + +print ("Ana" + " " "Pop") +print ("=" * 20) + +print(len("Matematica")) +print("mat" in "Matematica") + +s = "string" +s = 'A' + s[1:] +print (s) + +s = "Matematica" +print(s[0]) +print(s[4]) +print(s[-1]) +print(s[-3]) + +#slicing s[start:stop:pas] + +print(s[0:4]) +print(s[4:]) +print(s[:4]) +print(s[::2]) + +s ="Buna ziua! " +t = s.strip() +print(t) +t = s.upper() +print(t) +t = s.lower() +print(t) +t = s.replace('ziua','dimineata') +print(t) + +x = 1 + +if x>0: + print('pozitiv') + print('si real') +print('mereu') + +raza = float(input("raza: ")) +pi = math.pi + +aria = pi*raza**2 +circum = 2*pi*raza + +print(f"aria este: {aria:.4f} m patrati") +print(f"circumferinta este: {circum:.4f} m") + +n = int(input("n: ")) + +if n == 0: + print("n este 0") +else: + if n > 0: + semn = "pozitiv" + elif n < 0: + semn = "negativ" + if n % 2: + print(f"{n} este par si {semn}") + else: + print(f"{n} este impar si {semn}") + +n = 100 +suma = 0 +for i in range(1, n+1): + suma += i +print(suma) +print(n*(n+1) // 2) + +for i in range(5, 0, -1): + print(i, end = ' ') + +for litera in "Math": + print(litera) + +a = int(input('a= ')) +b = int(input('b= ')) + +while b != 0: + a, b = b, a % b +print (f"cmmdc = {a}") + +numar = int(input("numarul este ")) +card = int(0) +while numar != 0: + numar //= 10 #doua // inseamna / + card = card +1 +print (f"numarul de cifre al numarului este {card}") + +x = int(input("x = ")) +if x > 0: + print("pozitiv") + if x > 100: + print("mare") + + +numar_intreg = 42 +numar_real = 3.14159 +numar_complex = 3 + 4j +text = "matematica" +adevarat = True + +print(type(numar_intreg)) +print(type(numar_real)) +print(type(numar_complex)) +print(type(text)) +print(type(adevarat)) + +z1 = 3 + 4j +z2 = 1 - 2j + +print(z1.real) +print(z1.imag) +print(abs(z1)) +print(z1+z2) +print(z1*z2) +print(z1.conjugate()) + +n = int(input("Numar: ")) +print(n+1) + +nume = "Ana" +varsta = 20 +medie = 9.75 + +print("Studentul " + nume + " are " + str(varsta) + " ani ") + +print(f"Studentul {nume} are {varsta} ani.") + +print(f"Peste 5 ani {nume} va avea {varsta + 5} ani.") + +print(f"Dublul mediei este {2 * medie}") + +pi = math.pi + +print(f"pi = {pi:.2f}") +print(f"pi = {pi:.5f}") + +numar_mic = 0.000001234 +print(f"{numar_mic:.3e}") + +n = 1000000 +print(f"{n:,}") + +p = 0.8765 +print(f"{p:.1%}") + +for i in range(1,6): + print(f"{i:3d} | {i**2:5d} | {math.sqrt(i):.4f}") + + +x = float(input("Introdu un numar real: ")) +if x > 0: + print(f"{x} este pozitiv") +elif x < 0: + print(f"{x} este negativ") +else: + print("Numarul este zero") + +n = 10 +suma = 0 +for i in range (1,n+1): + suma += i + +print(f"Suma 1+2+3+...+{n} = {suma}") +formula = n * (n + 1) // 2 +print(f"Formula lui Gauss: n*(n+1)/2 = {formula}") + + +n = int(input("Introdu un numar intreg pozitiv: ")) +nr_cifre = 0 +temp = n + +while temp > 0: + temp //= 10 + nr_cifre += 1 + +print(f"Numarul {n} are {nr_cifre} cifre") + +n = int(input("n: ")) +for i in range(1,n+1): + if type(math.sqrt(i)) == int(math.sqrt(i)): + print(f"{i:3d} | {i**2} | {math.sqrt(i):.8f}") \ No newline at end of file diff --git a/python/curs/curs3_functii.py b/python/curs/curs3_functii.py new file mode 100644 index 0000000..4fdaebb --- /dev/null +++ b/python/curs/curs3_functii.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Mar 4 14:39:09 2026 + +@author: alex +""" + +import math + +#functii +def expr(a, b): + return (a*a - b*b)/(a + b) + +def este_prim(n): + if n < 2: + return False + for i in range (2, int(n**0.5 + 1)): + if n%i == 0: + return False + return True + +def putere(x, p=2): + return x**p +#p=2 val default, param def la final + +def f(a,b,c=0): + return a + 10*b +100*c + +def adauga(x, lista=None): + if lista is None: + lista = [] + lista.append(x) + return lista + +def impartire(a,b): + cat = a//b + rest = a%b + return cat,rest + + +def aplica(f, lista): + rezultat = [] + for x in lista: + rezultat.append(f(x)) + return rezultat + +def gdc(a, b): + if b == 0: + return a + return gdc(b, a % b) + +def fact(n): + if n <=1: # conditie + return 1 + return n * fact(n-1) # pas recursiv + +def fact_it(n): + p = 1 + for k in range(2,n+1): + p *= k + return p #nerecursiv + +print(expr(10,5)) + +print(este_prim(3)) + +print(putere(3)) #functie cu puterea 2 default +print(f(1,2,c=3)) #exemplu parametrii +print(f(1,2,3)) + +lista=[1,2,3] +adauga(4,lista) +print(lista) + +c, r = impartire(17,5) +print(c,r) + +valori = [0, 1, 4, 9, 16] + +print(aplica(math.sqrt, valori)) # functia este paramentrul altei functii sus + +print(gdc(2, 9)) +print(fact(10)) +print(fact_it(10)) + +#functii de o linie lambda +patrat = lambda x: x*x +print(patrat(5)) + +semn = lambda x: -1 if x < 0 else 1 +print(semn(-7),semn(3)) + +numere = [1, 4, 9, 16, 25] +radacini = list(map(math.sqrt, numere)) #map prelucreaza lista si transforma +#fiecare element al listei, transformare in-place / map(f, [a,b,c]) => [f(a), f(b), f(c)] +#nu are legatura cu structura map din c++ +print(radacini) + +pare = list(filter(lambda x: x%2 == 0, range(10))) +#filtreaza +print(pare) + +numere1= list(range(10)) +pare1 = list(filter(lambda x: x%2 == 0, numere1)) +# filter(p, [a,b,c]) p = paramentrul de filtrare i.e. functie cu return +print(pare1) + +#Recursivitate +print(fact(5)) + +#Comprehensions: metoda const o colectie (lista/dict/set) dintr-un iterabil +#folosind for si optional if +#lista = [] +#for x in A: lista.append(expresie) +#eq +#[expresie for x in A] +patrate = [x*x for x in range(10)] +print(patrate) + +patrate_pare = [x*x for x in range(10) if x%2 == 0] +print(patrate_pare) + +func = lambda x: x*x - 5*x + 6 +sol = [x for x in range (-10, 11) if func(x) < 0] +print(sol) + +#list map filter comprehensions diferente +#list(map(f,A)) ... [f(x) for x in A] +#list(filter(p,A)) .. [x for x in A if p(x)] +#list(map(f, filter(p,A))) ... [f(x) for x in A if p(x)] \ No newline at end of file diff --git a/python/curs/curs4_array.py b/python/curs/curs4_array.py new file mode 100644 index 0000000..bb79f99 --- /dev/null +++ b/python/curs/curs4_array.py @@ -0,0 +1,214 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Mar 11 14:12:41 2026 + +@author: alex +""" + +# lista + +x1 = 3 +x2 = 7 +x3 = 10 +x4 = 12 + +print (x1 + x2 + x3 + x4) + +valori = [3,7,10,12] +print(sum(valori)) + +# tipuri: liste, tuple, set ,dictionar +# lista col ord mod; tuple col ord nemod +# set col fara duplicate +# dic - map C++ +# ordonate =/= sortate; pastreaza ordinea data +# lista -> vector nr. ex + +note = [7,8,9,10] +print(note) +date = [3,4.5,"Ana"] +print(date) +print(note[0]) +print(note[2]) +print(note[-1]) +print(note[-4]) + +note = [7, 8, 9] +note[1] = 10 +print(note) + +valori = [1,2,3] +valori.append(4) +print(valori) +valori.remove(2) # sterge 2 din lista, nu indexul 2 +print(valori) + +x = valori.pop() # scoate ultimul si da return +print(x) +print(valori) + +note = [7,8,9,10] +for n in note: + print(n) + +# Exercitii + +#1 + +lista = [] + +for i in range(1,11): + lista.append(i) + +print(sum(lista)) +print(lista) + +elemente = [2, 5.6, "Text"] +print(elemente[-1]) +print(elemente[-2]) +elemente[-1] = 7 +print(elemente[-1]) + +#Tuple +#paranteze rotunde, nu se modifica, pot avea oricate elemente +punct = (2,5) +data = ( 15, 3, 2005) +culoate = (0,0,0) +#accesarea +print(data[0]) +print(data[1]) +print(data[2]) + +punct=(2,5) +#punct[0] = 1 EROARE + +def impartire(a,b): + cat = a // b + rest = a % b + return(cat,rest) +print(impartire(2,3)) + +coordonate = (2,5) +print(coordonate) +print(f"abscisa: {coordonate[0]}, ordonata: {coordonate[1]} ") + +c = (5, coordonate[1]) +coordonate = c +coordonate = (coordonate[0], 3) +print(coordonate) + +#Seturi +#fara duplicate, ordine neimportatnta, operatii cu multimi + +A = {1,2,3,3,4} +print(A) + +A = {1,2,3} +B = {3,4,5} + +print(A | B) #reuniune +print(A & B) #intersect +print(A - B) #dif + +cuvant = "matematica" +litere = set(cuvant) +print(litere) #ordinea nu se pastreaza + +litere1 = set("matematica") +litere2 = set("informatica") +print(litere1) +print(litere2) + +print(litere1 | litere2) +print(litere1 & litere2) +print(litere1 - litere2) +print(litere2 - litere1) + +#Dictionar +# cheie -> val +note = { + "Ana": 10, + "Ion": 8, + "Maria": 9 +} +print(note["Ana"]) + +note = {"Ana": 10, "Ion": 8} +note["Maria"] = 9 +note["Ion"] = 10 +print(note) + +for nume, nota in note.items(): + print(nume,nota) + +note = [7,8,9,10] +print(len(note)) # lungime +print(8 in note) # search function +print(5 in note) + +valori = [10,20,30,40,50,60] +print(valori[1:4]) #slicing; ultima val nu e inclusa +print(valori[:3]) +print(valori[3:]) +print(valori[::2]) #din 2 in 2 (al 3lea parametru) + +note = [7,8,9,10] + +for n in note: # i.e. for each + print(n) + +for i in range(len(note)): # for range + print("index =", i, "valoare = ", note[i]) + +for i, x in enumerate(note): # echivalent cu ^ + print(i, x) + +#sort + reverse +valori = [7,2,9,1,5] +valori.reverse() +print(valori) +valori.sort() +print(valori) +valori.reverse() +print(valori) +# = sorted() +valori = [7,2,9,1,5] +copie_sortata = sorted(valori) +print(valori) +print(copie_sortata) + +print(valori.count(2)) +print(valori.count(3)) +print(valori.index(2)) + +note = {"Ana": 10, "Ion":8 } +print(note.keys()) +print(note.values()) +print(note.items()) +print("Ana" in note) +print("Maria" in note) + +valori = [10,20,30] +#print(valori[3]) EROARE in afara listei + +note = {"Ana": 10, "Ion":8 } +#print(note["Maria"]) EROARE pt. ca cheia nu exista in dictionar + +a = {} #nu creaza multime vida; ci dic vid +b = set() #creaza multime vida +print(type(a)) +print(type(b)) + +note =[7,8,9,10] +media = sum(note) /len(note) +print(media) + +valori = [1,2,2,3,4,4,4,5] #transforma lista in set, i.e se elimina duplicate +distincte = set(valori) +print(distincte) + +tabel = {} # asociaza elemente din domeniu in codomeniu +for x in range (-2,3): # util pentru functii ex. x -> x^2 + 1 + tabel[x] = x*x +1 +print(tabel) diff --git a/python/curs/curs5_np_ndarray.py b/python/curs/curs5_np_ndarray.py new file mode 100644 index 0000000..3beb2d6 --- /dev/null +++ b/python/curs/curs5_np_ndarray.py @@ -0,0 +1,257 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Mar 18 14:16:17 2026 + +@author: alex +""" +import numpy as np + +#ndarray + +def delimit(i): + print(" ") + print(f"-({i})-" + 48*"-") + +delimit(0) + + +x = [1, 2, 3, 4] + +# fara numpy +rez = [] +for t in x: + rez.append(t*t + 1) +print(rez) + +# cu numpy +x = np.array([1, 2, 3, 4]) +rez = x * x + 1 +print(rez) + +delimit(1) + + +a = np.array([1, 2, 3]) +b = np.zeros(4) # 4 zerouri + +print(np.mean(a)) + +a = np.array([1, 2, 3, 4]) +print(a) +print(type(a)) #ndarray + +delimit(2) + + +A = np.array([[1,2,3], + [4,5,6]]) +print(A) +print(A.shape) +print(A.ndim) + +delimit(3) + + +L1 = [1,2,3] +L2 = [4,5,6] +print(L1+L2) #concatenare + +a = np.array([1, 2, 3]) +b = np.array([4, 5, 6]) +print(a+b) #adunare vectoriala + +print(L1*2) #dublare lista +print(a*2) #inmultire cu scalar + +delimit(4) + + +a = np.array([1, 2, 3]) +b = a * a + 1 +print(a) +print(b) + +delimit(5) + + +a = np.array([[1, 2, 3]]) #matrice de o linie si 3 coloane +print(a.shape) #(linii, coloane) +a = np.array([1,2,3]) # matrice de 3 linii si '0' coloane +# a doua forma e transpusa primei si viceversa +print(a.shape) + +b = a + a + 1 # exhivalent cu b = 2*a + 1 + +print(a) +print(b) +print(b-a) + +delimit(6) + + +c = np.array([[1,2,3], + [4,5,6]]) + +print(c) +print(c.shape) + +delimit(7) + + +lista = [1,2,3] +#print(lista + 1 ) # EROARE +lista2 = [1] +print(lista + lista2) #corect +print(lista + [6]) # corect + +delimit(8) + + +x = [0,1,2,3] +y = [] +for t in x: + y.append(t**2 + 1) +print(y) #explicit + +y = [t**2 + 1 for t in x] +print(y) #list comprehensions + +x = np.array([0,1,2,3]) +y = x**2 + 1 #array in numpy +print(y) + +# echivalente ^ + +delimit(9) + + +a = np.array([10,20,30,40]) +print(a) +print(a.shape) # 4 linii 1 col (4,) +print(a.size) # numarul de elemente +print(a.dtype) # tipul elementelor i.e. int64 +print(a.ndim) # numarul de dimensiuni ale array-ului + +delimit(10) + + +c = np.array([[1,2,3], + [4,5,6]]) + +print(c) +print(c.shape) +print(c.size) +print(c.dtype) +print(c.ndim) + +delimit(11) + + +#tip date int si float +a = np.array([1, 2, 3]) +b = np.array([1., 2., 3.]) +b_1 = np.array([1., 2, 3.]) + +print(a.dtype) +print(b.dtype) +print(b_1.dtype) + +delimit(12) + + +a = np.zeros(5) # 5 zerouri +b = np.ones(4) # 4 de 1 +c = np.arange(0, 10, 2) # A RANGE de la 0 la 10 din 2 in 2 (pas); + # 10 nu e luat in calcul +d = np.linspace(0, 1, 5) # multime de la 0 la 1 cu 5 elemente echidistante + # se foloseste pentru a crea domeniul unei functii pe interval +print(a) +print(b) +print(c) +print(d) + +delimit(13) + + +# operatii vectorizate + +a = np.array([1,2,3]) +print(a + 1) +print(a - 1) +print(a / 2) +print(a // 2) +print(2 * a) + +b = np.array([4,5,6]) + +print(a + b) +print(b - a) +print(b / a) +print(a * b) + +c = np.array([1,2,3]) +d = np.array([10,20]) +#print(c+d) # EROARE, array-urile trebuies sa fie de marime egala + +delimit(14) + + +a = np.array([0, np.pi/6, np.pi/4, np.pi/3, np.pi/2]) +print(np.sin(a)) +print(np.cos(a)) +#face aproximari a lui pi si deci cos(pi/2) nu e exact 0 + +delimit(15) + + +y = np.array([1,1,4,9,16,16]) +print(np.sqrt(y)) + +print(np.min(y)) +print(np.max(y)) +print(np.argmin(y)) # prima pozitie la care apare min +print(np.argmax(y)) # prima pozitie la care apare max + # indexate de la 0 +print(np.where(y == np.min(y))) +#gaseste toate pozitiile la care se gaseste elementul care +#satisface conditia ex. min +print(np.sum(y)) # suma +print(np.mean(y)) # media +print(np.std(y)) # eroarea medie statistica + +n = np.array([-1,-1,-4,-9,-16,-16,1,1,4,9,16,16]) +print(np.abs(n)) # modul + +a = np.array([4,7,2,9,10]) +print(np.sort(a)) +print(a) # nu modifica pe loc variabila + +delimit(16) + + +L = [1, 2, 3, 4] +a = np.array(L) + +print(L) +print(a) +print(type(L)) +print(type(a)) +L_1 = a.tolist() +print(L_1) +print(type(L_1)) + +delimit(17) + + +# Exemplu de program numpy.array vs list + for + +temperaturi = [10,15,30,40] +temperaturi_f = [] +for temp in temperaturi: + temperaturi_f += [(temp * (9/5) + 32)] +print(temperaturi_f) + +temperaturi = np.array([10,15,30,40]) +temperaturi_f = temperaturi * (9/5) + 32 +print(temperaturi_f) diff --git a/python/curs/curs6_matrice.py b/python/curs/curs6_matrice.py new file mode 100644 index 0000000..64b0d62 --- /dev/null +++ b/python/curs/curs6_matrice.py @@ -0,0 +1,294 @@ +# -*- coding: utf-8 -*- +import numpy as np + +#NumPy avansat + +def delimit(i): + print(" ") + print(f"-({i})-" + 48*"-") + +delimit(0)################################################################# + +v = np.array([1,2,3,4,5,6]) + +print(v[0]) +print(v[2]) +print(v[-1]) +print(v[1:4]) # de la 1 pana inainte de 4 +print(v[:3]) # pana inainte de 3 +print(v[3:]) # de la 3 +print(v[::2]) # pas + +delimit(1)################################################################# + + +L = [1,2,3,4,5,6] +L[1:4] = [0,0,0] # atribuie lista; L[1:4] = 0 gresit +print(L) + +v[1:4] = 0 # atribuie scalar direct +print(v) + +delimit(2)################################################################# + +A = np.array([[1,2,3], + [3,4,6], + [7,8,9]]) +print(A) +print(A.ndim) +print(A.size) + +delimit(3)################################################################# + +Z = np.zeros((2,3)) +O = np.ones((3,2)) +I = np.eye(3) + +print(A) +print(O) +print(I) + +delimit(4)################################################################# + +a= np.arange(1,7) +A = a.reshape(2,3) +print(a) +print(A) + +delimit(5)################################################################# + +A = np.array([[1,2,3], + [3,4,6], + [7,8,9]]) + +print(A[0,0]) # extrage element +print(A[1,2]) +print(A[2,1]) +print(A[1,:]) # extragere de linii; linia a doua +print(A[:, 0]) # extrage coloana 1 + +A = np.array([[1,2,3,4], + [5,6,7,8], + [9,10,11,12]]) +print(A[0:2, 1:3]) #extrage submatrice taind 0:2 pe linii si 1:3 pe col + +delimit(6)################################################################# + +# Operatii cu matrice in NumPy + +#A*B nu inseamna in general produs matricial + +A = np.array([[1,2], + [3,4]]) +B = np.array([[1,2], + [3,4]]) + +print(A+B) +print(A-B) + +# A * B +print(A * B) # element cu element nu matricial + +# A @ B +print(A @ B) # inmultire normala + +# Inmultirea cu scalar +print(3 * A) + +# alte operatii + +print(A.T) # transpusa +print(np.linalg.inv(A)) # inversa cu .inv din sublibraria .linalg +print(A^(-1)) # matricea cu inversele per element + +delimit(7)################################################################# + +# Broadcasting + +# combina automat array-uri cu forme diferite, extinzand implicit o dim. +# pentru a face operatia posibila +# functioneaza doar atunci cand formele array-urilor sunt compatibile + +A = np.array([[1,2,3], + [4,5,6], + [7,8,9]]) +v = np.array([1,2,3]) #vector linie + +print(A+10) # scalarul 10 este extins la forma matricei ex. (3x3) +print(A + v) # vectorul (:1) este extins la forma 3x3 i.e adauga vectorul +# pe cate numere sunt necesare + +u = np.array([[10], + [20], + [30]]) # vector coloana + +print(A + u) + +print(u+v) # adunare vector linie cu vector coloana +# extinde vectorul coloana in asa fel sa se potriveasca cu numarul de col +# a vectorului linie, si analog extinde vectorul inie i.e. (1x3) + (3x1) = (3x3) +# dimensiunea vec col = dim vec linie pentru ca numpy sa nu dea EROARE +# broadcasting-ul functioneaza cand dim matricilor sunt egale sau cand +# una dintre dimensiuni este 1. + +delimit(8)################################################################# + +A = np.array([[1, 2, 3], + [4, 5, 6]]) +print(np.sum(A)) +print(np.min(A)) +print(np.max(A)) +print(np.mean(A)) +# functiile de mai sus se fac cu toate elementele matricei + +#sume pe linie sau coloana + +print(np.sum(A, axis=0)) #return matrice cu sume per coloane +print(np.sum(A, axis=1)) #return matrice cu sume per linii + +print(np.mean(A, axis=0)) #return matrice cu medii per coloane +print(np.mean(A, axis=1)) #return matrice cu medii per linii + +print(np.max(A, axis=0)) #return matrice cu maxime de pe coloane +print(np.max(A, axis=1)) #return matrice cu maxime de pe linii + +print(np.min(A, axis=0)) #return matrice cu minime de pe coloane +print(np.min(A, axis=1)) #return matrice cu minime de pe linii +#axis = 0 coloane +#axis = 1 linii + +delimit(9)################################################################# +# A de mai sus + +rang_A = np.linalg.matrix_rank(A) +print(rang_A) # merge chiar daca matricea nu e patratica; rang deltaP + +A = np.array([[1,2,3], + [4,5,6], + [7,8,9]]) + +print(A) +det_A = np.linalg.det(A) +print(det_A) +#A_inv = np.linalg.inv(A) +#print(A_inv) # det matricei de mai sus este 0 si nu are inversa + +A_2 = np.array([[1,2,1], + [4,5,6], + [7,8,9]]) + +det_A_2 = np.linalg.det(A_2) +print(det_A_2) + +A_2_inv = np.linalg.inv(A_2) +print(A_2_inv) + +rang_A_2 = np.linalg.matrix_rank(A_2) +print(f"Rangul matricei A_2 (3x3) cu determinantul {det_A_2} este {rang_A_2}") + +A = np.array([[2,1], + [1,3]]) +b = np.array([1,2]) #solve + +print("Solutiile sistemului de ecuatii sunt: ", np.linalg.solve(A,b)) + +A = np.array([[1,2], + [3,4]]) + +A_inv = np.linalg.inv(A) +print(A @ A_inv) # inversa se face prin aproximari deci inmultirea nu o sa +# de matricea unitate; +# din acest motiv nu comparam direct matrici cu elemente de tip float folosind == +# in schimb folosim np.allclose() sa vedem daca elementele sunt apropiate + +print(A == A_inv) + +A = np.array([[1,0,0], + [0,1,0], + [0,0,1]]) +A_inv = np.linalg.inv(A) + +print(A) +print(A_inv) +print(A.T) +simterica = np.allclose(A, A.T) + +I = np.eye(A.shape[0]) # .shape() are output un tuple cu dimensiunile [0] scoate + # numarul liniilor, iar eye creaza mat. identitate de + # dimensiunea respectiva +print(I) # float-uri +print(A) # inturi + +print(I == A) # elementel din matrice sunt egale intre ele => matrice 3x3 de True +print(A == A_inv) # in cazul asta e True, dar mai sus e un exemplu pentru care +# aproximarile float al inversei cu val reale a inversei ar da False +ortogonala = np.allclose(A, A_inv) # true +print(ortogonala) # matricea identitate este egala cu inversa ei + +delimit(10)################################################################# + +a = np.array([1,2,7,1,9,5,8,9]) +print(a) + +print(np.where(a == 1)) # vector print unde el. = 1 + + +A = np.array([[4,2,7], + [1,5,1], + [3,6,8]]) + +poz = np.where(A == 1) +print(A) +print(poz) # pozitiile pentru care elementul din a este 1 +print(poz[0]) # randurile pe care se gasesc +print(poz[1]) # coloanele pe care se gasesc + +for row, col in zip(*poz): + print(f"({row}, {col})") +# zip(*poz) face perechi element cu element din lista de tuples de tipul i,j +# altfel coordonatele sunt in doua liste separate + +delimit(11)################################################################# + +col = np.array([0,2,0,2,2,1]) +print(np.unique(col)) # pastreaza din array doar elementele care sunt distincte +mat = np.array([[0,2,0], + [2,2,1]]) # pe matrice o forteaza intr-un vector si da return +print(np.unique(mat)) # elementelor distincte + +delimit(12)################################################################# + +# Problema, se da o matrice sa se determine coloanele pe care apare val min din +#matrice iar pe aceste coloane sa se adauge o constanta c. (cu np.where) + +c = 10 +minim = np.min(A) +linii, coloane = np.where(A == minim) #coloanele unde exista min +coloane_unice = np.unique(coloane) #elimina duplicate pentru nu a aduna c + #de doua ori + +A_nou = A.copy() +A_nou[:, coloane_unice] += c +#^merge pe fiecare linie pe coloanele din vectorul de coloane unice + +print("Minimul:", minim) +print("Linii: ", linii) +print("Coloane: ", coloane) +print("Coloane distincte:", coloane_unice) + +delimit(13)################################################################# + +# Se da o matrice A. Sa se determine coloanele in care apare valoarea maxima +# din matrice , iar toate elementele de pe aceste coloane sa fie inlocuite cu 0. + +maxim = np.max(A) +linii, coloane = np.where(A == maxim) +coloane_unice = np.unique(coloane) +A_nou = A.copy() + +A_nou[:, coloane_unice] = 0 + +print("Maximul: ", maxim) +print("Coloane unice: ", coloane_unice) +print("Matricea modificata: ") +print(A_nou) \ No newline at end of file diff --git a/python/curs/notare b/python/curs/notare new file mode 100644 index 0000000..f4c4bb8 --- /dev/null +++ b/python/curs/notare @@ -0,0 +1,4 @@ +examen 30% +test lab 30% +proiect final 30% +activitate 10% diff --git a/python/extra/bday_messages.py b/python/extra/bday_messages.py new file mode 100644 index 0000000..671de14 --- /dev/null +++ b/python/extra/bday_messages.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Sat Mar 21 18:28:22 2026 + +@author: alex +""" +import random +import pandas + +bday_messages = ['Hope you have a very Happy Birthday! 🎈', +'It\'s your special day – get out there and celebrate! 🎉', +'You were born and the world got better – everybody wins! 🥳', +'Have lots of fun on your special day! 🎂', +'Another year of you going around the sun! 🌞' +] +bday_m = random.choice(bday_messages) diff --git a/python/extra/intro.py b/python/extra/intro.py new file mode 100644 index 0000000..77e2568 --- /dev/null +++ b/python/extra/intro.py @@ -0,0 +1,33 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Mar 11 17:21:24 2026 + +@author: alex +""" +for bottles in range(99,0,-1): + print(f"{bottles} bottles of beer on the wall") + print(f"{bottles} bottles of beer") + print("Take one down, pass it around") + +for i in range (1,101): #fizzbuzz + if (i%3==0 and i%5==0): + print("FizzBuzz") + elif (i%3==0): + print("Fizz") + elif (i%5==0): + print("Buzz") + else: + print(i) + + + +def exp(a,b): + p = 1 + if(b<1): + return p + else: + p *= exp(a,b) + b = b -1 + +print(exp(2,2)) diff --git a/python/extra/main.py b/python/extra/main.py new file mode 100644 index 0000000..7b94387 --- /dev/null +++ b/python/extra/main.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Sat Mar 21 18:27:40 2026 + +@author: alex +""" +import datetime, bday_messages +today = datetime.date(2026,3,21) +next_birthday = datetime.date(2026,5,13) +time_difference = next_birthday - today +if time_difference == 0: + print(bday_m) +else: + print(f"My next birthday is {time_difference} days away!") diff --git a/python/python_syntax/classes_and_methods.py b/python/extra/python_syntax/classes_and_methods.py similarity index 100% rename from python/python_syntax/classes_and_methods.py rename to python/extra/python_syntax/classes_and_methods.py diff --git a/python/python_syntax/random_module.py b/python/extra/python_syntax/random_module.py similarity index 100% rename from python/python_syntax/random_module.py rename to python/extra/python_syntax/random_module.py diff --git a/python/laborator/lab3.py b/python/laborator/lab3.py new file mode 100644 index 0000000..26be07c --- /dev/null +++ b/python/laborator/lab3.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 6 14:12:20 2026 + +@author: alex +""" + +#functii + +def este_prim(n): + if n < 2: + return False + for i in range(2, int(n**0.5) + 1): + if n%i == 0: + return False + return True + +def cmmdc(a, b): + a, b = abs(a), abs(b) + while b != 0: + a,b = b, a % b + return a + + +def cmmc(a, b): + if a == 0 or b == 0: + return 0 + return abs(a * b) // cmmdc(a, b) + + +#cod + +#for n in [1, 2, 3 ,4, 17, 18, 97, 100]: +# stare = "prim" if este_prim(n) else "compus" +# print(f"{n:3d} este {stare}") + +perechi = [(12, 8), (100, 75), (17,13), (48, 36)] +print(f"{'a':>5} {'b':>5} {'CMMDC':>8} {'CMMC':>8}") +print("-" * 30) +for a, b in perechi: + print(f"{a:>5} {b:>5} {cmmdc(a, b):>8} {cmmc(a, b):>8}") diff --git a/python/laborator/lab3_2.py b/python/laborator/lab3_2.py new file mode 100644 index 0000000..c435875 --- /dev/null +++ b/python/laborator/lab3_2.py @@ -0,0 +1,95 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 6 14:36:50 2026 + +@author: alex +""" + +import math + +def putere(a, n): + p = 1 + if n < 1: + return p + return a*putere(a, n-1) + +def putere_it(a, n): + p = 1 + for i in range (1, n+1): + p = p*a + return p + +def factorial(n): + f = 1 + for i in range(1, n+1): + f = f*i + return f + +def comb(n, k): + return factorial(n) // (factorial(k) * factorial(n - k)) + +def cifre_pare(n): + n = abs(n) + cif_pare = 0 + while n!= 0: + if( (n%10)%2 == 0 ): + cif_pare += 1 + n //= 10 + return cif_pare + +def produs_div3(n): + p=1 + while (n != 0): + cifra = int(n%10) + print(cifra) + if (cifra % 3 == 0): + p *= cifra + n //= 10 + return p + +def lungime(n): + i = 0 + while n > 1: + n //= 10 + i += 1 + return i + +def oglindit(n): + og = 0 + while n != 0: + og += putere(10,lungime(n)) * int(n%10) + n //= 10 + return og + +def oglindit_2(n): + ogl = 0 + while n!= 0: + ogl = ogl * 10 + n%10 + n //= 10 + return ogl + +def parab(x): + return x*x + +def integreaza(f, a, b, n=1000): + h = (b - a) / n + integr = 0 + for i in range(n): + x = a + i*h + integr += f(x) * h + return integr + +#print(putere(2, 10)) +#print(putere_it(2, 10)) +#print(factorial(5)) +#print(comb(5, 2)) +#print(cifre_pare(2486135)) +#print(cifre_pare(2222222)) +#print(produs_div3(39162)) +#print(lungime(24)) +#print(oglindit(123)) +#print(oglindit_2(123)) + +print(integreaza(parab, 0, 1,10000)) +print(integreaza(math.sin, 0, math.pi)) diff --git a/python/laborator/lab4/1.py b/python/laborator/lab4/1.py new file mode 100644 index 0000000..04b1ff2 --- /dev/null +++ b/python/laborator/lab4/1.py @@ -0,0 +1,7 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Mar 11 14:12:41 2026 + +@author: alex +""" diff --git a/python/laborator/lab4/2.py b/python/laborator/lab4/2.py new file mode 100644 index 0000000..f2b38da --- /dev/null +++ b/python/laborator/lab4/2.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 13 14:16:54 2026 + +@author: alex +""" + +#Lab 4 + +note = [7, 8, 9, 10] +puncte = [(1,2), (3,4, (5,6))] +print(note[0]) +print(note[-1]) +print(note[-2]) + +v = [10, 20, 30, 40, 50, 60, 70, 80] +print(v[2:5]) +print(v[:5]) +print(v[::2]) +print(v[::-1]) + +note = [7,8,9,10] + +for i, val in enumerate(note): + print(f"{i} {val}") diff --git a/python/laborator/lab4/untitled2.py b/python/laborator/lab4/untitled2.py new file mode 100644 index 0000000..654b487 --- /dev/null +++ b/python/laborator/lab4/untitled2.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 13 14:28:27 2026 + +@author: alex +""" + +def inverseaza(lista): + lung = len(lista) + inv = [] + for i in range(0,lung): + inv.append(lista[lung-1-i]) + return inv +lista = [1,3,4,2,5,6] +print(lista) +lista = inverseaza(lista) +print(lista) + +def inverseaza_2(lista): + lista_2 = [] + for n in lista: + lista_2.insert(0,n) + return lista_2 + +lista = inverseaza_2(lista) +print(lista) diff --git a/python/laborator/lab4/untitled3.py b/python/laborator/lab4/untitled3.py new file mode 100644 index 0000000..9011dbc --- /dev/null +++ b/python/laborator/lab4/untitled3.py @@ -0,0 +1,39 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 13 14:38:04 2026 + +@author: alex +""" + +#def comune(A,B): +# intrare = "" +# print("adauga in A: ") +# while intrare != -1: +# intrare = input() +# A.append(intrare) +# print("adauga in B: ") +# A = int(A) +# while intrare != -1: +# intrare = input() +# B.append(intrare) +# B = int(B) +# print(A) +# print(B) +# +#A = [] +#B = [] +#comune(A,B) + +def comune(A,B): + A = set(A) + B = set(B) + intersectia = A & B + intersectia = list(intersectia) + intersectia.sort() + return intersectia + +A = [1,2,3,4,4] +B = [3,4,5,6,7] +C = comune(A,B) +print(C) diff --git a/python/laborator/lab4/untitled4.py b/python/laborator/lab4/untitled4.py new file mode 100644 index 0000000..ee486b4 --- /dev/null +++ b/python/laborator/lab4/untitled4.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 13 14:49:16 2026 + +@author: alex +""" +# Scrie o functie rotire lista k care roteste lista circular la dreapta cu n elemente +def rotire(lista, k): + lista_2 = [] + for i in lista: + lista_2=lista[k+1:] + lista[:-k] + return lista_2 + +lista =[1,2,3,4,5] +lista = rotire(lista,2) +print(lista) diff --git a/python/laborator/lab4/untitled5.py b/python/laborator/lab4/untitled5.py new file mode 100644 index 0000000..4a38258 --- /dev/null +++ b/python/laborator/lab4/untitled5.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 13 14:55:47 2026 + +@author: alex +""" + +def inverseaza_dict(d): + d_2 = dict() + for k, el in d.items(): + d_2[el]=k + return d_2 +D = {"a":1 , "b":2, "c":3} +D = inverseaza_dict(D) +print(D) diff --git a/python/laborator/lab4/untitled6.py b/python/laborator/lab4/untitled6.py new file mode 100644 index 0000000..828057e --- /dev/null +++ b/python/laborator/lab4/untitled6.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 13 15:06:25 2026 + +@author: alex +""" +def cel_mai_frecvent(lista): + frec = [0] * (max(lista) + 1) + + for n in lista: + frec[n] += 1 + + maxim = 0 + for i in range(len(frec)): + if frec[i] > maxim: + maxim = frec[i] + el = i + + return el + +lista = [1, 3, 2, 3, 1, 3, 2] +print(max(lista)) +print(cel_mai_frecvent(lista)) diff --git a/python/laborator/lab4/untitled7.py b/python/laborator/lab4/untitled7.py new file mode 100644 index 0000000..c1075e8 --- /dev/null +++ b/python/laborator/lab4/untitled7.py @@ -0,0 +1,41 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 13 15:24:08 2026 + +@author: alex +""" + +def cel_mai_frecvent(lista): + frec = [0] * (max(lista) + 1) + + for n in lista: + frec[n] += 1 + + maxim = 0 + for i in range(len(frec)): + if frec[i] > maxim: + maxim = frec[i] + el = i + + return el + + +def frecventa(lista): + rezultat = {} + for x in lista: + if x in rezultat: + rezultat[x] += 1 + else: + rezultat[x] = 1 + return rezultat + + +lista = [1, 3, 2, 3, 1, 3, 2] +print(max(lista)) +print(cel_mai_frecvent(lista)) +note = [7,8,9,7,10,8,7,9,9,10,1] +freq = frecventa(note) +print(freq) +for nota,cnt in sorted(freq.items()): + print(f"Nota {nota}: aparede {cnt} ori") diff --git a/python/laborator/lab4/untitled8.py b/python/laborator/lab4/untitled8.py new file mode 100644 index 0000000..497e925 --- /dev/null +++ b/python/laborator/lab4/untitled8.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 13 15:34:19 2026 + +@author: alex +""" + +def f(x): + return x*x -3*x +2 +tabel = {} +for x in range(-3,6): + tabel[x] = f(x) +#afisare tabel + +print(f"{'x':>5} | {'f(x)':>6}") +print("-" * 15) +for x, val in tabel.items(): + print(f"{x:>5} | {val:>6}") + +radacini = [x for x,val in tabel.items() if val == 0] +print(f"\nRadacini in [-3,5]: {radacini}") diff --git a/python/laborator/lab5.py b/python/laborator/lab5.py new file mode 100644 index 0000000..d6c5676 --- /dev/null +++ b/python/laborator/lab5.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 20 14:18:48 2026 + +@author: alex +""" + +import numpy as np + +a = np.array([1,2,3,4,5,6,7,8]) +rez = a[a>5] +print(rez) + +a = np.zeros(7) +b = np.ones(5) +c = np.arange(0,15,2) +print(a, b, c) + +d = np.linspace(-2, 2, 9) +print(d) +print(len(d)) + +f = np.arange(-5,6,1) +print(f) + +x = np.array([-3,-2,-1,0,1,2,3]) +print(x+2) +print(3*x -1) +print(x**2) +print(x**2 + 3*x +2) +print(np.abs(x)) +print(abs(x)) + +y = np.array([0,1,2,3,4,5]) +print(y*y + 3) + +y_1 = y.tolist() +print([i**2 + 3 for i in y_1]) + +a = np.array([4,7,2,9,6,2,9]) +print(np.sum(a)) +print(np.mean(a)) +print(f"minimul este {min(a)} la pozitia {np.argmax(a)}; maximul este {max(b)} la pozitia {np.argmin(a)}") +print(np.where(a == np.min(a))) +print(np.where(a == np.max(a))) +print(np.sort(a)) + +a = np.array([-4,-1,0,2,5,7,8,11]) +print(a[a>0]) +print(a[a%2 == 0]) +print(a[(a >= 0) & (a <= 7)]) +print(a[a > np.mean(a)]) + + +c = np.array([12,15,18,21,24,19,16]) + +f = c *(9/5) + 32 + +print(f) +print(np.mean(c)) +print(np.argmax(c)) +print(c - np.mean(c)) +print(c[c > np.mean(c)]) + +def distanta_fata_de_medie(a): + return np.abs((a-np.mean(a))) + +a = np.arange(-100,1,10) +print(a) +print(distanta_fata_de_medie(a)) + +def raport_fata_de_max(a): + if np.max(a) == 0: + return None + else: + return(a / np.max(a)) + +print(a) +print(raport_fata_de_max(a)) +a = np.arange(0,101,10) +print(a) +print(raport_fata_de_max(a)) + +a = np.arange(1,25,3) + +def normalizare_0_1(a): + if np.max(a) == np.min(a): + return a*0 + else: + return((a-np.min(a))/(np.max(a)-np.min(a))) + +print(a) +print(normalizare_0_1(a)) + +a = np.zeros(20) + +print(normalizare_0_1(a)) + +def este_sortat_crescator(a): + b = np.sort(a) + if np.array_equal(a,b): + print("Sirul este sortat") + else: + print("Sirul nu este sortat") + +ns = np.array([1,200,3,4,22,19]) +este_sortat_crescator(ns) +s = np.arange(1,10) +este_sortat_crescator(s)