Python教程：Pandas中有效处理大数据集的6种方法

Pandas是一个强大的Python数据操作包，经常用于涉及数据分析和修改的工作。然而，标准的Pandas程序在处理大型数据集时可能会变得资源密集且效率低下。这篇文章中研究在Pandas中有效处理大数据集的方法。

处理大型数据集的问题
Pandas在处理小型数据集时是一个很好的工具，通常上限在2到3GB之间。对于大于此阈值的数据集，不建议使用Pandas。这是因为，如果数据集大小超过可用RAM，Pandas会在处理之前将完整的数据集加载到内存中。即使是较小的数据集也会出现内存问题，因为预处理和修改会创建DataFrame的副本。

尽管存在这些缺点，但通过使用特定的方法，Pandas可以用于在Python中处理更大的数据集。这些技术可以让你使用Pandas来分析数百万条记录，并在Python中有效地管理庞大的数据集。

如何在Python中处理大型数据集？
使用高效的数据类型：使用更高效的内存数据类型（例如，int 32代替int 64，float 32代替float 64）以减少内存使用。

加载较少的数据：例如使用pd.read_csv()中的usecols参数只加载必要的列，从而减少内存消耗。

采样：对于探索性数据分析或测试，请考虑使用数据集的样本而不是整个数据集。

分块：使用pd.read_csv()中的chunksize参数以较小的块读取数据集，迭代地处理每个块。

优化Pandas dtypes：在加载数据后，如果合适的话，使用astype方法将列转换为内存效率更高的类型。

使用Dask库：使用Dask，一个并行计算库，通过利用并行处理将Pandas工作流扩展到更大内存的数据集。

1. 使用高效的数据类型

在Pandas中减少内存使用需要使用高效的数据类型。例如，如果精度允许，可以使用float32甚至float16来代替标准的float64 dtype。与此类似，如果数据范围允许，整数列可以向下转换为更小的整数类型，如int8、int16或int32。
优点：显著减少内存占用，特别是对于大型数据集。
实现：当阅读数据时，可以使用pd.read_csv（）或pd.read_sql（）等函数来指定dtype参数。此外，可以使用astype（）方法将现有列更改为更节省内存的类型。

示例：

import pandas as pd

# Define the size of the dataset
num_rows = 1000000  # 1 million rows

# Example DataFrame with inefficient datatypes
data = {'A': [1, 2, 3, 4],
        'B': [5.0, 6.0, 7.0, 8.0]}
df = pd.DataFrame(data)

# Replicate the DataFrame to create a larger dataset
df_large = pd.concat([df] * (num_rows // len(df)), ignore_index=True)

# Check memory usage before conversion
print("Memory usage before conversion:")
print(df_large.memory_usage().sum())

# Convert to more memory-efficient datatypes
df_large['A'] = pd.to_numeric(df_large['A'], downcast='integer')
df_large['B'] = pd.to_numeric(df_large['B'], downcast='float')

# Check memory usage after conversion
print("Memory usage after conversion:")
print(df_large.memory_usage().sum())
输出

Memory usage before conversion:
16000128
Memory usage after conversion:
5000128
2. 加载较少的数据

概述：这种技术只需要从数据集中加载相关列。这在处理具有大量列的数据集或分析仅需要一部分数据时特别有用。
优点：提高处理效率，使用更少的内存。
实现：要选择要加载的列，请在诸如pd.read_csv()之类中使用usecols参数。

import pandas as pd

# Create sample DataFrame
data = {'A': range(1000),
        'B': range(1000), 
        'C': range(1000), 
        'D': range(1000)}

# Load only specific columns
df = pd.DataFrame(data)
df_subset = df[['A', 'D']]
print('Specific Columns of the DataFrame')
print(df_subset.head())
输出

Specific Columns of the DataFrame
   A  D
0  0  0
1  1  1
2  2  2
3  3  3
4  4  4
3. 采样

采样是随机选择数据集的数据进行检查的过程。这可以用来快速分析数据集，探索它，或使用数据的代表性样本创建模型。
优点：使分析和实验更快，特别是在处理大数据集时。
实现：要从DataFrame中随机选择行或列，请使用Pandas的sample()方法。

import pandas as pd

# Create sample DataFrame
data = {'A': range(1000),
        'B': range(1000), 
        'C': range(1000), 
        'D': range(1000)}

# Sample 10% of the dataset
df = pd.DataFrame(data)
df_sample = df.sample(frac=0.1, random_state=42)
print(df_sample.head())
输出

       A    B    C    D
521  521  521  521  521
737  737  737  737  737
740  740  740  740  740
660  660  660  660  660
411  411  411  411  411
4. 分块

分块不是一次将完整的数据集加载到内存中，而是需要将数据集分成更小、更易于管理的部分进行处理。当处理太大而无法容纳在内存中的数据集时，这非常有用。
优点：在内存有限的设备上处理庞大的数据集，并使用更少的内存。
实现：要指定一次读取的行数，请在pd.read_csv()中使用chunksize参数。

import pandas as pd

# Create sample DataFrame
data = {'A': range(10000),
        'B': range(10000)}

# Process data in chunks
chunk_size = 1000
for chunk in pd.DataFrame(data).groupby(pd.DataFrame(data).index // chunk_size):
    print(chunk)
输出

(0,        A    B
0      0    0
1      1    1
2      2    2
3      3    3
4      4    4
..   ...  ...
995  995  995
996  996  996
997  997  997
998  998  998
999  999  999

[1000 rows x 2 columns])
(1,          A     B
1000  1000  1000
1001  1001  1001
1002  1002  1002
1003  1003  1003
1004  1004  1004
...    ...   ...
1995  1995  1995
1996  1996  1996
1997  1997  1997
1998  1998  1998
1999  1999  1999

[1000 rows x 2 columns])
(2,          A     B
2000  2000  2000
2001  2001  2001
2002  2002  2002
2003  2003  2003
2004  2004  2004
...    ...   ...
2995  2995  2995
2996  2996  2996
2997  2997  2997
2998  2998  2998
2999  2999  2999

[1000 rows x 2 columns])
(3,          A     B
3000  3000  3000
3001  3001  3001
3002  3002  3002
3003  3003  3003
3004  3004  3004
...    ...   ...
3995  3995  3995
3996  3996  3996
3997  3997  3997
3998  3998  3998
3999  3999  3999
5. 优化Pandas dtypes

查找数据类型不尽可能高效的列，并将其更改为可以保存更多内存的列。性能可以大大提高，内存利用率可以大大降低。
优点：提高处理速度并最大限度地减少内存占用。
实现：要将列转换为更有效的数据类型，请使用astype()方法。要将列分别转换为datetime或numeric类型，请使用pd.to_datetime()或pd.to_numeric()等函数。

import pandas as pd

# Create sample DataFrame
data = {'date_column': ['2022-01-01', '2022-01-02', '2022-01-03'],
        'numeric_column': [1.234, 2.345, 3.456]}

df = pd.DataFrame(data)

# Convert inefficient dtypes
df['date_column'] = pd.to_datetime(df['date_column'])
df['numeric_column'] = pd.to_numeric(df['numeric_column'], downcast='float')

print(df.dtypes)
输出

date_column       datetime64[ns]
numeric_column           float32
dtype: object
6. 使用Dask库

Dask是一个用于并行计算的软件包，它可以很好地与Pandas配合使用，并为大数据集提供并行化操作。您的Pandas工作流可以在它的帮助下跨多个核心甚至分布式集群进行扩展。
优点：允许并行执行Pandas操作，大大减少了大型数据集的处理时间。
实现：要在大型数据集上执行并行操作，请使用Dask数据结构，如dask.DataFrame和dask.array。Dask通过支持大多数著名的Pandas API，促进了当前代码库到并行执行的平滑传输。

import dask.dataframe as dd
import pandas as pd

# Create sample DataFrame
data = {'A': range(10000),
        'B': range(10000)}

df = pd.DataFrame(data)

# Load data using Dask
ddf = dd.from_pandas(df, npartitions=4)

# Perform parallelized operations
result = ddf.groupby('A').mean().compute()
print(result)
输出

           B
A           
0        0.0
1        1.0
2        2.0
3        3.0
4        4.0
...      ...
9995  9995.0
9996  9996.0
9997  9997.0
9998  9998.0
9999  9999.0

[10000 rows x 1 columns]

以上就是“Python教程：Pandas中有效处理大数据集的6种方法”的详细内容，想要了解更多Python教程欢迎持续关注编程学习网。