Pandas处理大数据的性能优化技巧

本文涉及的产品
云原生大数据计算服务 MaxCompute,5000CU*H 100GB 3个月
云原生大数据计算服务MaxCompute,500CU*H 100GB 3个月
简介: Pandas是Python中最著名的数据分析工具。本文将介绍一些使用Pandas处理大数据时的技巧,希望对你有所帮助

Pandas是Python中最著名的数据分析工具。在处理数据集时,每个人都会使用到它。但是随着数据大小的增加,执行某些操作的某些方法会比其他方法花费更长的时间。所以了解和使用更快的方法非常重要,特别是在大型数据集中,本文将介绍一些使用Pandas处理大数据时的技巧,希望对你有所帮助

数据生成

为了方便介绍,我们生成一些数据作为演示,faker是一个生成假数据的Python包。这里我们直接使用它

 import random
 from faker import Faker
 
 fake = Faker()
 
 car_brands = ["Audi","Bmw","Jaguar","Fiat","Mercedes","Nissan","Porsche","Toyota", None]
 tv_brands = ["Beko", "Lg", "Panasonic", "Samsung", "Sony"]
 
 def generate_record():
     """ generates a fake row
     """
     cid = fake.bothify(text='CID-###')
     name = fake.name()
     age=fake.random_number(digits=2) 
     city = fake.city()
     plate = fake.license_plate()
     job = fake.job()
     company = fake.company()
     employed = fake.boolean(chance_of_getting_true=75)
     social_security = fake.boolean(chance_of_getting_true=90)
     healthcare = fake.boolean(chance_of_getting_true=95)
     iban = fake.iban()
     salary = fake.random_int(min=0, max=99999)
     car = random.choice(car_brands)
     tv = random.choice(tv_brands)
     record = [cid, name, age, city, plate, job, company, employed, 
               social_security, healthcare, iban, salary, car, tv]
     return record
     
     
 record = generate_record()
 print(record)
 
 """
 ['CID-753', 'Kristy Terry', 5877566, 'North Jessicaborough', '988 XEE', 
 'Engineer, control and instrumentation', 'Braun, Robinson and Shaw', 
 True, True, True, 'GB57VOOS96765461230455', 27109, 'Bmw', 'Beko']
 """

我们创建了一个100万行的DF。

 import os
 import pandas as pd
 from multiprocessing import Pool
 
 N= 1_000_000
 
 if __name__ == '__main__':
     cpus = os.cpu_count()
     pool = Pool(cpus-1)
     async_results = []
     for _ in range(N):
         async_results.append(pool.apply_async(generate_record))
     pool.close()
     pool.join()
     data = []
     for i, async_result in enumerate(async_results):
         data.append(async_result.get())
     df = pd.DataFrame(data=data, columns=["CID", "Name", "Age", "City", "Plate", "Job", "Company",
                                      "Employed", "Social_Security", "Healthcare", "Iban", 
                                      "Salary", "Car", "Tv"])

磁盘IO

Pandas可以使用不同的格式保存DF。让我们比较一下这些格式的速度。

 #Write
 
 %timeit df.to_csv("df.csv")
 #3.77 s ± 339 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
 %timeit df.to_pickle("df.pickle")
 #948 ms ± 13.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
 %timeit df.to_parquet("df")
 #2.77 s ± 13 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
 %timeit df.to_feather("df.feather")
 #368 ms ± 19.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
 def write_table(df):
     dtf = dt.Frame(df)
     dtf.to_csv("df_.csv")
 
 %timeit write_table(df)
 #559 ms ± 10.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

 #Read
 
 %timeit df=pd.read_csv("df.csv")
 #1.89 s ± 22.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
 %timeit df=pd.read_pickle("df.pickle")
 #402 ms ± 6.96 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
 %timeit df=pd.read_parquet("df")
 #480 ms ± 3.62 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
 %timeit df=pd.read_feather("df.feather")
 #754 ms ± 8.31 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
 
 def read_table():
     dtf = dt.fread("df.csv")
     df = dtf.to_pandas()
     return df
 
 %timeit df = read_table()
 #869 ms ± 29.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

CSV格式是运行最慢的格式。在这个比较中,我有包含Excel格式(read_excel),因为它更慢,并且还要安装额外的包。

在使用CSV进行的操作中,首先建议使用datatable库将pandas转换为datatable对象,并在该对象上执行读写操作这样可以得到更快的结果。

但是如果数据可控的话建议直接使用pickle 。

数据类型

在大型数据集中,我们可以通过强制转换数据类型来优化内存使用。

例如,通过检查数值特征的最大值和最小值,我们可以将数据类型从int64降级为int8,它占用的内存会减少8倍。

 df.info()
 
 """
 <class 'pandas.core.frame.DataFrame'>
 RangeIndex: 1000000 entries, 0 to 999999
 Data columns (total 14 columns):
  #   Column           Non-Null Count    Dtype 
 ---  ------           --------------    ----- 
  0   CID              1000000 non-null  object
  1   Name             1000000 non-null  object
  2   Age              1000000 non-null  int64 
  3   City             1000000 non-null  object
  4   Plate            1000000 non-null  object
  5   Job              1000000 non-null  object
  6   Company          1000000 non-null  object
  7   Employed         1000000 non-null  bool  
  8   Social_Security  1000000 non-null  bool  
  9   Healthcare       1000000 non-null  bool  
  10  Iban             1000000 non-null  object
  11  Salary           1000000 non-null  int64 
  12  Car              888554 non-null   object
  13  Tv               1000000 non-null  object
 dtypes: bool(3), int64(2), object(9)
 memory usage: 86.8+ MB
 """

我们根据特征的数值范围对其进行相应的转换,例如AGE特征的范围在0到99之间,可以将其数据类型转换为int8。

 #int
 
 df["Age"].memory_usage(index=False, deep=False)
 #8000000
 
 #convert
 df["Age"] = df["Age"].astype('int8')
 
 df["Age"].memory_usage(index=False, deep=False)
 #1000000
 
 #float
 
 df["Salary_After_Tax"] = df["Salary"] * 0.6
 df["Salary_After_Tax"].memory_usage(index=False, deep=False)
 #8000000
 df["Salary_After_Tax"] = df["Salary_After_Tax"].astype('float16')
 df["Salary_After_Tax"].memory_usage(index=False, deep=False)
 #2000000
 
 #categorical
 df["Car"].memory_usage(index=False, deep=False)
 #8000000
 
 df["Car"] = df["Car"].astype('category')
 
 df["Car"].memory_usage(index=False, deep=False)
 #1000364

或者在文件读取过程中直接指定数据类型。

 dtypes = {
     'CID' : 'int32',
     'Name' : 'object',
     'Age' : 'int8',
     ...
 }
 dates=["Date Columns Here"]
 
 df = pd.read_csv(dtype=dtypes, parse_dates=dates)

查询过滤

常规过滤方法:

 %timeit df_filtered = df[df["Car"] == "Mercedes"]
 #61.8 ms ± 2.55 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

对于分类特征,我们可以使用pandas的group_by和get_group方法。

%timeit df.groupby("Car").get_group("Mercedes")
#92.1 ms ± 4.38 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

df_grouped = df.groupby("Car")
%timeit df_grouped.get_group("Mercedes")
#14.8 ms ± 167 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

分组的操作比正常应用程序花费的时间要长。如果要对分类特征进行很多过滤操作,例如在本例中,如果我们从头进行分组,并且只看get_group部分的执行时间,我们将看到该过程实际上比常规方法更快。也就是说,对于重复的过滤操作,我们可以首选此方法(get_group)。

计数

Value_counts方法比groupby和following size方法更快。

%timeit df["Car"].value_counts()
#49.1 ms ± 378 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
"""
Toyota      111601
Porsche     111504
Jaguar      111313
Fiat        111239
Nissan      110960
Bmw         110906
Audi        110642
Mercedes    110389
Name: Car, dtype: int64
"""

%timeit df.groupby("Car").size()
#64.5 ms ± 37.9 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
"""
Car
Audi        110642
Bmw         110906
Fiat        111239
Jaguar      111313
Mercedes    110389
Nissan      110960
Porsche     111504
Toyota      111601
dtype: int64
"""

迭代

在大容量数据集上迭代需要很长时间。所以有必要在这方面选择最快的方法。我们可以使用Pandas的iterrows和itertuples方法,让我们将它们与常规的for循环实现进行比较。

def foo_loop(df):
    total = 0
    for i in range(len(df)):
        total += df.iloc[i]['Salary']
    return total

%timeit foo_loop(df)
#34.6 s ± 593 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

def foo_iterrows(df):
    total = 0
    for index, row in df.iterrows():
        total += row['Salary']
    return total

%timeit foo_iterrows(df)
#22.7 s ± 761 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

def foo_itertuples(df):
    total = 0
    for row in df.itertuples(): 
        total += row[12]
    return total

%timeit foo_itertuples(df)
#1.22 s ± 14.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Iterrows方法比for循环更快,但itertuples方法是最快的。

另外就是Apply方法允许我们对DF中的序列执行任何函数。

def foo(val):
    if val > 50000:
        return "High"
    elif val <= 50000 and val > 10000:
        return "Mid Level"
    else:
        return "Low"

df["Salary_Category"] = df["Salary"].apply(foo)
print(df["Salary_Category"])
"""
0              High
1              High
2         Mid Level
3              High
4               Low
            ...    
999995         High
999996          Low
999997         High
999998         High
999999    Mid Level
Name: Salary_Category, Length: 1000000, dtype: object
"""

%timeit df["Salary_Category"] = df["Salary"].apply(foo)
#112 ms ± 50.6 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

def boo():
    liste = []
    for i in range(len(df)):
        val = foo(df.loc[i,"Salary"])
        liste.append(val)
    df["Salary_Category"] = liste

%timeit boo()
#5.73 s ± 130 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

而map方法允许我们根据给定的函数替换一个Series中的每个值。

print(df["Salary_Category"].map({'High': "H", "Mid Level": "M", "Low": "L"}))
"""
0         H
1         H
2         M
3         H
4         L
         ..
999995    H
999996    L
999997    H
999998    H
999999    M
Name: Salary_Category, Length: 1000000, dtype: object
"""

print(df["Salary_Category"].map("Salary Category is {}".format))
"""
0              Salary Category is High
1              Salary Category is High
2         Salary Category is Mid Level
3              Salary Category is High
4               Salary Category is Low
                      ...             
999995         Salary Category is High
999996          Salary Category is Low
999997         Salary Category is High
999998         Salary Category is High
999999    Salary Category is Mid Level
Name: Salary_Category, Length: 1000000, dtype: object
"""

df["Salary_Category"] = df["Salary"].map(foo)
print(df["Salary_Category"])
"""
0              High
1              High
2         Mid Level
3              High
4               Low
            ...    
999995         High
999996          Low
999997         High
999998         High
999999    Mid Level
Name: Salary_Category, Length: 1000000, dtype: object

让我们比较一下标对salary 列进行标准化工时每一中迭代方法的时间吧。

min_salary = df["Salary"].min()
max_salary = df["Salary"].max()

def normalize_for_loc(df, min_salary, max_salary):
    normalized_salary = np.zeros(len(df, ))
    for i in range(df.shape[0]):
        normalized_salary[i] = (df.loc[i, "Salary"] - min_salary) / (max_salary - min_salary)
    df["Normalized_Salary"] = normalized_salary
    return df

%timeit normalize_for_loc(df, min_salary, max_salary)
#5.45 s ± 15.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

def normalize_for_iloc(df, min_salary, max_salary):
    normalized_salary = np.zeros(len(df, ))
    for i in range(df.shape[0]):
        normalized_salary[i] = (df.iloc[i, 11] - min_salary) / (max_salary - min_salary)
    df["Normalized_Salary"] = normalized_salary
    return df

%timeit normalize_for_iloc(df, min_salary, max_salary)
#13.8 s ± 29.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

def normalize_for_iloc(df, min_salary, max_salary):
    normalized_salary = np.zeros(len(df, ))
    for i in range(df.shape[0]):
        normalized_salary[i] = (df.iloc[i]["Salary"] - min_salary) / (max_salary - min_salary)
    df["Normalized_Salary"] = normalized_salary
    return df

%timeit normalize_for_iloc(df, min_salary, max_salary)
#34.8 s ± 108 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

def normalize_for_iterrows(df, min_salary, max_salary):
    normalized_salary = np.zeros(len(df, ))
    i = 0
    for index, row in df.iterrows():
        normalized_salary[i] = (row["Salary"] - min_salary) / (max_salary - min_salary)
        i += 1
    df["Normalized_Salary"] = normalized_salary
    return df

%timeit normalize_for_iterrows(df, min_salary, max_salary)
#21.7 s ± 53.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

def normalize_for_itertuples(df, min_salary, max_salary):
    normalized_salary = list()
    for row in df.itertuples():
        normalized_salary.append((row[12] - min_salary) / (max_salary - min_salary))
    df["Normalized_Salary"] = normalized_salary
    return df

%timeit normalize_for_itertuples(df, min_salary, max_salary)
#1.34 s ± 4.29 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

def normalize_map(df, min_salary, max_salary):
    df["Normalized_Salary"] = df["Salary"].map(lambda x: (x - min_salary) / (max_salary - min_salary))
    return df

%timeit normalize_map(df, min_salary, max_salary)
#178 ms ± 970 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

def normalize_apply(df, min_salary, max_salary):
    df["Normalized_Salary"] = df["Salary"].apply(lambda x: (x - min_salary) / (max_salary - min_salary))
    return df
%timeit normalize_apply(df, min_salary, max_salary)
#182 ms ± 1.83 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

def normalize_vectorization(df, min_salary, max_salary):
    df["Normalized_Salary"] = (df["Salary"] - min_salary) / (max_salary - min_salary)
    return df

%timeit normalize_vectorization(df, min_salary, max_salary)
#1.58 ms ± 7.87 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

可以看到:

loc比iloc快。

  • 如果你要使用iloc,那么最好使用这样df.iloc[i, 11]的格式。
  • Itertuples比loc更好,iterrows确差不多。
  • Map和apply是第二种更快的选择。
  • 向量化的操作是最快的。

向量化

向量化操作需要定义一个向量化函数,该函数接受嵌套的对象序列或numpy数组作为输入,并返回单个numpy数组或numpy数组的元组。

def foo(val, min_salary, max_salary):
    return (val - min_salary) / (max_salary - min_salary)

foo_vectorized = np.vectorize(foo)
%timeit df["Normalized_Salary"] = foo_vectorized(df["Salary"], min_salary, max_salary)
#154 ms ± 310 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

#conditional
%timeit df["Old"] = (df["Age"] > 80)
#140 µs ± 11.8 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

#isin
%timeit df["Old"] = df["Age"].isin(range(80,100))
#17.4 ms ± 466 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

#bins with digitize
%timeit df["Age_Bins"] = np.digitize(df["Age"].values, bins=[0, 18, 36, 54, 72, 100])
#12 ms ± 107 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
print(df["Age_Bins"])
"""
0         3
1         5
2         4
3         3
4         5
         ..
999995    4
999996    2
999997    3
999998    1
999999    1
Name: Age_Bins, Length: 1000000, dtype: int64
"""

索引

使用.at方法比使用.loc方法更快。

%timeit df.loc[987987, "Name"]
#5.05 µs ± 33.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit df.at[987987, "Name"]
#2.39 µs ± 23.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Swifter

Swifter是一个Python包,它可以比常规的apply方法更有效地将任何函数应用到DF。

!pip install swifter
import swifter

#apply
%timeit df["Normalized_Salary"] = df["Salary"].apply(lambda x: (x - min_salary) / (max_salary - min_salary))
#192 ms ± 9.08 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

#swifter.apply
%timeit df["Normalized_Salary"] = df["Salary"].swifter.apply(lambda x: (x - min_salary) / (max_salary - min_salary))
#83.5 ms ± 478 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

总结

如果可以使用向量化,那么任何操作都应该优先使用它。对于迭代操作可以优先使用itertuples、apply或map等方法。还有一些单独的Python包,如dask、vaex、koalas等,它们都是构建在pandas之上或承担类似的功能,也可以进行尝试。

https://avoid.overfit.cn/post/d38401bd97e2442d89a9099ec260bfac

作者:Okan Yenigün

相关实践学习
基于MaxCompute的热门话题分析
本实验围绕社交用户发布的文章做了详尽的分析,通过分析能得到用户群体年龄分布,性别分布,地理位置分布,以及热门话题的热度。
SaaS 模式云数据仓库必修课
本课程由阿里云开发者社区和阿里云大数据团队共同出品,是SaaS模式云原生数据仓库领导者MaxCompute核心课程。本课程由阿里云资深产品和技术专家们从概念到方法,从场景到实践,体系化的将阿里巴巴飞天大数据平台10多年的经过验证的方法与实践深入浅出的讲给开发者们。帮助大数据开发者快速了解并掌握SaaS模式的云原生的数据仓库,助力开发者学习了解先进的技术栈,并能在实际业务中敏捷的进行大数据分析,赋能企业业务。 通过本课程可以了解SaaS模式云原生数据仓库领导者MaxCompute核心功能及典型适用场景,可应用MaxCompute实现数仓搭建,快速进行大数据分析。适合大数据工程师、大数据分析师 大量数据需要处理、存储和管理,需要搭建数据仓库?学它! 没有足够人员和经验来运维大数据平台,不想自建IDC买机器,需要免运维的大数据平台?会SQL就等于会大数据?学它! 想知道大数据用得对不对,想用更少的钱得到持续演进的数仓能力?获得极致弹性的计算资源和更好的性能,以及持续保护数据安全的生产环境?学它! 想要获得灵活的分析能力,快速洞察数据规律特征?想要兼得数据湖的灵活性与数据仓库的成长性?学它! 出品人:阿里云大数据产品及研发团队专家 产品 MaxCompute 官网 https://www.aliyun.com/product/odps&nbsp;
目录
相关文章
|
2月前
|
存储 大数据 测试技术
用于大数据分析的数据存储格式:Parquet、Avro 和 ORC 的性能和成本影响
在大数据环境中,数据存储格式直接影响查询性能和成本。本文探讨了 Parquet、Avro 和 ORC 三种格式在 Google Cloud Platform (GCP) 上的表现。Parquet 和 ORC 作为列式存储格式,在压缩和读取效率方面表现优异,尤其适合分析工作负载;Avro 则适用于需要快速写入和架构演化的场景。通过对不同查询类型(如 SELECT、过滤、聚合和联接)的基准测试,本文提供了在各种使用案例中选择最优存储格式的建议。研究结果显示,Parquet 和 ORC 在读取密集型任务中更高效,而 Avro 更适合写入密集型任务。正确选择存储格式有助于显著降低成本并提升查询性能。
383 1
用于大数据分析的数据存储格式:Parquet、Avro 和 ORC 的性能和成本影响
|
7天前
|
机器学习/深度学习 存储 数据采集
大数据性能优化
【10月更文挑战第24天】
39 3
|
2月前
|
存储 大数据 数据挖掘
【数据新纪元】Apache Doris:重塑实时分析性能,解锁大数据处理新速度,引爆数据价值潜能!
【9月更文挑战第5天】Apache Doris以其卓越的性能、灵活的架构和高效的数据处理能力,正在重塑实时分析的性能极限,解锁大数据处理的新速度,引爆数据价值的无限潜能。在未来的发展中,我们有理由相信Apache Doris将继续引领数据处理的潮流,为企业提供更快速、更准确、更智能的数据洞察和决策支持。让我们携手并进,共同探索数据新纪元的无限可能!
136 11
|
3月前
|
分布式计算 数据可视化 大数据
Vaex :突破pandas,快速分析100GB大数据集
Vaex :突破pandas,快速分析100GB大数据集
|
3月前
|
消息中间件 大数据 Kafka
"Apache Flink:重塑大数据实时处理新纪元,卓越性能与灵活性的实时数据流处理王者"
【8月更文挑战第10天】Apache Flink以卓越性能和高度灵活性在大数据实时处理领域崭露头角。它打破批处理与流处理的传统界限,采用统一模型处理有界和无界数据流,提升了开发效率和系统灵活性。Flink支持毫秒级低延迟处理,通过时间窗口、状态管理和自动并行化等关键技术确保高性能与可靠性。示例代码展示了如何使用Flink从Kafka读取实时数据并进行处理,简明扼要地呈现了Flink的强大能力。随着技术进步,Flink将在更多场景中提供高效可靠的解决方案,持续引领大数据实时处理的发展趋势。
102 7
|
3月前
|
前端开发 大数据 数据库
🔥大数据洪流下的决战:JSF 表格组件如何做到毫秒级响应?揭秘背后的性能魔法!💪
【8月更文挑战第31天】在 Web 应用中,表格组件常用于展示和操作数据,但在大数据量下性能会成瓶颈。本文介绍在 JavaServer Faces(JSF)中优化表格组件的方法,包括数据处理、分页及懒加载等技术。通过后端分页或懒加载按需加载数据,减少不必要的数据加载和优化数据库查询,并利用缓存机制减少数据库访问次数,从而提高表格组件的响应速度和整体性能。掌握这些最佳实践对开发高性能 JSF 应用至关重要。
65 0
|
4月前
|
分布式计算 大数据 Spark
Spark大数据处理:技术、应用与性能优化(全)PDF书籍推荐分享
《Spark大数据处理:技术、应用与性能优化》深入浅出介绍Spark核心,涵盖部署、实战与性能调优,适合初学者。作者基于微软和IBM经验,解析Spark工作机制,探讨BDAS生态,提供实践案例,助力快速掌握。书中亦讨论性能优化策略。[PDF下载链接](https://zhangfeidezhu.com/?p=347)。![Spark Web UI](https://img-blog.csdnimg.cn/direct/16aaadbb4e13410f8cb2727c3786cc9e.png#pic_center)
145 1
Spark大数据处理:技术、应用与性能优化(全)PDF书籍推荐分享
|
3月前
|
大数据 RDMA
神龙大数据加速引擎MRACC问题之MRACC-Spark利用eRDMA近网络优化插件来提升性能如何解决
神龙大数据加速引擎MRACC问题之MRACC-Spark利用eRDMA近网络优化插件来提升性能如何解决
40 0
|
4月前
|
存储 分布式计算 大数据
Pandas能处理大数据吗?
【7月更文挑战第9天】Pandas能处理大数据吗?
52 8
|
4月前
|
机器学习/深度学习 数据采集 大数据
驾驭大数据洪流:Pandas与NumPy在高效数据处理与机器学习中的核心作用
【7月更文挑战第13天】在大数据时代,Pandas与NumPy是Python数据分析的核心,用于处理复杂数据集。在一个电商销售数据案例中,首先使用Pandas的`read_csv`加载CSV数据,通过`head`和`describe`进行初步探索。接着,数据清洗涉及填充缺失值和删除异常数据。然后,利用`groupby`和`aggregate`分析销售趋势,并用Matplotlib可视化结果。在机器学习预处理阶段,借助NumPy进行数组操作,如特征缩放。Pandas的数据操作便捷性与NumPy的数值计算效率,共同助力高效的数据分析和建模。
83 3