DataFrame是一个【表格型】的数据结构。DataFrame由按一定顺序排列的多列数据组成。设计初衷是将Series的使用场景从一维拓展到多维。DataFrame既有行索引，也有列索引。

• 行索引：index

• 列索引：columns

• 值：values

DataFrame的创建

• 最常用的方法是传递一个字典来创建。DataFrame以字典的键作为每一【列】的名称，以字典的值（一个数组）作为每一列。

• 此外，DataFrame会自动加上每一行的索引。使用字典创建的DataFrame后，则columns参数将不可被使用。同Series一样，若传入的列与字典的键不匹配，则相应的值为NaN。

• DataFrame属性：values、columns、index、shape

dic={
    'xiaoming':[88,66,55],
    'lingling':[99,77,33],
    'xiaoli':[55,88,65]
}

df1=DataFrame(data=dic,index=['语文','数学','英语'])
df1
lingling    xiaoli  xiaoming
语文  99  55  88
数学  77  88  66
英语  33  65  55
12345678910111213

根据添加行索引添加行数据

df1.loc['物理']=[55,84,66]
df1

lingling    xiaoli  xiaoming
语文  99  55  88
数学  77  88  66
英语  33  65  55
物理  55  84  66
123456789

根据添加列索引添加列数据

df1['xixi']=[88,55,44,11]
df1

lingling    xiaoli  xiaoming    xixi
语文  99  55  88  88
数学  77  88  66  55
英语  33  65  55  44
物理  55  84  66  11
123456789

对列进行索引

• 通过类似字典的方式 df[‘q’]

• 通过属性的方式 df.q

• 可以将DataFrame的列获取为一个Series。返回的Series拥有原DataFrame相同的索引，且name属性也已经设置好了，就是相应的列名。

对行进行索引

• 使用.loc[]加index来进行行索引

• 使用.iloc[]加整数来进行行索引

• 同样返回一个Series，index为原来的columns。

使用行索引(iloc[3,1] or loc[‘C’,’q’]) 行索引在前，列索引在后

df.iloc[1,2]

df.loc['语文','xiaoli']1234

行切片

df1['语文':'英语']1

列切片

df1.loc[:,'lingling':'xiaoming']1

• 直接用中括号时：

• 索引表示的是列索引

• 切片表示的是行切片

DataFrame的运算

• 每个元素进行+-*/

df1+11

• DataFrame之间的运算，同Series一样：

• 在运算中自动对齐不同索引的数据

• 如果索引不对应，则补NaN

df2=DataFrame(data=np.random.randint(1,100,(4,4)),index=['A','B','C','D'],
             columns=['a','b','c','d'])
df2
df1+df2
12345

pandas处理空值操作

• isnull()

• notnull()

• dropna(): 过滤丢失数据

• fillna(): 填充丢失数据

• df.notnull().any()/all()来判断每行是否有空值

df3=DataFrame(data=np.random.randint(1,100,(4,5)),index=['A','B','C','D'],
             columns=['a','b','c','d','e'])
df3

df3.loc['A','b']=None
df3.loc['B','c']=None
df3

df3.notnull().all()
12345678910

判断哪一行有空值

df3.notnull().all(axis=1)1

过滤掉有空值的行

df3[df3.notnull().all(axis=1)]1

删除空值,默认删除行，设置axis=1删除列

df3.dropna(axis=1)1

填充空值

df3.fillna(66)1

创建多层列索引

• 隐式构造

df=DataFrame(data=np.random.randint(60,120,size=(2,4)),
         columns=[['qizhong','qizhong','qimo','qimo'],['chinese','math','chinese','math']],
         index=['tom','jay'])123

• 显示构造pd.MultiIndex.from_，使用product创建

col=pd.MultiIndex.from_product([['qizhong','qimo'],
                                ['chinese','math']])
df=DataFrame(data=np.random.randint(60,120,(2,4)),columns=col,index=['tom','bill'])123

• 多层列索引

df['qizhong']['math']1

多层行索引

df.loc['tom']['qizhong']['math']1

索引的堆（stack）：对矩阵的索引进行变换处理

• stack()：把列索引变成行索引 （从上到左）

• unstack()：把行索引变成列索引（从左到上）

• level=0,代表最外层索引，level=1代表第二层索引

df.stack(level=0)

df.unstack()123

聚合操作

• 所谓的聚合操作：平均数，方差，最大值，最小值……

• df.mean(),df.max(),df.min()…..

df2.max(axis=1)1

pandas的拼接操作

• pandas的拼接分为两种：

• 级联：pd.concat, pd.append

• 合并：pd.merge, pd.join

• 使用pd.concat()级联

• pandas使用pd.concat函数，与np.concatenate函数类似，只是多了一些参数：
  

• objs

• axis=0

• keys

• join=’outer’ / ‘inner’:表示的是级联的方式，outer会将所有的项进行级联（忽略匹配和不匹配），而inner只会将匹配的项级联到一起，不匹配的不级联

• ignore_index=False

df5=DataFrame(data=np.random.randint(1,100,(4,4)),index=['A','B','C','D'],
             columns=['a','b','c','d'])
df6=DataFrame(data=np.random.randint(1,100,(4,4)),index=['A','B','C','D'],
             columns=['a','b','c','d'])

pd.concat([df5,df6],ignore_index=True)123456

不匹配级联

• 不匹配指的是级联的维度的索引不一致。例如纵向级联时列索引不一致，横向级联时行索引不一致

• 有2种连接方式：
  

• 外连接：补NaN（默认模式）

• 内连接：只连接匹配的项

pd.concat([df1,df2])1

使用pd.merge()合并

• merge与concat的区别在于，merge需要依据某一共同的行或列来进行合并
  使用pd.merge()合并时，会自动根据两者相同column名称的那一列，作为key来进行合并。
  注意每一列元素的顺序不要求一致

• 参数：
  

• how：out取并集 inner取交集

• on：当有多列相同的时候，可以使用on来指定使用那一列进行合并，on的值为一个列表

• 一对一合并

df1 = DataFrame({'employee':['Bob','Jake','Lisa'],
                'group':['Accounting','Engineering','Engineering'],
                })
df2 = DataFrame({'employee':['Lisa','Bob','Jake'],
                'hire_date':[2004,2008,2012],
                })
pd.merge(df1,df2)1234567

列冲突的解决

• 当列冲突时，即有多个列名称相同时，需要使用on=来指定哪一个列作为key，配合suffixes指定冲突列名

• 可以使用suffixes=自己指定后缀

df8 = DataFrame({'name':['Peter','Paul','Mary'],
                'rank':[1,2,3]})

df9 = DataFrame({'name':['Peter','Paul','Mary'],
                'rank':[5,6,7]})

pd.merge(df8,df9,on='name')

pd.merge(df8,df9,on='name',suffixes=['_L','_R'])123456789

删除行重复元素

• 使用duplicated()函数检测重复的行，返回元素为布尔类型的Series对象，每个元素对应一行，如果该行不是第一次出现，则元素为True

• keep参数：指定保留哪一重复的行数据‘first’，‘last’，False

df5.loc['A']=66
df5.loc['C']=6612

查找每行的重复值，返回布尔值

df5.duplicated(keep=False)1

• 使用drop_duplicates()函数删除重复的行

drop_duplicates(keep='first/last'/False)1

• inplace=True会改变数据，彻底删除

df5.drop_duplicates(keep='first')1

映射

• 映射的含义：创建一个映射关系列表（一般用字典表示），把values元素和一个特定的标签或者字符串绑定（给一个元素值提供不同的表现形式）

• 包含三种操作：
  

• replace()函数：替换元素

• 最重要：map()函数：新建一列

• rename()函数：替换索引

• Series替换操作

• 单值替换

• 普通替换

• 字典替换(推荐）

• 多值替换

• 列表替换

• 参数

• to_replace:被替换的元素

• value:替换后的元素

s=Series(np.random.randint(1,100,6))
s

0    79
1    14
2    61
3    49
4    46
5    55
dtype: int32
1234567891011

单值映射

s.replace(to_replace=55,value=66)

0    79
1    14
2    61
3    49
4    46
5    66
dtype: int32123456789

多值列表映射

s.replace(to_replace=[14,46],value=[55,88])

0    79
1    55
2    61
3    49
4    88
5    55
dtype: int64

1234567891011

多值字典映射

s.replace(to_replace={79:100,
                      49:111
                     })
0    100
1     14
2     61
3    111
4     46
5     55
dtype: int6412345678910

• DataFrame使用replace同理Series，根据行索引，列索引，单个值进行替换

• map()函数：新建一列 ， map函数并不是df的方法，而是series的方法

• map(字典) 字典的键要足以匹配所有的数据，否则出现NaN: —df[‘c’].map({85:’bw’,100:’yb’})

• map()可以映射新一列数据

• map()中可以使用lambd表达式

• map()中可以使用方法，可以是自定义的方法

• eg:map({to_replace:value})

• 注意 map()中不能使用sum之类的函数，for循环

dic={
    'name':['xiaoming','zhangsan'],
    'age':[23,33]
}
df=DataFrame(data=dic)
df
age name
0   23  xiaoming
1   33  zhangsan

1234567891011

创建映射关系

e_name=df.name.map({'xiaoming':'bill',
                   'zhangsan':'jack'})
e_name
Out[23]:
0    bill
1    jack
Name: name, dtype: object
In [24]:12345678

增加一列

df['e_name']=e_name
df
age name    e_name
0   23  xiaoming    bill
1   33  zhangsan    jack12345

• map(func),可以传递自定义函数

• 注意：并不是任何形式的函数都可以作为map的参数。只有当一个函数具有一个参数且有返回值，那么该函数才可以作为map的参数

自定义 函数，使传入的参数+1

def func(s):
    return s+1
123

调用自定义函数 ，使得年龄+1

df.age.map(func)1

map(lambda 函数)

• 使得年龄+1

df.age.map(lambda s:s+1)1

rename()函数：替换索引

• 使用rename()函数替换行索引
  

• index 替换行索引

• columns 替换列索引

• level 指定多维索引的维度

df4 = DataFrame({'color':['white','gray','purple','blue','green'],'value':np.random.randint(10,size = 5)})1

改变行索引

df4.rename(index={0:'zero',
                 1:'one',
                 2:'two',
                 3:'three',
                 4:'four'})12345

改变列索引

df4.rename(columns={'color':'cl',
                   'value':'num'})12

使用聚合操作对数据异常值检测和过滤

• 使用df.std()函数可以求得DataFrame对象每一列的标准差

• 创建一个1000行3列的df 范围（0-1），求其每一列的标准差

df=DataFrame(np.random.random((1000,3)))
df.std(axis=0)12

• 保留小于两倍的第一列数据

df[0]<df[0].std()*21

• 将布尔值True作为行索引

df[df[0]<df[0].std()*2]1

…

给索引排序

• 使用.take()函数排序

• take()函数接受一个索引列表，用数字表示,使得df根据列表中索引的顺序进行排序,axis=0,代表行索引

• eg:df.take([1,3,4,2,5])

• 可以借助np.random.permutation()函数随机排序
  In [49]:

df=DataFrame(data=np.random.randint(0,100,size=(4,5)))
df.take([4,3,1,2,0],axis=1)12

随机排序

df.take(np.random.permutation(5),axis=1)1

数据分类处理【重点】

• 数据聚合是数据处理的最后一步，通常是要使每一个数组生成一个单一的数值。

• 数据分类处理：
  

• 分组：先把数据分为几组

• 用函数处理：为不同组的数据应用不同的函数以转换数据

• 合并：把不同组得到的结果合并起来
  

• 数据分类处理的核心：

• groupby()函数

• groups属性查看分组情况

df = DataFrame({'item':['Apple','Banana','Orange','Banana','Orange','Apple'],
                'price':[4,3,3,2.5,4,2],
               'color':['red','yellow','yellow','green','green','green'],
               'weight':[12,20,50,30,20,44]})
12345

分组后进行聚合操作

df.groupby(by='color')['price'].mean()

color
green     2.833333
red       4.000000
yellow    3.000000
Name: price, dtype: float641234567

• 找出哪些行是苹果的信息 使用==进行判断

df['item']=='Apple'
df[df['item']=='Apple']12

• 按颜色查看各种颜色的水果的平均价格，并将各种颜色水果的平均价格和df进行汇总

df.groupby(by='color')['price'].mean()
c_price_mean=df['color'].map({
    'green':2.83,
    'red':4,
    'yellow':3
})
df['c_price_mean']=c_price_mean1234567

高级数据聚合

• 使用groupby分组后，也可以使用transform和apply提供自定义函数实现更多的运算

• df.groupby(‘item’)[‘price’].sum() <==> df.groupby(‘item’)[‘price’].apply(sum)

• transform和apply都会进行运算，在transform或者apply中传入函数即可

• transform和apply也可以传入一个lambda表达式

• 注意
  

• transform 会自动匹配列索引返回值，不去重

• apply 会根据分组情况返回值，去重

def func(s):
    sum=0
    for i in s:
        sum+=i
    return sum/s.size12345

df.groupby(by='item')['price'].apply(func)1

df.groupby(by='item')['price'].transform(lambda s:s+1)