1

我正在编写一个 Python 脚本（使用 Python 3.2），在某些时候需要为字典中的每个键通过大约 800.000 行的文件。键的数量约为 150.000。文件中的行是以下格式的字典：

{'url': 'http://address.com/document/42/1998', 'referrer': 'http://address.com/search?&q=query1', 'session': '1', 'rank': 2, 'time': 1338447254}
{'url': 'http://address.com/document/55/17', 'referrer': 'http://address.com/search&q=query2', 'session': '1', 'rank': 2, 'time': 13384462462}

对于此文件中的每一行，我需要进行一些计算并存储结果。为了能够阅读字典并使用它，我使用 eval。这将导致 120.000.000.000 次调用 eval，这需要很长时间。因此，我正在寻找一种优化方法。

欢迎您提出所有可能的优化建议。每一点都可能会产生影响，但我主要对 eval 和我读取文件的方式感兴趣。自动取款机。我在想其他一些 eval 可能执行得更快的方法，但是我不能让 JSON 读取格式并且使用 split 的结果还不是很好。我从文件中读取的方式也可能会被优化。我已经尝试了以下代码中的方法，以及“with”（速度慢得多，但消耗的内存更少）。我还尝试使用 map 读取内存中的文件：

f_chunk = map(eval, codecs.open(chunk_file, "r", encoding="utf-8").readlines())

但这也不起作用。

无论如何，脚本的以下部分是沉重的。它在多个进程中运行：

def mine(id, tmp_sessions, chunk_file, work_q, result_q, init_qsize):
    #f_chunk = map(eval, codecs.open(chunk_file, "r", encoding="utf-8").readlines())
    f_chunk = codecs.open(chunk_file, "r", encoding="utf-8").readlines()

    while True:
        try:

            k = work_q.get()
            if k == 'STOP':

                work_q.task_done()
                break # reached end of queue

        except Queue.Empty:
            break

        #with codecs.open(chunk_file, "r", encoding="utf-8") as f_chunk:
        for line in f_chunk:
            #try:
            jlog_nest = dict()
            jlog_nest = eval(line)

            #jlog_nest = json.loads(line)
            #jlog_nest = line
            #jlog_nest = defaultdict(line)


            if jlog_nest["session"] == k: # If session is the same
                query_nest = prepare_test_cases_lib.extract_query(jlog_nest["referrer"])

                for q in tmp_sessions[k]:

                    if q[0] == query_nest:
                        url = jlog_nest["url"]
                        rank = jlog_nest["rank"]
                        doc_id = prepare_test_cases_lib.extract_document_id(url)

                        # Increase number of hits on that document, and save its rank
                        if doc_id in q[1]:
                            q[1][doc_id][0] += 1
                            q[1][doc_id][1].append(rank)
                        else:
                            q[1][doc_id] = [1, [rank]]
            #except:
            #    print ("error",k)

        result_q.put((k, tmp_sessions[k]))
        work_q.task_done()

如果它有助于理解在上面的代码运行之前发生了什么，tmp_session 可能看起来像这样：

tmp_sessions: {'39': [['q7', {}], ['q2', {}]], '40': [['q2', {}]]}

之后：

tmp_sessions: {'39': [['q7', {}], ['q2', {'133378': [1, [2]]}]], '40': [['q2', {'133378': [1, [2]]}]]}

在真实数据的子集上，我运行 pstats 文件中有 562 个键和 2232 行，按时间降序排序（这只是顶部）：

1284892 function calls in 76.810 seconds

Ordered by: cumulative time

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     8    0.000    0.000   77.985    9.748 {built-in method exec}
     8    1.607    0.201   77.978    9.747 prepare_hard_test_cases.py:29(mine)
1254384   75.051    0.000   76.220    0.000 {built-in method eval}
   562    0.008    0.000    0.050    0.000 queues.py:99(put)
     8    0.000    0.000    0.029    0.004 codecs.py:685(readlines)

由此看来，确实是 eval 占用了时间。

编辑：正如我所建议的那样，我尝试使用literal_eval。我实际上发现这是试图找到解决方案，但认为它与 eval 相同。我刚跑了。它确实产生了相同的结果，但运行时间非常糟糕：

 50205868 function calls (37662028 primitive calls) in 121.494 seconds

 Ordered by: cumulative time

 ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      8    0.001    0.000  121.494   15.187 {built-in method exec}
      8    0.008    0.001  121.493   15.187 <string>:1(<module>)
      8    4.935    0.617  121.485   15.186 prepare_hard_test_cases.py:29(mine)
1254384    5.088    0.000  116.425    0.000 ast.py:39(literal_eval)
1254384    1.098    0.000   71.432    0.000 ast.py:31(parse)
1254384   70.333    0.000   70.333    0.000 {built-in method compile}
13798224/1254384   22.996    0.000   39.336    0.000 ast.py:51(_convert)
7526304    8.539    0.000   23.042    0.000 ast.py:63(<genexpr>)
25087680    8.371    0.000    8.371    0.000 {built-in method isinstance}
    8    0.001    0.000    0.047    0.006 codecs.py:685(readlines)

编辑2：我现在尝试了两种新方法。第一个是通过从每一行手动提取键和值，构造一个字典来处理。这在我的测试集上运行得更快一些：

51460252 function calls in 45.207 seconds

 Ordered by: cumulative time

 ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      8    0.001    0.000   45.207    5.651 {built-in method exec}
      8    0.003    0.000   45.207    5.651 <string>:1(<module>)
      8    1.701    0.213   45.203    5.650 prepare_hard_test_cases.py:68(mine)
1254384    5.725    0.000   43.391    0.000 prepare_hard_test_cases.py:36(extractDict)
6271920   23.433    0.000   37.665    0.000 prepare_hard_test_cases.py:20(extractKeyValue)
18819074   11.308    0.000   11.308    0.000 {method 'find' of 'str' objects}
25092651    2.927    0.000    2.927    0.000 {built-in method len}

这是个好消息，但更好的是我使用 pickle 的第二种方法。现在我得到：

30091 function calls in 5.285 seconds

Ordered by: cumulative time

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     8    0.000    0.000    5.285    0.661 {built-in method exec}
     8    0.003    0.000    5.285    0.661 <string>:1(<module>)
     8    0.173    0.022    5.281    0.660 prepare_hard_test_cases.py:68(mine)
   570    0.001    0.000    5.057    0.009 queues.py:113(get)
  2281    3.925    0.002    3.925    0.002 {method 'acquire' of '_multiprocessing.SemLock' objects}
   570    1.133    0.002    1.133    0.002 {method 'recv' of '_multiprocessing.PipeConnection' objects}
     8    0.029    0.004    0.029    0.004 {built-in method load}

当我有时间时，我会尝试将这种方法应用于全套。

有什么建议么？

最好的问候，卡斯帕

4

1 回答 1

3

你应该ast.literal_eval()试一试，它是为这项工作而设计的，而且可能会更快。

eval()速度慢，不安全，通常是个坏主意。如果您认为自己需要它，请环顾四周，我向您保证，您 99.99% 的时间都不需要它。

另请注意：

f_chunk = codecs.open(chunk_file, "r", encoding="utf-8").readlines()
...

真的应该是：

with open(chunk_file, "r", encoding="utf-8") as f_chunk:
    ...

文件是迭代器，因此使用readlines()只会降低程序的内存效率。使用with可确保您的文件在完成后正确关闭（就像您在 3.x 中一样，您可以使用open()而不是codecs.open()因为它已更新以支持后者的额外功能）。

除此之外，据我所知，您的每一行数据都应该是有效的 JSON，因此该json模块也应该可以工作。

于 2013-03-14T13:02:34.690 回答