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 位浮点数（实数部分和虚数部分） |
Numpy创建数组
task02---索引、切片与迭代
1、副本与视图
在 Numpy 中，尤其是在做数组运算或数组操作时，返回结果不是数组的 **副本** 就是 **视图**，所有赋值运算不会为数组和数组中的任何元素创建副本。
`numpy.ndarray.copy()` 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。
import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x # 创建视图
y[0] = -1
print(x)
# [-1 2 3 4 5 6 7 8]
print(y)
# [-1 2 3 4 5 6 7 8]
'''
此处改变视图y，原数组x也随之改变
可理解为x和y同指向同一缓冲区，对
任一个数组中的元素进行修改都会引
起缓冲区内容的改变。
'''
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x.copy() # 创建副本
y[0] = -1
print(x)
# [1 2 3 4 5 6 7 8]
print(y)
# [-1 2 3 4 5 6 7 8]
'''
此处改变副本y，原数组x不变。承接之
前的思路：x和y指向不同的缓冲区，只
在创建副本时内容一致，在程序操作中
改变一者，另一者不受影响。
'''数组切片操作返回的对象只是原数组的视图。
import numpy as np
x = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
[31, 32, 33, 34, 35]])
y = x
y[::2, :3:2] = -1
print(x)
# [[-1 12 -1 14 15]
# [16 17 18 19 20]
# [-1 22 -1 24 25]
# [26 27 28 29 30]
# [-1 32 -1 34 35]]
print(y)
# [[-1 12 -1 14 15]
# [16 17 18 19 20]
# [-1 22 -1 24 25]
# [26 27 28 29 30]
# [-1 32 -1 34 35]]
x = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
[31, 32, 33, 34, 35]])
y = x.copy()
y[::2, :3:2] = -1
print(x)
# [[11 12 13 14 15]
# [16 17 18 19 20]
# [21 22 23 24 25]
# [26 27 28 29 30]
# [31 32 33 34 35]]
print(y)
# [[-1 12 -1 14 15]
# [16 17 18 19 20]
# [-1 22 -1 24 25]
# [26 27 28 29 30]
# [-1 32 -1 34 35]]2、索引与切片
数组索引机制指的是用方括号（ [ ] ）加序号的形式引用单个数组元素，它的用处很多，比如抽取元素，选取数组的几个元素，甚至为其赋一个新值。类似字符串和列表中的索引操作。
1）整数索引
要获取数组的单个元素，指定元素的索引即可。
import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
print(x[2]) # 3
x = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
[31, 32, 33, 34, 35]])
print(x[2]) # [21 22 23 24 25]
print(x[2][1]) # 22
print(x[2, 1]) # 222）切片索引
切片操作是指抽取数组的一部分元素生成新数组。对 python 列表进行切片操作得到的数组是原数组的副本，而对Numpy数据进行切片操作得到的数组则是指向相同缓冲区的视图。
如果想抽取（或查看）数组的一部分，必须使用切片语法，也就是，把几个用冒号（ `start:stop:step` ）隔开的数字置于方括号内。
为了更好地理解切片语法，还应该了解不明确指明起始和结束位置的情况。如省去第一个数字，numpy 会认为第一个数字是0；如省去第二个数字，numpy 则会认为第二个数字是数组的最大索引值；如省去最后一个数字，它将会被理解为1，也就是抽取所有元素而不再考虑间隔。
对一维数组的切片
import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
print(x[0:2]) # [1 2]
#用下标1~5,以2为步长选取数组
print(x[1:5:2]) # [2 4]
print(x[2:]) # [3 4 5 6 7 8]
print(x[:2]) # [1 2]
print(x[-2:]) # [7 8]
print(x[:-2]) # [1 2 3 4 5 6]
print(x[:]) # [1 2 3 4 5 6 7 8]
#利用负数下标翻转数组
print(x[::-1]) # [8 7 6 5 4 3 2 1]对二维数组切片
import numpy as np
x = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
[31, 32, 33, 34, 35]])
print(x[0:2])
# [[11 12 13 14 15]
# [16 17 18 19 20]]
print(x[1:5:2])
# [[16 17 18 19 20]
# [26 27 28 29 30]]
print(x[2:])
# [[21 22 23 24 25]
# [26 27 28 29 30]
# [31 32 33 34 35]]
print(x[:2])
# [[11 12 13 14 15]
# [16 17 18 19 20]]
print(x[-2:])
# [[26 27 28 29 30]
# [31 32 33 34 35]]
print(x[:-2])
# [[11 12 13 14 15]
# [16 17 18 19 20]
# [21 22 23 24 25]]
print(x[:])
# [[11 12 13 14 15]
# [16 17 18 19 20]
# [21 22 23 24 25]
# [26 27 28 29 30]
# [31 32 33 34 35]]
print(x[2, :]) # [21 22 23 24 25]
print(x[:, 2]) # [13 18 23 28 33]
print(x[0, 1:4]) # [12 13 14]
print(x[1:4, 0]) # [16 21 26]
print(x[1:3, 2:4])
# [[18 19]
# [23 24]]
print(x[:, :])
# [[11 12 13 14 15]
# [16 17 18 19 20]
# [21 22 23 24 25]
# [26 27 28 29 30]
# [31 32 33 34 35]]
print(x[::2, ::2])
# [[11 13 15]
# [21 23 25]
# [31 33 35]]
print(x[::-1, :])
# [[31 32 33 34 35]
# [26 27 28 29 30]
# [21 22 23 24 25]
# [16 17 18 19 20]
# [11 12 13 14 15]]
print(x[:, ::-1])
# [[15 14 13 12 11]
# [20 19 18 17 16]
# [25 24 23 22 21]
# [30 29 28 27 26]
# [35 34 33 32 31]]
x[0::2, 1::3] = 0
print(x)
# [[11 0 13 14 0]
# [16 17 18 19 20]
# [21 0 23 24 0]
# [26 27 28 29 30]
# [31 0 33 34 0]]通过对每个以逗号分隔的维度执行单独的切片，你可以对多维数组进行切片。因此，对于二维数组，我们的第一片定义了行的切片，第二片定义了列的切片。
task03---数组的操作
1）更改形状
在对数组进行操作时，为了满足格式和计算的要求通常会改变其形状。
`numpy.ndarray.shape`
表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 `ndim` 属性(秩)。
import numpy as np
x = np.array([1, 2, 9, 4, 5, 6, 7, 8])
print(x.shape) # (8,)
x.shape = [2, 4]
print(x)
# [[1 2 9 4]
# [5 6 7 8]]`numpy.ndarray.flat`
将数组转换为一维的迭代器，可以用for访问数组每一个元素。
import numpy as np
x = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
[31, 32, 33, 34, 35]])
y = x.flat
print(y)
# <numpy.flatiter object at 0x0000020F9BA10C60>
for i in y:
print(i, end=' ')
# 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
y[3] = 0
print(end='\n')
print(x)
# [[11 12 13 0 15]
# [16 17 18 19 20]
# [21 22 23 24 25]
# [26 27 28 29 30]
# [31 32 33 34 35]]忽然发现在对x进行.flat函数处理后，y内保存的地址在经过for循环打印输出一次之后无法再次实现打印输出。缘由目前我还不是很清楚。需要向其他大佬请教一下，回头解释。
`numpy.ndarray.flatten([order='C'])`
将数组的副本转换为一维数组，并返回。
- ndarray.flatten(order='C')
- Return a copy of the array collapsed into one dimension.
Parameters: order : {‘C’, ‘F’, ‘A’, ‘K’}, optional
‘C’ means to flatten in row-major (C-style) order. ‘F’ means to flatten in column-major (Fortran- style) order. ‘A’ means to flatten in column-major order if a is Fortran contiguous in memory, row-major order otherwise. ‘K’ means to flatten a in the order the elements occur in memory. The default is ‘C’.
Returns: A copy of the input array, flattened to one dimension
.
x = np.random.randint(1,100,[5,1,5])
print(x)
y = x.flatten()
print(y)
'''
[[[86 89 92 24 55]]
[[35 75 94 54 92]]
[[51 52 62 92 50]]
[[23 81 77 57 88]]
[[16 69 74 25 9]]]
[86 89 92 24 55 35 75 94 54 92 51 52 62 92 50 23 81 77 57 88 16 69 74 25
9]
'''
y[3] = 0
print(x)
'''
[[[86 89 92 24 55]]
[[35 75 94 54 92]]
[[51 52 62 92 50]]
[[23 81 77 57 88]]
[[16 69 74 25 9]]]
'''
y = x.flatten(order='F')
print(y)
'''
[86 35 51 23 16 89 75 52 81 69 92 94 62 77 74 24 54 92 57 25 55 92 50 88
9]
'''`numpy.ravel(a, order='C')`
- Return a contiguous flattened array.
- order='C'时返回的是视图；
- order=’F‘ 时是拷贝。
y = x.ravel()
print(y)
y[3] = 0
print(x)
'''
[86 89 92 24 55 35 75 94 54 92 51 52 62 92 50 23 81 77 57 88 16 69 74 25
9]
[[[86 89 92 0 55]]
[[35 75 94 54 92]]
[[51 52 62 92 50]]
[[23 81 77 57 88]]
[[16 69 74 25 9]]]
'''
y = x.ravel(order='F')
print(y)
y[1] = 0
print(x)
'''
[86 35 51 23 16 89 75 52 81 69 92 94 62 77 74 0 54 92 57 25 55 92 50 88
9]
[[[86 89 92 0 55]]
[[35 75 94 54 92]]
[[51 52 62 92 50]]
[[23 81 77 57 88]]
[[16 69 74 25 9]]]
'''`numpy.reshape(a, newshape[, order='C'])`
- 在不更改数据的情况下为数组赋予新的形状。
`reshape()`函数当参数`newshape = [rows,-1]`时，将根据行数自动确定列数。
x = np.arange(10)
y = np.reshape(x,[2,5])
print(y.dtype)
print(y)
#int32
#[[0 1 2 3 4]
# [5 6 7 8 9]]
y = np.reshape(x,[2,-1])
print(y)
#[[0 1 2 3 4]
# [5 6 7 8 9]]
y = np.reshape(x,[-1,2])
print(y)
#[[0 1]
# [2 3]
# [4 5]
# [6 7]
# [8 9]]
y[0,0] = 10
print(x)
#[10 1 2 3 4 5 6 7 8 9]（改变x去reshape后y中的值，x对应元素也改变）`reshape()`函数当参数`newshape = -1`时，表示将数组降为一维。
x = np.random.randint(1,100,[2,2,3])
print(x)
y = np.reshape(x,-1)
print(y)
#[[[47 76 25]
# [52 66 34]]
#
# [[29 76 56]
# [25 67 60]]]
#[47 76 25 52 66 34 29 76 56 25 67 60]2）更改维度
`numpy.newaxis = None`
- `None`的别名，对索引数组很有用。
很多工具包在进行计算时都会先判断输入数据的维度是否满足要求，如果输入数据达不到指定的维度时，可以使用`newaxis`参数来增加一个维度。
x = np.array([1,2,3,4,5,6,7,8,9])
print(x.shape)
print(x)
#(9,)
#[1 2 3 4 5 6 7 8 9]
y = x[np.newaxis,:]
print(y.shape)
print(y)
#(1, 9)
#[[1 2 3 4 5 6 7 8 9]]
y = x[:,np.newaxis]
print(y.shape)
print(y)
#(9, 1)
#[[1]
# [2]
# [3]
# [4]
# [5]
# [6]
# [7]
# [8]
# [9]]`numpy.squeeze(a, axis=None)`
- `a`表示输入的数组；
- `axis`用于指定需要删除的维度，但是指定的维度必须为单维度，否则将会报错
import numpy as np
x = np.arange(10)
print(x.shape)
#(10,)
x = x[np.newaxis,:]
print(x.shape)
#(1, 10)
x = np.squeeze(x)
print(x.shape)
#(10,)
x = np.random.randint(0,100,(1,3,5,1,7))
print(x.shape)
#(1, 3, 5, 1, 7)
y = np.squeeze(x)
print(y.shape)
#(3, 5, 7)
y = np.squeeze(x,0)
print(y.shape)
#(3, 5, 1, 7)
y = np.squeeze(x,1)
#ValueError: cannot select an axis to squeeze out which has size not equal to one在机器学习和深度学习中，通常算法的结果是可以表示向量的数组（即包含两对或以上的方括号形式[[]]），如果直接利用这个数组进行画图可能显示界面为空（见后面的示例）。我们可以利用`squeeze()`函数将表示向量的数组转换为秩为1的数组，这样利用 matplotlib 库函数画图时，就可以正常的显示结果了。
import matplotlib.pyplot as plt
x = np.array([[1,1,2,3,5,8,13,21]])
print(x.shape)
plt.plot(x)
plt.show()(1, 8)
x = np.squeeze(x)
print(x.shape)
plt.plot(x)
plt.show()(8,)
3）数组组合
`numpy.concatenate((a1, a2, ...), axis=0, out=None)`
- Join a sequence of arrays along an existing axis.
x = np.array([1,2,3,4])
y = np.array([2,3,4,5])
z = np.concatenate([x,y])
print(z)
#[1 2 3 4 2 3 4 5]
# x,y是二维的，拼接后的结果也是二维的。
x = x.reshape(1,4)
y = y.reshape(1,4)
z = np.concatenate([x,y])
print(z)
#[[1 2 3 4]
# [2 3 4 5]]
z = np.concatenate([x,y],axis=0)
print(z)
#[[1 2 3 4]
# [2 3 4 5]]
z = np.concatenate([x,y],axis=1)
print(z)
#[[1 2 3 4 2 3 4 5]]
`numpy.stack(arrays, axis=0, out=None)`
- Join a sequence of arrays along a new axis.
x = np.array([1,2,3,4])
y = np.array([2,3,4,5])
z = np.stack([x,y])
print(z.shape)
print(z)
#(2, 4)
#[[1 2 3 4]
# [2 3 4 5]]
z = np.stack([x,y],axis=0)
print(z.shape)
print(z)
#(2, 4)
#[[1 2 3 4]
# [2 3 4 5]]
z = np.stack([x,y],axis=1)
print(z.shape)
print(z)
#(4, 2)
#[[1 2]
# [2 3]
# [3 4]
# [4 5]]
x = x.reshape(1,4)
y = y.reshape(1,4)
z = np.stack([x,y])
print(z.shape)
print(z)
#(2, 1, 4)
#[[[1 2 3 4]]
#
# [[2 3 4 5]]]
z = np.stack([x,y],axis=0)
print(z.shape)
print(z)
#(2, 1, 4)
#[[[1 2 3 4]]
#
# [[2 3 4 5]]]
z = np.stack([x,y],axis=1)
print(z.shape)
print(z)
#(1, 2, 4)
#[[[1 2 3 4]
# [2 3 4 5]]]`numpy.hstack(tup)`
- Stack arrays in sequence horizontally (column wise).
操作数.ndim > 1时等价于np.concatenate((a1, a2, ...), axis=1), 操作数.ndim = 1时则可视作np.concatenate((a1, a2, ...), axis=0)
注：操作数为一维数组时.hstack并不完全等价于.concatenate
a = np.hstack([np.array([1, 2, 3, 4]), 5])
print(a)
# [1 2 3 4 5]
a = np.concatenate([np.array([1, 2, 3, 4]), 5])
print(a)
# all the input arrays must have same number of dimensions, but the array at index 0 has 1 dimension(s) and the array at index 1 has 0 dimension(s)`numpy.vstack(tup)`
- Stack arrays in sequence vertically (row wise).
操作数.ndim > 1时等价于np.concatenate((a1, a2, ...), axis=1),操作数.ndim =1时等价于np.stack(arrays, axis=0, out=None)
x = np.array([1,2,3])
y = np.array([4,5,6])
z = np.vstack([x,y])
print(z)
#[[1 2 3]
# [4 5 6]]
z = np.stack([x,y])
print(z)
#[[1 2 3]
# [4 5 6]]
x = np.random.randint(0,10,(3,3))
y = np.random.randint(0,10,(3,3))
print(x)
print(y)
#[[8 8 0]
# [4 2 6]
# [3 0 7]]
#[[0 0 1]
# [4 0 0]
# [0 3 1]]
z = np.vstack([x,y])
print(z)
#[[8 8 0]
# [4 2 6]
# [3 0 7]
# [0 0 1]
# [4 0 0]
# [0 3 1]]
z = np.concatenate([x,y])
print(z)
#[[8 8 0]
# [4 2 6]
# [3 0 7]
# [0 0 1]
# [4 0 0]
# [0 3 1]]4）数组拆分
`numpy.split(ary, indices_or_sections, axis=0)`
- Split an array into multiple sub-arrays as views into ary.
x = np.arange(12,24).reshape(3,-1)
print(x)
#[[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]
#indices_or_sections=a 为实数时，数组沿着axis=0轴均分成a段，不能均分时报错
y = np.split(x,3)
print(y)
#[array([[12, 13, 14, 15]]), array([[16, 17, 18, 19]]), array([[20, 21, 22, 23]])]
y = np.split(x,2)
#ValueError: array split does not result in an equal division
#indices_or_sections=a[a1,a2,...] 为一维数组时，数组沿着axis=0轴按照 [:a1],[a1,a2],[a2:]切割为片段，若数组中实数超过axis=0轴上的最大索引，生产空数组片段。
y = np.split(x,[1,3])
print(y)
#[array([[12, 13, 14, 15]]), array([[16, 17, 18, 19],
# [20, 21, 22, 23]]), array([], shape=(0, 4), dtype=int32)]
y = np.split(x,[1,3],axis=1)
print(y)
#[array([[12],
# [16],
# [20]]), array([[13, 14],
# [17, 18],
# [21, 22]]), array([[15],
# [19],
# [23]])]
`numpy.vsplit(ary, indices_or_sections)`
- Split an array into multiple sub-arrays vertically (row-wise).
#.vsplit等价于参数axis=0的.split函数
x = np.arange(12,24).reshape(3,-1)
print(x)
#[[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]
z = np.vsplit(x,3)
print(z)
#[array([[12, 13, 14, 15]]), array([[16, 17, 18, 19]]), array([[20, 21, 22, 23]])]
z = np.split(x,3)
print(z)
#[array([[12, 13, 14, 15]]), array([[16, 17, 18, 19]]), array([[20, 21, 22, 23]])]
z = np.vsplit(x,[1,3])
print(z)
#[array([[12, 13, 14, 15]]), array([[16, 17, 18, 19],
# [20, 21, 22, 23]]), array([], shape=(0, 4), dtype=int32)]
= np.split(x,[1,3])
print(z)
#[array([[12, 13, 14, 15]]), array([[16, 17, 18, 19],
# [20, 21, 22, 23]]), array([], shape=(0, 4), dtype=int32)]`numpy.hsplit(ary, indices_or_sections)`
- Split an array into multiple sub-arrays horizontally (column-wise).
#.hsplit等价于参数axis=1的.split函数
x = np.arange(12,24).reshape(3,-1)
print(x)
#[[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]
z = np.hsplit(x,3)
print(z)
#[array([[12, 13],
# [16, 17],
# [20, 21]]), array([[14, 15],
# [18, 19],
# [22, 23]])]
z = np.hsplit(x,[1,3])
print(z)
#[array([[12],
# [16],
# [20]]), array([[13, 14],
# [17, 18],
# [21, 22]]), array([[15],
# [19],
# [23]])]
z = np.split(x,[1,3],axis=1)
print(z)
#[array([[12],
# [16],
# [20]]), array([[13, 14],
# [17, 18],
# [21, 22]]), array([[15],
# [19],
# [23]])]
5）数组展平
`numpy.tile(A, reps)`
- Construct an array by repeating A the number of times given by reps.
- 'tile'是平铺或并列显示的意思
#将原矩阵横向、纵向地复制
x = np.array([[1,2],[3,4]])
print(x)
#[[1 2]
# [3 4]]
y = np.tile(x,(1,3))
print(y)
#[[1 2 1 2 1 2]
# [3 4 3 4 3 4]]
y = np.tile(x,(3,1))
print(y)
#[[1 2]
# [3 4]
# [1 2]
# [3 4]
# [1 2]
# [3 4]]
y = np.tile(x,(3,3))
print(y)
#[[1 2 1 2 1 2]
# [3 4 3 4 3 4]
# [1 2 1 2 1 2]
# [3 4 3 4 3 4]
# [1 2 1 2 1 2]
# [3 4 3 4 3 4]]`numpy.repeat(a, repeats, axis=None)`
- Repeat elements of an array.
- `axis=0`，沿着y轴复制，实际上增加了行数。
- `axis=1`，沿着x轴复制，实际上增加了列数。
- `repeats`，可以为一个数，也可以为一个矩阵。
- `axis=None`时就会flatten当前矩阵，实际上就是变成了一个行向量。
x = np.repeat(3,4)
print(x)
#[3 3 3 3]
x = np.array([[1,2],[3,4]])
print(x)
#[[1 2]
# [3 4]]
y = np.repeat(x,2)
print(y)
#[1 1 2 2 3 3 4 4]
y = np.repeat(x,2,axis=0)
print(y)
#[[1 2]
# [1 2]
# [3 4]
# [3 4]]
y = np.repeat(x,2,axis=1)
print(y)
#[[1 1 2 2]
# [3 3 4 4]]
y = np.repeat(x,[2,3],axis=0)
print(y)
#[[1 2]
# [1 2]
# [3 4]
# [3 4]
# [3 4]]
y = np.repeat(x,[2,3],axis=1)
print(y)
#[[1 1 2 2 2]
# [3 3 4 4 4]]6)添加和删除元素
numpy.insert(arr, obj, values, axis=None)
#参数axis为默认值时会将arr展平后进行insert操作
x = np.array([[1,2],[3,4]])
print(x)
#[[1 2]
# [3 4]]
y = np.insert(x,2,5)
print(y)
#[1 2 5 3 4]
#参数values与arr中的元素数据类型不同时，values会自动转换为arr中元素的类型
y = np.insert(x,2,5.0)
print(y)
#[1 2 5 3 4]
#multiple insertionns
y = np.insert(x,[2,3],5)
print(y)
#[1 2 5 3 5 4]
y = np.insert(x,[1,2],[5,6],axis=0)
print(y)
#[[1 2]
# [5 6]
# [3 4]
# [5 6]]
y = np.insert(x,[1,2],[5,6],axis=1)
print(y)
#[[1 5 2 6]
# [3 5 4 6]]numpy.delete(arr, obj, axis=None)
#参数axis为默认值时会将arr展平后进行delete操作
x = np.array([[1,2],[3,4]])
print(x)
#[[1 2]
# [3 4]]
y = np.delete(x,1)
print(y)
#[1 3 4]
y = np.delete(x,(1,2))
print(y)
#[1 4]
y = np.delete(x,1,axis=0)
print(y)
#[[1 2]]
y = np.delete(x,1,axis=1)
print(y)
#[[1]
# [3]]7)查找元素
`numpy.unique(ar, return_index=False, return_inverse=False,return_counts=False, axis=None)`
- Find the unique elements of an array.
- return_index：the indices of the input array that give the unique values
- return_inverse：the indices of the unique array that reconstruct the input array
- return_counts：the number of times each unique value comes up in the input array
a=np.array([1,1,2,3,3,4,4])
b=np.unique(a)
print(b)
#[1 2 3 4]
b = np.unique(a,return_index=True)
print(b)
#(array([1, 2, 3, 4]), array([0, 2, 3, 5], dtype=int64))
b = np.unique(a,return_inverse=True)
print(b)
#(array([1, 2, 3, 4]), array([0, 0, 1, 2, 2, 3, 3], dtype=int64))
b = np.unique(a,return_counts=True)
print(b)
#(array([1, 2, 3, 4]), array([2, 1, 2, 2], dtype=int64))
373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
