文章目录
- 一、DataFrame 行操作
-
- 1. 标签选取
- 2. 数值型索引和切片
- 3. 切片操作多行选取
- 4. 添加数据行
-
- 4.1 追加字典
- 4.2 追加列表
- 5. 删除数据行
- 二、常用属性和方法汇总
-
- 1. 转置
- 2. axes
- 3. dtypes
- 4. empty
- 5. columns
- 6. shape
- 7. values
- 8. head() & tail()
- 9. 修改列名 rename()
- 10. info() 函数
- 11. df. sort_index() 函数
- 12. df.sort_values() 函数
- DataFrame 是 Pandas 的重要数据结构之一，也是在使用 Pandas 进行数据分析过程中最常用的结构之一，可以这么说，掌握了 DataFrame 的用法，你就拥有了学习数据分析的基本能力。
- 在开始之前，我们需要先引入 numpy 和 pandas 库。
import numpy as np
import pandas as pd
一、DataFrame 行操作
- 在我们理解了前文的列索引操作后，行索引操作就变的简单。
- 具体列索引操作详见 Python 之 Pandas DataFrame 数据类型的简介、创建的列操作。
1. 标签选取
- 行操作需要借助 loc 属性来完成:按标签或布尔数组访问一组行和列。
- 首先，我们定义一个字典，作为初始数据，创建 DataFrame 数据结构。
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print("===========df原始数据========")
print(df)
#===========df原始数据========
# one two
# a 1.0 1
# b 2.0 2
# c 3.0 3
# d NaN 4
- 然后，我们确定标签为 b 的数据。
print("===========标签为b的数据========")
print(df.loc['b'])
#===========标签为b的数据========
#one 2.0
#two 2.0
#Name: b, dtype: float64
- 这里需要注意的是，loc 允许接受两个参数分别是行和列。
- 例如，我们选取 b 行 one 列交叉的数据。
df.loc['b',"one"]
#2.0
- 除此之外，行和列还可以使用切片。
- 例如，标签为 b 的行到标签为 d 的行, 对应标签为 one 的列。
- 这里需要注意的是，使用行标签切片，是包含结束的行。
df.loc['b':'d',"one"] # 注意
#b 2.0
#c 3.0
#d NaN
#Name: one, dtype: float64
- 用过 loc 索引的行和列与 numpy 整数数组索引的区别如下，loc 是通过标签进行取值，他有两个参数，第一个代表行，第二个代表列。
df.loc[['a','b'],["one","two"]]
# one two
#a 1.0 1
#b 2.0 2
- 我们可以通过 np.arange( ).reshape( ) 生成一个从 0 到 1 的三行四列的指定元素数组，然后调用其中第一行和第一列，第三行和第四列分别相交的数据。
s = np.arange(12).reshape((3,4))
s
#array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11]])
s[[0,2],[0,3]]
#array([ 0, 11])
2. 数值型索引和切片
- 使用数据型索引,需要使用 iloc 属性。
- 直接使用索引，会优先查找的是列标签，如果找不到会报错，列没有位置索引。
- 可以使用 iloc，行基于整数位置的按位置选择索引。
- 例如，我们指定 data 数据，然后定义行标签，通过字典创建 DataFrame。
data = {'Name':['关羽', '刘备', '张飞', '曹操'],'Age':[28,34,29,42]}
index = ["rank1", "rank2", "rank3", "rank4"]
df = pd.DataFrame(data, index=index)
df
# Name Age
#rank1 关羽 28
#rank2 刘备 34
#rank3 张飞 29
#rank4 曹操 42
- 然后，我们取得位置索引为 2 的数据。
df.iloc[2]
#Name 张飞
#Age 29
#Name: rank3, dtype: object
- 我们也可以同时取得位置索引分别为 0 和 2 的数据。
df.iloc[[0,2]]
Name Age
rank1 关羽 28
rank3 张飞 29
- 我们也可以选择行索引为 0，列索引为 1 的数据。
df.iloc[0,1]
#28
- 这里需要注意的是，loc 使用的是标签索引，iloc 使用的是位置索引，两者不能混用，比如在 loc 中使用位置索引，或者在 iloc 中使用标签索引。
- 常见有如下的错误写法：loc 当中使用了 1 这个位置索引，iloc 当中使用了 Name 这个标签索引。
#df.loc[1,"Name"]
#df.iloc[1,"Name"]
3. 切片操作多行选取
- 可以直接使用数值型切片操作行，和使用 iloc 同样的结果。
- 例如，我们指定 data 数据，然后定义行标签，通过字典创建 DataFrame。
data = {'Name':['关羽', '刘备', '张飞', '曹操'],'Age':[28,34,29,42]}
index = ["rank1", "rank2", "rank3", "rank4"]
df = pd.DataFrame(data, index=index)
df
# Name Age
#rank1 关羽 28
#rank2 刘备 34
#rank3 张飞 29
#rank4 曹操 42
- 然后，我们取得取得位置索引从 1 到 3 的行，但是不包含第 3 行的数据。
print("=====df.iloc[1:3]:=======")
print(df.iloc[1:3])
#=====df.iloc[1:3]:=======
# Name Age
#rank2 刘备 34
#rank3 张飞 29
- 我们使用切片可以直接提取行。
print("=====df[1:3]:=======")
print(df[1:3])
#=====df[1:3]:=======
# Name Age
#rank2 刘备 34
#rank3 张飞 29
4. 添加数据行
- 使用 append() 函数，可以将新的数据行添加到 DataFrame 中，该函数会在行末追加数据行.
- 其语法模板如下：
- 将 other 追加到调用者的末尾，返回一个新对象。other 行中不在调用者中的列将作为新列添加。
- 其参数含义如下：
- other 表示 DataFrame 或 Series/dict 类对象，或这些对象的列表。
- ignore_index 默认为 False，如果为 True 将不适用 index 标签。
- verify_integrity 默认为 False ，如果为 True，则在创建具有重复项的索引时引发 ValueError。
- sort 表示排序。
- 例如，我们可以生成一个指定数据的数组，并于后续的操作观察。
data = {
'Name':['关羽', '刘备', '张飞', '曹操'],
'Age':[28, 34, 29, 42],
"Salary":[5000, 8000, 4500, 10000]
}
df = pd.DataFrame(data)
df
# Name Age Salary
# 0 关羽 28 5000
# 1 刘备 34 8000
# 2 张飞 29 4500
# 3 曹操 42 10000
4.1 追加字典
- 我们在行末新加一个数据行，此时，我们需要添加 ignore_index=True，否则会报错。例如下述操作。
d2 = {"Name":"诸葛亮", "Age":30}
df3 = df.append(d2)
print(df3)
- 错误提示：Can only append a Series if ignore_index=True or if the Series has a name。
- 这是因为仅当 ignore_index=True 或序列有名称时，才能追加序列。
d2 = {"Name":"诸葛亮", "Age":30}
df3 = df.append(d2, ignore_index=True) # 需要添加
print(df3)
# Name Age Salary
#0 关羽 28 5000.0
#1 刘备 34 8000.0
#2 张飞 29 4500.0
#3 曹操 42 10000.0
#4 诸葛亮 30 NaN
- 或者 Series 数据当中有 name。
d2 = {"Name":"诸葛亮", "Age":30}
s = pd.Series(d2, name="a")
print(s)
df3 = df.append(s)
print(df3)
#Name 诸葛亮
#Age 30
#Name: a, dtype: object
# Name Age Salary
#0 关羽 28 5000.0
#1 刘备 34 8000.0
#2 张飞 29 4500.0
#3 曹操 42 10000.0
#a 诸葛亮 30 NaN
4.2 追加列表
- 如果 list 是一维的，则以列的形式追加。
- 如果 list 是二维的，则以行的形式追加。
- 如果 list 是三维的，只添加一个值。
- 这里需要注意的是，使用 append 可能会出现相同的 index，想避免的话,可以使用 ignore_index=True。
- 首先，我们生成输出数据数组，便于后续的观察操作。
data = [
[1, 2, 3, 4],
[5, 6, 7, 8]
]
df = pd.DataFrame(data)
print(df)
# 0 1 2 3
#0 1 2 3 4
#1 5 6 7 8
- （1） 当 list 是一维的，则以列的形式追加。
a_l = [10,20]
df3 = df.append(a_l)
print(df3)
# 0 1 2 3
#0 1 2.0 3.0 4.0
#1 5 6.0 7.0 8.0
#0 10 NaN NaN NaN
#1 20 NaN NaN NaN
- （2） 当 list 是二维的，则以行的形式追加。
a_l = [[10,"20",30],[2,5,6]]
df4 = df.append(a_l)
print(df4)
# 0 1 2 3
#0 1 2 3 4.0
#1 5 6 7 8.0
#0 10 20 30 NaN
#1 2 5 6 NaN
- 此时，我们会发现行标签有点不太对，因此我们使用 ignore_index=True。
print("=========使用:ignore_index=True===========")
df5 = df.append(a_l,ignore_index=True) # 需要添加
print(df5)
#=========使用:ignore_index=True===========
# 0 1 2 3
#0 1 2 3 4.0
#1 5 6 7 8.0
#2 10 20 30 NaN
#3 2 5 6 NaN
- 在这里需要注意的是，append 不改变原数据，是生成一个新数据。
5. 删除数据行
- 可以使用行索引标签，从 DataFrame 中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除。示例如下：
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
print("=======源数据df=======")
print(df)
#=======源数据df=======
# a b
#0 1 2
#1 3 4
#0 5 6
#1 7 8
- 注意此处调用了 drop() 方法，drop 默认不会更改源数据，而是返回另一个dataframe来存放删除后的数据。
- （1） drop 函数默认删除行，列需要加 axis = 1。
- （2） 当 inplace 为 False 时不会修改源数据，为 True 时会修改源数据。
df1 = df.drop(0)
print("=======修改后数据df1=======")
print(df1)
=======修改后数据df1=======
# a b
#1 3 4
#1 7 8
二、常用属性和方法汇总
| 名称 | 属性&方法描述 |
|---|---|
| T | 行和列转置。 |
| axes | 返回一个仅以行轴标签和列轴标签为成员的列表。 |
| dtypes | 返回每列数据的数据类型。 |
| empty | DataFrame中没有数据或者任意坐标轴的长度为0，则返回True |
| columns | 返回DataFrame所有列标签 |
| shape | 返回一个元组，获取行数和列数,表示了 DataFrame 维度。 |
| size | DataFrame中的元素数量。 |
| values | 使用 numpy 数组表示 DataFrame 中的元素值。 |
| head() | 返回前 n 行数据。 |
| tail() | 返回后 n 行数据。 |
| rename() | rename(columns=字典) ,修改列名 |
| info() | 可以显示信息，例如行数/列数，总内存使用量，每列的数据类型以及不缺少值的元素数 |
| sort_index() | 默认根据行标签对所有行排序，或根据列标签对所有列排序，或根据指定某列或某几列对行排序。 |
| sort_values() | 既可以根据列数据，也可根据行数据排序 |
- 我们先生成一个初始数据数组，用以后续的观察操作。
data = {
'Name':['关羽', '刘备', '张飞', '曹操'],
'Age':[28, 34, 29, 42],
"Salary":[5000, 8000, 4500, 10000]
}
df = pd.DataFrame(data)
df
# Name Age Salary
#0 关羽 28 5000
#1 刘备 34 8000
#2 张飞 29 4500
#3 曹操 42 10000
1. 转置
- 返回 DataFrame 的转置，也就是把行和列进行交换，但是源数据是不会发生任何变化的。
df.T
0 1 2 3
Name 关羽 刘备 张飞 曹操
Age 28 34 29 42
Salary 5000 8000 4500 10000
2. axes
- 返回一个行标签、列标签组成的列表。
print(df.axes)
[df.index,df.columns]
#[RangeIndex(start=0, stop=4, step=1), Index(['Name', 'Age', 'Salary'], dtype='object')]
3. dtypes
- 返回 Series 每一列的数据类型。示例如下：
df.dtypes
Name object
Age int64
Salary int64
dtype: object
4. empty
- 返回一个布尔值，判断输出的数据对象是否为空，若为 True 表示对象为空。
df.empty
#False
- 我们创建一个空的 DataFrame。
empty_df = pd.DataFrame()
empty_df.empty
#True
- 如果给 DataFrame 数据类型直接判断真假，则会报错:
The truth value of a DataFrame is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
5. columns
- 返回 DataFrame 所有列标签。
df.columns
#Index(['Name', 'Age', 'Salary'], dtype='object')
- 我们也可以通过 df.columns 的个数获取 DataFrame 当中列的个数。
len(df.columns)
#3
df.columns.size
#3
6. shape
- 返回一个元组，获取行数和列数，表示了 DataFrame 维度。
df.shape
#(4,3)
row_num,column_num = df.shape
print(row_num,column_num )
#4 3
7. values
- 以 ndarray 数组的形式返回 DataFrame 中的数据。
df.values
#array([['关羽', 28, 5000],
# ['刘备', 34, 8000],
# ['张飞', 29, 4500],
# ['曹操', 42, 10000]], dtype=object)
8. head() & tail()
- 我们可以使用 head() 获取前几行数据。
df.head(3)
# Name Age Salary
#0 关羽 28 5000
#1 刘备 34 8000
#2 张飞 29 4500
- 我们也可以使用 tail() 获取后几行数据。
df.tail(3)
# Name Age Salary
#1 刘备 34 8000
#2 张飞 29 4500
#3 曹操 42 10000
9. 修改列名 rename()
- 其语法模板如下：
- 其参数含义如下：
- index 表示修改后的行标签。
- columns 表示修改后的列标签。
- inplace 表示默认为 False，不改变源数据，返回修改后的数据，True 更改源数据。
- 先输出原始数据，便于操作和观察。
df
# Name Age Salary
#0 关羽 28 5000
#1 刘备 34 8000
#2 张飞 29 4500
#3 曹操 42 10000
- 我们可以修改变量 df 的行标签。
df.rename(index={1:"row2", 2:"row3"})
df
# Name Age Salary
#0 关羽 28 5000
#row2 刘备 34 8000
#row3 张飞 29 4500
#3 曹操 42 10000
- 我们可以修改变量 df 的列标签。
df.rename(columns = {"Name":"name", "Age":"age"})
df
# name age Salary
#0 关羽 28 5000
#1 刘备 34 8000
#2 张飞 29 4500
#3 曹操 42 10000
- 如果我需要修改源数据的话，添加 inplace 参数。
df.rename(index={1:"row2", 2:"row3"}, columns = {"Name":"name", "Age":"age"}, inplace=True)
df
# name age Salary
#0 关羽 28 5000
#row2 刘备 34 8000
#row3 张飞 29 4500
#3 曹操 42 10000
10. info() 函数
- 用于打印 DataFrame 的简要摘要，显示有关 DataFrame 的信息，包括索引的数据类型 dtype 和列的数据类型 dtype，非空值的数量和内存使用情况。
- 首先，我们创建一组数据，将数据追加到 df 数据中。
data = {"name":"诸葛亮","age":30}
df = df.append(data, ignore_index =True)
df
# name age Salary
#0 关羽 28 5000.0
#1 刘备 34 8000.0
#2 张飞 29 4500.0
#3 曹操 42 10000.0
#4 诸葛亮 30 NaN
- 然后使用 info() 函数。
df.info()
#<class 'pandas.core.frame.DataFrame'>
#RangeIndex: 5 entries, 0 to 4
#Data columns (total 3 columns):
## Column Non-Null Count Dtype
#--- ------ -------------- -----
#0 name 5 non-null object
#1 age 5 non-null int64
#2 Salary 4 non-null float64
#dtypes: float64(1), int64(1), object(1)
#memory usage: 248.0+ bytes
- 我们来看一看都有些什么信息：
- （1） <class ‘pandas.core.frame.DataFrame’> 表示数据类型为 DataFrame。
- （2） RangeIndex: 5 entries, 0 to 4 表示有 5 条数据（也就是 5 行），索引为 0-4。
- （3） Data columns (total 3 columns) 表示该数据帧有 3 列。
- （4）# 表示索引号，不用太在意。
- （5） column 表示每列数据的列名。
- （6） Non-Null count 表示每列数据的数据个数，缺失值 NaN 不作计算。可以看出上面 Salary 列数据有缺失值。
- （7） Dtype 表示数据的类型。
- （8） dtypes 表示float64(1), int64(1), object(1): 数据类型的统计。
- （9） memory usage 表示 248.0+ bytes: 该数据帧占用的运行内存（RAM）。
11. df. sort_index() 函数
- 默认根据行标签对所有行排序，或根据列标签对所有列排序，或根据指定某列或某几列对行排序。
- 其语法模板如下：
- 其参数含义如下：
- axis：0 表示按照行名排序；1 表示按照列名排序。
- ascending：默认 True 升序排列；False 降序排列。
- inplace：默认 False，否则排序之后的数据直接替换原来的数据。
- 需要注意的是，df.sort_index() 可以完成和 df.sort_values() 完全相同的功能，但 python 更推荐用只用 df.sort_index() 对根据行标签和根据列标签排序，其他排序方式用 df.sort_values()。
df = pd.DataFrame({'b':[1,2,2,3],'a':[4,3,2,1],'c':[1,3,8,2]},index=[2,0,1,3])
df
# b a c
#2 1 4 1
#0 2 3 3
#1 2 2 8
#3 3 1 2
- 我们默认按行标签升序排序，或 df.sort_index(axis=0, ascending=True)。
df.sort_index()
# b a c
#0 2 3 3
#1 2 2 8
#2 1 4 1
#3 3 1 2
- 我们按列标签升序排序
df.sort_index(axis=1)
# a b c
#2 4 1 1
#0 3 2 3
#1 2 2 8
#3 1 3 2
12. df.sort_values() 函数
- 既可以根据列数据，也可根据行数据排序。
- 其语法模板如下：
- 其参数含义如下：
- by：str or list of str；如果 axis=0，那么 by=“列名”；如果 axis=1，那么 by=“行名”。
- axis：{0 or ‘index’, 1 or ‘columns’}，default 0，默认按照列排序，即纵向排序；如果为 1，则是横向排序。
- ascending：布尔型，True 则升序，如果 by=[‘列名1’,‘列名2’]，则该参数可以是 [True, False]，即第一字段升序，第二个降序。
- inplace：布尔型，是否用排序后的数据框替换现有的数据框。
- na_position：{‘first’, ‘last’}, default ‘last’，默认缺失值排在最后面。
-
需要注意的是，必须指定 by 参数，即必须指定哪几行或哪几列；无法根据 index 名和 columns 名排序（由.sort_index()执行）。
- 我们先生成源数据。
df = pd.DataFrame({'b':[1,2,3,2],'a':[4,3,2,1],'c':[1,3,8,2]},index=[2,0,1,3])
df
# b a c
#2 1 4 1
#0 2 3 3
#1 3 2 8
#3 2 1 2
- （1） 按 b 列升序排序。
- 等同于 df.sort_values(by=‘b’,axis=0)。
df.sort_values(by='b')
print(df)
# b a c
#2 1 4 1
#0 2 3 3
#3 2 1 2
#1 3 2 8
- （2） 先按 b 列降序，再按 a 列升序排序。
- 等同于 df.sort_values(by=[‘b’,‘a’],axis=0,ascending=[False,True])。
df.sort_values(by=['b','a'],ascending=[False,True])
print(df)
# b a c
#1 3 2 8
#3 2 1 2
#0 2 3 3
#2 1 4 1
- （3） 按行 3 升序排列。
df.sort_values(by=3,axis=1)
print(df)
# a b c
#2 4 1 1
#0 3 2 3
#1 2 3 8
#3 1 2 2
- （4） 按行 3 升序，行 0 降排列。
df.sort_values(by=[3,0],axis=1,ascending=[True,False])
print(df)
# a b c
#2 4 1 1
#0 3 3 2
#1 2 8 3
#3 1 2 2
- 需要注意的是，指定多列（多行）排序时，先按排在前面的列（行）排序，如果内部有相同数据，再对相同数据内部用下一个列（行）排序，以此类推。
- 如果内部无重复数据，则后续排列不执行。即首先满足排在前面的参数的排序，再排后面参数。
![TestLink导出用例转换工具(XML2Excel)[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)