python多维数据划分_一、Numpy库与多维数组

#Author:Zhang Yuan

importnumpy as np'''重点摘录：

轴的索引axis=i可以理解成是根据[]层数来判断的，0表示[]，1表示[[]]...

Numpy广播的规则可理解成：结构相同，点对点；结果不同，分别匹配。[]是最小单元，按最小单元匹配。

Numpy中逻辑尽量用逻辑操作运算符&/|，少用关键字and/or

Numpy的向量化操作比纯Python速度更快。

ndarray的基本运算 + - * / // 等... 会调用对应的通用函数，为数组中元素的运算。'''

#NumPy 最重要的一个特点是其 N 维数组对象 ndarray。

#ndarray对象的维度是通过多层[]来确定的。[...]表示一维数据，[[...]]表示二维数据，[[[...]]]表示三维数据...#轴的索引axis=i是根据[]层数来判断的，0表示[]，1表示[[]]...

#[,]中的逗号，表示当前所在维度层的数据划分。[1,2,3] 一维划分。[[1, 2], [3, 4]] 外部逗号为第一层维度(行)划分，内部逗号为第二层维度(列)的划分

#int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替

#赋值系列---------------------------------------------------------------#原数据输入的方式形成数组：#原数据输入可以是各种类型。#"层次相同、数据个数相同"会默认转成多维数组，也就是严格符合多维数组格式的会自动转换.

print(np.array([1,2,[3]])) #[1 2 list([3])],只有一个二层次

print(np.asarray([(1,),2,[3]])) #[(1,) 2 list([3])]，只有一个一层次

print(np.array([(1,),(2,),[3,]])) #[[1],[2],[3]]，都是二层次，转换

print(np.asarray([(1,),(2,),(3,)])) #[[1],[2],[3]]，都是二层次，转换

print(np.array([(1,2),(3,)])) #[(1, 2) (3,)]，都二层，但大小不同

print(np.asarray([(1,2),(3,4)])) #[[1， 2]，[3, 4]]，都二层且大小相同，转换

#创建的方式形成数组：#以shape维度描述来创建。

print(np.zeros((3,2))) #empty(),ones()#以buffer来创建，用于实现动态数组。#buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。

print(np.frombuffer(b'Hello World',dtype = 'S1'))print(np.frombuffer(np.array([1,2,3,4,5]),dtype=int))#以迭代对象来创建

print(np.fromiter(range(5),dtype=int))#以数值范围来创建

print(np.arange(10,20,2)) #[10 12 14 16 18]

print(np.linspace(1,10,10)) #[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]

print(np.logspace(1,2,num=2)) #[ 10. 100.]#--------------------------------------------------------------------------

#访问系列------------------------------------------------------------------#切片还可以包括省略号 ...，来使选择元组的长度与数组的维度相同。如果在行位使用省略号，它将返回包含行中元素的 ndarray#多维数组的切片和索引[,]中第一层逗号表示维度划分，第一层逗号分割的左右部分一定是按照维度顺序.#多维数组若没有第一层逗号，会默认加上第一层逗号。但仅传入元组逗号省略。

a = np.array([[1,2,3],[4,5,6],[7,8,9]])print(a[...,1:]) #[[2 3],[5 6],[8 9]]，相当于a[:,1:].

print(a[(1,2)]) #6, 仅传入元组括号省略:a[1,2]=6.

print(a[[1,2]]) #[[4 5 6],[7 8 9]], 默认加上第一层逗号，相当于a[[1,2],]

print(a[[-1,-3]]) #[[7 8 9],[1 2 3]], 默认加上第一层逗号，相当于a[[-1,-3],]

print(a[(1,2),]) #[[4 5 6],[7 8 9]]，相当于a[(1,2),:]，行1、2，列全部

#多维多值索引一定要一一配对，且输出形式与输入的索引形式相同

print(a[[0,1,2], [0,1,0]]) #[1 5 7]，多值索引。一对一:0-0,1-1,2-0

print(a[ [ [0,0],[2,2] ] , [ [0,2],[0,2] ] ]) #[[1 3], [7 9]]

print(a[np.array([[1],[2]]),np.array([[0],[2]])]) #[[4], [9]]

print(a[ [[1],[2]] , [[0],[2]] ]) #[[4], [9]]

#多维多值索引各维度层次不同，会自动默认到最高层次.#各维度表示形式相同，点对点匹配，且大小必须相同。各维度表示形式不同，以不同的形式分别匹配。

x=np.arange(12).reshape((3,4))'''x=array([[0, 1, 2, 3],

[4, 5, 6, 7],

[8, 9, 10, 11]])'''

print(x[ [1,2,0] , [[[3,1,0]]] ]) #[[[7 9 0]]] 各维度表示形式相同，点对点匹配；层次不同，会自动默认到最高层次.

x1=x[ [[1],[2],[0]] , [[3,1,0]] ] #[x]配 [a,b,c,d]表示：按a,b,c,d顺序索引第x行

'''x1=array([[ 7, 5, 4],

[11, 9, 8],

[ 3, 1, 0]])'''x2=x[ [[1,2,0]] , [[3],[1],[0]] ] #[a,b,c,d]配[x]表示：按a,b,c,d顺序索引第x列

'''x2=array([[ 7, 11, 3],

[ 5, 9, 1],

[ 4, 8, 0]])'''

#其中x1、x2互为转置矩阵

#第一维行为变独立( array([[1],[3]]), array([[2, 5]]) )

np.ix_([1,3],[2,5])print(x[np.ix_([1,2,0],[3,1,0])])'''[ [ 7 5 4]

[11 9 8]

[ 3 1 0] ]'''

#以布尔数组np.array([True,False,...])形式可以过滤

x= np.array([1,2,3,4,5,6])

x[np.array([True,False,True,False,True,False])]#array([1, 3, 5])

x[x > 2] #array([3, 4, 5, 6])

a = np.array([np.nan, 1,2,np.nan,3,4,5])print(a[~np.isnan(a)]) #[1. 2. 3. 4. 5.]，其中 ~ 取补运算符，按位取反.#----------------------------------------------------------------------

#当运算中的 2 个数组的形状不同时，但要具备拉升可匹配性Broadcasting，numpy 会把数组自动拉升Broadcasting到相同，在进行元素运算

#numpy中运算函数也会遵循匹配性Broadcasting原则。

#对于一个多维数组a，如果a已经分配内存了，其转置a.T与a共享内存，且存储顺序也是一样的。#如果希望a.T与a存储顺序不同，可以需要重新分配内存：a.T.copy()。#或者控制遍历顺序：#for x in np.nditer(a, order='F'):Fortran order，即是列序优先；#for x in np.nditer(a.T, order='C'):C order，即是行序优先；

#注意numpy中纬度是：011---轴0、1、2---轴Z、Y、X，新增的纬度放入轴索引0#一维数据：0轴-X轴；二维数据：0轴-Y轴-列数据、1轴-X轴-行数据；...

#Numpy数组操作------------------------------------------------------#修改数组形状:#reshape 不改变数据的条件下修改形状#flat 数组元素迭代器#flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组#ravel 返回展开数组#翻转数组:#transpose 对换数组的维度#ndarray.T 和 self.transpose() 相同#rollaxis 向后滚动指定的轴#swapaxes 对换数组的两个轴#修改数组维度:#broadcast 产生模仿广播的对象#broadcast_to 将数组广播到新形状#expand_dims 扩展数组的形状#squeeze 从数组的形状中删除一维条目#连接数组#concatenate 连接沿现有轴的数组序列#stack 沿着新的轴加入一系列数组。#hstack 水平堆叠序列中的数组(列方向)#vstack 竖直堆叠序列中的数组(行方向)#分割数组#split 将一个数组分割为多个子数组#hsplit 将一个数组水平分割为多个子数组(按列)#vsplit 将一个数组垂直分割为多个子数组(按行)#数组元素的添加与删除#resize 返回指定形状的新数组#append 将值添加到数组末尾#insert 沿指定轴将值插入到指定下标之前#delete 删掉某个轴的子数组，并返回删除后的新数组#unique 查找数组内的唯一元素

#使用细节：#flat数组元素迭代器

a = np.arange(9).reshape(3,3)for row in a:print(row) #打印行

for element in a.flat:print (element) #打印元素

#可以先定义格式，再赋值

c=np.empty((4,3))

c.flat=[i for i in range(12)]#运算也遵循相同结构点对点，不同结构分配匹配原则

x = np.array([[7], [8], [9]])

x1= np.array([7, 8, 9])

y= np.array([4, 5, 6])print(x+y) #结果不同，分别运算。

print(x1+y) #结构相同，一对一运算。

print(x*y) #结果不同，分别运算。

print(x1*y) #结构相同，一对一运算。

#numpy.swapaxes函数用于交换数组的两个轴#注意numpy中纬度是：011---轴0、1、2---轴Z、Y、X，新增的纬度放入轴索引0

x=np.arange(8).reshape((2,2,2))print(x)print (np.swapaxes(x, 0, 2))#np.expand_dims()原理

x=np.array([1,2,3,4])print(x) #[1 2 3 4]

print(np.expand_dims(x,axis=0)) #[[1 2 3 4]] 相当于在第一层[]或第零层元素上加个[]

print(np.expand_dims(x,axis=1)) #[[1],[2],[3],[4]] 相当于在第二层[]或第一层元素上加个[]

y=np.array([[1,2],[3,4]])print(y) #[[1 2],[3 4]]

print(np.expand_dims(y,axis=0)) #[[[1 2],[3 4]]] 相当于在第一层[]或第零层元素上加个[]

print(np.expand_dims(y,axis=1)) #[[[1 2]], [[3 4]]] 相当于在第二层[]或第一层元素上加个[]

print(np.expand_dims(y,axis=2)) #[[[1],[2]],[[3],[4]]] 相当于在第三层[]或第二层元素上加个[]#---------------------------------------------------------------

#NumPy 字符串函数，用于对 dtype 为 numpy.string_ 或 numpy.unicode_ 的数组执行向量化字符串操作。#add() 对两个数组的逐个字符串元素进行连接#multiply() 返回按元素多重连接后的字符串#center() 居中字符串#capitalize() 将字符串第一个字母转换为大写#title() 将字符串的每个单词的第一个字母转换为大写#lower() 数组元素转换为小写#upper() 数组元素转换为大写#split() 指定分隔符对字符串进行分割，并返回数组列表#splitlines() 返回元素中的行列表，以换行符分割#strip() 移除元素开头或者结尾处的特定字符#join() 通过指定分隔符来连接数组中的元素#replace() 使用新字符串替换字符串中的所有子字符串#decode() 数组元素依次调用str.decode#encode() 数组元素依次调用str.encode

#NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。#numpy.matlib库不在init内，需要import numpy.matlib

#NumPy 提供了线性代数函数库 linalg，该库包含了线性代数所需的所有功能#dot 两个数组的点积，即元素对应相乘。#vdot 两个向量的点积#inner 两个数组的内积#matmul 两个数组的矩阵积#determinant 数组的行列式#solve 求解线性矩阵方程#inv 计算矩阵的乘法逆矩阵

#Numpy广播的规则可理解成：结构相同，点对点；结果不同，分别匹配。[]是最小单元，按最小单元匹配。#Numpy中逻辑尽量用逻辑操作运算符&/|，少用关键字and/or#Numpy的向量化操作比纯Python速度更快。