pythonffill

A. 利用python进行数据分析(9)-重采样resample和频率转换

Python-for-data-重新采样和频率转换

重新采样指的是将时尺耐间序列从一个频率转换到另一个频率的过程。

但是也并不是所有的采样方式都是属于上面的两种

pandas中使用resample方法来实现频率转换，下面是resample方法的参数详解：

将数据聚合到一个规则的低频上，例如将时间转换为每个月，"M"或者"BM"，将数据分成一个月的时间间隔。

每个间隔是半闭合的，一个数据只能属于一个时间间隔。时间间隔的并集必须是整个时间帧

默认情况下，左箱体边界是包含的。00:00的值是00：00到00：05间隔内的值

产生的时间序列按照每个箱体左边的时间戳被标记。

传递<span class="mark">label="right"</span>可以使用右箱体边界标记时间序列

向loffset参数传递字符串或者日期偏置

在金融数据中，为每个数据桶计算4个值是常见知困物的问题：

通过<span class="girk">ohlc聚合函数</span>能够得到四种聚合值列的DF数据

低频搭液转到高频的时候会形成缺失值

ffill() ：使用前面的值填充， limit 限制填充的次数

B. 利用Python进行数据分析-读书笔记(3)

pandas专门为处理表格和混杂数据设计
import pandas as pd
from pandas import Series,DataFrame

Series 类似于一维数组+索引
data = pd.Series([1,2,3,4,5]) 生成Series数据
data.values data.index
pd.Series([1,2],index = ['a','b']) 设置索引
data['a'] 通过索引选取Series中单个或一组值
data[data%2==0] 进行类似numpy数组的运算index仍会保留
'a' in data
pd.Series(python字典) 可以通过python字典创建Series
可以通过设置index改变Series元素顺序
缺失值用NaN表示
pd.isnull(data) 检测缺失数据
pd.notnull
data1 + data2 可以根据索引自动对齐数据进行运算，类似join操作
data.name data.index.name 可赋值
index可以通过赋值方式修改
pd.DataFrame(XXX)传入元素为等长列表或np数组组成的字典可以生成DataFrame数据，字典key值为列名
frame.head() 前五行
pd.DataFrame(XXX, columns = [xxx], index = [xxxxx]) 可能产生NaN
frame['a'] 取列名为a的一列数据 等价于 frame.a（此时a需要是合理的变量名） 可以以列表形式取多列数据 返回的Series序列索引与原DataFrame相同
frame.loc[0] 行选取
可以用一个Series/值对某列赋值，需要长度相等
对不存在的列赋值可创建新列
del frame[列名] 删除列
通过索引方式返回数据视图，修改此返回数据也会影响源数据，Series.()可以创建副本
嵌套字典传给DataFrame，外层字典的键作为列名，内层键作为行索引
frame.T 转置

frame.reindex(新索引列表) 根据新索引重排，若索引值当前不存在则NaN
列可以用columns关键字重新索引
obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
obj3.reindex(range(6), method='ffill') ffill实现前向值填充
reindex可以修改（行）索引和列。只传递一个序列时，会重新索引结果的行，列可以用columns关键字重新索引

Series索引
series(索引列表/数值范围切片) 选取对应元素

C. python中利用pandas怎么处理缺省值

null/None/NaN
null经常出现在数据库中
None是Python中的缺失值，类型是NoneType
NaN也是python中的缺失值，意思是不是一个数字，类型是float
在pandas和Numpy中会将None替换为NaN，而导入数据库中的时候则需要把NaN替换成None
找出空值
isnull()
notnull()
添加空值
numeric容器会把None转换为NaN
In [20]: s = pd.Series([1, 2, 3])

In [21]: s.loc[0] = None

In [22]: s
Out[22]:
0 NaN
1 2.0
2 3.0
dtype: float641234567891012345678910

object容器会储存None
In [23]: s = pd.Series(["a", "b", "c"])

In [24]: s.loc[0] = None

In [25]: s.loc[1] = np.nan

In [26]: s
Out[26]:
0 None
1 NaN
2 c
dtype:

空值计算
arithmetic operations(数学计算)
NaN运算的结果是NaN
statistics and computational methods(统计计算)
NaN会被当成空置
GroupBy
在分组中会忽略空值
清洗空值
填充空值
fillna
DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)
参数
value : scalar, dict, Series, or DataFrame
method : {‘backfill’, ‘bfill’, ‘pad’, ‘ffill’, None}, default None(bfill使用后面的值填充,ffill相反）
axis : {0 or ‘index’, 1 or ‘columns’}
inplace : boolean, default False
limit : int, default None
downcast : dict, default is None
返回值
filled : DataFrame
Interpolation
replace
删除空值行或列
DataFrame.dropna(axis=0, how=’any’, thresh=None, subset=None, inplace=False)
参数
axis : {0 or ‘index’, 1 or ‘columns’}, or tuple/list thereof
how : {‘any’, ‘all’}
thresh : int, default None
subset : array-like
inplace : boolean, default False
返回
dropped : DataFrame

D. python填充缺失值

对于大多数情况而言，fillna方法是最主要的函数。通过一个常数调用fillna就会将缺失值替换为那个常数值。
fillna(value)
参数：value
说明：用于填充缺失值的标量值或字典对象
#通过常数调用fillna
书写方式：df.fillna(0) #用0替换缺失值
#通过字典调用fillna
书写方式：df.fillna({1:0.5,3:-1})
fillna(value,inplace=True)
参数：inplace
说明：修改调用者对象而不产生副本
#总是返回被填充对象的引用
书写方式：df.fillna(0,inplace=True)
fillna(method=ffill)
参数：method
说明：插值方式。如果函数调用时未指定其他参数的话，默认为“ffill”
对reindex有效的那些插值方法也可用于fillna：
In [23]: from numpy import nan as NA
In [21]: df=DataFrame(np.random.randn(6,3))
In [24]: df.ix[2:,1]=NA;df.ix[4:,2]=NA
In [25]: df
Out[25]:
0 1 2
0 -0.863925 1.005127 -0.529901
1 0.701671 -0.501728 -0.617387
2 -0.951060 NaN -0.263626
3 0.810230 NaN -0.277401
4 -0.403899 NaN NaN
5 -0.081091 NaN NaN
In [26]: df.fillna(method='ffill')
Out[26]:
0 1 2
0 -0.863925 1.005127 -0.529901
1 0.701671 -0.501728 -0.617387
2 -0.951060 -0.501728 -0.263626
3 0.810230 -0.501728 -0.277401
4 -0.403899 -0.501728 -0.277401
5 -0.081091 -0.501728 -0.277401
fillna(limit=2)
参数：limit
说明：（对于前向和后向填充）可以连续填充的最大数量
In [27]: df.fillna(method='ffill',limit=2)
Out[27]:
0 1 2
0 -0.863925 1.005127 -0.529901
1 0.701671 -0.501728 -0.617387
2 -0.951060 -0.501728 -0.263626
3 0.810230 -0.501728 -0.277401
4 -0.403899 NaN -0.277401
5 -0.081091 NaN -0.277401
fillna(data.mean())
只要稍微动动脑子，就可以利用fillna实现许多别的功能。比如说，可以传入Series的平均值或中位数：
In [28]: data=Series([1,NA,3.5,NA,7])
In [29]: data.fillna(data.mean())

E. 怎么用python进行数据

pandas是本书后续内容的首选库。pandas可以满足以下需求：

• 具备按轴自动或显式数据对齐功能的数据结构。这可以防止许多由于数据未对齐以及来自不同数据源（索引方式不同）的数据而导致的常见错误。.

• 集成时间序列功能

• 既能处理时间序列数据也能处理非时间序列数据的数据结构

• 数学运算和简约（比如对某个轴求和）可以根据不同的元数据（轴编号）执行

• 灵活处理缺失数据

• 合并及其他出现在常见数据库（例如基于SQL的）中的关系型运算

1、pandas数据结构介绍

两个数据结构：Series和DataFrame。Series是一种类似于以为NumPy数组的对象，它由一组数据（各种NumPy数据类型）和与之相关的一组数据标签（即索引）组成的。可以用index和values分别规定索引和值。如果不规定索引，会自动创建 0 到 N-1 索引。



• #-*- encoding:utf-8 -*-import numpy as npimport osimport pandas as pdfrom pandas import Series,DataFrameimport matplotlib.pyplot as pltimport time#下面看一下cummin函数#注意：这里的cummin函数是截止到目前为止的最小值，而不是加和以后的最小值frame = DataFrame([[1,2,3,4],[5,6,7,8],[-10,11,12,-13]],index = list('abc'),columns = ['one','two','three','four'])print frame.cummin()print frame


• >>>


• one two three four


• a 1 2 3 4


• b 1 2 3 4


• c -10 2 3 -13


• one two three four


• a 1 2 3 4


• b 5 6 7 8


• c -10 11 12 -13

相关系数与协方差

有些汇总

F. python pandas 日期年份列的空白单元格如何处理

如果缺失正携备日期知道是1991年的话，那么可以使用前向填充隐猜：

data.fillna(method='ffill')

缺失的值会使用上一行的值来进行填举毁充，即1991，见下图：

G. Python pandas用法

在Python中，pandas是基于NumPy数组构建的，使数据预处理、清洗、分析工作变得更快更简单。pandas是专门为处理表格和混杂数据设计的，而NumPy更适合处理统一的数值数组数据。
使用下面格式约定，引入pandas包：

pandas有两个主要数据结构：Series和DataFrame。

Series是一种类似于一维数组的对象，它由 一组数据 （各种NumPy数据类型）以及一组与之相关的 数据标签（即索引） 组成，即index和values两部分，可以通过索引的方式选取Series中的单个或一组值。

pd.Series(list,index=[ ]) ，第二个参数是Series中数据的索引，可以省略。

Series类型索引、切片、运算的操作类似于ndarray，同样的类似Python字典类型的操作，包括保留字in操作、使用.get()方法。
Series和ndarray之间的主要区别在于Series之间的操作会根据索引自动对齐数据。

DataFrame是一个表格型的数据类型，每列值类型可以不同，是最常用的pandas对象。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）。DataFrame中的数据是以一个或多个二维块存放的（而不是列表、字典或别的一维数据结构）。

pd.DataFrame(data,columns = [ ],index = [ ]) ：columns和index为指定的列、行索引，并按照顺序排列。

如果创建时指定了columns和index索引，则按照索引顺序排列，并且如果传入的列在数据中找不到，就会在结果中产生缺失值：

数据索引 ：Series和DataFrame的索引是Index类型，Index对象是不可修改，可通过索引值或索引标签获取目标数据，也可通过索引使序列或数据框的计算、操作实现自动化对齐。索引类型index的常用方法：

重新索引 ：能够改变、重排Series和DataFrame索引，会创建一个新对象，如果某个索引值当前不存在，就引入缺失值。
df.reindex(index, columns ,fill_value, method, limit, ) ：index/columns为新的行列自定义索引；fill_value为用于填充缺失位置的值；method为填充方法，ffill当前值向前填充，bfill向后填充；limit为最大填充量； 默认True，生成新的对象，False时，新旧相等不复制。

删除指定索引 ：默认返回的是一个新对象。
.drop() ：能够删除Series和DataFrame指定行或列索引。
删除一行或者一列时，用单引号指定索引，删除多行时用列表指定索引。
如果删除的是列索引，需要增加axis=1或axis='columns'作为参数。
增加inplace=True作为参数，可以就地修改对象，不会返回新的对象。

在pandas中，有多个方法可以选取和重新组合数据。对于DataFrame，表5-4进行了总结

适用于Series和DataFrame的基本统计分析函数 ：传入axis='columns'或axis=1将会按行进行运算。
.describe() ：针对各列的多个统计汇总，用统计学指标快速描述数据的概要。
.sum() ：计算各列数据的和
.count() ：非NaN值的数量
.mean( )/.median() ：计算数据的算术平均值、算术中位数
.var()/.std() ：计算数据的方差、标准差
.corr()/.cov() ：计算相关系数矩阵、协方差矩阵，是通过参数对计算出来的。Series的corr方法用于计算两个Series中重叠的、非NA的、按索引对齐的值的相关系数。DataFrame的corr和cov方法将以DataFrame的形式分别返回完整的相关系数或协方差矩阵。
.corrwith() ：利用DataFrame的corrwith方法，可以计算其列或行跟另一个Series或DataFrame之间的相关系数。传入一个Series将会返回一个相关系数值Series（针对各列进行计算），传入一个DataFrame则会计算按列名配对的相关系数。
.min()/.max() ：计算数据的最小值、最大值
.diff() ：计算一阶差分，对时间序列很有效
.mode() ：计算众数，返回频数最高的那（几）个
.mean() ：计算均值
.quantile() ：计算分位数（0到1）
.isin() ：用于判断矢量化集合的成员资格，可用于过滤Series中或DataFrame列中数据的子集
适用于Series的基本统计分析函数，DataFrame[列名]返回的是一个Series类型。
.unique() ：返回一个Series中的唯一值组成的数组。
.value_counts() ：计算一个Series中各值出现的频率。
.argmin()/.argmax() ：计算数据最大值、最小值所在位置的索引位置（自动索引）
.idxmin()/.idxmax() ：计算数据最大值、最小值所在位置的索引（自定义索引）

pandas提供了一些用于将表格型数据读取为DataFrame对象的函数。下表对它们进行了总结，其中read_csv()、read_table()、to_csv()是用得最多的。

在数据分析和建模的过程中，相当多的时间要用在数据准备上：加载、清理、转换以及重塑。

在许多数据分析工作中，缺失数据是经常发生的。对于数值数据，pandas使用浮点值NaN（np.nan）表示缺失数据，也可将缺失值表示为NA（Python内置的None值）。

替换值
.replace(old, new) ：用新的数据替换老的数据，如果希望一次性替换多个值，old和new可以是列表。默认会返回一个新的对象，传入inplace=True可以对现有对象进行就地修改。

删除重复数据

利用函数或字典进行数据转换

df.head()：查询数据的前五行
df.tail()：查询数据的末尾5行
pandas.cut()
pandas.qcut() 基于分位数的离散化函数。基于秩或基于样本分位数将变量离散化为等大小桶。
pandas.date_range() 返回一个时间索引
df.apply() 沿相应轴应用函数
Series.value_counts() 返回不同数据的计数值
df.aggregate()
df.reset_index() 重新设置index，参数drop = True时会丢弃原来的索引，设置新的从0开始的索引。常与groupby()一起用
numpy.zeros()

H. pandas常用函数汇总

pandas官方文档:http://pandas.pydata.org/pandas-docs/stable/api.html

对常用函数做了汇总，每个函数的参数可能不是全的，但是常用的，不常用的没总结，如有问题，请不吝赐教，谢谢！

1、创建Series

      通用函数：pd.Series(values,index)

     1)pd.Series([1,2,3],index=[‘a’,‘b’,‘c‘])

     2)pd.Series(np.array([1,2,3]),index=[‘a’,‘b’,‘c‘])

     3)pd.Series({ 'a'：1,  'b'：2,  'c'：3})

        Series转字典：Series.to_dict()

     说明：Series的values参数是python中常见的一维数据类型。

2、属性李此拦

     1）Series.values --->array([1,2,3])

           Series的values是array类型

     2）Series.index--->index([‘a’,‘b’,‘c‘])

           未指定index时，自动生成 0-（N-1）的整数索引，

           指定 index时，使用指定索引。

 3、Series的索引与切片

       Series[0] / Series['a']  : Sereis可以位置索引或标签索引，也可以进行切片操作

1、创建DataFrame

    1) 创建DataFrame的通用函数：

     df = pd.DataFrame(values,index,columns)

     pd.dataFrame([[1,2,3],[4,5,6],[7,8,9]],index=['a','b','c'],columns=['bj','sh','sz'])

     pd.dataFrame(np.arange(1,10).reshape(3,3),index=['a','b','c'],columns=['bj','sh','sz'])

     pd.dataFrame('bj':[1,4,7],'sh':[2,5,8],'sz':[3,6,9],index=['a','b','c'])

说明：创建方法与Sries类似，Series的values参数是python中常见的一维数据类型，DataFrame的values参数是python中常见的二维数据类型。

    2) 通过网页中复制数据快捷创建

        import webbrowser

        link = 'https://www.tiobe.com/tiobe-index/'

        webbrowser.open(link)

        打开界面进行复扒做制，将数据复制到粘贴板中

        df = pd.read_clipboard()   #从粘贴板中读取数据

    3）通过Series创建DataFrame

        df = pd.DataFrame([s1,s2,s3],columns=['bj','sh','sz'])

        注意：单独的s1,s2,s3是纵向排列的的Series，但是在DataFrame中是横向排列的。

        自己总结：Series除了打印出来是Series格式外，其他时候可以直接当作list来操作。

2、属性

     1)df.columns

        通过columns生成新的DataFrame

        df_new = pd.DataFrame(df,columns=['x1','x2'])

       哪胡 或者df_new = df[['x1','x2']]

    2)df.shape  显示行列数

    3)df.head()   默认显示前5行

    4)df.tail()     默认显示后5行

3、获取DataFrame的列

     1）获取DataFrame某一列

          df.x1或df['x1']:返回值是Series,可以理解为一个DataFrame是由多个Series组成的。

      2) 获取DataFrame某几列

          df_new = df[['x1','x2','x3']]

4、为某列赋值

      1) df['x1'] = range(10)

      2) df['x1'] = numpy.arange(10)

      3) df['x1'] = pd.Series(np.arange(10))

      说明：类似于创建Series

 5、为某列对应的特定行重新赋值

        df['x1'] = pd.Series([2,3],index=[0,1])

        将列为x1,行索引为0和1的值改为2,3

 6、获取DadaFrame的行

      for row in DataFrame.iterrows():

              print(row[0],row[1])

      #每个row是一个元祖，包含2个元素，row[0]是整型索引，row[1]是Series,所以从行的角度也可以看出，一个DataFrame是由多个Series组成的。

 7、DataFrame的转置

      df_new = df.T

1、粘贴板的io

      df = pd.read_clipboard()

      df.to_clipboard()

 2、csv的io

       df.to_csv('xxx.csv')

       df = pd.read_csv('xxx.csv')

  3、json的io

       df.to_json()

       pd.read_json(df.to_json())

   4、excel的io

        df.to_excel('xx.xlsx')

        df = pd.read_excel('xx.xlsx')

   5、df = pd.read_sql('')

        df.to_sql('')

 1、iloc

      sub_df = df.iloc[10:20,:]  选取DataFrame的10-20行，所有列数据

      sub_df = df.iloc[10:20,0:2]

      说明：iloc函数是位置索引，与索引的名字无关。

   2、loc

      sub_df = df.loc[10:20,:'movie_name']

      说明：loc是标签索引，10,20，'movie_name'  都是索引名字，与位置无关。

1、Series.reindex(index=['x1','x2','x3'],fill_value=10)

      将df重新索引，并且将NaN空值用10进行填充

2、Series.reindex(index=range(15),method='ffill')

     前项填充，后面的值用前面的值进行填充

     通过reindex想到，如果想新增一个空列或者空行，可以用reindex方法,同样地，想减少某些行或者某些列，也可以用reindex方法。

      继reindex之后删除行列的函数操作

      Series.drop('A')   #删除'A'所对应的值

      DataFrame.drop(label,axis) 

      label可以是行名也可以是列名，label是行的话axis是0，label是列的话axis是1。

     ** 删除行还可以用 del df['A']

nan是numpy的一种数据类型，np.nan,float类型

任何数据与nan的运算结果都是nan

1、nan in Series

      Series.isnull()  -->返回value为True或者False的Series

      Series.notnull()  -->返回value为True或者False的Series

      Series.dropna()  -->返回删除nan值后的Series

      Series.fillna(method='ffill')  -->前项插值，按照前面的值填充后面的空值

2、nan in DataFrame

      df.isnull()  -->返回value为True或者False的DataFrame

      df.notnull()  -->返回value为True或者False的DataFrame

      df.dropna(axis=0/1,how='any/all'，thresh=None)

      说明：axis表示删除行为nan或者列为nan；

                any表示只要有一个为空，all表示行中的每个元素或者列中的每个元素为空；

                thresh是阈值的意思，表示某行或者某列nan的个数达到阈值的个数时才删除该行或该列。

      df.fillna(value=1)  --->所有的空值都填充为1

      df.fillna(value={0:0,1:1,2:2}) --->将0列的空值填为0,1列的空值填为1,2列的空值填为2，默认为填充列

      注意：fillna和dropna的特点，生成新的DataFrame,原来的DataFrame不变。

1、多重索引介绍

     Series = pd.Series(np.random.randn(6),index=[['1','1','1','2','2','2'],['a','b','c','a','b','c']])

    '1','2'为一级索引，'a','b','c'为二级索引

    df 可以看做是索引的'1','2'的Series

    Series['1']  -->Series

    Series['1']['a']  -->value

    Series[:,'a'] -->选择'1'和'2'中的'a'对应的值

2、多重索引格式转为二维DataFrame

    df = Series.unstack() -->转为二维DataFrame

3、多重索引在DataFrame中的操作

1、 map函数与apply函数、applymap函数的区别：

      1）map函数对Series中的每个元素作用；

      2）applymap函数对DataFrame中的每个元素作用；

      3）apply函数对对DataFrame和Series的一列做整体运算。

2、Series.replace(to_replace=[2,3,4],values=[20,30,40])  替换Series中多个值

    Series.replace({1:10,2:20})  将索引为1的值替换为10，将索引为2的值替换为20

    df.sum()  -->默认按照列进行求和,nan的值被忽略

    df.min()  -->默认按照列求最小值

    df.max()  -->默认按照列求最大值

    df.mean()  -->默认按照列求平均值

    df.describe()  -->默认按照列进行描述

    df.sum(axis=1)  -->按行求和，nan的值被忽略

    #axis=0表示对横轴进行操作，但是运算中表现为纵轴操作

    #axis=1表示对纵轴进行操作，但是运算中表现为横轴操作

 bins = [0,59,70,80,100],bins是分割范围

 score_cat = pd.cut(Series,bins)  --->得到catgory类型的数据

 DataFrame的分箱技术很棒啊！

 pd['catgory'] = pd.cut(df['a'],bins=[0,59,70,80,100],labels=['low','ok','good','great'])

 -->新增一列，将a列的值按照labels进行分类标记，good!!!

 #生成长度为3的随机字符串  pd.util.testing.rands(3)

1、按照一列分组

      g = df.groupby('city')

      g是分组类型数据，打印不出来，所以看不到，但是有属性和方法可以间接的了解

     1） g.groups  -->得到分的几个组，和每个组包含的索引

     2）g.get_group('BJ')  -->得到'BJ'所对应的组

     3）groupby = split +apply +combine

           g.mean()  -->求每组的平均值

           g.max()   -->求每组的最大值

           g.min()   -->求每组的最小值

           g.count()

           g.describe()

      4）g是一个可迭代对象，可以用list函数将其转化为list

          list(g) -- > [('组名1',DataFrame1),('组名2',DataFrame2),(),()]

          dict(list(g))  -->将其转化为字典

      同时可以通过for循环进行遍历操作：for item,desc in g:print(item,desc)

      #怪不得分组后不是DataFrame，因为元组的第一个元素是'分组名'。

2、按照多列分组

      g_new = df.groupby(['city','wind'])

      得到生成器((('分组1','分组2'),DataFrame),(),()...)

      g_new.get_group(('分组1','分组2'))

      for (name_1,name_2),group in g_new:

              print((name_1,name_2),group)

 g.mean()  -->求每组的平均值

 与g.agg('mean')方法一样

pd.pivot_table(df,index=['',''],aggfuc='sum',values=['',''])

index是分组的组名，values是透视表呈现结果的列，columns是values下的分解

#感觉透视表呈现的结果就是groupby+agg后的结果

#分析者需要对数据结构有一定的了解

df.sort_values(by='',ascending=True/False)[:10]  df可以索引

df.value_counts()  -->按值计数

df.['a'] = df['b'].apply(lambda x:x>0)  -->DataFrame中的True/False

通过g.size()可以看到被groupby之后的数据，得到的是一个Series

1、Series的排序：

    1）对值进行排序

    Series.sort_values()  --->直接对Series的值进行排序

    2）通过索引进行排序

    Series.sort_index() 

    #默认都是升序排列

2、DataFrame的排序

     df.sort_values(by='')  -->按照某列的顺序进行排序

    df['a'].sort_values()  -->返回对a列数据的排序结果，只返回a列

1、df.index = Series(['a','b','c'])  直接对index赋予新值

2、df.index = df.index.map(str.upper)

     map函数中只传入新的函数名即可

3、df.rename(index=str.upper,columns=str.lower)

      或者传递字典，进行一一转换

    pd.merge(df1,df2,on=None,how='left/right/inner/outer')

    pd.merge(df1,df2)  -->没有on参数默认先找相同的columns,然后在columns下找相同的values

    pd.merge(df1,df2,on='columns')  -->on参数是指按照指定列进行merge

    left:表示以左边的数据表为基准，进行填充右面的数据

    right:表示以右边的数据表为基准，填充左边的数据

    outer:以on的指定列的所有值为基准，填充两边的数据

    inner:默认inner,相同on指定的columns下的相同values对应的左右两边的数据

1、concat拼接

    pd.concat([Series1,Series2])

    pd.concat([df1,df2])  -- >上下叠加，将没有的列进行填充

2、combine组合

    Series1.combine_first(Series2)  -->用Series2的值去填充Series1中为空的值

    df1.combine_first(df2)  --->用df2将df1中的空值填充

    df['A'] = df['A'].apply(str.upper)  --->apply函数中也只输入函数名

    len(df)  -->求df的长度

    len(df['a'].unique())  -->查看a列中不重复数据的多少

    Series.plicated()  -->返回一列True/False的Series

    Series.drop_plicates()  -->删除重复值

    df.drop_plicates('a',keep='first/last')

    df.drop_plicates()  -->删除完全重复的行

    参数：'a'表示以a列为基准，删除重复值

              first表示保留第一个，last表示保留最后一个

    data_list = pd.date_range(start,end,period='D',freq)

    period='D',以天为单位

    freq = 'W' 以周为单位

    freq = 'W-Mon'以每周一位单位

    freq = '5H'  以5h为单位

    以data_range作为索引提取数据比较简单

    df[datetime(2017,9,1)]

    df['2017-09-01']

    df['20170901']

    df['201709']

    对时间序列数据进行分组聚合操作：

    s1.resample('M').mean()  -->以月为单位进行采样，然后求每组的平均值

    s1.resample('H').ffill()  -->前项填充

    s1.resample('H').bfill()  -->后项填充

补充：1）jupyter中可以执行linux命令，太棒了！

                !ls

                !more xxx.csv

                !pwd  等等

           2）jupyter 查看函数帮助的快捷键：摁住shift + tab  棒！！！

I. 缺失值处理

 缺失数据 

1 缺失值的统计和删除 

1.1 缺失信息的统计

缺失数据可以使用 isna 或 isnull （两个函数没有区别）来查看每个单元格是否缺失，通过和 sum 的组合可以计算出每列缺失值的比例。

如果想要查看某一列缺失或者非缺失的行，可以利用 Series 上的 isna 或者 notna 进行布尔索引。例如，查看身高缺失的行：

如果想要同时对几个列，检索出全部为缺失或者至少有一个缺失或者没有缺失的行，可以使用 isna, notna 和any, all 的组合。例如，对身高、体重和转系情况这 3 列分别进行这三种情况的检索

1.2 缺失信息的删除

数据处理中经常需要根据缺失值的大小、比例或其他特征来进行行样本或列特征的删除，pandas 中提供了dropna 函数来进行操作。

dropna 的主要参数为轴方向 axis （默认为 0，即删除行）、删除方式 how 、删除的非缺失值个数阈值 thresh（非缺失值没有达到这个数量的相应维度会被删除）、备选的删除子集 subset ，其中 how 主要有 any 和 all两种参数可以选择。

2 缺失值的填充和插值 

2.1 利用 fillna 进行填充 

在 fillna 中有三个参数是常用的：value, method, limit 。其中，value 为填充值，可以是标量，也可以是索引到元素的字典映射；method 为填充方法，有用前面的元素填充 ffill 和用后面的元素填充 bfill 两种类型，limit 参数表示连续缺失值的最大填充次数。

2.2 插值函数 

在关于 interpolate 函数的 文档 描述中，列举了许多插值法，包括了大量 Scipy 中的方法。由于很多插值方法涉及到比较复杂的数学知识，因此这里只讨论比较常用且简单的三类情况，即线性插值、最近邻插值和索引插值。

对于 interpolate 而言，除了插值方法（默认为 linear 线性插值）之外，有与 fillna 类似的两个常用参数，一个是控制方向的 limit_direction ，另一个是控制最大连续缺失值插值个数的 limit 。其中，限制插值的方向默认为 forward ，这与 fillna 的 method 中的 ffill 是类似的，若想要后向限制插值或者双向限制插值可以指定为 backward 或 both

关于 polynomial 和 spline 插值的注意事项

在 interpolate 中 如 果 选 用 polynomial 的 插 值 方 法， 它 内 部 调 用 的 是scipy.interpolate.interp1d(*,*,kind=order) ， 这 个 函 数 内 部 调 用 的 是 make_interp_spline方法，因此其实是样条插值而不是类似于 numpy 中的 polyfit 多项式拟合插值；而当选用 spline方法时，pandas 调用的是 scipy.interpolate.UnivariateSpline 而不是普通的样条插值。这一部分的文档描述比较混乱，而且这种参数的设计也是不合理的，当使用这两类插值方法时，用户一定要小心谨慎地根据自己的实际需求选取恰当的插值方法。

3 Nullable 类型

3.1 缺失记号及其缺陷

在 python 中的缺失值用 None 表示，该元素除了等于自己本身之外，与其他任何元素不相等：

在 numpy 中利用 np.nan 来表示缺失值，该元素除了不和其他任何元素相等之外，和自身的比较结果也返回False

值得注意的是，虽然在对缺失序列或表格的元素进行比较操作的时候，np.nan 的对应位置会返回 False ，但是在使用 equals 函数进行两张表或两个序列的相同性检验时，会自动跳过两侧表都是缺失值的位置，直接返回 True ：

在时间序列的对象中，pandas 利用 pd.NaT 来指代缺失值，它的作用和 np.nan 是一致的

那么为什么要引入 pd.NaT 来表示时间对象中的缺失呢？仍然以 np.nan 的形式存放会有什么问题？在 pandas中可以看到 object 类型的对象，而 object 是一种混杂对象类型，如果出现了多个类型的元素同时存储在 Series中，它的类型就会变成 object

NaT 问题的根源来自于 np.nan 的本身是一种浮点类型，而如果浮点和时间类型混合存储，如果不设计新的内置缺失类型来处理，就会变成含糊不清的 object 类型，这显然是不希望看到的。

同时，由于 np.nan 的浮点性质，如果在一个整数的 Series 中出现缺失，那么其类型会转变为 float64 ；而如果在一个布尔类型的序列中出现缺失，那么其类型就会转为 object 而不是 bool

因此，在进入 1.0.0 版本后，pandas 尝试设计了一种新的缺失类型 pd.NA 以及三种 Nullable 序列类型来应对这些缺陷，它们分别是 Int, boolean 和 string 。

3.2 Nullable 类型的性质

从字面意义上看 Nullable 就是可空的，言下之意就是序列类型不受缺失值的影响。例如，在上述三个 Nullable类型中存储缺失值，都会转为 pandas 内置的 pd.NA

在 Int 的序列中，返回的结果会尽可能地成为 Nullable 的类型

对于 boolean 类型的序列而言，其和 bool 序列的行为主要有两点区别：

第一点是带有缺失的布尔列表无法进行索引器中的选择，而 boolean 会把缺失值看作 False

第二点是在进行逻辑运算时，bool 类型在缺失处返回的永远是 False ，而 boolean 会根据逻辑运算是否能确定唯一结果来返回相应的值。那什么叫能否确定唯一结果呢？举个简单例子：True | pd.NA 中无论缺失值为什么值，必然返回 True ；False | pd.NA 中的结果会根据缺失值取值的不同而变化，此时返回 pd.NA ；False& pd.NA 中无论缺失值为什么值，必然返回 False 。

3.3 缺失数据的计算和分组

当调用函数 sum, prob 使用加法和乘法的时候，缺失数据等价于被分别视作 0 和 1，即不改变原来的计算结果

当使用累计函数时，会自动跳过缺失值所处的位置：

当进行单个标量运算的时候，除了 np.nan ** 0 和 1 ** np.nan 这两种情况为确定的值之外，所有运算结果全为缺失（pd.NA 的行为与此一致），并且 np.nan 在比较操作时一定返回 False ，而 pd.NA 返回 pd.NA

另外需要注意的是，diff, pct_change 这两个函数虽然功能相似，但是对于缺失的处理不同，前者凡是参与缺失计算的部分全部设为了缺失值，而后者缺失值位置会被设为 0% 的变化率

对于一些函数而言，缺失可以作为一个类别处理，例如在 groupby, get_mmies 中可以设置相应的参数来进行增加缺失类别：

4 练习 

4.1 Ex1：缺失值与类别的相关性检验

.4.2 Ex2：用回归模型解决分类问题

J. python(pandas模块)

1.什么是pandas? numpy模块和pandas模块都是用于处理数据的模块。 numpy主要用于针对数组进行统计计算,处理数字数据比较方便。 pandas除了可以处理数字数据,还可...