numpy的学习

import numpy as np
import numpy.matlib

# # 一维
# a = np.array([1,2,3])
# print(a)

# # 二维
# a = np.array([[1, 2], [3, 4]])
# print(a)

# # 最小维度
# a = np.array([1, 2, 3, 4], ndmin=3)
# print(a)

# # dtype 参数
# a = np.array([1, 2, 3], dtype=complex)
# print(a)

# # 使用标量类型
# dt = np.dtype(np.int32)
# print(dt)

# # int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
# dt = np.dtype('i4')
# print(dt)

# # 首先创建结构化数据类型
# dt = np.dtype([('age', np.int8)])
# print(dt)
# # 将数据类型应用于 ndarray 对象
# a = np.array([(10,), (20,), (30,)], dtype=dt)
# print(a)
# # 类型字段名可以用于存取实际的 age 列
# print(a['age'])

# # 结构化数据
# student = np.dtype([('name', 'S20'), ('age', 'i1'), ('marks', 'f4')])
# a = np.array([('abc', 21, 50), ('xyz', 18, 75)], dtype=student)
# print(a)

# # 数组的秩
# a = np.arange(24)
# print(a.ndim)  # a 现只有一个维度
# # 现在调整其大小
# b = a.reshape(1, 4, 6)  # b 现在拥有三个维度
# print(b)
# print(b.ndim)

# # 数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)
# a = np.array([[1, 2, 3], [4, 5, 6]])
# print(a.shape)
# print(a.ndim)

# # 调整数组的大小
# a = np.array([[1, 2, 3], [4, 5, 6]])
# b = a.reshape(3, 2)
# print(b)
# a.shape = (3, 2)
# print(a)

# # 数组的 dtype 为 int8（一个字节）
# x = np.array([1, 2, 3, 4, 5], dtype=np.int8)
# print(x.itemsize)
# # 数组的 dtype 现在为 float64（八个字节）
# y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
# print(y.itemsize)

# # ndarray 对象的内存信息
# x = np.array([1, 2, 3, 4, 5])
# print(x.flags)

# # 创建空数组
# x = np.empty([3, 2], dtype=int)
# print(x)

# # 创建指定大小的数组,数组元素以 0 来填充
# # 默认为浮点数
# x = np.zeros(5)
# print(x)
# # 设置类型为整数
# y = np.zeros((5,), dtype=np.int)
# print(y)
# # 自定义类型
# z = np.zeros((2, 2), dtype=[('x', 'i4'), ('y', 'i4')])
# print(z)

# # 创建指定形状的数组，数组元素以1来填充
# # 默认为浮点数
# x = np.ones(5)
# print(x)
# # 自定义类型
# x = np.ones([2, 2], dtype=int)
# print(x)

# # 将列表转换为 ndarray
# x = [1, 2, 3]
# a = np.asarray(x)
# print(a)

# # 将元组转换为 ndarray
# x = (1, 2, 3)
# a = np.asarray(x, dtype=float)
# print(a)

# # 将元组列表转换为ndarray
# x = [(1, 2, 3), (4, 5)]
# a = np.asarray(x)
# print(a)

# # 接受 buffer 输入参数，以流的形式读入转化成ndarray对象
# s = b'Hello World'
# a = np.frombuffer(s, dtype='S1')
# print(a)

# # 从可迭代对象中建立 ndarray 对象，返回一维数组
# list = range(5)
# it = iter(list)
# # 使用迭代器创建 ndarray
# x = np.fromiter(it, dtype=float)
# print(x)

# # 从数值范围创建数组
# x = np.arange(10, 20, 2, dtype=float)
# print(x)

# # 创建等差一维数组
# # 不包含终止值
# a = np.linspace(10, 20, 5, endpoint=False)
# print(a)
# # 显示间距
# a = np.linspace(1, 10, 10, retstep=True)
# print(a)
# b = np.linspace(1, 10, 10).reshape([10, 1])
# print(b)

# # 创建等比数列
# a = np.logspace(0, 9, 10, base=2)
# print(a)

# # 切片索引
# a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
# print(a)
# # 从某个索引处开始切割
# print('从数组索引 a[1:] 处开始切割')
# print(a[1:])
# print(a[..., 1])  # 第2列元素
# print(a[1, ...])  # 第2行元素
# print(a[..., 1:])  # 第2列及剩下的所有元素

# # 高级索引
# # 获取数组中(0,0)，(1,1)和(2,0)位置处的元素
# x = np.array([[1, 2], [3, 4], [5, 6]])
# y = x[[0, 1, 2], [0, 1, 0]]
# print(y)

# x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
# print('我们的数组是：')
# print(x)
# print('\n')
# rows = np.array([[0, 0], [3, 3]])
# cols = np.array([[0, 2], [0, 2]])
# y = x[rows, cols]
# print('这个数组的四个角元素是：')
# print(y)

# a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# b = a[1:3, 1:3]
# c = a[1:3, [1, 2]]
# d = a[..., 1:]
# print(b)
# print(c)
# print(d)

# # 布尔索引
# x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
# print('我们的数组是：')
# print(x)
# print('\n')
# # 现在我们会打印出大于 5 的元素
# print('大于 5 的元素是：')
# print(x[x > 5])

# # 使用 ~（取补运算符）来过滤 NaN
# a = np.array([np.nan, 1, 2, np.nan, 3, 4, 5])
# print(a[~np.isnan(a)])

# # 过滤掉非复数元素
# a = np.array([1, 2 + 6j, 5, 3.5 + 5j])
# print(a[np.iscomplex(a)])

# # 花式索引
# # 传入顺序索引数组,索引行号
# x = np.arange(32).reshape((8, 4))
# print(x[[4, 2, 1, 7]])

# # 传入倒序索引数组
# x = np.arange(32).reshape((8, 4))
# print(x[[-4, -2, -1, -7]])

# # 传入多个索引数组（要使用np.ix）
# x = np.arange(32).reshape((8, 4))
# print(x[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])])

# # 当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制
# a = np.array([[0, 0, 0],
#               [10, 10, 10],
#               [20, 20, 20],
#               [30, 30, 30]])
# b = np.array([1, 2, 3])
# print(a + b)
# # 相当于下面的操作
# a = np.array([[0, 0, 0],
#               [10, 10, 10],
#               [20, 20, 20],
#               [30, 30, 30]])
# b = np.array([1, 2, 3])
# bb = np.tile(b, (4, 1))
# print(bb)
# print(a + bb)

# # 迭代数组
# a = np.arange(0, 60, 5)
# a = a.reshape(3, 4)
# print('原始数组是：')
# print(a)
# print('\n')
# print('原始数组的转置是：')
# b = a.T
# print(b)
# print('\n')
# print('以 C 风格顺序排序：')
# c = b.copy(order='C')
# print(c)
# for x in np.nditer(c):
#     print(x, end=", ")
# print('\n')
# print('以 F 风格顺序排序：')
# c = b.copy(order='F')
# print(c)
# for x in np.nditer(c):
#     print(x, end=", ")

# # 修改数组中元素的值
# a = np.arange(0, 60, 5)
# a = a.reshape(3, 4)
# print('原始数组是：')
# print(a)
# print('\n')
# for x in np.nditer(a, op_flags=['readwrite']):
#     x[...] = 2 * x
# print('修改后的数组是：')
# print(a)

# # 广播迭代
# a = np.arange(0, 60, 5)
# a = a.reshape(3, 4)
# print('第一个数组为：')
# print(a)
# print('\n')
# print('第二个数组为：')
# b = np.array([1, 2, 3, 4], dtype=int)
# print(b)
# print('\n')
# print('修改后的数组为：')
# for x, y in np.nditer([a, b]):
#     print("%d:%d" % (x, y), end=", ")

# # numpy.ndarray.flat 是一个数组元素迭代器
# a = np.arange(9).reshape(3, 3)
# print('原始数组：')
# for row in a:
#     print(row)
#
# # 对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
# print('迭代后的数组：')
# for element in a.flat:
#     print(element)

# # numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
# a = np.arange(8).reshape(2, 4)
#
# print('原数组：')
# print(a)
# print('\n')
# # 默认按行
#
# print('展开的数组：')
# print(a.flatten())
# print('\n')
#
# print('以 F 风格顺序展开的数组：')
# print(a.flatten(order='F'))
# print(a)

# # numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。
# a = np.arange(8).reshape(2, 4)
# print('原数组：')
# print(a)
# print('\n')
#
# print('调用 ravel 函数之后：')
# print(a.ravel())
# print('\n')
#
# print('以 F 风格顺序调用 ravel 函数之后：')
# print(a.ravel(order='F'))

# # numpy.transpose 函数用于对换数组的维度
# a = np.arange(12).reshape(3, 4)
#
# print('原数组：')
# print(a)
# print('\n')
#
# print('对换数组：')
# print(np.transpose(a))
# print(a.T)

# # numpy.rollaxis 函数向后滚动特定的轴到一个特定位置(二进制编码理解)
# # 创建了三维的 ndarray
# a = np.arange(8).reshape(2, 2, 2)
#
# print('原数组：')
# print(a)
# print('\n')
# # 将轴 2 滚动到轴 0（宽度到深度）
#
# print('调用 rollaxis 函数：')
# print(np.rollaxis(a, 2))
# # 将轴 0 滚动到轴 1：（宽度到高度）
# print('\n')
#
# print('调用 rollaxis 函数：')
# print(np.rollaxis(a, 2, 1))

# # numpy.swapaxes 函数用于交换数组的两个轴
# # 创建了三维的 ndarray
# a = np.arange(8).reshape(2, 2, 2)
#
# print('原数组：')
# print(a)
# print('\n')
# # 现在交换轴 0（深度方向）到轴 2（宽度方向）
#
# print('调用 swapaxes 函数后的数组：')
# print(np.swapaxes(a, 2, 0))

# # numpy.broadcast 用于模仿广播的对象，它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果。
# x = np.array([[1], [2], [3]])
# y = np.array([4, 5, 6])
#
# # 对 y 广播 x
# b = np.broadcast(x, y)
# # 它拥有 iterator 属性，基于自身组件的迭代器元组
# print('对 y 广播 x：')
# r, c = b.iters
#
# # Python3.x 为 next(context) ，Python2.x 为 context.next()
# print(next(r), next(c))
# print(next(r), next(c))
# print(next(r), next(c))
# print(next(r), next(c))
# print('\n')
# # shape 属性返回广播对象的形状
#
# print('广播对象的形状：')
# print(b.shape)
# print('\n')
# # 手动使用 broadcast 将 x 与 y 相加
# b = np.broadcast(x, y)
# c = np.empty(b.shape)
# print(c)
# print('手动使用 broadcast 将 x 与 y 相加：')
# print(c.shape)
# print('\n')
# c.flat = [u + v for (u, v) in b]
#
# print('调用 flat 函数：')
# print(c)
# print('\n')
# # 获得了和 NumPy 内建的广播支持相同的结果
#
# print('x 与 y 的和：')
# print(x + y)

# # numpy.broadcast_to 函数将数组广播到新形状。它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError
# a = np.arange(4).reshape(1, 4)
#
# print('原数组：')
# print(a)
# print('\n')
#
# print('调用 broadcast_to 函数之后：')
# print(np.broadcast_to(a, (4, 4)))

# # numpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状
# x = np.array(([1, 2], [3, 4]))
#
# print('数组 x：')
# print(x)
# print('\n')
# y = np.expand_dims(x, axis=0)
#
# print('数组 y：')
# print(y)
# print('\n')
#
# print('数组 x 和 y 的形状：')
# print(x.shape, y.shape)
# print('\n')
# # 在位置 1 插入轴
# y = np.expand_dims(x, axis=1)
#
# print('在位置 1 插入轴之后的数组 y：')
# print(y)
# print('\n')
#
# print('x.ndim 和 y.ndim：')
# print(x.ndim, y.ndim)
# print('\n')
#
# print('x.shape 和 y.shape：')
# print(x.shape, y.shape)

# # numpy.squeeze 函数从给定数组的形状中删除一维的条目
# x = np.arange(9).reshape(1, 3, 3)
#
# print('数组 x：')
# print(x)
# print('\n')
# y = np.squeeze(x)
#
# print('数组 y：')
# print(y)
# print('\n')
#
# print('数组 x 和 y 的形状：')
# print(x.shape, y.shape)

# # numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组
# a = np.array([[1, 2], [3, 4]])
#
# print('第一个数组：')
# print(a)
# print('\n')
# b = np.array([[5, 6], [7, 8]])
#
# print('第二个数组：')
# print(b)
# print('\n')
# # 两个数组的维度相同
#
# print('沿轴 0 连接两个数组：')
# print(np.concatenate((a, b)))
# print('\n')
#
# print('沿轴 1 连接两个数组：')
# print(np.concatenate((a, b), axis=1))

# # numpy.stack 函数用于沿新轴连接数组序列
# a = np.array([[1, 2], [3, 4]])
#
# print('第一个数组：')
# print(a)
# print('\n')
# b = np.array([[5, 6], [7, 8]])
#
# print('第二个数组：')
# print(b)
# print('\n')
#
# print('沿轴 0 堆叠两个数组：')
# print(np.stack((a, b), 0))
# print('\n')
#
# print('沿轴 1 堆叠两个数组：')
# print(np.stack((a, b), 1))

# # numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组
# a = np.array([[1, 2], [3, 4]])
#
# print('第一个数组：')
# print(a)
# print('\n')
# b = np.array([[5, 6], [7, 8]])
#
# print('第二个数组：')
# print(b)
# print('\n')
#
# print('水平堆叠：')
# c = np.hstack((a, b))
# print(c)
# print('\n')

# # numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组
# a = np.array([[1, 2], [3, 4]])
#
# print('第一个数组：')
# print(a)
# print('\n')
# b = np.array([[5, 6], [7, 8]])
#
# print('第二个数组：')
# print(b)
# print('\n')
#
# print('竖直堆叠：')
# c = np.vstack((a, b))
# print(c)

# # numpy.split 函数沿特定的轴将数组分割为子数组
# a = np.arange(9)
#
# print('第一个数组：')
# print(a)
# print('\n')
#
# print('将数组分为三个大小相等的子数组：')
# b = np.split(a, 3)
# print(b)
# print('\n')
#
# print('将数组在一维数组中表明的位置分割：')
# b = np.split(a, [4, 7])
# print(b)

# # numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。
# harr = np.floor(10 * np.random.random((2, 6)))
# print('原array：')
# print(harr)
#
# print('拆分后：')
# print(np.hsplit(harr, 3))

# # numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。
# a = np.arange(16).reshape(4, 4)
#
# print('第一个数组：')
# print(a)
# print('\n')
#
# print('竖直分割：')
# b = np.vsplit(a, 2)
# print(b)

# # numpy.resize 函数返回指定大小的新数组。如果新数组大小大于原始大小，则包含原始数组中的元素的副本。
# a = np.array([[1, 2, 3], [4, 5, 6]])
#
# print('第一个数组：')
# print(a)
# print('\n')
#
# print('第一个数组的形状：')
# print(a.shape)
# print('\n')
# b = np.resize(a, (3, 2))
#
# print('第二个数组：')
# print(b)
# print('\n')
#
# print('第二个数组的形状：')
# print(b.shape)
# print('\n')
# # 要注意 a 的第一行在 b 中重复出现，因为尺寸变大了
#
# print('修改第二个数组的大小：')
# b = np.resize(a, (3, 3))
# print(b)

# # numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。
# # append 函数返回的始终是一个一维数组。
# a = np.array([[1, 2, 3], [4, 5, 6]])
#
# print('第一个数组：')
# print(a)
# print('\n')
#
# print('向数组添加元素：')
# print(np.append(a, [7, 8, 9]))
# print('\n')
#
# print('沿轴 0 添加元素：')
# print(np.append(a, [[7, 8, 9]], axis=0))
# print('\n')
#
# print('沿轴 1 添加元素：')
# print(np.append(a, [[5, 5, 5], [7, 8, 9]], axis=1))

# # numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。
# # 如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。
# a = np.array([[1, 2], [3, 4], [5, 6]])
#
# print('第一个数组：')
# print(a)
# print('\n')
#
# print('未传递 Axis 参数。 在插入之前输入数组会被展开。')
# print(np.insert(a, 3, [11, 12]))
# print('\n')
# print('传递了 Axis 参数。 会广播值数组来配输入数组。')
#
# print('沿轴 0 广播：')
# print(np.insert(a, 1, [11], axis=0))
# print('\n')
#
# print('沿轴 1 广播：')
# print(np.insert(a, 1, 11, axis=1))

# # numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。
# a = np.arange(12).reshape(3, 4)
#
# print('第一个数组：')
# print(a)
# print('\n')
#
# print('未传递 Axis 参数。 在插入之前输入数组会被展开。')
# print(np.delete(a, 5))
# print('\n')
#
# print('删除第二列：')
# print(np.delete(a, 1, axis=1))
# print('\n')
#
# print('包含从数组中删除的替代值的切片：')
# a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
# print(np.delete(a, np.s_[::2]))

# # numpy.unique 函数用于去除数组中的重复元素。
# a = np.array([5, 2, 6, 2, 7, 5, 6, 8, 2, 9])
#
# print('第一个数组：')
# print(a)
# print('\n')
#
# print('第一个数组的去重值：')
# u = np.unique(a)
# print(u)
# print('\n')
#
# print('去重数组的索引数组：')
# u, indices = np.unique(a, return_index=True)
# print(indices)
# print('\n')
#
# print('我们可以看到每个和原数组下标对应的数值：')
# print(a)
# print('\n')
#
# print('去重数组的下标：')
# u, indices = np.unique(a, return_inverse=True)
# print(u)
# print('\n')
#
# print('下标为：')
# print(indices)
# print('\n')
#
# print('使用下标重构原数组：')
# print(u[indices])
# print('\n')
#
# print('返回去重元素的重复数量：')
# u, indices = np.unique(a, return_counts=True)
# print(u)
# print(indices)

# # bitwise_and()函数对数组中整数的二进制形式执行位与运算
# print('13 和 17 的二进制形式：')
# a, b = 13, 17
# print(bin(a), bin(b))
# print('\n')
#
# print('13 和 17 的位与：')
# print(np.bitwise_and(13, 17))

# # bitwise_or()函数对数组中整数的二进制形式执行位或运算。
# a, b = 13, 17
# print('13 和 17 的二进制形式：')
# print(bin(a), bin(b))
#
# print('13 和 17 的位或：')
# print(np.bitwise_or(13, 17))

# # invert() 函数对数组中整数进行位取反运算，即 0 变成 1，1 变成 0。
# # 对于有符号整数，取该二进制数的补码，然后 +1。二进制数，最高位为0表示正数，最高位为 1 表示负数。
# print('13 的位反转，其中 ndarray 的 dtype 是 uint8：')
# print(np.invert(np.array([13], dtype=np.uint8)))
# print('\n')
# # 比较 13 和 242 的二进制表示，我们发现了位的反转
#
# print('13 的二进制表示：')
# print(np.binary_repr(13, width=8))
# print('\n')
#
# print('242 的二进制表示：')
# print(np.binary_repr(242, width=8))

# # left_shift() 函数将数组元素的二进制形式向左移动到指定位置，右侧附加相等数量的 0。
# print('将 10 左移两位：')
# print(np.left_shift(10, 2))
# print('\n')
#
# print('10 的二进制表示：')
# print(np.binary_repr(10, width=8))
# print('\n')
#
# print('40 的二进制表示：')
# print(np.binary_repr(40, width=8))
# #  '00001010' 中的两位移动到了左边，并在右边添加了两个 0。

# # right_shift() 函数将数组元素的二进制形式向右移动到指定位置，左侧附加相等数量的 0。
# print('将 40 右移两位：')
# print(np.right_shift(40, 2))
# print('\n')
#
# print('40 的二进制表示：')
# print(np.binary_repr(40, width=8))
# print('\n')
#
# print('10 的二进制表示：')
# print(np.binary_repr(10, width=8))
# #  '00001010' 中的两位移动到了右边，并在左边添加了两个 0。

# # numpy.char.add() 函数依次对两个数组的元素进行字符串连接。
# print('连接两个字符串：')
# print(np.char.add(['hello'], [' xyz']))
# print('\n')
#
# print('连接示例：')
# print(np.char.add(['hello', 'hi'], [' abc', ' xyz']))

# # numpy.char.multiply() 函数执行多重连接。
# print(np.char.multiply('Runoob ', 3))

# # numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。
# print(np.char.center('Runoob', 20, fillchar='*'))

# # numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串
# # 操作字符串
# print(np.char.join(':', 'runoob'))
#
# # 指定多个分隔符操作数组元素
# print(np.char.join([':', '-'], ['runoob', 'google']))

# # 三角函数
# a = np.array([0, 30, 45, 60, 90])
# print('不同角度的正弦值：')
# # 通过乘 pi/180 转化为弧度
# print(np.sin(a * np.pi / 180))
# print('\n')
# print('数组中角度的余弦值：')
# print(np.cos(a * np.pi / 180))
# print('\n')
# print('数组中角度的正切值：')
# print(np.tan(a * np.pi / 180))

# # 反三角函数
# a = np.array([0, 30, 45, 60, 90])
# print('含有正弦值的数组：')
# sin = np.sin(a * np.pi / 180)
# print(sin)
# print('\n')
# print('计算角度的反正弦，返回值以弧度为单位：')
# inv = np.arcsin(sin)
# print(inv)
# print('\n')
# print('通过转化为角度制来检查结果：')
# print(np.degrees(inv))
# print('\n')
# print('arccos 和 arctan 函数行为类似：')
# cos = np.cos(a * np.pi / 180)
# print(cos)
# print('\n')
# print('反余弦：')
# inv = np.arccos(cos)
# print(inv)
# print('\n')
# print('角度制单位：')
# print(np.degrees(inv))
# print('\n')
# print('tan 函数：')
# tan = np.tan(a * np.pi / 180)
# print(tan)
# print('\n')
# print('反正切：')
# inv = np.arctan(tan)
# print(inv)
# print('\n')
# print('角度制单位：')
# print(np.degrees(inv))

# # numpy.around() 函数返回指定数字的四舍五入值。
# a = np.array([1.0, 5.55, 123, 0.567, 25.532])
# print('原数组：')
# print(a)
# print('\n')
# print('舍入后：')
# print(np.around(a))
# print(np.around(a, decimals=1))
# print(np.around(a, decimals=-1))

# # numpy.floor() 返回数字的下舍整数。
# # numpy.ceil() 返回数字的上入整数。
# a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
# print('提供的数组：')
# print(a)
# print('\n')
# print('修改后的数组：')
# print(np.floor(a))
# print(np.ceil(a))

# a = np.arange(9, dtype=np.float_).reshape(3, 3)
# print('第一个数组：')
# print(a)
# print('\n')
# print('第二个数组：')
# b = np.array([10, 10, 10])
# print(b)
# print('\n')
# print('两个数组相加：')
# print(np.add(a, b))
# print('\n')
# print('两个数组相减：')
# print(np.subtract(a, b))
# print('\n')
# print('两个数组相乘：')
# print(np.multiply(a, b))
# print('\n')
# print('两个数组相除：')
# print(np.divide(a, b))

# # numpy.reciprocal() 函数返回参数逐元素的倒数
# a = np.array([0.25, 1.33, 1, 100])
# print('我们的数组是：')
# print(a)
# print('\n')
# print('调用 reciprocal 函数：')
# print(np.reciprocal(a))

# # numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂
# a = np.array([10, 100, 1000])
# print('我们的数组是；')
# print(a)
# print('\n')
# print('调用 power 函数：')
# print(np.power(a, 2))
# print('\n')
# print('第二个数组：')
# b = np.array([1, 2, 3])
# print(b)
# print('\n')
# print('再次调用 power 函数：')
# print(np.power(a, b))


# # numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。
# a = np.array([10, 20, 30])
# b = np.array([3, 5, 7])
# print('第一个数组：')
# print(a)
# print('\n')
# print('第二个数组：')
# print(b)
# print('\n')
# print('调用 mod() 函数：')
# print(np.mod(a, b))
# print('\n')
# print('调用 remainder() 函数：')
# print(np.remainder(a, b))

# # numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
# # numpy.amax() 用于计算数组中的元素沿指定轴的最大值。
# a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]])
# print('我们的数组是：')
# print(a)
# print('\n')
# print('调用 amin() 函数：')
# print(np.amin(a, 1))
# print('\n')
# print('再次调用 amin() 函数：')
# print(np.amin(a, 0))
# print('\n')
# print('调用 amax() 函数：')
# print(np.amax(a))
# print('\n')
# print('再次调用 amax() 函数：')
# print(np.amax(a, axis=0))

# # numpy.ptp()函数计算数组中元素最大值与最小值的差
# a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]])
# print('我们的数组是：')
# print(a)
# print('\n')
# print('调用 ptp() 函数：')
# print(np.ptp(a))
# print('\n')
# print('沿轴 1 调用 ptp() 函数：')
# print(np.ptp(a, axis=1))
# print('\n')
# print('沿轴 0 调用 ptp() 函数：')
# print(np.ptp(a, axis=0))

# # 百分位数是统计中使用的度量，表示小于这个值的观察值的百分比
# a = np.array([[10, 7, 4], [3, 2, 1]])
# print('我们的数组是：')
# print(a)
#
# print('调用 percentile() 函数：')
# # 50% 的分位数，就是 a 里排序之后的中位数
# print(np.percentile(a, 50))
#
# # axis 为 0，在纵列上求
# print(np.percentile(a, 50, axis=0))
#
# # axis 为 1，在横行上求
# print(np.percentile(a, 50, axis=1))
#
# # 保持维度不变
# print(np.percentile(a, 50, axis=1, keepdims=True))

# # numpy.median() 函数用于计算数组 a 中元素的中位数（中值）
# a = np.array([[30, 65, 70], [80, 95, 10], [50, 90, 60]])
# print('我们的数组是：')
# print(a)
# print('\n')
# print('调用 median() 函数：')
# print(np.median(a))
# print('\n')
# print('沿轴 0 调用 median() 函数：')
# print(np.median(a, axis=0))
# print('\n')
# print('沿轴 1 调用 median() 函数：')
# print(np.median(a, axis=1))

# # numpy.mean() 函数返回数组中元素的算术平均值
# a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
# print('我们的数组是：')
# print(a)
# print('\n')
# print('调用 mean() 函数：')
# print(np.mean(a))
# print('\n')
# print('沿轴 0 调用 mean() 函数：')
# print(np.mean(a, axis=0))
# print('\n')
# print('沿轴 1 调用 mean() 函数：')
# print(np.mean(a, axis=1))

# # numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。
# a = np.array([1, 2, 3, 4])
# print('我们的数组是：')
# print(a)
# print('\n')
# print('调用 average() 函数：')
# print(np.average(a))
# print('\n')
# # 不指定权重时相当于 mean 函数
# wts = np.array([4, 3, 2, 1])
# print('再次调用 average() 函数：')
# print(np.average(a, weights=wts))
# print('\n')
# # 如果 returned 参数设为 true，则返回权重的和
# print('权重的和：')
# print(np.average([1, 2, 3, 4], weights=[4, 3, 2, 1], returned=True))

# # 标准差
# print(np.std([1, 2, 3, 4]))

# # 方差
# print(np.var([1, 2, 3, 4]))

# # numpy.sort() 函数返回输入数组的排序副本
# a = np.array([[3, 7], [9, 1]])
# print('我们的数组是：')
# print(a)
# print('\n')
# print('调用 sort() 函数：')
# print(np.sort(a))
# print('\n')
# print('按列排序：')
# print(np.sort(a, axis=0))
# print('\n')
# # 在 sort 函数中排序字段
# dt = np.dtype([('name', 'S10'), ('age', int)])
# a = np.array([("raju", 21), ("anil", 25), ("ravi", 17), ("amar", 27)], dtype=dt)
# print('我们的数组是：')
# print(a)
# print('\n')
# print('按 name 排序：')
# print(np.sort(a, order='name'))

# # numpy.argsort() 函数返回的是数组值从小到大的索引值。
# x = np.array([3, 1, 2])
# print('我们的数组是：')
# print(x)
# print('\n')
# print('对 x 调用 argsort() 函数：')
# y = np.argsort(x)
# print(y)
# print('\n')
# print('以排序后的顺序重构原数组：')
# print(x[y])
# print('\n')
# print('使用循环重构原数组：')
# for i in y:
#     print(x[i], end=" ")

# # numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。
# nm = ('raju', 'anil', 'ravi', 'amar')
# dv = ('f.y.', 's.y.', 's.y.', 'f.y.')
# ind = np.lexsort((dv, nm))
# print('调用 lexsort() 函数：')
# print(ind)
# print('\n')
# print('使用这个索引来获取排序后的数据：')
# print([nm[i] + ", " + dv[i] for i in ind])

# # 复数排序
# print(np.sort_complex([5, 3, 6, 2, 1]))
# print(np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j]))

# # partition() 分区排序
# a = np.array([3, 4, 2, 1])
# print(np.partition(a, 3))  # 将数组 a 中所有元素（包括重复元素）从小到大排列，比第3小的放在前面，大的放在后面
# print(np.partition(a, (1, 3))) # 小于 1 的在前面，大于 3 的在后面，1和3之间的在中间

# # 找到数组的第 3 小（index=2）的值和第 2 大（index=-2）的值
# arr = np.array([46, 57, 23, 39, 1, 10, 0, 120])
# print(arr[np.argpartition(arr, 2)[2]])
# print(arr[np.argpartition(arr, -2)[-2]])

# # 同时找到第 3 和第 4 小的值。注意这里，用 [2,3] 同时将第 3 和第 4 小的排序好，然后可以分别通过下标 [2] 和 [3] 取得。
# arr = np.array([46, 57, 23, 39, 1, 10, 0, 120])
# print(arr[np.argpartition(arr, [2, 3])[2]])
# print(arr[np.argpartition(arr, [2, 3])[3]])

# # numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。
# a = np.array([[30, 40, 70], [80, 20, 10], [50, 90, 60]])
# print('我们的数组是：')
# print(a)
# print('\n')
# print('调用 argmax() 函数：')
# print(np.argmax(a))
# print('\n')
# print('展开数组：')
# print(a.flatten())
# print('\n')
# print('沿轴 0 的最大值索引：')
# maxindex = np.argmax(a, axis=0)
# print(maxindex)
# print('\n')
# print('沿轴 1 的最大值索引：')
# maxindex = np.argmax(a, axis=1)
# print(maxindex)
# print('\n')
# print('调用 argmin() 函数：')
# minindex = np.argmin(a)
# print(minindex)
# print('\n')
# print('展开数组中的最小值：')
# print(a.flatten()[minindex])
# print('\n')
# print('沿轴 0 的最小值索引：')
# minindex = np.argmin(a, axis=0)
# print(minindex)
# print('\n')
# print('沿轴 1 的最小值索引：')
# minindex = np.argmin(a, axis=1)
# print(minindex)

# # numpy.nonzero() 函数返回输入数组中非零元素的索引。
# a = np.array([[30, 40, 0], [0, 20, 10], [50, 0, 60]])
# print('我们的数组是：')
# print(a)
# print('\n')
# print('调用 nonzero() 函数：')
# print(np.nonzero(a))

# # numpy.where() 函数返回输入数组中满足给定条件的元素的索引。
# x = np.arange(9.).reshape(3, 3)
# print('我们的数组是：')
# print(x)
# print('大于 3 的元素的索引：')
# y = np.where(x > 3)
# print(y)
# print('使用这些索引来获取满足条件的元素：')
# print(x[y])

# # numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。
# x = np.arange(9.).reshape(3, 3)
# print('我们的数组是：')
# print(x)
# # 定义条件, 选择偶数元素
# condition = np.mod(x, 2) == 0
# print('按元素的条件值：')
# print(condition)
# print('使用条件提取元素：')
# print(np.extract(condition, x))

# # numpy.ndarray.byteswap() 函数将 ndarray 中每个元素中的字节进行大小端转换。
# a = np.array([1, 256, 8755], dtype=np.int16)
# print('我们的数组是：')
# print(a)
# print('以十六进制表示内存中的数据：')
# print(map(hex, a))
# # byteswap() 函数通过传入 true 来原地交换
# print('调用 byteswap() 函数：')
# print(a.byteswap(True))
# print('十六进制形式：')
# print(map(hex, a))
# # 我们可以看到字节已经交换了

# # 无复制
# a = np.arange(6)
# print('我们的数组是：')
# print(a)
# print('调用 id() 函数：')
# print(id(a))
# print('a 赋值给 b：')
# b = a
# print(b)
# print('b 拥有相同 id()：')
# print(id(b))
# print('修改 b 的形状：')
# b.shape = 3, 2
# print(b)
# print('a 的形状也修改了：')
# print(a)


# # 视图或浅拷贝
# # ndarray.view() 方会创建一个新的数组对象，该方法创建的新数组的维数更改不会更改原始数据的维数。
# # 最开始 a 是个 3X2 的数组
# a = np.arange(6).reshape(3, 2)
# print('数组 a：')
# print(a)
# print('创建 a 的视图：')
# b = a.view()
# print(b)
# print('两个数组的 id() 不同：')
# print('a 的 id()：')
# print(id(a))
# print('b 的 id()：')
# print(id(b))
# # 修改 b 的形状，并不会修改 a
# b.shape = 2, 3
# print('b 的形状：')
# print(b)
# print('a 的形状：')
# print(a)

# # 使用切片创建视图修改数据会影响到原始数组
# arr = np.arange(12)
# print('我们的数组：')
# print(arr)
# print('创建切片：')
# a = arr[3:]
# b = arr[3:]
# a[1] = 123
# b[2] = 234
# print(arr)
# print(id(a), id(b), id(arr[3:]))

# # 副本或深拷贝
# # ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。
# a = np.array([[10, 10], [2, 3], [4, 5]])
# print('数组 a：')
# print(a)
# print('创建 a 的深层副本：')
# b = a.copy()
# print('数组 b：')
# print(b)
# # b 与 a 不共享任何内容
# print('我们能够写入 b 来写入 a 吗？')
# print(b is a)
# print('修改 b 的内容：')
# b[0, 0] = 100
# print('修改后的数组 b：')
# print(b)
# print('a 保持不变：')
# print(a)

# # matlib.empty() 函数返回一个新的矩阵
# print(np.matlib.empty((2, 2)))
# # 填充为随机数据

# # numpy.matlib.zeros() 函数创建一个以 0 填充的矩阵。
# print(np.matlib.zeros((2, 2)))

# # numpy.matlib.ones()函数创建一个以 1 填充的矩阵
# print(np.matlib.ones((2, 2)))

# # numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。
# print(np.matlib.eye(n=3, M=4, k=0, dtype=float))

# # numpy.matlib.identity() 函数返回给定大小的单位矩阵。
# # 大小为 5，类型位浮点型
# print(np.matlib.identity(5, dtype=float))

# # numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的。
# print(np.matlib.rand(3, 3))

# # numpy.dot() 	两个数组的点积
# a = np.array([[1, 2], [3, 4]])
# b = np.array([[11, 12], [13, 14]])
# print(np.dot(a, b))

# # numpy.vdot() 函数是两个向量的点积
# a = np.array([[1, 2], [3, 4]])
# b = np.array([[11, 12], [13, 14]])
# # vdot 将数组展开计算内积
# print(np.vdot(a, b))

# # numpy.inner() 函数返回一维数组的向量内积
# print(np.inner(np.array([1, 2, 3]), np.array([0, 1, 0])))
# # 等价于 1*0+2*1+3*0
# a = np.array([[1, 2], [3, 4]])
#
# print('数组 a：')
# print(a)
# b = np.array([[11, 12], [13, 14]])
#
# print('数组 b：')
# print(b)
#
# print('内积：')
# print(np.inner(a, b))
# # 等价于:
# # 1*11+2*12, 1*13+2*14
# # 3*11+4*12, 3*13+4*14

# # numpy.matmul 函数返回两个数组的矩阵乘积
# a = [[1, 0], [0, 1]]
# b = [[4, 1], [2, 2]]
# print(np.matmul(a, b))

# # numpy.linalg.det() 函数计算输入矩阵的行列式。
# a = np.array([[1, 2], [3, 4]])
# print(np.linalg.det(a))

# # numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。
# x = np.array([[1, 2], [3, 4]])
# y = np.linalg.inv(x)
# print(x)
# print(y)
# print(np.dot(x, y))

# # numpy.save() 函数将数组保存到以 .npy 为扩展名的文件中
# a = np.array([1, 2, 3, 4, 5])
# # 保存到 outfile.npy 文件上
# np.save('outfile.npy', a)
# # 保存到 outfile2.npy 文件上，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上
# np.save('outfile2', a)
# b = np.load('outfile.npy')
# print(b)

# # numpy.savez() 函数将多个数组保存到以 npz 为扩展名的文件中。
# a = np.array([[1, 2, 3], [4, 5, 6]])
# b = np.arange(0, 1.0, 0.1)
# c = np.sin(b)
# # c 使用了关键字参数 sin_array
# np.savez("runoob.npz", a, b, sin_array=c)
# r = np.load("runoob.npz")
# print(r.files)  # 查看各个数组名称
# print(r["arr_0"])  # 数组 a
# print(r["arr_1"])  # 数组 b
# print(r["sin_array"])  # 数组 c

# # savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。
# a = np.array([1, 2, 3, 4, 5])
# np.savetxt('out.txt', a)
# b = np.loadtxt('out.txt')
# print(b)