Home | 简体中文 | 繁体中文 | 杂文 | 知乎专栏 | 51CTO学院 | CSDN程序员研修院 | Github | OSChina 博客 | 腾讯云社区 | 阿里云栖社区 | Facebook | Linkedin | Youtube | 打赏(Donations) | About
知乎专栏多维度架构

10.3. 数据帧(DataFrame)

10.3.1. 什么是 DataFrame

通俗的讲数据帧(DataFrame)是二维数据矩阵,即数据由行和列组成的表格,类似数据库中的表和 Excel 电子表格。

Pandas 数据分析过程,首先从各种媒体中加载数据,然后将数据放入 DataFrame 处理,最后输出,输出包括输出到各种媒体和可视化图表。

DataFrame 都能做哪些数据处理呢?

矩阵运算,排序,筛选,过滤,分组,以及各种函数(例如求和)等等,这些操作很类似 Excel 对表格的操作。

DataFrame 是 Pandas 中最重要的对象,把它搞定,也就是熟练掌握 Pandas 数据分析了。

10.3.2. 如何创建 DataFrame

pandas.DataFrame 参数

		
pandas.DataFrame( data, index, columns, dtype, copy)
参数如下:

参数		描述
------------------------
data	数据采取各种形式,如:ndarray,series,map,lists,dict,constant和另一个DataFrame。
index	对于行标签,要用于结果帧的索引是可选缺省值np.arrange(n),如果没有传递索引值。
columns	对于列标签,可选的默认语法是 - np.arange(n)。 这只有在没有索引传递的情况下才是这样。
dtype	每列的数据类型。
copy	用于复制数据,默认值为False,
		
		

创建 DataFrame

创建 DataFrame 有以下几种方式:

  • 列表
  • 字典
  • 序列
  • Numpy
  • ndarrays
  • 复制另一个数据帧(DataFrame)

创建一个空的基本数据帧

		
import pandas as pd
df = pd.DataFrame()
print(df)
		
		

下面集中演示

		
import pandas as pd


def line(msg):
    print('-' * 20, msg, '-'*20)


df = pd.DataFrame()
line('空数据')
print(df)

data = [1, 2, 3, 4, 5]
df = pd.DataFrame(data)
line('从列表创建数据帧')
print(df)

data = [['张三', 26], ['李四', 25], ['王五', 23]]
df = pd.DataFrame(data, columns=['Name', 'Age'])
print(df)

data = [['苹果', 26], ['鸭梨', 25], ['橘子', 23.45]]
df = pd.DataFrame(data, columns=['Name', 'Age'], dtype=float)
line('指定数据类型为浮点')
print(df)

data = {'Name': ['张三', '李四', '王五', '牛七', '马八'],
        'Age': [23, 24, 21, 25, 27]}
line('从字典创建数据帧')
df = pd.DataFrame(data)
print(df)


data = [{'苹果': 1, '鸭梨': 2}, {'苹果': 5, '鸭梨': 10, '葡萄': 20}, {'橘子': 30}]
df = pd.DataFrame(data)
line('列表+字典的数据结构')
print(df)
		
		

输出结果

		
-------------------- 空数据 --------------------
Empty DataFrame
Columns: []
Index: []
-------------------- 从列表创建数据帧 --------------------
   0
0  1
1  2
2  3
3  4
4  5
  Name  Age
0   张三   26
1   李四   25
2   王五   23
-------------------- 指定数据类型为浮点 --------------------
  Name    Age
0   苹果  26.00
1   鸭梨  25.00
2   橘子  23.45
-------------------- 从字典创建数据帧 --------------------
  Name  Age
0   张三   23
1   李四   24
2   王五   21
3   牛七   25
4   马八   27
-------------------- 列表+字典的数据结构 --------------------
    苹果    鸭梨    葡萄    橘子
0  1.0   2.0   NaN   NaN
1  5.0  10.0  20.0   NaN
2  NaN   NaN   NaN  30.0		
		
		

使用 Series 创建 DataFrame

		
import pandas as pd

data = pd.Series([1, 2, 3])
df = pd.DataFrame(data)
print(df)

data = {'序号': pd.Series([1, 2, 3]),
        '姓名': ['张三', '李四', '王五']}

df = pd.DataFrame(data)
print(df)		
		
		

10.3.3. 行与列操作 index/columns

可以把 DataFrame 理解为一个二维矩阵(多数情况下以二维存在),左侧行名保存在index, 头部列名保存在columns。

下面举例,我们构建一个 3×3 的DataFrame矩阵,程序如下:

		
import numpy as np
import pandas as pd

df = pd.DataFrame(np.arange(9).reshape(3, 3))
print(df)		
		
		

输出结果

		
   0  1  2
0  0  1  2
1  3  4  5
2  6  7  8		
		
		

第一行 0 1 2 是 columes

第一列 0 1 2 是 index

这里的 index 和 columes 是自动产生的。

10.3.3.1. 方法一,指定 index / columes 名称

			
import numpy as np
import pandas as pd

df = pd.DataFrame(np.arange(9).reshape(3, 3), index=[
                  'row1', 'row2', 'row3'], columns=['col1', 'col2', 'col3'])
print(df)
			
			

输出结果

			
      col1  col2  col3
row1     0     1     2
row2     3     4     5
row3     6     7     8		
			
			

row1 ~ row3 是 index 用于访问行,col1 ~ col3 是 columns 用于访问列

10.3.3.2. 方法二,指定 index / columes 名称

			
from pandas import DataFrame, Index
import numpy as np
import pandas as pd

df = pd.DataFrame(np.arange(9).reshape(3, 3))
# print(df)

df.index = Index(['第一行', '第二行', '第三行'], dtype='object')
df.columns = Index(['第一列', '第二列', '第三列'], dtype='object')

print(df)		
			
			

运行结果

			
     第一列  第二列  第三列
第一行    0    1    2
第二行    3    4    5
第三行    6    7    8		
			
			

10.3.3.3. 获取 columns 名称

		
import numpy as np
import pandas as pd

df = pd.DataFrame([['Snow', 'M', 22], ['Tyrion', 'M', 32], ['Sansa', 'F', 18], [
                  'Arya', 'F', 14]], columns=['Name', 'Gender', 'Age'])

print(df)

col_name = df.columns.tolist()
print(col_name)		
		
			

10.3.3.4. 插入列

			
import numpy as np
import pandas as pd

df = pd.DataFrame([['Snow', 'M', 22], ['Tyrion', 'M', 32], ['Sansa', 'F', 18], [
                  'Arya', 'F', 14]], columns=['Name', 'Gender', 'Age'])

print(df)

col_name = df.columns.tolist()
print(col_name)
col_name.insert(3, 'City')
# 对原行/列索引重新构建索引值
df = df.reindex(columns=col_name)
# 给City列赋值
df['City'] = ['China', 'Japan', 'Koren', 'Hongkong']
print(df)			
			
			

10.3.4. 数据访问

		
from pandas import DataFrame, Index
import numpy as np
import pandas as pd

df = pd.DataFrame(np.arange(9).reshape(3, 3))
# print(df)

df.index = Index(['第一行', '第二行', '第三行'], dtype='object')
df.columns = Index(['第一列', '第二列', '第三列'], dtype='object')

print("="*20, "原始数据", "=" * 20)
print(df)
print("="*20, "访问行", "=" * 20)
print(df[0:2])
print("="*20, "访问列", "=" * 20)
print(df.第一列)
print(df['第二列'])
		
		

输出结果

		
==================== 原始数据 ====================
     第一列  第二列  第三列
第一行    0    1    2
第二行    3    4    5
第三行    6    7    8
==================== 访问行 ====================
     第一列  第二列  第三列
第一行    0    1    2
第二行    3    4    5
==================== 访问列 ====================
第一行    0
第二行    3
第三行    6
Name: 第一列, dtype: int64
第一行    1
第二行    4
第三行    7
Name: 第二列, dtype: int64		
		
		

10.3.4.1. head() 与 tail()

head() 从头部取数据

tail() 从尾部取数据

			
import numpy as np
import pandas as pd

df = pd.DataFrame(np.arange(30).reshape(10, 3), index=list(
    range(10)), columns=['col1', 'col2', 'col3'])
print('-' * 20, "原始数据", '-' * 20)
print(df)
print('-' * 20, "head() 取出前5条数据", '-' * 20)
print(df.head())
print('-' * 20, "head() 取出前3条数据", '-' * 20)
print(df.head(3))
print('-' * 20, "tail() 取出尾部5条数据", '-' * 20)
print(df.tail())
print('-' * 20, "tail() 取出尾部3条数据", '-' * 20)
print(df.tail(3))
			
			

输出结果

			
-------------------- 原始数据 --------------------
   col1  col2  col3
0     0     1     2
1     3     4     5
2     6     7     8
3     9    10    11
4    12    13    14
5    15    16    17
6    18    19    20
7    21    22    23
8    24    25    26
9    27    28    29
-------------------- head() 取出前5条数据 --------------------
   col1  col2  col3
0     0     1     2
1     3     4     5
2     6     7     8
3     9    10    11
4    12    13    14
-------------------- head() 取出前3条数据 --------------------
   col1  col2  col3
0     0     1     2
1     3     4     5
2     6     7     8
-------------------- tail() 取出尾部5条数据 --------------------
   col1  col2  col3
5    15    16    17
6    18    19    20
7    21    22    23
8    24    25    26
9    27    28    29
-------------------- tail() 取出尾部3条数据 --------------------
   col1  col2  col3
7    21    22    23
8    24    25    26
9    27    28    29
			
			

10.3.4.2. iloc 访问数据

			
import numpy as np
import pandas as pd

df = pd.DataFrame(np.arange(9).reshape(3, 3), index=[
                  'row1', 'row2', 'row3'], columns=['col1', 'col2', 'col3'])

print("="*20, "原始数据", "=" * 20)
print(df)
print("="*20, "访问一行", "=" * 20)
print(df.iloc[0])
print(df.iloc[0, :])
print("="*20, "访问指定行", "=" * 20)
print(df.iloc[[0, 2]])
print(df.iloc[[0, 2], :])
print("="*20, "访问连续多行", "=" * 20)
print(df.iloc[0:3])
print(df.iloc[0:3, :])
print("="*20, "访问一列", "=" * 20)
print(df.iloc[:, 0])
print("="*20, "访问指定列", "=" * 20)
print(df.iloc[:, [0, 2]])
print("="*20, "访问连续列", "=" * 20)
print(df.iloc[:, 0:3])

df = pd.DataFrame(np.arange(25).reshape(5, 5), index=[
                  'row1', 'row2', 'row3', 'row4', 'row5'], columns=['col1', 'col2', 'col3', 'col4', 'col5'])
print("="*20, "访问中间区域", "=" * 20)
print(df.iloc[1:4:, 1:4])

			
			

运行结果

			
===================== 原始数据 ====================
      col1  col2  col3
row1     0     1     2
row2     3     4     5
row3     6     7     8
==================== 访问一行 ====================
col1    0
col2    1
col3    2
Name: row1, dtype: int64
col1    0
col2    1
col3    2
Name: row1, dtype: int64
==================== 访问指定行 ====================
      col1  col2  col3
row1     0     1     2
row3     6     7     8
      col1  col2  col3
row1     0     1     2
row3     6     7     8
==================== 访问连续多行 ====================
      col1  col2  col3
row1     0     1     2
row2     3     4     5
row3     6     7     8
      col1  col2  col3
row1     0     1     2
row2     3     4     5
row3     6     7     8
==================== 访问一列 ====================
row1    0
row2    3
row3    6
Name: col1, dtype: int64
==================== 访问指定列 ====================
      col1  col3
row1     0     2
row2     3     5
row3     6     8
==================== 访问连续列 ====================
      col1  col2  col3
row1     0     1     2
row2     3     4     5
row3     6     7     8
==================== 访问中间区域 ====================
      col2  col3  col4
row2     6     7     8
row3    11    12    13
row4    16    17    18
			
			

10.3.4.3. loc 访问数据

			
from pandas import DataFrame, Index
import numpy as np
import pandas as pd

df = pd.DataFrame(np.arange(25).reshape(5, 5), index=[
                  'row1', 'row2', 'row3', 'row4', 'row5'], columns=['col1', 'col2', 'col3', 'col4', 'col5'])

print("="*20, "原始数据", "=" * 20)
print(df)
print("="*20, "访问一行", "=" * 20)
print(df.loc['row1'])
print(df.loc['row1', :])
print("="*20, "访问指定行", "=" * 20)
print(df.loc[['row1', 'row2']])
print(df.loc[['row1', 'row2'], :])
print("="*20, "访问连续多行数据", "=" * 20)
print(df.loc['row1':'row3'])
print(df.loc['row1':'row3', :])

print("="*20, "访问一列", "=" * 20)
print(df.loc[:, 'col1'])
print("="*20, "访问指定列", "=" * 20)
print(df.loc[:, ['col1', 'col2']])
print("="*20, "访问连续多列数据", "=" * 20)
print(df.loc[:, 'col1':'col3'])
print("="*20, "访问数据区域", "=" * 20)
print(df.loc['row2':'row4':, 'col2':'col4'])

			
			

运行结果

			
==================== 原始数据 ====================
      col1  col2  col3  col4  col5
row1     0     1     2     3     4
row2     5     6     7     8     9
row3    10    11    12    13    14
row4    15    16    17    18    19
row5    20    21    22    23    24
==================== 访问一行 ====================
col1    0
col2    1
col3    2
col4    3
col5    4
Name: row1, dtype: int64
col1    0
col2    1
col3    2
col4    3
col5    4
Name: row1, dtype: int64
==================== 访问指定行 ====================
      col1  col2  col3  col4  col5
row1     0     1     2     3     4
row2     5     6     7     8     9
      col1  col2  col3  col4  col5
row1     0     1     2     3     4
row2     5     6     7     8     9
==================== 访问连续多行数据 ====================
      col1  col2  col3  col4  col5
row1     0     1     2     3     4
row2     5     6     7     8     9
row3    10    11    12    13    14
      col1  col2  col3  col4  col5
row1     0     1     2     3     4
row2     5     6     7     8     9
row3    10    11    12    13    14
==================== 访问一列 ====================
row1     0
row2     5
row3    10
row4    15
row5    20
Name: col1, dtype: int64
==================== 访问指定列 ====================
      col1  col2
row1     0     1
row2     5     6
row3    10    11
row4    15    16
row5    20    21
==================== 访问连续多列数据 ====================
      col1  col2  col3
row1     0     1     2
row2     5     6     7
row3    10    11    12
row4    15    16    17
row5    20    21    22
==================== 访问数据区域 ====================
      col2  col3  col4
row2     6     7     8
row3    11    12    13
row4    16    17    18
			
			

10.3.4.4. Axis(轴)

二维数据拥有两个轴:

axis = 0:沿着行的方向垂直往下。

axis = 1:沿着列的方向水平延伸。

			
import numpy as np
import pandas as pd

df = pd.DataFrame(np.arange(9).reshape(3, 3), index=[
                  'row1', 'row2', 'row3'], columns=['col1', 'col2', 'col3'])

print("=" * 20, "原始数据", "=" * 20)
print(df)
print("=" * 20, "axis=0", "=" * 20)
print(df.mean(axis=0))
print("=" * 20, "axis=1", "=" * 20)
print(df.mean(axis=1))
print("=" * 20, "删除行 row1, axis=0", "=" * 20)
print(df.drop('row1', axis=0))
print("=" * 20, "删除列 col1, axis=1", "=" * 20)
print(df.drop(['col1'], axis=1))

			
			
			
==================== 原始数据 ====================
      col1  col2  col3
row1     0     1     2
row2     3     4     5
row3     6     7     8
==================== axis=0 ====================
col1    3.0
col2    4.0
col3    5.0
dtype: float64
==================== axis=1 ====================
row1    1.0
row2    4.0
row3    7.0
dtype: float64
==================== 删除行 row1, axis=0 ====================
      col1  col2  col3
row2     3     4     5
row3     6     7     8
==================== 删除列 col1, axis=1 ====================
      col2  col3
row1     1     2
row2     4     5
row3     7     8
			
			

axis=0 按列计算的均值

axis=1 按行计算的均值

10.3.5. 添加操作

10.3.5.1. 添加列

		
import pandas as pd

data = {'序号': pd.Series([1, 2, 3]),
        '姓名': ['张三', '李四', '王五']}

df = pd.DataFrame(data)
df['年龄'] = [23, 25, 26]
print(df)		
		
			

输出结果

		
   序号  姓名  年龄
0   1  张三  23
1   2  李四  25
2   3  王五  26		
		
			

10.3.5.2. 追加数据

向 DataFrame 尾部追加数据

		
import pandas as pd

df = pd.DataFrame([[1, 2], [3, 4]], columns=['col1', 'col2'])
df1 = pd.DataFrame([[5, 6], [7, 8]], columns=['col1', 'col2'])
df2 = pd.DataFrame([[9, 10], [11, 12]], columns=['col1', 'col2'])

df = df.append(df1)
df = df.append(df2)
print(df)
		
			

输出结果

		
   col1  col2
0     1     2
1     3     4
0     5     6
1     7     8
0     9    10
1    11    12		
		
			

10.3.6. 删除操作

删除列数据

			
import pandas as pd

data = {'序号': pd.Series([1, 2, 3]),
        '姓名': ['张三', '李四', '王五'],
        '年龄': [23, 25, 26]
        }

df = pd.DataFrame(data)
print('-' * 20, "原始数据", '-' * 20)
print(df)
del df['年龄']
print('-' * 20, "del 删除数据", '-' * 20)
print(df)
print('-' * 20, "pop 删除数据", '-' * 20)
df.pop('序号')
print(df)
			
		

输出结果

		
-------------------- 原始数据 --------------------
   序号  姓名  年龄
0   1  张三  23
1   2  李四  25
2   3  王五  26
-------------------- del 删除数据 --------------------
   序号  姓名
0   1  张三
1   2  李四
2   3  王五
-------------------- pop 删除数据 --------------------
   姓名
0  张三
1  李四
2  王五		
		
		

使用 pandas.drop() 方法删除行与列

		
import pandas as pd

data = {'序号': pd.Series([1, 2, 3]),
        '姓名': ['张三', '李四', '王五'],
        '年龄': [23, 25, 26]
        }

df = pd.DataFrame(data)
print('-' * 20, "原始数据", '-' * 20)
print(df)
print('-' * 20, "drop(0) 删除第一行", '-' * 20)
print(df.drop(0))
print('-' * 20, "df.drop(index=1, axis=0) 删除一行", '-' * 20)
print(df.drop(index=1, axis=0))
print('-' * 20, "df.drop(index=[1, 2]) 删除行", '-' * 20)
print(df.drop(index=[1, 2]))

print('-' * 20, "df.drop('序号', axis=1) 删除序号列", '-' * 20)
print(df.drop('序号', axis=1))
		
		

多行与多列的删除方法



print(df.drop(index=['Bob', 'Dave', 'Frank'], columns=['Name', 'Age']))
print(df.drop(index=df.index[[1, 3, 5]], columns=df.columns[[1, 2]]))

df_org = df.copy()
df_org.drop(index=['Bob', 'Dave', 'Frank'], columns=['Name', 'Age'], inplace=True)

print(df.drop(columns='Name'))
print(df.drop(columns=['Name', 'Age']))
print(df.drop(['Name', 'Age'], axis=1))

print(df.columns[[1, 2]])
print(df.drop(df.columns[[1, 2]], axis=1))
print(df.drop(columns=df.columns[[1, 2]]))

10.3.7. 插入数据

10.3.7.1. 插入一列数据

在 Dataframe 的指定列后面插入数据



Dataframe.insert(loc, column, value, allow_duplicates=False):

参数介绍:
loc:  int型,表示第几列;若在第一列插入数据,则 loc=0
column: 给插入的列取名,如 column='新的一列'
value:数据,array,series
allow_duplicates: 是否允许列名重复,选择Ture表示允许新的列名与已存在的列名重复。

			
import numpy as np
import pandas as pd

data = pd.DataFrame(np.arange(16).reshape(4, 4), columns=list('ABCD'))
print(data)
print('-' * 20, '在最左侧插入一列', '-' * 20)
data.insert(loc=0, column='新增一列', value='1')
print(data)
print('-' * 20, '在第六列后面增加一列', '-' * 20)
data.insert(loc=2, column='新增列', value=2)
print(data)
print('-' * 20, '插入重复列名称', '-' * 20)
data.insert(loc=6, column='D', value=3, allow_duplicates=True)
print(data)

			
			

			
import numpy as np
import pandas as pd

data = pd.DataFrame(np.arange(16).reshape(4, 4), columns=list('ABCD'))
print(data)
print('-' * 20, '在最左侧插入一列', '-' * 20)
data.insert(loc=0, column='新增一列', value='1')
print(data)
print('-' * 20, '在第六列后面增加一列', '-' * 20)
data.insert(loc=2, column='新增列', value=2)
print(data)
print('-' * 20, '插入重复列名称', '-' * 20)
data.insert(loc=6, column='D', value=3, allow_duplicates=True)
print(data)

			
			

10.3.8. 替换操作

修改/替换 index 和 columns 标签名

		
import numpy as np
import pandas as pd

df = pd.DataFrame(np.arange(9).reshape(3, 3), index=[
                  'r1', 'r2', 'r3'], columns=['c1', 'c2', 'c3'])
print("=" * 20, "原始数据", "=" * 20)
print(df)

print('-' * 20, '重新定义行标签', '-' * 20)
df.index = ['a', 'b', 'c']
print(df)

print('-' * 20, '修改行标签', '-' * 20)
df.rename(index={'a': '第一行', 'b': '第二行', 'c': '第三行'}, inplace=True)
print(df)

print('-' * 20, '重新定义列标签', '-' * 20)
df.columns = ['A', 'B', 'C']
print(df)

print('-' * 20, '修改列标签', '-' * 20)
df.rename(columns={'A': '第一列', 'B': '第二列', 'C': '第三列'}, inplace=True)
print(df)
		
		

输出结果

		
==================== 原始数据 ====================
    c1  c2  c3
r1   0   1   2
r2   3   4   5
r3   6   7   8
-------------------- 重新定义行标签 --------------------
   c1  c2  c3
a   0   1   2
b   3   4   5
c   6   7   8
-------------------- 修改行标签 --------------------
     c1  c2  c3
第一行   0   1   2
第二行   3   4   5
第三行   6   7   8
-------------------- 重新定义列标签 --------------------
     A  B  C
第一行  0  1  2
第二行  3  4  5
第三行  6  7  8
-------------------- 修改列标签 --------------------
     第一列  第二列  第三列
第一行    0    1    2
第二行    3    4    5
第三行    6    7    8
		
		
		
import numpy as np
import pandas as pd

data = {
    '姓名': ['张三', '李四', '王五'],
    '年龄': [11, 12, 13],
    '性别': ['Y', 'Y', 'N']
}
df = pd.DataFrame(data)

print("=" * 20, "原始数据", "=" * 20)
print(df)

print("=" * 20, "列替换", "=" * 20)
df.loc[df['性别'] == 'Y', '性别'] = '男'
df.loc[df['性别'] == 'N', '性别'] = '女'
print(df)
print("=" * 20, "行替换", "=" * 20)
df.loc[0, df.loc[0, :] == 11] = 20
print(df)
		
		
		
		
==================== 原始数据 ====================
   姓名  年龄 性别
0  张三  11  Y
1  李四  12  Y
2  王五  13  N
==================== 列替换 ====================
   姓名  年龄 性别
0  张三  11  男
1  李四  12  男
2  王五  13  女
==================== 行替换 ====================
   姓名  年龄 性别
0  张三  20  男
1  李四  12  男
2  王五  13  女
		
		

10.3.9. 筛选

			
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import pandas as pd

file_path = r'团购.xlsx'
df = pd.read_excel(file_path, sheet_name="3月2日",
                   header=1, usecols=['房号', '客户名', '合计'])
data = df[2:-3]
print(data)
print(data[data['合计'] > 0])			
			
		
			
       房号 客户名   合计
2    7-6A  李松   25
3    7-8A  王雪   68
4    7-9A  梁梅  100
5   7-10A  宋森   21
6   9-27B  蓝天   20
7   9-28B  赵岚    0
8   9-30B  皮思   50
9   1-20B  龚风  256
10  1-24A  阮纵    0
			
		

筛选后

			
      房号 客户名   合计
2   7-6A  李松   25
3   7-8A  王雪   68
4   7-9A  梁梅  100
5  7-10A  宋森   21
6  9-27B  蓝天   20
8  9-30B  皮思   50
9  1-20B  龚风  256			
			
		

10.3.10. 排序

			
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import numpy as np
import pandas as pd

df = pd.DataFrame({'数值': np.random.randint(1, 10, size=8)})
print(("-" * 10) + "随机数" + ("-" * 10))
print(df)
print(("-" * 10) + "排序后" + ("-" * 10))
print(df.sort_values('数值'))
print(("-" * 10) + "降序排序" + ("-" * 10))
print(df.sort_values('数值', ascending=False))			
			
		

运行结果

			
----------随机数----------
   数值
0   5
1   9
2   1
3   6
4   2
5   5
6   3
7   4
----------排序后----------
   数值
2   1
4   2
6   3
7   4
0   5
5   5
3   6
1   9
----------降序排序----------
   数值
1   9
3   6
0   5
5   5
7   4
6   3
4   2
2   1			
			
		

多列排序

			
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import numpy as np
import pandas as pd

df = pd.DataFrame({'A': np.random.randint(1, 10, size=8), 'B': np.random.randint(
    1, 10, size=8), 'C': np.random.randint(1, 10, size=8)})
print(("-" * 10) + "随机数" + ("-" * 10))
print(df)
print(("-" * 10) + "B列排序" + ("-" * 10))
print(df.sort_values('B'))
print(("-" * 10) + "A降序,B升序" + ("-" * 10))
print(df.sort_values(['A', 'B'], ascending=[False, True]))
print(("-" * 10) + "横向排序(行排序)" + ("-" * 10))
print(df.sort_values(by=0, axis=1, ascending=False))
			
			
		

运行结果

			
----------随机数----------
   A  B  C
0  3  2  7
1  4  8  1
2  3  8  6
3  2  4  2
4  7  9  2
5  7  9  4
6  4  1  8
7  9  4  4
----------B列排序----------
   A  B  C
6  4  1  8
0  3  2  7
3  2  4  2
7  9  4  4
1  4  8  1
2  3  8  6
4  7  9  2
5  7  9  4
----------A降序,B升序----------
   A  B  C
7  9  4  4
4  7  9  2
5  7  9  4
6  4  1  8
1  4  8  1
0  3  2  7
2  3  8  6
3  2  4  2
----------横向排序(行排序)----------
   C  A  B
0  7  3  2
1  1  4  8
2  6  3  8
3  2  2  4
4  2  7  9
5  4  7  9
6  8  4  1
7  4  9  4			
			
		

标签排序

			
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import numpy as np
import pandas as pd

df = pd.DataFrame({'B': np.random.randint(1, 10, size=5), 'A': np.random.randint(
    1, 10, size=5), 'C': np.random.randint(1, 10, size=5)}, index=np.random.randint(1, 5, size=5))
print(("-" * 10) + "随机数" + ("-" * 10))
print(df)
print(("-" * 10) + "行标签排序后" + ("-" * 10))
print(df.sort_index())
print(("-" * 10) + "列标签排序后" + ("-" * 10))
print(df.sort_index(axis=1))			
			
		

运行结果

			
neo@MacBook-Pro-Neo ~/workspace/python/pandas % python3.9 /Users/neo/workspace/python/pandas/dataframe/index.py
----------随机数----------
   B  A  C
4  9  2  1
4  1  1  5
4  1  4  5
3  8  4  7
2  3  1  6
----------行标签排序后----------
   B  A  C
2  3  1  6
3  8  4  7
4  9  2  1
4  1  1  5
4  1  4  5
----------列标签排序后----------
   A  B  C
4  2  9  1
4  1  1  5
4  4  1  5
3  4  8  7
2  1  3  6			
			
		

10.3.11. 分类聚合

		
import pandas as pd

data = {'序号': list(range(6)),
        '姓名': ['张三', '李四', '王五', '赵六', '牛七', '马八'],
        '年龄': [23, 25, 26, 25, 25, 27],
        '生日': ['2001-12-01', '2001-12-05', '2001-10-01', '2001-1-5', '2002-2-15', '2001-08-01']
        }

df = pd.DataFrame(data)
print('-' * 20, "原始数据", '-' * 20)
print(df)
print('-' * 20, "按年龄分组", '-' * 20)
ages = df.groupby(['年龄'])
for k, v in ages:
    print("{0} 岁年龄组:".format(k))
    print(v)
    print()
print('-' * 20, "按年龄分组并计算数量", '-' * 20)
ages = df.groupby(['年龄'])['年龄'].count()
print(ages)		
		
		

输出结果

		
-------------------- 原始数据 --------------------
   序号  姓名  年龄          生日
0   0  张三  23  2001-12-01
1   1  李四  25  2001-12-05
2   2  王五  26  2001-10-01
3   3  赵六  25    2001-1-5
4   4  牛七  25   2002-2-15
5   5  马八  27  2001-08-01
-------------------- 按年龄分组 --------------------
23 岁年龄组:
   序号  姓名  年龄          生日
0   0  张三  23  2001-12-01

25 岁年龄组:
   序号  姓名  年龄          生日
1   1  李四  25  2001-12-05
3   3  赵六  25    2001-1-5
4   4  牛七  25   2002-2-15

26 岁年龄组:
   序号  姓名  年龄          生日
2   2  王五  26  2001-10-01

27 岁年龄组:
   序号  姓名  年龄          生日
5   5  马八  27  2001-08-01

-------------------- 按年龄分组并计算数量 --------------------
年龄
23    1
25    3
26    1
27    1
Name: 年龄, dtype: int64		
		
		

10.3.12. 数据去重

df.drop_duplicates(['姓名'],inplace=True)

			
import pandas as pd

data = {'序号': list(range(6)),
        '姓名': ['张三', '李四', '张三', '赵六', '张三', '马八'],
        '年龄': [23, 25, 26, 25, 25, 27],
        '生日': ['2001-12-01', '2001-12-05', '2001-10-01', '2001-1-5', '2002-2-15', '2001-08-01']
        }

df = pd.DataFrame(data)
print('-' * 20, "原始数据", '-' * 20)
print(df)
print('-' * 20, "重复数据", '-' * 20)
print(df[df.姓名.duplicated()])
print('-' * 20, "取出重复的姓名", '-' * 20)
df.drop_duplicates(['姓名'], inplace=True)
print(df)
		
			
		
		
-------------------- 原始数据 --------------------
   序号  姓名  年龄          生日
0   0  张三  23  2001-12-01
1   1  李四  25  2001-12-05
2   2  张三  26  2001-10-01
3   3  赵六  25    2001-1-5
4   4  张三  25   2002-2-15
5   5  马八  27  2001-08-01
-------------------- 重复数据 --------------------
   序号  姓名  年龄          生日
2   2  张三  26  2001-10-01
4   4  张三  25   2002-2-15
-------------------- 取出重复的姓名 --------------------
   序号  姓名  年龄          生日
0   0  张三  23  2001-12-01
1   1  李四  25  2001-12-05
3   3  赵六  25    2001-1-5
5   5  马八  27  2001-08-01		
		
		

10.3.13. 数据格式化

10.3.13.1. 日期格式化

df['创建时间'] = df['创建时间'].dt.strftime('%Y-%m-%d')

				
import pandas as pd

data = {'序号': pd.Series([1, 2, 3]),
        '姓名': ['张三', '李四', '王五'],
        '年龄': [23, 25, 26],
        '生日': ['2001-12-01', '2001-12-05', '2001-10-01']
        }

df = pd.DataFrame(data)
df.生日 = pd.to_datetime(df.生日)
print(df)
df['生日'] = df['生日'].dt.strftime('%Y-%m-%d %H:%M:%S')
print(df)
		
			
			

10.3.13.2. 浮点格式化

			
import pandas as pd

data = {'序号': pd.Series([1, 2, 3]),
        '姓名': ['张三', '李四', '王五'],
        '生活费': [123.23, 125.113, 226.999],
        '生日': ['2001/12/01', '2001-12-05', '2001-10-01']
        }

df = pd.DataFrame(data)

pd.options.display.float_format = '{:.2f}'.format
df.生日 = pd.to_datetime(df.生日)
print(df)
df['生日'] = df['生日'].dt.strftime('%Y-%m-%d %H:%M:%S')
print(df)			
			
			
			
import pandas as pd

df = pd.DataFrame([['10.0', 6, 7, 8],
                   ['1.0', 9, 12, 14],
                   ['5.0', 8, 10, 6]], columns=['A', 'B', 'C', 'D'])

df['A'] = pd.to_numeric(df['A'], errors='coerce')
print(df)
print('-' * 40)
print(df.info())