Строки в python 3. введение в работу со строками

Шаблоны и новая методика форматирования строк

Этот метод был добавлен в Python 2.4 в виде шаблонов строк, но в качестве обычного метода string, работающего через метод format в версии 2.6. Так что это не самый свежий метод, просто обновленный. В любом случае, приступим к работе с шаблонами!

Python

print(«%(lang)s is fun!» % {«lang»:»Python»}) # Python is fun!

1	print(«%(lang)s is fun!»%{«lang»»Python»})# Python is fun!

Должно быть это выглядит странно, но на самом деле мы сменили наши % на %(lang), с тем отличием, что данный объект идет в комплекте с переменной. Вторая часть пример вызывает словарь Python, который мы рассмотрим в следующей статье. В основном, это пара key:value, так что когда Python ищет ключ lang в строке и в указанном словаре ключей, он заменяет этот ключ его значением. Давайте взглянем на следующие примеры:

Python

a = «%(value)s %(value)s %(value)s !» % {«value»:»SPAM»}
print(a) # SPAM SPAM SPAM !

b = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2}
print(b)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
KeyError: ‘z’

c = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2, «z»:3}
print(c) # 1 + 2 = 3

1 2 3 4 5 6 7 8 9 10 11 12

a=»%(value)s %(value)s %(value)s !»%{«value»»SPAM»} print(a)# SPAM SPAM SPAM ! b=»%(x)i + %(y)i = %(z)i»%{«x»1,»y»2} print(b) Traceback(most recent call last) File»<string>»,line1,in<fragment> KeyError’z’ c=»%(x)i + %(y)i = %(z)i»%{«x»1,»y»2,»z»3} print(c)# 1 + 2 = 3

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

Python

a = «Python is as simple as {0}, {1}, {2}».format(«a», «b», «c»)
print(a) # ‘Python is as simple as a, b, c’

b = «Python is as simple as {1}, {0}, {2}».format(«a», «b», «c»)
print(b) # ‘Python is as simple as b, a, c’

xy = {«x»:0, «y»:10}
c = «Graph a point at where x={x} and y={y}».format(**xy)
print(c) # Graph a point at where x=0 and y=10

1 2 3 4 5 6 7 8 9

a=»Python is as simple as {0}, {1}, {2}».format(«a»,»b»,»c») print(a)# ‘Python is as simple as a, b, c’ b=»Python is as simple as {1}, {0}, {2}».format(«a»,»b»,»c») print(b)# ‘Python is as simple as b, a, c’ xy={«x»,»y»10} c=»Graph a point at where x={x} and y={y}».format(**xy) print(c)# Graph a point at where x=0 and y=10

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

• Документация Python 2.Х о

Translate и Replace

Первый случай — заменить или удалить некоторые символы или подстроки из текста. В Python есть встроенные функции в модуле string, которые выполняют эти задачи.

Метод использует таблицу (которая строится при помощи функции ) для удаления или изменения определенных символов:

test_string = 'The quick brown fox jumps over the lazy dog' 
translation_map = str.maketrans('eo', '  ') 
test_string.translate( translation_map ) 

Out: 'Th  quick br wn f x jumps  v r th  lazy d g'

Метод работает так, как следует из его названия — изменяя подстроку на нужную:

test_string = 'The quick brown fox jumps over the lazy dog'
test_string.replace( 'fox', 'squirell')

Out: 'The quick brown squirell jumps over the lazy dog'

“Старая-школа” форматирования строк в Python

До Python 3.6 у нас было два основных способа встраивания выражений Python в строковые литералы для форматирования: % — форматирование и str.format(). Рассмотрим, как их использовать и каковы их ограничения.

Вариант #1: % — форматирование

Этот способ форматирования Python существует в языке с самого его начала. Вы можете прочитать о нем больше информации в . Имейте в виду, что % — форматирование не рекомендуется к использованию:

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

Строковые объекты имеют встроенную операцию с использованием оператора %, который можно использовать для форматирования строк. Вот как это выглядит на практике:

>>> name = "Eric"
>>> "Hello, %s." % name
'Hello, Eric.'

Чтобы вставить более одной переменной, вы должны использовать кортеж из этих переменных.

>>> name = "Eric"
>>> age = 74
>>> "Hello, %s. You are %s." % (name, age)
'Hello Eric. You are 74.'

Недостатки % — форматирования

Примеры кода, которые вы только что видели выше, достаточно читабельны. Однако, как только вы начнете использовать несколько параметров и более длинные строки, ваш код быстро станет менее читаемым. Все начинает выглядеть немного грязно:

>>> first_name = "Eric"
>>> last_name = "Idle"
>>> age = 74
>>> profession = "comedian"
>>> affiliation = "Monty Python"
>>> "Hello, %s %s. You are %s. You are a %s. You were a member of %s." % (first_name, last_name, age, profession, affiliation)
'Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty Python.'

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

Вариант #2: str.format()

Этот новый способ вывода строк был представлен в Python 2.6. Вы можете обратиться к для получения дополнительной информации.

Как используется str.format()

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

С помощью str.format() поля вывода переменных отмечены фигурными скобками:

>>> "Hello, {}. You are {}.".format(name, age)
'Hello, Eric. You are 74.'

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

>>> "Hello, {1}. You are {0}.".format(age, name)
'Hello, Eric. You are 74.'

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

>>> person = {'name': 'Eric', 'age': 74}
>>> "Hello, {name}. You are {age}.".format(name=person, age=person)
'Hello, Eric. You are 74.'

Вы также можете использовать символ **, чтобы использовать этот трек со словарями:

>>> person = {'name': 'Eric', 'age': 74}
>>> "Hello, {name}. You are {age}.".format(**person)
'Hello, Eric. You are 74.'

str.format() определенно является улучшением по сравнению с % — форматированием, но и у него есть свои недостатки.

В чем недостатки str.format()

Код, использующий str.format(), гораздо легче читается, чем код, использующий % -форматирование, но str.format() все еще может быть достаточно многословным, когда вы имеете дело с несколькими параметрами и более длинными строками. Посмотрите на это:

>>> first_name = "Eric"
>>> last_name = "Idle"
>>> age = 74
>>> profession = "comedian"
>>> affiliation = "Monty Python"
>>> print(("Hello, {first_name} {last_name}. You are {age}. " + 
>>>        "You are a {profession}. You were a member of {affiliation}.") \
>>>        .format(first_name=first_name, last_name=last_name, age=age, \
>>>                profession=profession, affiliation=affiliation))
'Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty Python.'

Если у вас есть переменные, которые вы хотите передать в .format() в словаре, то вы можете просто распаковать его с помощью .format (** some_dict) и ссылаться на значения по ключу в строке.

Мир регулярных выражений

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

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

Разделение по шаблону:

import re
test_punctuation = "  This &is  example? {of} string. with.? punctuation!!!!  "
re.split('\W+', test_punctuation)

Out: 

Замена по шаблону:

import re
test_with_numbers = "This is 1 string with 10 words for 9 digits 2 example"
re.sub('\d', '*', test_with_numbers)

Out: 'This is * string with ** words for * digits * example'

Strip и zfill

Еще одна важная функция — это возможность удалять из строки лишние начальные и конечные символы. Для этого у нас есть семейство функций :

• Удалить пробелы по умолчанию.
• Удалить пробелы слева или справа.
• Удалить произвольные символы.

test_string_with_spaces = '     The quick brown fox jumps over the lazy dog    '
test_string_with_spaces.strip()

Out: 'The quick brown fox jumps over the lazy dog'

test_string_with_spaces.lstrip()

Out: 'The quick brown fox jumps over the lazy dog    '

test_string_with_spaces.rstrip()

Out: '     The quick brown fox jumps over the lazy dog'

test_string.rstrip('g')

Out: 'The quick brown fox jumps over the lazy do'

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

'29'.zfill(10)

Out: '0000000029'

'xA1'.zfill(4)

Out: '0xA1'

Методы join в Python, split() и функция replace Python 3

Метод join Python объединяет две строки и разделяет их указанным символом.

Давайте создадим строку:

balloon = "Sammy has a balloon."

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

" ".join(balloon)

Если мы выведем это:

print(" ".join(balloon))

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

Вывод:

S a m m y   h a s   a   b a l l o o n .

Функция join python также может использоваться для возврата строки, которая является перевернутой исходной строкой:

print("".join(reversed(balloon)))

Вывод:

.noollab a sah ymmaS

Метод str.join() также полезен для объединения списка строк в новую единственную строку.

Создадим разделенную запятыми строку из списка строк:

print(",".join())

Вывод:

sharks,crustaceans,plankton

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

".join().

Также можно и разбивать строки. Для этого используется метод str.split():

print(balloon.split())

Вывод:

Метод str.split() возвращает список строк, разделенных пробелами, если никакой другой параметр не задан.

Также можно использовать str.split() для удаления определенных частей строки. Например, давайте удалим из строки букву a:

print(balloon.split("a"))

Вывод:

Теперь буква a удалена, и строки разделены там, где она располагалась.

Метод str.replace() применять для замены части строки. Допустим, что  шарик, который был у Сэмми, потерян. Поскольку у Сэмми больше нет этого шарика, изменим подстроку «has» на новую строку «had»:

print(balloon.replace("has","had"))

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

Вывод:

Sammy had a balloon.

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

Escape Characters

Following table is a list of escape or non-printable characters that can be represented with backslash notation.

An escape character gets interpreted; in a single quoted as well as double quoted strings.

Backslash notation	Hexadecimal character	Description
\a	0x07	Bell or alert
\b	0x08	Backspace
\cx		Control-x
\C-x		Control-x
\e	0x1b	Escape
\f	0x0c	Formfeed
\M-\C-x		Meta-Control-x
\n	0x0a	Newline
\nnn		Octal notation, where n is in the range 0.7
\r	0x0d	Carriage return
\s	0x20	Space
\t	0x09	Tab
\v	0x0b	Vertical tab
\x		Character x
\xnn		Hexadecimal notation, where n is in the range 0.9, a.f, or A.F

Python string length

The method calculates the number of characters
in a string. The white characters are also counted.

string_length.py

#!/usr/bin/env python

# string_length.py

s1 = "Eagle"
s2 = "Eagle\n"
s3 = "Eagle  "

print(len(s1))
print(len(s2))
print(len(s3))

We compute the length of three strings.

s1 = "Eagle"
s2 = "Eagle\n"
s3 = "Eagle  "

Three strings are defined. The second string has a new line character at
its end. The third has two additional space characters.

print(len(s1))

We print the number of characters to the console.

$ ./length.py
5
6
7

From the output we can see that the white spaces (new line character and space
characters in our case) are counted, too.

Вводная информация о строках

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

Литералы строк

Литерал – способ создания объектов, в случае строк Питон предлагает несколько основных вариантов:

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

Разницы между строками с одинарными и двойными кавычками нет – это одно и то же

Какие кавычки использовать – решать вам, соглашение PEP 8 не дает рекомендаций по использованию кавычек. Просто выберите один тип кавычек и придерживайтесь его. Однако если в стоке используются те же кавычки, что и в литерале строки, используйте разные типы кавычек – обратная косая черта в строке ухудшает читаемость кода.

Кодировка строк

В третьей версии языка программирования Python все строки представляют собой последовательность Unicode-символов.

В Python 3 кодировка по умолчанию исходного кода – UTF-8. Во второй версии по умолчанию использовалась ASCII. Если необходимо использовать другую кодировку, можно разместить специальное объявление на первой строке файла, к примеру:

Максимальная длина строки в Python

Максимальная длина строки зависит от платформы. Обычно это:

• 2**31 — 1 – для 32-битной платформы;
• 2**63 — 1 – для 64-битной платформы;

Константа , определенная в модуле

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

Одна из самых распространенных операций со строками – их объединение (конкатенация). Для этого используется знак , в результате к концу первой строки будет дописана вторая:

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

Сравнение строк

При сравнении нескольких строк рассматриваются отдельные символы и их регистр:

• цифра условно меньше, чем любая буква из алфавита;
• алфавитная буква в верхнем регистре меньше, чем буква в нижнем регистре;
• чем раньше буква в алфавите, тем она меньше;

При этом сравниваются по очереди первые символы, затем – 2-е и так далее.

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

Как удалить строку в Python

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

Или перезаписать переменную пустой строкой:

Обращение по индексу

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

Индекс начинается с 0

В Python предусмотрена возможность получить доступ и по отрицательному индексу. В таком случае отсчет будет вестись от конца строки:

Расширенные строковые функции Python

encode()	Используется для возврата закодированных строк	str_name.encode (кодировка = кодировка, ошибки = ошибки)
expandtabs()	Для установки или исправления пробелов табуляции между символами или алфавитами	str_name.expandtabs (размер табуляции)
format()	Заменяет имя переменной, записанное в {}, значением при выполнении	str_name.format (значение1, значение2 …)
format_map()	Для форматирования заданной строки и возвращается	str_name.format_map (отображение)
isidentifier()	Проверяет, являются ли символы буквенно-цифровыми буквами (az) и (0-9) или подчеркиванием (_), и возвращает True	str_name.isidentifier()
isprintable()	Проверяет, все ли символы доступны для печати, затем возвращает True	str_name.isprintable()
istitle()	Проверяет, все ли начальные символы слов в верхнем регистре, затем возвращает True	str_name.istitle()
join()	Принимает слова как повторяемые и объединяет их в строку	str_name.join (повторяемый)
ljust()	Возвращает выровненную по левому краю строку с минимальным значением, заданным как ширина	str_name.ljust (длина, символ)
lstrip()	Удаляет символы с левого края на основе данного аргумента	str_name.lstrip (символы)
maketrans()	Создает сопоставленную таблицу, используемую для переводов.	str_name.maketrans (x, y, z)
rsplit()	Используется для разделения строки с правого конца	str_name.rsplit (разделитель, maxsplit)
rfind()	Ищет указанное значение и находит позицию его последнего значения.	str_name.rfind (значение, начало, конец)
rindex()	Ищет указанное значение и находит позицию его последнего значения.	str_name.rindex (значение, начало, конец)
rjust()	Возвращает выровненную по правому краю строку с минимальным значением, заданным как ширина	str_name.rjust (длина, символ)
rpartition()	Ищет последнее вхождение указанной строки и разбивает строку на кортеж из трех элементов.	str_name.rpartition (значение)
rstrip()	Удаляет символы с правого конца на основе заданного аргумента	str_name.rstrip (символы)
translate()	Используется для получения переведенной строки	str_name.translate (таблица)
zfill()	Он возвращает новую строку с символами «0», добавленными слева в строке.	str_name.zfill (len)

Using quotes in Python

Strings in Python are delimited by single or double quote characters.
What if we wanted to display quotes, for example in a direct speech?
There are two basic ways to do this.

quotes.py

#!/usr/bin/env python

# quotes.py

print("There are many stars.")
print("He said, \"Which one is your favourite?\"")

print('There are many stars.')
print('He said, "Which one is your favourite?"')

We use the character to escape additional quotes. Normally the double
quote character is used to delimit a string literal. However, when escaped, the
original meaning is suppressed. It appears as a normal character and can be
used within a string literal. The second way to use quotes within quotes is
to mix single and double quotes.

$ ./quotes.py
There are many stars.
He said, "Which one is your favourite?"
There are many stars.
He said, "Which one is your favourite?"

This is the output.

Пример: разделение строки по классу

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

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

Регулярное выражение ‘\d +’ соответствует одной или нескольким десятичным цифрам. В этом примере мы будем использовать это регулярное выражение для разделения строки на фрагменты, разделенные одной или несколькими десятичными цифрами.

import re

#a string
str = 'foo635bar4125mango2apple21orange'
#split with regular expression
chunks = re.split('\d+',str)
print(chunks)

Вывод:

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

В этом руководстве мы узнаем, как разделить строку пробелом в Python с помощью методов String.split() и re.split().

В этом примере мы возьмем строку, содержащую слова, элементы или фрагменты, разделенные пробелом. Затем мы разделим строку по пробелу с помощью метода String.split(), который возвращает список.

str = '63 41 92 81 69 70'

#split string by single space
chunks = str.split(' ')

print(chunks)

Вывод:

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

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

Python

# -*- coding: utf-8 -*-

my_string = «Я люблю %s» % «Python»
print(my_string) # Я люблю Python

var = «яблоки»
newString = «Я ем %s» % var
print(newString) # Я ем яблоки

another_string = «Я люблю %s и %s» % («Python», var)
print(another_string) # Я люблю Python и яблоки

1 2 3 4 5 6 7 8 9 10 11

# -*- coding: utf-8 -*-   my_string=»Я люблю %s»%»Python» print(my_string)# Я люблю Python var=»яблоки» newString=»Я ем %s»%var print(newString)# Я ем яблоки another_string=»Я люблю %s и %s»%(«Python»,var) print(another_string)# Я люблю Python и яблоки

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

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

Python

another_string = «Я люблю %s и %s» % «Python»

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: not enough arguments for format string

1 2 3 4 5

another_string=»Я люблю %s и %s»%»Python» Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErrornotenough arguments forformatstring

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

Python

my_string = «%i + %i = %i» % (1,2,3)
print(my_string) # ‘1 + 2 = 3’

float_string = «%f» % (1.23)
print(float_string) # ‘1.230000’

float_string2 = «%.2f» % (1.23)
print(float_string2) # ‘1.23’

float_string3 = «%.2f» % (1.237)
print(float_string3) # ‘1.24’

1 2 3 4 5 6 7 8 9 10 11

my_string=»%i + %i = %i»%(1,2,3) print(my_string)# ‘1 + 2 = 3’ float_string=»%f»%(1.23) print(float_string)# ‘1.230000’ float_string2=»%.2f»%(1.23) print(float_string2)# ‘1.23’ float_string3=»%.2f»%(1.237) print(float_string3)# ‘1.24’

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

Обратите внимание на то, что результат включает множество дополнительных нулей (1.230000). Нам это не нужно, так что мы указываем Python ограничить выдачу до двух десятичных значений в третьем примере (“%.2f”)

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

Python

int_float_err = «%i + %f» % («1», «2.00»)
Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: %d format: a number is required, not str

1 2 3 4

int_float_err=»%i + %f»%(«1″,»2.00») Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeError%dformatanumber isrequired,notstr

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

Python

int_float_err = «%i + %f» % (1, «2.00»)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: float argument required, not str

1 2 3 4 5

int_float_err=»%i + %f»%(1,»2.00″) Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErrorfloatargument required,notstr

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

Срезы

Часто в программировании
требуется выбрать не один какой-то символ, а сразу несколько. Для этого
используются так называемые срезы. Их работу проще показать на конкретных
примерах. Пусть у нас есть наша строка:

msg = "Hello World!"

и мы хотим
выделить последнее слово «World!». Для этого в квадратных скобках
указывается начальный индекс и через двоеточие – конечный. Если мы запишем все
вот в таком виде:

msg6:11

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

[6: 11)

Поэтому, мы
должны записать срез так:

msg6:12

Другой пример
для выделения символов «llo»:

msg2:5

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

msg:5

выделяет слово «Hello», а вот так:

msg6:

получим «World!». Наконец,
записав все в таком виде:

msg:

получим ту же
самую строку, не копию! Это можно проверить так:

copy = msg:
print(id(copy), id(msg))

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

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

msg::2

мы здесь ставим
еще одно двоеточие и указываем шаг 2, то есть, идем через символ: «HloWrd». Также
это можно комбинировать с граничными значениями:

msg:5:2
msg6::2
msg1:6:2

и использовать
отрицательный шаг:

msg::-1

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

Строки байтов — bytes и bytearray

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

Основное отличие типа str от bytes и bytearray заключается в том, что str всегда пытается превратить последовательность байтов в текст указанной кодировки. По умолчанию этой кодировкой является utf-8, но это очень большая кодировка и другие кодировки, например ASCII, Latin-1 и другие являются ее подмножествами

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

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

Например, что бы создать строку типа bytes или bytearray достаточно передать соответствующим функциям последовательности целых чисел:

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

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

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

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