Методы строк питон: Форматирование строк. Метод format | Python 3 для начинающих и чайников

Содержание

Форматирование строк. Метод format | Python 3 для начинающих и чайников

Иногда (а точнее, довольно часто) возникают ситуации, когда нужно сделать строку, подставив в неё некоторые данные, полученные в процессе выполнения программы (пользовательский ввод, данные из файлов и т. д.). Подстановку данных можно сделать с помощью форматирования строк. Форматирование можно сделать с помощью оператора %, либо с помощью метода format.

Форматирование строк с помощью метода format

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

>>> 'Hello, {}!'.format('Vasya')
'Hello, Vasya!'

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

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc')
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad')
'abracadabra'
>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
'Coordinates: 37.24N, -115.81W'

Однако метод format умеет большее. Вот его синтаксис:

поле замены     ::=  "{" [имя поля] ["!" преобразование] [":" спецификация] "}"
имя поля        ::=  arg_name ("." имя атрибута | "[" индекс "]")*
преобразование  ::=  "r" (внутреннее представление) | "s" (человеческое представление)
спецификация    ::=  см. ниже

Например:

>>> "Units destroyed: {players[0]}".format(players = [1, 2, 3])
'Units destroyed: 1'
>>> "Units destroyed: {players[0]!r}".format(players = ['1', '2', '3'])
"Units destroyed: '1'"

Теперь спецификация формата:

спецификация ::=  [[fill]align][sign][#][0][width][,][.precision][type]
заполнитель  ::=  символ кроме '{' или '}'
выравнивание ::=  "<" | ">" | "=" | "^"
знак         ::=  "+" | "-" | " "
ширина       ::=  integer
точность     ::=  integer
тип          ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" |
                  "n" | "o" | "s" | "x" | "X" | "%"

Выравнивание производится при помощи символа-заполнителя.'Выравнивание по центру.

Опция "знак" используется только для чисел и может принимать следующие значения:

ФлагЗначение
'+'Знак должен быть использован для всех чисел.
'-''-' для отрицательных, ничего для положительных.
'Пробел''-' для отрицательных, пробел для положительных.

Поле "тип" может принимать следующие значения:

ТипЗначение
'd', 'i', 'u'Десятичное число.
'o'Число в восьмеричной системе счисления.
'x'Число в шестнадцатеричной системе счисления (буквы в нижнем регистре).
'X'Число в шестнадцатеричной системе счисления (буквы в верхнем регистре).
'e'Число с плавающей точкой с экспонентой (экспонента в нижнем регистре).
'E'Число с плавающей точкой с экспонентой (экспонента в верхнем регистре).
'f', 'F'Число с плавающей точкой (обычный формат).
'g'Число с плавающей точкой. с экспонентой (экспонента в нижнем регистре), если она меньше, чем -4 или точности, иначе обычный формат.
'G'Число с плавающей точкой. с экспонентой (экспонента в верхнем регистре), если она меньше, чем -4 или точности, иначе обычный формат.
'c'Символ (строка из одного символа или число - код символа).
's'Строка.
'%'Число умножается на 100, отображается число с плавающей точкой, а за ним знак %.

И напоследок, несколько примеров:

>>> coord = (3, 5)
>>> 'X: {0[0]};  Y: {0[1]}'.format(coord)
'X: 3;  Y: 5'
>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
"repr() shows quotes: 'test1'; str() doesn't: test2"
>>> '{:<30}'.30}'.format('centered')  # use '*' as a fill char
'***********centered***********'
>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'
>>> # format also supports binary numbers
>>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)
'int: 42;  hex: 2a;  oct: 52;  bin: 101010'
>>> # with 0x, 0o, or 0b as prefix:
>>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)
'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'
>>> points = 19.5
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 88.64%'

Python | Работа со строками

Работа со строками

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

Строка представляет последовательность символов в кодировке Unicode. И мы можем обратиться к отдельным символам строки по индексу в квадратных скобках:


string = "hello world"
c0 = string[0]  # h
print(c0)
c6 = string[6]  # w
print(c6)

c11 = string[11]  # ошибка IndexError: string index out of range
print(c11)

Индексация начинается с нуля, поэтому первый символ строки будет иметь индекс 0. А если мы попытаемся обратиться к индексу, которого нет в строке, то мы получим исключение IndexError. Например, в случае выше длина строки 11 символов, поэтому ее символы будут иметь индексы от 0 до 10.

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


string = "hello world"
c1 = string[-1]  # d
print(c1)
c5 = string[-5]  # w
print(c5)

При работе с символами следует учитывать, что строка - это неизменяемый (immutable) тип, поэтому если мы попробуем изменить какой-то отдельный символ строки, то мы получим ошибку, как в следующем случае:


string = "hello world"
string[1] = "R"

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

Получение подстроки

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

  • string[:end]: извлекается последовательность символов начиная с 0-го индекса по индекс end

  • string[start:end]: извлекается последовательность символов начиная с индекса start по индекс end

  • string[start:end:step]: извлекается последовательность символов начиная с индекса start по индекс end через шаг step

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


string = "hello world"

# с 0 до 5 символа
sub_string1 = string[:5]
print(sub_string1)      # hello

# со 2 до 5 символа
sub_string2 = string[2:5]
print(sub_string2)      # llo

# со 2 по 9 символ через один символ
sub_string3 = string[2:9:2]
print(sub_string3)      # lowr

Функции ord и len

Поскольку строка содержит символы Unicode, то с помощью функции ord() мы можем получить числовое значение для символа в кодировке Unicode:

print(ord("A"))     # 65

Для получения длины строки можно использовать функцию len():


string = "hello world"
length = len(string)
print(length)	# 11

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

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


string = "hello world"
exist = "hello" in string
print(exist)    # True

exist = "sword" in string
print(exist)    # False

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

С помощью цикла for можно перебрать все символы строки:


string = "hello world"
for char in string:
    print(char)

F-строки Python 3: улучшенный синтаксис форматирования строк

Начиная с Python 3.6, f-строки — отличный новый способ форматирования строк. Это способ не только более читабелен, более краток и менее подвержен ошибкам, чем другие способы форматирования, но и быстрее всех других!

К концу этой статьи вы узнаете, как и почему нужно использовать f-строки.

Но сначала, рассмотрим старые варианты вывода строк.

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

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

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

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

Операции форматирования, описанные здесь, демонстрируют различные проблемы, которые приводят к ряду распространенных ошибок (таких как неправильное отображение кортежей и словарей).
Использование более новых форматированных строковых литералов или интерфейса str.format() помогает избежать этих ошибок. Эти альтернативы также предоставляют более мощные, гибкие и расширяемые подходы к форматированию текста. (Источник)

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

Строковые объекты имеют встроенную операцию с использованием оператора

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

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

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

>>> name = "Eric"
>>> age = 74
>>> "Hello, %s. You are %s." % (name, age)
'Hello Eric. You are 74.'
Недостатки % — форматирования

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

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

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

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

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

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

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

С помощью

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

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

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

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

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

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

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

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

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

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

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

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

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

f-Строки: новый и улучшенный способ форматирования строк в Python

f-строки были представлены в Python 3.6. Вы можете прочитать об этом в PEP 498, который был написан Эриком В. Смитом в августе 2015 года.

Также называемые «formatted string literals»(«отформатированные строковые литералы»), f-строки — это строковые литералы, которые имеют f в начале и фигурные скобки, содержащие выражения, которые будут заменены их значениями. Выражения оцениваются во время выполнения, а затем форматируются с использованием протокола format. Как всегда, документация Python — ваш друг, когда вы хотите получить больше информации.

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

Простой синтаксис

Синтаксис похож на тот, который вы использовали с str.format(), но менее подробный. Посмотрите, насколько легко это читается:

>>> name = "Eric"
>>> age = 74
>>> f"Hello, {name}. You are {age}."
'Hello, Eric. You are 74.'

Также было бы правильно использовать заглавную букву F:

>>> F"Hello, {name}. You are {age}."
'Hello, Eric. You are 74.'

Ты еще не любишь f — строки? Я надеюсь, что к концу этой статьи вы ответите >>> F"Yes!"

Произвольные выражения

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

Вы можете сделать что-то довольно простое, как это:

>>> f"{2 * 37}"
'74'

Но вы также можете вызывать функции. Вот пример:

>>> def to_lowercase(input):
...     return input.lower()

>>> name = "Eric Idle"
>>> f"{to_lowercase(name)} is funny."
'eric idle is funny.'

Вы также можете напрямую вызвать метод:

>>> f"{name.lower()} is funny."
'eric idle is funny.'

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

class Comedian:
    def __init__(self, first_name, last_name, age):
        self.first_name = first_name
        self.last_name = last_name
        self.age = age

    def __str__(self):
        return f"{self.first_name} {self.last_name} is {self.age}."

    def __repr__(self):
        return f"{self.first_name} {self.last_name} is {self.age}. Surprise!"

Вы сможете сделать это:

>>> new_comedian = Comedian("Eric", "Idle", "74")
>>> f"{new_comedian}"
'Eric Idle is 74.'

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

Строка, возвращаемая __str__(), является неформальным строковым представлением объекта и должна быть читабельной. Строка, возвращаемая __repr__(), является официальным представлением и должна быть однозначной. Вызов str() и repr() предпочтительнее прямого использования __str__ () и __repr__().

По умолчанию f-строки будут использовать __str__(), но вы можете убедиться, что они используют __repr__(), если вы включите флаг преобразования !r:

>>> f"{new_comedian}"
'Eric Idle is 74.'
>>> f"{new_comedian!r}"
'Eric Idle is 74. Surprise!'

Если вы хотите прочитать больше, о f-строк которые поддерживают полные выражения Python, вы можете сделать это здесь.

Многострочные f-строки

Вы можете использовать многострочные строки:

>>> name = "Eric"
>>> profession = "comedian"
>>> affiliation = "Monty Python"
>>> message = (
...     f"Hi {name}. "
...     f"You are a {profession}. "
...     f"You were in {affiliation}."
... )
>>> message
'Hi Eric. You are a comedian. You were in Monty Python.'

Но помните, что вам нужно поместить «f» перед каждой строкой многострочной строки. Следующий код не будет работать:

>>> message = (
...     f"Hi {name}. "
...     "You are a {profession}. "
...     "You were in {affiliation}."
... )
>>> message
'Hi Eric. You are a {profession}. You were in {affiliation}.'

Если вы хотите распределить строки по нескольким строкам, вы можете так же сделать это с помощью \:

>>> message = f"Hi {name}. " \
...           f"You are a {profession}. " \
...           f"You were in {affiliation}."
...
>>> message
'Hi Eric. You are a comedian. You were in Monty Python.'

Или с помощью «»»:

>>> message = f"""
...     Hi {name}. 
...     You are a {profession}. 
...     You were in {affiliation}.
... """
...
>>> message
'\n    Hi Eric.\n    You are a comedian.\n    You were in Monty Python.\n'

Скорость

Символ f в f — строках также может означать «быстро» (fast).

f-строки быстрее, чем % — форматирование и str.format(). Как вы уже видели, f-строки — это выражения, вычисляемые во время выполнения, а не постоянные значения. Вот выдержка из документов:

«f-строки обеспечивают способ встраивания выражений в строковые литералы, используя минимальный синтаксис. Следует отметить, что f-строка на самом деле является выражением, вычисляемым во время выполнения, а не постоянным значением. В исходном коде Python f-строка является литеральной строкой с префиксом f, которая содержит выражения внутри фигурных скобок. Выражения заменяются их значениями ». (Источник)

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

Вот сравнение скорости:

>>> import timeit
>>> timeit.timeit("""name = "Eric"
... age = 74
... '%s is %s.' % (name, age)""", number = 10000)
0.003324444866599663
>>> timeit.timeit("""name = "Eric"
... age = 74
... '{} is {}.'.format(name, age)""", number = 10000)
0.004242089427570761
>>> timeit.timeit("""name = "Eric"
... age = 74
... f'{name} is {age}.'""", number = 10000)
0.0024820892040722242

Как вы можете видеть, f-строки выходят на первое место.

Тем не менее, это не всегда так. Когда они были впервые реализованы, у них были некоторые проблемы со скоростью, и их нужно было делать быстрее, чем str.format(). Был введен специальный код BUILD_STRING.

Python f-строки: особенности использования

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

Кавычки

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

Этот код будет работать:

>>> f"{'Eric Idle'}"
'Eric Idle'

Этот код также будет работать:

>>> f'{"Eric Idle"}'
'Eric Idle'

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

>>> f"""Eric Idle"""
'Eric Idle'
>>> f'''Eric Idle'''
'Eric Idle'

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

>>> f"The \"comedian\" is {name}, aged {age}."
'The "comedian" is Eric Idle, aged 74.'

Словари

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

>>> comedian = {'name': 'Eric Idle', 'age': 74}
>>> f"The comedian is {comedian['name']}, aged {comedian['age']}."
The comedian is Eric Idle, aged 74.

Пример с синтаксической ошибкой:

>>> comedian = {'name': 'Eric Idle', 'age': 74}
>>> f'The comedian is {comedian['name']}, aged {comedian['age']}.
SyntaxError: invalid syntax

Если вы используете тот же тип кавычки вокруг ключей словаря, что и на внешней стороне f-строки, то кавычка в начале первого ключа словаря будет интерпретироваться как конец строки.

Фигурные скобки

Чтобы в скобках появилась скобка, вы должны использовать двойные скобки:

>>> f"{{74}}"
'{74}'

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

>>> f"{{{74}}}"
'{74}'

Тем не менее, вы можете получить больше фигурных скобок, если вы используете больше, чем тройные фигурные скобки:

>>> f"{{{{74}}}}"
'{{74}}'

Обратный слеш

Как вы видели ранее, вы можете использовать обратные слэши в строковой части f-строки. SyntaxError: f-string expression part cannot include '#'

Заключение

Вы по-прежнему можете использовать более старые способы форматирования строк, но с f-строками у вас теперь есть более лаконичный, читаемый и удобный способ, который быстрее и менее подвержен ошибкам. Упрощение вашей жизни с помощью f-строк — отличная причина начать использовать Python 3.6, если вы еще не сделали этого. (Если вы все еще используете Python 2, не забудьте, что 2020 скоро наступит!)

Согласно Zen of Python, когда вам нужно решить, как что-то сделать, должен быть один — и предпочтительно только один — очевидный способ сделать это. Хотя f-строки не единственный возможный способ отформатировать строки, они в состоянии стать тем очевидным и единственным способом сделать эту работу.

Дальнейшее чтение

Если вы хотите прочитать расширенное обсуждение интерполяции строк, взгляните на PEP 502. Кроме того, в черновике PEP 536 есть еще несколько мыслей о будущем f-строк.

Оригинальная статья by Joanna Jablonski  Python 3’s f-Strings: An Improved String Formatting Syntax (Guide)

Была ли вам полезна эта статья?

[9 / 4.6]


Split Python: описание методики

Автор ArseniyDV На чтение 5 мин. Просмотров 305 Опубликовано

Программный язык Python предполагает использование различного типа информационных данных. Среди них можно выделить основные типы, с которыми придется регулярно иметь дело каждому программисту. Примерами могут послужить вариации string, ingteger, float. Сегодня мы будем рассматривать split и попробуем определить, что он собой представляет.

Описание методики

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

Факт! Функция Input представляет собой фактически строку в рассматриваемом случае.

Сразу, как только вы применили вышеуказанную функцию, вы можете прибегнуть к методу строки, которая называется split. Для чего он предназначен? Он способен возвращать список строк. Делает он это так, чтобы исходная строка оказалась как бы разрезана. Фактически выделяются отдельные её части, при этом используются пробелы. Приведем пример:

A = input().split()

Вы запустили такую программу? Попробуйте ввести сразу после этого комбинацию 123. В итоге вы получите список, который будет сопоставлен со значением  [‘1’, ‘2’, ‘3’].

Обратите внимание! В структуре списка будут присутствовать строки. То есть в нем не будут обнаруживаться числа.

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

for i in range(len(A)):

A[i] = int(A[i])

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

for i in range(len(A)):

A[i] = int(A[i])

Можно делать всё то же самое с использованием вышеперечисленных элементов, но только в 1 строку:

A = list(map(int, input().split()))

Если приходится взаимодействовать со списком действительных чисел, то в этом перечне можно произвести замену. Она будет касаться компонента int, который впоследствии будет заменён на разновидность float.

Методика, о которой сказано ранее, имеет 1 необязательный параметр. Он непосредственно влияет на то, какую именно строку следует использовать при разделении составляющих перечня, то есть списка. Рассмотрим в качестве примера разновидность split(‘.’). Что такой объект способен сделать? В данном случае он возвращает список, который был разрезан с помощью программы, к символам первоначальной строки ‘.’.

Применение противоположных методов позволяет получить перечень, пользуясь единострочной командой. В такой ситуации на помощь придет метод строки, которая именуется Join. Список строк выступает в данном случае единственным параметром для такой методики. Что мы получаем в итоге, как результат?

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

A = [‘red’, ‘green’, ‘blue’]

print(‘ ‘.join(A))

print(».join(A))

print(‘***’.join(A))

Здесь можно будет вывести особые строки, которые примут вид ‘red green blue’, redgreenblue и red***green***blue.

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

print(‘ ‘.join(map(str, A)))

Прочие похожие методики

Есть методы, которые называются find и replace. Первый из указанных представляет собой инструмент для поиска подстроки в строке. Кроме того, указанный объект способен возвращать индекс первого по счёту компонента той подстройки, которую удалось найти. Если её не нашли, то будет обеспечиваться возвращение к показателю -1. Рассмотрим на примере:

>>> s

‘red blue orange white’

>>> s.find(‘blue’)

4

>>> s.find(‘green’)

-1

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

>>> letters = ‘ABCDACFDA’

>>> letters.find(‘A’, 3)

4

>>> letters.find(‘DA’, 0, 6)

3

Впоследствии поиск продолжается, но уже с третьего индекса и вплоть до конечных показателей. Также он производится с первого числа и вплоть до шестого компонента перечня. Важно обратить внимание на то, что метод find отвечает за возвращение только того объекта, который причисляется к первому по счёту. Допустим, последняя буква А не будет найдена с помощью выражения letters.find(‘A’, 3).

Это объясняется тем, что эта буква обнаружена под индексом, который был обозначен, как 4. Метод, который носит название replace(), отличается способностью подстраиваться отдельную строку на любую другую. Для наглядности приведем такой пример:

>>> letters.replace(‘DA’, ‘NET’)

‘ABCNETCFNET’

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

>>> letters

‘ABCDACFDA’

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

>>> new_letters = letters.replace(‘DA’, ‘NET’)

>>> new_letters

‘ABCNETCFNET’

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

Python статические методы класса с примерами

  • Статический метод Python принадлежит к классу.
  • Используется для создания служебных методов для класса.
  • Статический метод вызывается из ссылки на класс.
  • Не может изменить состояние объекта, поскольку принадлежит классу.
  • Фактически не имеет доступа к атрибутам класса.
  • Статический метод похож на функцию в скрипте Python, но внутри тела класса.
  • Мы можем вызвать этот метод либо из ссылки на класс, либо из ссылки на объект. Если foo() является статическим методом в Class Utils, мы можем называть его Utils.foo() а также Utils().foo() .

Зачем нужны статические методы Python?

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

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

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

class ListUtils:

    @staticmethod
    def reverse(l):
        pass

    @staticmethod
    def clear(l):
        pass

class StringUtils:

    @staticmethod
    def reverse(l):
        pass

    @staticmethod
    def upper(l):
        pass

class TupleUtils:

    @staticmethod
    def reverse(t):
        pass

    @staticmethod
    def shuffle(t):
        pass

Если нам нужно перевернуть список, мы ListUtils.reverse() метод ListUtils.reverse() . Если нам нужно перетасовать элементы кортежа, мы TupleUtils.shuffle() статический метод TupleUtils.shuffle() .

Как создать статический метод в Python

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

  1. метод staticmethod().
  2. функция @staticmethod.

1. Использование функции staticmethod()

Staticmethod() полезен, когда вы хотите создать статический метод, определенный в классе. Обратите внимание, что у метода не должно быть аргумента self.

class StringUtils:

    def to_uppercase(s):
        return str(s).upper()

StringUtils.upper = staticmethod(StringUtils.to_uppercase)

print(StringUtils.upper('Python'))  # PYTHON

Если мы попытаемся вызвать метод to_uppercase() из объекта StringUtils, он вызовет ошибку, поскольку «метод принимает 1 позиционный аргумент, но было дано 2».

su = StringUtils()

try:
    print(su.to_uppercase('Python'))
except TypeError as te:
    print(te)

# Output
# to_uppercase() takes 1 positional argument but 2 were given

Однако мы можем вызвать метод to_uppercase() из ссылки на класс.

print(StringUtils.to_uppercase('Python'))  # PYTHON

2. Использование аннотации @staticmethod

Это рекомендуемый способ создания статического метода. Нам просто нужно аннотировать метод декоратором @staticmethod.

class MathUtils:

    @staticmethod
    def multiply(a, b):
        return a * b

print(MathUtils.multiply(10, 5))  # 50

Вывод.

Статический метод и метода класса — сравнение

  • Метод класса Python может получить доступ к переменным класса, но статический метод не может получить доступ к переменным класса.
  • Метод класса требует, чтобы первый формальный параметр был привязан к классу. Статический метод может присутствовать без каких-либо параметров.
  • Мы используем @classmethod для создания методов класса. Мы используем @staticmethod для создания статических методов.
class Test:
    x = 10

    @classmethod
    def foo(cls):
        print(cls.x)

    @staticmethod
    def bar():
        # Unresolved reference error for class variable x
        # print(x)
        pass

Сравнение статического метода и метода экземпляра

  • Метод экземпляра в классе может обращаться как к переменным экземпляра, так и к переменным класса. Статический не может получить доступ к переменным класса или переменным экземпляра.
  • Нам нужна «собственная переменная» в качестве формального параметра для метода экземпляра. В статическом такого ограничения нет.
  • Мы используем декоратор @staticmethod. Нам не нужны декораторы для создания функции экземпляра.
class Test:
    x = 10

    def func(self):
        print(type(self))
        print(self.x)

Преимущества

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

Методы строк

str.capitalize()

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

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

str.casefold()

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

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

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

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

str.center(width[, fillchar])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    my_string.encode()
    # b'\xd0\xba\xd0\xbe\xd1\x82 cat'

    my_string.encode('ascii')
    # UnicodeDecodeError

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

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

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

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

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

    surrogated = '\udcd0\udcba\udcd0\udcbe\udcd1\udc82 cat'

    surrogated.encode()  
    # UnicodeEncodeError

    surrogated.encode(errors='surrogateescape')
    # b'\xd0\xba\xd0\xbe\xd1\x82 cat'

    surrogated.encode(errors='surrogatepass')
    # b'\xed\xb3\x90\xed\xb2\xba\xed\xb3\x90\xed\xb2\xbe\xed\xb3\x91\xed\xb2\x82 cat'

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

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

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

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

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

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

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

str.expandtabs(tabsize=8)

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

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

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

my_str = '\t1\t10\t100\t1000\t10000'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

str.format(args, *kwargs)

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

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

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

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

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

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

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

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

  • Атрибут объекта адресуется при помощи . (точки).
  • Доступ к элементу при помощи [] (квадратных скобок).
import datetime
obj = {'one': {'sub': 1}, 'two': [10, 2, 30], 'three': datetime.datetime.now()}
'{one[sub]}-{two[1]}-{three.year}'.format(**obj)

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

Обычно возврат отформатированого значения возлагается на метод __format__(), однако бывают случаи, что требуется произвести принудительное приведение, например, к строке, в обход имеющейся реализации. Логика форматирования по умолчанию обходится при помощи приведения значения к строке перед вызовом __format__().20}Конец'.format(9) print(right) print(left) print(center)

Результат

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

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

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

Результат

1.3333333333333333
1.333333
1.33
     1.333

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

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

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

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

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

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

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

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

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

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

str.isalnum()

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

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

    ''.isalnum()  # False
    '  '.isalnum()  # False
    '[email protected]#'.isalnum()  # False
    'abc'.isalnum()  # True
    '123'.isalnum()  # True
    'abc123'.isalnum()  # True

str.isalpha()

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

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

    ''.isalpha()  # False
    '  '.isalpha()  # False
    '[email protected]#'.isalpha()  # False
    'abc'.isalpha()  # True
    '123'.isalpha()  # False
    'abc123'.isalpha()  # False

str.isascii()

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

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

str.isdigit()

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

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

    ''.isdigit()  # False
    '  '.isdigit()  # False
    '[email protected]#'.isdigit()  # False
    'abc'.isdigit()  # False
    '123'.isdigit()  # True
    'abc123'.isdigit()  # False

str.isidentifier()

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

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

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

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

str.islower()

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

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

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

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

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

str.isnumeric()

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

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

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

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

str.isprintable()

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

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

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

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

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

str.isspace()

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

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

'  '.isspace()  # True
'\n'.isspace()  # True
'\t'.isspace()  # True
' '.isspace()  # True (OGHAM SPACE MARK)
''.isspace()  # False
'[email protected]#'.isspace()  # False
'abc'.isspace()  # False
'123'.isspace()  # False
'abc123'.isspace()  # False

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

str.istitle()

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

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

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

str.isupper()

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

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

str.join(iterable)

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

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

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

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

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

str.ljust(width[, fillchar])

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

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

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

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

    from string import ljust

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

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

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

str.lower()

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

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

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

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

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

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

str.lstrip([chars])

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

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

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

str.rstrip([chars])

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

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

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

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

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

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

str.partition(sep)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

str.rjust(width[, fillchar])

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

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

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

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

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

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

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

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

str.rpartition(sep)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    '1,2,,3,'.split(',')   # ['1', '2', '', '3', ''] 
    # сравните с '1 2   3'.split()

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

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

    '   1   2   3   '.split()  # ['1', '2', '3']  
    # сравните с '1,2,,3,'.split(',')

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

str.splitlines([keepends])

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

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

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

    my_str = 'ab c\n\nde fg\rkl\r\n'
    my_str.splitlines()  # ['ab c', '', 'de fg', 'kl']
    my_str.splitlines(True)  # ['ab c\n', '\n', 'de fg\r', 'kl\r\n']

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

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

    my_str = 'ab\n cd\n'

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

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

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

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

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

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

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

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

str.strip([chars])

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

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

str.swapcase()

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

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

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

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

str.title()

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

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

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

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

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

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

str.translate(table)

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

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

str.upper()

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

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

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

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

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

str.zfill(width)

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

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

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

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

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

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

Строковые методы 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 - Строковые методы

В 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 Строковые методы »grokonez

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

Создать необработанную строку с escape-символами

Мы используем r перед кавычкой строки:

>>> print (r'Играть с \ 'escape \' символами \ n \ t \\\ \ ')

Играть с \' escape-символами \ n \ t \\\\

Создать многострочную строку

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

Например:

>>> '' 'Мы решаем задачи двумя способами:

...

... -' грок 'настолько тщательно, что наблюдатель становится частью наблюдаемый.

... - контрастирует "дзен", который представляет собой подобное сверхъестественное понимание, переживаемое как единственная короткая вспышка.

...

... Это идея, на которой построен наш логотип. '' '

"Мы решаем проблемы двумя способами: \ n \ n-' грок 'настолько тщательно, что наблюдатель становится частью из наблюдаемых.\ n- контрастирует "дзен", которое представляет собой подобное сверхъестественное понимание, проявляющееся в виде единственной короткой вспышки. \ n \ nЭто идея, на которой построен наш логотип. "

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

print ('' 'Мы решаем проблемы двумя способами:

-' grok 'настолько тщательно, что наблюдатель становится частью наблюдаемого.

- контрастирует «дзен», которое представляет собой подобное сверхъестественное понимание, переживаемое как единая короткая вспышка.

Это идея, на которой построен наш логотип. '')

Вывод:

Мы решаем проблемы двумя способами:

- так тщательно, что наблюдатель становится частью наблюдаемого.

- контрастирует «дзен», которое представляет собой подобное сверхъестественное понимание, переживаемое как единственная короткая вспышка.

Это идея, на которой построен наш логотип.

Получить символы по индексу и строке слайда

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

>>> site = 'grokonez'

>>> site [0]

'g'

>> > site [1]

'r'

>>> site [0: 4]

'grok'

>>> site [4:]

'onez'

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

Верхняя и нижняя строка

upper () и lower () Методы возвращают новую строку (без изменения исходной строки) со всеми буквами, преобразованными в верхний или нижний регистр:

>>> site = 'grokonez'

>>> site.upper ()

'GROKONEZ'

>>> site

'grokonez'

>>> site = site.upper ()

>>> site

'GROKONEZ'

>>> site .lower ()

'grokonez'

Swap Upper-Lower String

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

>>> 'гроконез-технология'.swapcase ()

'GROKONEZ TECHNOLOGY'

>>> 'GROKONEZ Technology'.swapcase ()

' grokonez TECHNOLOGY '

Первая буква заглавной

-

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

>>> 'grokonez programming tutorials'.capitalize ()

' Grokonez programming tutorials '

>>>' GROKONEZ TUTORIALS '.capitalize ()

'Grokonez tutorials'

- title () возвращает строку с заглавной первой буквой каждого слова:

>>> 'grokonez programming tutorials'.title ()

'Учебники по программированию Grokonez'

>>> 'Учебники по программированию GROKONEZ'.title ()

' Учебники по программированию Grokonez '

Python методы проверки строк

Прописные буквы и строчные буквы
и islower () методы возвращают:
- Истинно , если:
+ строка содержит хотя бы одну букву (не число)
+ все буквы прописные / строчные
- Ложь для других случаев

Например :

>>> site = 'Grokonez'

>>> site.isupper ()

False

>>> site.islower ()

False

>>> site = 'grokonez'

>>> site.islower ()

True

>> > numberString = '12345'

>>> numberString.isupper ()

False

>>> numberString.islower ()

False

>>> flex = 'abc123'

>>> flex .islower ()

True

>>> flex = 'ABC123'

>>> flex.isupper ()

True

Буквы и числа

- isalpha () возвращает True , если строка содержит только буквы (не пустые).

>>> 'grokonez'.isalpha ()

True

>>>' jsa2018'.isalpha ()

False

>>> 'jsa-tech'.isalpha ()

Ложь

>>> 'jsa Technology'.isalpha ()

False

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

>>> 'grokonez2018'.isalnum ()

True

>>>' jsa-2018'.isalnum ()

False

>>> 'jsa Technology'. isalnum ()

False

- isdecimal () возвращает True , если строка содержит только числовые символы (не пустые).

>>> '2019'.isdecimal ()

True

>>>' 2016and2017'.isdecimal ()

False

>>> '2017-2018'.isdecimal ()

False

Space

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

>>> '\ n \ t'.isspace ()

True

>>>' 1 '.isspace ()

False

Тип заголовка

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

>>> 'Grokonez Technology'.istitle ()

True

>>>' JSA Technology'.istitle ()

False

>>> 'JSA Technology'. istitle ()

False

Начало / конец с

- startwith () возвращает True , если строковое значение начинается со строки, переданной методу:

>>> ' Grokonez Technology ».начинается с ('grokonez')

True

>>> 'grokonez Technology'.startswith (' Tech ')

False

>>>' grokonez Technology '. начинается с (' grokee ')

False

>>> 'grokonez Technology'.startswith (' grokonez Technology ')

True

- endwith () возвращает True , если строковое значение заканчивается строкой, переданной методу :

>>> 'Grokonez Technology'.endwith ('logy')

True

>>> 'grokonez Technology'.endswith (' biology ')

False

>>>' grokonez Technology'.endswith ('grokonez Techno')

False

>>> 'grokonez Technology'.endswith (' grokonez Technology ')

True

Python методы соединения и разделения строк

Join strings

Мы используем join () to join список строк в одно строковое значение.Возвращенная строка - это объединение каждой строки в переданном списке.

>>> ',' .join (['собака', 'кошка', 'тигр'])

'собака, кошка, тигр'

>>> '' .join ( ['grokonez', 'Programming', 'tutorials'])

'grokonez Programming tutorials'

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

split () вызывается для строкового значения и возвращает список строк.

>>> «Мой сайт - grokonez.com'.split ()

['Мой', 'веб-сайт', 'is', 'grokonez.com']

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

>>> 'Мой веб-сайт grokonez.com'.split (' e ')

[' My w ',' bsit ',' is grokon ',' z.com ']

Строка раздела

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

>>> 'grokonez programming tutorials'.partition (' ')

(' grokonez ',' ',' tutorials ')

>>>' grokonez programming tutorials'.partition ( 'ming')

('grokonez program', 'ming', 'tutorials')

Python Justify Text

Right Justified

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

>>> 'гроконез'.rjust (10)

'grokonez'

# 10 = 2 пробела + 8 букв

>>> 'grokonez'.rjust (5)

' grokonez '

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

>>> 'grokonez'.rjust (10,' = ')

' == grokonez '

По левому краю

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

>>> 'grokonez'.ljust (10)

' grokonez '

# 10 = 8 букв + 2 пробела

>>>' grokonez'.ljust (5)

' grokonez '

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

>>> 'grokonez'.ljust (10,' = ')

' grokonez == '

Center

center () работает как ljust () и rjust () , но центрирует текст, а не выравнивает его по левому или правому краю.

>>> 'grokonez'.center (10)

' grokonez '

>>>' grokonez'.center (5)

'grokonez'

>>> ' grokonez'.center (10, '=')

'= grokonez ='

Удаление символов

- strip () возвращает новую строку без каких-либо пробелов в начале или в конце:

>>> 'гроконез'.strip ()

'grokonez'

- lstrip () удаляет пробельные символы слева, а rstrip () удаляет пробельные символы с правых концов:

>>> ' grokonez '.lstrip ()

' grokonez '

>>>' grokonez '.rstrip ()

' grokonez '

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

>>> 'TutsTutsgrokonezTutsPythonTuts'.strip ('sTut')

'grokonezTutsPython'

>>> 'TutsTutsgrokonezTutsPythonTuts'.lstrip (' sTut ')

' GrokonezTutsPythonTuts '

'

'TutsTutsgrokonezTutsPython'

* Примечание: Порядок символов в строке, передаваемой в строку strip () не имеет значения: strip ('sTut') будет делать то же самое, что и Полоса ('tTus') или полоса ('Tuts') .

Проверить подстроку в строке

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

>>> 'grok' в 'grokonez Technology'

True

>>> 'konez' в 'grokonez Technology'

True

>>> 'Grok' в 'grokonez Technology'

False

>>> '' in ' grokonez Technology '

True

>>>' серый 'не в' grokonez Technology '

True

>>>' konez 'не в' grokonez Technology '

False

Python Методы поиска строк

Count Substrings

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

>>> string = 'grokonez образовано от слов grok и konez'

>>> substring = 'grok'

>>> string.count (substring)

2

Найти индекс подстроки
index () & rindex ()

- index () возвращает индекс первого вхождения подстроки (если найден) в строке, или генерирует исключение, если подстрока не найденный.

>>> string = 'grokonez образовано от слов grok и konez'

>>> substring = 'konez'

>>> string.index (substring)

3

# поиск в строке [5:]

>>> string.index (substring, 5)

44

# поиск в строке [2:10] = 'okonez i'

>>> строка .index (substring, 2, 10)

3

# поиск в строке [2: 7] = 'okone'

>>> строка.index (substring, 2, 7)

Traceback (последний вызов последний):

Файл "", строка 1, в

ValueError: подстрока не найдена

- rindex ( ) возвращает индекс последнего вхождения подстроки (если она есть) в строку, или генерирует исключение, если подстрока не найдена.

>>> string = 'grokonez образовано от слов grok и konez'

>>> substring = 'konez'

>>> строка.rindex (подстрока)

44

# поиск в строке [: 42] = 'grokonez происходит от слов grok an'

>>> string.rindex (substring, 0, 42)

3

# search in string [10:42] = 'происходит от слов grok an'

>>> string.rindex (substring, 10, 42)

Traceback (последний вызов последним):

File " ", строка 1, в

ValueError: подстрока не найдена

find () & rfind ()

- Аналогично методу index () / rindex () , но есть только одно отличие: find () / rfind () return -1 , если не найден.

>>> string = 'grokonez образовано от слов grok и konez'

>>> substring = 'konez'

>>> string.find (подстрока)

3

# поиск в строке [5:]

>>> string.find (substring, 5)

44

# поиск в строке [2:10] = 'okonez i'

>>> строка .find (substring, 2, 10)

3

# поиск в строке [2: 7] = 'okone'

>>> строка.find (substring, 2, 7)

-1

# === rfind () ===

>>> string.rfind (substring)

44

# поиск в строке [: 42] = 'grokonez образовано от слов grok an'

>>> string.rfind (substring, 0, 42)

3

# search in string [10:42] = 's производных от words grok an '

>>> string.rfind (substring, 10, 42)

-1

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

replace () возвращает строку, в которой каждая подстрока заменяется аргументом строка.

>>> string = 'grokonez образовано от слов grok и konez'

>>> string.replace ('nez', 'zen')

'grokozen образовано от слов grok и козень

По гроконез | 27 декабря 2018 г.

Python 3 String методы

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

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

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

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

Результат

  Укус пчелы  
корпус () Возвращает копию строки в развернутом виде. Строки с регистром могут использоваться для сопоставления без регистра. a = "BEE" print (a.casefold ())

Результат

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

Результат

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

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

Неперекрывающиеся вхождения означают, что 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 ' 
заканчивается на ( суффикс [, начало [, конец ]])

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

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

Результат

  Правда
Правда
Ложь
Правда  
expandtabs (tabsize = 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 () следует использовать только в том случае, если вам нужно знать позицию подстроки. Если вам не нужно знать его позицию (т.е. вам нужно только знать, существует ли подстрока в строке), используйте оператор in . См. Строковые операторы для примера в .

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}". формат (* "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 [, начало [, конец ]])

Подобно 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 считается буквенно-цифровым, если одно из следующих значений возвращает Истинно :

  • 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 ())

Результат

  Ложь
Ложь
Правда
Ложь
Ложь
Правда
Правда  
isnumeric ()

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

Числовые символы включают цифровые символы и все символы, которые имеют свойство числового значения 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 ()

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

Пробельные символы - это те символы, которые определены в базе данных символов Unicode как «Другой» или «Разделитель», а также символы, для которых свойство двунаправленности имеет одно из «WS», «B» или «S».

а = "" печать (a.isspace ()) а = "" печать (a.isspace ()) a = "Барт" печать (a.isspace ()) а = "\ т" печать (a.isspace ()) a = "\ r \ n" печать (a.isspace ()) a = "Барт \ r" print (a.isspace ())

Результат

  Ложь
Правда
Ложь
Правда
Правда
Ложь  
название ()

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

Пробельные символы - это те символы, которые определены в базе данных символов Unicode как «Другой» или «Разделитель», а также символы, для которых свойство двунаправленности имеет одно из «WS», «B» или «S».

а = "" print (a.istitle ()) а = "" печать (a.istitle ()) а = "т" print (a.istitle ()) а = "Т" печать (a.istitle ()) a = "Чай" печать (a.istitle ()) a = "Чай и кофе" печать (a.istitle ()) a = "Чай и кофе" печать (a.istitle ()) a = "1. Чай и кофе \ r" print (a.istitle ())

Результат

  Ложь
Ложь
Ложь
Правда
Правда
Ложь
Правда
Правда  
верхний ()

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

Символы в регистре - это символы, общее свойство категории которых является одним из следующих: «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 ((«Доктор», «Кто»)))

Результат

  1-2-3
СОЕДИНЕННЫЕ ШТАТЫ АМЕРИКИ
Доктор Кто  
ljust ( ширина [, fillchar ]) Возвращает строку с выравниванием по левому краю в строке длиной шириной .Заполнение может быть выполнено с использованием указанного fillchar (заполнение по умолчанию использует пробел ASCII). Исходная строка возвращается, если ширина меньше или равна лен (ов) a = "пчела" b = a.ljust (12, "-") print (b)

Результат

  пчела ---------  
нижний ()

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

casefold () - это более агрессивный метод перевода строки в нижний регистр, и он подходит для сопоставления регистра.

a = "BEE" print (a.lower ())

Результат

  пчела  
lstrip ([ 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 (frm, to) 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 ("е")) 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). Исходная строка возвращается, если ширина меньше или равна лен (ов) a = "пчела" b = a.rjust (12, "-") print (b)

Результат

  --------- пчела  
rраздел ( сен )

Разбивает строку в последнем вхождении 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 ])

Вернуть копию строки с удаленными завершающими символами. Аргумент символов - это строка, определяющая набор символов, которые необходимо удалить. Если опущено или задано значение Нет , аргумент символов по умолчанию удаляет пробелы.

Обратите внимание, что аргумент символов не является суффиксом - все комбинации его значений удаляются.

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 , тест начинается с этой позиции. С опциональным end тест прекращает сравнение в этой позиции.

a = "Гомер" print (a.startswith ("H")) print (a.startswith ("h")) print (a.startswith ("Гомер")) print (a.startswith ("z")) print (a.startswith ("om", 1, 3))

Результат

  Правда
Ложь
Правда
Ложь
Правда  
полоса ([ символов ])

Возвращает копию строки с удаленными начальными и конечными символами.Аргумент символов - это строка, определяющая набор символов, которые необходимо удалить. Если опущено или задано значение Нет , аргумент символов по умолчанию удаляет пробелы.

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

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 (frm, to) secret_code = "Секретный код" .translate (trans_table) print (secret_code)

Результат

  123425 6782  
верх ()

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

a = "пчела" print (a.upper ())

Результат

  пчела  
zfill ( ширина )

Возвращает копию строки, заполненную слева ASCII 0 цифрами, чтобы сделать строку длиной шириной . Префикс ведущего знака ( + / - ) обрабатывается путем вставки отступа после символа знака, а не перед ним.Исходная строка возвращается, если ширина меньше или равна лен (ов) .

а = "36" печать (a.zfill (5)) а = "-36" печать (a.zfill (5)) а = "+36" print (a.zfill (5))

Результат

  00036
-0036
+0036  

Метод заголовка строки Python - GeeksforGeeks

Метод заголовка строки Python

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

Синтаксис:

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

Питон

str1 = «Вундеркинды для гиков»

стр2 = стр1.название ()

print 'Первый вывод после метода Title () =' , str2

print 'Преобразованная строка =' , str1.title ()

print 'Исходная строка =' , str1

str3 = 'ASIPU pawan kuMAr' .title ()

print 'Второй результат после метода Title () =' , str3

str4 = 'stutya kUMari sHAW' .название ()

print 'Третий вывод после метода Title () =' , str4

str5 = '6041' .title ()

print 'Четвертый вывод после метода Title () =' , str5

Выход:

 Первый результат после метода title () = Компьютерщик Для компьютерного фаната
Конвертированная строка is = Компьютерщик для компьютерных фанатов
Исходная строка = компьютерщики для компьютерных фанатов
Второй результат после метода title () равен = Asipu Pawan Kumar
Третий результат после метода title () равен = Stutya Kumari Shaw
Четвертый результат после метода title () равен = 6041 

Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS .

Строки Python

  • Подписывайтесь на нас