其余两剑客：
🗡 数据分析三剑客之 Pandas 基础教程
🗡 数据分析三剑客之 Matplotlib 基础教程
目录
- 1 Ndarray对象(array)：
- 2 数据类型对象(dtype)：
- 3 数组属性：
- 4 数组构造：
- 5 数组操作：
- 6 位运算：
- 7 字符串操作(char)：
- 7.1 连接(add)：
- 7.2 复制拼接(multiply)：
- 7.3 居中并对两侧填充(center)：
- 7.4 将字符串的第一个字母转换为大写(capitalize)：
- 7.5 将字符串的每个单词的第一个字母转换为大写(title)：
- 7.6 将字符串的每个字母转换为小写(lower)：
- 7.7 将字符串的每个字母转换为大写(upper)：
- 7.8 分割字符串(split)：
- 7.9 换行符分割字符串(splitlines)：
- 7.10 首尾清理(strip)：
- 7.11 指定分隔符来连接数组中的元素或字符串(join)：
- 7.12 替换(replace)：
- 7.13 编码(encode)：
- 7.14 解码(decode)：
- 8 数学函数：
- 9 算数函数：
- 10 统计函数：
- 11 矩阵(matlib)：（Matrix）
- 12 线性代数：
- 13 文件操作：
0.1 先导条件
import numpy as np
1 Ndarray对象(array)：
np.array(
object, # 数组或嵌套的数列
dtype = None, # 数组元素的数据类型，可选
copy = True, # 对象是否需要复制，可选
order = None, # 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok = False, # 默认返回一个与基类类型一致的数组
ndmin = 0 # 指定生成数组的最小维度
)
1.1 基础操作：
一维：
np.array([1,2,3])
array([1, 2, 3])
二维：
np.array([[1,2,3],[4,5,6],[7,8,9]])
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
指定最小维度：
np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], ndmin=10)
array([[[[[[[[[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]]]]]]]]])
指定数据类型：
np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=complex) # 指定数据类型为复数
array([[1.+0.j, 2.+0.j, 3.+0.j],
[4.+0.j, 5.+0.j, 6.+0.j],
[7.+0.j, 8.+0.j, 9.+0.j]])
1.2 与list互相转换：
a = list(range(3))
print(a)
print(type(a))
[0, 1, 2]
<class 'list'>
b=np.array(a)
print(b)
print(type(b))
[0 1 2]
<class 'numpy.ndarray'>
c=b.tolist()
print(c)
print(type(c))
[0, 1, 2]
<class 'list'>
2 数据类型对象(dtype)：
np.dtype(
object, # 要转换为的数据类型对象
align, # 如果为 true，填充字段使其类似 C 的结构体。
copy # 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用
)
2.1 常用 NumPy 基本类型：
| bool_ | 布尔型数据类型（True 或者 False） |
|---|---|
| int_ | 默认的整数类型（类似于 C 语言中的 long，int32 或 int64） |
| intc | 与 C 的 int 类型一样，一般是 int32 或 int 64 |
| intp | 用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64） |
| int8 | 字节（-128 to 127） |
| int16 | 整数（-32768 to 32767） |
| int32 | 整数（-2147483648 to 2147483647） |
| int64 | 整数（-9223372036854775808 to 9223372036854775807） |
| uint8 | 无符号整数（0 to 255） |
| uint16 | 无符号整数（0 to 65535） |
| uint32 | 无符号整数（0 to 4294967295） |
| uint64 | 无符号整数（0 to 18446744073709551615） |
| float_ | float64 类型的简写 |
| float16 | 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位 |
| float32 | 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位 |
| float64 | 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位 |
| complex_ | complex128 类型的简写，即 128 位复数 |
| complex64 | 复数，表示双 32 位浮点数（实数部分和虚数部分） |
| complex128 | 复数，表示双 64 位浮点数（实数部分和虚数部分） |
每个内建类型都有一个唯一定义它的字符代码，如下：
| b | 布尔型 |
|---|---|
| i | (有符号) 整型 |
| u | 无符号整型 integer |
| f | 浮点型 |
| c | 复数浮点型 |
| m | timedelta（时间间隔） |
| M | datetime（日期时间） |
| O | (Python) 对象 |
| S,a | (byte-)字符串 |
| U | Unicode |
| V | 原始数据 (void) |
2.2 实例：
np.dtype(np.int32)
dtype('int32')
# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
np.dtype('i4')
dtype('int32')
np.dtype([('age',np.int8)])
dtype([('age', 'i1')])
print("加类型前：")
print(np.array([(10,), (20,), (30,)]))
print("加类型后：")
print(np.array([(10,), (20,), (30,)], dtype=np.dtype([('age', np.int8)])))
print("使用类型字段名读取数据：")
print(np.array([(10,), (20,), (30,)], dtype=np.dtype([('age', np.int8)]))['age'])
加类型前：
[[10]
[20]
[30]]
加类型后：
[(10,) (20,) (30,)]
使用类型字段名读取数据：
[10 20 30]
student = np.dtype([('name', 'U20'), ('age', 'i1'), ('score', 'f4')])
print("自定义结构化数据类型：")
print(student)
print("结构化前：")
print(np.array([('张三', 21, 50), ('李四', 18, 75)]))
print("结构化后：")
print(np.array([('张三', 21, 50), ('李四', 18, 75)], dtype=student))
自定义结构化数据类型：
[('name', '<U20'), ('age', 'i1'), ('score', '<f4')]
结构化前：
[['张三' '21' '50']
['李四' '18' '75']]
结构化后：
[('张三', 21, 50.) ('李四', 18, 75.)]
3 数组属性：
3.1 秩(ndim)：
a = np.array([1, 2, 3, 4, 5])
print("a:")
print(a)
print("a的秩:")
print(a.ndim)
b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("b:")
print(b)
print("b的秩:")
print(b.ndim)
a:
[1 2 3 4 5]
a的秩:
1
b:
[[1 2 3]
[4 5 6]
[7 8 9]]
b的秩:
2
3.2 形状(shape)：
3.2.1 获取数组形状：
a = np.array([1, 2, 3, 4])
print("a:")
print(a)
print("a的形状：")
print(a.shape)
b = np.array([[1, 2, 3], [4, 5, 6]])
print("b:")
print(b)
print("b的形状：")
print(b.shape)
a:
[1 2 3 4]
a的形状：
(4,)
b:
[[1 2 3]
[4 5 6]]
b的形状：
(2, 3)
3.2.2 修改数组形状：
a = np.array([[1, 2, 3], [4, 5, 6]])
print("修改前：")
print(a)
a.shape = (3, 2)
print("修改后：")
print(a)
修改前：
[[1 2 3]
[4 5 6]]
修改后：
[[1 2]
[3 4]
[5 6]]
3.3 大小(size)：
元素总个数
a = np.array([1, 2, 3, 4])
print("a:")
print(a)
print("a的元素总个数：")
print(a.size)
b = np.array([[1, 2, 3], [4, 5, 6]])
print("b:")
print(b)
print("b的元素总个数：")
print(b.size)
a:
[1 2 3 4]
a的元素总个数：
4
b:
[[1 2 3]
[4 5 6]]
b的元素总个数：
6
3.4 元素类型(dtype)：
详见前面 数据类型对象(dtype)
a = np.array([1, '2', 3, 4])
print("a:")
print(a)
print("a的元素类型：")
print(a.dtype)
b = np.array([[1, 2, 'qwer'], [4, 5, 6]])
print("b:")
print(b)
print("b的元素类型：")
print(b.dtype)
a:
['1' '2' '3' '4']
a的元素类型：
<U11
b:
[['1' '2' 'qwer']
['4' '5' '6']]
b的元素类型：
<U11
3.5 每个元素的大小(itemsize)：
# 数组的 dtype 为 int8（一个字节）
x = np.array([1, 2, 3, 4, 5], dtype=np.int8)
print("x(int8):")
print(x)
print("x的元素大小：")
print(x.itemsize)
# 数组的 dtype 现在为 float64（八个字节）
y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
print("y(float64):")
print(y)
print("y的元素大小：")
print(y.itemsize)
x(int8):
[1 2 3 4 5]
x的元素大小：
1
y(float64):
[1. 2. 3. 4. 5.]
y的元素大小：
8
3.6 内存信息(flags)：
包含以下属性：
| C_CONTIGUOUS © | 数据是在一个单一的C风格的连续段中 |
|---|---|
| F_CONTIGUOUS (F) | 数据是在一个单一的Fortran风格的连续段中 |
| OWNDATA (O) | 数组拥有它所使用的内存或从另一个对象中借用它 |
| WRITEABLE (W) | 数据区域可以被写入，将该值设置为 False，则数据为只读 |
| ALIGNED (A) | 数据和所有元素都适当地对齐到硬件上 |
| UPDATEIFCOPY (U) | 这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新 |
x = np.array([1,2,3,4,5])
print (x.flags)
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
4 数组构造：
4.1 创建普通数组(array)：
np.array(
object, # 数组。
公开数组接口的任何对象，__array__方法返回数组的对象，或任何（嵌套）序列。
dtype=None, # 数据类型，可选。
数组所需的数据类型。如果没有给出，那么类型将被确定为保持序列中的对象所需的最小类型。
此参数只能用于“upcast”数组。对于向下转换，请使用.astype(t)方法。
copy=True, # bool，可选。
如果为true（默认值），则复制对象。
否则，只有当__array__返回副本，obj是嵌套序列，
或者需要副本来满足任何其他要求（dtype，顺序等）时，才会进行复制。
order='K', # {'K'，'A'，'C'，'F'}，可选。
指定阵列的内存布局。
subok=False, # bool，可选。
如果为True，则子类将被传递，否则返回的数组将被强制为基类数组（默认）。
ndmin=0 # int，可选。
指定结果数组应具有的最小维数。根据需要，将根据需要预先设置形状。
)
一维数组：
np.array([1, 2, 3])
array([1, 2, 3])
二维数组：
np.array(
[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
三维数组：
np.array(
[[[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]]])
array([[[ 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]]])
…
n维数组~ ~ ~
4.2 创建指定形状和数据类型的数组(empty)：
数组中的数取决于数组在内存中的位置处的值.
np.empty(
shape, # 数组形状
dtype = float, # 数据类型，可选
order = 'C' # 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序
)
np.empty((2, 3, 4))
array([[[6.23042070e-307, 1.89146896e-307, 1.37961302e-306,
6.23053614e-307],
[6.23053954e-307, 9.34609790e-307, 8.45593934e-307,
9.34600963e-307],
[1.86921143e-306, 6.23061763e-307, 6.23060065e-307,
8.45603441e-307]],
[[9.79111267e-307, 1.11260144e-306, 1.60219035e-306,
8.34448533e-308],
[1.27946076e-307, 1.33511562e-306, 8.90103560e-307,
1.42410974e-306],
[1.00132228e-307, 1.33511018e-306, 1.69119330e-306,
3.46949290e-260]]])
4.3 创建指定形状且值全为0的数组(zeros)：
np.zeros(
shape, # 数组形状
dtype = float, # 数据类型，可选
order = 'C' # 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序
)
np.zeros((2, 3, 4))
array([[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]],
[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]]])
4.4 创建指定形状且值全为1的数组(ones)：
np.zeros(
shape, # 数组形状
dtype = float, # 数据类型，可选
order = 'C' # 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序
)
np.ones((2, 3, 4))
array([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]])
4.5 创建对角矩阵(eye)：
np.eye(
N， # 行数
M， # 列数，默认等于N,即方阵
k = 0，# 对角线的索引：0（默认值）指的是主对角线，正值指的是上对角线，负值指的是下对角线。
dtype = <class’flove’>，# 返回数组的数据类型。
order =‘C’ # 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
)
默认方阵：
np.eye(3)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
对角线向上平移1：
np.eye(3, k=1)
array([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.]])
非方阵矩阵：
np.eye(3, 4)
array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.]])
4.6 从已有数组创建数组：
4.6.1 改造已有数组(asarray)：
np.asarray(
a, # 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
dtype, # 数据类型
order # 可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
)
4.6.1.1np.asarray与np.array的区别：
array和asarray都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，array仍然会copy出一个副本，占用新的内存，但asarray不会。
当数据源时list对象时二者没有区别
data = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
array1 = np.array(data)
array2 = np.asarray(data)
print("data修改前：")
print("data:")
print(data)
print("array1：")
print(array1)
print("array2：")
print(array2)
data[0][0] = 100
print("data修改后：")
print("data:")
print(data)
print("array1：")
print(array1)
print("array2：")
print(array2)
data修改前：
data:
[[1, 1, 1], [1, 1, 1], [1, 1, 1]]
array1：
[[1 1 1]
[1 1 1]
[1 1 1]]
array2：
[[1 1 1]
[1 1 1]
[1 1 1]]
data修改后：
data:
[[100, 1, 1], [1, 1, 1], [1, 1, 1]]
array1：
[[1 1 1]
[1 1 1]
[1 1 1]]
array2：
[[1 1 1]
[1 1 1]
[1 1 1]]
但当数据源为ndarray对象时区别就显现出来了
data = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
array1 = np.asarray(data)
print("data修改前：")
print("data:")
print(data)
print("array1:")
print(array1)
data[0][0] = 100
print("data修改后：")
print("data:")
print(data)
print("array1:")
print(array1)
data修改前：
data:
[[1 1 1]
[1 1 1]
[1 1 1]]
array1:
[[1 1 1]
[1 1 1]
[1 1 1]]
data修改后：
data:
[[100 1 1]
[ 1 1 1]
[ 1 1 1]]
array1:
[[100 1 1]
[ 1 1 1]
[ 1 1 1]]
4.6.1.2 将元组转化为Ndarray：
np.asarray((1, 2, 3))
array([1, 2, 3])
4.6.1.3 将多维元组转化为Ndarray：
np.asarray(((1, 2, 3), (4, 5, 6), (7, 8, 9)))
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
np.asarray(((1, 2, 3), (4, 5, 6), (8, 9)))
array([(1, 2, 3), (4, 5, 6), (8, 9)], dtype=object)
4.6.1.4 将列表转化为Ndarray：
np.asarray([1, 2, 3])
array([1, 2, 3])
4.6.1.5 将多维列表转化为Ndarray：
np.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
array = np.asarray([[1, 2, 3], [4, 5, 6], [8, 9]])
print(array)
[list([1, 2, 3]) list([4, 5, 6]) list([8, 9])]
4.6.1.6 将列表和元组的混合元组转化为Ndarray：
np.asarray(((1, 2, 3), [4, 5, 6], [7, 8, 9]))
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
array = np.asarray(((1, 2, 3), [4, 5, 6], [8, 9]))
print(array)
[(1, 2, 3) list([4, 5, 6]) list([8, 9])]
4.6.1.7 将列表和元组的混合列表转化为Ndarray：
np.asarray([(1, 2, 3), [4, 5, 6], [7, 8, 9]])
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
np.asarray([(1, 2, 3), [4, 5, 6], [8, 9]])
array([(1, 2, 3), list([4, 5, 6]), list([8, 9])], dtype=object)
4.6.2 empty_like：
返回一个和a相同结构和数据类型， 但全部用随机数来填充的数组。
np.empty_like(a, dtype=None, order=‘K’,subok=True)
np.empty_like( np.array([1,2,3]))
array([-279555424, 502, 0])
4.6.3 zeros_like：
返回一个和a相同结构和数据类型，但全部用零填充的数组.
np.zeros_like(a, dtype=None, order=‘K’, subok=True)
np.zeros_like( np.array([1,2,3]))
array([0, 0, 0])
4.6.4 ones_like：
返回一个和a相同结构和数据类型， 但全部用1来填充的数组.
np.ones_like(a, dtype=None, order=‘K’, subok=True)
np.ones_like( np.array([1,2,3]))
array([1, 1, 1])
4.7 可迭代对象的数组转化(fromiter)：
该函数从可迭代对象中建立ndarray对象，返回一维数组。
np.fromiter(
iterable, # 可迭代对象
dtype, # 返回数组的数据类型
count=-1 # 读取的数据数量，默认为-1，读取所有数据
)
np.fromiter(iter(range(5)), dtype=int)
array([0, 1, 2, 3, 4])
np.fromiter(iter("1234"), dtype=int)
array([1, 2, 3, 4])
4.8 流转化(frombuffer)：
np.frombuffer(
buffer, # 可以是任意对象，会以流的形式读入。
dtype = float, # 返回数组的数据类型，可选
count = -1, # 读取的数据数量，默认为-1，读取所有数据。
offset = 0 # 读取的起始位置，默认为0。
)
# buffer是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。
np.frombuffer(b"1234", dtype="S1")
array([b'1', b'2', b'3', b'4'], dtype='|S1')
np.frombuffer(b"1234", dtype="S2")
array([b'12', b'34'], dtype='|S2')
4.9 从数值范围创建数组：
4.9.1 等差数列：
4.9.1.1 指定步长方式创建(arange)：(指定公差)
np.arange(
start, # 起始值，默认为0
stop, # 终止值（不包含）
step, # 步长，默认为1
dtype # 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。
)
np.arange(1, 11)
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
指定步长：
np.arange(1, 11, step=3)
array([ 1, 4, 7, 10])
4.9.1.2 指定数组元素个数创建(linspace)：(指定数列长度)
np.linspace(
start, # 序列的起始值
stop, # 序列的终止值，如果endpoint为true，该值包含于数列中
num=50, # 要生成的等步长的样本数量(数组元素个数)，默认为50
endpoint=True, # 该值为 true 时，数列中中包含stop值，反之不包含，默认是True。
retstep=False, # 如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype=None # ndarray 的数据类型
)
np.linspace(1, 10)
array([ 1. , 1.18367347, 1.36734694, 1.55102041, 1.73469388,
1.91836735, 2.10204082, 2.28571429, 2.46938776, 2.65306122,
2.83673469, 3.02040816, 3.20408163, 3.3877551 , 3.57142857,
3.75510204, 3.93877551, 4.12244898, 4.30612245, 4.48979592,
4.67346939, 4.85714286, 5.04081633, 5.2244898 , 5.40816327,
5.59183673, 5.7755102 , 5.95918367, 6.14285714, 6.32653061,
6.51020408, 6.69387755, 6.87755102, 7.06122449, 7.24489796,
7.42857143, 7.6122449 , 7.79591837, 7.97959184, 8.16326531,
8.34693878, 8.53061224, 8.71428571, 8.89795918, 9.08163265,
9.26530612, 9.44897959, 9.63265306, 9.81632653, 10. ])
指定数组元素个数：
np.linspace(1, 10, 5)
array([ 1. , 3.25, 5.5 , 7.75, 10. ])
4.9.2 等比数列(logspace)：
np.logspace(
start, # 序列的起始值
stop, # 序列的终止值
num=50, # 要生成的等步长的样本数量，默认为50
endpoint=True, # 该值为 true 时，数列中中包含stop值，反之不包含，默认是True。
base=10.0, # 对数 log 的底数。
dtype=None # 数据类型
)
np.logspace(0, 9, num=10)
array([1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07,
1.e+08, 1.e+09])
np.logspace(0, 9, num=10, dtype=int, base=2) # 指定公比
array([ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512])
4.10 构造复杂数组：
4.10.1 数组的重复(tile)：
np.tile(
a, # 要扩充的实体array_like
reps # 如果只是单独的一个数字，默认横向展开
如果是两个数字组成的元组，则按先行后列展开
)
a = np.arange(3)
print("原始数组：")
print(a)
print("一维：")
x = np.tile(a, 2)
print(x)
print("二维：")
x = np.tile(a, (2, 3))
print(x)
原始数组：
[0 1 2]
一维：
[0 1 2 0 1 2]
二维：
[[0 1 2 0 1 2 0 1 2]
[0 1 2 0 1 2 0 1 2]]
4.10.2 数组元素的重复(repeat)：
np.repeat(
a, # 要扩充的实体array_like
repeats, # 复制次数
axis=None # 默认为None,若为多为数组，则将其展开为一维数组元素重复
axis=0,沿着y轴复制，实际上增加了行数
axis=1,沿着x轴复制，实际上增加了列数
)
b = np.arange(3)
print("原始数组：")
print(b)
print("第一种方法：")
print(b.repeat(2))
print("第二种方法：")
x = np.repeat(b, 2)
x
print(x)
原始数组：
[0 1 2]
第一种方法：
[0 0 1 1 2 2]
第二种方法：
[0 0 1 1 2 2]
c=np.array(
[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print("原始数组：")
print(c)
print("一维展开：")
print(np.repeat(c,2))
print("增加行数：")
print(np.repeat(c,2,axis=0))
print("增加列数：")
print(np.repeat(c,2,axis=1))
原始数组：
[[1 2 3]
[4 5 6]
[7 8 9]]
一维展开：
[1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9]
增加行数：
[[1 2 3]
[1 2 3]
[4 5 6]
[4 5 6]
[7 8 9]
[7 8 9]]
增加列数：
[[1 1 2 2 3 3]
[4 4 5 5 6 6]
[7 7 8 8 9 9]]
4.10.3 一维数组网格化(meshgrid)：
X,Y = np.meshgrid(x, y)
x，y，是网格点的横纵坐标列向量（非矩阵）
X，Y，是坐标矩阵
a = np.arange(3)
b = np.arange(2)
print("a:")
print(a)
print("b:")
print(b)
grid_a, grid_b = np.meshgrid(a, b)
print("grid_a:")
print(grid_a)
print("grid_b:")
print(grid_b)
a:
[0 1 2]
b:
[0 1]
grid_a:
[[0 1 2]
[0 1 2]]
grid_b:
[[0 0 0]
[1 1 1]]
如果觉得看不明白的话，可以这样理解：
grid_a:[[0 1 2][0 1 2]]
grid_b:[[0 0 0][1 1 1]]
-
上下结合，就将a、b这两个一维数组网格化了，网格上的点即为（0，0）（1，0）（2，0）（0，1）（1，1）（2，1）
- ~ ~
4.10.4 指定范围和分割方式的网格化(mgrid)：
np.mgrid[
start:开始坐标
stop:结束坐标（实数不包括，复数包括）
step步长
]
np.mgrid[1:11:1]
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
grid_1,grid_2=np.mgrid[0:3:1,0:2:1]
print(grid_1)
print(grid_2)
[[0 0]
[1 1]
[2 2]]
[[0 1]
[0 1]
[0 1]]
对比和meshgrid的区别：
grid_1:[[0 0][1 1][2 2]]
grid_2:[[0 1][0 1][0 1]]
（0，0）（0，1）（1，0）（1，1）（2，0）（2，1）
5 数组操作：
5.1 改变数组形状：
np.reshape(
a， # array_like 要重塑的数组。
newshape， # int或int的元组。新形状应与原始形状兼容。
如果是整数，则结果将是该长度的一维数组。
一种形状尺寸可以为-1。在这种情况下，该值是根据数组的长度和其余维来推断的。
order ='C' # {'C'，'F'，'A'}，可选
使用此索引顺序读取a的元素，并使用此索引顺序将元素放入重新排列的数组中。
“ C”表示使用类似C的索引顺序读取/写入元素，最后一个轴索引更改最快，回到第一个轴索引更改最慢。
“ F”表示使用类似Fortran的索引顺序读取/写入元素，第一个索引更改最快，最后一个索引更改最慢。
请注意，“ C”和“ F”选项不考虑基础数组的内存布局，仅指索引的顺序。
如果a在内存中是连续的，则以类似于Fortran的索引顺序读取/写入元素，否则为类似于C的顺序。
)
5.1.1 改变数组形状(reshape)：
a = np.arange(1, 7)
a
array([1, 2, 3, 4, 5, 6])
一种方法：
b = np.reshape(a, (3, 2))
b
array([[1, 2],
[3, 4],
[5, 6]])
另一种方法：
np.arange(1, 7).reshape((3, 2))
array([[1, 2],
[3, 4],
[5, 6]])
当reshape形状不符合要求时会报错：
np.arange(1, 7).reshape((9, 9))
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-242-a2d3661a8a3f> in <module>
----> 1 np.arange(1, 7).reshape((9, 9))
ValueError: cannot reshape array of size 6 into shape (9,9)
5.1.2 改变数组形状(resize)：
a=np.arange(1, 7)
a
array([1, 2, 3, 4, 5, 6])
b=np.resize(a,(3,2))
b
array([[1, 2],
[3, 4],
[5, 6]])
当resize形状不符合时会自动填充：
np.resize(np.arange(1, 7), (9, 9))
array([[1, 2, 3, 4, 5, 6, 1, 2, 3],
[4, 5, 6, 1, 2, 3, 4, 5, 6],
[1, 2, 3, 4, 5, 6, 1, 2, 3],
[4, 5, 6, 1, 2, 3, 4, 5, 6],
[1, 2, 3, 4, 5, 6, 1, 2, 3],
[4, 5, 6, 1, 2, 3, 4, 5, 6],
[1, 2, 3, 4, 5, 6, 1, 2, 3],
[4, 5, 6, 1, 2, 3, 4, 5, 6],
[1, 2, 3, 4, 5, 6, 1, 2, 3]])
5.1.3 改变轴的顺序(rollaxis)：
np.rollaxis(
a, # 数组
axis, # 要改变的轴。其他轴的相对顺序保持不变
start=0 # 要改变的轴滚动至此位置之前。默认值为0
)
a = np.arange(8).reshape(2, 2, 2)
print('原数组：')
print(a)
print('将轴 2 滚动到轴 0：（宽度到深度）：')
print(np.rollaxis(a, 2))
print('将轴 0 滚动到轴 1：（宽度到高度）：')
print(np.rollaxis(a, 2, 1))
原数组：
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
将轴 2 滚动到轴 0：（宽度到深度）：
[[[0 2]
[4 6]]
[[1 3]
[5 7]]]
将轴 0 滚动到轴 1：（宽度到高度）：
[[[0 2]
[1 3]]
[[4 6]
[5 7]]]
5.1.4 数组降维：(n维降至一维)
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
a
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
a.reshape(-1)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
另一种方法：
a.ravel()
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
5.1.5 行列转换：（类似于矩转置）
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
a
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
a.transpose()
array([[1, 4, 7],
[2, 5, 8],
[3, 6, 9]])
5.2 广播(Broadcast)：
广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。
5.2.1 当二者形状相同时：
a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])
c = a * b
print(c)
[ 10 40 90 160]
5.2.2 当二者形状不同时，自动触发广播机制：
a = np.array([[0, 0, 0],
[10, 10, 10],
[20, 20, 20],
[30, 30, 30]])
b = np.array([1, 2, 3])
print(a + b)
[[ 1 2 3]
[11 12 13]
[21 22 23]
[31 32 33]]
5.3 切片和索引：
5.3.1 一维数组：
与list一样
a = np.arange(1, 11)
print(a[:])
print(a[::-1])
print(a[3:7])
print(a[3:7:2])
[ 1 2 3 4 5 6 7 8 9 10]
[10 9 8 7 6 5 4 3 2 1]
[4 5 6 7]
[4 6]
5.3.2 二维数组：
a=np.array([[1,2,3],[4,5,6],[7,8,9]])
print("原始数组：")
print(a)
print("获取某一行：")
print("法一：")
print(a[1]) # 第2行
print("法二：")
print (a[1,...]) # 第2行元素
print("获取多行：")
print(a[1:3]) # 后两行
print("获取某一列：")
print (a[...,1]) # 第2列元素
print("获取多列：")
print (a[...,1:]) # 第2列及剩下的所有元素
原始数组：
[[1 2 3]
[4 5 6]
[7 8 9]]
获取某一行：
法一：
[4 5 6]
法二：
[4 5 6]
获取多行：
[[4 5 6]
[7 8 9]]
获取某一列：
[2 5 8]
获取多列：
[[2 3]
[5 6]
[8 9]]
5.4 获取某个位置的元素：
x = np.array([[1, 2], [3, 4], [5, 6]])
print("原始数组：")
print(x)
y = x[[0, 1, 2],
[0, 1, 0]] # 竖着看（0，0）（1，1）（2，0）
print("获取谋某些位置的数值：")
print(y)
原始数组：
[[1 2]
[3 4]
[5 6]]
获取谋某些位置的数值：
[1 4 5]
5.5 布尔索引：
我们可以通过一个布尔数组来索引目标数组。
布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。
5.5.1 范围取值：
x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
print("原始数组：")
print(x)
print('布尔索引筛选：')
print(x[x > 5])
原始数组：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
布尔索引筛选：
[ 6 7 8 9 10 11]
5.5.2 过滤(~)：
a = np.array([np.nan, 1, 2, np.nan, 3, 4, 5])
print("原始数组：")
print(a)
print("过滤后：")
print(a[~np.isnan(a)])
原始数组：
[nan 1. 2. nan 3. 4. 5.]
过滤后：
[1. 2. 3. 4. 5.]
5.6 花式索引：
花式索引指的是利用整数数组进行索引。
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行。
花式索引跟切片不一样，它总是将数据复制到新数组中。
5.6.1 正序索引：
x = np.arange(32).reshape((8, 4))
print("原始数组：")
print(x)
print("新数组：")
print(x[[4, 2, 1, 7]])
原始数组：
[[ 0 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]]
新数组：
[[16 17 18 19]
[ 8 9 10 11]
[ 4 5 6 7]
[28 29 30 31]]
5.6.2 倒序索引：
x = np.arange(32).reshape((8, 4))
print("原始数组：")
print(x)
print("新数组：")
print(x[[-4, -2, -1, -7]])
原始数组：
[[ 0 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]]
新数组：
[[16 17 18 19]
[24 25 26 27]
[28 29 30 31]
[ 4 5 6 7]]
5.6.3 传入多个索引数组(ix_)：
x = np.arange(32).reshape((8, 4))
print("原始数组：")
print(x)
print("新数组：")
print(x[np.ix_([1, 5, 7, 2],
[0, 3, 1, 2])]) # 每行按照 0 3 1 2 来排序
原始数组：
[[ 0 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]]
新数组：
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
5.7 数组复制：
5.7.1 浅复制(view)：（共享内存）
a = np.array([1, 2])
a
array([1, 2])
b = a.view()
b
array([1, 2])
b is a
False
b.base is a
True
b.flags.owndata
False
5.7.2 深复制(copy)：（独享内存）
a = np.array([1, 2])
a
array([1, 2])
c = a.copy()
c
array([1, 2])
c is a
False
c.base is a
False
c.flags.owndata
True
5.8 数组合并：
5.8.1 append：
np.append(
arr, # 需要被添加values的数组
values, # 添加到数组arr中的值（array_like，类数组）
axis=None # 可选参数，如果axis没有给出，那么arr，values都将先展平成一维数组。
注：如果axis被指定了，那么arr和values需要有相同的shape，
否则报错：ValueError: arrays must have same number of dimensions
)
a=np.array([1,2])
a
array([1, 2])
添加一个元素：
np.append(a, 3)
array([1, 2, 3])
添加一个ndarray:
np.append(a, np.array([3, 4, 5, 6, 7]))
array([1, 2, 3, 4, 5, 6, 7])
水平合并：
np.append(np.array([[1, 2, 3]]), np.array([[4, 5, 6]]),axis=1)
array([[1, 2, 3, 4, 5, 6]])
竖直合并：
np.append(np.array([[1, 2, 3]]), np.array([[4, 5, 6]]),axis=0)
array([[1, 2, 3],
[4, 5, 6]])
5.8.2 concatenate：
np.concatenate(
(a1, a2, ...), # 传入的参数必须是一个多个数组的元组或者列表
axis=0
)
a = np.array([[1, 2], [3, 4]])
a
array([[1, 2],
[3, 4]])
b1 = np.array([5, 6]) # 一维数组
b1
array([5, 6])
np.concatenate((a,b1)) # 维数不一样会报错
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-279-70ebb45ced05> in <module>
----> 1 np.concatenate((a,b1)) # 维数不一样会报错
<__array_function__ internals> in concatenate(*args, **kwargs)
ValueError: all the input arrays must have same number of dimensions, but the array at index 0 has 2 dimension(s) and the array at index 1 has 1 dimension(s)
b2 = np.array([[5, 6]]) # 二维数组
b2
array([[5, 6]])
np.concatenate((a,b2),axis=0) # 纵向拼接
array([[1, 2],
[3, 4],
[5, 6]])
b3 = np.array([[5], [6]])
b3
array([[5],
[6]])
np.concatenate((a, b3), axis=1) # 横向拼接
array([[1, 2, 5],
[3, 4, 6]])
np.concatenate((a, b3), axis=None) # 拼接并展开为一维数组
array([1, 2, 3, 4, 5, 6])
5.8.3 stack：
np.stack(
arrays, # array_like
axis=0
)
a = np.arange(60).reshape(3, 4, 5)
b = np.arange(60).reshape(3, 4, 5)
a.shape, b.shape
((3, 4, 5), (3, 4, 5))
np.stack((a, b), axis=0).shape
(2, 3, 4, 5)
np.stack((a,b), axis=1).shape
(3, 2, 4, 5)
np.stack((a,b), axis=2).shape
(3, 4, 2, 5)
np.stack((a,b), axis=3).shape
(3, 4, 5, 2)
可见，axis等于几，就相当于把第几维的数据向前提升一个维度
5.8.4 hstack、vstack、dstack：
a = np.arange(9).reshape(3, 3)
a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
b = np.arange(9, 18).reshape(3, 3)
b
array([[ 9, 10, 11],
[12, 13, 14],
[15, 16, 17]])
np.hstack((a, b))
array([[ 0, 1, 2, 9, 10, 11],
[ 3, 4, 5, 12, 13, 14],
[ 6, 7, 8, 15, 16, 17]])
np.vstack((a, b))
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11],
[12, 13, 14],
[15, 16, 17]])
np.dstack((a, b))
array([[[ 0, 9],
[ 1, 10],
[ 2, 11]],
[[ 3, 12],
[ 4, 13],
[ 5, 14]],
[[ 6, 15],
[ 7, 16],
[ 8, 17]]])
5.9 数组拆分：
5.9.1 split：
np.split(
ary, # 要切分的数组
indices_or_sections, # 如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
axis=0 # 沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分
)
5.9.1.1 一维数组：
a = np.array([1, 2, 3, 4])
a
array([1, 2, 3, 4])
np.split(a, 2)
[array([1, 2]), array([3, 4])]
如果数组长度不能整除要分割的数量就会报错：
np.split(a, 3)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
C:\Anaconda\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
864 try:
--> 865 len(indices_or_sections)
866 except TypeError:
TypeError: object of type 'int' has no len()
During handling of the above exception, another exception occurred:
ValueError Traceback (most recent call last)
<ipython-input-297-9595497857d7> in <module>
----> 1 np.split(a, 3)
<__array_function__ internals> in split(*args, **kwargs)
C:\Anaconda\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
869 if N % sections:
870 raise ValueError(
--> 871 'array split does not result in an equal division')
872 return array_split(ary, indices_or_sections, axis)
873
ValueError: array split does not result in an equal division
5.9.1.2 二维数组：
a = np.arange(1, 17).reshape(4, 4)
a
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]])
纵向切割：
np.split(a, 2, axis=1)
[array([[ 1, 2],
[ 5, 6],
[ 9, 10],
[13, 14]]), array([[ 3, 4],
[ 7, 8],
[11, 12],
[15, 16]])]
横向切割：
np.split(a, 4, axis=0)
[array([[1, 2, 3, 4]]),
array([[5, 6, 7, 8]]),
array([[ 9, 10, 11, 12]]),
array([[13, 14, 15, 16]])]
同样不能整除会报错：
np.split(a, 3, axis=0)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
C:\Anaconda\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
864 try:
--> 865 len(indices_or_sections)
866 except TypeError:
TypeError: object of type 'int' has no len()
During handling of the above exception, another exception occurred:
ValueError Traceback (most recent call last)
<ipython-input-301-4ed6c4ac42f0> in <module>
----> 1 np.split(a, 3, axis=0)
<__array_function__ internals> in split(*args, **kwargs)
C:\Anaconda\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
869 if N % sections:
870 raise ValueError(
--> 871 'array split does not result in an equal division')
872 return array_split(ary, indices_or_sections, axis)
873
ValueError: array split does not result in an equal division
5.9.2 array_split：
split不能进行不均等分割，但它可以
5.9.2.1 一维数组：
a = np.array([1, 2, 3, 4, 5, 6])
a
array([1, 2, 3, 4, 5, 6])
np.array_split(a,5)
[array([1, 2]), array([3]), array([4]), array([5]), array([6])]
5.9.2.2 二维数组：
a = np.arange(1, 17).reshape(4, 4)
a
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]])
纵向切割：
np.array_split(a, 3, axis=1)
[array([[ 1, 2],
[ 5, 6],
[ 9, 10],
[13, 14]]), array([[ 3],
[ 7],
[11],
[15]]), array([[ 4],
[ 8],
[12],
[16]])]
横向切割：
np.array_split(a, 3, axis=0)
[array([[1, 2, 3, 4],
[5, 6, 7, 8]]), array([[ 9, 10, 11, 12]]), array([[13, 14, 15, 16]])]
5.9.3 hsplit、vsplit、dsplit：
a = np.arange(4).reshape(2, 2)
a
array([[0, 1],
[2, 3]])
x, y = np.hsplit(a, 2) # 水平拆分，返回list
print(x)
print()
print(y)
[[0]
[2]]
[[1]
[3]]
x, y = np.vsplit(a, 2) # 垂直拆分，返回list
print(x)
print()
print(y)
[[0 1]]
[[2 3]]
b = np.arange(8).reshape(2,2,2)
b
array([[[0, 1],
[2, 3]],
[[4, 5],
[6, 7]]])
x, y = np.dsplit(b, 2) # 深度拆分，返回list
print(x)
print()
print(y)
[[[0]
[2]]
[[4]
[6]]]
[[[1]
[3]]
[[5]
[7]]]
5.10 数组排序：
5.10.1 sort：
np.sort(
a, # 要排序的数组
axis=-1, # 沿着它排序数组的轴，如果没有，数组会被展开，沿着最后的轴排序
kind='quicksort', # 排序方法，默认为’quicksort’（快速排序），
其他选项还有 ‘mergesort’（归并排序）和 ‘heapsort’（堆排序）
order=None # 如果数组包含字段，则是要排序的字段
)
a = np.array([3, 1, 2])
a
array([3, 1, 2])
np.sort(a)
array([1, 2, 3])
dt = np.dtype([('name', 'S10'), ('age', int)])
b = np.array([("raju", 21), ("anil", 25),
("ravi", 17), ("amar", 27)], dtype=dt)
b
array([(b'raju', 21), (b'anil', 25), (b'ravi', 17), (b'amar', 27)],
dtype=[('name', 'S10'), ('age', '<i4')])
np.sort(b, order="name")
array([(b'amar', 27), (b'anil', 25), (b'raju', 21), (b'ravi', 17)],
dtype=[('name', 'S10'), ('age', '<i4')])
np.sort(b, order="age")
array([(b'ravi', 17), (b'raju', 21), (b'anil', 25), (b'amar', 27)],
dtype=[('name', 'S10'), ('age', '<i4')])
5.10.2 argsort：
对值排序返回索引数组，参数同上
a = np.array([3, 1, 2])
np.argsort(a)
array([1, 2, 0], dtype=int64)
5.11 数组查找：
a = np.array([4, 6, 2, 9, 1, 5, 3, 9, 6, 0, 1])
a
array([4, 6, 2, 9, 1, 5, 3, 9, 6, 0, 1])
5.11.1 返回数组中最大值和最小值的索引(argmax/argmin)：
np.argmax(a, axis=None, out=None)
3
np.argmin(a, axis=None, out=None)
9
5.11.2 返回数组中非零元素的索引(nonzero)：
np.nonzero(a)
(array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 10], dtype=int64),)
5.11.3 返回数组中满足给定条件的索引(where)：
np.where(a > 5)
(array([1, 3, 7, 8], dtype=int64),)
5.11.4 返回数组中满足给定条件的元素(extract)：
np.extract(a > 5, a)
array([6, 9, 9, 6])
5.12 数组增减元素(insert/delete)：
append也可以，见上面 数组合并-append
5.12.1 插入元素(insert)：
np.insert(
arr, # 一个数组，可以是一维的也可以是多维的，在arr的基础上插入元素
obj, # 元素插入的位置
values, # 需要插入的数值
axis=None # 指示在哪一个轴上对应的插入位置进行插入
)
a = np.array([[1, 1], [2, 2], [3, 3]])
a
array([[1, 1],
[2, 2],
[3, 3]])
默认平铺插入：
np.insert(a, 1, 5)
array([1, 5, 1, 2, 2, 3, 3])
插入行（若为一个值则插入的时相同小数组）：
np.insert(a, 1, 5, axis=0)
array([[1, 1],
[5, 5],
[2, 2],
[3, 3]])
插入行（插入一个小数组）：
np.insert(a, 1, [5,7], axis=0)
array([[1, 1],
[5, 7],
[2, 2],
[3, 3]])
插入列：
np.insert(a, 1, 5, axis=1)
array([[1, 5, 1],
[2, 5, 2],
[3, 5, 3]])
5.12.2 删除元素(delete)：
np.delete(
arr, # 需要处理的矩阵
obj, # 在什么位置处理
axis=None # # 指示在哪一个轴上对应的插入位置进行插入
)
a = np.array([[1, 2], [3, 4], [5, 6]])
a
array([[1, 2],
[3, 4],
[5, 6]])
默认平铺删除：
np.delete(a, 1)
array([1, 3, 4, 5, 6])
删除一行：
np.delete(a, 1, axis=0)
array([[1, 2],
[5, 6]])
删除一列：
np.delete(a, 1, axis=1)
array([[1],
[3],
[5]])
5.13 数组去重(unique)：
np.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)
5.13.1 x = np.unique(a)
对于一维数组或者列表，unique函数去除其中重复的元素，并按元素由大到小返回一个新的无元素重复的元组或者列表
a = np.array([3, 6, 2, 9, 6, 8, 3, 4, 2, 1, 0])
a
array([3, 6, 2, 9, 6, 8, 3, 4, 2, 1, 0])
x=np.unique(a)
print(x)
[0 1 2 3 4 6 8 9]
5.13.2 x, y = np.unique(b,return_index=True)
return_index=True表示返回新列表元素在旧列表中的位置，并以列表形式储存在y中。
b = np.array([3, 6, 2, 9, 6, 8, 3, 4, 2, 1, 0])
b
array([3, 6, 2, 9, 6, 8, 3, 4, 2, 1, 0])
x, y = np.unique(b, return_index=True)
print(x)
print(y)
[0 1 2 3 4 6 8 9]
[10 9 2 0 7 1 5 3]
5.13.3 x, y, z = np.unique(c, return_index=True, return_inverse=True)
return_inverse=True 表示返回旧列表元素在新列表中的位置，并以列表形式储存在z中
c = np.array([3, 6, 2, 9, 6, 8, 3, 4, 2, 1, 0])
c
array([3, 6, 2, 9, 6, 8, 3, 4, 2, 1, 0])
x, y, z = np.unique(c, return_index=True, return_inverse=True)
print(x)
print(y)
print(z)
[0 1 2 3 4 6 8 9]
[10 9 2 0 7 1 5 3]
[3 5 2 7 5 6 3 4 2 1 0]
5.14 数组迭代(nditer)：
np.nditer(
a, # 数组
order, # 'F'列序优先；'C'行序优先
)
a = np.arange(6).reshape(2, 3)
a
array([[0, 1, 2],
[3, 4, 5]])
默认行序优先：
for x in np.nditer(a):
print(x, end=" ")
0 1 2 3 4 5
列序优先：
for x in np.nditer(a,order='F'):
print(x, end=" ")
0 3 1 4 2 5
6 位运算：
6.1 获取一个数字的二进制(bin_repr)：
np.binary_repr(19, width = 8)
'00010011'
bin(19)
'0b10011'
6.2 按位与(bitwise_and)：
np.bitwise_and(17, 13)
1
17 & 13
1
6.3 按位或(bitwise_or)：
np.bitwise_or(13,16)
29
13 | 16
29
6.4 按位异或(bitwise_xor)：
np.bitwise_xor(10,16)
26
10 ^ 16
26
6.5 按位取反(invert)：
np.invert(13)
-14
~13
-14
6.6 二进制左移(left_shift)：
np.left_shift(10, 2) # 将10左移两位
40
10 << 2
40
6.7 二进制右移(right_shift)：
np.right_shift(10, 2) # 将10右移两位
2
10 >> 2
2
7 字符串操作(char)：
7.1 连接(add)：
np.char.add("qwer", "1234")
array('qwer1234', dtype='<U8')
np.char.add(["qwer"], ["1234"])
array(['qwer1234'], dtype='<U8')
np.char.add(np.array(["1", "2", "3"]),
np.array(["4", "5", "6"]))
array(['14', '25', '36'], dtype='<U2')
7.2 复制拼接(multiply)：
np.char.multiply('qwer ', 3)
array('qwer qwer qwer ', dtype='<U15')
np.char.multiply(["qwer"], 3)
array(['qwerqwerqwer'], dtype='<U12')
np.char.multiply(np.array(["1", "2", "3"]), 3)
array(['111', '222', '333'], dtype='<U3')
7.3 居中并对两侧填充(center)：
np.char.center('qwer',
width=20, # 总宽度
fillchar='*' # 填充字符
)
array('********qwer********', dtype='<U20')
np.char.center(['qwer'], width=20, fillchar='*')
array(['********qwer********'], dtype='<U20')
7.4 将字符串的第一个字母转换为大写(capitalize)：
np.char.capitalize('qwer')
array('Qwer', dtype='<U4')
np.char.capitalize(['qwer'])
array(['Qwer'], dtype='<U4')
7.5 将字符串的每个单词的第一个字母转换为大写(title)：
np.char.title('i love you')
array('I Love You', dtype='<U10')
np.char.title(['i love you'])
array(['I Love You'], dtype='<U10')
7.6 将字符串的每个字母转换为小写(lower)：
对每个元素调用 str.lower
np.char.lower('QWER')
array('qwer', dtype='<U4')
np.char.lower(['QWER'])
array(['qwer'], dtype='<U4')
7.7 将字符串的每个字母转换为大写(upper)：
对每个元素调用 str.upper
np.char.upper('qwer')
array('QWER', dtype='<U4')
np.char.upper(['qwer'])
array(['QWER'], dtype='<U4')
7.8 分割字符串(split)：
通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格
np.char.split('q w e r')
array(list(['q', 'w', 'e', 'r']), dtype=object)
np.char.split(['q w e r'])
array([list(['q', 'w', 'e', 'r'])], dtype=object)
np.char.split('q_w_e_r', sep='_')
array(list(['q', 'w', 'e', 'r']), dtype=object)
7.9 换行符分割字符串(splitlines)：
np.char.splitlines('i\nlove\nyou')
array(list(['i', 'love', 'you']), dtype=object)
np.char.splitlines(['i\nlove\nyou'])
array([list(['i', 'love', 'you'])], dtype=object)
\r也可以：
np.char.splitlines('i\rlove\ryou')
array(list(['i', 'love', 'you']), dtype=object)
7.10 首尾清理(strip)：
np.char.strip('abcd abcda','a')
array('bcd abcd', dtype='<U10')
np.char.strip(['abcda', 'aaaabcda'], 'a')
array(['bcd', 'bcd'], dtype='<U8')
7.11 指定分隔符来连接数组中的元素或字符串(join)：
np.char.join(':','qwer')
array('q:w:e:r', dtype='<U7')
np.char.join([':','-'],['abcd','qwer'])
array(['a:b:c:d', 'q-w-e-r'], dtype='<U7')
7.12 替换(replace)：
np.char.replace('aaabbbcccdddeeefff', 'a', 'A')
array('AAAbbbcccdddeeefff', dtype='<U18')
7.13 编码(encode)：
np.char.encode('qwer', 'cp500')
array(b'\x98\xa6\x85\x99', dtype='|S4')
7.14 解码(decode)：
np.char.decode(np.char.encode('qwer', 'cp500'), 'cp500')
array('qwer', dtype='<U4')
8 数学函数：
8.1 自然数(e)：
np.e
2.718281828459045
8.2 π \pi π ：
np.pi
3.141592653589793
8.3 三角函数：
a = np.array([0, 30, 45, 60, 90])
print('正弦：')
print(np.sin(a*np.pi/180))
print('反正弦：')
print(np.arcsin(np.sin(a*np.pi/180)))
print('角度制：')
print(np.degrees(np.arcsin(np.sin(a*np.pi/180))))
print('余弦：')
print(np.cos(a*np.pi/180))
print('反余弦：')
print(np.arccos(np.cos(a*np.pi/180)))
print('角度制：')
print(np.degrees(np.arccos(np.cos(a*np.pi/180))))
print('正切函数：')
print(np.tan(a*np.pi/180))
print('反正切：')
print(np.arctan(np.tan(a*np.pi/180)))
print('角度制：')
print(np.degrees(np.arctan(np.tan(a*np.pi/180))))
正弦：
[0. 0.5 0.70710678 0.8660254 1. ]
反正弦：
[0. 0.52359878 0.78539816 1.04719755 1.57079633]
角度制：
[ 0. 30. 45. 60. 90.]
余弦：
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
反余弦：
[0. 0.52359878 0.78539816 1.04719755 1.57079633]
角度制：
[ 0. 30. 45. 60. 90.]
正切函数：
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
反正切：
[0. 0.52359878 0.78539816 1.04719755 1.57079633]
角度制：
[ 0. 30. 45. 60. 90.]
8.4 向下取整(floor)：
np.floor(3.9999999)
3.0
np.floor([1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9])
array([1., 2., 3., 4., 5., 6., 7., 8., 9.])
8.5 向上取整(ceil)：
np.ceil(3.000000001)
4.0
np.ceil([1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9])
array([ 2., 3., 4., 5., 6., 7., 8., 9., 10.])
9 算数函数：
9.1 加(add)：
np.add(1, 2)
3
1+2
3
9.2 减(subtract)：
np.subtract(3,2)
1
3-2
1
9.3 乘(multiply)：
np.multiply(3,2)
6
3*2
6
9.4 除(divide)：
np.divide(9,3)
3.0
9/3
3.0
9.5 倒数(reciprocal)：
np.reciprocal(0.001)
1000.0
np.reciprocal(np.array([0.25, 1.33, 1, 100]))
array([4. , 0.7518797, 1. , 0.01 ])
9.6 幂(power)：
np.power(2,3)
8
2**3
8
np.power(np.array([0.25, 1.33, 1, 100]), 3)
array([1.562500e-02, 2.352637e+00, 1.000000e+00, 1.000000e+06])
9.7 余数(mod)：
np.mod(11,3)
2
np.mod(np.array([0.25, 1.33, 1, 100]), 3)
array([0.25, 1.33, 1. , 1. ])
10 统计函数：
10.1 最小/大值(amin/amax)：
a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]])
print('原始数组：')
print(a)
print('获取最小值：')
print(np.amin(a))
print('获取每一行的最小值：')
print(np.amin(a, 1))
print('获取每一列的最小值：')
print(np.amin(a, 0))
print('获取最大值：')
print(np.amax(a))
print('获取每一行的最大值：')
print(np.amax(a, 0))
print('获取每一列的最大值：')
print(np.amax(a, axis=0))
原始数组：
[[3 7 5]
[8 4 3]
[2 4 9]]
获取最小值：
2
获取每一行的最小值：
[3 3 2]
获取每一列的最小值：
[2 4 3]
获取最大值：
9
获取每一行的最大值：
[8 7 9]
获取每一列的最大值：
[8 7 9]
10.2 最小值最大值之差(ptp)：
a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]])
print('原始数组：')
print(a)
print('最小值最大值之差：')
print(np.ptp(a))
print('每一行的最小值最大值之差：')
print(np.ptp(a, axis=1))
print('每一列的最小值最大值之差：')
print(np.ptp(a, axis=0))
原始数组：
[[3 7 5]
[8 4 3]
[2 4 9]]
最小值最大值之差：
7
每一行的最小值最大值之差：
[4 5 7]
每一列的最小值最大值之差：
[6 3 6]
10.3 百分位数(percentile)：
np.percentile(
a, # 输入数组
q, # 要计算的百分位数，在 0 ~ 100 之间
axis # 沿着它计算百分位数的轴
)
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print ('原始数组：')
print (a)
print ('获取50%位置的树数：')
print (np.percentile(a, 50))
print ('获取每一列50%位置的树数：')
print (np.percentile(a, 50, axis=0))
print ('获取每一行50%位置的树数：')
print (np.percentile(a, 50, axis=1))
print("保持维度不变")
print (np.percentile(a, 50, axis=1, keepdims=True))
原始数组：
[[1 2 3]
[4 5 6]
[7 8 9]]
获取50%位置的树数：
5.0
获取每一列50%位置的树数：
[4. 5. 6.]
获取每一行50%位置的树数：
[2. 5. 8.]
保持维度不变
[[2.]
[5.]
[8.]]
10.4 中位数(median)：
a = np.array([[30,65,70],[80,95,10],[50,90,60]])
print ('原始数组：')
print (a)
print ('获取中位数：')
print (np.median(a))
print ('获取每一列的中位数：')
print (np.median(a, axis = 0))
print ('获取每一行的中位数：')
print (np.median(a, axis = 1))
原始数组：
[[30 65 70]
[80 95 10]
[50 90 60]]
获取中位数：
65.0
获取每一列的中位数：
[50. 90. 60.]
获取每一行的中位数：
[65. 80. 60.]
10.5 算术平均值(mean)：
a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
print('原始数组：')
print(a)
print('平均值：')
print(np.mean(a))
print('每一列的平均值：')
print(np.mean(a, axis=0))
print('每一行的平均值：')
print(np.mean(a, axis=1))
原始数组：
[[1 2 3]
[3 4 5]
[4 5 6]]
平均值：
3.6666666666666665
每一列的平均值：
[2.66666667 3.66666667 4.66666667]
每一行的平均值：
[2. 4. 5.]
10.6 加权平均(average)：
比如：
数组[1,2,3,4]，相应的权重[4,3,2,1]
加权平均值 = (1 * 4 + 2 * 3 + 3 * 2 + 4 * 1) / ( 4 + 3 + 2 + 1 )
a = np.array([1, 2, 3, 4])
print('原始数组：')
print(a)
print('不指定权重：')
print(np.average(a))# 不指定权重时相当于 mean 函数
wts = np.array([4, 3, 2, 1])
print('指定权重：')
print(np.average(a, weights=wts))# 如果 returned 参数设为 true，则返回权重的和
print('权重的和：')
print(np.average([1, 2, 3, 4], weights=[4, 3, 2, 1], returned=True))
原始数组：
[1 2 3 4]
不指定权重：
2.5
指定权重：
2.0
权重的和：
(2.0, 10.0)
10.7 方差(var)：
np.var([1, 2, 3, 4])
1.25
10.8 标准差(std)：
np.std([1, 2, 3, 4])
1.118033988749895
11 矩阵(matlib)：（Matrix）
前提import numpy.matlib
import numpy.matlib
11.1 创建一个全为随机值的新矩阵(empty)：
np.matlib.empty(
shape, # 定义新矩阵形状的整数或整数元组
dtype, # 数据类型
order # C（行序优先） 或者 F（列序优先）
)
np.matlib.empty((2,2))
matrix([[2.25, 0.25],
[0.25, 2.25]])
11.2 创建一个以 0 填充的矩阵(zeros)：
np.matlib.zeros((2,2))
matrix([[0., 0.],
[0., 0.]])
11.3 创建一个以 1 填充的矩阵(ones)：
np.matlib.ones((2,2))
matrix([[1., 1.],
[1., 1.]])
11.4 创建一个对角线元素为 1，其他位置为零的矩阵(eye)：
np.matlib.eye(
n, # 矩阵的行数
M, # 矩阵的列数，默认为 n
k, # 对角线的索引
dtype # 数据类型
)
np.matlib.eye(n = 3, M = 4, k = 0, dtype = float)
matrix([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.]])
11.5 创建给定大小的单位矩阵(identity)：
np.matlib.identity(5, dtype = float)
matrix([[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]])
11.6 创建一个数据是随机填充的给定大小的矩阵(rand)：
np.matlib.rand(3,3)
matrix([[0.2103638 , 0.19701695, 0.25662278],
[0.91461242, 0.53698155, 0.08962696],
[0.24858045, 0.66935183, 0.11712148]])
11.7 二维ndarray对象与矩阵的互换：
i = np.matrix('1,2;3,4')
i
matrix([[1, 2],
[3, 4]])
j = np.asarray(i)
j
array([[1, 2],
[3, 4]])
k = np.asmatrix(j)
k
matrix([[1, 2],
[3, 4]])
12 线性代数：
12.1 数组乘积(dot)：
np.dot(
a, # ndarray 数组
b, # ndarray 数组
out=None # ndarray, 可选，用来保存dot()的计算结果
)
a = np.array([[1, 2], [3, 4]])
b = np.array([[11, 12], [13, 14]])
print("a:")
print(a)
print("b:")
print(b)
print("a × b :")
print(np.dot(a, b))
# [[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]
a:
[[1 2]
[3 4]]
b:
[[11 12]
[13 14]]
a × b :
[[37 40]
[85 92]]
12.2 向量点积(vdot)：
如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开。
a = np.array([[1, 2], [3, 4]])
b = np.array([[11, 12], [13, 14]])
print("a:")
print(a)
print("b:")
print(b)
print("a × b :")
print(np.vdot(a, b))
# 1*11 + 2*12 + 3*13 + 4*14 = 130
a:
[[1 2]
[3 4]]
b:
[[11 12]
[13 14]]
a × b :
130
12.3 向量乘积(inner)：
一维数组：
np.inner(np.array([1, 2, 3]), np.array([0, 1, 0]))
# 1*0+2*1+3*0
2
二维数组：
a = np.array([[1, 2], [3, 4]])
print('a：')
print(a)
b = np.array([[11, 12], [13, 14]])
print('b：')
print(b)
print('a × b ：')
print(np.inner(a, b))
# 1*11+2*12, 1*13+2*14
# 3*11+4*12, 3*13+4*14
a：
[[1 2]
[3 4]]
b：
[[11 12]
[13 14]]
a × b ：
[[35 41]
[81 95]]
12.4 矩阵乘积(matmul)：
np.matmul 函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。
另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。
二维 × 二维：（就是矩阵乘法）
a = [[1,0],[0,1]]
print("a:")
print(a)
b = [[4,1],[2,2]]
print("b:")
print(b)
print("a × b :")
print (np.matmul(a,b))
a:
[[1, 0], [0, 1]]
b:
[[4, 1], [2, 2]]
a × b :
[[4 1]
[2 2]]
有一方为一维：
a = [[1, 0], [0, 1]]
print("a:")
print(a)
b = [1, 2]
print("b:")
print(b)
print("a × b :")
print(np.matmul(a, b))
print("b × a :")
print(np.matmul(b, a))
a:
[[1, 0], [0, 1]]
b:
[1, 2]
a × b :
[1 2]
b × a :
[1 2]
维度大于二：
a = np.arange(8).reshape(2, 2, 2)
print("a:")
print(a)
b = np.arange(4).reshape(2, 2)
print("b:")
print(b)
print("a × b :")
print(np.matmul(a, b))
a:
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
b:
[[0 1]
[2 3]]
a × b :
[[[ 2 3]
[ 6 11]]
[[10 19]
[14 27]]]
12.5 行列式(det)：
a = np.array([[1, 2], [3, 4]])
print("a:")
print(a)
print("det(a):")
print(np.linalg.det(a))
print("det(a):(验证)")
print(1*4-2*3)
b = np.array([[6, 1, 1], [4, -2, 5], [2, 8, 7]])
print("b:")
print(b)
print("det(b):")
print(np.linalg.det(b))
print("det(b):(验证)")
print(6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2))
a:
[[1 2]
[3 4]]
det(a):
-2.0000000000000004
det(a):(验证)
-2
b:
[[ 6 1 1]
[ 4 -2 5]
[ 2 8 7]]
det(b):
-306.0
det(b):(验证)
-306
12.6 矩阵除法(solve)：
a = np.array([[1,1,1],[0,2,5],[2,5,-1]])
print("a:")
print(a)
b = np.array([[6],[-4],[27]])
print("b:")
print (b)
print("a ÷ b :")
x = np.linalg.solve(a,b)
print (x)
a:
[[ 1 1 1]
[ 0 2 5]
[ 2 5 -1]]
b:
[[ 6]
[-4]
[27]]
a ÷ b :
[[ 5.]
[ 3.]
[-2.]]
12.7 检查结果是否正确(allclose)：
np.allclose(np.dot(a, x), b)
True
12.8 矩阵求逆(inv)：
a = np.array([[1,1,1],[0,2,5],[2,5,-1]])
print("a:")
print(a)
print("a的逆:")
print(np.linalg.inv(a))
a:
[[ 1 1 1]
[ 0 2 5]
[ 2 5 -1]]
a的逆:
[[ 1.28571429 -0.28571429 -0.14285714]
[-0.47619048 0.14285714 0.23809524]
[ 0.19047619 0.14285714 -0.0952381 ]]
12.9 实例：
有这样一个线性方程组：
x + y + z = 6
2y + 5z = -4
2x + 5y - z = 27
矩阵表示：
| 1 | 1 | 1 | x | 6 | ||||||
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 2 | 5 | × | y | = | -4 | ||||
| 2 | 5 | -1 | z | 27 | ||||||
| A | × | X | = | B |
a = np.array([[1, 1, 1], [0, 2, 5], [2, 5, -1]])
print('A：')
print(a)
ainv = np.linalg.inv(a)
print('B：')
b = np.array([[6], [-4], [27]])
print(b)
print('X：')
x = np.linalg.solve(a, b)
print(x)
A：
[[ 1 1 1]
[ 0 2 5]
[ 2 5 -1]]
B：
[[ 6]
[-4]
[27]]
X：
[[ 5.]
[ 3.]
[-2.]]
13 文件操作：
Numpy 可以读写磁盘上的文本数据或二进制数据。
NumPy 为 ndarray 对象引入了一个简单的文件格式：.npy。
.npy 文件用于存储重建 ndarray 所需的数据、图形、dtype 和其他信息。
13.1 写入.npy文件(save)：
np.save(
file, # 要保存的文件，扩展名为 .npy，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上。
arr, # 要保存的数组
allow_pickle=True, # 可选，布尔值，允许使用 Python pickles 保存对象数组，
Python 中的 pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。
fix_imports=True # 可选，为了方便 Pyhton2 中读取 Python3 保存的数据。
)
a = np.array([1, 2, 3, 4, 5])
# 保存到 outfile.npy 文件上
np.save('outfile.npy', a)
# 保存到 outfile2.npy 文件上，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上
np.save('outfile2', a)
常规方式打开是乱码：
因为它们是 Numpy 专用的二进制格式后的数据
with open ("outfile.npy","r")as f1,open ("outfile2.npy","r")as f2:
print(f1.read())
print(f2.read())
揘UMPYv{'descr': '<i4', 'fortran_order': False, 'shape': (5,), }
揘UMPYv{'descr': '<i4', 'fortran_order': False, 'shape': (5,), }
13.2 读取.npy文件(load)：
f1 = np.load('outfile.npy')
f2 = np.load('outfile2.npy')
print (f1)
print (f2)
[1 2 3 4 5]
[1 2 3 4 5]
13.3 保存多个数组到一个二进制的.npz文件中(savez)：（打包不压缩）
其实就是多个前面np.save的保存的npy,再通过打包(未压缩)的方式把这些文件归到一个文件上
np.savez(
file, # 文件名/文件路径
*args, # 要存储的数组,可以写多个,如果没有给数组指定Key,Numpy将默认从'arr_0','arr_1'的方式命名
**kwds
)
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("npztest.npz", a, b, sin_array=c)
a
array([[1, 2, 3],
[4, 5, 6]])
b
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
c
array([0. , 0.09983342, 0.19866933, 0.29552021, 0.38941834,
0.47942554, 0.56464247, 0.64421769, 0.71735609, 0.78332691])
r = np.load("npztest.npz")
print(r.files) # 查看各个数组名称
['sin_array', 'arr_0', 'arr_1']
print(r["arr_0"]) # a
[[1 2 3]
[4 5 6]]
print(r["arr_1"]) # b
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
print(r["sin_array"]) # c
[0. 0.09983342 0.19866933 0.29552021 0.38941834 0.47942554
0.56464247 0.64421769 0.71735609 0.78332691]
13.4 保存多个数组到一个二进制的.npz文件中(numpy.savez_compressed)：（打包压缩）
这个就是在前面numpy.savez的基础上加了压缩,前面我介绍时尤其注明numpy.savez是得到的文件打包,不压缩的.这个文件就是对文件进行打包时使用了压缩,可以理解为压缩前各npy的文件大小不变,使用该函数比前面的numpy.savez得到的npz文件更小.
注:函数所需参数和numpy.savez一致,用法完成一样.
13.5 以简单的文本文件格式存储数据(savetext)：
np.savetxt(
fname， # 文件名
X， # 1D或2D array_like ,要保存到文本文件的数据。
fmt ='％。18e'， # str或strs序列，可选
delimiter =''， # 分隔符
newline ='n'， # 换行符
header =''， # 在文件开头写入字符串。
footer =''， # 写在文件末尾的字符串
comments ='＃'， # 将附加到header和footer字符串的字符串，以将其标记为注释。默认值：'＃'，
encoding = None # 用于编码输出文件的编码。不适用于输出流。
)
a = np.array([1, 2, 3, 4, 5])
np.savetxt('out.txt', a)
13.6 读取文本格式数据(loadtext)：
np.loadtxt(
fname, # 被读取的文件名
dtype, # 指定读取后数据的数据类型
comments='#', # 跳过文件中指定参数开头的行（即不读取）
delimiter=None, # 指定读取文件中数据的分割符
converters=None, # 对读取的数据进行预处理
skiprows=0, # 选择跳过的行数
usecols=None, # 指定需要读取的列
unpack=False, # 选择是否将数据进行向量输出
encoding # 对读取的文件进行预编码
)
b = np.loadtxt('out.txt')
print(b)
[1. 2. 3. 4. 5.]
387
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
