Оно бывает в строку 4 буквы: И … в строку, 4 (четыре) буквы

Содержание

Методы строк

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', 2)  # False
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__(), однако бывают случаи, что требуется произвести принудительное приведение, например, к строке, в обход имеющейся реализации.

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

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

str.isalnum()

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

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

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

str.isalpha()

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

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

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

str.isascii()

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

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

str.isdigit()

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

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

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

str.isidentifier()

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

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

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

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

str.islower()

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

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

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

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

'12'.islower()  # False

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

str.isnumeric()

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

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

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

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

str.isprintable()

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

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

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

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

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

str.isspace()

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

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

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

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

str.istitle()

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

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

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

str.isupper()

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

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

str.join(iterable)

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

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

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

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

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

str.ljust(width[, fillchar])

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

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

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

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

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

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

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

str.lower()

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

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

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

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

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

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

str.lstrip([chars])

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

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

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

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

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

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

str.partition(sep)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

str.rjust(width[, fillchar])

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

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

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

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

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

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

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

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

str.rpartition(sep)

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

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

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

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

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

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

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

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

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

str.rstrip([chars])

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

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

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

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

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

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

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

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

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

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

str.splitlines([keepends])

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

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

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

my_str = 'ab 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', 1)  # False
my_str.startswith('world', 4, 9)  # True

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

str.strip([chars])

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

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

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

str.swapcase()

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

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

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

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

str.title()

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

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

'кот ОбОрмот!'.title()  # Кот Обормот!
"they're bill's friends from the UK".title()  
# They'Re Bill'S Friends From The Uk

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

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

str.translate(table)

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

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

str.upper()

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

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

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

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

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

str.zfill(width)

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

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

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

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

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

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

6 пунктов, которые помогут легко разобраться с regexp

Давно хотели изучить regexp? Это небольшое руководство поможет разобраться с ними в 6 этапов, а обилие примеров позволит закрепить материал.

Regexp представляет собой группу символов или знаков, которая используется для поиска определенного текстового шаблона.

Регулярное выражение – это шаблон, который сравнивается с предметной строкой слева направо. Словосочетание “regular expression” применяется не так широко, вместо него обычно употребляют “regex” и “regexp”. Регулярное выражение используется для замены текста внутри строки, проверки формы, извлечения подстроки из строки на основе соответствия шаблона и т. д.

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

Это выражение принимает строки john_doe, jo-hn_doe и john12_as. Однако имя пользователя Jo не будет соответствовать этому выражению, потому что оно содержит прописную букву, а также является слишком коротким.

Регулярное выражение — это всего лишь шаблон из символов, который мы используем для выполнения поиска в тексте. Например, регулярное выражение the означает букву t, за которой следует буква h, за которой следует буква e.

"the" => The fat cat sat on the mat.

Регулярное выражение 123 соответствует строке 123. Регулярное выражение сопоставляется входной строке путем сравнения каждого символа в regexp с каждым символом входной строки. Регулярное выражение и входная строка сравниваются посимвольно. Обычно regex чувствительны к регистру, поэтому The не соответствует строке the.

"The" => The fat cat sat on the mat.

Тестировать выражение

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

Метасимволы	Описание
.	Находит начало введенной строки.
$	Находит конец введенной строки.

2.1 Точка

. — это простейший пример метасимвола. Метасимвол . соответствует любому единичному символу. Например, регулярное выражение .ar означает: любой символ, за которым следует буква a, за которой следует буква r.

«.ar» => The car parked in the garage.

Тестировать выражение

2.2 Интервал символов

Интервал или набор символов также называют символьным классом. Для его обозначения используются квадратные скобки. Чтобы указать диапазон символов внутри класса, необходимо поставить знак тире. Порядок ряда символов в наборе неважен. Так, например, регулярное выражение [Tt]he означает: T или t, за которым следует буква h, за которой следует буква e. c]ar» => The car parked in the garage.

Тестировать выражение

2.3 Повторения

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

2.3.1 Звездочка

Этот символ поможет найти одно или более копий какого-либо символа. Регулярное выражение a* означает 0 или более повторений символа a. Но если этот символ появится после набора или класса символов, тогда будут найдены повторения всего сета. Например, выражение [a-z]* означает любое количество этих символов в строке.

"[a-z]*" => The car parked in the garage #21.

Тестировать выражение

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

Еще звездочку можно использовать со знаком пробела \s, чтобы подобрать строку из пробелов. Например, выражение \s*cat\s будет означать 0 или более пробелов, за которыми следует символ с, за ним а и t, а за ними снова 0 либо больше пробелов.

"\s*cat\s*" => The fat cat sat on the concatenation.

Тестировать выражение

2.3.2 Плюс

+ соответствует одному или нескольким повторениям предыдущего символа. Например, регулярное выражение c.+t означает: строчная буква c, за которой следует хотя бы один символ, за которым следует строчный символ t. Необходимо уточнить, что буква t должна быть последней t в предложении.

"c.+t" => The fat cat sat on the mat.

Тестировать выражение

2.3.3. Вопросительный знак

В regexp метасимвол ? делает предшествующий символ необязательным. Этот символ соответствует полному отсутствию или же одному экземпляру предыдущего символа. Например, регулярное выражение [T]?he означает: необязательно заглавную букву T, за которой следует строчный символ h, за которым следует строчный символ e.
"[T]he" => The car is parked in the garage.
Тестировать выражение

"[T]?he" => The car is parked in the garage.

Тестировать выражение

2.4 Скобки

Скобки в regexp, которые также называются квантификаторами, используются для указания допустимого количества повторов символа или группы символов. Например, регулярное выражение [0-9]{2,3} означает, что допустимое количество цифр должно быть не менее двух цифр, но не более 3 (символы в диапазоне от 0 до 9).

"[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.

Тестировать выражение

Мы можем убрать второе число. Например, выражение [0-9]{2,} означает 2 или более цифр. Если мы также уберем запятую, то тогда выражение [0-9]{3} будет находить только лишь 3 цифры, ни меньше и ни больше.

"[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.

Тестировать выражение

"[0-9]{3}" => The number was 9.9997 but rounded it off to 10.0.

Тестировать выражение

2.5 Символьная группа

Группа символов — это группа подшаблонов, которая записывается внутри скобок (...). Как было упомянуто раньше, если в регулярном выражении поместить квантификатор после символа, он повторит предыдущий символ. Но если мы поставим квантификатор после группы символов, он просто повторит всю группу. Например, регулярное выражение (ab)* соответствует нулю или более повторениям символа «ab». Мы также можем использовать | — метасимвол чередования внутри группы символов. Например, регулярное выражение (c|g|p)ar означает: символ нижнего регистра c, g или p, за которым следует символ a, за которым следует символ r.

"(c|g|p)ar" => The car is parked in the garage.

Тестировать выражение

2.6 Перечисление

В regexp вертикальная полоса | используется для определения перечисления. Перечисление — это что-то вроде условия между несколькими выражениями. Можно подумать, что набор символов и перечисление работают одинаково, но это совсем не так, между ними существует огромная разница. Перечисление работает на уровне выражений, а набор символов на уровне знаков. Например, регулярное выражение (T|t)he|car означает: T или t, сопровождаемая строчным символом h, сопровождаемый строчным символом e или строчным символом c, а затем a и r.

"(T|t)he|car" => The car is parked in the garage.

Тестировать выражение

2.7 Исключение специального символа

Обратная косая черта \ используется в regexp, чтобы избежать символа, который следует за ней. (T|t)he» => The car is parked in the garage.

Тестировать выражение

2.8.2 Доллар

Знак доллара используется для проверки, является ли символ в выражении последним в введенной строке. Например (at\.)$ означает строчную а, за которой следует t, за которой следует a ., которые должны заканчивать строку.

"(at\.)" => The fat cat. sat. on the mat.

Тестировать выражение

"(at\.)$" => The fat cat. sat. on the mat.
Тестировать выражение

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

Сокращение	Описание
.	Любой символ, кроме новой строки
\w	Соответствует буквенно-цифровым символам:`[a-zA-Z0-9_]`
\W	Соответствует не буквенно-цифровым символам:`[^\w]`
\d	Соответствует цифрам: `[0-9]`
\D	Соответствует нецифровым знакам: `[^\d]`
\s	Соответствует знаку пробела: `[\t\n\f\r\p{Z}]`
\S	Соответствует символам без пробела: `[^\s]`

Lookbehind и lookahead (также называемые lookaround) — это определенные типы non-capturing групп (Они используются для поиска, но сами в него не входят). Lookaheads используются, когда у нас есть условие, что этому шаблону предшествует или следует другой шаблон. Например, мы хотим получить все числа, которым предшествует символ $ из входной строки $4.44 and $10.88. Мы будем использовать регулярное выражение (?<=\$)[0-9\.]*, которое означает: получить все числа, содержащие . и которым предшествует символ $. Ниже приведены lookarounds, что используются в регулярных выражениях:

Символ	Описание
?=	Положительный Lookahead
?!	Отрицательный Lookahead
?<=	Положительный Lookbehind
?<!	Отрицательный Lookbehind

4.1 Положительный Lookahead

Положительный lookahead означает, что эта часть выражения должна следовать за впереди идущим выражением. Возвращаемое значение содержит текст, который совпадает с первой частью выражения. Чтобы определить позитивный lookahead, используют скобки. Внутри них размещают знак вопроса и знак равенства: (?=...). Само же выражение пишется после =. Например, выражение (T|t)he(?=\sfat) — это T в верхнем или нижнем регистре, за которым следует h и e. В скобках мы определяем позитивный lookahead, который говорит движку регулярного выражения искать The или the, за которыми следует fat.

"(T|t)he(?=\sfat)" => The fat cat sat on the mat.

Тестировать выражение

4.2 Отрицательный Lookahead

Негативный lookahead используется, когда нам нужно получить все совпадения в строке, за которой не следует определенный шаблон. Негативный lookahead определяется так же, как и позитивный, с той лишь разницей, что вместо знака равенства мы используем знак отрицания !. Таким образом, наше выражение приобретает следующий вид: (?!...). Теперь рассмотрим (T|t)he(?!\sfat), что означает: получить все The или the в введенной строке, за которыми не следует слово fat, предшествующее знаку пробела.

"(T|t)he(?!\sfat)" => The fat cat sat on the mat.

Тестировать выражение

4.3 Положительный Lookbehind

Положительный lookbehind используется для получения всех совпадений, которым предшествует определенный шаблон. Положительный lookbehind обозначается так: (?<=...). Например, регулярное выражение (?<=(T|t)he\s)(fat|mat) означает получить все fat или mat из строки ввода, которые идут после слова The или the.

"(? The fat cat sat on the mat.

Тестировать выражение

4.4 Отрицательный Lookbehind

Отрицательный lookbehind используется для получения всех совпадений, которым не предшествует определенный шаблон. Отрицательный lookbehind обозначается выражением (?<!...). Например, регулярное выражение (?<!(T|t)he\s)(cat) означает: получить все cat слова из строки ввода, которые не идут после The или the.

"(? The cat sat on cat.

Тестировать выражение

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

Флаг	Описание
i	Нечувствительность к регистру: делает выражение нечувствительным к регистру.
g	Глобальный поиск: поиск шаблона во всей строке ввода.
m	Многострочность: анкер метасимвола работает в каждой строке.

5.1 Нечувствительные к регистру

Модификатор i используется для поиска совпадений, нечувствительных к регистру. Например, выражение /The/gi означает прописную букву T, за которой следуют h и e. И в самом конце выражения стоит i, благодаря которому можно проигнорировать регистр. g применяется для того, чтобы найти шаблон во всей введенной строке.
"The" => The fat cat sat on the mat.
Тестировать выражение

"/The/gi" => The fat cat sat on the mat.

Тестировать выражение

5.2 Глобальный поиск

Модификатор используется для выполнения глобального поиска шаблона(поиск будет продолжен после первого совпадения). Например, регулярное выражение /.(at)/g означает любой символ, кроме новой строки, за которым следует строчный символ a, а затем t. Поскольку мы использовали флаг g в конце регулярного выражения, теперь он найдет все совпадения в вводимой строке, а не только в первой (что является стандартом). , $) используются для проверки, является ли шаблон началом или концом строки. Но если мы хотим, чтобы привязки работали в каждой строке, нужно использовать флаг m. Например, регулярное выражение /at(.)?$/gm означает: строчный символ a, за которым следует t и что угодно, только не новая строка. А благодаря флагу m этот механизм регулярных выражений соответствует шаблону в конце каждой строки строки.

"/.at(.)?$/" => The fat cat sat on the mat.

Тестировать выражение

"/.at(.)?$/gm" => The fat cat sat on the mat.

Тестировать выражение

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

"/(.*at)/" => The fat cat sat on the mat.

Тестировать выражение

Чтобы получить «ленивое» выражение, нужно использовать ?. Так будет получена максимально короткая строка.

"/(.*?at)/" => The fat cat sat on the mat.

Тестировать выражение

Практическое введение в регулярные выражения для новичков
5 практических примеров использования регулярных выражений на JavaScript
11 материалов по регулярным выражениям

Источник

excel. Есть ли простой способ проверить, начинается ли строка с букв (любых 4 букв)?

Подход с использованием функции FilterXML

Функция WorksheetFunction FilterXML() была добавлена в ►Excel 2013 и позволяет указать любую строку поиска XPath для данного документа XML, которая не должна быть локально сохраненный файл (требуется функция WebService() ), но может быть строкой в пределах правильно сформированных открывающих и закрывающих узлов, т. е. наша тестовая строка с некоторыми простыми добавлениями узлов (частично сравнимыми со структурой html).

Пример вызова

 Sub TextXML()
Dim myString как строку
myString = "ABCD бла"
Если проверить(мояСтрока) Тогда
   ДЕЛАТЬ ВЕЩИ
   Отладка. Печать "хорошо"
Еще
   Debug.Print "о нет"
Конец, если
Конец сабвуфера

Функция справки

 Проверка функции (ByVal teststring As String) Как Boolean
    Const s As String = Chr(185) ' необычный символ, например. Хр(185): "¹"
    При ошибке GoTo oops
    If Len(WorksheetFunction.FilterXML("" & teststring & "", "//i[substring(translate(.,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','" & _
       String(26, s) & "'),1,4)='" & String(4, s) & "']")) > 0 Затем проверьте = True
    Выход из функции
упс:
    Очистить
Конечная функция

tl;tr — как использовать VBA в версиях Excel до 2013 года

Классический способ использования XPath через методы XMLDOM:

Пример вызова

 Sub TextXML2()
Dim myString как строку
myString = "ABCD бла"
Если проверка2(мояСтрока) Тогда
   ДЕЛАТЬ ВЕЩИ
   Отладка.  Печать "хорошо"
Еще
   Debug.Print "о нет"
Конец, если
Конец сабвуфера

Справочные функции

 Функция check2 (ByVal teststring As String) As Boolean
' Цель: проверить, являются ли первые 4 символа тестовой строки заглавными буквами от A до Z.
  ' [0] поздняя привязка XML-документа
    Dim xDoc как объект
    Установите xDoc = CreateObject("MSXML2.DOMDocument.6.0")
  ' [1] сформируйте XML-строку, добавив имена открывающих и закрывающих узлов («теги»)
    тестовая строка = "" & тестовая строка & ""
  ' [2] загрузить XML
    Если xDoc.LoadXML(тестовая строка) Тогда
      ' [3a] список совпадающих элементов через XPath
        Dim myNodeList как объект
        Установите myNodeList = xDoc.SelectNodes(XPath())
            'Debug.Print тестовая строка, " найдено: " & myNodeList.Length
      ' [3b] вернуть true, если элемент совпадает, т. е. длина списка больше нуля
        Если myNodeList.Length > 0, то check2 = True
    Конец, если
Конечная функция
Функция XPath() как строка
' Цель: создать строку XPath для получения узлов, в которых первые 4 символа являются заглавными буквами A-Z. 
' Результат: //i[substring(translate(.,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹'),1,4)="¹¹¹¹"]
  ' получить ВЕРХНИЙ регистр алфавита
    Const ABC As String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  ' определить строку замены, состоящую из необычного символа, повторенного 26 раз
    Const UNUSUAL As String = "¹" ' << заменить предпочитаемым символом
    Замена Dim As String: замена = String(Len(ABC), UNUSUAL)
    'возвращаем строку XPath
    XPath = "//i[substring(translate(.,'" & ABC & "','" & replace & "'),1,4)=""" & String(4, UNUSUAL) & """] "
Конечная функция

Документация Learning with Python 2nd Edition

7.1. Составной тип данных

До сих пор мы видели пять типов: int, float, bool, NoneType и ул. Струны качественно отличаются от остальных четырех, потому что они состоят из более мелких частей — символов .

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

Оператор квадратных скобок выбирает один символ из строки:

 >>> fruit = "banana"
>>> буква = фрукты[1]
>>> распечатать письмо

Выражение fruit[1] выбирает символ номер 1 из фруктов. переменная буква относится к результату. Когда мы отображаем букву, мы получаем сюрприз:

Первая буква "банана" не а, если только вы не компьютер ученый. По извращенным причинам компьютерщики всегда начинают считать с нуля. Нулевая буква (zero-eth) слова «банан» — b. 1-й буква (one-eth) — это a, а 2-я ( two-eth) буква — n.

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

 >>> буква = фрукты[0]
>>> распечатать письмо
б

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

7.2. Длина

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

 >>> fruit = "banana"
>>> Лен(фрукты)
6

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

 длина = len(фрукты)
last = fruit[длина] # ОШИБКА!

Это не сработает. Это вызывает ошибку времени выполнения IndexError: индекс строки вне допустимого диапазона. Причина в том, что нет 6-го письмо в "банане". Поскольку мы начали считать с нуля, шесть букв равны пронумерованы от 0 до 5. Чтобы получить последний символ, мы должны вычесть 1 из длина:

 длина = длина (плод)
последний = фрукт [длина-1]

В качестве альтернативы мы можем использовать отрицательных индекса , которые считают в обратном направлении от конец строки. Выражение fruit[-1] дает последнюю букву, Fruit[-2] дает предпоследний результат и так далее.

7.3. Обход и цикл for

Многие вычисления включают обработку строки по одному символу за раз. Часто начинают сначала, выбирают каждого персонажа по очереди, что-то делают к нему и продолжайте до конца. Эта схема обработки называется обход . Один из способов кодирования обхода — это оператор while:

 index = 0
в то время как индекс < len (фрукты):
    буква = фрукты[индекс]
    распечатать письмо
    индекс += 1

Этот цикл проходит по строке и отображает каждую букву в строке отдельно. Условие цикла: index < len(fruit), поэтому, когда index равен длина строки, условие ложно и тело цикла не казнен. Последний доступный символ - это тот, у которого есть индекс len(fruit)-1, который является последним символом в строке.

Использование индекса для обхода набора значений настолько распространено, что Python предоставляет альтернативный, более простой синтаксис — цикл for:

 для char во фруктах:
    печатать символ

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

В следующем примере показано, как использовать конкатенацию и цикл for для генерировать абеседарианский ряд. Абеседариан относится к серии или списку, в котором элементы отображаются в алфавитном порядке. Например, в книге Роберта Макклоски. книга Уступи дорогу утятам , утят зовут Джек, Как, Лак, Мак, Нак, Уак, Пак и Шарлатан. Этот цикл выводит эти имена по порядку:

 префиксов = "JKLMNOPQ"
суффикс = "подтвердить"
для буквы в префиксах:
    печатать букву + суффикс

Вывод этой программы:

 Джек
Как
Недостаток
Мак
Нэк
Дуб
Пакет
Чак

Конечно, это не совсем так, потому что Ouack и Quack написаны с ошибками. Вы исправите это в качестве упражнения ниже.

7.4. Струнные ломтики

Подстрока строки называется слайсом . Выбор фрагмента аналогичен выбор символа:

 >>> s = "Пётр, Павел и Мария"
>>> напечатать с[0:5]
Питер
>>> вывести с[7:11]
Павел
>>> напечатать с[17:21]
Мэри

Оператор [n:m] возвращает часть строки из n-ного символа к m-этому символу, включая первый, но исключая последний. Этот поведение противоречит здравому смыслу; имеет больше смысла, если вы представляете индексы указывая между символами, как показано на следующей диаграмме:

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

 >>> фрукты = "банан"
>>> фрукты[:3]
'запретить'
>>> фрукты[3:]
ана

Как вы думаете, что означает s[:]?

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

Операторы сравнения работают со строками. Чтобы увидеть, равны ли две строки:

 если слово == "банан":
    print "Да, у нас нет бананов!"

Другие операции сравнения полезны для вставки слов в лексиграфический порядок:

, если слово < "банан":
    print "Ваше слово, " + слово + ", предшествует банану."
Элиф слово > "банан":
    print "Ваше слово, " + слово + ", идет после банана."
еще:
    print "Да, у нас нет бананов!"

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

 Твое слово, Зебра, важнее банана.

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

7.6. Строки неизменяемы

Заманчиво использовать оператор [] в левой части присваивания, с намерением изменить символ в строке. Например:

 приветствие = "Привет, мир!"
приветствие[0] = 'J' # ОШИБКА!
распечатать приветствие

Вместо вывода Jello, world! этот код выводит ошибка выполнения TypeError: объект 'str' не поддерживает назначение элементов.

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

 приветствие = "Привет, мир!"
new_greeting = 'J' + приветствие[1:]
распечатать новое_приветствие

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

7.7. Оператор in

Оператор in проверяет, является ли одна строка подстрокой другой:

 >>> 'p' в 'apple'
Истинный
>>> 'i' в 'яблоке'
ЛОЖЬ
>>> 'ап' в 'яблоке'
Истинный
>>> 'па' в 'яблоке'
ЛОЖЬ

Обратите внимание, что строка является подстрокой самой себя:

 >>> 'a' в 'a'
Истинный
>>> "яблоко" в "яблоке"
Истинный

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

 по определению remove_vowels(s):
    гласные = "aeiouAEIOU"
    s_без_гласных = ""
    для буквы в s:
        если буква не гласная:
            s_without_vowels += буква
    вернуть s_без_гласных

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

7.8. Функция поиска

Что делает следующая функция?

 определение найти (строка, ch):
    индекс = 0
    в то время как индекс < len (strng):
        если строка[индекс] == ch:
            возвращаемый индекс
        индекс += 1
    возврат -1

В некотором смысле find является противоположностью оператора []. Вместо того, чтобы брать индекс и извлечение соответствующего символа, он берет символ и находит индекс, в котором появляется этот символ. Если персонаж не найден, функция возвращает -1.

Это первый пример оператора return внутри цикла. Если strng[index] == ch, функция немедленно возвращается, выходя из петля преждевременно.

Если символ не появляется в строке, то программа выходит из цикла обычно и возвращает -1.

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

7.9. Зацикливание и подсчет

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

 фрукты = "банан"
количество = 0
для обугливания во фруктах:
    если символ == 'а':
        количество += 1
количество печатей

7.10. Дополнительные параметры

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

 def find2(strng, ch, start):
    индекс = начало
    в то время как индекс < len (strng):
        если строка[индекс] == ch:
            возвращаемый индекс
        индекс += 1
    возврат -1

Вызов find2('банан', 'а', 2) теперь возвращает 3, индекс первого появление буквы «а» в слове «банан» после индекса 2. Что означает find2('банан', 'n', 3) вернуть? Если вы сказали 4, есть большая вероятность, что вы понять, как работает find2.

Более того, мы можем объединить find и find2 с помощью необязательный параметр :

 def find(strng, ch, start=0):
    индекс = начало
    в то время как индекс < len (strng):
        если строка[индекс] == ch:
            возвращаемый индекс
        индекс += 1
    возврат -1

Вызов find('banana', 'a', 2) этой версии find ведет себя просто как find2, а в вызове find('banana', 'a') start будет установлено значение по умолчанию из 0.

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

 найти определение (сила, канал, начало = 0, шаг = 1):
    индекс = начало
    в то время как 0 <= индекс < len(strng):
        если строка[индекс] == ch:
            возвращаемый индекс
        индекс += шаг
    возврат -1

Передача значения len(strng)-1 для начала и -1 для шага заставить его искать в начале строки, а не в конце. Обратите внимание, что нам нужно было проверить нижнюю границу индекса в цикле while, а также верхняя граница для размещения этого изменения.

7.11. Струнный модуль

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

 >>> import string

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

 >>> каталог(строка)

, который вернет список элементов внутри строкового модуля:

['Шаблон', '_TemplateMetaclass', '__builtins__', '__doc__', '__file__', '__name__', '_float', '_idmap', '_idmapL', '_int', '_long', '_multimap', '_re', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'atof', 'atof_error', 'atoi', 'atoi_error', 'atol', 'atol_error', 'заглавные буквы', 'заглавные слова', 'центр', 'количество', 'цифры', 'expandtabs', 'найти', 'шестнадцатеричные цифры', 'индекс', 'index_error', 'объединить', 'joinfields', 'буквы', 'ljust', 'нижний', 'нижний регистр', 'lstrip', 'maketrans', 'octdigits', 'для печати', 'пунктуация', 'замена', «rfind», «rindex», «rjust», «rsplit», «rstrip», «split», 'splitfields', 'strip', 'swapcase', 'перевод', 'верхний', 'верхний регистр', 'пробел', 'zfill']

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

 >>> тип(строка.цифры)
<тип 'строка'>
>>> введите (string.find)
<тип 'функция'>

Поскольку string.digits — это строка, мы можем напечатать ее, чтобы увидеть, что она содержит:

 >>> print string.digits
0123456789

Неудивительно, что он содержит все десятичные цифры.

string.find — это функция, которая делает почти то же самое, что и функция, которую мы написал. Чтобы узнать больше об этом, мы можем распечатать его docstring , __doc__, который содержит документацию по функции:

 >>> print string.find.__doc__
найти (s, sub [ начало [ конец]]) -> в
    Возвращает наименьший индекс в s, где найдена подстрока sub,
    так что sub содержится в s[start,end]. По желанию
    аргументы start и end интерпретируются как в нотации среза.
    Возврат -1 в случае неудачи.

Параметры в квадратных скобках являются необязательными. Мы можем использовать string.find почти так же, как мы нашли:

 >>> fruit = "banana"
>>> index = string.find(плод, "а")
>>> распечатать индекс
1

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

На самом деле string.find более общий, чем наша версия. он может найти подстроки, а не только символы:

 >>> string.find("банан", "нет")
2

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

 >>> string.find("банан", "na", 3)
4

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

 >>> string.find("bob", "b", 1, 2)
-1

В этом примере поиск завершается ошибкой, так как буква b не появляется в списке. диапазон индекса от 1 до 2 (не включая 2).

7.12. Классификация символов

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

Строка string.lowercase содержит все буквы, которые система считается строчным. Точно так же string.uppercase содержит все заглавные буквы. Попробуйте следующее и посмотрите, что получится:

 печатать строку.нижний регистр
напечатать string.uppercase
напечатать string.digits

Мы можем использовать эти константы и find для классификации персонажей. Например, если find(lowercase, ch) возвращает значение, отличное от -1, тогда ch должен быть нижний регистр:

 по умолчанию is_lower(ch):
    вернуть string.find(string.lowercase, ch) != -1

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

 def is_lower(ch):
    вернуть ch в string.lowercase

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

 по определению is_lower(ch):
    вернуть 'а' <= ch <= 'г'

Если ch находится между a и z , это должна быть строчная буква.

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

 >>> напечатайте string.whitespace

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

В модуле string есть и другие полезные функции, но эта книга не предназначена для использования в качестве справочного руководства. С другой стороны, библиотека Python Ссылка есть. Наряду с большим количеством другой документации, она доступна по адресу веб-сайт Python, http://www.python.org.

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

Самый краткий и мощный способ форматирования строки в Python — это использование оператор форматирования строки , % вместе с форматированием строки Python операции. Чтобы понять, как это работает, давайте начнем с нескольких примеров:

 >>> "Его зовут %s. " % "Артур"
— Его зовут Артур.
>>> имя = "Алиса"
>>> возраст = 10
>>> "Я %s и мне %d лет." % (Назовите возраст)
«Я Алиса, мне 10 лет».
>>> n1 = 4
>>> n2 = 5
>>> "2**10 = %d и %d * %d = %f" % (2**10, n1, n2, n1 * n2)
'2**10 = 1024 и 4 * 5 = 20,000000'
>>>

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

 "<ФОРМАТ>" % (<ЗНАЧЕНИЯ>)

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

В первом примере выше имеется одна спецификация преобразования, %s, который указывает строку. Единственное значение, "Артур", отображается на него и является не заключаются в скобки.

Во втором примере имя имеет строковое значение «Алиса», а возраст целочисленное значение, 10. Они соответствуют двум спецификациям преобразования, %s и %д. d во второй спецификации преобразования указывает, что значение представляет собой десятичное целое число.

В третьем примере переменные n1 и n2 имеют целые значения 4 и 5 соответственно. В формате есть четыре спецификации преобразования строка: три %d и %f. f указывает, что значение должно быть представлено как число с плавающей запятой. Четыре значения, которые соответствуют четырем спецификации преобразования: 2**10, n1, n2 и n1 * n2.

s, d и f — все типы преобразования, которые нам понадобятся для этого. книга. Полный список см. в разделе «Операции форматирования строк». Справочник по библиотеке Python.

Следующий пример иллюстрирует реальную полезность форматирования строк:

 i = 1
напечатать "i\ti**2\ti**3\ti**5\ti**10\ti**20"
пока я <= 10:
    выведите i, '\t', i**2, '\t', i**3, '\t', i**5, '\t', i**10, '\t', i* *20
    я += 1

Эта программа распечатывает таблицу различных степеней чисел от 1 до 10. В своей текущей форме он использует символ табуляции (\t) для выравнивания столбцы значений, но это ломается, когда значения в таблице становятся больше чем ширина табуляции из 8 символов:

 я я**2 я**3 я**5 я**10 я**20
1 1 1 1 1 1
2 4 8 32 1024 1048576
3 9 27 243 59049 3486784401
4 16 64 1024 1048576 1099511627776
5 25 125 3125 9765625 95367431640625
6 36 216 7776 60466176 3656158440062976
7 49 343 16807 282475249 79792266297612001
8 64 512 32768 1073741824 1152921504606846976
9 81 729 59049 3486784401 121576654528801
10 100 1000 100000 10000000000 100000000000000000000

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

 i = 1
print "%-4s%-5s%-6s%-8s%-13s%-15s" % \
      («Я», «Я ** 2», «Я ** 3», «Я ** 5», «Я ** 10», «Я ** 20»)
пока я <= 10:
    напечатать "%-4d%-5d%-6d%-8d%-13d%-15d" % (i, i**2, i**3, i**5, i**10, i**20)
    я += 1

Запуск этой версии приводит к следующему выводу:

 i i**2 i**3 i**5 i**10 i**20
1 1 1 1 1 1
2 4 8 32 1024 1048576
3 9 27 243 59049 3486784401
4 16 64 1024 1048576 1099511627776
5 25 125 3125 9765625 95367431640625
6 36 216 7776 60466176 3656158440062976
7 49 343 16807 282475249 79792266297612001
8 64 512 32768 1073741824 1152921504606846976
9 81 729 59049 3486784401 121576654528801
10 100 1000 100000 10000000000 100000000000000000000

- после каждого процента в спецификациях преобразования указывает на левый оправдание. Числовые значения указывают минимальную длину, поэтому %-13d выровненный по левому краю номер шириной не менее 13 символов.

7.14. Резюме и первые упражнения

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

индексация ([])

Доступ к одному символу в строке по его положению (начиная с 0). Пример: 'This'[2] оценивается как 'i'.

функция длины (длина)

Возвращает количество символов в строке. Пример: len('happy') оценивается как 5.

для обхода петли (для)

Обход строки означает доступ к каждому символу в строке, один вовремя. Например, следующий цикл for:

 для буквы в «Примере»:
    распечатать 2 * письмо,

оценивается как EE xx aa mm pp ll ee

нарезка ([:])

Срез — это подстрока строки. Пример: «бананы и сливки» [3:6] оцениваются как ана (так же, как и «бананы и сливки'[1:4]).

сравнение строк (>, <, >=, <=, ==)

Операторы сравнения работают со строками, вычисляя по лексиграфический порядок. Примеры: «яблоко» < «банан» оценивается как True. 'Zeta' < 'Appricot' оценивается как False . 'Зебра' <= 'трубкозуб' оценивается как Истинно, потому что все символы в верхнем регистре буквы предшествуют строчным буквам.

в операторе (в)

Оператор in проверяет, содержится ли один символ или строка внутри другой строки. Примеры: «черт возьми» в «Я буду проверять вы." оценивается как Истинно. "сыр" в "Я буду проверять вы." оценивается как False.

7.14.1. Первые упражнения

Напишите оценку интерпретатора Python для каждого из следующих выражения:

 >>> 'Питон'[1]

 >>> "Строки — это последовательности символов."[5]

 >>> лен("замечательно")

 >>> 'Тайна'[:4]

 >>> 'p' в слове "ананас"

 >>> 'яблоко' в 'ананасе'

 >>> 'груша' в 'ананасе'

 >>> 'яблоко' > 'ананас'

 >>> 'ананас' < 'Персик'

Напишите код Python, чтобы пройти каждый из следующих доктестов:

 """
  >>> тип(фрукты)
  <тип 'строка'>
  >>> Лен(фрукты)
  8
  >>> фрукты[:3]
  'баран'
"""

 """
  >>> group = "Джон, Пол, Джордж и Ринго"
  >>> группа[12:x]
  'Джордж'
  >>> группа[n:m]
  'Павел'
  >>> группа[:r]
  'Джон'
  >>> группа[ы:]
  «Ринго»
"""

 """
  >>> Лен(ы)
  8
  >>> с[4:6] == 'включено'
  Истинный
"""

7.

15. Глоссарий

составной тип данных: Тип данных, в котором значения состоят из компонентов или элементов, которые сами являются ценностями.
значение по умолчанию: Значение, присвоенное необязательному параметру, если для него не указан аргумент. предоставляется в вызове функции.
строка документации: Строковая константа в первой строке определения функции или модуля (и, как мы увидим позже, также в определениях классов и методов). Строки документации предоставляют удобный способ связать документацию с код. Строки документации также используются модулем doctest для автоматизированного тестирование.
запись через точку: Использование оператор точки , ., для доступа к функциям внутри модуль.
неизменяемый: Составной тип данных, элементам которого нельзя присвоить новые значения.
индекс: Переменная или значение, используемое для выбора члена упорядоченного набора, например символ из строки.
дополнительный параметр: Параметр, записанный в заголовке функции с назначением значение по умолчанию, которое он получит, если соответствующий аргумент не указан данный для него в вызове функции.
ломтик: Часть строки (подстрока), заданная диапазоном индексов. Более как правило, можно создать подпоследовательность любого типа последовательности в Python. с помощью оператора среза (sequence[start:stop]).
траверса: Для перебора элементов набора, выполняя аналогичный операция на каждом.
пробел: Любой из символов, перемещающих курсор без печати, виден персонажи. Константа string.whitespace содержит все пробельные символы.

7.16. Упражнения

Изменить:

 префикса = "JKLMNOPQ"
суффикс = "подтвердить"
для буквы в префиксах:
    печатать букву + суффикс

, чтобы Ouack и Quack писались правильно.

Инкапсулировать
```
 фрукт = "банан"
количество = 0
для обугливания во фруктах:
    если символ == 'а':
        количество += 1
количество печатей
 
```
в функции с именем count_letters и обобщить ее так, чтобы она принимала строка и буква в качестве аргументов.
Теперь перепишите функцию count_letters так, чтобы вместо обхода строка, он неоднократно вызывает find (версия из Дополнительные параметры ), с необязательным третьим параметром для поиска учитываются новые вхождения буквы.
Как вы думаете, какая версия is_lower будет самой быстрой? Ты можешь думать о другие причины, кроме скорости, чтобы предпочесть ту или иную версию?

Создайте файл с именем stringtools.py и поместите в него следующее:

 по умолчанию реверс(и):
    """
      >>> реверс('счастливый')
      'иппа'
      >>> реверс('Питон')
      'nohtyP'
      >>> наоборот ("")
      ''
      >>> реверс ("П")
      'П'
    """
если __name__ == '__main__':
    импортировать доктест
    doctest.testmod()

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

Добавить зеркало в stringtools.py .

 защитное зеркало(я):
    """
      >>> зеркало("хорошо")
      'хорошо'
      >>> зеркало("да")
      'да'
      >>> зеркало('Питон')
      'ПитоннохтиП'
      >>> зеркало ("")
      ''
      >>> зеркало("а")
      'аа'
    """

Напишите для него тело функции, которое заставит его работать, как указано доктесты.

Включить remove_letter в stringtools.py .

 def remove_letter (буква, строка):
    """
      >>> remove_letter('а', 'яблоко')
      яблоко
      >>> remove_letter('а', 'банан')
      'бнн'
      >>> remove_letter('z', 'банан')
      'банан'
      >>> remove_letter('i', 'Миссисипи')
      'Мсссспп'
    """

Напишите для него тело функции, которое заставит его работать, как указано доктесты.

Наконец, добавьте тела к каждой из следующих функций, по одному

 по определению is_palindrome(s):
    """
      >>> is_palindrome('абба')
      Истинный
      >>> is_palindrome('абаб')
      ЛОЖЬ
      >>> is_palindrome('догмат')
      Истинный
      >>> is_palindrome('банан')
      ЛОЖЬ
      >>> is_palindrome('соломенные бородавки')
      Истинный
    """

 отсчет(суб, с):
    """
      >>> count('есть', 'Миссисипи')
      2
      >>> count('an', 'банан')
      2
      >>> count('ана', 'банан')
      2
      >>> count('нана', 'банан')
      1
      >>> count('нанан', 'банан')
      0
    """

 деф удалить(sub, s):
    """
      >>> удалить('банан')
      'бана'
      >>> удалить('цикл', 'велосипед')
      желчь
      >>> удалить('исс', 'Миссисипи')
      'Миссипи'
      >>> удалить('яйцо', 'велосипед')
      'велосипед'
    """

 по определению remove_all (sub, s):
    """
      >>> remove_all('an', 'банан')
      'ба'
      >>> remove_all('цикл', 'велосипед')
      желчь
      >>> remove_all('исс', 'Миссисипи')
      'Миппи'
      >>> remove_all('яйца', 'велосипед')
      'велосипед'
    """

, пока не пройдены все доктесты.