Как изменить регистр букв python

В одной из прошлых статей я разбирал строки в JavaScript. Теперь пришло время поговорить о строках в языке программирования Python. 

Начнем с теории. Строка – это последовательность символов произвольной длины. Также строки являются объектами класса str, и если мы захотим получить не строку, а число, то можем использовать функцию приведения.

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

Самый простой способ склеить строки в Python – это сложить их с помощью знака «+». Рассмотрим на примере:

str = "a"+"b"
print(str) # Выведет "ab"

Но такой способ не всегда будет нам подходить. Рассмотрим метод join():

str = ["a", "b", "c"]
print("".join(str)) # Выведет "abc"

Перед .join() мы указываем разделитель строк, а в скобках сам их массив.

Для того чтобы разделить строки, используем обратный метод – split(). Тут в скобках указываем набор символов, по которым будет идти разделение, а перед методом не забываем указать имя строки, а после нее поставить точку. Рассмотрим на примере:

str = "a,b,c"
print(str.split(",")) # Выведет ['a', 'b', 'c']

Существует и другой способ разделения строк, он называется срез. Срез str[x:y] позволит нам получить строку от символа x до y. При этом необязательно указывать оба параметра, ведь в таком случае срез произойдет от начала или до самого конца строки. 

Определенный промежуток:

str = "Строки в Python и методы работы с ними"
print(str[9:15]) # Выведет "Python"

С начала строки:

str = "Строки в Python и методы работы с ними"
print(str[:15]) # Выведет "Строки в Python"

До самого конца:

str = "Строки в Python и методы работы с ними"
print(str[18:]) # Выведет "методы работы с ними"

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

str = "123456789"
print(str[::2]) # Выведет "13579"

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

Для подстановки в строку любой переменной, которая может являться результатом работы основной части кода, нам понадобятся f-строки. Они появились в Python 3.6, поэтому я рекомендую использовать только свежие версии этого языка программирования. Рассмотрим на примере работу с f-строками:

num = 2*10
num2 = 100
str = f"Первое число: {num}. Второе число: {num2}"
print(str) # Выведет "Первое число: 20. Второе число: 100"

Поиск в строках

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

Первый метод – startswith(). Он позволяет искать набор символов в начале строки. Рассмотрим на примере:

str =  "Строки в Python и методы работы с ними"
print(str.startswith("Строки")) #Выведет True

Второй метод – endswith(). Он позволяет искать набор символов в конце строки. Рассмотрим на примере:

str =  "...я разбирал строки в JavaScript"
print(str.endswith("JavaScript")) #Выведет True

А если нам нужно найти набор символов в произвольном месте строки, то используем метод find(). Рассмотрим на примере:

str = "Строки в Python и методы работы с ними"
print(str.find("Python")) #Выведет 9

В данном случае скрипт нашел набор символов в строке и вывел индекс начала его вхождения в ней.

str = "Строки в Python и методы работы с ними"
print(str.find("JavaScript")) #Выведет -1

А в этом случае скрипт не нашел набор символов в строке и вывел «-1».

Замена в строках

Для замены одного набора символов на другой в строке используют метод replace(). Рассмотрим данный метод на примере:

str = "Строки в Python и методы работы с ними"
print(str.replace("Python", "JavaScript")) #Выведет "JavaScript"

Вывод каждого символа в строке

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

str = "123"
for i in str:
print(i) #Выведет "1" "2" "3"

Узнаем длину строки

Для того чтобы получить длину строки, используем метод len():

str = "123"
print(len(str)) # Выведет 3

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

Если мы имеем строку, состоящую из набора цифр, то мы смело можем преобразовать ее в число, используя функцию приведения int(). Рассмотрим на примере:

str = "123"
print(int(str)) # Выведет 123

Изменение регистра строк в Python

Для того чтобы все буквы в строке были заглавными, используем метод upper():

str = "Строки в Python и методы работы с ними"
print(str.upper()) # Выведет "СТРОКИ В PYTHON И МЕТОДЫ РАБОТЫ С НИМИ"

И метод lower() для строчных букв:

str = "СТРОКИ В PYTHON И МЕТОДЫ РАБОТЫ С НИМИ"
print(str.upper()) # Выведет "строки в python и методы работы с ними"

Чтобы первая буква в строке стала заглавной, следует использовать метод capitalize():

str = "строки в python и методы работы с ними"
print(str.capitalize()) # Выведет "Строки в python и методы работы с ними"

Удаление лишних пробелов из строк

Метод strip() удаляет пробельные символы в начале и в конце строки. lstrip() и rstrip() делают то же самое, но в определенных местах: первый метод в начале строки, а второй – в ее конце.

Итог

Мы разобрали основные методы работы со строками в Python. Предлагайте идеи для статей и удачи в ваших начинаниях!

Одним из самых распространённых типов данных является строковый. Вопреки расхожему мнению, программист чаще сталкивается не с числами, а с текстом. В Python, как известно, всё является объектами. Не исключение и строки – это объекты, состоящие из набора символов. Естественно, в языке существует широкий набор инструментов для работы с этим типом данных.

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

Операторы «+» и «*» в Питоне применимы не только к числам, но и к строкам.

Оператор сложения строк +

Оператор «+» выполняет операцию, называемую конкатенацией, — объединение строк.

Пример:

var_1 = 'Привет,'
var_2 = 'Python!'
print(var_1 + ' ' + var_2)
# Вывод:

Привет, Python!
  

Можно и так:

var_1 = 'Привет, '
var_2 = 'Python!'
var_1 += var_2
print(var_1)
# Вывод:

Привет, Python!
  

Оператор умножения строк *

Оператор «*» дублирует строку указанное количество раз.

Пример:

var_1 = 'O_o '
var_2 = 10
print(var_1 * var_2)
# Вывод:

O_o O_o O_o O_o O_o O_o O_o O_o O_o O_o
  

Это работает только с целочисленными множителями. Если умножить на ноль или отрицательное число, результатом будет пустая строка. Но лучше так не делать.

var_1 = 'O_o'
[print('При множителе', i, 'получаем строку: "' + var_1 * i + '"') for i in range(-1, 2)]
# Вывод:

При множителе -1 получаем строку: ""

При множителе 0 получаем строку: ""

При множителе 1 получаем строку: "O_o"
  

Оператор принадлежности подстроки in

Если надо проверить, содержится ли подстрока в строке, удобно пользоваться оператором “in”

var_1 = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit. Id,
fuga, earum consequuntur magni accusamus nihil ipsum qui. Facere,
error velit possimus qui dolorum dolorem illum voluptates nemo pariatur ea. Temporibus.
'''
print('ipsum' in var_1)
# Вывод:

True
  

Так же можно использовать этот оператор с «not» для инвертирования результата.

var_1 = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit. Id,
fuga, earum consequuntur magni accusamus nihil ipsum qui. Facere,
error velit possimus qui dolorum dolorem illum voluptates nemo pariatur ea. Temporibus.
'''
print('тру-ля-ля' not in var_1)
# Вывод:

True
  

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

Пайтон содержит ряд удобных встроенных функций для работы со строками.

Функция ord() возвращает числовое значение символа, при чём, как для кодировки ASCII, так и для UNICODE.

print('A', ord('A'))
print('А русская', ord('А'))
print('~', ord('~'))
print('1', ord('1'))  # Обратите внимание, что здесь единица является именно строкой
# Вывод:

A 65

А русская 1040

~ 126

1 49
  

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

from random import randint

for i in range(10):
[print(chr(randint(0, 8000)), end=' ') for i in range(10)]
print('')
# Вывод:

૸ ச ઘ ᔝ ዱ છ ᐝ § ඗ ֹ

ၹ ሌ ᔭ ཋ ٺ ຝ ྅ ᒊ ֚ ᴠ

д ߀ Ỽ Ů ጼ ̼ ᅌ ᶥ ḿ ᇶ

ᴗ ȹ ཱི ๤ ൉ ᥈ Ҥ Р ᇑ ਴

ސ ਋ ϯ ኊ ᠻ ដ ࡯ ᄖ ᓣ ᆧ

ଯ ᑟ ߂ ޸ ൢ ԝ ᤵ ඡ ᴼ ႊ

ᥒ ᜭ ˽ ä ؑ ૧ ᅈ ഉ ौ ଦ

ᔚ ॓ ௵ ᥰ ɵ ຘ Ἵ ৓ ᨃ ང

ᬇ ᳓ ᕈ ᳖ ૓ ࣝ ˼ ʋ ં გ

? ᓀ ځ ื ᚢ Ӌ ဃ ᡹ ؅ ႔
  

Функция len() возвращает количество символов в строке.

from random import randint

for i in range(10):
var = [chr(randint(500, 800)) for i in range(randint(10, 20))]
print(len(''.join(var)), ''.join(var))
# Вывод:

11 ˫ʸɹʄˈȺȨȪȍʮ˴

16 ȷ˝ȁɚ˷Ⱥʾ̂ʨʗȍɺɹ˫̓ȼ

13 əʼɒȞʪɗʍ̍ˡɮɫȉʙ

10 ʜ˧ˬɆ˃əȃ̚ʰ̏

12 ˤ˾ʀɨȷˌɏʿɴȨ˲ȟ

13 ˌʡ˝ȭʪɈ˾ʵȋɎʋ˿ʍ

13 ˜̃ȱ̇ˋ˂ʡȞȍ̄ʭȌʣ

14 ̙ɸɎˈ̀ȾȠ˞ȒɇʀɈȁȫ

20 ȞȎʯɐʪəʔȆʳȨɦʚ˾Ǵȁɕˋ˘̈˭

12 ʷɱ̄˺ʽʤɳȂȗʍˉɦ
  

 Функция str() возвращает строковое представление объекта.

from math import inf, e, pi

print(str(...))
print(str(inf))
print(str(e))
print(str(pi))
print(str(10 + 11))
print(str(10 + 11j))
print(str(None))
print(str(1 == 1))
# Вывод:

Ellipsis

inf

2.718281828459045

3.141592653589793

21

(10+11j)

None

True

  

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

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

var = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Consequuntur, eligendi, aperiam, consequatur, perferendis
non sequi voluptates asperiores soluta quam ad id beatae
facere aut quod libero dignissimos inventore nesciunt commodi.'''
print(var[0])
print(var[10])
print(var[33])
# Вывод:

L

m

c
  

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

var = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Consequuntur, eligendi, aperiam, consequatur, perferendis
non sequi voluptates asperiores soluta quam ad id beatae
facere aut quod libero dignissimos inventore nesciunt commodi.'''
print(var[330])
# Вывод:

Traceback (most recent call last):

File "C:UsersivandAppDataRoamingJetBrainsPyCharm2021.2scratchesscratch.py", line 7, in <module>

print(var[330])

IndexError: string index out of range

 

Process finished with exit code 1
  

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

var = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Consequuntur, eligendi, aperiam, consequatur, perferendis
non sequi voluptates asperiores soluta quam ad id beatae
facere aut quod libero dignissimos inventore nesciunt commodi.'''
print(var[-1])
print(var[-10])
print(var[-33])
# Вывод:

.

t

s
  

Срезы строк

В Python существует механизм срезов коллекций. Срезы позволяют обратиться к подстроке используя индексы. Для этого надо в квадратных скобках указать: [начальный индекс : конечный индекс : шаг]. Каждый из параметров является необязательным. Поскольку строка это коллекция, срезы применимы и к ней.

var = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Consequuntur, eligendi, aperiam, consequatur, perferendis
non sequi voluptates asperiores soluta quam ad id beatae
facere aut quod libero dignissimos inventore nesciunt commodi.'''
print(var[-1: 50: -3])
print(var[10:-160])
print(var[::-33])
# Вывод:

.ootieetv msg elo ara   ea   ual rrssauvuso   snee,tqn ae dgernqn    i

m dolor sit amet, consectetur adipisicing elit.

Consequuntur, eligendi, aperiam, co

.s r a n

  

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

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

Главной особенностью этой функции является возможность подстановки значения переменной в строку.

Чтобы это сделать с помощью f-строки необходимо:

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

var = 10 * 254 // 77 % 5 ** 5
var_2 = f'Вот что получилось {var}'
print(var_2)
# Вывод:

Вот что получилось 32

  

Изменение строк

Тип данных строка в Python относится к неизменяемым (immutable), но это почти не влияет на удобство их использования, ведь можно создать изменённую копию. Для этого есть два возможных пути:

• Использовать перезапись значения переменной

var = 'Что-то '
var += 'и что-то ещё'
print(var)
var = var[:16] + 'новое'
print(var)
# Вывод:

Что-то и что-то ещё

Что-то и что-то новое

  

• Использовать встроенный метод replace(x, y):

var = 'Что-то '
print(var.replace('то ', 'нибудь'))
print(var)
# Вывод:

Что-нибудь

Что-то

  

Как Вы можете видеть, данный метод не меняет строку, а возвращает изменённую копию.

Встроенные методы строк в Python

Поскольку строка в Пайтон – это объект, у него есть свои методы. Методы – это те же самые функции, просто они «закреплены» за объектами определённого класса.

Изменение регистра строки

Если Вам надо изменить регистр строки, удобно использовать один из следующих методов

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

var = 'abracadabra'
print(var.capitalize())
print(var)
# Вывод:

Abracadabra

abracadabra

  

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

var = '_abracadabra'
print(var.capitalize())
print(var)
# Вывод:

_abracadabra

_abracadabra

  

lower() преобразует все буквенные символы в строчные.

var = 'AbRaCAdAbRa'
print(var.lower())
print(var)
# Вывод:

abracadabra

AbRaCAdAbRa

  

swapcase() меняет регистр на противоположный.

var = 'AbRaCAdAbRa'
print(var.swapcase())
print(var)
# Вывод:

aBrAcaDaBrA

AbRaCAdAbRa

  

title() преобразует первые буквы всех слов в заглавные

var = 'я пРосТо ПРИМЕР'
print(var.title())
var = 'я @странный _ПРИМЕР'
print(var.title())
print(var)
# Вывод:

Я Просто Пример

Я @Странный _Пример

я @странный _ПРИМЕР

  

upper() преобразует все буквенные символы в заглавные.

var = 'я пРосТо ПРИМЕР'
print(var.upper())
var = 'я @странный _ПРИМЕР'
print(var.upper())
print(var)
# Вывод:

Я ПРОСТО ПРИМЕР

Я @СТРАННЫЙ _ПРИМЕР

я @странный _ПРИМЕР

  

Найти и заменить подстроку в строке

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

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

count() подсчитывает количество точных вхождений подстроки в строку.

var = 'Ололо'
print(var.count('ол'))
# Вывод:

1

  

endswith() определяет, заканчивается ли строка заданной подстрокой.

var = 'Олололололо'
print(var.endswith('оло'))
print(var.endswith('ол', 5, 10))
# Вывод:

True

True

  

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

var = 'Олололололо'
print(var.find('оло'))
print(var.find('лОл'))
# Вывод:

2

-1

  

index() ищет в строке заданную подстроку.

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

var = 'Олололололо'
print(var.index('лОл'))
# Вывод:

Traceback (most recent call last):

File "C:UsersivandAppDataRoamingJetBrainsPyCharm2021.2scratchesscratch.py", line 3, in <module>

print(var.index('лОл'))

ValueError: substring not found

 

Process finished with exit code 1

  

rfind() ищет в строке заданную подстроку, начиная с конца.

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

var = 'Олололололо'
print(var.rfind('оло'))
# Вывод:

8

  

rindex() ищет в строке заданную подстроку, начиная с конца.

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

startswith() определяет, начинается ли строка с заданной подстроки.

var = 'Олололололо'
print(var.startswith('Оло'))
# Вывод:

True

  

Классификация строк

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

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

var = 'Олололололо'
print(var.isalnum())
# Вывод:

True

  

isalpha() определяет, состоит ли строка только из букв.

isdigit() определяет, состоит ли строка из цифр.

isidentifier() определяет, является ли строка допустимым идентификатором (название переменной, функции, класса и т.д.) Python.

var = 'print'
print(var.isidentifier())
# Вывод:

True

  

isidentifier() вернет True для строки, которая соответствует зарезервированному ключевому слову Пайтон, даже если его нельзя использовать.

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

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

islower() определяет, являются ли буквенные символы строки строчными.

isprintable() определяет, состоит ли строка только из печатаемых символов.

print('qwerty'.isidentifier())
print(chr(7).isidentifier())
# Вывод:

True

False

Это единственный метод данной группы, который возвращает True, если строка не содержит символов. Все остальные возвращаются False.

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

Тем не менее есть несколько символов ASCII, которые считаются пробелами. И если учитывать символы Юникода, их еще больше:

‘f’ и ‘r’ являются escape-последовательностями для символов ASCII; ‘u2005’ это escape-последовательность для Unicode.

istitle() определяет, начинаются ли слова строки с заглавной буквы.

isupper() определяет, являются ли буквенные символы строки заглавными.

Выравнивание строк, отступы

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

center() выравнивает строку по центру.

print('qwerty'.center(50))
print((' ' * 22 + 'qwerty' + ' ' * 22))
print((' ' * (25 - int(len('qwerty') / 2)) + 'qwerty' + ' ' * (25 - int(len('qwerty') / 2)) == ('qwerty'.center(50))))
# Вывод:

                       qwerty                      
                       qwerty                      
True


  

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

print('qwerty'.center(50, '='))
# Вывод:

======================qwerty======================

  

Если строка больше или равна указанной ширине, строка возвращается без изменений:

print('qwerty'.center(6, '='))
# Вывод:

qwerty

  

expandtabs()  заменяет каждый символ табуляции (‘t’) пробелами. По умолчанию табуляция заменяются на 8 пробелов.

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

ljust() выравнивание по левому краю.

lstrip() удаляет переданные в качестве аргумента символы слева. По умолчанию это пробелы.

print('__init__.py'.lstrip('_'))
# Вывод:

init__.py

  

replace() заменяет вхождения подстроки в строке.

var = 'Hello, C! Hello, JS! Hello, Python!'
print(var.replace('C', 'PHP'))
# Вывод:

Hello, PHP! Hello, JS! Hello, Python!

  

Необязательный аргумент count, указывает количество замен, которое нужно осуществить:

var = 'Hello, C! Hello, JS! Hello, Python!'
print(var.replace('Hello', 'Bye', 2))
# Вывод:

Bye, C! Bye, JS! Hello, Python!

  

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

rstrip() обрезает пробельные символы.

strip() удаляет символы с левого и правого края строки.

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

var = 'Hello, C! Hello, JS! Hello, Python!'
print(var.replace('Hello', 'Buy', 2).center(60).swapcase())
# Вывод:

              bUY, c! bUY, js! hELLO, pYTHON!               

  

zfill()  возвращает копию строки дополненную нулями слева для достижения длины строки указанной в параметре width:

var = 12/100*(-0.5)

print(str(var).zfill(7))
# Вывод:

-000.06

  

Если строка короче или равна параметру width, строка возвращается без изменений:

var = 10/3
print(str(var).zfill(7))
# Вывод:

3.3333333333333335

  

Методы преобразования строки в список

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

join() возвращает строку, которая является результатом конкатенации элементов коллекции и разделителя.

var: list[str] = ['1', '2', '3']
print('+'.join(var))
var: tuple[str, str, str] = ('1', '2', '3')
print(' & '.join(var))
var: set[str, str, str] = {'1', '2', '3'}
print(' и '.join(var))
var: dict[str, int] = {'1': 4, '2': 5, '3': 6}
print('->'.join(var))
# Вывод:

1+2+3

1 & 2 & 3

3 и 2 и 1

1->2->3

  

Стоит обратить внимание что все элементы итерируемого объекта должны быть строкового типа. Так же Вы могли заметить в последнем примере, что для объединения словаря в строку метод join() использует не значения, а ключи. Если Вам нужны именно ключи, то делается это так:

var: dict[str, str] = {'1': '4', '2': '5', '3': '6'}
print('->'.join(var.values()))
# Вывод:

4->5->6

  

Сложнее ситуация, когда нужны пары ключ-значение. Здесь придётся сперва распаковать кортежи.

var: dict[str, str] = {'1': '4', '2': '5', '3': '6'}
print('->'.join([str(a+':'+b) for a, b in var.items()]))
# Вывод:

1:4->2:5->3:6

  

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

• Часть строки до разделителя
• Разделитель
• Часть строки после разделителя

print('1:4->2:5->3:6'.partition(':'))
# Вывод:

('1', ':', '4->2:5->3:6')

  

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

print('1:4->2:5->3:6'.partition('7'))
# Вывод:

('1:4->2:5->3:6', '', '')
  

rpartition() делит строку на основе разделителя, начиная с конца.

rsplit() делит строку на список из подстрок. По умолчанию разделителем является пробел.

print('1:4->2:5->3:6'.rsplit('->'))
# Вывод:

['1:4', '2:5', '3:6']

  

split() делит строку на список из подстрок.

Ведет себя как rsplit(), за исключением того, что при указании maxsplit – максимального количества разбиений, деление начинается с левого края строки:

print('1:4->2:5->3:6'.rsplit('->', 1))
print('1:4->2:5->3:6'.split('->', 1))
# Вывод:

['1:4->2:5', '3:6']

['1:4', '2:5->3:6']

  

Если параметр maxsplit не указан, между rsplit() и split() разницы нет.

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

Заключение

В этом уроке мы рассмотрели основные инструменты для работы со строками в Python. Как видите, они удобны и гибки. Есть встроенные функции и методы объекта «строка», строковые литералы. Ещё больше возможностей даёт нерассмотренный в этом уроке метод format и модуль re. Так же отдельного разговора заслуживает работа с кодировками. Следует отметить для тех, кто уже знаком с другими языками программирования: в отличие от некоторых из них, один символ в Пайтоне тоже является строкой. И изюминка напоследок. Поскольку в Питоне всё является объектом, у каждой строки тоже есть атрибуты.

from pprint import pprint

pprint('Строка'.__dir__())
# Вывод:

['__repr__',

'__hash__',

'__str__',

'__getattribute__',

'__lt__',

'__le__',

'__eq__',

'__ne__',

'__gt__',

'__ge__',

'__iter__',

'__mod__',

'__rmod__',

'__len__',

'__getitem__',

'__add__',

'__mul__',

'__rmul__',

'__contains__',

'__new__',

'encode',

'replace',

'split',

'rsplit',

'join',

'capitalize',

'casefold',

'title',

'center',

'count',

'expandtabs',

'find',

'partition',

'index',

'ljust',

'lower',

'lstrip',

'rfind',

'rindex',

'rjust',

'rstrip',

'rpartition',

'splitlines',

'strip',

'swapcase',

'translate',

'upper',

'startswith',

'endswith',

'removeprefix',

'removesuffix',

'isascii',

'islower',

'isupper',

'istitle',

'isspace',

'isdecimal',

'isdigit',

'isnumeric',

'isalpha',

'isalnum',

'isidentifier',

'isprintable',

'zfill',

'format',

'format_map',

'__format__',

'maketrans',

'__sizeof__',

'__getnewargs__',

'__doc__',

'__setattr__',

'__delattr__',

'__init__',

'__reduce_ex__',

'__reduce__',

'__subclasshook__',

'__init_subclass__',

'__dir__',

'__class__']
  

Строки в Python

str.capitalize()

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

'нАЧАТЬ С ЗАГЛАВНОЙ '.capitalize()  # Начать с заглавной

str.casefold()

Возвращает копию строки в сложенном регистре.

Преобразование в сложенный регистр похоже на преобразование к нижнему регистру, однако более агрессивно. Например: буква «ß» в нижнем регистре в немецком языке соответствует сочетанию «ss», однако, ввиду того, что символ «ß» уже имеет нижний регистр, метод .lower() ни к чему не приведёт, в то время как casefold() приведёт символ к «ss».

'ß'.lower()  # 'ß'
'ß'.casefold()  # 'ss'

'groß'.casefold() == 'gross'  # True

str.center(width[, fillchar])

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

width : Желаемая минимальная длина результирующей строки.

fillchar : Символ, которым следует расширять строку. По умолчанию — пробел.

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

''.center(3, 'w')  # www
'1'.center(2, 'w')  # 1w
'1'.center(4, 'w')  # w1ww
'1'.center(0, 'w')  # 1
'1'.center(4)  # ' 1  '

Символ добавляется к строке циклично сначала справа, затем слева.

Чтобы позиционировать строку вправо используйте str.rjust().
Чтобы позиционировать строку влево используйте str.ljust().

str.count(sub[, start[, end]])

Для строки возвращает количество непересекающихся вхождений в неё указанной подстроки.

sub : Подстрока, количество вхождений которой следует вычислить.

start=0 : Позиция в строке, с которой следует начать вычислять количество вхождений подстроки.

end=None : Позиция в строке, на которой следует завершить вычислять количество вхождений подстроки.

my_str = 'подстрока из строк'
my_str.count('строка')  # 1
my_str.count('стр')  # 2
my_str.count('стр', 0, -1)  # 2
my_str.count('стр', 8)  # 1
my_str.count('стр', 1, 5)  # 0
my_str.count('стр', 1, 6)  # 1

Позиции начала и конца трактуются также как в срезах.

str.encode(encoding=»utf-8», errors=»strict»)

Кодирует строку в байты/байтстроку, используя зарегистрированный кодек.

encoding : Название кодировки. По умолчанию — системная кодировка, доступная из sys.getdefaultencoding().

errors=strict : Наименование схемы обработки ошибок. По умолчанию — strict.

Имена доступных кодировок лучше всего узнавать из документации к модулю codecs.

from sys import getdefaultencoding
getdefaultencoding()  # utf-8
my_string = 'кот cat'
type(my_string)  # str

my_string.encode()
# b'xd0xbaxd0xbexd1x82 cat'

my_string.encode('ascii')
# UnicodeDecodeError

my_string.encode('ascii', errors='ignore')
# b' cat'

my_string.encode('ascii', errors='replace')  
# b'??? cat'

my_string.encode('ascii', errors='xmlcharrefreplace')
# b'кот cat'

my_string.encode('ascii', errors='backslashreplace')
# b'\u043a\u043e\u0442 cat'

my_string.encode('ascii', errors='namereplace')
# b'\N{CYRILLIC SMALL LETTER KA}\N{CYRILLIC SMALL LETTER O}\N{CYRILLIC SMALL LETTER TE} cat'

surrogated = 'udcd0udcbaudcd0udcbeudcd1udc82 cat'

surrogated.encode()  
# UnicodeEncodeError

surrogated.encode(errors='surrogateescape')
# b'xd0xbaxd0xbexd1x82 cat'

surrogated.encode(errors='surrogatepass')
# b'xedxb3x90xedxb2xbaxedxb3x90xedxb2xbexedxb3x91xedxb2x82 cat'

Зарегистрировать новую схему можно при помощи codecs.register_error().

str.endswith(suffix[, start[, end]])

Возвращает флаг, указывающий на то, заканчивается ли строка указанным постфиксом.

suffix : Строка-постфикс, в наличии которой требуется удостовериться.

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

end : Позиция (индекс символа), на которой следует завершить поиск. Поддерживает отрицательные значения.

my_str = 'Discworld'
my_str.endswith('jockey')  # False
my_str.endswith('world')  # True
my_str.endswith('jockey', 2)  # False
my_str.endswith('Disc', 0, 4)  # True

str.expandtabs(tabsize=8)

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

tabsize=8 : Максимальное количество пробелов на которое может быть заменена табуляция.

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

my_str = 't1t10t100t1000t10000'

my_str.expandtabs()
# '        1       10      100     1000    10000'

my_str.expandtabs(4)
# '    1   10  100 1000    10000'

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

Если очередной символ является табуляцией (t), то на его место вставляется столько пробелов, сколько требуется для того, что текущий номер столбца стал равным позиции следующей табуляции. При этом сам символ табуляции не копируется.

Если очередной символ является переносом строки (n) или возвратом каретки (r), он копируется, а текущий номер столбца задаётся равным нулю.

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

str.find(sub[, start[, end]])

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

sub : Подстрока, начальный индекс размещения которой требуется определить.

start=0 : Индекс начала среза в исходной строке, в котором требуется отыскать подстроку.

end=None : Индекс конца среза в исходной строке, в котором требуется отыскать подстроку.

Если подстрока не найдена, возвращает −1.

my_str = 'barbarian'
my_str.find('bar')  # 0
my_str.find('bar', 1)  # 3
my_str.find('bar', 1, 2)  # -1

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

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

my_str = 'barbarian'
'bar' in my_str  # True

str.format(args, *kwargs)

Возвращает копию строки, отформатированную указанным образом.

args : Позиционные аргументы.
kwargs : Именованные аргументы.

Строка, для которой вызывается данный метод может содержать как обычный текст, так и маркеры в фигурных скобках {}, которые следует заменить. Обычный текст, вне скобок будет выведен как есть без именений.

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

Наименование состоит из имени аргумента (либо его индекса). Числовой индекс при этом указывает на позиционный аргумент; имя указывает на именованный аргумент.

Если используются числа, и они составляют последовательность (0, 1, 2…), то они могут быть опущены разом (но не выборочно). Например, {}-{}-{} и {0}-{1}-{2} эквивалентны.

'{}-{}-{}'.format(1, 2, 3)  # Результат: '1-2-3'
'{}-{}-{}'.format(*[1, 2, 3])  # Результат: '1-2-3'
'{one}-{two}-{three}'.format(two=2, one=1, three=3)  # Результат: '1-2-3'
'{one}-{two}-{three}'.format(**{'two': 2, 'one': 1, 'three': 3})  # Результат: '1-2-3'

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

• Атрибут объекта адресуется при помощи . (точки).
• Доступ к элементу при помощи [] (квадратных скобок).

import datetime
obj = {'one': {'sub': 1}, 'two': [10, 2, 30], 'three': datetime.datetime.now()}
'{one[sub]}-{two[1]}-{three.year}'.format(**obj)

Приведение используется для приведения типов перед форматированием.

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

Поддерживаются три флага приведения:
* !s Вызывает str()
* !r Вызывает repr()
* !a Вызывает ascii().

import datetime 
demo = datetime.date.today()
result = '{!s}, {!r}, {!a}, {}'.format(demo, demo ,demo, demo)
print(result)

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

Можно задавать ширину поля и выравнивание

right = 'Начало{0:20}Конец'.format(7)
left = 'Начало{0:<20}Конец'.format(8)
center = 'Начало{0:^20}Конец'.format(9)

print(right)
print(left)
print(center)

Результат

Начало                   7Конец
Начало8                   Конец
Начало                   9Конец

Вывод вещественных чисел

print('{0}'.format(4/3))
print('{0:f}'.format(4/3))
print('{0:.2f}'.format(4/3))
print('{0:10.3f}'.format(4/3))

Результат

1.3333333333333333
1.333333
1.33
     1.333

str.index(sub[, start[, end]])

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

sub : Подстрока, начальный индекс размещения которой требуется определить.

start=0 : Индекс начала среза в исходной строке, в котором требуется отыскать подстроку.

end=None : Индекс конца среза в исходной строке, в котором требуется отыскать подстроку.

Работа данного метода аналогична работе str.find(), однако, если подстрока не найдена, возбуждается исключение

my_str = 'barbarian'
my_str.index('bar')  # 0
my_str.index('bar', 1)  # 3
my_str.index('bar', 1, 2)  # ValueError

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

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

my_str = 'barbarian'
'bar' in my_str  # True

str.isalnum()

Возвращает флаг, указывающий на то, содержит ли строка только цифры и/или буквы.

Вернёт True, если в строке хотя бы один символ и все символы строки являются цифрами и/или буквами, иначе — False.

''.isalnum()  # False
'  '.isalnum()  # False
'!@#'.isalnum()  # False
'abc'.isalnum()  # True
'123'.isalnum()  # True
'abc123'.isalnum()  # True

str.isalpha()

Возвращает флаг, указывающий на то, содержит ли строка только буквы.

Вернёт True, если в строке есть хотя бы один символ, и все символы строки являются буквами, иначе — False.

''.isalpha()  # False
'  '.isalpha()  # False
'!@#'.isalpha()  # False
'abc'.isalpha()  # True
'123'.isalpha()  # False
'abc123'.isalpha()  # False

str.isascii()

Возвращает флаг, указывающий на то, содержит ли строка только ASCII-символы.

Вернет True, если в строке содержаться только ASCII-символы или строка пустая, иначе вернет False.

str.isdigit()

Возвращает флаг, указывающий на то, содержит ли строка только цифры.

Вернёт True, если в строке хотя бы один символ и все символы строки являются цифрами, иначе — False.

''.isdigit()  # False
'  '.isdigit()  # False
'!@#'.isdigit()  # False
'abc'.isdigit()  # False
'123'.isdigit()  # True
'abc123'.isdigit()  # False

str.isidentifier()

Возвращает флаг, указывающий на то, является ли строка идентификатором.

Речь идёт об идентификаторах языка. Более подробная информация об идентификаторах и ключевых словах Питона содержится в разделе оригинальной документации Identifiers and keywords.

'continue'.isidentifier()  # True
'cat'.isidentifier()  # True
'function_name'.isidentifier()  # True
'ClassName'.isidentifier()  # True
'_'.isidentifier()  # True
'number1'.isidentifier()  # True
'1st'.isidentifier()  # False
'*'.isidentifier()  # False

Для проверки на то является ли строка зарезервированным идентификатором (например: def, class), используйте keyword.iskeyword().

str.islower()

Возвращает флаг, указывающий на то, содержит ли строка символы только нижнего регистра.

Вернёт True, если все символы строки поддерживающие приведение к регистру приведены к нижнему, иначе — False.

'нижний lower'.islower()  # True

Внимание
str.islower() может возвращать False, например, если строка содержит только символы не поддерживающие приведение к регистру:

'12'.islower()  # False

Для приведения символов строки к нижнему регистру используйте метод lower().

str.isnumeric()

Возвращает флаг, указывающий на то, содержит ли строка только числа.

Вернёт True, если в строке есть символы и все они присущи числам.

''.isnumeric()  # False
'a'.isnumeric()  # False
'0'.isnumeric()  # True
'10'.isnumeric()  # True
'⅓'.isnumeric()  # True
'Ⅻ'.isnumeric()  # True

К символам чисел относятся цифры, а также все символы, имеющие признак числа в Unicode, например: U+2155 (VULGAR FRACTION ONE FIFTH) — это любые символы, у которых признак Numeric_Type установлен равным Digit, или Decimal, или Numeric.

str.isprintable()

Возвращает флаг, указывающий на то, все ли символы строки являются печатаемыми.

Вернёт True, если строка пустая, либо если все её символы могут быть выведены на печать.

''.isprintable()  # True
' '.isprintable()  # True
'1'.isprintable()  # True
'a'.isprintable()  # True
''.isprintable()  # False (Group Separator)
''.isprintable()  # False (Escape)

Непечатаемыми символами являются символы Юникод из категории Other или Separator, исключая символ пробела из ASCII (0x20), который считается печатаемым.

Печатаемые символы не требуется экранировать в случае применения repr() к строке. Они не влияют на обработку строк, отправляемых в sys.stdout или sys.stderr.

str.isspace()

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

Вернёт True, если в строке есть символы и все они являются пробельными, иначе — False.

'  '.isspace()  # True
'n'.isspace()  # True
't'.isspace()  # True
' '.isspace()  # True (OGHAM SPACE MARK)
''.isspace()  # False
'!@#'.isspace()  # False
'abc'.isspace()  # False
'123'.isspace()  # False
'abc123'.isspace()  # False

Пробельными символами являются символы Юникод из категории Other или Separator, а также те, у которых свойство бинаправленности принимает значение WS, B, или S.

str.istitle()

Возвращает флаг, указывающий на то, начинается ли каждое из «слов» строки с заглавной буквы.

Вернёт True, если в строке хотя бы один символ или все «слова» в строке начинаются с заглавных букв, иначе — False.

'S'.istitle()  # True
'Some Text'.istitle()  # True
'Some text'.istitle()  # False
'S1 T2%'.istitle()  # True

str.isupper()

Возвращает флаг, указывающий на то, содержит ли строка символы только верхнего регистра.

Вернёт True, если все символы строки поддерживающие приведение к регистру приведены к верхнему, иначе — False.

str.join(iterable)

Возвращает строку, собранную из элементов указанного объекта, поддерживающего итерирование.

iterable : Объект со строками, поддерживающий итерирование.

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

dots = '..'
my_str = dots.join(['1', '2'])  # '1..2'
my_str = dots.join('ab')  # 'a..b'

Ожидается, что итерируемый объект выдаёт строки. Для массового приведения к строке можно воспользоваться функцией map(): dots.join(map(str, [100, 200])) # ‘100…200’

str.ljust(width[, fillchar])

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

width : Желаемая минимальная длина результирующей строки.

fillchar : Символ, которым следует расширять строку. По умолчанию — пробел.

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

''.ljust(3, 'w')  # www
'1'.ljust(4, 'w')  # 1www
'1'.ljust(0, 'w')  # 1
'1'.ljust(4)  # '1   '

Антонимом функции, позиционирующим строку вправо, является str.rjust().

Для расширения строки в обоих направлениях используйте str.center().

str.lower()

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

Алгоритм приведения к нижнему регистру описан в параграфе 3.13 стандарта Unicode.

'SoMe СлОнов'.lower()  # some слонов'

Для приведения символов строки к верхнему регистру используйте метод upper().

Для проверки того, содержит ли строка только символы в нижнем регистре используйте islower().

str.lower().islower() может возвращать False, если строка содержит только символы не поддерживающие приведение к регистру: ’12’.lower().islower() # False

str.lstrip([chars])

Возвращает копию указанной строки, с начала (слева l — left) которой устранены указанные символы.

chars=None : Строка с символами, которые требуется устранить. Если не указана, будут устранены пробельные символы. Это не префикс и не суффикс, это перечисление нужных символов.

'abca'.lstrip('ac')  # 'bca'

str.maketrans(x[, y[, z]])

Возвращает таблицу переводов, которую можно использовать в методе translate. В примере ниже букве «а» будет соответствовать «1», «b» — «2», а «с» — «3»

intab = "abc" 
outtab = "123" 
trantab = str.maketrans(intab, outtab) 

str.partition(sep)

Разбивает строку на три составляющие (начало, разделитель, конец) и возвращает в виде кортежа. Направление разбиения: слева направо.

sep : Строка-разделитель, при помощи которой требуется разбить исходную строку. Может содержать как один, так и несколько символов.

Возвращает кортеж из трёх элементов.

my_str = ''
my_str.partition('.')  # ('', '', '')

my_str = '12'
my_str.partition('.')  # ('12', '', '')

my_str = '.1.2'
my_str.partition('.')  # ('', '.', '1.2')

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

Когда требуется разбить строку на множество составляющих, используйте str.split.

str.replace(old, new[, count])

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

old : Искомая подстрока, которую следует заменить.

new : Подстрока, на которую следует заменить искомую.

maxcount=None : Максимальное требуемое количество замен. Если не указано, будут заменены все вхождения искомой строки.

my_str = 'barbarian'
my_str = my_str.replace('bar', 'mur')  # 'murmurian'
my_str = my_str.replace('mur', 'bur', 1)  # 'burmurian'

str.rfind(sub[, start[, end]])

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

str.rindex(sub[, start[, end]])

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

sub : Подстрока, начальный индекс размещения которой требуется определить.

start=0 : Индекс начала среза в исходной строке, в котором требуется отыскать подстроку.

end=None : Индекс конца среза в исходной строке, в котором требуется отыскать подстроку.

Работа данного метода аналогична работе str.rfind(), однако, если подстрока не найдена, возбуждается исключение

my_str = 'barbarian'
my_str.rindex('bar')  # 3
my_str.rindex('bar', 1)  # 3
my_str.rindex('bar', 1, 2)  # ValueError

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

str.rjust(width[, fillchar])

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

width : Желаемая минимальная длина результирующей строки.

fillchar : Символ, которым следует расширять строку. По умолчанию — пробел.

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

''.rjust(3, 'w')  # www
'1'.rjust(4, 'w')  # www1
'1'.rjust(0, 'w')  # 1
'1'.rjust(4)  # '   1'

Антонимом функции, позиционирующим строку влево, является str.ljust().

Для расширения строки в обоих направлениях используйте str.center().

Когда требуется дополнить строку нулями слева, используйте str.zfill().

str.rpartition(sep)

Разбивает строку на три составляющие (начало, разделитель, конец) и возвращает в виде кортежа. Направление разбиения: справа налево.

sep : Строка-разделитель, при помощи которой требуется разбить исходную строку. Может содержать как один, так и несколько символов.
Возвращает кортеж из трёх элементов.

Поведение метода аналогично поведению str.partition за исключением направления разбиения строки.

my_str = ''
my_str.rpartition('.')  # ('', '', '')

my_str = '12'
my_str.rpartition('.')  # ('', '', '12')

my_str = '.1.2'
my_str.rpartition('.')  # ('.1', '.', '2')

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

Разбивает строку на части, используя разделитель, и возвращает эти части списком. Направление разбиения: справа налево.

sep=None : Строка-разделитель, при помощи которой требуется разбить исходную строку. Может содержать как один, так и несколько символов. Если не указан, то используется специальный алгоритм разбиения, для которого разделителем считается последовательность пробельных символов.

maxsplit=-1 : Максимальное количество разбиений, которое требуется выполнить. Если −1, то количество разбиений не ограничено.

Поведение метода аналогично поведению str.split за исключением направления разбиения строки.

str.rstrip([chars])

Возвращает копию указанной строки, с конца (справа r — right) которой устранены указанные символы.

chars=None : Строка с символами, которые требуется устранить. Если не указана, будут устранены пробельные символы. Это не префикс и не суффикс, это перечисление нужных символов.

'abca'.rstrip('ac')  # 'ab'

Когда требуется разбить строку на три составляющие (начало, разделитель, конец), используйте str.rpartition.

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

Разбивает строку на части, используя разделитель, и возвращает эти части списком. Направление разбиения: слева направо.

sep=None : Строка-разделитель, при помощи которой требуется разбить исходную строку. Может содержать как один, так и несколько символов. Если не указан, то используется специальный алгоритм разбиения, для которого разделителем считается последовательность пробельных символов.

maxsplit=-1 : Максимальное количество разбиений, которое требуется выполнить. Если −1, то количество разбиений не ограничено.

Если указан разделитель, разбиение пустой строки вернёт список с единственным элементом — пустой строкой: [''].

'1,2,3'.split(',')  # ['1', '2', '3']
'1,2,3'.split(',', maxsplit=1)  # ['1', '2,3']

'1,2,,3,'.split(',')   # ['1', '2', '', '3', ''] 
'1   2   3'.split(' ')  # ['1', '', '', '2', '', '', '3']

Если разделитель не указан, разбиение пустой строки вернёт пустой список: [].

'1 2 3'.split()  # ['1', '2', '3']
'1 2 3'.split(maxsplit=1)  # ['1', '2 3']

'1   2   3'.split()  # ['1', '2', '3']  

В случаях, когда требуется, чтобы разбиение строки происходило справа налево, используйте str.rsplit. Когда требуется разбить строку на три составляющие (начало, разделитель, конец), используйте str.partition.

str.splitlines([keepends])

Разбивает строку на множество строк, возвращая их списком.

keepends=False — Флаг, указывающий на то следует ли оставлять в результирующем списке символы переноса строк. По умолчанию символы удаляются.

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

my_str = 'ab cnnde fgrklrn'
my_str.splitlines()  # ['ab c', '', 'de fg', 'kl']
my_str.splitlines(True)  # ['ab cn', 'n', 'de fgr', 'klrn']

В отличие от split(), которому можно передать символ-разделитель, данный метод для пустой строки вернёт пустой список, а символ переноса строки в конце не добавит в список дополнительного элемента.

''.splitlines()  # []
''.split('n')  # ['']

my_str = 'abn cdn'

my_str.splitlines()  # ['ab', 'cd']
my_str.split('n')  # ['ab', 'cd', '']

str.startswith(prefix[, start[, end]])

Возвращает флаг, указывающий на то, начинается ли строка с указанного префикса.

prefix : Строка-префикс, в наличии которой требуется удостовериться.

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

end : Позиция (индекс символа), на которой следует завершить поиск. Поддерживает отрицательные значения.

my_str = 'Discworld'
my_str.startswith('Mad')  # False
my_str.startswith('Disc')  # True
my_str.startswith('Disc', 1)  # False
my_str.startswith('world', 4, 9)  # True

Для определения наличия постфикса в строке используйте str.endswith().

str.strip([chars])

Возвращает копию указанной строки, с обоих концов которой устранены указанные символы.

chars=None : Строка с символами, которые требуется устранить. Если не указана, будут устранены пробельные символы. Это не префикс и не суффикс, это перечисление нужных символов.

'abca'.strip('ac')  # 'b'

str.swapcase()

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

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

'Кот ОбОрмот!'.swapcase()  # кОТ оБоРМОТ!

Внимание
Для 8-битных строк (Юникод) результат метода зависит от локали.
Следующее выражение не обязано быть истинным: `str`.swapcase().swapcase() == `str`.

str.title()

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

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

'кот ОбОрмот!'.title()  # Кот Обормот!

"they're bill's friends from the UK".title()  
# They'Re Bill'S Friends From The Uk

Алгоритм использует простое, независящее от языка определение слова — это группа последовательных букв. Такого определения во многих случаях достаточно, однако, в словах с апострофами (в английском они используются, например, в сокращениях и притяжательных формах) оно приводит к неожиданным результатам (см. пример выше). И в таких случаях лучше всего будет воспользоваться методом замены в регулярных выражениях (см. модуль re).

Для 8-битных строк (Юникод) результат метода зависит от текущей локали.

str.translate(table)

Возвращает строку, преобразованную с помощью таблицы переводов, которую в свою очередь можно получить с помощью str.maketrans. В примере ниже все
буквы «а» будут заменены на «1», а «b» — на «2».

trantab = str.maketrans("ab", "12")
print('abc test'.translate(trantab))

str.upper()

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

Алгоритм приведения к верхнему регистру описан в параграфе 3.13 стандарта Unicode.

'SoMe СлОнов'.upper()  # SOME СЛОНОВ

Для приведения символов строки к нижнему регистру используйте метод lower().

Для проверки того, содержит ли строка только символы в верхнем регистре используйте isupper().

str.zfill(width)

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

width : Желаемая минимальная длина результирующей строки.

Изначальная строка не обрезается, даже если в ней меньше символов, чем указано в параметре желаемой длины.
В ходе компоновки результирующей строки ведущие знаки *+* и *-* сохраняют своё место в её начале.

''.zfill(3)  # 000
'1'.zfill(4)  # 0001
'1'.zfill(0)  # 1
'-1'.zfill(4)  # -001
'a'.zfill(4)  # 000a
'-a'.zfill(4)  # -00a

Условно сходного результата можно также добиться при использовании метода str.rjust(), передав 0 в качестве второго аргумента.

Условным антонимом функции, добавляющим нули справа можно считать str.ljust(), передав 0 в качестве второго аргумента.