numpy 模块中的数组

数组的所有运算都是对应元素的运算；

1. 数组的创建

import numpy as np
#一维的数组
arr1 = np.array([1, 2, 3, 4])
print(arr1)
print(type(arr1))

[1 2 3 4]
<class 'numpy.ndarray'>

#二维的数组：
arr2 = np.array([[1, 2, 3],[0, 1, 2],[2, 3, 1]])
print(arr2)

[[1 2 3]
 [0 1 2]
 [2 3 1]]

#列向量类型的数组：
arr3 = np.array([[1], [2],[3],[4]])
print(arr3)

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

2. 数组的属性

print('一维数组结构：\n', arr1.shape)
print('二维数组结构：\n', arr2.shape)

一维数组结构：
 (4,)
二维数组结构：
 (3, 3)

print('一维数组的元素个数：\n', arr1.size)
print('二维数组的元素个数：\n', arr2.size)

一维数组的元素个数：
 4
二维数组的元素个数：
 9

print('一维数组元素的类型：\n', arr1.dtype)
print('二维数组元素类型：\n', arr1.dtype)

一维数组元素的类型：
 int32
二维数组元素类型：
 int32

print('一维数组的维度：\n', arr1.ndim)
print('二维数组的维度：\n', arr2.ndim)

一维数组的维度：
 1
二维数组的维度：
 2

3.数组的索引

# (1)一维数组的索引：
arr1[::-1]

array([4, 3, 2, 1])

# (2)二维数组的切片
print(arr2)
# arr2[行切片, 列切片]
arr2[1, 2]
arr2[:2, 0:2]

[[1 2 3]
 [0 1 2]
 [2 3 1]]





array([[1, 2],
       [0, 1]])

# (3)不同行不同列的切片

arr2[(0,1,2),(0,1,2)]

array([1, 1, 1])

arr2[(1,0,1),(0,1,2)]

array([0, 2, 2])

arr2

array([[1, 2, 3],
       [0, 1, 2],
       [2, 3, 1]])

#(5)bool取值# ： 不要行列同时传入bool值，只在行的位置或列的位置传入即可；
mask = np.array([1, 0, 1], dtype=np.bool )
print(mask)

[ True False  True]

arr2[mask, :2]

array([[1, 2],
       [2, 3]])

arr2[:2, mask]

array([[1, 3],
       [0, 2]])

arr2[mask, mask]

array([1, 1])

#练习
arr5 = np.array([1, 6, 3, 4, 5])
mask = np.array([0,1,0,1,1], dtype=np.bool)
arr5[mask]

array([6, 4, 5])

4.特殊函数创建数组

(1) arange ==> 类似于range

arr6 = np.arange(1,10, 1)
print(arr6)

[1 2 3 4 5 6 7 8 9]

(2) 等差数列：
np.linspace(start=a1, stop=an, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
参数说明：
endpoint=True: 表示等差数列， 在start与stop之间插入 n-2 个值；（n为数值的个数）
endpoint=False: 表示等差数列， 在start与stop之间插入 n-1个值，表示平均分成n份；（为线段的个数）

arr7 = np.linspace(2, 5, 5)
print(arr7)

[2.   2.75 3.5  4.25 5.  ]

(3)等比数列

arr8 = np.logspace(0, 2, 3, base=10.0)
print(arr8)

[  1.  10. 100.]

(4)全一数组

arr9 = np.ones((3, 4))
print(arr9)

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

(5) 全零数组

arr10 = np.zeros((3,3))
print(arr10)

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

(6)单位数组

arr11 = np.eye(3)
print(arr11)

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

(7)对角数组

arr12 = np.diag([1, 2, 3, 4])
print(arr12)

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

5.创建随机数组：

(1) 创建n个在0~1之间的随机数， 为一维数组

arr13 =np.random.random(10)
print(arr13)

[0.39707333 0.01181148 0.44722191 0.34679938 0.15179949 0.91379825
 0.50060085 0.40059831 0.93092686 0.34490374]

(2) 创建服从均匀分布的随机数组

arr14 = np.random.rand(10000)

import matplotlib.pyplot as plt

plt.figure()
plt.hist(arr14, 10)
plt.show()

(3) 创建正态分布数组随机数

arr15 = np.random.randn(10000)

import matplotlib.pyplot as plt

plt.figure()
plt.hist(arr15, 20)
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WpIASkRC-1608733108497)(output_65_0.png)]

(4) 随机整数的生成
low <= x < high

np.random.randint(2, 4, size=[2, 5])

array([[2, 2, 3, 3, 2],
       [3, 3, 2, 2, 2]])

6.矩阵形态变换

(1) 重置数组结构：

a、一维变二维

arr_1 = np.arange(10)
print(arr_1)

[0 1 2 3 4 5 6 7 8 9]

arr_2 = arr_1.reshape((2, 5))
print(arr_2)

[[0 1 2 3 4]
 [5 6 7 8 9]]

b.展平： 二维变一维

arr_2.ravel()

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

c、展平方法二：flatten
order=‘C’:表示横向展平； order='F’表示纵向展平；

arr_2.flatten('C') 

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

arr_2.flatten('F')

array([0, 5, 1, 6, 2, 7, 3, 8, 4, 9])

d、堆叠方法

arr_3 = np.zeros((3, 4))
arr_4 = np.ones((3, 4))

横向堆叠: 行数一样即可；

arr_5 = np.hstack((arr_3, arr_4))
print(arr_5)

[[0. 0. 0. 0. 1. 1. 1. 1.]
 [0. 0. 0. 0. 1. 1. 1. 1.]
 [0. 0. 0. 0. 1. 1. 1. 1.]]

纵向堆叠： 列数相同

arr_6 = np.vstack((arr_3, arr_4))
print(arr_6)

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

e:数组合并 concatenate

arr_i = np.concatenate((arr_3, arr_4), axis=0) #沿着axis=0的方向进行拼接
print(arr_i)

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

arr = np.concatenate((arr_3, arr_4), axis=1)  # 沿着axis=1轴的方向进行拼接
print(arr)

[[0. 0. 0. 0. 1. 1. 1. 1.]
 [0. 0. 0. 0. 1. 1. 1. 1.]
 [0. 0. 0. 0. 1. 1. 1. 1.]]

ar_1 = np.array([1,2,3,4])
ar_2 = np.array([0,1,2,2])

concatenate与hstack/vstack的区别：
concatenate是严格沿着数组的轴的方向拼接的，一维数组只有一个轴，因此只有一个种拼接方式；
hstack/vstack 不关注有几个轴，只是单纯按照纵向或横向方向堆叠即可，因此一维数组也有两种堆叠方式；

np.concatenate((ar_1, ar_2), axis=0)

array([1, 2, 3, 4, 0, 1, 2, 2])

np.vstack((ar_1, ar_2))

array([[1, 2, 3, 4],
       [0, 1, 2, 2]])

f.数组分割

#横向分割
np.hsplit(arr, 4 )

[array([[0., 0.],
        [0., 0.],
        [0., 0.]]), array([[0., 0.],
        [0., 0.],
        [0., 0.]]), array([[1., 1.],
        [1., 1.],
        [1., 1.]]), array([[1., 1.],
        [1., 1.],
        [1., 1.]])]

# 任意分割的方法：列索引取值 :2, 2:4, 4:7, 7:
np.hsplit(arr, np.array([2, 4, 7]))

[array([[0., 0.],
        [0., 0.],
        [0., 0.]]), array([[0., 0.],
        [0., 0.],
        [0., 0.]]), array([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]]), array([[1.],
        [1.],
        [1.]])]

np.vsplit(arr_i,3 )

[array([[0., 0., 0., 0.],
        [0., 0., 0., 0.]]), array([[0., 0., 0., 0.],
        [1., 1., 1., 1.]]), array([[1., 1., 1., 1.],
        [1., 1., 1., 1.]])]

np.split(arr_i,2, axis=1 ) # 沿着轴的分割；

[array([[0., 0.],
        [0., 0.],
        [0., 0.],
        [1., 1.],
        [1., 1.],
        [1., 1.]]), array([[0., 0.],
        [0., 0.],
        [0., 0.],
        [1., 1.],
        [1., 1.],
        [1., 1.]])]

7. 数组运算

（1）四则运算：+ - * / ** %

arr17 = np.arange(1, 17).reshape((4,4))
print(arr17)

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]
 [13 14 15 16]]

arr18 = np.diag([2, 3, 1, 5])
print(arr18)

[[2 0 0 0]
 [0 3 0 0]
 [0 0 1 0]
 [0 0 0 5]]

arr18 % arr17

array([[0, 0, 0, 0],
       [0, 3, 0, 0],
       [0, 0, 1, 0],
       [0, 0, 0, 5]], dtype=int32)

(2)比较运算： >, <, == <= >= !=

print(arr18 < arr17)

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

mask = arr17 > 8
print(mask)

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

arr17[mask]

array([ 9, 10, 11, 12, 13, 14, 15, 16])

(3) 逻辑运算

a、逻辑与运算：

np.all(mask)

False

b、逻辑或运算：

np.any(mask)

True

(4) 数组广播运算

a、二维数组+ 列向量

arr_19 = np.array([[1], [0], [1], [0]])
print(arr_19)

[[1]
 [0]
 [1]
 [0]]

print(arr17+ arr_19)

[[ 2  3  4  5]
 [ 5  6  7  8]
 [10 11 12 13]
 [13 14 15 16]]

b、二维数组+ 行向量

arr20 = np.array([0,1,0,1])
print(arr17+arr20)

[[ 1  3  3  5]
 [ 5  7  7  9]
 [ 9 11 11 13]
 [13 15 15 17]]

print(arr17 > 8 )

[[ 9 10 11 12]
 [13 14 15 16]
 [17 18 19 20]
 [21 22 23 24]]

(5) 特殊方法

a、排序

arr21 = np.array([21, 10, 20, 8, 15, 1])

排序，并修改原始数组

# arr21.sort()

print(arr21)

[21 10 20  8 15  1]

b.argsort: 返回的是排序后的索引；

arr21.argsort()

array([5, 3, 1, 4, 2, 0], dtype=int64)

arr22 = np.array([[12, 2, 10, 9], [2, 90, 25, 1]])
print(arr22)
# arr22.sort(axis=1)
# print(arr22)

[[12  2 10  9]
 [ 2 90 25  1]]

arr22.argsort(axis=0)

array([[1, 0, 0, 1],
       [0, 1, 1, 0]], dtype=int64)