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

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

Работа со строками нужна много где: создание логов, пользовательский текст, выдача текста читателю, парсинг страниц и так далее. Поэтому нет ничего удивительного в том, что объединение строк (их конкатенацию) можно производить сразу несколькими встроенными способами. Основные – это перегрузка оператора «+» и встроенный метод join в Python, хотя есть и более экстравагантные варианты, вроде объединения через print и обращения к методу перегрузки. Ниже мы перечислим все эти способы и вкратце отметим их эффективность – когда много строк объединяется в одну, и это нужно сделать 100 000 раз, эффективность начинает играть решающее значение.

Теория: что такое .join()

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

ООП, методы, перегрузка

ООП – это парадигма (набор идей) программирования, согласно которой все сущности можно разбить на объекты. Объекты, в свою очередь, являются экземплярами классов. Эта парадигма пришла к нам из реальной жизни, как хрестоматийный пример – есть абстрактный класс «стул», который мы представляем себе как набор параметров, и есть конкретный объект «стул», об который мы отбиваем себе мизинчик ночью. ООП – большая тема, но нас в контексте объединения строк интересуют 2 конкретные вещи: методы и перегрузка.

Метод – это набор действий, которые может совершать определенный объект. Методы прописываются у класса, и каждый объект данного класса этими методами обладает. Перегрузка – это когда мы берем какие-нибудь операторы (например, «+»), и задаем им поведение при различных типах объектов. Перегрузку проще понять на практике: 2 + 2 = 4. Здесь ничего пояснять не надо – оператор «+» перегружен таким образом, что если слева и справа от него стоят 2 числа, то он складывает их и оправляет куда-то результат. А теперь давайте предположим, что у нас есть 2 объекта – первый, date_of_launch, хранит дату запуска сервера в формате дд.мм.гггг, а второй, uptime, хранит текущий аптайм (длительность с момента запуска) сервера в секундах. Мы хотим узнать текущую дату из этих данных, то есть нам нужно сложить данные из первого объекта с данными из второго объекта, причем 86 400 секунд из второго объекта равны одному дню первого объекта. Конечно, можно написать функцию, все это складывающую, и писать нам ее придется в любом случае, но если такое сложение приходится выполнять часто, то проще писать

date_of_launch + uptime, чем result = function_name(date_of_launch, uptime)

да и поменять местами аргументы в случае с функцией так просто уже не получится (не говоря уже о том, что функция должна лежать в каком-то классе/объекте). Перегрузка – это когда мы оператору «+» даем задачу: «если с одной стороны от тебя находится объект типа date_of_launch, а с другой лежит uptime, то ты запускаешь функцию их сложения, после чего возвращаешь результат». То есть мы засовываем функцию подсчета в знак «+».

Реализация .join() для конкатенации

Последний теоретический штрих, после которого мы перейдем к практике: все в Python является объектом. А раз все является объектом, то оно вполне может иметь встроенные функции и перегрузку операторов – вот мы и подошли к + и join в Python. Join в Питоне – это основной способ конкатенации нескольких строк. Синтаксис:

• ‘’ – строка, которая будет работать как разделитель.
• . – вызов встроенного метода строки.
• Join – имя метода.
• Iterable – объект, из которого будут браться строки для конкатенации.

Синтаксис может казаться не самым интуитивным, но иначе сделать нельзя: поскольку join является встроенным методом объекта «строка», нам нужно взять какую-то строку и вызвать ее метод join, для чего в примере выше используется пустая строка. Чтобы эта часть команды была не совсем бесполезной, разработчики языка решили брать из строки разделитель: если вы напишете

то результатом будет hello1world. Заметьте, что в функцию передается строго один итерируемый (тот, который можно последовательно перебрать) объект, так уж устроена функция. Из этого следуют не совсем очевидные артефакты, например: в Python объединение словарей в строку возможно только по ключам, если не использовать дополнительные функции. То есть если вы скармливаете функции join словарь, то функция возьмет все ключи словаря и объединит их в одну строку, а значения отбросит. Чтобы объединить значения, вам нужно подать на вход

– функцию словаря, которая возвращает исключительно значения.

Реализация перегрузки для конкатенации

Ну и напоследок – про «+». У каждого объекта есть встроенная функция __add__, внутри этой функции описаны действия, которые нужно совершить, если встречается конструкция «объект + еще_какой-то_объект», то есть функция реализует перегрузку. В __add__ для string прописано, что если встречается конструкция «string + string», то нужно создать новую строку, в которой эти две строки будут объединены, и вернуть эту новую строку. Все.

Практика: работа + и .join()

Как пользоваться + и .join() для соединения строк:

Передаем список, возвращает «abc»:

Если строк много

И +, и join одинаково умеют справляться с множеством строк. Если используете +, то нужно писать string1 + string2 + string3 + … + stringN. Если же используете join, то нужно передать в функцию любой итерируемый объект (обычно – список) с любым количеством строк, и они будут объединены.

vowels = ["a", "e", "i", "o", "u"] vowelsCSV = ",".join(vowels) print("Vowels are link__3">
Производительность
Join производительнее, чем +. Это справедливо практически для всех функций в Python: чем более специфична функция, тем более она производительна. NumPy (библиотека с математическими операциями) вообще в 5-10 раз более производительна, чем стандартные математические операции Python. Причина повышенной производительности – в том, что join имеет возможность заранее посчитать необходимое место в памяти для всех операций, а + вынужден обращаться к памяти каждый раз, когда встречает новую строку. При использовании «+» в цикле происходит примерно следующее:
 
Происходит множество обращений к памяти, потому что каждый стандартный разделитель (пробел) – это отдельное обращение. .join() же оптимизирован – он сначала анализирует количество стандартных разделителей и элементов (строк), выделяет для всех них память, и уже после этого соединяет строку:
 
 
Поэтому у join меньше обращений к памяти (системных вызовов к операционной системе), отсюда и более высокая производительность.
 
Другие способы
Здесь мы перечислим варианты, которые не стоит использовать для конкатенации строк без большой на то необходимости. Они – неочевидные и неоптимизированные, вы ухудшите и читаемость кода, и производительность.
 
Оператор %
Этот оператор нужен для форматирования выводимых строк. Вообще, просто использовать его для конкатенации строк – крайне избыточно, но технически вы можете этим воспользоваться. Синтаксис:
“%s%s%s” % (“Hello ”, ”world”, ”!”)
 
На место каждой %s подставляются строки, которые мы указываем в скобках, по порядку.
 
Функция format()
 
Почти то же, что и предыдущий вариант, но дает немного больше гибкости:
 
Как видите, теперь значения подставляются не произвольно, а в таком порядке, в котором мы указываем.
 
Использование f-строки
 
Дальнейшая эволюция предыдущих двух методов. F-строки в Python – это строки, которые можно гибко форматировать. F-строка объявляется через f перед
 
В такие строки можно вставлять переменные:
 
string1 = “Hello” string2 = “!” result = f” world”
 
Print
 
Print в Python не так прост, как может показаться на первый взгляд. Его возможности по конкатенации строк могу пригодиться вам, если вы будете выводить информацию в файл. Разберемся в следующем куске кода:
 
with open('result.txt', 'w', encoding='utf-8') as file1: for i in range(1, 4): print(i, i**2, i**3, sep=”->”, end=” | ”, file=file1)
 
В результате выполнения в файл запишется: 1->1->1 | 2->4->8 | 3->9->27
 
Что произошло? В первой строке мы просто открываем файл безопасным образом – он автоматически закроется, когда код будет выполнен. Далее мы запускаем цикл от 1 до 3, для каждого числа мы выводим его квадрат и 3-ю степень. Для этого мы используем print и 2 именованных аргумента: sep и end. Sep – это разделитель, который вставляется между аргументами, которые мы передаем в print, по умолчанию sep – пробел. End – это то, что вставляется в конце строки, по умолчанию это перевод курсора на новую строку (\n). Поскольку мы переопределили их, вместо пробела между аргументами вставляется «->», а вместо перевода строки вставляется « | ». Последний аргумент указывает принту на файл, в который нужно выводить информацию.
 
Что почитать по теме
 
FAQ
 
Можно ли изменять строки в Python?
 
Нет, строки в Python – неизменяемые, поэтому результат конкатенации нужно сохранять в другую переменную или сразу подавать в метод.
 
Каким методом пользуются чаще всего?
 
Если производительность не важна, то используют «+». Если операций – много, и производительность начинает иметь значение, то используют join.
 
Подведем итоги
 
 
Основные методы конкатенации – «+» и join.
 
Чтобы использовать «+», нужно просто поместить слева и справа от него строки для объединения.
 
Для того, чтобы использовать join, нужно вызвать его у строки, и в качестве аргумента подать итерируемый объект, содержащий строки.
 
При выводе в файл можно конкатенировать строки с помощью print и именованных параметров sep, end и file.
 
 
Источник