Python методы строки: Строки. Функции и методы строк

Содержание

Строки. Функции и методы строк

S = ‘str’; S = «str»; S = »’str»’; S = «»»str»»» Литералы строк
S = «s\np\ta\nbbb» Экранированные последовательности
S = r»C:\temp\new» Неформатированные строки (подавляют экранирование)
S = b»byte» Строка байтов
S1 + S2 Конкатенация (сложение строк)
S1 * 3 Повторение строки
S[i] Обращение по индексу
S[i:j:step] Извлечение среза
len(S) Длина строки
S.find(str, [start],[end]) Поиск подстроки в строке. Возвращает номер первого вхождения или -1
S.rfind(str, [start],[end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или -1
S.index(str, [start],[end]) Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError
S.rindex(str, [start],[end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError
S.replace(шаблон, замена[, maxcount]) Замена шаблона на замену. maxcount ограничивает количество замен
S.split(символ) Разбиение строки по разделителю
S.isdigit() Состоит ли строка из цифр
S.isalpha() Состоит ли строка из букв
S.isalnum() Состоит ли строка из цифр или букв
S.islower() Состоит ли строка из символов в нижнем регистре
S.isupper() Состоит ли строка из символов в верхнем регистре
S.isspace() Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы (‘\f’), «новая строка» (‘\n’), «перевод каретки» (‘\r’), «горизонтальная табуляция» (‘\t’) и «вертикальная табуляция» (‘\v’))
S. istitle() Начинаются ли слова в строке с заглавной буквы
S.upper() Преобразование строки к верхнему регистру
S.lower() Преобразование строки к нижнему регистру
S.startswith(str) Начинается ли строка S с шаблона str
S.endswith(str) Заканчивается ли строка S шаблоном str
S.join(список) Сборка строки из списка с разделителем S
ord(символ) Символ в его код ASCII
chr(число) Код ASCII в символ
S.capitalize() Переводит первый символ строки в верхний регистр, а все остальные в нижний
S.center(width, [fill]) Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию)
S.count(str, [start],[end]) Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию)
S. expandtabs([tabsize]) Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам
S.lstrip([chars]) Удаление пробельных символов в начале строки
S.rstrip([chars]) Удаление пробельных символов в конце строки
S.strip([chars]) Удаление пробельных символов в начале и в конце строки
S.partition(шаблон) Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки
S.rpartition(sep) Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку
S. swapcase() Переводит символы нижнего регистра в верхний, а верхнего – в нижний
S.title() Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний
S.zfill(width) Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями
S.ljust(width, fillchar=» «) Делает длину строки не меньшей width, по необходимости заполняя последние символы символом fillchar
S.rjust(width, fillchar=» «) Делает длину строки не меньшей width, по необходимости заполняя первые символы символом fillchar
S.format(*args, **kwargs) Форматирование строки

работа со строками, форматирование,методы split, strip

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

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

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

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

Вы уже видели операторы + и * в применении их к числовым значениям в уроке по операторам в Python . Эти два оператора применяются и к строкам.

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

+

+ — оператор конкатенации строк. Он возвращает строку, состоящую из других строк, как показано здесь:

>>> s = 'py'
>>> t = 'th'
>>> u = 'on'

>>> s + t
'pyth'
>>> s + t + u
'python'

>>> print('Привет, ' + 'Мир!')
Go team!!!

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

*

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

s * n
n * s

Вот примеры умножения строк:

>>> s = 'py.'

>>> s * 4
'py.py.py.py.'
>>> 4 * s
'py.py.py.py.'

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

>>> 'py' * -6
''

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

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

in

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

>>> s = 'Python'
>>> s in 'I love Python.'
True
>>> s in 'I love Java.'
False

Есть также оператор not in, у которого обратная логика:

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

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

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

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

Более подробно о них ниже.

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

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

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

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

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

Unicode — это современный стандарт, который пытается предоставить числовой код для всех возможных символов, на всех возможных языках, на каждой возможной платформе. Python 3 поддерживает Unicode, в том числе позволяет использовать символы Unicode в строках.

Функция ord() также возвращает числовые значения для символов Юникода:

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

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

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

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

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

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

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

len(s) возвращает количество символов в строке s:

>>> s = 'Простоя строка. '
>>> len(s)
15

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

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

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

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

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

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

Индексация строк начинается с нуля: у первого символа индекс 0, следующего 1 и так далее. Индекс последнего символа в python — ‘‘длина строки минус один’’.

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

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

>>> s = 'foobar'

>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> s[5]
'r'

Попытка обращения по индексу большему чем len(s) - 1, приводит к ошибке IndexError:

>>> s[6]
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    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'

Попытка обращения по индексу меньшему чем -len(s), приводит к ошибке IndexError:

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

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

Срезы строк

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

>>> s = 'python'
>>> s[2:5]
'tho'

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

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

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

>>> s = 'python'
>>> s[:4]
'pyth'
>>> s[0:4]
'pyth'

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

>>> s = 'python'
>>> s[2:]
'thon'
>>> s[2:len(s)]
'thon'

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

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

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

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

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

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

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

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

Шаг для среза строки

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

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

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

>>> 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 = 'python'
>>> s[5:0:-2]
'nhy'

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

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

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

Это общая парадигма для разворота (reverse) строки:

>>> s = 'Если так говорит товарищ Наполеон, значит, так оно и есть.'
>>> s[::-1]
'.ьтсе и оно кат ,тичанз ,ноелопаН щиравот тировог кат илсЕ'

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

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

Возможности форматирования строк огромны и не будут подробно описана здесь.
Одной простой особенностью f-строк, которые вы можете начать использовать сразу, является интерполяция переменной. Вы можете указать имя переменной непосредственно в f-строковом литерале (f'string'), и python заменит имя соответствующим значением.

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

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print('Произведение', n, 'на', m, 'равно', prod)
Произведение 20 на 25 равно 500

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

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

Код с использованием f-string, приведенный ниже выглядит намного чище:

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print(f'Произведение {n} на {m} равно {prod}')
Произведение 20 на 25 равно 500

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

>>> var = 'Гав'
>>> print(f'Собака говорит {var}!')
Собака говорит Гав!
>>> print(f"Собака говорит {var}!")
Собака говорит Гав!
>>> print(f'''Собака говорит {var}!''')
Собака говорит Гав!

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

Строки — один из типов данных, которые Python считает неизменяемыми, что означает невозможность их изменять. Как вы ниже увидите, python дает возможность изменять (заменять и перезаписывать) строки.

Такой синтаксис приведет к ошибке TypeError:

>>> s = 'python'
>>> s[3] = 't'
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    s[3] = 't'
TypeError: 'str' object does not support item assignment

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

>>> s = s[:3] + 't' + s[4:]
>>> s
'pytton'

Есть встроенный метод string.replace(x, y):

>>> s = 'python'
>>> s = s.replace('h', 't')
>>> s
'pytton'

Читайте дальше о встроенных методах строк!

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

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

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

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

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

obj.foo(<args>)

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

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

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

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

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

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

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

>>> s = 'everyTHing yoU Can IMaGine is rEAl'
>>> s.capitalize()
'Everything you can imagine is real'

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

>>> s = 'follow us @PYTHON'
>>> s.capitalize()
'Follow us @python'

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

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

>>> 'everyTHing yoU Can IMaGine is rEAl'.lower()
'everything you can imagine is real'

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

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

>>> 'everyTHing yoU Can IMaGine is rEAl'.swapcase()
'EVERYthING YOu cAN imAgINE IS ReaL'

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

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

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

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

>>> 'follow us @PYTHON'.title()
'Follow Us @Python'

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

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

>>> 'follow us @PYTHON'.upper()
'FOLLOW US @PYTHON'

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

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

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

string.count(<sub>[, <start>[, <end>]]) подсчитывает количество вхождений подстроки в строку.

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

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

Количество вхождений изменится, если указать <start> и <end>:

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

string.endswith(<suffix>[, <start>[, <end>]]) определяет, заканчивается ли строка заданной подстрокой.

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

>>> 'python'.endswith('on')
True
>>> 'python'.endswith('or')
False

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

>>> 'python'.endswith('yt', 0, 4)
True
>>> 'python'.endswith('yt', 2, 4)
False

string.find(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку.

s.find(<sub>) возвращает первый индекс в s который соответствует началу строки <sub>:

>>> 'Follow Us @Python'.find('Us')
7

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

>>> 'Follow Us @Python'.find('you')
-1

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

>>> 'Follow Us @Python'.find('Us', 4)
7
>>> 'Follow Us @Python'.find('Us', 4, 7)
-1

string.index(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку.

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

>>> 'Follow Us @Python'.index('you')
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    'Follow Us @Python'.index('you')
ValueError: substring not found

string.rfind(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку, начиная с конца.

s.rfind(<sub>) возвращает индекс последнего вхождения подстроки <sub> в s, который соответствует началу <sub>:

>>> 'Follow Us @Python'.rfind('o')
15

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

>>> 'Follow Us @Python'.rfind('a')
-1

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

>>> 'Follow Us @Python'.rfind('Us', 0, 14)
7
>>> 'Follow Us @Python'.rfind('Us', 9, 14)
-1

string.rindex(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку, начиная с конца.

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

>>> 'Follow Us @Python'.rindex('you')
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    'Follow Us @Python'.rindex('you')
ValueError: substring not found

string.startswith(<prefix>[, <start>[, <end>]]) определяет, начинается ли строка с заданной подстроки.

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

>>> 'Follow Us @Python'.startswith('Fol')
True
>>> 'Follow Us @Python'.startswith('Go')
False

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

>>> 'Follow Us @Python'.startswith('Us', 7)
True
>>> 'Follow Us @Python'.startswith('Us', 8, 16)
False

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

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

string.isalnum() определяет, состоит ли строка из букв и цифр.

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

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

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

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

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

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

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

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

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

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

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

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

>>> 'and'.isidentifier()
True

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

string.center(<width>[, <fill>]) выравнивает строку по центру.

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

>>> 'py'.center(10)
'    py    '

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

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

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

>>> 'python'.center(2)
'python'

string.expandtabs(tabsize=8) заменяет табуляции на пробелы

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

>>> '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'

string.ljust(<width>[, <fill>]) выравнивание по левому краю строки в поле.

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

>>> 'python'.ljust(10)
'python    '

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

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

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

>>> 'python'.ljust(2)
'python'

string.lstrip([<chars>]) обрезает пробельные символы слева

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

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

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

>>> 'https://www.pythonru.com'.lstrip('/:pths')
'www.pythonru.com'

string.replace(<old>, <new>[, <count>]) заменяет вхождения подстроки в строке.

s.replace(<old>, <new>) возвращает копию s где все вхождения подстроки <old>, заменены на <new>:

>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love')
'I love python! I love python! I love python!'

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

>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love', 2)
'I love python! I love python! I hate python!'

string.rjust(<width>[, <fill>]) выравнивание по правому краю строки в поле.

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

>>> 'python'.rjust(10)
'    python'

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

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

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

>>> 'python'.rjust(2)
'python'

string.rstrip([<chars>]) обрезает пробельные символы справа

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

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

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

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

string.strip([<chars>]) удаляет символы с левого и правого края строки.

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.pythonru.com'.strip('w.moc')
'pythonru'

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

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

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

string.zfill(<width>) дополняет строку нулями слева.

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'

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

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

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

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

string.join(<iterable>) объединяет список в строку.

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', разделенного символом ':'.

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

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

Это можно исправить так:

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

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

string.partition(<sep>) делит строку на основе разделителя.

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

  • Часть s до <sep>
  • Разделитель <sep>
  • Часть s после <sep>

Вот пара примеров .partition()в работе:

>>> 'foo.bar'.partition('.')
('foo', '.', 'bar')
>>> '[email protected]@[email protected]@baz'.partition('@@')
('foo', '@@', '[email protected]@baz')

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

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

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

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

>>> '[email protected]@[email protected]@baz'.partition('@@')
('foo', '@@', '[email protected]@baz')

>>> '[email protected]@[email protected]@baz'.rpartition('@@')
('[email protected]@bar', '@@', 'baz')

string.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.pythonru.com'.rsplit(sep='.', maxsplit=1)
['www.pythonru', 'com']

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

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

string.split(sep=None, maxsplit=-1) делит строку на список из подстрок.

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

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

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

string.splitlines([<keepends>]) делит текст на список строк.

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

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

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

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

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

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

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

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

Заключение

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

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

Строки. Функции и методы строк — Документация Python Summary 1

# Литералы строк
S = 'str'; S = "str"; S = '''str'''; S = """str"""
# Экранированные последовательности
S = "s\np\ta\nbbb"
# Неформатированные строки (подавляют экранирование)
S = r"C:\temp\new"
# Строка байтов
S = b"byte"
# Конкатенация (сложение строк)
S1 + S2
# Повторение строки
S1 * 3
# Обращение по индексу
S[i]
# Извлечение среза
S[i:j:step]
# Длина строки
len(S)
# Поиск подстроки в строке. Возвращает номер первого вхождения или -1
S.find(str, [start],[end])
# Поиск подстроки в строке. Возвращает номер последнего вхождения или -1
S.rfind(str, [start],[end])
# Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError
S.index(str, [start],[end])
# Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError
S.rindex(str, [start],[end])
# Замена шаблона
S.replace(шаблон, замена)
# Разбиение строки по разделителю
S.split(символ)
# Состоит ли строка из цифр
S.isdigit()
# Состоит ли строка из букв
S.isalpha()
# Состоит ли строка из цифр или букв
S.isalnum()
# Состоит ли строка из символов в нижнем регистре
S.islower()
# Состоит ли строка из символов в верхнем регистре
S.isupper()
# Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы ('\f'), "новая строка" ('\n'), "перевод каретки" ('\r'), "горизонтальная табуляция" ('\t') и "вертикальная табуляция" ('\v'))
S.isspace()
# Начинаются ли слова в строке с заглавной буквы
S.istitle()
# Преобразование строки к верхнему регистру
S.upper()
# Преобразование строки к нижнему регистру
S.lower()
# Начинается ли строка S с шаблона str
S.startswith(str)
# Заканчивается ли строка S шаблоном str
S.endswith(str)
# Сборка строки из списка с разделителем S
S.join(список)
# Символ в его код ASCII
ord(символ)
# Код ASCII в символ
chr(число)
# Переводит первый символ строки в верхний регистр, а все остальные в нижний
S.capitalize()
# Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию)
S.center(width, [fill])
# Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию)
S.count(str, [start],[end])
# Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам
S.expandtabs([tabsize])
# Удаление пробельных символов в начале строки
S.lstrip([chars])
# Удаление пробельных символов в конце строки
S.rstrip([chars])
# Удаление пробельных символов в начале и в конце строки
S.strip([chars])
# Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки
S.partition(шаблон)
# Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку
S.rpartition(sep)
# Переводит символы нижнего регистра в верхний, а верхнего – в нижний
S.swapcase()
# Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний
S.title()
# Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями
S.zfill(width)
# Делает длину строки не меньшей width, по необходимости заполняя последние символы символом fillchar
S.ljust(width, fillchar=" ")
# Делает длину строки не меньшей width, по необходимости заполняя первые символы символом fillchar
S.rjust(width, fillchar=" ")

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

Основные методы строк

Последнее обновление: 02.05.2017

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

  • isalpha(): возвращает True, если строка состоит только из алфавитных символов

  • islower(): возвращает True, если строка состоит только из символов в нижнем регистре

  • isupper(): возвращает True, если все символы строки в верхнем регистре

  • isdigit(): возвращает True, если все символы строки — цифры

  • isnumeric(): возвращает True, если строка представляет собой число

  • startswith(str): возвращает True, если строка начинается с подстроки str

  • endswith(str): возвращает True, если строка заканчивается на подстроку str

  • lower(): переводит строку в нижний регистр

  • upper(): переводит строку в вехний регистр

  • title(): начальные символы всех слов в строке переводятся в верхний регистр

  • capitalize(): переводит в верхний регистр первую букву только самого первого слова строки

  • lstrip(): удаляет начальные пробелы из строки

  • rstrip(): удаляет конечные пробелы из строки

  • strip(): удаляет начальные и конечные пробелы из строки

  • ljust(width): если длина строки меньше параметра width, то справа от строки добавляются пробелы, чтобы дополнить значение width,
    а сама строка выравнивается по левому краю

  • rjust(width): если длина строки меньше параметра width, то слева от строки добавляются пробелы, чтобы дополнить значение width,
    а сама строка выравнивается по правому краю

  • center(width): если длина строки меньше параметра width, то слева и справа от строки равномерно добавляются пробелы,
    чтобы дополнить значение width, а сама строка выравнивается по центру

  • find(str[, start [, end]): возвращает индекс подстроки в строке. Если подстрока не найдена, возвращается число -1

  • replace(old, new[, num]): заменяет в строке одну подстроку на другую

  • split([delimeter[, num]]): разбивает строку на подстроки в зависимости от разделителя

  • join(strs): объединяет строки в одну строку, вставляя между ними определенный разделитель

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


string = input("Введите число: ")
if string.isnumeric():
    number = int(string)
    print(number)

Проверка, начинается или оканчивается строка на определенную подстроку:


file_name = "hello.py"

starts_with_hello = file_name.startswith("hello")   # True
ends_with_exe = file_name.endswith("exe")           # False

Удаление пробелов в начале и в конце строки:


string = "   hello  world!  "
string = string.strip()
print(string)           # hello  world!

Дополнение строки пробелами и выравнивание:


print("iPhone 7:", "52000".rjust(10))
print("Huawei P10:", "36000".rjust(10))

Консольный вывод:


iPhone 7:      52000
Huawei P10:      36000

Поиск в строке

Для поиска подстроки в строке в Python применяется метод find(), который возвращает индекс первого вхождения подстроки в строку и
имеет три формы:

  • find(str): поиск подстроки str ведется с начала строки до ее конца

  • find(str, start): параметр start задает начальный индекс, с которого будет производиться поиск

  • find(str, start, end): параметр end задает конечный индекс, до которого будет идти поиск

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


welcome = "Hello world! Goodbye world!"
index = welcome.find("wor")
print(index)       # 6

# поиск с 10-го индекса
index = welcome.find("wor",10)
print(index)       # 21

# поиск с 10 по 15 индекс
index = welcome.find("wor",10,15)
print(index)       # -1

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

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

  • replace(old, new): заменяет подстроку old на new

  • replace(old, new, num): параметр num указывает, сколько вхождений подстроки old надо заменить на new


phone = "+1-234-567-89-10"

# замена дефисов на пробел
edited_phone = phone.replace("-", " ")
print(edited_phone)     # +1 234 567 89 10

# удаление дефисов
edited_phone = phone.replace("-", "")
print(edited_phone)     # +12345678910

# замена только первого дефиса
edited_phone = phone.replace("-", "", 1)
print(edited_phone)     # +1234-567-89-10

Разделение на подстроки

Метод split() разбивает строку на список подстрок в зависимости от разделителя. В качестве разделителя может выступать любой символ или последовательность символов.
Данный метод имеет следующие формы:

  • split(): в качестве разделителя используется пробел

  • split(delimeter): в качестве разделителя используется delimeter

  • split(delimeter, num): параметр num указывает, сколько вхождений delimeter используется для разделения. Оставшаяся часть строки добавляется
    в список без разделения на подстроки


text = "Это был огромный, в два обхвата дуб, с обломанными ветвями и с обломанной корой"
# разделение по пробелам
splitted_text = text.split()
print(splitted_text)
print(splitted_text[6])     # дуб,

# разбиение по запятым
splitted_text = text.split(",")
print(splitted_text)
print(splitted_text[1])     # в два обхвата дуб

# разбиение по первым пяти пробелам
splitted_text = text.split(" ", 5)
print(splitted_text)        
print(splitted_text[5])     # обхвата дуб, с обломанными ветвями и с обломанной корой

Соединение строк

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


words = ["Let", "me", "speak", "from", "my", "heart", "in", "English"]

# разделитель - пробел
sentence = " ".join(words)
print(sentence)  # Let me speak from my heart in English

# разделитель - вертикальная черта
sentence = " | ".join(words)
print(sentence)  # Let | me | speak | from | my | heart | in | English

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


word = "hello"
joined_word = "|".join(word)
print(joined_word)      # h|e|l|l|o

Интерактивный учебник языка Python

1. Строки

Строка считывается со стандартного ввода функцией input(). Напомним,
что для двух строк определена операция сложения (конкатенации), также определена
операция умножения строки на число.

Строка состоит из последовательности символов. Узнать количество символов (длину строки)
можно при помощи функции len.

Любой другой объект в Питоне можно перевести к строке, которая ему соответствует.
Для этого нужно вызвать функцию str(), передав ей в качестве параметра объект,
переводимый в строку.

На самом деле каждая строка, с точки зрения Питона, — это объект
класса str. Чтобы получить по объекту другой объект другого класса, как-то ему соответствующий,
можно использовать функцию приведения. Имя этой функции совпадает с именем класса, к которому мы приводим объект.
(Для знатоков: эта функция — это конструктор объектов данного класса.) Пример: int — класс
для целых чисел. Перевод строки в число осуществляется функцией int().

What is the answer?
42
s = input()
print(len(s))
t = input()
number = int(t)
u = str(number)
print(s * 3)
print(s + ' ' + u)

2. Срезы (slices)

Срез (slice) — извлечение из данной строки одного символа или некоторого фрагмента
подстроки или подпоследовательности.

Есть три формы срезов. Самая простая форма среза: взятие одного символа
строки, а именно, S[i] — это срез, состоящий из одного символа,
который имеет номер i. При этом считается, что нумерация начинается
с числа 0. То есть если S = 'Hello', то
S[0] == 'H', S[1] == 'e', S[2] == 'l',
S[3] == 'l', S[4] == 'o'.

Заметим, что в Питоне нет отдельного типа для символов строки. Каждый объект, который получается
в результате среза S[i] — это тоже строка типа str.

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

Если указать отрицательное значение индекса, то номер будет отсчитываться
с конца, начиная с номера -1. То есть S[-1] == 'o',
S[-2] == 'l', S[-3] == 'l', S[-4] == 'e',
S[-5] == 'H'.

Или в виде таблицы:

Строка S H e l l o
Индекс S[0] S[1] S[2] S[3] S[4]
Индекс S[-5] S[-4] S[-3] S[-2] S[-1]

Если же номер символа в срезе строки S больше либо равен len(S),
или меньше, чем -len(S), то при обращении к этому символу строки произойдет
ошибка IndexError: string index out of range.

Срез с двумя параметрами: S[a:b]
возвращает подстроку из b - a символов,
начиная с символа c индексом a,
то есть до символа с индексом b, не включая его.
Например, S[1:4] == 'ell', то же самое получится
если написать S[-4:-1]. Можно использовать как положительные,
так и отрицательные индексы в одном срезе, например, S[1:-1] —
это строка без первого и последнего символа (срез начинается с символа с индексом 1 и
заканчиватеся индексом -1, не включая его).

При использовании такой формы среза ошибки IndexError
никогда не возникает. Например, срез S[1:5]
вернет строку 'ello', таким же будет результат,
если сделать второй индекс очень большим, например,
S[1:100] (если в строке не более 100 символов).

Если опустить второй параметр (но поставить двоеточие),
то срез берется до конца строки. Например, чтобы удалить
из строки первый символ (его индекс равен 0), можно
взять срез S[1:]. Аналогично
если опустить первый параметр, то можно взять срез от начала строки.
То есть удалить из строки последний символ можно при помощи среза
S[:-1]. Срез S[:] совпадает с самой строкой
S.

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

На самом деле в питоне нет и переменных. Есть лишь имена, которые связаны с какими-нибудь объектами.
Можно сначала связать имя с одним объектом, а потом — с другим. Можно несколько имён
связать с одним и тем же объектом.

Если задать срез с тремя параметрами S[a:b:d],
то третий параметр задает шаг, как в случае с функцией
range, то есть будут взяты символы с индексами
a, a + d, a + 2 * d и т. д.
При задании значения третьего параметра, равному 2, в срез попадет
кажый второй символ, а если взять значение среза, равное
-1, то символы будут идти в обратном порядке.
Например, можно перевернуть строку срезом S[::-1].

	
s = 'abcdefg'
print(s[1])
print(s[-1])
print(s[1:3])
print(s[1:-1])
print(s[:3])
print(s[2:])
print(s[:-1])
print(s[::2])
print(s[1::2])
print(s[::-1])

3. Методы

Метод — это функция, применяемая к объекту, в данном случае — к строке.
Метод вызывается в виде Имя_объекта.Имя_метода(параметры).
Например, S.find("e") — это применение к строке S
метода find с одним параметром "e".

3.1. Методы find и rfind

Метод find находит в данной строке (к которой применяется метод)
данную подстроку (которая передается в качестве параметра).
Функция возвращает индекс первого вхождения искомой подстроки.
Если же подстрока не найдена, то метод возвращает значение -1.

	
S = 'Hello'
print(S.find('e'))
# вернёт 1
print(S.find('ll'))
# вернёт 2
print(S.find('L'))
# вернёт -1

Аналогично, метод rfind возвращает индекс последнего вхождения
данной строки (“поиск справа”).

	
S = 'Hello'
print(S.find('l'))
# вернёт 2
print(S.rfind('l'))
# вернёт 3

Если вызвать метод find с тремя параметрами
S.find(T, a, b), то поиск будет осуществляться
в срезе S[a:b]. Если указать только два параметра
S.find(T, a), то поиск будет осуществляться
в срезе S[a:], то есть начиная с символа с индексом
a и до конца строки. Метод S.find(T, a, b)
возращает индекс в строке S, а не индекс относительно среза.

3.2. Метод replace

Метод replace заменяет все вхождения одной строки на другую. Формат:
S.replace(old, new) — заменить в строке S
все вхождения подстроки old на подстроку new. Пример:

	
print('Hello'.replace('l', 'L'))
# вернёт 'HeLLo'

Если методу replace задать еще один параметр: S.replace(old, new, count),
то заменены будут не все вхождения, а только не больше, чем первые count из них.

	
print('Abrakadabra'.replace('a', 'A', 2))
# вернёт 'AbrAkAdabra'
3.3. Метод count

Подсчитывает количество вхождений одной строки в другую строку. Простейшая
форма вызова S.count(T)  возвращает число вхождений строки
T внутри строки S. При этом подсчитываются только
непересекающиеся вхождения, например:

	
print('Abracadabra'.count('a'))
# вернёт 4
print(('a' * 10).count('aa'))
# вернёт 5

При указании трех параметров S.count(T, a, b),
будет выполнен подсчет числа вхождений строки T
в срезе S[a:b].


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

Работа со строками в Python. Готовимся к собеседованию: вспоминаем азы

Петр Смолович

ведущий разработчик хостинг-провайдера и регистратора доменов REG.RU

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

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

Как склеить две строки?

>>> s = "abc" + "def"
>>> s += "xyz"

Элементарно? Почти. Важно помнить, что строки — это неизменяемые объекты. Каждый раз, когда мы говорим про «изменение» строки, технически мы создаем новый объект и записываем туда вычисленное значение.

А как склеить три строки? Напрашивается ответ «точно так же», и иногда это самый лучший способ. Но интервьюер скорее всего хочет проверить, знаете ли вы про метод .join().

>>> names = ["John", "Paul", "Ringo", "George"]
>>> ", ".join(names)
'John, Paul, Ringo, George'

join() — очень удобный метод, позволяющий склеить N строк, причём с произвольным разделителем.

Здесь важно не только получить результат, но и понимать, как работает приведённая конструкция. А именно, что join() — это метод объекта «строка», принимающий в качестве аргумента список и возвращающий на выходе новую строку.
Кстати, хорошая задачка для интервью — написать свою реализацию join().

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

Есть несколько способов получить часть строки. Первый — это split, обратный метод для join. В отличие от join’а, он применяется к целевой строке, а разделитель передаётся аргументом.

>>> s = "Альфа, Браво, Чарли"
>>> s.split(", ")
['Альфа', 'Браво', 'Чарли']

Второй — срезы (slices).

Срез s[x:y] позволяет получить подстроку с символа x до символа y. Можно не указывать любое из значений, чтобы двигаться с начала или до конца строки. Отрицательные значения используются для отсчёта с конца (-1 — последний символ, -2 — предпоследний и т.п.).

>>> s = "Hello, world!"
>>> print(s[0:5])
Hello
>>> print(s[-6:])
world!

При помощи необязательного третьего параметра s[x:y:N] можно выбрать из подстроки каждый N-ый символ. Например, получить только чётные или только нечётные символы:

>>> s = "0123456789"
>>> print(s[::2])
02468
>>> print(s[1::2])
13579

Что насчёт поиска в строке?

Самое быстрое — проверить, начинается ли (заканчивается ли) строка с выбранных символов. Для этого в Python предусмотрены специальные строковые методы.

>>> s = "0123456789"
>>> s.startswith("012")
True
>>> s.endswith("69")
False

Для поиск подстроки в произвольном месте есть метод с говорящим названием find()./]+)(.*)$», s)
>>> print(result.group(1))
https
>>> print(result.group(2))
www.reg.ru
>>> print(result.group(3))
/hosting/

А замену в строке сделать сможете?

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

>>> s = "Hello, darling! How are you?"
>>> s[:7] + "Василий" + s[14:]
'Hello, Василий! How are you?'

Во-вторых, умеешь find(), умей и replace().

>>> s.replace("darling", "Василий")
'Hello, Василий! How are you?'

В-третьих, любую проблему можно решить регулярными выражениями. Либо получить две проблемы 🙂 В случае с заменой вам нужен метод re.sub().

>>> s = "https://www.reg.ru/hosting/";
>>> import re
>>> print(re.sub('[a-z]', 'X', s))
XXXXX://XXX.XXX.XX/XXXXXXX/

Посимвольная обработка?

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

>>> s = "Hello, world!"
>>> for c in s:
>>>     if c == "o":
>>>         counter += 1
>>> print(counter)
2

Иногда удобнее бежать по индексу.

>>> for i in range(len(s)):
>>>     if s[i] == "o":
>>>         counter += 1

Помним, что строки неизменяемы, поэтому подменить i-ый символ по индексу не получится, нужно создавать новый объект:

>>> s[i] = "X"
Traceback (most recent call last):
File "", line 1, in 
TypeError: 'str' object does not support item assignment
>>> s[:i] + "X" + s[i+1:]
'HellX, world!'

Либо можно преобразовать строку в список, сделать обработку, а потом склеить список обратно в строку:

>>> arr = list(s)
>>> "".join(arr)
'Hello, world!'

А форматирование строк?

Типичная жизненная необходимость — сформировать строку, подставив в неё результат работы программы. Начиная с Python 3.6, это можно делать при помощи f-строк:

>>> f"Строка '{s}' содержит {len(s)} символов."
"Строка 'Hello, world!' содержит 13 символов."

В более старом коде можно встретить альтернативные способы

>>> "Строка '%s' содержит %d символов" % (s, len(s))
>>> "Строка '{}' содержит {} символов".format(s, len(s))

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

>>> "Строка '" + s + "' содержит " + str(len(s)) + " символов."
"Строка 'Hello, world!' содержит 13 символов."

***

Цель работодателя на собеседовании — убедиться что вы соображаете и что вы справитесь с реальными задачами. Однако погружение в реальные задачи занимает несколько недель, а время интервью ограничено. Поэтому вас ждут учебные задания, которые можно решить за 10-30 минут, а также вопросы на понимание того, как работает код. О них и поговорим в следующей части.

Обработка строк в Python

В Python существуют несколько видов данных. Основные типы данных, с которыми вы столкнетесь – это string, ingteger, float, list, dict и tuple. В данной статье мы рассмотрим тип данных string (строка). Вы удивитесь тому, сколько всего можно делать со строками в Python. Также существует модуль string, который можно импортировать для получения доступа к еще большим возможностям, но мы рассмотрим его в другой статье. Вместо этого, мы пройдемся по следующим разделам:

  • Как создавать строки
  • Конкатенация строк
  • Методы строк
  • Замена строк

Как создать строку

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

my_string = «Добро пожаловать в Python!»
another_string = ‘Я новый текст тут…’

a_long_string = »’А это у нас
новая строка
в троичных скобках»’

my_string = «Добро пожаловать в Python!»

another_string = ‘Я новый текст тут…’

 

a_long_string = »’А это у нас

новая строка

в троичных скобках»’

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

my_string = «I’m a Python programmer!»
otherString = ‘Слово «Python» обычно подразумевает змею’
tripleString = «»»В такой «строке» мы можем ‘использовать’ все.»»»

my_string = «I’m a Python programmer!»

otherString = ‘Слово «Python» обычно подразумевает змею’

tripleString = «»»В такой «строке» мы можем ‘использовать’ все.»»»

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

my_number = 123
my_string = str(my_number)

my_number = 123

my_string = str(my_number)

Если вы впишете данный код в ваш интерпретатор, вы увидите, что вы изменили значение интегратора на строку и присвоили ее переменной my_string. Это называется кастинг, или конвертирование. Вы можете конвертировать некоторые типы данных в другие, например числа в строки. Но вы также заметите, что вы не всегда можете делать обратное, например, конвертировать строку вроде ‘ABC’ в целое число. Если вы сделаете это, то получите ошибку вроде той, что указана в этом примере:

int(‘ABC’)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
ValueError: invalid literal for int() with base 10: ‘ABC’

int(‘ABC’)

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

ValueError: invalid literal for int() with base 10: ‘ABC’

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

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

my_string = «abc»
my_string[0] = «d»

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: ‘str’ object does not support item assignment

my_string = «abc»

my_string[0] = «d»

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

TypeError: ‘str’ object does not support item assignment

Здесь мы пытаемся изменить первую букву с «а» на «d«, в итоге это привело к ошибке TypeError, которая не дает нам сделать это. Теперь вы можете подумать, что присвоение новой строке то же значение и есть изменение строки. Давайте взглянем, правда ли это:

my_string = «abc»
a = id(my_string)
print(a) # 19397208

my_string = «def»
b = id(my_string)
print(b) # 25558288

my_string = my_string + «ghi»
c = id(my_string)
print(c) # 31345312

my_string = «abc»

a = id(my_string)

print(a) # 19397208

 

my_string = «def»

b = id(my_string)

print(b) # 25558288

 

my_string = my_string + «ghi»

c = id(my_string)

print(c) # 31345312

Проверив id объекта, мы можем определить, что когда мы присваиваем новое значение переменной, то это меняет тождество. Обратите внимание, что в версии Python, начиная с 2.0, строки могут содержать только символы ASCII. Если вам нужен Unicode, тогда вы должны вписывать u перед вашей строкой. Пример:

# -*- coding: utf-8 -*-
my_unicode_string = u»Это юникод!»

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

my_unicode_string = u»Это юникод!»

В Python, начиная с версии 3, все строки являются юникодом.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

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

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

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

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

string_one = «Собака съела »
string_two = «мою книгу!»
string_three = string_one + string_two

print(string_three) # Собака съела мою книгу!

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

 

string_one = «Собака съела «

string_two = «мою книгу!»

string_three = string_one + string_two

 

print(string_three) # Собака съела мою книгу!

Оператор + конкатенирует две строки в одну

Методы строк

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

my_string = «This is a string!»

my_string = «This is a string!»

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

Если вы открыли ваш интерпретатор, вы также можете сделать то же самое:

«This is a string!».upper()

«This is a string!».upper()

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

Вы увидите что-то на подобие этого:

[‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__doc__’, ‘__eq__’, ‘__format__’,
‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getnewargs__’, ‘__getslice__’, ‘__gt__’,
‘__hash__’, ‘__init__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mod__’, ‘__mul__’, ‘__ne__’,
‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__rmod__’, ‘__rmul__’, ‘__-
setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘_formatter_field_name_split’,
‘_formatter_parser’, ‘capitalize’, ‘center’, ‘count’, ‘decode’, ‘encode’, ‘endswith’, ‘expandtabs’,
‘find’, ‘format’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isdigit’, ‘islower’, ‘isspace’,
‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’,
‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’,
‘title’, ‘translate’, ‘upper’, ‘zfill’]

[‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__doc__’, ‘__eq__’, ‘__format__’,

‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getnewargs__’, ‘__getslice__’, ‘__gt__’,

‘__hash__’, ‘__init__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mod__’, ‘__mul__’, ‘__ne__’,

‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__rmod__’, ‘__rmul__’, ‘__-

setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘_formatter_field_name_split’,

‘_formatter_parser’, ‘capitalize’, ‘center’, ‘count’, ‘decode’, ‘encode’, ‘endswith’, ‘expandtabs’,

‘find’, ‘format’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isdigit’, ‘islower’, ‘isspace’,

‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’,

‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’,

‘title’, ‘translate’, ‘upper’, ‘zfill’]

Вы можете спокойно игнорировать методы, которые начинаются и заканчиваются двойным подчеркиванием, например __add__. Они не используются в ежедневном программировании в Python. Лучше обратите внимание на другие. Если вы хотите узнать, что делает тот или иной метод, просто обратитесь к справке. Например, если вы хотите узнать, зачем вам capitalize, впишите следующее, чтобы узнать:

help(my_string.capitalize)

help(my_string.capitalize)

Вы получите следующую информацию:

Help on built-in function capitalize:

capitalize(…)
S.capitalize() -> string

Выдача копии строки S только с заглавной буквой.

Help on built-in function capitalize:

 

capitalize(…)

    S.capitalize() -> string

 

Выдача копии строки S только с заглавной буквой.

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

type(my_string) # <type ‘str’>

type(my_string) # <type ‘str’>

Как вы видите, тип переменной my_string является str!

Нарезка строк

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

my_string = «I like Python!»

my_string = «I like Python!»

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

print( my_string[0:1] ) # I

print( my_string[0:1] ) # I

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

0 1 2 3 4 5 6 7 8 9 10 11 12 13 — I l i k e P y t h o n !

0 1 2 3 4 5 6 7 8 9 10 11 12 13 — I l i k e P y t h o n !

Таким образом, у нас есть строка длиной в 14 символов, начиная с нуля и до тринадцати. Давайте приведем несколько примеров, чтобы понять это лучше.

my_string[:1] # ‘I’
my_string[0:12] # ‘I like Pytho’
my_string[0:13] # ‘I like Python’
my_string[0:14] # ‘I like Python!’
my_string[0:-5] # ‘I like Py’
my_string[:] # ‘I like Python!’
my_string[2:] # ‘like Python!’

my_string[:1] # ‘I’

my_string[0:12] # ‘I like Pytho’

my_string[0:13] # ‘I like Python’

my_string[0:14] # ‘I like Python!’

my_string[0:-5] # ‘I like Py’

my_string[:] # ‘I like Python!’

my_string[2:] # ‘like Python!’

Как видно в данных примерах, мы можем назначить срез, лишь указав его начало (другими словами, my_string[2:]), конец среза (my_string[:1]), или оба (my_string[0:13]). Мы можем даже использовать отрицательные значения, которые начинаются с конца строки. Так что в примере, где мы указали my_string[0:-5], начало ведется с нуля и заканчивается 5 символами, перед концом строки. Вы можете задаться вопросом «Зачем мне это и где это можно применить?». Лично я использовал это для разбора записей с фиксированной шириной в файлах, или ситуативно для парсинга сложных названий файлов, с очень специфическими наименованиями. Также я использовал это для парсинга значений в бинарных файлах. Любая работа, которая включает в себя обработку текстовых файлов, может быть намного проще, если вы понимаете, как работает нарезка и как эффективно использовать данный инструмент. Вы также можете получить доступ к отдельным символам в строке с помощью индексации. Например:

Данный код выдаст первый символ в строке.

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

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

# -*- 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 и яблоки

# -*- 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 попытается вставить ее в строку. Вы можете вставить несколько строк, добавив несколько знаков процента в свою строку. Это видно в последнем примере. Обратите внимание на то, что когда вы добавляете больше одной строки, вам нужно закрыть эти строки в круглые скобки. Теперь взглянем на то, что случится, если мы вставим недостаточное количество строк:

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

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

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

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

TypeError: not enough arguments for format string

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

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’

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 округлит числа для вас, если вы передадите ему дробь, что лучше, чем два десятичных значения. Давайте взглянем на то, что произойдет, если мы передадим неправильные данные:

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

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

В данном примере мы передали две строки вместо целого числа и дроби. Это привело к ошибке TypeError, что говорит нам о том, что 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

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

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

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

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

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

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

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

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

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

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

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

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

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

Подведем итоги

Мы проработали большой объем в данной статье. Давайте разберемся:
Сначала мы узнали, как создавать строки, после чего мы перешли к вопросу об их конкатенации. После этого, мы взглянули на несколько методов, которые предлагает нам объект string. Далее, мы рассмотрели нарезку строк и закончили замещением строк.

Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

E-mail: [email protected]

Образование
Universitatea Tehnică a Moldovei (utm.md)

  • 2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
  • 2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»

Строковые методы Python

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

Метод Описание
capitalize () Преобразует первый
символ в верхний регистр
casefold () Преобразует строку в
нижний регистр
по центру () Возвращает по центру
строка
count () Возвращает количество
раз указанное значение встречается в строке
encode () Возвращает закодированный
версия строки
endwith () Возвращает true, если
строка заканчивается указанным значением
expandtabs () Устанавливает
размер табуляции строки
find () Ищет в строке
указанное значение и возвращает позицию, где оно было найдено
формат () Указанные форматы
значения в строке
format_map () Указанные форматы
значения в строке
index () Ищет строку
для указанного значения и возвращает позицию, где оно было найдено
isalnum () Возвращает True, если все
символы в строке буквенно-цифровые
isalpha () Возвращает True, если все
символы в строке находятся в алфавите
isdecimal () Возвращает True, если все
символы в строке десятичные
isdigit () Возвращает True, если все
символы в строке — это цифры
isidentifier () Возвращает True, если
строка является идентификатором
islower () Возвращает True, если все
символы в строке строчные
isnumeric () Возвращает True, если
все символы в строке числовые
isprintable () Возвращает True, если
все символы в строке печатаются
isspace () Возвращает True, если все
символы в строке — это пробелы
название () Возвращает True, если строка соответствует правилам
название
isupper () Возвращает True, если все
символы в строке в верхнем регистре
join () Присоединяет элементы
итерация до конца строки
ljust () Возвращает выровненный по левому краю
версия строки
lower () Преобразует строку в
нижний регистр
lstrip () Возвращает левую обрезку
версия строки
maketrans () Возвращает
таблица переводов для использования в переводах
partition () Возвращает кортеж
где струна разделена на три части
replace () Возвращает строку
где указанное значение заменяется указанным значением
rfind () Ищет строку для
указанное значение и возвращает последнюю позицию, где оно было найдено
rindex () Ищет строку для
указанное значение и возвращает последнюю позицию, где оно было найдено
rjust () Возвращает выровненный по правому краю
версия строки
rpartition () Возвращает кортеж
где струна разделена на три части
rsplit () Разбивает строку на
указанный разделитель и возвращает список
rstrip () Возвращает правую обшивку
версия строки
split () Разбивает строку на
указанный разделитель и возвращает список
splitlines () Разделяет строку
при переносе строки и возвращает список
начинается с () Возвращает истину, если
строка начинается с указанного значения
strip () Возвращает обрезанную версию строки
Своп-кейс () Своп-кейс, нижний
регистр становится прописным и наоборот
название () Преобразует первое
символ каждого слова в верхнем регистре
translate () Возвращает
переведенная строка
верхний () Преобразует строку
в верхний регистр
zfill () Заполняет строку
указанное количество значений 0 в начале

Python String find () Method

❮ Строковые методы


Пример

Где в тексте слово «добро пожаловать» ?:

txt = «Привет, добро пожаловать в мой мир.»

x = txt.find (» добро пожаловать «)

print (x)

Попробуй сам »


Определение и использование

Метод find () находит первый
появление указанного значения.

Метод find () возвращает -1, если значение
не найден.

Метод find () почти такой же, как и метод
индекс ()
метод, единственное отличие состоит в том, что индекс ()
метод вызывает исключение, если значение не найдено.(См. Пример ниже)


Синтаксис

строка .find (значение , начало, конец )

Значения параметров

Параметр Описание
значение Обязательно. Значение для поиска
начало Необязательно. С чего начать поиск. По умолчанию 0
конец Необязательно.Где закончить поиск. По умолчанию до конца строки

Другие примеры

Пример

Где в тексте впервые встречается буква «е» ?:

txt = «Привет, добро пожаловать в мой мир.»

x = txt.find («e»)

print (x)

Попробуй сам »

Пример

Где в тексте буква «е» встречается впервые, когда
вы ищите только между позициями 5 и 10 ?:

txt = «Привет, добро пожаловать в мой мир.»

x = txt.find (» e «,
5, 10)

отпечаток (x)

Попробуй сам »

Пример

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

txt = «Привет, добро пожаловать в мой мир.»

print (txt.find («q»))
print (txt.index («q»))

Попробуй сам »


❮ Строковые методы

Python String index () Метод

❮ Строковые методы


Пример

Где в тексте слово «добро пожаловать» ?:

txt = «Привет, добро пожаловать в мой мир.»

x = txt.index (» добро пожаловать «)

print (x)

Попробуй сам »


Определение и использование

Метод index () находит первый
появление указанного значения.

Метод index () вызывает исключение, если значение не найдено.

Метод index () почти такой же, как и метод
найти ()
метод, единственная разница в том, что find ()
метод возвращает -1, если значение не найдено.(См. Пример ниже)


Синтаксис

строка .index (значение , начало, конец )

Значения параметров

Параметр Описание
значение Обязательно. Значение для поиска
начало Необязательно. С чего начать поиск. По умолчанию 0
конец Необязательно.Где закончить поиск. По умолчанию до конца строки

Другие примеры

Пример

Где в тексте впервые встречается буква «е» ?:

txt = «Привет, добро пожаловать в мой мир.»

x = txt.index («e»)

print (x)

Попробуй сам »

Пример

Где в тексте буква «е» встречается впервые, когда
вы ищите только между позициями 5 и 10 ?:

txt = «Привет, добро пожаловать в мой мир.»

x = txt.index (» e «,
5, 10)

отпечаток (x)

Попробуй сам »

Пример

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

txt = «Привет, добро пожаловать в мой мир.»

print (txt.find («q»))
print (txt.index («q»))

Попробуй сам »


❮ Строковые методы

3.6.1 Строковые методы

3.6.1 Строковые методы

3.6.1 Строковые методы

Это строковые методы, которые используют как 8-битные строки, так и Unicode.
поддержка объектов:

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

Для 8-битных строк этот метод зависит от языкового стандарта.

центр ( ширина [, fillchar ] )
Возврат по центру строки длиной и шириной .Заполнение сделано
используя указанный fillchar (по умолчанию — пробел).

Изменено в версии 2.4:
Поддержка аргумента fillchar .

количество ( подчиненный [, начало [, конец ] ] )
Вернуть количество вхождений подстроки sub в строку
S [ начало : конец ] . Необязательные аргументы начинают и
конец интерпретируются как в нотации среза.
декодировать ( [ кодировка [, ошибки ] ] )
Декодирует строку, используя кодек, зарегистрированный для с кодировкой .
Кодировка По умолчанию используется строковая кодировка по умолчанию. ошибок
может быть задан для установки другой схемы обработки ошибок. По умолчанию
'строгий' , что означает, что ошибки кодирования вызывают
UnicodeError. Другие возможные значения: 'ignore' ,
"заменить" и любое другое имя, зарегистрированное через
кодеки.register_error, см. раздел 4.8.1.

Новое в версии 2.2.

Изменено в версии 2.3:
Добавлена ​​поддержка других схем обработки ошибок.

кодировать ( [ кодировка [, ошибки ] ] )
Вернуть закодированную версию строки. Кодировка по умолчанию — текущая
кодировка строки по умолчанию. ошибок может быть задано для установки другого
схема обработки ошибок. По умолчанию для ошибок
"строгий" , что означает, что ошибки кодирования вызывают
UnicodeError.Другие возможные значения: 'ignore' ,
'replace' , 'xmlcharrefreplace' , 'backslashreplace'
и любое другое имя, зарегистрированное через codecs.register_error,
см. раздел 4.8.1.
Список возможных кодировок см. В разделе 4.8.3.

Новое в версии 2.0.

Изменено в версии 2.3:
Поддержка 'xmlcharrefreplace', и
, «backslashreplace», и другие схемы обработки ошибок.

заканчивается с ( суффикс [, начало [, конец ] ] )
Вернуть Истина , если строка заканчивается указанным суффиксом ,
в противном случае верните False . суффикс также может быть кортежем
суффиксы, которые нужно искать. С опциональным start , тест начинается с
эта позиция. С опциональным и концом прекратите сравнение в этой позиции.

Изменено в версии 2.5:
Принимайте кортежи как с суффиксом .

Вернуть копию строки, в которой раскрыты все символы табуляции
используя пробелы. Если размер табуляции не указан, размер табуляции 8
предполагается наличие символов.
найти ( подчиненный [, начало [, конец ] ] )
Возвращает наименьший индекс в строке, где подстрока sub
найдено, так что sub содержится в диапазоне [ start ,
конец ].Необязательные аргументы начало и конец :
интерпретируется как в обозначении среза. Вернуть -1 , если под
не найден.
индекс ( подчиненный [, начало [, конец ] ] )
Подобно find (), но вызывает ValueError, когда
подстрока не найдена.
Вернуть истину, если все символы в строке буквенно-цифровые и есть
хотя бы один символ, иначе false.

Для 8-битных строк этот метод зависит от языкового стандарта.

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

Для 8-битных строк этот метод зависит от языкового стандарта.

Вернуть истину, если все символы в строке являются цифрами и есть
хотя бы один символ, иначе false.

Для 8-битных строк этот метод зависит от языкового стандарта.

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

Для 8-битных строк этот метод зависит от языкового стандарта.

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

Для 8-битных строк этот метод зависит от языкового стандарта.

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

Для 8-битных строк этот метод зависит от языкового стандарта.

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

Для 8-битных строк этот метод зависит от языкового стандарта.

Вернуть строку, которая является конкатенацией строк в
последовательность последовательность . Разделителем между элементами служит строка
предоставляя этот метод.
ljust ( ширина [, fillchar ] )
Вернуть строку, выровненную по левому краю, в строке длиной и шириной .
Заполнение выполняется с использованием указанного поля fillchar (по умолчанию
космос). Исходная строка возвращается, если
ширина меньше лён ( s ) .

Изменено в версии 2.4:
Поддержка аргумента fillchar .

Вернуть копию строки, преобразованную в нижний регистр.

Для 8-битных строк этот метод зависит от языкового стандарта.

Вернуть копию строки с удаленными ведущими символами. В
символов аргумент — строка, определяющая набор символов
быть удаленным. Если опущено или Нет , символов аргумент
по умолчанию удаляются пробелы. Аргумент символов не является
приставка; скорее, все комбинации его значений удаляются:

    >>> 'просторный'.lstrip ()
    'просторный'
    >>> 'www.example.com'.lstrip (' cmowz. ')
    example.com
 

Изменено в версии 2.2.2:
Поддержка аргумента символов .

Разделите строку при первом вхождении sep и верните
3-кортеж, содержащий часть перед разделителем, разделитель
сама и часть после разделителя. Если разделитель не
найдено, вернуть 3-кортеж, содержащий саму строку, за которой следует
две пустые струны.Новое в версии 2.5.

заменить ( старые, новые [, кол-во ] )
Вернуть копию строки со всеми вхождениями подстроки
старый заменен на новый . Если необязательный аргумент
count дано, только первые count вхождений
заменены.
rfind ( подчиненный [, начало [, конец ] ] )
Возвращает наивысший индекс в строке, где подстрока sub
найдено, так что sub содержится в s [начало, конец].По желанию
аргументы начало и конец интерпретируются как в срезе
обозначение. Вернуть -1 в случае неудачи.
rindex ( подчиненный [, начало [, конец ] ] )
Подобно rfind (), но вызывает ошибку ValueError, когда
подстрока подстрока не найдена.
rjust ( ширина [, fillchar ] )
Вернуть строку, выровненную по правому краю, в строке длиной и шириной .Заполнение выполняется с использованием указанного поля fillchar (по умолчанию — пробел).
Исходная строка возвращается, если
ширина меньше лён ( s ) .

Изменено в версии 2.4:
Поддержка аргумента fillchar .

Разделите строку на последнее вхождение sep и верните
3-кортеж, содержащий часть перед разделителем, разделитель
сама и часть после разделителя. Если разделитель не
найдено, вернуть 3-кортеж, содержащий две пустые строки, за которыми следует
сама струна.Новое в версии 2.5.

rsplit ( [ sep [, maxsplit ] ] )
Вернуть список слов в строке, используя sep в качестве
строка-разделитель. Если задано maxsplit , максимум maxsplit
деления сделаны, крайних правых . Если сен не указан
или Нет , любая строка с пробелами является разделителем.За исключением расщепления
справа rsplit () ведет себя как split (), который
подробно описывается ниже.

Новое в версии 2.4.

Вернуть копию строки с удаленными завершающими символами. В
символов аргумент — строка, определяющая набор символов
быть удаленным. Если опущено или Нет , символов аргумент
по умолчанию удаляются пробелы. Аргумент символов не является
суффикс; скорее, все комбинации его значений удаляются:

    >>> 'просторный'.rstrip ()
    'просторный'
    >>> 'миссисипи'.rstrip (' ipz ')
    'миссис'
 

Изменено в версии 2.2.2:
Поддержка аргумента символов .

раздельный ( [ sep [, maxsplit ] ] )
Вернуть список слов в строке, используя sep в качестве
строка-разделитель. Если задано maxsplit , максимум maxsplit
деления сделаны.(таким образом, в списке будет не более maxsplit +1
элементы). Если не указан maxsplit , то там
нет ограничения на количество разбиений (делаются все возможные разбиения).
Последовательные разделители не группируются вместе и
считается ограничивающим пустые строки (например, «‘1„ 2’.split (‘, ‘) «возвращает» [‘ 1 ‘,’ ‘,’ 2 ‘] «). Аргумент sep может состоять из
несколько символов (например, «’1, 2, 3′.split (‘, ‘)» возвращает
«[‘1’, ‘2’, ‘3’]»). Разделение пустой строки указанным
разделитель возвращает «[»]».

Если sep не указан или равен None , другое разделение
алгоритм применяется. Во-первых, пробельные символы (пробелы, табуляции,
символы новой строки, возврата и перевода страницы) удаляются с обоих концов. Потом,
слова разделяются строками пробелов произвольной длины
символы. Последовательные разделители пробелов обрабатываются как один
delimiter («‘1 2 3’.split ()» возвращает «[‘ 1 ‘,’ 2 ‘,’ 3 ‘]»).
Разделение пустой строки или строки, состоящей только из пробелов
возвращает пустой список.

Вернуть список строк в строке с разрывом в строке
границы. Разрывы строк не включаются в результирующий список, если только
keepends дано и верно.
начинается с ( префикс [,
начало
[, конец ] ] )
Вернуть Истина , если строка начинается с префикса , в противном случае
возврат Ложь .Префикс также может быть кортежем
префиксы, которые нужно искать. При необязательном начале тестовая строка начинается с
эта позиция. С опциональным end прекратите сравнение строки на этом
должность.

Изменено в версии 2.5:
Принимать кортежи как префикс .

Вернуть копию строки с начальными и конечными символами
удаленный. Аргумент символов — это строка, определяющая набор
удаляемые символы.Если опущено или Нет , символов
по умолчанию аргумент удаляет пробелы. Аргумент символов не является
префикс или суффикс; скорее, все комбинации его значений удаляются:

    >>> 'просторный' .strip ()
    'просторный'
    >>> 'www.example.com'.strip (' cmowz. ')
    'пример'
 

Изменено в версии 2.2.2:
Поддержка аргумента символов .

Вернуть копию строки с заглавными буквами, преобразованными в
строчные и наоборот.

Для 8-битных строк этот метод зависит от языкового стандарта.

Возвращает версию строки с заглавными буквами: слова начинаются с верхнего регистра
символы, все остальные символы в регистре — строчные.

Для 8-битных строк этот метод зависит от языкового стандарта.

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

Вы можете использовать вспомогательную функцию maketrans () в
строковый модуль для создания таблицы перевода.

Для объектов Unicode метод translate () не работает.
принять необязательный аргумент deletechars . Вместо этого
возвращает копию s , где все символы были сопоставлены
через данную таблицу трансляции, которая должна быть отображением
Порядковые номера Unicode в порядковые номера Unicode, строки Unicode или Нет .
Неотмеченные символы остаются нетронутыми. Символы сопоставлены с Нет
удалены.Обратите внимание, что более гибкий подход — создать собственный
кодек отображения символов с использованием модуля кодеков (см.
encodings.cp1251 для примера).

Вернуть копию строки, преобразованную в верхний регистр.

Для 8-битных строк этот метод зависит от языкового стандарта.

Возврат числовой строки, заполненной нулями слева в строке
длины ширины . Исходная строка возвращается, если
ширина меньше лён ( s ) .Новое в версии 2.2.2.


Release 2.5.4, документация обновлена ​​23 декабря 2008 г.

См. Об этом документе … для получения информации о предложениях изменений.

Строковые методы Python | Programiz

Python Строка capitalize ()

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

Python String casefold ()

преобразует струны в футляр

Python Центр струны ()

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

Python Количество строк ()

возвращает вхождения подстроки в строке

Кодировка строки Python ()

возвращает закодированную строку заданной строки

Python Строка заканчивается на ()

Проверяет, заканчивается ли строка указанным суффиксом

Python String expandtabs ()

Заменяет символ табуляции пробелами

Python String find ()

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

Python Формат строки ()

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

Python String format_map ()

Форматирует строку с помощью словаря

Индекс строки Python ()

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

Python Строка isalnum ()

Проверяет буквенно-цифровые символы

Python Строка isalpha ()

Проверяет, все ли символы являются алфавитами

Python Строка isdecimal ()

Проверяет десятичные символы

Строка Python isdigit ()

Проверяет цифры символов

Python Строка isidentifier ()

Проверяет действительный идентификатор

Python Строка islower ()

Проверяет, все ли буквы в строке строчные

Python Строка isnumeric ()

Проверяет числовые символы

Python Строка isprintable ()

Проверяет печатный символ

строка Python isspace ()

Проверяет пробельные символы

Python String istitle ()

Проверяет строку с заголовком

Строка Python isupper ()

возвращается, если все символы являются прописными

Python String join ()

Возвращает составную строку

Строка Python ljust ()

возвращает выровненную по левому краю строку заданной ширины

Нижняя строка Python ()

возвращает строку в нижнем регистре

Python String lstrip ()

Удаляет начальные символы

Python String maketrans ()

возвращает таблицу преобразования

Раздел строки Python ()

возвращает кортеж

Python String replace ()

Заменяет подстроку внутри

Python Строка rfind ()

Возвращает наивысший индекс подстроки

Python String rindex ()

Возвращает наивысший индекс подстроки

Python Строка rjust ()

возвращает выровненную по правому краю строку заданной ширины

Python String rpartition ()

возвращает кортеж

Python String rsplit ()

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

Python String rstrip ()

Удаляет конечные символы

Python String split ()

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

Python String splitlines ()

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

Строка Python начинается с ()

Проверяет, начинается ли строка с указанной строки

Полоска Python String ()

Удаляет начальные и конечные символы

Python String swapcase ()

заменить заглавные буквы на строчные; наоборот

Python String title ()

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

Python String translate ()

возвращает отображенную символьную строку

Python String upper ()

возвращает строку в верхнем регистре

Python Строка zfill ()

Возвращает копию строки с нулями

Python 3-х строковые методы

Метод Описание Примеры
капитализировать ()

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

Используйте title () , если вы хотите, чтобы первый символ всех слов был заглавным (т. Е. Регистр заголовка).

a = «пчелиный укус»
print (a.capitalize ())

Результат

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

a = «BEE»
print (a.casefold ())

Результат

  пчела  
центр ( ширина [, fillchar ]) Возвращает строку с центром в строке длиной и шириной . Заполнение может быть выполнено с использованием указанного поля fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна len (s)

a = «пчела»
б = а.центр (12, «-«)
print (b)

Результат

  ---- пчела -----  
count ( sub [, start [, end ]])

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

Неперекрывающиеся вхождений означает, что Python не будет дублировать символы, которые уже были подсчитаны. Например, использование подстроки xxx против xxxx возвращает 1 .

a = «Шашлычный суп»
print (a.count («O»))
print (a.count («o»))
print (a.count («oo»))
print (a.count («ооо»))
print (a.count («Гомер»))
print (a.count («o», 4, 7))
print (a.count («o», 7))

Результат

  0
5
2
1
0
2
3  
кодировать (encoding = "utf-8", errors = "strict")

Возвращает закодированную версию строки как байтовый объект.Кодировка по умолчанию — utf-8 . ошибки могут быть заданы для установки другой схемы обработки ошибок. Возможное значение для ошибок :

  • strict (ошибки кодирования вызывают UnicodeError )
  • игнорировать
  • заменить
  • xmlcharrefreplace
  • обратная косая черта заменить
  • любое другое имя, зарегистрированное с помощью кодеков.register_error ()

из base64 импортировать b64encode

a = «Банан»
печать (а)

a = b64encode (a.encode ())
print (a)

Результат

  банан
b'QmFuYW5h ' 
заканчивается на ( суффикс [, начало [, конец ]])

Возвращает Истина , если строка заканчивается указанным суффиксом, в противном случае возвращает Ложь .Суффикс также может быть кортежем суффиксов. Если указан (необязательный) аргумент start , тест начинается с этой позиции. С опциональным и концом тест прекращает сравнение в этой позиции.

a = «Банан»
print (a.endswith («a»))
print (a.endswith («нана»))
print (a.endswith («z»))
print (a.endswith («an», 1, 3))

Результат

  Верно
Правда
Ложь
Правда  
развертки (размер табуляции = 8)

Возвращает копию строки, в которой все символы табуляции заменены одним или несколькими пробелами, в зависимости от текущего столбца и заданного размера табуляции.Позиции табуляции встречаются для каждого символа табуляции (по умолчанию 8 , что дает позиции табуляции в столбцах 0, 8, 16 и т. Д.).

а = «1 \ t2 \ t3»
печать (а)
печать (a.expandtabs ())
печать (a.expandtabs (tabsize = 12))
print (a.expandtabs (tabsize = 2))

Результат

  1 2 3
1 2 3
1 2 3
1 2 3  
find ( sub [, start [, end ]])

Возвращает наименьший индекс в строке, где подстрока sub находится в пределах фрагмента s [начало: конец] .Необязательные аргументы начало и конец интерпретируются как в нотации среза. Возвращает -1 , если sub не найден.

Метод find () следует использовать только в том случае, если вам нужно знать позицию подстроки. Если вам не нужно знать его позицию (т.е. вам нужно только знать, существует ли подстрока в строке), используйте оператор в . См. Строковые операторы для примера в .

a = «Фитнес»
print (a.find («F»))
print (a.find («f»))
print (a.find («n»))
print (a.find («сущность»))
print (a.find («ess»))
print (a.find («z»))
print (a.find («Homer»))

Результат

  0
-1
3
3
4
-1
-1  
формат (* args , ** kwargs )

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

# Пример 1
print («{} и {}».формат («Чай», «Кофе»))

# Пример 2
print («{1} и {0}». format («Чай», «Кофе»))

# Пример 3
print («{обед} и {ужин}». format (обед = «Горошек», ужин = «Фасоль»))

# Пример 4
print («{0}, {1}, {2}». format (* «123»))

# Пример 5
обед = {«food»: «Пицца», «drink»: «Вино»}
print («Обед: {еда}, {напиток}». format (** обед))

Результат

  Чай и кофе
Кофе и чай
Горох и фасоль
1, 2, 3
Обед: пицца, вино  
format_map ( отображение )

Аналогично формату (** отображение) , за исключением того, что отображение используется напрямую и не копируется в словарь.Это полезно, если, например, отображение является подклассом dict.

# Пример 1
обед = {«Еда»: «Пицца», «Напиток»: «Вино»}
print («Обед: {Еда}, {Напиток}». format_map (Обед))

# Пример 2
класс по умолчанию (dict):
def __missing __ (я, ключ):
ключ возврата

обед = {«Еда»: «Пицца»}
print («Обед: {Еда}, {Напиток}». format_map (По умолчанию (обед)))

обед = {«Напиток»: «Вино»}
print («Обед: {Еда}, {Напиток}». format_map (По умолчанию (обед)))

Результат

  Обед: Пицца, Вино
Обед: пицца, напитки
Обед: еда, вино  
индекс ( sub [, start [, end ]])

Как find () (выше), но вызывает ValueError , когда подстрока не найдена ( find () возвращает -1 , если подстрока не найдена).

a = «Фитнес»
print (a.index («F»))
print (a.index («n»))
print (a.index («сущность»))
print (a.index («ess»))
print (a.index («z»)) #Error

Результат

  0
3
3
4
ValueError: подстрока не найдена  
isalnum ()

Возвращает Истина , если все символы в строке буквенно-цифровые и есть хотя бы один символ.Возвращает Ложь, иначе .

Символ c считается буквенно-цифровым, если одно из следующих значений возвращает True :

  • c.isalpha ()
  • c.isdecimal ()
  • c.isdigit ()
  • c.isnumeric ()

c = «Фитнес»
печать (c.isalnum ())

c = «123»
печать (c.isalnum ())

c = «1,23»
печать (c.isalnum ())

c = «$ *% !!!»
печать (c.isalnum ())

c = «0,34j»
print (c.isalnum ())

Результат

  Верно
Правда
Ложь
Ложь
Ложь  
isalpha ()

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

Обратите внимание, что «алфавитными» в данном случае являются те символы, которые определены в базе данных символов Unicode как «Letter». Это персонажи, общее свойство категории которых может быть одним из «Lm», «Lt», «Lu», «Ll» или «Lo». Это отличается от свойства «Alphabetic», определенного в стандарте Unicode.

c = «Фитнес»
печать (c.isalpha ())

c = «123»
печать (c.isalpha ())

c = «$ *% !!!»
print (c.isalpha ())

Результат

  Верно
Ложь
Ложь  
десятичное ()

Возвращает Истинно , если все символы в строке являются десятичными и есть хотя бы один символ.Возвращает Ложь, иначе .

Десятичные символы — это те, которые могут использоваться для формирования чисел с основанием 10. Десятичные символы — это символы из общей категории Unicode «Nd».

Вы можете увидеть разницу между isdigit () и isdecimal () по тому, как они обрабатывают второй пример ( u "\ u00B2" ).

c = «123»
печать (c.isdecimal ())

c = u «\ u00B2»
печать (c.isdecimal ())

c = «1,23»
печать (c.isdecimal ())

c = «u123»
печать (c.isdecimal ())

c = «Фитнес»
печать (c.isdecimal ())

c = «$ *% !!!»
print (c.isdecimal ())

Результат

  Верно
Ложь
Ложь
Ложь
Ложь
Ложь  
isdigit ()

Возвращает Истина , если все символы в строке являются цифрами и есть хотя бы один символ. Возвращает Ложь, иначе .

Метод isdigit () часто используется при работе с различными символами Юникода, например с надстрочными индексами (например, 2 ).

Цифра — это символ, имеющий значение свойства Numeric_Type = Digit или Numeric_Type = Decimal .

Вы можете увидеть разницу между isdigit () и isdecimal () по тому, как они обрабатывают второй пример ( u "\ u00B2" ).

c = «123»
печать (c.isdigit ())

c = u «\ u00B2»
печать (c.isdigit ())

c = «1,23»
печать (c.isdigit ())

c = «u123»
печать (c.isdigit ())

c = «Фитнес»
печать (c.isdigit ())

c = «$ *% !!!»
print (c.isdigit ())

Результат

  Верно
Правда
Ложь
Ложь
Ложь
Ложь  
isidentifier ()

Возвращает истину, если строка является допустимым идентификатором в соответствии с определением языка, разделом «Идентификаторы» и ключевыми словами из документации Python.

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

а = «123»
печать (a.isidentifier ())

a = «_user_123»
печать (a.isidentifier ())

a = «_user-123»
печать (a.isidentifier ())

a = «Гомер»
печать (a.isidentifier ())

a = «для»
print (a.isidentifier ())

Результат

  Ложь
Правда
Ложь
Правда
Правда  
ниже ()

Возвращает Истинно , если все символы в регистре в строке строчные и есть хотя бы один символ в регистре.Возвращает Ложь, иначе .

Символы в регистре — это символы, общее свойство категории которых является одним из «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, регистр заголовка).

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

а = «»
печать (a.islower ())

а = «123»
печать (a.islower ())

a = «_user_123»
печать (a.islower ())

a = «Гомер»
печать (a.islower ())

a = «HOMER»
печать (a.islower ())

а = «гомер»
печать (a.islower ())

a = «HOMER»
a = a.casefold () # Принудительно использовать строчные буквы
print (a.islower ())

Результат

  Ложь
Ложь
Правда
Ложь
Ложь
Правда
Правда  
является числовым ()

Возвращает Истинно , если все символы в строке являются числовыми символами и есть хотя бы один символ.Возвращает Ложь, иначе .

Числовые символы включают цифровые символы и все символы, которые имеют свойство числового значения Unicode. Числовые символы — это символы со значением свойства Numeric_Type = Digit , Numeric_Type = Decimal или Numeric_Type = Numeric .

c = «123»
печать (c.isnumeric ())

c = u «\ u00B2»
печать (c.isnumeric ())

c = «1,23»
печать (c.isnumeric ())

c = «u123»
печать (c.isnumeric ())

c = «Фитнес»
печать (c.isnumeric ())

c = «$ *% !!!»
print (c.isnumeric ())

Результат

  Верно
Правда
Ложь
Ложь
Ложь
Ложь  
для печати ()

Возвращает Истина , если все символы в строке печатаются или строка пуста. Возвращает Ложь, иначе .

Непечатаемые символы — это те символы, которые определены в базе данных символов Unicode как «Другой» или «Разделитель», за исключением пробела ASCII ( 0x20 ), который считается печатаемым.

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

а = «»
печать (a.isprintable ())

а = «»
печать (a.isprintable ())

a = u «\ u00B2»
печать (a.isprintable ())

a = «Барт»
печать (a.isprintable ())

а = «\ т»
печать (a.isprintable ())

a = «\ r \ n»
печать (a.isprintable ())

a = «Барт \ r»
print (a.isprintable ())

Результат

  Верно
Правда
Правда
Правда
Ложь
Ложь
Ложь  
isspace ()

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

Пробельные символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», а также те, для которых свойство двунаправленности является одним из «WS», «B» или «S».

а = «»
печать (a.isspace ())

а = «»
печать (a.isspace ())

a = «Барт»
печать (a.isspace ())

а = «\ т»
печать (a.isspace ())

a = «\ r \ n»
печать (a.isspace ())

a = «Барт \ r»
print (a.isspace ())

Результат

  Ложь
Правда
Ложь
Правда
Правда
Ложь  
название ()

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

Пробельные символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», а также те, для которых свойство двунаправленности является одним из «WS», «B» или «S».

а = «»
печать (a.istitle ())

а = «»
печать (a.istitle ())

а = «т»
печать (a.istitle ())

а = «Т»
печать (a.istitle ())

a = «Чай»
печать (a.istitle ())

a = «Чай и кофе»
печать (a.istitle ())

a = «Чай и кофе»
печать (a.istitle ())

a = «1. Чай и кофе \ r»
print (a.istitle ())

Результат

  Ложь
Ложь
Ложь
Правда
Правда
Ложь
Правда
Правда  
isupper ()

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

Символы в регистре — это символы, общее свойство категории которых является одним из «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, регистр заголовка).

а = «»
печать (a.isupper ())

а = «123»
печать (a.isupper ())

a = «_USER_123»
печать (a.isupper ())

a = «Гомер»
печать (a.isupper ())

a = «HOMER»
печать (a.isupper ())

а = «гомер»
печать (a.isupper ())

a = «HOMER»
a = a.casefold () # Принудительно использовать строчные буквы
print (a.isupper ())

Результат

  Ложь
Ложь
Правда
Ложь
Правда
Ложь
Ложь  
соединение (итерация)

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

а = «-»
print (a.join («123»))

a = «.»
print (a.join («США»))

a = «.»
print (a.join ((«Dr», «Who»)))

Результат

  1-2-3
США
Доктор Кто  
ljust ( ширина [, fillchar ]) Возвращает строку, выровненную по левому краю, в строке длиной и шириной .Заполнение может быть выполнено с использованием указанного поля fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна len (s)

a = «пчела»
b = a.ljust (12, «-«)
print (b)

Результат

  пчела ---------  
нижний ()

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

casefold () — это более агрессивный метод перевода строки в нижний регистр, и он подходит для сопоставления регистра.

a = «BEE»
print (a.lower ())

Результат

  пчела  
lstrip ([ chars ])

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

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

a = «Пчела»
print (a.lstrip (), «!»)

a = «—— Пчела ——»
print (a.lstrip («-«))

Результат

  Пчела!
Пчела -----  
макетранс ( x [, y [, z ]])

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

  • Если есть только один аргумент, это должен быть словарь, отображающий порядковые номера Unicode (целые числа) или символы (строки длиной 1) в порядковые номера Unicode, строки (произвольной длины) или равные None . Затем символьные ключи будут преобразованы в порядковые.
  • Если есть два аргумента, они должны быть строками одинаковой длины, и в результирующем словаре каждый символ в x будет сопоставлен с символом в той же позиции в y .
  • Если есть третий аргумент, это должна быть строка, символы которой в результате будут сопоставлены с Нет .

frm = «SecrtCod»
to = «12345678»
trans_table = str.maketrans (от, до)
secret_code = «Секретный код» .translate (trans_table)
print (secret_code)

Результат

  123425 6782  
перегородка ( сен )

Разбивает строку при первом вхождении sep и возвращает кортеж из трех частей, содержащий часть перед разделителем, сам разделитель и часть после разделителя.Если разделитель не найден, он возвращает 3-кортеж, содержащий саму строку, за которой следуют две пустые строки.

a = «Python-программа»

print (a.partition («-«))
print (a.partition («.»))

Результат

  ('Python', '-', 'программа')
('Python-программа', '', '')  
заменить ( старый , новый [, count ])

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

a = «Чайный пакетик. Чайная чашка. Чайные листья.»

print (a.replace («Чай», «Кофе»))
print (a.replace («Чай», «Кофе», 2))

Результат

  Кофейный пакетик. Чашка кофе. Листья кофе.
Пакетик кофе. Чашка кофе. Чайные листья. 
rfind ( sub [, start [, end ]])

Возвращает наивысший индекс в строке, в которой найдена подстрока sub , так что sub содержится в пределах с [начало: конец] . Необязательные аргументы начало и конец интерпретируются как в нотации среза. Этот метод возвращает -1 в случае ошибки.

a = «Да, фитнес»

print (a.rfind («Y»))
print (a.rfind («e»))
print (a.rfind («s»))
print (a.rfind («сс»))
print (a.rfind («y»))
print (a.rfind («z»))
print (a.rfind («Homer»))

Результат

  0
8
10
9
-1
-1
-1  
rindex ( sub [, start [, end ]])

Аналогично rfind () , но вызывает ошибку ValueError , если подстрока sub не найдена.

a = «Да, фитнес»

print (a.rindex («Y»))
print (a.rindex («e»))
print (a.rindex («s»))
print (a.rindex («сс»))
print (a.rindex («y»))
print (a.rindex («z»))
print (a.rindex («Homer»))

Результат

  0
8
10
9
ValueError: подстрока не найдена
ValueError: подстрока не найдена
ValueError: подстрока не найдена  
rjust ( ширина [, fillchar ]) Возвращает строку, выровненную по правому краю, в строке длиной и шириной .Заполнение может быть выполнено с использованием указанного поля fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна len (s)

a = «пчела»
b = a.rjust (12, «-«)
print (b)

Результат

  --------- пчела  
r раздел ( sep )

Разбивает строку в последнем вхождении sep и возвращает кортеж из трех частей, содержащий часть перед разделителем, сам разделитель и часть после разделителя.Если разделитель не найден, он возвращает 3-кортеж, содержащий саму строку, за которой следуют две пустые строки.

a = «Гомер-Джей-Симпсон»

print (a.rpartition («-«))
print (a.rpartition («.»))

Результат

  ('Гомер-Джей', '-', 'Симпсон')
('', '', 'Гомер-Джей-Симпсон')  
rsplit (sep = None, maxsplit = -1)

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

За исключением разделения справа, rsplit () ведет себя как split () , описанный ниже.

a = «Гомер Джей Симпсон»
печать (a.rsplit ())

a = «Гомер-Джей-Симпсон»
печать (a.rsplit (sep = «-«, maxsplit = 1))

Результат

  [«Гомер», «Джей», «Симпсон»]
["Гомер-Джей", "Симпсон"]  
rstrip ([ chars ])

Вернуть копию строки с удаленными завершающими символами. Аргумент символов — это строка, определяющая набор символов, которые необходимо удалить. Если опущено или установлено значение Нет , аргумент символов по умолчанию удаляет пробелы.

Обратите внимание, что аргумент chars не является суффиксом — все комбинации его значений удаляются.

a = «Пчела»
print (a.rstrip (), «!»)

a = «—— Пчела ——»
print (a.rstrip («-«))

Результат

  Пчела!
----- Пчела  
разделить (sep = None, maxsplit = -1)

Возвращает список слов в строке, используя sep в качестве строки разделителя.Если задано maxsplit , будет выполнено не более maxsplit разбиений. Если maxsplit не указан или -1 , то количество разделений не ограничено.

Если задано sep , последовательные разделители не группируются вместе и считаются разделителями пустых строк (например, '1`` 2'.split (', ') возвращает [' 1 ',' ', «2»] ).

Аргумент sep может состоять из нескольких символов (например, '1 <> 2 <> 3'.split ('<>') возвращает ['1', '2', '3'] ). Разделение пустой строки с указанным разделителем возвращает [''] .

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

a = «Гомер Джей Симпсон»
печать (a.split ())

a = «Гомер-Джей-Симпсон»
print (a.split (sep = «-«, maxsplit = 1))

a = «Гомер, Барт,»
print (a.split («,»))

a = «Гомер ,, Барт»
print (a.split («,», maxsplit = 1))

a = «Гомер <> Барт <> Мардж»
print (a.split («<>«))

Результат

  [«Гомер», «Джей», «Симпсон»]
["Гомер", "Джей-Симпсон"]
['Гомер', '', 'Барт', '']
['Гомер', ', Барт']
[Гомер, Барт, Мардж]  
Splitlines ([keepends])

Возвращает список строк в строке с разрывом по границам строки.Разрывы строк не включаются в результирующий список, если не указано значение keepends и его значение — True .

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

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

a = «Чай \ n \ nи кофе \ rчашки \ r \ n»

печать (a.splitlines ())
print (a.splitlines (keepends = True))

Результат

  ["Чай", "", "и кофе", "чашки"]
['Чай \ n', '\ n', 'и кофе \ r', 'чашки \ r \ n']  
начинается с ( префикс [, начало [, конец ]])

Возвращает Истина , если строка начинается с указанного префикса, в противном случае возвращает Ложь .Префикс также может быть кортежем префиксов. Если указан (необязательный) аргумент start , тест начинается с этой позиции. С опциональным и концом тест прекращает сравнение в этой позиции.

a = «Гомер»
print (a.startswith («H»))
print (a.startswith («h»))
print (a.startswith («Гомер»))
print (a.startswith («z»))
print (a.startswith («om», 1, 3))

Результат

  Верно
Ложь
Правда
Ложь
Правда  
полоса ([ символов ])

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

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

a = «Пчела»
print (a.strip (), «!»)

a = «—— Пчела ——»
print (a.strip («-«))

Результат

  Пчела!
Пчела  
свопкейс ()

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

Обратите внимание, что использование swapcase () дважды в строке не всегда возвращает ее к исходному регистру. В некоторых случаях два разных символа нижнего регистра используют один символ верхнего регистра, и, следовательно, замена регистра может иметь непреднамеренный эффект. См. Этот вопрос / ответ о переполнении стека для примеров.

a = «Гомер Симпсон»
print (a.swapcase ())

Результат

  ГОМЕР СИМПСОН  
титул ()

Возвращает версию строки с заглавным регистром.Регистр заголовка — это когда слова начинаются с символа верхнего регистра, а остальные символы — с нижнего регистра.

Используйте capitalize () , если вы хотите, чтобы первое слово было заглавным.

a = «чай и кофе»
print (a.title ())

a = «ЧАЙ И КОФЕ»
print (a.title ())

Результат

  Чай и кофе
Чай и кофе  
перевести ( таблица )

Возвращает копию строки, в которой каждый символ был отображен в данной таблице перевода.Таблица должна быть объектом, который реализует индексацию через __getitem __ () , обычно отображение или последовательность.

Вы можете использовать maketrans () для создания карты перевода из символьных отображений в разных форматах.

frm = «SecrtCod»
to = «12345678»
trans_table = str.maketrans (от, до)
secret_code = «Секретный код» .translate (trans_table)
print (secret_code)

Результат

  123425 6782  
верх ()

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

a = «пчела»
print (a.upper ())

Результат

  ПЧЕЛ  
zfill ( ширина )

Возвращает копию строки, слева заполненную цифрами ASCII 0 , чтобы получилась строка длиной и шириной . Префикс ведущего знака ( + / - ) обрабатывается путем вставки отступа после символа знака, а не перед ним.Исходная строка возвращается, если ширина меньше или равна len (s) .

а = «36»
печать (a.zfill (5))

а = «-36»
печать (a.zfill (5))

а = «+36»
print (a.zfill (5))

Результат

  00036
-0036
+0036  

Строковые функции Python — JournalDev

Python предоставляет множество встроенных функций для управления строками.Python String неизменяем, поэтому все эти функции возвращают новую строку, а исходная строка остается неизменной.

Строковые функции Python

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

  • Должен знать строковые функции
  • Полезно знать строковые функции
  • Разные строковые функции
  • Встроенные функции, работающие со строкой
  • Полезные строковые операции

Строковые функции должны знать

Описание функции
format () Используется для создания форматированной строки из строки шаблона и предоставленных значений.
split () Функция Python string split () используется для разделения строки на список строк на основе разделителя.
join () Эта функция возвращает новую строку, которая представляет собой конкатенацию строк в итерации со строковым объектом в качестве разделителя.
strip () Используется для обрезки пробелов в строковом объекте.
format_map () Python string Функция format_map () возвращает отформатированную версию строки с использованием подстановок из предоставленного сопоставления.
upper () Мы можем преобразовать строку в верхний регистр в Python с помощью функции str.upper ().
lower () Эта функция создает новую строку в нижнем регистре.
replace () Строка Python Функция replace () используется для создания новой строки путем замены некоторых частей другой строки.
find () Python String Метод find () используется для поиска индекса подстроки в строке.
translate () Python String Функция translate () возвращает новую строку, в которой каждый символ в строке заменяется с использованием данной таблицы перевода.

Полезно знать Строковые функции

Функция Описание
encode () Функция Python string encode () используется для кодирования строки с использованием предоставленной кодировки.
count () Python Функция count () String возвращает количество вхождений подстроки в заданной строке.
startwith () Функция Python startwith () возвращает True, если строка начинается с заданного префикса, в противном случае возвращает False.
endwith () Python stringndswith () функция возвращает True, если строка заканчивается заданным суффиксом, в противном случае она возвращает False.
capitalize () Python String Функция capitalize () возвращает версию строки с заглавной буквы.
center () Python string Функция center () возвращает центрированную строку указанного размера.
casefold () Python string Функция casefold () возвращает свернутую по регистру копию строки. Эта функция используется для сравнения строк без учета регистра.
expandtabs () Python string Функция expandtabs () возвращает новую строку, в которой символы табуляции (\ t) заменены одним или несколькими пробелами.
index () Python Функция index () String возвращает наименьший индекс, в котором находится указанная подстрока.
__contains __ () Python Класс String имеет функцию __contains __ (), которую мы можем использовать, чтобы проверить, содержит ли он другую строку или нет. Мы также можем использовать оператор «in» для выполнения этой проверки.

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

Функция Описание
isalnum () Python string isalnum () функция возвращает True, если она состоит только из буквенно-цифровых символов.
isalpha () Python String Функция isalpha () возвращает True, если все символы в строке являются алфавитными, в противном случае — False.
isdecimal () Python String Функция isdecimal () возвращает True, если все символы в строке являются десятичными символами, в противном случае — False.
isdigit () Python String Функция isdigit () возвращает True, если все символы в строке являются цифрами, в противном случае — False.
isidentifier () Python String Функция isidentifier () возвращает True, если строка является допустимым идентификатором в соответствии с определением языка Python.
islower () Python String islower () возвращает True, если все символы в регистре в строке строчные и есть хотя бы один символ в регистре, в противном случае возвращается False.
isnumeric () Python String Функция isnumeric () возвращает True, если все символы в строке числовые, в противном случае — False. Если строка пуста, эта функция возвращает False.
isprintable () Python String Функция isprintable () возвращает True, если все символы в строке печатаются или строка пуста, в противном случае — False.
isspace () Python String Функция isspace () возвращает True, если в строке есть только пробельные символы, в противном случае она возвращает False.
istitle () Python String istitle () возвращает True, если строка имеет регистр заголовка и не пуста, в противном случае она возвращает False.
isupper () Python String Функция isupper () возвращает True, если все символы в регистре находятся в верхнем регистре.
rjust (), ljust () Служебные функции для создания новой строки указанной длины из исходной строки с выравниванием по правому и левому краю.
swapcase () Python String Функция swapcase () возвращает новую строку с символами верхнего регистра, преобразованными в нижний регистр и наоборот.
partition () Python Функция String partition () разбивает строку на основе разделителя на кортеж из трех строк.
splitlines () Python Функция splitlines () строки возвращает список строк в строке.
title () Python String Функция title () возвращает версию строки, основанную на заголовке.
zfill () Python String Функция zfill (width) возвращает новую строку указанной ширины. Строка заполняется 0 с левой стороны, чтобы создать указанную ширину.

Встроенные функции, которые работают со строкой

Функция Описание
len () Python Длина строки может быть определена с помощью встроенной функции len ().
ascii () Функция Python ascii () возвращает строковое представление объекта.Эта функция внутренне вызывает функцию repr () и перед возвратом строки представления экранирует символы, отличные от ASCII, с помощью экранирования \ x, \ u или \ U.
bool () Python функция bool () возвращает логическое значение для объекта. У класса bool всего два экземпляра — True и False.
bytearray () Функция Python bytearray () возвращает объект bytearray, который содержит массив байтов из источника ввода.
bytes () Эта функция возвращает объект байтов, который представляет собой неизменяемую последовательность целых чисел в диапазоне 0 <= x <256.
ord () Функция Python ord () принимает строковый аргумент из одного символа Юникода и возвращает его целочисленное значение кодовой точки Юникода.
enumerate () Функция перечисления Python принимает последовательность, а затем превращает каждый элемент последовательности в кортеж.
float () Как следует из названия, функция python float () возвращает число с плавающей запятой из входного аргумента.
hash () Эта функция возвращает хеш-значение заданного объекта.
id () Функция Python id () возвращает «идентичность» объекта. Идентификатор объекта — это целое число, которое гарантированно будет уникальным и постоянным для этого объекта в течение его жизненного цикла.
int () Функция Python int () возвращает целочисленный объект из указанного ввода. Возвращаемый объект int всегда будет в базе 10.
map () Функция Python map () используется для применения функции ко всем элементам указанного итеративного и возвращаемого объекта карты.
print () Функция Python print () используется для печати данных в консоли.
slice () Функция Python slice () возвращает объект среза, представляющий набор индексов, заданных диапазоном (start, stop, step).
type () Эта функция возвращает тип объекта.

Полезные строковые операции

Нужно ли мне помнить их все?

Никто не может вспомнить их всех.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *