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

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

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

41 вопрос о работе со строками в Python / Блог компании RUVDS.com / Хабр

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

Быть хорошим программистом — это не значит помнить все встроенные функции некоего языка. Но это не означает и того, что их запоминание — бесполезное дело. Особенно — если речь идёт о подготовке к собеседованию.

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

1. Как проверить два объекта на идентичность?

Оператор

is

возвращает

True

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

Не стоит путать is и ==. Оператор == проверяет лишь равенство объектов.

animals           = ['python','gopher']
more_animals      = animals
print(animals == more_animals) #=> True
print(animals is more_animals) #=> True
even_more_animals = ['python','gopher']
print(animals == even_more_animals) #=> True
print(animals is even_more_animals) #=> False

Обратите внимание на то, что

animals

и

even_more_animals

не идентичны, хотя и равны друг другу.

Кроме того, существует функция id(), которая возвращает идентификатор адреса памяти, связанного с именем переменной. При вызове этой функции для двух идентичных объектов будет выдан один и тот же идентификатор.

name = 'object'
id(name)
#=> 4408718312

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

Существует строковый метод

istitle()

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

print( 'The Hilton'.istitle() ) #=> True
print( 'The dog'.istitle() ) #=> False
print( 'sticky rice'.istitle() ) #=> False

3. Как проверить строку на вхождение в неё другой строки?

Существует оператор

in

, который вернёт

True

в том случае, если строка содержит искомую подстроку.

print( 'plane' in 'The worlds fastest plane' ) #=> True
print( 'car' in 'The worlds fastest plane' ) #=> False

4. Как найти индекс первого вхождения подстроки в строку?

Есть два метода, возвращающих индекс первого вхождения подстроки в строку. Это —

find()

и

index()

. У каждого из них есть определённые особенности.

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

'The worlds fastest plane'.find('plane') #=> 19
'The worlds fastest plane'.find('car') #=> -1

Метод

index()

в подобной ситуации выбрасывает ошибку

ValueError

.

'The worlds fastest plane'.index('plane') #=> 19
'The worlds fastest plane'.index('car') #=> ValueError: substring not found

5. Как подсчитать количество символов в строке?

Функция

len()

возвращает длину строки.

len('The first president of the organization..') #=> 41

6. Как подсчитать то, сколько раз определённый символ встречается в строке?

Ответить на этот вопрос нам поможет метод

count()

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

'The first president of the organization..'.count('o') #=> 3

7. Как сделать первый символ строки заглавной буквой?

Для того чтобы это сделать, можно воспользоваться методом

capitalize()

.

'florida dolphins'.capitalize() #=> 'Florida dolphins'

8. Что такое f-строки и как ими пользоваться?

В Python 3.6 появилась новая возможность — так называемые «f-строки». Их применение чрезвычайно упрощает интерполяцию строк. Использование f-строк напоминает применение метода

format()

.

При объявлении f-строк перед открывающей кавычкой пишется буква f.

name = 'Chris'
food = 'creme brulee'
f'Hello. My name is {name} and I like {food}.'
#=> 'Hello. My name is Chris and I like creme brulee'

9. Как найти подстроку в заданной части строки?

Метод

index()

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

'the happiest person in the whole wide world.'.index('the',10,44)
#=> 23

Обратите внимание на то, что вышеприведённая конструкция возвращает

23

, а не

0

, как было бы, не ограничь мы поиск.

'the happiest person in the whole wide world.'.index('the')
#=> 0

10. Как вставить содержимое переменной в строку, воспользовавшись методом format()?

Метод

format()

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

format()

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

format()

.

difficulty = 'easy'
thing = 'exam'
'That {} was {}!'.format(thing, difficulty)
#=> 'That exam was easy!'

11. Как узнать о том, что в строке содержатся только цифры?

Существует метод

isnumeric()

, который возвращает

True

в том случае, если все символы, входящие в строку, являются цифрами.

'80000'.isnumeric() #=> True

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

'1.0'.isnumeric() #=> False

12. Как разделить строку по заданному символу?

Здесь нам поможет метод

split()

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

'This is great'.split(' ')
#=> ['This', 'is', 'great']
'not--so--great'.split('--')
#=> ['not', 'so', 'great']

13. Как проверить строку на то, что она составлена только из строчных букв?

Метод

islower()

возвращает

True

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

'all lower case'.islower() #=> True
'not aLL lowercase'.islower() # False

14. Как проверить то, что строка начинается со строчной буквы?

Сделать это можно, вызвав вышеописанный метод

islower()

для первого символа строки.

'aPPLE'[0].islower() #=> True

15. Можно ли в Python прибавить целое число к строке?

В некоторых языках это возможно, но Python при попытке выполнения подобной операции будет выдана ошибка

TypeError

.

'Ten' + 10 #=> TypeError

16. Как «перевернуть» строку?

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

''.join(reversed("hello world"))
#=> 'dlrow olleh'

17. Как объединить список строк в одну строку, элементы которой разделены дефисами?

Метод

join()

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

'-'.join(['a','b','c'])
#=> 'a-b-c'

18. Как узнать о том, что все символы строки входят в ASCII?

Метод

isascii()

возвращает

True

в том случае, если все символы, имеющиеся в строке, входят в ASCII.

print( 'Â'.isascii() ) #=> False
print( 'A'.isascii() ) #=> True

19. Как привести всю строку к верхнему или нижнему регистру?

Для решения этих задач можно воспользоваться методами

upper()

и

lower()

, которые, соответственно, приводят все символы строк к верхнему и нижнему регистрам.

sentence = 'The Cat in the Hat'
sentence.upper() #=> 'THE CAT IN THE HAT'
sentence.lower() #=> 'the cat in the hat'

20. Как преобразовать первый и последний символы строки к верхнему регистру?

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

animal = 'fish'
animal[0].upper() + animal[1:-1] + animal[-1].upper()
#=> 'FisH'

21. Как проверить строку на то, что она составлена только из прописных букв?

Имеется метод

isupper()

, который похож на уже рассмотренный

islower()

. Но

isupper()

возвращает

True

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

'Toronto'.isupper() #=> False
'TORONTO'.isupper() #= True

22. В какой ситуации вы воспользовались бы методом splitlines()?

Метод

splitlines()

разделяет строки по символам разрыва строки.

sentence = "It was a stormy night\nThe house creeked\nThe wind blew."
sentence.splitlines()
#=> ['It was a stormy night', 'The house creeked', 'The wind blew.']

23. Как получить срез строки?

Для получения среза строки используется синтаксическая конструкция следующего вида:

string[start_index:end_index:step]

Здесь

step

— это шаг, с которым будут возвращаться символы строки из диапазона

start_index:end_index

. Значение

step

, равное 3, указывает на то, что возвращён будет каждый третий символ.

string = 'I like to eat apples'
string[:6] #=> 'I like'
string[7:13] #=> 'to eat'
string[0:-1:2] #=> 'Ilk oetape' (каждый 2-й символ)

24. Как преобразовать целое число в строку?

Для преобразования числа в строку можно воспользоваться конструктором

str()

.

str(5) #=> '5'

25. Как узнать о том, что строка содержит только алфавитные символы?

Метод

isalpha()

возвращает

True

в том случае, если все символы в строке являются буквами.

'One1'.isalpha() #=> False
'One'.isalpha() #=> True

26. Как в заданной строке заменить на что-либо все вхождения некоей подстроки?

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

replace()

.

sentence = 'Sally sells sea shells by the sea shore'
sentence.replace('sea', 'mountain')
#=> 'Sally sells mountain shells by the mountain shore'

27. Как вернуть символ строки с минимальным ASCII-кодом?

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

min()

возвращает символ строки, имеющий наименьший код.

min('strings') #=> 'g'

28. Как проверить строку на то, что в ней содержатся только алфавитно-цифровые символы?

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

isalnum()

.

'Ten10'.isalnum() #=> True
'Ten10.'.isalnum() #=> False

29. Как удалить пробелы из начала строки (из её левой части), из её конца (из правой части), или с обеих сторон строки?

Здесь нам пригодятся, соответственно, методы

lstrip()

,

rstrip()

и

strip()

.

string = '  string of whitespace    '
string.lstrip() #=> 'string of whitespace    '
string.rstrip() #=> '  string of whitespace'
string.strip() #=> 'string of whitespace'

30. Как проверить то, что строка начинается с заданной последовательности символов, или заканчивается заданной последовательностью символов?

Для ответа на этот вопрос можно прибегнуть, соответственно, к методам

startswith()

и

endswith()

.

city = 'New York'
city.startswith('New') #=> True
city.endswith('N') #=> False

31. Как закодировать строку в ASCII?

Метод

encode()

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

utf-8

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

UnicodeEncodeError

.

'Fresh Tuna'.encode('ascii')
#=> b'Fresh Tuna'
'Fresh Tuna Â'.encode('ascii')
#=> UnicodeEncodeError: 'ascii' codec can't encode character '\xc2' in position 11: ordinal not in range(128)

32. Как узнать о том, что строка включает в себя только пробелы?

Есть метод

isspace()

, который возвращает

True

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

''.isspace() #=> False
' '.isspace() #=> True
'   '.isspace() #=> True
' the '.isspace() #=> False

33. Что случится, если умножить некую строку на 3?

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

'dog' * 3
# 'dogdogdog'

34. Как привести к верхнему регистру первый символ каждого слова в строке?

Существует метод

title()

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

'once upon a time'.title() #=> 'Once Upon A Time'

35. Как объединить две строки?

Для объединения строк можно воспользоваться оператором

+

.

'string one' + ' ' + 'string two' 
#=> 'string one string two'

36. Как пользоваться методом partition()?

Метод

partition()

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

sentence = "If you want to be a ninja"
print(sentence.partition(' want '))
#=> ('If you', ' want ', 'to be a ninja')

37. Строки в Python иммутабельны. Что это значит?

То, что строки иммутабельны, говорит о том, что после того, как создан объект строки, он не может быть изменён. При «модификации» строк исходные строки не меняются. Вместо этого в памяти создаются совершенно новые объекты. Доказать это можно, воспользовавшись функцией

id()

.

proverb = 'Rise each day before the sun'
print( id(proverb) )
#=> 4441962336
proverb_two = 'Rise each day before the sun' + ' if its a weekday'
print( id(proverb_two) )
#=> 4442287440

При конкатенации

'Rise each day before the sun'

и

' if its a weekday'

в памяти создаётся новый объект, имеющий новый идентификатор. Если бы исходный объект менялся бы, тогда у объектов был бы один и тот же идентификатор.

38. Если объявить одну и ту же строку дважды (записав её в 2 разные переменные) — сколько объектов будет создано в памяти? 1 или 2?

В качестве примера подобной работы со строками можно привести такой фрагмент кода:

animal = 'dog'
pet = 'dog'

При таком подходе в памяти создаётся лишь один объект. Когда я столкнулся с этим в первый раз, мне это не показалось интуитивно понятным. Но этот механизм помогает Python экономить память при работе с длинными строками.

Доказать это можно, прибегнув к функции id().

animal = 'dog'
print( id(animal) )
#=> 4441985688
pet = 'dog'
print( id(pet) )
#=> 4441985688

39. Как пользоваться методами maketrans() и translate()?

Метод

maketrans()

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

Метод translate() позволяет применить заданную таблицу для преобразования строки.

# создаём отображение
mapping = str.maketrans("abcs", "123S")
# преобразуем строку
"abc are the first three letters".translate(mapping)
#=> '123 1re the firSt three letterS'

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

a

,

b

,

c

и

s

, соответственно, на символы

1

,

2

,

3

и

S

.

40. Как убрать из строки гласные буквы?

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

string = 'Hello 1 World 2'
vowels = ('a','e','i','o','u')
''.join([c for c in string if c not in vowels])
#=> 'Hll 1 Wrld 2'

41. В каких ситуациях пользуются методом rfind()?

Метод

rfind()

похож на метод

find()

, но он, в отличие от

find()

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

story = 'The price is right said Bob. The price is right.'
story.rfind('is')
#=> 39

Итоги

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

Уважаемые читатели! Что, касающееся обработки строк в Python, вы посоветовали бы изучить тем, кто готовится к собеседованию?

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

Python: вызов функции из имени строки

У меня есть объект str, например: menu = 'install' . Я хочу запустить метод установки из этой строки. Например, когда я звоню menu(some, arguments) , он звонит install(some, arguments) . Есть ли какой-нибудь способ сделать это ?

python

Поделиться

Источник

İlker Dağlı    

29 октября 2011 в 02:17

3 ответа

• Как сделать вызов определенной функции в скрипте python из командной строки

  У меня есть пара вопросов относительно интеграции java — python У меня есть скрипт python, и он имеет 2 или более функций. 1) Как сделать вызов конкретной функции в скрипте python из командной строки. 2) Как передать параметры метода одной из функций в скрипте python из командной строки

• Вызов функции из строки в Python вызывает ошибку

  Я пытаюсь вызвать функцию из строки в Python, как описано в разделе вызов функции модуля из строки с именем function’s в Python . К сожалению, это не работает, и интерпретатор Python выдает ошибку: TypeError: ‘str’ object is not callable def current(self, t): if self.iMode == None: return…

130

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

class MyClass(object):
    def install(self):
          print "In install"

method_name = 'install' # set by the command line options
my_cls = MyClass()

method = None
try:
    method = getattr(my_cls, method_name)
except AttributeError:
    raise NotImplementedError("Class `{}` does not implement `{}`".format(my_cls.__class__.__name__, method_name))

method()

или если это функция:

def install():
       print "In install"

method_name = 'install' # set by the command line options
possibles = globals().copy()
possibles.update(locals())
method = possibles.get(method_name)
if not method:
     raise NotImplementedError("Method %s not implemented" % method_name)
method()

Поделиться

Sam Dolan    

29 октября 2011 в 02:21

69

Вы также можете использовать словарь.

def install():
    print "In install"

methods = {'install': install}

method_name = 'install' # set by the command line options
if method_name in methods:
    methods[method_name]() # + argument list of course
else:
    raise Exception("Method %s not implemented" % method_name)

Поделиться

concentricpuddle    

29 октября 2011 в 09:17

36

Почему мы не можем просто использовать eval()?

def install():
    print "In install"

Новый метод

def installWithOptions(var1, var2):
    print "In install with options " + var1 + " " + var2

А затем вы вызываете метод, как показано ниже

method_name1 = 'install()'
method_name2 = 'installWithOptions("a","b")'
eval(method_name1)
eval(method_name2)

Это дает результат в виде

In install
In install with options a b

Поделиться

Husain Khambaty    

25 апреля 2013 в 13:05

• ctypes Python динамический вызов функции

  Я пишу тестовый скрипт в Python для вызова функций C с помощью ctypes ctypes-Beginner У меня есть список функций и соответствующие имена общих объектов, и мне нужно динамически вызывать эти функции с помощью скрипта python. В то время как я использую его для прямого вызова имени функции в скрипте…

• Вызов встроенной функции со строкой в Python

  Я ссылался на следующие темы и не думаю, что этот пост является дубликатом какой-либо из них: Вызов функции модуля с помощью его имени (строки ) Python вызов функции из строки Используйте строку для вызова функции в Python Например, предположим, что у меня есть строка data_type = int , и я хочу…

Похожие вопросы:

Вычисление имени функции из имени другой функции

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

Python вызов функции из строки

s = func Теперь предположим, что существует функция, называемая func. Как я могу вызвать Python 2.7 call func, если имя функции задано в виде строки?

Вызов функции Python из MATLAB

Возможный Дубликат : Вызов функции Python из MATLAB Мне нужно вызвать функцию Python из среды MATLAB. Возможно ли это? Предположим, у меня есть следующий код Python: def squared(x): y = x * x return…

Как сделать вызов определенной функции в скрипте python из командной строки

У меня есть пара вопросов относительно интеграции java — python У меня есть скрипт python, и он имеет 2 или более функций. 1) Как сделать вызов конкретной функции в скрипте python из командной…

Вызов функции из строки в Python вызывает ошибку

Я пытаюсь вызвать функцию из строки в Python, как описано в разделе вызов функции модуля из строки с именем function’s в Python . К сожалению, это не работает, и интерпретатор Python выдает…

ctypes Python динамический вызов функции

Я пишу тестовый скрипт в Python для вызова функций C с помощью ctypes ctypes-Beginner У меня есть список функций и соответствующие имена общих объектов, и мне нужно динамически вызывать эти функции…

Вызов встроенной функции со строкой в Python

Я ссылался на следующие темы и не думаю, что этот пост является дубликатом какой-либо из них: Вызов функции модуля с помощью его имени (строки ) Python вызов функции из строки Используйте строку для…

(Отражение) Вызов Метода С Параметрами По Имени Функции В Swift

Контекст У меня есть экземпляр класса с именем Solution , и у меня есть имя функции в виде строки functionName , которую я хочу вызвать на экземпляре Solution solutionInstance . У меня есть…

Вызов имени функции Python из имени конкатенированной строки

Я хочу создать имя функции def из объединения string + variable + string и вызвать эту функцию def. В настоящее время я использую эту сокращенную версию кода для простоты аналогичного выполнения…

Вызов функции java из python-Chaquopy

Я просмотрел документы Chaquopy и нашел; с помощью Chaquopy код java и python можно вызывать по желанию пользователя. Я просмотрел примеры приложений и нашел примеры либо вызова python из java, либо…

Strings — Learn Python 3

Строку можно считывать со стандартного ввода, используя функцию input() или определяемую в одинарных или двойных кавычках. Две строки могут быть объединены, и мы также можем повторить строку n раз, умножая ее на integer:

None

print('>_< ' * 5)  # &gt; _ &lt;&gt; _ &lt;&gt; _ &lt;&gt; _ &lt;&gt; _ &lt;

Строка в Python представляет собой последовательность символов. Функция len(some_string) возвращает количество символов в строке:

None

print(len('abcdefghijklmnopqrstuvwxyz'))  # 26

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

None

s = str(2 ** 100)
print(s)  # 1267650600228229401496703205376
print(len(s))  # 31

Срез дает из заданной строки один символ или некоторый фрагмент: подстрока или подпоследовательность.

Существует три формы срезов. Простейшая форма среза: один фрагмент символа S[i] дает i й символ строки. Мы будем считать символы, начинающиеся с 0. То есть, если S = 'Hello' , S[0] == 'H' , S[1] == 'e' , S[2] == 'l' , S[3] == 'l' , S[4] == 'o' . Обратите внимание, что в Python для символов строки не существует отдельного типа. S[i] также имеет тип str , как и исходная строка.

Число i в S[i] называется индексом .

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

Подведем итог в таблице:

Если индекс в срезе S[i] больше или равен len(S) или меньше, чем -len(S) , следующая ошибка вызывает IndexError: string index out of range .

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

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

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

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

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

Давайте продемонстрируем, что:

None

s = 'Hello'
t = s  # s и t указывают на одну и ту же строку
t = s[2:4]  # теперь t указывает на новую строку 'll'
print(s)  # печатает «Hello», так как s не изменяется
print(t)  # отпечатки 'll'

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

None

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

Обратите внимание, как третий параметр среза похож на третий параметр range() функций range() :

None

s = 'abcdefghijklm'
print(s[0:10:2])
for i in range(0, 10, 2):
    print(i, s[i])

Метод — это функция, привязанная к объекту. Когда метод вызывается, метод применяется к объекту и выполняет некоторые вычисления, связанные с ним. Методы вызываются как object_name.method_name(arguments) . Например, в s.find("e") метод string find() применяется к строке s с одним аргументом "e" .

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

None

s = 'Hello'
print(s.find('e'))
# 1
print(s.find('ll'))
# 2
print(s.find('L'))
# -1

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

None

s = 'abracadabra'
print(s.find('b'))
# 1
print(s.rfind('b'))
# 8

Если вы вызываете find() с тремя аргументами s.find(substring, left, right) , поиск выполняется внутри среза s[left:right] . Если вы укажете только два аргумента, например s.find(substring, left) , поиск выполняется в срезе s[left:] , то есть начиная с символа с индексом left до конца строки. Метод s.find(substring, left, right) возвращает абсолютный индекс относительно всей строки s , а не срез.

None

s = 'my name is bond, james bond, okay?'
print(s.find('bond'))
# 11
print(s.find('bond', 12))
# 23

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

None

print('a bar is a bar, essentially'.replace('bar', 'pub'))
# «Паб - это паб, по сути,

Можно пройти третий count аргумента, например: s.replace(old, new, count) . Это делает replace() , чтобы заменить только первый count вхождений , а затем остановится.

None

print('a bar is a bar, essentially'.replace('bar', 'pub', 1))
# «Паб - это бар,

Этот метод подсчитывает количество вхождений одной строки в другую строку. Простейшая форма: s.count(substring) . Учитываются только неперекрывающиеся вхождения:

None

print('Abracadabra'.count('a'))
# 4
print(('aaaaaaaaaa').count('aa'))
# 5

Если вы укажете три параметра s.count(substring, left, right) , подсчет выполняется внутри среза s[left:right] .

str (строка) в Python

Строка — базовый тип представляющий из себя неизменяемую последовательность символов; str от «string» — «строка».

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

Начиная с +py3.0 имеется в виду последовательность кодовых точек Unicode (соответствует типу unicode в предыдущих версиях Python).

До -py3.0 последовательность представляла из себя строку байт (поддерживает ASCII).

Поскольку в языке нет типа для одиночного символа (character, char), то обращение к строке при помощи индекса: my_str[1] — возвращает новую строку с символом по этому индексу.

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

    # Одиночные кавычки. Часто встречаемый вариант записи.
my_str = 'а внутри "можно" поместить обычные'
# Кавычки.
my_str = "а внутри 'можно' поместить одиночные"
# Три одиночных кавычки. Удобно для записей в несколько строк
my_str = '''В трёх одиночных 
кавычках'''  
# Тройные кавычки. Общепринятый способ для строк документации.
my_str = """Three double quotes"""

Строковые литералы, содержащие промеж себя только пробел объединяются в единую строку:

    ('Кот' 'обус') == 'Котобус'

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

Другие типы могут быть приведены к строке при помощи конструктора str(): str(obj).

    str(10)  # '10'
str(len)  # '<built-in function len>'

Таким образом можно получить «неформальное» строковое представление объектов. Для пользовательских типов такое представление может быть определено в специализированном методе __str__.

В случае, если получить строковое представление не удалось, производится попытка получить «формальное» представление (см. repr).

Синонимы поиска: str (строка), строки, строковые методы, функции для строк, преобразование в строку, методы строк, char

Как преобразовать строку в функцию в python? Ru Python

Например, если у меня есть функция, называемая add like

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

Можно ли использовать w для ссылки на функцию add?

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

 dispatcher={'add':add} w='add' try: function=dispatcher[w] except KeyError: raise ValueError('invalid input') 

Если вы хотите оценить строки, такие как 'add(3,4)' , вы можете использовать безопасную оценку :

 eval('add(3,4)',{'__builtins__':None},dispatcher) 

eval в целом может быть опасным при применении к пользовательскому вводу. Вышеуказанное безопаснее, поскольку __builtins__ отключен, а locals ограничены dispatcher . Кто-то умнее, чем я мог бы по-прежнему создавать проблемы, но я не мог сказать вам, как это сделать.

ПРЕДУПРЕЖДЕНИЕ. Даже eval(..., {'__builtins__':None}, dispatcher) небезопасно для ввода пользователя. Злоумышленник может выполнять произвольные функции на вашем компьютере, если им предоставляется возможность оценить свою строку по eval .

Один безопасный способ – сопоставить имена от функций. Это безопаснее, чем использование eval .

 function_mappings = { 'add': add, } def select_function(): while True: try: return function_mappings[raw_input('Please input the function you want to use')] except KeyError: print 'Invalid function, try again.' 

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

Если существует конечное число предопределенных функций, вы должны избегать eval и вместо этого использовать таблицу поиска (т.е. Dict ). Никогда не доверяйте своим пользователям.

Решение unutbu – это то, что я обычно использовал, но для полноты:

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

 eval("add")(x,y) 

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

 #!/usr/bin/env python import cmd import shlex import sys class MyCmd(cmd.Cmd): def do_add(self, arguments): '''add - Adds two numbers the print the sum''' x, y = shlex.split(arguments) x, y = int(x), int(y) print x + y def do_quit(self, s): '''quit - quit the program''' sys.exit(0) if __name__ == '__main__': cmd = MyCmd() cmd.cmdloop('type help for a list of valid commands') 

Вот пример запуска сеанса:

$ python cmd_tryout.py
введите help для списка допустимых команд
(Cmd) добавить
add – добавляет два числа для печати суммы
(Cmd) добавить 5 3
8
(Cmd) выйти

В командной строке (Cmd) вы можете выпустить команду help которую вы получите бесплатно. Другие команды – add и quit которые соответствуют do_add() и do_quit() .

Обратите внимание, что команда help отображает docstring для вашей функции. Строка docstring является строкой, которая сразу же следует за декларацией функции (например, do_add() ).

Модуль cmd не выполняет разделение аргументов, разбор, поэтому вам нужно сделать это самостоятельно. Функция do_add() иллюстрирует это.

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

У меня было много ситуаций, когда мне нужно было сравнить строку с int и наоборот в шаблоне Django.

Я создал фильтр, который позволил мне передать имя функции и использовать eval () для его преобразования.

Пример:

Шаблон:

 {% ifequal string int|convert:'str' %} do something {% endifequal %} 

Template Filter (где я использую строку для вызова имени функции):

 @register.filter def convert(value, funcname): try: converted = eval(funcname)(value) return converted except: return value 

Python String format () — JournalDev

Python Функция String format () используется для создания форматированной строки из строки шаблона и предоставленных значений.

Python String format ()

Python String format () синтаксис функции:

 
str.format (* аргументы, ** kwargs)
  

• Строка шаблона может быть строковым литералом или содержать замещающие поля с использованием {} в качестве разделителя.
• Поле замены может быть числовым индексом предоставленных аргументов или они могут быть аргументами на основе ключевых слов.
• Если заменяемые поля не имеют индекса или значения ключевого слова, то они заменяются на основе индекса и в порядке, т.е. 0,1,…, n.
• Мы можем предоставить такие последовательности, как кортеж и список, в качестве аргумента для замены на основе индекса.
• Мы можем предоставить словарь в качестве аргумента для замены на основе ключевых слов.
• Аргумент функции форматирования также может быть объектом, мы можем получить доступ к его атрибутам, используя оператор точки для поля замены.
• Мы можем создать строку заданной длины с помощью функции format () с выравниванием строкового литерала вправо, влево или по центру.Мы также можем указать символ, который будет использоваться для заполнения, по умолчанию — пробел.
• Функция String format () предоставляет множество функций для форматирования чисел. Например, базовое преобразование из десятичного числа в восьмеричное, шестнадцатеричное и т. Д. Мы также можем выполнять проценты, заполнение и т. Д.
• Существуют быстрые способы вызова функций __str __ () и __repr __ () для аргумента с использованием ! S и ! R .

Python String format () Примеры

Давайте рассмотрим несколько примеров использования функции format ().

Простое форматирование на основе индекса

 
print ("Меня зовут {0}". format ("Панкадж"))

print ("Мне нравятся {0} и {1}". format ("Java", "Python"))
# то же, что и выше
print ("Мне нравятся {} и {}". format ("Java", "Python"))

# индекс может быть в любом порядке
print ("Мне нравятся {1} и {0}". format ("Java", "Python"))
  

Выход:

 
Меня зовут Панкадж
Мне нравится Java и Python
Мне нравится Java и Python
Мне нравятся Python и Java
  

Последовательности как аргумент format ()

 
# распаковка из последовательностей
t = ("Java", "Python")
print ("Мне нравятся {1} и {0}".формат (* t))

l = ["Java", "Python"]
print ("Мне нравятся {} и {}". format (* t))
  

Выход:

 
Мне нравятся Python и Java
Мне нравится Java и Python
  

Аргументы ключевого слова в формате ()

 
print ("{имя} - это {работа} {компании}". format (name = "Pankaj", job = "CEO", company = "JournalDev"))
  

Вывод: Панкай - генеральный директор JournalDev

Словарь как аргумент format ()

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

 
d = {"name": "Pankaj", "job": "CEO", "company": "JournalDev"}
print ("{company} {job} is {name}". format (** d))
  

Вывод: Генеральный директор JournalDev - Панкай

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

Мы можем передать объект в методе format () и использовать оператор точки для доступа к его атрибутам для замены поля.

 
Данные класса:
    id = 0
    имя = ''

    def __init __ (self, i, n):
        self. 30}".формат ("центр обработки данных выровнен")
"дата-центр согласован"

>>> "{: 30}". Format ("данные без выравнивания")
'данные без выравнивания'

>>> "{:  

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

Формат строки () с числами

Существует множество вариантов форматирования чисел, давайте рассмотрим некоторые из них.

Указание знака (+, -) для форматированной строки

 
print ('{: + f}; {: + f}'. format (1.23, -1.23))
print ('{: f}; {: f}'. format (1.23, -1.23))
print ('{: - f}; {: -f}'. format (1.23, -1.23))
  

Выход:

 
+1.230000; -1,230000
 1,230000; -1,230000
1,230000; -1,230000
  

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

Форматировать целые числа по разным основаниям

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

 
print ("int: {0: d}; hex: {0: x}; oct: {0: o}; bin: {0: b}". format (28))
print ("int: {0: d}; hex: {0: x}; oct: {0: o}; bin: {0: b}". format (0x1c))
print ("int: {0: d}; hex: {0: #x}; oct: {0: #o}; bin: {0: #b}". format (28))
  

Выход:

 
int: 28; шестнадцатеричный: 1c; октябрь: 34; корзина: 11100
int: 28; шестнадцатеричный: 1c; октябрь: 34; корзина: 11100
int: 28; шестнадцатеричный: 0x1c; окт: 0o34; корзина: 0b11100
  

формат () с комплексным числом

 
комплексное_число = 4 + 2j
print ("Настоящее: {0.real}, Imaginary: {0.imag} ". format (complex_number))
  

Вывод: Реальный: 4,0, Мнимый: 2,0

Это похоже на доступ к атрибутам объекта.

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

 
print ('{:,}'. формат (1234567890))
  

Вывод: 1,234,567,890

Процент, заполнение и округление

 
print ('Percentage: {: .3%}'. format (19/28))
print ('{0: 7.2f}'. format (2.344))
print ('{0: 10.2f}'. format (22222.346))
  

Выход:

 
Процент: 67,857%
   2.34
  22222,35
  

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

Вызов функций str () и repr ()

Мы можем легко вызвать функции str () и repr () для объекта, используя ! S и ! R соответственно.

 
print ("С кавычками: {0! r}, без кавычек: {0! s}".формат ("Данные"))


класс Test:

    def __str __ (сам):
        вернуть 'test str'

    def __repr __ (сам):
        вернуть 'test repr'


print ("Тестовое представление: {0! r}, Тестовое представление строки: {0! s}". format (Test ()))
  

Выход:

 
С кавычками: «Данные», без кавычек: данные
Представление теста: test repr, представление тестовой строки: test str
  

Резюме

Python Метод String format () очень эффективен при создании строки из различных типов источников ввода и применении правил форматирования.Это намного лучше, чем предыдущее форматирование на основе% и строки шаблонов. Однако, если вы используете Python 3.6+, вам также следует обратить внимание на форматирование f-строки (PEP 498 — Literal String Interpolation).

Ссылка: API Doc

Вы можете проверить полный сценарий Python и другие примеры Python в нашем репозитории GitHub.

Python String split — JournalDev

Python String split () функция используется для разделения строки на список строк на основе разделителя.

Python String split

Синтаксис функции Python string split ():

 
ул.split (sep = None, maxsplit = -1)
  

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

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

Если предоставляется maxsplit, выполняется не более maxsplit разбиений (таким образом, список будет содержать не более maxsplit + 1 элементов). Если maxsplit не указан или -1, то количество разделений не ограничено, и в списке возвращаются все возможные разделения.

Python String split (), пример

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

 
s = 'Python хорош'

# простой пример разделения строки
str_list = s.разделить (sep = '')
печать (str_list)
  

Выход:

 
['Python', 'is', 'Nice']
  

Разделение строки () с примером maxsplit

 
s = 'Python хорош'

str_list = s.split (sep = '', maxsplit = 1)
печать (str_list)
  

Вывод: ['Python', 'is Nice']

Обратите внимание, что возвращенный список содержит только 2 элемента, строка была разделена только один раз.

sep не предоставляется или отсутствует

 
s = 'Java Python iOS Android'
str_list = s.расколоть()
печать (str_list)
  

Вывод: ['Java', 'Python', 'iOS', 'Android']

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

Пример многострочного разделения струны

 
multiline_str = 'Привет \ nКак дела? \ nЯ в порядке'
multiline_str_split_list = multiline_str.split (sep = '\ n')
для s в multiline_str_split_list:
    печать (и)
  

Выход:

 
Всем привет
Как дела?
я в порядке
  

Пример многосимвольного разделителя

 
s = 'Привет || Привет || Прощай'
str_list = s.сплит ('||')
печать (str_list)
  

Вывод: ['Hi', 'Hello', 'Adios']

Пример функции str.split ()

Мы также можем использовать функцию split () непосредственно из класса str.

 
print (str.split ('ABACAD', sep = 'A'))
print (str.split ('ABACAD', sep = 'A', maxsplit = 2))
  

Выход:

 
['', 'B', 'C', 'D']
['', 'B', 'CAD']
  

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

Пример разделения строки CSV с вводом пользователем

Наконец, давайте посмотрим на реальный пример, где пользователь вводит данные CSV, а мы разделим их на список строк.

 
input_csv = input ('Пожалуйста, введите данные CSV \ n')
input_csv_split_list = input_csv.split (sep = ',')
print ('Длина входных данных =', len (input_csv_split_list))
print ('Список входов =', input_csv_split_list)
  

Выход:

 
Пожалуйста, введите данные CSV
Java, Android, Python, iOS, jQuery
Длина входных данных = 5
Список входов = ['Java', 'Android', 'Python', 'iOS', 'jQuery']
  

Вот и все, что касается примеров функции split () строки Python.Это очень полезная функция для разделения строки в список на основе некоторого разделителя.

Python String rsplit ()

Python String Функция rsplit () очень похожа на функцию split (). Единственная разница в том, что разделение выполняется, начиная с конца струны и двигаясь вперед.

Давайте посмотрим на некоторые примеры функции rsplit ().

 
# пример rsplit ()
s = 'Python - это круто'
str_list = s.rsplit (sep = '')
печать (str_list)

str_list = s.rsplit (sep = '', maxsplit = 1)
печать (str_list)

s = 'Java Python iOS Android'
str_list = s.rsplit ()
печать (str_list)

multiline_str = 'Привет \ nКак дела? \ nЯ в порядке'
multiline_str_split_list = multiline_str.rsplit (sep = '\ n')
для s в multiline_str_split_list:
    печать (и)

s = 'Привет || Привет || Прощай'
str_list = s.rsplit ('||')
печать (str_list)

# использование split () с классом str
печать (str.rsplit ('ABACAD', sep = 'A'))
print (str.rsplit ('ABACAD', sep = 'A', maxsplit = 2))

# csv и пример пользовательского ввода
input_csv = input ('Пожалуйста, введите данные CSV \ n')
input_csv_split_list = input_csv.rsplit (сеп = ',')
print ('Длина входных данных =', len (input_csv_split_list))
print ('Список входов =', input_csv_split_list)
  

Выход:

 
['Python', 'is', 'Awesome']
['Python is', 'Awesome']
[Java, Python, iOS, Android]
Всем привет
Как дела?
я в порядке
[«Привет», «Привет», «Прощай»]
['', 'B', 'C', 'D']
["AB", "C", "D"]
Пожалуйста, введите данные CSV
х, у, г
Длина входных данных = 3
Список входов = ['x', 'y', 'z']
  

Обратите внимание, что разница видна, если указан аргумент maxsplit.В противном случае вывод функций split () и rsplit () будет таким же.

Вы можете получить полный скрипт Python и другие примеры Python в нашем репозитории GitHub.

Ссылка: API Doc

Python Strings (с примерами)

Что такое строка в Python?

Строка — это последовательность символов.

Символ — это просто символ. Например, в английском языке 26 символов.

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

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

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

Как создать строку в Python?

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

  # определение строк в Python
# все следующее эквивалентно
my_string = 'Привет'
печать (моя_строка)

my_string = "Привет"
печать (моя_строка)

my_string = '' 'Привет' ''
печать (моя_строка)

# строка тройных кавычек может занимать несколько строк
my_string = "" "Привет, добро пожаловать в
           мир Python "" "
печать (my_string)  

Когда вы запустите программу, вывод будет:

  Привет
Привет
Привет
Привет добро пожаловать в
           мир Python  

Как получить доступ к символам в строке?

Мы можем получить доступ к отдельным символам с помощью индексации и к диапазону символов с помощью нарезки.Индекс начинается с 0. Попытка получить доступ к символу вне диапазона индекса вызовет IndexError . Индекс должен быть целым числом. Мы не можем использовать числа с плавающей запятой или другие типы, это приведет к TypeError .

Python допускает отрицательную индексацию своих последовательностей.

Индекс -1 относится к последнему элементу, -2 — ко второму последнему элементу и так далее. Мы можем получить доступ к диапазону элементов в строке с помощью оператора среза : (двоеточие).

  # Доступ к строковым символам в Python
str = 'programiz'
печать ('стр =', стр)

# первый персонаж
print ('str [0] =', str [0])

# последний персонаж
print ('str [-1] =', str [-1])

# нарезка со 2-го по 5-й символ
print ('str [1: 5] =', str [1: 5])

# нарезка с 6-го на 2-й последний символ
print ('str [5: -2] =', str [5: -2])  

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

  str = programiz
str [0] = p
str [-1] = z
str [1: 5] = rogr
str [5: -2] = am  

Если мы попытаемся получить доступ к индексу вне диапазона или использовать числа, отличные от целого, мы получим ошибки.

  # индекс должен быть в диапазоне
>>> my_string [15]
...
IndexError: индекс строки вне допустимого диапазона

# индекс должен быть целым числом
>>> my_string [1.5]
...
TypeError: строковые индексы должны быть целыми числами  

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

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

Нарезка строки в Python

Как изменить или удалить строку?

Строки неизменяемы.Это означает, что элементы строки не могут быть изменены после того, как они были назначены. Мы можем просто переназначить разные строки одному и тому же имени.

  >>> my_string = 'programiz'
>>> my_string [5] = 'а'
...
TypeError: объект 'str' не поддерживает назначение элементов
>>> my_string = 'Python'
>>> my_string
'Python'  

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

  >>> del my_string [1]
...
TypeError: объект 'str' не поддерживает удаление элемента
>>> del my_string
>>> my_string
...
NameError: имя my_string не определено  

Операции со строками Python

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

Чтобы узнать больше о типах данных, доступных в Python, посетите: Типы данных Python

Конкатенация двух или более строк

Объединение двух или более строк в одну называется конкатенацией.

Оператор + делает это в Python. Простое объединение двух строковых литералов также объединяет их.

Оператор * может использоваться для повторения строки заданное количество раз.

  # Операции со строками Python
str1 = 'Привет'
str2 = 'Мир!'

# используя +
print ('str1 + str2 =', str1 + str2)

# с использованием *
print ('str1 * 3 =', str1 * 3)  

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

  str1 + str2 = HelloWorld!
str1 * 3 = Привет, привет, привет,  

Запись двух строковых литералов вместе также объединяет их, как оператор + .

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

  >>> # два строковых литерала вместе
>>> 'Привет, мир!'
'Привет мир!'

>>> # используя круглые скобки
>>> s = ('Привет'
...      'Мир')
>>> с
«Привет, мир»  

Итерация по строке

Мы можем перебирать строку, используя цикл for. Вот пример подсчета количества «l» в строке.

  # Итерация по строке
count = 0
для письма в "Hello World":
    если (буква == 'l'):
        count + = 1
print (count, 'буквы найдены')  

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

  Найдено 3 буквы  

Тест на членство в строке

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

  >>> 'а' в 'программу'
Истинный
>>> 'в' не в 'битве'
Ложь  

Встроенные функции для работы с Python

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

Среди наиболее часто используемых — enumerate () и len () . Функция enumerate () возвращает объект перечисления. Он содержит индекс и значение всех элементов в строке в виде пар.Это может быть полезно для повторения.

Аналогично len () возвращает длину (количество символов) строки.

  str = 'холодный'

# перечислить ()
list_enumerate = список (перечислить (str))
print ('список (перечислить (str) =', перечислить_список)

# количество символов
print ('len (str) =', len (str))  

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

  list (enumerate (str) = [(0, 'c'), (1, 'o'), (2, 'l'), (3, 'd')]
len (str) = 4  

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

Последовательность побега

Если мы хотим напечатать такой текст, как Он сказал: «Что там?» , мы не можем использовать ни одинарные, ни двойные кавычки.Это приведет к SyntaxError , поскольку сам текст содержит как одинарные, так и двойные кавычки.

  >>> print («Он сказал:« Что там? »»)
...
SyntaxError: недопустимый синтаксис
>>> print ('Он сказал: «Что там?»)
...
SyntaxError: недопустимый синтаксис  

Один из способов обойти эту проблему — использовать тройные кавычки. В качестве альтернативы мы можем использовать escape-последовательности.

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

  # использование тройных кавычек
print ('' 'Он сказал: "Что там?"' '')

# экранирование одинарных кавычек
print ('Он сказал: «Что там?»)

# экранирование двойных кавычек
print ("Он сказал: \" Что там? \ "")  

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

  Он сказал: "Что там?"
Он сказал: "Что там?"
Он сказал: "Что там?"  

Вот список всех escape-последовательностей, поддерживаемых Python.

Колокол

Вот несколько примеров

  >>> print ("C: \\ Python32 \\ Lib")
C: \ Python32 \ Lib

>>> print ("Это напечатано в две строчки")
Это напечатано
в две строки

>>> print ("Это представление \ x48 \ x45 \ x58")
Это шестнадцатеричное представление  

Необработанная строка для игнорирования escape-последовательности

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

  >>> print ("Хороший пример \ x61 \ n")
Это
хороший пример
>>> print (r "Это \ x61 \ nХороший пример")
Это \ x61 \ nхороший пример  

Метод форматирования строк format ()

Метод format () , доступный для строкового объекта, очень универсален и эффективен при форматировании строк.Строки формата содержат фигурные скобки {} в качестве заполнителей или заменяемых полей, которые подлежат замене.

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

  # Метод Python String format ()

# порядок по умолчанию (неявный)
default_order = "{}, {} и {}". format ('Джон', 'Билл', 'Шон')
print ('\ n --- Порядок по умолчанию ---')
печать (default_order)

# порядок с использованием позиционного аргумента
positional_order = "{1}, {0} и {2}".  строку в заданном пространстве.


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

 
  >>> # форматирование целых чисел
>>> "Двоичное представление {0} - {0: b}". Format (12)
'Двоичное представление 12 равно 1100'

>>> # форматирование поплавков
>>> "Экспонентное представление: {0: e}".10} | {:> 10} | ".format ('масло', 'хлеб', 'ветчина')
'| масло | хлеб | ветчина | '  
 Форматирование в старом стиле 
 Мы можем даже форматировать строки, как в старом стиле  sprintf () , который использовался в языке программирования C. Для этого мы используем оператор % .
  >>> х = 12,3456789
>>> print ('Значение x равно% 3.2f'% x)
Значение x равно 12,35.
>>> print ('Значение x равно% 3.4f'% x)
Значение x равно 12.3457  
 Общие строковые методы Python 
 Для строкового объекта доступно множество методов. Упомянутый выше метод  format ()  является одним из них. Некоторые из наиболее часто используемых методов:  lower () ,  upper () ,  join () ,  split () ,  find () ,  replace ()  и т. Д. Вот полный список все встроенные методы для работы со строками в Python.
  >>> "ПрОгРаМиЗ".ниже()
'programiz'
>>> "PrOgRaMiZ" .upper ()
'ПРОГРАММИРОВАТЬ'
>>> «Это разделит все слова на список» .split ()
['This', 'will', 'split', 'all', 'words', 'into', 'a', 'list']
>>> '' .join (['This', 'will', 'join', 'all', 'words', 'into', 'a', 'string'])
'Это объединит все слова в строку'
>>> 'С Новым годом'. Найти ('фу')
7
>>> 'С Новым годом'. Заменить ('Happy', 'Brilliant')
'Блестящий Новый год'  
 строка - Стандартные строковые операции - Python 3.9.6 документация 
 Строковые константы 
 В этом модуле определены следующие константы:
  строка.   ascii_letters 
 Объединение  ascii_lowercase  и  ascii_uppercase 
 константы, описанные ниже. Это значение не зависит от языкового стандарта.
  строка.   ascii_lowercase 
 Строчные буквы  'abcdefghijklmnopqrstuvwxyz' .Это значение не
 зависит от локали и не изменится.
  строка.   ascii_uppercase 
 Заглавные буквы  'ABCDEFGHIJKLMNOPQRSTUVWXYZ' . Это значение не
 зависит от локали и не изменится.
  строка.   цифр 
 Строка  '0123456789' .
  строка.   шестнадцатеричные цифры 
 Строка  '0123456789abcdefABCDEF' ._` {|} ~ .
  строка.   для печати 
 Строка символов ASCII, которые считаются печатаемыми. Это
 комбинация  цифр ,  ascii_letters ,  знаков препинания ,
 и  пробел .
  строка.   пробел 
 Строка, содержащая все символы ASCII, которые считаются пробелами.
 Сюда входят пробел, табуляция, перевод строки, возврат, перевод страницы и
 вертикальная табуляция.
 Пользовательское форматирование строки 
 Встроенный строковый класс предоставляет возможность выполнять сложные переменные.
 замены и форматирование значений с помощью метода  format () , описанного в
  ПЕР 3101 . Класс  Formatter  в модуле  string  позволяет
 вы можете создавать и настраивать свои собственные способы форматирования строк, используя те же
 реализация как встроенный метод  format () .
  класс   строка.  Форматтер 
 Класс  Formatter  имеет следующие общедоступные методы:
  формат  ( format_string , /,  * args ,  ** kwargs )
 Основной метод API. Требуется строка формата и
 произвольный набор позиционных и ключевых аргументов.
 Это просто оболочка, которая вызывает  vformat () .
  vformat  ( format_string ,  args ,  kwargs )
 Эта функция выполняет собственно работу по форматированию.Он выставлен как
 отдельная функция для случаев, когда вы хотите передать предопределенный
 словарь аргументов, а не распаковывать и переупаковывать
 словарь как отдельные аргументы с использованием  * args  и  ** kwargs 
 синтаксис.  vformat ()  выполняет работу по разбиению строки формата
 в символьные данные и поля замены. Он вызывает различные
 методы, описанные ниже.
 Кроме того,  Formatter  определяет ряд методов, которые
 предполагается заменить подклассами:
  синтаксический анализ  ( format_string )
 Перебирать строку format_string и возвращать итерацию кортежей
 ( literal_text ,  field_name ,  format_spec ,  преобразование ).Это используется
 на  vformat () , чтобы разбить строку на буквальный текст или
 поля замены.
 Значения в кортеже концептуально представляют собой диапазон буквального текста.
 за которым следует одно поле замены. Если нет буквального текста
 (что может произойти, если два поля замены встречаются последовательно), тогда
  literal_text  будет строкой нулевой длины. Если нет замены
 field, затем значения  field_name ,  format_spec  и  преобразование 
 будет  Нет .
  get_field  ( имя_поля ,  args ,  kwargs )
 Учитывая  field_name , возвращенное функцией  parse ()  (см. Выше), преобразуйте его в
 форматируемый объект. Возвращает кортеж (obj, used_key). По умолчанию
 версия принимает строки формы, определенной в  PEP 3101 , например
 «0 [имя]» или «label.title».  args  и  kwargs  переданы в
  вформат () .Возвращаемое значение  used_key  имеет то же значение, что и
  ключ  параметр для  get_value () .
  get_value  ( ключ ,  args ,  kwargs )
 Получить значение заданного поля. Аргумент ключа   будет либо
 целое число или строка. Если это целое число, оно представляет собой индекс
 позиционный аргумент в  args ; если это строка, то она представляет собой
 названный аргумент в  kwargs .
 Параметр  args  установлен в список позиционных аргументов для
  vformat () , а параметр  kwargs  установлен в словарь
 аргументы ключевого слова.
 Для составных имен полей эти функции вызываются только для первого
 компонент имени поля; последующие компоненты обрабатываются через
 обычные операции с атрибутами и индексацией.
 Так, например, выражение поля "0.name" вызовет
  get_value () , который будет вызываться с ключом , аргумент  равен 0.Название  
 атрибут будет найден после того, как  get_value ()  вернется путем вызова
 встроенная функция  getattr () .
 Если индекс или ключевое слово относятся к несуществующему элементу, то
  IndexError  или  KeyError  должны быть вызваны.
  check_unused_args  ( used_args ,  args ,  kwargs )
 При необходимости выполните проверку неиспользуемых аргументов.Аргументы в пользу этого
 функция - это набор всех ключей аргументов, которые фактически упоминались в
 строка формата (целые числа для позиционных аргументов и строки для
 именованные аргументы), а также ссылку на  args  и  kwargs , которые были
 перешел на вформат. Набор неиспользуемых аргументов может быть вычислен из этих
 параметры.  check_unused_args () Предполагается, что  вызовет исключение, если
 проверка не удалась.
  поле_форматирования  (значение  ,  спецификация_форматирования )
  format_field ()  просто вызывает встроенный глобальный  format () .В
 предоставляется так, чтобы подклассы могли его переопределить.
  convert_field  ( значение ,  преобразование )
 Преобразует значение (возвращаемое функцией  get_field () ) с учетом типа преобразования.
 (как в кортеже, возвращаемом методом  parse () ). По умолчанию
 версия понимает "s" (str), "r" (repr) и "a" (ascii) преобразование
 типы.
 Синтаксис строки формата 
  ул.format () метод  и класс  Formatter  используют одно и то же
 синтаксис для форматных строк (хотя в случае  Formatter ,
 подклассы могут определять свой собственный синтаксис строки формата). Синтаксис:
 связан с форматированными строковыми литералами, но это
 менее сложен и, в частности, не поддерживает произвольные выражения.
 Строки формата содержат «замещающие поля», заключенные в фигурные скобки  {} .
 Все, что не заключено в фигурные скобки, считается буквальным текстом, т.е.
 скопировано без изменений на вывод.Если вам нужно включить фигурную скобку в
 буквальный текст, его можно экранировать удвоением:  {{ и }} .
 Грамматика заменяемого поля выглядит следующим образом:
 Выражаясь менее формально, поле замены может начинаться с  field_name , которое указывает
 объект, значение которого должно быть отформатировано и вставлено
 в вывод вместо поля замены.
 После  field_name , необязательно, следует поле  преобразования , которое
 перед ним стоит восклицательный знак  '!'  и  format_spec , которому предшествует
 двоеточием  ':' .Они определяют нестандартный формат для значения замены.
 См. Также раздел «Мини-язык спецификации формата».
  имя_поля  само начинается с  имя_аргумента , которое является либо числом, либо
 ключевое слово. Если это число, это относится к позиционному аргументу, а если это ключевое слово,
 он ссылается на именованный аргумент ключевого слова. Если числовые arg_names в строке формата
 0, 1, 2,… по порядку, все они могут быть опущены (а не только некоторые)
 и числа 0, 1, 2,… будут автоматически вставлены в этом порядке.Поскольку  arg_name  не разделен кавычками, невозможно указать произвольный
 ключи словаря (например, строки  '10'  или  ': -]' ) в строке формата.
  arg_name  может сопровождаться любым числом индекса или
 выражения атрибутов. Выражение формы  '.name'  выбирает названный
 атрибут с использованием  getattr () , а выражение вида  '[index]' 
 выполняет поиск по индексу с использованием  __getitem __ () .
 Изменено в версии 3.1: спецификаторы позиционных аргументов могут быть опущены для  str.format () ,
 поэтому  '{} {}'. format (a, b)  эквивалентно  '{0} {1}'. format (a, b) .
 Изменено в версии 3.4: спецификаторы позиционных аргументов могут быть опущены для  Formatter .
 Некоторые примеры простых форматных строк:
 "Сначала посчитай до {0}" # Ссылается на первый позиционный аргумент
"Bring me a {}" # Неявно ссылается на первый позиционный аргумент
"От {} до {}" # То же, что и "От {0} до {1}"
"My quest is {name}" # Ссылается на аргумент ключевого слова 'name'
"Вес в тоннах {0.weight} "# атрибут 'weight' первого позиционного аргумента
"Юниты уничтожены: {player [0]}" # Первый элемент аргумента ключевого слова 'игроки'.
 
 Поле  преобразования  вызывает приведение типа перед форматированием. Обычно
 задание форматирования значения выполняется методом  __format __ ()  значения
 сам. Однако в некоторых случаях желательно принудительно отформатировать тип.
 как строку, переопределяя собственное определение форматирования. Преобразуя
 значение в строку перед вызовом  __format __ () , нормальная логика форматирования
 обходится.
 В настоящее время поддерживаются три флага преобразования:  '! S' , который вызывает  str () 
 по значению  '! r' , который вызывает  repr ()  и  '! a' , который вызывает
  ascii () .
 Некоторые примеры:
 "Гарольд умный {0! S}" # Сначала вызывает str () для аргумента
"Вывести святое {имя! R}" # Сначала вызывает repr () для аргумента
"More {! A}" # Сначала вызывает ascii () для аргумента
 
 Поле  format_spec  содержит спецификацию того, каким должно быть значение.
 представлены, включая такие детали, как ширина поля, выравнивание, заполнение, десятичная дробь
 точность и так далее.Каждый тип значения может определять свое собственное «форматирование.
 мини-язык »или интерпретация  format_spec .
 Большинство встроенных типов поддерживают общий мини-язык форматирования, который
 описано в следующем разделе.
 Поле  format_spec  может также включать в себя вложенные поля замены.
 Эти вложенные поля замены могут содержать имя поля, флаг преобразования.
 и спецификация формата, но более глубокая вложенность
 не положено. Поля замены в
 format_spec подставляются перед интерпретацией строки  format_spec .Это позволяет динамически указывать форматирование значения.
 См. Некоторые примеры в разделе «Примеры форматов».
 Спецификация формата Мини-язык 
 «Спецификации формата» используются в полях замены, содержащихся в
 строка формата для определения того, как представлены отдельные значения (см.
 Синтаксис форматной строки и форматированные строковые литералы).
 Их также можно передать напрямую во встроенный
  формат ()  функция. Каждый тип таблицы форматирования может определять, как формат
 Спецификация подлежит интерпретации.
 Большинство встроенных типов реализуют следующие параметры спецификаций формата:
 хотя некоторые параметры форматирования поддерживаются только числовыми типами.
 Общее соглашение заключается в том, что спецификация пустого формата производит
 тот же результат, как если бы вы вызвали  str ()  для значения. А
 Спецификация непустого формата обычно изменяет результат.
 Общая форма спецификатора стандартного формата  :
  format_spec  :: = [[ fill ]  align ] [ sign ] [#] [0] [ width ] [ grouping_option ] [."
  знак  :: = "+" | "-" | ""
  ширина  :: =  цифр  +
  опция_группировки  :: = "_" | ","
  точность  :: =  цифр  +
  тип  :: = "b" | "с" | "д" | "е" | "E" | "е" | "F" | "г" | "G" | "п" | "о" | "s" | «х» | «Х» | "%"
 
 Если указано действительное значение  align , ему может предшествовать заливка  
 символ, который может быть любым символом; если он опущен, по умолчанию используется пробел.Невозможно использовать буквальную фигурную скобку (« {» или «} ») в качестве
  заполняет символ  в форматированном строковом литерале или при использовании  str.format () 
 метод. Однако можно вставить фигурную скобку.
 с вложенным полем замены. Это ограничение не
 влияет на функцию  format () .
 Значение различных вариантов выравнивания следующее:
 Опция
 Значение
  '<
 Принудительное выравнивание поля по левому краю в пределах доступного
 пробел (это значение по умолчанию для большинства объектов).
  '>' 
 Принудительное выравнивание поля по правому краю в пределах
 доступное пространство (это значение по умолчанию для чисел).
  '=' 
 Принудительно помещает отступы после знака (если есть)
 но до цифр. Используется для печати полей
 в виде «+000000120». Этот вариант выравнивания только
 действительно для числовых типов. Он становится значением по умолчанию, когда «0»
 непосредственно перед шириной поля.'
 Принудительно центрирует поле в пределах доступного
 пространство.
 Обратите внимание, что если минимальная ширина поля не определена, ширина поля всегда будет
 быть того же размера, что и данные для его заполнения, поэтому параметр выравнивания не имеет
 смысл в данном случае.
 Знак  Параметр  действителен только для числовых типов и может быть одним из
 следующий:
 Опция
 Значение
  '+ 
 указывает, что знак должен использоваться для обоих
 положительные и отрицательные числа.
  '-' 
 указывает, что знак следует использовать только для отрицательных
 числа (это поведение по умолчанию).
 место
 указывает, что на
 положительные числа и знак минус на отрицательных числах.
 Параметр  '#'  вызывает использование «альтернативной формы» для
 конверсия.Альтернативная форма определяется по-разному для разных
 типы. Эта опция действительна только для целых чисел, чисел с плавающей запятой и сложных
 типы. Для целых чисел при двоичном, восьмеричном или шестнадцатеричном выводе
 используется, эта опция добавляет соответствующий префикс  '0b' ,  '0o' ,
  '0x'  или  '0X'  к выходному значению. Для плавающих и сложных
 альтернативная форма приводит к тому, что результат преобразования всегда содержит
 десятичный знак, даже если за ним нет цифр. Обычно
 в результате этих преобразований появляется десятичный знак.
 только если за ним следует цифра.Кроме того, для  'g'  и  'G' 
 преобразования, конечные нули не удаляются из результата.
 Опция  ','  сигнализирует об использовании запятой для разделителя тысяч.
 Для разделителя с учетом языкового стандарта используйте целочисленный тип представления  'n' .
 вместо.
 Изменено в версии 3.1: добавлены опции  ','  (см. Также  PEP 378 ).
 Опция  '_'  сигнализирует об использовании символа подчеркивания для тысяч
 разделитель для типов представления с плавающей запятой и для целых чисел
 тип презентации  'd' .Для целочисленных типов представления  'b' ,
  'o' ,  'x'  и  'X' , подчеркивания будут вставляться каждые 4
 цифры. Для других типов презентаций указание этой опции является
 ошибка.
 Изменено в версии 3.6: Добавлен параметр  '_'  (см. Также  PEP 515 ).
  ширина  - десятичное целое число, определяющее минимальную общую ширину поля,
 включая любые префиксы, разделители и другие символы форматирования.
 Если не указан, то ширина поля будет определяться содержимым.
 Если не указано явное выравнивание, перед полем шириной   стоит ноль
 ( '0' ) символ включает
 знаковое заполнение нулями для числовых типов. Это эквивалентно  заливке 
 символ  '0'  с выравниванием  Тип   '=' .
 Точность   - десятичное число, указывающее, сколько цифр должно быть
 отображается после десятичной точки для значения с плавающей запятой, отформатированного с помощью
  'f'  и  'F'  или до и после десятичной точки для чисел с плавающей запятой
 значение, отформатированное как  'g'  или  'G' .Для нечисловых типов поле
 указывает максимальный размер поля - другими словами, сколько символов будет
 используется из содержимого поля. Точность   недопустима для целочисленных значений.
 Наконец, тип   определяет, как данные должны быть представлены.
 Доступные типы представления строк:
 Тип
 Значение
  's' 
 Строковый формат.Это тип по умолчанию для строк и
 может быть опущено.
 Нет
 То же, что и  .
 Доступные целочисленные типы представления:
 Тип
 Значение
  'b' 
 Двоичный формат. Выводит число по основанию 2.
  'c' 
 Персонаж. Преобразует целое число в соответствующее
 символ юникода перед печатью.
  'd' 
 Целое десятичное число. Выводит число по основанию 10.
  'или 
 Восьмеричный формат. Выводит число по основанию 8.
  'x' 
 Шестнадцатеричный формат.Выводит число по основанию 16, используя
 строчные буквы для цифр выше 9.
  'X' 
 Шестнадцатеричный формат. Выводит число по основанию 16, используя
 заглавные буквы для цифр выше 9.
 Если указано  '#' , префикс  '0x'  будет
 также быть в верхнем регистре  '0X' .
  'n' 
 Номер. Это то же самое, что и  'd' , за исключением того, что в нем используется
 текущий параметр локали, чтобы вставить соответствующий
 числовые разделители символов.
 Нет
 То же, что  d .
 В дополнение к указанным выше типам представления целые числа могут быть отформатированы.
 с типами представления с плавающей запятой, перечисленными ниже (кроме
  'n'  и  Нет ). При этом  float ()  используется для преобразования
 целое число в число с плавающей запятой перед форматированием.
 Доступные типы представления для  float  и
  Десятичные значения :
 Тип
 Значение
  'e' 
 Научное обозначение.Для заданной точности  p ,
 форматирует число в экспоненциальном представлении с
 буква «е», отделяющая коэффициент от экспоненты.
 Перед коэффициентом одна цифра и  p  цифр.
 после десятичной точки, всего  p + 1 
 значащие цифры. Без указания точности использует
 точность  6  цифр после десятичной точки для
  с плавающей запятой , и показывает все цифры коэффициента
 для  Десятичное . Если после цифр нет
 десятичная точка, десятичная точка также удаляется, если
 используется опция  # .
  'E' 
 Научное обозначение. То же, что и  'e' , за исключением того, что в нем используется
 верхний регистр "E" в качестве символа-разделителя.
  'f' 
 Обозначение с фиксированной точкой. Для заданной точности  p ,
 форматирует число как десятичное с точностью
  p  цифр после десятичной точки. Без
 заданная точность, используется точность  6  цифр после
 десятичная точка для  с плавающей запятой  и использует
 достаточно большая точность, чтобы отображать все цифры коэффициента
 для  Десятичное .Если после цифр нет
 десятичная точка, десятичная точка также удаляется, если
 используется опция  # .
  'F' 
 Обозначение с фиксированной точкой. То же, что  'f' , но преобразует
  нан  до  NAN  и  инф  до  INF .
  'г' 
 Общий формат. Для заданной точности  p> = 1 ,
 это округляет число до  p  значащих цифр и
 затем форматирует результат в формате с фиксированной точкой
 или в научном обозначении, в зависимости от его величины.Точность  0  рассматривается как эквивалент
 точность  1 .
 Точные правила таковы: предположим, что
 результат отформатирован с типом представления  'e'  и
 точность  p-1  будет иметь показатель степени  exp . Затем,
 если  м <= exp
, где  м  - -4 для поплавков и -6
 для  десятичных знаков  это число
 отформатирован с типом представления  'f'  и точностью
  п-1-ехр .В противном случае число форматируется
 с типом представления  'e'  и точностью  p-1 .
 В обоих случаях убираются незначащие нули в конце.
 из мантиссы, и десятичная точка также
 удаляется, если после него нет оставшихся цифр,
 если не используется опция  '#' .
 Если точность не указана, используется точность  6 
 значащие цифры для  с плавающей запятой . Для
  Десятичное , коэффициент результата
 формируется из разряда коэффициента значения;
 научная запись используется для значений меньше, чем
  1e-6  по абсолютной величине и значениям, где место
 значение младшего разряда больше 1,
 в противном случае используется запись с фиксированной точкой.
 Положительная и отрицательная бесконечность, положительная и отрицательная
 ноль и nans форматируются как  inf ,  -inf ,
  0 , -0  и  нан  соответственно, независимо от
 точность.
  'G' 
 Общий формат. То же, что и  'g' , за исключением переключения на
  'E' , если число становится слишком большим. В
 представления бесконечности и NaN также в верхнем регистре.
  'n' 
 Номер.Это то же самое, что и  'g' , за исключением того, что в нем используется
 текущий параметр локали, чтобы вставить соответствующий
 числовые разделители символов.
  '%' 
 Процент. Умножает число на 100 и отображает
 в фиксированном формате ( 'f' ), за которым следует знак процента.
 Нет
 Для  с плавающей запятой  это то же самое, что и  'g' , за исключением
 что когда используется запись с фиксированной точкой для форматирования
 результат, он всегда включает как минимум одну цифру после
 десятичная точка.Используемая точность настолько велика, насколько это необходимо
 верно представлять данное значение.
 Для  Decimal  это то же самое, что
 либо  'g' , либо  'G'  в зависимости от значения
  context.capitals  для текущего десятичного контекста.
 Общий эффект должен соответствовать выходу  str () 
 как изменено другими модификаторами формата.
 Примеры формата 
 В этом разделе собраны примеры  ул.format ()  синтаксис и
 сравнение со старым %  -форматирование.
 В большинстве случаев синтаксис аналогичен старому форматированию % , с
 добавление  {}  и :  вместо % .
 Например,  '% 03.2f'  можно преобразовать в  '{: 03.2f}' .
 Новый синтаксис формата также поддерживает новые и различные параметры, показанные в
 следующие примеры.
 Доступ к аргументам по позиции:
 >>> '{0}, {1}, {2}'.формат ('a', 'b', 'c')
'а, б, в'
>>> '{}, {}, {}'. format ('a', 'b', 'c') только # 3.1+
'а, б, в'
>>> '{2}, {1}, {0}'. Format ('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'. Format (* 'abc') # распаковка последовательности аргументов
'c, b, a'
>>> '{0} {1} {0}'. Format ('abra', 'cad') # arguments 'индексы могут повторяться
'абракадабра'
 
 Доступ к аргументам по имени:
 >>> 'Координаты: {широта}, {долгота}'. Формат (широта = '37 .24N ', долгота =' - 115.81 Вт ')
'Координаты: 37.24N, -115.81W'.
>>> Coord = {'latitude': '37 .24N ',' longitude ':' -115.81W '}
>>> 'Координаты: {широта}, {долгота}'. Формат (** координаты)
'Координаты: 37.24N, -115.81W'.
 
 Атрибуты аргументов доступа:
 >>> c = 3-5j
>>> ('Комплексное число {0} образовано из действительной части {0.real}'
... 'и мнимая часть {0.imag}.'). формат (c)
Комплексное число (3-5j) состоит из действительной части 3,0 и мнимой части -5.0. '
>>> Класс Point:
... def __init __ (self, x, y):
... self.x, self.y = x, y
... def __str __ (сам):
... вернуть 'Point ({self.x}, {self.y})'. format (self = self)
...
>>> str (Точка (4, 2))
'Точка (4, 2)'
 
 Доступ к элементам аргументов:
 >>> координата = (3, 5)
>>> 'X: {0 [0]}; Y: {0 [1]} '. Формат (координаты)
'X: 3; Y: 5 '
 
 Замена % s  и % r :
 >>> "repr () показывает кавычки: {! R}; str () не показывает: {! S}".30} '. Format (' center ') # используйте' * 'в качестве символа заполнения
'*********** по центру ***********'
 
 Замена % + f , % -f  и % f  и указание знака:
 >>> '{: + f}; {: + f} '. format (3.14, -3.14) # показывать всегда
'+3.140000; -3,140000 '
>>> '{: f}; {: f} '. format (3.14, -3.14) # показать пробел для положительных чисел
'3.140000; -3,140000 '
>>> '{: -f}; {: -f} '. format (3.14, -3.14) # показывать только минус - то же, что и' {: f}; {: f} '
'3.140000; -3,140000 '
 
 Замена % x  и % на  и преобразование значения в другое основание:
 >>> # формат также поддерживает двоичные числа
>>> "int: {0: d}; hex: {0: x}; oct: {0: o}; bin: {0: b}".>', ['left', 'center', 'right']):
.'
'>>>>>>>>>>> правильно'
>>>
>>> октеты = [192, 168, 0, 1]
>>> '{: 02X} {: 02X} {: 02X} {: 02X}'. Формат (* октеты)
'C0A80001'
>>> интервал (_, 16)
3232235521
>>>
>>> ширина = 5
>>> для числа в диапазоне (5,12):
... для базы в 'dXob':
... print ('{0: {width} {base}}'. format (num, base = base, width = width), end = '')
...     Распечатать()
...
    5 5 5 101
    6 6 6 110
    7 7 7 111
    8 8 10 1000
    9 9 11 1001
   10 А 12 1010
   11 В 13 1011
 
 Строки шаблона 
 Строки шаблона обеспечивают более простые замены строк, как описано в
  ПАП 292 .Основной вариант использования строк шаблона -
 интернационализация (i18n), поскольку в этом контексте более простой синтаксис и
 функциональность упрощает перевод, чем другие встроенные строки
 средства форматирования в Python. Как пример библиотеки, построенной по шаблону
 строки для i18n см.
 flufl.i18n пакет.
 Строки шаблона поддерживают замены на основе  $ , используя следующие правила:
  $$  - побег; он заменяется одиночным   $.
  $ идентификатор  именует заполнитель подстановки, соответствующий ключу сопоставления
  «идентификатор» . По умолчанию  "идентификатор"  ограничен любым
 буквенно-цифровая строка ASCII без учета регистра (включая символы подчеркивания),
 начинается с символа подчеркивания или буквы ASCII. Первый неидентификатор
 символ после символа  $  завершает этот заполнитель
 Спецификация.
  $ {идентификатор}  эквивалентно  $ идентификатору .Требуется, когда
 допустимые символы идентификатора следуют за заполнителем, но не являются частью
 заполнитель, например  "$ {имя существительное} ification" .
 Любое другое появление  $  в строке приведет к  ValueError 
 поднимается.
 Модуль  string  предоставляет класс  Template , который реализует
 эти правила. Методы  Template :
  класс   строка.  Шаблон  ( шаблон )
 Конструктор принимает единственный аргумент - строку шаблона.
  заменить  (сопоставление  = {} , /,  ** kwds )
 Выполняет подстановку шаблона, возвращая новую строку.  отображение  есть
 любой подобный словарю объект с ключами, которые соответствуют заполнителям в
 шаблон. В качестве альтернативы вы можете указать аргументы ключевого слова, где
 ключевые слова - это заполнители.Если заданы оба сопоставления   и  kwds 
 и есть дубликаты, заполнители из  kwds  имеют приоритет.
  safe_substitute  (сопоставление  = {} , /,  ** kwds )
 Подобно , замените () , за исключением того, что если заполнители отсутствуют в
  сопоставление  и  kwds , вместо того, чтобы вызывать исключение  KeyError ,
 исходный заполнитель появится в результирующей строке без изменений.Также,
 в отличие от замены  () , любые другие появления  $  будут
 просто верните  $  вместо  ValueError .
 Хотя могут возникать и другие исключения, этот метод называется «безопасным».
 потому что он всегда пытается вернуть пригодную для использования строку вместо
 создание исключения. С другой стороны,  safe_substitute ()  может быть
 что-либо кроме безопасного, так как он будет молча игнорировать искаженный
 шаблоны, содержащие висящие разделители, несовпадающие фигурные скобки или
 заполнители, которые не являются действительными идентификаторами Python.
  Экземпляры шаблона  также предоставляют один атрибут общедоступных данных:
  шаблон 
 Это объект, переданный в аргумент  шаблона конструктора. В
 В общем, вы не должны изменять его, но доступ только для чтения не применяется.
 Вот пример использования шаблона:
 >>> из шаблона импорта строки
>>> s = Template ('$ кому нравится $ what')
>>> с.заменить (who = 'tim', what = 'kung pao')
'Тим любит кунг пао'
>>> d = dict (кто = 'tim')
>>> Шаблон ('Дайте кому $ 100'). Replace (d)
Отслеживание (последний вызов последний):
...
ValueError: недопустимый заполнитель в строке: строка 1, столбец 11
>>> Шаблон ('$ кому нравится $ what'). Replace (d)
Отслеживание (последний вызов последний):
...
KeyError: 'что'
>>> Шаблон ('$ кому нравится $ what'). Safe_substitute (d)
"Тим любит $ что"
 
 Расширенное использование: вы можете создать подклассы шаблона   для настройки
 синтаксис заполнителя, символ-разделитель или все регулярное выражение
 используется для анализа строк шаблона.Для этого вы можете переопределить этот класс
 атрибуты:
  разделитель  - это буквальная строка, описывающая заполнитель
 вводим разделитель. Значение по умолчанию -   долларов. Обратите внимание, что это должно
 , а не , будет регулярным выражением, поскольку реализация вызовет
  re.escape ()  в этой строке по мере необходимости. Обратите внимание, что вы не можете
 измените разделитель после создания класса (т.е. другой разделитель должен
 быть установленным в пространстве имен класса подкласса).
  idpattern  - это регулярное выражение, описывающее шаблон для
 заполнители без скобок. Значение по умолчанию - регулярное выражение.
  (? A: [_ a-z] [_ a-z0-9] *) . Если это дано и  braceidpattern  is
  Нет  этот шаблон также будет применяться к заполнителям в фигурных скобках.
 Примечание
 Поскольку по умолчанию  flags  -  re.IGNORECASE , шаблон  [a-z]  может соответствовать
 с некоторыми символами, отличными от ASCII.Вот почему мы используем локальный флаг  и .
 здесь.
 Изменено в версии 3.7:  braceidpattern  можно использовать для определения отдельных шаблонов, используемых внутри и
 вне брекетов.
  braceidpattern  - это похоже на  idpattern , но описывает шаблон для
 заполнители в скобках. По умолчанию  Нет , что означает возврат к
  idpattern  (т.е. один и тот же узор используется как внутри, так и снаружи фигурных скобок).
 Если задано, это позволяет вам определять разные шаблоны для фигурных скобок и
 свободные заполнители.
  flags  - флаги регулярного выражения, которые будут применяться при компиляции
 регулярное выражение, используемое для распознавания замен. Значение по умолчанию
 это  re.IGNORECASE . Обратите внимание, что  re.VERBOSE  всегда будет добавляться к
 flags, поэтому пользовательские  idpattern  должны следовать соглашениям для подробных регулярных
 выражения.
 В качестве альтернативы вы можете предоставить весь шаблон регулярного выражения,
 переопределение атрибута класса  шаблон .Если вы это сделаете, значение должно быть
 объект регулярного выражения с четырьмя именованными группами захвата. Захват
 группы соответствуют приведенным выше правилам вместе с недопустимым заполнителем
 правило:
  escape  - Эта группа соответствует escape-последовательности, например  $$ , в
 шаблон по умолчанию.
  с именем  - эта группа соответствует имени заполнителя без скобок; это не должно
 включить разделитель в группу захвата.
  в фигурных скобках  - Эта группа соответствует имени заполнителя в фигурных скобках; должно
 не включать в группу захвата ни разделитель, ни фигурные скобки.
  недопустимый  - Эта группа соответствует любому другому шаблону разделителя (обычно один
 разделитель), и он должен быть последним в регулярном выражении.
 Строковые функции в Python 3 
 Введение 
 Python имеет несколько встроенных функций, связанных с строковым типом данных. Эти функции позволяют нам легко изменять строки и управлять ими. Мы можем думать о функциях как о действиях, которые мы выполняем над элементами нашего кода.Встроенные функции - это те, которые определены на языке программирования Python и легко доступны для использования.
 В этом руководстве мы рассмотрим несколько различных функций, которые можно использовать для работы со строками в Python 3.
 Изготовление струн в верхнем и нижнем регистре 
 Функции  str.upper ()  и  str.lower ()  вернут строку, в которой все буквы исходной строки преобразованы в буквы верхнего или нижнего регистра. Поскольку строки являются неизменяемыми типами данных, возвращаемая строка будет новой строкой.Любые символы в строке, не являющиеся буквами, не будут изменены.
 Преобразуем строку  Sammy Shark  в верхний регистр:
  ss = "Сэмми Акула"
печать (ss.upper ())
  
  
 Выход 
 SAMMY SHARK
  
 Теперь давайте преобразуем строку в нижний регистр:
  печать (ss.lower ())
  
  
 Ouput 
 Sammy Shark
  
  ул. Верхняя ()  и  ул.Функции lower ()  упрощают оценку и сравнение строк, обеспечивая единообразие регистра во всем. Таким образом, если пользователь записывает свое имя в нижнем регистре, мы все равно можем определить, есть ли его имя в нашей базе данных, например, сравнив его с версией, написанной полностью в верхнем регистре.
 Логические методы 
 Python имеет несколько строковых методов, которые вычисляют логическое значение. Эти методы полезны, когда мы, например, создаем формы для заполнения пользователями. Если мы запрашиваем почтовый индекс, мы хотим принять только числовую строку, но когда мы запрашиваем имя, мы хотим принять только буквенную строку.
 Существует ряд строковых методов, которые возвращают логические значения:
 Метод
  Истинно , если
  str.isalnum () 
 Строка состоит только из буквенно-цифровых символов (без символов)
  str.isalpha () 
 Строка состоит только из буквенных символов (без символов)
  ул. Ниже () 
 Все буквы в строке строчные.
  ул.isnumeric () 
 Строка состоит только из цифровых символов
  стр. Пробел () 
 Строка состоит только из пробелов
  str.istitle () 
 Строка в заглавном регистре
  верхняя ул. () 
 Все буквенные символы строки - заглавные
 Давайте посмотрим на пару из них в действии:
  число = "5"
письма = "abcdef"

печать (число.isnumeric ())
печать (letter.isnumeric ())
  
  
 Выход 
 True
Ложь
  
 Использование метода  str.isnumeric ()  в строке  5  возвращает значение  True , а использование того же метода в строке  abcdef  возвращает значение  False .
 Аналогичным образом мы можем запросить, указаны ли буквенные символы строки в регистре заголовка, верхнем или нижнем регистре. Создадим несколько строк:
  movie = "2001: САММИ ОДИССЕЯ"
book = "Тысяча великолепных акул"
poem = "Сэмми жил в красивом городке"
  
 Теперь давайте попробуем логические методы, которые проверяют регистр:
  отпечаток (ролик.islower ())
печать (movie.isupper ())
  
  печать (название книги ())
печать (book.isupper ())
  
  печать (название стихотворения ())
печать (poem.islower ())
  
 Теперь мы можем запустить эти небольшие программы и увидеть результат:
  
 Вывод строки фильма 
 Ложь
Истинный
  
  
 Вывод книжной строки 
 True
Ложь
  
  
 Вывод строки стихотворения 
 Ложь
Истинный
  
 Проверка того, являются ли символы строчными, прописными или заглавными буквами, может помочь нам правильно отсортировать наши данные, а также предоставить нам возможность стандартизировать данные, которые мы собираем, путем проверки и последующего изменения строк по мере необходимости.
 Логические строковые методы полезны, когда мы хотим проверить, соответствует ли что-то, что вводит пользователь, заданным параметрам.
 Определение длины строки 
 Строковая функция  len ()  возвращает количество символов в строке. Этот метод полезен, когда вам нужно установить минимальную или максимальную длину пароля, например, или усечь большие строки, чтобы они находились в определенных пределах для использования в качестве сокращений.
 Чтобы продемонстрировать этот метод, найдем длину строки, состоящей из предложения:
  open_source = "Сэмми участвует в разработке открытого исходного кода."
печать (len (open_source))
  
  
 Выход 
 33
  
 Мы устанавливаем переменную  open_source  равной строке  «Сэмми способствует открытому исходному коду». , а затем мы передали эту переменную в функцию  len ()  с  len (open_source) . Затем мы передали метод в метод  print () , чтобы мы могли видеть вывод на экране нашей программы.
 Имейте в виду, что любой символ, заключенный в одинарные или двойные кавычки, включая буквы, числа, пробелы и символы, будет подсчитан функцией  len () .
 методы join (), split () и replace () 
 Методы  str.join () ,  str.split ()  и  str.replace ()  - это несколько дополнительных способов управления строками в Python.
 Метод  str.join ()  объединяет две строки, но таким образом, чтобы одна строка передавалась через другую.
 Создадим строку:
  balloon = "У Сэмми воздушный шарик."
  
 Теперь возьмем  str.join () , чтобы добавить пробел в эту строку, что мы можем сделать так:
  "" .join (баллон)
  
 Если распечатать это:
  печать ("" .join (баллон))
  
 Мы увидим, что в новой возвращаемой строке добавлен пробел по всей первой строке:
  
 Ouput 
 S a m y h a s a b a l o o n.
  
 Мы также можем использовать метод  str.join ()  для возврата строки, которая является разворотом исходной строки:
  печать ("".присоединиться (перевернутый (воздушный шар)))
  
  
 Выход 
 .noollab и sah ymmaS
  
 Мы не хотели добавлять какую-либо часть другой строки к первой строке, поэтому мы оставили кавычки соприкасающимися без пробелов между ними.
 Метод  str.join ()  также полезен для объединения списка строк в новую отдельную строку.
 Давайте создадим строку, разделенную запятыми, из списка строк:
  print (",". Join (["акулы", "ракообразные", "планктон"]))
  
  
 Выход 
 акулы, ракообразные, планктон
  
 Если мы хотим добавить запятую и пробел между строковыми значениями в нашей новой строке, мы можем просто переписать наше выражение с пробелом после запятой:  ",".присоединиться ([«акулы», «ракообразные», «планктон»]) .
 Так же, как мы можем соединять строки вместе, мы можем также разделять строки. Для этого воспользуемся методом  str.split () :
  печать (Balloon.split ())
  
  
 Ouput 
 ['Сэмми', 'имеет', 'а', 'баллон.']
  
 Метод  str.split ()  возвращает список строк, разделенных пробелами, если не указан другой параметр.
 Мы также можем использовать  ул.split ()  для удаления определенных частей исходной строки. Например, давайте удалим букву  a  из строки:
  печать (баллон.split ("а"))
  
  
 Ouput 
 ['S', 'mmy h', 's', 'b', 'lloon.']
  
 Теперь буква  a  была удалена, и строки были разделены там, где был каждый экземпляр буквы  a , с сохранением пробелов.
 Метод  str.replace ()  может принимать исходную строку и возвращать обновленную строку с некоторой заменой.
 Допустим, воздушный шар, который был у Сэмми, потерян. Поскольку у Сэмми больше нет этого балуна, мы заменим подстроку  «has»  с исходной строки  балл  на  «has»  в новой строке:
  печать (Balloon.replace ("имеет", "имел"))
  
 В круглых скобках первая подстрока - это то, что мы хотим заменить, а вторая подстрока - это то, чем мы заменяем эту первую подстроку. Наш результат будет выглядеть так:
  
 Ouput 
 У Сэмми был воздушный шар. 
 Использование строковых методов  str.join () ,  str.split ()  и  str.replace ()  предоставит вам больше возможностей для управления строками в Python.
 Заключение 
 В этом руководстве были рассмотрены некоторые из распространенных встроенных методов для строкового типа данных, которые вы можете использовать для работы со строками и управления ими в ваших программах Python.
 Вы можете узнать больше о других типах данных в разделе «Общие сведения о типах данных», узнать больше о строках в разделе «Введение в работу со строками» и узнать об изменении внешнего вида строк в разделе «Как форматировать текст в Python 3.”
 Учебное пособие по строкам
 Python - строковые функции с примерами 
 Здравствуйте, зрители, в этом посте мы исследуем мир Python Strings, часто используемых функций и некоторых важных функций. Строки в Python являются объектами, а Python предоставляет нет. встроенных / библиотечных функций для их изменения.
 Кроме того, вы согласны с тем, что каждый из нас очень часто использует строки Python в обычной деятельности по программированию. Учитывая этот факт, мы постарались охватить все строковые операторы и функции Python в одном посте.
 Мы предоставили соответствующие примеры для каждой из тем, которые мы сегодня рассматриваем. Они помогут вам глубже разобраться в предмете.
 Давайте посмотрим на основные моменты текущего обсуждения.
 Изучение основ строк Python 
 Как создавать строки в Python? 
 Создавать строки очень просто, поскольку вам нужно только заключить символы в одинарные или двойные кавычки.
 В следующем примере мы предоставляем различные способы инициализации строк.
 Чтобы поделиться важным примечанием, вы также можете использовать тройные кавычки для создания строк. Однако программисты используют их для маркировки многострочных строк и строк документации.
 # Примеры строк Python - все назначения идентичны.
String_var = 'Python'
String_var = "Python"
String_var = "" "Python" ""

# с тройными кавычками Строки могут расширяться до нескольких строк
String_var = "" "Этот документ поможет вам
изучить все концепции
строк Python !!! "" "

# Заменить «документ» на «учебник» и сохранить в другой переменной
substr_var = String_var.replace ("документ", "учебник")
печать (substr_var)
 
 Строки индекса и среза в Python 
 Доступ к отдельным символам строки 
 Вам необходимо знать индекс символа, чтобы получить его из String.
 Как и большинство языков программирования, Python позволяет индексировать с нулевой позиции в строках. Но он также поддерживает отрицательные индексы. Индекс «-1» представляет последний символ строки. Точно так же, используя «-2», мы можем получить доступ к предпоследнему элементу строки и так далее.
 sample_str = 'Строка Python'

print (sample_str [0]) # возвращает 1-й символ
# вывод: P

print (sample_str [-1]) # возвращает последний символ
# output: g

print (sample_str [-2]) # возвращает последний второй символ
# вывод: n
 
 Нарезка строки в Python 
 Чтобы получить диапазон символов в строке, мы используем «оператор среза», знак двоеточия «:». С помощью оператора среза мы определяем диапазон как [a: b].Это позволит нам распечатать все символы String, начиная с индекса «a» и заканчивая символом с индексом «b-1». Таким образом, символ с индексом «b» не является частью вывода.
 sample_str = 'Строка Python'
print (sample_str [3: 5]) # вернуть диапазон символов
# хо
print (sample_str [7:]) # возвращает все символы из индекса 7
# Нить
print (sample_str [: 6]) # возвращает все символы до индекса 6
# Python
печать (пример_стр [7: -4])
# St
 
 Далее у нас нет.из  руководств / викторин / вопросов для собеседований по Python  в этом блоге. Если вы хотите попробовать их, обратитесь к любому из сообщений, перечисленных ниже.
  Рекомендуемая литература: 
  ТОС 
 строки Python - распространенные коды ошибок 
  1-  Если мы попытаемся получить символы с индексом вне диапазона, то возникнет исключение «IndexError».
 sample_str = "Python поддерживает машинное обучение."
print (sample_str [1024]) #index должен быть в диапазоне

# IndexError: индекс строки вне допустимого диапазона
 
  2-  Индекс строки должен иметь целочисленный тип данных.Вы не должны использовать для этой цели float или любой другой тип данных. В противном случае подсистема Python помечает исключение TypeError, поскольку обнаруживает нарушение типа данных для строкового индекса.
 sample_str = "Приветственное сообщение"
print (sample_str [1.25]) #index должен быть целым числом

# TypeError: строковые индексы должны быть целыми числами
 
 Изменить / удалить строку в Python 
 Python Строки неизменны по своей конструкции. Он предполагает, что после привязки String к переменной ее нельзя изменить.
 Если вы хотите обновить String, повторно назначьте новое значение String той же переменной.
 sample_str = 'Строка Python'
sample_str [2] = "а"

# TypeError: объект 'str' не поддерживает назначение элементов

sample_str = 'Строка программирования'
печать (sample_str)

# Выход => Строка программирования
 
 Точно так же мы не можем изменить строку, удалив из нее некоторые символы. Вместо этого мы можем полностью удалить строки с помощью команды «del».
 sample_str = "Python - лучший язык сценариев."
del sample_str [1]
# TypeError: объект 'str' не поддерживает удаление элемента

del sample_str
печать (sample_str)
# NameError: имя sample_str не определено
 
  Рекомендуемая литература: 
  ТОС 
 Строковые операторы в Python 
 Конкатенация (+) 
 Он объединяет две струны в одну.
 # example
var1 = 'Python'
var2 = 'Строка'
печать (var1 + var2)
# PythonString 
 Повторение (*) 
 Этот оператор создает новую строку, повторяя ее заданное количество раз.
 # example
var1 = 'Python'
печать (var1 * 3)
# PythonPythonPython 
 Нарезка [] 
 Оператор среза печатает символ по заданному индексу.
 # example
var1 = 'Python'
печать (var1 [2])
# t 
 Нарезка диапазона [x: y] 
 Он печатает символы, присутствующие в заданном диапазоне.
 # example
var1 = 'Python'
печать (var1 [2: 5])
# tho 
 Членство (в) 
 Этот оператор возвращает значение «Истина», если символ присутствует в данной строке.
 # example
var1 = 'Python'
print ('n' в var1)
# True 
 Членство (не в) 
 Возвращает значение «Истина», если символ отсутствует в данной строке.
 # example
var1 = 'Python'
print ('N' отсутствует в var1)
# True 
 Итерация (для) 
 С помощью этого оператора мы можем перебирать все символы строки.
 # example
для var в var1: print (var, end = "")
# Python 
 Необработанная струна (r / R) 
 Мы можем использовать его, чтобы игнорировать фактическое значение escape-символов внутри строки.Для этого мы добавляем «r» или «R» перед строкой.
 # example
печать (г '\ п')
# \ n
печать (R '\ n')
# \ n 
  ТОС 
 Операторы форматирования строк в Python 
 escape-символы Python 
 Escape-последовательность начинается с обратной косой черты (\), которая сигнализирует компилятору, что нужно обращаться с ней по-другому. Подсистема Python автоматически интерпретирует escape-последовательность независимо от того, находится ли она в одинарных или двойных кавычках строках.
 Давайте обсудим пример. Одна из важных escape-последовательностей - это экранирование одинарной или двойной кавычки.
 Предположим, у нас есть строка вроде - Python - «широко используемый» язык.
 Двойные кавычки вокруг слова «широко» маскируют python, что строка там заканчивается.
 Нам нужен способ сообщить Python, что двойные кавычки внутри строки не являются кавычками разметки строки. Вместо этого они являются частью String и должны появиться в выводе.
 Чтобы решить эту проблему, мы можем избежать двойных и одинарных кавычек как:
 print («Python -« широко »используемый язык»)

# SyntaxError: неверный синтаксис

# После экранирования двойными кавычками

print ("Python - это \" широко \ "используемый язык")

# Вывод: Python - «широко используемый» язык
 
 Список персонажей побега 
 Вот полный список escape-символов, которые представлены с использованием обратной косой черты.
 \ N {name}
 Имя символа в базе данных Unicode (только Unicode)
 \ uxxxx
 Символ с 16-битным шестнадцатеричным значением xxxx (только Unicode)
 \ Uxxxxxxxx
 Символ с 32-битным шестнадцатеричным значением xxxxxxxx (только Unicode)
 \ v
 Вертикальная табуляция ASCII (VT)
 \ ooo
 Знаки с восьмеричным числом ooo
 \ xnn
 Символ с шестнадцатеричным значением nn, где n может быть любым из диапазона 0-9, a-f или A-F.
  ТОС 
 Символы формата Python 
 Строковый оператор «%», используемый для форматирования строк. Мы часто используем этот оператор с функцией print ().
 Вот простой пример.
 print ("Имя сотрудника:% s, \ n Возраст сотрудника:% d"% ('Ashish', 25))

# Имя сотрудника: Ашиш,
# Возраст сотрудника: 25
 
 Список символов формата 
 Ниже приводится таблица, содержащая полный список символов, которые можно использовать с оператором «%».
% s
 преобразование строки через str () перед форматированием
% u
 целое десятичное без знака
% x
 шестнадцатеричное целое число (строчные буквы)
% X
 шестнадцатеричное целое число (заглавные буквы)
% e
 экспоненциальная запись (со строчной буквой "e")
% E
 экспоненциальное представление (с ВЕРХНИМ регистром "E")
% f
 вещественное число с плавающей запятой
% g
 короче из% f и% e
% G
 короче% f и% E
 Поддержка Unicode String в Python 
 Regular Strings хранится как 8-битное значение ASCII, тогда как Unicode String соответствует 16-битному стандарту ASCII.Это расширение позволяет строкам включать символы из разных языков мира. В Python буква «u» работает как префикс, чтобы различать Unicode и обычные строки.
 print (u 'Привет, Python !!')

# Привет, Python
 
  Рекомендуемая литература: 
  ТОС 
 Встроенные строковые функции в Python 
 Функции преобразования 
  1. capitalize () -  Возвращает строку, в которой первый символ состоит из заглавной буквы, а остальные символы - в нижнем регистре.
 var = "ПИТОН"
печать (var.capitalize ())
# Python 
  2. lower () -  Преобразует все символы String в нижний регистр
 var = 'TechBeamers'
печать (var.lower ())
# techbeamers 
  3. upper () -  Преобразует все символы String в верхний регистр
 var = 'TechBeamers'
печать (var.upper ())
# TECHBEAMERS 
  4. swapcase () -  Меняет местами регистр каждого символа в строке означает, что символы нижнего регистра были преобразованы в верхний регистр и наоборот.
 var = 'TechBeamers'
печать (var.swapcase ())
# ТЕХБИМЕРЫ 
  5. title () -  Возвращает "заглавную" версию String, что означает, что все слова начинаются с верхнего регистра, а остальные символы в словах находятся в нижнем регистре.
 var = 'добро пожаловать в программирование на Python'
печать (var.title ())
# Добро пожаловать в программирование на Python 
  6. count (str [, begin [, end]]) -  Возвращает, сколько раз подстрока 'str' встречается в диапазоне [begin, end], если заданы начальный и конечный индексы, иначе поиск продолжается в полной строке Поиск чувствителен к регистру.
 var = 'TechBeamers'
str = 'e'
печать (var.count (str))
# 3 
 var1 = 'Орлиные глаза'
печать (var1.count ('e'))
# 2 
 var2 = 'Орлиные глаза'
print (var2.count ('E', 0,5))
# 1 
  ТОС 
 Функции сравнения - Часть 1 
  1. islower () -  Возвращает «Истина», если все символы в строке находятся в нижнем регистре. Если какой-либо из символов находится в верхнем регистре, он вернет False.
 var = 'Python'
печать (var.islower ())
# Ложь

var = 'питон'
печать (var.islower ())
# True 
  2. isupper () -  Возвращает «Истина», если все символы в строке находятся в верхнем регистре. Если какой-либо из символов находится в нижнем регистре, он вернет False.
 var = 'Python'
печать (var.isupper ())
# Ложь

var = 'PYTHON'
печать (var.isupper ())
# True 
  3. isdecimal () -  Возвращает «Истина», если все символы в строке являются десятичными. Если какой-либо символ в строке имеет другой тип данных, он вернет False.
 Десятичные символы относятся к категории Unicode Nd.
 число = u'2016 '
печать (число.isdecimal ())
# True 
  4. isdigit () -  Возвращает «Истина» для любого символа, для которого isdecimal () вернет «Истина» и некоторые символы в категории «Нет». Если есть какие-либо символы, кроме этих, он вернет False ’.
 Точнее, цифры - это символы, для которых свойство Unicode включает: Numeric_Type = Digit или Numeric_Type = Decimal.
 Например, верхние индексы - это цифры, а дроби - нет.
 печать ('2'.isdigit ())
# Истинный

print ('²'.isdigit ())
# True 
 Функции сравнения - Часть 2 
  1. isnumeric () -  Возвращает «Истина», если все символы строки Unicode принадлежат одной из категорий Nd, No и NI.
 Если есть какие-либо символы, кроме этих, он вернет False.
 Точно, числовые символы - это символы, для которых свойство Unicode включает: Numeric_Type = Digit, Numeric_Type = Decimal или Numeric_Type = Numeric.
 число = u'2016 '
печать (число.isnumeric ())
# Истинный

num = u'year2016 '
печать (число.isnumeric ())
# False 
  2. isalpha () -  Возвращает «Истина», если Строка содержит хотя бы один символ (непустая Строка), и все символы являются алфавитными, в противном случае - «Ложь».
 печать ('python'.isalpha ())
# Истинный

печать ('python3'.isalpha ())
# False 
  3. isalnum () -  Возвращает «Истина», если Строка содержит хотя бы один символ (непустую Строку), и все символы являются буквенными или десятичными цифрами, в противном случае «Ложь».
 печать ('python'.isalnum ())
# Истинный
печать ('python3'.isalnum ())
# True 
  ТОС 
 Функции заполнения 
  1. rjust (width [, fillchar]) -  Возвращает строку, заполненную входным символом, при перемещении исходного содержимого с правой стороны.
 По умолчанию для заполнения используется пробел. В противном случае «fillchar» указывает символ-заполнитель.
 var = 'Python'
печать (var.rjust (10))
# Python

печать (var.rjust (10, '-'))
# ---- Python 
  2. ljust (width [, fillchar]) -  Возвращает дополненную версию String с исходной String, выровненной по левому краю до общей ширины столбцов
 По умолчанию для заполнения используется пробел. В противном случае «fillchar» указывает символ-заполнитель.
 var = 'Python'
печать (var.ljust (10))
# Python

print (var.ljust (10, '-'))
# Python ---- 
  3. center (width [, fillchar]) -  Возвращает строку, заполненную входным символом, при перемещении исходного содержимого в центр.
 По умолчанию для заполнения используется пробел. В противном случае «fillchar» указывает символ-заполнитель.
 var = 'Python'
печать (var.center (20))
# Python

печать (var.center (20, '*'))
# ******* Python ******* 
  4. zfill (width) -  Возвращает строку, заполненную исходным содержимым, дополненным слева нулями, так что общая длина String становится равной входному размеру.
 Если в строке присутствует начальный знак (+/-), то с этой функцией заполнение начинается после символа, а не до него.
 var = 'Python'
печать (var.zfill (10))
# 0000Пайтон

var = '+ Python'
печать (var.zfill (10))
# + 000Python 
  ТОС 
 Функции поиска 
  1. find (str [, i [, j]]) -  Ищет 'str' в полной строке (если i и j не определены) или в подстроке строки (если i и j определены) . Эта функция возвращает индекс, если найдена 'str', иначе возвращает '-1'.
 Здесь i = поиск начинается с этого индекса, j = поиск заканчивается по этому индексу.
 Подробнее -  Python String Find () 
 var = "Tech Beamers"
str = "Луч"
печать (var.find (str))
# 5

var = "Tech Beamers"
str = "Луч"
печать (var.find (str, 4))
# 5

var = "Tech Beamers"
str = "Луч"
печать (var.find (str, 7))
# -1 
  2. index (str [, i [, j]]) -  Аналогичен методу поиска. Единственное отличие состоит в том, что он вызывает исключение ValueError, если str не существует.
 var = 'Tech Beamers'
str = 'Луч'
печать (var.index (str))
# 5

var = 'Tech Beamers'
str = 'Луч'
печать (var.index (str, 4))
# 5

var = 'Tech Beamers'
str = 'Луч'
печать (var.index (str, 7))
# ValueError: подстрока не найдена 
  3. rfind (str [, i [, j]]) -  Это то же самое, что и find (), только эта функция возвращает последний индекс, в котором найдена 'str'. Если "str" ​​не найдена, возвращается "-1".
 var = 'Это хороший пример'
str = 'is'
печать (var.rfind (str, 0,10))
# 5

печать (var.rfind (str, 10))
# -1 
  4. count (str [, i [, j]]) -  Возвращает количество вхождений подстроки «str» в строку. Ищет «str» в полной строке (если i и j не определены) или в подстроке строки (если i и j определены).
 Где: i = поиск начинается с этого индекса, j = поиск заканчивается по этому индексу.
 var = 'Это хороший пример'
str = 'is'
печать (var.count (str))
# 2

печать (var.count (str, 4,10))
# 1 
  ТОС 
 Функции подстановки строк 
  1.replace (old, new [, count]) -  Заменяет все вхождения подстроки «старый» на «новый» в строке.
 Если счет доступен, то только «count» количество появлений «old» будет заменено на «new» переменную.
 Где старая = подстрока для замены, новая = подстрока
 var = 'Это хороший пример'
str = 'было'
print (var.replace ('есть', str))
# Это был хороший пример печати (var.replace ('is', str, 1))
# Это хороший пример 
  2.split ([sep [, maxsplit]]) -  Возвращает список подстрок, полученных после разделения строки с помощью «sep» в качестве разделителя.
 Где sep = разделитель, по умолчанию - пробел, maxsplit = количество делений, которые необходимо сделать
 var = "Это хороший пример"
печать (var.split ())
# ['This', 'is', 'a', 'good', 'example'] print (var.split ('', 3))
# ['This', 'is', 'a', 'good example'] 
  3. splitlines (num) -  Разбивает строку по разрывам строки и возвращает список после удаления разрывов строк.
 Где num =, если это положительное значение. Это указывает на то, что в возвращаемом списке появятся разрывы строк.
 var = 'Печатать новую строку \ nСледующая \ n \ nПерейти к новой строке'
печать (var.splitlines ())
# ['Печатать новую строку', 'Следующая строка', '', 'Снова перейти к новой строке'] print (var.splitlines (1))
# ['Печатать новую строку \ n', 'Следующая строка \ n', '\ n', 'Снова перейти к новой строке'] 
  4. join (seq) -  Возвращает строку, полученную после объединения последовательности «seq» со строкой-разделителем.
 Где: seq = последовательность элементов для объединения
 seq = ('ab', 'bc', 'cd').
str = '='
печать (str.join (seq))
# ab = bc = cd 
  ТОС 
 Различные строковые функции 
  1. lstrip ([chars]) -  Возвращает строку после удаления символов из начала строки.
 Где: Chars = это символ, который нужно вырезать из строки.
 По умолчанию используется пробельный символ.
 var = 'Это хороший пример'
печать (var.lstrip ())
# Это хороший пример
var = '***** Это хороший пример *****'
печать (var.lstrip ('*'))
# Это хороший пример ********** 
  2. rstrip () -  Возвращает строку после удаления символов из конца строки.
 Где: Chars = это символ, который нужно вырезать из строки. По умолчанию используется пробельный символ.
 var = 'Это хороший пример'
печать (var.rstrip ())
# Это хороший пример
var = '***** Это хороший пример *****'
печать (var.lstrip ('*'))
# ***** Это хороший пример 
  3. rindex (str [, i [, j]]) -  Ищет 'str' в полной строке (если i и j не определены) или в подстроке строки (если i и j определены. ). Эта функция возвращает последний индекс, по которому доступна "str".
 Если «str» отсутствует, возникает исключение ValueError.
 Где: i = поиск начинается с этого индекса, j = поиск заканчивается по этому индексу.
 var = 'Это хороший пример'
str = 'is'
печать (var.rindex (str, 0,10))
# 5
print (var.rindex (str, 10))
# ValueError: подстрока не найдена 
  4. len (строка) -  Возвращает длину заданной строки
 var = 'Это хороший пример'
печать (len (var))
# 22 
  ТОС 
 В этом посте мы попытались охватить большую часть строковых функций, доступных в Python. И мы надеемся, что вы лучше поймете строки Python.
 Однако, если у вас есть какие-либо вопросы относительно строк Python, сообщите нам об этом.Мы постараемся решить ее в кратчайшие сроки.
 Кроме того, в Python 3.6 был введен новый стиль строк, известный как  f-строки , проходят через него.
  Всего наилучшего, 
  TechBeamers 
 Строки и символьные данные в Python - Real Python 
 В следующих разделах выделены операторы, методы и функции, доступные для работы со строками.
 Строковые операторы 
 Вы уже видели операторы  +  и  * , применяемые к числовым операндам в учебнике по операторам и выражениям в Python.Эти два оператора также могут применяться к строкам.
 +  Оператор 
 Оператор  +  объединяет строки. Он возвращает строку, состоящую из операндов, объединенных вместе, как показано здесь:
>>>
  >>> s = 'foo'
>>> t = 'бар'
>>> u = 'baz'

>>> с + т
'foobar'
>>> с + т + и
'foobarbaz'

>>> print ('Go team' + '!!!')
Вперед, команда !!!
  
 Оператор
 * 
 Оператор  *  создает несколько копий строки.Если  s  - строка, а  n  - целое число, любое из следующих выражений возвращает строку, состоящую из  n  объединенных копий  s :
.
  с * с  
  с * с 
 Вот примеры обеих форм:
>>>
  >>> s = 'foo.'

>>> с * 4
'foo.foo.foo.foo.'
>>> 4 * с
'foo.foo.foo.foo.'
  
 Операнд множителя  n  должен быть целым числом.Вы могли подумать, что это должно быть положительное целое число, но, что забавно, оно может быть нулем или отрицательным, и в этом случае результатом будет пустая строка:
 Если бы вы создали строковую переменную и инициализировали ее пустой строкой, присвоив ей значение  'foo' * -8 , любой справедливо подумал бы, что вы немного глупы. Но это сработает.
 в  Оператор
 Python также предоставляет оператор членства, который можно использовать со строками. Оператор  в  возвращает  True , если первый операнд содержится во втором, и  False  в противном случае:
>>>
  >>> s = 'foo'

>>> Вот это пища для размышлений.'
Истинный
>>> в "Пока все хорошо".
Ложь
  
 Также есть  не в операторе , который делает наоборот:
>>>
  >>> 'z' не входит в 'abc'
Истинный
>>> 'z' не входит в 'xyz'
Ложь
  
 Встроенные строковые функции 
 Как вы видели в учебнике по основным типам данных в Python, Python предоставляет множество функций, встроенных в интерпретатор и всегда доступных. Вот некоторые из них, которые работают со строками:
 Функция
 Описание
  chr () 
 Преобразует целое число в символ
  порядковый номер () 
 Преобразует символ в целое число
  л. () 
 Возвращает длину строки
  ул. () 
 Возвращает строковое представление объекта
 Более подробно они рассматриваются ниже.
 орд (в) 
 Возвращает целое число для данного символа.
 На самом базовом уровне компьютеры хранят всю информацию в виде чисел. Для представления символьных данных используется схема перевода, которая сопоставляет каждый символ с его репрезентативным номером.
 Самая простая из распространенных схем называется ASCII. Он охватывает распространенные латинские символы, с которыми вы, вероятно, привыкли работать. Для этих символов  ord (c)  возвращает значение ASCII для символа  c :
.
 >>>
  >>> ord ('а')
97
>>> ord ('#')
35 год
  
 ASCII в порядке.Но в мире используется много разных языков, а на цифровых носителях появляется бесчисленное количество символов и глифов. Полный набор символов, который потенциально может потребоваться представить в компьютерном коде, намного превосходит обычные латинские буквы, цифры и символы, которые вы обычно видите.
 Unicode - амбициозный стандарт, который пытается предоставить числовой код для каждого возможного символа на всех возможных языках и на всех возможных платформах. Python 3 широко поддерживает Юникод, в том числе позволяет использовать символы Юникода в строках.
 Пока вы остаетесь в домене общих символов, между ASCII и Unicode мало практических различий. Но функция  ord ()  также вернет числовые значения для символов Юникода:
>>>
  >>> ord ('€')
8364
>>> ord ('∑')
8721
  
 ребро (п) 
 Возвращает символьное значение для заданного целого числа.
  chr ()  выполняет обратную операцию  ord () .Учитывая числовое значение  n ,  chr (n)  возвращает строку, представляющую символ, который соответствует  n :
>>>
  >>> chr (97)
'а'
>>> chr (35)
'#'
  
  chr ()  также обрабатывает символы Unicode:
>>>
  >>> chr (8364)
'€'
>>> chr (8721)
'∑'
  
  лин (и) 
 Возвращает длину строки.
 С помощью  len ()  вы можете проверить длину строки Python. len (s)  возвращает количество символов за  с :
>>>
  >>> s = 'Я струна'.
>>> len (s)
14
  
  ул (объект) 
 Возвращает строковое представление объекта.
 Практически любой объект в Python может быть отображен в виде строки.  str (obj)  возвращает строковое представление объекта  obj :
>>>
  >>> ул (49.2)
'49.2 '
>>> str (3 + 4j)
'(3 + 4j)'
>>> ул (3 + 29)
'32'
>>> str ('фу')
'фу'
  
 Индексирование строк 
 Часто в языках программирования к отдельным элементам в упорядоченном наборе данных можно получить доступ напрямую, используя числовой индекс или значение ключа. Этот процесс называется индексацией.
 В Python строки представляют собой упорядоченные последовательности символьных данных и, следовательно, могут индексироваться таким образом. Доступ к отдельным символам в строке можно получить, указав имя строки, за которым следует число в квадратных скобках ( [] ).
 Индексирование строк в Python начинается с нуля: первый символ в строке имеет индекс  0 , следующий имеет индекс  1  и так далее. Индекс последнего символа будет длиной строки минус один.
 Например, схематическая диаграмма индексов строки  'foobar'  будет выглядеть так:
Строковые индексы
 Доступ к отдельным символам можно получить по индексу следующим образом:
>>>
  >>> s = 'foobar'

>>> s [0]
'f'
>>> s [1]
'о'
>>> s [3]
'b'
>>> len (s)
6
>>> s [len (s) -1]
'р'
  
 Попытка индексировать за пределами конца строки приводит к ошибке:
>>>
  >>> s [6]
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    s [6]
IndexError: индекс строки вне допустимого диапазона
  
 Индексы строки также могут быть указаны с отрицательными числами, и в этом случае индексация происходит с конца строки назад:  -1  относится к последнему символу,  -2  - к предпоследнему символу и т. Д.Вот та же диаграмма, показывающая как положительные, так и отрицательные индексы в строке  'foobar' :
.
 Положительные и отрицательные строковые индексы
 Вот несколько примеров отрицательной индексации:
>>>
  >>> s = 'foobar'

>>> s [-1]
'р'
>>> с [-2]
'а'
>>> len (s)
6
>>> s [-len (s)]
'f'
  
 Попытка индексирования с отрицательными числами за пределами начала строки приводит к ошибке:
>>>
  >>> с [-7]
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    с [-7]
IndexError: индекс строки вне допустимого диапазона
  
 Для любой непустой строки  с ,  с [лен (с) -1]  и  с [-1]  оба возвращают последний символ.Нет никакого индекса, который имел бы смысл для пустой строки.
 Нарезка струн 
 Python также позволяет использовать синтаксис индексации, который извлекает подстроки из строки, известный как нарезка строки. Если  s  является строкой, выражение вида  s [m: n]  возвращает часть  s , начиная с позиции  m  и до, но не включая позицию  n :
>>>
  >>> s = 'foobar'
>>> s [2: 5]
'оба'
  
  Помните:  Строковые индексы отсчитываются от нуля.Первый символ в строке имеет индекс  0 . Это относится как к стандартной индексации, так и к нарезке.
 Опять же, второй индекс определяет первый символ, который не включен в результат - символ  'r'  ( s [5] ) в примере выше. Это может показаться немного неинтуитивным, но дает такой результат, который имеет смысл: выражение  s [m: n]  вернет подстроку длиной  n - m  символов, в данном случае  5 - 2 = 3 .
 Если вы опустите первый индекс, срез начнется в начале строки. Таким образом,  с [: m]  и  с [0: m]  эквивалентны:
>>>
  >>> s = 'foobar'

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

>>> s [2:]
'обар'
>>> s [2: len (s)]
'обар'
  
 Для любой строки  s  и любого целого  n  ( 0 ≤ n ≤ len (s) )  s [: n] + s [n:]  будет равно  s :
>>>
  >>> s = 'foobar'

>>> s [: 4] + s [4:]
'foobar'
>>> s [: 4] + s [4:] == s
Истинный
  
 Если пропустить оба индекса, будет полностью возвращена исходная строка.В прямом смысле. Это не копия, это ссылка на исходную строку:
>>>
  >>> s = 'foobar'
>>> t = s [:]
>>> id (s)
59598496
>>> id (t)
59598496
>>> s is t
Истинный
  
 Если первый индекс в срезе больше или равен второму индексу, Python возвращает пустую строку. Это еще один запутанный способ сгенерировать пустую строку, если вы ее искали:
>>>
  >>> s [2: 2]
''
>>> s [4: 2]
''
  
 Отрицательные индексы также могут использоваться с нарезкой.–1  относится к последнему символу, –2  - предпоследнему и так далее, как и при простой индексации. На диаграмме ниже показано, как вырезать подстроку  'oob'  из строки  'foobar' , используя как положительные, так и отрицательные индексы:
Нарезка строки с положительными и отрицательными индексами
 Вот соответствующий код Python:
>>>
  >>> s = 'foobar'

>>> s [-5: -2]
'oob'
>>> s [1: 4]
'oob'
>>> s [-5: -2] == s [1: 4]
Истинный
  
 Указание шага в срезе строки 
 Остается обсудить еще один вариант синтаксиса нарезки.Добавление дополнительного :  и третьего индекса обозначает шаг (также называемый шагом), который указывает, на сколько символов нужно перейти после получения каждого символа в срезе.
 Например, для строки  'foobar'  фрагмент  0: 6: 2  начинается с первого символа и заканчивается последним символом (всей строкой), и каждый второй символ пропускается. Это показано на следующей диаграмме:
Индексирование строки с помощью Stride
 Аналогично,  1: 6: 2  определяет срез, начинающийся со второго символа (индекс  1 ) и заканчивающийся последним символом, и снова значение шага  2  заставляет пропускать все остальные символы. :
Другая строковая индексация с помощью Stride
 Пример кода REPL показан здесь:
>>>
  >>> s = 'foobar'

>>> s [0: 6: 2]
'foa'

>>> s [1: 6: 2]
'obr'
  
 Как и в случае любой нарезки, первый и второй индексы можно опустить и по умолчанию использовать первый и последний символы соответственно:
>>>
  >>> s = '12345' * 5
>>> с
'1234512345123451234512345'
>>> s [:: 5]
'11111'
>>> s [4 :: 5]
'55555'
  
 Вы также можете указать отрицательное значение шага, и в этом случае Python переместится назад по строке.В этом случае начальный / первый индекс должен быть больше, чем конечный / второй индекс:
>>>
  >>> s = 'foobar'
>>> s [5: 0: -2]
'rbo'
  
 В приведенном выше примере  5: 0: -2  означает «начать с последнего символа и сделать шаг назад на  2 , вплоть до первого символа, но не включая его».
 Когда вы делаете шаг назад, если первый и второй индексы опущены, значения по умолчанию меняются интуитивно понятным способом: первый индекс по умолчанию соответствует концу строки, а второй индекс по умолчанию - началу.Вот пример:
>>>
  >>> s = '12345' * 5
>>> с
'1234512345123451234512345'
>>> s [:: - 5]
'55555'
  
 Это обычная парадигма переворачивания строки:
>>>
  >>> s = 'Если товарищ Наполеон так говорит, значит, это правильно'.
>>> s [:: - 1]
'.thgir eb tsum ti, ti syas noelopaN edarmoC fI'
  
 Интерполяция переменных в строку 
 В версии Python 3.6 был представлен новый механизм форматирования строк.Эта функция официально называется литералом форматированной строки, но чаще упоминается по псевдониму  f-string .
 Возможности форматирования, предоставляемые f-строками, обширны и не будут здесь подробно рассматриваться. Если вы хотите узнать больше, вы можете ознакомиться со статьей Real Python «f-строки Python 3: улучшенный синтаксис форматирования строк» ​​(руководство). Позже в этой серии вы найдете учебное пособие по форматированному выводу, в котором более подробно рассматриваются f-строки.
 Одна простая функция f-струн, которую вы можете сразу начать использовать, - это интерполяция переменных.Вы можете указать имя переменной непосредственно в литерале f-строки, и Python заменит имя соответствующим значением.
 Например, предположим, что вы хотите отобразить результат арифметического вычисления. Вы можете сделать это с помощью простого оператора  print () , разделив числовые значения и строковые литералы запятыми:
>>>
  >>> п = 20
>>> m = 25
>>> prod = n * m
>>> print ('Произведение', n, 'и', m, 'is', prod)
Произведение 20 и 25 равно 500.
  
 Но это громоздко.Чтобы сделать то же самое, используя f-строку:
 Укажите строчные  f  или прописные  F  непосредственно перед открывающей кавычкой строкового литерала. Это говорит Python, что это f-строка, а не стандартная строка.
 Укажите любые переменные для интерполяции в фигурных скобках ( {} ).
 Повторное преобразование с использованием f-строки, приведенный выше пример выглядит намного чище:
>>>
  >>> п = 20
>>> m = 25
>>> prod = n * m
>>> print (f'Произведение {n} и {m} равно {prod} ')
Произведение 20 и 25 равно 500.
  
 Для определения f-строки можно использовать любой из трех механизмов цитирования Python:
>>>
  >>> var = 'Кора'

>>> print (f'A dog говорит {var}! ')
Собака говорит: "Лай!"
>>> print (f "Собака говорит {var}!")
Собака говорит Лай!
>>> print (f '' 'Собака говорит {var}!' '')
Собака говорит Лай!
  
 Изменение строк 
 Короче говоря, нельзя.Строки - это один из типов данных, которые Python считает неизменяемыми, то есть не подлежащими изменению. Фактически, все типы данных, которые вы видели до сих пор, неизменяемы. (Как вы скоро увидите, Python предоставляет типы данных, которые являются изменяемыми.)
 Подобный оператор вызовет ошибку:
>>>
  >>> s = 'foobar'
>>> s [3] = 'х'
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    s [3] = 'x'
TypeError: объект 'str' не поддерживает назначение элементов
  
 По правде говоря, нет особой необходимости изменять строки.Обычно вы можете легко выполнить то, что хотите, сгенерировав копию исходной строки, в которой есть желаемое изменение. В Python есть очень много способов сделать это. Вот одна возможность:
>>>
  >>> s = s [: 3] + 'x' + s [4:]
>>> с
'fooxar'
  
 Для этого существует также встроенный строковый метод:
>>>
  >>> s = 'foobar'
>>> s = s.replace ('б', 'х')
>>> с
'fooxar'
  
 Читайте дальше, чтобы узнать больше о встроенных строковых методах!
 Встроенные строковые методы 
 Из учебника по переменным в Python вы узнали, что Python является очень объектно-ориентированным языком.Каждый элемент данных в программе Python - это объект.
 Вы также знакомы с функциями: вызываемые процедуры, которые можно вызывать для выполнения определенных задач.
 Методы аналогичны функциям. Метод - это специализированный тип вызываемой процедуры, который тесно связан с объектом. Как и функция, метод вызывается для выполнения отдельной задачи, но он вызывается для конкретного объекта и знает о своем целевом объекте во время выполнения.
 Синтаксис вызова метода для объекта следующий:
 Это вызывает метод .foo ()  для объекта  obj .    указывает аргументы, передаваемые методу (если есть).
 Вы узнаете гораздо больше об определении и вызове методов позже при обсуждении объектно-ориентированного программирования. На данный момент цель состоит в том, чтобы представить некоторые из наиболее часто используемых встроенных методов, которые Python поддерживает для работы со строковыми объектами.
 В следующих определениях методов аргументы, указанные в квадратных скобках ( [] ), являются необязательными.
 Преобразование корпуса 
 Методы этой группы выполняют преобразование регистра в целевой строке.
  s.capitalize () 
 Делает целевую строку с заглавной буквы.
  s.capitalize ()  возвращает копию  s  с первым символом, преобразованным в верхний регистр, а все остальные символы преобразованы в нижний регистр:
>>>
  >>> s = 'foO BaR BAZ quX'
>>> s.capitalize ()
'Foo bar baz qux'
  
 Неалфавитные символы без изменений:
>>>
  >>> s = 'foo123 # BAR #.'
>>> s.capitalize ()
'Foo123 # bar #.'
  
  с. Нижний () 
 Преобразует буквенные символы в нижний регистр.
  s.lower ()  возвращает копию  s  со всеми буквенными символами, преобразованными в нижний регистр:
>>>
  >>> 'FOO Bar 123 baz qUX'.lower ()
'foo bar 123 baz qux'
  
  s.swapcase () 
 Меняет местами регистр буквенных символов.
  с.swapcase ()  возвращает копию  s  с прописными буквенными символами, преобразованными в строчные и наоборот:
>>>
  >>> 'FOO Bar 123 baz qUX'.swapcase ()
'foo bAR 123 BAZ Qux'
  
  название () 
 Преобразует целевую строку в «регистр заголовка».
  s.title ()  возвращает копию  s , в которой первая буква каждого слова преобразована в верхний регистр, а остальные буквы в нижний регистр:
>>>
  >>> 'солнце тоже восходит'.заглавие()
"И солнце восходит"
  
 В этом методе используется довольно простой алгоритм. Он не пытается различать важные и неважные слова, а также не изящно обрабатывает апострофы, притяжательные формы или акронимы:
>>>
  >>> «Что случилось с акциями IBM Теда?». Title ()
"Что случилось с Ibm Stock Теда?"
  
  с. Верх () 
 Преобразует буквенные символы в верхний регистр.
  с.upper ()  возвращает копию  s  со всеми буквенными символами, преобразованными в верхний регистр:
>>>
  >>> 'FOO Bar 123 baz qUX'.upper ()
'FOO BAR 123 BAZ QUX'
  
 Найти и заменить 
 Эти методы предоставляют различные средства поиска указанной подстроки в целевой строке.
 Каждый метод в этой группе поддерживает необязательные аргументы    и   . Они интерпретируются как нарезка строки: действие метода ограничено частью целевой строки, начинающейся с позиции символа    и продолжающейся до позиции символа   , но не включая ее.Если    указано, но не   , метод применяется к части целевой строки от    до конца строки.
  s.count ( [,  [, ]]) 
 Подсчитывает количество вхождений подстроки в целевой строке.
  s.count ()  возвращает количество неперекрывающихся вхождений подстроки    за  с :
>>>
  >>> 'foo goo moo'.count ('oo')
3
  
 Счетчик ограничен количеством вхождений в подстроке, указанной как    и   , если они указаны:
>>>
  >>> 'foo goo moo'.count (' oo ', 0, 8)
2
  
  s.endswith (<суффикс> [, <начало> [, <конец>]]) 
 Определяет, заканчивается ли целевая строка заданной подстрокой.
  s.endswith (<суффикс>)  возвращает  True , если  s  заканчивается указанным  <суффикс>  и  False  в противном случае:
>>>
  >>> 'foobar'.заканчивается ('бар')
Истинный
>>> 'foobar'.endswith (' баз ')
Ложь
  
 Сравнение ограничено подстрокой, указанной как    и   , если они указаны:
>>>
  >>> 'foobar'.endswith (' oob ', 0, 4)
Истинный
>>> 'foobar'.endswith (' oob ', 2, 4)
Ложь
  
  s.find ( [,  [, ]]) 
 Ищет в целевой строке заданную подстроку.
 Вы можете использовать  .find () , чтобы узнать, содержит ли строка Python конкретную подстроку.  s.find ()  возвращает самый низкий индекс за  s , где найдена подстрока   :
>>>
  >>> 'foo bar foo baz foo qux'.find (' foo ')
0
  
 Этот метод возвращает  -1 , если указанная подстрока не найдена:
>>>
  >>> 'foo bar foo baz foo qux'.найти ('grault')
-1
  
 Поиск ограничен подстрокой, указанной как    и   , если они указаны:
>>>
  >>> 'foo bar foo baz foo qux'.find (' foo ', 4)
8
>>> 'фу бар фу баз фу qux'.find (' фу ', 4, 7)
-1
  
  s.index ( [,  [, ]]) 
 Ищет в целевой строке заданную подстроку.
 Этот метод идентичен .find () , за исключением того, что он вызывает исключение, если    не найден, а не возвращает -1 :
>>>
  >>> 'foo bar foo baz foo qux'.index (' grault ')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    'foo bar foo baz foo qux'.index (' grault ')
ValueError: подстрока не найдена
  
  s.rfind ( [,  [, ]]) 
 Ищет в целевой строке заданную подстроку, начиная с конца.
  s.rfind ()  возвращает наивысший индекс за  s , где найдена подстрока   :
>>>
  >>> 'фу бар фу баз фу qux'.rfind (' фу ')
16
  
 Как и в случае с  .find () , если подстрока не найдена, возвращается -1 :
>>>
  >>> 'foo bar foo baz foo qux'.rfind (' grault ')
-1
  
 Поиск ограничен подстрокой, указанной как    и   , если они указаны:
>>>
  >>> 'foo bar foo baz foo qux'.rfind ('фу', 0, 14)
8
>>> 'фу бар фу баз фу qux'.rfind (' фу ', 10, 14)
-1
  
  s.rindex ( [,  [, ]]) 
 Ищет в целевой строке заданную подстроку, начиная с конца.
 Этот метод идентичен  .rfind () , за исключением того, что он вызывает исключение, если    не найден, а не возвращает -1 :
>>>
  >>> 'foo bar foo baz foo qux'.rindex ('граулт')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    'foo bar foo baz foo qux'.rindex (' граулт ')
ValueError: подстрока не найдена
  
  s.startswith (<префикс> [, <начало> [, <конец>]]) 
 Определяет, начинается ли целевая строка с данной подстроки.
 При использовании метода Python  .startswith ()   s.startswith ()  возвращает  True , если  s  начинается с указанного    и  False  в противном случае:
>>>
  >>> 'foobar'.начинается с ('фу')
Истинный
>>> 'foobar'.startswith (' бар ')
Ложь
  
 Сравнение ограничено подстрокой, указанной как    и   , если они указаны:
>>>
  >>> 'foobar'.startswith (' bar ', 3)
Истинный
>>> 'foobar'.startswith (' бар ', 3, 2)
Ложь
  
 Классификация персонажей 
 Методы этой группы классифицируют строку на основе содержащихся в ней символов.
  s.isalnum () 
 Определяет, состоит ли целевая строка из буквенно-цифровых символов.
  s.isalnum ()  возвращает  True , если  s  непусто и все его символы являются буквенно-цифровыми (буква или число), а  False  в противном случае:
>>>
  >>> 'abc123'.isalnum ()
Истинный
>>> 'abc $ 123'.isalnum ()
Ложь
>>> '' .isalnum ()
Ложь
  
  с.isalpha () 
 Определяет, состоит ли целевая строка из буквенных символов.
  s.isalpha ()  возвращает  True , если  s  непусто и все его символы буквенные, и  False  в противном случае:
>>>
  >>> 'ABCabc'.isalpha ()
Истинный
>>> 'abc123'.isalpha ()
Ложь
  
  s.isdigit () 
 Определяет, состоит ли целевая строка из цифровых символов.
 Вы можете использовать метод Python  .isdigit () , чтобы проверить, состоит ли ваша строка только из цифр.  s.isdigit ()  возвращает  True , если  s  непусто и все его символы являются числовыми цифрами, и  False  в противном случае:
>>>
  >>> '123'.isdigit ()
Истинный
>>> '123abc'.isdigit ()
Ложь
  
  s.isidentifier () 
 Определяет, является ли целевая строка допустимым идентификатором Python.
  s.isidentifier ()  возвращает  True , если  s  является допустимым идентификатором Python в соответствии с определением языка, и  False  в противном случае:
>>>
  >>> 'foo32'.isidentifier ()
Истинный
>>> '32foo'.isidentifier ()
Ложь
>>> 'foo $ 32'.isidentifier ()
Ложь
  
  Примечание:   .isidentifier ()  вернет  True  для строки, соответствующей ключевому слову Python, даже если на самом деле это не будет действительным идентификатором:
>>>
  >>> 'и'.isidentifier ()
Истинный
  
 Вы можете проверить, соответствует ли строка ключевому слову Python, используя функцию  iskeyword () , которая содержится в модуле  keyword . Один из возможных способов сделать это показан ниже:
>>>
  >>> from keyword import iskeyword
>>> iskeyword ('и')
Истинный
  
 Если вы действительно хотите убедиться, что строка будет служить допустимым идентификатором Python, вам следует проверить, что .isidentifier ()  - это  True , а  iskeyword ()  -  False .
 См. Модули и пакеты Python - Введение, чтобы узнать больше о модулях Python.
  с. Ниже () 
 Определяет, являются ли буквенные символы целевой строки строчными буквами.
  s.islower ()  возвращает  True , если  s  непусто и все содержащиеся в нем буквенные символы строчные, и  False  в противном случае.Неалфавитные символы игнорируются:
>>>
  >>> 'abc'.islower ()
Истинный
>>> 'abc1 $ d'.islower ()
Истинный
>>> 'Abc1 $ D'.islower ()
Ложь
  
  s. Печатная () 
 Определяет, состоит ли целевая строка полностью из печатаемых символов.
  s.isprintable ()  возвращает  True , если  s  пусто или все содержащиеся в нем буквенные символы можно распечатать.Он возвращает  False , если  s  содержит хотя бы один непечатаемый символ. Неалфавитные символы игнорируются:
>>>
  >>> 'a \ tb'.isprintable ()
Ложь
>>> 'a b'.isprintable ()
Истинный
>>> '' .isprintable ()
Истинный
>>> 'a \ nb'.isprintable ()
Ложь
  
  Примечание:  Это единственный метод  .isxxxx () , который возвращает  True , если  s  - пустая строка. Все остальные возвращают  False  для пустой строки.
  s. Пробел () 
 Определяет, состоит ли целевая строка из пробельных символов.
  s.isspace ()  возвращает  True , если  s  непусто и все символы являются пробельными символами, и  False  в противном случае.
 Наиболее часто встречающиеся пробельные символы - это пробел  '' , табуляция  '\ t'  и новая строка  '\ n' :
.
 >>>
  >>> '\ t \ n'.isspace ()
Истинный
>>> 'а' .isspace ()
Ложь
  
 Однако есть несколько других символов ASCII, которые квалифицируются как пробелы, и если вы учитываете символы Unicode, их довольно много помимо этого:
>>>
  >>> '\ f \ u2005 \ r'.isspace ()
Истинный
  
 ( '\ f'  и  '\ r'  - это escape-последовательности для символов подачи формы ASCII и символов возврата каретки;  '\ u2005'  - это escape-последовательности для Unicode Four-Per-Em Space.)
  с. Наименование () 
 Определяет, имеет ли целевая строка регистр заголовка.
  s.istitle ()  возвращает  True , если  s  непусто, первый буквенный символ каждого слова - заглавные, а все остальные буквенные символы в каждом слове - строчные. Возвращает  Ложь  иначе:
>>>
  >>> 'This Is A Title'. Название ()
Истинный
>>> 'Это заголовок'.istitle ()
Ложь
>>> «Дайте мне # $ # @ Ball!».istitle ()
Истинный
  
  Примечание:  Вот как документация Python описывает  .istitle () , на случай, если вы сочтете это более интуитивным: «Заглавные символы могут следовать только за символами без регистра, а за символами в нижнем регистре - только за ними».
  с. Верхний () 
 Определяет, являются ли буквенные символы целевой строки прописными.
  s.isupper ()  возвращает  True , если  s  непусто и все содержащиеся в нем буквенные символы прописные, а  False  в противном случае.Неалфавитные символы игнорируются:
>>>
  >>> 'ABC'.isupper ()
Истинный
>>> 'ABC1 $ D'.isupper ()
Истинный
>>> 'Abc1 $ D'.isupper ()
Ложь
  
 Форматирование строки 
 Методы этой группы изменяют или улучшают формат строки.
  s.center ( [, ]) 
 Центрирует строку в поле.
  s.center ()  возвращает строку, состоящую из  s  с центром в поле шириной   .По умолчанию заполнение состоит из символа пробела ASCII:
.
 >>>
  >>> 'foo'.center (10)
'фу'
  
 Если указан необязательный аргумент   , он используется в качестве символа заполнения:
>>>
  >>> 'bar'.center (10,' - ')
'---бар----'
  
 Если  с  уже не меньше  <ширина> , он возвращается без изменений:
>>>
  >>> 'фу'.центр (2)
'фу'
  
  s.expandtabs (tabsize = 8) 
 Раскрывает табуляции в строке.
  s.expandtabs ()  заменяет каждый символ табуляции ( '\ t' ) пробелами. По умолчанию пробелы заполняются с учетом позиции табуляции в каждом восьмом столбце:
>>>
  >>> 'a \ tb \ tc'.expandtabs ()
'а б в'
>>> 'aaa \ tbbb \ tc'.expandtabs ()
'aaa bbb c'
  
  tabsize  - необязательный параметр ключевого слова, определяющий альтернативные столбцы табуляции:
>>>
  >>> 'а \ tb \ tc'.expandtabs (4)
'а б в'
>>> 'aaa \ tbbb \ tc'.expandtabs (tabsize = 4)
'aaa bbb c'
  
  s.ljust (<ширина> [, <заполнить>]) 
 Выравнивает строку в поле по левому краю.
  s.ljust ()  возвращает строку, состоящую из  s , выровненных по левому краю, в поле шириной   . По умолчанию заполнение состоит из символа пробела ASCII:
.
 >>>
  >>> 'foo'.ljust (10)
'фу'
  
 Если указан необязательный аргумент   , он используется в качестве символа заполнения:
>>>
  >>> 'фу'.ljust (10, '-')
'фу -------'
  
 Если  с  уже не меньше  <ширина> , он возвращается без изменений:
>>>
  >>> 'foo'.ljust (2)
'фу'
  
  s.lstrip ([]) 
 Обрезает начальные символы строки.
  s.lstrip ()  возвращает копию  s  с любыми пробельными символами, удаленными с левого края:
>>>
  >>> 'foo bar baz'.lstrip ()
'foo bar baz'
>>> '\ t \ nfoo \ t \ nbar \ t \ nbaz'.lstrip ()
'foo \ t \ nbar \ t \ nbaz'
  
 Если указан необязательный аргумент   , это строка, которая определяет набор символов, которые необходимо удалить:
>>>
  >>> 'http: //www.realpython.com'.lstrip (' /: pth ')
"www.realpython.com"
  
  s.replace (,  [, ]) 
 Заменяет вхождения подстроки в строке.
 В Python для удаления символа из строки можно использовать метод Python string  .replace () .  s.replace (, )  возвращает копию  s  со всеми вхождениями подстроки   , замененной на   :
>>>
  >>> 'foo bar foo baz foo qux'.replace (' foo ',' grault ')
'Grault Bar Grault Baz Grault Qux'
  
 Если указан необязательный аргумент   , выполняется максимум    замен, начиная с левого конца  с :
>>>
  >>> 'foo bar foo baz foo qux'.replace ('фу', 'граулт', 2)
'grault bar grault baz foo qux'
  
  s.rjust ( [, ]) 
 Выравнивает строку в поле по правому краю.
  s.rjust ()  возвращает строку, состоящую из  s , выровненных по правому краю, в поле шириной   . По умолчанию заполнение состоит из символа пробела ASCII:
.
 >>>
  >>> 'foo'.rjust (10)
'фу'
  
 Если указан необязательный аргумент   , он используется в качестве символа заполнения:
>>>
  >>> 'фу'.rjust (10, '-')
'------- фу'
  
 Если  с  уже не меньше  <ширина> , он возвращается без изменений:
>>>
  >>> 'foo'.rjust (2)
'фу'
  
  s.rstrip ([]) 
 Обрезает завершающие символы строки.
  s.rstrip ()  возвращает копию  s  с удаленными пробельными символами с правого конца:
>>>
  >>> 'foo bar baz'.rstrip ()
'foo bar baz'
>>> 'foo \ t \ nbar \ t \ nbaz \ t \ n'.rstrip ()
'foo \ t \ nbar \ t \ nbaz'
  
 Если указан необязательный аргумент   , это строка, которая определяет набор символов, которые необходимо удалить:
>>>
  >>> 'foo. $$$;'. Rstrip ('; $.')
'фу'
  
  s.strip ([]) 
 Удаляет символы с левого и правого концов строки.
  s.strip ()  по существу эквивалентен вызову  s.lstrip ()  и  s.rstrip ()  последовательно. Без аргумента    он удаляет начальные и конечные пробелы:
>>>
  >>> s = 'foo bar baz \ t \ t \ t'
>>> s = s.lstrip ()
>>> s = s.rstrip ()
>>> с
'foo bar baz'
  
 Как и в случае с  .lstrip ()  и  .rstrip () , необязательный аргумент    указывает набор символов, которые необходимо удалить:
>>>
  >>> 'www.realpython.com'.strip ('w.moc')
'realpython'
  
  Примечание:  Когда возвращаемое значение строкового метода является другой строкой, как это часто бывает, методы могут быть вызваны последовательно путем объединения вызовов:
>>>
  >>> 'foo bar baz \ t \ t \ t'.lstrip (). Rstrip ()
'foo bar baz'
>>> 'foo bar baz \ t \ t \ t'.strip ()
'foo bar baz'

>>> 'www.realpython.com'.lstrip (' w.moc '). rstrip (' w.moc ')
'realpython'
>>> 'www.realpython.com'.полоса ('w.moc')
'realpython'
  
  s.zfill (<ширина>) 
 Добавляет нули в строку слева.
  s.zfill ()  возвращает копию  s  с заполнением слева  '0'  символов до указанного   :
>>>
  >>> '42'.zfill (5)
«00042»
  
 Если  s  содержит начальный знак, он остается у левого края строки результата после вставки нулей:
>>>
  >>> '+42'.zfill (8)
'+0000042'
>>> '-42'.zfill (8)
'-0000042'
  
 Если  с  уже не меньше  <ширина> , он возвращается без изменений:
>>>
  >>> '-42'.zfill (3)
'-42'
  
  .zfill ()  наиболее полезен для строковых представлений чисел, но Python все равно с радостью выполнит обнуление строки, которая не является:
>>>
  >>> 'foo'.zfill (6)
'000foo'
  
 Преобразование между строками и списками 
 Методы этой группы преобразуют строку в какой-либо составной тип данных, либо склеивая объекты вместе, чтобы получилась строка, либо разбивая строку на части.
 Эти методы работают или возвращают  итераций , общий термин Python для последовательного набора объектов. Вы изучите внутреннюю работу итераций более подробно в следующем руководстве по определенной итерации.
 Многие из этих методов возвращают либо список, либо кортеж. Это два похожих составных типа данных, которые являются прототипами итераций в Python. Они будут рассмотрены в следующем руководстве, так что скоро вы узнаете о них! А пока считайте их просто последовательностями значений.Список заключен в квадратные скобки ( [] ), а кортеж заключен в круглые скобки ( () ).
 После этого введения давайте взглянем на последнюю группу строковых методов.
  s.join () 
 Объединяет строки из итерируемого объекта.
  s.join ()  возвращает строку, полученную в результате объединения объектов в   , разделенных  s .
 Обратите внимание, что  .join ()  вызывается на  s , строке-разделителе.    также должна быть последовательностью строковых объектов.
 Некоторые примеры кода должны помочь прояснить ситуацию. В следующем примере разделитель  s  - это строка  ',' , а    - это список строковых значений:
>>>
  >>> ',' .join (['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'
  
 Результат - одна строка, состоящая из объектов списка, разделенных запятыми.
 В следующем примере    указывается как одно строковое значение. Когда строковое значение используется как повторяющееся, оно интерпретируется как список отдельных символов строки:
>>>
  >>> список ('corge')
['c', 'o', 'r', 'g', 'e']

>>> ':'. join ('corge')
'c: o: r: g: e'
  
 Таким образом, результат  ':'. Join ('corge')  представляет собой строку, состоящую из каждого символа в  'corge' , разделенных  ':' .
 Этот пример не выполняется, потому что один из объектов в    не является строкой:
>>>
  >>> '---'. Join (['foo', 23, 'bar'])
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    '---'. join (['foo', 23, 'bar'])
TypeError: элемент последовательности 1: ожидаемый экземпляр str, найдено int
  
 Но это можно исправить:
>>>
  >>> '---'. Join (['foo', str (23), 'bar'])
'foo --- 23 --- bar'
  
 Как вы вскоре увидите, многие составные объекты в Python могут быть сконструированы как итерируемые объекты, а .join ()  особенно полезен для создания из них строк.
  раздел () 
 Делит строку по разделителю.
  s.partition ()  разбивает  s  при первом появлении строки   . Возвращаемое значение представляет собой кортеж из трех частей, состоящий из:
 Часть  с , предшествующая   
    сам
 Часть  с  после   
 Вот несколько примеров .partition ()  в действии:
>>>
  >>> 'foo.bar'.partition ('. ')
('фу', '.', 'бар')
>>> 'foo @@ bar @@ baz'.partition (' @@ ')
('foo', '@@', 'bar @@ baz')
  
 Если    не найдено в  s , возвращаемый кортеж содержит  s , за которыми следуют две пустые строки:
>>>
  >>> 'foo.bar'.partition (' @@ ')
('foo.bar', '', '')
  
  Помните:  Списки и кортежи рассматриваются в следующем руководстве.
  с.р раздел () 
 Делит строку по разделителю.
  s.rpartition ()  работает точно так же, как  s.partition () , за исключением того, что  s.  разбивается на последнее вхождение    вместо первого вхождения:
>>>
  >>> 'foo @@ bar @@ baz'.partition (' @@ ')
('foo', '@@', 'bar @@ baz')

>>> 'foo @@ bar @@ baz'.rpartition (' @@ ')
('foo @@ bar', '@@', 'baz')
  
  с.rsplit (sep = None, maxsplit = -1) 
 Разбивает строку на список подстрок.
 Без аргументов  s.rsplit ()  разбивает  s  на подстроки, разделенные любой последовательностью пробелов, и возвращает подстроки в виде списка:
>>>
  >>> 'foo bar baz qux'.rsplit ()
['foo', 'bar', 'baz', 'qux']
>>> 'foo \ n \ tbar baz \ r \ fqux'.rsplit ()
['foo', 'bar', 'baz', 'qux']
  
 Если указано   , оно используется в качестве разделителя для разделения:
>>>
  >>> 'foo.bar.baz.qux'.rsplit (sep = '.')
['foo', 'bar', 'baz', 'qux']
  
 (Если    указано со значением  None , строка разделяется пробелами, как если бы    не было указано вообще.)
 Когда    явно задано как разделитель, предполагается, что последовательные разделители в  с  ограничивают пустые строки, которые будут возвращены:
>>>
  >>> 'foo...bar'.rsplit (sep = '.')
['фу', '', '', 'бар']
  
 Однако это не тот случай, когда    опущено. В этом случае последовательные символы пробелов объединяются в один разделитель, и результирующий список никогда не будет содержать пустых строк:
>>>
  >>> 'foo \ t \ t \ tbar'.rsplit ()
['фу', 'бар']
  
 Если указан необязательный параметр ключевого слова   , выполняется максимальное из этого количества разбиений, начиная с правого конца  с :
>>>
  >>> 'www.realpython.com'.rsplit (sep = '.', maxsplit = 1)
['www.realpython', 'com']
  
 Значение по умолчанию для    - -1 , что означает, что должны быть выполнены все возможные разбиения - то же самое, как если бы    полностью опущено:
>>>
  >>> 'www.realpython.com'.rsplit (sep ='. ', Maxsplit = -1)
['www', 'realpython', 'com']
>>> 'www.realpython.com'.rsplit (sep ='. ')
['www', 'realpython', 'com']
  
  с.split (sep = None, maxsplit = -1) 
 Разбивает строку на список подстрок.
  s.split ()  ведет себя точно так же, как  s.rsplit () , за исключением того, что если указано   , разделения отсчитываются с левого конца  с , а не с правого конца:
>>>
  >>> 'www.realpython.com'.split ('. ', Maxsplit = 1)
['www', 'realpython.com']
>>> 'www.realpython.com'.rsplit ('. ', maxsplit = 1)
['www.realpython ',' com ']
  
 Если    не указано,  .split ()  и  .rsplit ()  неотличимы.
  s.splitlines ([]) 
 Разрывает строку по границам строки.
  s.splitlines ()  разбивает  s  на строки и возвращает их в виде списка. Любой из следующих символов или последовательностей символов считается границей строки:
 Последовательность выхода
 Персонаж
  \ n 
 Новая строка
  
 Возврат каретки
  \ r \ n 
 Возврат каретки + перевод строки
  \ v  или  \ x0b 
 Строчная таблица
  \ f  или  \ x0c 
 Подача формы
  \ x1c 
 Разделитель файлов
  \ x1d 
 Разделитель групп
  \ x1e 
 Разделитель записей
  \ x85 
 Следующая строка (код управления C1)
  \ u2028 
 Разделитель строк Unicode
  \ u2029 
 Разделитель абзацев Unicode
 Вот пример использования нескольких разных разделителей строк:
>>>
  >>> 'foo \ nbar \ r \ nbaz \ fqux \ u2028quux'.splitlines ()
['foo', 'bar', 'baz', 'qux', 'quux']
  
 Если в строке присутствуют последовательные символы границы строки, предполагается, что они ограничивают пустые строки, которые появятся в списке результатов:
>>>
  >>> 'foo \ f \ f \ fbar'.splitlines ()
['фу', '', '', 'бар']
  
 Если необязательный аргумент    указан и является истинным, то границы строк сохраняются в строках результатов:
>>>
  >>> 'foo \ nbar \ nbaz \ nqux'.splitlines (True)
['foo \ n', 'bar \ n', 'baz \ n', 'qux']
>>> 'foo \ nbar \ nbaz \ nqux'.splitlines (1)
['foo \ n', 'bar \ n', 'baz \ n', 'qux']
  
 .
Добавить комментарий Отменить ответ
Ваш адрес email не будет опубликован. Обязательные поля помечены *
Комментарий *
Имя * 
Email * 
Сайт