• Numpy学习

    目录

    一: Ndarray对象介绍：

    • ndarray只能存储相同的元素（每个元素在内存中占用相同的大小）
    • ndarray是多维数组。

    二： 数组的基本使用:

    1: numpy数据类型

    • numpy的数据类型实际上是dtype对象的实例，并对应唯一的字符， 包括： np.bool_, np.int32, np.float32等等。

    • 每个内建类型，都有一个唯一定义它的字符代码

      • b : 布尔类型
      • i : 有符号整型
      • u : 无符号整型
      • f : 浮点类型
      • c : 复数浮点类型
      • m : timedalta 时间间隔类型
      • M : datetime (日期类型)
      • O : 对象
      • S， s : byte 类型
      • U: unicode 类型
      • v 原始数据类型（viod）

    • 数据类型对象（dtype）

      • 作用： 与数据对应的内存区域如何使用。

      • 创建数据类型对象

    import numpy as np

# 案例一：创建数据类型对象
dt = np.dtype(np.int32)
print(dt)
print(type(dt))
# int32
# 

# 案例二：使用字符代码创建数据对象
dt = np.dtype("i4")
print(dt)
print(type(dt))
# int32
# 

# 案例三：创建复杂类型的数据对象
student = np.dtype([('name', 'S20'), ('age', 'i4'), ('marks', 'f4')])
print(student)
print(type(student))
# [('name', 'S20'), ('age', '
# 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    2: 创建ndarray数组对象

    • ndarray所有的数据类型结构必然是相同的
    • 如果传递进来的是不同类型， 则需要转换成同个类型： str > float > int
    • numpy.array(object, dtype = None, copy = True, order = None, subok = Flase, ndmin = 0)
      • object： 数组/嵌套的数列
      • dtype: 数据元素类型
      • copy: 是否支持复制
      • order: 创建数组的样式（C: 行方向， F列方向， A任意方向）
      • subok: 返回一个与基类型一致的数组
      • ndmin: 指定数组的最小维度
    import numpy as np

# 案例一：创建一个一维数组
arr = np.array([1, 2, 3, 4])
print(arr)
print(type(arr))
# [1 2 3 4]
# 

# 案例二：多维数组
arr = np.array([[1, 2, 3], [2, 3, 4]])
print(arr)
print(type(arr))
# [[1 2 3]
#  [2 3 4]]
# 

# 案例三： 限制最小维度
arr = np.array([1, 2, 3], ndmin=2)
print(arr)
print(type(arr))
# [[1 2 3]]
# 

# 案例四：限制类型
arr = np.array([1, 2, 3], dtype=np.float)
print(arr)
print(type(arr))
# [1. 2. 3.]
# 

# 案例五： 使用结构化数据
student = np.dtype([('name', 'S20'), ('age', 'i4'), ('mark', 'f4')])
arr = np.array([('ren', 18, 20.99), ('li', 20, 30.88)], dtype=student)
print(arr)
print(type(arr))
# [(b'ren', 18, 20.99) (b'li', 20, 30.88)]
# 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • numpy.asarray(a, dtype= None, order = None)
      • a : 任意输入形式
      • dtype : 类型
      • order : C代表行优先， F代表列优先
    import numpy as np

# 1:创建一维数组
arr = np.asarray([1, 2, 3, 4])
print(arr)
print(type(arr))
# [1 2 3 4]
# 

# 2: 创建二维数组
arr = np.asarray([[1, 2, 3], [4, 5, 6]])
print(arr)
print(type(arr))
# [[1 2 3]
#  [4 5 6]]
# 

# 3: 创建复杂类型
student = np.dtype([('name', 'S20'), ('age', 'i4'), ('mark', 'f4')])
arr = np.asarray([('ren', 5, 100.1), ('li', 3, 20.0)], dtype=student)
print(arr)
print(type(arr))
# [(b'ren', 5, 100.1) (b'li', 3,  20. )]
# 


# 4: 创建(列表套字典元素类型)
arr = np.asarray([[(1, 2, 3)], [(2, 3, 4)]])
print(arr)
print(type(arr))
# [[[1 2 3]]
#  [[2 3 4]]]
# 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • numpy.empty(shape, dtype=float, order = “C”)
      • shape: 数组形状
      • dtype: 数组类型
      • order: C: 行优先; F: 列优先
    import numpy as np

# 创建一维数组两行三列的初始化数组
arr = np.empty([2, 3], dtype=int)
print(arr)
print(type(arr))
# [[   0 2043    1]
#  [   0    0    0]]
# 


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • numpy.zeros(shape, dtype = float, order = “C”)
      • shape: 数组形状
      • dtype: 数据类型
      • order: ‘C’行， ‘F’ 列
      • 作用: 创建指定大小的数组， 数据元素默认用0填充
    import numpy as np

# 创建一维数组(三行四列)
arr = np.zeros([3, 2], dtype='f4')
print(arr)
print(type(arr))
# [[0. 0.]
#  [0. 0.]
#  [0. 0.]]
# 

# 创建结构化数组
arr = np.zeros([2, 3], dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'S30')])
print(arr)
print(type(arr))
# [[(0, 0., b'') (0, 0., b'') (0, 0., b'')]
#  [(0, 0., b'') (0, 0., b'') (0, 0., b'')]]
# 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • numpy.ones(shape, dtype = float, order = “C”)
      • shape: 数组形状
      • dtype: 数据类型
      • order: ‘C’行， ‘F’ 列
      • 作用: 创建指定大小的数组， 数据元素默认用1填充
    import numpy as np

# 创建一维数组(三行四列)
arr = np.ones([3, 2], dtype='f4')
print(arr)
print(type(arr))
# [[1. 1.]
#  [1. 1.]
#  [1. 1.]]
# 

# 创建结构化数组
arr = np.ones([2, 3], dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'S30')])
print(arr)
print(type(arr))
# [[(1, 1., b'1') (1, 1., b'1') (1, 1., b'1')]
#  [(1, 1., b'1') (1, 1., b'1') (1, 1., b'1')]]
# 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • numpy.eye(N, M=None, k=0, dtype=float, order=“C”)
      • 作用：对角线为1， 其余的均为0.
      • N: 行数量
      • M: 列数量
      • dtype: 数据类型
      • order: ‘C’行， ‘F’ 列
    import numpy as np

# 1: 生成4 * 4的对角矩阵（中间是1，两边是0）
arr = np.eye(N=4, dtype=int)
print(arr)
print(type(arr))
# [[1 0 0 0]
#  [0 1 0 0]
#  [0 0 1 0]
#  [0 0 0 1]]
# 

# 2: 生成对角矩阵（3 * 4）
arr = np.eye(N=3, M=4, dtype=int)
print(arr)
print(type(arr))
# [[1 0 0 0]
#  [0 1 0 0]
#  [0 0 1 0]]
# 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • numpy.arange(start, stop, step, dtype)
      • 作用: 创建数值类型范围
      • stop: 终止值
      • start: 开始值
      • step: 步长
    import numpy as np

# 1: 生成1～10的一维数组
arr = np.arange(start=0, stop=10, step=1)
print(arr)
# [0 1 2 3 4 5 6 7 8 9]

arr = np.arange(start=0, stop=10)
print(arr)
# [0 1 2 3 4 5 6 7 8 9]

# 2 生成[2， 4， 6， 8]
arr = np.arange(start=2, stop=10, step=2)
print(arr)
# [2 4 6 8]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • numpy.frombuffer(buffer, dtype = float, count= 1, offset = 0)
      • 作用， 传入其他对象， 转换成数组对象
      • buffer: 任意对象
      • dtype: 类型
      • count: 读取的数据量
      • offset: 偏移掉的个数
    import numpy as np

# 1: 读取字符串中的全部数据
test_str = b'ren shan wen is a good man.'
arr = np.frombuffer(test_str, dtype="S1")
print(arr)
# [b'r' b'e' b'n' b' ' b's' b'h' b'a' b'n' b' ' b'w' b'e' b'n' b' ' b'i'
#  b's' b' ' b'a' b' ' b'g' b'o' b'o' b'd' b' ' b'm' b'a' b'n' b'.']

# 2: 只将"a good man" 读取
test_str = b'ren shan wen is a good man.'
arr = np.frombuffer(test_str, dtype="S1", count=10, offset=16)
print(arr)
# [b'a' b' ' b'g' b'o' b'o' b'd' b' ' b'm' b'a' b'n']

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • numpy.fromiter(iterable, dtype, count=1)
      • 作用：将可迭代对象转换成ndarry对象
      • iterable: 可迭代对象
      • dtype: 返回的类型
      • count: 读取的数据量
    import numpy as np

# 1: 读取字符串中的全部数据
test_list = ['ren', 'shan', "wen"]
arr = np.fromiter(test_list, dtype="S3")
print(arr)
# [b'ren' b'sha' b'wen']

# 2: 读取前2位
test_list = ['ren', 'shan', "wen"]
arr = np.fromiter(test_list, dtype="S3", count=2)
print(arr)
# [b'ren' b'sha']

# 3: 读取后两位
test_list = ['ren', 'shan', "wen"]
arr = np.fromiter(test_list[-2:], dtype="S3", count=2)
print(arr)
# [b'sha' b'wen']


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • numpy.linespace(start, stop, num=50, endpoint=True, restep=False, dtype=None)
      • 作用： 创建一个等差数列构成的一维数组
      • start : 序列开始值
      • stop : 序列终止值
      • num: 生成一维数组的长度
      • endpoint: true: 数列中包含stop
      • restep: true: 显示间距
    import numpy as np

arr = np.linspace(start=1, stop=10, num=10, dtype="i4")
print(arr)
# [ 1  2  3  4  5  6  7  8  9 10]
arr = np.linspace(start=1, stop=9, num=5, dtype="i4")
print(arr)
# [1 3 5 7 9]


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtyope=None)
      • 作用： 创建等比数列
      • base: 对数log的底数
      • start: 序列开始值： base * start
      • stop: 序列终止值： base * stop
      • num: 生成一维数组的长度
      • endpoint: true: 数列中包含stop
    import numpy as np

arr = np.logspace(start=1.0, stop=2.0, num=10)
print(arr)
# [ 10.          12.91549665  16.68100537  21.5443469   27.82559402
#   35.93813664  46.41588834  59.94842503  77.42636827 100.        ]

arr = np.logspace(start=1.0, stop=10.0, num=10, base=2.0)
print(arr)
# [   2.    4.    8.   16.   32.   64.  128.  256.  512. 1024.]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • np.random.rand()
      • 作用： 生成0到1之间的随机数
    import numpy as np

rand_int = np.random.rand()
print(rand_int)
# 0.9589287295877952

arr = np.random.rand(3)
print(arr)
# [0.42679038 0.49927222 0.13372776]


arr = np.random.rand(3, 2)
print(arr)
# [[0.93187502 0.74321757]
#  [0.42415062 0.96488193]
#  [0.31604436 0.3220751 ]]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • np.random.random(size=None)
      • 作用： 生成0到1之间的随机数
      • size: 指定元素的个数
    
import numpy as np

rand_int = np.random.random()
print(rand_int)
# 0.9589287295877952

arr = np.random.random(3)
print(arr)
# [0.42679038 0.49927222 0.13372776]


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • np.random.randint(size=None)
      • 作用： 生成0到1之间的随机整数
      • low: 下限
      • hight: 上线
      • size: 个数
      • dtype: 类型
    
import numpy as np

arr = np.random.randint(low=0, high=10, size=10)
print(arr)
# [5 8 3 3 7 3 9 6 9 6]


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • np.random.randn()
      • 作用： 返回一个/一组， 标准正态分布的数据。
    import numpy as np

arr = np.random.randn()
print(arr)
# 0.03645361634459795

arr = np.random.randn(3)
print(arr)
# [-1.728654    0.34386948 -0.90550311]

arr = np.random.randn(3, 2)
print(arr)
# [[-0.24651029 -0.87297746]
#  [ 2.30646279 -0.52588351]
#  [ 0.41470461 -0.57592071]]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • np.random.normal(loc=0.0, scale=1.0, size = None)
      • 作用： 生成高斯分布的概率密度随机数

    3: numpy数组与Python中列表对比

    • ndarray的维度/轴的数量， 叫秩。可以用axis进行声明。
      • axis = 0， 表示对列进行操作。
      • axis = 1, 表示对行进行操作。
    • 常用的属性
      • ndmin: 秩
      • shape: 数组的维度： n行m列
      • size: 数组的大小： n * m
      • dtype: 对象元素属性
      • itemsize: 对象元素的大小
      • flags: 对象的内存信息
      • real: 元素的实部
      • imag: 元素的虚部
    import numpy as np

# 1：打印数组的秩
arr = np.arange(24)
print(arr.ndim)
# 1
arr2 = arr.reshape(2, 3, 4)
print(arr2.ndim)
# 3

# 2: 打印数组的维度
print(arr2.shape)
# (2, 3, 4)

# 3: 修改数组的维度
arr3 = np.array([[1, 2, 3], [4, 5, 6]])
arr3.shape = (3, 2)
print(arr3)
# [[1 2]
#  [3 4]
#  [5 6]]

# 4: 打印数组的大小
print(arr3.size)
# 6

# 5: 打印数据类型
print(arr3.dtype)
# int64

# 6: 打印元素内存元素大小
print(arr3.itemsize)
# 8 (每个元素8个字节)

# 7： 返回元素内存信息
print(arr3.flags)
#   C_CONTIGUOUS : True
#   F_CONTIGUOUS : False
#   OWNDATA : True
#   WRITEABLE : True
#   ALIGNED : True
#   WRITEBACKIFCOPY : False


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    三： 元素操作

    3.1: 切片和索引

    • ndarray对象可以像列表一样， 使用下标进行访问。
    • 可以使用内置slice函数， 设置: start, stop, step，基于原来的ndarray对象， 创建一个新的nadarry对象。
    • … 表示取全部
    import numpy as np

# 1: 下标方式访问
arr = np.arange(10)
print(arr[9])
# 9

# 2: 基于原来新建ndarray对象
arr2 = arr[slice(2, 8, 2)]
print(arr2)
# [2 4 6]

# 3: 冒号方式
arr3 = arr[2: 8: 2]
print(arr3)
# [2 4 6]

# 4: 多维数据提取
arr = np.arange(15)
arr.shape = (5, 3)
print(arr)
# [[ 0  1  2]
#  [ 3  4  5]
#  [ 6  7  8]
#  [ 9 10 11]
#  [12 13 14]]
arr2 = arr[1:]   # 截取第二行往后的
print(arr2)
# [[ 3  4  5]
#  [ 6  7  8]
#  [ 9 10 11]
#  [12 13 14]]

arr3 = arr[..., 2:]  # 截取第二列往后的
print(arr3)
# [[ 2]
#  [ 5]
#  [ 8]
#  [11]
#  [14]]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    3.2: 高级索引

    • 整数索引
    import numpy as np


# 1: 获取0,0   1,1   2,0下标的元素
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr[[0, 1, 2], [0, 1, 0]])
# [1 5 7]

# 2: 获取第一行之后的， 和第一列之后的交集元素
print(arr[1:, 1:])
# [[5 6]
#  [8 9]]

# 3：获取第一行之后和1， 2列的元素
print(arr[1:, [1, 2]])
# [[5 6]
#  [8 9]]

# 4: 获取全部的行， 和1， 2列的元素
print(arr[..., [1, 2]])
# [[2 3]
#  [5 6]
#  [8 9]]

# 5: 获取 [00, 02], [30, 32]的元素
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
print(arr[[0, 0, 3, 3], [0, 2, 0, 2]])
# [ 1  3 10 12]
print(arr[[[0, 0], [3, 3]], [[0, 2], [0, 2]]])
# [[ 1  3]
#  [10 12]]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 布尔索引
    import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr[arr > 5])
# [6]

arr = np.array([np.nan, 1, 2, np.nan])
print(arr[np.isnan(arr)])
# [nan nan]
print(arr[~np.isnan(arr)])
# [1. 2.]


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

    3.3: 广播

    • 形状相同的对象， 可以直接操作

    import numpy as np

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
print(arr1 + arr2)
# [5 7 9]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 形状不相同， 通过广播后， 也可以进行运算
    arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([1, 1, 1])
print(arr1 + arr2)
# [[2 3 4]
# [5 6 7]]

    • 1
    • 2
    • 3
    • 4
    • 5

    3.4: 迭代

    • numpy.nditer()进行迭代
    import numpy as np

arr1 = np.arange(12)
arr1 = arr1.reshape(3, 4)
print(arr1)
# [[ 0  1  2  3]
# [ 4  5  6  7]
# [ 8  9 10 11]]

for i in np.nditer(arr1):
    print(i, end=", ")
# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 列优先遍历和行优先遍历
      • 默认是行优先遍历
    
for i in np.nditer(arr1, order="C"):
    print(i, end=", ")
print("\n")
# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,

for i in np.nditer(arr1, order="F"):
    print(i, end=", ")
# 0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11, 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 遍历的过程中修改元素
    for i in np.nditer(arr1, order="C", op_flags=["readwrite"]):
    i[...] = i * 2
    print(i, end=", ")
print("\n")
# 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 外部循环
      • 参数：flags
        • c_index
        • f_index
        • nulti-index
        • external_loop : 遍历完的数据， 放到一个数组中。
    for i in np.nditer(arr1, order="C", op_flags=["readwrite"], flags=["external_loop"]):
    i[...] = i * 2
    print(i)
print("\n")
# [ 0  2  4  6  8 10 12 14 16 18 20 22]


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 广播迭代
    import numpy as np

arr1 = np.arange(12).reshape(3, 4)
print(arr1)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
arr2 = np.arange(1, 5)
print(arr2)
# [1 2 3 4]


for x, y in np.nditer([arr1, arr2]):
    print("%s %s" % (x, y))
# 0 1
# 1 2
# 2 3
# 3 4
# 4 1
# 5 2
# 6 3
# 7 4
# 8 1
# 9 2
# 10 3
# 11 4


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    四： 数组操作

    4.1: 修改数组形状

    • reshape(shape, order)

      • shape: (2, 3)
      • order: 顺序

    • flat:

      • 数值形式拿出来

    • flatten()

      • 展平： 不会修改原数组

    • ravel()

      • 展平： C方式修改原数组， F方式不会修改原来数组。
    import numpy as np

# 1：reshape修改数组形状
arr = np.arange(12)
arr1 = arr.reshape(3, 4)
print(arr1)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# 2: 使用flat展平数组
for i in arr1.flat:
    print(i, end=", ")
print("\n")
# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,


# 3: flatten 展平数组
arr2 = arr1.flatten(order="F")
print(arr2)
# [ 0  4  8  1  5  9  2  6 10  3  7 11]
arr2[0] = 100
print(arr1)  # 原数组没有改变
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# 4: ravel 展平数组
arr3 = arr1.ravel(order="F")
print(arr3)
# [ 0  4  8  1  5  9  2  6 10  3  7 11]
arr3[0] = 100
print(arr1)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

arr4 = arr1.ravel(order="C")
print(arr4)
# [ 0  4  8  1  5  9  2  6 10  3  7 11]
arr4[0] = 100  # C 方式改变形状，则会影响到原来的数组 
print(arr1)
# [[100   1   2   3]
#  [  4   5   6   7]
#  [  8   9  10  11]]


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    4.2: 翻转数组

    • transpose(a, axes)

      • 作用： 翻转数组
      • axes： 要翻转的维度
      • a: 原来的数组

    • a.T

      • 作用： 翻转数组

    • rollaxis(a, axis, start=0):

      • a : 原始数组
      • axis: 向后滚动的轴
      • start: 开始滚动的轴， 默认是0轴。

    • swapaxes(a, axis1, axis2)

      • 交换数组的两个轴
    
import numpy as np

arr = np.arange(12).reshape(3, 4)
print(arr)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# 1：transpose翻转数组
arr1 = np.transpose(arr)
print(arr1)
# [[ 0  4  8]
#  [ 1  5  9]
#  [ 2  6 10]
#  [ 3  7 11]]


# 2: T方式翻转数组
arr2 = arr.T
print(arr2)
# [[ 0  4  8]
#  [ 1  5  9]
#  [ 2  6 10]
#  [ 3  7 11]]

# 3: rollaxis翻转数组
arr3 = np.rollaxis(arr, axis=1)
print(arr3)
# [[ 0  4  8]
#  [ 1  5  9]
#  [ 2  6 10]
#  [ 3  7 11]]

# 4: swapaxes进行翻转
arr4 = np.swapaxes(arr, 0, 1)
print(arr4)
# [[ 0  4  8]
#  [ 1  5  9]
#  [ 2  6 10]
#  [ 3  7 11]]

# 5: 三维数组，交换维度
arr = np.arange(24).reshape(2, 3, 4)
print(arr)
# [[[ 0  1  2  3]
#   [ 4  5  6  7]
#   [ 8  9 10 11]]
#
#  [[12 13 14 15]
#   [16 17 18 19]
#   [20 21 22 23]]]

arr2 = np.swapaxes(arr, 1, 2)
print(arr2)
# [[[ 0  4  8]
#   [ 1  5  9]
#   [ 2  6 10]
#   [ 3  7 11]]
# 
#  [[12 16 20]
#   [13 17 21]
#   [14 18 22]
#   [15 19 23]]]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64

    4.3: 修改数组维度

    • broadcast()

    • broadcast_to()

      • 将数组广播到新的形状

    • expand_dims（）

      • 增加维度

    • squeeze()

      • 降低维度
    import numpy as np

arr1 = np.array([[1], [2], [4]])
arr2 = np.array([4, 5, 6])

# arr2广播到arr1维度
arr = np.broadcast(arr1, arr2)
new_arr = np.empty(arr.shape)
print(new_arr)

# 改变维度
a = np.arange(1, 5).reshape(1, 4)
print(a)
# [[1 2 3 4]
b = np.broadcast_to(a, (2, 4))
print(b)
# [[1 2 3 4]
#  [1 2 3 4]]

# 增加维度
x = np.arange(1, 5).reshape((2, 2))
print(x)
# [[1 2]
#  [3 4]]
y = np.expand_dims(x, axis=0)
print(y)
# [[[1 2]
#   [3 4]]]

# 减少维度(只能减少维度值为1的)
z = np.squeeze(y)
print(z)
# [[1 2]
#  [3 4]]


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    4.4: 连接数组

    • np.concatenate()
    • np.stack()
    • np.hstack()
    • np.vstack()
    import numpy as np

# 1: concatenate合并数组
x = np.arange(4).reshape((2, 2))
y = np.arange(4, 8).reshape((2, 2))
z = np.concatenate((x, y), axis=0)
print(z)
# [[0 1]
#  [2 3]
#  [4 5]
#  [6 7]]
h = np.concatenate((x, y), axis=1)
print(h)
# [[0 1 4 5]
#  [2 3 6 7]]

# 2: stack合并数组(会新增一个维度)
z2 = np.stack((x, y), axis=0)
print(z2)
# [[[0 1]
#   [2 3]]
#
#  [[4 5]
#   [6 7]]]
h2 = np.stack((x, y), axis=1)
print(h2)
# [[[0 1]
#   [4 5]]
#
#  [[2 3]
#   [6 7]]]

# 3: hstack 合并
z3 = np.hstack((x, y))
print(z3)
# [[0 1 4 5]
#  [2 3 6 7]]

# 4： vstack 合并
z4 = np.vstack((x, y))
print(z4)
# [[0 1]
#  [2 3]
#  [4 5]
#  [6 7]]


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    4.5: 分割数组

    • np.splite()
    • np.hsplite()
    • np.vsplite()
    
import numpy as np

# 1: 切分一维数组
arr = np.arange(12)
arr1 = np.split(arr, 2)  # 平均分成两份
print(arr1)
# [array([0, 1, 2, 3, 4, 5]), array([ 6,  7,  8,  9, 10, 11])]
arr2 = np.split(arr, [3, 6]) # 从下标为3的地方开始切下标为5的结束
print(arr2)
# [array([0, 1, 2]), array([3, 4, 5]), array([ 6,  7,  8,  9, 10, 11])]

# 2: 切分二维数组
arr = np.arange(12).reshape(3, 4)
print(arr)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
arr1 = np.split(arr, 3)
print(arr1)
# [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
arr1 = np.vsplit(arr, 3)
print(arr1)
# [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
arr2 = np.split(arr, 4, axis=1)
print(arr2)
# [array([[0],
#        [4],
#        [8]]), array([[1],
#        [5],
#        [9]]), array([[ 2],
#        [ 6],
#        [10]]), array([[ 3],
#        [ 7],
#        [11]])]
arr2 = np.hsplit(arr, 4)
print(arr2)
# [array([[0],
#        [4],
#        [8]]), array([[1],
#        [5],
#        [9]]), array([[ 2],
#        [ 6],
#        [10]]), array([[ 3],
#        [ 7],
#        [11]])]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    4.6: 数组元素的添加和删除

    • 重置数组
      • resize(arr, shape)
      • 不够的话， 从开头开始取之， 补充到最后。
    import numpy as np

# 重置数组
arr = np.arange(6).reshape(2, 3)
print(arr)
# [[0 1 2]
#  [3 4 5]]

arr1 = np.resize(arr, (3, 2))
print(arr1)
# [[0 1]
#  [2 3]
#  [4 5]]

# 不够从开头开始抄
arr2 = np.resize(arr, (3, 3))
print(arr2)
# [[0 1 2]
#  [3 4 5]
#  [0 1 2]]


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 追加数组
      • numpy.append(arr, values, axis=None)
      • 在数组尾部追加
      • 追加后的数组是个新数组
      • 追加的数组的维度必须匹配
    import numpy as np

arr = np.arange(6).reshape(2, 3)
print(arr)
# [[0 1 2]
#  [3 4 5]]
arr1 = np.append(arr, [7, 8, 9])
print(arr1)
# [0 1 2 3 4 5 7 8 9]
arr2 = np.append(arr, [[7, 8, 9]], axis=0)
print(arr2)
# [[0 1 2]
#  [3 4 5]
#  [7 8 9]]

arr3 = np.append(arr, [[7, 8], [8, 9]], axis=1)
print(arr3)
# [[0 1 2 7 8]
#  [3 4 5 8 9]]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 插入数据
      • insert(arr, obj, values,axis)
    import numpy as np

arr = np.arange(6).reshape(3, 2)
print(arr)
# [[0 1]
#  [2 3]
#  [4 5]]

arr2 = np.insert(arr, 3, [11, 12])
print(arr2)
# [ 0  1  2 11 12  3  4  5]

arr3 = np.insert(arr, 3, [11, 12], axis=0)
print(arr3)
# [[ 0  1]
#  [ 2  3]
#  [ 4  5]
#  [11 12]]

arr4 = np.insert(arr, 1, [11], axis=1)
print(arr4)
# [[ 0 11  1]
#  [ 2 11  3]
#  [ 4 11  5]]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 删除指定的子数组， 得到新数组
      • numpy.delete(arr, obj, axis)
    
import numpy as np

arr = np.arange(12).reshape(3, 4)
print(arr)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

arr2 = np.delete(arr, 1)
print(arr2)
# [ 0  2  3  4  5  6  7  8  9 10 11]

arr3 = np.delete(arr, 1, axis=0)
print(arr3)
# [[ 0  1  2  3]
#  [ 8  9 10 11]]

arr4 = np.delete(arr, 1, axis=1)
print(arr4)
# [[ 0  2  3]
#  [ 4  6  7]
#  [ 8 10 11]]


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 数组去重
      • numpy.unique(arr, return_index, return_inverse, return_counts)
      • return_index: 现在数据元素在原数组中的下标
      • return_inverse： 原来数组在现数组中的下标
      • return_counts: 返回原数组中该元素的数量
    
import numpy as np

arr = np.array([1, 2, 3, 4, 1, 2, 7, 8, 9, 1, 2, 3])
print(arr)
# [1 2 3 4 1 2 7 8 9 1 2 3]
arr1 = np.unique(arr)
print(arr1)
# [1 2 3 4 7 8 9]
arr2 = np.unique(arr, return_index=True)
print(arr2)
# (array([1, 2, 3, 4, 7, 8, 9]), array([0, 1, 2, 3, 6, 7, 8]))
arr3 = np.unique(arr, return_inverse=True)
print(arr3)
# (array([1, 2, 3, 4, 7, 8, 9]), array([0, 1, 2, 3, 0, 1, 4, 5, 6, 0, 1, 2]))
arr4 = np.unique(arr, return_counts=True)
print(arr4)
# (array([1, 2, 3, 4, 7, 8, 9]), array([3, 3, 2, 1, 1, 1, 1]))


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    五：函数

    5.1: 字符串函数

    • add()
      • 元素拼接
    • nultiply()
      • 多重拼接
    • center()
      • 左右填充
    • capitalize()
      • 单词首字母大写
    • title()
      • 首个字母大写
    • lower()
      • 转化小写
    • upper()
      • 转化大写
    • split()
      • 指定分隔符， 进行切割
    • splitlines()
      • 根据换行符切割
    • strip()
      • 去除首尾的空格
    • join()
      • 指定分隔符连接元素
    • encode()
      • 编码
    • decode()
      • 解码
    import numpy as np

# add
print(np.char.add(["good"], ["good"]))
print(np.char.add(["good", "night"], ["good", "night"]))
# ['goodgood']
# ['goodgood' 'nightnight']

# multiply
print(np.char.multiply("good", 3))
# goodgoodgood

# center
print(np.char.center(["nice", "handsome"], 20, fillchar="*"))
# ['********nice********' '******handsome******']

# capitalize
print(np.char.capitalize(["suck is a good man"]))
# ['Suck is a good man']

# title
print(np.char.title(["suck is a good man"]))
# ['Suck Is A Good Man']

# lower
print(np.char.lower(["SuCk is A gOod Man"]))
# ['suck is a good man']

# upper
print(np.char.upper(["SuCk is A gOod Man"]))
# ['SUCK IS A GOOD MAN']

# split
print(np.char.split(["SuCk is A gOod Man"]))
# [list(['SuCk', 'is', 'A', 'gOod', 'Man'])]

# splitlines
print(np.char.splitlines(["SuCk is \n A gOod \n Man"]))
# [list(['SuCk is ', ' A gOod ', ' Man'])]

# strip
print(np.char.strip(["******SuCk is  A gOod Man****"], "*"))
# ['SuCk is  A gOod Man']

# join
print(np.char.join("-", ["nice", "good"]))
# ['n-i-c-e' 'g-o-o-d']
print(np.char.join(["-", "*"], ["nice", "good"]))
# ['n-i-c-e' 'g*o*o*d']

# replace
print(np.char.replace(["suck is a good man"], "good", "handsome"))
# ['suck is a handsome man']

# encode
print(np.char.encode(["suck is a good man"], "utf-8"))
#[b'suck is a good man']

# decode
print(np.char.decode([b"suck is a good man"], "utf-8"))
# ['suck is a good man']


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62

    5.2: 数学函数

    • 三角函数
      • np.sin()
      • np.cos()
      • np.tan()
      • np.arcsin()
      • np.arccos()
      • np.arctan()
    • 四舍五入
      • around()
      • floor(): 向上取整
      • ceil(): 向下取整

    5.3: 算数函数

    • 加减乘除
      • np.add()
      • np.subtract()
      • multiply()
      • divide()
    • 取倒数
      • reciprocal()
    • 幂运算
      • power()
    • 取余数
      • mod()
      • remainder()
    import numpy as np

arr = np.array([1, 0.5, 3])
arr2 = np.reciprocal(arr)
print(arr2)
# [1.         2.         0.33333333]

arr3 = np.power([1, 2, 3], [1, 2, 3])
print(arr3)
# [ 1  4 27]

arr4 = np.mod([5, 3], [3, 2])
print(arr4)
# [2 1]
arr5 = np.remainder([5, 3], [3, 2])
print(arr5)
# [2 1]

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

    5.4: 排序函数

    • sort()
    • argsort()
    • lexsort()
    • msort()
    import numpy as np

x = np.random.randint(1, 11, 12).reshape(3, 4)
print(x)

# 排序
a = np.sort(x)
print(a)

# 按列排序
b = np.sort(x, axis=0)
print(b)

# 按照字段排序
dt = np.dtype([("name", "S10"), ("age", int)])
y = np.array([("lidehua", 93), ("xakxns", 44), ("daddasd", 55)], dtype=dt)
print(np.sort(y, order="age"))
# [(b'xakxns', 44) (b'daddasd', 55) (b'lidehua', 93)]

# 返回应该顺序的下标
x = np.array([3, 1, 2])
a = np.argsort(x)
print(a)
# [1 2 0]
b = x[a]
print(b)
# [1 2 3]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    5.5: 搜索函数

    • 搜索给定轴最大值和最小值(索引)

      • min(): 返回最小值
      • max(): 返回最大值
      • argmin(): 返回最小值下标
      • argmax(): 返回最大值下标

    • 返回非0元素的索引:

      • nonzero()

    • 返回给定条件的索引:

      • where()

    • 抽取符合条件的元素返回

      • extract()
    
import numpy as np

arr = np.array([1, 2, 3])
arr1 = np.array([[1, 4, 3], [2, 2, 6]])
# min
print(np.min(arr))
# 1
print(np.min(arr1, axis=0))
# [1 2 3]
print(np.min(arr1, axis=1))
# [1 2]
print(np.argmin(arr1,  axis=0))
# [0 1 0]
print(np.argmax(arr1, axis=1))
# [1 2]

arr = np.array([0, 1, 2, 3])
print(np.nonzero(arr))
# (array([1, 2, 3]),)

print(np.where(arr > 2))
# (array([3]),) # 返回的下标

arr = np.array([[31, 40, 4], [2, 23, 4], [50, 3, 60]])
con = np.mod(arr, 2) == 0
print(np.extract(con, arr))
# [40  4  2  4 50 60]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    六：拷贝

    6.1: 赋值

    6.2: 视图

    6.3: 副本

    七：IO操作

    6.1: IO函数

  • 相关阅读:
    扬帆牧哲—跨境电商行业商标有多重要？
    pytorch:dataloader自定义数据集制作
    Three.js-着色器加工材质及材质着色器详解
    计算机毕设 基于机器学习的文本聚类 - 可用于舆情分析
    适合初学者的云服务器——观星云
    【深入了解操作系统进程：它们的角色、管理和重要性】
    Spring学习笔记（狂神说）
    Matter 是什么？
    LVS -DR
    1044 Shopping in Mars
  • 原文地址：https://blog.csdn.net/qq_41341757/article/details/126112409