Строки пайтон: Интерактивный учебник языка Python

Содержание

Интерактивный учебник языка Python

Занятие 5. Строки

1. Строки

Строка считывается со стандартного ввода функцией input(). Напомним, что для двух строк определена операция сложения (конкатенации), также определена операция умножения строки на число.

Строка состоит из последовательности символов. Узнать количество символов (длину строки) можно при помощи функции len.

Любой другой объект в Питоне можно перевести к строке, которая ему соответствует. Для этого нужно вызвать функцию str(), передав ей в качестве параметра объект, переводимый в строку.

На самом деле каждая строка, с точки зрения Питона, — это объект класса str. Чтобы получить по объекту другой объект другого класса, как-то ему соответствующий, можно использовать функцию приведения. Имя этой функции совпадает с именем класса, к которому мы приводим объект. (Для знатоков: эта функция — это конструктор объектов данного класса. ) Пример: int — класс для целых чисел. Перевод строки в число осуществляется функцией

int().

s = input()
print(len(s))
t = input()
number = int(t)
u = str(number)
print(s * 3)
print(s + ' ' + u)

2. Срезы (slices)

Срез (slice) — извлечение из данной строки одного символа или некоторого фрагмента подстроки или подпоследовательности.

Есть три формы срезов. Самая простая форма среза: взятие одного символа строки, а именно, S[i] — это срез, состоящий из одного символа, который имеет номер i. При этом считается, что нумерация начинается с числа 0. То есть если S = 'Hello', то S[0] == 'H', S[1] == 'e', S[2] == 'l',

S[3] == 'l', S[4] == 'o'.

Заметим, что в Питоне нет отдельного типа для символов строки. Каждый объект, который получается в результате среза S[i] — это тоже строка типа str.

Номера символов в строке (а также в других структурах данных: списках, кортежах) называются индексом.

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

, S[-5] == 'H'.

Или в виде таблицы:

Строка S	H	e	l	l	o
Индекс	S[0]	S[1]	S[2]	S[3]	S[4]
Индекс	S[-5]	S[-4]	S[-3]	S[-2]	S[-1]

Если же номер символа в срезе строки

S больше либо равен len(S), или меньше, чем -len(S), то при обращении к этому символу строки произойдет ошибка IndexError: string index out of range.

Срез с двумя параметрами: S[a:b] возвращает подстроку из b - a символов, начиная с символа c индексом a, то есть до символа с индексом b, не включая его. Например, S[1:4] == 'ell', то же самое получится если написать S[-4:-1]. Можно использовать как положительные, так и отрицательные индексы в одном срезе, например,

S[1:-1] — это строка без первого и последнего символа (срез начинается с символа с индексом 1 и заканчиватеся индексом -1, не включая его).

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

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

Аналогично если опустить первый параметр, то можно взять срез от начала строки. То есть удалить из строки последний символ можно при помощи среза S[:-1]. Срез S[:] совпадает с самой строкой S.

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

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

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

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

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

3. Методы

Метод — это функция, применяемая к объекту, в данном случае — к строке. Метод вызывается в виде Имя_объекта.Имя_метода(параметры). Например, S.find("e") — это применение к строке S метода find с одним параметром "e".

3.1. Методы find и rfind

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

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

S = 'Hello'
print(S.find('e'))
# вернёт 1
print(S.find('ll'))
# вернёт 2
print(S.find('L'))
# вернёт -1

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

S = 'Hello'
print(S.find('l'))
# вернёт 2
print(S.rfind('l'))
# вернёт 3

Если вызвать метод find с тремя параметрами S.find(T, a, b), то поиск будет осуществляться в срезе

S[a:b]. Если указать только два параметра S.find(T, a), то поиск будет осуществляться в срезе S[a:], то есть начиная с символа с индексом a и до конца строки. Метод S.find(T, a, b) возращает индекс в строке S, а не индекс относительно среза.

3.2. Метод replace

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

print('Hello'.replace('l', 'L'))
# вернёт 'HeLLo'

Если методу replace задать еще один параметр: S.replace(old, new, count), то заменены будут не все вхождения, а только не больше, чем первые count из них.

print('Abrakadabra'.replace('a', 'A', 2))
# вернёт 'AbrAkAdabra'

3.3. Метод count

Подсчитывает количество вхождений одной строки в другую строку. Простейшая форма вызова S.count(T) возвращает число вхождений строки T внутри строки S. При этом подсчитываются только непересекающиеся вхождения, например:

print('Abracadabra'.count('a'))
# вернёт 4
print(('a' * 10).count('aa'))
# вернёт 5

При указании трех параметров S.count(T, a, b), будет выполнен подсчет числа вхождений строки T в срезе S[a:b].

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

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

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

Строка представляет последовательность символов в кодировке Unicode, заключенных в кавычки. Причем для определения строк Python позволяет использовать как одинарные, так и двойные кавычики:


message = "Hello World!"
print(message)  # Hello World!

name = 'Tom'
print(name)  # Tom

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


text = ("Laudate omnes gentes laudate "
        "Magnificat in secula ")
print(text)

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


'''
Это комментарий
'''
text = '''Laudate omnes gentes laudate
Magnificat in secula
Et anima mea laudate
Magnificat in secula 
'''
print(text)

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

Управляющие последовательности в строке

Строка может содержать ряд специальных символов — управляющих последовательностей или escape-последовательности. Некоторые из них:

\: позволяет добавить внутрь строки слеш
\’: позволяет добавить внутрь строки одинарную кавычку
\»: позволяет добавить внутрь строки двойную кавычку
\n: осуществляет переход на новую строку
\t: добавляет табуляцию (4 отступа)

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


text = "Message:\n\"Hello World\""
print(text)

Консольный вывод программы:


Message:
"Hello World"

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


path = "C:\python\name.txt"
print(path)

Здесь переменная path содержит некоторый путь к файлу. Однако внутри строки встречаются символы «\n», которые будут интерпретированы как управляющая последовательность. Так, мы получим следующий консольный вывод:


C:\python
ame.txt

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


path = r"C:\python\name.txt"
print(path)

Вставка значений в строку

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


userName = "Tom"
userAge = 37
user = f"name: {userName}  age: {userAge}"
print(user)   # name: Tom  age: 37

В данном случае на место {userName} будет вставляться значение переменной userName. Аналогично на вместо {userAge} будет вставляться значение переменной userAge.

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

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


string = "hello world"
c0 = string[0]  # h
print(c0)
c6 = string[6]  # w
print(c6)

c11 = string[11]  # ошибка IndexError: string index out of range
print(c11)

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

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

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

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

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

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

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

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

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

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

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

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

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


string = "hello world"

# с 0 до 5 индекса
sub_string1 = string[:5]
print(sub_string1)      # hello

# со 2 до 5 индекса
sub_string2 = string[2:5]
print(sub_string2)      # llo

# с 2 по 9 индекса через один символ
sub_string3 = string[2:9:2]
print(sub_string3)      # lowr

Объединение строк

Одной из самых распространенных операций со строками является их объединение или конкатенация. Для объединения строк применяется операция сложения:


name = "Tom"
surname = "Smith"
fullname = name + " " + surname
print(fullname)  # Tom Smith

С объединением двух строк все просто, но что, если нам надо сложить строку и число? В этом случае необходимо привести число к строке с помощью функции str():


name = "Tom"
age = 33
info = "Name: " + name + " Age: " + str(age)
print(info)  # Name: Tom Age: 33

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

Для повторения строки определенное количество раз применяется операция умножения:


print("a" * 3)  # aaa
print("he" * 4)  # hehehehe

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

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


str1 = "1a"
str2 = "aa"
str3 = "Aa"
print(str1 > str2)  # False, так как первый символ в str1 - цифра
print(str2 > str3)  # True, так как первый символ в str2 - в нижнем регистре

Поэтому строка «1a» условно меньше, чем строка «aa». Вначале сравнение идет по первому символу. Если начальные символы обоих строк представляют цифры, то меньшей считается меньшая цифра, например, «1a» меньше, чем «2a».

Если начальные символы представляют алфавитные символы в одном и том же регистре, то смотрят по алфавиту. Так, «aa» меньше, чем «ba», а «ba» меньше, чем «ca».

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

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

Функция lower() приводит строку к нижнему регистру, а функция upper() — к верхнему.


str1 = "Tom"
str2 = "tom"
print(str1 == str2)  # False - строки не равны

print(str1.lower() == str2.lower())  # True

Функции ord и len

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

print(ord("A"))     # 65

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

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

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

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

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

НазадСодержаниеВперед

Строки | Основы Python

Зарегистрируйтесь для доступа к 15+ бесплатным курсам по программированию с тренажером

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

Определить строку довольно просто — это некий набор символов. Представим, что у нас есть такие записи:

'Hello'
'Goodbye'
'G'
' '
''

Какие из этих вариантов — строки? На самом деле, все пять вариантов подходят:

С 'Hello' и 'Goodbye' все очевидно — мы уже работали с подобными конструкциями и называли их строками
'G' и ' ' — тоже строки, просто в них всего по одному символу
'' — это пустая строка, потому в ней ноль символов

Кавычки

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

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

print("Dracarys!")

Теперь представьте, что вы хотите напечатать строчку Dragon’s mother. Апостроф перед буквой s — это такой же символ, как одинарная кавычка. Попробуем:

print('Dragon's mother')
# SyntaxError: invalid syntax

Такая программа не будет работать. С точки зрения Python строчка началась с одинарной кавычки, а потом закончилась после слова dragon. Дальше были символы s mother без кавычек — значит, это не строка. А потом была одна открывающая строку кавычка, которая так и не закрылась: '). Этот код содержит синтаксическую ошибку — это видно даже по тому, как подсвечен код.

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

print("Dragon's mother")

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

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

Теперь представим, что мы хотим создать такую строку:

Dragon's mother said "No"

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

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

# Экранируем кавычки вокруг No, чтобы интерпретатор
# распознал их как часть строки
print("Dragon's mother said \"No\"")
# => Dragon's mother said "No"

Обратите внимание, что в примере выше нам не пришлось экранировать одинарную кавычку (апостроф ‘s), потому что сама строка создана с двойными кавычками. Если бы строка создавалась с одинарными кавычками, то символ экранирования нужен был бы перед апострофом, но не перед двойными кавычками.

Если нужно вывести сам обратный слеш, то работает такое же правило. Как и любой другой специальный символ, его надо экранировать:

print("\\")
# => \

Экранированные последовательности

Мы хотим показать вот такой диалог:

- Are you hungry?
- Aaaarrrgh!

Попробуем вывести на экран строку с таким текстом:

print("- Are you hungry?- Aaaarrrgh!")
# => - Are you hungry?- Aaaarrrgh!

Как видите, результат получился не такой, как мы хотели. Строки расположились друг за другом, а не одна ниже другой. Нам нужно как-то сказать интерпретатору «нажать на Enter» — сделать перевод строки после вопросительного знака. Это можно сделать с помощью символа \n:

print("- Are you hungry?\n- Aaaarrrgh!")
# => - Are you hungry?
# => - Aaaarrrgh!

\n — это пример экранированной последовательности (escape sequence). Такие последовательности еще называют управляющими конструкциями. Их нельзя увидеть в том же виде, в котором их набрали.

Набирая текст в Word, вы нажимаете на Enter в конце строчки. Редактор при этом ставит в конец строчки специальный невидимый символ, который называется LINE FEED (LF, перевод строчки). В некоторых редакторах можно даже включить отображение невидимых символов. Тогда текст будет выглядеть примерно так:

- Привет!¶
- О, привет!¶
- Как дела?

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

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

табуляция \t — разрыв, который получается при нажатии на кнопку Tab
возврат каретки \r — работает только в Windows

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

print("Gregor Clegane\nDunsen\nPolliver\nChiswyck")

Тогда на экран выведется:

Gregor Clegane
Dunsen
Polliver
Chiswyck

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

Не важно, что стоит перед или после \n: символ или пустая строка. Перевод обнаружится и выполнится в любом случае

Строка может содержать только \n:

print('Gregor Clegane') # Строка с текстом
print("\n") # Строка с невидимыми символов перевода строки
print('Dunsen') # Строка с текстом

Программа выведет на экран:

Gregor Clegane
Dunsen

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

print("Joffrey loves using \\n")
# => Joffrey loves using \n

В Windows для перевода строк по умолчанию используется \r\n. Такая комбинация хорошо работает только в Windows, но создает проблемы при переносе в другие системы. Например, когда в команде разработчиков есть пользователи Linux.

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

В таком случае перевод строки всегда трактуется одинаково и отлично работает в любой системе. Не забудьте настроить ваш редактор на использование \n.

Конкатенация

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

Чтобы соединить строки, нужно выполнить конкатенацию:

# Оператор такой же, как и при сложении чисел,
# но здесь он имеет другой смысл (семантику)
print('Dragon' + 'stone')  # => Dragonstone

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

print('Kings' + 'wood')      # => Kingswood
print('Kings' + 'road')      # => Kingsroad
print("King's" + 'Landing')  # => King'sLanding

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

Пробел — такой же символ, как и другие, поэтому сколько пробелов поставите в строке, столько и получится в итоговой строке:

# Ставим пробел в левой части
print("King's " + 'Landing')  # => King's Landing
# Ставим пробел в правой части
print("King's" + ' Landing')  # => King's Landing

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

REPL для экспериментов
История перевода строки
Что такое кодировки?

Остались вопросы? Задайте их в разделе «Обсуждение»

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

Введение в Python. Часть 2. Строки

Напомню, что мы работаем с Python в Jupyter Notebook. Это, по сути, записная книжка для программирования, и в ней мы можем прописывать не только код, но и текст, который помогает, например, вести конспект лекции и не забыть, какое действие выполняет та или иная ячейка. Делать пометки также полезно, чтобы те, с кем вы поделитесь кодом, смогли его прочитать. Тетрадку этого урока можно скачать на нашем GitHub.

Съемка, монтаж: Глеб Лиманский

Давайте попробуем это сделать и напишем тему урока. Сегодня мы поговорим о таком типе данных в Python как строки. Чтобы сделать заголовок «Строки», прописываем текст в первой ячейке, затем в верхнем меню выбираем тип Heading и активируем ячейку (shift и enter). Теперь она выглядит как заголовок. Чтобы добавить подзаголовок «Как выглядят строки», делаем все то же самое, но выбираем тип Markdown.

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

Что такое строки

Строка в Python – это последовательный набор символов, который может состоять как из цифр, так и из букв, и разделителей. Для создания строки мы используем кавычки (одинарные или двойные – не имеет значения). Я напишу пример строки и присвою его переменной а. Например: a=’важные истории’ или b=’0123456789’. Давайте проверим, что а и b действительно строки. Определяем их тип: type(a) и type(b). И видим str (string) – это и означает, что перед нами именно строки.

Сложение строк

Первая операция со строками, которую мы изучим – конкатенация (или сложение строк). Давайте создадим две новые строки a=’важные’, b=’истории’. Строки в Python относятся к категории неизменяемых последовательностей, то есть все функции и методы могут лишь создавать новую строку. Поэтому, чтобы соединить a и b в одну новую строку – мы должны создать переменную c, и положить в нее a+b. И тогда мы получим новую строку, в которой будут соединены две предыдущие. Так как они соединились без разделителя, чтобы между словами был пробел, нам надо прописать его внутри первой строки: a=’важные ’, b=’истории’. Если мы сложим эти две строки, внутри которых находятся числа, эта операция не сложит эти цифры, а соединит их в одно выражение: a=’1 ’, b=’2’, с=a+b, c=’12’.

Дублирование строк

Строки также можно дублировать. Для этого применяется операция умножения (*). Например, если мы умножим a*3, получим слово ’важные ’ с пробелом, записанное 3 раза.

Длина строк

Мы можем измерить длину строки, она равна количеству символов в строке. Давайте снова положим в переменную а слова ’важные истории’: a=’важные истории’ И измерим длину строки. Делается это так: len(a). Мы увидим, что длина строки равна количеству букв в словах ’важные истории’ плюс еще один символ – пробел.

Индексы

Каждый символ в строке имеет свой индекс – то есть порядковый номер. Но в Python эти номера начинаются не с 1, а с 0. То есть первый символ будет нулевым, второй первым, третий вторым и так далее. Давайте посмотрим на примере. Чтобы узнать индекс конкретного символа, есть специальная операция index(). Например, a.index(‘в’), где a – это название переменной, а в скобках искомое значение. Эта операция выдаст нам 0. Это значит, что буква «в» имеет нулевой индекс. Если мы таким же образом найдем индекс буквы «а», мы получим 1. Буква «и» встречается в строке 3 раза. Если мы попытаемся узнать индекс повторяющегося символа, мы получим индекс первой по порядку буквы «и», в данном случае – 7. Мы также можем узнать, какой символ записан под тем или иным индексом. Например, чтобы узнать, какой символ имеет нулевой индекс, мы должны написать следующую строчку кода: a[0]. Мы получим букву «в». Соответственно, a[1] покажет букву «а», и так далее. Индексы можно рассчитывать и с обратной стороны строки. Например, если мы напишем a[-3], то получим букву «р», которая стоит на третьем с конца месте строки.

Извлечение среза

Мы можем извлекать из строк не только отдельные символы, но и целые отрезки. Например, из выражения «важные истории», можно извлечь только слово «важные». Для этого нам надо написать конструкцию вида a[x:y], где x – индекс первого символа, а y – индекс последнего символа + 1. Так как индекс, записанный в «y» не включается, то например, когда мы указываем 6, мы подразумеваем, что последний индекс будет равен 5. К примеру, если мы укажем a[0:6], то получим первые 6 символов – слово «важные», несмотря на то, что индекс буквы «е» равен 5.

Если мы не укажем никаких символов – a[:], то код выдаст нам строку целиком, потому что по умолчанию x=0, а y=длине строки. Поэтому мы можем указывать только индекс начала отрезка или только индекс конца. a[7:] или a[:6].

Шаг среза

Мы так же можем указать шаг среза через еще одно двоеточие. Давайте сначала положим в переменную а цифры от 0 до 9: a=’0123456789′. И затем попросим отрезать все символы от первого до последнего с шагом 2: a[0:10:2]. Это означает, что мы выведем первый символ, второй пропустим, третий возьмем, четвертый пропустим и так далее.

Замена шаблона

Мы можем заменить часть строки на новую. Например, давайте превратим «важные истории» в «грустные истории». Делается это так: a=’важные истории’, b=a.replace(‘важные’,’грустные’), где на первом месте в скобках указывается старое значение, а на втором новое.

Изменение регистра текста

Можно изменить регистр текста внутри строки. Например, сейчас «важные истории» написаны в нижнем регистре, но с помощью операции upper() мы можем перевести буквы в верхний регистр и потом обратно в нижний с помощью операции lower().

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

Строки можно разделять. За это отвечает операция split(). Например, b=a.split(). Тогда наше выражение поделится на два слова. В данном случае программа сама нашла разделитель – это пробел. Но не все символы он не считывает как разделители. Если бы слово «важные» было поделено на буквы с точками – «в.а.ж.н.ы.е.», операция разделения выдала бы следующий результат: [‘в.а.ж.н.ы.е’]. Чтобы получить список из букв слова «важные», мы можем указать разделитель – точку – самостоятельно: b=a.split(‘.’).

Если мы узнаем тип данных получившегося объекта, мы увидим, что это list – то есть список. О том, что такое списки в Python, мы расскажем в следующий выпусках мастерской. А пока рекомендую вам выполнить все операции из этого урока самостоятельно. А если что-то не получится, вы можете написать в наш чат в Telegram, и мы вам поможем. Кроме этого, практически на любой вопрос можно найти ответ на сайте Stack Overflow – это сервис вопросов и ответов о программировании, в котором пользователи помогают друг другу. Почти на все вопросы, которые возникали в процессе обучения Python у меня, там уже были ответы.

Python: String (Строки)

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

Если статья вам понравилась, то можете поддержать проект.

format
F-strings: новый способ форматирования
Байтовые строки

В Python строки относятся к классу str вместо привычных String в других языках. Полный список методов класса можно узнать через команду:


print(str)

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


print("Мурзик")
print('Барсик')
print('Рыжик любил полежать на крыше автомобиля "Жигули"')

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


print("Мурзик\t5 лет") # табуляция
print('Рыжик любил полежать \nна крыше автомобиля "Жигули"') # перевод строки
print(r'D:\cats.txt') # отключение экранирования

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


pushkin = """У лукоморья дуб зелёный;
Златая цепь на дубе том:
И днём и ночью кот учёный
Всё ходит по цепи кругом;
Идёт направо - песнь заводит,
Налево - сказку говорит."""
print(pushkin)

Длину строки можно узнать через метод len().


str = "cat"
print(len(str)) # 3

Склеиваем две строки

Склейка двух строк (concatinate) происходит очень просто через сложение.


str1 = "Hello"
str2 = "Kitty"
concat = str1 + " " + str2
print(concat)

Метод split(): разбить строку

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


terminator = "I\'ll be back."
list = terminator.split()
print(list[0]) # I'll

Укажем разделитель явно.


myString = "one|two|three"
list = myString.split("|")
print(list[1])

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


myString = "one|two|three"
list = myString.split("|", 1)
print(list[1]) # two|three

«Умножаем» строку (повтор)

Довольно неожиданный оператор, который не встречал в других языках. Оказывается, строку можно «умножить». На самом деле, оператор позволяет повторить строку указанное число раз.


str = "cat"
repeatedStr = str * 3
print(repeatedStr)

Доступ к отдельному символу можно получить по индексу.


cat = "кот"
print(cat[0])
print(cat[1])
print(cat[2])

Можно указывать отрицательные значения, тогда отсчёт пойдёт с конца строки, начиная с -1.


cat = "кот"
print(cat[-1]) # т
print(cat[-2]) # о
print(cat[-3]) # к

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


cat = "скотина"
print(cat[1:4]) # кот

Возможные другие варианты среза. Смотрите примеры.


cat = "скотина"
print(cat[1:-3]) # кот
print(cat[:4])   # скот
print(cat[3:])   # тина
print(cat[:])    # скотина

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


cat = "скотина"
print(cat[::-1])  # анитокс
print(cat[1:6:2]) # ктн
print(cat[2::2])  # оиа

Для удаления символов новой строки в конце строки можно использовать метод rstrip(«\r\n») без удаления конечных пробелов:


>>> lines = ("line 1 \r\n"
... "\r\n"
... "\r\n")
>>> lines.rstrip("\r\n")
'line 1 '

Также есть всевозможные функции перевода в верхний/нижний регистр, проверок на наличие цифр и т. п.

format

Мощная функция с большими возможностями для форматирования строк.

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


print('Hello, {} !'.format('Kitty'))

Другие варианты.


print('{1}, {0}, {2}'.format('Кошка', 'Кот', 'Котёнок')) # Кот, Кошка, Котёнок
print('{}, {}, {}'.format('Кошка', 'Кот', 'Котёнок')) # Кошка, Кот, Котёнок

На самом деле функцию следует изучить по документации, слишком много вариантов.

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


print('Барсик')
print('Мурзик', end='')
print('Васька')

# Результат
Барсик
МурзикВаська

F-strings: новый способ форматирования

Всё же format() не слишком читабелен и удобен при большом количестве параметров. Гораздо приятнее использовать новый способ. Нужно всего лишь подставить символ f перед кавычками и затем просто подставлять имена переменных в фигурных скобках.


catName = 'Рыжик'
age = 7
print(f"Моего кота зовут {catName}, ему {age} лет")

Байтовые строки

Байтовые строки очень похожи на обычные строки, но с небольшими отличиями.

Создадим байтовую строку.


b'bytes'
# b'bytes'

'Байты'.encode('utf-8')
# b'\xd0\x91\xd0\xb0\xd0\xb9\xd1\x82\xd1\x8b'

bytes('bytes', encoding = 'utf-8')
# b'bytes'

bytes([50, 100, 76, 72, 41]) # числам от 0 до 255 соответствуют символы как у chr()
# b'2dLH)'

Байтовые строки используют для записи в файл или чтения из него.

Для преобразования в обычную строку используют метод decode().


b'\xd0\x91\xd0\xb0\xd0\xb9\xd1\x82\xd1\x8b'.decode('utf-8')
# 'Байты'

Строки в Python — CodeChick

В этом руководстве вы научитесь создавать, форматировать, изменять и удалять строки в Python.

А еще познакомитесь с различными строковыми операциями и функциями.

Что такое строка

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

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

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

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

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

Подробнее о Юникоде в Python.

Как создать строку

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

# все способы ниже эквиваленты: они делают одно и то же
my_string = 'Привет'
print(my_string)

my_string = "Привет"
print(my_string)

my_string = '''Привет'''
print(my_string)

# тройные кавычки позволяют создавать многострочные строки
my_string = """Привет, добро пожаловать
           в мир Python"""
print(my_string)

Вывод:

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

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

1. По индексу

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

Примечание. Первый элемент в строке (то есть первый символ) Python имеет индекс 0.

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

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

Индекс не обязательно должен быть положительным числом. Python поддерживает и «отрицательную индексацию». Индекс -1 ссылается на последний символ, -2 — на предпоследний и так далее.

2. С помощью среза

Получить доступ к символам в строке можно и с помощью слайсинга (от англ. «нарезание»). Таким способом удобно получать набор символов в заданном диапазоне.

Срезы задаются с помощью квадратных скобов [] и 2-3 аргументов через двоеточие :.

my_collection[старт:стоп:шаг]

string = 'codechick'
print('string = ', string)

#первый символ
print('string[0] = ', string[0])

#последний символ
print('string[-1] = ', string[-1])

#срез от 2 до 5 символа
print('string[1:5] = ', string[1:5])

#срез от 6 до предпоследнего символа
print('string[5:-2] = ', string[5:-2])

Вывод:

string =  codechick
string[0] =  c
string[-1] =  k
string[1:5] =  odec
string[5:-2] =  hi

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

Помните строку my_string?

# длина строки my_string = 6 символов, а мы пытаемся получить 15 символ
>>> my_string[15]  
...
IndexError: string index out of range# индекс должен быть целым числом
>>> my_string[1.5] 
...
TypeError: string indices must be integers

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

Строка — неизменяемый тип данных. Это значит, что мы не можем изменить элементы строки после создания. Зато можем переназначать разные строки одной и той же переменной.

>>> my_string = 'codechick'
>>> my_string[5] = 'a'
...
TypeError: 'str' object does not support item assignment

>>> my_string = 'Python'
>>> my_string
'Python'

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

>>> del my_string[1]
...
TypeError: 'str' object does not support item deletion>>> del my_string
>>> my_string
. ..
NameError: name 'my_string' is not defined

Строковые операции

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

Конкатенация строк

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

Эту операцию в Python выполняет оператор +. А с помощью оператора * можно повторить строку заданное количество раз — «умножить» строку на число.

string1 = 'Привет, '
string2 ='мир!'

# используем +
print('string1 + string2 = ', string1 + string2)

# используем *
print('string1 * 3 =', string1 * 3)

Вывод:

string1 + string2 =  Привет, мир!
string1 * 3 = Привет, Привет, Привет,

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

>>> # два строковых литералы записаны вместе
>>> 'Привет, ''мир!'
'Привет, мир!'

>>> # круглые скобки объединяют строковые литералы
>>> s = ('Привет, '
...     'мир')

>>> s
'Привет, мир'

Итерирование по строке

В Python можно «пройтись» по строке, то есть перебрать все символы в ней. Для этого нужно использовать цикл for.

count = 0
for letter in 'Привет, мир!':
    if (letter == 'и'):
        count += 1
print(count, 'буквы «и» в данной строке')

Вывод:

2 буквы «и» в данной строке

Проверка на вхождение

В Python можно проверить, находится ли данная подстрока в строке или нет с помощью операторов членства in и not in.

>>> 'chick' in 'codechick'
True

>>> 'code' not in 'codechick'
False

Функции для работы со строками

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

Самые полезные:

enumerate() — позволяет перебирать строку, отслеживая индекс текущего элемента.
len() — возвращает длину строки.

string = 'кодер'

# enumerate()
list_enumerate = list(enumerate(string))
print('list(enumerate(string) = ', list_enumerate)

# считаем количество символов
print('len(string) = ', len(string))

Вывод:

list(enumerate(string) =  [(0, 'к'), (1, 'о'), (2, 'д'), (3, 'е'), (4, 'р')]
len (string) = 5

Методы строк

`split(символ)`	Разбивает строки по заданном разделителю (по умолчанию — пробел)
`join(список)`	«Собирает» строку из списка с разделителем
`find(подстрока, начало, конец)`	Поиск подстроки в строке. Возвращает индекс первого вхождения слева. Если подстроки в строке нет, возвращает -1
`index(подстрока, начало, конец)`	Поиск подстроки в строке. Возвращает индекс первого вхождения. Если подстроки в строке нет, возвращает ValueError
`replace(шаблон, замена)`	Замена шаблона в строке
`isdigit()`	Проверяет, состоит ли строка из цифр. Возвращает True или False
`isalpha()`	Проверяет, состоит ли строка из букв. Возвращает True или False
`islower()`	Проверяет, состоит ли строка из символов в нижнем регистре. Возвращает True или False
`isupper()`	Проверяет, состоит ли строка из символов в верхнем регистре. Возвращает True или False
`upper()`	Преобразует строку к верхнему регистру
`lower()`	Преобразует строку к нижнему регистру
`ord(символ)`	Преобразует символ в ASCII-код
`chr(число)`	Преобразует ASCII-код в символ

>>> "CoDeCHicK". lower()
'codechick'

>>> "CoDeCHicK".upper()
'CODECHICK'

>>> "Эта инструкция разобьет строку и засунет элемент в список".split()
['Эта', 'инструкция', 'разобьет', 'строку', 'и', 'засунет', 'элемент', 'в', 'список']

>>> ' '.join(['Эта', 'инструкция', 'соберет', 'все', 'слова', 'в', 'одну', 'строку'])
'Эта инструкция соберет все слова в одну строку'

>>> 'Счастливого Рождества!r'.find('ож')
13

>>> 'Счастливого Рождества!'.replace('Счастливого', 'Чудесного')
'Чудесного Рождества!'

Как форматировать строки

Управляющие последовательности

Допустим, нам нужно напечатать на экран такое сообщение: He said, "What's there?" (Он сказал: «Что там?»). Проблема в том, что в этом тексте есть и двойные, и одинарные кавычки (апостроф), поэтому мы не можем использовать их для создания строки — это приведет к ошибке SyntaxError.

>>> print("He said, "What's there?"")
. ..
SyntaxError: invalid syntax>>> print('He said, "What's there?"')
...
SyntaxError: invalid syntax

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

Есть два способа обойти эту проблему: использовать тройные кавычки или escape-последовательности — их еще иногда называют управляющими последовательностями.

Вот, как это выглядит на практике.

# с помощью тройных кавычке
print('''He said, "What's there?"''')

# escape-последовательность и одинарные кавычки
print('He said, "What\'s there?"')

# escape-последовательность и двойные кавычки
print("He said, \"What's there?\"")

Вывод:

He said, "What's there?"
He said, "What's there?"
He said, "What's there?"

Список escape-последовательностей

Управляющая последовательность	Описание
`\\`	Экранирование обратного слэша
`\'`	Экранирование одинарной кавычки
`\"`	Экранирование двойной кавычки
`\a`	Звуковой сигнал или предупреждение
`\b`	Возврат на одну позицию
`\n`	Перенос строки на новую
`\r`	Возврат каретки
`\t`	Горизонтальный Tab
`\v`	Вертикальный Tab
`\ooo`	Восьмеричное значение
`\xHH`	Шестнадцатеричное значение

>>> print("C:\\Python32\\Lib")
C:\Python32\Lib

>>> print("Это сообщение печатается\на двух строках")
Это сообщение печатается
на двух строках

Игнорирование управляющих последовательностей

Чтобы Python проигнорировал escape-последовательность в строке, можно написать перед этой строкой r или R.

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

Метод format()

Метод format() — очень гибкий и мощный инструмент для форматирования строк. В качестве заполнителей используются фигурные скобки {}.

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

# порядок по умолчанию
default_order = "{}, {} и {}".format('Петя','Ваня','Катя')
print('\n--- Порядок по умолчанию ---')
print(default_order)

# порядок с позиционными аргументами
positional_order = "{1}, {0} и {2}".format('Петя','Ваня','Катя')
print('\n--- Позиционный порядок ---')
print(positional_order)

# порядок по ключевым словам
keyword_order = "{s}, {b} и {j}".format(j='Петя',b='Петя',s='Катя')
print('\n--- Порядок по ключевым словам ---')
print(keyword_order)

Вывод:

--- Порядок по умолчанию ---
Петя, Ваня и Катя--- Позиционный порядок ---
Ваня, Петя и Катя
--- Порядок по ключевым словам ---
Катя, Ваня и Петя

У метода format() есть дополнительные настройки. 10}|{:>10}|».format(‘масло’, ‘булка’, ‘колбаса’) ‘|масло | булка | колбаса|’

string — Общие операции со строками — Документация по Python 3.10.7

Исходный код: Lib/string.py

См. также

Тип текстовой последовательности — str

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

Строковые константы

Константы, определенные в этом модуле:

Строка . ascii_letters: Конкатенация ascii_lowercase и ascii_uppercase константы, описанные ниже. Это значение не зависит от языкового стандарта.

Строка . ascii_lowercase: Строчные буквы 'abcdefghijklmnopqrstuvwxyz' . Это значение не зависит от локали и не изменится.

Строка . ascii_uppercase: Прописные буквы 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' . Это значение не зависит от локали и не изменится.

нить. цифр: Строка '0123456789' .

Строка . шестнадцатеричные цифры: Строка '0123456789abcdefABCDEF' .

Строка . восьмизначный: Строка '01234567' .

Строка . пунктуация: Строка символов ASCII, которые считаются знаками препинания в 9_`{|}~ .

Строка . для печати: Строка символов ASCII, которые считаются печатаемыми. Это комбинация цифр , ascii_letters , пунктуация , и пробел .

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

Пользовательское форматирование строк

Встроенный строковый класс позволяет выполнять сложные переменные замены и форматирование значений с помощью метода format() , описанного в ПЭП 3101 . Класс Formatter в модуле string позволяет вы можете создавать и настраивать свои собственные способы форматирования строк, используя те же реализация как встроенный метод format() .

класс строка. Форматер

Класс Formatter имеет следующие общедоступные методы:

формат ( format_string , /, *args , **kwargs )

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

Изменено в версии 3.7: Аргумент строки формата теперь является только позиционным.

vformat ( format_string , аргументов , kwargs ): Эта функция выполняет фактическую работу по форматированию. Он выставляется как отдельная функция для случаев, когда вы хотите передать предопределенный словарь аргументов, а не распаковывать и перепаковывать словарь как отдельные аргументы с использованием *args и **kwargs синтаксис. vformat() выполняет работу по разбиению строки формата в символьные данные и поля замены. Он вызывает различные методы, описанные ниже.

Кроме того, Formatter определяет ряд методов, которые предназначен для замены подклассами:

разбор ( format_string )

Перебрать строку format_string и вернуть итерацию кортежей ( literal_text , field_name , format_spec , преобразование ). Это используется с помощью vformat() , чтобы разбить строку либо на буквальный текст, либо поля замены.

Значения в кортеже концептуально представляют собой диапазон буквенного текста за которым следует одно поле замены. Если нет дословного текста (что может произойти, если два поля замены встречаются последовательно), то literal_text будет строкой нулевой длины. Если нет замены поле, затем значения field_name , format_spec и преобразование будет Нет .

get_field ( field_name , аргументы , kwargs ): Учитывая field_name , возвращенное parse() (см. выше), преобразовать его в объект для форматирования. Возвращает кортеж (obj, used_key). По умолчанию version принимает строки в форме, определенной в PEP 3101 , например «0[имя]» или «метка.название». args и kwargs передаются в vformat() . Возвращаемое значение used_key имеет то же значение, что и ключ параметр для get_value() .

get_value ( ключ , аргументов , kwargs )

Получить заданное значение поля. Аргумент ключа будет либо целое число или строка. Если это целое число, оно представляет собой индекс позиционный аргумент в args ; если это строка, то она представляет именованный аргумент в kwargs .

аргументов 9Параметр 0168 установлен в список позиционных аргументов для vformat() , а параметр kwargs установлен в словарь аргументы ключевых слов.

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

Так, например, выражение поля «0.name» вызовет get_value() для вызова с ключом аргумент 0. Имя атрибут будет найден после того, как get_value() вернется, вызвав метод встроенная функция getattr() .

Если индекс или ключевое слово относится к несуществующему элементу, то IndexError или KeyError должно возникнуть.

check_unused_args ( used_args , аргументов , kwargs ): Реализовать проверку неиспользуемых аргументов, если это необходимо. Аргументы к этому Функция — это набор всех ключей-аргументов, на которые фактически ссылались в строка формата (целые числа для позиционных аргументов и строки для именованные аргументы) и ссылка на args и kwargs , что было перешел на vformat. Набор неиспользуемых аргументов может быть рассчитан из этих параметры. Предполагается, что check_unused_args() вызовет исключение, если проверка не проходит.

format_field ( значение , format_spec ): format_field() просто вызывает встроенный глобальный format() . предоставляется так, что подклассы могут переопределить его.

convert_field ( значение , преобразование ): Преобразует значение (возвращенное функцией get_field() ) с заданным типом преобразования (как в кортеже, возвращаемом методом parse() ). По умолчанию версия понимает преобразование «s» (str), «r» (repr) и «a» (ascii) типы.

Синтаксис строки формата

Метод str.format() и Formatter 9Класс 0020 одинаковый синтаксис для строк формата (хотя в случае Formatter , подклассы могут определять свой собственный синтаксис строки формата). Синтаксис по сравнению с форматированными строковыми литералами, но менее сложный и, в частности, не поддерживает произвольные выражения.

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

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

  replace_field  ::= "{" [  field_name  ] ["!"  преобразование  ] [":"  format_spec  ] "}"
  имя_поля  ::= имя_аргумента ("."  имя_атрибута  | "["  индекс_элемента  "]")*
  arg_name  ::= [  идентификатор  |  цифра  +]
  имя_атрибута  ::=  идентификатор 
  element_index  ::=  цифра  + |  index_string 
  index_string  ::= <любой исходный символ, кроме "]"> +
  преобразование  ::= "r" | "с" | "а"
  format_spec  ::= <описано в следующем разделе>

В менее формальных терминах заменяющее поле может начинаться с field_name , которое указывает объект, значение которого должно быть отформатировано и вставлено в вывод вместо поля замены. field_name может сопровождаться полем преобразования , которое перед восклицательным знаком '!' и format_spec , которому предшествует через двоеточие ':' . Они определяют нестандартный формат для замещающего значения.

См. также раздел «Мини-язык спецификации формата».

Само поле field_name начинается с arg_name , которое является либо числом, либо ключевое слово. Если это число, оно относится к позиционному аргументу, а если это ключевое слово, он ссылается на именованный аргумент ключевого слова. Если числовые arg_names в строке формата 0, 1, 2, … по порядку, все они могут быть опущены (не только некоторые) и числа 0, 1, 2, … будут автоматически вставлены в этом порядке. Потому что имя_аргумента не заключено в кавычки, невозможно указать произвольный ключи словаря (например, строки '10' или ':-]' ) в строке формата. За arg_name может следовать любое количество индексов или атрибутивные выражения. Выражение вида '.name' выбирает именованный атрибут с использованием getattr() , а выражение вида '[index]' выполняет поиск по индексу, используя __getitem__() .

Изменено в версии 3.1: Спецификаторы позиционных аргументов могут быть опущены для str.format() , поэтому '{} {}'.format(a, b) эквивалентно '{0} {1}'.format(a, b) .

Изменено в версии 3.4: Спецификаторы позиционных аргументов могут быть опущены для Formatter .

Примеры строк простого формата:

 "Сначала ты должен считать до {0}" # Ссылка на первый позиционный аргумент
"Принеси мне {}" # Неявно ссылается на первый позиционный аргумент
"От {} до {}" # То же, что и "От {0} до {1}"
"My quest is {name}" # Ссылки на аргумент ключевого слова 'name'
"Вес в тоннах {0.weight}" # атрибут "вес" первого позиционного аргумента
"Юниты уничтожены: {players[0]}" # Первый элемент ключевого аргумента 'players'.

Поле преобразования вызывает приведение типа перед форматированием. Как правило, работа по форматированию значения выполняется методом __format__() значения сам. Однако в некоторых случаях желательно принудительно форматировать тип. как строку, перекрывая собственное определение форматирования. Путем преобразования значение в строку перед вызовом __format__() , нормальная логика форматирования обойден.

В настоящее время поддерживаются три флага преобразования: '!s' , который вызывает str() по значению, '!r' , который вызывает repr() и '!a' , который вызывает ascii() .

Некоторые примеры:

 "Гарольд - умный {0!s}" # Сначала вызывает str() для аргумента
"Вынеси святое {name!r}" # Сначала вызывает repr() для аргумента
"More {!a}" # Сначала вызывает ascii() для аргумента

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

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

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

Некоторые примеры см. в разделе «Примеры форматирования».

`Спецификация формата Mini-Language`

«Спецификации формата» используются в полях замены, содержащихся в строка формата для определения того, как представляются отдельные значения (см. Синтаксис форматированной строки и форматированные строковые литералы). Они также могут быть переданы непосредственно во встроенный формат() функция. Каждый форматируемый тип может определять, как формат Спецификация подлежит интерпретации.

Большинство встроенных типов реализуют следующие параметры спецификации формата: хотя некоторые параметры форматирования поддерживаются только числовыми типами.

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

Общая форма спецификатора стандартного формата :

  format_spec  ::= [[  fill  ]  align  ][  sign  ][#][0][  width  ][  grouping_option  ][.  точность  ][  тип 9"
  знак  ::= "+" | "-" | " "
  ширина  ::=  цифра  +
  grouping_option  ::= "_" | ","
  точность  ::=  цифра  +
  тип  ::= "b" | "с" | "д" | "е" | "Э" | "ф" | "Ф" | "г" | "Г" | "н" | "о" | "с" | "х" | "Х" | "%"

Если указано допустимое значение выравнивания , ему может предшествовать заливка символ, который может быть любым символом и по умолчанию равен пробелу, если он опущен. Невозможно использовать буквальную фигурную скобку (” { » или « } ») как заполняет символов в форматированном строковом литерале или при использовании str.format() метод. Однако можно вставить фигурную скобку с вложенным замещающим полем. Это ограничение не влияют на функцию format() .

Значение различных вариантов выравнивания следующее:

Опция
Значение
'<'
Принудительное выравнивание поля по левому краю в пределах доступного пространство (это значение по умолчанию для большинства объектов).
'>'
Принудительное выравнивание поля по правому краю доступное пространство (это значение по умолчанию для чисел).
'='
Принудительное размещение отступа после знака (если есть) но перед цифрами. Это используется для печати полей в виде «+000000120». Этот вариант выравнивания только допустимо для числовых типов. Он становится значением по умолчанию для числа, когда «0» непосредственно предшествует ширине поля. 9
Принудительно центрирует поле в пределах доступного пространство.

Опция	Значение
`'<'`	Принудительное выравнивание поля по левому краю в пределах доступного пространство (это значение по умолчанию для большинства объектов).
`'>'`	Принудительное выравнивание поля по правому краю доступное пространство (это значение по умолчанию для чисел).
`'='`	Принудительное размещение отступа после знака (если есть) но перед цифрами. Это используется для печати полей в виде «+000000120». Этот вариант выравнивания только допустимо для числовых типов. Он становится значением по умолчанию для числа, когда «0» непосредственно предшествует ширине поля. 9	Принудительно центрирует поле в пределах доступного пространство.

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

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

Опция
Значение
'+'
указывает, что знак должен использоваться для обоих положительные, так и отрицательные числа.
'-'
указывает, что знак следует использовать только для отрицательных значений. номера (это поведение по умолчанию).
пробел
указывает, что в начале следует использовать пробел. положительные числа и знак минус на отрицательных числах.

Опция	Значение
`'+'`	указывает, что знак должен использоваться для обоих положительные, так и отрицательные числа.
`'-'`	указывает, что знак следует использовать только для отрицательных значений. номера (это поведение по умолчанию).
пробел	указывает, что в начале следует использовать пробел. положительные числа и знак минус на отрицательных числах.

Опция '#' приводит к использованию «альтернативной формы» для преобразование. Альтернативная форма определяется по-разному для разных типы. Эта опция действительна только для целых чисел, чисел с плавающей запятой и сложных чисел. типы. Для целых чисел при двоичном, восьмеричном или шестнадцатеричном выводе используется, эта опция добавляет соответствующий префикс '0b' , '0o' , '0x' или '0X' в выходное значение. Для поплавка и комплекса альтернативная форма приводит к тому, что результат преобразования всегда содержит символ десятичной точки, даже если за ним не следуют никакие цифры. Обычно в результате этих преобразований появляется символ десятичной точки только если за ним следует цифра. Кроме того, за "г" и "г" конверсий конечные нули не удаляются из результата.

Опция ',' сигнализирует об использовании запятой для разделителя тысяч. Для разделителя с учетом локали используйте целочисленный тип представления 'n' . вместо.

Изменено в версии 3.1: Добавлена опция ',' (см. также PEP 378 ).

Опция '_' сигнализирует об использовании подчеркивания для тысяч разделитель для типов представления с плавающей запятой и для целых чисел тип презентации 'д' . Для целочисленных типов представления 'b' , 'o' , 'x' и 'X' , символы подчеркивания будут вставлены через каждые 4 цифры. Для других типов презентаций указание этого параметра ошибка.

Изменено в версии 3.6: Добавлена опция '_' (см. также PEP 515 ).

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

Если явное выравнивание не задано, перед полем ширины ставится ноль ( '0' ) символ включает знаковое заполнение нулями для числовых типов. Это эквивалентно заполнению . символ '0' с выравниванием типа '=' .

Изменено в версии 3.10: добавление перед полем ширины значения '0' больше не влияет на значение по умолчанию. выравнивание для строк.

Прецизионный — десятичное целое число, указывающее, сколько цифр должно быть отображается после запятой для типов представления 'f' и 'F' или до и после десятичной точки для представления типы 'g' или 'G' . Для типов строкового представления поле указывает максимальный размер поля — другими словами, сколько символов будет используется из содержимого поля. Точность не допускается для целых чисел. виды представления.

Наконец, тип определяет способ представления данных.

Доступные типы представления строк:

Тип
Значение
"с"
Строковый формат. Это тип по умолчанию для строк и может быть опущен.
Нет
То же, что и 's' .

Тип	Значение
`"с"`	Строковый формат. Это тип по умолчанию для строк и может быть опущен.
Нет	То же, что и `'s'` .

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

Тип
Значение
«б»
Двоичный формат. Выводит число по основанию 2.
«с»
Символ. Преобразует целое число в соответствующее символ Юникода перед печатью.
«д»
Десятичное целое. Выводит число по основанию 10.
"о"
Восьмеричный формат. Выводит число по основанию 8.
'х'
Шестнадцатеричный формат. Выводит число в базе 16, используя строчные буквы для цифр выше 9.
«Х»
Шестнадцатеричный формат. Выводит число в базе 16, используя заглавные буквы для цифр выше 9. В случае указания '#' префикс '0x' будет быть также в верхнем регистре до '0X' .
'н'
Номер. Это то же самое, что и 'd' , за исключением того, что в нем используется текущую настройку локали, чтобы вставить соответствующий символы-разделители чисел.
Нет
То же, что и 'd' .

Тип	Значение
`«б»`	Двоичный формат. Выводит число по основанию 2.
`«с»`	Символ. Преобразует целое число в соответствующее символ Юникода перед печатью.
`«д»`	Десятичное целое. Выводит число по основанию 10.
`"о"`	Восьмеричный формат. Выводит число по основанию 8.
`'х'`	Шестнадцатеричный формат. Выводит число в базе 16, используя строчные буквы для цифр выше 9.
`«Х»`	Шестнадцатеричный формат. Выводит число в базе 16, используя заглавные буквы для цифр выше 9. В случае указания `'#'` префикс `'0x'` будет быть также в верхнем регистре до `'0X'` .
`'н'`	Номер. Это то же самое, что и `'d'` , за исключением того, что в нем используется текущую настройку локали, чтобы вставить соответствующий символы-разделители чисел.
Нет	То же, что и `'d'` .

В дополнение к указанным выше типам представления целые числа могут быть отформатированы с перечисленными ниже типами представления с плавающей запятой (кроме 'n' и Нет ). При этом float() используется для преобразования целое число в число с плавающей запятой перед форматированием.

Доступные типы представления для float и Десятичные значения :

Тип
Значение
'е'
Научное обозначение. Для заданной точности p , форматирует число в экспоненциальном представлении с буква «е», отделяющая коэффициент от показателя степени. Коэффициент имеет одну цифру перед и p цифр после запятой, всего р + 1 значащие цифры. Без указания точности использует точность 6 знаков после запятой для float и показывает все цифры коэффициентов для Десятичный . Если цифры не следуют за десятичной точки, десятичная точка также удаляется, если используется вариант #.
'Е'
Научное обозначение. То же, что и 'e' , за исключением использования буква «E» в верхнем регистре в качестве символа-разделителя.
"ж"
Представление с фиксированной точкой. Для заданной точности p , форматирует число как десятичное число точно p знаков после запятой. Без заданная точность, использует точность 6 цифр после десятичная точка для с плавающей запятой и использует точность достаточно велика, чтобы показать все цифры коэффициента для Десятичный . Если цифры не следуют за десятичной точки, десятичная точка также удаляется, если 9Используется опция 0019 # .
F
Представление с фиксированной точкой. То же, что и 'f' , но преобразует nan до NAN и inf до INF .
"г"
Общий формат. Для заданной точности p >= 1 , это округляет число до p значащих цифр и затем форматирует результат в любом формате с фиксированной точкой или в научной записи, в зависимости от его величины. Точность 0 рассматривается как эквивалент точность 1 .
Точные правила таковы: предположим, что результат отформатирован с типом презентации 'e' и точность p-1 будет иметь показатель степени exp . Затем, если м <= exp < p , где м равно -4 для поплавков и -6 для Decimals число отформатировано с типом представления 'f' и точностью р-1-ехр . В противном случае число форматируется с типом презентации 'e' и точность p-1 . В обоих случаях незначащие конечные нули удаляются. от мантиссы, и десятичная точка также удаляется, если после него нет оставшихся цифр, если не используется опция '#' .
Без указания точности использует точность 6 значащие цифры для с плавающей запятой . За Десятичный , коэффициент результата формируется из разрядов коэффициента значения; научное обозначение используется для значений, меньших, чем 1e-6 по абсолютной величине и значениям, где место значение младшей значащей цифры больше 1, в противном случае используется запись с фиксированной точкой.
Положительная и отрицательная бесконечность, положительная и отрицательная ноль и нанс форматируются как inf , -inf , 0 , -0 и нан соответственно, независимо от точность.
"Г"
Общий формат. То же, что 'g' кроме переключения на 'E' , если число становится слишком большим. представления бесконечности и NaN также заглавные.
'н'
Номер. Это то же самое, что и 'g' , за исключением того, что он использует текущую настройку локали, чтобы вставить соответствующий символы-разделители чисел.
'%'
Процент. Умножает число на 100 и отображает фиксированный ( 'f' ), за которым следует знак процента.
Нет
Для float это то же самое, что и 'g' , за исключением что когда запись с фиксированной точкой используется для форматирования результат, он всегда включает по крайней мере одну цифру после десятичная точка. Используемая точность настолько велика, насколько это необходимо для точного представления заданного значения.
Для Decimal это то же самое, что и либо 'g' , либо 'G' в зависимости от значения context. capitals для текущего десятичного контекста.
Общий эффект должен соответствовать выходным данным str() как изменено другими модификаторами формата.

Тип	Значение
`'е'`	Научное обозначение. Для заданной точности `p` , форматирует число в экспоненциальном представлении с буква «е», отделяющая коэффициент от показателя степени. Коэффициент имеет одну цифру перед и `p` цифр после запятой, всего `р + 1` значащие цифры. Без указания точности использует точность `6` знаков после запятой для `float` и показывает все цифры коэффициентов для `Десятичный` . Если цифры не следуют за десятичной точки, десятичная точка также удаляется, если используется вариант `#`.
`'Е'`	Научное обозначение. То же, что и `'e'` , за исключением использования буква «E» в верхнем регистре в качестве символа-разделителя.
`"ж"`	Представление с фиксированной точкой. Для заданной точности `p` , форматирует число как десятичное число точно `p` знаков после запятой. Без заданная точность, использует точность `6` цифр после десятичная точка для `с плавающей запятой` и использует точность достаточно велика, чтобы показать все цифры коэффициента для `Десятичный` . Если цифры не следуют за десятичной точки, десятичная точка также удаляется, если 9Используется опция 0019 # .
`F`	Представление с фиксированной точкой. То же, что и `'f'` , но преобразует `nan` до `NAN` и `inf` до `INF` .
`"г"`	Общий формат. Для заданной точности `p >= 1` , это округляет число до `p` значащих цифр и затем форматирует результат в любом формате с фиксированной точкой или в научной записи, в зависимости от его величины. Точность `0` рассматривается как эквивалент точность `1` . Точные правила таковы: предположим, что результат отформатирован с типом презентации `'e'` и точность `p-1` будет иметь показатель степени `exp` . Затем, если `м <= exp < p` , где `м` равно -4 для поплавков и -6 для `Decimals` число отформатировано с типом представления `'f'` и точностью `р-1-ехр` . В противном случае число форматируется с типом презентации `'e'` и точность `p-1` . В обоих случаях незначащие конечные нули удаляются. от мантиссы, и десятичная точка также удаляется, если после него нет оставшихся цифр, если не используется опция `'#'` . Без указания точности использует точность `6` значащие цифры для `с плавающей запятой` . За `Десятичный` , коэффициент результата формируется из разрядов коэффициента значения; научное обозначение используется для значений, меньших, чем `1e-6` по абсолютной величине и значениям, где место значение младшей значащей цифры больше 1, в противном случае используется запись с фиксированной точкой. Положительная и отрицательная бесконечность, положительная и отрицательная ноль и нанс форматируются как `inf` , `-inf` , `0` , `-0` и `нан` соответственно, независимо от точность.
`"Г"`	Общий формат. То же, что `'g'` кроме переключения на `'E'` , если число становится слишком большим. представления бесконечности и NaN также заглавные.
`'н'`	Номер. Это то же самое, что и `'g'` , за исключением того, что он использует текущую настройку локали, чтобы вставить соответствующий символы-разделители чисел.
`'%'`	Процент. Умножает число на 100 и отображает фиксированный ( `'f'` ), за которым следует знак процента.
Нет	Для `float` это то же самое, что и `'g'` , за исключением что когда запись с фиксированной точкой используется для форматирования результат, он всегда включает по крайней мере одну цифру после десятичная точка. Используемая точность настолько велика, насколько это необходимо для точного представления заданного значения. Для `Decimal` это то же самое, что и либо `'g'` , либо `'G'` в зависимости от значения `context. capitals` для текущего десятичного контекста. Общий эффект должен соответствовать выходным данным `str()` как изменено другими модификаторами формата.

`Примеры формата`

Этот раздел содержит примеры синтаксиса str.format() и сравнение со старым % -форматированием.

В большинстве случаев синтаксис аналогичен старому % - форматирование, с добавление {} и с : вместо % . Например, '%03.2f' можно преобразовать в '{:03.2f}' .

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

Доступ к аргументам по позиции:

 >>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'а, б, в'
>>> '{}, {}, {}'.format('a', 'b', 'c') # только 3.1+
'а, б, в'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'в, б, а'
>>> '{2}, {1}, {0}'. format(*'abc') # распаковка последовательности аргументов
'в, б, а'
>>> '{0}{1}{0}'.format('abra', 'cad') # arguments' индексы могут повторяться
абракадабра

Доступ к аргументам по имени:

 >>> 'Координаты: {широта}, {долгота}'.format(широта='37.24N', долгота='-115.81W')
«Координаты: 37,24 северной широты, -115,81 западной долготы»
>>> coord = {'широта': '37,24 с.ш.', 'долгота': '-115,81 з.д.'}
>>> 'Координаты: {широта}, {долгота}'.format(**coord)
«Координаты: 37,24 северной широты, -115,81 западной долготы»

Доступ к атрибутам аргументов:

 >>> с = 3-5j
>>> ('Комплексное число {0} образовано из действительной части {0.real} '
... 'и мнимая часть {0.imag}.').format(c)
«Комплексное число (3-5j) образуется из действительной части 3,0 и мнимой части -5,0».
>>> класс Точка:
... def __init__(self, x, y):
... self.x, self.y = x, y
... защита __str__(я):
... return 'Point({self.x}, {self.y})'.format(self=self)
...
>>> ул(точка(4, 2))
«Точка (4, 2)»

Доступ к элементам аргументов:

 >>> координата = (3, 5)
>>> 'Х: {0[0]}; Y: {0[1]}'. 30}'.format('centered') # используйте '*' как заполняющий символ
'*********** по центру***********'

Замена %+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 и %o и преобразование значения в разные основания:

 >>> # формат также поддерживает двоичные числа
>>> "целое: {0:d}; шестнадцатеричный: {0:x}; окт.: {0:o}; bin: {0:b}".format(42)
'целое: 42; шестнадцатеричный: 2а; окт.: 52; бин: 101010'
>>> # с префиксом 0x, 0o или 0b:
>>> "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)
'целое: 42; шестнадцатеричный: 0x2a; окт: 0o52; бин: 0b101010'

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

 >>> '{:,}'. format(1234567890)
«1 234 567 890»

Выражение процента: 9' '>>>>>>>>>>право' >>> >>> октеты = [192, 168, 0, 1] >>> '{:02X}{:02X}{:02X}{:02X}'.format(*октеты) «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 99 11 1001 10 А 12 1010 11 Б 13 1011

`Строки шаблона`

Строки шаблона обеспечивают более простые замены строк, как описано в ПЭП 292 . Основной вариант использования строк шаблона для интернационализация (i18n), поскольку в этом контексте более простой синтаксис и функциональность облегчает перевод, чем другие встроенные строки средства форматирования в Python. Как пример библиотеки, построенной на шаблоне строки для i18n, см. пакет флюфл.i18n.

Строки шаблона поддерживают замен на основе $ с использованием следующих правил:

$$ — побег; он заменен на единый $.
$identifier называет заполнитель замены, соответствующий ключу сопоставления "идентификатор" . По умолчанию "идентификатор" ограничен любым нечувствительная к регистру буквенно-цифровая строка ASCII (включая символы подчеркивания), которая начинается с символа подчеркивания или буквы ASCII. Первый неидентификатор персонаж после Символ $ завершает этот заполнитель Технические характеристики.
${identifier} эквивалентно $identifier . Требуется, когда допустимые символы идентификатора следуют за заполнителем, но не являются частью заполнитель, например "${noun}ification" .

Любое другое появление $ в строке приведет к ошибке ValueError поднимается.

Модуль string обеспечивает Класс шаблона , реализующий эти правила. Методы шаблона :

класс строка. Шаблон ( шаблон )

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

заменить ( отображение = {} , / , **kwds ): Выполняет замену шаблона, возвращая новую строку. сопоставление это любой подобный словарю объект с ключами, которые соответствуют заполнителям в шаблон. В качестве альтернативы вы можете указать аргументы ключевого слова, где ключевые слова являются заполнителями. Когда задано отображение и kwds и есть дубликаты, заполнители из kwds имеют приоритет.

safe_substitute ( сопоставление = {} , / , **kwds )

Нравится замена() , за исключением случаев, когда заполнители отсутствуют в сопоставление и kwds вместо создания исключения KeyError , исходный заполнитель появится в результирующей строке без изменений. Также, в отличие от replace() , любые другие появления $ будут просто верните $ вместо повышения ValueError .

Несмотря на то, что могут возникать другие исключения, этот метод называется «безопасным». потому что он всегда пытается вернуть пригодную для использования строку вместо возбуждение исключения. В другом смысле safe_substitute() может быть ничего, кроме безопасного, так как он молча игнорирует искаженные шаблоны, содержащие висячие разделители, непарные фигурные скобки или заполнители, которые не являются допустимыми идентификаторами Python.

Экземпляры шаблона также предоставляют один общедоступный атрибут данных:

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

Вот пример использования шаблона:

 >>> из шаблона импорта строки
>>> s = Template('$кому нравится $что')
>>> s. substitute(кто='тим', что='кун пао')
Тим любит кунг пао
>>> d = dict(кто='тим')
>>> Шаблон('Дать $кому 100$').substitute(d)
Traceback (последний последний вызов):
...
ValueError: Недопустимый заполнитель в строке: строка 1, столбец 11
>>> Template('$кому нравится $что').substitute(d)
Traceback (последний последний вызов):
...
KeyError: 'что'
>>> Template('$кому нравится $что').safe_substitute(d)
'Тим любит $что'

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

разделитель — это буквальная строка, описывающая заполнитель введение разделителя. Значение по умолчанию — $ . Обратите внимание, что это должно не быть регулярным выражением, так как реализация вызовет re.escape() в этой строке по мере необходимости. Обратите внимание, что вы не можете изменить разделитель после создания класса (т. е. другой разделитель должен быть установлен в пространстве имен класса подкласса).
idpattern — это регулярное выражение, описывающее шаблон для незакрепленные заполнители. Значение по умолчанию — регулярное выражение (?a:[_a-z][_a-z0-9]*) . Если это задано и braceidpattern Нет Этот шаблон также применим к фигурным заполнителям.
Примечание
Поскольку по умолчанию флаги равны re.IGNORECASE , шаблон [a-z] может соответствовать с некоторыми не-ASCII-символами. Вот почему мы используем локальный флаг a . здесь.
Изменено в версии 3.7: braceidpattern можно использовать для определения отдельных шаблонов, используемых внутри и вне брекетов.
braceidpattern — похоже на idpattern , но описывает шаблон для раскосные заполнители. По умолчанию Нет , что означает вернуться к idpattern (т.е. один и тот же шаблон используется как внутри, так и снаружи фигурных скобок). Если задано, это позволяет вам определить различные шаблоны для раскосов и незакрепленные заполнители.
Новое в версии 3.7.
flags — Флаги регулярного выражения, которые будут применяться при компиляции регулярное выражение, используемое для распознавания замен. Значение по умолчанию re.IGNORECASE . Обратите внимание, что re.VERBOSE всегда будет добавляться к флаги, поэтому пользовательские idpattern s должны следовать соглашениям для подробных регулярных выражения.
Новое в версии 3.2.

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

escaped — эта группа соответствует escape-последовательности, например $$ , в шаблон по умолчанию.
с именем — эта группа соответствует имени-заполнителю без фигурных скобок; это не должно включить разделитель в группу захвата.
braced — эта группа соответствует имени-заполнителю, заключенному в фигурные скобки; должно не включать ни разделитель, ни фигурные скобки в группу захвата.
недопустимый — эта группа соответствует любому другому шаблону-разделителю (обычно одиночный). разделитель), и он должен стоять последним в регулярном выражении.

`Вспомогательные функции`

Строка . ключевые слова ( s , sep=Нет ): Разделите аргумент на слова, используя str. split() , начните каждое слово с заглавной буквы используя str.capitalize() , и соедините заглавные слова, используя ул.присоединиться() . Если необязательный второй аргумент сен отсутствует или None , пробельные символы заменяются одним пробелом а начальные и конечные пробелы удаляются, иначе sep используется для разделить и соединить слова.

`Строка Python — GeeksforGeeks`

В Python Строки — это массивы байтов, представляющие символы Unicode.

Пример:

 "Geeksforgeeks" или "Geeksforgeeks"

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

`Python3`

print ( "A Computer Science portal for geeks" )

Output:

 A Computer Science portal for geeks

`Creating a Строка в Python`

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

`Python3`

String1 = 'Добро пожаловать в Geeks World'

Print (

.

print (String1)

String1 = "I'm a Geek"

print ( "\nString with the use of Double Quotes: " )

print (String1)

String1 =

print ( "\nString with the use of Triple Quotes: " )

print (String1)

String1 =

print ( "\nCreating a multiline String: " )

print (String1)

Output:

 Строка с использованием одинарных кавычек:
Добро пожаловать в мир гиков
Строка с использованием двойных кавычек:
я гик
Строка с использованием тройных кавычек:
Я гик и живу в мире гиков
Создание многострочной строки:
Компьютерщики
            За
            Жизнь

`Доступ к символам в строке Python`

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

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

 
 Python3 
  
  String1   =   "GeeksForGeeks" 
  print   (   "Initial String: "   ) 
  print   ( String1) 
  
  print   (   "\nПервый символ строки: "   ) 
  print 0(String1 [  0  ]) 
  Печать   (  "\ NLAST Символ String:"  ) 
  Print   (String112020202011  1919 (
  19 (
 .   ]) 
  Вывод:   
 Исходная строка:
GeeksForGeeks
Первый символ строки:
грамм
Последний символ строки:
s 
 При доступе к символам из строки мы также можем их инвертировать. Мы можем перевернуть строку, написав [::-1], и строка будет перевернута.
 Python3 
   gfg   =   "geeksforgeeks" 
  print   (gfg[::   -   1   ]) 
  Output : 
 skeegrofskeeg 
 Мы также можем перевернуть строку, используя встроенную функцию соединения и реверсирования.
 Python3 
  
  gfg  =   "Geeksforgeeks" 
  GFG   =   ".
  Вывод: 
 skeegrofskeeg 
 Для доступа к диапазону символов в строке используется метод нарезки. Нарезка в строке выполняется с помощью оператора нарезки (двоеточие).
 Python3 
  String1   =   "Geeksforgeeks" 
  Печать   (  ".
  Печать   (  "\ nslicing символы от 3-12:"  ) 
  Печать   (String1 [  3  :   12   3  :   12  019]) 
  Печать   (  "\ nslicing символы между"   + 
    "3 -й и 2 -й. [   3   :   -   2   ]) 
  Исходное значение:  GeeksForGeeks
Нарезка персонажей с 3 по 12:
ксфоргик
Нарезка символов между 3-м и 2-м последним символом:
ксфорджи 
 Удаление/обновление строки 
 В Python не допускается обновление или удаление символов из строки. Это вызовет ошибку, поскольку назначение или удаление элемента из строки не поддерживается. Хотя удаление всей строки возможно с использованием встроенного ключевого слова del. Это связано с тем, что строки неизменяемы, поэтому элементы строки не могут быть изменены после того, как они были назначены. Только новые строки могут быть переназначены тому же имени.
 Обновление персонажа: 
 Python3 
  String1   =   "Hello, I I Geek" 
  Print   ( 
  Print   ( 1955
  Print   (  "
 .   (String1) 
  List1   =   Список   (String1) 
  LIST1 [  2  ]   = 20202020202019
      
   2020202020202019        20202020202020202019 '   .0005  String2   =   ''.join(list1) 
  print   (   "\nUpdating character at 2nd Index: "   ) 
  print   (String2) 
  String3   =   String1 [  0  :   2  ]   +   'P'   +  . 1683  Печать   (String3) 
  Ошибка: 
 TRACEBACK (самый последний звонок в последний раз): 
 Файл «/HOME/360BB1830C83A918FC78AIA». = 'P' 
 TypeError: 'Str' Object не поддерживает назначение элементов
 Обновление всей строки: 
 Python3 
  String12020  = 202
  String1920  = 20202
 , я. 
  print   (   "Initial String: "   ) 
  print   (String1) 
  
  String1   =   "Welcome to the Geek World" 
  Печать   (  "\ nupdated String:"  ) 
  Печать   (String1) 
  Выход: 
698 
  : 9005 
6698   
Привет, я гик
Обновленная строка:
Добро пожаловать в мир гиков 
 Deletion of a character:  
 Python3 
  
  String1   =   "Hello, I'm a Geek" 
  print   (   "Initial String: "   ) 
  print   (String1) 
  
  String2   =   String1[   0   :   2   ]   +   String1 [  3  :] 
  Печать   (  "\ NDELETING. Ошибка:   
 Исходная строка:  
 Здравствуйте, я гик
 Удаление символа во 2-м индексе:  
 Привет, я гик
 Удаление всей строки: 
 Удаление всей строки возможно с удалением всей строки использование ключевого слова del. Кроме того, если мы попытаемся напечатать строку, это приведет к ошибке, потому что строка удалена и недоступна для печати.
 Python3 
   
  String1   =   "Hello, I'm a Geek" 
  print   (   "Initial String: "   ) 
  print   (String1) 
  DEL   String1 
  Печать   (  "\ ndeleting Целая струна:"  ) 
1683 1120202020202020202020202020201201201 2011202012012. 0019 (String1) 
  Error:   
 Traceback (most recent call last):  
 File “/home/e4b8f2170f140da99d2fe57d9d8c6a94.py”, line 12, in  
 print(String1)  
 NameError: name 'String1' не определен 
 Последовательность экранирования в Python 
 При печати строк с одинарными и двойными кавычками возникает ошибка  SyntaxError , так как строка уже содержит одинарные и двойные кавычки и, следовательно, не может быть напечатана с использованием любого из них. Следовательно, для печати такой строки используются либо тройные кавычки, либо Escape-последовательности для печати таких строк.
 Escape-последовательности начинаются с обратной косой черты и могут интерпретироваться по-разному. Если для представления строки используются одинарные кавычки, то все одинарные кавычки, присутствующие в строке, должны быть экранированы, и то же самое делается для двойных кавычек.
 Python3 
  
  String1   = 
  print   (   "Initial String with use of Triple Quotes: "   ) 
  print   (String1) 
  String1   =   'I \' M A "Geek" '
  Печать   (  "\ Nescaping Single Coutte:"   (  "\ nescaping Single Quote:"   (  ". Печать   (String1) 
  String1   =   "I'm A \" Geek \ "" 
  Печать   (  "\ nescaping Double Quotots:"   (  "\ nescap
 Печать   (String1) 
  String1   =   "C: \\ Python \\ Geeks \\" 
  Print   (  "\ nescaping назад.
  print   (String1) 
  
  String1   =   "Hi\tGeeks" 
  print   (   "\nTab: "   ) 
  print   (String1) 
  
  String1   =   "Python\nGeeks" 
  print   (   "\nNew Line: "   ) 
  print   (String1 ) 
  Вывод: 
 Исходная строка с использованием тройных кавычек:
Я "Гик"
Экранирование одинарной кавычки:
Я "Гик"
Экранирование двойных кавычек:
Я "Гик"
Экранирование обратной косой черты:
C:\Python\Geeks\
Вкладка:
Привет гики
Новая линия:
питон
Компьютерщики 
 Чтобы игнорировать escape-последовательности в строке, используется  r  или  R . Это означает, что строка является необработанной строкой, и escape-последовательности внутри нее следует игнорировать.
 Python3 
   String1   =   "\110\145\154\154\157" 
  print   (   "\nPrinting in Octal with the use of Escape Sequences: "   ) 
  печать  (String1) 
  String1   =   R   "Это \ 110 \ 145 \ 154 \ 154 \ 157" 
  Печать   (  "\ nprint : "   ) 
  print   (String1) 
  
  String1   =   "This is \x47\x65\x65\x6b\x73 in \x48\x45\x58" 
  print   (   "\nПечать в HEX с использованием управляющих последовательностей: "   ) 
  print   (String1) 
  
  String1   =   r   "This is \x47\x65\x65\x6b\x73 in \x48\x45\x58" 
  print   (   "\nPrinting Raw String in HEX Format: "   ) 
  print   (String1) 
  Output: 
 Printing in Octal with the использование Escape-последовательностей:
Привет
Печать необработанной строки в восьмеричном формате:
Это \110\145\154\154\157
Печать в HEX с использованием Escape-последовательностей:
Это Компьютерщики в HEX
Печать необработанной строки в формате HEX:
Это \x47\x65\x65\x6b\x73 в \x48\x45\x58 
 Форматирование строк 
 Строки в Python можно форматировать с помощью метода format(), который является очень универсальным и мощным инструментом для форматирования строк. Метод Format в String содержит фигурные скобки {} в качестве заполнителей, которые могут содержать аргументы в соответствии с позицией или ключевым словом для указания порядка.
 Python3 
   
  String1   =   "{} {} {}"   .   формат   (  'Geeks'  ,   'для'  ,   'Life'  ) 
  Печать   (  "Печата.  print   (String1) 
  
  String1   =   "{1} {0} {2}"   .   формат   (   'Гики'   ,   'Для'   ,   'Life'   ) 
  print   (   "\nPrint String in Positional order: "   ) 
  print   (String1) 
  
  String1   =   "{l} {f} {g}"   .   Формат   (G   =   'Geeks'  , F   =   'для'  , L   =   'Life'  )   =   ' )   =  '  )   =   ' )0005
  print   (   "\nPrint String in order of Keywords: "   ) 
  print   (String1) 
  Output:   
 Print String in default order :
Компьютерщики на всю жизнь
Вывести строку в позиционном порядке:
Для вундеркиндов
Вывести строку в порядке ключевых слов:
Life For Geeks 
 Целые числа, такие как двоичные, шестнадцатеричные и т. д., а также числа с плавающей точкой могут округляться или отображаться в форме экспоненты с использованием спецификаторов формата.
 Python3 
  String1   =   "{0:b}"   .   format   (   16   ) 
  print   (   "\nBinary representation of 16 is "   ) 
  print   (String1) 
  
  String1   =   "{0:e}"   .   формат   (   165.6458  ) 
  Печать   (  "\ Nexponent Presention 165,6458 IS"  ) 
  PRINT   (Строситель112020
 . 0:.2f}"   .   Формат   (  1   /  6  ) 
  Печать   (  "\ none-Sixth IS:"  )10} | {:> 10} | " .   Формат   (  'Heeks'  , 
    'для'  , 
9183  'для'  , 
9183  ' , 18393 '  , ,
 3  ',  ,  9005 . ) 
  print   (   "\nВыравнивание по левому краю, центру и правому краю с форматированием: "   ) 
  print   (String1)
} был основан в {1: <4}! " .   Формат   ( " Geeksforgeeks " , 
    2009  ) 59
3331202AS   ( (  ( (  () 5
33333339333112020100  ( ). 
  Вывод:   
 Выравнивание по левому краю, по центру и по правому краю с форматированием:
|Вундеркинды | для | Компьютерщики|
 GeeksforGeeks была основана в 2009 году! 
 Old style formatting was done without the use of format method by using  %  operator 
 Python3 
  
  Integer1   =   12.3456789 
  print   (   "Formatting в формате 3.2f: "   ) 
  print   (   'Целое число1 равно %3.2f'   %   Целое1)
0 0019 Печать   (  "\ nformatting в 3,4F Формат:"  ) 
  Печать   (  'Значение INTEGER1 IS % 3. 4F'   %  1919.K
  Вывод:   
 Форматирование в формате 3.2f:
Значение Integer1 равно 12,35.
Форматирование в формате 3.4f:
Значение Integer1 равно 12,3457 
 Полезные операции со строками Python     Логические операторы в строке
 Форматирование строки с использованием %
 Класс шаблона строки
 Разделение строки
 Строки документации Python
 Разрезание строки
 Поиск всех повторяющихся символов в строке Проверка
 Обратное преобразование строки в 396 программ в Python 9 (13 различных3) строка является палиндромом или нет
 Строковые константы Python  
     Встроенная функция  Описание
 string.ascii_letters  Объединение констант ascii_lowercase и ascii_uppercase.
 string.ascii_lowercase  Concatenation of lowercase letters
 string. ascii_uppercase  Concatenation of uppercase letters
 string.digits  Digit in strings
 string.hexdigits  Hexadigit in strings
 string.letters  объединение строк нижнего и верхнего регистра
 string.lowercase  Строка должна содержать строчные буквы.
 string.octdigits  Octadigit в строке
 string.punctuation  Символы ASCII, содержащие знаки препинания.
 string.printable  Строка символов, которую можно распечатать
 String.endswith()  Возвращает True, если строка заканчивается данным суффиксом, в противном случае возвращает False
 String.startswith()  Возвращает True, если строка начинается с данного префикса, в противном случае возвращает False
 String.isdigit()  Возвращает «True», если все символы в строке являются цифрами. В противном случае, Возвращает «Ложь».
 String.isalpha()  Возвращает «Истина», если все символы в строке являются алфавитами, в противном случае возвращает «Ложь».
 string.isdecimal()  Возвращает значение true, если все символы в строке являются десятичными.
 str.format()  один из методов форматирования строк в Python3, допускающий множественные замены и форматирование значений.
 String.index  Возвращает позицию первого вхождения подстроки в строку
 string.uppercase  Строка должна содержать буквы верхнего регистра.
 string.whitespace  Строка, содержащая все символы, которые считаются пробелами.
 string.swapcase()  Метод преобразует все символы верхнего регистра в нижний и наоборот заданной строки и возвращает его
 replace()  возвращает копию строки, в которой все вхождения подстроки заменяется другой подстрокой.
 Устаревшие строковые функции 
 Встроенная функция  Описание
 string 9.Isdecimal0656  Возвращает истину, если все символы в строке являются десятичными.
 String.Isalnum  Возвращает истину, если все символы в данной строке являются буквенно-цифровыми.
 string.Istitle  Возвращает True, если строка является строкой с заглавным регистром.
 String.Isidentifier  Проверить, является ли строка допустимым идентификатором.
 String.len  Возвращает длину строки.
 String.rindex  Возвращает наибольший индекс подстроки внутри строки, если подстрока найдена.
 String.Max  Возвращает старший буквенный символ в строке.
 String.min  Возвращает минимальный буквенный символ в строке.
 String.splitlines  Возвращает список строк в строке.
 string.capitalize  Возвращает слово с заглавной первой буквой.
 string.expandtabs  Расширить вкладки в строке, заменив их одним или несколькими пробелами
 string.find  Возвращает наименьший индекс подстроки.
 string.rfind  найти самый высокий индекс.
 string.count  Возвращает количество (непересекающихся) вхождений подстроки sub в строке
 string.lower  Возвращает копию s, но с прописными буквами, преобразованными в строчные.
 string.split  Возвращает список слов строки, если необязательный второй аргумент sep отсутствует или отсутствует
 string.rsplit()  Возвращает список слов строки s , сканирование s с конца.
 rpartition()  Метод разбивает заданную строку на три части
 string. splitfields  Возвращает список слов строки при использовании только с двумя аргументами.
 string.join  Объединение списка или кортежа слов с промежуточными вхождениями sep.
 string.strip()  Возвращает копию строки с удаленными начальными и конечными пробелами
 string.lstrip  Возвращает копию строки с удаленными начальными пробелами.
 string.rstrip  Возвращает копию строки с удаленными пробелами в конце.
 string.swapcase  Преобразует строчные буквы в прописные и наоборот.
 string.translate  Перевести символы с помощью таблицы
 string.upper  строчные буквы преобразованы в прописные.
 string.ljust  выравнивание по левому краю в поле заданной ширины.
 string.rjust  Выравнивание по правому краю в поле заданной ширины.
 string.center()  Выравнивание по центру в поле заданной ширины.
 string-zfill  Дополнить числовую строку слева нулевыми цифрами, пока не будет достигнута заданная ширина.
 string.replace  Возвращает копию строки s со всеми вхождениями старой подстроки, замененной новой.
 string.casefold()  Возвращает строку в нижнем регистре, которую можно использовать для безрегистровых сравнений.
 string.encode  Кодирует строку в любую кодировку, поддерживаемую Python. Кодировка по умолчанию utf-8.
 String.Maketrans  Возвращает таблицу перевода, используемая для str.translate ()
 Недавние статьи на String 
 больше видео на Python
.1393 Python String Methods – Part2 
 Python String Methods – Part 3 
 Logical Operations and Splitting in Strings 
  Programs of Python Strings    
 Strings – Set 1, Set 2
 String Methods – Set 1 , Набор 2 , Набор 3
 Регулярные выражения (поиск, сопоставление и поиск всех)
 Метод заголовка строки Python
 Замена запятых и точек в строке
 Программа для преобразования строки в список
 Подсчет и отображение гласных в строке
 Программа на Python для проверки правильности пароля
 Программа на Python для подсчета количества гласных с использованием наборов в заданной строке
 Проверка URL-адреса в строке
 Проверка наличия подстроки в заданной строке
 Проверить, являются ли две строки анаграммой или нет
 Функция отображения и словарь в Python для суммирования значений ASCII
 Функция отображения и лямбда-выражение в Python для замены символов
 SequenceMatcher в Python для самой длинной общей подстроки
 Вывести инициалы имени с фамилией полностью
 k наиболее часто встречающихся слов из набора данных в Python
 Найти все близкие совпадения входной строки из списка
 Проверить, если есть K последовательных единиц в двоичном числе
 Лямбда и фильтр в Python
 Составная строка с необычными символами в Python
 Проверьте, имеют ли обе половины строки одинаковый набор символов в Python
 Поиск первого повторяющегося слова в строке в Python
 Второе наиболее повторяющееся слово в последовательности в Python
 K-й неповторяющийся символ в Python
 Обратное слово в данной строке в Python
 Вывести число с запятыми как 1000 разделителей в Python
 Сопоставление префиксов в Python с использованием модуля pytrie
 Python Regex для извлечения максимального числового значения из строки
 Пары полных строк в двух наборах
 Удалить все повторяющиеся слова из заданного предложения
 Сортировка слов предложения в порядке возрастания
 Переворачивание каждого слова в предложении
 Код Python для печати общих символов двух строк в алфавитном порядке
 Программа Python для разделения и объединения строки
 Код Python для перемещения пробелов вперед строки в одном проходе
 Кодирование длины выполнения в Python
 Удаление всех дубликатов из заданной строки в Python
 Способы увеличения символа в Python
 Сопоставление префиксов в Python с использованием модуля pytrie
 Вывести число с запятыми как 1000 разделителей в Python
 Перевернуть слова в заданной строке в Python
 Выполнить строку кода в Python
 Разрезать строку в Python, чтобы проверить, может ли строка стать пустой при рекурсивном удалении
 Способы для печати escape-символов в Python
 Разрезание строки в Python для поворота строки
 Подсчет вхождений слова в строке
 Поиск k наиболее часто встречающихся слов из набора данных в Python
 Питон | Печатать инициалы имени с фамилией полностью
 Функция Zip в Python для перехода на новый набор символов
 Python String isnumeric() и ее приложение
 Сортировка слов в лексикографическом порядке в Python
 Найти встречающееся число Нечетное количество раз с использованием лямбда-выражения и функции сокращения
 Метод Python String Title
 Сортировка слов предложения в порядке возрастания
 Преобразование списка символов в строку
 Групповой метод Python для удаления всех последовательных дубликатов
 Групповой метод Python для удаления всех последовательных дубликатов
 Программа Python для удаления i-го символа из строки
 Замена строк числами в Python для анализа данных
 Форматированные строковые литералы ( f-strings) в Python
 Python Docstrings
 Перестановка заданной строки с использованием встроенной функции
 Найти частоту каждого слова в строке в Python
 Программа для приема строк, содержащих все гласные буквы
 Подсчет количества совпадающих символов в паре строк
 Подсчет всех префиксов в заданной строке с наибольшей частотой
 Программа для проверки наличия в строке специальных символов
 Генерация случайные строки, пока заданная строка не будет сгенерирована
 Программа Python для подсчета символов верхнего и нижнего регистра без использования встроенных функций
 
 Строки Python 
 В Python строка является неизменяемым типом данных последовательности. Это последовательность символов Unicode, заключенная в одинарные, двойные или тройные кавычки.
 Следующие строки являются допустимыми строковыми литералами в Python.
 'Это строка в Python' # строка в одинарных кавычках
"Это строка в Python" # строка в двойных кавычках
'''Это строка в Python''' # строка в тройных кавычках
"""Это строка в Python""" # строка в тройных двойных кавычках
 
 Строковый литерал может быть присвоен переменной, как показано ниже.
 str1='Это строка в Python'
печать (стр1)
str2="Это строка в Python"
печать (стр2)
 
 Это строка в Python
Это строка в Python
 
 Многострочные строки должны быть заключены в тройные кавычки, как показано ниже.
 str1='''Это
первый
Многострочная строка.
'''
печать (стр1)

str2="""Это
секунда
Многострочный
нить."""
печать (стр2)
 
 Это
первый
Многострочная строка.

Это
секунда
Многострочный
нить. 
 
 Если строковый литерал требует включения двойных кавычек как части строки, то он должен быть заключен в одинарные кавычки.
 Аналогично, если строка включает одинарную кавычку как часть строки, ее следует заключить в двойные кавычки.
 str1='Добро пожаловать в "Учебник по Python" на TutorialsTeacher'
печать (стр1)

str2="Добро пожаловать в 'Учебник по Python' на TutorialsTeacher"
печать (стр2)
     
 Добро пожаловать в «Учебное пособие по Python» от TutorialsTeacher
Добро пожаловать в «Учебник по Python» на TutorialsTeacher
 
 Используйте функцию  len()  для получения длины строки, как показано ниже.
 >>> приветствие='Привет'
>>> лен (приветствовать)
5
 
 Последовательность определяется как упорядоченный набор элементов. Следовательно, строка представляет собой упорядоченный набор символов.
 Последовательность использует индекс, начинающийся с нуля, чтобы получить из нее определенный элемент (символ в случае строки).
 >>> приветствие='привет'
>>> поприветствовать[0]
'час'
>>> поприветствовать[1]
'е'
>>> поприветствовать[2]
'л'
>>> поприветствовать[3]
'л'
>>> поприветствовать[4]
'о'
>>> welcome[5] # выдать ошибку, если index > len(string)-1
Traceback (последний последний вызов):
Файл "", строка 1, в 
приветствовать [5]
IndexError: индекс строки вне допустимого диапазона
 
 Python также поддерживает отрицательное индексирование, начиная с -(длина строки) и заканчивая -1.
 >>> приветствие='привет'
>>> поприветствовать[-5]
'час'
>>> поприветствовать[-4]
'е'
>>> поприветствовать[-3]
'л'
>>> поприветствовать[-2]
'л'
>>> поприветствовать[-1]
'о'
 
 Строка является неизменяемым объектом. Следовательно, изменить его невозможно.
 Попытка присвоить разные символы по определенному индексу приводит к ошибкам.
 >>> приветствие='привет'
>>> приветствие[0]='А'
Traceback (последний последний вызов):
Файл "", строка 1, в 
приветствовать[0]='А'
TypeError: объект 'str' не поддерживает назначение элемента
 
 ул Класс 
 Все строки являются объектами класса  str  в Python.
 >>> приветствие='привет'
>>> типа (приветствовать)
<класс 'ул'>
 
 Используйте функцию  str()  для преобразования числа в строку.
 >>> ул(100)
«100»
>>> ул(-10)
'-10'
>>> ул(правда)
'Истинный'
 
 Escape-последовательности 
 Управляющий символ используется для вызова альтернативной реализации последующего символа в последовательности.
 В Python в качестве управляющего символа используется обратная косая черта \. Используйте символ обратной косой черты, за которым следует символ, который вы хотите вставить в строку, например.  \'  для включения кавычек или  \"  для включения в строку двойных кавычек, как показано ниже.
 str1='Добро пожаловать в \'Учебное пособие по Python\' на TutorialsTeacher'
печать (стр1)

str2="Добро пожаловать в \"Учебное пособие по Python\" на TutorialsTeacher"
печать (стр2)
     
 Добро пожаловать в «Учебное пособие по Python» от TutorialsTeacher
Добро пожаловать в «Учебник по Python» на TutorialsTeacher
 
 Используйте  r  или  r , чтобы игнорировать управляющие последовательности в строке.
 str1=r'Добро пожаловать в \'Учебное пособие по Python\' на TutorialsTeacher'
печать (стр1)
 
 Добро пожаловать в «Учебное пособие по Python» от TutorialsTeacher
 
 В следующей таблице перечислены управляющие последовательности в Python.
 Последовательность выхода  Описание  Пример
 \\  Обратная косая черта  >>> "Привет\\Привет" 
 Привет
 \б  Backspace  >>> "аб\бк" 
 переменный ток
 \f  Подача формы 
 \n  Новая линия  >>> "привет\nмир" 
 Привет 
 Мир
 \nnn  Восьмеричная запись, где n находится в диапазоне 0–7.  >>> '\101' 
 А
 \т  Вкладка  >>> 'Привет\tPython' 
 Привет    Питон
 \xnn  Шестнадцатеричная запись, где n находится в диапазоне от 0 до 9, от a до f или от A до F.  >>> '\x48\x69
 Привет
 \онн  Восьмеричная запись, где n находится в диапазоне 0–9.  >>> "\110\151" 
 Привет
 Строковые операторы 
 Очевидно, что арифметические операторы не работают со строками. Однако существуют специальные операторы для обработки строк.
 Оператор  Описание  Пример
 +  Добавляет вторую строку к первой  >>> а='привет' 
 >>> b='мир' 
 >>> а+б 
 г. 'Привет, мир'
 *  Объединяет несколько копий одной и той же строки  >>> а='привет' 
 >>> а*3 
 'Привет привет привет'
 []  Возвращает символ по заданному индексу  >>> а = 'Питон' 
 >>> а[2] 
 т
 [ : ]  Выбирает символы в диапазоне, указанном двумя операндами индекса, разделенными символом :  >>> а = 'Питон' 
 >>> а[0:2] 
 'Пи'
 в  Возвращает  true , если в данной строке существует символ.  >>> а = 'Питон' 
 >>> 'х' в 
 Ложь 
 >>> 'у' в 
 Правда 
 г.
 >>> 'p' в 
 ЛОЖЬ
 не в  Возвращает  true , если символ не существует в заданной строке  >>> а = 'Питон' 
 г.
 >>> 'x' не в 
 Правда 
 >>> 'y' не в 
 ЛОЖЬ
 Строковые методы 
 Метод  Описание
 ул. капитализовать()  Возвращает копию строки с заглавной буквой первого символа и строчными буквами остальных букв.
 string.casefold()  Возвращает строку в нижнем регистре. Он похож на метод lower(), но метод casefold() преобразует больше символов в нижний регистр.
 строка.центр()  Возвращает новую центрированную строку указанной длины, дополненную указанным символом. Символ по умолчанию — пробел.
 строка.количество()  Выполняет поиск (с учетом регистра) указанной подстроки в заданной строке и возвращает целое число, указывающее вхождения подстроки.
 строка.заканчивается()  Возвращает True, если строка заканчивается указанным суффиксом (с учетом регистра), в противном случае возвращает False.
 строка.expandtabs()  Возвращает строку, в которой все символы табуляции \t заменены одним или несколькими пробелами, в зависимости от количества символов перед \t и указанного размера табуляции.
 строка.найти()  Возвращает индекс первого вхождения подстроки в заданной строке (с учетом регистра). Если подстрока не найдена, возвращается -1.
 строка. индекс()  Возвращает индекс первого вхождения подстроки в заданной строке.
 string.isalnum()  Возвращает True, если все символы в строке являются буквенно-цифровыми (буквами или цифрами). Если нет, возвращается False.
 string.isalpha()  Возвращает True, если все символы в строке являются буквенными (как строчными, так и прописными), и возвращает False, если хотя бы один символ не является алфавитом.
 строка.isascii()  Возвращает True, если строка пуста или все символы в строке ASCII.
 строка.isdecimal()  Возвращает True, если все символы в строке являются десятичными. Если нет, возвращается False.
 строка.isdigit()  Возвращает True, если все символы в строке являются цифрами или символами Unicode цифры. Если нет, возвращается False.
 строка.идентификатор()  Проверяет, является ли строка допустимой строкой идентификатора или нет. Он возвращает True, если строка является допустимым идентификатором, в противном случае возвращает False.
 строка. islower()  Проверяет, все ли символы данной строки в нижнем регистре или нет. Он возвращает True, если все символы в нижнем регистре, и False, даже если один символ в верхнем регистре.
 строка.isnumeric()  Проверяет, все ли символы строки являются числовыми или нет. Он вернет True, если все символы являются числовыми, и вернет False, даже если один символ не является числовым.
 строка.isprintable()  Возвращает True, если все символы данной строки являются Printable. Он возвращает False, даже если один символ является непечатаемым.
 строка. isspace()  Возвращает True, если все символы заданной строки являются пробелами. Он возвращает False, даже если один символ не является пробелом.
 строка.istitle()  Проверяет, является ли первый символ каждого слова прописным, а остальные строчными или нет. Он возвращает True, если строка имеет заглавный регистр; в противном случае возвращается False. Символы и цифры игнорируются.
 строка.isupper()  Возвращает True, если все символы в верхнем регистре, и False, даже если один символ не в верхнем регистре.
 строка. присоединиться()  Возвращает строку, которая представляет собой конкатенацию строки (для которой она вызывается) со строковыми элементами указанного итерируемого объекта в качестве аргумента.
 строка.ljust()  Возвращает выровненную по левому краю строку с указанной шириной. Если указанная ширина больше длины строки, то оставшаяся часть строки заполняется указанным fillchar.
 строка.нижний()  Возвращает копию исходной строки, в которой все символы преобразованы в нижний регистр.
 строка.lstrip()  Возвращает копию строки, удаляя начальные символы, указанные в качестве аргумента.
 строка.maketrans()  Возвращает таблицу сопоставления, которая сопоставляет каждый символ в заданной строке с символом во второй строке в той же позиции. Эта таблица сопоставления используется с методом translate(), который заменяет символы в соответствии с таблицей сопоставления.
 строка.раздел()  Разделяет строку при первом появлении указанного аргумента разделителя строк и возвращает кортеж, содержащий три элемента: часть перед разделителем, сам разделитель и часть после разделителя.
 строка.заменить()  Возвращает копию строки, в которой все вхождения подстроки заменены другой подстрокой.
 строка.rfind()  Возвращает наивысший индекс указанной подстроки (последнее вхождение подстроки) в данной строке.
 строка.rindex()  Возвращает индекс последнего вхождения подстроки в заданной строке.
 строка.rjust()  Возвращает выровненную по правому краю строку с указанной шириной. Если указанная ширина больше длины строки, то оставшаяся часть строки заполняется указанным заполняющим символом.
 строка.rpartition()  Разбивает строку в последнем вхождении указанного аргумента sep разделителя строк и возвращает кортеж, содержащий три элемента: часть перед разделителем, сам разделитель и часть после разделителя.
 строка.rsplit()  Разделяет строку с указанным разделителем и возвращает объект списка со строковыми элементами.
 строка.rstrip()  Возвращает копию строки, удаляя конечные символы, указанные в качестве аргумента.
 строка.split()  Разделяет строку с указанным разделителем и возвращает объект списка со строковыми элементами.
 строка.splitlines()  Разбивает строку по границам строк и возвращает список строк в строке.
 строка.начинается с()  Возвращает True, если строка начинается с указанного префикса. Если нет, возвращается False.
 строка.strip()  Возвращает копию строки, удаляя как начальные, так и конечные символы.
 строка.свопкейс()  Возвращает копию строки с преобразованием символов верхнего регистра в нижний регистр и наоборот. Символы и буквы игнорируются.
 строка.название()  Возвращает строку, в которой каждое слово начинается с символа верхнего регистра, а остальные символы — строчными.
 строка.перевести()  Возвращает строку, в которой каждый символ сопоставляется с соответствующим символом в таблице перевода.
 строка.верхняя()  Возвращает строку в верхнем регистре. Символы и цифры остаются неизменными.
 строка.zfill()  Возвращает копию строки с символами '0', дополненными слева. Он добавляет нули (0) в начало строки до тех пор, пока длина строки не станет равной указанному параметру ширины.
 Основное руководство по Python String на практических примерах 
  Резюме : в этом уроке вы узнаете о строке Python и ее основных операциях.
 Введение в строку Python 
 Строка — это последовательность символов. В Python все, что заключено в кавычки, является строкой. И вы можете использовать как одинарные, так и двойные кавычки. Например:
   message = 'Это строка в Python'
message = "Это тоже строка"  
  Язык кода: Python (python)  
 Если строка содержит одинарную кавычку, вы должны поместить ее в двойные кавычки следующим образом:
   message = "Это строка"  
  Язык кода: Python (python)  
 И когда строка содержит двойные кавычки, вы можете использовать одинарные кавычки:
   message = '"Красиво лучше чем некрасиво».  Сказал Тим Питерс  
  Язык кода: Python (python)  
 Чтобы избежать кавычек, вы используете обратную косую черту (  \  ). Например:
   message = 'Это также допустимая строка'  
  Язык кода: Python (python)  
 Интерпретатор Python будет обрабатывать символ обратной косой черты (\) по-особому. Если вы этого не хотите, вы можете использовать необработанные строки, добавив букву  r  перед первой кавычкой. Например:
   message = r'C:\python\bin'  
  Язык кода: Python (python)  
 Создание многострочных строк 
 Чтобы разделить строку на несколько строк, используйте тройные кавычки «» "…""" или же "'…"'. Например:
   help_message = '''
Использование: команда mysql
    -h имя хоста
    -d имя базы данных
    -у имя пользователя
    -p пароль
'''
print(help_message)  
  Язык кода: Python (python)  
 При выполнении программы будет выведено следующее:
   Использование: команда mysql
    -h имя хоста
    -d имя базы данных
    -у имя пользователя
    -p пароль  
  Язык кода: Python (python)  
 Использование переменных в строках Python с f-строками 
 Иногда вы хотите использовать значения переменных в строке.
 Например, вы можете использовать значение переменной  name  внутри строковой переменной  message :
   name = 'John'
message = 'Hi'  
  Язык кода: Python (python)  
 Для этого нужно поместить букву  f  перед открывающей кавычкой и заключить имя переменной в фигурную скобку:
   name = ' Джон'
сообщение = f'Привет {имя}'
печатать(сообщение)  
  Язык кода: Python (python)  
 Python заменит  {name}  значением переменной  name . Код отобразит на экране следующее:
   Привет, Джон  
  Язык кода: Python (python)  
 Сообщение   представляет собой строку формата или сокращенно f-строку. Python представил f-строку в версии 3.6.
 Объединение строк Python 
 Когда вы размещаете строковые литералы рядом друг с другом, Python автоматически объединяет их в одну строку. Например:
   приветствие = "Доброе утро!"
print(приветствие)  
  Язык кода: Python (python)  
 Вывод:
   Доброе утро!  
  Язык кода: Python (python)  
 Для объединения двух строковых переменных используется оператор  +  :
   приветствие = 'Хорошо'
время = 'Полдень'
приветствие = приветствие + время + '!'
print(приветствие)  
  Язык кода: Python (python)  
 Вывод:
   Добрый день!  
  Язык кода: Python (python)  
 Доступ к элементам строки 
 Поскольку строка представляет собой последовательность символов, вы можете получить доступ к ее элементам, используя индекс. Первый символ в строке имеет нулевой индекс.
 В следующем примере показано, как получить доступ к элементам с помощью индекса:
   str = "Python String"
print(str[0]) # P
print(str[1]) # у  
  Язык кода: Python (python)  
 Как это работает:
 Сначала создайте переменную, содержащую строку  "Python String"  .
 Затем получите доступ к первому и второму символам строки, используя квадратные скобки  []  и индексы.
 Если вы используете отрицательный индекс, Python возвращает символ, начиная с конца строки. Например:
   str = "Строка Python"
print(str[-1]) # г
print(str[-2]) # n  
  Язык кода: Python (python)  
 Ниже показаны индексы строки  "Python String"  :
   +---+---+---+---+- --+---+---+---+---+---+---+---+---+
| П | у | т | ч | о | н | | С | т | р | я | н | г |
+---+---+---+---+---+---+---+---+---+---+---+---+- --+
  0 1 2 3 4 5 6 7 8 9 10 11 12
-13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1  
  Кодовый язык: Python (python)  
 Получение длины строки 
 Чтобы получить длину строки, вы используете функцию  len() . Например:
   str = "Строка Python"
str_len = длина (ул)
Печать (str_len)  
  Язык кода: Python (Python)  
 Вывод:
   13  
  Код. нить. Например: 
    ул = "Строка Python"
print(str[0:2])  
  Язык кода: Python (python)  
 Вывод:
   Py  
  Язык кода: Python (python)  
 str[90:0019]  возвращает подстроку, содержащую символ с индексом от 0 (включено) до 2 (исключено).
 Синтаксис для нарезки следующий:
   строка[начало:конец]  
  Кодовый язык: Python (python)  
 Подстрока всегда включает символ в начале   и исключает строку в конце   .
  start  и  end  являются необязательными. Если вы опустите  start  , по умолчанию он равен нулю. Если вы опустите  end  , по умолчанию будет длина строки.
 Строки Python неизменяемы 
 Строки Python неизменны. Это означает, что вы не можете изменить строку. Например, вы получите сообщение об ошибке, если обновите один или несколько символов в строке:
   ул = "Строка Python"
str[0] = 'J'  
  Язык кода: Python (python)  
 Ошибка:
   Трассировка (последний последний вызов):
  Файл "app. py", строка 2, в 
    ул[0] = 'J'
TypeError: объект 'str' не поддерживает назначение элементов  
  Язык кода: Python (python)  
 Если вы хотите изменить строку, вам нужно создать новую из существующей строки. Например:
   ул = "Строка Python"
new_str = 'J' + ул[1:]
Печать (new_str)  
  Язык кода: Python (Python)  
 Вывод:
   Jython String  
  Код. персонажей. Кроме того, строки Python неизменяемы.   Используйте кавычки, одинарные или двойные кавычки для создания строковых литералов. 
  Использовать символ обратной косой черты  \  для экранирования кавычек в строках 
  Используйте необработанные строки  r'. ..'  для экранирования символа обратной косой черты. 
  Используйте f-строки для вставки заменяющих переменных в литеральные строки. 
  Поместите литеральные строки рядом друг с другом, чтобы соединить их. И используйте оператор + для конкатенации строковых переменных. 
  Используйте функцию  len()  для получения размера строки. 
  Используйте  str[n]  для доступа к символу в позиции n строки  стр  . 
  Используйте нарезку для извлечения подстроки из строки. 
   Считаете ли вы это руководство полезным? 
   Питон | Струны | Codecademy 
   Строка — это последовательность символов, заключенная в пару одинарных ( '  ) или двойных кавычек (  "  ). Строки могут хранить слова, предложения или целые абзацы. Они могут быть любой длины и содержать буквы, цифры, символы и пробелы 
    message1 = "Я строка" 
  message2 = 'Я тоже строка' 
 
 Другие типы данных, такие как  целых чисел  ,  удвоений  и  логических значений  также могут быть  строками  , если они заключены в кавычки.
 Пример  Строка?
 «2» (с двойными кавычками)  Да ✅
 ‘3.6’ (с одинарными кавычками)  Да ✅
 «Правда» (также в кавычках)  Да ✅
 7 (целое)  Нет ❌
 Привет (без кавычек)  Нет ❌
 Истина (логическое значение)  Нет ❌
 Строки неизменяемы; они не могут измениться. Каждый раз, когда над строкой выполняется операция, в памяти создается новая строка.
 Доступ к символам строки 
 Строки в Python технически представляют собой тип списка, в котором каждый символ является отдельным элементом. Это означает, что к каждому символу в строке можно получить индивидуальный доступ по индексу, как и к элементам в списке:
   myString = "Привет, мир!" 
  var_1 = myString[0] 
  var_2 = myString[7:] 
  var_3 = myString[1:4] 
  print("var_1: " + var_1) # Вывод: var_1: H 
  print("var_2 : " + var_2) # Вывод: var_2: Мир! 
  print("var_3: " + var_3) # Вывод: var_3: ell 
 
 Если будет предпринята попытка доступа к индексу за пределами границ, он вернет  IndexError  .
   имя = "филлис" 
  name[8] # Выдает ошибку IndexError 
 
 Многострочные строки 
 Строки могут быть длинными или короткими. Для более длинного текста можно использовать многострочную строку. Многострочные строки начинаются и заканчиваются тремя одинарными или двойными кавычками:
   my_string = """Если бы это было сделано тогда, когда это было сделано, то это было хорошо до следствия, и поймать 
  С его окончанием успеха, что но этот удар 
  Может быть, все и конец всего здесь, 
  Но здесь, на этом берегу и отмели времени, 
  Мы прыгнем в грядущую жизнь.""" 
 
 Escape Characters 
 Иногда строка может содержать символ, который Python пытается интерпретировать, например,  '  .
   my_string = 'Прекрасный день!' 
  print(my_string) 
 
 Это вызовет ошибку, потому что интерпретатор считает, что вторая 9
 SyntaxError: недопустимый синтаксис
 
 
 Эти символы можно «экранировать», предварительно добавив обратную косую черту.  \  называется escape-символом.
 Обратная косая черта не будет видна, если будет напечатана строка:
   my_string = 'Прекрасный день!' 
  print(my_string) 
  # Вывод: Прекрасный день! 
 
 Этой проблемы можно избежать, заключая строки, содержащие  '  символов, в двойные кавычки:
   my_string = "Прекрасный день!" 
  print(my_string) 
  # Вывод: Прекрасный день! 
 
 Python также имеет ряд непечатаемых символов, которые могут изменять строки. Например, \n  добавляет новую строку, а  \t  добавляет вкладку:
   note = "Я сверху!\nЯ снизу. \n\tУ меня есть отступ!" 
  print(note) 
 
 Это выведет:
   Я на вершине! 
  Я на дне.  
  У меня отступ! 
 
 Изменение строк 
 В Python есть специальные операторы для изменения строк. Например,  +  можно использовать для объединения строк, а  *  — для умножения строки. Ключевое слово  в  можно использовать, чтобы узнать, существует ли данный символ или подстрока в строке   .
   string_one = "Привет," 
  string_two = "Мир!" 
  combo = string_one + string_two 
  print(combo) 
  # Вывод: Hello, World! 
  new_combo = combo * 2 
  print(new_combo) 
  # Вывод: Привет, мир! Привет, мир! 
  if "Мир" в new_combo: 
  print("Это здесь!") 
  # Вывод: Это здесь! 
 
 Строки также могут быть отформатированы одним из следующих способов:
 Флаг  f/F  (помещается перед открывающей кавычкой).
 Метод .format() (требуется добавление заполнителей вручную).
 Сравнение строк 
 Python может использовать операторы сравнения для сравнения содержимого двух строк. Операторы ведут себя так же, как и с числовыми аргументами:
 Оператор  Срок  Описание
  ==  Равно  Возвращает  True , если две строки равны.
  !=  Не равно  Возвращает  True , если две строки не равны.
  <  Менее  Возвращает  True , если левая строка лексически предшествует правой строке.
  >  Больше  Возвращает  Истина  — левая строка лексически следует за правой строкой.
  <=  Меньше или равно  Возвращает  True , если левая строка равна или лексически предшествует правой строке.
  >=  Больше или равно  Возвращает  True , если левая строка равна или лексически следует за правой строкой.
 В следующем примере показано сравнение строк:
  Код 
  Выход 
  Загрузка... 
 
 Встроенные строковые методы 
 Python имеет ряд встроенных строковых методов, которые манипулируют строками. Однако при вызове этих методов исходная строка не будет изменена, поэтому любые изменения необходимо будет сохранить в новой переменной. Несколько полезных встроенных строковых методов перечислены ниже.
 Учебники по струнам и заметки | Python 
 Python String: 
 Строки представляют собой последовательности символов. Ваше имя можно считать строкой. Или, скажем, вы живете в Замбии, тогда название вашей страны  "Замбия"  , это строка.
 В этом руководстве вы увидите, как строки обрабатываются в Python, различные способы представления строк в Python и способы использования строк в коде.
 Как создать строку и присвоить ее переменной 
 Чтобы создать строку, поместите последовательность символов в одинарные, двойные или тройные кавычки, а затем присвойте ее переменной. Вы можете посмотреть, как переменные работают в Python, в учебнике по переменным Python.
 Например, вы можете присвоить символ «a» переменной  single_quote_character  . Обратите внимание, что строка состоит из одного символа и «заключена» в одинарные кавычки.
 >>> single_quote_character = 'а'
>>> печать (одинарная_кавычка_символ)
а
>>> print(type(single_quote_character)) # проверить тип переменной.
<класс 'ул'>
 
 Точно так же вы можете присвоить один символ переменной  double_quote_character  . Обратите внимание, что строка состоит из одного символа, но она «заключена» в двойные кавычки.
 >>> double_quote_character = "б"
>>> печать (символ_двойной_кавычки)
б
>>> печать (тип (символ_двойной кавычки))
<класс 'ул'>
 
 Также проверьте, можно ли присвоить переменной последовательность символов или несколько символов. Вы можете назначать как последовательности одинарных кавычек, так и последовательности двойных кавычек.
 >>> double_quote_multiple_characters = "аиоу"
>>> single_quote_multiple_characters = 'aiou'
>>> print(type(двойные_кавычки_multiple_characters), type(single_quote_multiple_characters))
<класс 'ул'> <класс 'ул'>
 
 Интересно, что если вы проверите эквивалентность одного другому, используя ключевое слово  is , оно вернет True.
 >>> print(double_quote_multiple_characters is double_quote_multiple_characters)
Истинный
 
 Взгляните на присвоение строк с помощью тройных кавычек и проверьте, принадлежат ли они также к классу  str .
 >>> triple_quote_example = """это предложение, заключенное в тройные кавычки"""
>>> печать (тип (triple_quote_example))
<класс 'ул'>
 
 В приведенных выше примерах функция  типа  используется для отображения базового класса, к которому будет принадлежать объект. Обратите внимание, что все переменные, которые были инициированы одинарными, двойными или тройными кавычками, воспринимаются как строки. Вы можете использовать одинарные и двойные кавычки для одной строки символов. Несколько строк обычно заключаются в тройные кавычки.
 Общие методы строки 
 2 возвращается, так как положение отдельных букв в строках имеет нулевой индекс. Итак, индекс «а» в «abcde» равен 0, индекс «b» равен 1 и так далее.
 Проверить, является ли подстрока частью большей строки. Это делается с помощью ключевого слова  в  и написания теста. Скелет показан ниже.
 подстрока в строке
 >>> # например, проверить, присутствует ли строка "i" в строке "pythonic" хотя бы один раз. «i» присутствует в строке. Следовательно, результат должен быть верным.
>>> "i" в "pythonic"
Истинный
>>> # поскольку "x" отсутствует в строке "pythonic", приведенный ниже тест должен вернуть false
>>> "x" в "pythonic" # "x" отсутствует в "pythonic"
ЛОЖЬ
 
 Присоедините список строк, используя метод соединения. Список строк записывается путем разделения последовательности запятыми  ,  и заключения всей группы в скобки  [. ..]  . Более подробное руководство по спискам можно найти в учебнике по спискам Python.
Вы можете присоединиться к списку строк, задав разделитель в качестве объекта, над которым будет действовать метод  join , и список строк в качестве аргумента.
 >>> # объединить список строк 1, 2, 3 с помощью пробела в качестве разделителя и 1,2,3 в качестве списка строк. Таким образом, результатом будут строки с пробелами между ними.
>>> comb_string = " ".join(["1", "2", "3"])
«1 2 3»
 
 Разорвать строку по некоторому правилу.
Это принимает строку как объект, на который передается метод  split  с использованием оператора точки. Разделение требует пробела в качестве параметра по умолчанию.
 Например, вы можете разделить строку на основе пробелов между отдельными значениями.
 >>> # разделить строку "1 2 3" и вернуть список чисел.
    >>> "1 2 3".split() # разделение
    ['1', '2', '3']
 
 Или вы можете разделить строку на основе разделителя, например  :  .
No related posts.
Вперед Какие атрибуты существуют у тега table: Атрибут таблицы
Назад Продвижение портала: Бесплатная пошаговая инструкция по продвижению сайтов самостоятельно — SEO на vc.ru
Добавить комментарий Отменить ответ
Ваш адрес email не будет опубликован. Обязательные поля помечены *
Комментарий *
Имя * 
Email * 
Сайт 
  
  
Рубрики
Css
Html
Http
Javascript
Photoshop
Верстка
Вопросы и ответы
Макет
Развитие сайтов
Сайт
Шаблон
Шрифт
Разное
Рубрики
Css
Html
Http
Javascript
Linux
Photoshop
Адаптив
Верстка
Вопросы и ответы
Макет
Развитие сайтов
Разное
Сайт
Советы
Шаблон
Шаблоны
Шрифт
Шрифты
 Блог сумасшедшего сисадмина © 2024. Все права защищены.
Карта сайта