Question

我有一个pandas数据框，每行我想执行一个函数。但是，该功能包括对远程服务器的I / O调用，因此，如果我仅对数据帧使用.apply()来调用它，就会非常慢。

这里是一个例子：

def f(data):
    r = requests.get(data["url"])
    x = process(r.content)
    y = process_2(r.content)
    z = process_3(r.content)
    print("Done")

    return [x, y, z]

df.apply(lambda x: f(x), axis=1)

在此代码中，问题是requests.get(data["url"])需要一段时间，因此整个apply()函数的完成速度非常慢。 print()每隔几秒钟就会打印在控制台上。

是否可以异步执行apply()函数并更快地获得结果？我的数据框有5,000多行，对每个原始数据的函数调用应花费几秒钟。

Answer 1

异步I / O 方法与著名的asyncio + aiohttp库：

在示例数据框和简单的网页内容处理例程上进行了演示（以展示该方法的原理）。
假设我们需要通过所有 url 计算所有 header ， link （<a>）和 span 标签>并将结果计数器存储在源数据帧中。

import pandas as pd
import asyncio
import aiohttp
from bs4 import BeautifulSoup


def count_headers(html):
    return len(list(html.select('h1,h2,h3,h4,h5,h6')))

def count_links(html):
    return len(list(html.find_all('a')))

def count_spans(html):
    return len(list(html.find_all('spans')))


df = pd.DataFrame({'id': [1, 2, 3], 'url': ['https://stackoverflow.com/questions',
                                            'https://facebook.com',
                                            'https://wiki.archlinux.org']})
df['head_c'], df['link_c'], df['span_c'] = [None, None, None]
# print(df)

async def process_url(df, url):
    async with aiohttp.ClientSession() as session:
        resp = await session.get(url)
        content = await resp.text()
        soup = BeautifulSoup(content, 'html.parser')
        headers_count = count_headers(soup)
        links_count = count_links(soup)
        spans_count = count_spans(soup)
        print("Done")

        df.loc[df['url'] == url, ['head_c', 'link_c', 'span_c']] = \
            [[headers_count, links_count, spans_count]]


async def main(df):
    await asyncio.gather(*[process_url(df, url) for url in df['url']])
    print(df)


loop = asyncio.get_event_loop()
loop.run_until_complete(main(df))
loop.close()

输出：

Done
Done
Done
   id                                  url  head_c  link_c  span_c
0   1  https://stackoverflow.com/questions      25     306       0
1   2                 https://facebook.com       3      55       0
2   3           https://wiki.archlinux.org      15      91       0

享受性能差异。

Answer 2

如果不更清楚地描述正在使用的数据，很难确切地知道您想做什么以及什么是最好的。

import multiprocessing

def process_data(iterrow_row):
    row_idx, data = iterrow_row
    r = requests.get(data["url"])
    x = process(r.content)
    y = process_2(r.content)
    z = process_3(r.content)
    print("Done")

    return row_idx, [x, y, z]

mpool = multiprocessing.Pool(processes=20, maxtasksperchild=100)

for row_name, result in mpool.imap(process_data, df.iterrows()):
    pass # pack up the processed data

这是我所知道的使您的问题并行化的最简单方法。如果您更喜欢线程而不是派生的进程，则可能还可以使用ThreadPool。为此，dask的实现将是很多不必要的工作。

Answer 3

优化 Pandas 应用的另一个想法是使用 Swifter https://github.com/jmcarpenter2/swifter

Answer 4

使用 dask 的解决方案很简单：

import dask.dataframe as dd

npartitions = 24
dd.from_pandas(df, npartitions=npartitions).apply(lambda x: f(x), meta=list, axis=1).compute()

一个更常见的用例可能是应用函数返回一个数据帧。为此，您希望在您的函数中 return pd.Series({'x': x, 'y': y, 'z': z}) 然后通过例如meta={'x': float, 'y': float, 'z': float} 到 apply。

我可以异步执行“应用于”熊猫数据帧中的函数吗？

4 个答案: