Numpy este cea mai populara biblioteca(o colecție de clase, module si funcții) pentru calcul științific în Python. Oferă un obiect matricial multidimensional de înaltă performanță și instrumente pentru lucrul cu aceste obiecte.
Înțelegeți diferența dintre tablouri(arrays) de dimeniunile unu, două și n-dimensionale în NumPy;
Înțelegeți cum să aplicați unele operații de algebră liniară pe tabourile n-dimensionale fără a utiliza bucle/cicluri;
Înțelegeți proprietățile axei și formei pentru tablourile n-dimensionale.
Obiectul principal al NumPy este tabloul multidimensional. Este un tabel de elemente (de obicei numere), toate de același tip, indexate de un tuple de numere întregi non-negative. Dimensiunile unui tablou se numesc axe.
De exemplu, coordonatele unui punct din spațiul 3D [1, 2, 1] au o axă. Acea axă are 3 elemente în ea, deci spunem că are o lungime de 3. În exemplul ilustrat mai jos, tabloul are 2 axe. Prima axa are o lungime de 2, a doua axa are o lungime de 3.
lista = [[ 1., 0., 0.],
[ 0., 1., 2.]]
lista
[[1.0, 0.0, 0.0], [0.0, 1.0, 2.0]]
# asa importam un modul dintr-o librarie
import numpy as np
# cuvantul cheie 'as' ne permite sa prescurtam numele numpy ---> np
Clasa de matrice NumPy se numește ndarray. Atributele mai importante ale unui obiect ndarray sunt:
ndarray.ndim
numărul de axe (dimensiuni) ale tabloului.
ndarray.shape
dimensiunile tabloului. Acesta este un tuple de numere întregi care indică dimensiunea tabloului în fiecare dimensiune. Pentru o matrice cu n rânduri și m coloane, forma va fi (n, m). Lungimea tuplei de formă este, prin urmare, numărul axelor, ndim.
ndarray.size
numărul total de elemente ale tabloului. Aceasta este egală cu produsul elementelor de formă.
ndarray.dtype
un obiect care descrie tipul elementelor din tablou. Se poate crea sau specifica tipul de tip folosind tipurile Python standard. În plus, NumPy oferă tipuri proprii. numpy.int32, numpy.int16 și numpy.float64 sunt câteva exemple.
ndarray.itemsize
dimensiunea în octeți a fiecărui element al tabloului. De exemplu, o serie de elemente de tip float64 are dimensiunea de articole 8 (= 64/8), în timp ce una de tip complex32 are dimensiunea articolelor 4 (= 32/8). Este echivalent cu ndarray.dtype.itemsize.
ndarray.data
bufferul care conține elementele reale ale tabloului. În mod normal, nu va trebui să folosim acest atribut, deoarece vom accesa elementele dintr-un tablou folosind facilități de indexare.
Putem inițializa matricii numpy din listele de liste Python și accesa elemente folosind paranteze pătrate:
a = np.array([1, 2, 3]) # cream un vector, tablou de dimensiunea 1
# print(type(a))
# print(a.shape)
# print(a[0], a[1], a[2])
# a[0] = 5 # Schimbam elementele unui tablou
# print(a)
# b = np.array([[1,2,3],[4,5,6]]) # cream un vector, tablou de dimensiunea 2
# print(b.shape)
# print(b[0, 0], b[0, 1], b[1, 0])
#metoda 1
#metoda 2
Numpy oferă, de asemenea, multe funcții pentru a crea tablouri:
a = np.zeros((2,2)) # cream un tablou de zerouri
# print(a)
# b = np.ones((1,2)) # cream un tablou de cifre de unu
# print(b)
# e = np.random.random((2,2)) # cream un tablou de valori random
# print(e)
#metoda 3??
Indexarea
Similar cu listele Python, tablourile numpy pot fi tăiate. Deoarece tablourile pot fi multidimensionale, trebuie să specificați o felie(slice) pentru fiecare dimensiune a tabloului
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
# Use slicing to pull out the subarray consisting of the first 2 rows
# and columns 1 and 2; b is the following array of shape (2, 2):
# [[2 3]
# [6 7]]
b = a[:2, 1:3]
# A slice of an array is a view into the same data, so modifying it
# will modify the original array.
print(a[0, 1]) # Prints "2"
b[0, 0] = 77 # b[0, 0] is the same piece of data as a[0, 1]
print(a[0, 1]) # Prints "77"
De asemenea, puteți amesteca indexarea cu numere cu indexarea feliilor.
# Two ways of accessing the data in the middle row of the array.
# Mixing integer indexing with slices yields an array of lower rank,
# while using only slices yields an array of the same rank as the
# original array:
row_r1 = a[1, :] # Rank 1 view of the second row of a
row_r2 = a[1:2, :] # Rank 2 view of the second row of a
print(row_r1, row_r1.shape) # Prints "[5 6 7 8] (4,)"
print(row_r2, row_r2.shape) # Prints "[[5 6 7 8]] (1, 4)"
# We can make the same distinction when accessing columns of an array:
col_r1 = a[:, 1]
col_r2 = a[:, 1:2]
print(col_r1, col_r1.shape) # Prints "[ 2 6 10] (3,)"
print(col_r2, col_r2.shape) # Prints "[[ 2]
# [ 6]
# [10]] (3, 1)"
a = np.array([[1,2], [3, 4], [5, 6]]) # complicat si nu folosim -> delete
# An example of integer array indexing.
# The returned array will have shape (3,) and
print(a[[0, 1, 2], [0, 1, 0]]) # Prints "[1 4 5]"
# The above example of integer array indexing is equivalent to this:
print(np.array([a[0, 0], a[1, 1], a[2, 0]])) # Prints "[1 4 5]"
# When using integer array indexing, you can reuse the same
# element from the source array:
print(a[[0, 0], [1, 1]]) # Prints "[2 2]"
# Equivalent to the previous integer array indexing example
print(np.array([a[0, 1], a[0, 1]])) # Prints "[2 2]"
[1 4 5]
[1 4 5]
[2 2]
[2 2]
Puteti folosi si tablouri cu variabile boolean
a = np.array([[1,2], [3, 4], [5, 6]])
bool_idx = (a > 2) # Find the elements of a that are bigger than 2;
# this returns a numpy array of Booleans of the same
# shape as a, where each slot of bool_idx tells
# whether that element of a is > 2.
print(bool_idx) # Prints "[[False False]
# [ True True]
# [ True True]]"
# We use boolean array indexing to construct a rank 1 array
# consisting of the elements of a corresponding to the True values
# of bool_idx
print(a[bool_idx]) # Prints "[3 4 5 6]"
# We can do all of the above in a single concise statement:
print(a[a > 2]) # Prints "[3 4 5 6]"
x = np.array([1, 2]) # Let numpy choose the datatype
print(x.dtype) # Prints "int64"
x = np.array([1.0, 2.0]) # Let numpy choose the datatype
print(x.dtype) # Prints "float64"
x = np.array([1, 2], dtype=np.int64) # Force a particular datatype
print(x.dtype)
int64
float64
int64
Nan
myarr = np.array([1., 0., np.nan, 3.])
# print(myarr == np.nan)
# np.nan == np.nan # is always False! Use special numpy functions instead.
# myarr[myarr == np.nan] = 0. # doesn't work
# print(myarr)
# myarr[np.isnan(myarr)] = 0. # use this instead find
# print(myarr)
x = np.array([[1,2],[3,4]])
#todo: add a image
print(np.sum(x)) # Compute sum of all elements; prints "10"
print(np.sum(x, axis=0)) # Compute sum of each column; prints "[4 6]"
print(np.sum(x, axis=1)) # Compute sum of each row; prints "[3 7]"
10
[4 6]
[3 7]
Functii/Metode utile
numpy.arange
np.arange(6,10,2)
array([6, 8])
numpy.reshape - schimba forma taboului
numpy.pad() - adauga elemente la sfarsitul tabloului
creati o matrice cu valori de la 0 la 24 cu forma (6,4)
selectati prima coloana din taboul a
#??
Board Game Data
citesc cu csv si fac liste apoi array
import urllib, csv
path = "https://girlsgoitpublic.z6.web.core.windows.net/books.csv"
response = urllib.request.urlopen(path)
lines = [l.decode('utf-8') for l in response.readlines()]
content = csv.reader(lines)
books = list(content)
books[:2]
[['id',
'name',
'authour',
'score',
'rating',
'rating_count',
'review_count',
'page_count',
'year',
'genres'],
['2767052',
'The Hunger Games (The Hunger Games, #1)',
'Suzanne Collins',
'2959668',
'4.33',
'6223460',
'169961',
'374',
'2008',
'Young Adult']]
Acest set de date conține 200 de cărți(rânduri) și 13 coloane pe care le puteți vedea mai jos.
Mai jos aveți o funcție care iterează printr-o listă de liste și numără intr-o coloană cate valori de același fel sunt, rezultatele stocându-le într-un dicționar. Intr-un final funcția va returna un dicționar cu cheile sortate în ordine numerică sau alfabetică crescătoare.
def column_tolist(data, index):
list_name = []
for row in data[1:]:
list_name.append(float(row[index]))
return list_name
Mai jos vedeti o variatie a functiei, care mai adauga niste parametri pentru a extrage o felie din setul de date, si mai multe coloane
def column_tolist(data, index_start, index_sfarsit, start=1, sfarsit=12):
list_name = []
for row in data[start: sfarsit]:
list_name.append([row[index] for index in range(index_start, index_sfarsit)])
return list_name
a = 4
b = 1 if a > 3 else 2
print(b)
a = [i+3 for i in range(3)]
print(a)
care este numarul randului cu cartea cea mai veche?
Care este rating-ul mediu pentru cartile publicate dupa anii 2000?
Care este rating-ul maxim pentru cartile publicate dupa anii 2000?
Care este rating-ul maxim pentru cartile publicate inainte de anii 2000?
#??
Teme avansate
Broadcasting
# Compute outer product of vectors
v = np.array([1,2,3]) # v has shape (3,)
w = np.array([4,5]) # w has shape (2,)
# To compute an outer product, we first reshape v to be a column
# vector of shape (3, 1); we can then broadcast it against w to yield
# an output of shape (3, 2), which is the outer product of v and w:
# [[ 4 5]
# [ 8 10]
# [12 15]]
print(np.reshape(v, (3, 1)) * w)
[[ 4 5]
[ 8 10]
[12 15]]
# We will add the vector v to each row of the matrix x,
# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = x + v # Add v to each row of x using broadcasting
print(y) # Prints "[[ 2 2 4]
# [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]"
x = np.array([[1,2],[3,4]])
y = np.array([[5,6],[7,8]])
v = np.array([9,10])
w = np.array([11, 12])
# Inner product of vectors; both produce 219
print(v.dot(w))
print(np.dot(v, w))
# Matrix / vector product; both produce the rank 1 array [29 67]
print(x.dot(v))
print(np.dot(x, v))
# Matrix / matrix product; both produce the rank 2 array
# [[19 22]
# [43 50]]
print(x.dot(y))
print(np.dot(x, y))
x = np.array([[1,2], [3,4]])
print(x) # Prints "[[1 2]
# [3 4]]"
print(x.T) # Prints "[[1 3]
# [2 4]]"
# Note that taking the transpose of a rank 1 array does nothing:
v = np.array([1,2,3])
print(v) # Prints "[1 2 3]"
print(v.T) # Prints "[1 2 3]"
