import numpy as np

===============================基础操作===============================

arr = np.array([[1,2,3],[4,5,6]], dtype='int')  # 创建数组
arr

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

arr[1,2]  # 根据索引取值

6

arr.ndim # 查看数组的维度

2

arr.shape  # 查看数组的行数和列数

(2, 3)

arr.size  # 查看数组的元素个数

6

# arr = np.array([1,2,3], dtype='int64')  # 创建一维数组  
arr = np.array([[1,2,3],[4,5,6]], dtype=np.float32)  # 创建二维数组  
# dtype：指定数据类型，指定类型是可以通过dtype='float32' 或 dtype=np.float32 来指定。

arr.dtype

dtype('float32')

arr_zero = np.zeros([3,4])  # 生成一个3行4列的全0数组
arr_zero

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

arr_one = np.ones((3,4))  # 生成一个3行4列的全1数组
arr_one

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

arr_null = np.empty([2,4])  # 生成一个3
arr_null

array([[ 0.00281566,  0.41417892,  0.34726707,  0.30388972],
       [ 0.31434997,  0.19546101,  0.45246514,  0.93921855]])

arr = np.arange(10,20,2)  # 使用arange生成一个数组
arr

array([10, 12, 14, 16, 18])

arr = np.arange(1,21,).reshape([4,5])  # 使用arange生成一个数组，然后使用reshape()重新定义数组的行和列
arr

array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10],
       [11, 12, 13, 14, 15],
       [16, 17, 18, 19, 20]])

arr = np.linspace(1,10,5,endpoint=False)  # 在指定的间隔内返回均匀间隔的数字, endpoint：如果是真，则一定包括stop，如果为False，一定不会有stop，默认为True
arr

array([ 1. ,  2.8,  4.6,  6.4,  8.2])

arr = np.linspace(1,10,5,endpoint=True)  # 在指定的间隔内返回均匀间隔的数字
arr

array([  1.  ,   3.25,   5.5 ,   7.75,  10.  ])

arr = np.linspace(1,10,10).reshape([2,5])
arr

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

===============================基础运算===============================

arr1 = np.array([1,2,5,7,9])
arr2 = np.array([2,4,6,8,10])
arr3 = np.array([1,1,1,1,1])
arr1 + arr2    # 将两个数组对应位置的元素相加

array([ 3,  6, 11, 15, 19])

arr1 + arr2 + arr3    # 将三个数组对应位置的元素相加

array([ 4,  7, 12, 16, 20])

arr1 + arr2 - arr3

array([ 2,  5, 10, 14, 18])

arr1 * arr2    # 将三个数组对应位置的元素相乘

array([ 2,  8, 30, 56, 90])

arr = np.array([10,20,30,40,50])
np.sin(arr)   # 求arr中每个元素的sin值

array([-0.54402111,  0.91294525, -0.98803162,  0.74511316, -0.26237485])

arr = np.array([1,3,5,7,8,9])
arr < 5  # 判断arr中的每个元素是否小于5

array([ True,  True, False, False, False, False], dtype=bool)

arr = np.array([1,3,5,7,8,9])
arr == 5  # 判断arr中的每个元素是否等于5

array([False, False,  True, False, False, False], dtype=bool)

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

arr * arr2  # 对应位置上的元素相乘

array([[ 5, 12],
       [21, 32]])

np.dot(arr,arr2)  # 矩阵相乘

array([[19, 22],
       [43, 50]])

arr.dot(arr2)  # 矩阵相乘，和上面的方法一样

array([[19, 22],
       [43, 50]])

arr = np.random.random([2,4])  # 生成2行4列的数组每个元素的范围在0到1之间
arr

array([[ 0.25720558,  0.13483034,  0.32514644,  0.50040623],
       [ 0.36687543,  0.83781214,  0.51544328,  0.33124224]])

arr = np.array([i for i in range(1,13)]).reshape([3,4])
arr

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

arr.sum()  # 求arr数组中元素的和
np.sum(arr)  # 求arr数组中元素的和

78

arr.max()  # 求arr数组中的最大值

12

arr.min()  # 求arr数组中的最小值

1

arr.min(axis=1)  # 求arr数组中每一行的最小值

array([1, 5, 9])

arr.max(axis=0)  # 求arr数组中每一列的最大值

array([ 9, 10, 11, 12])

arr.mean()  # 求arr数组中元素的平局值

6.5

arr = np.array([np.random.randint(1,11) for i in range(12)]).reshape(3,4)
arr

array([[ 4, 10,  8,  1],
       [ 2,  9,  9,  7],
       [10,  4, 10,  2]])

np.argmin(arr)  # 查找最小值的索引

3

arr.argmin()  # 查找最小值的索引

3

arr.argmax()  # # 查找最大值的索引

1

arr.argmax(axis=1)  # # 查找每一行最大值的索引

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

arr.argmin(axis=0)  # # 查找每一列最小值的索引

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

arr = np.arange(1,10)
arr

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

np.median(arr)  # 正确的方法
# arr.median()    # 错误方法

5.5

arr.cumsum()  # 累加(每个元素和前面所有元素相加)

array([ 1,  3,  6, 10, 15, 21, 28, 36, 45, 55], dtype=int32)

arr = np.array([np.random.randint(1,11) for i in range(12)])
arr

array([5, 4, 8, 7, 4, 5, 5, 3, 6, 3, 4, 4])

np.diff(arr)  # 累差(后面的数减去前面的数)
# arr.diff()  # 错误方法

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

arr = np.array([np.random.randint(0,6) for i in range(5)])
arr

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

np.nonzero(arr)  # 查找非零元素的索引

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

arr = np.array([np.random.randint(0,6) for i in range(12)]).reshape([3,4])
arr

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

np.nonzero(arr)  # 查找非零元素的索引，当数组为二维数组时，返回行和列的对应

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

np.sort(arr)  # 按行排序

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

np.sort(arr,axis=0)  # 按列排序

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

arr = np.array([np.random.randint(1,11) for i in range(12)]).reshape([3,4])
arr

array([[ 6,  1,  4,  5],
       [ 4,  5,  5,  6],
       [ 4, 10,  6, 10]])

np.transpose(arr)  # 将行和列进行转换

array([[ 6,  4,  4],
       [ 1,  5, 10],
       [ 4,  5,  6],
       [ 5,  6, 10]])

arr.T  # 将行和列进行转换

array([[ 6,  4,  4],
       [ 1,  5, 10],
       [ 4,  5,  6],
       [ 5,  6, 10]])

arr

array([[ 6,  1,  4,  5],
       [ 4,  5,  5,  6],
       [ 4, 10,  6, 10]])

np.clip(arr,5,9)  # 将小于5的数变成5，将大于9的数变成9

array([[6, 5, 5, 5],
       [5, 5, 5, 6],
       [5, 9, 6, 9]])

arr

array([[ 6,  1,  4,  5],
       [ 4,  5,  5,  6],
       [ 4, 10,  6, 10]])

np.mean(arr)  # 求所有元素的平均值

5.5

np.mean(arr,axis=1)  # 求每一行的平均值

array([ 4. ,  5. ,  7.5])

np.mean(arr,axis=0)  # 求每一列的平均值

array([ 4.66666667,  5.33333333,  5.        ,  7.        ])

===============================numpy的索引===============================

arr = np.arange(1,13)
arr

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

arr[3]

4

arr = np.arange(1,13).reshape((3,4))
arr

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

arr[1,3]

8

arr[1][3]

8

arr[1:]  # 取第一行到最后的所有元素

array([[ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

arr[行索引:列索引]¶

arr[1,:]  # 取第一行的元素

array([5, 6, 7, 8])

arr[:,1]  # 取第一列元素

array([ 2,  6, 10])

arr

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

arr[:,1:3]  # 取每一行的第一和第二列

array([[ 2,  3],
       [ 6,  7],
       [10, 11]])

arr[1:3,1:3]  # 取第一行和第二行的第一和第二列

array([[ 6,  7],
       [10, 11]])

arr

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

for row in arr: # 循环打印每一行
    print(row)

[1 2 3 4]
[5 6 7 8]
[ 9 10 11 12]

for column in arr.T:  # 循环打印每一列  首先将行和列进行转换，然后在循环
    print(column)

[1 5 9]
[ 2  6 10]
[ 3  7 11]
[ 4  8 12]

arr.flatten()  # 转换为一维数组

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

for item in arr.flatten():
    print(item)

arr.flat  # 迭代器

<numpy.flatiter at 0x250bece2050>

np.array(arr.flat)

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

for item in arr.flat:
    print(item)

===============================numpy的array合并===============================

arr = np.array([1,1,1])
arr2 = np.array([2,2,2])
arr3 = np.array([3,3,3])

np.vstack((arr,arr2,arr3))  # 行合并(合并后增加行数)

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

np.hstack([arr,arr2,arr3])  # 列合并(合并后增加列数)

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

arr = np.array([1,2,3,4])

arr[:,np.newaxis]  # 是每个元素变为一行

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

arr[np.newaxis,:]  # 时每个元素变为一列

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

arr = np.array([1,1,1])[:,np.newaxis]
arr2 = np.array([2,2,2])[:,np.newaxis]

arr

array([[1],
       [1],
       [1]])

arr2

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

np.hstack([arr,arr2])

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

np.vstack([arr,arr2])

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

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

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

np.concatenate((arr,arr2),axis=0)

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

===============================numpy的array分割===============================

arr = np.arange(12).reshape((3,4))
arr

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

np.split(arr,2,axis=1)   # 纵向分割  将所有列分为两部分

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

arr = np.arange(12).reshape((4,3))
arr

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

np.split(arr,2,axis=0)   # 横向分割  按所有行分为两部分

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

arr = np.arange(12).reshape((3,4))
arr

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

np.array_split(arr,3,axis=1)  # 不等量分割

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

arr = np.arange(15).reshape((3,5))
arr

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

np.array_split(arr,3,axis=1)  # 不等量分割

[array([[ 0,  1],
        [ 5,  6],
        [10, 11]]), array([[ 2,  3],
        [ 7,  8],
        [12, 13]]), array([[ 4],
        [ 9],
        [14]])]