1，Python常用库之一：Numpy

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

Numpy支持大量的维度数组和矩阵运算，对数组运算提供了大量的数学函数库！

Numpy比Python列表更具优势，其中一个优势便是速度。在对大型数组执行操作时，Numpy的速度比Python列表的速度快了好几百。因为Numpy数组本身能节省内存，并且Numpy在执行算术、统计和线性代数运算时采用了优化算法。

Numpy的另一个强大功能是具有可以表示向量和矩阵的多维数组数据结构。Numpy对矩阵运算进行了优化，使我们能够高效地执行线性代数运算，使其非常适合解决机器学习问题。

与Python列表相比，Numpy具有的另一个强大优势是具有大量优化的内置数学函数。这些函数使你能够非常快速地进行各种复杂的数学计算，并且用到很少代码（无需使用复杂的循环），使程序更容易读懂和理解。

Numpy简单创建数组

1 a = [1, 2, 3]

2 b = np.array(a)

3 c = np.array([[0, 1, 2, 10],

4               [12, 13, 100, 101],

5               [102, 110, 112, 113]], int)

6 print(c)

7 print(b)

创建数值为1的数组

Numpy.ones(参数 1：shape，数组的形状；参数 2：dtype，数值类型)

1 array_one = np.ones([10, 10], dtype=np.int)

2 print(array_one)

创建数值为0的数组

Numpy.zeros(参数 1：shape，数组的形状；参数 2：dtype，数值类型)

1 array_zero = np.zeros([10, 9], dtype=np.float)

2 print(array_zero)

创建指定数值的数组

Numpy.full(参数 1：shape，数组的形状；参数 2：constant value，数组填充的常数值；参数 3：dtype，数值类型)

1 array_full = np.full((2, 3), 5)

2 print(array_full)

创建单位矩阵

Numpy.eye(参数 1：N，方阵的维度)

1 array_eye = np.eye(5)

2 print(array_eye)

创建对角矩阵

Numpy.diag(参数1：v，主对角线数值，参数 2：k，对角线元素)：K = 0表示主对角线，k>0的值选择在主对角线之上的对角线中的元素，k<0的值选择在主对角线之下的对角线中的元素

1 array_diag = np.diag([10, 20, 30, 40])

2 print(array_diag)

Numpy查看数组属性

数组元素个数：b.size

数组形状：b.shape

数组维度：b.ndim

数组元素类型：b.dtype

# 数组元素个数：3

print(b.size)

# 数组形状:(3,)

print(b.shape)

# 数组维度:1

print(b.ndim)

# 数组元素类型:int32

print(b.dtype)

矩阵第一维的长度：shape[0] # 行

矩阵第二维的长度：shape[1] # 列

.......

1 array_rand = np.random.rand(10, 10, 4)

2 print(array_rand)

3 print(array_rand.ndim)

4 print(array_rand.shape[0])

5 print(array_rand.shape[1])

6 print(array_rand.shape[2])

Numpy创建随机数组（np.random）

均匀分布

创建指定形状的数组，数值范围在0~1之间

1 array_rand = np.random.rand(10, 10, 4)

2 print(array_rand)

3 print(array_rand.ndim)

创建指定范围内的一个数：Numpy.random.uniform(low, high, size=None)

1 array_uniform = np.random.uniform(0, 100, size=5)

2 print(array_uniform)

创建指定范围的一个整数：Numpy.random.randint(low, high, size=None)

1 array_int = np.random.randint(0, 100, size=3)

2 print(array_int)

3 print(array_int.size)

Numpy.arange()和Numpy.linspace()函数也可以均匀分布

Numpy.arange(start, stop, step)：创建一个秩为1的array，其中包含位于半开区间[start, stop)内并均匀分布的值，step表示两个相邻值之间的差。

Numpy.linspace(start, stop, N)：创建N个在闭区间[start, stop]内均匀分布的值。

1 X = np.arange(1, 5, 2, dtype=np.int)

2 print(X)

3 y = np.linspace(1, 5, 3)

4 print(y)

正态分布

创建给定均值、标准差、维度的正态分布：Numpy.random.normal(loc, scale, size)

1 # 正态生成4行5列的二位数组

2 array_normal = np.random.normal(loc=1.75, scale=0.1, size=[4, 5])

3 print(array_normal)

4 print(array_normal.ndim)

Numpy数组操作

数组的索引

array[start : end]

array[start:]

array[:end]

布尔型索引：array[array>10 & array<20]

np.random.seed(10)

arr = np.random.randint(0,100,size=(5,6))

arr

array([[ 9, 15, 64, 28, 89, 93],

       [29,  8, 73,  0, 40, 36],

       [16, 11, 54, 88, 62, 33],

       [72, 78, 49, 51, 54, 77],

       [69, 13, 25, 13, 92, 86]])

arr[[1,2]]

array([[29,  8, 73,  0, 40, 36],

       [16, 11, 54, 88, 62, 33]])

数组的切片

arr[0:2]

array([[ 9, 15, 64, 28, 89, 93],

       [29,  8, 73,  0, 40, 36]])

#获取二维数组前两列

arr[:,0:2]

array([[ 9, 15],

       [29,  8],

       [16, 11],

       [72, 78],

       [69, 13]])

#获取二维数组前两行和前两列数据

arr[0:2,0:2]

array([[ 9, 15],

       [29,  8]])

#将数组的行倒序

arr[::-1]

array([[69, 13, 25, 13, 92, 86],

       [72, 78, 49, 51, 54, 77],

       [16, 11, 54, 88, 62, 33],

       [29,  8, 73,  0, 40, 36],

       [ 9, 15, 64, 28, 89, 93]])

#列倒序

arr[:,::-1]

array([[93, 89, 28, 64, 15,  9],

       [36, 40,  0, 73,  8, 29],

       [33, 62, 88, 54, 11, 16],

       [77, 54, 51, 49, 78, 72],

       [86, 92, 13, 25, 13, 69]])

#全部倒序

arr[::-1,::-1]

array([[86, 92, 13, 25, 13, 69],

       [77, 54, 51, 49, 78, 72],

       [33, 62, 88, 54, 11, 16],

       [36, 40,  0, 73,  8, 29],

       [93, 89, 28, 64, 15,  9]])

数组的复制

Numpy.copy(参数 1：数组)：创建给定array的一个副本，还可当做方法用。

1 after_array = array_normal[:3, 2:4].copy()

2 copy_array = np.copy(array_normal[:, 2:4])

数组排序

Numpy.sort(参数 1：a，数组；参数 2：axis=0/1，0表示行1表示列)：np.sort()作为函数使用时，不更改被排序的原始array；array.sort()作为方法使用时，会对原始array修改为排序后数组array

1 # 整体排序

2 np.sort(array_normal)

3 # 仅行排序

4 np.sort(array_normal, axis=0)

5 # 仅列排序

6 np.sort(array_normal, axis=1)

数组唯一元素

Numpy.unique(参数 1：a，数组；参数 2：return_index=True/False，新列表元素在旧列表中的位置；参数 3：return_inverse=True/False，旧列表元素在新列表中的位置；参数 4：return_counts，元素的数量；参数 5：axis=0/1，0表示行1表示列)：查找array中的唯一元素。

1 print("提取唯一元素", np.unique(array_normal))

2 print("提取唯一元素", np.unique(array_normal, return_index=True))

3 print("提取唯一元素", np.unique(array_normal, return_counts=True))

4 print("提取唯一元素", np.unique(array_normal, return_index=True, return_inverse=True, axis=0))

数组的改变

数组转置

1 array_normal.T

reshape()：把指定的数组改变形状，但是元素个数不变；有返回值，即不对原始多维数组进行修改

 1 c = np.array([[[0, 1, 2],

 2                [10, 12, 13]],

 3               [[100, 101, 102],

 4                [110, 112, 113]]])

 5 """

 6 [[[  0   1]

 7   [  2  10]]

 9  [[ 12  13]

10   [100 101]]

12  [[102 110]

13   [112 113]]]

14 """

15 print(c.reshape(3, 2, 2))

16 """

17 [[  0   1   2  10]

18  [ 12  13 100 101]

19  [102 110 112 113]]

20 """

21 # 某一维指定为-1时，自动计算维度

22 print(c.reshape(3, -1))

23 """[[[  0   1]

24     [  2  10]

25     [ 12  13]]

26

27     [[100 101]

28     [102 110]

29     [112 113]]]"""

30 print(c.reshape(2, -1, 2))

resize()：把指定的数组改变形状，但是元素个数可变，不足补0；无返回值，即对原始多维数组进行修改

 1 a = np.array([[[0, 1, 2],

 2                [10, 12, 13]],

 3               [[100, 101, 102],

 4                [110, 112, 113]]])

 5 b = np.array([[[0, 1, 2],

 6                [10, 12, 13]],

 7               [[100, 101, 102],

 8                [110, 112, 113]]])

 9 '''[[0]

10     [1]

11     [2]]'''

12 a.resize((3, 1))

13 '''[[  0   1   2  10  12]

14     [ 13 100 101 102 110]

15     [112 113   0   0   0]]'''

16 b.resize((3, 5))

17 print(a)

18 print(b)

数组的级联

np.concatenate((arr,arr),axis=1)

array([[ 9, 15, 64, 28, 89, 93,  9, 15, 64, 28, 89, 93],

       [29,  8, 73,  0, 40, 36, 29,  8, 73,  0, 40, 36],

       [16, 11, 54, 88, 62, 33, 16, 11, 54, 88, 62, 33],

       [72, 78, 49, 51, 54, 77, 72, 78, 49, 51, 54, 77],

       [69, 13, 25, 13, 92, 86, 69, 13, 25, 13, 92, 86]])

级联需要注意的点：

级联的参数是列表：一定要加中括号或小括号
维度必须相同
形状相符:在维度保持一致的前提下，如果进行横向（axis=1）级联，必须保证进行级联的数组行数保持一致。如果进行纵向（axis=0）级联，必须保证进行级联的数组列数保持一致。
可通过axis参数改变级联的方向

*Numpy计算

条件运算

Numpy.where(condition, x, y)：三目运算满足condition，为x；不满足condition，则为y

1 score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])

2 # 如果数值小于80，替换为0，如果大于等于80，替换为90

3 re_score = np.where(score < 80, 0, 90)

4 print(re_score)

统计运算

指定轴最大值：amax(参数1：数组；参数2：axis=0/1，0表示行1表示列)

1 # 求整个矩阵的最大值

2 result = np.amax(score)

3 print(result)

4 # 求每一列的最大值（0表示行）

5 result = np.amax(score, axis=0)

6 print(result)

7 # 求每一行的最大值（1表示列）

8 result = np.amax(score, axis=1)

9 print(result)

指定轴最小值：amin(参数1：数组；参数2：axis=0/1，0表示行1表示列)

1 # 求整个矩阵的最小值

2 result = np.amin(score)

3 print(result)

4 # 求每一列的最小值（0表示行）

5 result = np.amin(score, axis=0)

6 print(result)

7 # 求每一行的最小值（1表示列）

8 result = np.amin(score, axis=1)

9 print(result)

指定轴平均值：mean(参数1：数组；参数2：axis=0/1，0表示行1表示列；参数3：dtype，输出数据类型)

1 # 求整个矩阵的平均值

2 result = np.mean(score, dtype=np.int)

3 print(result)

4 # 求每一列的平均值（0表示行）

5 result = np.mean(score, axis=0)

6 print(result)

7 # 求每一行的平均值（1表示列）

8 result = np.mean(score, axis=1)

9 print(result)

指定轴方差：std(参数1：数组；参数2：axis=0/1，0表示行1表示列；参数3：dtype，输出数据类型)

1 # 求整个矩阵的方差

2 result = np.std(score)

3 print(result)

4 # 求每一列的方差（0表示列）

5 result = np.std(score, axis=0)

6 print(result)

7 # 求每一行的方差（1表示行）

8 result = np.std(score, axis=1)

9 print(result)

类似的，求和：Numpy.sum()，求中值：Numpy.median

数组运算

数组与数的运算（加、减、乘、除、取整、取模）

 1 # 循环数组行和列，每一个数值都加5

 2 score[:, :] = score[:, :]+5

 3 print(score)

 4 # 循环数组行和列，每一个数值都减5

 5 score[:, :] = score[:, :]-5

 6 print(score)

 7 # 循环数组行和列，每一个数值都乘以5

 8 score[:, :] = score[:, :]*5

 9 print(score)

10 # 循环数组行和列，每一个数值都除以5

11 score[:, :] = score[:, :]/5

12 print(score)

13 # 循环数组行和列，每一个数值除以5取整

14 score[:, :] = score[:, :] // 5

15 print(score)

16 # 循环数组行和列，每一个数值除以5取模

17 score[:, :] = score[:, :] % 5

18 print(score)

数组间运算（加、减、乘、除），前提是两个数组的shape一样

加：“+”或者np.add(a, b)　　减：“-”或者np.subtract(a, b)

乘：“*”或者np.multiply(a, b)　　除：“/”或者np.divide(a, b)

1 c = score + score

2 d = score - score

3 e = score * score

4 # 分母数组保证每个数值不能为0

5 b = score / score

Numpy.intersect1d(参数 1：数组a；参数 2：数组b)：查找两个数组中的相同元素

Numpy.setdiff1d(参数 1：数组a；参数 2：数组b)：查找在数组a中不在数组b中的元素

Numpy.union1d(参数 1：数组a；参数 2：数组b)：查找两个数组的并集元素

矩阵运算（一种特殊的二维数组）

计算规则

（M行，N列）*（N行，Z列）=（M行，Z列）

1 st_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])

2 # 平时成绩占40% 期末成绩占60%, 计算结果

3 q = np.array([[0.4], [0.6]])

4 result = np.dot(st_score, q)

5 print(result)

矩阵拼接

矩阵垂直拼接（前提两个两个矩阵列数相同，行数随意）：vstack(参数：tuple)

1 v1 = [[0, 1, 2, 3, 4, 5],

2       [6, 7, 8, 9, 10, 11]]

3 v2 = [[12, 13, 14, 15, 16, 17],

4       [18, 19, 20, 21, 22, 23],

5       [18, 19, 20, 21, 22, 23]]

6 result = np.vstack((v1, v2))

7 print(result)

矩阵水平拼接（前提两个两个矩阵行数相同，列数随意）：hstack(参数：tuple)

1 v1 = [[0, 1, 2, 3, 4, 5],

2       [6, 7, 8, 9, 10, 11]]

3 v2 = [[12, 13, 14, 15, 16, 17],

4       [18, 19, 20, 21, 22, 23]]

5 result = np.hstack((v1, v2))

6 print(result)

矩阵删除：Numpy.delete(参数 1：a，数组；参数 2：elements，删除的对象；参数 3：axis=0/1)

1 OriginalY = np.array([[1, 2, 3],

2                      [4, 5, 6],

3                      [7, 8, 9]])

4 print(np.delete(OriginalY, [0, 2]))

5 print(np.delete(OriginalY, [0, 2], axis=0))

6 print(np.delete(OriginalY, [0, 2], axis=1))

矩阵添加：Numpy.append(参数 1：array，数组；参数 2： elements，添加元素；参数 3： axis=0/1)

1 OriginalY = np.array([[1, 2, 3],

2                      [4, 5, 6],

3                      [7, 8, 9]])

4 # 末尾添加元素

5 print(np.append(OriginalY, [0, 2]))

6 # 最后一行添加一行

7 print(np.append(OriginalY, [[0, 2, 11]], axis=0))

8 # 最后一列添加一列（注意添加元素格式）

9 print(np.append(OriginalY, [[0], [2], [11]], axis=1))

矩阵插入：Numpy.insert(参数 1：array，数组；参数 2：index，插入位置索引；参数 3： elements，添加元素；参数 4： axis=0/1)

1 OriginalY = np.array([[1, 2, 3],

2                      [4, 5, 6],

3                      [7, 8, 9]])

4 print(np.insert(OriginalY, 1, [11, 12, 10]))

5 print(np.insert(OriginalY, 1, [[11, 12, 10]], axis=0))

6 # 在列索引1的位置插入（注意元素格式，跟添加格式不同）

7 print(np.insert(OriginalY, 1, [[11, 12, 10]], axis=1))

文件加载

np.loadtxt(fname,dtype,comments='#',delimiter=None,skiprows=0,usecols=None)

fname:读取的文件、文件名

dtype：数据类型

comments：注释

delimiter：分隔符，默认是空格

skiprows：跳过前几行读取，默认是0

usecols：读取哪些列，usecols=（1， 2， 5）读取第1,2,5列，默认所有列

正文

Numpy简单创建数组

1 a = [1, 2, 3]
2 b = np.array(a)
3 c = np.array([[0, 1, 2, 10],
4 [12, 13, 100, 101],
5 [102, 110, 112, 113]], int)
6 print(c)
7 print(b)

Numpy查看数组属性

Numpy创建随机数组（np.random）

均匀分布

正态分布

Numpy数组操作

数组的索引

数组的切片

数组的复制

数组排序

数组唯一元素

数组的改变

数组的级联

*Numpy计算

数组运算

矩阵运算（一种特殊的二维数组）

计算规则

矩阵拼接

文件加载

相关阅读

python怎么装，python怎么装numpy库

python中的协方差计算，numpy协方差

linuxpython安装numba，linux安装numpy模块

numpy安装到python2.7里，python3中numpy安装

【机器学习】【No176】2017年最新北风网零基础学习机器学习（Python语言、算法、Numpy库、MatplotLib)视频教程）

python中numpy中的求和，python nums

Python列表转矩阵例题，numpy列表转矩阵

python中1维数组和2维数组的区别，python怎么把一维数组变为二维

目录[+]

Numpy简单创建数组 1 a = [1, 2, 3] 2 b = np.array(a) 3 c = np.array([[0, 1, 2, 10], 4 [12, 13, 100, 101], 5 [102, 110, 112, 113]], int) 6 print(c) 7 print(b)

Numpy查看数组属性

Numpy创建随机数组（np.random）

均匀分布

正态分布

Numpy数组操作

数组的索引

数组的切片

数组的复制

数组排序

数组唯一元素

数组的改变

数组的级联

*Numpy计算

数组运算

矩阵运算（一种特殊的二维数组）

计算规则

矩阵拼接

文件加载

相关阅读

python怎么装，python怎么装numpy库

python中的协方差计算，numpy协方差

linuxpython安装numba，linux安装numpy模块

numpy安装到python2.7里，python3中numpy安装

【机器学习】【No176】2017年最新北风网零基础学习机器学习（Python语言、算法、Numpy库、MatplotLib)视频教程）

python中numpy中的求和，python nums

Python列表转矩阵例题，numpy列表转矩阵

python中1维数组和2维数组的区别，python怎么把一维数组变为二维

目录[+]

Numpy简单创建数组

1 a = [1, 2, 3]
2 b = np.array(a)
3 c = np.array([[0, 1, 2, 10],
4 [12, 13, 100, 101],
5 [102, 110, 112, 113]], int)
6 print(c)
7 print(b)