numpy
je paket (modul) za (efikasno) numeričko računanje u Pythonu. Naglasak je na efikasnom računanju s nizovima, vektorima i matricama, uključivo višedimenzionalne stukture. Napisan je u C-u i Fortanu te koristi BLAS biblioteku.
from numpy import *
numpy
modula¶v = array([1,2,3,4])
v
array([1, 2, 3, 4])
M = array([[1, 2], [3, 4]])
M
array([[1, 2], [3, 4]])
type(v), type(M)
(numpy.ndarray, numpy.ndarray)
v.shape
(4,)
M.shape
(2, 2)
v.size, M.size
(4, 4)
Možemo koristiti i funkcije numpy.shape
, numpy.size
shape(M)
(2, 2)
size(M)
4
Koja je razlika između numpy.ndarray
tipa i standardnih lista u Pythonu?
numpy.ndarray
numpy.ndarray
nisu dinamički objekti: pri kreiranju im je određen tipnumpy.ndarray
implementirane su razne efikasne metode važne u numericidtype
(data type) nam daje informaciju o tipu podataka u nizu:
M.dtype
dtype('int64')
Kako je M statički objekt, ne možemo napraviti ovo:
M[0,0] = "hello"
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-31-a09d72434238> in <module>() ----> 1 M[0,0] = "hello" ValueError: invalid literal for int() with base 10: 'hello'
Naravno, ovo je ok:
M[0,0]=5
dtype
se može eksplicitno zadati:
M = array([[1, 2], [3, 4]], dtype=complex)
M
array([[ 1.+0.j, 2.+0.j], [ 3.+0.j, 4.+0.j]])
Tipično dtype
su: int
, float
, complex
, bool
, object
, itd.
Ali možemo biti i eksplicitni vezano za veličinu registra: int64
, int16
, float128
, complex128
.
x = arange(0, 10, 1) # argumenti: početak, kraj, korak
x # 10 nije u nizu!
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x = arange(-1, 1, 0.1)
x
array([ -1.00000000e+00, -9.00000000e-01, -8.00000000e-01, -7.00000000e-01, -6.00000000e-01, -5.00000000e-01, -4.00000000e-01, -3.00000000e-01, -2.00000000e-01, -1.00000000e-01, -2.22044605e-16, 1.00000000e-01, 2.00000000e-01, 3.00000000e-01, 4.00000000e-01, 5.00000000e-01, 6.00000000e-01, 7.00000000e-01, 8.00000000e-01, 9.00000000e-01])
# ovdje su i početak i kraj uključeni!
linspace(0, 10, 25)
array([ 0. , 0.41666667, 0.83333333, 1.25 , 1.66666667, 2.08333333, 2.5 , 2.91666667, 3.33333333, 3.75 , 4.16666667, 4.58333333, 5. , 5.41666667, 5.83333333, 6.25 , 6.66666667, 7.08333333, 7.5 , 7.91666667, 8.33333333, 8.75 , 9.16666667, 9.58333333, 10. ])
logspace(0, 10, 10, base=e)
array([ 1.00000000e+00, 3.03773178e+00, 9.22781435e+00, 2.80316249e+01, 8.51525577e+01, 2.58670631e+02, 7.85771994e+02, 2.38696456e+03, 7.25095809e+03, 2.20264658e+04])
x, y = mgrid[0:5, 0:5] # slično kao meshgrid u MATLAB-u
x
array([[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4]])
y
array([[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]])
from numpy import random
# uniformna distribucija na [0,1]
random.rand(5,5)
array([[ 0.46634159, 0.18383259, 0.99043082, 0.95553566, 0.86117026], [ 0.18758889, 0.66275122, 0.88660117, 0.48603761, 0.58020297], [ 0.76289553, 0.66796829, 0.70291958, 0.84876206, 0.90293859], [ 0.62222178, 0.46259364, 0.86471336, 0.73420665, 0.21731253], [ 0.63499971, 0.49470533, 0.06818067, 0.85432396, 0.87013258]])
# standardna normalna distribucija
random.randn(5,5)
array([[ 1.8841264 , 1.79222299, -0.15896515, -0.95471483, 0.604597 ], [ 0.01879898, -0.21818353, -0.02871515, -0.17077362, 2.32474892], [ 0.47474772, 0.30405552, -0.37323118, -0.60411745, 1.06795274], [-0.2546505 , -0.10511935, 0.73920025, 2.50885605, -1.04196785], [ 0.2522967 , -0.87931277, -0.93793984, -0.71194124, 0.67464873]])
# dijagonalna matrica
diag([1,2,3])
array([[1, 0, 0], [0, 2, 0], [0, 0, 3]])
# matrica sa sporednom dijagonalom
diag([1,2,3], k=1)
array([[0, 1, 0, 0], [0, 0, 2, 0], [0, 0, 0, 3], [0, 0, 0, 0]])
zeros((3,3))
array([[ 0., 0., 0.], [ 0., 0., 0.], [ 0., 0., 0.]])
ones((3,3))
array([[ 1., 1., 1.], [ 1., 1., 1.], [ 1., 1., 1.]])
Često učitavamo podatke iz datoteka (lokalno ili s weba). Važni formati su cvs (comma-separated values) i tsv (tab-separated values).
!head tpt-europe.csv
1850,-0.211 1851,-0.403 1852,0.334 1853,-0.762 1854,-0.019 1855,-0.961 1856,-0.243 1857,0.420 1858,-0.059 1859,0.018
data = genfromtxt('tpt-europe.csv')
data.shape, data.dtype
((158,), dtype('float64'))
Uz numpy.savetxt
možemo napraviti i obrnuto.
M = random.rand(3,3)
M
array([[ 0.93875912, 0.43215004, 0.23129988], [ 0.13593153, 0.0413665 , 0.21458492], [ 0.96261572, 0.22372779, 0.44478241]])
savetxt("random-matrix.csv", M)
!cat random-matrix.csv
9.387591161588458855e-01 4.321500444939530006e-01 2.312998801967627305e-01 1.359315283144698627e-01 4.136650288835774791e-02 2.145849165333063580e-01 9.626157155774026641e-01 2.237277861211310892e-01 4.447824126746069417e-01
savetxt("random-matrix.csv", M, fmt='%.5f') # s fmt specificiramo format
!cat random-matrix.csv
0.93876 0.43215 0.23130 0.13593 0.04137 0.21458 0.96262 0.22373 0.44478
Postoji i interni format za numpy
nizove:
save("random-matrix.npy", M)
!file random-matrix.npy
random-matrix.npy: data
load("random-matrix.npy")
array([[ 0.93875912, 0.43215004, 0.23129988], [ 0.13593153, 0.0413665 , 0.21458492], [ 0.96261572, 0.22372779, 0.44478241]])
M.itemsize # byte-ovi po elementu
8
M.nbytes
72
M.ndim
2
Indeksiranje funkcionira standardno.
v[0]
1
M[1,1]
0.041366502888357748
M
array([[ 0.93875912, 0.43215004, 0.23129988], [ 0.13593153, 0.0413665 , 0.21458492], [ 0.96261572, 0.22372779, 0.44478241]])
M[1]
array([ 0.13593153, 0.0413665 , 0.21458492])
Naravno, možemo koristiti i :
operator:
M[1,:] # redak 1
array([ 0.13593153, 0.0413665 , 0.21458492])
M[:,1] # stupac 1
array([ 0.43215004, 0.0413665 , 0.22372779])
M[1,:] = 0
M[:,2] = -1
M
array([[ 0.93875912, 0.43215004, -1. ], [ 0. , 0. , -1. ], [ 0.96261572, 0.22372779, -1. ]])
A = array([1,2,3,4,5])
A
array([1, 2, 3, 4, 5])
A[1:3]
array([2, 3])
A[1:3] = [-2,-3]
A
array([ 1, -2, -3, 4, 5])
A[::]
array([ 1, -2, -3, 4, 5])
A[::2]
array([ 1, -3, 5])
A[:3]
array([ 1, -2, -3])
A[3:]
array([4, 5])
S negativnim indeksima računamo od kraja niza:
A = array([1,2,3,4,5])
A[-1] # zadnji element niza
5
A[-3:] # zadnja tri elementa
array([3, 4, 5])
Naravno, iste operacije imamo i za višedimenzionalne nizove.
A = array([[n+m*10 for n in range(5)] for m in range(5)])
A
array([[ 0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]])
A[1:4, 1:4]
array([[11, 12, 13], [21, 22, 23], [31, 32, 33]])
A[::2, ::2]
array([[ 0, 2, 4], [20, 22, 24], [40, 42, 44]])
indeksi_redaka = [1, 2, 3]
A[indeksi_redaka]
array([[10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34]])
indeksi_stupaca = [1, 2, -1]
A[indeksi_redaka, indeksi_stupaca]
array([11, 22, 34])
Možemo koristiti i tzv. maske: ako je maska numpy
niz tipa bool
, tada se izabiru oni elementi koji u maski odgovaraju vrijednosti True
.
B = array([n for n in range(5)])
B
array([0, 1, 2, 3, 4])
maska = array([True, False, True, False, False])
B[maska]
array([0, 2])
maska = array([1,0,1,0,0], dtype=bool)
B[maska]
array([0, 2])
Zanimljiviji primjer:
x = arange(0, 10, 0.5)
x
array([ 0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5])
maska = (5 < x) * (x < 7.5)
maska
array([False, False, False, False, False, False, False, False, False, False, False, True, True, True, True, False, False, False, False, False], dtype=bool)
x[maska]
array([ 5.5, 6. , 6.5, 7. ])
indeksi = where(maska)
indeksi
(array([11, 12, 13, 14]),)
x[indeksi]
array([ 5.5, 6. , 6.5, 7. ])
print(A)
diag(A)
[[ 0 1 2 3 4] [10 11 12 13 14] [20 21 22 23 24] [30 31 32 33 34] [40 41 42 43 44]]
array([ 0, 11, 22, 33, 44])
diag(A, -1)
array([10, 21, 32, 43])
v2 = arange(-3,3)
v2
array([-3, -2, -1, 0, 1, 2])
indeksi_redaka = [1, 3, 5]
v2[indeksi_redaka]
array([-2, 0, 2])
v2.take(indeksi_redaka)
array([-2, 0, 2])
U sljedećem primjeru take
djeluje na listu, a izlaz je array
:
take([-3, -2, -1, 0, 1, 2], indeksi_redaka)
array([-2, 0, 2])
Funkcija choose
:
koji = [1, 0, 1, 0]
izbori = [[-1,-2,-3,-4], [5,4,3,2]]
choose(koji, izbori)
array([ 5, -2, 3, -4])
Što radi ova funkcija?
Što je više operacija s nizovima, to će kod generalno biti brži.
v1 = arange(0, 5)
v1 * 2
array([0, 2, 4, 6, 8])
v1 + 2
array([2, 3, 4, 5, 6])
print(A)
A * 2, A + 2
[[ 0 1 2 3 4] [10 11 12 13 14] [20 21 22 23 24] [30 31 32 33 34] [40 41 42 43 44]]
(array([[ 0, 2, 4, 6, 8], [20, 22, 24, 26, 28], [40, 42, 44, 46, 48], [60, 62, 64, 66, 68], [80, 82, 84, 86, 88]]), array([[ 2, 3, 4, 5, 6], [12, 13, 14, 15, 16], [22, 23, 24, 25, 26], [32, 33, 34, 35, 36], [42, 43, 44, 45, 46]]))
Defaultne operacije na nizovima su uvijek definirane po elementima.
A * A
array([[ 0, 1, 4, 9, 16], [ 100, 121, 144, 169, 196], [ 400, 441, 484, 529, 576], [ 900, 961, 1024, 1089, 1156], [1600, 1681, 1764, 1849, 1936]])
v1 * v1
array([ 0, 1, 4, 9, 16])
A.shape, v1.shape
((5, 5), (5,))
print(A,v1)
A * v1
[[ 0 1 2 3 4] [10 11 12 13 14] [20 21 22 23 24] [30 31 32 33 34] [40 41 42 43 44]] [0 1 2 3 4]
array([[ 0, 1, 4, 9, 16], [ 0, 11, 24, 39, 56], [ 0, 21, 44, 69, 96], [ 0, 31, 64, 99, 136], [ 0, 41, 84, 129, 176]])
Kako doći do standardnog umnoška?
dot(A, A)
array([[ 300, 310, 320, 330, 340], [1300, 1360, 1420, 1480, 1540], [2300, 2410, 2520, 2630, 2740], [3300, 3460, 3620, 3780, 3940], [4300, 4510, 4720, 4930, 5140]])
A @ A # nova operacija definirana u Python-u 3.5+
array([[ 300, 310, 320, 330, 340], [1300, 1360, 1420, 1480, 1540], [2300, 2410, 2520, 2630, 2740], [3300, 3460, 3620, 3780, 3940], [4300, 4510, 4720, 4930, 5140]])
matmul(A,A) # @ je zapravo pokrata za matmul, dot i matmul nisu iste operacije (poklapaju se na 1D i 2D nizovima)
array([[ 300, 310, 320, 330, 340], [1300, 1360, 1420, 1480, 1540], [2300, 2410, 2520, 2630, 2740], [3300, 3460, 3620, 3780, 3940], [4300, 4510, 4720, 4930, 5140]])
dot(A, v1)
array([ 30, 130, 230, 330, 430])
A @ v1
array([ 30, 130, 230, 330, 430])
v1 @ v1 # analogno dot(v1, v1)
30
Matrice mogu biti i višedimenzionalne
a = random.rand(8,13,13)
b = random.rand(8,13,13)
matmul(a, b).shape
(8, 13, 13)
Postoji i tip matrix
. Kod njega operacije +, -, *
se ponašaju onako kako smo navikli.
M = matrix(A)
v = matrix(v1).T # da bi dobili stupčasti vektor
v
matrix([[0], [1], [2], [3], [4]])
M*M
matrix([[ 300, 310, 320, 330, 340], [1300, 1360, 1420, 1480, 1540], [2300, 2410, 2520, 2630, 2740], [3300, 3460, 3620, 3780, 3940], [4300, 4510, 4720, 4930, 5140]])
M*v
matrix([[ 30], [130], [230], [330], [430]])
# skalarni produkt
v.T * v
matrix([[30]])
v + M*v
matrix([[ 30], [131], [232], [333], [434]])
Naravno, dimenzije trebaju biti kompatibilne.
v = matrix([1,2,3,4,5,6]).T
shape(M), shape(v)
((5, 5), (6, 1))
M * v
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-138-995fb48ad0cc> in <module>() ----> 1 M * v /projects/anaconda3/lib/python3.5/site-packages/numpy/matrixlib/defmatrix.py in __mul__(self, other) 341 if isinstance(other, (N.ndarray, list, tuple)) : 342 # This promotes 1-D vectors to row vectors --> 343 return N.dot(self, asmatrix(other)) 344 if isscalar(other) or not hasattr(other, '__rmul__') : 345 return N.dot(self, other) ValueError: shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)
Još neke funkcije: inner
, outer
, cross
, kron
, tensordot
.
C = matrix([[1j, 2j], [3j, 4j]])
C
matrix([[ 0.+1.j, 0.+2.j], [ 0.+3.j, 0.+4.j]])
conjugate(C)
matrix([[ 0.-1.j, 0.-2.j], [ 0.-3.j, 0.-4.j]])
Adjungiranje:
C.H
matrix([[ 0.-1.j, 0.-3.j], [ 0.-2.j, 0.-4.j]])
Za izvlačenje realnog, odnosno imaginarnog dijela: real
i imag
:
real(C) # isto što i C.real
matrix([[ 0., 0.], [ 0., 0.]])
imag(C) # isto što i C.imag
matrix([[ 1., 2.], [ 3., 4.]])
angle(C+1) # u MATLAB-u je to funkcija arg, dakle argument (faza) kompleksnog broja
array([[ 0.78539816, 1.10714872], [ 1.24904577, 1.32581766]])
abs(C)
matrix([[ 1., 2.], [ 3., 4.]])
from numpy.linalg import inv, det
inv(C) # isto što i C.I
matrix([[ 0.+2.j , 0.-1.j ], [ 0.-1.5j, 0.+0.5j]])
C.I * C
matrix([[ 1.00000000e+00+0.j, 0.00000000e+00+0.j], [ 1.11022302e-16+0.j, 1.00000000e+00+0.j]])
det(C)
(2.0000000000000004+0j)
det(C.I)
(0.49999999999999967+0j)
# u stockholm_td_adj.dat su podaci o vremenu za Stockholm
dataStockholm = genfromtxt('stockholm_td_adj.dat')
dataStockholm.shape
(77431, 7)
# temperatura se nalazi u 4. stupcu (znači stupcu broj 3)
mean(dataStockholm[:,3])
6.1971096847515854
Prosječna dnevna temperatura u Stockholmu u zadnjiih 200 godina je bila 6.2 C.
std(dataStockholm[:,3]), var(dataStockholm[:,3])
(8.2822716213405734, 68.596023209663414)
dataStockholm[:,3].min()
-25.800000000000001
dataStockholm[:,3].max()
28.300000000000001
d = arange(0, 10)
d
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
sum(d)
45
prod(d+1)
3628800
# kumulativa suma
cumsum(d)
array([ 0, 1, 3, 6, 10, 15, 21, 28, 36, 45])
# kumulativan produkt
cumprod(d+1)
array([ 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800])
# isto što i: diag(A).sum()
trace(A)
110
Naravno, sve ove operacije možemo raditi na dijelovima nizova.
!head -n 3 stockholm_td_adj.dat
1800 1 1 -6.1 -6.1 -6.1 1 1800 1 2 -15.4 -15.4 -15.4 1 1800 1 3 -15.0 -15.0 -15.0 1
Format je: godina, mjesec, dan, prosječna dnevna temperatura, najniža, najviša, lokacija.
Recimo da nas zanimaju samo temperature u veljači.
# mjeseci su 1.,..., 12.
unique(dataStockholm[:,1])
array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.])
maska_velj = dataStockholm[:,1] == 2
mean(dataStockholm[maska_velj,3])
-3.2121095707365961
Sada nije problem doći do histograma za prosječne mjesečne temperature u par redaka.
mjeseci = arange(1,13)
mjeseci_prosjek = [mean(dataStockholm[dataStockholm[:,1] == mjesec, 3]) for mjesec in mjeseci]
from pylab import *
%matplotlib inline
fig, ax = subplots()
ax.bar(mjeseci, mjeseci_prosjek)
ax.set_xlabel("Mjesec")
ax.set_ylabel("Prosj. mj. temp.");
m = rand(3,3)
m
array([[ 0.66942337, 0.98488678, 0.06962048], [ 0.93170674, 0.70455373, 0.10112863], [ 0.4101218 , 0.20957115, 0.9954116 ]])
m.max()
0.99541159521774658
# max u svakom stupcu
m.max(axis=0)
array([ 0.93170674, 0.98488678, 0.9954116 ])
# max u svakom retku
m.max(axis=1)
array([ 0.98488678, 0.93170674, 0.9954116 ])
Oblik niza se može promijeniti bez da se dira memorija, dakle mogu se primijenjivati i na veliku količinu podataka.
A
array([[ 0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]])
n, m = A.shape
B = A.reshape((1,n*m))
B
array([[ 0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31, 32, 33, 34, 40, 41, 42, 43, 44]])
B[0,0:5] = 5 # promijenili smo B
B
array([[ 5, 5, 5, 5, 5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31, 32, 33, 34, 40, 41, 42, 43, 44]])
A # a time smo promijenili i A
array([[ 5, 5, 5, 5, 5], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]])
Funkcija flatten
radi kopiju.
B = A.flatten()
B
array([ 5, 5, 5, 5, 5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31, 32, 33, 34, 40, 41, 42, 43, 44])
B[0:5] = 10
B
array([10, 10, 10, 10, 10, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31, 32, 33, 34, 40, 41, 42, 43, 44])
A # A je sad ostao isti
array([[ 5, 5, 5, 5, 5], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]])
v = array([1,2,3])
shape(v)
(3,)
# pretvorimo v u matricu
v[:, newaxis]
array([[1], [2], [3]])
v[:,newaxis].shape
(3, 1)
v[newaxis,:].shape
(1, 3)
a = array([[1, 2], [3, 4]])
# ponovimo svaki element tri puta
repeat(a, 3)
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])
tile(a, 3)
array([[1, 2, 1, 2, 1, 2], [3, 4, 3, 4, 3, 4]])
b = array([[5, 6]])
concatenate((a, b), axis=0)
array([[1, 2], [3, 4], [5, 6]])
concatenate((a, b.T), axis=1)
array([[1, 2, 5], [3, 4, 6]])
vstack((a,b))
array([[1, 2], [3, 4], [5, 6]])
hstack((a,b.T))
array([[1, 2, 5], [3, 4, 6]])
A = array([[1, 2], [3, 4]])
A
array([[1, 2], [3, 4]])
# B je isto što i A (bez kopiranja podataka)
B = A
Ako želimo napraviti novu kopiju, koristimo funkciju copy
:
B = copy(A)
v = array([1,2,3,4])
for element in v:
print (element)
1 2 3 4
M = array([[1,2], [3,4]])
for row in M:
print ("redak {}".format(row))
for element in row:
print (element)
redak [1 2] 1 2 redak [3 4] 3 4
Funkcija enumerate
nam daje i element i njegov indeks:
for row_idx, row in enumerate(M):
print ("indeks retka {} redak {}".format(row_idx, row))
for col_idx, element in enumerate(row):
print ("col_idx {} element {}".format(col_idx, element))
M[row_idx, col_idx] = element ** 2
indeks retka 0 redak [1 2] col_idx 0 element 1 col_idx 1 element 2 indeks retka 1 redak [3 4] col_idx 0 element 3 col_idx 1 element 4
def Theta(x):
"""
Sklarna verzija step funkcije.
"""
if x >= 0:
return 1
else:
return 0
Theta(array([-3,-2,-1,0,1,2,3]))
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-198-6658efdd2f22> in <module>() ----> 1 Theta(array([-3,-2,-1,0,1,2,3])) <ipython-input-197-840f7d4ff406> in Theta(x) 3 Sklarna verzija step funkcije. 4 """ ----> 5 if x >= 0: 6 return 1 7 else: ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
Theta_vec = vectorize(Theta)
Theta_vec(array([-3,-2,-1,0,1,2,3]))
array([0, 0, 0, 1, 1, 1, 1])
To smo mogli napraviti i ručno.
def Theta(x):
"""
Vektorska verzija step funkcije.
"""
return 1 * (x >= 0)
Theta(array([-3,-2,-1,0,1,2,3]))
array([0, 0, 0, 1, 1, 1, 1])
# radi naravno i za skalare
Theta(-1.2), Theta(2.6)
(0, 1)
M
array([[ 1, 4], [ 9, 16]])
if (M > 5).any():
print ("barem jedan element iz M je veći od 5")
else:
print ("svi elementi iz M su manji ili jednaki od 5")
barem jedan element iz M je veći od 5
if (M > 5).all():
print ("svi elementi iz M su veći od 5")
else:
print ("barem jedan element je manji ili jednak od 5")
barem jedan element je manji ili jednak od 5
Eksplicitno pretvaranje podataka. Uvijek stvara novi niz.
M.dtype
dtype('int64')
M2 = M.astype(float)
M2
array([[ 1., 4.], [ 9., 16.]])
M2.dtype
dtype('float64')
M3 = M.astype(bool)
M3
array([[ True, True], [ True, True]], dtype=bool)
from verzije import *
from IPython.display import HTML
HTML(print_sysinfo()+info_packages('numpy,matplotlib'))
Python verzija | 3.5.3 |
kompajler | GCC 4.8.2 20140120 (Red Hat 4.8.2-15) |
sustav | Linux |
broj CPU-a | 8 |
interpreter | 64bit |
numpy verzija | 1.11.3 |
matplotlib verzija | 2.0.0 |
A=random.randn(5,5)
. Izvucite $2\times 2$ matricu $B$ iz gornjeg desnog kuta matrice $A$. Pomnožite matricu $B$ s nekom drugom $2\times 2$ matricom te ubacite tu matricu u gornji lijevi kut matrice $A$.x = linspace(0, 1, 3)
# y = 2*x + 1:
y=x; y*=2; y+=1
# z = 4*x - 4:
z=x; z*=4; z-=4
print (x, y, z)
Izvršite ovaj kod. Objasnite zašto x
, y
i z
imaju iste vrijednosti.
f
i broj n
te dva niza a,b
a vraćati niz brojeva koji odgovaraju aproksimaciji integrala $\int_{a_i}^{b_i} f(x) dx$ trapeznom formulom.
Ovdje je $n$ realan broj, $0 < n \le 1$. Napišite vektoriziranu funkciju za računanje $f(x)$ na skupu $m$ ekvidistribuiranih brojeva između 0 i 1 (dakle, bez korištenja petlji).
$\frac{b-a}{n} \sum_{i=1}^n f(x_i)$, postupak koji se obično zove Monte Carlo integracija. Napišite funkciju koja kao ulazne varijable prima $a$, $b$, $f$ te $n$ s predefiniranom vrijednošću 1000, a vraća rezultat Monte Carlo integracije. I u ovom zadatku se ne smiju koristiti petlje.