参考：Kaggle Pandas Tutorial Part 1
参考：Kaggle Pandas Tutorial Part 2
参考：Pandas速查手册
- pandas.Series：单列的
- pandas.DataFrame：数据表格
ref: Pandas: Comparison with SQL（※ 文档中对比两者的实现方式）
Series([data, index, dtype, name, copy, …]) One-dimensional ndarray with axis labels (including time series).
I. Add new column
ref: Adding new column to existing DataFrame in Pandas
- By declaring a new list as a column
- By using DataFrame.insert()
- Using Dataframe.assign() method
- By using a dictionary
II. Loop through Series
- Series.iteritems()
- This function will return a list of tuples, so we should use item[1] to get the specific value of every row.
III. Loop through DataFrame
ref: Different ways to iterate over rows in Pandas Dataframe
- Using index attribute of the Dataframe
df["Name"][index] # 列名+索引 df["Name"] # 相当于获取 Series df["Name"][index] # 从 Series 中获取具体索引的值
- Using loc[] function of the Dataframe
可以直接修改信息df.loc[index, "Name"] # 索引+列名
按照列名定位 cell - Using iloc[] function of the DataFrame
与 loc[] 的区别就是列名改成列索引df.loc[index, index] # 行索引+列索引
- Using iterrows() method of the Dataframe
- Using itertuples() method of the Dataframe
- Using apply() method of the Dataframe
IV. Get Unique Values in A pandas column
- 获取列的不重复值，df.name.unique() ，参考：List Unique Values In A pandas Column
- 获取列不重复值的数量，df.name.value_counts() ，参考：Count unique values with pandas per groups [duplicate]
V. Sum DataFrame rows
-
df['Total'] = df.iloc[:, 1] + df.iloc[:, 2] + df.iloc[:, 3] df['Total'] = df.iloc[:, 1:4].sum(axis = 1) # row1+row2+row3
VI. Convert Strings to Floats for columns
ref: How to Convert Strings to Floats in Pandas DataFrame
-
df_geo_aus['co_lon'] = df_geo_aus['co_lon'].astype(float) df_geo_aus['co_lat'] = df_geo_aus['co_lat'].astype(float) df_geo_aus['geo_lon'] = df_geo_aus['geo_lon'].astype(float) df_geo_aus['geo_lat'] = df_geo_aus['geo_lat'].astype(float) df_geo_aus.dtypes
- 利用 astype() 来实现，然后通过 dtypes 来查看
VII. Keras Tutorial: Deep Learning
- if separator is a semicolon and not a regular comma
pd.read_csv("path", sep=';') - data exploration
df.info() - add a new column
red['type'] = 1
white['type'] = 0
# append 'white' to 'red'
wines = red.append(white, ignore_index=True) - heatmap from seaborn
import seaborn as sns corr = wines.corr() sns.heatmap(corr, xticklabels=corr.columns.values, yticklabels=corr.columns.values) plt.show() - import the train_test_split from sklearn.model_selection
# Import `train_test_split` from `sklearn.model_selection` from sklearn.model_selection import train_test_split # Specify the data X=wines.ix[:,0:11] # Specify the target labels and flatten the array y=np.ravel(wines.type) # Split the data up in train and test sets X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
- standardize the data
# Import `StandardScaler` from `sklearn.preprocessing` from sklearn.preprocessing import StandardScaler # Define the scaler scaler = StandardScaler().fit(X_train) # Scale the train set X_train = scaler.transform(X_train) # Scale the test set X_test = scaler.transform(X_test)
VIII. Rename columns of DataFrame
- 参考：python——修改Dataframe列名的两种方法
- df.rename(columns={'a':'A'}, inplace=True)
表示原地修改
目录
- Series 对象的几种创建方式
- DataFrame 对象的几种创建方式
- Series 对象元素的选取方式
- DataFrame 对象元素的选取方式
- 位置索引（查询）
- 自定义索引（查询）
- 在有多重索引的情况下进行选取
- 布尔索引（查询）
一、基础概念
- import pandas as pd，是 Pandas 库约定的导入方式。
- Pandas 库的两种重要数据类型：
Series类型（对应一维）和DataFrame类型（对应二维）。 - DataFrame 类型的每一列对应着一个 Series 类型。
- DataFrame 类型中行和列的概念，大部分方法默认使用的是行（即 axis=0），通过 axis=1 来指定使用列。注意这里的行和列指的是用来计算的部分，如使用不指定 axis 的 count() 时，会把每一列的所有行的值加起来。
二、创建基本对象
1. Series 对象的几种创建方式
# 不指定索引，也会有默认的位置索引（0...n），从 0 开始
pd.Series(range(5))
# 加上自定义索引，会和默认索引共存
pd.Series([9, 8, 7, 6], ['a', 'b', 'c', 'd'])
# 字典形式创建
pd.Series({'a':1, 'b':2, 'c':3})
# 根据索引选择字典中的值，不存在返回 NaN
pd.Series({'a':8, 'b':9, 'c':7}, ['c', 'b', 'd', 'a'])
# 和 Numpy 完美兼容
pd.Series(np.arange(3), ['one', 'two', 'three'])
>>> import pandas as pd
>>> pd.Series(range(5))
0 0
1 1
2 2
3 3
4 4
dtype: int64
>>> pd.Series([9, 8, 7, 6], ['a', 'b', 'c', 'd'])
a 9
b 8
c 7
d 6
dtype: int64
>>> pd.Series({'a':1, 'b':2, 'c':3})
a 1
b 2
c 3
dtype: int64
>>> import numpy as np
>>> pd.Series(np.arange(3), ['one', 'two', 'three'])
one 0
two 1
three 2
dtype: int32
2. DataFrame 对象的几种创建方式
# 用 ndarray 对象创建
pd.DataFrame(np.arange(10).reshape(2, 5))
# 用 Series 对象创建
dt = {
'one': pd.Series([1, 2, 3], ['a', 'b', 'c']),
'two': pd.Series([9, 8, 7, 6], ['a', 'b', 'c', 'd']),
}
pd.DataFrame(dt)
# 用字典组成的列表创建
lst = [{'one':1}, {'one':2}, {'one':3}]
pd.DataFrame(lst)
# 指定行列
dates = pd.date_range('20180101', periods=6) # 创建一个长度为 6 的时间序列，单位天
pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))
>>> pd.DataFrame(np.arange(10).reshape(2, 5))
0 1 2 3 4
0 0 1 2 3 4
1 5 6 7 8 9
>>> dt = {
'one': pd.Series([1, 2, 3], ['a', 'b', 'c']),
'two': pd.Series([9, 8, 7, 6], ['a', 'b', 'c', 'd'])
}
>>> pd.DataFrame(dt)
one two
a 1.0 9
b 2.0 8
c 3.0 7
d NaN 6
>>> lst = [{'one':1}, {'one':2}, {'one':3}]
>>> lst
[{'one': 1}, {'one': 2}, {'one': 3}]
>>> pd.DataFrame(lst)
one
0 1
1 2
2 3
>>> dates = pd.date_range('20180101', periods=6)
>>> pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))
A B C D
2018-01-01 -0.855157 -1.578338 1.225785 -0.114200
2018-01-02 0.281253 -0.120724 -1.423745 -1.715242
2018-01-03 1.699892 0.462409 -1.219692 0.870826
2018-01-04 -1.723124 -0.731188 -0.411660 -0.409501
2018-01-05 -0.730508 0.216860 -1.342256 2.212581
2018-01-06 -0.842541 -1.871722 -0.287997 -0.868190
3. Series 对象元素的选取方式
注意位置索引和自定义索引不能混用。
位置索引
# 选取第 2 行元素 s[1] # 选取第 2 到第 9 行元素 s[1:9] # 选取第 2 到最后，每隔 2 行的元素 s[1::2]
自定义索引
# 选取 one 行的元素 s['one'] # 选取 one 到 three 行元素 s['one':'three'] # 选取开头到 three 行，每隔 2 行的元素 s[:'three':2]
布尔索引
# 选取所有 value 小于 10 的 s s[s < 10] # 选取所有 value 大于等于 10，小于 20 的 s s[s.between(10, 20)] # 选取所有 value 等于 5 或 10 的 s s[s.isin([2, 5])]
4. DataFrame 对象元素的选取方式
注意位置索引和自定义索引不能混用。
要选取列，用这种方式，快很多（但不支持位置索引和切片）：
# 选择 xm 这一列，是 Series 类型 df['xm'] # 选择 xm 这一列，是 DataFrame 类型 df[['xm']] # 选择 xm, csrq 两列，是 DataFrame 类型 df[['xm','csrq']] # 列顺序会根据输入顺序返回，所以这种方法可以改变列顺序 df = df[['csrq', 'xm']]
5. 位置索引
# 选择第二行所有数据，是 Series 类型 df.iloc[2] # 选择第二行所有数据，是 DataFrame 类型 df.iloc[[2]] # 选择第二列所有数据，是 Series 类型 df.iloc[:, 2] # 选择第二列所有数据，是 DataFrame 类型 df.iloc[:, [2]] # 选择第 1、2、-2、-1 列所有数据，是 DataFrame 类型 df.iloc[:, [1, 2, -2, -1]] # 选择 0 到 2 列所有数据 df.iloc[:, 0:2] # 选择 2 和 3 行，0 到 2 列所有数据 df.iloc[[2,3], 0:2] # 根据位置快速取出数据，获取单个数据推荐这种方法 df.iat[1, 1]
>>> import numpy as np
>>> import pandas as pd
>>> a = np.arange(12).reshape(3, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> b = pd.DataFrame(a)
>>> b
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
>>> b.iloc[2]
0 8
1 9
2 10
3 11
Name: 2, dtype: int32
>>> b.iloc[[2]]
0 1 2 3
2 8 9 10 11
>>> b.iloc[:, 2]
0 2
1 6
2 10
Name: 2, dtype: int32
>>> b.iloc[:, [2]]
2
0 2
1 6
2 10
>>> b.iloc[:, [1, 2, -2, -1]]
1 2 2 3
0 1 2 2 3
1 5 6 6 7
2 9 10 10 11
>>> b.iloc[:, 0:2]
0 1
0 0 1
1 4 5
2 8 9
>>> b.iloc[[1,2], 0:2]
0 1
1 4 5
2 8 9
>>> b.iat[1, 1]
5
6. 自定义索引
# 选择指定行数据，是 Series 类型 df.loc['top'] # 选择指定行数据，是 DataFrame 类型 df.loc[['top']] # 选择指定列数据，是 Series 类型（不推荐） df.loc[:, 'xm'] # 选择指定列数据，是 DataFrame 类型（不推荐） df.loc[:, ['xm']] # 选择多列数据（不推荐） df.loc[:, ['bj','xm']] # 选择多列之间所有数据，列切片只能用这种方法 df.loc[:, 'bj':'xb'] # 选择指定行，指定列数据 df.loc[['top','count'], 'bj':'xb'] # 根据自定义索引快速取出数据，获取单个数据推荐这种方法 df.at['top', 'xm']
7. 在有多重索引的情况下进行选取
在用 df.set_index() 设置了多个索引的情况下使用。
# 一级索引，二级索引
df.loc[('state', 'city')]
# 上面的省略写法
df.loc['state', 'city']
# 同时指定列
df.loc[('state', 'city'), ['name']]
8. 布尔索引（查询）
类似 SQL 查询，可以选取需要的内容
# 选取所有出生日期大于等于 1998 年的数据，这里是字符串比较（直接比较数值查询）
df[df['csrq']>='1998']
# 选取所有出生日期大于等于 1997 年小于 1999 年的数据（and 关系查询）
df[(df['csrq']>='1997')&(df['csrq']<'1999')]
# 选取所有出生日期大于等于 1997 年小于 1999 年的数据（数值范围查询）
df[df['csrq'].between('1997', '1999')]
# 选取所有出生日期大于等于 1997 年或者姓名为张三的数据（or，不同属性的条件查询）
df[(df['csrq']>='1997')|(df['xm']=='张三')]
# 另一种选取方式（不推荐，实测效率比上面低）
df[df.csrq>='1998']
# 选择字段值为指定内容的数据（多个选择，类似 or，同一属性多个选择）
df[df['xm'].isin(['张三','李四'])]
三、Series 对象的使用实例
1. 重要属性
# 所有元素的 value，ndarray 类型 s.values # 元素类型 s.dtype # 元素的数量 s.size # 每个元素的大小，字节为单位 s.itemsize # 所有数据占用的大小，字节为单位，等于 `s.size * s.itemsize` s.nbytes
2. 常用方法
# 返回一个去重后的 ndarray 数组 s.unique() # 显示唯一值和计数，dropna=False 代表不包含 NaN s.value_counts(dropna=False) # 删除第一行，非原地 s.drop(0) # 在行尾添加数据，s 是 Series 对象 s.append(s) # 将 func 作用在 s 所有值上 s.apply(func) # 根据 s 的 value 排序，可传入 ascending 参数决定升序降序 s.sort_values() # 根据 s 的 index 排序，可传入 ascending 参数决定升序降序 s.sort_index() # 改变类型，非原地 s.astype()
3. 字符串系列方法
字符串类型在 Pandas 中显示为 object。
# 和 Python 原生字符串操作基本一致，只不过作用于所有元素
s.str.xxx()
# 是否包含字符串，支持通配符，返回 bool 数组
s.str.contains('Din*')
# 支持切片，同样作用于所有元素
s.str[1, -1]
4. 时间系列方法
先要用 pd.to_datetime(s['time']) 或 s.astype('datetime64[ns]') 把 Series 对象元素类型转成 datetime64[ns] 类型。
# 取出年月日 s.dt.date() # 取出时间 s.dt.time() # 取出年 s.dt.year() # 取出月 s.dt.month() # 取出日 s.dt.day() # 取出时 s.dt.hour() # 取出分 s.dt.minute() # 取出秒 s.dt.second()
5. 相关运算
# 所有元素加 1，原地 s += 1
其他符号的运算与此类似。
四、DataFrame 对象的使用实例
大部分也适用 Series 类型。
1. 重要属性
# 查看所有元素的 value
df.values
# 查看所有元素的类型
df.dtypes
# 查看所有行名，后加 `.tolist()`，可以返回列表
df.index
# 重命名行名，所有
df.index = ['总数', '不同', '最多', '频率']
# 查看所有列名，后加 `.tolist()`，可以返回列表
df.columns
# 重命名列名，所有
df.columns = ['班级', '姓名', '性别', '出生日期']
# 重命名列名，指定列，更好
df.rename(columns={'A':'a', 'B':'b', 'C':'c'}, inplace = True)
# 转置后的 df，非原地
df.T
>>> b.values
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> b.dtypes
0 int32
1 int32
2 int32
3 int32
dtype: object
>>> b.index
RangeIndex(start=0, stop=3, step=1)
>>> b.columns
RangeIndex(start=0, stop=4, step=1)
>>> b.columns.tolist()
[0, 1, 2, 3]
>>> b.T
0 1 2
0 0 4 8
1 1 5 9
2 2 6 10
3 3 7 11
2. 查看数据
# 查看 df 前 n 条数据, 默认 5 条 df.head(n) # 查看 df 后 n 条数据, 默认 5 条 df.tail(n) # 随机查看 n 条数据 df.sample(n) # 查看行数和列数 df.shape # 查看索引，数据类型和内存信息 df.info
3. 数据统计
默认统计的是行，但大部分可以通过设置参数 axis=1 来计算列。
# 查看数据统计特征，是 DataFrame 类型，只显示能统计的列
df.describe()
# 返回每一列中的非空值的个数
df.count()
# 返回每一列的和，无法计算返回空，下同
df.sum()
# `numeric_only=True` 代表只计算数字型元素，下同
df.sum(numeric_only=True)
# 返回每一列的最大值
df.max()
# 返回每一列的最小值
df.min()
# 返回最大值所在的自动索引位置
df.argmax()
# 返回最小值所在的自动索引位置
df.argmin()
# 返回最大值所在的自定义索引位置
df.idxmax()
# 返回最小值所在的自定义索引位置
df.idxmin()
# 返回每一列的均值
df.mean()
# 返回每一列的中位数
df.median()
# 返回每一列的方差
df.var()
# 返回每一列的标准差
df.std()
# 检查 df 中空值，NaN 为 True，否则 False，返回一个布尔数组
df.isnull()
# 检查 df 中空值，非 NaN 为 True，否则 False，返回一个布尔数组
df.notnull()
# 相关系数
df.corr() # 默认 pearson
df.corr('spearman')
df.corr('kendall')
4. 数据处理
- 将字符串直接转为 datetime 类型
- 直接获取 datetime 中的日期和时间信息
- 去除重复项（去除重复的 Tweets）
# 改变列顺序
df = df[['xm','csrq']]
# 改变指定列元素类型，非原地
df.astype({'xh':'int', 'csrq':'datetime64[ns]'})
# 根据 xm 和 xh 去重，默认保留第一个数据，非原地
df.drop_duplicates(['xm', 'xh'])
# 不传入参数，所有列相同才会去重，保留最后一个数据，非原地
df.drop_duplicates(keep='last')
# 不保留重复项（求差集），非原地
df.drop_duplicates(keep=False)
# 根据 csrq 排序，默认升序，非原地
df.sort_values(by='csrq')
# ascending 决定升序降序
df.sort_values(['col1', 'col2'], ascending=[True, False])
# 用 'one' 代替所有等于 1 的值
df.replace(1,'one')
# 用 'one' 代替 1，用 'three' 代替 3
df.replace([1,3], ['one','three'])
# 用 x 替换 df 中所有的空值，非原地
df.fillna(x)
# 用 x 替换 df 的 xh 列中所有的空值
df.fillna({'xh':0})
# 删除所有包含空值的行
df.dropna()
# 删除所有包含空值的列
df.dropna(axis=1)
# 删除某列含有空值的行
df.dropna(subset=['nj'])
# 设置多索引，并排序索引
df.set_index(['state', 'city']).sort_index()
# 把相关函数作用在所有 df 成员上
df.applymap(func)
# 根据其他列处理某列
df.apply(lambda x: func(x['sell sku'], x['shape']), axis = 1)
5. 分组
# 根据列分组
df.groupby(['Country', 'Income'])
# 聚合，默认情况对分组之后其他列进行聚合
df.groupby('Country').agg(['min', 'mean', 'max'])
# 对分组后的部分列进行聚合
num_agg = {'Age':['min', 'mean', 'max']}
df.groupby('Country').agg(num_agg)
groupby 可以简单总结为 split，apply，combine，也就是说：
- split : 先将数据按一个属性分组（得到 DataFrameGroupby / SeriesGroupby）
- apply : 对每一组数据进行操作（取平均 取中值 取方差 或 自定义函数）
- combine：将操作后的结果结合起来（得到一个DataFrame 或 Series 或可视化图像）
6. 添加和删除
# 假设 cj 列本来不存在，这样会在列尾添加新的一列 cj，值为 s（Series 对象），原地
df['cj'] = s
# 添加或修改一个列表在指定行，原地
df.iloc[0] = lst
# 在第 1 列位置插入一列 dz（地址），值为 s，原地
df.insert(0, 'dz', s)
# 删除单列，并返回删除的列，原地
df.pop('xm')
# 删除指定行，非原地
df.drop(1)
# 删除指定列，axis=1 指第 2 维（列），axis 默认 0（行），非原地
df.drop(['xm', 'xh'], axis=1)
7. 合并
# 内连接 Inner Join output = pd.merge(df1, df2, on='key') # 左连接 Left Outer Join output = pd.merge(df1, df2, on='key', how='left') # 右连接 Right Join output = pd.merge(df1, df2, on='key', how='right') # 全连接 Full Join output = pd.merge(df1, df2, on='key', how='outer') # 在 df 中添加内容为 df2 （必须是 DataFrame 对象）的新列（添加列），非原地 df.join(df2) # 将 df2 中的行添加到 df 的尾部（添加行），非原地 df.append(df2)
8. 相关运算
# age 列所有元素加 1，原地 df['age'] += 1 # ...
还可以调用方法，方法中可以指定运算的维度：
df.div(df.sum(), axis=0)
9. Pandas 其他常用函数
# 将 Series 对象转换成时间类型，可以用相关方法
pd.to_datetime(s)
# 生成一个时间列表，periods 决定数量，freq 决定单位，比如这里 'D' 是指天
# 成员是 Timestamp 类型，可以使用相关方法
pd.date_range('2017-7-27', periods=15, freq='D')
# 判断某个值是否为 NAN
# 也可判断 df, 返回一个 bool 类型的 df
pd.isna(df)
10. CSV 存取
# 导出数据到 CSV 文件，不包含索引：
df.to_csv('example.csv', index=False)
# 从 CSV 文件导入数据：
pd.read_csv('example.csv')
# 首先查询当前的工作路径：
import os
os.getcwd() #获取当前工作路径
# to_csv()是DataFrame类的方法，read_csv()是pandas的方法
# dt.to_csv() #默认dt是DataFrame的一个实例，参数解释如下
# 路径 path_or_buf: A string path to the file to write or a StringIO
dt.to_csv('Result.csv') #相对位置，保存在getwcd()获得的路径下
dt.to_csv('C:/Users/think/Desktop/Result.csv') #绝对位置
# 分隔符 sep : Field delimiter for the output file (default ”,”)
dt.to_csv('C:/Users/think/Desktop/Result.csv',sep='?')#使用?分隔需要保存的数据，如果不写，默认是,
# 替换空值 na_rep: A string representation of a missing value (default ‘’)
dt.to_csv('C:/Users/think/Desktop/Result1.csv',na_rep='NA') #确实值保存为NA，如果不写，默认是空
# 格式 float_format: Format string for floating point numbers
dt.to_csv('C:/Users/think/Desktop/Result1.csv',float_format='%.2f') #保留两位小数
# 是否保留某列数据 cols: Columns to write (default None)
dt.to_csv('C:/Users/think/Desktop/Result.csv',columns=['name']) #保存索引列和name列
# 是否保留列名 header: Whether to write out the column names (default True)
dt.to_csv('C:/Users/think/Desktop/Result.csv',header=0) #不保存列名
# 是否保留行索引 index: whether to write row (index) names (default True)
dt.to_csv('C:/Users/think/Desktop/Result1.csv',index=0) #不保存行索引