Python
精通Python中的.loc: 初学者指南

掌握 Python 中的 .loc: 初学者指南

MoeNagy Dev

理解 .loc 访问器

什么是 .loc 访问器?

Pandas 中的 .loc 访问器是一个强大的工具,用于根据行和列标签选择和访问 DataFrame 或 Series 中的数据。它允许您通过明确指定行和列标签来选择数据,而不是像使用 .iloc 访问器那样使用数字索引。

使用行和列标签访问数据

要使用 .loc 访问器访问数据,您需要提供行和列标签作为参数。这里有一个基本示例:

import pandas as pd
 
# 创建一个示例 DataFrame
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
                   'B': [10, 20, 30, 40, 50]},
                  index=['row1', 'row2', 'row3', 'row4', 'row5'])
 
# 访问单个元素
print(df.loc['row2', 'B'])  # 输出: 20
 
# 访问一行
print(df.loc['row3'])
# 输出:
# A    3
# B   30
# Name: row3, dtype: int64
 
# 访问一列
print(df.loc[:, 'A'])
# 输出:
# row1    1
# row2    2
# row3    3
# row4    4
# row5    5
# Name: A, dtype: int64

在上面的示例中,我们创建了一个示例 DataFrame,其行标签为 'row1''row5',列标签为 'A''B'。然后我们演示如何使用 .loc 访问器来选择单个元素、整行和整列。

选择单个元素、行和列

.loc 访问器允许您通过提供适当的标签来选择单个元素、行和列。这里有一些示例:

# 选择单个元素
print(df.loc['row2', 'B'])  # 输出: 20
 
# 选择一行
print(df.loc['row3'])
# 输出:
# A    3
# .
```这是中文翻译版本:
 
# 名称: row3, dtype: int64
 
# 选择一个列
print(df.loc[:, 'A'])
# 输出:
# row1    1
# row2    2
# row3    3
# row4    4
# row5    5
# 名称: A, dtype: int64
 
### 选择多行和多列
您还可以使用 `.loc` 访问器来选择多行和多列,只需提供标签列表或范围:
 
```python
# 选择多行
print(df.loc[['row2', 'row4']])
#    A   B
# row2  2  20
# row4  4  40
 
# 选择多列
print(df.loc[:, ['A', 'B']])
#        A   B
# row1   1  10
# row2   2  20
# row3   3  30
# row4   4  40
# row5   5  50
 
# 选择一个行范围
print(df.loc['row2':'row4'])
#        A   B
# row2   2  20
# row3   3  30
# row4   4  40

在上面的示例中,我们演示了如何使用标签列表或范围来选择多行和多列。

使用 .loc 进行条件选择

根据条件过滤行和列

.loc 访问器还可用于根据特定条件过滤行和列。这在需要选择满足某些标准的数据时特别有用。

# 根据条件过滤行
print(df.loc[df['A'] > 3])
#        A   B
# row4   4  40
# row5   5  50
 
# 根据条件过滤列
print(df.loc[:, df.columns.str.startswith('A')])
#        A
# row1   1
# row2   2
# row3   3
# row4   4
# row5   5

在第一个示例中,我们过滤 DataFrame 以仅包含 'A' 列值大于 3 的行。在第二个示例中,我们过滤 DataFrame 以仅包含名称以 'A' 开头的列。

使用布尔运算符组合多个条件

您还可以使用布尔运算符 & (和) 和 | (或) 组合多个条件来创建更复杂的过滤器。

# 使用布尔运算符组合多个条件
print(df.loc[(df['A'] > 2) & (df['B'] < 40)])
#        A   B
# row3   3  30

在这个示例中,我们选择 'A' 列值大于 2 且 'B' 列值小于 40 的行。基于复杂条件选择行和列 .loc访问器允许您通过组合多个过滤器和使用布尔运算符来创建复杂的条件。当您需要执行更高级的数据选择和提取时,这可能特别有用。

# 根据复杂条件选择行和列
print(df.loc[(df['A'] > 2) & (df['B'] < 40), ['A', 'B']])
#        A   B
# row3   3  30

在这个例子中,我们选择了'A'列的值大于2且'B'列的值小于40的行,并只返回'A'和'B'列。

使用.loc修改数据

为特定元素赋值

.loc访问器也可用于为DataFrame或Series中的特定元素赋值。

# 为特定元素赋值
df.loc['row2', 'B'] = 25
print(df)
#        A   B
# row1   1  10
# row2   2  25
# row3   3  30
# row4   4  40
# row5   5  50

在这个例子中,我们使用.loc访问器将值25赋给位于行'row2'和列'B'的元素。

更新多个行和列

您也可以使用.loc访问器同时更新多个行和列。

# 更新多个行和列
df.loc[['row2', 'row4'], ['A', 'B']] = [[12, 125], [42, 420]]
print(df)
#         A    B
# row1    1   10
# row2   12  125
# row3    3   30
# row4   42  420
# row5    5   50

在这个例子中,我们使用.loc访问器更新了'row2'和'row4'行的'A'和'B'列的值。

使用.loc处理缺失数据

.loc访问器也可用于处理DataFrame或Series中的缺失数据。

# 创建一个包含缺失数据的DataFrame
df = pd.DataFrame({'A': [1, 2, None, 4, 5],
                   'B': [10, 20, 30, None, 50]},
                  index=['row1', 'row2', 'row3', 'row4', 'row5'])
 
# 使用.loc填充缺失值
df.loc[:, 'A'] = df['A'].fillna(0)
df.loc[:, 'B'].

= df['B'].fillna(0) print(df)

A B

row1 1 10

row2 2 20

row3 0 30

row4 4 0

row5 5 50

在这个例子中,我们创建了一个包含缺失值的 DataFrame,然后使用 .loc 访问器将缺失值填充为 0。

使用 .loc 的高级技术

将 .loc 与其他 pandas 操作链接

.loc 访问器可以与其他 pandas 操作链接,以创建更复杂的数据选择和操作工作流。

# 将 .loc 与其他 pandas 操作链接
filtered_df = df.loc[(df['A'] > 2) & (df['B'] < 40), ['A', 'B']]
filtered_df['C'] = filtered_df['A'] + filtered_df['B']
print(filtered_df)
#        A   B   C
# row3   3  30  33

在这个例子中,我们首先使用 .loc 访问器根据条件过滤 DataFrame,然后创建一个新的列 'C',其值是过滤后的行中 'A' 和 'B' 列的和。

处理层次化(多级)索引

.loc 访问器也可用于处理具有层次化(多级)索引的 DataFrame 或 Series。

# 创建一个具有多级索引的 DataFrame
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
                   'B': [10, 20, 30, 40, 50]},
                  index=pd.MultiIndex.from_tuples([('group1', 'row1'), ('group1', 'row2'),
                                                  ('group2', 'row1'), ('group2', 'row2'),
                                                  ('group2', 'row3')],
                                                 names=['group', 'row']))
 
# 使用 .loc 访问具有多级索引的数据
print(df.loc[('group2', 'row1'), 'A'])  # 输出: 3
print(df.loc[('group1', slice(None)), 'B'])
# 输出:
# ('group1', 'row1')    10
# ('group1', 'row2')    20
# Name: B, dtype: int64

在这个例子中,我们创建了一个具有多级索引的 DataFrame,然后演示了如何使用 .loc 访问器根据层次化索引选择数据。 与其他 pandas 访问器(例如,.at,.iat)结合使用 .loc 访问器可以与其他 pandas 访问器(如 .at.iat)结合使用,以提供更精确和高效的数据访问。

# 将 .loc 与 .at 和 .iat 结合使用
print(df.at[('group2', 'row1'), 'A'])  # 输出: 3
print(df.iat[2, 0])  # 输出: 3

在这个例子中,我们使用 .at 访问器根据行和列标签选择单个元素,使用 .iat 访问器根据行和列整数位置选择单个元素。

使用 .loc 的性能考虑

理解 .loc 的效率

.loc 访问器通常比使用布尔索引或基于整数的索引(.iloc)更有效,因为它避免了不必要的计算和数据复制。

# .loc、.iloc 和布尔索引的比较
import pandas as pd
import numpy as np
 
# 创建一个大型 DataFrame
df = pd.DataFrame(np.random.rand(1000000, 5), columns=['A', 'B', 'C', 'D', 'E'])
 
# Timeit 比较
%timeit df.loc[df['A'] > 0.5, ['B', 'C']]
%timeit df.iloc[df['A'] > 0.5, [1, 2]]
%timeit df[(df['A'] > 0.5) & (df['B'] < 0.7)]

在这个例子中,我们创建了一个大型 DataFrame,并比较了使用 .loc.iloc 和布尔索引来选择一组行和列的性能。.loc 访问器通常是这三种方法中最高效的。

比较 .loc 与其他选择方法(如 .iloc、布尔索引)

虽然 .loc 访问器通常很高效,但在某些情况下,其他选择方法(如 .iloc 或布尔索引)可能更合适,这取决于您的具体使用情况和数据结构。

# 比较 .loc、.iloc 和布尔索引
# 何时使用每种方法
# .loc: 当您有标签数据并想根据标签进行选择时
# .iloc: 当您有数字索引并想根据位置进行选择时
# 布尔索引: 当您想根据复杂条件过滤数据时

理解权衡并为您的具体需求选择合适的选择方法很重要。

列表和元组

列表和元组都是 Python 中的序列类型,但它们有一些关键区别。列表是可变的,这意味着您可以更改它们的元素,而元组是不可变的,这意味着它们的元素不能被更改。

列表

列表使用方括号 [] 定义。这里有一个例子:

fruits = ['苹果', '香蕉', '樱桃']

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

print(fruits[0])  # 输出: '苹果'
print(fruits[1])  # 输出: '香蕉'

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

fruits[1] = '橙子'
print(fruits)  # 输出: ['苹果', '橙子', '樱桃']

列表有许多有用的方法,如 append()insert()remove()pop()。这里有一个例子:

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

元组

元组使用括号 () 定义。这里有一个例子:

point = (3, 4)

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

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

但是,您不能修改元组的元素:

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

元组通常用于表示不可变数据,如坐标或键值对。

字典

字典是 Python 中另一个重要的数据结构。它们用于存储键值对,其中键是唯一的,值可以是任何数据类型。

字典使用花括号 {} 定义,键值对用冒号 : 分隔。

person = {
    '姓名': '约翰·道',
    '年龄': 35,
    '职业': '软件工程师'
}

您. 你可以使用字典的键来访问其中的值:

print(person['name'])  # 输出: 'John Doe'
print(person['age'])   # 输出: 35

你也可以添加、修改和删除字典中的键值对:

person['email'] = 'john.doe@example.com'
person['age'] = 36
del person['occupation']
print(person)  # 输出: {'name': 'John Doe', 'age': 36, 'email': 'john.doe@example.com'}

字典有许多有用的方法,如 keys()values()items(),可以让你处理字典中的键和值。

print(list(person.keys()))   # 输出: ['name', 'age', 'email']
print(list(person.values())) # 输出: ['John Doe', 36, 'john.doe@example.com']
print(list(person.items()))  # 输出: [('name', 'John Doe'), ('age', 36), ('email', 'john.doe@example.com')]

字典非常灵活,可用于存储复杂的数据结构,如嵌套字典或字典列表。

条件语句

Python 中的条件语句允许你根据特定条件执行不同的代码块。

最常见的条件语句是 if-elif-else 语句:

x = 10
if x > 0:
    print("x 是正数")
elif x < 0:
    print("x 是负数")
else:
    print("x 是零")

你也可以使用 andornot 运算符来组合多个条件:

age = 25
if age >= 18 and age < 65:
    print("你是成年人")
else:
    print("你不是成年人")

另一个有用的条件语句是三元运算符,它允许你在一行中编写简单的 if-else 语句:

is_student = True
status = "学生" if is_student else "非学生"
print(status)  # 输出: "学生"

条件语句对于构建复杂的 Python 程序逻辑非常重要。

循环

Python 中的循环允许你重复执行一个代码块,直到满足某个条件为止。

最常见的循环是 for 循环。这是一个 Python 中的 for 循环示例,用于遍历一个序列(如列表、元组或字符串):

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

你也可以使用 range() 函数创建一个数字序列来进行遍历:

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

while 循环在你事先不知道迭代次数,而需要循环直到满足特定条件时使用:

计数 = 0
while 计数 < 3:
    print("你好")
    计数 += 1

你可以使用 breakcontinue 语句来控制循环的流程:

for i in range(10):
    if i % 2 == 0:
        continue  # 跳过偶数
    if i > 7:
        break     # 当 i 大于 7 时停止循环
    print(i)      # 输出: 1, 3, 5, 7

循环是自动化重复任务和处理大量数据的关键,在 Python 程序中非常重要。

函数

Python 中的函数是执行特定任务的可重用代码块。它们使你的代码更加模块化和可维护。

你使用 def 关键字定义一个函数,后跟函数名和一对括号。函数体缩进,可以包含任何有效的 Python 代码。

def 问候(名字):
    print(f"你好, {名字}!")
 
问候("Alice")  # 输出: "你好, Alice!"

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

def 加数字(a, b):
    return a + b
 
结果 = 加数字(3, 4)
print(结果)  # 输出: 7

你还可以为函数参数定义默认值:

def 问候(名字, 消息="你好"):
    print(f"{消息}, {名字}!")
 
问候("Bob")       # 输出: "你好, Bob!"
问候("Charlie", "嗨")  # 输出: "嗨, Charlie!"

函数也可以使用 *args**kwargs 语法定义可变数量的参数:

def 打印数字(*args):
    for arg in args:
        print(arg)
 
打整数(1, 2, 3)   # 输出: 1, 2, 3
print_numbers(4, 5, 6, 7, 8)  # 输出: 4, 5, 6, 7, 8
 
函数是Python编程的基本构建块,对于创建模块化、可重用和可维护的代码至关重要。
 
## 模块和包
在Python中,模块和包用于组织和分发代码。
 
模块是包含定义和语句的单个Python文件。您可以使用`import`关键字导入模块:
 
```python
import math
print(math.pi)  # 输出: 3.141592653589793

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

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

包是相关模块的集合。它们以分层目录结构组织,每个目录都包含一个__init__.py文件。

下面是如何使用包的示例:

import my_package.my_module
my_package.my_module.my_function()

您也可以使用from关键字从包中导入特定项目:

from my_package.my_module import my_function
my_function()

模块和包对于组织和分发Python代码至关重要,因为它们允许您创建可重用和可维护的代码,并与他人共享。

结论

在本教程中,您已经学习了以下Python中的关键概念:

  • 列表和元组:用于存储数据集合的序列类型
  • 字典:用于存储键值对的数据结构
  • 条件语句:根据条件执行代码
  • 循环:重复执行代码块
  • 函数:执行特定任务的可重用代码块
  • 模块和包:组织和分发Python代码

这些概念是Python编程的基础,将为构建更复杂的应用程序提供坚实的基础。请记住练习和实验这些概念,以加深理解并成为更熟练的Python程序员。

[![MoeNagy Dev] moenagy-dev

我的个人网站

这是我的个人网站,用于展示我的作品和技能。

主要功能

  1. 作品展示: 展示我的各种作品,包括网页设计、插画、摄影等。
  2. 技能介绍: 介绍我的专业技能,如前端开发、UI 设计、摄影等。
  3. 联系方式: 提供联系方式,方便有需要的人与我取得联系。

技术栈

这个网站使用以下技术栈构建:

<!-- HTML -->
<header>
  <nav>
    <!-- 导航栏 -->
  </nav>
</header>
 
<main>
  <section>
    <!-- 作品展示区域 -->
  </section>
  <section>
    <!-- 技能介绍区域 -->
  </section>
  <section>
    <!-- 联系方式区域 -->
  </section>
</main>
 
<footer>
  <!-- 页脚 -->
</footer>
/* CSS */
body {
  /* 全局样式 */
}
 
header {
  /* 头部样式 */
}
 
nav {
  /* 导航栏样式 */
}
 
main {
  /* 主体内容样式 */
}
 
section {
  /* 各个区域样式 */
}
 
footer {
  /* 页脚样式 */
}
// JavaScript
document.addEventListener('DOMContentLoaded', function() {
  // 页面加载完成后的初始化操作
});

未来计划

  1. 增加博客功能,分享技术文章和生活感悟。
  2. 优化网站的用户体验和视觉效果。
  3. 添加更多的作品展示和技能介绍。

欢迎大家访问我的网站,如有任何意见或建议,欢迎随时与我联系。