Numpy 数组的创建、类型转换、数组切片、改变数组形态
目录
Numpy 数组对象ndarry
1 创建数组对象
1.1 np.array函数创建ndarray数组
ndarray类对象的常见属性
属 性 名 : 解 释 , 返 回 类 型 \color{red}{属性名:解释,返回类型} 属性名:解释,返回类型
- shape属性:形状,tuple
- size 属性: 元素个数 int
- ndim属性:维度, int
- dtypes属性: 元素数据类型, str
- itemsize 属性: 元素字节数 int
- T属性: 转置,ndarray
- 使用 np.array 创建数组
# 编程实例
import numpy as np
# (0)创建数组对象
ar_1d = np.array([1, 2, 3, 4]) # 参数是列表或者元组
print('\n(0.1)一维数组ar_1d:\n', ar_1d) # [1 2 3 4]
ar_2d = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]])
print('\n(0.2) 二维数组ar_2d:\n', ar_2d)
'''
[[ 1 2 3 4]
[ 4 5 6 7]
[ 7 8 9 10]]
'''
# (1) shape属性:形状,tuple
print("(1.1) ar_1d的形状属性值:", ar_1d.shape) # (1.1) ar_1d的形状属性值: (4,)
print("(1.2) ar_2d的形状属性值:", ar_2d.shape) # (1.2) ar_2d的形状属性值: (3, 4)
# (2)size 属性: 元素个数 int
print("\n(2.1) ar_1d的元素个数属性值:", ar_1d.size) # (2.1) ar_1d的元素个数属性值: 4
print("(2.2) ar_2d的元素个数属性值:", ar_2d.size) # (2.2) ar_2d的元素个数属性值: 12
# (3)ndim属性:维度, int
print("\n(3.1) ar_1d的维度属性值:", ar_1d.ndim) # (3.1) ar_1d的维度属性值: 1
print("(3.2) ar_2d的维度属性值:", ar_2d.ndim) # (3.2) ar_2d的维度属性值: 2
# (4)dtypes属性: 元素数据类型, str
print("\n(4.1) ar_1d的元素数据类型属性值:", ar_1d.dtype) # (4.1) ar_1d的元素数据类型属性值: int32
print("(4.2) ar_2d的元素数据类型属性值:", ar_2d.dtype) # (4.2) ar_2d的元素数据类型属性值: int32
# (5) itemsize 属性: 元素字节数 int
print("\n(5.1) ar_1d的元素字节数属性值:", ar_1d.itemsize) # (5.1) ar_1d的元素字节数属性值: 4
print("(5.2) ar_2d的元素字节数 属性值:", ar_2d.itemsize) # (5.2) ar_2d的元素字节数 属性值: 4
# (6)T属性: 转置,ndarray
print("\n(6.1) ar_1d的转置属性值:\n", ar_1d.T)
'''
(6.1) ar_1d的转置属性值:
[1 2 3 4]
'''
print("(6.1) ar_1d的转置属性值:\n", ar_2d.T)
'''
(6.1) ar_1d的转置属性值:
[[ 1 4 7]
[ 2 5 8]
[ 3 6 9]
[ 4 7 10]]
'''
ar_2d.shape=2,6
print(' 修改形状后的二维数组ar_2d:\n',ar_2d)
1.2 np.arange、np.linspace创建ndarray数组
- ① np.arange(起始位置,终止位置(不包括),步长)
- ② np.linspace(起始位置,终止位置(包含),显示的个数)
#编程实例
import numpy as np
print('(1).使用arange函数创建数组:',np.arange(0,1,0.1))
print('(2).使用linspace函数创建等差数组:',np.linspace(0,1,11))
a = np.arange(0, 1, 0.1) # [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
print(a[0]) # 0.0
print(a[1]) # 0.1
1.3 其他方法创建ndarray数组
① np.logspce 等比数列
起始指数, 最后一个数的指数 显示的个数
start, stop, num=50, endpoint=True, base=10.0, dtype=None,axis=0):
起始数, 倍数, 显示个数
a1=3, q=9, n=6
最后一个数 = a1*a1**(n-1) = 3 (11)
得出底数为3, base = 3, ze logx3 = a > 第一个为 1, 最后一个 11, 显示个数6
arr6 = np.logspace(1,11,6,base=3)
print(arr6)
[3.00000e+00 2.70000e+01 2.43000e+02 2.18700e+03 1.96830e+04 1.77147e+05]
② np.ones 全一数组
arr7 = np.ones((3,4))
print(arr7)
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
③ np.zeros 全 0 数组
arr8 = np.zeros((3,4))
print(arr7, arr8)
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
④ np.eye 单位数组
对角线为 1
arr9 = np.eye(3)
print(arr9)
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
⑤ np.diag 对角数组
arr10 = np.diag([1,2,3,4])
print(arr10)
[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]
⑥ np.random.random 0-1之间随机数组
在0-1之间产生随机数组
随机数组 random 随机100个数,数在0-1之间, 一维数组
arr11 = np.random.random(10)
print(arr11)
[0.94291171 0.37437134 0.95882402 0.53468268 0.61535727 0.99573457
0.40829533 0.54493658 0.26366464 0.30122991]
⑦ np.random.rand 均匀分布随机数组
每个区间内的随机数,出现的概率都均匀分布
arr12 = np.random.rand(10)
print(arr12)
[0.54421722 0.88963632 0.55908979 0.75682079 0.33739974 0.06608583
0.87322233 0.72741851 0.20770551 0.1719531 ]
⑧ np.random.randn 正态分布随机数组
在数轴中,会显示一个峰值,指定是数据出现的概率,峰值越高,概率则越高,临近0的位置概率越高
有正 有负
arr13 = np.random.randn(50)
print(arr13)
[ 1.26533955 -1.78556978 0.93679018 -0.44488995 2.71992622 2.23053563
-0.50636456 1.43736733 1.456863 -0.29957034 0.79827706 0.78054322
0.62672284 1.16400739 -0.7550562 -1.95943291 -1.17037617 1.53813303
-0.04651108 -0.763941 -0.62367491 0.69005622 1.11434205 -0.48368366
0.49187281 -0.10056911 -0.8721509 0.66926024 -0.2262314 -0.20382128
-1.60633907 1.08232747 0.9563421 -1.00991936 -0.15346309 0.80780588
-2.30794637 1.16900935 -0.10164755 -0.4816431 1.44266502 -0.97043795
1.50490985 -0.51082826 -1.84256456 0.80230763 0.56863096 2.22493269
-0.53022144 -1.22730517]
⑨ np.random.randint 随机整数的生成
最小值 最大值 显示的个数 不包含最大值
arr14 = np.random.randint(2, 8,size =[4,4])
print(arr14)
[[3 2 5 7]
[4 7 4 3]
[2 3 7 4]
[5 7 2 2]]
2 数组的数据类型及转换
2.1 创建指定类型数组
# 编程实例
import numpy as np
ar_int8 = np.array([1, -2, 3, -4], dtype='int8')
print("(1.0) arr1_int8数组:\n", ar_int8) # [ 1 -2 3 -4]
print("(1.1) ar_int8中数组元素的数据类型:", ar_int8.dtype) # int8
ar_uint8 = np.array([1, -2, 257, 4], dtype='uint8')
print("\n(2.0) ar_uint8数组:\n", ar_uint8) # [ 1 254 1 4]
print("(2.1) ar_uint8中数组元素的数据类型:", ar_uint8.dtype) # uint8
2.2 利用Numpy类型转换函数进行数组类型转换
# 编程实例
import numpy as np
ar_int8 = np.array([1, -2, 3, -4], dtype='int8')
ar_float32 = np.float32(ar_int8)
print("\n(1.0) ar_float32数组:\n", ar_float32) # [ 1. -2. 3. -4.]
print("\n(1.1) ar_float32中数组元素的数据类型:", ar_float32.dtype) # float32
3 生成随机数数组
3.1 random()函数生成服从0~1 之间均匀分布的一维或多维数组
-
np.random.random(5) 生成(几行几列) 0-1之间的随机数
-
np.random.randn()函数
-
语法:
-
np.random.randn(d0,d1,d2……dn)
-
当函数括号内没有参数时,则返回一个浮点数。
-
当函数括号内有一个参数时,则返回秩为1的数组,不能表示向量和矩阵。
-
当函数括号内有两个及以上参数时,则返回对应维度的数组,能表示向量或矩阵。
-
np.random.standard_normal()函数与np.random.randn()类似,但是np.random.standard_normal()的输入参数为元组(tuple)。
-
np.random.randn()的输入通常为整数,但是如果为浮点数,则会自动直接截断转换为整数。
-
-
作用:
- 通过本函数可以返回一个或一组服从标准正态分布的随机样本值。
-
特点:
标准正态分布是以0为均数、以1为标准差的正态分布,记为N(0,1)。
-
#编程实例
import numpy as np
ar_rdm_1=np.random.random(5)
ar_rdm_2=np.random.random(5)
ar_rdm_3=np.random.random([2,3])#创建多维数组时,必须用元组或列表作为参数
print("\n(1). ar_rdm_1数组:\n",ar_rdm_1)
print("\n(2). ar_rdm_2数组:\n",ar_rdm_2)
print("\n(3). ar_rdm_3数组:\n",ar_rdm_3)
print("\n(3). ar_rdm_3中数组元素的数据类型:",ar_rdm_1.dtype)
3.2. randint()函数生成给定上下范围的一维或多维随机数组
- np.random.randint 生成一个整数或N维整数数组,取数范围:若high不为None时,取[low,high)之间随机整数,否则取值[0,low)之间随机整数。左闭右开!!!
#编程实例
import numpy as np
ar_rdint = np.random.randint(2, 6, size=[2, 5])
print("\n(1). ar_rdint数组:\n", ar_rdint)
'''
[[2 5 5 3 4]
[5 5 2 4 2]]
'''
print("\n(2). ar_rdint中数组元素的数据类型:", ar_rdint.dtype) # int32
4 通过切片访问数组
4.1 一维数组切片
切片,指从数组的获取若干个元素,结果可能是单个元素(类型是元素类型,非数组类型),也可能是重新封装成一个新的数组。
(1)用单位置,结果是单个元素
- 格式 ndarray[单位置]
(2)用一组位置,结果是一维数组
- 格式 ndarray[位置区间/位置组合]
说明 :
位置区间写法: [i:j:k] ---- i:起始位置,j:结束位置(不包含),k:步长
位置组合写法:位置组成的list、ndarray, 不 可 用 t u p l e \color{red}{不可用tuple} 不可用tuple
名词解释:
1)一组位置:由任意个(0个、1个、多个)位置组成组合型数据,包括连续(均匀间隔)的位置区间
和任意(连续离散皆可)的位置组合。
2)位置区间:由连续(均匀间隔)的位置组成,[i:j:k] i表示区间起始位置,j表示区间终止位置(区间不含j),k指步长。
3)位置组合:由任意(连续离散皆可)的位置组成的组合型数据。
#编程实例
# (0)准备数据
import numpy as np
ar_1d = np.array([5, 6, 7, 8])
print('(0) 一维数组ar_1d为:', ar_1d)
# (1)用单位置,结果是单个元素
print('\n(1.1)一维数组ar_1d的第2个元素值为:', ar_1d[2]) # 引用 # 7
print('(1.2) 一维数组ar_1d的最后1个元素值为:', ar_1d[-1]) # 引用 # 8
# (2)用一组位置,结果是一维数组
# (2.1) ndarray[位置区间]
print('\n(2.1-1)一维数组ar_1d的前2个元素切片:', ar_1d[:2]) # 切片 # [5 6]
print('(2.1-2)一维数组ar_1d的第0、2元素切片:', ar_1d[0:3:2]) # 切片 # [5 7]
ar_1d[0:2] = 15, 17
print('(2.1-3) 修改后的一维数组ar_1d为:', ar_1d) # [15 17 7 8]
# (2.2) ndarray[位置组合]
list_pos = [0, 2, 3]
ar_pos = np.array(list_pos)
print('\n(2.2-1) 一维数组ar_1d的第0、2、3元素切片:', ar_1d[list_pos]) # [15 7 8]
print('(2.2-1) 一维数组ar_1d的第0、2、3元素切片:', ar_1d[ar_pos]) # [15 7 8]
# 也就是下面的
print(ar_1d[[0,2,3]]) # [15 7 8]
4.2 二维数组切片
(1)用单行位置,单列位置结果是单个元素 a[2, 1]
- 格式 ndarray[单行位置,单列位置]
(2)用单行位置,一组列位置,结果是一维数组 a[2, 1:4] / a[2, [0, 2, 3]]
- 格式 ndarray[单行位置,列位置区间/列位置组合]
(3)用一组行位置,单列位置,结果是一维数组 a[0:3, 1]) / a[[0, 2, 3], 1]
- 格式 ndarray[行位置区间/行位置组合,单列位置]
(4)用一组行位置,一组列位置,结果是二维数组 a[1:3, 1:4] / a[1:3, [0, 2]]
- 格式 ndarray[行位置区间/行位置组合,列位置区间/列位置组合]
要求:
行位置组合,列位置组合同时出现时,表示离散切片!!! (跨区间)
二维数组切片中,行位置组合、列位置组合可以是位置组成的tuple、list、ndarray
(5)离散切片,结果是一维数组
- 格式 ndarray[行位置组合,列位置组合]
要求: 行位置组合和列位置组合元素个数相等。
以二者的每对对应元素分别作为行列位置,从ndarray中切出1个元素,最后封装成一维数组。
import numpy as np
# (0)准备数据 二维数组
ar_2d = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [7, 8, 9, 10, 11], [5, 5, 5, 5, 5]])
print('\n(0)二维数组ar_2d:\n', ar_2d)
'''
[[ 1 2 3 4 5]
[ 4 5 6 7 8]
[ 7 8 9 10 11]
[ 5 5 5 5 5]]
'''
# (1)用单行位置,单列位置结果是单个元素
# 格式 ndarray[单行位置,单列位置]
print('\n(1)二维数组ar_2d的第2行第1列元素:\n', ar_2d[2, 1]) # 8
# (2)用单行位置,一组列位置,结果是一维数组 ***
# 格式 ndarray[单行位置,列位置区间/列位置组合]
print('\n(2.1)二维数组ar_2d的第2行第1-3列切片:\n', ar_2d[2, 1:4]) # [ 8 9 10] 左闭右开!
print('\n(2.2)二维数组ar_2d的第2行第0、2、3列切片:\n', ar_2d[2, [0, 2, 3]]) # [ 7 9 10]
# (3)用一组行位置,单列位置,结果是一维数组
# 格式 ndarray[行位置区间/行位置组合,单列位置]
print('\n(3.1)二维数组ar_2d的第0-2行第1列切片:\n', ar_2d[0:3, 1]) # [2 5 8] 左闭右开
print('\n(3.2)二维数组ar_2d的第0、2、3行第1列切片:\n', ar_2d[[0, 2, 3], 1]) # [2 8 5]
# (4)用一组行位置,一组列位置,结果是二维数组
# 格式 ndarray[行位置区间/行位置组合,列位置区间/列位置组合]
print('\n(4.1)二维数组ar_2d的第1-2行第1-3列切片:\n', ar_2d[1:3, 1:4])
'''
[[ 5 6 7]
[ 8 9 10]]
'''
print('\n(4.2)二维数组ar_2d的第1-2行第0、2列切片:\n', ar_2d[1:3, [0, 2]])
'''
[[4 6]
[7 9]]
'''
# (5)离散切片,结果是一维数组***
# 格式 ndarray[行位置组合,列位置组合]
print('\n(5.1)二维数组ar_2d的第0行1列、第1行2列元素:\n', ar_2d[[0, 1], [1, 2]])
print('\n(5.2)二维数组ar_2d的第0行0列、第2行1列、第3行3列元素:\n', ar_2d[(0, 2, 3), [0, 1, 3]]) # [1 8 5]
print('\n(5.3)二维数组ar_2d的第0行0列、第2行1列、第3行3列元素:\n', ar_2d[[0, 2, 3], (0, 1, 3)]) # [1 8 5]
5 变换数组的形态
5.1 reshape()方法改变数组的形状
- ndarray.reshape
每一维用一个 [] 括起,不同维之间用 , 逗号间隔,最后总体再用 [] 括起!!!
说明:列表肯定是一维的,多个列表一行一行堆叠形成二维,多个这样的二维构成三维,以此类推可得更高维矩阵(一般3维以上就不用numpy.array()这种方法创建了)。
注意:高维数组,以三维(5,2,3)为例:前面的5代表页数,即表示(2,3)这样的二维矩阵有5个。即:前面的数,永远代表比它"低一维"的数组有多少个!最外面有几个 ] 中括号就是几维数组。
# 编程实例
# (1)创建一维度数组
import numpy as np
ar_1d = np.arange(12)
print('(1.0)一维数组arr1为:', ar_1d)
# (2)改变一维数组的形状
ar_2d = ar_1d.reshape(3, 4) # 不改变本身
print('ar_1d不变,仍为:\n', ar_1d) # [ 0 1 2 3 4 5 6 7 8 9 10 11]
print('\n(2.0) ar_1d形状改变后的数组ar_2d为:\n', ar_2d)
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
'''
print('(2.1) ar_2d维度为:', ar_2d.ndim)
ar_2d.shape = 2, 6 # 改变本身
print('(2.2) ar_2d为:\n', ar_2d) #
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
'''
ar_2d.shape = 2, 6, 1 # 改变本身 2页 6行 1列
print('(2.3) ar_2d为:\n', ar_2d)
'''
[[[ 0]
[ 1]
[ 2]
[ 3]
[ 4]
[ 5]]
[[ 6]
[ 7]
[ 8]
[ 9]
[10]
[11]]]
'''
5.2 数组的展平
-
ravel()函数只能横向展平数组*
-
flatten()函数可以横向展平数组,也可以纵向展平数组 # order:‘C’ – 按行,‘F’ – 按列,‘A’ – 原顺序,‘K’ – 元素在内存中的出现顺序。
# 编程实例
import numpy as np
# (1)初始二维数组
ar_2d = np.array([[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11]])
print('\n(1) ar_2d为:\n', ar_2d)
# (2)ravel()展平后的数组
ar_1d_1 = ar_2d.ravel()
print('\n(2)ar_1d_1:', ar_1d_1) # [ 0 1 2 3 4 5 6 7 8 9 10 11]
ar_1d_2 = ar_2d.flatten()
print('\n(3)ar_1d_2:', ar_1d_2) # [ 0 1 2 3 4 5 6 7 8 9 10 11]
5.3 数组的堆叠
- np.hstack()函数实现两个数组横向堆叠 ----行数必须一样
- np.vstack()函数实现两个数组纵向堆叠 ----列数必须一样
# 编程实例
import numpy as np
# (1)准备初始二维数组
ar_2d_3x4 = np.arange(12).reshape(3, 4)
ar_2d_3x5 = np.arange(15).reshape(3, 5)
ar_2d_2x4 = np.arange(8).reshape(2, 4)
print('(1.1)数组ar_2d_3x4为:\n', ar_2d_3x4)
print('(1.2)数组ar_2d_3x5为:\n', ar_2d_3x5)
print('(1.3)数组ar_2d_2x4为:\n', ar_2d_2x4)
# (2)用hstack()实现横向堆叠
ar_2d_3x9 = np.hstack((ar_2d_3x4, ar_2d_3x5))
print('\n(2)横向堆叠后的数组ar_2d_3x9为:\n', ar_2d_3x9)
'''
[[ 0 1 2 3 0 1 2 3 4]
[ 4 5 6 7 5 6 7 8 9]
[ 8 9 10 11 10 11 12 13 14]]
'''
# (3)用vstack()纵向堆叠
ar_2d_5x4 = np.vstack((ar_2d_3x4, ar_2d_2x4))
print('\n(3)纵向堆叠后的数组ar_2d_5x4为:\n', ar_2d_5x4)
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 0 1 2 3]
[ 4 5 6 7]]
'''
5.4 数组的分割
-
np.hsplit()函数将一个数组横向分割
-
- np.hsplit(x,2) # 将x按列拆分成2个数组,第二个参数表示拆分成几个数组 - np.hsplit(x,(2,3)) # 将x按特定列进行拆分,示例在第二列和第三列进行拆分。第二个参数表示拆分的位置
-
import numpy as np x=np.arange(16).reshape(4,4) print(x) """"x=[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15]]""" #将x按列拆分成2个数组,第二个参数表示拆分成几个数组 x_1=np.hsplit(x, 2) print(x_1) """x_1=[array([[ 0, 1], [ 4, 5], [ 8, 9], [12, 13]]), array([[ 2, 3], [ 6, 7], [10, 11], [14, 15]])]""" #将x按特定列进行拆分,示例在第二列和第三列进行拆分。第二个参数表示拆分的位置 x_2=np.hsplit(x,(2,3)) print(x_2) """x_2=[array([[ 0, 1], [ 4, 5], [ 8, 9], [12, 13]]), array([[ 2], [ 6], [10], [14]]), array([[ 3], [ 7], [11], [15]])]""" y=np.arange(8).reshape(2,2,2) print(y) """y=[[[0 1] [2 3]] [[4 5] [6 7]]]""" #注意三维数组的拆分,是对数组中的每个元素的列进行拆分,而不是对数组的列 y_1=np.hsplit(y,2) print(y_1) """y_1=[array([[[0, 1]], [[4, 5]]]), array([[[2, 3]], [[6, 7]]])]"""
-
-
np.vsplit()函数将一个数组横向分割
将一个二维数组分割成含有两个或多个元素的python列表,每个列表元素是一个ndarray数组
# 编程实例
import numpy as np
# (1)准备初始二维数组
ar_2d_4x8 = np.arange(32).reshape(4, 8)
print('\n(1)数组ar_2d_4x8为:\n', ar_2d_4x8)
'''
[[ 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]]
'''
# (2)用hsplit()函数横向分割
list_1 = np.hsplit(ar_2d_4x8, 2)
print('\n(2.1)hsplit()函数横向分割结果:\n', list_1)
'''
[array([[ 0, 1, 2, 3],
[ 8, 9, 10, 11],
[16, 17, 18, 19],
[24, 25, 26, 27]]), array([[ 4, 5, 6, 7],
[12, 13, 14, 15],
[20, 21, 22, 23],
[28, 29, 30, 31]])]
'''
print('\n(2.2)分割结果数据类型:\n', type(list_1)) # <class 'list'>
# (3)用vsplit()函数纵向向分割:
list_2 = np.vsplit(ar_2d_4x8, 2)
print('\n(3.1)vsplit()函数纵向分割结果:\n', list_2)
'''
[array([[ 0, 1, 2, 3, 4, 5, 6, 7],
[ 8, 9, 10, 11, 12, 13, 14, 15]]), array([[16, 17, 18, 19, 20, 21, 22, 23],
[24, 25, 26, 27, 28, 29, 30, 31]])]
'''
print('\n(3.2)分割结果数据类型:\n', type(list_2)) # <class 'list'>
图像处理中的维度变换
某图像数组,数据组织是C(BGR),H=4,W=5。
现在需要进行AI模型进行目标检测,训练数据要求格式是H=4,W=5,C(RGB)
#编程实例
# (1)多维数组的维度变换
import numpy as np
ar_3d_chw=np.uint8(np.arange(60)).reshape(3,4,5)
print('\n(1.0) ar_3d_chw数组\n',ar_3d_chw)
ar_3d_hwc=np.transpose(ar_3d_chw,(1,2,0))
print('\n(1.1) ar_3d_hwc数组\n',ar_3d_hwc)
#(2) 调整ar_3d_hwc中第2维c的顺序为RGB
##想一想怎么做??
import numpy as np
# (1)多维数组的维度变换
ar_3d_chw = np.uint8(np.arange(60)).reshape(3, 4, 5)
print('\n(1.0) ar_3d_chw数组\n', ar_3d_chw)
ar_3d_hwc = np.transpose(ar_3d_chw, (1, 2, 0))
print('\n(1.1) ar_3d_hwc数组\n', ar_3d_hwc)
# (2) 调整ar_3d_hwc中第2维c的顺序为RGB
print("\n\n----------------------------\n",ar_3d_hwc)
ar_3d_hwc[:,:,[2,1,0]] = ar_3d_hwc[:,:,[0,1,2]]
ar_3d_hwc[:,:,[1,2,0]] = ar_3d_hwc[:,:,[0,2,1]]
ar_3d_hwc_2 = ar_3d_hwc
print("\n\n----------------------------\n",ar_3d_hwc_2)
##自由练习,理解数组元素的数据类型
import numpy as np
a=np.array(['ab','x','mn'],dtype='str')
print(a.dtype) # <U2
print(a.itemsize) # 8
b=np.array([10],dtype='float')
print(b.dtype) # float64
print(b.itemsize) # 8
print(a) # ['ab' 'x' 'mn']
6 易错点
6.1 Python Numpy 实现交换两行和两列的方法
numpy应该是一个和常用的包了,但是在百度查了很久,也没有查到如何交换两列(交换两行的有),所以查看了其他的文档,找到了方法。
6.1.1 np.copy、tmp暂存交换法
交换两行
比如a = np.array([[1,2,3],[2,3,4],[1,6,5], [9,3,4]]),想要交换第二行和第三行,看起来很简单,直接写代码:
import numpy as np
a = np.array([[1,2,3],[2,3,4],[1,6,5], [9,3,4]])
tmp = a[1]
a[1] = a[2]
a[2] = tmp
运行结果却为:
array([[1, 2, 3],
[1, 6, 5],
[1, 6, 5],
[9, 3, 4]])
原因是因为tmp = a[1]并非a[1]的一个copy,而是一个“别名”,也就是说tmp和a[1]都指向同一个对象,通过一方改变指向的对象,那么再次引用该对象时,自然也就变了,那么我们改写成:
import numpy as np
a = np.array([[1,2,3],[2,3,4],[1,6,5], [9,3,4]])
tmp = np.copy(a[1])
a[1] = a[2]
a[2] = tmp
运行结果为:
array([[1, 2, 3],
[1, 6, 5],
[2, 3, 4],
[9, 3, 4]])
结果正常
6.1.2 一种更加简单的方法
利用了Python数组名a指向了一个数组对象的特点,修改a指向的值
交换两行
import numpy as np
a = np.array([[1,2,3],[2,3,4],[1,6,5], [9,3,4]])
a[[1,2], :] = a[[2,1], :]
得到:
[[1 2 3]
[1 6 5]
[2 3 4]
[9 3 4]]
交换两列,和上面类似:
import numpy as np
a = np.array([[1,2,3],[2,3,4],[1,6,5], [9,3,4]])
a[:,[1,0]] =a[:,[0,1]]
print(a)
得到:
[[2 1 3]
[3 2 4]
[6 1 5]
[3 9 4]]