numpy的知识内容主要分为以下8个部分
所有代码均在jupyter中运行
out: 后面的内容均为运行输出的结果
目录：
1.创建数组
2.shape函数返回数组的维度(元组的形式返回)
3.数组切片
4.改变数组维度
5.数组的组合
6.分割数组
7.数组的属性
8.数组的转换
最重要的，先导入numpy包
import numpy as np
1.创建数组
使用numpy创建数组的方法有以下几种
(1)
numpy.arange([start, ]stop, [step, ]dtype=None)
参数详解：
start, stop ----> 数组的起始位置和停止的位置，元组的形式，遵循左闭右开原则，start省略的时候默认为0
step ----> 等差数组的步长, 默认为1
dtype ----> 指定数据类型
只能创建一维数组，可以后期通过其他的方法改变它的维度
# 不指定start
a = np.arange(5)
a
# out: array([0, 1, 2, 3, 4])
--------------
# 指定start
a = np.arange(2, 5)
a
# out: array([2, 3, 4])
--------------
# 指定步长step
a = np.arange(2, 10, 2) # 带有start参数的指定方式
a
# out: array([2, 4, 6, 8])
a = np.arange(10, step = 2) # 不带start参数的指定方式
a
# out: array([0, 2, 4, 6, 8])
(2)
numpy.array(object, dtype=None, copy=True, order=‘K’, subok=False, ndmin=0)
参数详解：
dtype ----> 指定数据类型
可以创建一维或多维数组
# 创建一维数组
a = np.array([1, 2, 3, 4])
a
# out: array([1, 2, 3, 4])
------
# 创建一个二维数组
a = np.array([[1, 2], [3, 4]])
a
'''
out:
array([[1, 2],
[3, 4]])
'''
------
# 指定数据类型
a = np.array([1, 2, 3, 4], dtype = 'str')
a
# out: array(['1', '2', '3', '4'], dtype='<U1')
# 可以看到数组中的所有元素均变成字符串类型
（3）
np.zeros()函数，创建一个元素全为0的数组，可以是任意维度
# np.zeros()
np.zeros(10) # 创建一个全为0的一维数组
# out:array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
np.zeros((3, 6)) # 创建一个全为0的二维数组
'''
out:
array([[0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0.]])
'''
np.zeros((3, 2, 2, 2)) # 创建一个全为0的四维维数组
'''
out:
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）
np.empty()函数，创建一个空的数组
np.empty((2, 2))
'''
out:
array([[1.19255575e-311, 4.92089383e-321],
[3.33988377e-321, 3.33988377e-321]])
'''
（5）
np.ones()函数，创建一个元素全为1的数组
np.ones((2, 2))
'''
out:
array([[1., 1.],
[1., 1.]])
'''
2.shape函数返回数组的维度(元组的形式返回)
shape主要是用于查看数组的维度，形状
shape也能改变数组的维度，形状
# 用shape查看数组a的维度和形状
a = np.array([[0,1,2,3,4],[1,3,2,3,4]])
a.shape
# out: (2, 5)
# 可以看到数组a是一个二维数组
------
# 用shape改变数组的维度和形状
a = np.arange(8) # 先创建一个一维数组a
a
# out: array([0, 1, 2, 3, 4, 5, 6, 7])
a.shape # 数组的形状
# out: (8,)
# 然后用shape改变a的形状
a.shape = (2, 4)
a # 再次查看数组a
'''
out:
array([[0, 1, 2, 3],
[4, 5, 6, 7]])
'''
a.shape # 再次查看a的形状
# out: (2, 4)
# 可以发现，数组a发生了一定的变化，但是它本身具有的元素个数和内容不变
3.数组切片
数组切片主要是获取数组的某一部分，遵循左闭右开原则
也发现了给步长设置为-1还有反转数组元素顺序的功能，但是这个功能在arange函数创建数组中却不能用，只能创建一个空的数组
以及“…”省略号在多维数组中的妙用
# 一维数组的切片
a = np.arange(9)
a[3:7] # 3和7是数组元素的索引值，这里指的是获取数组第4个元素到滴7个元素
# 该操作返回一个新的数组，不会改变原数组
# 如果需要改变原数组，可以使用a = a[3:7]的方式
# out： array([3, 4, 5, 6])
------
# 多维数组的切片
b = np.arange(24).reshape(2, 3, 4) # reshape是用于改变数组的形状和维度用的，后面会讲到
b
'''
out:
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]]])
'''
# 选取其中一个元素
b[0,0,0]
# out: 0
# 选取其中的一部分
b[:,0,0] # "："表示选中所有元素，每个元素的第1个元素的第0个元素
# 这里所说的元素不仅仅指的是一个数字，也包括一个包含于数组中的列表
'''
out:
array([ 0, 12])
'''
# 以更加复杂的方式进行多维数组的切片
b[:,0,1:3] # 这里的1:3表示对对应层的列表进行切片
'''
out:
array([[ 1, 2],
[13, 14]])
'''
------
# “...”省略号在多维数组中的妙用
b[..., 1] # 相当于b[:, :, 1], 连续的：可以用省略号...代替
'''
out:
array([[ 1, 5, 9],
[13, 17, 21]])
'''
b[1,...] # 相当于b[1, :, :]
'''
out:
array([[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]])
'''
------
# 如何反转数组
# 先看看原来的数组
b
'''
out:
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]]])
'''
b[::-1] # 反转最外层的列表
# 要注意：这里的2个":"没有用逗号分隔，第一个":"代表选取整个数组作为切片，
# 第二个":"是用于分隔后面一个参数，这个参数是步长，当步长为-1的时候回反转整个数组的顺序
# 如果是[:,-1]这种形式的-1代表的是选取最后一个元素
'''
out:
array([[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]],
[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]])
'''
# 这里的只是反转了最为外面的一层
花式索引（拓展）
# 花式索引
arr = np.arange(32).reshape((8, 4))
arr
'''
out:
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],
[24, 25, 26, 27],
[28, 29, 30, 31]])
'''
# 选取特定的行并选择行的某一列（这个例子中行的列只有单个数字元素）
arr[[1, 5, 7, 2], [0, 3, 1, 2]]
# out： array([ 4, 23, 29, 10])
# 还能选取特定的行，然后将每一行的元素进行排列后整行输出
arr[[1, 5, 7, 2]][:,[0, 3, 1, 2]]
'''
out:
array([[ 4, 7, 5, 6],
[20, 23, 21, 22],
[28, 31, 29, 30],
[ 8, 11, 9, 10]])
'''
# numpy中的方法实现上面的输出、
arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])]
'''
out:
array([[ 4, 7, 5, 6],
[20, 23, 21, 22],
[28, 31, 29, 30],
[ 8, 11, 9, 10]])
'''
4.改变数组维度
能够起到改变数组维度作用的函数有许多个，功能各不相同
主要有：
reshape函数
ravel函数
flatten函数
shape函数
transpose函数
resize函数
接下来用代码看看它们各自应该怎么使用
# reshape改变数组维度, 但是不会改变原数组
b = np.arange(24).reshape(2, 3, 4) # 可以直接设置数组的维度，
# 但是有一点必须要注意：
# 各个维度的乘积要与数组最小单位元素个数相同，如：24 = 2*3*4
b
'''
out:
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]]])
'''
------
# ravel函数用于展平数组，就是将数组全部元素集合成为一个一维数组
b.ravel() # 不会改变原来的数组
'''
out:
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])
'''
------
# 与ravel函数相同，用于展平数组，但是ravel只是返回数组的视图， 而flatten会请求分配内存来保存结果
b.flatten() # 不会改变原来的数组
'''
out:
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])
'''
------
# 在上面我们知道了shape是用于查看数组的形状和维度，但是它还能改变数组的形状和维度
b.shape = (6, 4) # 直接用元组的形式设置b数组的维度
# 会直接修改原本的数组
b
'''
out:
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]])
'''
------
# 在b数组被shape改变维度的情况下，我们继续用transpose函数来对数组进行操作
# transpose函数用于转置矩阵: 将多维数组的每一列变成每一行，每一行又变成每一列，
# 相当于把一个矩形翻转90度
b.transpose() # 转置矩阵，不会改变原数组
'''
out:
array([[ 0, 4, 8, 12, 16, 20],
[ 1, 5, 9, 13, 17, 21],
[ 2, 6, 10, 14, 18, 22],
[ 3, 7, 11, 15, 19, 23]])
'''
------
# resize和reshape的功能一样，但是resize会直接修改所操作的数组
b.resize((2, 12))
b
'''
out:
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]])
'''
5.数组的组合
NumPy数组有水平组合、垂直组合和深度组合等多种组合方式
可以使用 vstack 、dstack 、 hstack 、 column_stack 、 row_stack 以及 concatenate 函数来完成数组的组合
这里下面说的第几维度，其实就是通过shape函数获得的元组的第几个元素
水平组合(第二维度堆叠组合)
# 创建2个多维数组
a = np.arange(9).reshape(3,3)
a
'''
out:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
'''
b = 2 * a # a中所有的元素都乘以（*）2
b
'''
out:
array([[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
'''
# 水平组合
# 从维度的方向来讲，只要出来第二维度之外,其他维度相等，以及维数相等，就能实现两个数组之间的水平组合
# 从行列来讲，只要数组对应的行数相同，就可以进行组合
np.hstack((a, b))
‘’‘
out：
array([[ 0, 1, 2, 0, 2, 4],
[ 3, 4, 5, 6, 8, 10],
[ 6, 7, 8, 12, 14, 16]])
‘’’
# 我在试一下第二维度维度不同的情况能不能水平组合
# 修改b数组
b = np.arange(12).reshape(3,4)
b
'''
out:
array([[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
'''
np.hstack((a, b))
'''
out:
array([[ 0, 1, 2, 0, 1, 2, 3],
[ 3, 4, 5, 4, 5, 6, 7],
[ 6, 7, 8, 8, 9, 10, 11]])
'''
# 我再试一下在上一个例子的基础上维数不同的情况
# 更改b的形状
b = np.arange(12).reshape(2,3,2)
b
'''
out:
array([[[ 0, 1],
[ 2, 3],
[ 4, 5]],
[[ 6, 7],
[ 8, 9],
[10, 11]]])
'''
np.hstack((a, b))
'''
out:
ValueError: all the input arrays must have same number of dimensions
'''
# 报错了，错误提示：所有输入数组的维数必须相同，说明水平组合的数组维数必须相同
------
# 其实，用concatenate函数也能达到同样的效果
# 也是一样创建两个数组
a = np.arange(9).reshape(3,3)
a
'''
out:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
'''
b = 2 * a # a中所有的元素都乘以（*）2
b
'''
out:
array([[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
'''
# concatenate((a, b), axis = 0)可以实现相同的效果 axis表示从第几个维度拼接，第一个维度是0
np.concatenate((a, b), axis = 1)
'''
out:
array([[ 0, 1, 2, 0, 2, 4],
[ 3, 4, 5, 6, 8, 10],
[ 6, 7, 8, 12, 14, 16]])
'''
通过这个例子可以总结出来，hstack和axis = 1的concatenate函数效果上是相同的
我们把数组看成一个个矩阵，行和列看作宽和高，仔细观察hstack上面的例子，其实水平组合就是在高相同的情况下把两个矩阵的宽拼接起来，形成一个新的矩阵
同理，下面的垂直组合与水平组合相反，它是把两个矩阵上下拼接起来形成一个新的矩阵，新的矩阵的宽与原来矩阵的宽都是相同的，但是高是原来矩阵叠加起来的和
垂直组合(第一维度堆叠组合)
# 还是先创建两个数组
a = np.arange(9).reshape(3,3)
a
'''
out:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
'''
b = 2 * a # a中所有的元素都乘以（*）2
b
'''
out:
array([[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
'''
# 垂直组合vstacknp.
np.vstack((a, b))
'''
out:
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
'''
# 使用concatenate可以达到同样的效果
np.concatenate((a, b), axis = 0) # axis=0代表第一维度
'''
out:
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
'''
垂直组合，只要第一维度相等，并且维数相同，那么就可以组合两个数组，vstack效果上和axis = 0的concatenate函数效果上是相同的
深度组合(第三维度堆叠组合)
a = np.arange(12).reshape(2,3,2)
a
'''
out:
array([[[ 0, 1],
[ 2, 3],
[ 4, 5]],
[[ 6, 7],
[ 8, 9],
[10, 11]]])
'''
c = np.arange(12).reshape(2,3,2)
c
'''
out:
array([[[ 0, 1],
[ 2, 3],
[ 4, 5]],
[[ 6, 7],
[ 8, 9],
[10, 11]]])
'''
np.dstack((a, c))
'''
out:
array([[[ 0, 1, 0, 1],
[ 2, 3, 2, 3],
[ 4, 5, 4, 5]],
[[ 6, 7, 6, 7],
[ 8, 9, 8, 9],
[10, 11, 10, 11]]])
'''
# 再来看一下深度组合后维度的变化
np.dstack((a, c)).shape
# out: (2, 3, 4)
# 发现第三维度叠加起来了
# 使用concatenate
np.concatenate((a,c),axis=2)
'''
out:
array([[[ 0, 1, 0, 1],
[ 2, 3, 2, 3],
[ 4, 5, 4, 5]],
[[ 6, 7, 6, 7],
[ 8, 9, 8, 9],
[10, 11, 10, 11]]])
# 效果与dstack相同
'''
改变一下数组再来进行比较
a = np.arange(18).reshape(2,9)
a
'''
out:
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8],
[ 9, 10, 11, 12, 13, 14, 15, 16, 17]])
'''
c = np.arange(18).reshape(2,9,1)
c
'''
out:
array([[[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5],
[ 6],
[ 7],
[ 8]],
[[ 9],
[10],
[11],
[12],
[13],
[14],
[15],
[16],
[17]]])
'''
np.dstack((a, c))
'''
out:
array([[[ 0, 0],
[ 1, 1],
[ 2, 2],
[ 3, 3],
[ 4, 4],
[ 5, 5],
[ 6, 6],
[ 7, 7],
[ 8, 8]],
[[ 9, 9],
[10, 10],
[11, 11],
[12, 12],
[13, 13],
[14, 14],
[15, 15],
[16, 16],
[17, 17]]])
'''
# 使用concatenate
np.concatenate((a,c),axis=2)
'''
out:
AxisError: axis 2 is out of bounds for array of dimension 2
'''
# 报错了，是因为有数组的维数达不到concatenate指定的维数
通过这个案例dstack函数的一些特性，在使用dstack函数进行组合的数组中，他们的维度可以省略，就是说dstack函数不仅仅可以组合两个三维数组，它还能组合两个二维数组，两个一维数组。
也可以发现dstack函数与concatenate函数的区别，dstack可以组合低于它要求的维度的数组，只要两个数组之间除了相应的第几个维度之外，其他的相同就可以成功组合，升值维数可以不同
但是对于concatenate函数，必须要全部维度显式的表示出来，两个数组的维度也必须要相同。而且除了组合的对应维度可以不同之外，其他的维度必须是相同的。
还有两个函数
row_stack
column_stack
我用上面的例子试了一下，发现列组合column_stack与水平组合hstack都能达到同样的效果，暂时不知道它们之间的区别在哪里
同样row_stack与vstack也是一样
后续继续探讨，如果找到区别再更新
6.分割数组
需要注意的是，数组进行分割后得到的是一个包含多个数组的列表
水平分割hsplit
# 创建一个二维数组
a = np.arange(9)
a.shape = (3, 3)
a
'''
out:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
'''
# 水平分割
np.hsplit(a, 3) # 水平分割就是矩阵数组保持高度不变的情况下，对宽进行平均的分割，得到多个新的数组，新数组的形状相同
'''
Out:
[array([[0],
[3],
[6]]),
array ([[1],
[4],
[7]]),
array ([[2],
[5],
[8]])]
'''
np.split(a, 3, axis = 1) # axis=1就是对每一行进行切割，axis=0就是对每一列进行切割，
'''
out:
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]
'''
a # 不改变原来的数组
'''
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
'''
水平分割hsplit
a = np.arange(9)
a.shape = (3, 3)
a
'''
out:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
'''
# 垂直分割 vsplit
np.vsplit(a, 3) # 垂直分割就是矩阵数组保持宽度不变的情况下，对高进行平均的分割，得到多个新的数组，新数组的形状相同
'''
out:
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
'''
# 调用split函数可以达到相同的效果
np.split(a, 3, axis = 0)
'''
out:
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
'''
深度分割dsplit
注意：
dsplit只适用于3维或3维以上的数组
a = np.arange(54).reshape(3, 3, 3)
a
'''
out:
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],
[24, 25, 26]]])
'''
# 深度分割,参数数组必须是三维和三维以上
np.dsplit(a, 2)
'''
out:
[
array([[[ 0],
[ 3],
[ 6]],
[[ 9],
[12],
[15]],
[[18],
[21],
[24]]]),
array([[[ 1],
[ 4],
[ 7]],
[[10],
[13],
[16]],
[[19],
[22],
[25]]]),
array([[[ 2],
[ 5],
[ 8]],
[[11],
[14],
[17]],
[[20],
[23],
[26]]])
]
'''
# 观察out（输出）的结果可以发现，深度分割dsplit是按照数组的列来分的，
从维度上看：
水平分割是从第二维度分的，也就是把第二维度平分，垂直分割是从第一维度，深度分割是从第三维度。
用shape函数观察分割后的每一个数组可以发现这个规律
以深度分割为例：
a = np.arange(27).reshape(3, 3, 3)
a.shape
# out: (3, 3, 3)
# 深度分割
l = np.dsplit(a, 3)
l[0].shape # out: (3, 3, 1)
l[1].shape # out: (3, 3, 1)
l[2].shape # out: (3, 3, 1)
7.数组的属性
shape, reshape 显示和设置数组的维度
dtype 用于显示数组的类型
ndim 输出数组的维数
itemsize 给出数组中的元素在内存中所占的字节数
nbytes 给出数组中的所有元素在内存中所占的字节数
T 效果与transpose一样,但是T不会改变原数组，而transpose会改变原数组
flat 返回一个numpy.flatiter 对象，可以让我们像遍历一维数组一样去遍历任意的多维数组
# shape和reshape
'''
shape用于显示数组的维度，也可以利用元组的方式设置数组的维度
reshape用于设置数组的维度
'''
# 例如
a = np.arange(12)
a
'''out: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])'''
# shape 查看数组维度
a.shape
'''out : (12,)'''
# shape设置数组的维度
a.shape = (3, 4)
a
'''
out:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
'''
a.shape
'''out:(3, 4) '''
# 重置a数组
a = np.arange(12)
a
'''out: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])'''
# reshape设置数组的维度
a.reshape(3, 4)
'''
out:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
'''
a
'''out: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])'''
'''
有上面两个例子可以看到，
shape设置的数组维度是会直接改变原数组的，
但是reshape设置数组的维度不会改变原数组
'''
a = np.arange(12)
# dtype属性,用于显示数组的类型
a.dtype
'''
out:
dtype('int32')
'''
# ndim,输出数组的维数
a.ndim
# out: 1
# size给出数组元素的总个数
a.size
# out:12
# itemsize, 给出数组中的元素在内存中所占的字节数
a.itemsize
# out: 4
# nbytes
a.nbytes
# out: 48
a.size * b.itemsize
# out: 48
'''
其实nbytes就是等于size*itemsize
'''
# T 属性，效果与transpose一样,但是T不会改变原数组，而transpose会改变原数组
a = np.arange(12)
a.resize(4, 3)
a
'''
out:
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
'''
a.T # 不会改变原数组
'''
out:
array([[ 0, 3, 6, 9],
[ 1, 4, 7, 10],
[ 2, 5, 8, 11]])
'''
a
'''
out:
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
'''
# 对于一位数组，其T属性就是它自己
q = np.arange(5)
q
# out:array([0, 1, 2, 3, 4])
q.T
# out:array([0, 1, 2, 3, 4])
q.transpose
q
# out: array([0, 1, 2, 3, 4])
'''
flat属性
#
'''
flat 属性将返回一个 numpy.flatiter 对象，这是获得 flatiter 对象的唯一方式——我
们无法访问 flatiter 的构造函数。这个所谓的“扁平迭代器”可以让我们像遍历一维数
组一样去遍历任意的多维数组
'''
b = np.arange(4).reshape(2, 2)
b
'''
out:
array([[0, 1],
[2, 3]])
'''
f = b.flat # flat属性不会改变原数组，得到的是一个可迭代的对象
b
'''
out:
array([[0, 1],
[2, 3]])
'''
for item in f:
print(item, end=',')
'''
知识拓展：
print函数的end属性是输出后面带的符号，默认是\n（换行符），可以修改end属性强制不换行或者换成以其他符号结尾
'''
# flat属性获取数组的一部分
# flat还可以获取数组的一个元素
b.flat[[2]]
# out : 2
# 或者获取一部分元素
b.flat[[1, 3]] # 获取整个数组迭代对象中下标为1和3的元素,多个下标需要[]包围起来
# out： array([1, 3])
b.flat[:3] # 还可以用切片的方式获取数组
# 实质上就是先把数组切片，然后把这个新数组传给flat得到可迭代对象
# out: array([0, 1, 2])
注意：给flat对象赋值会直接改变原来的数组
# 给flat对象赋值
# 给整个数组赋值
b.flat = 7
b
'''
out:
array([[7, 7],
[7, 7]])
'''
# 给数组部分赋值
b.flat[[0, 2]] = 3
b
'''
out:
array([[3, 7],
[3, 7]])
'''
b.flat[:3] = 1
b
'''
out:
array([[1, 1],
[1, 7]])
'''
8.数组的转换
tolist函数numpy数组转换成python列表
c = np.arange(8).reshape(2, 2, 2)
c
'''
out:
array([[[0, 1],
[2, 3]],
[[4, 5],
[6, 7]]])
'''
c.tolist()
# out: [[[0, 1], [2, 3]], [[4, 5], [6, 7]]]
# 再来一个例子
d = np.arange(32).reshape(2, 2, 2, 2, 2)
d
'''
out:
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]]],
[[[24, 25],
[26, 27]],
[[28, 29],
[30, 31]]]]])
'''
d.tolist()
'''
out:
[[[[[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]]]]]
'''
# 由两个例子可以看出来，转化成的列表的维度与原本数组的维度相同
astype函数可以在转换数组时指定数据类型
# 1.首先创建一个浮点类型的数组
e = np.array([1.12, 1.56])
e
# out: array([1.12, 1.56])
# 此时将数组e转换为整形
e.astype(int) # 这个方法不会改变原来的数组
# out: array([1, 1]) 可以看到小数部分被强制删除了
e
# out: array([1.12, 1.56])
# 2.将e转换为字符串类型
e.astype(str)
# out : array(['1.12', '1.56'], dtype='<U32')
# 转换成功， 说明数值型可以转换为字符串类型，那么字符串能不能转换为数值类型呢
# 3.将字符串类型转换为数值类型
e = e.astype(str)
e
# out: array(['1.12', '1.56'], dtype='<U32')
e.astype(float)
# out: array([1.12, 1.56])
#成功，说明是可以互相转换的
e.astype(int)
'''
out:
ValueError: invalid literal for int() with base 10: '1.12'
转换失败，说明要从字符串类型转换成数值型必须要对应格式
'''
