Строки и символьные данные в Python

В руководстве поBasic Data Types in Python вы узнали, как определять объектыstrings:, содержащие последовательности символьных данных. Обработка символьных данных является неотъемлемой частью программирования. Это редкое приложение, которому не нужно манипулировать строками, по крайней мере, до некоторой степени.

Here’s what you’ll learn in this tutorial: Python предоставляет богатый набор операторов, функций и методов для работы со строками. Когда вы закончите работу с этим руководством, вы узнаете, как получить доступ и извлечь части строк, а также познакомитесь с методами, которые доступны для манипулирования и изменения строковых данных.

Вы также познакомитесь с двумя другими объектами Python, используемыми для представления необработанных байтовых данных, типамиbytes иbytearray.

__ Take the Quiz: Проверьте свои знания с помощью нашей интерактивной викторины «Строки и символьные данные Python». По окончании вы получите оценку, чтобы вы могли отслеживать прогресс в обучении с течением времени:

Пройти тест »

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

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

Строковые операторы

Вы уже видели, как операторы+ и* применялись к числовым операндам в учебнике поOperators and Expressions in Python. Эти два оператора могут быть применены и к строкам.

Оператор`+`

Оператор+ объединяет строки. Он возвращает строку, состоящую из операндов, соединенных вместе, как показано здесь:

>>>

>>> s = 'foo'
>>> t = 'bar'
>>> u = 'baz'

>>> s + t
'foobar'
>>> s + t + u
'foobarbaz'

>>> print('Go team' + '!!!')
Go team!!!

Оператор`*`

Оператор* создает несколько копий строки. Еслиs - строка, аn - целое число, любое из следующих выражений возвращает строку, состоящую изn объединенных копийs:

s * n
n * s

Вот примеры обеих форм:

>>>

>>> s = 'foo.'

>>> s * 4
'foo.foo.foo.foo.'
>>> 4 * s
'foo.foo.foo.foo.'

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

>>>

>>> 'foo' * -8
''

Если бы вы создали строковую переменную и инициализировали ее пустой строкой, присвоив ей значение'foo' * -8, кто-нибудь справедливо подумал бы, что вы немного глупы. Но это будет работать.

Оператор`in`

Python также предоставляет оператор членства, который может использоваться со строками. Операторin возвращаетTrue, если первый операнд содержится во втором, иFalse в противном случае:

>>>

>>> s = 'foo'

>>> s in 'That\'s food for thought.'
True
>>> s in 'That\'s good for now.'
False

Также есть операторnot in, который делает наоборот:

>>>

>>> 'z' not in 'abc'
True
>>> 'z' not in 'xyz'
False

Встроенные строковые функции

Как вы видели в руководстве поBasic Data Types in Python, Python предоставляет множество функций, которые встроены в интерпретатор и всегда доступны. Вот некоторые из них, которые работают со строками:

функция Описание

функция	Описание
`chr()`	Преобразует целое число в символ
`ord()`	Преобразует символ в целое число
`len()`	Возвращает длину строки
`str()`	Возвращает строковое представление объекта

chr()

Преобразует целое число в символ

ord()

Преобразует символ в целое число

len()

Возвращает длину строки

str()

Возвращает строковое представление объекта

Они более подробно рассматриваются ниже.

`ord(c)`

Возвращает целочисленное значение для данного символа.

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

Самая простая из распространенных схем называетсяASCII. Он охватывает обычные латинские символы, с которыми вы, вероятно, привыкли работать. Для этих символовord(c) возвращает значение ASCII для символаc:

>>>

>>> ord('a')
97
>>> ord('#')
35

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

Unicode - амбициозный стандарт, который пытается предоставить числовой код для каждого возможного символа на всех возможных языках и на всех возможных платформах. Python 3 широко поддерживает Unicode, включая использование символов Unicode в строках.

For More Information: См.Python’s Unicode Support в документации Python.

Пока вы остаетесь в области общих символов, между ASCII и Unicode практически нет различий. Но функцияord() также вернет числовые значения для символов Юникода:

>>>

>>> ord('€')
8364
>>> ord('∑')
8721

`chr(n)`

Возвращает символьное значение для данного целого числа.

chr() делает обратноеord(). Учитывая числовое значениеn,chr(n) возвращает строку, представляющую символ, соответствующийn:

>>>

>>> chr(97)
'a'
>>> chr(35)
'#'

chr() также обрабатывает символы Unicode:

>>>

>>> chr(8364)
'€'
>>> chr(8721)
'∑'

len(s)

Возвращает длину строки.

С помощьюlen() вы можете проверить длину строки Python. len(s) возвращает количество символов вs:

>>>

>>> s = 'I am a string.'
>>> len(s)
14

str(obj)

Возвращает строковое представление объекта.

Практически любой объект в Python может быть представлен в виде строки. str(obj) возвращает строковое представление объектаobj:

>>>

>>> str(49.2)
'49.2'
>>> str(3+4j)
'(3+4j)'
>>> str(3 + 29)
'32'
>>> str('foo')
'foo'

Индексирование строк

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

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

Индексирование строк в Python начинается с нуля: первый символ в строке имеет индекс0, следующий - индекс1 и так далее. Индекс последнего символа будет длиной строки минус один.

Например, схематическая диаграмма индексов строки'foobar' будет выглядеть так:

Отдельные символы могут быть доступны по индексу следующим образом:

>>>

>>> s = 'foobar'

>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> len(s)
6
>>> s[len(s)-1]
'r'

Попытка индексирования за концом строки приводит к ошибке:

>>>

>>> s[6]
Traceback (most recent call last):
  File "", line 1, in 
    s[6]
IndexError: string index out of range

Индексы строки также могут быть указаны с отрицательными числами, и в этом случае индексация выполняется с конца строки назад:-1 относится к последнему символу,-2 - к предпоследнему символу и т. Д. . Вот та же диаграмма, показывающая как положительные, так и отрицательные индексы в строке'foobar':

Вот несколько примеров негативной индексации:

>>>

>>> s = 'foobar'

>>> s[-1]
'r'
>>> s[-2]
'a'
>>> len(s)
6
>>> s[-len(s)]
'f'

Попытка индексировать с отрицательными числами после начала строки приводит к ошибке:

>>>

>>> s[-7]
Traceback (most recent call last):
  File "", line 1, in 
    s[-7]
IndexError: string index out of range

Для любой непустой строкиs,s[len(s)-1] иs[-1] возвращают последний символ. Нет никакого индекса, который имеет смысл для пустой строки.

Струнная нарезка

Python также допускает форму индексации синтаксиса, которая извлекает подстроки из строки, известную как срезы строк. Еслиs является строкой, выражение формыs[m:n] возвращает частьs, начиная с позицииm, и до, но не включая позициюn :

>>>

>>> s = 'foobar'
>>> s[2:5]
'oba'

Remember: Строковые индексы отсчитываются от нуля. Первый символ в строке имеет индекс0. Это относится как к стандартной индексации, так и к нарезке.

Опять же, второй индекс указывает первый символ, который не включен в результат - символ'r' (s[5]) в приведенном выше примере. Это может показаться немного неинтуитивным, но дает такой результат, который имеет смысл: выражениеs[m:n] вернет подстроку длинойn - m символов, в данном случае5 - 2 = 3.

Если вы пропустите первый индекс, срез начнется в начале строки. Таким образом,s[:m] иs[0:m] эквивалентны:

>>>

>>> s = 'foobar'

>>> s[:4]
'foob'
>>> s[0:4]
'foob'

Аналогично, если вы опустите второй индекс, как вs[n:], срез простирается от первого индекса до конца строки. Это хорошая и лаконичная альтернатива более громоздкомуs[n:len(s)]:

>>>

>>> s = 'foobar'

>>> s[2:]
'obar'
>>> s[2:len(s)]
'obar'

Для любой строкиs и любого целого числаn (0 ≤ n ≤ len(s))s[:n] + s[n:] будет равноs:

>>>

>>> s = 'foobar'

>>> s[:4] + s[4:]
'foobar'
>>> s[:4] + s[4:] == s
True

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

>>>

>>> s = 'foobar'
>>> t = s[:]
>>> id(s)
59598496
>>> id(t)
59598496
>>> s is t
True

Если первый индекс в срезе больше или равен второму индексу, Python возвращает пустую строку. Это еще один запутанный способ создания пустой строки, если вы ее искали:

>>>

>>> s[2:2]
''
>>> s[4:2]
''

Отрицательные индексы можно использовать и с нарезкой. -1 относится к последнему символу,-2 - предпоследнему и так далее, как и при простой индексации. На диаграмме ниже показано, как вырезать подстроку'oob' из строки'foobar', используя как положительные, так и отрицательные индексы:

Вот соответствующий код Python:

>>>

>>> s = 'foobar'

>>> s[-5:-2]
'oob'
>>> s[1:4]
'oob'
>>> s[-5:-2] == s[1:4]
True

Указание строки в фрагменте строки

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

Например, для строки'foobar' срез0:6:2 начинается с первого символа и заканчивается последним символом (всей строкой), и каждый второй символ пропускается. Это показано на следующей диаграмме:

Точно так же1:6:2 указывает срез, начинающийся со второго символа (индекс1) и заканчивающийся последним символом, и снова значение шага2 заставляет пропускать все остальные символы:

Иллюстративный код REPL показан здесь:

>>>

>>> s = 'foobar'

>>> s[0:6:2]
'foa'

>>> s[1:6:2]
'obr'

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

>>>

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'

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

>>>

>>> s = 'foobar'
>>> s[5:0:-2]
'rbo'

В приведенном выше примере5:0:-2 означает «начать с последнего символа и сделать шаг назад на2, вплоть до первого символа, но не включая его».

Когда вы делаете шаг назад, если первый и второй индексы опущены, значения по умолчанию меняются местами интуитивно: первый индекс по умолчанию равен концу строки, а второй индекс по умолчанию - началу. Вот пример:

>>>

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::-5]
'55555'

Это общая парадигма для обращения строки:

>>>

>>> s = 'If Comrade Napoleon says it, it must be right.'
>>> s[::-1]
'.thgir eb tsum ti ,ti syas noelopaN edarmoC fI'

Интерполяция переменных в строку

В Python версии 3.6 был представлен новый механизм форматирования строк. Эта функция официально называется литералом форматированной строки, но чаще упоминается ее псевдонимомf-string.

Возможности форматирования, предоставляемые f-строками, обширны и не будут подробно описаны здесь. Если вы хотите узнать больше, вы можете прочитать статьюPython 3’s f-Strings: An Improved String Formatting Syntax (Guide) на Real Python. Существует также учебное пособие по форматированному выводу, которое будет опубликовано позже в этой серии, в котором более подробно рассматриваются f-строки.

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

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

>>>

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print('The product of', n, 'and', m, 'is', prod)
The product of 20 and 25 is 500

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

Укажитеf в нижнем регистре илиF в верхнем регистре непосредственно перед открывающей кавычкой строкового литерала. Это говорит Python, что это f-строка вместо стандартной строки.
Укажите любые переменные, которые нужно интерполировать, в фигурных скобках ({}).

Пересмотрите, используя f-строку, приведенный выше пример выглядит намного чище:

>>>

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print(f'The product of {n} and {m} is {prod}')
The product of 20 and 25 is 500

Любой из трех механизмов цитирования Python может использоваться для определения f-строки:

>>>

>>> var = 'Bark'

>>> print(f'A dog says {var}!')
A dog says Bark!
>>> print(f"A dog says {var}!")
A dog says Bark!
>>> print(f'''A dog says {var}!''')
A dog says Bark!

Модификация строк

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

Такое утверждение приведет к ошибке:

>>>

>>> s = 'foobar'
>>> s[3] = 'x'
Traceback (most recent call last):
  File "", line 1, in 
    s[3] = 'x'
TypeError: 'str' object does not support item assignment

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

>>>

>>> s = s[:3] + 'x' + s[4:]
>>> s
'fooxar'

Для этого также есть встроенный строковый метод:

>>>

>>> s = 'foobar'
>>> s = s.replace('b', 'x')
>>> s
'fooxar'

Читайте дальше для получения дополнительной информации о встроенных строковых методах!

Встроенные Строковые Методы

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

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

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

Синтаксис для вызова метода на объект выглядит следующим образом:

obj.foo()

Это вызывает метод.foo() для объектаobj. <args> указывает аргументы, передаваемые методу (если есть).

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

В следующих определениях методов аргументы, указанные в квадратных скобках ([]), необязательны.

Преобразование дела

Методы в этой группе выполняют преобразование регистра для целевой строки.

s.capitalize()

Прописывает целевую строку.

s.capitalize() возвращает копиюs с первым символом, преобразованным в верхний регистр, а все остальные символы преобразованы в нижний регистр:

>>>

>>> s = 'foO BaR BAZ quX'
>>> s.capitalize()
'Foo bar baz qux'

Неалфавитные символы неизменны:

>>>

>>> s = 'foo123#BAR#.'
>>> s.capitalize()
'Foo123#bar#.'

s.lower()

Преобразует буквенные символы в строчные.

s.lower() возвращает копиюs со всеми буквенными символами, преобразованными в нижний регистр:

>>>

>>> 'FOO Bar 123 baz qUX'.lower()
'foo bar 123 baz qux'

s.swapcase()

Меняет регистр буквенных символов.

s.swapcase() возвращает копиюs с буквенными символами верхнего регистра, преобразованными в нижний регистр и наоборот:

>>>

>>> 'FOO Bar 123 baz qUX'.swapcase()
'foo bAR 123 BAZ Qux'

s.title()

Преобразует целевую строку в «case title».

s.title() возвращает копиюs, в которой первая буква каждого слова преобразована в верхний регистр, а остальные буквы в нижний регистр:

>>>

>>> 'the sun also rises'.title()
'The Sun Also Rises'

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

>>>

>>> "what's happened to ted's IBM stock?".title()
"What'S Happened To Ted'S Ibm Stock?"

s.upper()

Преобразует буквенные символы в прописные.

s.upper() возвращает копиюs со всеми буквенными символами, преобразованными в верхний регистр:

>>>

>>> 'FOO Bar 123 baz qUX'.upper()
'FOO BAR 123 BAZ QUX'

Найти и заменить

Эти методы предоставляют различные средства поиска целевой строки для указанной подстроки.

Каждый метод в этой группе поддерживает необязательные аргументы<start> и<end>. Они интерпретируются как нарезка строки: действие метода ограничено частью целевой строки, начинающейся с позиции символа<start> и продолжающейся до позиции символа<end>, но не включая ее. Если<start> указан, а<end> - нет, метод применяется к части целевой строки от<start> до конца строки.

s.count(_{[, [, ]])}

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

s.count() возвращает количество неперекрывающихся вхождений подстроки вs:

>>>

>>> 'foo goo moo'.count('oo')
3

Счетчик ограничивается количеством вхождений в подстроке, обозначенной<start> и<end>, если они указаны:

>>>

>>> 'foo goo moo'.count('oo', 0, 8)
2

s.endswith([, [, ]])

Определяет, заканчивается ли целевая строка заданной подстрокой.

s.endswith(<suffix>) возвращаетTrue, еслиs заканчивается указанным<suffix>, иFalse в противном случае:

>>>

>>> 'foobar'.endswith('bar')
True
>>> 'foobar'.endswith('baz')
False

Сравнение ограничено подстрокой, обозначенной<start> и<end>, если они указаны:

>>>

>>> 'foobar'.endswith('oob', 0, 4)
True
>>> 'foobar'.endswith('oob', 2, 4)
False

s.find(_{[, [, ]])}

Ищет в целевой строке заданную подстроку.

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

>>>

>>> 'foo bar foo baz foo qux'.find('foo')
0

Этот метод возвращает-1, если указанная подстрока не найдена:

>>>

>>> 'foo bar foo baz foo qux'.find('grault')
-1

Поиск ограничен подстрокой, обозначенной<start> и<end>, если они указаны:

>>>

>>> 'foo bar foo baz foo qux'.find('foo', 4)
8
>>> 'foo bar foo baz foo qux'.find('foo', 4, 7)
-1

s.index(_{[, [, ]])}

Ищет в целевой строке заданную подстроку.

Этот метод идентичен.find(), за исключением того, что он вызывает исключение, если не найден, а не возвращает-1:

>>>

>>> 'foo bar foo baz foo qux'.index('grault')
Traceback (most recent call last):
  File "", line 1, in 
    'foo bar foo baz foo qux'.index('grault')
ValueError: substring not found

s.rfind(_{[, [, ]])}

Ищет в целевой строке заданную подстроку, начиная с конца.

s.rfind() возвращает наивысший индекс вs, где находится подстрока:

>>>

>>> 'foo bar foo baz foo qux'.rfind('foo')
16

Как и в случае с.find(), если подстрока не найдена, возвращается-1:

>>>

>>> 'foo bar foo baz foo qux'.rfind('grault')
-1

Поиск ограничен подстрокой, обозначенной<start> и<end>, если они указаны:

>>>

>>> 'foo bar foo baz foo qux'.rfind('foo', 0, 14)
8
>>> 'foo bar foo baz foo qux'.rfind('foo', 10, 14)
-1

s.rindex(_{[, [, ]])}

Ищет в целевой строке заданную подстроку, начиная с конца.

Этот метод идентичен.rfind(), за исключением того, что он вызывает исключение, если не найден, а не возвращает-1:

>>>

>>> 'foo bar foo baz foo qux'.rindex('grault')
Traceback (most recent call last):
  File "", line 1, in 
    'foo bar foo baz foo qux'.rindex('grault')
ValueError: substring not found

s.startswith([, [, ]])

Определяет, начинается ли целевая строка с заданной подстроки.

Когда вы используете метод Python.startswith(),s.startswith(<suffix>) возвращаетTrue, еслиs начинается с указанного<suffix>, иFalse в противном случае:

>>>

>>> 'foobar'.startswith('foo')
True
>>> 'foobar'.startswith('bar')
False

Сравнение ограничено подстрокой, обозначенной<start> и<end>, если они указаны:

>>>

>>> 'foobar'.startswith('bar', 3)
True
>>> 'foobar'.startswith('bar', 3, 2)
False

Классификация персонажей

Методы в этой группе классифицируют строку на основе символов, которые она содержит.

s.isalnum()

Определяет, состоит ли целевая строка из буквенно-цифровых символов.

s.isalnum() возвращаетTrue, еслиs непусто и все его символы являются буквенно-цифровыми (буква или число), иFalse в противном случае:

>>>

>>> 'abc123'.isalnum()
True
>>> 'abc$123'.isalnum()
False
>>> ''.isalnum()
False

s.isalpha()

Определяет, состоит ли целевая строка из буквенных символов.

s.isalpha() возвращаетTrue, еслиs непусто и все его символы буквенные, иFalse в противном случае:

>>>

>>> 'ABCabc'.isalpha()
True
>>> 'abc123'.isalpha()
False

s.isdigit()

Определяет, состоит ли целевая строка из цифровых символов.

Вы можете использовать метод Python.isdigit(), чтобы проверить, состоит ли ваша строка только из цифр. s.digit() возвращаетTrue, еслиs непусто и все его символы являются числовыми цифрами, иFalse в противном случае:

>>>

>>> '123'.isdigit()
True
>>> '123abc'.isdigit()
False

s.isidentifier()

Определяет, является ли целевая строка допустимым идентификатором Python.

s.isidentifier() возвращаетTrue, еслиs является допустимым идентификатором Python в соответствии с определением языка, иFalse в противном случае:

>>>

>>> 'foo32'.isidentifier()
True
>>> '32foo'.isidentifier()
False
>>> 'foo$32'.isidentifier()
False

Note:.isidentifier() вернетTrue для строки, которая соответствует ключевому слову Python, даже если на самом деле это не будет действительным идентификатором:

>>>

>>> 'and'.isidentifier()
True

Вы можете проверить, соответствует ли строка ключевому слову Python, используя функцию с именемiskeyword(), которая содержится в модуле с именемkeyword. Один из возможных способов сделать это показан ниже:

>>>

>>> from keyword import iskeyword
>>> iskeyword('and')
True

Если вы действительно хотите убедиться, что строка будет служить допустимым идентификатором Python, вы должны проверить, что.isidentifier() равноTrue, аiskeyword() равноFalse.

См.Python Modules and Packages—An Introduction, чтобы узнать больше о модулях Python.

s.islower()

Определяет, являются ли алфавитные символы целевой строки строчными.

s.islower() возвращаетTrue, еслиs непусто и все содержащиеся в нем буквенные символы строчные, иFalse в противном случае. Неалфавитные символы игнорируются:

>>>

>>> 'abc'.islower()
True
>>> 'abc1$d'.islower()
True
>>> 'Abc1$D'.islower()
False

s.isprintable()

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

s.isprintable() возвращаетTrue, еслиs пуст или все содержащиеся в нем буквенные символы можно распечатать. Он возвращаетFalse, еслиs содержит хотя бы один непечатаемый символ. Неалфавитные символы игнорируются:

>>>

>>> 'a\tb'.isprintable()
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'a\nb'.isprintable()
False

Note: Это единственный метод.isxxxx(), который возвращаетTrue, еслиs - пустая строка. Все остальные возвращаютFalse для пустой строки.

s.isspace()

Определяет, состоит ли целевая строка из пробельных символов.

s.isspace() возвращаетTrue, еслиs непусто и все символы являются пробельными символами, иFalse в противном случае.

Наиболее часто встречающиеся пробельные символы - это пробел' ', табуляция' ' и новая строка' ':

>>>

>>> ' \t \n '.isspace()
True
>>> '   a   '.isspace()
False

Тем не менее, есть несколько других символов ASCII, которые квалифицируются как пробелы, и если вы учитываете символы Юникода, есть и некоторые другие:

>>>

>>> '\f\u2005\r'.isspace()
True

(' ' и' ' - это escape-последовательности для символов подачи формы ASCII и символов возврата каретки;' ' - escape-последовательность для Unicode Four-Per-Em Space.)

s.istitle()

Определяет, является ли целевая строка заголовком.

s.istitle() возвращаетTrue, еслиs непусто, первый буквенный символ каждого слова - заглавные, а все остальные буквенные символы в каждом слове - строчные. В противном случае он возвращаетFalse:

>>>

>>> 'This Is A Title'.istitle()
True
>>> 'This is a title'.istitle()
False
>>> 'Give Me The #$#@ Ball!'.istitle()
True

Note: Вот как документация Python описывает.istitle(), если вы сочтете это более интуитивным: «Символы верхнего регистра могут следовать только за символами без регистра, а символы в нижнем регистре - только за ними».

s.isupper()

Определяет, являются ли алфавитные символы целевой строки заглавными.

s.isupper() возвращаетTrue, еслиs непусто и все содержащиеся в нем буквенные символы являются прописными, иFalse в противном случае. Неалфавитные символы игнорируются:

>>>

>>> 'ABC'.isupper()
True
>>> 'ABC1$D'.isupper()
True
>>> 'Abc1$D'.isupper()
False

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

Методы в этой группе изменяют или улучшают формат строки.

s.center([, ])

Центрирует строку в поле.

s.center(<width>) возвращает строку, состоящую изs с центром в поле шириной<width>. По умолчанию отступ состоит из пробела ASCII:

>>>

>>> 'foo'.center(10)
'   foo    '

Если указан необязательный аргумент<fill>, он используется в качестве символа заполнения:

>>>

>>> 'bar'.center(10, '-')
'---bar----'

Еслиs уже как минимум столько же, сколько<width>, он возвращается без изменений:

>>>

>>> 'foo'.center(2)
'foo'

s.expandtabs(tabsize=8)

Расширяет вкладки в строку.

s.expandtabs() заменяет каждый символ табуляции (' ') пробелами. По умолчанию пробелы заполняются в предположении остановки табуляции в каждом восьмом столбце:

>>>

>>> 'a\tb\tc'.expandtabs()
'a       b       c'
>>> 'aaa\tbbb\tc'.expandtabs()
'aaa     bbb     c'

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

>>>

>>> 'a\tb\tc'.expandtabs(4)
'a   b   c'
>>> 'aaa\tbbb\tc'.expandtabs(tabsize=4)
'aaa bbb c'

s.ljust([, ])

Выравнивание по левому краю строки в поле.

s.ljust(<width>) возвращает строку, состоящую изs с выравниванием по левому краю в поле шириной<width>. По умолчанию отступ состоит из пробела ASCII:

>>>

>>> 'foo'.ljust(10)
'foo       '

Если указан необязательный аргумент<fill>, он используется в качестве символа заполнения:

>>>

>>> 'foo'.ljust(10, '-')
'foo-------'

Еслиs уже как минимум столько же, сколько<width>, он возвращается без изменений:

>>>

>>> 'foo'.ljust(2)
'foo'

s.lstrip([])

Обрезает ведущие символы из строки.

s.lstrip() возвращает копиюs с удалением любых пробельных символов с левого края:

>>>

>>> '   foo bar baz   '.lstrip()
'foo bar baz   '
>>> '\t\nfoo\t\nbar\t\nbaz'.lstrip()
'foo\t\nbar\t\nbaz'

Если указан необязательный аргумент<chars>, это строка, которая определяет набор символов, которые необходимо удалить:

>>>

>>> 'http://www.realpython.com'.lstrip('/:pth')
'www.realpython.com'

s.replace(, [, ])

Заменяет вхождения подстроки в строке.

В Python для удаления символа из строки можно использовать метод Python string.replace(). s.replace(<old>, <new>) возвращает копиюs со всеми вхождениями подстроки<old>, замененной на<new>:

>>>

>>> 'foo bar foo baz foo qux'.replace('foo', 'grault')
'grault bar grault baz grault qux'

Если указан необязательный аргумент<count>, выполняется максимум замен<count>, начиная с левого концаs:

>>>

>>> 'foo bar foo baz foo qux'.replace('foo', 'grault', 2)
'grault bar grault baz foo qux'

s.rjust([, ])

Выравнивание по правому краю строки в поле.

s.rjust(<width>) возвращает строку, состоящую изs, выровненную по правому краю, в поле шириной<width>. По умолчанию отступ состоит из пробела ASCII:

>>>

>>> 'foo'.rjust(10)
'       foo'

Если указан необязательный аргумент<fill>, он используется в качестве символа заполнения:

>>>

>>> 'foo'.rjust(10, '-')
'-------foo'

Еслиs уже как минимум столько же, сколько<width>, он возвращается без изменений:

>>>

>>> 'foo'.rjust(2)
'foo'

s.rstrip([])

Обрезает конечные символы из строки.

s.rstrip() возвращает копиюs с удаленными пробельными символами с правого конца:

>>>

>>> '   foo bar baz   '.rstrip()
'   foo bar baz'
>>> 'foo\t\nbar\t\nbaz\t\n'.rstrip()
'foo\t\nbar\t\nbaz'

>>>

>>> 'foo.$$$;'.rstrip(';$.')
'foo'

s.strip([])

Удаляет символы с левого и правого концов строки.

s.strip() по сути эквивалентен последовательному вызовуs.lstrip() иs.rstrip(). Без аргумента<chars> он удаляет начальные и конечные пробелы:

>>>

>>> s = '   foo bar baz\t\t\t'
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
'foo bar baz'

Как и в случае с.lstrip() и.rstrip(), необязательный аргумент<chars> указывает набор символов, которые необходимо удалить:

>>>

>>> 'www.realpython.com'.strip('w.moc')
'realpython'

Note: Когда возвращаемое значение строкового метода является другой строкой, как это часто бывает, методы могут быть вызваны последовательно путем объединения вызовов:

>>>

>>> '   foo bar baz\t\t\t'.lstrip().rstrip()
'foo bar baz'
>>> '   foo bar baz\t\t\t'.strip()
'foo bar baz'

>>> 'www.realpython.com'.lstrip('w.moc').rstrip('w.moc')
'realpython'
>>> 'www.realpython.com'.strip('w.moc')
'realpython'

s.zfill()

Дополняет строку слева нулями.

s.zfill(<width>) возвращает копиюs, дополненную слева символами'0', до указанного<width>:

>>>

>>> '42'.zfill(5)
'00042'

Еслиs содержит начальный знак, он остается у левого края строки результата после вставки нулей:

>>>

>>> '+42'.zfill(8)
'+0000042'
>>> '-42'.zfill(8)
'-0000042'

Еслиs уже как минимум столько же, сколько<width>, он возвращается без изменений:

>>>

>>> '-42'.zfill(3)
'-42'

.zfill() наиболее полезен для строковых представлений чисел, но Python по-прежнему с радостью добавит нуля в строку, которой нет:

>>>

>>> 'foo'.zfill(6)
'000foo'

Преобразование между строками и списками

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

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

Многие из этих методов возвращают либо список, либо кортеж. Это два похожих составных типа данных, которые являются прототипами примеров итераций в Python. Они описаны в следующем уроке, так что вы скоро узнаете о них! До этого просто думайте о них как о последовательностях ценностей. Список заключен в квадратные скобки ([]), а кортеж заключен в круглые скобки (()).

В этом вступлении давайте рассмотрим последнюю группу строковых методов.

s.join()

Объединяет строки из повторяемого.

s.join(<iterable>) возвращает строку, полученную в результате объединения объектов в<iterable>, разделенныхs.

Обратите внимание, что.join() вызывается вs, строке-разделителе. <iterable> также должна быть последовательностью строковых объектов.

Некоторый пример кода должен помочь уточнить. В следующем примере разделительs - это строка', ', а<iterable> - это список строковых значений:

>>>

>>> ', '.join(['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'

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

В следующем примере<iterable> указывается как одно строковое значение. Когда строковое значение используется в качестве итерируемого, оно интерпретируется как список отдельных символов строки:

>>>

>>> list('corge')
['c', 'o', 'r', 'g', 'e']

>>> ':'.join('corge')
'c:o:r:g:e'

Таким образом, результатом':'.join('corge') является строка, состоящая из каждого символа в'corge', разделенного':'.

Этот пример не работает, потому что один из объектов в<iterable> не является строкой:

>>>

>>> '---'.join(['foo', 23, 'bar'])
Traceback (most recent call last):
  File "", line 1, in 
    '---'.join(['foo', 23, 'bar'])
TypeError: sequence item 1: expected str instance, int found

Это можно исправить, хотя:

>>>

>>> '---'.join(['foo', str(23), 'bar'])
'foo---23---bar'

Как вы скоро увидите, многие составные объекты в Python могут быть сконструированы как итерируемые, и.join() особенно полезен для создания из них строк.

s.partition()

Делит строку на основе разделителя.

s.partition(<sep>) разделяетs при первом появлении строки<sep>. Возвращаемое значение представляет собой кортеж из трех частей, состоящий из:

Частьs, предшествующая<sep>
<sep> сам
Частьs после<sep>

Вот пара примеров.partition() в действии:

>>>

>>> 'foo.bar'.partition('.')
('foo', '.', 'bar')
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')

Если<sep> не найден вs, возвращаемый кортеж содержитs, за которым следуют две пустые строки:

>>>

>>> 'foo.bar'.partition('@@')
('foo.bar', '', '')

Remember: Списки и кортежи рассматриваются в следующем руководстве.

s.rpartition()

Делит строку на основе разделителя.

s.rpartition(<sep>) действует точно так же, какs.partition(<sep>), за исключением того, чтоs разделяется при последнем появлении<sep> вместо первого появления:

>>>

>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')

>>> 'foo@@bar@@baz'.rpartition('@@')
('foo@@bar', '@@', 'baz')

s.rsplit(sep=None, maxsplit=-1)

Разбивает строку на список подстрок.

Без аргументовs.rsplit() разбиваетs на подстроки, разделенные любой последовательностью пробелов, и возвращает подстроки в виде списка:

>>>

>>> 'foo bar baz qux'.rsplit()
['foo', 'bar', 'baz', 'qux']
>>> 'foo\n\tbar   baz\r\fqux'.rsplit()
['foo', 'bar', 'baz', 'qux']

Если указан<sep>, он используется как разделитель для разделения:

>>>

>>> 'foo.bar.baz.qux'.rsplit(sep='.')
['foo', 'bar', 'baz', 'qux']

(Если<sep> указан со значениемNone, строка разделяется пробелами, как если бы<sep> не был указан вообще.)

Когда<sep> явно указан как разделитель, предполагается, что последовательные разделители вs ограничивают пустые строки, которые будут возвращены:

>>>

>>> 'foo...bar'.rsplit(sep='.')
['foo', '', '', 'bar']

Однако это не тот случай, когда<sep> опущен. В этом случае последовательные пробельные символы объединяются в один разделитель, и результирующий список никогда не будет содержать пустых строк:

>>>

>>> 'foo\t\t\tbar'.rsplit()
['foo', 'bar']

Если указан необязательный параметр ключевого слова<maxsplit>, выполняется максимум из этого количества разделений, начиная с правого концаs:

>>>

>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=1)
['www.realpython', 'com']

Значение по умолчанию для<maxsplit> --1, что означает, что должны быть выполнены все возможные разделения - так же, как если бы<maxsplit> был полностью опущен:

>>>

>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=-1)
['www', 'realpython', 'com']
>>> 'www.realpython.com'.rsplit(sep='.')
['www', 'realpython', 'com']

s.split(sep=None, maxsplit=-1)

Разбивает строку на список подстрок.

s.split() ведет себя точно так же, какs.rsplit(), за исключением того, что если указан<maxsplit>, расщепления считаются с левого концаs, а не с правого конца:

>>>

>>> 'www.realpython.com'.split('.', maxsplit=1)
['www', 'realpython.com']
>>> 'www.realpython.com'.rsplit('.', maxsplit=1)
['www.realpython', 'com']

Если<maxsplit> не указан,.split() и.rsplit() неразличимы.

s.splitlines([])

Разрывает строку на границах строки.

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

Escape-последовательность символ

Escape-последовательность	символ
`\n`	Новая линия
`\r`	Возврат каретки
`\r\n`	Возврат каретки + перевод строки
или	Табулирование строк
или	Подача формы
`\x1c`	Разделитель файлов
`\x1d`	Разделитель групп
`\x1e`	Разделитель записей
`\x85`	Следующая строка (контрольный код C1)
`\u2028`	Разделитель строк Unicode
`\u2029`	Разделитель абзацев Unicode

\n

Новая линия

\r

Возврат каретки

\r\n

Возврат каретки + перевод строки

или

Табулирование строк

или

Подача формы

\x1c

Разделитель файлов

\x1d

Разделитель групп

\x1e

Разделитель записей

\x85

Следующая строка (контрольный код C1)

\u2028

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

\u2029

Разделитель абзацев Unicode

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

>>>

>>> 'foo\nbar\r\nbaz\fqux\u2028quux'.splitlines()
['foo', 'bar', 'baz', 'qux', 'quux']

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

>>>

>>> 'foo\f\f\fbar'.splitlines()
['foo', '', '', 'bar']

Если необязательный аргумент<keepends> указан и является правдивым, тогда границы строк сохраняются в строках результатов:

>>>

>>> 'foo\nbar\nbaz\nqux'.splitlines(True)
['foo\n', 'bar\n', 'baz\n', 'qux']
>>> 'foo\nbar\nbaz\nqux'.splitlines(1)
['foo\n', 'bar\n', 'baz\n', 'qux']

`bytes` Объекты

Объектbytes является одним из основных встроенных типов для управления двоичными данными. Объектbytes - это неизменная последовательность одиночных значенийbyte. Каждый элемент в объектеbytes представляет собой небольшое целое число в диапазоне от0 до255.

Определение объекта Literal`bytes`

Литералbytes определяется так же, как строковый литерал с добавлением префикса'b':

>>>

>>> b = b'foo bar baz'
>>> b
b'foo bar baz'
>>> type(b)

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

>>>

>>> b'Contains embedded "double" quotes'
b'Contains embedded "double" quotes'

>>> b"Contains embedded 'single' quotes"
b"Contains embedded 'single' quotes"

>>> b'''Contains embedded "double" and 'single' quotes'''
b'Contains embedded "double" and \'single\' quotes'

>>> b"""Contains embedded "double" and 'single' quotes"""
b'Contains embedded "double" and \'single\' quotes'

В литералеbytes разрешены только символы ASCII. Любое значение символа больше127 должно быть указано с использованием соответствующей escape-последовательности:

>>>

>>> b = b'foo\xddbar'
>>> b
b'foo\xddbar'
>>> b[3]
221
>>> int(0xdd)
221

Префикс'r' может использоваться в литералеbytes, чтобы отключить обработку управляющих последовательностей, как со строками:

>>>

>>> b = rb'foo\xddbar'
>>> b
b'foo\\xddbar'
>>> b[3]
92
>>> chr(92)
'\\'

Определение объекта`bytes` с помощью встроенной функции`bytes()`

Функцияbytes() также создает объектbytes. Какой тип объектаbytes будет возвращен, зависит от аргумента (ов), переданного функции. Возможные формы показаны ниже.

bytes(, )

Создает объектbytes из строки.

bytes(<s>, <encoding>) преобразует строку<s> в объектbytes, используяstr.encode() в соответствии с указанным<encoding>:

>>>

>>> b = bytes('foo.bar', 'utf8') >>> b b'foo.bar' >>> type(b)

Technical Note: В этой форме функцииbytes() требуется аргумент<encoding>. «Кодировка» относится к способу перевода символов в целочисленные значения. Значение"utf8" указывает на формат преобразования UnicodeUTF-8, который представляет собой кодировку, которая может обрабатывать все возможные символы Unicode. UTF-8 также можно указать, указав"UTF8","utf-8" или"UTF-8" для<encoding>.

См.Unicode documentation для получения дополнительной информации. Пока вы имеете дело с обычными латинскими символами, UTF-8 будет вам полезен.

bytes()

Создает объектbytes, состоящий из нулевых (0x00) байтов.

bytes(<size>) определяет объектbytes указанного<size>, который должен быть положительным целым числом. Результирующий объектbytes инициализируется нулевыми (0x00) байтами:

>>>

>>> b = bytes(8) >>> b b'\x00\x00\x00\x00\x00\x00\x00\x00' >>> type(b)

bytes()

Создает объектbytes из итерируемого объекта.

bytes(<iterable>) определяет объектbytes из последовательности целых чисел, сгенерированной<iterable>. <iterable> должен быть итерацией, которая генерирует последовательность целых чиселn в диапазоне0 ≤ n ≤ 255:

>>>

>>> b = bytes([100, 102, 104, 106, 108]) >>> b b'dfhjl' >>> type(b) >>> b[2] 104

Операции с объектамиbytes

Как и строки, объектыbytes поддерживают общие операции последовательности:

Операторыin иnot in:

>>>

>>> b = b'abcde' >>> b'cd' in b True >>> b'foo' not in b True

Операторы конкатенации (+) и репликации (*):

>>>

>>> b = b'abcde' >>> b + b'fghi' b'abcdefghi' >>> b * 3 b'abcdeabcdeabcde'

Индексирование и нарезка:

>>>

>>> b = b'abcde' >>> b[2] 99 >>> b[1:3] b'bc'

Встроенные функции:

>>>

>>> len(b) 5 >>> min(b) 97 >>> max(b) 101

Многие методы, определенные для строковых объектов, также действительны для объектовbytes:

>>>

>>> b = b'foo,bar,foo,baz,foo,qux' >>> b.count(b'foo') 3 >>> b.endswith(b'qux') True >>> b.find(b'baz') 12 >>> b.split(sep=b',') [b'foo', b'bar', b'foo', b'baz', b'foo', b'qux'] >>> b.center(30, b'-') b'---foo,bar,foo,baz,foo,qux----'

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

>>>

>>> b = b'foo.bar' >>> b + '.baz' Traceback (most recent call last): File "", line 1, in b + '.baz' TypeError: can't concat bytes to str >>> b + b'.baz' b'foo.bar.baz' >>> b.split(sep='.') Traceback (most recent call last): File "", line 1, in b.split(sep='.') TypeError: a bytes-like object is required, not 'str' >>> b.split(sep=b'.') [b'foo', b'bar']

Хотя определение и представление объектаbytes основано на тексте ASCII, на самом деле оно ведет себя как неизменяемая последовательность небольших целых чисел в диапазоне от0 до255 включительно. Вот почему отдельный элемент из объектаbytes отображается как целое число:

>>>

>>> b = b'foo\xddbar' >>> b[3] 221 >>> hex(b[3]) '0xdd' >>> min(b) 97 >>> max(b) 221

Срез отображается как объектbytes, даже если он имеет длину всего один байт:

>>>

>>> b[2:3] b'c'

Вы можете преобразовать объектbytes в список целых чисел с помощью встроенной функцииlist():

>>>

>>> list(b) [97, 98, 99, 100, 101]

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

bytes.fromhex()

Возвращает объектbytes, созданный из строки шестнадцатеричных значений.

bytes.fromhex(<s>) возвращает объектbytes, который получается в результате преобразования каждой пары шестнадцатеричных цифр в<s> в соответствующее значение байта. Пары шестнадцатеричных цифр в<s> могут при желании разделяться пробелом, который игнорируется:

>>>

>>> b = bytes.fromhex(' aa 68 4682cc ') >>> b b'\xaahF\x82\xcc' >>> list(b) [170, 104, 70, 130, 204]

Note: Этот метод является методом класса, а не методом объекта. Он привязан к классуbytes, а не к объектуbytes. Вы еще больше углубитесь в различия между классами, объектами и их соответствующими методами в следующих руководствах поobject-oriented programming. А пока просто обратите внимание, что этот метод вызывается для классаbytes, а не для объектаb.

b.hex()

Возвращает строку шестнадцатеричного значения из объектаbytes.

b.hex() возвращает результат преобразования объектаbytesb в строку пар шестнадцатеричных цифр. То есть он делает обратное.fromhex():

>>>

>>> b = bytes.fromhex(' aa 68 4682cc ') >>> b b'\xaahF\x82\xcc' >>> b.hex() 'aa684682cc' >>> type(b.hex())

Note: В отличие от.fromhex(),.hex() является методом объекта, а не методом класса. Таким образом, он вызывается для объекта классаbytes, а не для самого класса.

bytearray Объекты

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

В Python нет специального синтаксиса, встроенного в Python для определения литералаbytearray, такого как префикс'b', который можно использовать для определения объектаbytes. Объектbytearray всегда создается с помощью встроенной функцииbytearray():

>>>

>>> ba = bytearray('foo.bar.baz', 'UTF-8') >>> ba bytearray(b'foo.bar.baz') >>> bytearray(6) bytearray(b'\x00\x00\x00\x00\x00\x00') >>> bytearray([100, 102, 104, 106, 108]) bytearray(b'dfhjl')

Объектыbytearray изменяемы. Вы можете изменить содержимое объектаbytearray с помощью индексации и нарезки:

>>>

>>> ba = bytearray('foo.bar.baz', 'UTF-8') >>> ba bytearray(b'foo.bar.baz') >>> ba[5] = 0xee >>> ba bytearray(b'foo.b\xeer.baz') >>> ba[8:11] = b'qux' >>> ba bytearray(b'foo.b\xeer.qux')

Объектbytearray также может быть построен непосредственно из объектаbytes:

>>>

>>> ba = bytearray(b'foo') >>> ba bytearray(b'foo')

Заключение

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

Эти типы являются первыми из рассмотренных вами типов, которые составлены из набора более мелких частей. Python предоставляет несколько составных встроенных типов. В следующем руководстве вы изучите два наиболее часто используемых:lists иtuples.

__ Take the Quiz: Проверьте свои знания с помощью нашей интерактивной викторины «Строки и символьные данные Python». По окончании вы получите оценку, чтобы вы могли отслеживать прогресс в обучении с течением времени:

Пройти тест »

TOC

Строки и символьные данные в Python