Python
Pandas 重命名: 轻松重命名的初学者指南

Pandas 重命名: 轻松重命名的初学者指南

MoeNagy Dev

Pandas 重命名: 了解基础知识

介绍 pandas.DataFrame.rename() 方法

pandas.DataFrame.rename() 方法是一个强大的工具,用于重命名 pandas DataFrame 的列和索引 (行和列)。这个方法允许您以灵活高效的方式修改数据的名称,使您的数据更易于使用和理解。

重命名列

要重命名 DataFrame 中的列,可以使用 rename() 方法的 columns 参数。您可以传递一个字典或函数来指定新的列名。

import pandas as pd
 
# 创建一个示例 DataFrame
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# 通过名称重命名列
df = df.rename(columns={'A': 'alpha', 'B': 'beta', 'C': 'gamma'})
print(df)

输出:

   alpha  beta  gamma
0      1     4      7
1      2     5      8
2      3     6      9

重命名索引 (行和列)

rename() 方法也可用于重命名 DataFrame 的行索引和列索引。您可以使用 index 参数重命名行,使用 columns 参数重命名列。

# 重命名行和列
df = df.rename(index={0: 'one', 1: 'two', 2: 'three'}, columns={'alpha': 'A', 'beta': 'B', 'gamma': 'C'})
print(df)

输出:

        A  B  C
one     1  4  7
two     2  5  8
three   3  6  9

同时处理多个重命名

您还可以通过传递一个字典或函数到 rename() 方法来同时执行多个重命名操作。

df = df.rename(index={'one': '第一', 'two': '第二', 'three': '第三'},
               columns={'A': 'X', 'B': 'Y', 'C': 'Z'})
print(df)

输出: X Y Z 第一 1 4 7 第二 2 5 8 第三 3 6 9


## Pandas Rename: 重命名列

### 按名称重命名列

您可以通过在 `rename()` 方法的 `columns` 参数中直接指定旧列名和新列名来重命名列。

```python
# 按名称重命名列
df = pd.DataFrame({'original_a': [1, 2, 3], 'original_b': [4, 5, 6], 'original_c': [7, 8, 9]})
df = df.rename(columns={'original_a': 'new_a', 'original_b': 'new_b', 'original_c': 'new_c'})
print(df)

输出:

   new_a  new_b  new_c
0      1      4      7
1      2      5      8
2      3      6      9

使用字典重命名列

您也可以使用字典将旧列名映射到新列名。

# 使用字典重命名列
rename_dict = {'original_a': 'new_a', 'original_b': 'new_b', 'original_c': 'new_c'}
df = df.rename(columns=rename_dict)
print(df)

输出:

   new_a  new_b  new_c
0      1      4      7
1      2      5      8
2      3      6      9

使用函数重命名列

您也可以使用函数来转换列名。该函数应该以原始列名作为输入并返回新的列名。

# 使用函数重命名列
def rename_func(column_name):
    if column_name.startswith('original_'):
        return column_name.replace('original_', 'new_')
    else:
        return column_name
 
df = df.rename(columns=rename_func)
print(df)

输出:

   new_a  new_b  new_c
0      1      4      7
1      2      5      8
2      3      6      9

处理列名的大小写敏感性

默认情况下, rename() 方法是大小写敏感的。如果您想执行不区分大小写的重命名, 您可以将列名转换为特定的大小写. 使用 rename() 方法之前的情况。

# 处理列名的大小写敏感性
df = pd.DataFrame({'OriginalA': [1, 2, 3], 'OriginalB': [4, 5, 6], 'OriginalC': [7, 8, 9]})
df = df.rename(columns={c.lower(): f'new_{c.lower()}' for c in df.columns})
print(df)

输出:

   new_originala  new_originalb  new_originalc
0             1              4              7
1             2              5              8
2             3              6              9

处理具有重复名称的列

如果您的 DataFrame 有具有重复名称的列,您可以使用 rename() 方法来解决这个问题。

# 处理具有重复名称的列
df = pd.DataFrame({'A': [1, 2, 3], 'A': [4, 5, 6], 'B': [7, 8, 9]})
df = df.rename(columns={'A': 'A_1', 'A.1': 'A_2'})
print(df)

输出:

   A_1  A_2  B
0    1    4  7
1    2    5  8
2    3    6  9

Pandas Rename: 重命名索引

重命名行(索引)

您可以使用 rename() 方法的 index 参数来重命名 DataFrame 的行索引。

# 重命名行(索引)
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}, index=['old_index_1', 'old_index_2', 'old_index_3'])
df = df.rename(index={'old_index_1': 'new_index_1', 'old_index_2': 'new_index_2', 'old_index_3': 'new_index_3'})
print(df)

输出:

            A  B
new_index_1  1  4
new_index_2  2  5
new_index_3  3  6

重命名列(列)

同样,您可以使用 rename() 方法的 columns 参数来重命名 DataFrame 的列索引。

# 重命名列(列)
df = pd.DataFrame({'old_col_a': [1, 2, 3], 'old_col_b': [4, 5, 6]}, index=['row_1', 'row_2', 'row_3'])
df = df.rename(columns={'old_col_a': 'new_col_a', 'old_col_b': 'new_col_b'})
print(df)

输出:

        new_col_a  new_col_b
row_1          1          4
row_2          2          5
row_3          3          6

同时重命名行和列

您可以同时重命名行和列。中文翻译:

# 同时重命名行和列
df = pd.DataFrame({'old_col_a': [1, 2, 3], 'old_col_b': [4, 5, 6]}, index=['old_row_1', 'old_row_2', 'old_row_3'])
df = df.rename(index={'old_row_1': 'new_row_1', 'old_row_2': 'new_row_2', 'old_row_3': 'new_row_3'},
               columns={'old_col_a': 'new_col_a', 'old_col_b': 'new_col_b'})
print(df)

输出:

            new_col_a  new_col_b
new_row_1          1          4
new_row_2          2          5
new_row_3          3          6

处理层次化索引(多级索引)

rename() 方法也可用于重命名 DataFrame 中的层次化索引(多级索引)。

# 处理层次化索引(多级索引)
df = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
                  index=pd.MultiIndex.from_tuples([('old_level1', 'old_level2'), ('new_level1', 'new_level2'), ('third_level1', 'third_level2')],
                                                 names=['level1', 'level2']),
                  columns=['old_col_a', 'old_col_b', 'old_col_c'])
df = df.rename(index={'old_level1': 'renamed_level1', 'new_level1': 'renamed_level1_2', 'third_level1': 'renamed_level1_3'},
               columns={'old_col_a': 'new_col_a', 'old_col_b': 'new_col_b', 'old_col_c': 'new_col_c'})
print(df)

输出:

                             new_col_a  new_col_b  new_col_c
level1          level2
renamed_level1  old_level2           1          2          3
renamed_level1_2 new_level2          4          5          6
renamed_level1_3 third_level2        7          8          9

Pandas Rename: 高级技术

基于特定条件的有条件重命名

您可以使用函数根据特定条件执行有条件的重命名。

# 基于特定条件的有条件重命名
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7.
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
df = df.rename(columns=lambda x: 'new_' + x if x in ['A', 'B'] else x)
print(df)

输出:

   new_A  new_B  C
0      1      4  7
1      2      5  8
2      3      6  9

使用正则表达式进行重命名

您可以使用正则表达式执行更复杂的重命名操作。

# 使用正则表达式进行重命名
import re
 
df = pd.DataFrame({'feature_1': [1, 2, 3], 'feature_2': [4, 5, 6], 'target': [7, 8, 9]})
df = df.rename(columns=lambda x: re.sub(r'feature_(\d+)', r'new_feature_\1', x))
print(df)

输出:

   new_feature_1  new_feature_2  target
0             1              4       7
1             2              5       8
2             3              6       9

进行就地修改的重命名

默认情况下,rename() 方法会返回一个新的 DataFrame,其中包含重命名的列或索引。如果您想就地修改原始的 DataFrame,可以将 inplace 参数设置为 True

# 进行就地修改的重命名
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df.rename(columns={'A': 'new_A', 'B': 'new_B'}, inplace=True)
print(df)

输出:

   new_A  new_B
0      1      4
1      2      5
2      3      6

列表和元组

列表和元组是 Python 中最常用的两种数据结构。它们允许您存储和操作数据集合。

列表

列表是可变的,这意味着您可以在创建列表后添加、删除或修改其中的元素。您可以使用方括号 [] 创建一个列表,并用逗号分隔各个元素。

fruits = ['apple', 'banana', 'cherry']
print(fruits)  # 输出: ['apple', 'banana', 'cherry']

您可以使用索引访问列表中的单个元素,索引从 0 开始。

print(fruits[0])  # 输出: 'apple'
print(fruits[1])  # 输出: 'banana'
print(fruits[-1])  # 输出: 'cherry' (负索引从末尾开始)

您也可以修改列表中的元素:

fruits[1] = 'orange'
print(fruits)  # 输出: ['apple', 'orange', 'cherry']

列表支持各种内置方法,如 append(), remove(), sort() 等。

fruits.append('葡萄')
print(fruits)  # 输出: ['苹果', '橙子', '樱桃', '葡萄']
 
fruits.insert(1, '梨子')
print(fruits)  # 输出: ['苹果', '梨子', '橙子', '樱桃', '葡萄']
 
fruits.remove('橙子')
print(fruits)  # 输出: ['苹果', '梨子', '樱桃', '葡萄']
 
fruits.sort()
print(fruits)  # 输出: ['苹果', '樱桃', '葡萄', '梨子']

元组

元组与列表类似,但是它们是不可变的,这意味着您无法在创建后修改它们的元素。您可以使用括号 () 创建一个元组,并用逗号分隔元素。

point = (3, 4)
print(point)  # 输出: (3, 4)

您可以使用索引访问元组中的单个元素,就像使用列表一样。

print(point[0])  # 输出: 3
print(point[1])  # 输出: 4

但是,您无法修改元组中的元素:

point[0] = 5  # TypeError: 'tuple' object does not support item assignment

当您需要确保数据结构保持不变时,例如处理坐标或其他不应修改的数据类型时,元组会很有用。

条件语句

条件语句允许您根据某些条件执行不同的代码块。Python 中最常见的条件语句是 if-elif-else 语句。

age = 25
if age < 18:
    print("您是未成年人。")
elif age < 65:
    print("您是成年人。")
else:
    print("您是老年人。")

在这个例子中,程序检查 age 变量的值,并根据条件执行相应的代码块。

您还可以使用逻辑运算符,如 andornot,来组合多个条件。

temperature = 35
humidity = 80
if temperature > 30 and humidity > 70:
    print("外面又热又潮湿。")
else:
    print("天气舒适。")

Python 也支持三元运算符,允许您以更简洁的方式编写条件语句。以下是中文翻译版本:

is_student = True
discount = 50 if is_student else 0
print(f"您的折扣是 {discount}%.")  # 输出: 您的折扣是 50%.

在这个例子中, discount 的值如果 is_studentTrue, 则设置为 50, 否则为 0.

循环

Python 中的循环允许您重复执行一个代码块。最常见的两种类型是 for 循环和 while 循环。

For 循环

for 循环用于遍历一个序列, 如列表、元组或字符串。

fruits = ['苹果', '香蕉', '樱桃']
for fruit in fruits:
    print(fruit)

这将输出:

苹果
香蕉
樱桃

您也可以使用 range() 函数创建一个数字序列并遍历它们。

for i in range(5):
    print(i)  # 输出: 0 1 2 3 4

While 循环

while 循环用于只要某个条件为真就执行一个代码块。

count = 0
while count < 3:
    print(f"第 {count + 1} 次迭代")
    count += 1

这将输出:

第 1 次迭代
第 2 次迭代
第 3 次迭代

您还可以使用 breakcontinue 语句来控制循环的流程。

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num == 3:
        break
    print(num)  # 输出: 1 2

在这个例子中, 当遇到数字 3 时, 循环会停止, 因为使用了 break 语句。

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        continue
    print(num)  # 输出: 1 3 5

在这个例子中, 循环会跳过偶数, 因为使用了 continue 语句。

函数

Python 中的函数是可重复使用的代码块, 用于执行特定的任务。您可以使用 def 关键字定义一个函数。

def greet(name):
    print(f"你好, {name}!")
 
greet("Alice")  # 输出: 你好, Alice!

函数也可以接受参数并返回值。

def add_numbers(a, b):
    return a + b
 
result = add_numbers(3, 4)  # result 为 7

rs(3, 4) print(result) # 输出: 7

您也可以为函数参数定义默认值。
 
```python
def greet(name, message="Hello"):
    print(f"{message}, {name}!")
 
greet("Alice")  # 输出: Hello, Alice!
greet("Bob", "Hi")  # 输出: Hi, Bob!

函数也可以嵌套,您可以定义接受其他函数作为参数的函数(高阶函数)。

def apply_twice(func, arg):
    return func(func(arg))
 
def square(x):
    return x * x
 
result = apply_twice(square, 3)
print(result)  # 输出: 81

在这个例子中,apply_twice() 函数接受一个函数 func 和一个参数 arg,并将该函数应用两次于该参数。

模块和包

在 Python 中,您可以将代码组织成模块和包,以使其更加模块化和可重用。

模块

模块是包含 Python 定义和语句的文件。您可以使用 import 语句导入一个模块。

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

您也可以仅导入模块中的特定函数或变量。

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

包是组织成目录结构的一组模块。您可以创建自己的包来将相关的模块分组在一起。

假设您有以下目录结构:

my_package/
    __init__.py
    math_utils.py
    string_utils.py

math_utils.py 文件中,您可以定义一个函数:

def square(x):
    return x * x

要使用这个函数,您可以从包中导入它:

from my_package.math_utils import square
print(square(5))  # 输出: 25

__init__.py 文件用于指定包的内容,也可以包含初始化代码。

结论

在本教程中,您学习了各种 Python 概念,包括列表、元组、条件语句、循环、函数以及模块/包。这些是 Python 编程的基础. Python 基础知识

Python 是一种强大且易学的编程语言,它是构建各种应用程序的基础。本文将介绍 Python 语言的基本构建块,并帮助您编写更高效和有条理的代码。

记住,提高 Python 技能的最佳方式是实践、实验和探索 Python 库和工具的广阔生态系统。继续学习,祝你编码愉快!

MoeNagy Dev.