Часть 1. Создание строк, повторение, доступ к символам, подсчет количества символов в строке и копирование строкового объекта.
Вероятно, наиболее широко используемый тип данных (помимо числовых типов, таких как, например, целые числа) в программной инженерии и компьютерных науках в целом — это… строка. Вездесущая строка — это не что иное, как простая последовательность символов. Символ в компьютерной терминологии — это единица информации, эквивалентная одной букве или символу алфавита, согласно этому источнику.
Строка обычно считается типом данных и часто реализуется как структура данных массива, хранящая последовательность элементов с использованием некоторой кодировки символов (например, ASCII или Unicode).
Однако в Python все является классом. И строки в Python не исключение. Они по-прежнему считаются последовательностями символов Unicode.
Создание строки
Мы можем сделать это в Python несколькими способами, в зависимости от того, как мы используем строку. Например, если нам нужна строка в буквальном виде, мы можем просто сделать:
my_string = "abc" print(my_string) Output: abc
То же самое происходит, когда нам нужно инициализировать строку как пустую строку:
my_empty_string = "" print(my_empty_string) Output:
Ничто не мешает нам использовать одинарные кавычки вместо двойных:
my_string = 'abc' print(my_string) Output: abc
Единственное, что вам нужно знать, это то, что в зависимости от стиля цитат, которые вы можете выбрать, некоторые ситуации могут быть немного сложными, например:
my_single_quote_string = 'I'm ready!'
Видите проблему? Строка теперь содержит 3 одинарных кавычки. И Python будет рассматривать только I как строку, а остальное как синтаксическую ошибку с нашей стороны. То же самое касается следующего:
my_double_quotes_string = "She said: "Get over here now!""
Python распознает только She said: как действительную строку, в то время как остальное в значительной степени оценивается как простая синтаксическая ошибка. Не то, что мы хотим.
Хитрость в обоих случаях заключается в эффективном объединении одинарных и двойных кавычек, в зависимости от контекста:
my_single_quote_string = "I'm ready!" my_double_quotes_string = 'She said: "Get over here now!"' my_other_double_quotes_string = "I said: 'Sure thing!'"
В Python также используются тройные кавычки ('''). Они позволяют использовать многострочные строки. То же самое касается тройных двойных кавычек ("""). Тройные двойные кавычки особенно полезны при создании строк документации класса/модуля/метода/функции. Вы можете прочитать больше о строках документации здесь в качестве отправной точки.
my_string = '''This is a
multiline string.'''
print(my_string)
Output:
This is a
multiline string.
Обратите внимание, как на самом деле сохранялся отступ от кода до вывода. Если нам это на самом деле не нужно, так как нас больше интересует просто сохранение коротких строк кода, мы могли бы разбить длинную строку следующим образом:
my_long_string = "This is a long string \ that's printed on a single line." print(my_long_string) Output: This is a long string that's printed on a single line.
Мы также могли бы использовать конструктор str(), который можно использовать либо для создания строки, либо для преобразования объекта другого типа в строку:
# create a string out of the number 123
number = 123
my_new_string = str(number)
print(f"{my_new_string} is a {type(my_new_string)}")
# create an empty string
my_new_empty_string = str()
print(my_new_empty_string)
Output:
123 is a <class 'str'>
Строки неизменяемы
Таким образом, изменение строки в конечном итоге приведет Python к созданию совершенно нового строкового объекта, содержащего новую последовательность символов:
# build the string
my_string = "abc"
print(f"{id(my_string)}: {my_string}")
# alter the string
my_string += "d"
print(f"{id(my_string)}: {my_string}")
Output:
139757030244464: abc
139757030562480: abcd
Как видно, добавляя букву d к нашей строке, мы можем подумать, что Python действительно выполнил операцию добавления к нашей исходной строке. Но на самом деле Python создал совершенно новый строковый объект, содержащий полную добавленную последовательность символов. Это доказывает неизменное свойство строк: мы не можем изменить содержимое строки, не изменив строковый объект.
Итерация по строке
Это можно сделать так же, как если бы мы перебирали, скажем, список:
my_string = "abc"
for letter in my_string:
print(letter)
Output:
a
b
c
Доступ к строковым символам
Опять же, аналогично тому, как мы разрезаем список, поскольку строки в Python упорядочены, мы можем применить к ним то же самое:
my_string = "abc" print(my_string[0:2]) print(my_string[-1]) Output: ab c
Подсчет количества символов в строке
Мы можем, как вы уже догадались, просто использовать функцию len, которая дает нам длину строки в символах:
my_string = "abc" length = len(my_string) print(length) Output: 3
Копирование строкового объекта — поверхностное копирование
Использование конструктора str:
# create the first string and its copy
my_string = "abc"
my_second_string = str(my_string)
print(f"{id(my_string)}: {my_string}")
print(f"{id(my_second_string)}: {my_second_string}")
# alter the second string
my_second_string += "d"
print(f"{id(my_string)}: {my_string}")
print(f"{id(my_second_string)}: {my_second_string}")
Output:
139939605151920: abc
139939605151920: abc
139939605151920: abc
139939605470320: abcd
Как видно, изменение второй строки не отражается на первой строке. Сразу после объявления двух строк мы наблюдаем ситуацию «две переменные, указывающие на один и тот же объект». Но поскольку строки неизменяемы, в тот момент, когда мы изменяем вторую строку, Python решает построить новый строковый объект, содержащий новое значение для второй строки, оставив первое без изменений. Мы увидим, что это поведение остается прежним, даже при попытке получить копии через copy.copy() или даже copy.deepcopy().
Действительно, используя подход copy.copy():
import copy
# create the first string and its copy
my_string = "abc"
my_second_string = copy.copy(my_string)
print(f"{id(my_string)}: {my_string}")
print(f"{id(my_second_string)}: {my_second_string}")
# alter the second string
my_second_string += "d"
print(f"{id(my_string)}: {my_string}")
print(f"{id(my_second_string)}: {my_second_string}")
Output:
140404784447664: abc
140404784447664: abc
140404784447664: abc
140404784766896: abcd
Те же результаты: поскольку строки неизменяемы, изменение в копии не отразится на исходном строковом объекте.
Использование copy.deepcopy():
import copy
# create the first string and its copy
my_string = "abc"
my_second_string = copy.deepcopy(my_string)
print(f"{id(my_string)}: {my_string}")
print(f"{id(my_second_string)}: {my_second_string}")
my_second_string += "d"
print(f"{id(my_string)}: {my_string}")
print(f"{id(my_second_string)}: {my_second_string}")
Output:
140288536264880: abc
140288536264880: abc
140288536264880: abc
140288536584176: abcd
Действительно, никакой разницы с предыдущими примерами.
И на этом первая часть подходит к концу. Следующая статья будет посвящена методам класса строк, которые мы можем использовать при работе со строками в Python. До тех пор оставайтесь в безопасности и счастливого кодирования! Ваше здоровье!
Дополнительные материалы на PlainEnglish.io. Подпишитесь на нашу бесплатную еженедельную рассылку новостей. Подпишитесь на нас в Twitter и LinkedIn. Присоединяйтесь к нашему сообществу Discord.
