Skip to main content

CP09数据拆分之列行增扩

阅读:-


在现实世界中,应用报表的格式总是多种多样的,而我们的常用的数据保存的容器是excel文件,而从客户处收集的而一些excel数据的格式往往是非标准的,所以就需要做格式转换。而通过程序来实现格式转换,往往是应用中的一个难点,今天我们就来看看,如何通过程序来实现格式转换吧。

9 Pandas-数据拆分-列行增扩

9.1 用例故事

在实际应用中我们可能会面临更为复杂的实际用例,下面一起来看一个例子。

1587356394689

图 1 :蜂窝网络的基础模型

从上图可见,以上是物联网中的一个蜂窝网模型,每一个节点都不是在孤立的工作,需要和自己的存在邻接关系的基站建立逻辑上的联系。大致的模型是:

1587356415426

图2: 模型转换

从上图可见,本题要解决的问题是在于 如果将一个简约的关联记录,增扩为一个详细的关联记录。

其中,在简约的关联记录中,1 个小区,是和自己的邻小区列表建立关联关系,这里邻小区列表中包含了多个邻小区的标识信息。

相关的记录只有一行。

在在详细的关联记录中,1 个小区,需要和自己有关联的小区,都需要建立关联关系,这样就是多行记录。

虽然简约关联记录和详细关联记录描述的是同一个模型,但是用途和表达形式不尽相同。

其中简约的模型,适合作为长期保存;而详细模型,则适合与对具体的问题进展专案分析。

9.1.1 用例分析

  1. 用户输入期待处理的文件路径,输出结果文件的,相关的信息结构

[ 输入文件绝对路径,输出文件绝对路径]

举例如下:[D:\PAE\id-cgi.xlsx, D:\PAE\extend-id-grid.xlsx]

  1. 应用程序读取输入文件,转换为内存的一个DF。

  2. 应用程序将DF进行一系列的转换,生成结果DF

  3. 应用程序将内存中的 data set,也就是新生成的DF2, 写入输出结果xlsx文件的句柄, 相关文件决对路径来自输入数据。

举例:D:\PAE\extend-id-grid.xlsx

  1. 应用程序返回程序执行响应 [ 执行结果,输出结果文件信息]

其中执行结果:0 成功 1 失败

输出结果文件信息:提供输出结果文件的决对路径,举例如下:

举例:D:\PAE\extend-id-grid.xlsx

9.1.2 IPO 分析

主要参考用例分析

9.1.2.1 输入数据分析

输入文件数据格式

1587356477078

9.1.2.2 处理过程

将 id 与 CGI 一对多的数据格式,转化为一对一,输出 csv 文件如下

9.1.2.3 输出数据

输出文件格式:

1587356501684

9.2 用例约束

  1. 使用 pandas 处理数据。

  2. 使用 python3 以上版本。

9.3 流转换过程分析

由于这一道题目的转换过程比较复杂,所以提前做一下相关的穿越分析,读者根据相关流转换的过程设计对应的 pandas 的操作函数。

  1. 输入数据

Csv 中数据格式

1587357087140

内存中 df 数据格式:

1587357104679

  1. 对 df 数据的 CGI 列进行拆分:

1587357137522

  1. 拆分完成后行列互换;

1587357184157

  1. 删除索引:

1587357220094

  1. 多列数据合并:

1587357296031

  1. 对数据重署名:

1587357317092

  1. 输出数据格式:

1587357335147

9.4 语法详解

9.4.1 Excel 安装

  1. 需要安装 xlrd 模块, 打开 cmd,输入命令:pip install xlrd 进行安装

  2. pandas 库支持 excel 的操作;且 pandas 操作更加简介方便,引入 import pandas as pd

pd.read_excel(io,sheetname=0,header=0,skiprows=None,
    index_col=None,names=None,arse_cols=None,date_parser=None,
    na_values=None,thousands=None,convert_float=True,
    has_index_names=None,converters=None,dtype=None,
    true_values=None,false_values=None,engine=None,
    squeeze=False, **kwargs)
  1. io :excel 路径;

  2. sheetname:默认是 sheetname 为 0,返回多表使用 sheetname=[0,1],若 sheetname=None 是返回全表 。注意:int/string 返回的是 dataframe,而 non

  3. header :指定作为列名的行,默认 0,即取第一行,数据为列名行以下的数据;若数据不含列名,则设定 header = None;

  4. skiprows:省略指定行数的数据

  5. skip_footer:省略从尾部数的行数据

  6. index_col:指定列为索引列,也可以使用 u’string’

  7. names:指定列的名字,传入一个 list 数据

9.4.2 Pandas 行列选取

pandas 安装

pip install pandas

9.4.2.1 选取行/列([df] df.loc[] df.iloc[] df.ix[] df.at[] df.iat[]):

Pandas 中,数据主要保存为 Dataframe 和 Series 是数据结构,这两种数据结构数据选取的方式基本一致,在 Dataframe 中选取数据大抵包括 3 中情况:

1)行(列)选取(单维度选取):df[]。这种情况一次只能选取行或者列,即一次选取中,只能为行或者列设置筛选条件(只能为一个维度设置筛选条件)。

2)区域选取(多维选取):df.loc[],df.iloc[],df.ix[]。这种方式可以同时为多个维度设置筛选条件。

3)单元格选取(点选取):df.at[],df.iat[]。准确定位一个单元格。

1、行选取:

整数索引切片:前闭后开选取第一行:df[0:1]

标签索引切片:前闭后闭df[‘a’:‘b’]

布尔数组:选取所有age大于30的行df[[each>30 for each in df[‘age’]]]= df[df[‘age’]>30]

选取出所有age为20或32的行,df[(df[‘age’]==20) | (df[‘age’]==32)] 多个布尔条件判断的情况,多个条件最好(一定)用括号括起来,否则非常容易出错。

9.4.2.2 列选取:

标签索引、标签列表、Callable 对象

a)标签索引:选取单个列

选取name列所有数据df[‘name’]

b)标签列表:选取多个列

选取name和age两列数据df[[‘name’,‘age’]]

c)callable 对象

选取第一列 df[lambda df: df.columns[0]]

9.4.3 str.split():

str.split()

一列变多列,expand

单一分隔符,使用 str.split()即可

str.split 不支持正则及多个切割符号,不感知空格的数量

re.split()

多个分隔符,复杂的分隔情况,使用 re.split

原型: re.split(pattern, string, maxsplit=0)

通过正则表达式将字符串分离。如果用括号将正则表达式括起来,那么匹配的字符串也会被列入到 list 中返回。maxsplit 是分离的次数,maxsplit=1 分离一次,默认为 0,不限制次数。

9.4.4 .stack()函数

函数原型为:stack(arrays, axis=0),arrays 可以传数组和列表。Axis 为维度

列表 a 如下:

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

增加一维,新维度的下标为 Axis=0

[[ 1 2 3 4]

[ 5 6 7 8]

[ 9 10 11 12]]

增加一维,新维度的下标为 Axis=1

[[ 1 5 9]

[ 2 6 10]

[ 3 7 11]

[ 4 8 12]]

9.4.5 reset_index()函数

它是 set_index()的反操作,调用它分层索引的索引层级会被还原到列中

Data:
a   b   c d
bar one z 1.0
    two y 2.0
foo one x 3.0
    two w 4.0

data.reset_index()

Data:
  a   b   c d
0 bar one z 1.0
1 bar two y 2.0
2 foo one x 3.0
3 foo two w 4.0

9.4.6 concat()

1.当没有索引时:为按照一定条件合并

2.当有索引、并按照索引合并时,得到结果为两者混合到一起了,重新按照一定规则排序了。

3.当没有索引时、concat 不管列名,直接加到一起,可以加到后面、也可以加到右边,axis=0 为加到后面,axis=1 为加到右边,左边的数据结构没有变,变的是右边数据结构。

4.当有索引、并按照索引合并时,得到结果两者混合到一起了。

9.5 设计方案简介

9.5.1 正向增扩

9.5.1.1 设计要点

这是非常常见的一种数据扩展的一种操作,会用到一系列的pandas的高级操作。

9.5.1.2 调用关系

1587364432179

9.5.1.3 流穿越

1、df = pd.read_excel(“./id_cgi.xlsx”, encoding=‘gbk’)

1587364462235

2、df2 = df[‘CGI’].str.split(’;’, expand=True)

print(df2)

1587364483269

3、df3 = df2.stack()

df4 = df3.reset_index(level=1, drop=True)

print(df4)

1587364499566

4、res = pd.concat([df[‘name’],df[‘id’], df4,df[‘time’]], axis=1)

1587364519106

5、res.columns=[‘name’, ‘id’, “CGI”, ‘time’]

1587364534807

1、 写入本地 csv

1587364550547

9.5.2 反向缩减

9.5.2.1 设计要点

9.5.2.2 调用关系

1587364589875

9.5.2.3 流穿越

1、读取源文件

1587364613553

2、分组后转 dict

res=df.groupby(["name","id","time"])
data=dict(list(res))
print(data)

1587364737449

3、应用列表生成式取 key

for key,value in data.items():

    [list_value.append(  i) for i in list(key)]

1587364751647

4、应用列表生成式取 value

list_value.append( ''.join( [i+"," for i in value["CGI"]]))

print(list_value)

1587364794794

5、将所有结果存储至 list 中

1587364807726

6、 list 转 dict

1587364821915

7、 写入本地

1587364835691

9.6 正向增扩方案详解

9.6.1 正向增扩领域对象模型

1587364861906

图 9-1 正向增扩相关的领域模型

从上图可见,以上是正向增扩相关的领域对象模型。相关模型的主要的操作包括

1.选择 CGI 字段进行字符串拆分为多列操作,形成一个 DF2。

2.将 DF2 进行行列转换,并删除索引。

3.将多列数据进行合并,生成结果 RES(dataframe 格式), 重新命名。

9.6.2 关键知识点

数据拆分-正向增扩方案1、行列转换DF.stack()
2,DF 的索引模型说明 DF 的结构
对 df 一列进行字符串切割df[].str.split()
重排乱序索引df.reset_index()
df 标题重命名df.columns=[]

9.6.3 行列转换

9.6.3.1 应用目的

信息提取,在海量数据中,筛选所需信息结构。

9.6.3.2 语法说明

df.stack()

9.6.3.3 case 举例

pandas 中,这三种方法都是用来对表格进行重排的,其中 stack()是 unstack()的逆操作。某种意义上,unstack()方法和 pivot()方法是很像的,主要的不同在于,unstack()方法是针对索引或者标签的,即将列索引转成最内层的行索引;而 pivot()方法则是针对列的值,即指定某列的值作为行索引,指定某列的值作为列索引,然后再指定哪些列作为索引对应的值。因此,总结起来一句话就是:unstack()针对索引进行操作,pivot()针对值进行操作。但实际上,两者在功能往往可以互相实现。

unstack(self, level=-1, fill_value=None)、pivot(self, index=None, columns=None, values=None,对比这两个方法的参数,这里要注意的是,对于pivot(),如果参数values指定了不止一列作为值的话,那么生成的DataFrame的列索引就会出现层次索引,最外层的索引为原来的列标签;unstack()没有指定值的参数,会把剩下的列都作为值,即把剩下的列标签都作为最外层的索引,每个索引对应一个子表。

pivot()方法其实比较容易理解,就是指定相应的列分别作为行、列索引以及值。下面我们通过几张原理图详细说明stack()和unstack(),最后再通过一个具体的例子来对比stack()、unstack()和pivot()这三种方法。

先看stack(),如图。stack()是将原来的列索引转成了最内层的行索引,这里是多层次索引,其中AB索引对应第三层,即最内层索引。

1587365023901

再看 unstack(),如图。显然,unstack()是 stack()的逆操作,这里把最内层的行索引还原成了列索引。但是 unstack()中有一个参数可以指定旋转第几层索引,比如 unstack(0)就是把第一层行索引转成列索引,但默认的是把最内层索引转层列索引。

1587365041446

最后,我们在看一个具体的例子。首先我们构造一个如下图的 DataFrame 对象,现在目的是要把 ticker 列作为行索引,tradeDate 列作为列索引,closeIndex 作为值,生成一个新的表格。这可以通过 unstack()和 pivot()分别实现,我们先看 unstack()如何实现。

1587365056251

我们之前说过,unstack()是针对索引的,因此,我们需要先把 ticker 和 tradeDate 这两列的值设置为索引,然后才能对其进行操作,代码如下。利用 DataFrame 的 set_index()方法,并把需要作为 index 的两列标签的列表作为参数传递给这个方法,就可以把这两列设置为行索引。

1587365077597

设置成行索引后,我们可以对这个对象用 unstack()方法,默认把最内层转为列索引,代码如下。如图输入的结果,已经实现了我们目的,其中 closeIndex 作为列的最外层索引出现,如果我们再加一条代码 df_daily_industry_symbol.set_index([‘tradeDate’,‘ticker’]).unstack()[‘closeIndex’],则就会得到 closeIndex 索引下的表格。

1587365106929

1587365128123

最后,我们看下如何用 pivot()实现这个目的,代码如下。显然,用 pivot()方法简单很多,可以直接通过设置相关参数实现。但是这里由于 ticker 和 tradeDate 最初就是值而不是索引,索引可以直接这样一行代码解决,若原数据中,这两列本来就是多层次的索引,那么用 unstack()就会简单很多,因此,用什么方法取决于原数据的构成。

1587365147438

9.6.3.4 注意事项

请根据实际应用场景,选择使用

9.6.4 DF 的索引模型

9.6.4.1 应用目的

Pndas 是一个强大的分析结构化数据的工具集,基于 NumPy 构建,提供了 高级数据结构 和 数据操作工具,它是使 Python 成为强大而高效的数据分析环境的重要因素之一。

1.一个强大的分析和操作大型结构化数据集所需的工具集

2.基础是 NumPy,提供了高性能矩阵的运算

3.提供了大量能够快速便捷地处理数据的函数和方法

4.应用于数据挖掘,数据分析

5.提供数据清洗功能

9.6.4.2 语法说明+case- Series

Pandas 的数据结构- Series

import pandas as pd

Pandas 有两个最主要也是最重要的数据结构: Series 和 DataFrame

Series

Series 是一种类似于一维数组的 对象,由一组数据(各种 NumPy 数据类型)以及一组与之对应的索引(数据标签)组成。

类似一维数组的对象

由数据和索引组成

索引(index)在左,数据(values)在右

索引是自动创建的

1587365789938

1. 通过 list 构建 Series
ser_obj = pd.Series(range(10))

1587365818517

输出

1587365845302

2. 获取数据和索引
ser_obj.index 和 ser_obj.values

1587365874820

输出

[10 11 12 13 14 15 16 17 18 19]

RangeIndex(start=0, stop=10, step=1)

3. 通过索引获取数据
ser_obj[idx]

1587365893439

输出:

10

18

4. 索引与数据的对应关系不被运算结果影响

1587365911312

效果:

1587365925938

5. 通过 dict 构建 Series

1587365967691

1587366002379

6、name 属性

对象名:ser_obj.name

对象索引名:ser_obj.index.name

1587366019608

1587366033575

9.6.4.3 语法说明+case-df

DataFrame

DataFrame 是一个表格型的数据结构,它含有一组有序的列,每列可以是不同类型的值。DataFrame 既有行索引也有列索引,它可以被看做是由 Series 组成的字典(共用同一个索引),数据是以二维结构存放的。

类似多维数组/表格数据 (如,excel, R 中的 data.frame)

每列数据可以是不同的类型

索引包括列索引和行索引

1587366058318

1. 通过 ndarray 构建 DataFrame

输出如下:

1587366135614

2. 通过 dict 构建 DataFrame

1587366162858

3. 通过列索引获取列数据(Series 类型)
df_obj[col_idx] 或 df_obj.col_idx

1587366199505

1587366219410

4. 增加列数据
df_obj[new_col_idx] = data
类似 Python 的 dict 添加 key-value
5. 删除列
del df_obj[col_idx]

9.6.4.4 Pandas 的索引操作-

索引对象 Index

1、index 对象
1. Series 和 DataFrame 中的索引都是 Index 对象

1587366332782

1587366352137

2. 索引对象不可变,保证了数据的安全

1587366396025

常见的 Index 种类

Index,索引

Int64Index,整数索引

MultiIndex,层级索引

DatetimeIndex,时间戳类型

2、Series
索引
1. index 指定行索引名

1587366433729

2. 行索引

ser_obj[‘label’], ser_obj[pos]

1587366449486

1587366460681

3. 切片索引

ser_obj[2:4], ser_obj[‘label1’: ’label3’]

注意,按索引名切片操作时,是包含终止索引的。

1587366479934

1587366493669

4. 不连续索引

ser_obj[[‘label1’, ’label2’, ‘label3’]]

1587366510035

1587366530556

5. 布尔索引

1587366568461

3、Df 索引
1. columns 指定列索引名

1587366600855

1587366614523

2. 列索引
df_obj[[‘label’]]

1587366634663

1587366648966

3. 不连续索引
df_obj[[‘label1’, ‘label2’]]

1587366669912

1587366683995

4、高级索引:标签、位置和混合

Pandas 的高级索引有 3 种

1. loc 标签索引

DataFrame 不能直接切片,可以通过 loc 来做切片

loc 是基于标签名的索引,也就是我们自定义的索引名

1587366708712

1587366728563

2. iloc 位置索引

作用和 loc 一样,不过是基于索引编号来索引

1587366748708

1587366766327

3. ix 标签与位置混合索引

意涵,为以上二者的结合,老版本语法,目前显示已过时不再推荐使用!

9.6.4.5 注意事项

DataFrame 索引操作,可将其看作 ndarray 的索引操作

标签的切片索引是包含末尾位置的

9.6.5 对 df 一列进行字符串切割

见 8.4.3

9.6.6 重排乱序索引

见 7.5.3

9.6.7 df 标题重命名

应用目的

语法说明

case 举例

注意事项

数据拆分- 列行增扩1、行列转换DF.stack()
2,DF 的索引模型说明 DF 的结构
3,对 df 一列进行字符串切割df[].str.split()
4,重排乱序索引df.reset_index()
5,df 合并Concat()
6,df 标题重命名df.columns=[]

备注: 这里重点讲解一下 multi-index 的结构

1587366858069

9.6.8 在 multiIndex 中选定指定索引的行

9.6.8.1 应用目的

我们在用 pandas 类似 groupby 来使用多重 index 时,有时想要对多个 level 中的某个 index 对应的行进行操作,就需要在 dataframe 中找到该 index 对应的行,在单层 index 中我们可以方便的使用 df.loc[index]来选择,在多重 Index 中我们可以利用的类似的思路

9.6.8.2 语法+case

1 index 为有序的

1.1 创建测试数据

首先创建一个 dataframe 数据

df = pd.DataFrame({'class':['A','A','A','B','B','B','C','C'],

                   'id':['a','b','c','a','b','c','a','b'],

                   'value':[1,2,3,4,5,6,7,8]})

df 中内容如下图:

1587366951747

1.2 设置 multiIndex

通过 set_index 设为多重索引

df = df.set_index(['class','id'])

设置索引后效果:

1587366978582

1.3 切片筛选 index

这里同样使用 loc 定位

df.loc[('A',slice(None)),:]

各参数的解释如下:

loc[(a,b),c]中第一个参数元组为索引内容,a 为 level0 索引对应的内容,b 为 level1 索引对应的内容

因为 df 是一个 dataframe,所以要用 c 来指定列

这里‘A’,指选择 class 中的 A 类

slice(None), 是 Python 中的切片操作,这里用来选择任意的 id,要注意!不能使用‘:’来指定任意 index

‘:’,用来指定 dataframe 任意的列

执行后的结果如下:

1587367007364

同样,如果想只保留 id 中的’a’,则可以使用:

df.loc[(slice(None),'a'),:]

2 index 无序

前面的例子对应的 index 列为数字或字母,是有序的,接下来我们看看 index 列为中文的情况。

2.1 创建无序测试数据

df2 = pd.DataFrame({'课程':['语文','语文','数学','数学'],'得分':['最高','最低','最高','最低'],'分值':[90,50,100,60]})

df2 = df2.set_index(['课程','得分'])

1587367049956

2.2 尝试切片选择 index

df2.loc[('语文',slice(None)),:]

我们进行同样的操作,这时会发现提示出错:

UnsortedIndexError: ‘MultiIndex Slicing requires the index to be fully lexsorted tuple len (2), lexsort depth (0)’

这是因为此时的 index 无法进行排序,在 pandas 文档中提到:Furthermore if you try to index something that is not fully lexsorted, this can raise:

我们可以通过 df2.index.is_lexsorted()来检查 index 是否有序,

In[1]: df2.index.is_lexsorted()

out[1]: False

接下来,我们尝试对 Index 进行排序。(排序时要在 level 里指定 index 名)

2.3 对 index 排序后切片选择 index

df2 = df2.sort_index(level='课程')

df2.loc[('语文',slice(None)),:]

1587367097878

9.6.8.3 注意事项

使用 loc 时,如果 df index 乱序会产生报错,用 sort_index 来重新排列

9.7 反向合并方案详解

9.7.1 反向合并的领域对象模型

1587367130973

图 9-2 反向合并的领域对象模型

从上面的分析可见,整个的处理过程比较复杂,主要包含两个部分:

  1. DF2dict{}: 在这个阶段,将 DF 经过分组以后,转换为一个 dict{} 结构。

  2. 构建目标信息结构:在这个阶段,是通过字典的方式来构建目标信息结构。

下面分别做一个介绍

9.7.1.1 分组对象 res

首先从用例的角度进行分析,我们需要将多行数据合并为 1 行数据,此时要能够确定合并的条件。目前合并的条件见下图:

1587367166922

图 9-3 合并条件

从上图可见,相关的转换过程中,核心是需要能够将具有共性特征的行数据压缩为 1 行,这就正好适合应用分组的功能。

主要的代码为:

1587367181995

经过 groupby()操作以后,我们获得了一个 pandas 的对象,这个对象是一个不可打印对象。

1587367195519

1587367210500

图 9-4 分组以后的对象

这个对象中,存在 2 个元素。这个是根据应用的分组条件而言的。

因为 csv 文件只有两行,所以是 2 个元素 其中每个元素中还有两个元素,类似如下:(((),df),((),df))

1587367257607

,进一步打印这两个元素,会发现如下的结构:

1587367274564

图 9-5 遍历观察其中的元素

9.7.1.2 分组对象转换为字典

data=dict(list(res))

这里是两步转换法,首先

1,list 转换

list(res) 经过转换以后获得了一个结构:

【((元组),df),((元组),df)】 这个结果也是一个 list,其中有两个元素。

打印结构为:

1587367304065

2.将 list 转换为字典

{(元组 1):df1,(元组 2):df2}

1587367348203

这个就一行代码,就是将 df 分组后。分组选择项的值作为字典的 key,其他项为 df 为字典的 value。这样就可以随意组合数据了。

9.7.1.3 关键转换

1587367368366

1、应用列表生成式取 key,生成 3 个字段

for key,value in data.items():

    [list_value.append(  i) for i in list(key)]

1587367388152

1587367404896

备注: 这里是从元组中取值,所以列表生成方式应用在外面。

2 、应用列表生成式取 value,生成 1 个字段,进行追加,形成 4 个字段

list_value.append( ''.join( [i+"," for i in value["CGI"]]))

print(list_value)

1587367427798

备注: 这里是从 1 个 DF 中取值,所以列表生成式的条件在内部。

4、将所有结果存储至 list 中

1587367445948

9.7.2 关键知识点

1587367465488

反向合并方案1,从元组中取值列表生成式
2,从 DF 中取值列表生成式
3,从 DF 中取值dict(list(df.groupby))
4,字典的迭代items
5,list 转 dfpd.DataFrame(list)

9.7.3 从元组中取值

9.7.3.1 应用目的

Information 提取

9.7.3.2 语法说明

基本列表生成式,不涉及复杂语法

9.7.3.3 case 举例

df 复合型数据结构

1587367555695

代码:

1587367571008

新建空 list 中存放的值

1587367587112

9.7.3.4 注意事项

需要根据应用场景自己选择,流处理方案

9.7.4 从 DF 中取值

9.7.4.1 应用目的

根据题目要求,选择合适的流穿越方案

9.7.4.2 语法说明

列表生成式,不涉及新语法

9.7.4.3 case 举例

初始 df:

1587367624319

df 复合型数据结构

1587367641505

源 list,上一步得出:

1587367655179

代码:

1587367670997

新 list:

1587367684811

9.7.4.4 注意事项

需要进行,详尽的流穿越设计。

9.7.5 分组后转字典

9.7.5.1 应用目的

流转换

9.7.5.2 语法说明

data=dict(list(df))

9.7.5.3 case 举例

初始 df:

1587367724517

df = pd.read_excel("./单格转多格.xlsx", encoding='gbk')

res=df.groupby(["name","id","time"])

data=dict(list(res))

1587367737545

9.7.5.4 注意事项

9.7.6 字典的迭代

9.7.6.1 应用目的

流转换

9.7.6.2 语法说明

1587367772037

9.7.6.3 case 举例

1587367790605

1587367804599

9.7.6.4 注意事项

掌握流穿越细节

9.7.7 list 转 df

见 9.6.4.3

9.8 总结

本章讲解了一个非常重要的操作,就是行列增扩,其中的 DF.stack()用法,可以灵活的处理很多复杂的应用。由于 pandas 强大的内生结构,使得我们可以很方便的来处理一些复杂额格式变换的操作。

分享到微博
Starter
MicroServ
Tutorials
Report
Blog