pandas
pandas
数据结构
pandas的基础数据结构，包括各类对象的数据类型，索引，轴标记，对齐等基本操作
数据对齐是内在的，这一原则是根本，除非显式指定，pandas不会断开标签和数据之间的连接
1.Series
Series是一个带标签的一维数组，可存储整数，浮点数，字符串，python对象等类型的数据，轴标签统称为索引，调用pd.Series函数即可创建Series
创建Series对象
# Series参数
data=None, index=None, dtype=None, name=None, copy=False, fastpath=False
方法一：使用数组形式创建
s = pd.Series(data,index=index)
# demon s = pd.Series([1,2,3,4,5],index=['a','b','c','d','e'])
# data支持的数据类型
python字典
多维数组
标量值（如，5） 只有一个值，这一行的值都是这一个
方法二：使用字典形式创建
s = pd.Series({'a':1,'b':2,'c':3})
# data为字典且未设置index参数时，python版本>=3.6，Series按字典的插入顺序排序索引
a 1
c 2
b 3
s = pd.Series({'a':1,'c':2,'b':3},index=['a','b','c','d','e'])
# 如果设置了index参数，则按索引标签提取data中对应的值，如果data中有，索引中没有，将不传递显示
a 1.0
b 3.0
c 2.0
d NaN
e NaN
# pandas用NaN表示缺失数据
方法三：当data为标量值时
s = pd.Series(5,index=['a','b','c','d','e'])
# 当data为标量值时，必须提供索引，Series按索引长度重复该标量值
a 5
b 5
c 5
d 5
e 5
基本操作
切片
s[0:1] # 对值进行切片，前开后闭
a 1.0
b 3.0
s = pd.Series({'a':1,'c':2,'b':3},index=['a','b','c','d','e'])
s[[4,3,1]] # 取索引为4，3，1的值
e NaN
d NaN
b 3.0
array操作
s = pd.Series({'a':1,'c':2,'b':3},index=['a','b','c','d','e'])
s.array
# 执行不用索引的操作时，如禁用自动对齐，访问数组非常有用，Series.array一般使扩展数组，
<PandasArray>
[1.0, 3.0, 2.0, nan, nan] # 如果值中有nan，也会显示，可以使用 dropna 函数清除
Length: 5, dtype: float64
s = pd.Series({'a':1,'c':2,'b':3})
s.to_numpy()
# 提取真正的多维数组，要用Series.to_numpy()
array([1, 2], dtype=int64)
# Series时扩展数组，Series.to_numpy()返回的时NumPy多维数组
Series对象取值
s['a'] 或 s[0]
Series类似于字典，可以用索引标签取值或设置值，如果引用Series里没有的标签回触发异常，使用get可以提取没有的标签，返回None或指定默认值
矢量操作
s + s
s * 2
# Series和多维数组的主要区别在于，Series之间的操作会自动基于标签对齐数据，因此不用顾及执行计算操作的Series是否有相同的标签，总之，让不同索引对象操作的默认结果生成索引并集，是为了避免信息丢失，就算确实了数据，索引标签依然包含计算的重要信息，当然也可所以用 dropna 函数清除含有确实值的标签
名称属性
Series支持 name 属性
s = pd.Series(np.random.randn(5),name='something')
Out[33]:
0 -0.314390
1 -0.305942
2 0.440155
3 -0.800408
4 0.721798
Name: something, dtype: float64
# 如果没有指定name属性，查询的时候是没有name属性的
s.name # 查询name
s.rename # 重命名Series
2.DataFrame
创建DataFrame对象
DataFrame是由多种类型的列构成的二维标签数据结构，类似于Excel，SQL表，或Series对象后成的字典，DataFrame是最常用的Pandas对象，与Series一样，DataFrame支持多种类型的输出数据：
# DataFrame 支持的输入数据类型
一维ndarry，列表，字典，Series字典
二维numpy.ndarry
结构多维数组或记录多维数据
Series
DataFrame
除了数据，还可以有选择地传递 index 行标签和 columns 列标签参数，传递了索引或列，就可以确保生成的DataFrame里包含索引或列，Series字典加上指定索引时，会丢弃与传递的索引不匹配的所有数据，没有传递轴标签时，按常规依据输入数据进行构建。
# 注意
python>=3.6,且pandas>=0.23,数据是字典，且未指定 columns 参数时， DataFrame 的列按字典的插入顺序排序
# DataFrame参数
self, data=None, index=None, columns=None, dtype=None, copy=False
用Series字典或字典生成DataFrame（用字典生成）
df = pd.DataFrame({'one':pd.Series([1,2,3,4,5],index=['a','b','c','d','e']),'two':{'a':6,'c':8,'f':9}})
one two
a 1 6.0
b 2 NaN
c 3 8.0
d 4 NaN
e 5 NaN
f Nan 9.0
# 1.生成的索引是每一个Series索引的并集，先把套接字典转换成Series，如果没有指定列，DataFrame的列就是字典键的有序列表
# 2.index 和columns 属性分别用于访问行，列标签，指定列与数据字典一起传递时，传递的列会覆盖掉字典的键
# 3.如果有一列有指定的行索引，并且另一列与这一列的索引有相似的部分，呢会将这两列的索引进行合并，缺失的地方使用Nan替换掉
用多维数组字典，列表字典生成DataFrame（用字典生成）
df = pd.DataFrame({'one':[1,2,3,4,5],'two':[6,7,8,9,0]},index=['a','b','c','d','e'])
用列表字典生成DataFrame（用字典生成）
df = pd.DataFrame([{'a':1,'b':2,'c':3},{'b':5}],index=['first','second'])
a b c
first 1.0 2 3.0
second NaN 5 NaN
用包含日期时间索引与标签的NumPy数组生成DataFrame（随机数生成）
In [5]: dates = pd.date_range('20130101', periods=6)
In [6]: dates
Out[6]:
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',
'2013-01-05', '2013-01-06'],
dtype='datetime64[ns]', freq='D')
In [7]: df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
In [8]: df
Out[8]:
A B C D
2013-01-01 0.469112 -0.282863 -1.509059 -1.135632
2013-01-02 1.212112 -0.173215 0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929 1.071804
2013-01-04 0.721555 -0.706771 -1.039575 0.271860
2013-01-05 -0.424972 0.567020 0.276232 -1.087401
2013-01-06 -0.673690 0.113648 -1.478427 0.524988
用Series字典对象生成DataFrame（字典生成）
In [9]: df2 = pd.DataFrame({'A': 1.,
...: 'B': pd.Timestamp('20130102'),
...: 'C': pd.Series(1, index=list(range(4)), dtype='float32'),
...: 'D': np.array([3] * 4, dtype='int32'),
...: 'E': pd.Categorical(["test", "train", "test", "train"]),
...: 'F': 'foo'})
...:
In [10]: df2
Out[10]:
A B C D E F
0 1.0 2013-01-02 1.0 3 test foo
1 1.0 2013-01-02 1.0 3 train foo
2 1.0 2013-01-02 1.0 3 test foo
3 1.0 2013-01-02 1.0 3 train foo
用Series创建DataFrame
生成的DataFrame继承了输入的Series的索引，如果没有指定列名，默认列名是输入Series的名称
df = pd.DataFrame(
[pd.Series({'a':1,'b':2},index=['a','c','d']),
pd.Series({'a':1,'b':2,'d':4},index=['a','c','d'])])
a c d
0 1.0 NaN NaN
1 1.0 NaN 4.0
DataFrame常用操作
提取 添加 删除列
# DataFrame就像带索引的Series字典，提取，设置，删除列的操作与字典类似
df = pd.DataFrame([{'a':1,'b':2,'c':3},{'b':5}],index=['first','second'])
************************* 提取 *************************
df['b'] # 提取 b 列的内容
first 2
second 5
Name: b, dtype: int64
************************* 删除 *************************
del df['a'] # 删除指定列
b c
first 2 3.0
second 5 NaN
df1 = df.pop('a') # 获取指定的删除列
first 1.0
second NaN
Name: a, dtype: float64
************************* 添加 *************************
df['three'] = [11,22]
a b c three
first 1.0 2 3.0 11
second NaN 5 NaN 22
# 可以插入原生多维数组，但长度必须与DataFrame索引长度一致，默认在DataFrame为不插入列，insert 函数可以指定插入列的位置
df.insert(1, 'bar', df['one']) # 在第一行插入列名为 bar ，值为df['one']的数据
one bar flag foo one_trunc
a 1.0 1.0 False bar 1.0
b 2.0 2.0 False bar 2.0
c 3.0 3.0 True bar NaN
d NaN NaN False bar NaN
用方法链分配新列
DataFrame 提供了 assign() 方法，可以利用现有的列创建新列
df = pd.DataFrame({'one':[1,2,3,4,5],'two':[6,7,8,9,0]},index=['a','b','c','d','e'])
df1 = df.assign(three=df['one']*2)
df1
one two three
a 1 6 2
b 2 7 4
c 3 8 6
d 4 9 8
e 5 0 10
# assign 返回的是数据副本，原DataFrame不变，可以使用assign执行一些数据操作之类数据进行返回
# assign 函数的签名就是 **kwargs，键是新字段的列名，值为插入值
# assign 在pythn3.6之后可以保存 **kwargs 顺序，**kwargs 后的表达式可以引用同一个assign 函数里之前创建的列
索引/选择
| 操作 | 句法 | 结果 |
|---|---|---|
| 选择列 | df[col] | Series |
| 用标签选择行 | df.loc[label] | Series |
| 用整数位置选择行 | df.iloc[loc] | Series |
| 行切片 | df[1:3] | DataFrame |
| 用布尔向量选择行 | df[bool_vec] | DataFrame |
数据对齐和运算
DataFrame对象可以自动对齐 **列与索引列（行标签） **的数据，生成的结果是列和行标签的并集
转置
T 属性可以转置 DataFrame ，相当于把行和列转换位置，但是所对应的值不变
df.T
控制台显示
df.info() # info() 函数可以查看DataFrame的信息摘要
df.to_string() # 以表格的形式返回DataFrame的字符串表示形式
常用操作
查看数据
numpy和pandas的区别：Numpy数组只有一种数据里类型，DataFrame每列的数据类型各不相同
df.head() # 默认显示5行
df.tail(3) # 显示最后三行
df.index # 显示索引名
df.columns # 显示列名
df.to_numpy()
# 返回一个array对象，DataFrame的列由多种数据类型组成时，该操作耗费系统资源比较大，df.to_numpy()的输出不包含行索引和列索引
df.describe() # 快速查看数据的统计摘要
df.T # 转置数据
df.sort_index(axis=1,ascending=False) # 转轴排序
df.sort_values(by='B') # 按值排序
选择数据
推荐使用优化过的Pandas数据访问方法 .at .iat .loc .iloc
# 按标签选
df.A # 获取单列，产生Series对象
df['A'] # 获取单列，产生Series对象
df[1:3] # 用[]切片行
df.loc[] # 按标签取值，第一个参数是行，第二个参数是列
In [30]: df.loc[dates[0], 'A']
Out[30]: 0.46911229990718628
# 按位置选
df.iloc[3] # 第一个参数是第几行，第二个参数是低级列
df.iloc[3:5, 0:2] # 切片取值
df.iloc[[1, 2, 4], [0, 2]] # 用整数列表按位置切片，取出1，2，4行，0，2列
df.iloc[1, 1] # 显式提取值
# 布尔索引
df[df > 0] # 会在全表中选出判断结果为True的值，不满足条件的使用NaN填充
df2 = df.copy() # 将df的值拷贝一份
df[df['E'].isin(['test'])] # 取 df 的 E 列中含有 test 值的行
赋值
# 用索引自动对齐新增列的数据
s1 = pd.Series([1, 2, 3, 4, 5, 6], index=pd.date_range('20130102', periods=6))
df['F'] = s1
# 按标签赋值
df.at[1,'B'] = 111 # 将第一行，B列的值改为111
# 按位置赋值
df.iat[0,1] = 222 # 将第0行，第1列的值改为222
# 用where条件赋值
df[df > 0] = 111 # 将df中值大于0的更改为111
缺失值
Pandas 主要用 np.nan 表示缺失数据，计算时，默认不包含空值，
重建索引（reindex）可以更改，添加，删除指定轴的索引，并返回数据福本，即不更改原数据
df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ['E'])
删除所有缺失值的行
df.dropna(how='any') # 删除所有含缺失值的行
填充缺失值
df.fillna(value=5555)
提取 nan 值的布尔掩码
pd.isna(df1) # 对所有值进行判断，如果是nan就为True，不是就为False
方法解析
pandas中fillna()方法，能够使用指定的方法填充NA/NaN值。
# 函数形式
fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)
# 参数说明
value：用于填充的空值的值。
method： {'backfill', 'bfill', 'pad', 'ffill', None}, default None。定义了填充空值的方法， pad / ffill表示用前面行/列的值，填充当前行/列的空值， backfill / bfill表示用后面行/列的值，填充当前行/列的空值。
# ffill axis=1 使用前边一列值填充，bfill，axis=1 使用后一列值填充
axis：轴。 0或'index'，表示按行删除；1或'columns'，表示按列删除。
inplace：是否原地替换。布尔值，默认为False。如果为True，则在原DataFrame上进行操作，返回值为None。
limit：int， default None。如果method被指定，对于连续的空值，这段连续区域，最多填充前 limit 个空值（如果存在多段连续区域，每段最多填充前 limit 个空值）。如果method未被指定， 在该axis下，最多填充前 limit 个空值（不论空值连续区间是否间断）
downcast：dict, default is None，字典中的项为，为类型向下转换规则。或者为字符串“infer”，此时会在合适的等价类型之间进行向下转换，比如float64 to int64 if possible。
运算
apply函数
df.apply(lambda x: x.max() - x.min()) # 可以在apply中定义匿名函数使用
字符串方法
Series 的 str 属性包含一组字符串处理功能，str 的模式匹配默认使用正则表达式
s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
s.str.lower()
合并（Merge）
结合（concat）
pandas 提供了多种将Series，DataFrame对象组合在一起的功能，用索引与关联代数功能的多种设置逻辑可执行连接（join）与合并（merge）操作
连接(join)
追加（append）
分组（grouping）
group by 指的是涵盖下列一项或多项步骤的处理流程
分割 ：按条件把数据分割成多组
应用 ：为每组单独应用函数
组合：将处理结果结合成一个数据结构
重塑（reshaping）
堆叠（stack）
数据透视表（pivot tables）
时间序列（timeseries）
rng = pd.date_range('20200101',periods=10,freq='S')
ts = pd.Series(np.random.randint(0,100,len(rng)),index=rng)
# 时区表示
ts.tz_localize('UTC')
# 转换成其他时区
ts_utc.tz_convert('US/Eastern')
# 转换时间段
类别型（categoricals）
可视化
DataFrame的 plot() 方法可以快速绘制所有带标签的列
数据输入/输出
CSV
read_csv()
# 读取csv文件
pd.read_csv('foo.csv')
# 参数说明
filepath_or_buffer: FilePathOrBuffer, ******* # 文件名或位置
sep=default_sep, # 分隔符
delimiter=None,
# 1.列和索引的位置和名称
header="infer",
names=None,
index_col=None, *******# 用作索引的列编号或者列名
usecols=None, *******# 返回数据子集，例：[0,1,2]或者 [‘foo’, ‘bar’, ‘baz’]
squeeze=False,
prefix=None, *******# 在没有列标题的时候，给列添加前缀
mangle_dupe_cols=True, # 将重复的列表示为X.0, X.1, X.2, 如果设定为false，会将所有重复的列名覆盖掉
# 2.常规解析配置
dtype=None, # 每一类数据的数据类型
engine=None,
converters=None, # 列转换函数的字典，key可以是列名或者列的序号
true_values=None,
false_values=None,
skipinitialspace=False,
skiprows=None,
skipfooter=0,
nrows=None, # 需要读取的行数（从文件头开始算起）
# 3.不适用和缺失数据处理
na_values=None,
keep_default_na=True,
na_filter=True, # 检查是否丢失值（空字符串或空值），对于数据集中没有空值，设定False可以提升读取速度
verbose=False,
skip_blank_lines=True, # 如果为True，则跳过空行，否则记为NaN
# 4.日期时间处理
parse_dates=False,
infer_datetime_format=False,
keep_date_col=False,
date_parser=None,
dayfirst=False,
cache_dates=True,
# 5.迭代
iterator=False,
chunksize=None,
# 6.报价，压缩和文件格式
compression="infer",
thousands=None, # 千分位分隔符
decimal=b".", # 字符中的小数点
lineterminator=None,
quotechar='"',
quoting=csv.QUOTE_MINIMAL,
doublequote=True,
escapechar=None,
comment=None,
encoding=None, *******# 指定字符集类型，通常指定为'utf-8'
dialect=None,
# 7.错误处理
error_bad_lines=True,
warn_bad_lines=True,
# 8.内部
delim_whitespace=False,
low_memory=_c_parser_defaults["low_memory"],
memory_map=False,
float_precision=None,
to_csv()
# 写入CSV文件
df.to_csv('foo.csv')
# 参数说明
path_or_buf=None, # 路径
sep=",", # 分隔符
na_rep="", # 替换空值，缺失值保存为Na，如果不写，默认为空
float_format=None, # 格式，float_format='%.2f' 保留两位小数
columns=None, # 是否保留某列的值， columns=['name'] 保存索引列和name的值
header=True, # 是否保留列名，False不保留列名
index=True, # 是否保留索引行，False不保留
index_label=None,
mode="w", # 如果需要在现有文件中追加，把 w 改成 a,前提是格式都一样
encoding=None,
compression="infer",
quoting=None,
quotechar='"',
line_terminator=None,
chunksize=None,
date_format=None,
doublequote=True,
escapechar=None,
decimal=".",
HDF5
# 读取HDF5文件
pd.read_hdf('foo.h5', 'df')
# 写入HDF5
df.to_hdf('foo.h5', 'df')
Excel
# 读取Excel文件
pd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA'])
# 写入Excel
df.to_excel('foo.xlsx', sheet_name='Sheet1')
to_msgpack
pandas.DataFrame.to_msgpack(path=None,encoding='utf-8',**kwargs)
msgpack（序列化）对象以输入文件路径
# 参数说明
path 字符串文件路径，类似缓冲区的文件或无，如果为None，则返回生成的字符串
append 布尔值是否追加到现有的msgpack，默认为False
compress 压缩器的类型（zlib或blosc）默认为None（无压缩）
基础用法
df.columns = ['a','b','c'] # 更换列的值
df.array() # 用于提取数据，推荐使用
df.to_numpy() # 用于提取数据，推荐使用
df.rename(columns={'adj_price_open': 'price_open'}, inplace=True) # 更改列名
inplace=True # 不创建新的对象，直接对原始对象进行修改
inplace=False # 对数据进行修改，创建并返回新的对象承载其修改结果
合并重叠数据集
合并两个相似的数据集，一个中的数据比另一个多，合并后选择覆盖范围广的，使用 combin_first() 函数
In [71]: df1 = pd.DataFrame({'A': [1., np.nan, 3., 5., np.nan],
....: 'B': [np.nan, 2., 3., np.nan, 6.]})
....:
In [72]: df2 = pd.DataFrame({'A': [5., 2., 4., np.nan, 3., 7.],
....: 'B': [np.nan, np.nan, 3., 4., 6., 8.]})
....:
In [73]: df1
Out[73]:
A B
0 1.0 NaN
1 NaN 2.0
2 3.0 3.0
3 5.0 NaN
4 NaN 6.0
In [74]: df2
Out[74]:
A B
0 5.0 NaN
1 2.0 NaN
2 4.0 3.0
3 NaN 4.0
4 3.0 6.0
5 7.0 8.0
In [75]: df1.combine_first(df2)
Out[75]:
A B
0 1.0 NaN
1 2.0 2.0
2 3.0 3.0
3 5.0 4.0
4 3.0 6.0
5 7.0 8.0
聚合函数使用
sum() # 求和
mean() # 返回平均值
std() # 返回标准差
median() # 所有值的中位数
min() # 最小值
max() # 最大值
abs() # 绝对值
prod() # 数据元素的乘积
cumsum() # 累计总和
describe() # 统计信息摘要
索引
重建索引
重建索引会更改DataFrame的行标签和列标签，重新索引以为这符合数据以匹配特定轴上的一组给定的标签，可以通过索引实现多个操作
- 重新排序现有数据以匹配一组新的标签
- 在没有标签数据的标签位置插入缺失值标记
df.reindex(index=[]) # 重建索引，如果指定的数据没有和此索引建立关联，新产生的表格就为NaN
df.rename(index=[], columns=[]) # 索引重命名
迭代
iteritems() - 迭代(key，value)对
iterrows() - 将行迭代为(索引，系列)对
itertuples() - 以namedtuples的形式迭代行
排序
pandas排序有两种：按标签 按实际值
df.sort_index() # 按标签排
df.sort_index(ascending=False) # 排序顺序
df.sort_index(axis=1) # 按列排序
df.sort_values(by='B') # 按某一列的值排序
合并连接
Merge方法
# Merge方法是基于共同列将两个dataFrame连接起来
pd.merge(left,right,how="inner",on=None,left_on=None,right_on=None,left_index=False,right_index=False,sort=False,
suffixes # 合表中遇到相同的列名，给重复的列名增加后缀=("_x", "_y"),copy=True,indicator=False,validate=None,)
# 参数说明
left/right # 左右位置的dataframe
how # 合并方式 left：基于左边dataframe列的数据合并，right：基于右边，outer：两者并集，inner，两者交集，默认是inner
on # 用来合并的列名，这个参数需要保证两个dataframe有相同的列名
left_on/right_on # 左右dataframe合并的列名，也可以为索引，数组和列表
left_index/right_index # 是否以index作为数据合并的列名，True表示是
sort # 根据dataframe合并的keys排序，默认是
suffixes # 合表中遇到相同的列名，给重复的列名增加后缀
on参数：在实际应用中，如果右表的索引值正是左表的某一列的值，这时可以通过将右表的索引和左表的列对其合并，这样灵活的方式进行合并
In [59]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
....: 'B': ['B0', 'B1', 'B2', 'B3'],
....: 'key': ['K0', 'K1', 'K0', 'K1']})
....:
In [60]: right = pd.DataFrame({'C': ['C0', 'C1'],
....: 'D': ['D0', 'D1']},
....: index=['K0', 'K1'])
result = left.join(right,on='Key')
suffix后缀参数：如果和表合并的过程中遇到有一列两个表都同名，但是值不同，合并的时候又都想保留下来，就可以用suffixes给每个表的重复列名增加后缀。
result = pd.merge(left, right, on='k', suffixes=['_l', '_r'])
组合多个dataframe：一次组合多个dataframe的时候可以传入元素为dataframe的列表或者tuple。
right2 = pd.DataFrame({'v': [7, 8, 9]}, index=['K1', 'K1', 'K2'])
result = left.join([right, right2])
concat方法
concat方法是拼接函数，有行拼接和列拼接，默认是行拼接，拼接方式默认的是外拼接（并集），拼接对象是pandas数据类型
pd.concat(objs,axis=0,join="outer",join_axes=None,ignore_index=False,keys=None,levels=None,names=None,verify_integrity=False,sort=None,copy=True)
# 参数说明：
objs：series，dtaframe或者panel构成的序列list，需要可迭代
axis：需要合并连接的轴，0是行，1是列
join：连接的方式，或者outer， inner：两表的交集，outer：两者的并集
keys：当axis=0的时候，按照行拼接，会加一列，表示这一列是哪一个表中的数据；axis=1的时候，按照列拼接， 会将列名改为对应的值，表示这一列是哪一个表中的数据
join_axes：指定根据那个轴来对齐数据 join_axes=[df.index]
ignore_index：设置为True，合并的两个表就会根据列字段对齐，然后合并，最后再重新整理一个新的index
********************** Series类型的拼接方法 **********************
# 例1：行拼接
df1 = pd.Series([1.1,2.2,3.3],index=['i1','i2','i3'])
df2 = pd.Series([4.4,5.5,6.6],index=['i2','i3','i4'])
pd.concat([df1,df2])
行拼接如果有相同的索引，为了区分索引，我们在最外层定义了索引的分组情况
# 对行拼接分组
pd.concat([df1,df2],keys=['fea1','fea2'])
# 例2：列拼接
默认以并集的方式拼接
pd.concat([df1,df2],axis=1) # axis=0 行拼接 axis=1 列拼接
列拼接的内连接（交），取相同的部分
pd.concat([df1,df2],axis=1,join='inner')
设置列拼接的列名（交）
pd.concat([df1,df2],axis=1,join='inner',keys=['fea1','fea2'])
指定索引[i1,i2,i3]的列拼接
pd.concat([df1,df2],axis=1,join_axes=[['i1','i2','i3']])
********************** DataFrame类型的拼接方法 **********************
# 行拼接
df1 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3', 'K4', 'K5'], 'A': ['A0', 'A1', 'A2', 'A3', 'A4', 'A5']})
df2 = pd.DataFrame({'key': ['K0', 'K1', 'K2'],'B': ['B0', 'B1', 'B2']})
pd.concat([df1,df2])
# 列拼接
pd.concat([df1,df2],axis=1)
若列拼接或行拼接有重复的列名和行名，则报错
# 判断是否有重复的列名，若有则报错
pd.concat([df1,df2],axis=1,verify_integrity = True)
append方法
dataframe 数据类型的方法，提供了行方向的拼接操作
DataFrame.append(other, ignore_index=False, verify_integrity=False, sort=None)
# 功能说明：
向DataFrame对象中添加新的行，如果添加的列名不在DataFrame对象中，将会被当作新的列进行添加
# 参数说明
other # DataFrame,Series,dict,list这样的数据结构
ignore_index # 默认值为False，如果为True，则不适用index标签
verify_integrity # 默认值为False，如果为True，当创建相同的index时会抛出ValueError的异常
sort # 默认是None
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B4', 'B5', 'B6', 'B7'],
'C': ['C4', 'C5', 'C6', 'C7'],
'D': ['D4', 'D5', 'D6', 'D7']})
df3 = df1.append(df2, ignore_index=True) # 如果不使用ignore_index=True,会出现多个相同的索引
result = df1.append([df2, df3]) # 可以添加多个
join方法
dataframe 数据类型的方法，提供了列方向的拼接操作，支持左联，右联，内联，外联四种
DataFrame.join(other, on=None, how=’left’, lsuffix=”, rsuffix=”, sort=False)
# 功能说明
通过索引或者指定的连接两个DataFrame，通过一个list可以一次高效的连接多个DataFrame
# 参数说明
other # DataFrame，或者带有名字的Series，或者DataFrame的list，如果传递的是Series，那么其name属性应当是一个集合，并且该集合将会作为结果DataFrame的列名
on # 列名称，或者列名称的list/tuple，或者类似形状的数组，连接的列，默认使用索引连接
how # {‘left’, ‘right’, ‘outer’, ‘inner’}, default: ‘left’，连接的方式，默认为左连接
lsuffix # string，左DataFrame中重复列的后缀
rsuffix # string，右DataFrame中重复列的后缀
sort # boolean, default False，按照字典顺序对结果在连接键上排序。如果为False，连接键的顺序取决于连接类型（关键字）。
pandas删除行
1.指定删除行数删除 .drop([i,j])
.drop([i,j])方法如果不设置参数inplace=True,则只能在生成的新数据块中实现删除效果，而不能删除原有数据块的相应行，设置后直接在原有的数据块上进行操作
pandas删除列
1.pop()删除 df.pop([指定列])
.pop([])方法可以将所选列从原数据快中弹出，原数据块不在保留该列
2.drop()删除 df.drop([],axis=1)
df.drop([],axis=1) 方法既可以保留原数据块中的所选列，也可以删除，这取决于inplace
当inplace=True时，执行内部删除，不返回任何值，原数据发生变化
当inplace=False，执行内部删除，有返回值，生成新的df
常用方法
df["gender"].unique 查看某一列的唯一值
df["gender"].value_counts(dropna=False) 查看看某一列值分布
df.values 查看数据表的值，返回的是arry对象，列表套列表，一行数据一个小列表
df.rename(columns={"gender":"性别"}) 更改列名称
df['education'].drop_duplicates() 删除后出现的重复值
df['education'].drop_duplicates(keep='last') 删除先出现的重复值
df['education'].replace('本科'，'大学') 数据替换
merge，join，concat 数据表合并
pd.merge(df1,df2,on='id',how='inner') 交集合并，按照id列
pd.merge(df1,df2,on='id',how='left') 按左边合并
pd.merge(df1,df2,on='id',how='right') 按右边合并
pd.merge(df1,df2,on='id',how='outer') 按照并集合并，两者共同的部分，没有的部分使用Nan替换
merge参数_(self, left, right, how, on, left_on, right_on, axis, left_index, right_index, sort, suffixes, copy, indicator, validate)
result = df.append(df1) 新增
df.set_index('id') 设置索引
df.reset_index(drop=True) 删除索引
df.sort_values(by=['age']) 按照特定的列排序
df.sort_index() 按照索引列排序
# 数据提取
loc:按标签值进行提取 iloc：按位置进行提取
df.columns 获取所有列，返回的是列表的形式
pandas常用函数
# shift() # 对数据进行移动操作，索引不移动
df.shift() # 将本列数据整体向下移动，移动后的空格使用NaN填充
df.shift(-1) # 将本例数据整体向上移动一格，移动后的空格使用NaN填充
# diff() # 两条临近记录的差值
pandas操作文件
import pandas as pd
pd.read_csv(file_path,) 读取csv文件
pd.to_csv(file_path) 写入csv文件
df.astype(int) 将对象转换成int类型
时间戳字符串转换
import time
import datetime
import pandas as pd
# 时间字符串转换成时间戳
a1 = "2019-5-10 23:40:00"
# 先转换为时间数组
timeArray = time.strptime(a1, "%Y-%m-%d %H:%M:%S")
timeStamp = int(time.mktime(time.strptime(a1, "%Y-%m-%d %H:%M:%S")))
print(timeStamp)
# 1557502800
# 字符串转换成时间戳
d = '201703270000'
sss = time.mktime(datetime.datetime.strptime(d, "%Y%m%d%H%M%S").timetuple())
print(sss)
# 1490544000.0
# 时间戳转换成时间字符串
dd = 1490544000.0
dt = pd.to_datetime(dd, unit='s')
print(dt)
# 2017-03-26 16:00:00
