Am adaugat materialele din săpt trecute.
This commit is contained in:
@@ -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}")
|
||||
@@ -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)]
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -0,0 +1,4 @@
|
||||
examen 30%
|
||||
test lab 30%
|
||||
proiect final 30%
|
||||
activitate 10%
|
||||
Reference in New Issue
Block a user