DataFrame

DataFrame是一种表格型数据结构，它含有一组有序的列，每列可以是不同的值。DataFrame既有行索引，也有列索引，它可以看作是由Series组成的字典，不过这些Series公用一个索引。

一. DataFrame的创建
二.DataFrame 的属性
三. DataFrame的索引
四. DataFrame的运算
五. DataFrame 处理丢失数据
六. DataFrame的多层索引
七. DataFrame的合并

一. DataFrame的创建

字典创建

import pandas as pd
dict = {
    'name':['lucy','ann','lisa'],
    'sex':['f','m','f'],
    'age':[18,20,18]
}
df = pd.DataFrame(dict)
print(df)
#    name sex  age
# 0  lucy   f   18
# 1   ann   m   20
# 2  lisa   f   19

二.DataFrame 的属性

DataFrame 的属性：

values,columns,index,shape

import pandas as pd
dict = {
   'name':['lucy','ann','lisa'],
   'sex':['f','m','f'],
   'age':[18,20,19]
}
df = pd.DataFrame(dict)

print(df.shape) 
# (3, 3)
print(df.index)
# RangeIndex(start=0, stop=3, step=1)
print(df.columns)
# Index(['name', 'sex', 'age'], dtype='object')
print(df.values)
# [['lucy' 'f' 18]
#  ['ann' 'm' 20]
#  ['lisa' 'f' 19]]

修改属性值

df = pd.DataFrame(dict)
df.index = ['a','b','c']
df.columns=['name','sex','a']

print(df)
#    name sex   a
# a  lucy   f  18
# b   ann   m  20
# c  lisa   f  19

三. DataFrame的索引

若索引为汉字，有时无法检索结果

列索引

访问dataframe的列，有两种方法，返回series

print(df.name)
# a    lucy
# b     ann
# c    lisa
# Name: name, dtype: object
print(df['sex'])
# a    f
# b    m
# c    f
# Name: sex, dtype: object

行索引

访问指定行，返回series

df.loc[] 可设置选取条件
df.iloc[]

print(df.loc['a'])
# name    lucy
# sex        f
# age       18
# Name: a, dtype: object

# 检索多行
print(df.loc[['a','b']])
#    name sex  age
# a  lucy   f   18
# b   ann   m   20

# 切片，检索 a行至c行
print(df.loc['a':'c'])
#    name sex  age
# a  lucy   f   18
# b   ann   m   20
# c  lisa   f   19

print(df.iloc[1:3])
#    name sex  age
# b   ann   m   20
# c  lisa   f   19

元素索引

取出某个值或修改某个值

print(df.values[0,2])
# 18
print(df['name']['b'])
# ann

df['name']['b'] = 'sunny'
print(df)
#    name sex  age
# a  lucy   f   18
# b   ann   m   20
# c  lisa   f   19

四. DataFrame的运算

df1 = pd.DataFrame(np.random.randint(0,150,size=(4,4)),
                   index=['张','李','王','刘'],
                   columns=['语文','英语','js','python'])

df2 = pd.DataFrame(np.random.randint(0,150,size=(5,4)),
                   index=['张','李','王','刘','胡'],
                   columns=['语文','英语','js','python'])

# fill_value 置空缺值为多少
print(df1.add(df2,fill_value=0))
#       语文     英语     js  python
# 刘  200.0  163.0  256.0   213.0
# 张  127.0  289.0  168.0   144.0
# 李  133.0  122.0  147.0   128.0
# 王  291.0  157.0   78.0   116.0
# 胡   73.0   21.0   72.0   122.0

参数：

fill_value：空缺时的默认值
axis：
为0 或 index 表示以列为单位操作
为1 或 columns 表示以行为单位操作
默认为 columns

单列运算

df1 = pd.DataFrame(np.random.randint(0,150,size=(4,4)),
                   index=['张','李','王','刘'],
                   columns=['语文','英语','js','python'])
df = df1['js']
print(df1.add(df,axis='index'))
#     语文   英语   js  python
# 张   65  114   26      45
# 李   89  151  128      93 
# 王  134  194  220     227
# 刘  186  190  122     176

汇总，平均，最大

sum()
mean()
max()

df1 = pd.DataFrame(np.random.randint(0,150,size=(4,4)),
                   index=['张','李','王','刘'],
                   columns=['语文','英语','js','python'])

print(df1.max(axis=0))
# 语文        136
# 英语        137
# js         90
# python     75
# dtype: int32

print(df1.mean(axis=0))
#语文         98.25
# 英语        102.25
# js         51.50
# python     55.50
# dtype: float64

print(df1.sum(axis=1))
# 张    274
# 李    310
# 王    363
# 刘    283
# dtype: int64

五. DataFrame 处理丢失数据

有两种丢失数据类型：

None ----- 不能参与任何计算，类型为 python object
np.nan(NaN) ----- 能参与计算，类型为浮点型，计算结果为 NaN

操作：

isnull()
notnull()
dropnull() 过滤丢失数据
fillna() 填充丢失数据

判断数据数据丢失情况

dict = {'salary':[1000,2000,2152], 'age':[18,20,18],}
df = pd.DataFrame(dict,index=['lucy','ann','lisa'],columns=['salary','age','work'])
df['work'].loc['ann']='js'
print(df)
#       salary  age work
# lucy    1000   18  NaN
# ann     2000   20   js
# lisa    2152   18  NaN

s1 = df.isnull().any(axis=1)
print(s1)
# lucy     True
# ann     False
# lisa     True
# dtype: bool

# 获得空数据所在行
print(df[s1])
#       salary  age work
# lucy    1000   18  NaN
# lisa    2152   18  NaN

isnull().any() -----表示此行/列存在数据为空就为true ，若此行/列数据都存在则为false

notnull().all() -----表示此行/列所有数据都存在则为true，否则为false

删除缺失数据所在列/行

print(df.dropna(axis=1,how='any'))
#       salary  age
# lucy    1000   18
# ann     2000   20
# lisa    2152   18

how='any' ----表示此行/列存在空数据时删除
how='all' ----表示此行/列全为空数据时删除

填充缺失数据

dict = {'salary':[1000,2000,2152], 'age':[18,20,18],}
df = pd.DataFrame(dict,index=['lucy','ann','lisa'],columns=['salary','age','work'])
df['work'].loc['ann']='js'
print(df)
#       salary  age work
# lucy    1000   18  NaN
# ann     2000   20   js
# lisa    2152   18  NaN

print(df.fillna(value='c++'))
#       salary  age work
# lucy    1000   18  c++
# ann     2000   20   js
# lisa    2152   18  c++

print(df.fillna(method='ffill'))
#       salary  age work
# lucy    1000   18  NaN
# ann     2000   20   js
# lisa    2152   18   js

函数内部参数：

value: 缺失数据所填充的值
method:
'backfill'，'bfill' ----- 向后填充
'pad'，‘ffill’ ----- 向前填充
inplace: 为 True 在原来dataframe进行修改，为 false 未改变原来的dataframe
axis: 0/1

六. DataFrame的多层索引

列多层索引与行多层索引相似

隐式构造

df = pd.DataFrame(np.random.randint(0,150,size=(6,4)),
                   index=[['张','张','李','李','王','王'],['mid','end','mid','end','mid','end']],
                   columns=['语文','英语','js','python'])

print(df)
#        语文  英语   js  python
# 张  mid  17  49  114     127
#      end  23  57    8     124
# 李  mid  48  44   93     114
#      end  37  90   50     129
# 王  mid  14  72  149      98
#      end  39  12   71      35

显式构造

使用数组
index = pd.MultiIndex.from_arrays([['张','张','李','李','王','王'],['mid','end','mid','end','mid','end']])
使用 tuple
index = pd.MultiIndex.from_tuples()
使用 product -----简单，推荐使用
index = pd.MultiIndex.from_product([['张','李','王'],['mid','end']])

七. DataFrame的合并

merge 与 concat 的区别在于，merge 需要依据共同的一行或列进行合并
使用 pd.merge() 进行合并时，会自动根据两者相同 column 名称的那一列，作为key 来进行合并

一对一合并

df1 = pd.DataFrame({'item':['apple','bananla'],
                   'price':[10,20],
                   'number':[30,20]})
df2 = pd.DataFrame({'item':['apple','bananla'],
                   'size':['s','m'] })

print(pd.merge(df1,df2))
#       item  price  number size
# 0    apple     10      30    s
# 1  bananla     20      20    m

若列名相同列的数据不同，则取其公共部分：

df1 = pd.DataFrame({'item':['apple','bananla','melon'],
                   'price':[10,20,30],
                   'number':[30,20,10]})
df2 = pd.DataFrame({'item':['apple','bananla','purple'],
                   'size':['s','m','l'] })

print(pd.merge(df1,df2))
#       item  price  number size
# 0    apple     10      30    s
# 1  bananla     20      20    m

多对一合并

若列名相同列的数据存在一对多个的情况，则展示多个；

df1 = pd.DataFrame({'item':['apple','bananla','melon'],
                   'price':[10,20,30],
                   'number':[30,20,10]})
df2 = pd.DataFrame({'item':['apple','bananla','apple'],
                   'size':['s','m','l'] })

print(pd.merge(df1,df2))
#       item  price  number size
# 0    apple     10      30    s
# 1    apple     10      30    l
# 2  bananla     20      20    m

多对多合并

在多对多进行合并时，每一个数据都没有放过

df1 = pd.DataFrame({'item':['apple','bananla','apple'],
                   'price':[10,20,30],
                   'number':[30,20,10]})
df2 = pd.DataFrame({'item':['apple','bananla','apple'],
                   'size':['s','m','l'] })

print(pd.merge(df1,df2))
#       item  price  number size
# 0    apple     10      30    s
# 1    apple     10      30    l
# 2    apple     30      10    s
# 3    apple     30      10    l
# 4  bananla     20      20    m

解决列冲突

当存在多列相同时，指定key为哪列

参数 on = ' ' ,指定列
suffixes = [ ] , 除指定列，分辨相同列列名

df1 = pd.DataFrame({'item':['apple','bananla','melon'],
                   'price':[10,20,30],
                   'number':[30,20,10]})
df2 = pd.DataFrame({'item':['apple','bananla','melon'],
                    'price': [1, 2, 30],
                   'size':['s','m','l'] })

print(pd.merge(df1,df2, on = 'item' ,suffixes = ['_A商家','_B商家'] ))
#       item  price_A商家  number  price_B商家 size
# 0    apple         10      30          1    s
# 1  bananla         20      20          2    m
# 2    melon         30      10         30    l

内合并

只保留两者都有的 key （默认模式）

外合并

how = 'outer' : 空缺处补 NaN

左右合并

how = 'left'
how = 'right'