Reference material
The following are recommended because there are few types and there is little risk of confusion
numpy.py
import numpy as np
np.array([2, 0, 2, 0])
numpy.py
import numpy as np
x = np.array([[2, 0, 2, 0],[2, 0, 2, 1]])
numpy.dot function = find vector inner product and matrix product
ʻArray is general-purpose data that represents a collection of data of any dimension, not just for
matrix`.
numpy_array.py
import numpy as np
x = np.array([2, 0, 2, 0])
y = np.array([2, 0, 2, 1])
print(x + y)
print(x * y)
print(x.dot(y))
=> [4, 0, 4, 1] #Element by element
=> [4, 0, 4, 0] #Element by element (Caution)
=> 8 #inner product
#Matrix x vector
import numpy as np
A = np.array([[1, 2, 3],[4, 5, 6]])
x = np.array([7, 8, 9])
print(A.dot(x))
=> [ 50, 122]
#Matrix x Matrix
import numpy as np
A = np.array([[1, 2, 3],[4, 5, 6]])
B = np.array([[1, 2], [3, 4], [5, 6]])
print(A.dot(B))
=>[[22 28]
[49 64]]
matrix is a class that represents a matrix
Note that ʻarray and
matrix` are different
Characteristics of np.matrix class
numpy_matrux.py
import numpy as np
A = np.matrix([[1, 2, 3],[4, 5, 6]])
B = np.matrix([[1, 2], [3, 4], [5, 6]])
print(A.dot(B)) #numpy.The result of the dot function calculates the inner product together with the array
=> [[22 28]
[49 64]]
import numpy as np
A = np.matrix([[1, 2, 3],[4, 5, 6]])
B = np.matrix([[1, 2], [3, 4], [5, 6]])
print(A * B) #Operator in matrix"*"Calculate the inner product with
=> [[22 28]
[49 64]]
import numpy as np
A = np.array([[1, 2, 3],[4, 5, 6]])
B = np.array([[1, 2], [3, 4], [5, 6]])
print(A * B) #An error occurs because the matrix shapes do not match when trying to calculate for each element.
=> ValueError: operands could not be broadcast together with shapes (2,3) (3,2)
python:numpy.array.py
import numpy as np
#Arithmetic progression(Arithmetic progression)
np.arrange(2, 3, 0.2)
=> array([ 2. , 2.2, 2.4, 2.6, 2,8])
#Arithmetic progression(Specify points)
np.linspace(2, 3, 6)
=> array([ 2. , 2.2, 2.4, 2.6, 2.8, 3. ])
#Line up zore
np.zeros((3, 2))
=> array([[0., 0.],
[0., 0.],
[0., 0.]])
#Line up one
np.ones((2, 3))
=> array([[1., 1.],
[1., 1.],
[1., 1.]])
#Method
#Make a shape with 0 and assign a value to each element
import numpy as np
def make_diag(n):
A = np.zeros((n, n))
for i in range(n):
A[i, i] = i + 1
return A
print(make_diag(4))
=> [[1. 0. 0. 0.]
[0. 2. 0. 0.]
[0. 0. 3. 0.]
[0. 0. 0. 4.]]
#Reshape that changes shape while leaving the arrangement of elements as it is
import numpy as np
A = np.arange(0, 15, 1)
print("Contents of A:\n{}".format(A))
B = A.reshape(3, 5)
print("Contents of B:\n{}".format(B))
C = B.reshape(5, 3)
print("Contents of C:\n{}".format(C))
=>Contents of A:
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
Contents of B:
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
Contents of C:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]
[12 13 14]]
#Use of random numbers random
import numpy as np
np.random.random((3, 3))
=>array([[0.96781535, 0.64650387, 0.05718226],
[0.78586557, 0.4422813 , 0.92825971],
[0.94403786, 0.90600626, 0.85543603]])
#Specify each component with a function
import numpy as np
def f(i, j):
return i + j
A = np.fromfunction(f, (3, 3))
print(A)
=>[[0. 1. 2.]
[1. 2. 3.]
[2. 3. 4.]]
numpy.py
import numpy as np
A = np.arange(0, 15, 1)
print("A=>\n{}".format(A))
B = A.reshape(3, 5)
print("B=>\n{}".format(B))
print("B[1:2]=>\n{}".format(B[1:2]))
print("B[1:3, 2:3]=>\n{}".format(B[1:3, 2:4]))
print("B[1:3, :]=>\n{}".format(B[1:3, :]))
print("B[:, 2:4]=>\n{}".format(B[:, 2:4]))
print("B[:, 2]=>\n{}".format(B[:, 2]))
print("B[:, :]=>\n{}".format(B[:,:])
A=>
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
B=>
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
B[1:2]=>
[[5 6 7 8 9]]
B[1:3, 2:3]=>
[[ 7 8]
[12 13]]
B[1:3, :]=>
[[ 5 6 7 8 9]
[10 11 12 13 14]]
B[:, 2:4]=>
[[ 2 3]
[ 7 8]
[12 13]]
B[:, 2]=>
[ 2 7 12]
B[:, :]=>
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
numpy
provides functions with the same names as those provided by the math module, such as sin and cos.
They behave as ʻapply to all elements of array for array
universal.py
import numpy as np
import math
r = np.linspace(0, 0.5 * math.pi, 6)
print(r)
sin_r = np.sin(r)
print(sin_r)
cos_r = np.cos(r)
print(cos_r)
print("TypeError when using the function provided by math for numpy")
print(math.sin(r)
[0. 0.31415927 0.62831853 0.9424778 1.25663706 1.57079633]
[0. 0.30901699 0.58778525 0.80901699 0.95105652 1. ]
[1.00000000e+00 9.51056516e-01 8.09016994e-01 5.87785252e-01
3.09016994e-01 6.12323400e-17]
TypeError when using the function provided by math
Traceback (most recent call last):
File "test_conda.py", line 14, in <module>
print(math.sin(r))
TypeError: only size-1 arrays can be converted to Python scalars
Recommended Posts