numpy

In [290]:

import numpy as np

 

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

In [291]:

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

Out[291]:

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

In [292]:

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

Out[292]:

6

In [293]:

arr.ndim # 查看数组的维度

Out[293]:

2

In [294]:

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

Out[294]:

(2, 3)

In [295]:

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

Out[295]:

6

In [296]:

# 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 来指定。

In [297]:

arr.dtype

Out[297]:

dtype('float32')

In [298]:

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

Out[298]:

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

In [299]:

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

Out[299]:

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

In [300]:

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

Out[300]:

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

In [301]:

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

Out[301]:

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

In [302]:

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

Out[302]:

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

In [303]:

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

Out[303]:

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

In [304]:

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

Out[304]:

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

In [305]:

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

Out[305]:

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

 

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

In [306]:

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    # 将两个数组对应位置的元素相加

Out[306]:

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

In [307]:

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

Out[307]:

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

In [308]:

arr1 + arr2 - arr3

Out[308]:

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

In [309]:

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

Out[309]:

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

In [310]:

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

Out[310]:

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

In [311]:

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

Out[311]:

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

In [312]:

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

Out[312]:

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

In [313]:

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

In [314]:

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

Out[314]:

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

In [315]:

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

Out[315]:

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

In [316]:

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

Out[316]:

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

In [317]:

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

Out[317]:

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

In [318]:

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

Out[318]:

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

In [319]:

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

Out[319]:

78

In [320]:

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

Out[320]:

12

In [321]:

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

Out[321]:

1

In [322]:

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

Out[322]:

array([1, 5, 9])

In [323]:

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

Out[323]:

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

In [324]:

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

Out[324]:

6.5

In [325]:

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

Out[325]:

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

In [326]:

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

Out[326]:

3

In [327]:

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

Out[327]:

3

In [328]:

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

Out[328]:

1

In [329]:

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

Out[329]:

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

In [331]:

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

Out[331]:

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

In [332]:

arr = np.arange(1,10)
arr

Out[332]:

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

In [337]:

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

Out[337]:

5.5

In [338]:

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

Out[338]:

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

In [341]:

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

Out[341]:

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

In [346]:

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

Out[346]:

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

In [354]:

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

Out[354]:

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

In [355]:

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

Out[355]:

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

In [356]:

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

Out[356]:

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

In [357]:

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

Out[357]:

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

In [358]:

np.sort(arr)  # 按行排序

Out[358]:

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

In [361]:

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

Out[361]:

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

In [362]:

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

Out[362]:

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

In [364]:

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

Out[364]:

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

In [365]:

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

Out[365]:

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

In [369]:

arr 

Out[369]:

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

In [371]:

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

Out[371]:

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

In [373]:

arr

Out[373]:

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

In [374]:

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

Out[374]:

5.5

In [375]:

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

Out[375]:

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

In [376]:

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

Out[376]:

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

In [ ]:

 

 

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

In [377]:

arr = np.arange(1,13)
arr

Out[377]:

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

In [378]:

arr[3]

Out[378]:

4

In [379]:

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

Out[379]:

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

In [386]:

arr[1,3]

Out[386]:

8

In [382]:

arr[1][3]

Out[382]:

8

In [383]:

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

Out[383]:

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

 

arr[行索引:列索引]¶

In [384]:

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

Out[384]:

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

In [385]:

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

Out[385]:

array([ 2,  6, 10])

In [407]:

arr

Out[407]:

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

In [411]:

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

Out[411]:

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

In [413]:

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

Out[413]:

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

In [414]:

arr

Out[414]:

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

In [415]:

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

 

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

In [416]:

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

 

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

In [420]:

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

Out[420]:

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

In [426]:

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

 

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

In [427]:

arr.flat  # 迭代器

Out[427]:

<numpy.flatiter at 0x250bece2050>

In [428]:

np.array(arr.flat)

Out[428]:

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

In [429]:

for item in arr.flat:
    print(item)

 

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

 

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

In [434]:

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

In [436]:

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

Out[436]:

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

In [437]:

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

Out[437]:

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

In [447]:

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

In [448]:

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

Out[448]:

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

In [449]:

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

Out[449]:

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

In [450]:

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

In [452]:

arr

Out[452]:

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

In [453]:

arr2

Out[453]:

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

In [451]:

np.hstack([arr,arr2])

Out[451]:

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

In [454]:

np.vstack([arr,arr2])

Out[454]:

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

In [461]:

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

Out[461]:

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

In [462]:

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

Out[462]:

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

 

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

In [480]:

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

Out[480]:

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

In [481]:

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

Out[481]:

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

In [486]:

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

Out[486]:

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

In [470]:

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

Out[470]:

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

In [471]:

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

Out[471]:

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

In [472]:

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

Out[472]:

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

In [473]:

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

Out[473]:

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

In [474]:

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

Out[474]:

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