Производительность соединения строки python

В Интернете много статей о производительности питона, первое, что вы читаете: конкатенировать строки не следует, используя «+»: избегать s1 + s2 + s3, вместо этого использовать str.join

Я пробовал следующее: конкатенация двух строк как часть пути к каталогу: три подхода:

  1. '+', который я не должен делать
  2. str.join
  3. os.path.join

Вот мой код:

import os,time s1='/part/one/of/dir' s2='part/two/of/dir' N=10000 t=time.clock() for i in xrange(N): s=s1+os.sep+s2 print time.clock()-t t=time.clock() for i in xrange(N): s=os.sep.join((s1,s2)) print time.clock()-t t=time.clock() for i in xrange(N): s=os.path.join(s1,s2) print time.clock()-t 

Здесь результаты (python 2.5 WinXP)

 0.0182201927899 0.0262544541275 0.120238186697 

Разве это не должно быть наоборот?

  • Файл .py, который скомпилирован из файла .qrc (с использованием pyside-rcc), не работает
  • Python не может открыть файл с неанглийскими символами в пути
  • Как вы можете создать кнопку формы для выбора файла Django?
  • Автоматический отступ для Python в Notepad ++
  • Разбор даты, которая может быть в нескольких форматах в python
  • моделирование движения толпы с помощью matplotlib
  • Разница между типом данных 'datetime64 ' и '<M8 '?
  • Ошибка pyspark: AttributeError: объект 'SparkSession' не имеет атрибута 'parallelize'
  • 6 Solutions collect form web for “Производительность соединения строки python”

    Правда, вы не должны использовать «+». Ваш пример довольно особенный, попробуйте тот же код:

     s1='*'*100000 s2='+'*100000 

    Затем вторая версия (str.join) выполняется намного быстрее.

    Большинство проблем производительности при конкатенации строк являются характеристиками асимптотической производительности, поэтому различия становятся наиболее значительными, когда вы объединяете многие длинные строки. В вашем примере вы выполняете одну и ту же конкатенацию много раз. Вы не создаете длинную строку, и может быть, что интерпретатор python оптимизирует ваши циклы. Это объясняет, почему время увеличивается, когда вы переходите на str.join и path.join – это более сложные функции, которые не так легко сокращаются. (os.path.join делает много проверок на строках, чтобы увидеть, нужно ли их переписывать каким-либо образом, прежде чем они будут объединены. Это приносит в жертву некоторую производительность ради мобильности.)

    Кстати, поскольку пути к файлам обычно не очень длинные, вы почти наверняка хотите использовать os.path.join ради переносимости. Если производительность конкатенации является проблемой, вы делаете что-то очень странное с вашей файловой системой.

    Разве это не должно быть наоборот?

    Не обязательно. Я не знаю внутренних компонентов Python достаточно хорошо, чтобы прокомментировать, но некоторые общие наблюдения заключаются в том, что ваш первый цикл использует простой оператор + который, вероятно, реализован как примитив во время выполнения. Напротив, другие петли сначала должны решить имя модуля, разрешить найденную там переменную / класс, а затем вызвать функцию-член на этом.

    Еще одно замечание: ваша петля может быть слишком мала, чтобы давать значительные числа. Учитывая низкое общее время работы, это, вероятно, делает ваши тесты бесполезными.

    Кроме того, ваш тестовый пример очень специализирован на двух коротких строках. Такие случаи никогда не дают четкого представления о производительности краевого случая.

    Совет о конкатенировании множества строк.

    Для вычисления s = s1 + s2 + … + sn,

    1) используя +. Создается новая строка s1 + s2, затем создается новая строка s1 + s2 + s3, … и т. Д., Поэтому задействовано много операций по распределению памяти и копированию. На самом деле s1 копируется n-1 раз, s2 копируется n-2 раза, … и т. Д.

    2) используя «" .join ([s1, s2, …, sn]). Конкатенация выполняется за один проход, и каждый символ в строках копируется только один раз.

    В вашем коде на каждой итерации вызывается объединение, поэтому оно равнозначно использованию +. Правильный способ – собрать элементы в массиве, а затем вызвать соединение с ним.

    edit: исправлена ​​опечатка

    Конкатенация строк ( + ) имеет оптимизированную реализацию на CPython. Но это может быть не так на других архитектурах, таких как Jython или IronPython. Поэтому, когда вы хотите, чтобы ваш код .join() хорошо на этих интерпретаторах, вы должны использовать метод .join() для строк. os.path.join() специально предназначен для соединения с файловыми путями. Он также заботится о разных разделителях пути. Это будет правильный способ создания имени файла.

    Я хотел бы добавить ссылку на вики python, где есть заметки о конкатенации строк, а также о том, что « этот раздел несколько ошибочен с python2.5. Конкатенация строк Python 2.5 довольно быстрая ».

    Я считаю, что объединение строк было большим улучшением с 2,5, и хотя str.join все еще быстрее (особенно для больших строк), вы не увидите такого улучшения, как в старых версиях Python.

    http://wiki.python.org/moin/PythonSpeed/PerformanceTips#StringConcatenation

    Python - лучший язык программирования в мире.