机器学习基础 --- numpy的基本使用-低调大师

机器学习基础 --- numpy的基本使用

2018-04-14 716

一、numpy的简介

　　numpy是Python的一种开源的数值计算扩展库。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。

　　NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。

　　Numpy中包含了大量的矩阵运算，所以读者最好具有一点儿线性代数的基础。

二、numpy基本使用

1. 导入numpy库并使用numpy的array方法配合Python中的list生成矩阵

import numpy as np

vetor = np.array([1,2,3,4])     # 一维
matrix = np.array([
    [1,1,1],
    [2,2,2],
    [3,3,3]
])   # 二维
print(vetor)
print(matrix)

　　输出：

[1 2 3 4]
[[1 1 1]
 [2 2 2]
 [3 3 3]]

2. 获取矩阵的组成

print(vetor.shape)
print(matrix.shape)

　　输出：

(4,)
(3, 3)

3. 数据类型

numbers = np.array([1,3,5,7])   # 全为int型
print(numbers)
numbers.dtype

　　输出：

[1 3 5 7]
dtype('int64')

numbers = np.array([1,3,5,7.0])  # 有一个为float型，全为float型
print(numbers)
numbers.dtype

示例2

[1. 3. 5. 7.]
dtype('float64')

输出2

numbers = np.array([1,3,5,'7'])  # 有一个为字符串，全为字符串
print(numbers)
numbers.dtype

示例3

['1' '3' '5' '7']
dtype('<U21')

输出3

4. 操作矩阵的某个值，某些值

vetor = np.array([1,2,3,4])
matrix = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(vetor[2])    # 打印vetor的第2个元素
print(vetor[:3])   # 打印vetor的第0到第二个（不包括第三个）元素
print(matrix[2,2]) # 打印matrix第2行，第2列的元素
print(matrix[:, 1]) # 打印每一行的第1列元素

　　输出：

3
[1 2 3]
9
[2 5 8]

5. 迭代判断矩阵中的所有值是否等于某个值

import numpy as np
vector = np.array([1,3,5,7])
vector == 5

　　输出：

array([False, False,  True, False])

matrix = np.array([
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9]
])
matrix == 5

示例2

array([[False, False, False],
       [False,  True, False],
       [False, False, False]])

输出2

vector = np.array([1,3,4,5,7])
equal_three_and_five = (vector == 3) & (vector == 5)  # 迭代判断vector中的所有值是否即等于3又等于5
print(equal_three_and_five)

示例3

[False False False False False]

输出3

vector = np.array([1,3,4,5,7])
equal_three_or_five = (vector == 3) | (vector == 5) # 迭代判断vector中的所有值是否即等于3或者等于5
print(equal_three_or_five)

示例4

[False  True False  True False]

输出4

matrix = np.array([
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9]
])
equal_ten = (matrix == 5)   # 比较的结果可视为一个索引
print(equal_ten)
print(matrix[equal_ten])

进阶使用1

[[False False False]
 [False  True False]
 [False False False]]
[5]

进阶输出1

matrix = np.array([
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9]
])
equal_ten = (matrix[:, 1] == 5)   # 迭代判断matrix的第1列的值是否等于5
print(equal_ten)
print(matrix[equal_ten, :])

进阶使用2

[False  True False]
[[2 5 8]]

进阶输出2

vector = np.array([1,3,4,5,7])
equal_three_or_five = (vector == 3) | (vector == 5) # 迭代判断vector中的所有值是否即等于3或者等于5
vector[equal_three_or_five] = 10    # 将等于3或者等于5的值替换成10
print(vector)

进阶使用3

[ 1 10  4 10  7]

进阶输出3

6.类型转换

vector = np.array(['1', '3', '5', '7'])
print(vector.dtype)
print(vector)
vector = vector.astype(int)   #使用astype方法做类型转换
print(vector.dtype)
print(vector)

　　输出：

<U1
['1' '3' '5' '7']
int64
[1 3 5 7]

7.常规计算

vector = np.array([1,3,4,5,7])
print(vector.min())     #求最大值
print(vector.max())    #求最小组

　　输出：

1
7

# 示例2
matrix = np.array([
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9]
])
print(matrix.min(axis=1))   # 按行求最小值，axis=1表示按行
print(matrix.max(axis=0))   # 按列求最大值，axis=0表示按列
print(matrix.max())    # 所有值求最大值

# 输出2
[1 2 3]
[3 6 9]
9

# 示例3
matrix = np.array([
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9]
])
print(matrix.sum(axis=1))   # 按行求和
print(matrix.sum(axis=0))   # 按列求和
print(matrix.sum())    # 所有值求和

# 输出3
[12 15 18]
[ 6 15 24]
45

8.生成初始矩阵

# 示例1
print(np.arange(15))   # 取0到14组成一个一维矩阵
a = np.arange(15).reshape(3,5)    # 取0到14组成一个3行5列的2维矩阵
print(a)

# 输出1
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]

# 示例2
a.ndim     # 获取a的维度
a.dtype.name   #获取a中数据的类型
a.size     # a中数据的数量

# 示例3
b = np.zeros((3, 4))    # 一个3行4列的矩阵， 由0构成
print(b)

# 输出3
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

# 示例4
c = np.ones((2,3,4), dtype=np.int32)   # 3维矩阵，2组3行4列的2维矩阵，由1构成
print(c)

# 输出4
[[[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]

 [[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]]

# 示例5
d = np.arange(10, 30, 5)  #初值为10，增量为5，最大不超过30，构成一维矩阵，numpy中arange的用法几乎和Python中的range一样
print(d)

# 输出5
[10 15 20 25]

# 示例6
e = np.random.random((2, 3))   #由0到1之间的随机数构成一个2行3列的矩阵，np.random中的方法几乎和Python的random模块中的方法相同
print(e)

# 输出6
[[0.26358359 0.86922218 0.12168824]
 [0.58244693 0.30264221 0.795065  ]]

# 示例7
from numpy import pi
f = np.linspace(0, 2*pi, 100)   #由0到2pi中间的100个数构成一个一维矩阵，这些书之间的增量相同
print(f)

# 输出7
[0.         0.06346652 0.12693304 0.19039955 0.25386607 0.31733259
 0.38079911 0.44426563 0.50773215 0.57119866 0.63466518 0.6981317
 0.76159822 0.82506474 0.88853126 0.95199777 1.01546429 1.07893081
 1.14239733 1.20586385 1.26933037 1.33279688 1.3962634  1.45972992
 1.52319644 1.58666296 1.65012947 1.71359599 1.77706251 1.84052903
 1.90399555 1.96746207 2.03092858 2.0943951  2.15786162 2.22132814
 2.28479466 2.34826118 2.41172769 2.47519421 2.53866073 2.60212725
 2.66559377 2.72906028 2.7925268  2.85599332 2.91945984 2.98292636
 3.04639288 3.10985939 3.17332591 3.23679243 3.30025895 3.36372547
 3.42719199 3.4906585  3.55412502 3.61759154 3.68105806 3.74452458
 3.8079911  3.87145761 3.93492413 3.99839065 4.06185717 4.12532369
 4.1887902  4.25225672 4.31572324 4.37918976 4.44265628 4.5061228
 4.56958931 4.63305583 4.69652235 4.75998887 4.82345539 4.88692191
 4.95038842 5.01385494 5.07732146 5.14078798 5.2042545  5.26772102
 5.33118753 5.39465405 5.45812057 5.52158709 5.58505361 5.64852012
 5.71198664 5.77545316 5.83891968 5.9023862  5.96585272 6.02931923
 6.09278575 6.15625227 6.21971879 6.28318531]

9.矩阵的基础运算

# 示例2
# 矩阵的加减运算
a = np.array([20, 30, 40, 50])
b = np.arange(4)
print(a)
print(b)
c = a - b     # 将a与b对应的位置相减
d = a + b    # 将a与b对应的位置相加
print('----------->')
print(c)
print(d)
c = c -2
print('----------->')
print(c)
print(b ** 2)    # 对b中的每个元素平方
print(a < 40)   # 迭代判断a中的元素是否小于40

#输出1
[20 30 40 50]
[0 1 2 3]
----------->
[20 29 38 47]
[20 31 42 53]
----------->
[18 27 36 45]
[0 1 4 9]
[ True  True False False]

# 示例2
# 矩阵的乘法
A = np.array([
    [1, 1],
    [0, 1]
])
B = np.array([
    [2, 0],
    [3, 4]
])
print(A)
print("=============")
print(B)
print("=============")
print(A*B)    # 矩阵对应位置的元素相乘
print("=============")
print(A.dot(B))   # 矩阵乘积
print("=============")
print(np.dot(A, B))  # 矩阵乘积

# 输出2
[[1 1]
 [0 1]]
=============
[[2 0]
 [3 4]]
=============
[[2 0]
 [0 4]]
=============
[[5 4]
 [3 4]]
=============
[[5 4]
 [3 4]]

10.矩阵的其他操作

# 示例1
import numpy as np
B = np.arange(3)
print(B) 
print(np.exp(B))    # 分别计算e的0，1，2（即B中的每个元素）次幂
print(np.sqrt(B))   # 对B求算数平方根


# 输出1：
[0 1 2]
[1.         2.71828183 7.3890561 ]
[0.         1.         1.41421356]

# 示例2
a = np.random.random((3, 4))
print(a)
b = np.floor(10 * a)    #取整，截除小数点后面的部分
print(b)
print("------------------------------>")
c = b.ravel()     # 二维转一维，即矩阵转向量，返回一个新的矩阵，自身结构不改变
print(c)
c.shape = (6, 2)    # 一维转二维，向量转为6×2的矩阵，对自己自身结构
print(c)
print("------------------------------>")
d = c.T
print(c.T)     # 对矩阵进行转置

# 输出2：
[[0.07997894 0.66199346 0.66872968 0.09003685]
 [0.80189354 0.02278636 0.82955998 0.3037011 ]
 [0.31794432 0.67269324 0.12022113 0.12148777]]
[[0. 6. 6. 0.]
 [8. 0. 8. 3.]
 [3. 6. 1. 1.]]
------------------------------>
[0. 6. 6. 0. 8. 0. 8. 3. 3. 6. 1. 1.]
[[0. 6.]
 [6. 0.]
 [8. 0.]
 [8. 3.]
 [3. 6.]
 [1. 1.]]
------------------------------>
[[0. 6. 8. 8. 3. 1.]
 [6. 0. 0. 3. 6. 1.]]

# 示例3
import numpy as np
a = np.floor(10 * np.random.random((2, 2)))
b = np.floor(10 * np.random.random((2, 2)))
print(a)
print(b)
print("------------------------------>")
c = np.vstack((a, b))    # 将两个矩阵按行合并，两个矩阵的列必须相同
print(c)
print("------------------------------>")
d = np.hstack((a, b))   # 两个矩阵按列合并，两个矩阵的行必须相同
print(d)

# 输出3：
[[8. 7.]
 [0. 0.]]
[[6. 9.]
 [0. 1.]]
------------------------------>
[[8. 7.]
 [0. 0.]
 [6. 9.]
 [0. 1.]]
------------------------------>
[[8. 7. 6. 9.]
 [0. 0. 0. 1.]]

# 示例4
import numpy as np
a = np.floor(10 * np.random.random((2, 12)))
print(a)
print("------------------------------>")
b,c,d = np.hsplit(a, 3)    # 按列切平均分为3份
print(b)
print(c)
print(d)
print("------------------------------>")
e,f,g = np.vsplit(a.T, 3)   # 按行切平均分为3份
print(e)
print(f)
print(g)
print("------------------------------>")
h, i, j, k = np.hsplit(a, (3, 6, 8))  # 在第3列前面，第6列前面，第8列后面进行分割，分割为4个矩阵，np.vsplit()用法相同
print(h)
print(i)
print(j)
print(k)


# 输出4：
[[3. 1. 7. 4. 1. 1. 5. 8. 3. 9. 5. 6.]
 [2. 7. 6. 3. 7. 1. 6. 3. 5. 7. 9. 0.]]
------------------------------>
[[3. 1. 7. 4.]
 [2. 7. 6. 3.]]
[[1. 1. 5. 8.]
 [7. 1. 6. 3.]]
[[3. 9. 5. 6.]
 [5. 7. 9. 0.]]
------------------------------>
[[3. 2.]
 [1. 7.]
 [7. 6.]
 [4. 3.]]
[[1. 7.]
 [1. 1.]
 [5. 6.]
 [8. 3.]]
[[3. 5.]
 [9. 7.]
 [5. 9.]
 [6. 0.]]
------------------------------>
[[3. 1. 7.]
 [2. 7. 6.]]
[[4. 1. 1.]
 [3. 7. 1.]]
[[5. 8.]
 [6. 3.]]
[[3. 9. 5. 6.]
 [5. 7. 9. 0.]]

11.矩阵的复制

# 示例1
a = np.arange(12)
b = a       # 这种方式对b赋值，b和a是同一个对象，改变一个，另一个也改变，相当于别名
print(b)
print(a)
print(b is a)
print("------------------------------>")
a.shape = (3, 4)
print(a)
print(b)
print(b.shape)
print(id(a))
print(id(b))


输出1：
[ 0  1  2  3  4  5  6  7  8  9 10 11]
[ 0  1  2  3  4  5  6  7  8  9 10 11]
True
------------------------------>
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
(3, 4)
4426322848
4426322848

# 示例2
# 浅拷贝（不建议使用）
a = np.arange(12)
a.shape = (2, 6)
c = a.view()   # 浅拷贝，c和a是两个对象，但是是同一份数据
print(a)
print(c)
print(c is a)
print("------------------------------>")
a.shape = (3, 4)   # 改变结构，两个不相互影响
print(a)
print(c)
print("------------------------------>")
c[0,4] = 10000    # 改变数据，会影响另外一个
print(a)
print(c)


# 输出2：
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
False
------------------------------>
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
------------------------------>
[[    0     1     2     3]
 [10000     5     6     7]
 [    8     9    10    11]]
[[    0     1     2     3 10000     5]
 [    6     7     8     9    10    11]]

# 示例3
# 深拷贝
a = np.arange(12)
a.shape = (2, 6)
d = a.copy()       # 深拷贝，d和a是两个对象，两份数据
print(a)
print(d)
print(d is a)
print("------------------------------>")
a.shape = (3, 4)   # 改变结构，两个不相互影响
print(a)
print(d)
print("------------------------------>")
d[0,4] = 10000    # 改变数据，两个不相互影响
print(a)
print(d)


# 输出3：
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
False
------------------------------>
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
------------------------------>
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[    0     1     2     3 10000     5]
 [    6     7     8     9    10    11]]

12.numpy的一些常用方法：

# 示例1
import numpy as np
data = np.sin(np.arange(20)).reshape(5, 4)
print(data)
ind = data.argmax(axis = 0) # 按列求最大值，得到行的索引，比如第1列的最大值在第2行，则返回2，依次求出所有列最大值的索引组成一个向量
print(ind)
print(range(data.shape[1]))
data_max = data[ind, range(data.shape[1])]  # 相当于由data[2,0],data[0,1],data[3,2],data[1,3]构成的一个矩阵
print(data_max)


# 输出1：
[[ 0.          0.84147098  0.90929743  0.14112001]
 [-0.7568025  -0.95892427 -0.2794155   0.6569866 ]
 [ 0.98935825  0.41211849 -0.54402111 -0.99999021]
 [-0.53657292  0.42016704  0.99060736  0.65028784]
 [-0.28790332 -0.96139749 -0.75098725  0.14987721]]
[2 0 3 1]
range(0, 4)
[0.98935825 0.84147098 0.99060736 0.6569866 ]

# 示例2
a = np.arange(0, 10, 2)
print(a)
b = np.tile(a, (4, 3))   # 将a当成一个整体，将其复制为4行3列构成一个矩阵
print(b)
print('----------------------------------->')
c = np.arange(0, 11, 2)
c.shape = (2, 3)       # 对于二维同样如此
print(c)
d = np.tile(c, (4, 3)) 
print(d)


# 输出2：
[0 2 4 6 8]
[[0 2 4 6 8 0 2 4 6 8 0 2 4 6 8]
 [0 2 4 6 8 0 2 4 6 8 0 2 4 6 8]
 [0 2 4 6 8 0 2 4 6 8 0 2 4 6 8]
 [0 2 4 6 8 0 2 4 6 8 0 2 4 6 8]]
----------------------------------->
[[ 0  2  4]
 [ 6  8 10]]
[[ 0  2  4  0  2  4  0  2  4]
 [ 6  8 10  6  8 10  6  8 10]
 [ 0  2  4  0  2  4  0  2  4]
 [ 6  8 10  6  8 10  6  8 10]
 [ 0  2  4  0  2  4  0  2  4]
 [ 6  8 10  6  8 10  6  8 10]
 [ 0  2  4  0  2  4  0  2  4]
 [ 6  8 10  6  8 10  6  8 10]]

# 示例3
a = np.floor(10 * np.random.random((15)))
c = a.copy()
a.shape = (5, 3)
print(a)
print('----------------------------------->')
b = np.sort(a, axis=0)  # axis=0按列进行升序排序， axis=1按行升序排序， 默认按行排序
print(b)
print('----------------------------------->')
a.sort(axis=1)
print(a)
print('----------------------------------->')
j = np.argsort(c)     # 排序，取原来的索引，比如[5 3 6]执行，得到[1 0 2], 
print(c)
print(j)
print(c[j])


# 输出3：
[[2. 5. 5.]
 [6. 4. 9.]
 [8. 3. 0.]
 [2. 3. 0.]
 [5. 5. 4.]]
----------------------------------->
[[2. 3. 0.]
 [2. 3. 0.]
 [5. 4. 4.]
 [6. 5. 5.]
 [8. 5. 9.]]
----------------------------------->
[[2. 5. 5.]
 [4. 6. 9.]
 [0. 3. 8.]
 [0. 2. 3.]
 [4. 5. 5.]]
----------------------------------->
[2. 5. 5. 6. 4. 9. 8. 3. 0. 2. 3. 0. 5. 5. 4.]
[ 8 11  0  9  7 10  4 14  1  2 12 13  3  6  5]
[0. 0. 2. 2. 3. 3. 4. 4. 5. 5. 5. 5. 6. 8. 9.]

微信关注我们

原文链接：https://yq.aliyun.com/articles/620429

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

json模块和pickle模块的用法

json模块和pickle模块的用法在python中，可以使用pickle和json两个模块对数据进行序列化操作其中： json可以用于字符串或者字典等与python数据类型之间的序列化与反序列化操作 pickle可以用于python特有类型与python数据类型之间的序列化与反序列化操作 json模块的用法查看json模块内的方法： >>> import json >>> dir(json) ['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_encoder', 'decoder', 'dump', 'dumps', 'enc...

2018-04-14

545

在Parasoft C++ test中进行Qt单元测试

为什么写这篇帖子上周关键科技（Parasoft的代理）组织了一次C++test的公开课，就报名了（值得一提的是报名参加培训的学员都给了15天的C++test的正版许可）。在这次培训中确实学到了很多新的东西，所以趁着C++test的许可还没过期，把培训中学到的东西分享给需要的同仁。这篇帖子都写了什么在这篇帖子中我将详细讲述我是用的开发环境和测试环境，如何在Parasoft C++test中创建Qt的的测试工程，如何进行静态扫描，如何进行单元测试，如何插桩，以及一些使用C++test的小技巧。这篇贴子中使用了什么环境这篇帖子中使用的开发和测试环境分别为mingw4.4、Qt4.8.3和Parasoft C++test 9.6。具体聊聊该怎么做搭建开发和测试环境首先我们在安装完以上三个软件以后需要配置环境变量，我的环境变量配置如下图所示。创建Qt工程搭建好环境创建一个带有Gui的Qt工程用于后边讲解，然后在工程中添加新类MyClass并在MyClass中添加以下内容。 #ifndef MYCLASS_H #define MYCLASS_H class MyClass { ...

2018-04-14

861

发表评论

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。