python 数据分析 |3. Pandas 学习

利用Pandas库可以快速地完成数据读写、数据分片／分组统计、数据整理等操作。Pandas的所有功能都是构建在两个最基础的数据结构之上：Series与DataFrame

Series是一种类似于一维数组的对象，由一组数据，以及一组与之相关的数据标签（即索引）组成。

DataFrame是一个表格型的数据结构，包含一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型等），DataFrame既有行索引，也有列索引，可以看作是由Series组成的字典。

目录

1.1 DataFrame

1.2 数据类型

1.3 Series

1.4 属性

1.5 方法

1.6 修改索引与列

1.7 分组、应用和聚合

1.8 数据读入

1.9 数据合并

1.1 DataFrame

DataFrame有3个基本要素，它们分别是索引、列、数据。首先运行如下代码。

 # 导入Pandas库
import pandas as pd

设置Jupyter Notebook中显示数据时，最多显示7行
pd.set_option('display.max_rows',7)
设置Jupyter Notebook中显示数据时，最多显示6列
pd.set_option('display.max_columns',6)

read_csv（）函数来将本地目录下的数据文件Online_Retail_Fake.csv读入到一个DataFrame中
retail_data = pd.read_csv("../data/Online_retail_Fake.csv")
head( )函数只能读取前五行数据
retail_data.head()

DataFrame把索引和列都当作轴（axis），一个DataFrame有一个竖轴（Index）和一个横轴（Columns）。分别用0/1来表示竖/横轴。 在函数中指定参数axis=0的情况，就是指函数是作用于行。 在函数中指定参数axis=1的情况，就是指函数是作用于列 DataFrame中每一列数据要求是相同类型，但是不同列却可以是不同数据类型。对于数据缺失的情况，Pandas中采用了NaN进行表示。

index= retail_data.index  # 获取索引总行数
columns = retail_data.columns # 获取列类信息
data = retail_data.values #获取所有数据列表

1.2 数据类型

Pandas中的主要数据类型。

查看DataFrame对象中列的数据类型
retail_data.dtypes

 查看DataFrame中每种数据类型各有几列
retail_data.dtypes.value_counts()

1.3 Series

Series就是构成DataFrame的列，每一列就是一个Series。一个Series是一个一维的数据类型，其中每一个元素都有一个标签，类似于NumPy中元素带标签的数组。标签可以是数字或字符串。如果访问DataFrame中的某一列，可以采用如下代码。

第一种访问方式  操作符 "[列名]"
访问 Country 列 ,返回一个Series，包含Index和数据，同时改Series的列名为Country
retail_data['Country']

 第二种访问方式 操作符  ".列名"
不建议使用 如果对应的列名包含特殊字符，这种方法可能无效
retail_data.Country

Series运算，获取了某一列数据后，Python中支持的大部分运算操作符都可以应用于Series，代码如下。

retail_data["UnitPrice"] + 1  #  每个数据都加1，为True/False的新Series。
retail_data["UnitPrice"] * 2  #  每个数据都乘以2，
retail_data["UnitPrice"] > 2  #  将列中的每个数据与2比较，返回取值为True/False的新Series
retail_data.Country == 'France' #  字符串比较，返回取值为True/False的新Series

对DataFrame的列进行逻辑运算，之后赋值给新的列
retail_data['key_customer'] = retail_data["Total_price']>1000

1.4 属性

shape属性，可查看数据 行列

df.shape

size 属性可以查看数据总数

df.size

ndim属性查看数据的维度

df.ndim

1.5 方法

在Pandas库中，DataFrame和Series的很多操作都将返回一个新的DataFrame或Series，此时我们又可以对新的DataFrame和Series进行方法调用

如果想直接在原DataFrame上修改，通常只需要在函数中加上参数inplace=True就可以了。

head（）函数查看数据的前5行 tail（）函数查看数据的后5行

df.head()
df.tail()

dtypes() 函数获取DataFrame的每一列的数据类型

df.dtype()

memory_usage(deep=True) 函数，是对数据所占内存进行精确统计

deep=True参数 代表是否计算引用的对象的内存使用情况
men = df.memory_usage(deep=True)

转换为兆字节显示
round(men.sum()/(1024*1024))

info() 函数获取元数据信息是数据的类型、占用内存大小信息

df.info()

value_counts（）方法统计某列有多少重复值

 先获取了CustomerID列，并将其赋值给了一个新变量customers
customers= retail_data["CustomerID"]

 用value_counts（）方法统计某列有多少重复值
customers.value_counts()

nunique() 统计DateFrame中每列的不同值的个数

df.nunique()

astype() 函数 用于转化dateFrame 某一列的数据类型

retail_data["Country"] = retail_data["Country"].astype('category')

isnull() 函数 用来对DataFrame或Series中的缺失值进行统计

notnull（）函数判断是否存在缺失值

isnull()  notnull（）函数判断是否存在缺失值
retail_data['UnitPrice'].isnull()
retail_data['UnitPrice'].notnull()

 调用sum（）函数，该函数将对Series的值的总和
retail_data['UnitPrice'].isnull().sum()

mean（）函数用求平均值函数，来获取缺失数据所占比例

用求平均值函数mean（）来获取缺失数据所占比例
df.mean(0) 按列求平均值
df.mean(1) 按行求平均值
retail_data['UnitPrice'].isnull().mean()

mode() 函数 获取沿选定轴的众数

获取数据中最常出现的数
df.mean(0) 按列获取
df.mean(1) 按行获取
retail_data['UnitPrice'].mode()

fillna（）函数对缺失数据进行填充

 利用fillna（）函数对缺失数据进行填充
retail_data['UnitPrice'].fillna(0)

 填充时指定limit，每列最多填充 3次
retail_data['UnitPrice'].fillna(0,limit=3)

均值填充
retail_data['UnitPrice'].fillna(retail_data['UnitPrice'].mean(), limit=3)

用前值填充
retail_data['UnitPrice'].fillna(retail_data['UnitPrice'].mean(), limit=3)

用后值填充
retail_data['UnitPrice'].fillna(method='bfill')

手工补充值  指定索引标签处的值用指定值来代替的功能
fill_values = pd.Series([1,2],index=['b','c'])
df['c4'].fillna(fill_values)

interpolate() 函数插值函数来完成缺失值的补齐

不考虑索引因素插入
df.interpolate()

考虑时间插入 method="time"
df.interpolate(method="time")

非时间索引也可以采用类似方法指定参数method='values'
df.interpolate(method='values')

数据是倒序排列，所以需要按照索引重新排序

按照索引排序
df.sort_index()

按照数值排序
ascending=False参数表明是降序排列，升序则为True。
df.sort_values(ascending=False)

指定多列排序
df.sort_values(['Total_price','Country'],ascending=True)

pct_change() 函数用于计算某列元素与前元素之间的百分比

计算涨跌幅，用pct_change（）函数来实现

sh = pd.read_csv("../data/sh.cvs",index_col="data")
percent = sh["close"].pct_change()
sh.head()

to_datetime（）函数可以完成时间类型的转换

retail_data['InvoiceDate'] = pd.to_datetime(retail_data['InvoiceDate'])

duplicated()函数,用于查看数据是否存在重复，

subset可以指定只针对特定列数据来判断重复,可以指定subset='CustomerID'。
 keep参数取值可以为'first'，'last'，False，取值为'first'代表了第一个取值不标记为重复，'last'则#  相反，False则代表只要相同就是重复

retail_data_na.duplicated()

drop_duplicates()函数可以丢弃重复数据

 检查指定列，多列 数据，丢弃重复数据
df.drop_duplicated(['a','b'])

丢弃重复数据，可以选择是保留前面的数据还是后面的重复数据
df.drop_duplicated(method='last')

describe()函数默认会给出数据计数、均值、标准差、最大值、最小值和第1，2，3分位数。

T代表求转置，即行列变换
retail_data.describe(include=[np.number]).T

percentiles 分别指定了函数输出要显示的分位数   include 指定np.number类型的列
retail_data.describe(include=[np.number], percentiles=[.05, .10,.25, .5, .75, .9, .95]).T

数值类型，describe()函数输出均值等信息，其他类型，输出则是计数、不同值个数、出现频率等信息
retail_data.describe(include=[np.object]).T

nlargest(num, ‘columns_name’)查看一定数量的最大值

retail_data.nlargest(50,'Total_price').head()

nsmallest(num, ‘columns_name’)查看一定数量的最小值

retail_data.nsmallest(50,'Total_price').head()

拆分数据

melt() 将数据流从宽格式转换为长格式

 melt 参数
 frame：需要处理的数据框。 　
 id_vars：保持原样的数据列。不需要别转换的列名 　
 value_vars：需要被转换成变量值的数据列。 如果剩下的列全部要转换，就不用写了　
 var_name：转换后变量的列名。 自定义设置对应列名　
 value_name：数值变量的列名。 自定义设置对应列名　
df = pd.read_csv("../data/pew-raw.csv")
df.head(5)
formatted_df = pd.melt(df, id_vars=['religion'], var_name='income',value_name='freq')

stack()函数 即堆叠， 作用是将 列旋转到行

unstack()函数，将行旋转到列

 stack()函数
formatted_df = df.set_index('religion')
formatted_df = formatted_df.stack()
formatted_df.index = formatted_df.index.rename('income',level=1)
formatted_df.name = 'frep'
formatted_df = formatted_df.reset_index()
formatted_df.head()

extract() 文本数据方法

Series.str.extract(pat,flags=0,expand=None)
pat:字符串或正则表达式
flags：整型
expand： 布尔型，是否返回数据框
returns dataFrame/索引index

df['week'] = df['week'].str.extract('(\d+)',expand=False).astype(int)

用pivot_table()函数将单列数据拆分为两列

pivot_table（）函数将原来的id、date列变换成为行的索引
df = df.pivot_table(index=["id","date"],columns="element",values="value")

需要利用reset_index（）函数将多级索引id、date还原到列
df.reset_index(drop=False,inplace=True)

pandas.to_numeric() 将参数转换为数字类型

将参数转换为数字类型
默认返回dtype 为float64 或int64 具体取决于提供的数据，
arg:  scalar, list,tuple,series
errors: {'ignore','raise','coerce'} 默认为raise 则无效的解析会发生异常，coerce 无效解析设置为# NAN ， 如果为ignore 则无效的解析返回输入
downcast {integer','signed','unsigned','float'}
默认为none

pandas.to_numeric(arg, errors='raise', downcast=None)

df[["id","year","month"]] = df[["year","month","id"]].apply(lambda x:pd.to_numeric(x,errors='ignore'))

pandas.to_datetime() 将参数转换为时间数据

将参数转换为时间数据
arg
errors: {'ignore','raise','coerce'} 默认为raise 则无效的解析会发生异常，coerce 无效解析设置为# NAN ， 如果为ignore 则无效的解析返回输入
format 格式化显示时间格式
unit: 默认值为 ns,则将会精确到微秒，s 为秒

pandas.to_datetime(arg, errors='ignore', format="%Y%m%d")

pandas.to_timedelta() 将参数转换为timedelta

arg: str ,timedelta 类似list或者raise
unit: 默认 ns  表示arg单位，可能取值 Y M W D days day  hours hour hr h m  minute min
minutes  T S seconds ms等
errors: {'ignore','raise','coerce'} 默认为raise 则无效的解析会发生异常，coerce 无效解析设置为# box: 默认为True，则返回结果的TimeDelta/Timedeltaindex

pandas.to_timedelta(arg, errors='ignore', unit="w")

pandas.DateOffset() 函数用于时间戳的加减

pandans.DateOffset() 常用参数
months、days、years、hours、minutes、minutes、seconds

df['date'] = pd.to_datetime(df['date.entered'])+pd.to_timedelta([df['week'],unit='w')-pd.DataOffset(weeks=1)

apply()函数，函数作为一个对象，能作为参数传递给其他函数

df[["id","year","month"]] = df[["year","month","id"]].apply(lambda x:pd.to_numeric(x,errors='ignore'))

1.6 修改索引与列

默认的索引值，取值为0，1，…然而分析中想要的是用指定列的数据作为索引可以使用参数index_col=”,在读取数据时就将某列设置为索引.。 或者在读入数据后，再使用函数set_index()修改

第一种方式
指定列作为索引 index_col("列名") 或者使用 index_col("索引")
gapminder = pd.read_csv("../data/gapminder.csv",index_col='Life expectancy')
gapminder.head()

第二种方式
读入数据后再修改 set_index
gapminder =  pd.read_csv("../data/gapminder.csv")
gapminder=gapminder.set_index("Life expectancy")
gapminder.head()

reset_index() 函数将索引重新恢复到列中

将索引重新恢复到列中 reset_index()
gapainder.reset_index()

如何同时修改索引与列名 rename(index=” “,columns=” “,level=索引)

同时修改索引与列名 rename 返回的是一个新的DataFrame
gapminder = pd.read_csv("../data/gapminder.csv",index_col="Life expectancy")
idx_rename = {'Abkhazia':'Abk','Afghanistan':'Afg'}
col_rename = {'Unnamed:0':'Wrong Column','1801':'1801Y'}
gapminder_new = gapminder.rename(index=idx_rename,columns=col_rename)
gapminder_new.head()

 修改列名位置，按照指定列名顺序排序
price_info = ["UnitPrice","Quantity","Total_price"]
invoice_info=["InvoiceNo","InvoiceDate","StockCode","Description"]
customer_info=["CustomerID","Country"]
columns_new = price_info + invoice_info + customer_info、

retail_data_new = retail_data[columns_new]
retail_data_new.head()

index和columns也可以转换为列表对象，可以通过直接将一个列表赋值给index和columns的方法来完成修改

retail_data = pd.read_csv("../data/Online_Retail_Fake.csv")
retail_data.head()
添加新列 只需要给该列赋值就可以完成
retail_data['Total_price'] = retail_data['UnitPrice']*retail_data['Quantity']
retail_data[['Total_price','UnitPrice','Quantity']]

获取指定列的位置 , .columns.get_loc(“列名”)

获取指定列所在位置 .columns.get_loc("列名")
totalPrice_index = retail_data.columns.get_loc("CustomerID")+1

指定位置，增加新列，采用insert（loc=’ ‘, column=’ ‘, value=’ ‘）方法

retail_data.insert(loc=totalPrice_index,column="New_totalPrice",value=retail_data['Total_price'])
retail_data.head()

使用drop() 方法删除列,drop（）方法返回的是一个新的DataFrame

删除指定列 使用 drop('列名',axis='columns')
retail_data.drop('New_totalPrice',axis='columns')

dropna() 删除存在缺失数据行

删除存在有缺失值的数据行
df.dropna()

删除整行都是缺失值的行， how='all'代表了要整行都是缺失数据才丢弃
df.dropna(how='all')

axis=1代表了要整列都是缺失数据才丢弃该列
df.dropna(how='all',axis=1)

指定一个阈值 thresh,要求至少有几列数据不是缺失值
df.dropna(thresh=4)

使用del 方法删除列

使用 del 删除指定列
del retail_data['New_totalPrice']

选择多列，返回一个新的DataFrame

DataFrame[[ "xx","xx","xx" ]] 指定列名，选择多列，返回一个新的DataFrame
retail_data[["Total_price", "UnitPrice","Quantity" ]]

根据数据类型选择多列   select_dtypes(include=[数据类型])
retail_data.dtypes.value_counts()  #查看DataFrame的包含的数据类型
retail_data.select_dtypes(include=['float64']).head()  # select_dtypes() 选择数据类型

根据字符串匹配选择列 filter()  有3个互斥的参数 分别为items、regex和like
items中的列名不存在，此时不会返回KeyError错误
retail_data.filter(items=['Total_price','UnitPrice']).head()

#

选择特定行

读取数据并新增Total_price 列
retail_data = pd.read_csv("../data/Online_Retail_Fake.csv")
retail_data["UnitPrice"] = retail_data["UnitPrice"].fillna(retail_data["UnitPrice"].mean())
retail_data["Quantity"] = retail_data["Quantity"].fillna(retail_data["Quantity"].mode())
retail_data["Total_price"] = retail_data["UnitPrice"]*retail_data["Quantity"]

选择country 列
country = retail_data['Country']

#返回特定的行
第一种方式：使用iloc[索引下标] 返回特定行
country.iloc[0],country.iloc[7279],country.iloc[541909]

 同时选择多行 iloc[["","",""]]
country.iloc[[0,7279,541909]]

切片方式选择多行
country.iloc[10:50:10]

第二种方式： 遇到索引不是数字，是字符的，使用.loc来选择对应的行、
college = pd.read_csv("../data/College.csv",index_col=0)
college.loc['Yale University']

同时访问多行 切片
college.loc["Abilene Christian University":"Alaska Pacific University"：50]

同时选择行与列，rows代表了行的选择，它既可以是列表，也可以是数据切片方式的输入，columns代表了列的选择 df.iloc[rows, columns] df.loc[rows, columns]

df.iloc[rows, columns]      df.loc[rows, columns]
 “:”后没有内容，那么代表直到结束；
 前面没有内容，那么代表直到开始
 只是“:”，那么代表所有行或列

college.loc["Westminster College of Salt Lack City":,:"Accept"].head()

college.loc[:,['Apps',"Accept"]].head()

college.iloc[-5:,:].head()

college.iloc[-5:,[1,2]].head()

在不输入列的情况下，默认选择所有列
college.iloc[:5].head()

多条件筛选

使用函数比较或者比较操作符 有 gt() 、eq（）、ne（）、le（）、lt（）、ge（）

比较函数 gt()、eq（）、ne（）、le（）、lt（）、ge（）
cwur['score'].gt(85)

1.7 分组、应用和聚合

首先将数据按照不同的key进行分割（Split），然后将求和函数sum（）应用（Apply）于各组，最后再将数据合并（Combine）到一起，得到最终结果

import pandas as pd
import seaborn as sns

#以Seaborn中自带的tips数据集为例对GroupBy进行讲解
df_tips = sns.load_dataset('tips')
df_tips

groupby() 函数创建一个DataFrameGroupBy对象,DataFrameGroupBy对象，是完成了图的Split工作，

df_tips.groupby(by='sex')

多列分组
df_tips.groupby(by=['sex','day'])

size() 是DataFrameGroupBy对象提供的一个分组聚合函数，该函数将自动统计Male组和Female组中的数据大小分组里面男性（Male）和女性（Female）各有多少

df_tips.groupby(by='sex').size()

get_group() 函数来获取指定组

groups=df_tips.groupby(by='sex')

对分组对象进行遍历
for group in groups:
    print(group)

获取指定组
groups.get_group('Female').head(3)

对分组中每列都进行聚合运算

df_tips.groupby(by='sex')['total_bill'].mean()

#提供了如下的聚合函数。 　
sum（）：求和 　
mean（）：求平均值
count（）：统计所有非空值 　
size（）：统计所有值 　
max（）：求最大值 　
min（）：求最小值 　
std（）：计算标准差

#count（）函数不会统计空值，而size（）函数只是统计组的大小，不管取值是否为空。

也可以使用agg（）或aggregate（）函数来进行分组统计
grouped=df_tips.groupby(by='sex')['total_bill'].agg('mean')

可以完成多种求值
grouped=df_tips.groupby(by='sex')['total_bill'].agg(['mean','min','max'])

可以对聚合后的列进行重命名
grouped=df_tips.groupby(by='sex')['total_bill'].agg([('tip_mean','mean'),('tip_min','min')])

不同列的进行不同的聚合运算
df_tips.groupby(by='sex').agg({'tip':[('avg_mean','mean'),('max_tip','max')],'total_bill':[('avg_bill',"mean")]})

自定义分组函数
grouped=df_tips.groupby(by='sex').agg({'total_bill': lambda bill:bill.max()-bill.min()})
不同的列定义不同的函数
grouped=df_tips.groupby(by='sex').agg({'total_bill': lambda bill:bill.max()-bill.min(),'tip':lambda tip:tip.max()})

grouped=df_tips.groupby(by='sex')['total_bill'].aggregate('mean')

自定义新函数
def max_deviation(s):
    std_score = (s-s.mean())/s.std()
    return std_score.abs().max()

df_tips.groupby('sex')['tip'].agg(max_deviation)

完成聚合后，想将Index去掉，那么可以直接使用reset_index（）函数
grouped.reset_index()

数据过滤与交换

filter（）和transform（）函数 进行过滤和变换

filter 对数据进行过滤
df_tips.groupby('day').filter(lambda x:x['total_bill'].mean()>20)

tarnsform 对数据进行交换
df_tips['day_average'] = df_tips.groupby('day')['total_bill'].tarnsform(lambda x:x.mea())

1.8 数据读入

常用的数据读取函数有：

read_csv()
to_csv()

read_excel()
to_excel()

read_hdf()
to_hdf()

read_sql()
to_sql()

read_json()
to_json()

read_html()
to_html

read_stata()
to_stata()

read_sas()
to_sas()

read_clipboard()
to_clipboard()

read_pickle()
to_pickle()

read_csv()读取数据

path = "../data/Online_Retail_Fake.csv"
读取文件 必要参数path给出文件路径，encoding 设置CSV文件编码格式，默认为 utf-8
 df = pd.read_csv(path,encoding='gbk')

指定用Team来作为index的列
df = pd.read_csv(path,index_col='Team')

sep 给出文件分隔符，默认为‘,’
 df = pd.read_csv(path,encoding='gbk',sep=',')

 设置文件标题 header默认为0，表示0行为标题，可以定None表示文件无标题，header为none，可以给定#   names来给定列名
 df = pd.read_csv(path,encoding='gbk',sep=',',header=None)
 df = pd.read_csv(path,header=None,names=list('abcdef'))

 支持预先指定列的数据类型
 df = pd.read_csv(path,header=None,names=list('abcdef'),dtype={'Goals':np.float64})

只需要读取部分列的数据，此时可以通过usecols参数来进行设置
 df = pd.read_csv(path,index_col=0,usecols=['Team','Goals','Shots on target'])

nrows 从文件开始时选取需要读取的行数
 df = pd.read_csv(path,encoding='gbk',sep=',',nrows=5)

skiprows 可以忽略前面行数
 df = pd.read_csv(path,encoding='gbk',sep=',',skiprows=5)

skipfooter 可以忽略 最后行数
df = pd.read_csv(path,encoding='gbk',sep=',',skipfooter=5)

na_values 一组可以用来替换NA值,数组中的值为NA
 df = pd.read_csv(path,encoding='gbk',sep=',',skiprows=5,na_values=[0])

read_excel()读取数据

path = "../data/Eueo2012_excel.xlsx"
读取文件 通过参数sheet_name可以指定读入哪一个表
eu12 = pd.read_excel(path,sheet_name='Eueo2011')

1.9 数据合并

pandas.merge()函数 将不同结构的数据框，按照一定条件进行合并

pandas.merge()参数
left： 参与合并左侧的DateFrame
right： 参与合并的右侧DataFrame
how： 'inner' 'outer' 'left' 'right' 默认为inner
on: 用于连接的列名 必须存在于两个DataFrame中
left_on: 左侧DataFrame中用作连接的列
right_on:   右侧DataFrame中用作连接的列
left_index: 将左侧的行索引用作其连接链
right_index: 将右侧的行索引用作其连接链
sort 根据连接链合并进行排序，大数据量是可禁用
suffixes: 字符串值元祖，用于追加到重叠列名的末尾 默认为_x _y
copy 设置为FALSE，可以在某些情况下避免将数据复制到结果数据结构中，默认总是复制

创建两个DataFrame
df1 = pd.DataFrame({'key':list("bbaca","data1":range(5)})
df2 = pd.DataFrame({'key':list("abc","data1":range(3)})

inner内连接， 并安装相同字段合并
pd.merge(df1,df2,on='key')

当两边合并字段不同是，可以使用left_on 和right_on 参数设置合并字段，left_on 和right_on值都是可以
pd.merge(df1,df2,left_on='key',right_on='key')

设置外联方式 ,取并集， 是左右连接的并集
pd.merge(df1,df2,how='outer')

设置左联方式 ,左连接是左侧DataFrame取全部数据，右侧DataFrame匹配左侧的DataFrame
pd.merge(df1,df2,how='left')

Pandas.join() 提供了函数来合并DataFrame的列

采用左连接方式基于索引进行合并，左边数据集的列会加上后缀_left，右边的加上后缀_right
left.join(right,lsuffix='_left',rsuffix='_right')

实现了外连接
left.join(right,how='outer',lsuffix='_left',rsuffix='_right')

实现了内连接
left.join(right,how='inner',lsuffix='_left',rsuffix='_right')

concat() 将数据根据不同的轴作简单的融合

objs: series,dataFrame 或者panel 构成的序列lsit
axis 需要合并链接的轴 0是行，1是列
join 连接方式inner 或者 outer
df.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None,
names=None, verify_integrity=False)

Original: https://blog.csdn.net/V_jome/article/details/121770828
Author: 马蹄疾
Title: python 数据分析 |3. Pandas 学习