З'єднання рядків проти підстановки рядків у Python

У Python ухиляється від того, де і коли використовується конкатенація рядків проти підстановки рядків. Оскільки конкатенація струн спричинила значне підвищення продуктивності, чи це (стає все більше) стилістичним рішенням, а не практичним?

Для конкретного прикладу, як слід обробляти конструкцію гнучких URI:

DOMAIN = 'http://stackoverflow.com'
QUESTIONS = '/questions'

def so_question_uri_sub(q_num):
    return "%s%s/%d" % (DOMAIN, QUESTIONS, q_num)

def so_question_uri_cat(q_num):
    return DOMAIN + QUESTIONS + '/' + str(q_num)

Редагувати: Також були пропозиції щодо приєднання до списку рядків та використання названої підстановки. Це варіанти на центральну тему, що полягає в тому, який спосіб - це правильний спосіб зробити це в який час? Дякуємо за відповіді!

Згідно з моєю машиною конкатенація (значно) швидша. Але стилістично я готовий заплатити ціну заміни, якщо продуктивність не є критичною. Ну, а якщо мені потрібне форматування, не потрібно навіть задавати питання ... немає іншого варіанту, як використовувати інтерполяцію / шаблонування.

>>> import timeit
>>> def so_q_sub(n):
...  return "%s%s/%d" % (DOMAIN, QUESTIONS, n)
...
>>> so_q_sub(1000)
'http://stackoverflow.com/questions/1000'
>>> def so_q_cat(n):
...  return DOMAIN + QUESTIONS + '/' + str(n)
...
>>> so_q_cat(1000)
'http://stackoverflow.com/questions/1000'
>>> t1 = timeit.Timer('so_q_sub(1000)','from __main__ import so_q_sub')
>>> t2 = timeit.Timer('so_q_cat(1000)','from __main__ import so_q_cat')
>>> t1.timeit(number=10000000)
12.166618871951641
>>> t2.timeit(number=10000000)
5.7813972166853773
>>> t1.timeit(number=1)
1.103492206766532e-05
>>> t2.timeit(number=1)
8.5206360154188587e-06

>>> def so_q_tmp(n):
...  return "{d}{q}/{n}".format(d=DOMAIN,q=QUESTIONS,n=n)
...
>>> so_q_tmp(1000)
'http://stackoverflow.com/questions/1000'
>>> t3= timeit.Timer('so_q_tmp(1000)','from __main__ import so_q_tmp')
>>> t3.timeit(number=10000000)
14.564135316080637

>>> def so_q_join(n):
...  return ''.join([DOMAIN,QUESTIONS,'/',str(n)])
...
>>> so_q_join(1000)
'http://stackoverflow.com/questions/1000'
>>> t4= timeit.Timer('so_q_join(1000)','from __main__ import so_q_join')
>>> t4.timeit(number=10000000)
9.4431309007150048

Не забувайте про названу заміну:

def so_question_uri_namedsub(q_num):
    return "%(domain)s%(questions)s/%(q_num)d" % locals()

Будьте обережні, що поєднуються рядки в циклі! Вартість конкатенації рядків пропорційна довжині результату. Цикл веде вас прямо до землі N-квадрата. Деякі мови оптимізують конкатенацію до останнього виділеного рядка, але ризикувати розраховувати на компілятор, щоб оптимізувати ваш квадратичний алгоритм до лінійного. Найкраще використовувати примітив ( join?), Який займає цілий список рядків, робить одне виділення і об'єднує їх усі за один раз.

"Оскільки конкатенація рядків побачила значне збільшення продуктивності ..."

Якщо продуктивність має значення, це добре знати.

Однак проблеми, які я бачив, ніколи не зводилися до строкових операцій. Як правило, у мене виникли проблеми з операціями вводу / виводу, сортування та операціями O ( n ² ), які є вузькими місцями.

Поки рядкові операції не обмежують продуктивність, я буду дотримуватися очевидних речей. Здебільшого, це підміна, коли це один рядок або менше, конкатенація, коли вона має сенс, і інструмент шаблону (як Mako), коли він великий.

Що ви хочете об'єднати / інтерполювати та як відформатувати результат, має сприяти вашому рішенню.

• Інтерполяція рядків дозволяє легко додавати форматування. Насправді, ваша версія рядкової інтерполяції не робить те саме, що ваша версія конкатенації; він фактично додає додатковий нахил вперед перед q_numпараметром. Щоб зробити те саме, вам доведеться написати return DOMAIN + QUESTIONS + "/" + str(q_num)в цьому прикладі.

• Інтерполяція полегшує форматування чисел; "%d of %d (%2.2f%%)" % (current, total, total/current)було б набагато менш читабельним у формі конкатенації.

• Зв'язування корисно, коли у вас немає фіксованої кількості елементів для string-ize.

Крім того, знайте, що Python 2.6 представляє нову версію інтерполяції рядків, що називається templating string :

def so_question_uri_template(q_num):
    return "{domain}/{questions}/{num}".format(domain=DOMAIN,
                                               questions=QUESTIONS,
                                               num=q_num)

Шаблони рядків плануються з часом, щоб замінити% -інтерполяцію, але це не відбудеться досить довго, я думаю.

Я просто перевіряв швидкість різних методів конкатенації / заміщення рядків з цікавості. Гугл-пошук на цю тему привів мене сюди. Я думав, що опублікую свої результати тесту в надії, що це може допомогти комусь прийняти рішення.

    import timeit
    def percent_():
            return "test %s, with number %s" % (1,2)

    def format_():
            return "test {}, with number {}".format(1,2)

    def format2_():
            return "test {1}, with number {0}".format(2,1)

    def concat_():
            return "test " + str(1) + ", with number " + str(2)

    def dotimers(func_list):
            # runs a single test for all functions in the list
            for func in func_list:
                    tmr = timeit.Timer(func)
                    res = tmr.timeit()
                    print "test " + func.func_name + ": " + str(res)

    def runtests(func_list, runs=5):
            # runs multiple tests for all functions in the list
            for i in range(runs):
                    print "----------- TEST #" + str(i + 1)
                    dotimers(func_list)

... Після запуску runtests((percent_, format_, format2_, concat_), runs=5)я виявив, що метод% був приблизно вдвічі швидшим, ніж інші у цих маленьких рядках. Метод concat завжди був найповільнішим (ледве). Були дуже невеликі відмінності при перемиканні позицій вformat() методі, але перемикання позицій завжди було щонайменше .01 повільніше, ніж метод звичайного формату.

Зразок результатів тесту:

    test concat_()  : 0.62  (0.61 to 0.63)
    test format_()  : 0.56  (consistently 0.56)
    test format2_() : 0.58  (0.57 to 0.59)
    test percent_() : 0.34  (0.33 to 0.35)

Я запускав їх, бо використовую конкатенацію рядків у своїх сценаріях, і мені було цікаво, яка вартість. Я керував ними різними порядками, щоб переконатися, що нічого не заважає, або покращуючи продуктивність першими чи останніми. Зі сторони, я вклав декілька довгих генераторів рядків у такі функції, як "%s" + ("a" * 1024)звичайний конмат був майже в 3 рази швидшим (1,1 проти 2,8), ніж за допомогою методів formatта %. Я думаю, це залежить від рядків і того, що ви намагаєтесь досягти. Якщо продуктивність дійсно має значення, можливо, краще спробувати різні речі та перевірити їх. Я схильний вибирати читабельність над швидкістю, якщо швидкість не стане проблемою, але це тільки я. Так мені не сподобалася моя копія / вставка, мені довелося поставити 8 пробілів на все, щоб воно виглядало правильно. Я зазвичай використовую 4.

Пам'ятайте, що стилістичні рішення - це практичні рішення, якщо ви коли-небудь плануєте підтримувати чи налагоджувати свій код :-) Є відома цитата Кнута (можливо, цитування Хоара?): "Ми повинні забути про невелику ефективність, скажімо, про 97% часу: передчасна оптимізація - корінь усього зла ».

Поки ви обережні, щоб не (сказати) не перетворити завдання O (n) на завдання O (n ² ), я б пішов із тим, що вам найлегше зрозуміти ..

Я використовую заміну, де можу. Я використовую конкатенацію лише тоді, коли будую рядок в, наприклад, циклі for.

Насправді правильне в цьому випадку (побудова доріжок) - це використання os.path.join. Не рядкове конкатенація чи інтерполяція