Типы итераторов
Python поддерживает концепцию итерации контейнеров. Это реализовано с использованием двух различных методов; они используются, чтобы позволить определяемым пользователем классам поддерживать итерацию. Последовательности, описанные ниже более подробно, всегда поддерживают итерационные методы.
Для объектов-контейнеров необходимо определить один метод, обеспечивающий поддержку итераций:
container.__iter__( )
Вернуть объект-итератор. Объект требуется для поддержки протокола итератора, описанного ниже. Если контейнер поддерживает разные типы итераций, могут быть предоставлены дополнительные методы для специального запроса итераторов для этих типов итераций. (Примером объекта, поддерживающего несколько форм итерации, может быть древовидная структура, которая поддерживает обход как в ширину, так и в глубину.) Этот метод соответствует tp_iter слоту структуры типов для объектов Python в API Python / C.
Сами объекты итератора должны поддерживать следующие два метода, которые вместе образуют протокол итератора :
iterator.__iter__( )
Вернуть сам объект итератора. Это необходимо , чтобы оба контейнера и итератора , которые будут использоваться с for и in отчетности. Этот метод соответствует tp_iter слоту структуры типов для объектов Python в API Python / C.
iterator.__next__( )
Верните следующий предмет из контейнера. Если других элементов нет, вызовите StopIteration исключение. Этот метод соответствует tp_iternext слоту структуры типов для объектов Python в API Python / C.
Python определяет несколько объектов-итераторов для поддержки итерации по общим и конкретным типам последовательностей, словарям и другим более специализированным формам. Конкретные типы не важны, кроме их реализации протокола итератора.
Когда __next__() вызывается метод итератора StopIteration, он должен продолжать делать это при последующих вызовах. Реализации, которые не подчиняются этому свойству, считаются неисправными.
Типы генераторов
Генераторы Python предоставляют удобный способ реализации протокола итератора. Если контейнер объекта __iter__() метод реализован в качестве генератора, он будет автоматически возвращать объект итератора (технически, объект генератора) подачи __iter__() и __next__() методы. Более подробную информацию о генераторах можно найти в документации к выражению yield .
Типы последовательностей - list, tuple, range
Существует три основных типа последовательности: списки, кортежи и объекты диапазона. Дополнительные типы последовательностей, предназначенные для обработки двоичных данных и текстовых строк , описаны в специальных разделах.
Общие последовательности операций
Операции в следующей таблице поддерживаются большинством типов последовательностей, как изменяемыми, так и неизменяемыми. collections.abc.Sequence ABC предусмотрено , чтобы сделать его легче правильно выполнять эти операции над типами пользовательских последовательностей.
В этой таблице перечислены операции последовательности, отсортированные по возрастанию приоритета. В таблице s и t - это последовательности одного типа, n , i , j и k - целые числа, а x - произвольный объект, отвечающий любым ограничениям типа и значения, налагаемым s .
in и not in операции имеют те же приоритеты , как операции сравнения. + + (Конкатенация) и операции * (повторение) имеют один и тот же приоритет, что и соответствующие числовые операции.
Неизменяемые типы последовательностей
Единственная операция, которую обычно реализуют неизменяемые типы последовательностей, которая также не реализуется изменяемыми типами последовательностей, - это поддержка встроенной hash() .
Эта поддержка позволяет неизменные последовательности, такие как tuple экземпляры, которые будут использоваться в качестве dict ключей и хранятся в set и frozenset экземплярах.
Попытка хешировать неизменяемую последовательность, содержащую нехешируемые значения, приведет к TypeError.
Типы изменяемых последовательностей
Операции в следующей таблице определены для изменяемых типов последовательностей. collections.abc.MutableSequence ABC предусмотрено , чтобы сделать его легче правильно выполнять эти операции над типами пользовательских последовательностей.
В таблице s - это экземпляр изменяемого типа последовательности, t - любой повторяемый объект, а x - произвольный объект, который соответствует любым ограничениям типа и значения, налагаемым s (например, bytearray принимает только целые числа, которые соответствуют ограничению значения 0 <= x <= 255 ).
Списки
Списки - это изменяемые последовательности, обычно используемые для хранения коллекций однородных элементов (где точная степень сходства зависит от приложения).
class list( [ iterable ] )
Списки могут быть составлены несколькими способами:
- Использование пары квадратных скобок для обозначения пустого списка: []
- Используя квадратные скобки, разделяя элементы запятыми: [a],[a, b, c]
- Используя понимание списка: [x for x in iterable]
- Использование конструктора типа: list()илиlist(iterable)
Конструктор создает список, элементы которого находятся в том же порядке и в том же порядке, что и элементы итерируемого объекта. iterable может быть либо последовательностью, контейнером, поддерживающим итерацию, либо объектом-итератором. Если iterable уже является списком, создается и возвращается копия, аналогично iterable [:]. Например, list ('abc') возвращает ['a', 'b', 'c'], а list ((1, 2, 3)) возвращает [1, 2, 3]. Если аргумент не указан, конструктор создает новый пустой список [].
Многие другие операции также создают списки, в том числе sorted() встроенные.
Списки реализуют все общие и изменяемые операции последовательности. Списки также предоставляют следующий дополнительный метод:
sort(*, key=None, reverse=False)
Этот метод сортирует список на месте, используя только <сравнения между элементами. Исключения не подавляются - если какая-либо операция сравнения завершится неудачно, вся операция сортировки завершится неудачно (и список, скорее всего, останется в частично измененном состоянии).
sort() принимает два аргумента, которые могут быть переданы только с помощью ключевого слова (аргументы, содержащие только ключевое слово ):
key указывает функцию одного аргумента, которая используется для извлечения ключа сравнения из каждого элемента списка (например, key=str.lower). Ключ, соответствующий каждому элементу в списке, вычисляется один раз и затем используется для всего процесса сортировки. Значение по умолчанию None означает, что элементы списка сортируются напрямую, без вычисления отдельного значения ключа.
functools.cmp_to_key() Утилита доступна для преобразования 2.x стиля КСС функции к ключевой функции.
reverse - это логическое значение. Если установлено True, то элементы списка сортируются, как если бы каждое сравнение было обратным.
Этот метод изменяет существующую последовательность для экономии места при сортировке большой последовательности. Чтобы напомнить пользователям, что он работает как побочный эффект, он не возвращает отсортированную последовательность (используется sorted() для явного запроса нового экземпляра отсортированного списка).
sort() Метод гарантированно будет стабильным. Сортировка является стабильной, если она гарантирует не изменять относительный порядок сравниваемых элементов - это полезно для сортировки за несколько проходов (например, сортировка по отделам, а затем по уровню заработной платы).
Детали реализации CPython: пока список сортируется, результат попытки изменить или даже проверить список не определен. Реализация Python на языке C заставляет список казаться пустым на время и увеличивается, ValueError если он может обнаружить, что список был изменен во время сортировки.
Кортежи
Кортежи - это неизменяемые последовательности, обычно используемые для хранения коллекций разнородных данных (таких как кортежи из двух элементов, созданные enumerate() встроенным модулем). Кортежи также используются в случаях, когда требуется неизменная последовательность однородных данных (например, разрешение хранения в экземпляре set или dict).
class tuple( [ iterable ] )
Кортежи могут быть построены несколькими способами:
- Использование пары круглых скобок для обозначения пустого кортежа: ()
- Использование конечной запятой для одноэлементного кортежа: a,или(a,)
- Разделение элементов запятыми: илиa, b, c(a, b, c)
- Использование tuple() встроенного: tuple() или tuple(iterable)
Конструктор создает кортеж, элементы которого совпадают и находятся в том же порядке, что и элементы итерируемого объекта. iterable может быть либо последовательностью, контейнером, поддерживающим итерацию, либо объектом-итератором. Если итерация уже является кортежем, она возвращается без изменений. Например, tuple ('abc') возвращает ('a', 'b', 'c'), а tuple ([1, 2, 3]) возвращает (1, 2, 3). Если аргумент не указан, конструктор создает новый пустой кортеж ().
Обратите внимание, что на самом деле кортеж составляет запятая, а не круглые скобки. Скобки необязательны, за исключением случая пустого кортежа или когда они необходимы, чтобы избежать синтаксической двусмысленности. Например, f (a, b, c) - это вызов функции с тремя аргументами, а f ((a, b, c)) - это вызов функции с трехкомпонентным кортежем в качестве единственного аргумента.
Кортежи реализуют все стандартные операции последовательности.
Диапазоны
rangeТип представляет собой неизменяемую последовательность цифр и обычно используется для цикла определенного числа раз for.
class range(stop)
class range(start, stop[, step])
Аргументы конструктора диапазона должны быть целыми числами (либо встроенными, int либо любым объектом, реализующим __index__специальный метод). Если аргумент шаг опущен, по умолчанию используется 1. Если начальный аргумент опущен, по умолчанию используется 0. Если шаг равен нулю, ValueError повышается.
Для положительного шага содержимое диапазона rопределяется формулой где и .r[i] = start + step*ii >= 0r[i] < stop
Для отрицательного шага содержимое диапазона по-прежнему определяется формулой , но ограничениями являются и .r[i] = start + step*ii >= 0r[i] > stop
Объект диапазона будет пустым, если r[0]не соответствует ограничению значения. Диапазоны действительно поддерживают отрицательные индексы, но они интерпретируются как индексация от конца последовательности, определяемой положительными индексами.
Диапазоны, содержащие абсолютные значения, превышающие sys.maxsize разрешенные, но некоторые функции (например, len() ) могут повышаться OverflowError.
Примеры диапазонов:
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]
Диапазоны реализуют все общие операции с последовательностями, кроме конкатенации и повторения (из-за того, что объекты диапазона могут представлять только последовательности, которые следуют строгому шаблону, а повторение и объединение обычно нарушают этот шаблон).
start
Значение начального параметра (или 0если параметр не указан)
stop
Значение параметра остановки
step
Значение параметра шага (или 1если параметр не указан)
Преимущество range типа над регулярным list или tuple в том , что range объект всегда будет принимать такое же (небольшое) количество памяти, независимо от размера диапазона он представляет (как он хранит только start, stopи stepзначение, вычисление отдельных элементов и поддиапазонов как необходимо).
Объекты диапазона реализуют collections.abc.Sequence ABC и предоставляют такие функции, как тесты включения , поиск индекса элемента, срезы и поддержка отрицательных индексов
>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18
Проверка объектов диапазона на равенство с помощью == и ! = Сравнивает их как последовательности. То есть два объекта диапазона считаются равными, если они представляют одну и ту же последовательность значений. (Обратите внимание, что два объекта диапазона, которые сравнивают равные, могут иметь разные атрибуты start, stop и step, например range (0) == range (2, 1, 3) или range (0, 3, 2) == range (0, 4, 2).)
Тип текстовой последовательности - str
Текстовые данные в Python обрабатываются с помощью str объектов или строк . Строки - это неизменяемые последовательности кодовых точек Unicode. Строковые литералы записываются разными способами:
- Одиночные кавычки: 'allows embedded "double" quotes'
- Двойные кавычки: ."allows embedded 'single' quotes"
- Тройной цитировал: ,'''Three single quotes'''"""Three double quotes"""
Строки в тройных кавычках могут занимать несколько строк - все связанные пробелы будут включены в строковый литерал.
Строковые литералы, которые являются частью одного выражения и имеют только пробелы между ними, будут неявно преобразованы в один строковый литерал. То есть .("spam " "eggs") == "spam eggs"
См. Строковые и байтовые литералы для получения дополнительной информации о различных формах строковых литералов, включая поддерживаемые escape-последовательности и r(«необработанный») префикс, который отключает большую часть обработки escape-последовательностей.
Строки также могут быть созданы из других объектов с помощью str конструктора.
Поскольку нет никакого отдельного типа «символ», индексирует строку производит строки длины 1. То есть, для непустая строка s , .s[0] == s[0:1]
Существует также нет изменяемого типа строки, но str.join() и io.StringIO может эффективно использоваться для построения строки из нескольких фрагментов.
Изменено в версии 3.3: для обратной совместимости с серией Python 2 uпрефикс снова разрешен для строковых литералов. Он не влияет на значение строковых литералов и не может сочетаться с rпрефиксом.
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')
Вернуть строковую версию объекта . Если объект не указан, возвращает пустую строку. В противном случае поведение str() зависит от того, указана ли кодировка или ошибки , как показано ниже.
Если не указаны ни кодировка, ни ошибки , str(object) возвращается object.__str__(), что является «неформальным» или красиво печатаемым строковым представлением объекта . Для строковых объектов это сама строка. Если у объекта нет __str__() метода, он str() возвращается к возврату repr(object).
Если задана хотя бы одна из кодировки или ошибок , объект должен быть байтовым объектом (например, bytesили bytearray). В этом случае, если объект является bytes(или bytearray) объектом, то эквивалентно . В противном случае перед вызовом получается объект байтов, лежащий в основе буферного объекта . См. Типы двоичных последовательностей - байты, байтовый массив, memoryview и Buffer Protocol для получения информации об объектах буфера .str(bytes, encoding, errors)bytes.decode(encoding, errors)bytes.decode()
Передача bytesобъекта в str()без аргументов кодировки или ошибок подпадает под первый случай возврата неформального строкового представления (см. Также параметр -bкомандной строки для Python). Например:
>>> str(b'Zoot!')
"b'Zoot!'"
Для получения дополнительной информации о str классе и его методах см. Тип текстовой последовательности - str и раздел Строковые методы ниже.
Строковые методы
Строки реализуют все стандартные операции с последовательностью, а также дополнительные методы, описанные ниже.
Строки также поддерживают два стиль строки форматирования, один обеспечивает большую степень гибкости и настроек, а другие на основе C printf стиля форматирования , который обрабатывает диапазон более узких типов и немного сложнее, правильно, но часто быстрее в тех случаях, когда он может обрабатывать ( форматирование строк в стиле printf ).
Раздел « Службы обработки текста» стандартной библиотеки охватывает ряд других модулей, которые предоставляют различные утилиты, связанные с текстом (включая поддержку регулярных выражений в reмодуле).
str.capitalize( )
Вернуть копию строки, в которой первый символ будет заглавной, а остальные - строчными.
Изменено в версии 3.8: первый символ теперь помещается в регистр заголовка, а не в верхний регистр. Это означает, что символы, такие как диграфы, будут иметь заглавную только первую букву, а не полный символ.
str.casefold( )
Верните копию строки в разложенном виде. Строки с регистром могут использоваться для сопоставления без регистра.
Раскладка регистра похожа на регистр нижнего регистра, но более агрессивна, поскольку предназначена для устранения всех различий регистра в строке. Например, немецкая строчная буква 'ß'эквивалентна "ss". Поскольку это уже строчная буква, lower()ничего не делать 'ß'; casefold() преобразует его в "ss".
Алгоритм casefolding описан в разделе 3.13 стандарта Unicode.
Новое в версии 3.3.
str.center( ширина [ , fillchar ] )
Возврат по центру строки длины и ширины . Заполнение выполняется с использованием указанного fillchar (по умолчанию используется пробел ASCII). Исходная строка возвращается, если ширина меньше или равна len(s).
str.count( sub [ , начало [ , конец ] ] )
Возвращает количество неперекрывающихся вхождений подстроки sub в диапазоне [ начало , конец ]. Необязательные аргументы start и end интерпретируются как в нотации среза.
str.encode( encoding = "utf-8" , errors = "strict" )
Вернуть закодированную версию строки в виде байтового объекта. Кодировка по умолчанию 'utf-8'. могут быть заданы ошибки для установки другой схемы обработки ошибок. Значение по умолчанию для ошибок - это 'strict'означает, что ошибки кодирования вызывают расширение UnicodeError. Другие возможные значения 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace'и любое другое имя , зарегистрированные с помощью codecs.register_error(), смотрите раздел Обработчиков ошибок . Список возможных кодировок см. В разделе Стандартные кодировки .
Изменено в версии 3.1: добавлена поддержка аргументов ключевых слов.
str.endswith( суффикс [ , начало [ , конец ] ] )
Вернуть, Trueесли строка заканчивается указанным суффиксом , в противном случае - возврат False. суффикс также может быть кортежем суффиксов, которые нужно искать. При необязательном запуске тест начинается с этой позиции. С необязательным концом прекратите сравнение в этой позиции.
str.expandtabs( tabsize = 8 )
Вернуть копию строки, в которой все символы табуляции заменены одним или несколькими пробелами, в зависимости от текущего столбца и заданного размера табуляции. Позиции табуляции встречаются для каждого символа табуляции (по умолчанию 8, что дает позиции табуляции в столбцах 0, 8, 16 и так далее). Чтобы развернуть строку, текущий столбец устанавливается в ноль, и строка просматривается посимвольно. Если символ табуляции ( \t), один или несколько пробелов вставляются в результат до тех пор, пока текущий столбец не станет равен позиции следующей табуляции. (Сам символ табуляции не копируется.) Если это символ новой строки ( \n) или return (\r), он копируется, и текущий столбец сбрасывается до нуля. Любой другой символ копируется без изменений, а текущий столбец увеличивается на единицу независимо от того, как символ представлен при печати.
>>> '01\t012\t0123\t01234'.expandtabs()
'01 012 0123 01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01 012 0123 01234'
str.find( sub [ , начало [ , конец ] ] )
Возвращает наименьший индекс в строке, в которой подстрока sub находится внутри среза s[start:end]. Необязательные аргументы start и end интерпретируются как в нотации среза. Вернуть, -1если подписка не найдена.
Заметка
find() Метод следует использовать только , если вам нужно знать положение подпункта . Чтобы проверить, является ли sub подстрокой или нет, используйте inоператор:
>>> 'Py' in 'Python'
True
str.format( * аргументы , ** kwargs )
Выполните операцию форматирования строки. Строка, для которой вызывается этот метод, может содержать буквальный текст или поля замены, разделенные фигурными скобками {}. Каждое поле замены содержит либо числовой индекс позиционного аргумента, либо имя аргумента ключевого слова. Возвращает копию строки, в которой каждое поле замены заменяется строковым значением соответствующего аргумента.
>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'
Заметка
При форматировании числа ( int, float, complex, decimal.Decimalи подклассы) с nтипом (например: '{:n}'.format(1234)), функция временно устанавливает LC_CTYPEязыковой стандарт для LC_NUMERICлокализации для декодирования decimal_pointи thousands_sepполей , localeconv()если они не являются ASCII , или больше , чем 1 байт, а LC_NUMERICязыковой стандарт отличается чем LC_CTYPEместность. Это временное изменение влияет на другие потоки.
Изменено в версии 3.7: при форматировании числа с помощью nтипа функция в некоторых случаях временно устанавливает LC_CTYPEязыковой стандарт на LC_NUMERICязыковой стандарт.
str.format_map( отображение )
Аналогично str.format(**mapping), за исключением того, что mappingиспользуется напрямую, а не копируется в dict. Это полезно, если, например mapping, это подкласс dict:
>>> class Default(dict):
... def __missing__(self, key):
... return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'
str.index( sub [ , начало [ , конец ] ] )
Вроде find(), но поднимать, ValueError когда подстрока не найдена.
str.isalnum( )
Вернуть, True если все символы в строке буквенно-цифровые и есть хотя бы один символ, в False противном случае. Символ cявляется буквенно - цифровым , если один из следующих возвращений True: c.isalpha(), c.isdecimal(), c.isdigit(), или c.isnumeric().
str.isalpha( )
Вернуть, Trueесли все символы в строке буквенные и есть хотя бы один символ, в Falseпротивном случае. Алфавитные символы - это те символы, которые определены в базе данных символов Unicode как «Letter», т. Е. Те, у которых свойство общей категории является одним из «Lm», «Lt», «Lu», «Ll» или «Lo». Обратите внимание, что это отличается от свойства «Alphabetic», определенного в стандарте Unicode.
str.isascii( )
Вернуть, Trueесли строка пуста или все символы в строке ASCII, в Falseпротивном случае. Символы ASCII имеют кодовые точки в диапазоне U + 0000-U + 007F.
str.isdecimal( )
Вернуть, Trueесли все символы в строке являются десятичными и есть хотя бы один символ, в False противном случае. Десятичные символы - это те, которые могут использоваться для образования чисел с основанием 10, например U + 0660, АРАБСКИЙ ЦИФРОВОЙ ЦИФР НУЛЬ. Формально десятичный символ - это символ из общей категории Unicode «Nd».
str.isdigit( )
Вернуть, Trueесли все символы в строке являются цифрами и есть хотя бы один символ, в Falseпротивном случае. Цифры включают десятичные символы и цифры, требующие особой обработки, например цифры надстрочного индекса совместимости. Это касается цифр, которые нельзя использовать для образования чисел с основанием 10, таких как числа Харости. Формально цифра - это символ, имеющий значение свойства Numeric_Type = Digit или Numeric_Type = Decimal.
str.isidentifier( )
Вернуть, Trueесли строка является допустимым идентификатором в соответствии с определением языка, разделом « Идентификаторы и ключевые слова» .
Вызов, keyword.iskeyword() чтобы проверить, sявляется ли строка зарезервированным идентификатором, например defи class.
>>> from keyword import iskeyword
>>> 'hello'.isidentifier(), iskeyword('hello')
True, False
>>> 'def'.isidentifier(), iskeyword('def')
True, True
str.islower( )
Вернуть, Trueесли все символы в регистре 4 в строке строчные и есть хотя бы один символ в регистре, в Falseпротивном случае.
str.isnumeric( )
Вернуть, True если все символы в строке являются числовыми символами, и есть хотя бы один символ, в False противном случае. Числовые символы включают символы цифр и все символы, которые имеют свойство числового значения Unicode, например U + 2155, VULGAR FRACTION ONE FIFTH. Формально числовые символы - это символы со значением свойства Numeric_Type = Digit, Numeric_Type = Decimal или Numeric_Type = Numeric.
str.isprintable( )
Вернуть, True если все символы в строке печатаются или строка пуста, в False противном случае. Непечатаемые символы - это те символы, которые определены в базе данных символов Unicode как «Другой» или «Разделитель», за исключением пробела ASCII (0x20), который считается пригодным для печати. (Обратите внимание, что печатаемые символы в этом контексте - это те, которые не следует экранировать при repr()вызове строки. Это не имеет никакого отношения к обработке строк, записанных в sys.stdoutили sys.stderr.)
str.isspace( )
Вернуть, True если в строке есть только пробельные символы и есть хотя бы один символ, в Falseпротивном случае.
Символ является пробел , если в базе данных символов Unicode (см unicodedata), либо его общая категория Zs ( «Separator, пространство»), или его двунаправленный класс является одним из WS, Bили S.
str.istitle( )
Возврат, True если строка является строкой с заглавными буквами и есть хотя бы один символ, например, символы верхнего регистра могут следовать только за символами без регистра, а символы нижнего регистра - только за символами в регистре. В False противном случае верните .
str.isupper( )
Вернуть, True если все символы в регистре 4 в строке прописные и есть хотя бы один символ в регистре, в False противном случае.
str.join( итерация )
Вернуть строку, которая является объединением строк в итерируемом . A TypeError будет вызываться, если в итерации есть какие-либо нестроковые значения , включая bytesобъекты. Разделителем между элементами является строка, обеспечивающая этот метод.
str.ljust( ширина [ , fillchar ] )
Возвращает строку, выровненную по левому краю, в строке длины и ширины . Заполнение выполняется с использованием указанного fillchar (по умолчанию используется пробел ASCII). Исходная строка возвращается, если ширина меньше или равна len(s).
str.lower( )
Вернуть копию строки, в которой все символы в регистре 4 преобразованы в нижний регистр.
Используемый алгоритм нижнего регистра описан в разделе 3.13 стандарта Unicode.
str.lstrip( [ символы ] )
Вернуть копию строки с удаленными ведущими символами. Символы аргументом является строка , определяющая набор символов , которые будут удалены. Если опущено или None, аргумент chars по умолчанию удаляет пробелы. Символы аргумент не префикс; скорее, все комбинации его значений удаляются:
>>> ' spacious '.lstrip()
'spacious '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'
static str.maketrans( x [ , y [ , z ] ] )
Этот статический метод возвращает таблицу перевода, используемую для str.translate().
Если есть только один аргумент, это должен быть словарь, отображающий порядковые номера Unicode (целые числа) или символы (строки длиной 1) в порядковые номера Unicode, строки (произвольной длины) или None. После этого символьные ключи будут преобразованы в порядковые.
Если есть два аргумента, они должны быть строками одинаковой длины, и в результирующем словаре каждый символ в x будет сопоставлен с символом в той же позиции в y. Если есть третий аргумент, это должна быть строка, символы которой будут сопоставлены Noneв результате.
str.partition( sep )
Разделите строку при первом появлении sep и верните кортеж из трех частей, содержащий часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, верните 3-кортеж, содержащий саму строку, за которой следуют две пустые строки.
str.replace( старый , новый [ , count ] )
Вернуть копию строки со всеми вхождениями старой подстроки, замененной на новую . Если указан необязательный аргумент count , заменяются только первые вхождения count .
str.rfind( sub [ , начало [ , конец ] ] )
Возвращает самый высокий индекс в строке , где подстрока югу находится, таким образом, что к югу находится внутри s[start:end]. Необязательные аргументы start и end интерпретируются как в нотации среза. Вернитесь -1в случае неудачи.
str.rindex( sub [ , начало [ , конец ] ] )
Подобно, rfind()но возникает, ValueErrorкогда подстрока sub не найдена.
str.rjust( ширина [ , fillchar ] )
Возвращает строку, выровненную по правому краю, в строке длины и ширины . Заполнение выполняется с использованием указанного fillchar (по умолчанию используется пробел ASCII). Исходная строка возвращается, если ширина меньше или равна len(s).
str.rpartition( sep)
Разделите строку на последнее вхождение sep и верните кортеж из трех частей, содержащий часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, верните 3-кортеж, содержащий две пустые строки, за которыми следует сама строка.
str.rsplit( sep = Нет , maxsplit = -1 )
Вернуть список слов в строке, используя sep в качестве строки-разделителя. Если maxsplit дается, в большинстве maxsplit разделений сделаны, в крайние правые одни. Если sep не указан или None, любая строка с пробелами является разделителем. За исключением разделения справа, rsplit()ведет себя, как split()описано ниже.
str.rstrip( [ символы ] )
Вернуть копию строки с удаленными завершающими символами. Символы аргументом является строка , определяющая набор символов , которые будут удалены. Если опущено или None, аргумент chars по умолчанию удаляет пробелы. Символы аргумент не суффикс; скорее, все комбинации его значений удаляются:
>>> ' spacious '.rstrip()
' spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'
str.split( sep = Нет , maxsplit = -1 )
Вернуть список слов в строке, используя sep в качестве строки-разделителя. Если задано maxsplit, выполняется не более maxsplit разбиений (таким образом, список будет содержать не больше maxsplit+1элементов). Если maxsplit не указан или -1, то количество разделений не ограничено (выполняются все возможные разделения).
Если задано sep , последовательные разделители не группируются вместе и считаются ограничивающими пустые строки (например, '1,,2'.split(',')возвращаемые значения ). Сентябрь аргумент может состоять из нескольких символов (например, возвращает ). Возвращается разделение пустой строки указанным разделителем .['1', '', '2']'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', '']
Если sep не указан или не указан None, применяется другой алгоритм разделения: последовательности последовательных пробелов рассматриваются как один разделитель, и результат не будет содержать пустых строк в начале или конце, если строка имеет ведущие или завершающие пробелы. Следовательно, разделение пустой строки или строки, состоящей только из пробелов, с Noneразделителем возвращается [].
Например:
>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> ' 1 2 3 '.split()
['1', '2', '3']
str.splitlines( [ keepends ] )
Вернуть список строк в строке с разрывом по границам строки. Разрывы строк не включаются в результирующий список, если keepends не задано и не истинно.
Этот метод разбивается на следующие границы строки. В частности, границы - это надмножество универсальных новых строк .
Например:
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']
В отличие от случая , когда задана split()строка разделителя sep , этот метод возвращает пустой список для пустой строки, а разрыв строки терминала не приводит к появлению дополнительной строки:
>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']
Для сравнения split('\n')дает:
>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']
str.startswith( префикс [ , начало [ , конец ] ] )
Вернуть, Trueесли строка начинается с префикса , в противном случае - вернуть False. prefix также может быть набором префиксов для поиска. При необязательном начале тестовая строка начинается с этой позиции. С необязательным концом прекратите сравнивать строку в этой позиции.
str.strip( [ символы ] )
Вернуть копию строки с удаленными начальными и конечными символами. Символы аргументом является строка , определяющая набор символов , которые будут удалены. Если опущено или None, аргумент chars по умолчанию удаляет пробелы. Символы аргумент не префикс или суффикс; скорее, все комбинации его значений удаляются:
>>> ' spacious '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'
Самые внешние начальные и конечные значения аргументов символов удаляются из строки. Символы удаляются с ведущего конца до тех пор, пока не будет достигнут строковый символ, который не содержится в наборе символов в chars . Аналогичное действие происходит на заднем конце. Например:
>>> comment_string = '#....... Section 3.2.1 Issue #32 .......' >>> comment_string.strip('.#! ') 'Section 3.2.1 Issue #32'
str.swapcase( )
Вернуть копию строки с символами верхнего регистра, преобразованными в нижний регистр и наоборот. Обратите внимание, что это не обязательно так .s.swapcase().swapcase() == s
str.title( )
Возвращает версию строки с заголовком, в которой слова начинаются с символа верхнего регистра, а остальные символы - с нижнего регистра.
Например:
>>> 'Hello world'.title()
'Hello World'
Алгоритм использует простое независимое от языка определение слова как группы последовательных букв. Определение работает во многих контекстах, но это означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может не быть желаемым результатом:
>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"
Обход апострофов можно создать с помощью регулярных выражений:
>>> import re
>>> def titlecase(s):
... return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
... lambda mo: mo.group(0).capitalize(),
... s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."
str.translate( таблица )
Вернуть копию строки, в которой каждый символ был сопоставлен с данной таблицей перевода. Таблица должна быть объектом, который реализует индексацию через __getitem__(), обычно отображение или последовательность . При индексировании порядковым номером Unicode (целым числом) объект таблицы может выполнять любое из следующих действий: возвращать порядковый номер Unicode или строку для сопоставления символа с одним или несколькими другими символами; return None, чтобы удалить символ из возвращаемой строки; или вызвать LookupErrorисключение, чтобы сопоставить символ самому себе.
Вы можете использовать str.maketrans()для создания карты перевода из символьных сопоставлений в разных форматах.
См. Также codecsмодуль для более гибкого подхода к отображению настраиваемых символов.
str.upper( )
Вернуть копию строки, в которой все символы в регистре 4 преобразованы в верхний регистр. Обратите внимание, что это s.upper().isupper()может быть, Falseесли он s содержит символы без регистра или если категория Unicode результирующего символа (ов) не «Lu» (буква, прописные буквы), а, например, «Lt» (буква, регистр заголовка).
Используемый алгоритм верхнего регистра описан в разделе 3.13 стандарта Unicode.
str.zfill( ширина )
Вернуть копию строки, заполненную слева '0'цифрами ASCII, чтобы получилась строка длиной и шириной . Префикс ведущего знака ( '+'/ '-') обрабатывается путем вставки отступа после символа знака, а не перед ним. Исходная строка возвращается, если ширина меньше или равна len(s).
Например:
>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'
printf-стиль форматирования строки
Описанные здесь операции форматирования обладают множеством причуд, которые приводят к ряду распространенных ошибок (например, неправильное отображение кортежей и словарей). Использование более новых форматированных строковых литералов , str.format() интерфейса или строк шаблона может помочь избежать этих ошибок. Каждая из этих альтернатив обеспечивает свои собственные компромиссы и преимущества простоты, гибкости и / или расширяемости.
Строковые объекты имеют одну уникальную встроенную операцию: %оператор (по модулю). Это также известно как оператор форматирования строки или интерполяции . При заданном (где формат - это строка) спецификации преобразования в формате заменяются нулем или несколькими элементами значений . Эффект аналогичен использованию в языке C.format % values%sprintf()
Если формат требует одного аргумента, значения могут быть одним объектом, не являющимся кортежем. 5 В противном случае значения должны быть кортежем с точным количеством элементов, указанным в строке формата, или одним объектом отображения (например, словарем).
Спецификатор преобразования содержит два или более символа и следующие компоненты, которые должны встречаться в следующем порядке:
- Символ '%', обозначающий начало спецификатора.
- Ключ сопоставления (необязательно), состоящий из заключенной в скобки последовательности символов (например, (somename)).
- Флаги преобразования (необязательно), которые влияют на результат некоторых типов преобразования.
- Минимальная ширина поля (необязательно). Если указано как '*'(звездочка), фактическая ширина считывается из следующего элемента кортежа в значениях , а объект для преобразования появляется после минимальной ширины поля и дополнительной точности.
- Точность (необязательно), обозначается '.'точкой (точка), за которой следует точность. Если указано как '*'(звездочка), фактическая точность считывается из следующего элемента кортежа в values , а значение для преобразования идет после точности.
- Модификатор длины (необязательно).
- Тип конверсии.
Если правым аргументом является словарь (или другой тип сопоставления), тогда форматы в строке должны включать заключенный в скобки ключ сопоставления в этот словарь, вставленный сразу после '%'символа. Ключ сопоставления выбирает значение для форматирования из сопоставления. Например:
>>> print('%(language)s has %(number)03d quote types.' %
... {'language': "Python", "number": 2})
Python has 002 quote types.
В этом случае *в формате не могут встречаться спецификаторы (поскольку они требуют последовательного списка параметров).
Модификатор длины ( h, lили L) может присутствовать, но игнорируется, так как он не требуется для Python, поэтому, например %ld, идентичен %d.
Типы конверсии:
Заключение
Пост создан для тг-канала @coolcoders