一、复习切片和索引、广播机制
1.切片和索引
ndarray 数组可以基于 0 - n 的下标进行索引;通过冒号分隔切片参数 start:stop:step 来进行切片操作。
b = a[2:7:2] # 从索引 2 开始到索引 7 停止,间隔为 2
冒号 : 的解释:如果只放置一个参数,如 [2],将返回与该索引相对应的单个元素。如果为 [2:],表示从该索引开始以后的所有项都将被提取。如果使用了两个参数,如 [2:7],那么则提取两个索引(不包括停止索引)之间的项。
还有高级索引:1.整数数组索引y = x[[0,1,2], [0,1,0]] #获取数组中(0,0),(1,1)和(2,0)位置处的元素
2.布尔索引x[x > 5] #获取大于 5 的元素
3.花式索引:和整数索引差不多。
2.广播
广播规则:对两个数组,分别比较他们的每一个维度(若其中一个数组没有当前维度则忽略),满足:
数组拥有相同形状。
当前维度的值相等。
当前维度的值有一个是 1。
二、学习新知识
1.Numpy数组操作
1.1 修改数组形状
numpy.reshape()
numpy.reshape(arr, newshape, order=‘C’)
arr:要修改形状的数组
newshape:整数或者整数数组,新的形状应当兼容原有形状
order:'C' -- 按行,'F' -- 按列,'A' -- 原顺序,'k' -- 元素在内存中的出现顺序。
a = np.arange(8)
print ('原始数组:')
print (a)
print ('\n')
b = a.reshape(4,2)
print ('修改后的数组:')
print (b)
输出:
原始数组:
[0 1 2 3 4 5 6 7]
修改后的数组:
[[0 1]
[2 3]
[4 5]
[6 7]]
numpy.ndarray.flat
numpy.ndarray.flat是一个数组元素迭代器
实例:
新建一个数组:
a = np.arange(24).reshape(4,6)
print(a)
输出:
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
迭代
for item in a.flat:
print(item)
输出:
6
7
8
9
10
11
0
1
2
3
4
5
12
13
14
15
16
17
18
19
20
21
22
23
也可以:
for i in range(a.size):
print(a.flat[i])
或者:
for item in items:
print(item)
numpy.ndarray.flatten ()
numpy.ndarray.flatten()返回一份数组拷贝,对拷贝所做的修改不会影响原始数组,
ndarray.flatten(order=‘C’)
例:
a = np.arange(24).reshape(4,6)
a2 = a.flatten()
print(a2)
print(a2.ndim)
print(id(a),id(a2))
输出:
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
1
1821482336496 1821482338512
指定顺序:
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'))
输出:
原数组:
[[0 1 2 3]
[4 5 6 7]]
展开的数组:
[0 1 2 3 4 5 6 7]
以 F 风格顺序展开的数组:
[0 4 1 5 2 6 3 7]
numpy.ravel()
numpy.ravel() 展平数组元素,顺序通常是"C风格",返回的是数组视图,修改会影响原始数组。
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'))
输出:
原数组:
[[0 1 2 3]
[4 5 6 7]]
调用 ravel 函数之后:
[0 1 2 3 4 5 6 7]
以 F 风格顺序调用 ravel 函数之后:
[0 4 1 5 2 6 3 7]
区别
a = np.arange(8).reshape(2,4)
a.flatten()[1] = 99
print(a)
a.ravel()[1] = 100
print(a)
输出:
[[0 1 2 3]
[4 5 6 7]] #a没变
[[ 0 100 2 3]
[ 4 5 6 7]] #a变了
1.2 翻转数组
numpy.transpose()
numpy.transpose() 函数用于对换数组的维度,numpy.transpose(arr, axes)
参数说明:
arr:要操作的数组
axes:整数列表,对应维度,通常所有维度都会对换。
a = np.arange(24).reshape(4,6)
print(a)
np.transpose(a,axes=(1,0))
输出:
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
array([[ 6, 0, 12, 18],
[ 7, 1, 13, 19],
[ 8, 2, 14, 20],
[ 9, 3, 15, 21],
[10, 4, 16, 22],
[11, 5, 17, 23]])
numpy.ndarray.T 类似 numpy.transpose:a.T
输出:
array([[ 6, 0, 12, 18],
[ 7, 1, 13, 19],
[ 8, 2, 14, 20],
[ 9, 3, 15, 21],
[10, 4, 16, 22],
[11, 5, 17, 23]])
numpy.rollaxis()
numpy.rollaxis() 函数向后滚动特定的轴到一个特定位置numpy.rollaxis(arr, axis, start)
参数说明:
arr:数组
axis:要向后滚动的轴,其它轴的相对位置不会改变
start:默认为零,表示完整的滚动。会滚动到特定位置。
a = np.arange(8).reshape(2,2,2)
print ('原数组:',a)
# 将轴 2 滚动到轴 0(宽度到深度)
b = np.rollaxis(a,2,0)
print ('调用 rollaxis 函数:\n',b)
# 将轴 2 滚动到轴 1:(宽度到高度)
c = np.rollaxis(a,2,1)
print ('调用 rollaxis 函数:\n',c)
输出:
np.rollaxis(a, 2,0)
,轴2滚动到了轴0前面,其他轴相对2轴位置不变(start默认0),数组下标排序由0,1,2变成了1,2,0,按列分块
同样,np.rollaxis(a,2,1)
,数组下标排序由0,1,2变成了0,1,2,
输出:
原数组: [[[0 1]
[2 3]]
[[4 5]
[6 7]]]
调用 rollaxis 函数:
[[[0 2]
[4 6]]
[[1 3]
[5 7]]]
调用 rollaxis 函数:
[[[0 2]
[1 3]]
[[4 6]
[5 7]]]
numpy.swapaxes()
numpy.swapaxes ()函数用于交换数组的两个轴numpy.swapaxes(arr, axis1, axis2)
arr:输入的数组
axis1:对应第一个轴的整数
axis2:对应第二个轴的整数
例:
# 创建了三维的 ndarray
a = np.arange(8).reshape(2,2,2)
print ('原数组:')
print (a)
print ('\n')
# 现在交换轴 0(深度方向)到轴 2(宽度方向)
print ('调用 swapaxes 函数后的数组:')
print (np.swapaxes(a, 2, 0))
输出:
原数组:
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
调用 swapaxes 函数后的数组:
[[[0 4]
[2 6]]
[[1 5]
[3 7]]]
与transpose相比:transpose可以同时交换3个轴,swapaxes只能交换两个轴,比如:
a = np.arange(8).reshape(2,2,2)
a.transpose(2,1,0)
1.3 连接数组
numpy.concatenate()
numpy.concatenate() 函数用于沿指定轴连接相同形状的两个或多个数组numpy.concatenate((a1, a2, ...), axis)
参数说明:
a1, a2, ...:相同类型的数组
axis:沿着它连接数组的轴,默认为 0
按行拼接:
a = np.arange(24).reshape(4,6)
a2 = np.arange(24).reshape(4,6)
np.concatenate((a,a2))
输出:
array([[ 6, 7, 8, 9, 10, 11],
[ 0, 1, 2, 3, 4, 5],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23],
[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23]])
按列拼接:
np.concatenate((a,a2),axis=1)
输出:
array([[ 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5],
[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17, 12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23, 18, 19, 20, 21, 22, 23]])
numpy.stack()
numpy.stack() 函数用于沿新轴连接数组序列numpy.stack(arrays, axis)
参数说明:
arrays相同形状的数组序列
axis:返回数组中的轴,输入数组沿着它来堆叠
np.stack((a,a2))
输出:
array([[[ 6, 7, 8, 9, 10, 11],
[ 0, 1, 2, 3, 4, 5],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23]],
[[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23]]])
按列:
np.column_stack((a,a2))
输出:
array([[ 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5],
[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17, 12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23, 18, 19, 20, 21, 22, 23]])
按行:
np.row_stack((a,a2))
输出:
array([[ 6, 7, 8, 9, 10, 11],
[ 0, 1, 2, 3, 4, 5],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23],
[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23]])
numpy.hstack():numpy.hstack 是 numpy.stack 函数的变体,它通过水平堆叠来生成数组。
numpy.vstack():numpy.vstack 是 numpy.stack 函数的变体,它通过垂直堆叠来生成数组。
np.dstack:沿深度堆叠
np.dstack((a,a2))
输出:
array([[[ 6, 0],
[ 7, 1],
[ 8, 2],
[ 9, 3],
[10, 4],
[11, 5]],
[[ 0, 6],
[ 1, 7],
[ 2, 8],
[ 3, 9],
[ 4, 10],
[ 5, 11]],
[[12, 12],
[13, 13],
[14, 14],
[15, 15],
[16, 16],
[17, 17]],
[[18, 18],
[19, 19],
[20, 20],
[21, 21],
[22, 22],
[23, 23]]])
1.4分割数组
numpy.split()
numpy.split() 函数沿特定的轴将数组分割为子数组numpy.split(ary, indices_or_sections, axis)
参数说明:
ary:被分割的数组
indices_or_sections:如果是一个整数,就用该数平均切分,如果是一个数组,为沿轴切分的位置(左开右闭)
axis:设置沿着哪个方向进行切分,默认为 0,横向切分,即水平方向。为 1 时,纵向切分,即竖直方向。
例:
print ('\n')
print ('将数组分为三个大小相等的子数组:')
b = np.split(a,3)
print (b)
print ('\n')
print ('将数组在一维数组中表明的位置分割:')
b = np.split(a,[4,7])
print (b)
输出:
第一个数组:
[0 1 2 3 4 5 6 7 8]
将数组分为三个大小相等的子数组:
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
将数组在一维数组中表明的位置分割:
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
axis 为 0 时在水平方向分割,axis 为 1 时在垂直方向分割。
numpy.hsplit()
numpy.hsplit 函数用于水平分割数组,通过指定要返回的相同形状的数组数量来拆分原数组。
a = np.arange(24).reshape(4,6)
np.hsplit(a,2)
输出:
[array([[ 6, 7, 8],
[ 0, 1, 2],
[12, 13, 14],
[18, 19, 20]]),
array([[ 9, 10, 11],
[ 3, 4, 5],
[15, 16, 17],
[21, 22, 23]])]
numpy.vsplit() :垂直分割
例:
a4,a3,a2,a1 = np.vsplit(a,4)
a4
输出:
array([[ 6, 7, 8, 9, 10, 11]])
a3
输出:
array([[0, 1, 2, 3, 4, 5]])
dsplit():
a2 = np.arange(24).reshape(4,6)
a_13 = np.dstack((a,a2))
np.dsplit(a_13,2)
输出:
[array([[[ 6],
[ 7],
[ 8],
[ 9],
[10],
[11]],
[[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5]],
[[12],
[13],
[14],
[15],
[16],
[17]],
[[18],
[19],
[20],
[21],
[22],
[23]]]),
array([[[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5]],
[[ 6],
[ 7],
[ 8],
[ 9],
[10],
[11]],
[[12],
[13],
[14],
[15],
[16],
[17]],
[[18],
[19],
[20],
[21],
[22],
[23]]])]
a_14,a_15 = np.dsplit(a_13,2)
print(a_14.shape)
print(a_14.ndim)
输出:
(4, 6, 1)
3
1.5数组元素的添加与删除
numpy.append()
numpy.append ()函数在数组的末尾添加值。 追加操作会分配整个数组,并把原来的数组复制到新数组中。 此外,输入数组的维度必须匹配否则将生成ValueError。numpy.append(arr, values, axis=None)
参数说明:
arr:输入数组
values:要向arr添加的值,需要和arr形状相同(除了要添加的轴)
axis:默认为 None。当axis无定义时,是横向加成,返回总是为一维数组!当axis有定义的时候,分别为0和1的时候。当axis有定义的时候,分别为0和1的时候(列数要相同)。当axis为1时,数组是加在右边(行数要相同)。
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))
输出:
第一个数组:
[[1 2 3]
[4 5 6]]
向数组添加元素:
[1 2 3 4 5 6 7 8 9]
沿轴 0 添加元素:
[[1 2 3]
[4 5 6]
[7 8 9]]
沿轴 1 添加元素:
[[1 2 3 5 5 5]
[4 5 6 7 8 9]]
numpy.insert()
numpy.insert ()函数在给定索引之前,沿给定轴在输入数组中插入值。
如果值的类型转换为要插入,则它与输入数组不同。 插入没有原地的,函数会返回一个新数组。 此外,如果未提供轴,则输入数组会被展开。
numpy.insert(arr, obj, values, axis)
参数说明:
arr:输入数组
obj:在其之前插入值的索引
values:要插入的值
axis:沿着它插入的轴,如果未提供,则输入数组会被展开
此外,输入数组的维度必须匹配。
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))
输出:
第一个数组:
[[1 2]
[3 4]
[5 6]]
未传递 Axis 参数。 在删除之前输入数组会被展开。
[ 1 2 3 11 12 4 5 6]
传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播:
[[ 1 2]
[11 11]
[ 3 4]
[ 5 6]]
沿轴 1 广播:
[[ 1 11 2]
[ 3 11 4]
[ 5 11 6]]
numpy.delete()
numpy.delete ()函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样,如果未提供轴参数,则输入数组将展开。Numpy.delete(arr, obj, axis)
参数说明:
arr:输入数组
obj:可以被切片,整数或者整数数组,表明要从输入数组删除的子数组
axis:沿着它删除给定子数组的轴,如果未提供,则输入数组会被展开
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]))
输出:
第一个数组:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0 1 2 3 4 6 7 8 9 10 11]
删除第二列:
[[ 0 2 3]
[ 4 6 7]
[ 8 10 11]]
包含从数组中删除的替代值的切片:
[ 2 4 6 8 10]
打印 np.s_[::2]
,输出slice(None, None, 2)
相当于取 从0索引开始,步长为2的索引位置的数值。
numpy.unique()
numpy.unique() 函数用于去除数组中的重复元素。
numpy.unique(arr, return_index, return_inverse, return_counts)
参数说明:
arr:输入数组,如果不是一维数组则会展开
return_index:如果为true,返回新列表元素在旧列表中的位置(下标),并以列表形式储
return_inverse:如果为true,返回旧列表元素在新列表中的位置(下标),并以列表形式储
return_counts:如果为true,返回去重数组中的元素在原数组中的出现次数
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 ('去重的数组的索引:')
u,indices = np.unique(a,return_inverse = True)
print (u)
print ('\n')
print ('返回重复元素的重复数量:')
u,indices = np.unique(a,return_counts = True)
print (u)
print (indices)
输出:
第一个数组:
[5 2 6 2 7 5 6 8 2 9]
第一个数组的去重值:
[2 5 6 7 8 9]
去重之后数组的索引数组:
[1 0 2 4 7 9]
去重的数组的索引:
[2 5 6 7 8 9]
返回重复元素的重复数量:
[2 5 6 7 8 9]
[3 2 2 1 1 1]
2. NumPy 字符串函数
#### #### numpy.char.add()
numpy.char.add() 函数依次对两个数组的元素进行字符串连接。
print ('连接两个字符串:')
print (np.char.add(['hello'],[' xyz']))
print ('\n')
print ('连接示例:')
print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))
输出:
连接两个字符串:
['hello xyz']
连接示例:
['hello abc' 'hi xyz']
numpy.char.multiply()
numpy.char.multiply() 函数执行多重连接。
print (np.char.multiply('Runoob ',3))
输出:
Runoob Runoob Runoob
numpy.char.center()
numpy.char.center() 函数用于将字符串居中,并使用指定字符在左侧和右侧进行填充。np.char.center(str , width,fillchar)
# str: 字符串,width: 长度,fillchar: 填充字符
print (np.char.center('Runoob', 20,fillchar = '*'))
输出:
*******Runoob*******
numpy.char.capitalize()
numpy.char.capitalize() 函数将字符串的第一个字母转换为大写:print (np.char.capitalize('runoob'))
输出:
Runoob
numpy.char.title()
numpy.char.title() 函数将字符串的每个单词的第一个字母转换为大写:print (np.char.title('i like runoob'))
输出:
I Like Runoob
numpy.char.lower()
numpy.char.lower() 函数对数组的每个元素转换为小写。它对每个元素调用 str.lower。
#操作数组
print (np.char.lower(['RUNOOB','GOOGLE']))
# 操作字符串
print (np.char.lower('RUNOOB'))
输出:
['runoob' 'google']
runoob
numpy.char.upper()
numpy.char.upper() 函数对数组的每个元素转换为大写。它对每个元素调用 str.upper。
#操作数组
print (np.char.upper(['runoob','google']))
# 操作字符串
print (np.char.upper('runoob'))
输出:
['RUNOOB' 'GOOGLE']
RUNOOB
numpy.char.split()
numpy.char.split() 通过指定分隔符对字符串进行分割,并返回数组。默认情况下,分隔符为空格。
# 分隔符默认为空格
print (np.char.split ('i like runoob?'))
# 分隔符为 .
print (np.char.split ('www.runoob.com', sep = '.'))
输出:
输出结果为:
['i', 'like', 'runoob?']
['www', 'runoob', 'com']
numpy.char.splitlines()
numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串,并返回数组。
# 换行符 \n
print (np.char.splitlines('i\nlike runoob?'))
print (np.char.splitlines('i\rlike runoob?'))
输出:
['i', 'like runoob?']
['i', 'like runoob?']
numpy.char.strip()
numpy.char.strip() 函数用于移除开头或结尾处的特定字符。
# 移除字符串头尾的 a 字符
print (np.char.strip('ashok arunooba','a'))
# 移除数组元素头尾的 a 字符
print (np.char.strip(['arunooba','admin','java'],'a'))
输出:
shok arunoob
['runoob' 'dmin' 'jav']
numpy.char.join()
numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串
# 操作字符串
print (np.char.join(':','runoob'))
# 指定多个分隔符操作数组元素
print (np.char.join([':','-'],['runoob','google']))
输出:
r:u:n:o:o:b
['r:u:n:o:o:b' 'g-o-o-g-l-e']
numpy.char.replace()
numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。
print (np.char.replace ('i like runoob', 'oo', 'cc'))
输出:
i like runccb