Как складывать строки в питоне

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

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

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

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

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

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

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

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

>>> ''.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 = "".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.

Следите за новыми постами по любимым темам

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

Строковый тип данных в Python: string

Строка — это некоторая последовательность символов. В языке Python строковые данные имеют формат str.

Строка в Python

Создадим первую текстовую переменную. Для создания строки можно использовать как одинарные, так и двойные кавычки:

>>> s = 'Hello world' >>> s 'Hello world' >>> s = "Hello world" >>> s 'Hello world'

Вывод в Python всегда будет в одинарных кавычках, так как производится перевод двойных кавычек в одинарные.

Проверим тип этой переменной:

>>> type(s)

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

>>> s='''Hello World!!''' >>> s 'Hello\nWorld!!'

В данном примере сохранился знак перехода на новую строку (‘\n’).

Преобразование чисел в строки и обратно

Любое число можно преобразовать в строку. Для этого используется функция str() давайте попробуем:

>>> str(1232) '1232' >>> str(-0.5) '-0.5'

Теперь попробуем выполнить обратное действие

>>> s = '123' >>> int(s) 123 >>> float(s) 123.0 >>> s = '1.23' >>> float(s) 1.23 >>> int(s) Traceback (most recent call last): File "", line 1, in int(s) ValueError: invalid literal for int() with base 10: '1.23'

Если вид числа не удовлетворяет типу данных, то преобразование не выполняется. Компилятор выдает ошибку вида invalid literal, что в переводе означает недопустимый литерал (символ), из-за наличия точки, то есть данное число является числом с плавающей точкой (float).

Чтобы избежать данной ошибки, в первую очередь необходимо выполнить преобразование в тип float. Если нужно, то затем преобразовываем полученный float в int.

>>> s='0.23' >>> int(float(s)) 0

Основные операции со строками в Python

Длина строки

В Python строка представляет собой массив символов, расположенных в определенной последовательности. Когда мы пишем:

>>> s='Hello world'

Компьютер представляет это следующим образом:

0	1	2	3	4	5	6	7	8	9	10
H	e	l	l	o	w	o	r	l	d

Воспользуемся функцией len(), чтобы узнать длину строки.

>>> len(s) 11

Как и было указано выше, длина данной строки — 11 символов (нумерация начинается с нуля).

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

>>> s[2] 'l' >>> s[4] 'o'

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

>>> s='Hello world' >>> s[2:5] 'llo'

Сложение строк

Давайте попробуем сложить 2 строки:

>>> s1='Hello' >>> s2='world' >>> s1+s2 'Helloworld'

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

>>> s1='Hello' >>> s2='world' >>> s1+' '+s2+"!" 'Hello world!'

Попробуем сложить строки и числа:

>>> s1='number ' >>> s1+1 Traceback (most recent call last): File "", line 1, in s1+1 TypeError: can only concatenate str (not "int") to str

Строковой тип данных можно складывать только с таким же типом.

Достаточно выполнить преобразование, чтобы получить правильное решение:

>>> s1+str(1) 'number 1'

Умножение строк

Давайте попробуем выполнить различные умножения: на целое число, на дробное число, на само себя:

>>> s='Hi' >>> s*2 'HiHi' >>> s*1.2 Traceback (most recent call last): File "", line 1, in s*1.2 TypeError: can't multiply sequence by non-int of type 'float' >>> s*s Traceback (most recent call last): File "", line 1, in s*s TypeError: can't multiply sequence by non-int of type 'str'

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

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

Курсы Робикс, в которых изучается этот материал.

1. Программирование на Python в Minecraft
2. Duckietown робот с системой Автопилота

Useful blog

Linux, Java, Python, Php, Javascript, FTP, SSH, HTTP, настройки, конфигурирование, администрирование и т.п. Всё, с чем приходится сталкиваться.

понедельник, 31 января 2011 г.

Python — сложение строк или конкатенация

В питоне складывать строки очень просто, вот примеры, из которых все понятно:
Пример №1

>>>print ‘Привет! ‘ + ‘Как дела?’
Привет! Как дела?

>>> a = ‘Хорошо’
>>> b = ‘ А у тебя как?’
>>> c = a + b
>>> print c
Хорошо А у тебя как?

Пример №3 (c преобразованием числа в строку)

>>> x = 12
>>> y = 6
>>> print ’12 * 6 = ‘+str(x*y)
12 * 6 = 72

5 комментариев:

не вводите людей в заблуждение. При конкатенации строк в python пробела между строками нет! Ответить Удалить

Анон, смотри внимательнее:
‘ А у тебя как?’ < В начале строки пробел. Ответить Удалить

Может нужно было сказать про метод join?
Он более эффективен для сложения строк в python. Вот только не пойму, при сложении 2 или 3 строк писать таки join или + ?
При 20 и больше строках однозначно верю что join Ответить Удалить

Пробела во второй строке точно не вижу. Join 100500 более выгоден, чем «+», так как «+» надо пропарсить, а join просматривается в первую очередь.
Да и конструкции при многократном сложении строк выглядят несколько в духе basic, что ес-но непитонично. Не говоря уже о скорости. Ответить Удалить

Индексация и разделение строк в Python 3

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

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

Индексация строк

Как и тип данных списка, который содержит элементы, соответствующие индексу, строки также содержат символы, которым соответствуют индексы, начиная с 0.

Для строки Sammy Shark! индекс выглядит следующим образом:

S	a	m	m	y	S	h	a	r	k	!
0	1	2	3	4	5	6	7	8	9	10	11

Как видите, первая S начинается с индекса 0, а заканчивается строка символом ! с индексом 11.

Также отметим, что символу пробела между Sammy и Shark также соответствует собственный индекс. В данном случае пробелу соответствует индекс 5.

Восклицательному знаку ( ! ) также соответствует индекс. Все другие специальные символы и знаки препинания, в том числе *#$&. ;? , также являются символами и будут иметь свои индексы.

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

Доступ к символам через положительный числовой индекс

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

ss = "Sammy Shark!" print(ss[4]) 

Output
y 

Когда мы ссылаемся на определенный числовой индекс строки, Python возвращает символ, находящийся на соответствующей позиции. Поскольку букве y соответствует индекс 4 строки ss = «Sammy Shark!» , когда мы выводим ss[4] , мы получаем y в качестве вывода.

Числовые индексы позволяют получать доступ к определенным символам в строках.

Доступ к символам через отрицательный индекс

Если у нас имеется длинная строка, и мы хотим использовать символ ближе к концу строки, мы также можем использовать обратный отсчет от конца строки, начиная с индекса -1 .

Для той же строки Sammy Shark! отрицательная разбивка индекса выглядит следующим образом:

S	a	m	m	y	S	h	a	r	k	!
-12	-11	-10	-9	-8	-7	-6	-5	-4	-3	-2	-1

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

print(ss[-3]) 

Output
r 

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

Разделение строк

Также мы можем вызвать ряд символов из строки. Допустим, мы хотим вывести слово Shark . Для этого мы можем создать срез, представляющий собой последовательность символов в исходной строке. С помощью срезов мы можем вызывать несколько значений символов, создавая диапазоны символов, разделенные двоеточием [x:y] :

print(ss[6:11]) 

Output
Shark 

При построении среза, такого как [6:11] , первый индекс соответствует началу среза (включительно), а второй — окончанию среза (не включительно). Поэтому в нашем примере конец диапазона обозначается индексом позиции сразу после конца строки.

При разделении строк на срезы мы создаем подстроки, то есть, строки внутри других строк. Вызывая ss[6:11] , мы вызываем подстроку Shark , существующую в строке Sammy Shark! .

Если мы хотим включить любой конец строки, мы можем пропустить одно из чисел в синтаксисе string[n:n] . Например, если нам нужно вывести первое слово строки ss — “Sammy”, мы можем сделать это так:

print(ss[:5]) 

Output
Sammy 

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

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

print(ss[7:]) 

Output
hark! 

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

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

Давайте используем два отрицательных индекса для создания среза строки ss :

print(ss[-4:-1]) 

Output
ark 

Подстрока “ark” выводится из строки “Sammy Shark!”, потому что символ “a” соответствует индексу -4, а символ “k” находится перед позицией индекса -1.

Определение шага при создании срезов строк

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

Давайте снова посмотрим на пример выше, который выводит подстроку “Shark”:

print(ss[6:11]) 

Output
Shark 

Мы можем получить те же результаты, добавив третий параметр шага со значением 1:

print(ss[6:11:1]) 

Output
Shark 

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

Если же мы увеличим значение шага, некоторые символы будут пропущены:

print(ss[0:12:2]) 

Output
SmySak 

Если мы зададим шаг 2 как последний параметр в синтаксисе Python ss[0:12:2] , будет пропущен каждый второй символ. Выводимые символы обозначены красным цветом:

S a m m y S h a r k !

Обратите внимание, что символ пробела с индексом 5 также пропускается, если задан шаг 2.

Если мы используем более крупное значение шага, подстрока будет значительно короче:

print(ss[0:12:4]) 

Output
Sya 

Если мы укажем шаг 4 как последний параметр синтаксиса Python ss[0:12:4] , будет выведен только каждый четвертый символ. Выводимые символы также обозначены красным цветом:

S amm y Sh a rk!

В этом примере символ пробела тоже пропускается.

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

print(ss[::4]) 

Output
Sya 

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

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

print(ss[::-1]) 

Output
!krahS ymmaS 

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

Давайте повторим эту команду, но используем шаг -2:

print(ss[::-2]) 

Output
!rh ma 

В этом примере, ss[::-2] , мы включаем в диапазон всю первоначальную строку, поскольку индексы не указаны, и задаем обратный порядок вывода отрицательным значением шага. Кроме того, с шагом -2 мы пропускаем каждую вторую букву строки, выводимой в обратном порядке:

! k r a h S [пробел] y m m a S

В этом примере выводится символ пробела.

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

Методы подсчета

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

Вначале мы рассмотрим метод len() , который поможет определить длину любого типа данных упорядоченной или неупорядоченной последовательности, включая строки, списки, кортежи и словари.

Давайте выведем длину строки ss :

print(len(ss)) 

Output
12 

Длина строки “Sammy Shark!” составляет 12 символов, включая символ пробела и символ восклицательного знака.

Вместо использования переменной мы также можем передать строку прямо в метод len() :

print(len("Let's print the length of this string.")) 

Output
38 

Метод len() подсчитывает общее количество символов в строке.

Если нам нужно подсчитать, сколько раз в строке встречается определенный символ или последовательность символов, мы можем использовать метод str.count() . Давайте возьмем нашу строку ss = «Sammy Shark!» и подсчитаем, сколько раз в ней встречается символ “a”:

print(ss.count("a")) 

Output
2 

Мы можем поискать и другой символ:

print(ss.count("s")) 

Output
0 

Хотя в строке есть буква “S”, важно понимать, что при подсчете учитывается регистр. Если мы хотим найти все буквы в строке независимо от регистра, мы можем использовать метод str.lower() , чтобы предварительно конвертировать все символы строки в нижний регистр. Вы можете узнать больше об этом методе в учебном модуле Введение в методы строк в Python 3.

Давайте попробуем использовать str.count() с последовательностью символов:

likes = "Sammy likes to swim in the ocean, likes to spin up servers, and likes to smile." print(likes.count("likes")) 

Output
3 

В строке likes последовательность символов, эквивалентная “likes”, встречается в исходной строке 3 раза.

Также мы можем определить позицию символа или последовательности символов в строке. Для этого мы можем использовать метод str.find() , который выводит позицию символа на базе номера индекса.

Мы можем посмотреть, где появляется первый символ “m” в строке ss :

print(ss.find("m")) 

Ouput
2 

Первый символ “m” появляется в строке “Sammy Shark!” на позиции с индексом 2. Мы можем проверить позиции индекса в строке ss выше.

Давайте посмотрим, где встречается первая последовательность символов “likes” в строке likes :

print(likes.find("likes")) 

Ouput
6 

Первый экземпляр последовательности символов “likes” начинается с индекса 6, соответствующего позиции символа l в последовательности likes .

Что делать, если, если мы хотим увидеть, где начинается вторая последовательность “likes”? Для этого мы можем передать второй параметр в метод str.find() , который будет начинаться с конкретного индекса. Вместо того, чтобы начинать с начала строки, начнем с индекса 9:

print(likes.find("likes", 9)) 

Output
34 

Во втором примере, который начинается с индекса 9, первая последовательность символов “likes” начинается с индекса 34.

Также мы можем указать в качестве третьего параметра конец диапазона. Как и в случае со срезами, мы можем использовать обратный отсчет, указав отрицательный индекс:

print(likes.find("likes", 40, -6)) 

Output
64 

В последнем примере мы ищем позицию последовательности “likes” между индексами 40 и -6. Поскольку последний параметр отрицательный, отсчет выполняется с конца первоначальной строки.

Методы строки len() , str.count() и str.find() можно использовать для определения длины, количества символов или последовательностей символов и индексов символов или последовательностей символов в строках.

Заключение

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

Чтобы продолжить изучение строк, вы можете прочитать дополнительные материалы по форматированию строк и методам строк.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.