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

Синтаксис

• str.capitalize () -> str
• str.casefold () -> str [только для Python> 3.3]
• str.center (width [, fillchar]) -> str
• str.count (sub [, start [, end]]) -> int
• str.decode (encoding = "utf-8" [, errors]) -> unicode [только в Python 2.x]
• str.encode (encoding = "utf-8", errors = "strict") -> bytes
• str.endswith (суффикс [, start [, end]]) -> bool
• str.expandtabs (tabsize = 8) -> str
• str.find (sub [, start [, end]]) -> int
• str.format (* args, ** kwargs) -> str
• str.format_map (mapping) -> str
• str.index (sub [, start [, end]]) -> int
• str.isalnum () -> bool
• str.isalpha () -> bool
• str.isdecimal () -> bool
• str.isdigit () -> bool
• str.isidentifier () -> bool
• str.islower () -> bool
• str.isnumeric () -> bool
• str.isprintable () -> bool
• str.isspace () -> bool
• str.istitle () -> bool
• str.isupper () -> bool
• str.join (iterable) -> str
• str.ljust (width [, fillchar]) -> str
• str.lower () -> str
• str.lstrip ([chars]) -> str
• static str.maketrans (x [, y [, z]])
• str.partition (sep) -> (head, sep, tail)
• str.replace (old, new [, count]) -> str
• str.rfind (sub [, start [, end]]) -> int
• str.rindex (sub [, start [, end]]) -> int
• str.rjust (width [, fillchar]) -> str
• str.rpartition (sep) -> (head, sep, tail)
• str.rsplit (sep = None, maxsplit = -1) -> список строк
• str.rstrip ([chars]) -> str
• str.split (sep = None, maxsplit = -1) -> список строк
• str.splitlines ([keepends]) -> список строк
• str.startswith (prefix [, start [, end]]) -> book
• str.strip ([chars]) -> str
• str.swapcase () -> str
• str.title () -> str
• str.translate (table) -> str
• str.upper () -> str
• str.zfill (width) -> str

замечания

Изменение капитализации строки

Строковый тип Python предоставляет множество функций, которые действуют на капитализацию строки. Они включают :

• str.casefold
• str.upper
• str.lower
• str.capitalize
• str.title
• str.swapcase

С unicode-строками (по умолчанию в Python 3) эти операции не являются 1: 1 сопоставлениями или обратимыми. Большинство из этих операций предназначены для показа, а не для нормализации.

"XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

str.upper()

str.upper берет каждый символ в строке и преобразует его в свой верхний регистр, например:

"This is a 'string'.".upper()
# "THIS IS A 'STRING'."

str.lower()

str.lower делает обратное; он принимает каждый символ в строке и преобразует его в его нижний регистр:

"This IS a 'string'.".lower()
# "this is a 'string'."

str.capitalize()

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

"this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."

str.title()

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

"this Is a 'String'".title()
# "This Is A 'String'"

str.swapcase()

str.swapcase возвращает новый строковый объект, в котором все символы нижнего регистра заменяются на верхний регистр, а все символы верхнего регистра - ниже:

"this iS A STRiNG".swapcase() #Swaps case of each character
# "THIS Is a strIng"

Использование методов класса str

Стоит отметить, что эти методы можно назвать либо строковыми объектами (как показано выше), либо как метод класса класса str (с явным вызовом str.upper и т. Д.),

str.upper("This is a 'string'")
# "THIS IS A 'STRING'"

Это наиболее полезно при применении одного из этих методов ко многим строкам сразу, скажем, к функции map .

map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

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

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

str.split принимает строку и возвращает список подстрок исходной строки. Поведение отличается в зависимости от того, предоставлен или исключен аргумент sep .

Если sep не предоставлен или None , то расщепление происходит везде, где есть пробелы. Однако ведущее и завершающее пробелы игнорируются, а несколько последовательных символов пробелов обрабатываются так же, как один символ пробела:

>>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']

>>> " This is    a sentence.  ".split()
['This', 'is', 'a', 'sentence.']

>>> "            ".split()
[]

Параметр sep может использоваться для определения строки разделителя. Исходная строка разделяется на строку разделителя, и сам разделитель отбрасывается. Несколько последовательных разделителей не обрабатываются так же, как одно вхождение, а скорее создают пустые строки.

>>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is    a sentence.  ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']

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

>>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']

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

str.rsplit («right split») отличается от str.split («left split»), когда maxsplit . Разделение начинается в конце строки, а не в начале:

>>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']

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

Замените все вхождения одной подстроки на другую подстроку

У str типа Python также есть метод для замещения вхождения одной подстроки другой подстрокой в ​​заданной строке. Для более требовательных случаев можно использовать re.sub .

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

str.replace принимает два аргумента old и new содержащие old подстроку, которая должна быть заменена new подстрокой. Необязательный аргумент count указывает количество замен:

Например, чтобы заменить 'foo' на 'spam' в следующей строке, мы можем вызвать str.replace со old = 'foo' и new = 'spam' :

>>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."

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

>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

если, конечно, мы не даем значение для count . В этом случае count экземпляров собираются заменить:

>>> """It can foo multiple examples of foo if you want, \
... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third argument.'

str.format и f-strings: форматирование значений в строку

Python предоставляет функции интерполяции и форматирования строк через функцию str.format , введенную в версии 2.6 и f-строки, введенные в версии 3.6.

Учитывая следующие переменные:

i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

Следующие утверждения эквивалентны

"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"

>>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)

>>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

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

"%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

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

"I am from Australia. I love cupcakes from Australia!"

>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

Хотя официальная документация на python, как обычно, достаточно тщательна, pyformat.info имеет большой набор примеров с подробными объяснениями.

Кроме того, символы { и } могут быть экранированы с помощью двойных скобок:

"{'a': 5, 'b': 6}"

>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

См. Форматирование строк для получения дополнительной информации. str.format() был предложен в PEP 3101 и f-строках в PEP 498 .

Подсчет количества раз, когда подстрока появляется в строке

Один метод доступен для подсчета количества вхождений подстроки в другой строке str.count .

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

str.count возвращает int указывающий количество неперекрывающихся вхождений подстроки sub в другой строке. Необязательные аргументы start и end указывают начало и конец, в котором будет выполняться поиск. По умолчанию start = 0 и end = len(str) означает, что вся строка будет искать:

>>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

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

>>> s.count("sea", start)
1

эквивалентно:

>>> t = s[start:]
>>> t.count("sea")
1

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

Чтобы проверить начало и окончание заданной строки в Python, можно использовать методы str.startswith() и str.endswith() .

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

Как следует из названия, str.startswith используется для проверки того, начинается ли заданная строка с заданными символами в prefix .

>>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")  
False

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

>>> s.startswith("is", 2)
True

Это дает True поскольку s[2] == 'i' и s[3] == 's' .

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

>>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False

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

str.endswith точно подобен str.startswith с той лишь разницей, что он ищет конечные символы, а не начальные символы. Например, чтобы проверить, заканчивается ли строка с полной остановкой, можно написать:

>>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False

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

>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

Вы также можете использовать tuple чтобы проверить, заканчивается ли он любым набором строк

>>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False

Тестирование строки, состоящей из

Тип str Python также имеет ряд методов, которые можно использовать для оценки содержимого строки. Это str.isalpha , str.isdigit , str.isalnum , str.isspace . Капитализацию можно протестировать с помощью str.isupper , str.islower и str.istitle .

str.isalpha

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

>>> "Hello World".isalpha()  # contains a space
False
>>> "Hello2World".isalpha()  # contains a number
False
>>> "HelloWorld!".isalpha()  # contains punctuation
False
>>> "HelloWorld".isalpha()
True

В качестве краевого случая пустая строка оценивается как False при использовании с "".isalpha() .

str.isupper , str.islower , str.istitle

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

str.isupper - это метод, возвращающий True если все символы в заданной строке имеют верхний регистр и False противном случае.

>>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

И наоборот, str.islower - это метод, который возвращает True если все символы в заданной строке имеют строчные буквы и False противном случае.

>>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False

str.istitle возвращает значение True если заданная строка имеет название; то есть каждое слово начинается с символа верхнего регистра, за которым следуют строчные буквы.

>>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

str.isdecimal , str.isdigit , str.isnumeric

str.isdecimal возвращает, является ли строка последовательностью десятичных цифр, подходящей для представления десятичного числа.

str.isdigit содержит цифры не в форме, подходящей для представления десятичного числа, например надстрочных цифр.

str.isnumeric включает любые значения чисел, даже если не цифры, такие как значения вне диапазона 0-9.

            isdecimal    isdigit   isnumeric

12345        True        True       True
១2߃໔5        True        True       True
①²³🄅₅       False       True       True
⑩⒓          False       False      True
Five         False       False      False

Bytestrings ( bytes в Python 3, str в Python 2), поддерживает только isdigit , которая проверяет только основные ASCII-цифры.

Как и в случае str.isalpha , пустая строка оценивается как False .

str.isalnum

Это комбинация str.isalpha и str.isnumeric , в частности, она принимает значение True если все символы в данной строке являются буквенно-цифровыми , то есть они состоят из буквенных или числовых символов:

>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum()  # contains whitespace
False

str.isspace

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

>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

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

>>> "".isspace()
False

Чтобы покрыть этот случай, нам нужен дополнительный тест

>>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

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

>>> not my_str.strip()
True

str.translate: перевод символов в строку

Python поддерживает метод translate по типу str который позволяет вам указать таблицу переводов (используется для замены), а также любые символы, которые необходимо удалить в процессе.

str.translate(table[, deletechars])

Метод maketrans ( str.maketrans в Python 3 и string.maketrans в Python 2) позволяет сгенерировать таблицу переводов.

>>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th3s 3s 1 str3ng!'

Метод translate возвращает строку, которая представляет собой переведенную копию исходной строки.

Вы можете установить аргумент table None если вам нужно только удалить символы.

>>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl'

Удаление ненужных ведущих / завершающих символов из строки

str.strip три метода, которые позволяют str.strip ведущие и завершающие символы из строки: str.strip , str.rstrip и str.lstrip . Все три метода имеют одну и ту же подпись, и все три возвращают новый строковый объект с удалением ненужных символов.

str.strip([chars])

str.strip действует на заданной строки и удаляет (полоски) или каких - либо ведущих задних символов , содержащихся в аргументе chars ; если chars не указаны или None , все символы пробела удаляются по умолчанию. Например:

>>> "    a line with leading and trailing space     ".strip() 
'a line with leading and trailing space'

Если заданы chars , все символы, содержащиеся в нем, удаляются из строки, которая возвращается. Например:

>>> ">>> a Python prompt".strip('> ')  # strips '>' character and space character 
'a Python prompt'

str.rstrip([chars]) и str.lstrip([chars])

Эти методы имеют сходную семантику и аргументы с str.strip() , их различие лежит в том направлении, с которого они начинаются. str.rstrip() начинается с конца строки, а str.lstrip() разбивается с начала строки.

Например, используя str.rstrip :

>>> "     spacious string      ".rstrip()
'     spacious string'

Хотя, используя str.lstrip :

>>> "     spacious string      ".rstrip()
'spacious string      '

Сравнительные строки, нечувствительные к регистру

Сравнение строки в нечувствительном к регистру образом кажется чем-то тривиальным, но это не так. В этом разделе рассматриваются только строки unicode (по умолчанию в Python 3). Обратите внимание, что Python 2 может иметь небольшие недостатки относительно Python 3 - более поздняя обработка юникода намного более полная.

Первое, что следует отметить, - это то, что конверсии case-remove в unicode не являются тривиальными. Существует текст, для которого text.lower() != text.upper().lower() , например "ß" :

>>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

Но скажем, вы хотели без "BUSSE" сравнений "BUSSE" и "Buße" . Черт, вы, вероятно, также хотите сравнить "BUSSE" и "BUẞE" равными - это более новая форма капитала. Рекомендуемым способом является использование casefold :

>>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
      S.casefold() -> str
    
     Return a version of S suitable for caseless comparisons.
"""

Не используйте только lower . Если casefold недоступен, выполнение .upper().lower() помогает (но только несколько).

Тогда вы должны рассмотреть акценты. Если ваш рендерер шрифта хорош, вы, вероятно, думаете "ê" == "ê" - но это не так:

>>> "ê" == "ê"
False

Это потому, что они на самом деле

>>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

Самый простой способ справиться с этим - unicodedata.normalize . Вероятно, вы хотите использовать нормализацию NFKD , но не стесняйтесь проверить документацию. Тогда

>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True

Чтобы закончить, здесь это выражается в функциях:

import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right)

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

Строку можно использовать в качестве разделителя для объединения списка строк в одну строку с использованием метода join() . Например, вы можете создать строку, в которой каждый элемент в списке разделяется пробелом.

>>> " ".join(["once","upon","a","time"])
"once upon a time"

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

>>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time"

Полезные константы модуля String

string модуль Python предоставляет константы для операций, связанных с строкой. Чтобы использовать их, импортируйте string модуль:

>>> import string

string.ascii_letters :

Конкатенация ascii_lowercase и ascii_uppercase :

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase :

Содержит все символы ASCII нижнего регистра:

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase :

Содержит все символы ASCII верхнего регистра:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits :

Содержит все десятичные знаковые символы:

>>> string.digits
'0123456789'

string.hexdigits :

Содержит все символы шестнадцатеричной цифры:

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits :

Содержит все восьмеричные цифры:

>>> string.octaldigits
'01234567'

string.punctuation :

Содержит все символы, которые считаются пунктуацией в локали C :

>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

string.whitespace :

Содержит все символы ASCII, считанные пробелами:

>>> string.whitespace
' \t\n\r\x0b\x0c'

В режиме сценария print(string.whitespace) будет печатать фактические символы, используйте str для получения строки, возвращенной выше.

string.printable :

Содержит все символы, которые считаются пригодными для печати; комбинация string.digits , string.ascii_letters , string.punctuation и string.whitespace .

>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

Обращение строки

Строка может быть отменена с помощью встроенной функции reverse reversed() , которая берет строку и возвращает итератор в обратном порядке.

>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

reversed() может быть завернута в вызов ''.join() чтобы сделать строку из итератора.

>>> ''.join(reversed('hello'))
'olleh'

Хотя использование reversed() может быть более читаемым для непосвященных пользователей Python, использование расширенного среза с шагом -1 выполняется быстрее и более кратким. Здесь попробуйте реализовать его как функцию:

>>> def reversed_string(main_string):
...     return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'

Обозначить строки

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

Ниже приведен пример str.ljust и str.rjust :

interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189,305),
}
for road, length in interstates_lengths.items():
    miles,kms = length
    print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))

  40 -> 2555 mi. (4112 km.)
  19 -> 63   mi. (102  km.)
   5 -> 1381 mi. (2222 km.)
  93 -> 189  mi. (305  km.)

ljust и rjust очень похожи. Оба имеют параметр width и необязательный параметр fillchar . Любая строка, созданная этими функциями, по крайней мере до тех пор, пока параметр width который был передан в функцию. Если строка длиннее width , она не усекается. Аргумент fillchar , который по умолчанию имеет символ пробела ' ' должен быть одним символом, а не многострочной.

ljust функция подушечки конца строки она называется на с fillchar до тех пор, пока width длиной символов. Функция rjust устанавливает начало строки аналогичным образом. Следовательно, l и r в именах этих функций относятся к стороне, в которой исходная строка, а не fillchar , fillchar в выходную строку.

Преобразование между данными str или байтов и символами Unicode

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

В Python 2 вам может потребоваться преобразовать данные str в символы Unicode. Значение по умолчанию ( '' , "" и т. Д.) Является строкой ASCII с любыми значениями вне диапазона ASCII, отображаемыми как экранированные значения. Строки Unicode - u'' (или u"" и т. Д.).

# You get "© abc" encoded in UTF-8 from a file, network, or other data source

s = '\xc2\xa9 abc'  # s is a byte array, not a string of characters
                    # Doesn't know the original was UTF-8
                    # Default form of string literals in Python 2
s[0]                # '\xc2' - meaningless byte (without context such as an encoding)
type(s)             # str - even though it's not a useful one w/o having a known encoding

u = s.decode('utf-8')  # u'\xa9 abc'
                       # Now we have a Unicode string, which can be read as UTF-8 and printed properly
                       # In Python 2, Unicode string literals need a leading u
                       # str.decode converts a string which may contain escaped bytes to a Unicode string
u[0]                # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # unicode

u.encode('utf-8')   # '\xc2\xa9 abc'
                    # unicode.encode produces a string with escaped bytes for non-ASCII characters

В Python 3 вам может понадобиться преобразовать массивы байтов (называемые «байтовым литералом») в строки символов Unicode. По умолчанию используется строка Юникода, а литералы bytestring теперь должны быть введены как b'' , b"" и т. isinstance(some_val, byte) вернет True в isinstance(some_val, byte) , предполагая, что some_val будет строкой, которая может быть закодирована как байты.

# You get from file or network "© abc" encoded in UTF-8

s = b'\xc2\xa9 abc' # s is a byte array, not characters
                    # In Python 3, the default string literal is Unicode; byte array literals need a leading b
s[0]                # b'\xc2' - meaningless byte (without context such as an encoding)
type(s)             # bytes - now that byte arrays are explicit, Python can show that.

u = s.decode('utf-8')  # '© abc' on a Unicode terminal
                       # bytes.decode converts a byte array to a string (which will, in Python 3, be Unicode)
u[0]                # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # str
                    # The default string literal in Python 3 is UTF-8 Unicode

u.encode('utf-8')   # b'\xc2\xa9 abc'
                    # str.encode produces a byte array, showing ASCII-range bytes as unescaped characters.

Содержит строку

Python чрезвычайно интуитивно проверяет, содержит ли строка заданную подстроку. Просто используйте оператор in :

>>> "foo" in "foo.baz.bar"
True

Примечание: тестирование пустой строки всегда приведет к True :

>>> "" in "test"
True