Numpy学习

目录

• ​​一: Ndarray对象介绍：​​
• ​​二： 数组的基本使用:​​

• ​​1: numpy数据类型​​
• ​​2: 创建ndarray数组对象​​
• ​​3: numpy数组与Python中列表对比​​

• ​​三： 元素操作​​

• ​​3.1: 切片和索引​​
• ​​3.2: 高级索引​​
• ​​3.3: 广播​​

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

• ​​3.4: 迭代​​

• ​​四： 数组操作​​

• ​​4.1: 修改数组形状​​
• ​​4.2: 翻转数组​​
• ​​4.3: 修改数组维度​​
• ​​4.4: 连接数组​​
• ​​4.5: 分割数组​​
• ​​4.6: 数组元素的添加和删除​​

• ​​五：函数​​

• ​​5.1: 字符串函数​​
• ​​5.2: 数学函数​​
• ​​5.3: 算数函数​​
• ​​5.4: 排序函数​​
• ​​5.5: 搜索函数​​

• ​​六：拷贝​​

• ​​6.1: 赋值​​
• ​​6.2: 视图​​
• ​​6.3: 副本​​

• ​​七：IO操作​​

• ​​6.1: IO函数​​

一: 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
# <class 'numpy.dtype[int32]'>

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

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

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]
# <class 'numpy.ndarray'>

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

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

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

# 案例五： 使用结构化数据
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)]
# <class 'numpy.ndarray'>

• 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]
# <class 'numpy.ndarray'>

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

# 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. )]
# <class 'numpy.ndarray'>


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

• 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]]
# <class 'numpy.ndarray'>

• 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.]]
# <class 'numpy.ndarray'>

# 创建结构化数组
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'')]]
# <class 'numpy.ndarray'>

• 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.]]
# <class 'numpy.ndarray'>

# 创建结构化数组
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')]]
# <class 'numpy.ndarray'>

• 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]]
# <class 'numpy.ndarray'>

# 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]]
# <class 'numpy.ndarray'>

• 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]

• 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']

• 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']

• 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]

• 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.]

• 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 ]]

• 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]

• 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]

• 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]]

• 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

三： 元素操作

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]]

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]]

• 布尔索引

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.]

3.3: 广播

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

import numpy as np

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

• 形状不相同， 通过广播后， 也可以进行运算

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

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,

• 列优先遍历和行优先遍历

• 默认是行优先遍历

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,

• 遍历的过程中修改元素

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,

• 外部循环

• 参数：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]

• 广播迭代

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

四： 数组操作

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]]

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]]]

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]]

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]]

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]])]

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]]

• 追加数组

• 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]]

• 插入数据

• 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]]

• 删除指定的子数组， 得到新数组

• 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]]

• 数组去重

• 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]))

五：函数

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']

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]

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]

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]

六：拷贝

6.1: 赋值

6.2: 视图

6.3: 副本

七：IO操作

6.1: IO函数