Python конкатенация строк: Как быстро конкатенировать строки в Python

Как быстро конкатенировать строки в Python

Рассказывает Рювен Лэрнер, преподаватель

Как вы, наверное, знаете один из принципов в Python: «Должен быть один и только один способ сделать что-либо». Можете убедиться в этом, выполнив в в интерпретаторе import this (вы увидите Дзен Python). Несмотря на это, иногда вам всё равно приходится выбирать между несколькими способами сделать что-то, и не всегда очевидно, какой способ лучше. Недавно один студент спросил меня, какой способ конкатенации строк в Python самый эффективный. Я решил поделиться результатом своего маленького исследования и с вами.

Для начала вспомним, какие способы объединения строк предоставляет нам Python. Во-первых, это оператор +:

>> 'abc' + 'def'
'abcdef'

Также мы можем использовать оператор %, который, конечно, может использоваться не только для соединения строк, но и для этого тоже:

>>> "%s%s" % ('abc', 'def')
'abcdef'

Есть и ещё более современная замена % — это str.format:

>>> '{0}{1}'.format('abc', 'def')
'abcdef'

Так же, как и %, этот метод гораздо мощнее, чем обычный +, но тем не менее строки соединяют и с его помощью.

Как же мы будем замерять время? В Jupyter (так же известном, как IPython) мы можем использовать магическую команду timeit для запуска кода. Для запуска я подготовил четыре функции, каждая из которых складывает строки разным образом. Исходные строки хранятся в глобальных переменных (x и y), а локальная (для каждой функции) переменная z содержит результат сложения. Затем функция возвращает результат.

def concat1(): 
    z = x + y 
    return z 

 def concat2(): 
    z = "%s%s" % (x, y) 
    return z 

def concat3(): 
    z = "{}{}".format(x, y) 
    return z 

def concat4(): 
    z = "{0}{1}".format(x, y) 
    return z

Конечно concat3() и concat4() фактически одинаковы, но я решил проверить и то, влияет указание порядка строк на скорость или нет. Затем я определил наши глобальные переменные:

x = 'abc' 
y = 'def'

И запустил наши функции:

%timeit concat1()
%timeit concat2()
%timeit concat3()
%timeit concat4()

Результат оказался следующим:

• concat1: 153 наносекунды;
• concat2: 275 наносекунд;
• concat3: 398 наносекунд;
• concat4: 393 наносекунды.

Здесь мы можем видеть, что concat1(), который использует оператор +, выполняется гораздо быстрее остальных. Это немного расстроило меня, потому что мне очень нравится str.format, однако теперь в задачах, которые требуют огромного количества обработки строк, от него придётся отказаться.

Возможно, такие результаты могут быть связаны с тем, что короткие строки не создаются в Python каждый раз снова, а хранятся в специальной таблице? Давайте попробуем изменить наши глобальные переменные следующим образом:

x = 'abc' * 10000 
y = 'def' * 10000

Теперь мы получим следующие результаты:

• concat1: 2.64 микросекунды;
• concat2: 3.09 микросекунды;
• concat3: 3.33 микросекунды;
• concat4: 3.48 микросекунды;

Да, каждый из методов теперь работал гораздо дольше, однако общий результат не изменился — оператор + по прежнему лидирует. Заметим так же, что разница во времени между третьим и четвёртым методом, как и ожидалось, пренебрежимо мала.

После этого я попробовал не объявлять переменные глобальными, а задавать их в теле метода, но на результаты это всё равно не повлияло. Разумеется, можно проводить ещё много разных опытов (например, попробовать сложить больше, чем две строки), однако этого уже достаточно, чтобы иметь примерное представление о скоростях работы различных способов сложения строк в языке Python.

Перевод статьи «Speedy string concatenation in Python»

Переменные и конкатенация — Python

Для закрепления предыдущей темы попробуем использовать переменные с конкатенацией. Синтаксически ничего не меняется: мы умеем конкатенировать (склеивать) две строки:

what = "Kings" + "road"
print(what)  # => "Kingsroad"

… а значит сумеем конкатенировать строку и одну переменную, в которой записана строка:

first = "Kings"
what = first + "road"

print(what)  # => "Kingsroad"

… и даже конкатенировать две переменные, в которых записаны строки:

first = "Kings"
last = 'road'

what = first + last
print(what)  # => "Kingsroad"

Задание

Сайты постоянно посылают письма своим пользователям. Типичная задача — сделать автоматическую отправку персонального письма, где в заголовке будет имя пользователя. Если где-то в базе сайта хранится имя человека в виде строки, то задача генерации заголовка сводится к конкатенации: например, нужно склеить строку Здравствуйте со строкой, где записано имя.

Напишите программу, которая будет генерировать заголовок и тело письма, используя уже готовые переменные, и выводить получившиеся строки на экран.

Для заголовка используйте переменные first_name и greeting, запятую и восклицательный знак. Выведите это на экран в правильном порядке.

Для тела письма используйте переменные info и intro, при этом второе предложение должно быть на новой строке.

Результат на экране будет выглядеть так:

Hello, Joffrey!
Here is important information about your account security.
We couldn't verify you mother's maiden name.

Выполните задание, используя только два print().

Советы

• Подумайте, с какой строкой и в каком порядке нужно склеивать переменные, чтобы получить такой двустрочный вывод тела письма.

• Помните, что можно создать строку, которая содержит только управляющую последовательность \n.

Нашли ошибку? Есть что добавить? Пулреквесты приветствуются https://github.com/hexlet-basics

Какой предпочтительный способ объединить строку в Python?

Лучший способ добавления строки в строковой переменной является использование +или +=. Это потому, что это читается и быстро. Они также такие же быстрые, какой из них вы выбираете — дело вкуса, последний является наиболее распространенным. Вот время с timeitмодулем:

a = a + b:
0.11338996887207031
a += b:
0.11040496826171875

Однако те, кто рекомендует иметь списки и добавлять к ним, а затем присоединяться к этим спискам, делают это, потому что добавление строки в список, по-видимому, очень быстро по сравнению с расширением строки. И это может быть правдой, в некоторых случаях. Вот, например, один миллион добавлений односимвольной строки, сначала в строку, затем в список:

a += b:
0.10780501365661621
a.append(b):
0.1123361587524414

Хорошо, получается, что даже когда длина получаемой строки составляет миллион символов, добавление все равно происходит быстрее.

Теперь давайте попробуем добавить строку длиной в тысячу символов сто тысяч раз:

a += b:
0.41823482513427734
a.append(b):
0.010656118392944336

Таким образом, длина конечной строки составляет около 100 МБ. Это было довольно медленно, добавление в список было намного быстрее. То, что это время не включает финал a.join(). Так как долго это займет?

a.join(a):
0.43739795684814453

Oups. Оказывается, даже в этом случае, добавление / объединение происходит медленнее.

Так откуда эта рекомендация? Python 2?

a += b:
0.165287017822
a.append(b):
0.0132720470428
a.join(a):
0.114929914474

Что ж, добавление / объединение происходит немного быстрее, если вы используете очень длинные строки (чего у вас обычно нет, что бы вы имели строку размером 100 МБ в памяти?)

Но настоящий довод — это Python 2.3. Там, где я даже не покажу вам время, потому что оно настолько медленное, что еще не закончено. Эти тесты внезапно занимают минуты . За исключением append / join, который так же быстр, как и при поздних Pythons.

Ага. Конкатенация строк в Python была очень медленной еще в каменном веке. Но на 2.4 он больше не существует (или, по крайней мере, на Python 2.4.7), поэтому рекомендация использовать append / join устарела в 2008 году, когда Python 2.3 перестал обновляться, и вы должны были прекратить его использование. 🙂

(Обновление: оказывается, когда я проводил более тщательное тестирование, чем использование, +и +=оно быстрее для двух строк на Python 2.3. Рекомендации по использованию ''.join()должны быть недопониманием)

Тем не менее, это CPython. Другие реализации могут иметь другие проблемы. И это еще одна причина, по которой преждевременная оптимизация является корнем всего зла. Не используйте технику, которая считается «более быстрой», если вы сначала не измерите ее.

Поэтому «лучшая» версия для объединения строк — использовать + или + = . И если это окажется для вас медленным, что маловероятно, то сделайте что-нибудь еще.

Итак, почему я использую много дополнений / соединений в моем коде? Потому что иногда это на самом деле понятнее. Особенно, когда все, что вы должны объединить вместе, должно быть разделено пробелами, запятыми или символами новой строки.

python — Конкатенация строк и подстановка строк в 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)

Изменить: Также были предложения о присоединении списка строк и для использования именованной подстановки. Это варианты центральной темы, а именно, как правильно и в какое время это сделать? Спасибо за ответы!

98

gotgenes

18 Дек 2008 в 02:39

9 ответов

Лучший ответ

Конкатенация (значительно) быстрее в зависимости от моей машины. Но стилистически я готов заплатить цену замещения, если производительность не критична. Ну, а если мне нужно форматирование, нет необходимости даже задавать вопрос … нет другого выбора, кроме как использовать интерполяцию / шаблонирование.

>>> 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

55

Nilesh
21 Июн 2015 в 06:41

Не забудьте о названной замене:

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

24

too much php
18 Дек 2008 в 00:22

Остерегайтесь конкатенации строк в цикле! Стоимость конкатенации строк пропорциональна длине результата. Циклы ведут вас прямо в землю N-квадрата. Некоторые языки оптимизируют конкатенацию для последней выделенной строки, но рассчитывать на компилятор, чтобы оптимизировать ваш квадратичный алгоритм до линейного, рискованно. Лучше всего использовать примитив (join?), Который принимает весь список строк, выполняет одно выделение и объединяет их все за один раз.

12

Norman Ramsey
18 Дек 2008 в 04:40

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

    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() были очень небольшие различия, но переключение позиций всегда было как минимум на 0,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), и обычный concat был почти в 3 раза быстрее (1.1 против 2.8), чем при использовании методов format и % , Я думаю, это зависит от условий и того, чего вы пытаетесь достичь. Если производительность действительно имеет значение, может быть лучше попробовать разные вещи и проверить их. Я склонен выбирать удобочитаемость, а не скорость, если только скорость не становится проблемой, но это только я. ТАК не понравилось мое копирование / вставка, я должен был поместить 8 пробелов на все, чтобы это выглядело правильно. Я обычно использую 4.

7

Cj Welborn
13 Май 2013 в 03:27

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

0

Draemon
17 Дек 2008 в 23:56

То, что вы хотите объединить / интерполировать и как вы хотите отформатировать результат, должно определять ваше решение.

• Строковая интерполяция позволяет легко добавлять форматирование. Фактически, ваша версия с интерполяцией строк не делает то же самое, что и версия с конкатенацией; фактически он добавляет дополнительную косую черту перед параметром q_num. Чтобы сделать то же самое, вам нужно написать return DOMAIN + QUESTIONS + "/" + str(q_num) в этом примере.

• Интерполяция упрощает форматирование чисел; "%d of %d (%2.2f%%)" % (current, total, total/current) будет гораздо менее читаемым в виде конкатенации.

• Конкатенация полезна, когда у вас нет фиксированного количества элементов для строкового ввода.

Также знайте, что Python 2.6 представляет новую версию интерполяции строк, которая называется шаблонизация строк:

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

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

10

Tim Lesher
18 Дек 2008 в 00:18

«Поскольку конкатенация строк значительно повысилась в производительности …»

Если производительность имеет значение, это полезно знать.

Однако проблемы с производительностью, которые я видел, никогда не сводились к строковым операциям. Обычно у меня возникают проблемы с операциями ввода-вывода, сортировки и операций O ( n ² ), которые являются узкими местами.

Пока строковые операции не ограничивают производительность, я буду придерживаться очевидных вещей. В основном это подстановка, когда она меньше одной строки, конкатенация, когда это имеет смысл, и инструмент для создания шаблонов (например, Mako), когда он большой.

11

S.Lott
18 Дек 2008 в 00:18

Помните, стилистические решения являются практическими решениями, если вы когда-нибудь планируете поддерживать или отлаживать свой код 🙂 Есть известная цитата из Кнута (возможно, цитирующая Хоара?): «Мы должны забыть о небольшой эффективности, скажем, около 97% времени: преждевременная оптимизация — корень всего зла ».

²

4

John Fouhy
18 Дек 2008 в 01:04

На самом деле правильная вещь в этом случае (создание путей) — использовать os.path.join. Не конкатенация строк или интерполяция

-1

hoskeri
20 Авг 2011 в 03:56

376461

Работа со строками в Python OTUS

Язык программирования Python поддерживает разные виды данных. В этой статье, предназначенной для начинающих, будет рассмотрен строковый тип string и основные операции, связанные с обработкой строк. Среди них:

• создание строк;
• конкатенация строк;
• выборка символов по индексам.

Создание строки

Строки (strings) используются для хранения текстовых данных. Их создание возможно одним из 3-х способов. Тут все просто, т. к. возможно применение разных кавычек: одинарных, двойных либо тройных. То есть в эти кавычки и нужно обернуть текст:

otus_string_1 = 'Привет, друзья!'

otus_string_2 = "Хотите выучить Python?"

otus_string_3 = """Ждем вас на наших курсах!"""

Кавычки в данном случае — это строковые литералы, позволяющие создавать в памяти программы Python объект типа string.

Нужно понимать, что разницы, какие именно кавычки использует разработчик, нет. Главное — открывающие и закрывающие кавычки должны быть однотипными. Если же поставить вначале одинарную кавычку, а в конце двойную — ошибки не избежать.

Можно ли применять кавычки внутри строк?

Можно, для чего есть несколько вариантов. Один из них — использовать внутри строки кавычки другого типа. К примеру, наружные кавычки являются двойными, а внутренние — одинарными. Или наоборот:

otus_string_1 = 'Хотите выучить "Пайтон?" и стать профессионалом'

otus_string_2 = "Запишитесь на курс в 'Отус' уже сегодня!"

Второй метод — экранирование. Для экранирования используется обратный слэш. Вот, как это выглядит в коде:

otus_string_1 = "Я и \'Пайтон\' созданы друг для друга"

У тройных кавычек есть особенности. Заключенные в них строки поддерживают многострочность, то есть для переноса не нужен символ \n. А еще внутри тройных кавычек можно вставлять как двойные, так и одинарные кавычки:

my_string = """Учитесь

программированию

в "Отус"!"""

print (my_string)

Вывод будет следующим:

Строки являются неизменяемыми объектами (как и числа). В этом легко убедиться, если создать переменные с одинаковыми именами, а потом вывести на экран их id — идентификаторы будут различаться:

otus_string = 'Привет, друзья!'

print(id(otus_string))

otus_string = "Хотите выучить Python?"

print(id(otus_string))

Рекомендуется повторить вышеописанные операции самостоятельно и попрактиковаться. Сделать это можно, даже не устанавливая «Пайтон», используя любой онлайн-компилятор.  

Конкатенация строк

Конкатенация — это сложение строк, в результате чего они соединяются друг с другом. Самый простой способ сделать это — использовать простейший оператор сложения, то есть знак «+».

Это простейший синтаксис, причем можно брать сколько угодно строк и соединять их:

otus_string = "Я " + "просто " + "обожаю " + "Python!"

print(otus_string)

Если надо, можно задействовать и операнд умножения. Он позволит продублировать строку, умножив ее на соответствующее значение, которое разработчик передаст в коде.  

otus_string = "Code" * 10

print(otus_string)

Важное свойство строк — длина (число символов). Узнать количество символов, из которых состоит строка, можно, задействовав встроенную функцию len (от англ. length — длина).

Код ниже посчитает число символов:

otus_string = "Python is a good for coding"

print(len(otus_string))

Итого: строка содержит 27 символов (пробел — тоже символ):

Можно попробовать передать пустую строку и постараться посчитать число символов в ней. Если вставить хотя бы пробел, на выходе получится 1 символ, если не вставлять вообще ничего, число символов будет равняться нулю.

otus_string_1 = ""

print(len(otus_string_1))

otus_string_2 = " "

print(len(otus_string_2))

Несколько слов о методах строк

Ранее уже использовались такие методы, как print и id. Есть свои методы и у строковых данных — они принадлежат конкретному классу str. Чтобы вывести их, можно воспользоваться функцией dir:

Зубрить каждый из них нет необходимости, так как нужные методы будут запоминаться с практикой. Чтобы обратиться к одному из них, следует сначала обратиться к соответствующему объекту, потом поставить точку, потом написать нужный метод и круглые скобки. Лучше это увидеть:

string_1 = "oTUs"

string_1 = string_1.title()

print(string_1)

string_1 = string_1.upper()

print(string_1)

string_1 = string_1.lower()

print(string_1)

Что отображено на скриншоте выше:

• была создана новая строка string_1 с содержимым “oTUs”;
• вначале задействовали метод title — вывод слова получился с заглавной буквы;
• потом использовали метод для верхнего регистра upper — заглавными (прописными)  стали все символы строки;
• далее применили lower — все символы стали маленькими (строчными), то есть перешли в нижний регистр.  

Какие еще есть методы:

• replace —для замены одной части исходной строки (подстроки) на другую;
• split — позволяет разделить (не удалить!) строку по переданному делителю, возвращает список;
• join — склеивает подстроки по конкретному разделителю;
• strip. В языке программирования Python strip используется для обрезки ненужных символов, причем ненужный символ передается в виде аргумента. Обрезку можно выполнять по-разному: если с первого символа слева, то применяют не strip, а lstrip, если справа, то rstrip (с конца строки, если интересует последний символ).

Индексы

В «Питоне» у каждого символа есть свой номер — индекс. Если разработчика интересует поиск какого-нибудь символа, к нему можно обратиться. Код ниже возвращает индекс для каждого символа из слова Otus:

string_1 = "Otus"

print(string_1[0])

print(string_1[1])

print(string_1[2])

print(string_1[3])

Тут важен один момент: индексация начинается не с единицы, а с нуля, поэтому первый символ имеет индекс 0.

Дополнительно: преобразование символа в целое число

Компьютеры хранят все данные в виде цифр, и символьных данных это тоже касается. Для представления символов строкового типа String применяют схему перевода. Самая простая из них — ASCII. Если нужно вернуть число для какого-нибудь конкретного символа, используют функцию ord. К примеру, для символа «a» кодовое значение по ASCII будет равняться 97, а для «#» — 35.

Кроме ASCII, также широко известен  Unicode, который тоже поддерживается «Питоном».

Источники:

• https://zen.yandex.ru/media/id/5cab3ea044061700afead675/vse-o-strokah-v-python-5f60744e5622142b93b2031e;
• https://pythonru.com/osnovy/stroki-python.

Лабораторная работа 5 Работа со строками в Python

Результат выполнения программы с использованием функций и методов работы со строками

Проверить, будет ли строка читаться одинаково справа налево и слева направо (т. е. является ли она палиндромом).

Сначала введём строку командой: s=input(‘Введите строку ‘).

Затем определим логическую переменную  flag и присвоим ей значение 1: flag=1.

Для начала в введённой строке нужно удалить пробелы. Для этого воспользуемся циклической конструкцией for, которая выполнится столько раз, какую имеет длину строка. Длину строки определим функцией len(s).

В теле цикла будем проверять следующее условие: s[i]!=’ ‘. Данное логическое выражение будет истинно в том случае, если i-ый элемент строки не будет равен пробелу, тогда выполнится команда следующая после двоеточия: string+=s[i].

К сроке string, которая была объявлена в начале программы, будет добавляться посимвольно строка s, но уже без пробелов.

Для проверки строки на «палиндром» воспользуемся циклической конструкцией for.

Длина половины строки находится делением нацело на 2.  Если количество символов нечетно,  то стоящий в середине не учитывается, т.к. его сравниваемая пара — он сам.

Количество повторов цикла равно длине половины строки. Длину строки определим функцией len(s), где аргумент введённая нами строка s. Зная длину строки, можно вычислить количество повторов цикла. Для этого целочисленно разделим длину строки на 2: len(s)//2.

Для задания диапазона для цикла используем функцию range(), в которой аргументом будет являться половина длины строки: range(len(s//2 )).

for i in range(len(s//2 )).

Если символ с индексом i не равен «симметричному» символу с конца строки (который находится путем индексации с конца)

if s[i] != s[-1-i],

то переменной flag присваивается значение 0 и происходит выход из цикла командой break. 

Далее, при помощи условной конструкции if-else в зависимости от значения flag либо — 0, либо -1 выводится сообщение, что строка палиндром, либо нет.

Пример программы на PythonРезультат выполнения программы

Задания для самостоятельной работы (по вариантам)

Всё о строках в Python

Друзья всем привет, вы на канале Python Today и сегодня мы поговорим о строках в языке Python, рассмотрим форматирование, конкатенацию, срезы и конечно методы для работы со строками.

Создание строк в Python

Строки в Python принадлежат к типу данных str/string и служат для хранения текстовых данных. 

Для того, чтобы создать объект строки нам нужно нашу фразу, любой текст или символы обернуть в одинарные, двойные или тройные кавычки: 

my_string_1 = 'I like Python'
my_string_2 = "You like Python"
my_string_3 = """We like Python"""

Сами кавычки являются строковым литералом, которые создают в памяти объект типа string. 

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

Например если мы попробуем вначале строки поставить одинарную кавычку, а в конце двойную, то получим ошибку:

my_string_4 = 'He likes Python"
print(my_string_4)

    my_string_4 = 'He likes Python"
                                  ^
SyntaxError: EOL while scanning string literal

Внутри строк мы также можем использовать кавычки и для этого есть несколько способов.

Первый, кавычки внутри строки должны быть другого типа, т.е отличаться от внешних. Например если мы используем внешние двойные кавычки, то внутренние должны быть одинарными и наоборот:

my_string_1 = "I 'like' Python"
print(my_string_1)
my_string_2 = 'I "like" Python'
print(my_string_2)

I 'like' Python
I "like" Python

Второй способ, это экранировать кавычки с помощью обратного слэша: 

my_string_3 = "I \"like\" Python"
print(my_string_3)

I "like" Python

Тройные одинарные или двойные кавычки обычно используются для документации в коде, так как имеют интересные свойства. Строки заключённые в них поддерживают многострочность и не требуют использования специального символа \n для переноса строки. Внутри тройных кавычек мы так же можем вставлять двойные или одинарные кавычки:

my_string = """Python
"is"
awesome
"""
print(my_string)

my_string_1 = "Hello \nWorld"
print(my_string_1)

Python
"is"
awesome

Hello 
World

Строки как и числа в Python являются неизменяемыми объектами. Мы можем убедиться в этом создав две переменные с одинаковым именем и распечатать их id, и как видим они будут разными:

my_string = "Python"
print(id(my_string))
my_string = "JavaScript"
print(id(my_string))

140050277286512
140050275652464

Конкатенация строк в Python

Давайте поговорим о конкатенации строк и говоря простыми словами это соединение одной строки с другой.

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

В операциях со строками функционал этого операнда отличается от работы с числами.

Синтаксис весьма прост мы берём две, три, пять сколько угодно строк и складываем их между собой использую операнд сложения:

my_string = "Python " + "is" + " awesome!"
print(my_string)

Python is awesome!

В Python мы так же можем использовать операнд умножения «*» при работе со строками. Операнд умножения дублирует нашу строку умножая её на переданное значение:

my_string = "Go" * 10
print(my_string)

GoGoGoGoGoGoGoGoGoGo

Важным свойством строк является их длина. Длину строки мы можем узнать с помощью встроенной функции len() сокращение от слова length, что в переводе с английского означает — длина.

my_string = "Python"
print(len(my_string))

6

Обратите внимание, что если передать пустую строку и вывести её длину, мы получим 0 т.е boolean значение False, а если хотя бы поставим пробел, то получим 1 эквивалентную значению True.

my_string = ""
print(len(my_string))
my_string_1 = " "
print(len(my_string_1))

0
1

Если вы пока не знакомы с типом данных boolean, не переживайте, позже мы его рассмотрим.

Методы строк в Python

Мы уже использовали ранее некоторые так называемые независимые функции такие как print(), type() и id().

my_string = "Python"
print(my_string)
print(type(my_string))
print(id(my_string))

Python
<class 'str'>
139975328428592

И конечно у строк есть свои методы. В чём их отличие от функций. Методы это теже самые функции которые принадлежат конкретному классу и являются его атрибутом. В данном уроке мы работаем с классом str, классом строк в Python.

Для того, чтобы увидеть список доступных методов для строк, давайте воспользуемся функцией dir() и выведем их через цикл в столбик:

my_string = "python"
for mth in dir(my_string):
    print(mth)

__add__
__class__
__contains__
__delattr__
__dir__
__doc__
__eq__
__format__
__ge__
__getattribute__
__getitem__
__getnewargs__
__gt__
__hash__
__init__
__init_subclass__
__iter__
__le__
__len__
__lt__
__mod__
__mul__
__ne__
__new__
__reduce__
__reduce_ex__
__repr__
__rmod__
__rmul__
__setattr__
__sizeof__
__str__
__subclasshook__
capitalize
casefold
center
count
encode
endswith
expandtabs
find
format
format_map
index
isalnum
isalpha
isascii
isdecimal
isdigit
isidentifier
islower
isnumeric
isprintable
isspace
istitle
isupper
join
ljust
lower
lstrip
maketrans
partition
replace
rfind
rindex
rjust
rpartition
rsplit
rstrip
split
splitlines
startswith
strip
swapcase
title
translate
upper
zfill

На первый взгляд методов у объекта строк достаточно много и даже не думайте пугаться этого или пытаться их заучивать, это попросту незачем.

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

Чтобы вызвать метод у конкретного объекта класса, мы сначала обращаемся к объекту, затем ставим точку и далее пишем нужный нам метод в конце указывая круглые скобки тем самым вызывая его.

Есть как простые методы например  upper() и lower() которые приводят строку к разным регистрам, или title() который возвращает первую заглавную букву:

my_string = "python"
my_string = my_string.upper()
print(my_string)
my_string = my_string.lower()
print(my_string)
my_string = my_string.title()
print(my_string)

PYTHON
python
Python

Откровенно говоря, я вот прям не вспомню когда последний раз использовал их в работе, это к вопросу о надобности и зазубревании.

И конечно есть методы более интересные, которые я использую регулярно. Например метод replace(), который принимает первым аргументом искомую подстроку, а вторым подстроку на которую нужно заменить искомую. Сам метод возвращает копию строки:

my_string = "I like PHP"
print(my_string)
my_string = my_string.replace('PHP', 'Python')
print(my_string)

I like PHP
I like Python

Кстати обратите внимание, что при использовании какого либо метода, я заново сохраняю получаемое значение в переменную. Но что будет если я этого не сделаю:

my_string = "I like PHP"
print(my_string)
my_string.replace('PHP', 'Python')
print(my_string)

I like PHP
I like PHP

Как видим мы получаем старое значение, до использования метода. Напоминаю, что происходит это из-за того, что строки неизменяемы, поэтому всякий раз при работе с неизменяемым типом объекта мы вынуждены каждый раз сохранять результат в новую переменную либо перезаписывать старую как делаем мы.

Следующим полезным методом является метод split(), который разделят строку по переданному делителю и возвращает список:

my_string = "I like Python"
my_string = my_string.split(' ')
print(my_string)

['I', 'like', 'Python']

Например разделив нашу строку по пробелу, мы получим список из трёх объектов.

Склеить строку мы можем как с помощью операнда сложения, так и используя интересный метод join() который возвращает склеенную по разделителю строку из итерируемого объекта, в данном случае списка:

my_string = "I " + "like" + " Python"
print(my_string)

my_string = my_string.split(' ')
my_string = '-'.join(my_string)
print(my_string)

I like Python
I-like-Python

Перед методом указывается разделитель, и давайте например укажем дефис, а не пробел. На выходе получаем строку со словами разделёнными дефисом.

Часто требуется убрать пробелы вначале или в конце строки, для этого в Python существует метод strip(). Его так же можно использовать для обрезки ненужных нам символов, передав их в качестве аргумента. Например мы хотим убрать восклицательный знак:

my_string = "I like Python!       "
my_string = my_string.strip()
print(my_string)

my_string = my_string.strip('!')
print(my_string)

I like Python!
I like Python

У него есть несколько похожих методов таких как lstrip() что означает обрезать слева и rstrip() соответственно обрезать справа: 

my_string = "@I like Python!"
print(my_string)
my_string = my_string.lstrip("@")
print(my_string)
my_string = my_string.rstrip("!")
print(my_string)

@I like Python!
I like Python!
I like Python

Форматирование строк в Python

Порою, а точнее сказать очень часто нам требуется заполнить строку подставив в неё некоторые значения или нужные нам данные полученные в процессе выполнения программы.

Вы можете встретить несколько типов форматирования строки, первый и лично мой самым любимый это так называемый метод f-строк доступный нам с версии Python 3.6 и который имеет следующий синтаксис:

name = 'Андрей'
my_string = f'Привет {name}!'
print(my_string)

Привет Андрей!

Например у нас есть переменная name со значением «Андрей» и строка my_string = со значением «Привет !», для того, чтобы подставить в нашу строку переменную name, мы вначале строки указываем букву f, а внутрь строки передаём в фигурных скобках переменную name. Таким образом мы можем передавать сколько угодно значений в строку, подставляя в нужные места переменные:

name = 'Андрей'
my_string = f'Привет {name}!'
print(my_string)

name_1 = 'Кристина'
name_2 = "Влад"
my_string = f'Привет {name}, {name_1}, {name_2}!'
print(my_string)

Привет Андрей!
Привет Андрей, Кристина, Влад!

Следующий способ форматирования строк, через строковый метод format(). Мы не указываем вначале букву f, а передаём значения в виде аргументов в сам метод:

name = 'Анна'
my_string = 'Привет {}'.format(name)
print(my_string)

Привет Анна

Для передачи нескольких значений, мы можем разделять аргументы запятыми добавляя в строку новые фигурные скобки. Изменить порядок переданных значений в строке, мы можем с помощью указания индексов:

name = 'Анна'
my_string = 'Привет {1}{0}'.format(name, "!")
print(my_string)

Привет !Анна

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

Либо можем передать значения присваивая их через именованные аргументы:

name = 'Анна'
my_string = 'Привет {important}{name}'.format(name=name, important='!')
print(my_string)

Привет !Анна

И последний, весьма старый способ который вы можете встретить в своей практике это форматирование через оператор процента:

name = 'Алекс'
my_string = 'Привет %s'
print(my_string % name)

Привет Алекс

Данный метод форматирования постепенно исчезает из кода, но тем неменее встречается в книгах и старых проектах.

Индексы и срезы строк в Python

Строки в Python являются неизменяемыми и упорядоченными итерируемыми объектами. Это означает, что каждому символу в строке присвоен свой номер или так называемый индекс.

Индексация строк начинается с нуля, затем один, два и так далее по порядку до самого конца строки. С помощью индексов мы можем обращаться к значениям строк.

Например у нас есть переменная my_string со значением «Python is awesome», при обращении к переменной my_string мы получаем строку целиком:

my_string = "Python is awesome"
print(my_string)

Python is awesome

Каждый символ нашей строки имеет свой индекс, начиная с 0. Так у P будет индекс равный 0, у Y равный 1 и так далее. Для получения конкретного символа мы должны обратиться к его индексу используя квадратные скобки, передавая внутрь индекс:

my_string = "Python is awesome"
# print(my_string)
print(my_string[0])
print(my_string[1])
print(my_string[2])
print(my_string[3])
print(my_string[4])
print(my_string[5])
print(my_string[6])

P
y
t
h
o
n

Окей, обратите внимание, что нет ничего сложного получить первый символ в строке, он всегда будет под индексом 0. Но как нам быть если нужно забрать последний символ.

Мы можем воспользоваться уже знакомой нам функцией len() и напечатать длину нашей строки равную 17.

my_string = "Python is awesome"
print(len(my_string))

17

Давайте попробуем вывести последний символ, передав индекс 17.

my_string = "Python is awesome"
print(my_string[17])

    print(my_string[17])
IndexError: string index out of range

И мы получаем ошибку, говорящую нам о том, что данного индекса не существует. Но как же так, давайте разберёмся.

Функция len() начинает свой отсчёт с 1, именно поэтому показывает длину равную 17. Но помните что индексирование строк начинается с 0, т.е на единицу меньше чем начало отсчёта функции len(). 

Для того, чтобы обратиться к последнему символу во многих языках в том числе и в Python мы можем использовать конструкцию my_string[len(my_string) — 1]:

my_string = "Python is awesome"
print(my_string[len(my_string) - 1])

e

Но Python не зря считается самым простым и функциональным языком и для того чтобы упростить данный пример и получить последний символ нашей строки, нам достаточно просто обратиться к индексу -1.

Нумерация отрицальтельных индексов начинается с правого края и минус единицы. Т.е буква «e» имеет индекс -1, «m» -2, «o» -3 и так далее справа налево:

my_string = "Python is awesome"
print(my_string[-1])
print(my_string[-2])
print(my_string[-3])

e
m
o

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

Рассматривайте срез как будто вы отрезаете кусок от торта, вот допустим вам нужен кусочек с ягодой, и мы можем вырезать его как с краю, так и из середины.

Вернёмся к нашей строке. Например нам нужно вырезать слово Python. Мы как и прежде обращаемся к строке, затем ставим квадратные скобки, указываем начальный индекс равный 0, т.е с какой буквы нам нужно отрезать и через двоеточие указываем индекс буквы по которую нужно получить срез, буква «n» имеет индекс равный 5.

my_string = "Python is awesome"
print(my_string[0:5])

Pytho

Но как видим срез то мы получили, только с небольшой проблемой. Буква «n» в него не попала. Запомните, что в срез попадают буквы с указанного слева индекса, но не попадает последний символ индекса справа, и для того, чтобы получить желаемый последний символ, нужно взять индекс на единицу больший.

my_string = "Python is awesome"
print(my_string[0:6])

Python

Давайте ещё раз попробуем получить срез, на этот раз возьмём слово «is», «i» у нас имеет индекс равный 7, а «s» под 8, получается нам нужно указать срез с 7 по 8 индекс, но не забываем прибавить единицу и получается с 7 по 9.

my_string = "Python is awesome"
print(my_string[7:9])

is

Хорошо.

Мы только что указывали индексы для среза слева и справа. Но это необязательные параметры. Так не передав вообще никакие индексы, т.е не указав никакого интервала, мы получим строку целиком:

my_string = "Python is awesome"
print(my_string[:])

Python is awesome

Указав индекс только с одной стороны, мы получим все значения с указанного интервала который если не указывать по умолчанию равен 0 и по указанный интервал:

my_string = "Python is awesome"
print(my_string[:13])

Python is awe

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

Шаг можно указать через двоеточие. Давайте создадим строку с цифрами для большей наглядности. И например укажем шаг равный 2 для всей нашей строки, в результате мы получим только нечётные числа:

my_string = "123456789"
print(my_string[::2])

13579

Т.е получаем единицу, прибавляем к ней шаг равный 2 получаем 3, далее прибавляем шаг равный 2 и получаем 5, 7 и так далее.

Если мы не укажем интервал и поставим шаг равный -1 то получим перевернутую строку:

my_string = "123456789"
print(my_string[::-1])

987654321

На сегодня пожалуй всё, мы рассмотрели очень важную, большую и в тоже время простую тему.

У нас будет с вами много практики и не переживайте если вы что-то не уловили. Enjoy!

Конкатенация и форматирование строк — PythonForBeginners.com

Одна общая задача, которую вам нужно выполнить с любым языком, — это слияние или комбинирование строк. Этот процесс называется конкатенацией.

Лучше всего это описать, когда вы берете две отдельные строки, хранящиеся в интерпретаторе, и объединяете их так, чтобы они стали одной.

Например, одна строка будет «привет», а другая — «мир». Когда вы используете конкатенацию для их объединения, получается одна строка или «привет, мир».

В этом посте будет описано, как объединять строки в Python. Есть разные способы сделать это, и мы обсудим наиболее распространенные методы. После мы рассмотрим форматирование и то, как оно работает.

Конкатенация

В Python есть несколько способов сцепления или комбинирования строк. Создаваемая новая строка называется строковым объектом. Очевидно, это связано с тем, что все в Python является объектом, поэтому Python является объектно-ориентированным языком.

Чтобы объединить две строки в один объект, вы можете использовать оператор «+». При написании кода это будет выглядеть так:

   str1 = «Привет» 
  str2 = «Мир» 
  стр1 + стр2   

Последняя строка в этом коде — это конкатенация, и когда интерпретатор выполнит ее, будет создана новая строка.

Следует отметить, что Python не может объединять строку и целое число. Они считаются двумя отдельными типами объектов.Итак, если вы хотите объединить два, вам нужно будет преобразовать целое число в строку.

В следующем примере показано, что происходит, когда вы пытаетесь объединить строковый и целочисленный объект. Он был скопирован с личного сайта Дэвида Бау.

   >>> печать «красный» + «желтый» 
  Красно-желтый 
  >>> напишите «красный» * 3 
  Redredred 
  >>> печать «красный» + 3 
  Traceback   (последний звонок последний): 
  Файл «», строка 1, в 
  TypeError  : невозможно объединить объекты «  str  » и «  int  » 
  >>>   

Для справки, символы «>>>» указывают, где интерпретатор запрашивает команду.

Обратите внимание, как умножение строки «red» три раза возвращает значение «redredred». Это важно, поэтому обязательно запишите это в память.

Кроме того, мы видим, что при попытке объединить «красный» и 3 интерпретатор выдает ошибку. Здесь мы пытаемся объединить строку и целочисленный объект, и это не удалось.

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

Чтобы это стало возможным, мы можем преобразовать число в строку, используя соответствующую функцию. Код для этого будет выглядеть так:

   >>> печать «красная» +   str   (  3) 
  красный3 
  >>>   

Для этого мы использовали метод str ( ) .Обратите внимание, как интерпретатор просто объединил два объекта и выплюнул их, когда его попросили распечатать данные?

Рекомендуемое обучение Python

Для обучения Python наша главная рекомендация — DataCamp.

Форматирование строк в Python

В Python мы можем использовать два отдельных метода интерполяции строк.

Строковая интерполяция — это термин, используемый для описания процесса оценки строкового значения, которое содержится в одном или нескольких заполнителях.Проще говоря, он помогает разработчикам с форматированием и объединением строк.

Надеюсь, вы сами лучше знакомы с этим термином, потому что это важный элемент любого языка программирования, особенно Python.

Форматирование строки с помощью оператора%

Прежде чем мы рассмотрим подробнее, важно понять, что строковый оператор% будет устаревшим — больше не будет использоваться — в Python 3.1 и более поздних версиях. Со временем он будет полностью удален из будущих версий языка.

Тем не менее, знакомство с этим методом по-прежнему является хорошей идеей и обычной практикой.

Лучший способ понять, как работать с операторами, — это посмотреть на активный код.

   x   = «яблоко   s  » 
  y   = «лимон   s  » 
  z   = «  В   корзина% s и% s»% (  x, y  )   

В этом примере кода значения оператора «% s» заменяются соответствующей строкой в ​​установленном нами порядке.Когда вы печатаете строковый объект «z» — после выполнения приведенного выше кода — он вернет следующее:

   В корзине яблоки и лимоны   

Форматирование строки с помощью операторов {}

Когда вы используете фигурные скобки или операторы {} , они служат в качестве заполнителей для переменных, которые вы хотите сохранить внутри строки. Чтобы передать переменные в строку, вы должны вызвать метод формата ( ) .

Одним из преимуществ использования метода формата ( ) является то, что вам не нужно преобразовывать целые числа в строку перед объединением данных. Он сделает это автоматически за вас. Это одна из причин, почему это предпочтительный операторный метод.

Опять же, давайте взглянем на код, показывающий это в действии:

   Fname   = «Джон» 
  Lname   = «Самка» 
  Возраст = «24»

 
  p   rint «{} {} - {}   лет.«  формат (  имя  ,   имя  , возраст)   

Это будет принимать соответствующие значения и сохранять их как переменные в соответствующей строке.

Еще одна полезная особенность метода формата ( ) заключается в том, что на самом деле вам не нужно передавать входные данные интерпретатору в том же порядке, в котором вы хотите, чтобы переменные отображались, если вы нумеруете заполнители вроде так:

   печать «{0} {1} {2} лет.»  формат (  имя  ,   имя  , возраст)   

Использование метода соединения в Python

Метод соединения в Python используется для объединения списка строк.

Например,

   >>>   ' '   .join (['the', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']) 
  «Быстрая коричневая лисица перепрыгивает через ленивого пса»   

Давайте создадим новый список, в который войдут несколько великих групп, но на этот раз давайте поступим по-другому.

   >>> music = [«Metallica», «Rolling Stones», «ACDC», «Black Sabbath», «  Shinedown  »]   

Этот фрагмент кода создаст строку — или список — под названием «музыка» с указанными нами переменными.

Вы можете присоединиться к новому списку, добавив пустое место, например:

   >>> print   ‘’   .join (музыка)   

Вы также можете присоединиться к нему, начав код с новой строки, например:

   >>> печать «
  “.присоединиться   (музыка)   

Нет правильного или неправильного пути, используйте тот метод, который вам больше нравится.

Похожие сообщения

Строки Python

Реверсивные списки и строки

Манипуляции со строками

Рекомендуемое обучение Python

Для обучения Python наша главная рекомендация — DataCamp.

Конкатенация строк в Python

— GeeksforGeeks

В Python строки — это массивы байтов, представляющие символы Юникода.Однако в Python нет символьного типа данных, одиночный символ — это просто строка длиной 1. Квадратные скобки [] могут использоваться для доступа к элементам строки.

Пример:

Вывод:

Добро пожаловать
статистика
 

Конкатенация строк в Python

Конкатенация строк — это метод объединения двух строк .Конкатенацию строк можно выполнить разными способами.

Мы можем выполнить конкатенацию строк следующими способами:

1. Использование оператора +
2. Использование метода join ()
3. Использование оператора%
4. Использование функции format ()

Использование оператора +

Очень просто использовать оператор + для конкатенации строк. Этот оператор можно использовать для сложения нескольких строк вместе. Однако аргументы должны быть строкой.

Примечание. Строки неизменяемы, поэтому всякий раз, когда они объединяются, они присваиваются новой переменной.

Пример:

Вывод:

Привет, мир
 

Здесь переменная var1 хранит строку «Hello», а переменная var2 хранит строку «World».Оператор + объединяет строку, которая хранится в переменных var1 и var2, и сохраняет в другой переменной var3.

Использование метода join ()

Метод join () является строковым методом и возвращает строку, в которой элементы последовательности были соединены разделителем str.

Пример:

Выход:

Привет, мир
Привет, мир
 

В приведенном выше примере переменная var1 хранит строку «Hello», а переменная var2 хранит строку «World».Метод join () объединяет строку, которая хранится в переменных var1 и var2. Метод соединения принимает только список, поскольку его аргумент и размер списка могут быть любыми. Мы можем сохранить объединенную строку в другой переменной var3 , разделенной пробелом.

Примечание: Чтобы узнать больше о методе join () , щелкните здесь.

Использование оператора%

Мы можем использовать оператор% для форматирования строк, он также может использоваться для конкатенации строк.Это полезно, когда мы хотим объединить строки и выполнить простое форматирование.

Пример:

Вывод:

Привет, мир
 

Здесь оператор % объединяет строку, которая хранится в переменных var1 и var2.% s обозначает строковый тип данных. Значение обеих переменных передается в строку% s и становится «Hello World».

Использование функции format ()

str.format () — один из методов форматирования строк в Python, который допускает множественные подстановки и форматирование значений. Этот метод позволяет нам объединять элементы в строке посредством позиционного форматирования.

Пример:

Вывод:

Привет, мир
Привет, мир
 

Здесь функция format () объединяет строку, которая хранится в переменных var1 и var2, и сохраняет в другой переменной var3.Фигурные скобки {} используются для установки положения строк. Первая переменная хранится в первых фигурных скобках, а вторая переменная хранится во вторых фигурных скобках. Наконец, он выводит значение «Hello World».

Примечание: Чтобы узнать больше о функции format () , щелкните здесь.

Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS .

Какой способ объединения строки в Python является предпочтительным?

Наилучший способ добавления строки к строковой переменной — использовать + или + = . Это потому, что он удобочитаемый и быстрый. Они также такие же быстрые, какой выбрать — дело вкуса, последний — самый распространенный. Вот тайминги с модулем timeit :

  а = а + б:
0,11338996887207031
а + = Ь:
0,11040496826171875
  

Однако те, кто рекомендует иметь списки и добавлять к ним, а затем присоединять к этим спискам, делают это, потому что добавление строки к списку предположительно очень быстро по сравнению с расширением строки.И в некоторых случаях это может быть правдой. Вот, например, один
миллион добавлений односимвольной строки сначала к строке, затем к списку:

  а + = Ь:
0,10780501365661621
a.append (b):
0,1123361587524414
  

Хорошо, оказывается, что даже когда результирующая строка имеет длину в миллион символов, добавление все равно было быстрее.

Теперь давайте попробуем добавить строку из тысячи символов сто тысяч раз:

  а + = Ь:
0,41823482513427734
а.добавить (б):
0,010656118392944336
  

Таким образом, конечная строка имеет длину около 100 МБ. Это было довольно медленно, добавление в список было намного быстрее. Это время не включает окончательный a.join () . Так сколько времени это займет?

  a.join (a):
0,43739795684814453
  

Упс. Оказывается, даже в этом случае добавление / присоединение происходит медленнее.

Так откуда взялась эта рекомендация? Python 2?

  а + = Ь:
0.165287017822
a.append (b):
0,0132720470428
a.join (a):
0,114929914474
  

Ну, добавление / объединение на немного быстрее на , если вы используете очень длинные строки (чего обычно нет, какая у вас строка размером 100 МБ в памяти?)

Но настоящий решающий аргумент — Python 2.3. Где я даже не буду показывать вам тайминги, потому что он настолько медленный, что еще не закончен. Эти тесты внезапно занимают минут . За исключением добавления / соединения, которое работает так же быстро, как и в более поздних версиях Pythons.

Ага. Конкатенация строк была очень медленной в Python еще в каменном веке. Но в версии 2.4 этого уже нет (или, по крайней мере, Python 2.4.7), поэтому рекомендация использовать добавление / соединение устарела в 2008 году, когда Python 2.3 перестал обновляться, и вам следовало прекратить его использовать. 🙂

(Обновление: когда я проводил более тщательное тестирование, выяснилось, что использование + и + = также быстрее для двух строк на Python 2.3. Рекомендация использовать ».join () должно быть недоразумение)

Однако это CPython. В других реализациях могут быть другие проблемы. И это еще одна причина, по которой преждевременная оптимизация является корнем всех зол. Не используйте технику, которая считается «более быстрой», если вы ее сначала не измерили.

Следовательно, «лучшая» версия для конкатенации строк — использовать + или + = . И если это окажется для вас медленным, что маловероятно, тогда займитесь чем-нибудь другим.

Итак, почему я использую много добавлений / присоединений в моем коде? Потому что иногда это на самом деле яснее.Особенно, когда все, что вы должны объединить, следует разделять пробелами, запятыми или символами новой строки.

python — есть ли причина не использовать знак «+» для объединения двух строк?

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

Создайте два списка, один из связанного вопроса SO, а другой — более крупный сфабрикованный

  >>> myl1 = ['A', 'B', 'C', 'D', 'E', 'F']
>>> myl2 = [chr (random.randint (65,90)) для i в диапазоне (0,10000)]
  

Давайте создадим две функции, UseJoin и UsePlus , чтобы использовать соответствующие функции join и + .

  >>> def UsePlus ():
    return [myl [i] + myl [i + 1] для i в диапазоне (0, len (myl), 2)]

>>> def UseJoin ():
    [''.join ((myl [i], myl [i + 1])) для i в диапазоне (0, len (myl), 2)]
  

Запускаем timeit с первым списком

  >>> myl = myl1
>>> t1 = timeit.Timer ("UsePlus ()", "from __main__ import UsePlus")
>>> t2 = timeit.Timer ("UseJoin ()", "from __main__ import UseJoin")
>>> напечатайте "% .2f usec / pass"% (1000000 * t1.timeit (number = 100000) / 100000)
2,48 мксек / проход
>>> напечатайте "% .2f usec / pass"% (1000000 * t2.timeit (number = 100000) / 100000)
2,61 мксек / проход
>>>
  

У них практически одинаковая продолжительность работы.

Давайте использовать cProfile

  >>> myl = myl2
>>> cProfile.run ("UsePlus ()")
         5 вызовов функций за 0,001 секунды ЦП

   Упорядочено по: стандартному названию

   ncalls tottime percall cumtime percall имя файла: белье (функция)
        1 0,001 0,001 0,001 0,001 : 1 (UsePlus)
        1 0,000 0,000 0,001 0,001 <строка>: 1 (<модуль>)
        1 0,000 0,000 0,000 0,000 {len}
        1 0,000 0,000 0.000 0.000 {метод 'disable' объектов '_lsprof.Profiler'}
        1 0,000 0,000 0,000 0,000 {диапазон}


>>> cProfile.run ("UseJoin ()")
         5005 вызовов функций за 0,029 секунды ЦП

   Упорядочено по: стандартному названию

   ncalls tottime percall cumtime percall имя файла: белье (функция)
        1 0,015 0,015 0,029 0,029 : 1 (UseJoin)
        1 0,000 0,000 0,029 0,029 <строка>: 1 (<модуль>)
        1 0,000 0,000 0,000 0.000 {len}
        1 0.000 0.000 0.000 0.000 {метод 'disable' объектов '_lsprof.Profiler'}
     5000 0,014 0,000 0,014 0,000 {метод 'join' объектов 'str'}
        1 0,000 0,000 0,000 0,000 {диапазон}
  

И похоже, что использование Join приводит к ненужным вызовам функций, которые могут увеличить накладные расходы.

Теперь вернемся к вопросу. Следует ли во всех случаях препятствовать использованию + вместо присоединиться к ?

Полагаю, что нет, надо принимать во внимание

1. Длина рассматриваемой строки
2. Нет операции конкатенации.

И конечно же в разработке преждевременная оптимизация — это зло.

Конкатенация строкового литерала

Python — qaru

Прочтите справочное руководство , там .
В частности:

Допускается использование нескольких смежных строковых или байтовых литералов (разделенных пробелом), возможно, с использованием различных соглашений о кавычках, и их значение такое же, как и их конкатенация. Таким образом, «hello» «мир» эквивалентно «helloworld». Эту функцию можно использовать для уменьшения количества необходимых обратных косых черт, для удобного разделения длинных строк на длинные строки или даже для добавления комментариев к частям строк,

^{(упорная шахта )}

Вот почему:

  string = str ("Некоторые символы"
         "Еще несколько символов")
  

в точности совпадает с: str («Несколько символов, несколько символов») .

Это действие выполняется везде, где может появиться строковый литерал, инициализации списка, вызовы функций (как в случае с str выше) и так далее.

Единственное предостережение — когда строковый литерал не содержится между одним из разделителей группировки () , {} или [] , а вместо этого распространяется между двумя отдельными физическими строками. В этом случае мы можем альтернативно использовать символ обратной косой черты, чтобы соединить эти строки и получить тот же результат:

  string = "Некоторые символы" \
         "Еще несколько символов"
  

Конечно, конкатенация строк в одной физической строке не требует обратной косой черты.( string = "Hello" "World" отлично)

Соединяет ли Python эти две отдельные строки или редактор / компилятор обрабатывает их как одну строку?

Python, теперь , когда именно Python делает это, становится интересно.

Из того, что я мог собрать ( воспринимайте это с долей скепсиса, я не эксперт по синтаксическому анализу ), это происходит, когда Python преобразует дерево синтаксического анализа ( LL (1) Parser ) для данного выражения в это соответствует AST (абстрактное синтаксическое дерево) .

Вы можете получить представление о проанализированном дереве через анализатор модуль:

  синтаксический анализатор импорта

expr = "" "
       str ("Привет"
           "Мир")
"" "
pexpr = parser.expr (выражение)
parser.st2list (pexpr)
  

Это выводит довольно большой и запутанный список, который представляет конкретное синтаксическое дерево, проанализированное из выражения в expr :

  - остальное для краткости обрезано -

          [322,
             [323,
                [3, '"привет"'],
                [3, '"мир"']]]]]]]]]]]]]]]]]],

- остальное для краткости обрезано -
  

Числа соответствуют символам или токенам в дереве синтаксического анализа, а отображения символа в правило грамматики и токена в константу находятся в Lib / symbol.py и Lib / token.py соответственно.

Как вы можете видеть в добавленной мной сокращенной версии, у вас есть две разные записи, соответствующие двум разным литералам str в анализируемом выражении.

Затем мы можем просмотреть выходные данные дерева AST, созданного предыдущим выражением, с помощью модуля ast , представленного в стандартной библиотеке:

  p = ast.parse (expr)
ast.dump (p)

# выводит следующее:
"Модуль (body = [Expr (value = Call (func = Name (id = 'str', ctx = Load ()), args = [Str (s = 'hello world')], keywords = []))] ) "
  

В этом случае вывод более удобен для пользователя; вы можете видеть, что args для вызова функции — это единственная объединенная строка Hello World .

Вдобавок еще наткнулся на прикольный модуль, который генерирует визуализацию дерева для аст узлов. Используя его, вывод выражения expr визуализируется следующим образом:

^{Изображение обрезано, чтобы показать только соответствующую часть выражения.}

Как вы можете видеть, в оконечном листовом узле у нас есть единственный объект str , объединенная строка для «Hello» и «World» , т.е.e «Привет, мир» .

Если вы чувствуете себя достаточно храбрым, покопайтесь в источнике, исходный код для преобразования выражений в дерево синтаксического анализа находится по адресу Parser / pgen.c , а код, преобразующий дерево синтаксического анализа в абстрактное дерево синтаксиса, находится в Python / ast.c .

Эта информация относится к Python 3.5 , и я почти уверен, что если вы не используете какую-то очень старую версию ( <2.5 ) функциональность и расположение должны быть аналогичными .

Кроме того, если вас интересует весь этап компиляции, который следует за Python, хорошее мягкое вступление предоставлено одним из основных участников, Бреттом Кэнноном, в видео From Source to Code: How CPython's Compiler Works .

Конкатенация строк

в Python - AskPython

Конкатенация - это метод объединения строк для образования новой строки.

Ниже приведены методы для выполнения конкатенации строк в Python:

1. С помощью оператора +
2. С помощью метода join ()
3. С помощью оператора %
4. С помощью функции format ()
5. С помощью Интерполяция литеральной строки
6. С помощью StringIO из модуля ввода-вывода
7. Используя + = оператор конкатенации

1.Объединение строк с использованием оператора +

Синтаксис : строка1 + строка2

str1 = 'Сафа'
str2 = 'Мулани'

результат = str1 + str2

печать (результат)
 

Выход : SafaMulani

2. Объединение строк Python с использованием метода join ()

Синтаксис : join (строка1, строка2)

str1 = 'Сафа'
str2 = 'Мулани'

print ("" .join ([str1, str2]))
 

Выход : Safa Mulani

3.Объединение строк с использованием оператора%

Синтаксис :% (строка1, строка2)

str1 = 'Сафа'
str2 = 'Мулани'
результат = "% s% s"% (str1, str2)
print ('Объединенная строка =', результат)

 

Выход : конкатенированная строка = Safa Mulani

4. Объединение строк с использованием функции format ()

Синтаксис : формат (строка1, строка2)

str1 = 'Сафа'
str2 = 'Мулани'
res = "{} {}". format (str1, str2)
print ('Объединенная строка =', res)

 

Выход : конкатенированная строка = Safa Mulani

5.Конкатенация строк с использованием интерполяции буквальных строк

Версии

Python 3.6+ позволяют нам использовать f-строку для конкатенации строк, введенную в Literal String Interpolation.

Синтаксис : f '{строка1} {строка2} ’

str1 = 'Сафа'
str2 = 'Мулани'
res = f '{str1} {str2}'
print ('Объединенная строка =', res)
 

Выход : конкатенированная строка = Safa Mulani

6. Объединение строк с использованием StringIO из модуля ввода-вывода

из io import StringIO
 
результат = StringIO ()
 
результат.написать ('Сафа')
 
result.write ('Mulani')
 
result.write ('Разработка')
  
печать (результат.getvalue ())
 

Выход : Safa Mulani Engineering

7. Использование оператора конкатенации + =

Синтаксис : строка1 + = строка2

str1 = 'Сафа'
 
str2 = 'Мулани'
 
str1 + = str2
 
печать (str1)
 

Выход : Safa Mulani

Список литературы

Объединение строк Python - Подсказка для Linux

Объединение строк означает создание новой строки путем объединения двух или более строковых значений.Многие встроенные методы и оператор ‘+’ используются для объединения строковых значений во многих языках программирования. ‘+’ Оператор также используется в Python для комбинирования строковых значений, но работает иначе, чем другие языки сценариев. В JavaScript, когда строковое значение комбинируется с числовым значением, числовое значение автоматически преобразуется в строку и объединяется с другим строковым значением. Но если вы выполните ту же задачу в Python, это вызовет ошибку, потому что Python не может автоматически преобразовать число в строку.В Python существует множество других способов комбинирования строковых значений. В этой статье показано, как можно выполнить конкатенацию строк в Python разными способами. Здесь для написания и выполнения сценариев этой статьи используется редактор spyder3 .

Объединение строк с использованием оператора «+»

Создайте файл python со следующим сценарием, чтобы проверить, как оператор ‘+’ работает в Python для конкатенации строк. Переменным с именами str1 и str2 присваиваются два строковых значения.Эти два значения правильно скомбинированы и напечатаны. Затем одно строковое значение и числовое значение присваиваются переменным с именами text и price . Если вы хотите объединить эти значения, это сгенерирует ошибку, указав, что значение int может быть преобразовано в str . Таким образом, числовое значение преобразуется в строковое значение с помощью метода str () перед объединением данных.

#! / usr / bin / env python3
# Определить строковые значения
str1 = "Мне нравится"
str2 = "Programming"

# Объединение строкового значения с другим строковым значением
commonText1 = str1 + str2

# Распечатать объединенный вывод
print ("Объединение строки со строкой: \ n" ,commonText1)

# Определить строковое значение
text = "Цена книги составляет"

# Определение числового значения
price = 50

# Объединение строкового значения с числовым значением
commonText2 = text + "$" + str (price)

# Печать объединенный вывод
print ("\ nCombining string with number: \ n", combText2)

Вывод:

Результат показан в правой части изображения.

Объединение строк с использованием оператора «%»

Создайте файл python со следующим сценарием, чтобы проверить, как символ «%» работает для конкатенации строк в Python. Он работает как строковое форматирование языка C. Здесь переменным присваиваются два строковых значения: str1 и str2. Вы можете объединить два или более строковых значения, создав группу, разделенную запятыми, и используя символ «%» в начале группы. Здесь первые квадратные скобки () используются для группировки строковых значений, а «% s» используется в методе print () для определения того, что печатаемые значения являются строковыми.

#! / usr / bin / env python3
# Определить два строковых значения
str1 = "Python"
str2 = "является популярным языком сценариев"

# Объедините строковые значения с помощью оператора '%'
print ("Результат после объединения строк: \ n \ n% s% s"% (str1, str2))

Вывод:

Результат показан в правой части изображения.

Конкатенация строк с использованием формата

() метод

Если вы хотите более конкретно комбинировать строковые значения, вы должны использовать метод format () языка Python.Используя этот метод, вы можете комбинировать строковые значения в зависимости от их позиций. Позиции строки считаются как 0,1,2 и так далее. Два строковых значения берутся у пользователя и присваиваются переменным с именами str1 и str2 . Затем эти переменные используются в методе format () в качестве аргументов. Позиции переменных в сценарии не упоминаются. Итак, позиции переменных по умолчанию - 0 и 1.

#! / usr / bin / env python3
# Определить два строковых значения
str1 = input ("Введите первое строковое значение \ n")
str2 = input ("Введите второе строковое значение \ n")

# Объедините строковые значения с помощью оператора format ()
commonText = "{} {}".format (str1, str2)

# Распечатать объединенный текст
print ("Результат после объединения строк: \ n \ n" ,commonText)

Вывод:

Результат показан в правой части изображения. Здесь два входных значения: «Linux» и «Подсказка» , а выходными являются « LinuxHint » после объединения.

Конкатенация строк с использованием метода

join ()

join () - еще один полезный метод Python для объединения строк.Если вы хотите добавить какое-либо конкретное строковое значение во время конкатенации строк, вам потребуется использовать метод join () для конкатенации. Создайте файл python со следующим скриптом, чтобы проверить использование метода join () . Переменным с именами str1 , str2 и str3 присваиваются три строковых значения. Первый join () используется для объединения строк без какой-либо конкретной строки. Второй join () используется для объединения строковых значений с запятой (,).Третий join () используется для объединения строковых значений с новой строкой (\ n).

#! / usr / bin / env python3
# Определите два строковых значения

str1 = "Python Programmming"
str2 = "Bash Programming"
str3 = "Java Programming"

# Использование метода join () для объединения строк
combText = "" .join ([str1, str2, str3])

# Распечатать результат
print ("\ nOutput: \ n% s" %commonText)

# Использование метода join () с запятой для объединения строк
combText = ",".join ([str1, str2, str3])

# Распечатать результат
print ("\ nOutput: \ n% s" %commonText)

# Использование метода join () с новой строкой для объединения строк
commonText = "\ n ".join ([str1, str2, str3])

# Распечатать вывод
print (" \ nOutput: \ n% s "%commonText)

Вывод:

Результат показан в правой части изображения.

Объединение строки кортежа с помощью метода join ()

Создайте файл Python с помощью следующего сценария.Здесь метод join () объединит строковые значения кортежа с новой строкой (\ n).

#! / usr / bin / env python3
# Определить кортеж строковых значений
tupleString = ("Ubuntu", "Windows", "MacOS", "Fedora", "Android", "RedHat")

# Объедините строковые значения кортежа с помощью метода join ()
commonText = "\ n" .join (tupleString)

# Распечатать результат
print ("\ nСписок операционных систем: \ n \ n% s" %commonText)

Вывод:

Результат показан в правой части изображения.

Сгенерировать последовательность строк путем объединения двух строк

Последовательность строковых значений может быть легко сгенерирована с помощью метода join (). Создайте файл Python со следующим сценарием, чтобы создать последовательность алфавита с номером.

#! / usr / bin / env python3
# Определить два строковых значения
str1 = "ABCD"
str2 = "1"

# Сгенерировать последовательность строк с помощью метода join ()
commonText = str2.join (str1)

# Распечатать результат
print ("\ n% s" %commonText)

Вывод:

Результат показан в правой части изображения.