pandas（三）DataFrame结构介绍

DataFrame是一个2维标签的数据结构，可以把它简单的想成Excel表格或SQL Table，它的每一行或者每一列都是一个Series，所以也可以把它抽象成Series数组。

一.创建

和Series一样，DataFrame接受许多不同的类型用于创建DataFrame：

• 字典对象
• 2维列表,ndarray对象
• Series对象
• 其他DataFrame对象

1. 由字典对象创建

字典的Key作为DataFrame的列名，字典的Value作为列数据。这里，Value可以是列表，字典，或者Series等对象。可以利用index参数指定索引。

dic={'A':[1,2,3,4,5],'B':[3,2,4,5,6]}
d=df(dic)
print(d)

Out[1]: 
   A  B
0  1  3
1  2  2
2  3  4
3  4  5
4  5  6

2. 由二维结构对象创建

在创建时，我们可以使用columns参数与index参数分别指定列名与索引名，但是注意，要与列，行的数量严格匹配，否则报错。

list=[[1,2,3,4,5],[3,2,4,5,6],[2,2,2,2,2]]
d=df(list,columns=['a','b','c','d','e'],index=[1,2,3])
print(d)

Out[2]:
   a  b  c  d  e
1  1  2  3  4  5
2  3  2  4  5  6
3  2  2  2  2  2

3. 由Series对象创建

该方法可以创建一个只有一列的DataFrame对象。

s=[1,2,3,4,5]
d=df(s)
print(d)

Out[3]:
   0
0  1
1  2
2  3
3  4
4  5

4. 由其他DataFrame对象创建

类似于利用Series创建，这里不再赘述。

二. 查找与索引

DataFrame支持的查找方式有很多，主要包括：

• 点字符 :访问列
• 中括号 [ ]
• loc[ ] ：基于标签索引，可以批量选取
• iloc[ ] ：基于位置索引，可以批量选取
• at[ ] : 基于标签索引，只能选取一个元素
• iat[ ] ： 基于位置索引，只能选取一个元素
• ix[ ] ：loc与iloc的混合体，容易发生位置与标签冲突的情况，pandas不推荐使用，这里不再介绍

1. 点字符

使用点字符以访问成员变量的方式访问列，一次可以访问一列。这里不推荐使用这种方式，主要是为了避免列名与函数名或者保留字冲突。

s={'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
d=df(s,index=['a','b','c','d','e'])
print(d.A)

2. 中括号

使用中括号访问数据是Numpy遗留下来的方式，pandas虽然支持这种方式，但并不是极力推荐的。
示例数据d为：

   A   B
a  1   6
b  2   7
c  3   8
d  4   9
e  5  10

(1)访问列

• 使用列标签访问单个列：d['A'] (注意只能用列标签，不可以是列位置序号)
• 使用列列表访问多个列：d[['A','B']]

(2)访问行

• 使用索引切片访问多行：d['a' : 'c'] （此处可以使用位置）
• 使用布尔表达式访问多行： d[d['A']>2] #获取A列中大于2的所有行

(3)访问块
使用2个中括号，一个处理行，一个处理列，就可以进行块访问了，且不区分行[ ]与列[ ]的顺序。
举个栗子：

print(d [['A','B']] [d['B']>8] )
Out[4]:
   A   B
d  4   9
e  5  10

这里不要纠结，为什么行可以用切片，而列不可以；为什么列可以用列表，而行却不可以；我想说的是语法就是语法，就是不可以。

3. 使用loc

loc是严格的基于标签的索引方法，即便使用数字也会被理解为标签是数字类型的，而不会被处理为位置下标。若在loc方法中使用位置下标会发生错误。如果索引是日期类型，那么可以使用日期字符串，比如'20170912'。另外，如果访问的索引不在数据中，那么将报错。

1. loc方法的基本格式：

d.loc[行标签，列标签] #行列同时筛选
d.loc[:,列标签] #只筛选列
d.loc[行标签] #只筛选行

2. 使用loc方法接受以下输入：

• 单个标签（可以是数字）
• 标签列表
• 标签切片
• 布尔类型：判断大小，isin等
• 函数

注意：与中括号不同的是，loc的切片既可以用在行筛选，又可以用在列筛选中。另外，别忘了，标签切片，左闭右闭；位置切片，左闭右开。
举个例子：

print(d.loc[1:4,'A':'B'])

Out[5]:
   A   B
1  2   7
2  3   8
3  4   9
4  5  10

再来一个例子：

print(d.loc[d.loc[:,'A']>2,d.loc[2]>3])
Out[6]:
    B
2   8
3   9
4  10

4. 使用iloc

iloc的用法与loc完全相同，区别仅在于iloc是严格基于数字位置下标的索引方法。在iloc中，仅可以使用数字下标，否则报错。
使用iloc方法接受以下输入：

• 位置下标
• 位置列表
• 切片
• 布尔
• 函数
  注意：iloc的切片是左闭右开的！！！这点与loc不同。

print(d.iloc[1:4,0:1])
Out[7]:
   A
1  2
2  3
3  4

5. 使用at[ ] & iat[ ]

这两个函数都是通过行列坐标定位到某个具体元素的，at是基于标签的，iat是基于数字下标的。

d.at[行标签，列标签]
d.iat[行下标，列下标]

三. 添加与插入

1. 插入列

插入列一般适用于插入一列的情况，若是要插入多列，则应该数据整形，这个之后会讨论。

• 插入在最后列：直接给新列赋值就好。但是要注意，新列的名字不能与之前已经存在的列重复，否则会覆盖之前列的数据。

s={'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
d=df(s)
d['C']=[2,3,4,5,6]
print(d)

Out[4]:
   A   B  C
0  1   6  2
1  2   7  3
2  3   8  4
3  4   9  5
4  5  10  6

• 插入在其他位置：使用insert()函数

DataFrame.insert(loc, column, value, allow_duplicates=False)

loc : 插入的位置（从0开始）
column ： 列名标签字符串
value : 列数据，可以是Series或者数组序列
allow_duplicates : False时列名如果已经存在，会报错。True则不会。

s={'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
d=df(s)
d.insert(1,'C',[2,3,4,5,6])
print(d)

Out[5]:
   A  C   B
0  1  2   6
1  2  3   7
2  3  4   8
3  4  5   9
4  5  6  10

2. 插入行

目前没有函数能够直接处理插入行到指定位置，除非分割再合并，我们将在数据整形介绍。下面我们看一下如何添加一行在末尾。

• 直接赋值：
  由于中括号[ ]只能选择列，所以在选择行时，我们使用loc与iloc。但是，iloc只能给已经存在的索引赋值，而loc没有限制，所以我们使用loc来添加一行。可以想象，如果index已经存在，那么新的数据会将其覆盖，所以我们要保证插入的索引是原来不存在的。

s={'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
d=df(s)
d[5]=pd.Series([1,1],index=['A','B'])
print(d)

Out[6]:
   A   B
0  1   6
1  2   7
2  3   8
3  4   9
4  5  10
5  1   1

这里需要注意，给新行赋值的数据可以是数组序列，也可以是Series。若为Series，则必须保证Series的索引与原数据的列名相对应，否则由于自动对齐性质，将插入nan。

• 使用append()函数：

DataFrame.append(data, ignore_index=False, verify_integrity=False, sort=None)

该函数可以在末尾添加一行，添加的数据类型可以是DataFrame，Series，但是会发生自动对齐，所以要注意Series的索引，DataFrame的列名与原数据对应。

s={'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
d=df(s,index=['a','b','c','d','e'])
d=d.append(pd.Series([1,2],index=['A','B']),ignore_index=True)
print(d)

Out[7]:
   A   B
0  1   6
1  2   7
2  3   8
3  4   9
4  5  10
5  1   2

四. 删除

常用的删除函数主要有2个，drop函数和pop函数。drop可以删除行，也可以删除列，而pop只能删除列。

1. drop

DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False)

• labels：要删除的行索引或者列的标签，与axis搭配使用。
• axis：要删除哪个轴，0行，1列
• index/columns：分别表示要删除的行的索引与列的标签，使用它们等价于使用labels+axis
• levels：多重索引的层级
• inplace：是否直接修改数据，False表示不修改原数据，返回一个新的删除后的数据，True则直接在原数据中删除。

d.drop(index=[0,1],inplace=True)
Out[8]:
   A   B
2  3   8
3  4   9
4  5  10

2. pop

DataFrame.pop(item)

• item: 要弹出的列标签，并且返回该列。

五. 修改

1. 修改某个值

d.loc[2,'B']=111
Out[9]:
   A    B
0  1    6
1  2    7
2  3  111
3  4    9
4  5   10

2. 修改某行

• 整行变成同一个数字

d.loc[2]=111
Out[10]:
     A    B
0    1    6
1    2    7
2  111  111
3    4    9
4    5   10

• 整行变成一组数字

d.loc[2]=[12,23]
Out[11]:
    A   B
0   1   6
1   2   7
2  12  23
3   4   9
4   5  10

3. 修改某列

同修改某行方法类似。

4. 修改某块

d.loc[2:3]=111
Out[12]:
     A    B
0    1    6
1    2    7
2  111  111
3  111  111
4    5   10