Python
掌握 pandas.loc:轻松访问数据的初学者指南

掌握 pandas.loc:轻松访问数据的初学者指南

MoeNagy Dev

使用 pandas.loc 访问数据

介绍 pandas.loc

pandas.loc 是 pandas 库中一个强大的数据访问方法,pandas 是 Python 中广泛使用的数据操作和分析工具。pandas.loc 提供了一种灵活直观的方式,可以基于标签索引从 pandas DataFrame 或 Series 中选择和访问数据。

pandas.loc 的主要目的是使您能够通过标签选择数据,这意味着您可以根据行和列标签访问行、列或单个元素,而不是它们的整数位置。这使得 pandas.loc 在处理真实世界数据集时特别有用,因为数据通常具有有意义的行和列标签。

pandas.loc 是 pandas 中三种主要数据访问方法之一,另外两种是 pandas.iloc(基于整数的索引)和 pandas.ix(标签和整数索引的混合)。了解这些方法之间的差异对于有效地导航和操作您的数据至关重要。

选择行和列

按标签选择行

要按标签选择行,可以使用以下语法:

df.loc[row_labels]

这里,row_labels 可以是单个标签、标签列表、标签切片或布尔数组。

示例:

import pandas as pd
 
# 创建一个示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [25, 30, 35, 40],
        'City': ['New York', 'London', 'Paris', 'Tokyo']}
df = pd.DataFrame(data)
 
# 按标签选择行
print(df.loc['Alice'])
print(df.loc[['Alice', 'Bob']])
```以下是中文翻译版本:
 
```python
import pandas as pd
 
# 创建一个示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [25, 30, 35, 40],
        'City': ['New York', 'London', 'Paris', 'Tokyo']}
df = pd.DataFrame(data)
 
# 打印整个 DataFrame
print(df)
 
# 选择 'Alice' 到 'Charlie' 的行
print(df.loc['Alice':'Charlie'])

输出:

   Name  Age        City
0  Alice   25  New York
1    Bob   30    London
2  Charlie  35      Paris
3   David   40     Tokyo

   Name   Age        City
0  Alice   25  New York
2  Charlie  35      Paris

按标签选择列

要按标签选择列,可以使用以下语法:

df.loc[:, column_labels]

这里, column_labels 可以是单个标签、标签列表、标签切片或布尔数组。

示例:

# 按标签选择列
print(df.loc[:, 'Name'])
print(df.loc[:, ['Name', 'Age']])
print(df.loc[:, 'Name':'City'])

输出:

0    Alice
1      Bob
2  Charlie
3    David
Name: Name, dtype: object
   Name  Age
0  Alice   25
1    Bob   30
2  Charlie  35
3   David   40
   Name   Age        City
0  Alice   25  New York
1    Bob   30    London
2  Charlie  35      Paris
3   David   40     Tokyo

选择单个值

要选择单个值,可以使用以下语法:

df.loc[row_label, column_label]

示例:

# 选择单个值
print(df.loc['Alice', 'Age'])

输出:

25

选择多行和多列

您可以通过传递标签列表或切片来同时选择多行和多列。

示例:

# 选择多行和多列
print(df.loc[['Alice', 'Charlie'], ['Name', 'City']])

输出:

        Name        City
0     Alice  New York
2  Charlie      Paris

条件选择

根据条件过滤行

您可以使用布尔索引根据一个或多个条件过滤行。

示例:

# 根据条件过滤行
print(df.loc[df['Age'] > 30])

输出:

       Name  Age        City
2  Charlie   35      Paris
3    David   40     Tokyo

组合多个条件

您可以使用布尔运算符(如 & (和)、| (或)、~ (非))组合多个条件。 例子:

# 组合多个条件
print(df.loc[(df['Age'] > 30) & (df['City'] != 'New York')])

输出:

       Name  Age        City
2  Charlie   35      Paris
3    David   40     Tokyo

同时选择行和列

您可以使用 pandas.loc 同时选择行和列。

例子:

# 同时选择行和列
print(df.loc[df['Age'] > 30, ['Name', 'City']])

输出:

       Name        City
2  Charlie      Paris
3    David     Tokyo

处理缺失数据

在 pandas.loc 中处理缺失值

pandas.loc 处理缺失值的方式与其他 pandas 数据访问方法相同。如果行或列包含缺失值,它将包含在选择中。

例子:

# 创建一个包含缺失值的 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
        'Age': [25, 30, None, 40, 35],
        'City': ['New York', 'London', 'Paris', None, 'Tokyo']}
df = pd.DataFrame(data)
 
# 选择包含缺失值的行和列
print(df.loc[:, ['Age', 'City']])

输出:

     Age        City
0   25.0  New York
1   30.0    London
2   NaN      Paris
3   40.0       NaN
4   35.0     Tokyo

替换缺失值

您可以使用 pandas.loc 替换 DataFrame 中的缺失值。

例子:

# 用特定值替换缺失值
df.loc[:, 'Age'] = df['Age'].fillna(0)
df.loc[:, 'City'] = df['City'].fillna('Unknown')
print(df)

输出:

       Name  Age        City
0     Alice   25  New York
1       Bob   30    London
2   Charlie    0      Paris
3     David   40    Unknown
4       Eve   35     Tokyo

插值缺失数据

您也可以使用 pandas.loc 根据其他行的值插值缺失值。

例子:

# 插值缺失值
df['Age'] = df['Age'].interpolate()
print(df.loc[:, 'Age'])

输出:

0    25.0
1    30.0
2    35.0
3    40.0
4    35.0
Name: Age, dtype: float64

40.0 4 35.0 Name: Age, dtype: float64


### 高级索引

#### 使用布尔数组进行选择

您可以使用布尔数组根据特定条件选择行和列。

示例:
```python
# 使用布尔数组进行选择
bool_mask = (df['Age'] > 30) & (df['City'] != 'New York')
print(df.loc[bool_mask, ['Name', 'Age', 'City']])

输出:

       Name  Age        City
2   Charlie 35.0      Paris
3     David 40.0     Unknown
4       Eve 35.0     Tokyo

基于整数位置进行选择

虽然 pandas.loc 主要用于基于标签的索引,但您也可以通过结合使用 pandas.iloc 来进行基于整数的索引。

示例:

# 结合基于标签和整数的索引
print(df.loc[0, 'Name'])
print(df.loc[1:3, 'Name':'City'])

输出:

Alice
   Name  Age        City
1   Bob   30    London
2  Charlie 35.0      Paris
3   David 40.0     Unknown

结合多种索引技术

您可以结合各种索引技术,如基于标签、整数和布尔的索引,创建复杂的选择。

示例:

# 结合多种索引技术
print(df.loc[bool_mask, df.columns[::2]])

输出:

       Name        City
2   Charlie      Paris
3     David     Unknown
4       Eve     Tokyo

修改数据

为行和列赋值

您可以使用 pandas.loc 为特定行和列赋值。

示例:

# 为行和列赋值
df.loc['Alice', 'Age'] = 26
df.loc[:, 'City'] = 'San Francisco'
print(df)

输出:

       Name  Age           City
0     Alice   26  San Francisco
1       Bob   30  San Francisco
2   Charlie   35  San Francisco
3     David   40  San Francisco
4       Eve   35  San Francisco

更新现有数据

您也可以使用 pandas.loc 更新 DataFrame 中的现有数据。

示例:

# 更新现有数据
df.loc[df['Name'] == 'Bob', 'Age'].
```中文翻译:
 
= 31
print(df)

输出:

       姓名  年龄           城市
0     Alice   26  旧金山
1       Bob   31  旧金山
2   Charlie   35  旧金山
3     David   40  旧金山
4       Eve   35  旧金山

添加新数据

虽然 pandas.loc 主要用于数据选择, 但您也可以使用它来向 DataFrame 添加新行.

示例:

# 添加新数据
new_row = pd.Series({'姓名': 'Frank', '年龄': 28, '城市': '洛杉矶'})
df.loc[len(df)] = new_row
print(df)

输出:

       姓名  年龄           城市
0     Alice   26  旧金山
1       Bob   31  旧金山
2   Charlie   35  旧金山
3     David   40  旧金山
4       Eve   35  旧金山
5      Frank   28  洛杉矶

使用 MultiIndex

从 MultiIndex DataFrame 中选择数据

当使用具有 MultiIndex 的 DataFrame 时, 您可以使用 pandas.loc 根据层次索引选择数据.

示例:

# 创建一个 MultiIndex DataFrame
index = pd.MultiIndex.from_tuples([('A', 'X'), ('A', 'Y'), ('B', 'X'), ('B', 'Y')],
                                 names=['Group', 'Subgroup'])
df = pd.DataFrame({'Value': [10, 20, 30, 40]}, index=index)
 
# 从 MultiIndex DataFrame 中选择数据
print(df.loc[('A', 'Y')])
print(df.loc[('B', :)])

输出:

Value    20
Name: ('A', 'Y'), dtype: int64
           Value
Group Subgroup  
B     X        30
      Y        40

使用 MultiIndex 进行条件选择

您也可以使用 pandas.loc 对 MultiIndex DataFrame 进行条件选择.

示例:

# 使用 MultiIndex 进行条件选择
print(df.loc[('A', 'X'), 'Value'])
print(df.loc[df['Value'] > 25])

输出:

10
           Value
Group Subgroup  
B     X        30
      Y        40

修改 MultiIndex DataFrame 中的数据

pandas.loc 也可用于修改 MultiIndex DataFrame 中的数据.

示例:

# 修改 MultiIndex DataFrame 中的数据
df.loc[('B', .以下是中文翻译版本:
 
'Y'), 'Value'] = 45
print(df)

输出:

                Value
Group Subgroup       
A      X           10
       Y           20
B      X           30
       Y           45

优化性能

虽然 pandas.loc 是一个强大的工具,但理解其性能特征以及如何优化其使用非常重要。

理解 pandas.loc 的性能特征

pandas.loc 通常比 pandas.iloc 更快,因为它可以直接通过标签访问数据。但是,对于大型数据集或复杂操作,pandas.loc 可能仍然比其他方法(如布尔索引)慢。

以下是基于提供的大纲的 2000 多字的 Python 教程的后半部分:

处理文件

处理文件是许多编程任务的重要组成部分。Python 提供了一种简单直接的方式来与系统上的文件进行交互。

打开和关闭文件

要打开一个文件,可以使用内置的 open() 函数。open() 函数需要两个参数:文件路径和打开模式。

file = open('example.txt', 'r')

打开模式可以是以下之一:

  • 'r': 读取模式(默认)
  • 'w': 写入模式(覆盖现有内容)
  • 'a': 追加模式(在文件末尾添加内容)
  • 'x': 独占创建模式(创建新文件,如果文件已存在则失败)

完成对文件的操作后,请务必使用 close() 方法关闭文件:

file.close()

读取和写入文件

有了文件对象后,您可以使用各种方法从文件中读取或写入:

# 读取整个文件
file = open('example.txt', 'r')
content = file.read()
print(content)
file.close()
 
# 逐行读取
file = open('example.txt', 'r')
for line in file:
    print(line.strip())
file.close()
 
# 写入文件
file = open('example.txt', 'w')
file.write('这是一个新行。')
file.close()
print('这是另一行。')
file.close()

上下文管理器 (with 语句)

为了简化打开和关闭文件的过程,你可以使用 with 语句,它充当一个上下文管理器。这可以确保即使发生异常,文件也会被正确关闭。

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

使用模块和包

Python 的模块化设计允许你将代码组织成可重用的组件,称为模块。可以在 Python 脚本中导入和使用这些模块。

导入模块

要在 Python 脚本中使用一个模块,可以使用 import 语句。你可以导入整个模块,也可以导入模块中的特定函数或变量。

# 导入整个模块
import math
result = math.sqrt(16)
print(result)  # 输出: 4.0
 
# 导入特定函数
from math import sqrt, pi
result = sqrt(16)
print(result)  # 输出: 4.0
print(pi)  # 输出: 3.141592653589793
 
# 使用别名导入
import math as m
result = m.sqrt(16)
print(result)  # 输出: 4.0

创建模块

你可以通过将 Python 代码放在 .py 文件中来创建自己的模块。文件名就是模块名,你可以在其他部分的代码中导入和使用该模块。

# my_module.py
def greet(name):
    print(f"Hello, {name}!")
 
# 使用该模块
import my_module
my_module.greet("Alice")  # 输出: Hello, Alice!

包是一种组织和构建模块的方式。包是一组模块的集合,允许你将相关的模块组合在一起。

要创建一个包,需要创建一个目录并将模块文件放在其中。此外,还需要在包目录中包含一个名为 __init__.py 的特殊文件。

my_package/
    __init__.py
    module1.py
    module2.py

然后,你可以使用点符号从包中导入模块:

import my_package.module1
```我的包.模块1
我的包.模块1.来自模块1的函数()
 
从我的包中导入模块2
模块2.来自模块2的函数()
 
## 处理异常
 
异常是一种处理代码中意外或容易出错情况的方式。Python 有一个内置的异常处理机制,允许您预料并优雅地处理这些情况。
 
### 引发异常
 
您可以使用 `raise` 语句引发异常。当您想要表示某个特定条件已经发生时,这很有用。
 
```python
raise ValueError("无效的输入值")

处理异常

您可以使用 try-except 块来处理代码中的异常。如果 try 块中发生异常,相应的 except 块将被执行。

try:
    结果 = 10 / 0
except ZeroDivisionError:
    print("错误: 除以零")

您也可以在同一个 except 块中处理多个异常:

try:
    结果 = int("abc")
except (ValueError, TypeError):
    print("错误: 无效的输入")

自定义异常

您可以通过定义继承自内置 Exception 类或其子类的新异常类来创建自己的自定义异常。

class CustomException(Exception):
    pass
 
raise CustomException("这是一个自定义异常")

finally 子句

finally 子句用于确保无论是否引发异常,某个代码块都会被执行。这通常用于清理资源,如关闭文件或连接。

try:
    file = open("example.txt", "r")
    content = file.read()
    print(content)
except FileNotFoundError:
    print("错误: 文件未找到")
finally:
    file.close()

使用面向对象编程 (OOP)

Python 是一种多范式语言,这意味着它同时支持过程式和面向对象编程 (OOP) 风格。OOP 是一种组织和构建代码的强大方式。

##.# 类和对象

在面向对象编程中,你定义类作为创建对象的蓝图。对象是这些类的实例,拥有自己的属性和方法。

class Car:
    def __init__(self, make, model):
        # 初始化汽车的制造商和型号
        self.make = make
        self.model = model
 
    def start(self):
        # 启动汽车
        print(f"Starting the {self.make} {self.model}.")
 
# 创建对象
my_car = Car("Toyota", "Corolla")
my_car.start()  # 输出: Starting the Toyota Corolla.

继承

继承是一种基于现有类创建新类的方式。新类(子类)继承了现有类(父类)的属性和方法。

class ElectricCar(Car):
    def __init__(self, make, model, battery_capacity):
        # 调用父类的初始化方法
        super().__init__(make, model)
        self.battery_capacity = battery_capacity
 
    def charge(self):
        # 为电动汽车充电
        print(f"Charging the {self.make} {self.model} with a {self.battery_capacity}kWh battery.")
 
# 创建子类的对象
my_electric_car = ElectricCar("Tesla", "Model S", 100)
my_electric_car.start()  # 继承自父类
my_electric_car.charge()  # 定义在子类中

多态

多态允许不同类的对象被视为共同父类的对象。这通常通过方法重写来实现。

class Motorcycle:
    def start(self):
        # 启动摩托车
        print("Starting the motorcycle.")
 
class Bicycle:
    def start(self):
        # 开始踩自行车
        print("Starting to pedal the bicycle.")
 
# 多态的应用
vehicles = [Motorcycle(), Bicycle()]
for vehicle in vehicles:
    vehicle.start()

封装

封装是将数据和方法捆绑到单个单元(类)中,并隐藏内部实现细节的概念。这通过访问修饰符(如 publicprivateprotected)来实现。

class BankAccount:
    def __init__(self, owner, balance):
        # 初始化银行账户的所有者和余额
        self.__owner = owner
        self.__balance = balance
```这是一个关于 Python 中私有属性和封装概念的示例代码。以下是中文翻译:
 
```python
# 私有属性
self.__balance = balance  # 私有属性
 
def deposit(self, amount):
    self.__balance += amount
 
def withdraw(self, amount):
    if amount <= self.__balance:
        self.__balance -= amount
    else:
        print("余额不足。")
 
def get_balance(self):
    return self.__balance
 
# 使用 BankAccount 类
account = BankAccount("Alice", 1000)
account.deposit(500)
print(account.get_balance())  # 输出: 1500
account.__balance = 0  # 这将无法生效,因为 __balance 是私有属性

结论

在这个全面的 Python 教程中,我们涵盖了广泛的主题,从处理文件和模块到探索面向对象编程的基础知识。现在,您应该对这些关键概念有了扎实的理解,并正在成为一名熟练的 Python 程序员。

请记住,提高 Python 技能的最佳方式是实践、实验和持续学习。探索更高级的主题,进行个人项目,并参与活跃的 Python 社区。通过专注和坚持,您将能够利用 Python 的强大功能来解决复杂的问题并创造出惊人的应用程序。

祝您编码愉快!

MoeNagy Dev.