Python
轻松排序 Pandas 数据框: 初学者指南

轻松排序 Pandas 数据框: 初学者指南

MoeNagy Dev

排序的基础知识

理解排序在数据分析中的重要性

排序数据是数据分析中的一项基本操作,通常是准备数据进行进一步处理、可视化和决策制定的关键步骤。排序可以帮助您:

  • 以逻辑和有意义的方式组织数据
  • 更容易识别模式和趋势
  • 执行高效的数据查找和搜索
  • 促进数据分析和报告
  • 提高数据的整体质量和可用性

介绍 Pandas 中的 sort_values() 方法

在 Pandas 中,sort_values() 方法是排序 DataFrame 的主要方式。该方法允许您根据一个或多个列对 DataFrame 进行排序,并可以选择升序或降序排列。

import pandas as pd
 
# 创建一个示例 DataFrame
df = pd.DataFrame({'Name': ['Alice', 'Bob', 'Charlie', 'David'],
                   'Age': [25, 30, 35, 40],
                   'Score': [85, 92, 78, 88]})
 
# 根据 'Age' 列对 DataFrame 进行排序
sorted_df = df.sort_values(by='Age')
print(sorted_df)

输出:

     Name  Age  Score
0  Alice   25     85
1    Bob   30     92
2 Charlie   35     78
3  David   40     88

按单个列排序

要根据单个列对 DataFrame 进行排序,只需将列名传递给 sort_values() 方法的 by 参数即可。

# 根据 'Score' 列以升序对 DataFrame 进行排序
sorted_df = df.sort_values(by='Score')
print(sorted_df)

输出:

       Name  Age  Score
2  Charlie   35     78
0    Alice   25     85
3    David   40     88
1    .
```鲍勃   30     92

按多列排序

您可以通过将列名列表传递给 by 参数来对 DataFrame 进行多列排序。

# 按 'Age' 升序和 'Score' 降序对 DataFrame 进行排序
sorted_df = df.sort_values(by=['Age', 'Score'], ascending=[True, False])
print(sorted_df)

输出:

     Name  Age  Score
0  Alice   25     85
1    Bob   30     92
2 Charlie   35     78
3  David   40     88

升序和降序排序

升序排序

默认情况下, sort_values() 方法以升序对 DataFrame 进行排序。您可以显式地将 ascending 参数设置为 True 来进行升序排序。

# 按 'Age' 列升序对 DataFrame 进行排序
sorted_df = df.sort_values(by='Age', ascending=True)
print(sorted_df)

输出:

     Name  Age  Score
0  Alice   25     85
1    Bob   30     92
2 Charlie   35     78
3  David   40     88

降序排序

要以降序对 DataFrame 进行排序, 请将 ascending 参数设置为 False

# 按 'Age' 列降序对 DataFrame 进行排序
sorted_df = df.sort_values(by='Age', ascending=False)
print(sorted_df)

输出:

     Name  Age  Score
3  David   40     88
2 Charlie   35     78
1    Bob   30     92
0  Alice   25     85

处理排序过程中的缺失值

Pandas 在排序过程中处理缺失值 (用 NaN 表示) 时, 可以根据 na_position 参数将它们放在排序后的 DataFrame 的开头或结尾。

# 创建一个包含缺失值的 DataFrame
df_with_na = pd.DataFrame({'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Emily'],
                           'Age': [25, 30, None, 40, 35],
                           'Score': [85, 92, 78, None, 88]})
 
# 按 'Age' 列排序, 将 NaN 值放在开头
sorted_df = df_with_na.sort_values(by='Age', na_position='first')
print(sorted_df)

输出: ``.以下是中文翻译:

姓名 年龄 分数 2 Charlie None 78 3 David 40.0 NaN 4 Emily 35.0 88 0 Alice 25.0 85 1 Bob 30.0 92

自定义排序

基于预定义顺序进行排序

您可以根据列中的预定义顺序对DataFrame进行排序。这在您想要保持特定顺序(如按分类变量排序)时很有用。

# 创建一个包含分类数据的DataFrame
df = pd.DataFrame({'Category': ['A', 'B', 'C', 'D', 'E']})
 
# 定义'Category'列的自定义顺序
custom_order = ['C', 'A', 'E', 'B', 'D']
 
# 根据'Category'列使用自定义顺序对DataFrame进行排序
sorted_df = df.sort_values(by='Category', key=lambda x: pd.Categorical(x, categories=custom_order, ordered=True))
print(sorted_df)

输出:

  Category
2       C
0       A
4       E
1       B
3       D

利用 sort_values() 中的 key 参数

sort_values() 中的 key 参数允许您对要排序的列应用自定义排序函数。当您需要执行复杂的排序操作时,这可能很有用。

# 根据'Name'列的长度对DataFrame进行排序
sorted_df = df.sort_values(by='Name', key=lambda x: x.str.len())
print(sorted_df)

输出:

     Name  Age  Score
0  Alice   25     85
1    Bob   30     92
2 Charlie   35     78
3  David   40     88

排序分类数据

在Pandas中处理分类数据

Pandas提供了对分类数据进行处理的支持,这在排序数据时可能很有用。分类数据在Pandas中被表示为一种特殊的数据类型,允许您保留类别的顺序和含义。

# 创建一个包含分类数据的DataFrame
df = pd.DataFrame({'Category': pd.Categorical(['High', 'Low', 'Medium', 'High', 'Low'], ordered=True)})
 
# 根据'Category'列对DataFrame进行排序
sorted_df = df.sort_values(by='Category')
print(sorted_df)

输出: ``.分类 1 低 4 低 2 中等 0 高 3 高

对分类列进行排序

当按分类列对 DataFrame 进行排序时, Pandas 会保留类别的顺序, 即使底层值是字符串.

# 创建一个包含分类数据的 DataFrame
df = pd.DataFrame({'Category': pd.Categorical(['高', '低', '中等'], ordered=True)})
 
# 按 'Category' 列对 DataFrame 进行排序
sorted_df = df.sort_values(by='Category')
print(sorted_df)

输出:

    Category
1      低
2    中等
0     高

保留类别顺序

如果您想在排序时维持特定的类别顺序, 可以在创建分类数据时定义类别及其顺序.

# 定义类别及其顺序
categories = ['低', '中等', '高']
 
# 创建一个包含分类数据和预定义顺序的 DataFrame
df = pd.DataFrame({'Category': pd.Categorical(['高', '低', '中等'], categories=categories, ordered=True)})
 
# 按 'Category' 列对 DataFrame 进行排序
sorted_df = df.sort_values(by='Category')
print(sorted_df)

输出:

    Category
1      低
2    中等
0     高

对日期时间列进行排序

在 Pandas 中处理日期时间数据

Pandas 提供了出色的支持来处理日期时间数据, 包括按日期时间列进行排序.

# 创建一个包含日期时间数据的 DataFrame
import datetime
 
df = pd.DataFrame({'Date': [datetime.datetime(2022, 1, 1),
                           datetime.datetime(2022, 3, 15),
                           datetime.datetime(2021, 12, 31),
                           datetime.datetime(2022, 2, 28)]})
 
# 按 'Date' 列对 DataFrame 进行排序
sorted_df = df.sort_values(by='Date')
print(sorted_df)

输出:

           Date
2 2021-12-31 00:00:00
0 2022-01-01 00:00:00
3 2022-02-28 00:00:00
1 2022-03-15 00:00:00

按日期时间列进行排序

您可以按一个或多个日期时间列对 DataFrame 进行排序.使用 sort_values() 方法。

# 创建一个包含多个日期时间列的 DataFrame
df = pd.DataFrame({'Date': [datetime.datetime(2022, 1, 1),
                           datetime.datetime(2022, 3, 15),
                           datetime.datetime(2021, 12, 31),
                           datetime.datetime(2022, 2, 28)],
                   'Time': [datetime.time(10, 30),
                           datetime.time(15, 45),
                           datetime.time(9, 0),
                           datetime.time(12, 0)]})
 
# 按 'Date' 和 'Time' 对 DataFrame 进行排序
sorted_df = df.sort_values(by=['Date', 'Time'])
print(sorted_df)

输出:

           Date     Time
2 2021-12-31 00:00:00  09:00:00
0 2022-01-01 00:00:00  10:30:00
3 2022-02-28 00:00:00  12:00:00
1 2022-03-15 00:00:00  15:45:00

按日期时间组件进行排序

您还可以按照日期时间列的单个组件(如年、月、日、时、分、秒)对 DataFrame 进行排序。

# 按 'Date' 列的年份对 DataFrame 进行排序
sorted_df = df.sort_values(by=pd.to_datetime(df['Date']).dt.year)
print(sorted_df)

输出:

           Date     Time
2 2021-12-31 00:00:00  09:00:00
0 2022-01-01 00:00:00  10:30:00
3 2022-02-28 00:00:00  12:00:00
1 2022-03-15 00:00:00  15:45:00

高效的排序技术

优化排序性能

对大型 DataFrame 进行排序可能会很耗计算资源,因此在排序数据时,考虑性能很重要。Pandas 提供了几种选项来优化排序性能。

# 就地对 DataFrame 进行排序,以避免创建新的 DataFrame
df.sort_values(by='Age', inplace=True)

利用 inplace 参数

sort_values() 中的 inplace 参数允许您直接修改原始 DataFrame,而不是创建一个新的 DataFrame。这在处理大型数据集时可以更加节省内存。

# 就地对 DataFrame 进行排序,以避免创建新的 DataFrame
df..
```以下是该 Markdown 文件的中文翻译。对于代码部分,仅翻译注释,不翻译代码本身。文件开头没有添加任何额外的注释。
 
sort_values(by='Age', inplace=True)

使用 ignore_index 参数

sort_values() 中使用 ignore_index 参数可以丢弃 DataFrame 排序后的原始索引。如果您不需要保留原始索引,并且想节省内存,这可能很有用。

# 对 DataFrame 进行排序并丢弃原始索引
sorted_df = df.sort_values(by='Age', ignore_index=True)

使用多级索引进行排序

在 Pandas 中使用多级索引

Pandas 支持多级(层次)索引,这在对数据进行排序时可能很有用。多级索引允许您以更复杂的结构组织数据。

Python 教程 (第二部分)

函数

函数是 Python 中的一个基本概念。它们允许您封装一组指令并在整个代码中重复使用。以下是一个简单的计算矩形面积的函数示例:

def calculate_area(length, width):
    area = length * width
    return area
 
# 调用函数
rectangle_area = calculate_area(5, 10)
print(rectangle_area)  # 输出: 50

在这个例子中,calculate_area 函数接受两个参数 lengthwidth,并返回计算出的面积。您可以使用不同的值调用此函数来获得不同矩形的面积。

函数还可以有默认参数值和可变数量的参数:

def greet(name, message="Hello"):
    print(f"{message}, {name}!")
 
greet("Alice")  # 输出: Hello, Alice!
greet("Bob", "Hi")  # 输出: Hi, Bob!
 
def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total
 
print(sum_numbers(1, 2, 3))  # 输出: 6
print(sum_numbers(4, 5, 6, 7, 8))  # 输出: 30

在第一个示例中,greet 函数的 message 参数有一个默认值。在第二个示例中,sum_numbers 函数可以接受任意数量的参数,它们将被相加。

模块模块和包

Python 的标准库提供了广泛的内置模块,您可以在程序中使用。您也可以创建自己的模块和包来组织您的代码。

这里是使用 math 模块的示例:

import math
 
print(math.pi)  # 输出: 3.141592653589793
print(math.sqrt(16))  # 输出: 4.0

您也可以从模块中导入特定的函数或属性:

from math import pi, sqrt
 
print(pi)  # 输出: 3.141592653589793
print(sqrt(16))  # 输出: 4.0

要创建自己的模块,您可以简单地保存一个带有 .py 扩展名的 Python 文件。例如,让我们创建一个名为 my_module.py 的模块:

def greet(name):
    print(f"Hello, {name}!")
 
def calculate_area(length, width):
    return length * width

您可以在主脚本中导入和使用这个模块中的函数:

import my_module
 
my_module.greet("Alice")  # 输出: Hello, Alice!
area = my_module.calculate_area(5, 10)
print(area)  # 输出: 50

包是一种组织模块的层次结构的方式。要创建一个包,您需要创建一个带有 __init__.py 文件的目录。这里有一个例子:

my_package/
    __init__.py
    utils/
        __init__.py
        math_functions.py
        string_functions.py
    data/
        __init__.py
        database.py

在这个例子中,my_package 是包,它包含两个子包:utilsdata。每个子包都有一个 __init__.py 文件,可用于定义包级别的功能。

您可以像这样导入和使用子模块中的函数:

from my_package.utils.math_functions import calculate_area
from my_package.data.database import connect_to_db
 
area = calculate_area(5, 10)
db_connection = connect_to_db()

面向对象编程 (OOP)

Python 支持面向对象编程,允许您创建自定义类和对象。这里有一个简单的例子。以下是该 Markdown 文件的中文翻译版本。对于代码部分,仅翻译注释,不翻译代码本身。文件开头没有添加任何额外的注释。

Dog 类:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed
 
    def bark(self):
        print("汪汪!")
 
# 创建对象
my_dog = Dog("Buddy", "拉布拉多")
print(my_dog.name)  # 输出: Buddy
print(my_dog.breed)  # 输出: 拉布拉多
my_dog.bark()  # 输出: 汪汪!

在这个例子中, Dog 类有一个 __init__ 方法,这是一个用于初始化对象属性的特殊方法。bark 方法是一个自定义方法,可以在 Dog 对象上调用。

你也可以在类之间建立继承关系:

class GuideDog(Dog):
    def __init__(self, name, breed, training_level):
        super().__init__(name, breed)
        self.training_level = training_level
 
    def guide(self):
        print("我正在引导我的主人!")
 
guide_dog = GuideDog("Buddy", "拉布拉多", "高级")
guide_dog.bark()  # 输出: 汪汪!
guide_dog.guide()  # 输出: 我正在引导我的主人!

在这个例子中, GuideDog 类继承自 Dog 类,并添加了 training_level 属性和 guide 方法。

异常和错误处理

Python 提供了一个强大的异常处理机制来处理运行时错误。以下是一个处理 ZeroDivisionError 的例子:

def divide(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("错误: 除数为零.")
        return None
 
print(divide(10, 2))  # 输出: 5.0
print(divide(10, 0))  # 输出: 错误: 除数为零.

在这个例子中, divide 函数使用 try-except 块来捕获 ZeroDivisionError 并优雅地处理它。

你也可以创建自己的自定义异常:

class InvalidInputError(Exception):
    pass
 
def calculate_area(length, width):
    if length <= 0 or width <= 0:
        raise InvalidInputError("长度和宽度必须是正数.")
    return length * width
 
try:
    area = calculate_area(5, 10)
    pri.以下是该 Markdown 文件的中文翻译。对于代码部分,我只翻译了注释,而没有翻译代码本身。我也没有在文件开头添加任何额外的注释。
 
```python
try:
    area = calculate_area(-5, 10)  # 输出: 50
except InvalidInputError as e:
    print(e)  # 输出: 长度和宽度必须是正数。

在这个例子中,calculate_area函数在输入值无效时会引发一个自定义的InvalidInputError异常。try-except块捕获并处理了这个异常。

结论

在本教程中,您已经学习了 Python 中各种重要的概念,包括函数、模块和包、面向对象编程以及异常处理。这些主题对于构建更复杂和更健壮的 Python 应用程序至关重要。请记得练习和实验提供的代码示例,以巩固您的理解。祝您编码愉快!

MoeNagy Dev.