DataFrame是一个表格型（类似Excel）的数据结构，它既有行，也有列，每一行的索引为index，每一列的索引为column。
同样也可以把DataFrame类型看作是一维的，由同样行索引的一组数据组成。

DataFrame的创建

创建空的DataFrame

import pandas as pd
pd.DataFrame(columns={"a":"","b":"","c":""},index=[0])
1
2

---

通过字典创建

• key为列名，字典的value就是一个Serise.values，即为一列数据

dict1 = {"name":["Jim", "Lucy", "HanMeimei", "Lili"], "age":[11, 12, 13, 14], "score":[90, 100, 80, 70]}
pd.DataFrame(dict1)
1
2

---

直接用list的数据创建DataFrame

• 一个二维列表，注意列表中的每一个列表元素为一行数据

df1 = pd.DataFrame([[1, 2, 3],["a", "b", "c"], ["a1", "b2", "c3"]], index=["第一行", "第二行", "第三行"], 
                   columns=["第一列", "第二列", "第三列"])
print(df1)
1
2
3

    第一列 第二列 第三列
第一行   1   2   3
第二行   a   b   c
第三行  a1  b2  c3
1
2
3
4

---

读取csv或者excel文件为DataFrame格式

df1 = pd.read_excel(r".\study\test_excel.xlsx", sheet_name="student")
print("df1---------------\n", df1, type(df1))
1
2

df1---------------
   name  age sex address  score
0   刘一   18   女      上海    100
1   花二   40   男      上海     99
2   张三   25   男      北京     80
3   李四   30   男      西安     40
4   王五   70   男      青岛     70
5   孙六   65   女      泰州     90 
1
2
3
4
5
6
7
8

---

用numpy的矩阵创建dataframe

import numpy as np
array = np.random.rand(2,3)    #2行3列
df1 = pd.DataFrame(array,columns=['first','second','third'])
print(df1)
1
2
3
4

      first    second     third
0  0.671161  0.319496  0.998158
1  0.372354  0.456053  0.945547
1
2
3

---

查看DataFrame数据属性

df.head()

• 默认查看数据前5行

array = np.random.rand(8,3)
df1 = pd.DataFrame(array,columns=['first','second','third'])
print(df1.head(3))
1
2
3

      first    second     third
0  0.414661  0.576802  0.733472
1  0.304392  0.706122  0.367632
2  0.737718  0.700953  0.710541
1
2
3
4

---

查看数据后几行

• 默认查看数据后5行

df1.tail()
1

---

重置索引

• df.reset_index, 重置索引，添加新的索引0-n
• df.set_index, 重置索引，设置某一列为新的索引

print(df1.reset_index())
print(df1.set_index("第0列"))
1
2

  index       第0列       第1列       第2列
0   第0行  0.938223  0.450784  0.958613
1   第1行  0.005883  0.433231  0.654217
2   第2行  0.729364  0.424220  0.960798
3   第3行  0.829794  0.090153  0.134994
4   第4行  0.391034  0.001752  0.626693
5   第5行  0.975350  0.318862  0.626255
6   第6行  0.400560  0.815432  0.417564
7   第7行  0.359789  0.565618  0.130726
               第1列       第2列
第0列                         
0.938223  0.450784  0.958613
0.005883  0.433231  0.654217
0.729364  0.424220  0.960798
0.829794  0.090153  0.134994
0.391034  0.001752  0.626693
0.975350  0.318862  0.626255
0.400560  0.815432  0.417564
0.359789  0.565618  0.130726
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

---

查看下标

• df.index, df.columns
• 当需要修改时，必须统一修改，不能单个修改

df1.index = ["第"+ str(i) +"行" for i in range(8)]
df1.columns = ["第"+ str(i) +"列" for i in range(3)]
print(df1.index)
print(df1.columns)
1
2
3
4

Index(['第0行', '第1行', '第2行', '第3行', '第4行', '第5行', '第6行', '第7行'], dtype='object')
Index(['第0列', '第1列', '第2列'], dtype='object')
1
2

---

查看下标

• df.index, df.columns
• 当需要修改时，必须统一修改，不能单个修改

---

查看数据值

df1.values
1

array([[0.38875075, 0.43803462, 0.12459244],
       [0.56419024, 0.75568682, 0.13764671],
       [0.80400939, 0.79626389, 0.66016963],
       [0.31140927, 0.76798005, 0.21945531],
       [0.14646588, 0.92297446, 0.7054672 ],
       [0.66496854, 0.30049814, 0.54736761],
       [0.07047599, 0.47393679, 0.2407982 ],
       [0.5220982 , 0.61223117, 0.68845914]])
1
2
3
4
5
6
7
8

---

查看数据特性

• df.dtypes
• df.shape
• df.ndim
• df.size
• df.axes

print(df1.dtypes) #查看dataframe数据类型
print(df1.shape)  #查看dataframe的形状
print(df1.ndim)   #返回维数
print(df1.size)   #查看dataframe的数据数目
print(df1.axes)   #查看横纵坐标的标签名
1
2
3
4
5

first     float64
second    float64
third     float64
dtype: object
(8, 3)
2
24
[RangeIndex(start=0, stop=8, step=1), Index(['first', 'second', 'third'], dtype='object')]
1
2
3
4
5
6
7
8

---

单独计算某列的统计值

• df1[‘first’].sum() #求和
• df1[‘first’].mean() #求平均数
• df1[‘first’].count() #求数量
• df1[‘first’].max()
• df1[‘first’].min()

---

DataFrame元素的访问

索引单个cell

使用at,iat

• 通过元素的行和列索引对来访问单个cell，at 和 iat 属性只能访问单个cell，区别是at可以使用字符串和整数，而iat只能使用整数。
  at 和 iat 的格式是：[row, column]。

df1 = pd.read_excel(r".\study\test_excel.xlsx", sheet_name="student")
print("df1---------------\n", df1, type(df1))
1
2

df1---------------
   name  age sex address  score
0   刘一   18   女      上海    100
1   花二   40   男      上海     99
2   张三   25   男      北京     80
3   李四   30   男      西安     40
4   王五   70   男      青岛     70
5   孙六   65   女      泰州     90 
1
2
3
4
5
6
7
8

print(df1.at[3, "age"])
print(df1.iat[3, 0])
print(df1.loc[3, 'age'])
1
2
3

30
李四
30
1
2
3

---

使用属性和索引方式

print(df1.name[2])
print(df1["name"][4])    # df1["name"]得到一列，series，df1["name"][4]得到该series中的一个数据
1
2

张三
王五
1
2

---

使用loc,iloc

• df.loc和iloc主要是根据DataFrame的行标和列标进行数据的筛选的，通过行列名称或者索引进行访问行或者列，都可以只传入单个值，实现精确匹配

print(df1.loc[2, "name"])
1

张三
1

---

访问多个元素

• loc 和 iloc 属性可以访问多个cell，区别是loc可以使用标签和布尔（掩码）数组，不能使用整数位置（整数代表元素的位置），
  而iloc只能使用整数位置。

通过属性方式访问列

• 通过属性方式只能访问单独的列，返回series对象。
• 对于列索引数组方式，一次访问多列。返回的对象是DataFrame类型。

df1 = pd.read_excel(r".\study\test_excel.xlsx", sheet_name="student")
print("df1---------------\n", df1["age"])  # 通过索引方式访问 
print("df1---------------\n", df1.age)     # 通过属性方式访问 
print(df[['name','age']])    # 通过索引数组方式访问 
1
2
3
4
5

df1---------------
 0    18
1    40
2    25
3    30
4    70
5    65
Name: age, dtype: int64
df1---------------
 0    18
1    40
2    25
3    30
4    70
5    65
Name: age, dtype: int64
  name  age
0   刘一   18
1   花二   40
2   张三   25
3   李四   30
4   王五   70
5   孙六   65
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

---

访问单行，包括所有列

• loc[row] 访问单行，包含所有列的数据

df1 = pd.read_csv(r".\study\weather.txt")
df1.set_index('ymd', inplace=True)   #将行标签改为第ymd列的值
df1.loc["2018-01-03"]
1
2
3

bWendu         2℃
yWendu        -5℃
tianqi         多云
fengxiang      北风
fengli       1-2级
aqi            28
aqiInfo         优
aqiLevel        1
Name: 2018-01-03, dtype: object
1
2
3
4
5
6
7
8
9

---

通过loc和iloc多方式访问

[row, column]方式

• [row, column]访问由row和column 确定的元素
• 行列标签任意可以是列表或者一个范围

df1 = pd.read_csv(r".\study\weather.txt")
df1.set_index('ymd', inplace=True)   #将行标签改为第ymd列的值
print(df1.loc[['2018-01-03','2018-01-04','2018-01-08'], 'bWendu'])    #得到series类型
print(df1.loc[['2018-01-03','2018-01-04','2018-01-05'], ['bWendu', 'yWendu']])     #得到DataFrame类型
df2 = df1.loc['2018-01-03':'2018-01-05', 'bWendu':'fengxiang']    # 行列都是范围
print("df2-----------\n", df2)
df1.loc["2018-01-03"]
1
2
3
4
5
6
7

ymd
2018-01-03    2℃
2018-01-04    0℃
2018-01-08    2℃
Name: bWendu, dtype: object
           bWendu yWendu
ymd                     
2018-01-03     2℃    -5℃
2018-01-04     0℃    -8℃
2018-01-05     3℃    -6℃
df2-----------
            bWendu yWendu tianqi fengxiang
ymd                                      
2018-01-03     2℃    -5℃     多云        北风
2018-01-04     0℃    -8℃      阴       东北风
2018-01-05     3℃    -6℃   多云~晴       西北风





bWendu         2℃
yWendu        -5℃
tianqi         多云
fengxiang      北风
fengli       1-2级
aqi            28
aqiInfo         优
aqiLevel        1
Name: 2018-01-03, dtype: object
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

布尔列表，访问行

• 为True的访问，否则不访问

df2.loc[[True, False, True]]   # 布尔列表，和行对应
1

---

条件筛选

• 可以是条件表达式，得到一个布尔列表。序列具有矢量化操作的特性，当选择某一列时，可以通过逻辑运算得出布尔索引数组
• 当条件表达式组合时，注意每一个都需要有括号, 通过逻辑运算符连接起来

df1 = pd.read_excel(r".\study\test_excel.xlsx", sheet_name="student")
print("df1---------------\n", df1, type(df1))
print((df1["age"]>50) & (df1["score"]<80))
df1.loc[(df1["age"]>50) & (df1["score"]<80), :]
1
2
3
4

df1---------------
   name  age sex address  score
0   刘一   18   女      上海    100
1   花二   40   男      上海     99
2   张三   25   男      北京     80
3   李四   30   男      西安     40
4   王五   70   男      青岛     70
5   孙六   65   女      泰州     90 
0    False
1    False
2    False
3    False
4     True
5    False
dtype: bool
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

利用函数查询

• lambda函数

df1.loc[lambda df1: (df1["age"]<50) & (df1["score"]<80), :]
1

• 自定义函数

df1 = pd.read_csv(r".\study\weather.txt")
df1.set_index('ymd', inplace=True)   #将行标签改为第ymd列的值
# df1.index.str.startswith("2018-09") & (df1["aqiLevel"]==1)
def query_my_data(df):
    return df.index.str.startswith("2018-09")& df1["aqiLevel"]==1
df1.loc[query_my_data,:].head(5)    #传函数名，参数就为df1
1
2
3
4
5
6