Python笔记8|Numpy模块数组的创建、类型转换、数组切片、改变数组形态

Syc1102g

已于 2022-03-29 23:11:43 修改

阅读量666

点赞数

分类专栏： Python学习笔记文章标签： python 开发语言后端

于 2022-03-29 22:52:12 首次发布

本文链接：https://blog.csdn.net/Syc1102g/article/details/123834456

版权

Python学习笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

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， $\color{red}{不可用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]]

Syc1102g

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Python笔记8|Numpy模块数组的创建、类型转换、数组切片、改变数组形态

Python笔记8|Numpy模块数组的创建、类型转换、数组切片、改变数组形态
复制链接

扫一扫

专栏目录