Tti - Lucrarea1 - Colaboratory

12.10.2022, 20:29 Copie a blocnotesului lucrarea1-intro.
ipynb - Colaboratory
Introducere
Obiectiv. Această lucrare îsi propune familiarizarea studentilor cu limbajul de programare

Python - mediul Colab pentru simularea conceptelor din Teoria Informatiei. Vor fi parcurse:
1. Notiuni de bază in Python : tipuri de date (containere, liste, dicționare, seturi, tupluri),
funcții, clase
2. Calcul matriceal, Numpy: matrice, indexare matrice, tipuri de date, matematică matrice,
broadcasting
3. Elemente de grafica, Matplotlib: Figuri, Subplots, Imagini
4. Exercitii
Descrierea mediului de lucru
Python este un limbaj de programare de uz general, de sine statator insă, cu ajutorul câtorva
biblioteci populare (numpy, scipy, matplotlib) devine un mediu puternic pentru calculul științific.
Colaboratory, sau „Colab” pe scurt, este un produs al Google Research. Colab permite oricui să
scrie și să execute coduri Python folosind browser-ul. Este util pentru învățarea automată,
analiza datelor și educație. O definitie mai tehnica ar fi: Colab este un serviciu de notebook-uri
Jupyter găzduit de Google, care nu necesită nicio configurare pentru utilizare, oferind în același
timp acces gratuit la resurse de calcul performante, inclusiv GPU-uri.
Versiunea Python curenta se poate verifica din linia de comandă executând !python --version.
Incepând din aprilie 2020, Colab folosește Python 3.6.9 care ar trebui să ruleze totul fără erori.
!python --version
Python 3.7.12
Tipuri de date de bază in Python
Dați dublu clic (sau apăsați pe Enter) pentru a edita
Numere
https://colab.research.google.com/drive/14DjQT14qWJBKL4xT2NIDxW3rXw6yik8_#scrollTo=YnijUxRZEWdf&printMode=true 1/17
12.10.2022, 20:29 Copie a blocnotesului lucrarea1-intro.ipynb - Colaboratory
Există trei categorii numerice distincte: numere întregi (integers), numere cu virgulă mobilă
(floats) și numere complexe. În plus, Booleans este o subcategorie de numere întregi. Numerele
întregi au o precizie nelimitată. Numerele în virgulă mobilă sunt de obicei implementate folosind
double în C; Numerele complexe au o parte reală și imaginară, care sunt fiecare un număr în
virgulă mobilă. Pentru a extrage aceste părți dintr-un număr complex z, utilizați z.real și z.imag.
x =-9
print(x, type(x))
-9 <class 'int'>
Operatii matematice uzuale:
print(x + 50) # Adunarea
print(x - 2) # Scaderea
print(x * 2) # Inmultirea
print(x / 2) # Impartirea
print(x % 2) #restul impartirii
print(x**2) # Ridicarea la putere
print (-x)
print(abs(x)) # modul x
41
-11
-18
-4.5
81
Pentru ridicarea la putere se poate folosi si:
y=3
print(pow(x,y))
print(x ** y)
-729
-729
x += 6 # x=x+6
print(x)
x -= 25
print(x)
-3
-28
Observatie: Spre deosebire de alte limbaje (C/C++, Java, Javascript, C#, PHP) Python nu are
operatori de incrementare(x++) sau decrementare (x--).
z = 5.7
print(type(z))
print(z, z + 3, z * 5, z ** 3)
<class 'float'>
5.7 8.7 28.5 185.193
Operatori Booleni
Pentru implementarea operatorilor uzuali in logica booleana Python foloseste cuvinte in loc de
simboluri:
t= True
print(type(t))
<class 'bool'>
f=False
print(t and f) # AND;
print(t or f) # OR;
print(not t) # NOT;
print(t != f) # XOR;
False
True
False
True
a = -5
b = -10
c = 0

if a > 0 or b > 0:
print("Cel putin unul dintre cele doua nr. este mai mare decat 0")
else:
print("Niciunul dintre numere nu este mai mare ca zero 0")
Niciunul dintre numere nu este mai mare ca zero 0
Caractere (Strings)
salut = 'buna dimineata' # sirurile de caractere se definesc folosind fie prin ghilimele
lab = "in laborator"
print(salut, len(salut))
buna dimineata 14
mesaj = salut + ' ' + lab # Operatie de concatenare
print(mesaj)
buna dimineata in laborator
Pentru variabilele de tip caracter exista o multime de optiuni:
s = "buna"
print(s.capitalize()) # Capitalize a string
print(s.upper().rjust(20)) # Convert a string to uppercase and right justify in the
print(s.rjust(10)) # Right-justify a string, padding with spaces
print(s.center(10)) # Center a string, padding with spaces
print(s.replace('n', '(b)')) # Replace all instances of one substring with another
Buna
BUNA
buna
buna
bu(b)a
'The sum of 2 + 5 is {0}'.format(2+5) #formatarea unui sir de caractere
'The sum of 2 + 5 is 7'
Containere
Python include cateva tipuri de containere: liste, dictionare, multimi (sets), si tuple (tuples).
Liste
O listă este echivalentul Python al unei matrice, cu mentiunea ca este redimensionabilă și poate
conține elemente de diferite tipuri. Aici documentatie.
De retinut. Indexul listei in Python incepe
de la 0!!!
l = [3, 1, 7, 9, 2] # crearea unei liste implica utilizarea parantezelor []
print(l) # parantezele rotunde sunt folosite pentru apelarea functiilor
print('al doilea elemente este',l[1]) #atentie, indexul incepe de la 0.
print('ultimul element din lista este',l[-1]) #Indicele negativ intoarce de la sfarsitul l
[3, 1, 7, 9, 2]
al doilea elemente este 1
ultimul element din lista este 2
Deoarce lista contine elemente de diferite tipuri, unul din elemente poate fi inlocuit cu un sir de
caractere:
l[3]='soare'
print(l)
[3, 1, 7, 'soare', 2]
La sfarsitul listei se poate adauga un element:
l.append('mar')
print(l)
#extragerea acestui element din lista
l.pop(-1)
print(l)
[3, 1, 9, 2, 'mar', 'mar']
[3, 1, 9, 2, 'mar']
In plus fata de extragerea /inserarea unui element din lista, in Pyhon este posibila secventierea
(slicing) unei liste.
a = list(range(8)) # range este o functie built in ce creaza o lista de var de tip inte
print(a)
print(a[0:5]) # exatragerea secventei dintre indexul 2 to 4 (exclusive)
print(a[3:]) # extragerea secventei de la pozitia 3 pana la sfarsit
print(a[:2]) # Extragerea secveneti de la start pana la pozitia 2
print(a[:]) # afiseaza intreaga lista
print(a[:-3]) # afiseaza lista fara ultimele trei elemente
a[5:6] = [238, 195] # inlocuieste o secventa din lista cu alta
print(a)
print(len(a)) # len(a) determina lungimea listei // s-a modificat lista intre timp (nu
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4]
[3, 4, 5, 6, 7]
[0, 1]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 238, 195, 6, 7]
Loops
Parcugerea elementelor unei liste se poate face printr-un for
words = ['food', 'for', 'soul']
for cuvant in words:
print(cuvant) #nu avem nevoie de keyword dupa for
food
for
soul
Pentru a accesa indexul fiecărui element din interiorul unei bucle se foloseste funcția
enumerate
words = ['food', 'for', 'soul']
for idx, word in enumerate(words):
print('#{}: {}'.format(idx + 1 , word)) #idx+1 pentru ca enumerarea sa inceapa de la 1
#1: food
#2: for
#3: soul
"Simplificarea" listelor ne permite sa transformam rapid un tip de date in altul. Ridicarea la

patrat a elementelor unei liste
a = list(range(5)) # sau a=[0,1,2,3,4]
squares = [] #initializarea liste de patrate perfecte // nu e keyword
for x in a:
squares.append(x ** 4) #adaugarea element cu element a elementelor din a^2
print(squares)
[0, 1, 16, 81, 256]
se poate realiza mai simplu astfel:
a = list(range(5))
squares = [x ** 2 for x in a]
print(squares)
[0, 1, 4, 9, 16]
Sintaxele folosite pentru simplificare pot include si conditii, precum afisarea din lista doar a
numerelor pare:
a = list(range(5))
nr_pare = [x ** 2 for x in a if x % 2 == 0]
print(nr_pare)
[0, 4, 16]
Dictionare
Un dicționar memoreaza perechi (cheie, valoare), similar cu o hartă în Java sau unui obiect în
Javascript. Se poate folosi astfel:
dict = {'persoana': 2, 'pisica': 4, 'omida': 16} #pentru dictionar se folosesc {}
for fiinta, picioare in dict.items():
print('O {} are {} picioare.'.format(fiinta, picioare))
O persoana are 2 picioare.
O pisica are 4 picioare.
O omida are 16 picioare.
Afisarea valorii unei chei din dictionar:
print(dict['omida'])
16
Multimi
o multime este o colecție neordonată de elemente distincte. Fie o multime definita astfel:
animals = {'cat', 'dog'}
print('cat' in animals) # Check if an element is in a set; prints "True"
print('floare' in animals) # prints "False"
True
False
Multimile permit adaugarea/extragerea unui element:
animals.add('fish')
print('fish' in animals) # verifica introducerea elementului in multime
print(len(animals)) # cate elemente are multimea
animals.remove('cat')
print(len(animals))
True
Operatiunile cu multimi pot fi de asemenea simplificate similar cu cazul listelor sau al

dictionarelor:
# extragerea radicalului din multimea numerelor pana la 30
from math import sqrt
print({float(sqrt(x)) for x in range(30)})
{0.0, 1.0, 2.0, 1.7320508075688772, 1.4142135623730951, 2.23606797749979, 2.44948974
Tuple
Un tuplu este o listă ordonată (invariabila) de valori. Un tuplu este în multe feluri similar cu o
listă; Una dintre cele mai importante diferențe este că tuplurile pot fi utilizate drept chei în
dicționare sau ca elemente ale multimilor, în timp ce listele nu. Iată un exemplu:
d = {(x, x + 1): x for x in range(10)} # Crearea unui dictionar cu chei de tip tuple
t = (5, 6)
print(t) # crearea unui tuplu
print(type(t))
print(d)
print(d[t])
print(d[(2,3)])# afisarea unei valori pentru o cheie tuplu din dictionarul d ???
(5, 6)
<class 'tuple'>
{(0, 1): 0, (1, 2): 1, (2, 3): 2, (3, 4): 3, (4, 5): 4, (5, 6): 5, (6, 7): 6, (7, 8)
5
Definirea functiilor
Definirea unei functii in Python impune folosirea cuvatului cheie def urmata de numele functiei.
def sign(x):
if x > 0:
return 'positive'
elif x < 0:
return 'negative'
else:
return 'zero'
for x in [-7, 0, 3]: # apelarea functiei
print(sign(x))
negative
zero
positive
Numpy
Numpy este biblioteca de bază pentru calcul științific în Python. Oferă o structura de tip matrice
multidimensionala de înaltă performanță și instrumente pentru lucrul cu aceste matrici. Dacă
sunteți deja familiarizati cu MATLAB, acest tutorial este util pentru a folosi avantajele Numpy.
Pentru a utiliza Numpy (vezi cheet sheet), trebuie se importa mai întâi pachetul numpy:
import numpy as np
Matrici
O matrice numpy este un tabel de valori, toate de același tip, indexată de un tuplu de numere
întregi nenegative. Numărul de dimensiuni este rangul matricei; forma unui tablou este un tuplu
de numere întregi care oferă dimensiunea tabloului de-a lungul fiecărei dimensiuni.
Putem
inițializa matrice numpy din liste Python suprapuse și accesa elementele unei matrici folosind
paranteze pătrate:
A = np.array([1, 2, 3]) # Crearea unei matrici unidimensionale- vector
print(type(A), A.shape, A[0], A[1], A[2]) #ce inseamna mai exact shape??
A[0] = 5 # Modificarea unui element
print(A) #numpy acesta e un pachet
<class 'numpy.ndarray'> (3,) 1 2 3
[5 2 3]
B = np.array([[1,2,3],[4,5,6]]) # Crearea unei matrici bidimensionale
print(B)
print(B[1,0])# Afisarea primului element al matricii.Atentie, nu uitati ca indexarea incep
# daca iesim din domeniu ne da IndexError: index 5 is out of bounds for axis
[[1 2 3]
[4 5 6]]
Numpy permite si crearea unor matrici standar (matrice nula, matricea identitate):
A = np.zeros((13,13)) # Creare unei matrici 2 x 2 de elemente nule
print(A)
[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]
B = np.ones((3,4)) # Crearea unei matrici de elemente 1
print(B)
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
C = np.full((3,3), 4) # Crearea unei matrici cu acelasi elemewnt
print(C)
[[4 4 4]
[4 4 4]
[4 4 4]]
D = np.eye(2) # Crearea matricii identitate
print(D)
[[1. 0.]
[0. 1.]]
E = np.random.random((3,3)) # Crearea unei matrice cu elemente aleatoare
print(E)
[[0.00974621 0.47277552 0.7390955 ]
[0.9149505 0.60293474 0.2841868 ]
[0.41769649 0.01968888 0.30483397]]
Indexarea matricilor
Numpy oferă mai multe modalități de indexare în matrice.
Secventiere: Similar listelor Python,
pot fi extrase matrici numpy. Deoarece matricile pot fi multidimensionale (ex. in cazul
imaginilor), este necesara specificarea secventei pentru fiecare dimensiune a matricei:
#Fie o matrice bidimensionala a(3, 4):
A = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12], [2.3, 3.1, 4, 5]]) #merge doar cu numere
print('A=',A)
# Secventierea pentru a extrage coloana a doua adica o un vector coloana(3, 1):
B = A[:4, 1:2] #:3 toate elementele de pe linii, 1:2 coloana a 2 a
print('B=',B)
A= [[ 1. 2. 3. 4. ]
[ 5. 6. 7. 8. ]
[ 9. 10. 11. 12. ]
[ 2.3 3.1 4. 5. ]]
B= [[ 2. ]
[ 6. ]
[10. ]
[ 3.1]]
Transpunerea unei matrici A se obtine folosind instructiunea A.transpose()
a0,0 a0,1 a0,2

A 2,3 = ( )
a1,0 a1,1 a1,2
obtinandu-se
a0,0 a1,0
⎛ ⎞
A 3,2 = ⎜ a0,1 a1,1 ⎟
⎝ ⎠
a0,2 a1,2
A = np.array([[1,2,3], [5,6,7]])
print('A=',A)
B=A.transpose()
print('B=',B)
A= [[1 2 3]
[5 6 7]]
B= [[1 5]
[2 6]
[3 7]]
Matplotlib
Matplotlib (vezi cheet sheet) este o librarie dedicata vizulizarii grafice a datelor. In sectiunea
urmatoare sunt prezentate cateva dintre functiile acesteia similiare de altfel cu cele existente in
MATLAB.
import matplotlib.pyplot as plt
Functia cea mai des folosita este plot, ce permite redarea unui grafic bidimensional.
# Calculul punctelor x si y pentru reprezentarea functiei sin
x = np.arange(0, 3 * np.pi, 0.1) # definirea unui vector de valori intre 0 si 3pi, cu pas
y = np.tan(x)
print(x)
# Plot the points using matplotlib // matlab il folosim in general pt functii
plt.plot(x, y,color = 'purple')
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. 1.1 1.2 1.3 1.4 1.5 1.6 1.7
1.8 1.9 2. 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3. 3.1 3.2 3.3 3.4 3.5
3.6 3.7 3.8 3.9 4. 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 5. 5.1 5.2 5.3
5.4 5.5 5.6 5.7 5.8 5.9 6. 6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 7. 7.1
7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 8. 8.1 8.2 8.3 8.4 8.5 8.6 8.7 8.8 8.9
9. 9.1 9.2 9.3 9.4]
[<matplotlib.lines.Line2D at 0x7f1a4211d110>]
# 2 grafice pe aceeasi axa de coordonate
y_sin = np.sin(x)
y_cos = np.cos(x)
# reprezentare, etichetare axa, adaugarea titlului, a legendei
plt.plot(x, y_sin)
plt.plot(x, y_cos)
plt.xlabel('x axis label')
plt.ylabel('y axis label')
plt.title('Sine and Cosine')
plt.legend(['Sine', 'Cosine'])
<matplotlib.legend.Legend at 0x7f7adb09e490>
Categorii de valori - Bar/Barh
flori = ['trandafiri', 'bujori', 'petunii', 'floarea-soarelui',]
nr_de_studenti = [2, 3, 0.5, 0.2]
plt.bar(flori, nr_de_studenti, color='purple') #grafic pe verticala
plt.figure() #ca in matlab , folosim aceasta functie ca sa putem avea 2 grafice
plt.barh(flori, nr_de_studenti, color='pink') #grafic pe orizontala
<BarContainer object of 4 artists>
plt.pie(nr_de_studenti, labels = flori);
plt.title('Preferintele studentilor in flori')
Text(0.5, 1.0, 'Preferintele studentilor in flori')
Distributia si frecventa datelor - Hist

plt.hist([1, 2, 2, 3, 3, 3, 4, 4, 10], color='b')
(array([1., 2., 3., 2., 0., 0., 0., 0., 0., 1.]),
array([ 1. , 1.9, 2.8, 3.7, 4.6, 5.5, 6.4, 7.3, 8.2, 9.1, 10. ]),
<a list of 10 Patch objects>)
Exercitii
1. Calculul cantitatii de informatie obtinute pentru experimentul aruncarii cu banul.
from math import log2 #math e o biblioteca
# probabilitatea de aparitie a evenimentului "cap" sau "pajura"
p =1/2
# informatia obtinuta dupa realizarea acestui eveniment
i = -log2(p)
print('p(x)=%.2f, information: %.2f bits' % (p, i))
p(x)=0.50, information: 1.00 bits
2. Calculul entropiei pentru experimentul aruncarii cu zarul. Pentru orice densitate de

probabilitate se poate defini notiunea de entropie, ce are multe proprietati in comun cu
ceea ce ar trebui sa fie o masura a informatiei. Continutul informational al unui rezultat x,
definit de Shannon, este:
n
H (X) = − ∑ p(xi )log2 p(xi ),
i=1
from math import log2
# numarul de rezultate posibile
n = 6
# probabilitatea asociata fiecarui rezultat- evenimente echiprobabile, distributie uniform
prob = [1.0 /n]*n #intreg impartit, ca sa obtin probabilitatea,multiplicarea cu n a listei
print(prob)
# calculul entropiei
entropia = -sum([p * log2(p) for p in prob])
# print the result
print('Entropia: %.2f biti' % entropia)
[0.16666666666666666, 0.16666666666666666, 0.16666666666666666, 0.16666666666666666,

Entropia: 2.58 biti
3. Informatia proprie asupra realizarii unui eveniment xi ce rezulta chiar din realizarea acelui
eveniment, este o functie de probabilitatea de realizare. Ce se intampla cu valoarea
informatiei pe masura ce creste probabilitatea de realizare catre 1 (evenimentul sigur)?
# Informatia proprie in functie de probabilitate
from matplotlib import pyplot as plt
# valori ale probabilitatii
prob = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
# calculul informatiei proprii pentru fiecare valoare
infp = [-log2(p) for p in prob]
# reprezetare grafica - evolutia informatiei proprii cu cresterea probabilitatii
plt.plot(prob, infp, marker='*')
plt.title('Dependenta Informatiei proprii de probabilitate ')
plt.xlabel('Probabilitate')
plt.ylabel('Informatie proprie')
#plt.show()
#Raspuns : Informatia scade, intrucat evenimentul devine din ce in ce mai probabil, pana
3.5431651821620047
Text(0, 0.5, 'Informatie proprie')
4. Calculul entropiei unei variabile aleatoare
# calculul entropiei pentru diverse distributii de probabilitate
from matplotlib import pyplot
# crearea unei functii pentru calculul entropiei
def entropie(events, ets=1e-30):
return -sum([p * log2(p + ets) for p in events])
# introducerea vectorului de probabilitati
prob = (0.2, 0.05, 0.4, 0.15, 0.2)
H = entropie(prob)
print('H=',H,'biti')
H= 2.0841837197791886 biti
Bibliografie
1. Overview of Colaboratory features
2. External data:Local files, drive, sheets and cloud storage
3. Calcul si algebra liniara
4. Introducere in probabilitati si statistica
5. Memorator - Python 3
Anexa 1- Utilizarea Google Drive local
from google.colab import drive
drive.mount('/content/drive')
Mounted at /content/drive
Produse cu plată din Colaborare

-
Anulați contractele de aici
check 0 sec. s-a finalizat la 20:28

Tti - Lucrarea1 - Colaboratory

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Tti - Lucrarea1 - Colaboratory

Încărcat de

Drepturi de autor:

Formate disponibile

12.10.2022, 20:29 Copie a blocnotesului lucrarea1-intro.

Obiectiv. Această lucrare îsi propune familiarizarea studentilor cu limbajul de programare

Descrierea mediului de lucru

Tipuri de date de bază in Python

Dați dublu clic (sau apăsați pe Enter) pentru a edita

Operatii matematice uzuale:

Pentru ridicarea la putere se poate folosi si:

5.7 8.7 28.5 185.193

Niciunul dintre numere nu este mai mare ca zero 0

buna dimineata in laborator

Pentru variabilele de tip caracter exista o multime de optiuni:

'The sum of 2 + 5 is 7'

al doilea elemente este 1

ultimul element din lista este 2

La sfarsitul listei se poate adauga un element:

[3, 1, 9, 2, 'mar', 'mar']

[0, 1, 2, 3, 4, 238, 195, 6, 7]

Parcugerea elementelor unei liste se poate face printr-un for

"Simplificarea" listelor ne permite sa transformam rapid un tip de date in altul. Ridicarea la

[0, 1, 16, 81, 256]

se poate realiza mai simplu astfel:

O persoana are 2 picioare.

O pisica are 4 picioare.

O omida are 16 picioare.

Afisarea valorii unei chei din dictionar:

Multimile permit adaugarea/extragerea unui element:

Operatiunile cu multimi pot fi de asemenea simplificate similar cu cazul listelor sau al

{0.0, 1.0, 2.0, 1.7320508075688772, 1.4142135623730951, 2.23606797749979, 2.44948974

<class 'numpy.ndarray'> (3,) 1 2 3

[[0.00974621 0.47277552 0.7390955 ]

[0.9149505 0.60293474 0.2841868 ]

[0.41769649 0.01968888 0.30483397]]

[ 9. 10. 11. 12. ]

Transpunerea unei matrici A se obtine folosind instructiunea A.transpose()

a0,0 a0,1 a0,2

A 3,2 = ⎜ a0,1 a1,1 ⎟

9. 9.1 9.2 9.3 9.4]

Categorii de valori - Bar/Barh

<BarContainer object of 4 artists>

Text(0.5, 1.0, 'Preferintele studentilor in flori')

Distributia si frecventa datelor - Hist

<a list of 10 Patch objects>)

p(x)=0.50, information: 1.00 bits

2. Calculul entropiei pentru experimentul aruncarii cu zarul. Pentru orice densitate de

H (X) = − ∑ p(xi )log2 p(xi ),

[0.16666666666666666, 0.16666666666666666, 0.16666666666666666, 0.16666666666666666,

Text(0, 0.5, 'Informatie proprie')

4. Calculul entropiei unei variabile aleatoare

Anexa 1- Utilizarea Google Drive local

Produse cu plată din Colaborare

check 0 sec. s-a finalizat la 20:28

S-ar putea să vă placă și