Операции со строками python: Работа со строками в Python. Готовимся к собеседованию: вспоминаем азы

Работа со строками в Python. Готовимся к собеседованию: вспоминаем азы

Петр Смолович

ведущий разработчик хостинг-провайдера и регистратора доменов REG.RU

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

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

Как склеить две строки?

>>> s = "abc" + "def"
>>> s += "xyz"

Элементарно? Почти. Важно помнить, что строки — это неизменяемые объекты. Каждый раз, когда мы говорим про «изменение» строки, технически мы создаем новый объект и записываем туда вычисленное значение.

А как склеить три строки? Напрашивается ответ «точно так же», и иногда это самый лучший способ. Но интервьюер скорее всего хочет проверить, знаете ли вы про метод

.join().

>>> names = ["John", "Paul", "Ringo", "George"]
>>> ", ".join(names)
'John, Paul, Ringo, George'

join() — очень удобный метод, позволяющий склеить N строк, причём с произвольным разделителем.

Здесь важно не только получить результат, но и понимать, как работает приведённая конструкция. А именно, что join() — это метод объекта «строка», принимающий в качестве аргумента список и возвращающий на выходе новую строку.
Кстати, хорошая задачка для интервью — написать свою реализацию join().

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

Есть несколько способов получить часть строки. Первый — это split, обратный метод для join. В отличие от join’а, он применяется к целевой строке, а разделитель передаётся аргументом.

>>> s = "Альфа, Браво, Чарли"
>>> s.split(", ")
['Альфа', 'Браво', 'Чарли']

Второй — срезы (slices).

Срез s[x:y] позволяет получить подстроку с символа x до символа y. Можно не указывать любое из значений, чтобы двигаться с начала или до конца строки. Отрицательные значения используются для отсчёта с конца (-1 — последний символ, -2 — предпоследний и т.п.).

>>> s = "Hello, world!"
>>> print(s[0:5])
Hello
>>> print(s[-6:])
world!

При помощи необязательного третьего параметра s[x:y:N] можно выбрать из подстроки каждый N-ый символ. Например, получить только чётные или только нечётные символы:

>>> s = "0123456789"
>>> print(s[::2])
02468
>>> print(s[1::2])
13579

Что насчёт поиска в строке?

Самое быстрое — проверить, начинается ли (заканчивается ли) строка с выбранных символов. Для этого в Python предусмотрены специальные строковые методы./]+)(.*)$», s) >>> print(result.group(1)) https >>> print(result.group(2)) www.reg.ru >>> print(result.group(3)) /hosting/

А замену в строке сделать сможете?

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

>>> s = "Hello, darling! How are you?"
>>> s[:7] + "Василий" + s[14:]
'Hello, Василий! How are you?'

Во-вторых, умеешь find(), умей и replace().

>>> s.replace("darling", "Василий")
'Hello, Василий! How are you?'

В-третьих, любую проблему можно решить регулярными выражениями. Либо получить две проблемы 🙂 В случае с заменой вам нужен метод re.sub().

>>> s = "https://www.reg.ru/hosting/";
>>> import re
>>> print(re.sub('[a-z]', 'X', s))
XXXXX://XXX.XXX.XX/XXXXXXX/

Посимвольная обработка?

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

>>> s = "Hello, world!"
>>> for c in s:
>>>     if c == "o":
>>>         counter += 1
>>> print(counter)
2

Иногда удобнее бежать по индексу.

>>> for i in range(len(s)):
>>>     if s[i] == "o":
>>>         counter += 1

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

>>> s[i] = "X"
Traceback (most recent call last):
File "", line 1, in 
TypeError: 'str' object does not support item assignment
>>> s[:i] + "X" + s[i+1:]
'HellX, world!'

Либо можно преобразовать строку в список, сделать обработку, а потом склеить список обратно в строку:

>>> arr = list(s)
>>> "".join(arr)
'Hello, world!'

А форматирование строк?

Типичная жизненная необходимость — сформировать строку, подставив в неё результат работы программы. Начиная с Python 3.6, это можно делать при помощи f-строк:

>>> f"Строка '{s}' содержит {len(s)} символов."
"Строка 'Hello, world!' содержит 13 символов."

В более старом коде можно встретить альтернативные способы

>>> "Строка '%s' содержит %d символов" % (s, len(s))
>>> "Строка '{}' содержит {} символов".format(s, len(s))

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

>>> "Строка '" + s + "' содержит " + str(len(s)) + " символов."
"Строка 'Hello, world!' содержит 13 символов."

***

Цель работодателя на собеседовании — убедиться что вы соображаете и что вы справитесь с реальными задачами. Однако погружение в реальные задачи занимает несколько недель, а время интервью ограничено. Поэтому вас ждут учебные задания, которые можно решить за 10-30 минут, а также вопросы на понимание того, как работает код. О них и поговорим в следующей части.

Python. Строки. Общие понятия. Объявление строки. Операции над строками. Примеры

Строки. Общие понятия. Объявление строки. Операции над строками. Примеры

---

Содержание

---

Поиск на других ресурсах:

1. Определение строки. Назначение строк

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

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

• информацию в файлах;
• данные об именах, описаниях, комментариях в базах данных;
• доменные имена в сети Internet;
• информационные тексты в документах, которые поддерживают кодирование Unicode;
• другое.

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

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

Примеры строк литералов.

"Hello world!"
'bestprog.net'
'1234567890'
"1234567890"
"I'm" # строка I'm - одинарные кавычки в двойных кавычках
'I"m' # строка I"m - двойные кавычки в одинарных кавычках

  ⇑

2. Какие строковые типы поддерживаются в Python?

В языке Python поддерживаются три типа строк:

• строки типа str – предназначенные для представления текста в формате Unicode и других системах кодирования. Этот формат содержит символы в кодировке ASCII и символы в других кодировках;
• строки типа bytes – предназначенные для представления двоичных данных;
• строки типа bytearray – предназначенные для представления двоичных данных с учетом изменений в типе bytes.

В версии Python 2.6 для представления текста Unicode используется тип unicode.

  ⇑

3. Как объявить переменную типа «строка»? Общая форма

Чтобы объявить переменную типа строка достаточно использовать оператор присваивания =. Общая форма объявления переменной следующая

variable_name = string

где

• variable_name – имя создаваемой переменной. В дальнейшем это имя используется в программе и связано со строкой string;
• string – строка (литерал), размещенная между одинарными или двойными кавычки.

---

---

  ⇑

4. Примеры объявления строковых переменных

 

a = 'abcde' # объявление с помощью одинарной кавычки
b = "abcde" # объявление с помощью двойной кавычки
line = '' # пустая строка
block_s = """abcde""" # блок в тройной кавычке
s1 = b'hello' # строка байт в версиях 3.0 и старше
s2 = u'hello' # строка с символами Unicode
s3 = 's\np\ta\x00m' # экранированные последовательности
s4 = r'c:\myfolder\myfile1.txt' # неформатированная строка

  ⇑

5. Существует ли в Python тип, который описывает одиночный символ (например char)?

Нет, не существует. Для описания одиночного символа используется одна и та же строка, которая содержит только один символ (односимвольная строка), например:

firstLetter = 'A'
lastLetter = 'Z'
zero = '0'

  ⇑

6. Базовые операторы для работы со строками. Таблица

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

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

Оператор (операция)	Использование в программах	Объяснение
+	s1+s2	Конкатенация
*	s*2	Повторение
[ ]	s[i]	Обращение к символу строки s по индексу i
[:]	s[i:j]	Вытягивание подстроки из позиции i до позиции j

  ⇑

7. Пример использования оператора + конкатенации (сложение) строк

Оператор конкатенации или сложения строк обозначается символом +. Оператор может использоваться в выражениях различной сложности.

Пример.

# Оператор конкатенации - сложение строк
s1 = 'Hello'
s2 = 'world!'
s3 = s1 + ' ' + s2 # s3 = 'Hello world!'

  ⇑

8. Пример использования оператора * повторения строк

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

Пример. В примере строка s2 равна трем строкам s1

# Оператор повторения строк *
s1 = 'abc'
s2 = s1*3 # 'abcabcabc'

  ⇑

9. Пример использования оператора [] вытягивания элемента строки по ее индексу

Чтобы получить один символ строки, используется операция индексирования []. Ниже приведены примеры получения символа строки по ее индексу. Нумерация индексов начинается с 0.

Пример. В примере переменной c присваивается символ с индексом [1] строки

s.

# Оператор [] - вытягивание символа в строке по ее индексу
s1 = 'abc'
c = s1[1] # c = 'b'

  ⇑

10. Пример использования оператора [:] вытягивания подстроки из строки

Оператор [:] используется для обработки подстрок в строках. Этот оператор имеет много разновидностей. Более подробно о работе оператора [:] описывается здесь. В данной теме приведены несколько ограниченных примеров использования оператора вытягивания строки из подстроки.

Пример.

# Оператор [:] - вытягивание символа в строке по индексу
s1 = '01234567890'
s2 = s1[2:4] # s2 = '23'
s3 = s1[:5] # s3 = '01234'
s4 = s1[:-1] # s4 = '0123456789'

  ⇑

11. Пример обхода строки с помощью оператора цикла for

В примере демонстрируется просмотр всех символов строки с помощью оператора цикла for. Решается задача просмотра количества символов ‘z’ в строке. Строка вводится с клавиатуры.

# Строки
# Пример обхода элементов строки в цикле

# 1. Ввод строки
s = str(input("Enter string: "))

# 2. Вывод строки для проверки - цикл обхода строки
for c in s:
    print(c, end=' ') # посимвольный вывод строки
print()

# 3. Определение количества символов 'z' в строке
count = 0;
for c in s:
    if c=='z':
        count = count+1

# вывод результата
print("count = ", count)

Результат выполнения программы

Enter string: zero z1sdlkj 12+laksd
z e r o   z 1 s d l k j   1 2 + l a k s d
count = 2

  ⇑

12. Сравнение строк. Рисунок. Примеры

Строки можно сравнивать между собой с помощью операций сравнения >, <, >=, <=, ==, !=.

Строки сравниваются по следующим правилам (рисунок 1):

1. Направление сравнения происходит слева направо;
2. Строки сравниваются посимвольно. Сравниваются коды соответствующих символов;
3. Сравнение строк завершается при выполнении одного из следующих условий:
   • нарушается равенство кодов;
   • одна из строк оканчивается;
   • обе строки оканчиваются.

Рисунок 1. Сравнение строк: а) строки разной длины; б) строки одинаковой длины

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

Рисунок 2. Пример одинаковых строк. Строка s1 равна строке s2

Пример. В примере демонстрируется ввод строк и вывод результата их сравнения.

# Ввод строк для сравнения
s1 = input("s1 = ")
s2 = input("s2 = ")

# Сравнение строк и вывод результата
if s1>s2:
    print("s1 > s2")
elif s1==s2:
    print("s1 == s2")
else:
    print("s1 < s2")

  ⇑

---

Связанные темы

  ⇑

---

 

Введение в 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

В Python существуют несколько видов данных. Основные типы данных, с которыми вы столкнетесь – это string, ingteger, float, list, dict и tuple. В данной статье мы рассмотрим тип данных string (строка). Вы удивитесь тому, сколько всего можно делать со строками в Python. Также существует модуль string, который можно импортировать для получения доступа к еще большим возможностям, но мы рассмотрим его в другой статье. Вместо этого, мы пройдемся по следующим разделам:

• Как создавать строки
• Конкатенация строк
• Методы строк
• Замена строк

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

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

my_string = «Добро пожаловать в Python!» another_string = ‘Я новый текст тут…’ a_long_string = »’А это у нас новая строка в троичных скобках»’

my_string = «Добро пожаловать в Python!» another_string = ‘Я новый текст тут…’   a_long_string = »’А это у нас новая строка в троичных скобках»’

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

my_string = «I’m a Python programmer!» otherString = ‘Слово «Python» обычно подразумевает змею’ tripleString = «»»В такой «строке» мы можем ‘использовать’ все.»»»

my_string = «I’m a Python programmer!» otherString = ‘Слово «Python» обычно подразумевает змею’ tripleString = «»»В такой «строке» мы можем ‘использовать’ все.»»»

Данный код демонстрирует то, как вы можете вписать одинарные или двойные скобки в строку. Существует еще один способ создания строки, при помощи метода str. Как это работает:

my_number = 123 my_string = str(my_number)

my_number = 123 my_string = str(my_number)

Если вы впишете данный код в ваш интерпретатор, вы увидите, что вы изменили значение интегратора на строку и присвоили ее переменной my_string. Это называется кастинг, или конвертирование. Вы можете конвертировать некоторые типы данных в другие, например числа в строки. Но вы также заметите, что вы не всегда можете делать обратное, например, конвертировать строку вроде ‘ABC’ в целое число. Если вы сделаете это, то получите ошибку вроде той, что указана в этом примере:

int(‘ABC’) Traceback (most recent call last): File «<string>», line 1, in <fragment> ValueError: invalid literal for int() with base 10: ‘ABC’

int(‘ABC’)   Traceback (most recent call last):     File «<string>», line 1, in <fragment> ValueError: invalid literal for int() with base 10: ‘ABC’

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

То все должно работать. Обратите внимание на то, что строка – это один из неизменных типов Python. Это значит, что вы не можете менять содержимое строки после ее создания. Давайте попробуем сделать это и посмотрим, что получится:

my_string = «abc» my_string[0] = «d» Traceback (most recent call last): File «<string>», line 1, in <fragment> TypeError: ‘str’ object does not support item assignment

my_string = «abc» my_string[0] = «d»   Traceback (most recent call last):     File «<string>», line 1, in <fragment> TypeError: ‘str’ object does not support item assignment

Здесь мы пытаемся изменить первую букву с «а» на «d«, в итоге это привело к ошибке TypeError, которая не дает нам сделать это. Теперь вы можете подумать, что присвоение новой строке то же значение и есть изменение строки. Давайте взглянем, правда ли это:

my_string = «abc» a = id(my_string) print(a) # 19397208 my_string = «def» b = id(my_string) print(b) # 25558288 my_string = my_string + «ghi» c = id(my_string) print(c) # 31345312

my_string = «abc» a = id(my_string) print(a) # 19397208   my_string = «def» b = id(my_string) print(b) # 25558288   my_string = my_string + «ghi» c = id(my_string) print(c) # 31345312

Проверив id объекта, мы можем определить, что когда мы присваиваем новое значение переменной, то это меняет тождество. Обратите внимание, что в версии Python, начиная с 2.0, строки могут содержать только символы ASCII. Если вам нужен Unicode, тогда вы должны вписывать u перед вашей строкой. Пример:

# -*- coding: utf-8 -*- my_unicode_string = u»Это юникод!»

# -*- coding: utf-8 -*- my_unicode_string = u»Это юникод!»

В Python, начиная с версии 3, все строки являются юникодом.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

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

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

# -*- coding: utf-8 -*- string_one = «Собака съела » string_two = «мою книгу!» string_three = string_one + string_two print(string_three) # Собака съела мою книгу!

# -*- coding: utf-8 -*-   string_one = «Собака съела « string_two = «мою книгу!» string_three = string_one + string_two   print(string_three) # Собака съела мою книгу!

Оператор + конкатенирует две строки в одну

Методы строк

Строка является объектом в Python. Фактически, все, что есть в Python – является объектом. Если вы хотите узнать больше об Объектно-ориентированном программирование, мы рассмотрим это в другой статье «Классы в Python«. В данный момент достаточно знать, что строки содержат собственные встроенные методы. Например, допустим, у вас есть следующая строка:

my_string = «This is a string!»

my_string = «This is a string!»

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

Если вы открыли ваш интерпретатор, вы также можете сделать то же самое:

«This is a string!».upper()

«This is a string!».upper()

Существует великое множество других методов строк. Например, если вам нужно, что бы все было в нижнем регистре, вам нужно использовать метод lower(). Если вы хотите удалить все начальные и конечные пробелы, вам понадобится метод strip(). Для получения списка всех методов строк, впишите следующую команду в ваш интерпретатор:

Вы увидите что-то на подобие этого:

[‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getnewargs__’, ‘__getslice__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mod__’, ‘__mul__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__rmod__’, ‘__rmul__’, ‘__- setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘_formatter_field_name_split’, ‘_formatter_parser’, ‘capitalize’, ‘center’, ‘count’, ‘decode’, ‘encode’, ‘endswith’, ‘expandtabs’, ‘find’, ‘format’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isdigit’, ‘islower’, ‘isspace’, ‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’, ‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’, ‘title’, ‘translate’, ‘upper’, ‘zfill’]

[‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getnewargs__’, ‘__getslice__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mod__’, ‘__mul__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__rmod__’, ‘__rmul__’, ‘__- setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘_formatter_field_name_split’, ‘_formatter_parser’, ‘capitalize’, ‘center’, ‘count’, ‘decode’, ‘encode’, ‘endswith’, ‘expandtabs’, ‘find’, ‘format’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isdigit’, ‘islower’, ‘isspace’, ‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’, ‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’, ‘title’, ‘translate’, ‘upper’, ‘zfill’]

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

help(my_string.capitalize)

help(my_string.capitalize)

Вы получите следующую информацию:

Help on built-in function capitalize: capitalize(…) S.capitalize() -> string Выдача копии строки S только с заглавной буквой.

Help on built-in function capitalize:   capitalize(…)     S.capitalize() -> string   Выдача копии строки S только с заглавной буквой.

Вы только что узнали кое-что о разделе, под названием интроспекция. Python может исследовать все свои объекты, что делает его очень легким в использовании. В основном, интроспекция позволяет вам спрашивать Python о нём. Вам моет быть интересно, как сказать о том, какой тип переменной был использован (другими словами int или string). Вы можете спросить об этом у Python!

type(my_string) # <type ‘str’>

type(my_string) # <type ‘str’>

Как вы видите, тип переменной my_string является str!

Нарезка строк

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

my_string = «I like Python!»

my_string = «I like Python!»

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

print( my_string[0:1] ) # I

print( my_string[0:1] ) # I

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

0 1 2 3 4 5 6 7 8 9 10 11 12 13 — I l i k e P y t h o n !

0 1 2 3 4 5 6 7 8 9 10 11 12 13 — I l i k e P y t h o n !

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

my_string[:1] # ‘I’ my_string[0:12] # ‘I like Pytho’ my_string[0:13] # ‘I like Python’ my_string[0:14] # ‘I like Python!’ my_string[0:-5] # ‘I like Py’ my_string[:] # ‘I like Python!’ my_string[2:] # ‘like Python!’

my_string[:1] # ‘I’ my_string[0:12] # ‘I like Pytho’ my_string[0:13] # ‘I like Python’ my_string[0:14] # ‘I like Python!’ my_string[0:-5] # ‘I like Py’ my_string[:] # ‘I like Python!’ my_string[2:] # ‘like Python!’

Как видно в данных примерах, мы можем назначить срез, лишь указав его начало (другими словами, my_string[2:]), конец среза (my_string[:1]), или оба (my_string[0:13]). Мы можем даже использовать отрицательные значения, которые начинаются с конца строки. Так что в примере, где мы указали my_string[0:-5], начало ведется с нуля и заканчивается 5 символами, перед концом строки. Вы можете задаться вопросом «Зачем мне это и где это можно применить?». Лично я использовал это для разбора записей с фиксированной шириной в файлах, или ситуативно для парсинга сложных названий файлов, с очень специфическими наименованиями. Также я использовал это для парсинга значений в бинарных файлах. Любая работа, которая включает в себя обработку текстовых файлов, может быть намного проще, если вы понимаете, как работает нарезка и как эффективно использовать данный инструмент. Вы также можете получить доступ к отдельным символам в строке с помощью индексации. Например:

Данный код выдаст первый символ в строке.

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

Форматирование строк (также известно как замещение) – это замещение значений в базовой строке. Большую часть времени вы будете вставлять строки внутри строк, однако, вам также понадобиться вставлять целые числа и числа с запятыми в строки весьма часто. Существует два способа достичь этой цели. Начнем с старого способа, после чего перейдем к новому:

# -*- coding: utf-8 -*- my_string = «Я люблю %s» % «Python» print(my_string) # Я люблю Python var = «яблоки» newString = «Я ем %s» % var print(newString) # Я ем яблоки another_string = «Я люблю %s и %s» % («Python», var) print(another_string) # Я люблю Python и яблоки

# -*- coding: utf-8 -*-   my_string = «Я люблю %s» % «Python» print(my_string) # Я люблю Python   var = «яблоки» newString = «Я ем %s» % var print(newString) # Я ем яблоки   another_string = «Я люблю %s и %s» % («Python», var) print(another_string) # Я люблю Python и яблоки

Как вы могли догадаться, % — это очень важная часть вышеописанного кода. Этот символ указывает Python, что вы скоро вставите текст на его место. Если вы будете следовать за строкой со знаком процента и другой строкой или переменной, тогда Python попытается вставить ее в строку. Вы можете вставить несколько строк, добавив несколько знаков процента в свою строку. Это видно в последнем примере. Обратите внимание на то, что когда вы добавляете больше одной строки, вам нужно закрыть эти строки в круглые скобки. Теперь взглянем на то, что случится, если мы вставим недостаточное количество строк:

another_string = «Я люблю %s и %s» % «Python» Traceback (most recent call last): File «<string>», line 1, in <fragment> TypeError: not enough arguments for format string

another_string = «Я люблю %s и %s» % «Python»   Traceback (most recent call last):     File «<string>», line 1, in <fragment> TypeError: not enough arguments for format string

О-па. Мы не передали необходимое количество аргументов для форматирования строки. Если вы внимательно взгляните на пример, вы увидите, что у нас есть два экземпляра %, но для того, чтобы вставить строки, вам нужно передать столько же %, сколько у нас строк. Теперь вы готовы к тому, чтобы узнать больше о вставке целых чисел, и чисел с запятыми. Давайте взглянем.

my_string = «%i + %i = %i» % (1,2,3) print(my_string) # ‘1 + 2 = 3’ float_string = «%f» % (1.23) print(float_string) # ‘1.230000’ float_string2 = «%.2f» % (1.23) print(float_string2) # ‘1.23’ float_string3 = «%.2f» % (1.237) print(float_string3) # ‘1.24’

my_string = «%i + %i = %i» % (1,2,3) print(my_string) # ‘1 + 2 = 3’   float_string = «%f» % (1.23) print(float_string) # ‘1.230000’   float_string2 = «%.2f» % (1.23) print(float_string2) # ‘1.23’   float_string3 = «%.2f» % (1.237) print(float_string3) # ‘1.24’

Первый пример достаточно простой. Мы создали строку, которая принимает три аргумента, и мы передаем их. В случае, если вы еще не поняли, Python не делает никаких дополнений в первом примере. Во втором примере, мы передаем число с запятой. Обратите внимание на то, что результат включает множество дополнительных нулей (1.230000). Нам это не нужно, так что мы указываем Python ограничить выдачу до двух десятичных значений в третьем примере (“%.2f”). Последний пример показывает, что Python округлит числа для вас, если вы передадите ему дробь, что лучше, чем два десятичных значения. Давайте взглянем на то, что произойдет, если мы передадим неправильные данные:

int_float_err = «%i + %f» % («1», «2.00») Traceback (most recent call last): File «<string>», line 1, in <fragment> TypeError: %d format: a number is required, not str

int_float_err = «%i + %f» % («1», «2.00») Traceback (most recent call last):     File «<string>», line 1, in <fragment> TypeError: %d format: a number is required, not str

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

int_float_err = «%i + %f» % (1, «2.00») Traceback (most recent call last): File «<string>», line 1, in <fragment> TypeError: float argument required, not str

int_float_err = «%i + %f» % (1, «2.00»)   Traceback (most recent call last):     File «<string>», line 1, in <fragment> TypeError: float argument required, not str

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

Шаблоны и новая методика форматирования строк

Этот метод был добавлен в Python 2.4 в виде шаблонов строк, но в качестве обычного метода string, работающего через метод format в версии 2.6. Так что это не самый свежий метод, просто обновленный. В любом случае, приступим к работе с шаблонами!

print(«%(lang)s is fun!» % {«lang»:»Python»}) # Python is fun!

print(«%(lang)s is fun!» % {«lang»:»Python»}) # Python is fun!

Должно быть это выглядит странно, но на самом деле мы сменили наши % на %(lang), с тем отличием, что данный объект идет в комплекте с переменной. Вторая часть пример вызывает словарь Python, который мы рассмотрим в следующей статье. В основном, это пара key:value, так что когда Python ищет ключ lang в строке и в указанном словаре ключей, он заменяет этот ключ его значением. Давайте взглянем на следующие примеры:

a = «%(value)s %(value)s %(value)s !» % {«value»:»SPAM»} print(a) # SPAM SPAM SPAM ! b = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2} print(b) Traceback (most recent call last): File «<string>», line 1, in <fragment> KeyError: ‘z’ c = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2, «z»:3} print(c) # 1 + 2 = 3

a = «%(value)s %(value)s %(value)s !» % {«value»:»SPAM»} print(a) # SPAM SPAM SPAM !   b = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2} print(b)   Traceback (most recent call last):    File «<string>», line 1, in <fragment> KeyError: ‘z’   c = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2, «z»:3} print(c) # 1 + 2 = 3

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

a = «Python is as simple as {0}, {1}, {2}».format(«a», «b», «c») print(a) # ‘Python is as simple as a, b, c’ b = «Python is as simple as {1}, {0}, {2}».format(«a», «b», «c») print(b) # ‘Python is as simple as b, a, c’ xy = {«x»:0, «y»:10} c = «Graph a point at where x={x} and y={y}».format(**xy) print(c) # Graph a point at where x=0 and y=10

a = «Python is as simple as {0}, {1}, {2}».format(«a», «b», «c») print(a) # ‘Python is as simple as a, b, c’   b = «Python is as simple as {1}, {0}, {2}».format(«a», «b», «c») print(b) # ‘Python is as simple as b, a, c’   xy = {«x»:0, «y»:10} c = «Graph a point at where x={x} and y={y}».format(**xy) print(c) # Graph a point at where x=0 and y=10

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

Подведем итоги

Мы проработали большой объем в данной статье. Давайте разберемся:
Сначала мы узнали, как создавать строки, после чего мы перешли к вопросу об их конкатенации. После этого, мы взглянули на несколько методов, которые предлагает нам объект string. Далее, мы рассмотрели нарезку строк и закончили замещением строк.

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

E-mail: [email protected]

Образование
Universitatea Tehnică a Moldovei (utm.md)

• 2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
• 2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»

Python: поиск подстроки, операции со строками. Как выполнять поиск в строке Python?

В этой статье поговорим про строки в Python, особенности поиска, а также о том, как искать подстроку или символ в строке. Но сначала давайте вспомним основные методы для обработки строк в Python: • isalpha(str): если строка в Python включает в себя лишь алфавитные символы, возвращается True; • islower(str): True возвращается, если строка включает лишь символы в нижнем регистре; • isupper(str): True, если символы строки в Python находятся в верхнем регистре; • startswith(str): True, когда строка начинается с подстроки str; • isdigit(str): True, когда каждый символ строки — цифра; • endswith(str): True, когда строка в Python заканчивается на подстроку str; • upper(): строка переводится в верхний регистр; • lower(): строка переводится в нижний регистр; • title(): для перевода начальных символов всех слов в строке в верхний регистр; • capitalize(): для перевода первой буквы самого первого слова строки в верхний регистр; • lstrip(): из строки в Python удаляются начальные пробелы; • rstrip(): из строки в Python удаляются конечные пробелы; • strip(): из строки в Python удаляются и начальные, и конечные пробелы; • rjust(width): когда длина строки меньше, чем параметр width, слева добавляются пробелы, строка выравнивается по правому краю; • ljust(width): когда длина строки в Python меньше, чем параметр width, справа от неё добавляются пробелы для дополнения значения width, при этом происходит выравнивание строки по левому краю; • find(str[, start [, end]): происходит возвращение индекса подстроки в строку в Python. В том случае, если подстрока не найдена, выполняется возвращение числа -1; • center(width): когда длина строки в Python меньше, чем параметр width, слева и справа добавляются пробелы (равномерно) для дополнения значения width, причём происходит выравнивание строки по центру; • split([delimeter[, num]]): строку в Python разбиваем на подстроки в зависимости от разделителя; • replace(old, new[, num]): в строке одна подстрока меняется на другую; • join(strs): строки объединяются в одну строку, между ними вставляется определённый разделитель.

Обрабатываем строку в Python

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

string = input("Введите какое-нибудь число: ")
if string.isnumeric():
    number = int(string)
    print(number)

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

string = "   привет мир!  "
string = string.strip()
print(string)           # привет мир!

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

print("iPhone 7:", "52000".rjust(10))
print("Huawei P10:", "36000".rjust(10))

В консоли Python будет выведено следующее:

iPhone 7:      52000
Huawei P10:      36000

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

Чтобы в Python выполнить поиск в строке, используют метод find(). Он имеет три формы и возвращает индекс 1-го вхождения подстроки в строку: • find(str): поиск подстроки str производится с начала строки и до её конца; • find(str, start): с помощью параметра start задаётся начальный индекс, и именно с него и выполняется поиск; • find(str, start, end): посредством параметра end задаётся конечный индекс, поиск выполняется до него.

Когда подстрока не найдена, метод возвращает -1:

    welcome = "Hello world! Goodbye world!"
index = welcome.find("wor")
print(index)       # 6

# ищем с десятого индекса
index = welcome.find("wor",10)
print(index)       # 21

# ищем с 10-го по 15-й индекс
index = welcome.find("wor",10,15)
print(index)       # -1

Замена в строке

Чтобы в Python заменить в строке одну подстроку на другую, применяют метод replace(): • replace(old, new): подстрока old заменяется на new; • replace(old, new, num): параметр num показывает, сколько вхождений подстроки old требуется заменить на new.

Пример замены в строке в Python:

    phone = "+1-234-567-89-10"

# дефисы меняются на пробелы
edited_phone = phone.replace("-", " ")
print(edited_phone)     # +1 234 567 89 10

# дефисы удаляются
edited_phone = phone.replace("-", "")
print(edited_phone)     # +12345678910

# меняется только первый дефис
edited_phone = phone.replace("-", "", 1)
print(edited_phone)     # +1234-567-89-10

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

Для разделения в Python используется метод split(). В зависимости от разделителя он разбивает строку на перечень подстрок. В роли разделителя в данном случае может быть любой символ либо последовательность символов. Этот метод имеет следующие формы: • split(): в роли разделителя применяется такой символ, как пробел; • split(delimeter): в роли разделителя применяется delimeter; • split(delimeter, num): параметром num указывается, какое количество вхождений delimeter применяется для разделения. При этом оставшаяся часть строки добавляется в перечень без разделения на подстроки.

Соединение строк в Python

Рассматривая простейшие операции со строками, мы увидели, как объединяются строки через операцию сложения. Однако есть и другая возможность для соединения строк — метод join():, объединяющий списки строк. В качестве разделителя используется текущая строка, у которой вызывается этот метод:

words = ["Let", "me", "speak", "from", "my", "heart", "in", "English"]

# символ разделителя - пробел
sentence = " ".join(words)
print(sentence)  # Let me speak from my heart in English

# символ разделителя - вертикальная черта
sentence = " | ".join(words)
print(sentence)  # Let | me | speak | from | my | heart | in | English

А если вместо списка в метод join передать простую строку, разделитель будет вставляться уже между символами:

word = "hello"
joined_word = "|".join(word)
print(joined_word)      # h|e|l|l|o

Python: работа со строками

Краткий обзор работы со строками:

# Объявить строку

Str = ‘text’

Str = «text «

Str = «»»многострочный текст»»»

# При использовании кириллицы(Юникода)

Str = u’текст’

# Преобразование кодов символов

ord(‘W’) # вернет 87 — код символа в ASCII

chr(87) # вернет W — символ для кода 87

# Оператор форматирования строк %, производит подстановку в строку значений из кортежа

‘моя строка %s с числом %d’ % (‘№1’, 1)

# оператор форматирования, словарь в виде аргумента

print «Hello %(name)s! How’s %(value)s?» % {‘name’: ‘Bill’, ‘value’: ‘life’} # Hello Bill! How’s life?

# Не форматированные строки или сырые строки(игнорируются знаки типа перевода строки и подобные)

Str = r’ ext’

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

Str = Str1 + Str2

# Повторение (повторить строку n-раз)

Str = ‘hello’ * 10

# Обратиться к символу по номеру

symbol = Str[i]

# Извлечение подстроки

Str = Str[i:j] # где i индекс начало среза, j — длина среза

Str = u’питону’ # строка юникод

print Str[:-1]+u’ы’ # вся строка без последнего символа + буква Ы

# Расширенная операция извлечения подстроки

Str[1:10:2] # каждый второй элемент в последовательности от 1 до 9, то есть Str[начальная позиция:конечная позиция:длина]

Str[::2] # каждый второй элемент от начала и до конца стоки, в данном случае начальная позиция принимается как начало строки, конечная — как конец строки

# Длина строки

len(Str)

# Количество вхождений подстроки в строку, если нет совпадений — 0

Str.count(‘то что ищем’)

# Поиск подстроки, возвращает позицию первого совпадения, иначе -1

Str.find(‘то что ищем’)

# Поиск и замена, если строка не найдена — возвращает исходную строку

Str.replace(‘то что ищем’, ‘то на что заменяем’)

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

Str.split(‘символ или строка’)

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

‘разделитель’.join(Str)

# Регистр

Str.upper() # к верхнему

Str.lower() # к нижнему

Str.title() # первый символ каждого слова к верхнему

Str.capitalize() # первый символ строки к верхнему

Str.isupper() # проверить находиться ли строка в верхнем регистре

Str.islower() # проверить находиться ли строка в нижнем регистре

Str.startswith(‘строка’) # определяет начинается ли строка с указанной подстроки

Str.endswith(‘строка’) # определяет заканчивается ли строка с указанной подстрокой

# Удаляет пробельные символы

Str.strip() # в начале и конце

Str.lstrip() # в начале

Str.rstrip() # в конце

используемые методы, функции и операторы, примеры кода

От автора: в Python все является объектом, и строка тоже. Строка Python может быть создана просто с помощью заключения символов в двойные кавычки.

Например:

В этом руководстве мы узнаем:

Бесплатный курс «Python. Быстрый старт»

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

Получить курс

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

О различных строковых операторах

Еще несколько примеров

О методе Python String replace()

Как приводить строки к верхнему и нижнему регистру

Об использование для строки функцию «join»

О реверсе строк

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

Доступ к значениям в строках

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

var1 = «Guru99!» var2 = «Software Testing» print («var1[0]:»,var1[0]) print («var2[1:5]:»,var2[1:5])

var1 = «Guru99!» var2 = «Software Testing» print («var1[0]:»,var1[0]) print («var2[1:5]:»,var2[1:5])

Различные строковые операторы

Существуют различные строковые операторы, которые можно использовать по-разному, например, объединять строки. Предположим, что если a=guru, а b=99, то a+b= «guru99″. Точно так же, если вы используете *2, это будет «GuruGuru». Также вы можете использовать другие операторы.

Оператор []. Описание: Фрагмент — дает символ с данным индексом. Пример: a[1] дает «u» из слова Guru, так как (0=G, 1=u, 2=r и 3=u).

Оператор [:]. Описание: Диапазон фрагментов — дает символы из заданного диапазона. Пример: x[1:3] даем «ur» из слова гуру Guru. Помните, что это не учитывать 0, который является G, это будет учитывать буквы после него.

Оператор in. Описание: Содержит — возвращает true, если в заданной строке есть буква. Пример: u присутствует в слове Guru и, следовательно, это даст 1 (true).

Оператор not in. Описание: Не содержит -возвращает true, если буква не существует в данной строке. Пример: l не присутствует в слове Guru и, следовательно, это даст 1.

x=»Guru» print «l» not in x

x=»Guru» print «l» not in x

Оператор r/R. Описание: Необработанная строка подавляет фактическое значение escape-символов. Пример: Напечатайте r’\n’ печатает \n и напечатайте R’\n’ печатает \n.

Оператор % — используется для формата строк. Описание: %r — вставляет каноническое строковое представление объекта (т. е. repr(o)), %s — вставляет строковое представление объекта (т. е. str(o)), %d — форматирует число для отображения. Пример: Вывод этого кода будет «guru 99″.

name = ‘guru’ number = 99 print’%s %d’ % (name,number)

name = ‘guru’ number = 99 print’%s %d’ % (name,number)

Оператор +. Описание: Объединение 2 строк. Пример: Объединяет строки и дает результат.

x=»Guru» y=»99″ print x+y

x=»Guru» y=»99″ print x+y

Оператор *. Описание: Повторение. Пример: Выводит символ дважды.

x=»Guru» y=»99″ print x*2

x=»Guru» y=»99″ print x*2

Еще несколько примеров

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

x = «Hello World!» print(x[:6]) print(x[0:6] + «Guru99»)

x = «Hello World!» print(x[:6]) print(x[0:6] + «Guru99»)

Примечание: — Slice:6 или 0:6 дает тот же результат.

Метод строк Python replace()

Метод replace() возвращает копию строки, в которой значения старой строки были заменены новым значением.

oldstring = ‘I like Guru99’ newstring = oldstring.replace(‘like’, ‘love’) print(newstring)

oldstring = ‘I like Guru99’ newstring = oldstring.replace(‘like’, ‘love’) print(newstring)

Бесплатный курс «Python. Быстрый старт»

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

Получить курс

Изменение верхнего и нижнего регистра строк

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

string=»python at guru99″ print(string.upper())

string=»python at guru99″ print(string.upper())

Кроме того, вы также можете использовать другую функцию, такую как capitalize:

string=»python at guru99″ print(string.capitalize())

string=»python at guru99″ print(string.capitalize())

Вы также можете преобразовать строку в нижний регистр:

string=»PYTHON AT GURU99″ print(string.lower())

string=»PYTHON AT GURU99″ print(string.lower())

Использование для строки функции «join»

Функция join является более гибким способом объединения строк. С помощью функции join вы можете добавить в строку любой символ.

Например, если вы хотите добавить двоеточие (:) после каждого символа в строке «Python», вы можете использовать следующий код.

print(«:».join(«Python»))

print(«:».join(«Python»))

Реверс строк

Используя функцию реверса, вы можете перевернуть строку. Например, если у нас есть строка «12345», а затем, если вы применяете код для обратной функции, как показано ниже.

string=»12345″ print(».join(reversed(string)))

string=»12345″ print(».join(reversed(string)))

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

Разделение строк — это еще одна функция, которая может применяться в Python, давайте посмотрим на строку «guru99 career guru99″. Сначала мы разделим строку с помощью команды word.split и получим результат.

word=»guru99 career guru99″ print(word.split(‘ ‘))

word=»guru99 career guru99″ print(word.split(‘ ‘))

Чтобы лучше это понять, мы рассмотрим еще один пример разделения, вместо пробела (») мы используем (‘r’), и это будет разбивать строку везде, где в строке встречается ‘r’:

word=»guru99 career guru99″ print(word.split(‘r’))

word=»guru99 career guru99″ print(word.split(‘r’))

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

x = «Guru99″ x.replace(«Guru99″,»Python») print(x)

x = «Guru99» x.replace(«Guru99″,»Python») print(x)

все равно возвращает Guru99. Это связано с тем, что x.replace («Guru99″, «Python») возвращает копию X с выполненными заменами. Вам нужно будет использовать следующий код, чтобы увидеть изменения:

x = «Guru99″ x = x.replace(«Guru99″,»Python») print(x)

x = «Guru99» x = x.replace(«Guru99″,»Python») print(x)

Приведенные выше коды являются примерами Python 3. Если вы хотите запустить Python 2, рассмотрите следующий код.

#Accessing Values in Strings var1 = «Guru99!» var2 = «Software Testing» print «var1[0]:»,var1[0] print «var2[1:5]:»,var2[1:5] #Some more examples x = «Hello World!» print x[:6] print x[0:6] + «Guru99″ #Python String replace() Method oldstring = ‘I like Guru99’ newstring = oldstring.replace(‘like’, ‘love’) print newstring #Changing upper and lower case strings string=»python at guru99″ print string.upper() string=»python at guru99″ print string.capitalize() string=»PYTHON AT GURU99″ print string.lower() #Using «join» function for the string print»:».join(«Python») #Reversing String string=»12345″ print».join(reversed(string)) #Split Strings word=»guru99 career guru99″ print word.split(‘ ‘) word=»guru99 career guru99″ print word.split(‘r’) x = «Guru99″ x.replace(«Guru99″,»Python») print x x = «Guru99″ x = x.replace(«Guru99″,»Python») print x

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

#Accessing Values in Strings var1 = «Guru99!» var2 = «Software Testing» print «var1[0]:»,var1[0] print «var2[1:5]:»,var2[1:5] #Some more examples x = «Hello World!» print x[:6] print x[0:6] + «Guru99» #Python String replace() Method oldstring = ‘I like Guru99’ newstring = oldstring.replace(‘like’, ‘love’) print newstring #Changing upper and lower case strings string=»python at guru99″ print string.upper() string=»python at guru99″ print string.capitalize() string=»PYTHON AT GURU99″ print string.lower() #Using «join» function for the string print»:».join(«Python») #Reversing String string=»12345″ print».join(reversed(string)) #Split Strings word=»guru99 career guru99″ print word.split(‘ ‘) word=»guru99 career guru99″ print word.split(‘r’) x = «Guru99» x.replace(«Guru99″,»Python») print x x = «Guru99» x = x.replace(«Guru99″,»Python») print x

В Python появилась функция .format, которая позволяет использовать %d и т. д. для форматирования строк.

Заключение

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

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

В нарезке, если диапазон объявлен [1: 5], он может фактически извлечь значение из диапазона [1: 4]

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

Метод replace() возвращает копию строки, в которой вхождение старых символов заменяется новыми.

Синтаксис для метода replace: oldstring.replace(«значение, на которое заменяем», «значение, которое заменяем»)

Строковые операторы, такие как [], [:], in, Not in и т. д., могут применяться для конкатенации строки, извлечения или вставки определенных символов в строку или для проверки того, существует ли определенный символ в строке

Другие строковые операции включают:

Изменение верхнего и нижнего регистра

Функция Join, чтобы добавить любой символ в строку

Реверс строк

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

Источник: //www.guru99.com

Редакция: Команда webformyself.

Бесплатный курс «Python. Быстрый старт»

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

Получить курс

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

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

Метод	Описание
capitalize ()	Преобразует первый символ в верхний регистр
casefold ()	Преобразует строку в нижний регистр
по центру ()	Возвращает по центру строка
count ()	Возвращает количество раз указанное значение встречается в строке
encode ()	Возвращает закодированный версия строки
endwith ()	Возвращает true, если строка заканчивается указанным значением
expandtabs ()	Устанавливает размер табуляции строки
find ()	Ищет строку для указанное значение и возвращает позицию, где оно было найдено
формат ()	Указанные форматы значения в строке
format_map ()	Указанные форматы значения в строке
index ()	Ищет строку для указанного значения и возвращает позицию, где оно было найдено
isalnum ()	Возвращает True, если все символы в строке буквенно-цифровые
isalpha ()	Возвращает True, если все символы в строке находятся в алфавите
isascii ()	Возвращает True, если все символы в строке — это символы ascii
isdecimal ()	Возвращает True, если все символы в строке десятичные
isdigit ()	Возвращает True, если все символы в строке — это цифры
isidentifier ()	Возвращает True, если строка является идентификатором
islower ()	Возвращает True, если все символы в строке строчные
isnumeric ()	Возвращает True, если все символы в строке числовые
isprintable ()	Возвращает True, если все символы в строке печатаются
isspace ()	Возвращает True, если все символы в строке — это пробелы
название ()	Возвращает True, если строка соответствует правилам название
isupper ()	Возвращает True, если все символы в строке в верхнем регистре
join ()	Присоединяет элементы итерация до конца строки
ljust ()	Возвращает выровненный по левому краю версия строки
lower ()	Преобразует строку в нижний регистр
lstrip ()	Возвращает левую обрезку версия строки
maketrans ()	Возвращает таблица переводов для использования в переводах
partition ()	Возвращает кортеж где струна разделена на три части
replace ()	Возвращает строку где указанное значение заменяется указанным значением
rfind ()	Ищет строку для указанное значение и возвращает последнюю позицию, где оно было найдено
rindex ()	Ищет строку для указанное значение и возвращает последнюю позицию, где оно было найдено
rjust ()	Возвращает выровненный по правому краю версия строки
rpartition ()	Возвращает кортеж где струна разделена на три части
rsplit ()	Разбивает строку на указанный разделитель и возвращает список
rstrip ()	Возвращает правую обшивку версия строки
split ()	Разбивает строку на указанный разделитель и возвращает список
splitlines ()	Разделяет строку при переносе строки и возвращает список
начинается с ()	Возвращает истину, если строка начинается с указанного значения
strip ()	Возвращает обрезанную версию строки
Своп-кейс ()	Своп-кейс, нижний регистр становится прописным и наоборот
название ()	Преобразует первое символ каждого слова в верхнем регистре
translate ()	Возвращает переведенная строка
верхний ()	Преобразует строку в верхний регистр
zfill ()	Заполняет строку указанное количество значений 0 в начале

строка — Стандартные строковые операции — Python 3.9.7 документация

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

В этом модуле определены следующие константы:

строка. ascii_letters

Объединение ascii_lowercase и ascii_uppercase константы, описанные ниже. Это значение не зависит от языкового стандарта.

строка. ascii_lowercase

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

строка. ascii_uppercase

Заглавные буквы 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' . Это значение не зависит от локали и не изменится.

строка. цифр

Строка '0123456789' .

строка. шестнадцатеричные цифры

Строка '0123456789abcdefABCDEF' ._` {|} ~ .

строка. для печати

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

строка. пробел

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

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

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

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

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

формат ( формат_строка , /, * аргументы , ** kwargs )

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

vformat ( format_string , args , kwargs )

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

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

синтаксический анализ ( format_string )

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

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

get_field ( имя_поля , args , kwargs )

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

get_value ( ключ , args , kwargs )

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

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

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

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

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

check_unused_args ( used_args , args , kwargs )

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

format_field ( значение , format_spec )

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

convert_field ( значение , преобразование )

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

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

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

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

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

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

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

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

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

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

Некоторые примеры простых форматных строк:

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

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

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

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

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

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

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

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

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

Спецификация формата Мини-язык

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

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

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

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

  format_spec  :: = [[ fill ]  align ] [ sign ] [#] [0] [ width ] [ grouping_option ] [."
  знак  :: = "+" | "-" | ""
  ширина  :: =  цифр  +
  опция_группировки  :: = "_" | ","
  точность  :: =  цифр  +
  тип  :: = "b" | "с" | "д" | "е" | "E" | "е" | "F" | "г" | "G" | "п" | "о" | "s" | «х» | «Х» | "%"
 

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

Значение различных вариантов выравнивания таково:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Тип	Значение
b	Двоичный формат. Выводит число по основанию 2.
'c'	Персонаж. Преобразует целое число в соответствующее символ юникода перед печатью.
'd'	Целое десятичное число. Выводит число по основанию 10.
'o'	Восьмеричный формат. Выводит число по основанию 8.
'x'	Шестнадцатеричный формат.Выводит число по основанию 16, используя строчные буквы для цифр выше 9.
'X'	Шестнадцатеричный формат. Выводит число по основанию 16, используя заглавные буквы для цифр выше 9. Если указан '# , префикс ' 0x ' будет также быть в верхнем регистре на '0X' .
'n'	Номер. Это то же самое, что 'd' , за исключением того, что в нем используется текущий параметр локали, чтобы вставить соответствующий числовые разделители символов.
Нет	То же, что d .

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

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

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

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

В этом разделе собраны примеры ул.format () синтаксис и сравнение со старым % -форматирование.

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

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

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

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

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

 >>> 'Координаты: {широта}, {долгота}'. Формат (широта = '37 .24N ', долгота =' - 115.81 Вт ')
'Координаты: 37.24N, -115.81W'.
>>> Coord = {'latitude': '37 .24N ',' longitude ':' -115.81W '}
>>> 'Координаты: {широта}, {долгота}'. Формат (** координаты)
'Координаты: 37.24N, -115.81W'.
 

Атрибуты аргументов доступа:

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

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

 >>> координата = (3, 5)
>>> 'X: {0 [0]}; Y: {0 [1]} '. Формат (координаты)
'X: 3; Y: 5 '
 

Замена % s и % r :

 >>> "repr () показывает кавычки: {! R}; str () не показывает: {! S}".30} '. Format (' center ') # используйте' * 'в качестве символа заполнения
'*********** по центру ***********'
 

Замена % + f , % -f и % f и указание знака:

 >>> '{: + f}; {: + f} '. format (3.14, -3.14) # показывать всегда
'+3.140000; -3,140000 '
>>> '{: f}; {: f} '. format (3.14, -3.14) # показать пробел для положительных чисел
'3.140000; -3,140000 '
>>> '{: -f}; {: -f} '. format (3.14, -3.14) # показывать только минус - то же, что и' {: f}; {: f} '
'3.140000; -3,140000 '
 

Замена % x и % на и преобразование значения в другое основание:

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

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

 >>> '{:,}'.>', ['left', 'center', 'right']):
.'
'>>>>>>>>>>> правильно'
>>>
>>> октеты = [192, 168, 0, 1]
>>> '{: 02X} {: 02X} {: 02X} {: 02X}'. Формат (* октеты)
'C0A80001'
>>> интервал (_, 16)
3232235521
>>>
>>> ширина = 5
>>> для числа в диапазоне (5,12):
... для базы в 'dXob':
... print ('{0: {width} {base}}'. format (num, base = base, width = width), end = '')
...     Распечатать()
...
    5 5 5 101
    6 6 6 110
    7 7 7 111
    8 8 10 1000
    9 9 11 1001
   10 А 12 1010
   11 В 13 1011
 

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

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

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

• $$ - побег; он заменен на одинарный $.

• $ идентификатор именует заполнитель подстановки, соответствующий ключу сопоставления «идентификатор» . По умолчанию "идентификатор" ограничен любым буквенно-цифровая строка ASCII без учета регистра (включая символы подчеркивания), начинается с символа подчеркивания или буквы ASCII. Первый неидентификатор символ после символа $ завершает этот заполнитель Технические характеристики.

• $ {идентификатор} эквивалентен $ идентификатору .Требуется, когда допустимые символы идентификатора следуют за заполнителем, но не являются частью заполнитель, например "$ {существительное} ification" .

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

Модуль string предоставляет класс Template , который реализует эти правила. Методы шаблона :

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

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

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

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

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

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

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

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

шаблон

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

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

 >>> из шаблона импорта строк
>>> s = Template ('$ кому нравится $ what')
>>> с.заменить (who = 'tim', what = 'kung pao')
'Тим любит кунг пао'
>>> d = dict (кто = 'tim')
>>> Шаблон ('Дайте кому $ 100'). Replace (d)
Отслеживание (последний вызов последний):
...
ValueError: недопустимый заполнитель в строке: строка 1, столбец 11
>>> Шаблон ('$ кому нравится $ what'). Replace (d)
Отслеживание (последний вызов последний):
...
KeyError: 'что'
>>> Шаблон ('$ кому нравится $ what'). Safe_substitute (d)
"Тим любит $ что"
 

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

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

• idpattern - это регулярное выражение, описывающее шаблон для заполнители без скобок. Значение по умолчанию - регулярное выражение. (? A: [_ a-z] [_ a-z0-9] *) . Если это дано и braceidpattern is Нет этот шаблон также будет применяться к заполнителям в фигурных скобках.

  Примечание

  Поскольку по умолчанию flags равен re.IGNORECASE , шаблон [a-z] может соответствовать с некоторыми символами, отличными от ASCII.Вот почему мы используем локальный флаг a . здесь.

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

• braceidpattern - это похоже на idpattern , но описывает шаблон для заполнители в скобках. По умолчанию Нет , что означает возврат к idpattern (т.е. один и тот же узор используется как внутри, так и снаружи фигурных скобок). Если задано, это позволяет вам определять разные шаблоны для фигурных скобок и свободные заполнители.

• flags - флаги регулярного выражения, которые будут применяться при компиляции регулярное выражение, используемое для распознавания замен. Значение по умолчанию это re.IGNORECASE . Обратите внимание, что re.VERBOSE всегда будет добавляться к flags, поэтому пользовательские idpattern s должны следовать соглашениям для подробных регулярных выражения.

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

• экранированный - Эта группа соответствует escape-последовательности, например $$ , в шаблон по умолчанию.

• с именем - эта группа соответствует имени заполнителя без скобок; это не должно включить разделитель в группу захвата.

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

• недопустимый - Эта группа соответствует любому другому шаблону разделителя (обычно один разделитель), и он должен быть последним в регулярном выражении.

Строки Python (с примерами)

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

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

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

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

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

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

---

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

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

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

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

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

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

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

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

---

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

---

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

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

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

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

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

---

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

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

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

Объединение двух или более строк

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

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

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

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

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

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

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

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

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

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

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

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

---

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

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

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

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

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

---

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

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

  >>> 'а' в 'программу'
Правда
>>> 'в' не в 'битве'
Ложь  

---

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

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

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

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

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

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

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

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

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

---

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

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

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

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

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

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

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

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

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

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

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

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

Колокол

Escape Sequence	Описание
\ новая строка	Обратная косая черта и новая строка игнорируются
\	Обратная косая черта
\ '	Одиночная кавычка
\ "	Двойная цитата
\ а	ASCII
\ б	ASCII Backspace
\ f	ASCII Formfeed
\ п	ASCII перевод строки
\ r	ASCII возврат каретки
\ т	ASCII горизонтальная вкладка
\ v	ASCII вертикальная вкладка
\ ooo	Знак с восьмеричным числом ооо
\ xHH	Символ с шестнадцатеричным значением HH

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

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

>>> print ("Это напечатано \ n двумя строками")
Это напечатано
в две строки

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

---

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

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

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

---

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

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

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

  # Метод Python string format ()

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

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


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

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

>>> # форматирование поплавков
>>> "Экспонентное представление: {0: e}".10} | {:> 10} | ".format ('масло', 'хлеб', 'ветчина')
'| масло | хлеб | ветчина | '  
 Форматирование в старом стиле 
 Мы можем даже форматировать строки, как в старом стиле  sprintf () , используемом в языке программирования C. Для этого мы используем оператор % .
  >>> х = 12,3456789
>>> print ('Значение x равно% 3.2f'% x)
Значение x равно 12,35.
>>> print ('Значение x равно% 3.4f'% x)
Значение x равно 12.3457  
 Общие строковые методы Python 
 Для строкового объекта доступно множество методов. Упомянутый выше метод  format ()  является одним из них. Некоторые из часто используемых методов:  lower () ,  upper () ,  join () ,  split () ,  find () ,  replace ()  и т. Д. Вот полный список все встроенные методы для работы со строками в Python.
  >>> "ПрОгРаМиЗ".ниже()
'programiz'
>>> "PrOgRaMiZ" .upper ()
'ПРОГРАММИРОВАТЬ'
>>> «Это разделит все слова на список» .split ()
['This', 'will', 'split', 'all', 'words', 'into', 'a', 'list']
>>> '' .join (['This', 'will', 'join', 'all', 'words', 'into', 'a', 'string'])
'Это объединит все слова в строку'
>>> 'С Новым годом'. Найти ('фу')
7
>>> 'С Новым годом'. Заменить ('Happy', 'Brilliant')
'Блестящий Новый год'  
 Python 3 Строковые операторы 
 Список строковых операторов, доступных в Python 3.
 Оператор
 Описание
 Эксплуатация
 Пример
  + 
 Объединяет (объединяет)  строка1  и  строка2 
  строка1 + строка2 
 a = «Чай» + «Лист»
print (a)
 Результат
  Чайный лист  
  * 
 Повторяет строку столько раз, сколько указано в  x 
  строка * x 
 a = "Пчела" * 3
print (a)
 Результат
  Пчела Пчела Пчела  
  [] 
 Slice - возвращает символ из индекса  x .
  строка [x] 
 a = "Море"
print (a [1])
 Результат
  e  
  [:] 
 Range Slice - возвращает символы из диапазона  x: y .
  строка [x: y] 
 a = "Гриб"
print (a [4: 8])
 Результат
  к.  
  дюйм 
 Membership - возвращает  True , если в строке существует  x .Может быть несколько символов.
  х в строке 
 a = "Гриб"
print ("m" в a)
print ("b" в a)
print ("shroo" in a)
 Результат
  Верно
Ложь
Правда  
  не в 
 Membership - возвращает  True , если  x  не  не существует в строке. Может быть несколько символов.
  x не в строке 
 a = "Гриб"
print ("m" не в a)
print ("b" не в a)
print ("shroo" не в а)
 Результат
  Ложь
Правда
Ложь  
  r 
 Подавляет escape-последовательность ( \  x  ), так что она фактически отображается. Другими словами, это предотвращает превращение escape-символа в escape-символ.
  r "\ x" 
 a = "1" + "\ t" + "Пчела"
b = "2" + r "\ t" + "Чай"
печать (а)
print (b)
 Результат
  1 пчела
2 \ t Чай  
 % 
 Выполняет форматирование строк. Его можно использовать в качестве заполнителя для другого значения, вставляемого в строку.Символ %  является префиксом к другому символу (  x  ), который определяет тип значения, которое будет вставлено. Вставляемое значение указывается в конце строки после другого символа % .
 Знак
 Описание
 % c 
 Персонаж.
 % s 
 Преобразование строки через  str ()  перед форматированием.
 % i 
 Десятичное целое число со знаком.
 % d 
 Десятичное целое число со знаком.
 % и 
 Десятичное целое без знака.
 % или 
 Восьмеричное целое число.
 % x 
 Шестнадцатеричное целое число с использованием строчных букв.
 % X 
 Шестнадцатеричное целое число с прописными буквами.
 % e 
 Экспоненциальная запись со строчными буквами  e .
 % E 
 Экспоненциальная запись с прописными буквами  e .
 % f 
 Действительное число с плавающей запятой.
 % г 
 Более короткий из % f  и % e .
 % G 
 Короче из % f  и % E .
 %  x  
 a = "Привет,% s"% ("Гомер")
print (a)
 Результат
  Привет, Гомер  
 Основные строковые операции в Python 
 Строки - это последовательности символов.Существует множество  алгоритмов  обработки строк, в том числе для поиска, сортировки, сравнения и преобразования.  Строки Python  «неизменяемы», что означает, что они не могут быть изменены после создания. Чтобы создать строку, поместите последовательность символов в одинарные, двойные или тройные кавычки, а затем назначьте ее переменной.
 str = 'Здравствуй, мир!'
str = "Здравствуй, мир!"
str = "" "воскресенье
 понедельник
 Вторник"""  Доступ к символам в строке 
 Чтобы получить доступ к символам из String, используйте квадратные скобки [] для нарезки вместе с индексом или индексами для получения ваших символов.Индекс Python String начинается с 0.
 str = 'Здравствуй, мир!'
print (str [0]) # вывод - "H"
print (str [7]) # вывод - "W"
print (str [0: 6]) #output is Hellow
print (str [7:12]) #output is World
 Python допускает отрицательную индексацию своих последовательностей.
 Индекс -1 относится к последнему элементу, -2 - ко второму последнему элементу и так далее.
 print (str [0: -6]) # вывод - Hellow
print (str [7: -1]) # вывод - World  Конкатенация строк 
 Объединение двух или более строк в одну называется конкатенацией.Python использует оператор «+» для соединения одной или нескольких строк
 str1 = 'Привет'
str2 = 'Мир!'
печать (str1 + str2)
 выход 
 Привет, мир!  Переверните струну 
 В Python строки можно нарезать. Нарезка строки дает вам новую строку от одной точки в строке, назад или вперед, до другой точки, с заданными приращениями. Они принимают обозначение среза или объект среза в нижнем индексе:
 строка [нижний индекс]
 Нижний индекс создает срез, включая двоеточие в фигурные скобки:
 строка [начало: конец: шаг]
 Он работает, выполняя [begin: end: step] - оставляя begin и end off и задавая шаг -1, он меняет строку.
 str = 'Строка Python'
print (str [:: - 1])
 выход 
 gnirtS nohtyP  Строковые методы 
 Python имеет несколько встроенных методов, связанных с строковым типом данных. Эти методы позволяют нам легко изменять строки и манипулировать ими. Встроенные методы - это те, которые определены на языке программирования Python и легко доступны для использования. Вот некоторые из наиболее распространенных строковых методов.
  Python String метод len () 
 String Метод len () возвращает длину строки.
 str = "Здравствуй, мир!"
печать (len (str))
 выход 
 13  Python String count () метод  Метод
 String count () возвращает количество вхождений подстроки в заданной строке.
 str = "Python объектно-ориентированный"
substr = "Объект"
print (str.count (substr)) # return 1, потому что слово Object существует 1 раз в str
 выход 
 1  Python String index () метод 
 Метод String index () возвращает индекс подстроки внутри заданной строки.
 индекс (подстановка, начало, конец)
 end (необязательно) по умолчанию равно длине строки.
 str = "Python объектно-ориентированный"
 substr = "есть"
 печать (str.index (substr))
 выход 
 7  Python String upper () метод 
 String upper () преобразует данную строку в прописные буквы и возвращает новую строку.
 str = "Python объектно-ориентированный"
печать (str.upper ())
 выход 
 PYTHON ОБЪЕКТИВНО ОРИЕНТИРУЕТСЯ  Python String lower () метод 
 String lower () преобразует данную строку в строчные буквы и возвращает новую строку.
 str = "Python объектно-ориентированный"
печать (str.lower ())
 выход 
 Python является объектно-ориентированным  Python String начинается с метода () 
 Метод startwith () возвращает логическое значение ИСТИНА, если строка начинается с указанной подстроки, в противном случае возвращается значение Ложь.
 str = "Python объектно-ориентированный"
print (str.startswith ("Python"))
print (str.startswith ("Объект"))
 выход 
 Правда
Ложь  Python String заканчивается методом () 
 Метод Endwith () возвращает логическое значение ИСТИНА, если строка заканчивается указанной подстрокой, в противном случае возвращается значение Ложь.
 str = "Python объектно-ориентированный"
print (str.endswith ("Ориентировано"))
print (str.endswith ("Объект"))
 выход 
 Правда
Ложь  Python String split () метод 
 String Метод split () разбивает строку на более мелкие строки на основе разделителя или символа.
 str = 'Python объектно-ориентированный'
печать (str.split ())
 выход 
 ['Python', 'is', 'Object', 'Oriented']
 пример 
 str = 'Python, объектно-ориентированный'
печать (ул.расколоть(','))
 выход 
 ['Python', 'is', 'Object', 'Oriented']
 пример 
 str = 'Python, объектно-ориентированный'
печать (str.split (',', 2))
 выход 
 ['Python', 'is', 'Object, Oriented']
 Python вернул разделенную строку в виде списка
 str = 'Python, объектно-ориентированный'
sList = str.split (',')
для температуры в sList:
 печать (темп)
 выход 
 Python
является
Объект
Ориентированный  Python String метод join () 
 String join () - это строковый метод, который возвращает строку, объединенную с элементами итерируемого объекта.
 str = "Python объектно-ориентированный"
tmp = "-"
печать (tmp.join (str))
 выход 
 П-у-т-ч-о-н-и-с-о-б-дже-с-т-о-р-и-е-н-т-е-д  Python String метод find () 
 String find () возвращает позицию индекса первого вхождения указанной строки. Он вернет -1, если указанная строка не найдена.
 str = "Python объектно-ориентированный"
st = "Объект"
печать (str.find (st))
print (str.find (st, 20)) # поиск с 20 позиции
 выход 
 10
-1  Python String strip () метод 
 String strip () удаляет указанные символы как с правой, так и с левой стороны строки (по умолчанию, пробелы) и возвращает новую строку.
 str = "Python объектно-ориентированный"
печать (str.strip ())
 выход 
 Python объектно-ориентированный  Python String метод rstrip () 
 String rstrip () возвращает копию строки с удаленными завершающими символами.
 str = "Python объектно-ориентированный"
печать (str.rstrip ())
 выход 
 Python объектно-ориентированный  Python String lstrip () метод 
 String lstrip () возвращает копию строки с удаленными начальными символами.
 str = "Python объектно-ориентированный"
печать (str.lstrip ())
 выход 
 Python объектно-ориентированный 
 
 
 
 
 Строковые операции Python - примеры Python 
 Строковые операции Python 
 Эти серии операций со строками Python включают примеры того, как работать со строками в программировании на Python.
 Здесь вы можете узнать, как инициализировать строку, получить длину строки, найти ее подстроку, обрезать пробелы в строке, преобразовать символы в строке в верхний и нижний регистры, заменить подстроку в строке и т. Д.
 В большинстве приложений данные хранятся в виде строк, и разработчикам часто приходится преобразовывать строковые значения с помощью строковых операций, регулярных выражений и т. Д.
 Список строковых операций Python 
 Ниже приводится список тем, охватывающих основные Строковые операции на языке Python.
 Содержит 
 В этих руководствах будут рассмотрены такие сценарии, как строка содержит подстроку или строка содержит любую строку в качестве подстроки из списка, строка содержит только алфавиты и т. Д.
 Замена 
 Замена - это строковая операция, в которой мы заменяем некоторые символы или подстроки другой строкой. Следующие руководства помогут вам начать работу с некоторыми сценариями операции замены в Python.
 Разделение 
 Разделение - это строковая операция, в которой ввод представляет собой строку, содержащую фрагменты, разделенные разделителем. Мы должны извлечь фрагменты из строки в виде списка.
 Python - Разделение строк - В этом руководстве содержится простое введение в разделение строк.
 Следующий набор руководств поможет вам с различными сценариями разделения строки.
 Сортировка 
 Сортировка - это расположение строк в порядке возрастания или убывания. В следующих руководствах рассматриваются концепции сортировки со строками.
 Сравнение 
 Сравнение - это действие для проверки того, равны ли две строки, одна строка больше другой или одна строка меньше другой.
 Форматирование 
 Резюме 
 В этом руководстве примеров Python мы узнали о строках и различных операциях, которые могут выполняться со строками, с помощью хорошо подробных примеров.
 Строки Python - Обзор основных операций со строками 
 Строки - это один из основных типов данных в Python. Строки Python представляют собой комбинацию любого количества символов, состоящих из букв, цифр и других специальных символов. В этом руководстве вы узнаете, как создавать, изменять и форматировать их для использования в различных сценариях.
 Создание новых строк в Python 
 Чтобы создать новую строку Python, вам просто нужно объявить последовательность символов, заключенную в одинарные или двойные кавычки.Тройные кавычки также используются для строк, состоящих из нескольких строк.
  double_quotes = "Меня зовут Джон!"

single_quotes = 'Меня зовут Джон!'

multi_line_string = '' '1. Меня зовут Джон!
                       2. Я программист »»
  
 Индексирование строк 
 Каждый символ в строке Python имеет целочисленный индекс. Индексирование начинается с 0 первого символа и увеличивается по строке. Вы можете использовать индекс отдельного символа для извлечения этого символа из строки, как показано в следующем примере.
  myPet = "Собака, а не кошка"

myPet [0] # 'D'
myPet [5] # 'о'
myPet [7] # ''
myPet [12] # 'т'
# myPet [15] # IndexError
  
 Попытка получить доступ к символу за пределами индекса последнего символа приводит к ошибке  IndexError .
 Вы можете получить доступ к символу в строке, используя отрицательный индекс. В этом случае индексация начинается с -1 в последнем символе строки и отрицательно увеличивается при движении назад.
  myPet = "Собака, а не кошка"

myPet [-1] # 'т'
myPet [-6] # ''
myPet [-8] # 'о'
myPet [-13] # 'D'
  
 Нарезка струн 
 Нарезка - это метод извлечения подстроки (части строки) из строки.Эта задача достигается с помощью индексации строк.
  myPet = "Собака, а не кошка"

myPet [5: 7] # 'не'
myPet [1:12] # 'og not a ca'
  
 Здесь представлены два индекса, разделенных двоеточием, первый индекс указывает, где начать разрезание, а второй индекс указывает, где остановиться. Результирующая подстрока включает символы от начального индекса до символа перед конечным индексом, символ в конечном индексе не включается в подстроку.
 Если вы не укажете начальный индекс, нарезка начнется с первого символа строки.Если вы не укажете конечный индекс, нарезка заканчивается на последнем символе, включая его в результирующую подстроку.
  myPet = "Собака, а не кошка"

myPet [: 7] # 'Собака не'
myPet [10:] # 'кошка'
myPet [:] # 'Собака, а не кошка'
  
 Вы также можете предоставить отрицательные индексы в качестве индексов среза.
  myPet = "Собака, а не кошка"

myPet [10: -1] # 'ca'
  
 Длина строки 
 Встроенный метод Python  len ()  выводит длину строки.
  myPet = "Собака, а не кошка"
len (myPet) # 13
  
 Итерация по строке 
 Вы можете перебирать каждый символ в строке, используя цикл  для .
 Пример:
  name = "John"
для символа в имени:
    печать (символ)
# 'Джон'
  
 Конкатенация строк 
 Конкатенация строк - это объединение двух или более строк для создания одной строки. В Python есть несколько методов объединения строк.
 Один использует оператора  + .
  str1 = 'Привет'
str2 = 'Мир'
concat_str = str1 + str2 # 'HelloWorld'
concat_str = str1 + '' + str2 # 'Привет, мир'
  
 Оператор  *  можно использовать для объединения строки с самой собой любое количество раз.
  concat_str = str1 * 3 # 'HelloHelloHello'
  
 Другой способ объединения строк - использование метода  join () .
 Встроенный метод  join ()  используется для объединения массива строк с использованием общего разделителя.
  arr = [str1, str2]
concat_str = ('') .join (arr) # 'Привет, мир'
concat_str = (','). join (arr) # 'Привет, мир'
  
 В приведенном выше коде первый метод  join ()  добавляет пробел между каждым словом в массиве.
 Второй метод  join ()  вставляет запятую между каждым словом в массиве.
 Конкатенация строк и целых значений 
 В Python мы также можем объединить строку с целым числом, но не с помощью оператора  + .Если мы попытаемся использовать следующий код:
  name = "John"
возраст = 35

печать (a + b)
  
 Мы получим:
  Traceback (последний вызов последний):
  Файл "concat.py", строка 5, в 
    печать (a + b)
TypeError: можно только объединить str (не "int") с str
  
 Примечание:
 Вы не можете объединить строку и целое число с помощью оператора  + .
 Чтобы избежать этой ошибки, мы можем использовать метод  str ()  для преобразования целого числа в строку, например:
  name = "John"
age = "35"

print (a + str (b)) # Иоанна 35
  
 Как разбить строку 
 Встроенный метод  split ()  используется для разделения одной строки на массив строк.
  string = "Меня зовут Джон"
split_arr = string.split ('') # ['Мой', 'имя', 'есть', 'Джон']

Мы также можем разделить строку с помощью разделителя:

string = "Джон, Роза, Джек, Мэри"
split_arr = string.split (',') # ['Джон', 'Роза', 'Джек', 'Мэри']
  
 Полоса - удаление пробелов 
  strip () , встроенный строковый метод используется для удаления пробелов в начале и конце строки.
  string = "Привет, мир"
stripper_str = строка.strip () # 'Привет, мир'
  
 Как видите,  strip ()  не удаляет пробелы между другими символами, а только на двух концах.
 Существует два варианта метода полоски  () , левая полоса и правая полоса:
 Эти методы удаляют пробелы слева и справа от строки соответственно.
 Пример:
  lsplit_str = string.lstrip () # 'Hello, World'
rsplit_str = строка.rstrip () # 'Привет, мир'
  
Методы
 Strip особенно полезны при чтении вводимых пользователем данных, когда пользователи могут пропускать лишние пробелы.
 Форматирование строки 
 Метод Python  format ()  используется для форматирования строки. Фигурные скобки  {}  используются внутри строки, которую необходимо отформатировать в качестве заполнителя для части, которую необходимо заменить аргументами, предоставленными методу  format () .
 Пример:
  «Привет, {}».format ('John') # 'Привет, Джон'
  
 В приведенном выше примере  {}  заменено на «Джон» в форматированной строке.
 Внутри строки для форматирования можно использовать несколько фигурных скобок. Они заменяются аргументами, предоставленными методу  format ()  либо в указанном порядке (если внутри фигурных скобок не указаны позиционные индексы), либо в позиционном порядке.
 Пример:
  "У меня есть {}, {} и {}". Format ('dog', 'cat', 'rabbit') # 'У меня есть собака, кошка и кролик'
«У меня есть {1}, {0} и {2}».format ('dog', 'cat', 'rabbit') # 'У меня есть кошка, собака и кролик'
  
 Вместо использования индексов вы можете предоставить аргументы ключевого слова методу  format () , чтобы эти ключевые слова можно было использовать внутри фигурных скобок.
 Пример:
  print («{друг} - мой друг, а {враг} - мой враг» .format (friend = "John", enemy = "Jack"))
# 'Джон - мой друг, а Джек - мой враг'
  
 Метод  format ()  довольно универсален, так как его можно использовать во многих случаях использования.
 Вот некоторые другие применения метода  format () :
  arr = [3, 5]
"У меня {0 [0]} собак и {0 [1]} кошек". Формат (обр.)
# "У меня 3 собаки и 4 кошки"

# преобразовать числа в разные основания
"int: {0: d}; hex: {0: x}; oct: {0: o}; bin: {0: b}". format (42)
# 'int: 42; шестнадцатеричный: 2а; октябрь: 52; бункер: 101010 '
  
 Преобразование строки в нижний регистр 
 Используя метод Python  lower () , вы можете преобразовать строку в нижний регистр.
 Пример:
  string = "Hello, World!"
нить.lower () # 'привет, мир!'
  
 Преобразование строки в верхний регистр 
 Аналогичным образом, используя метод Python  upper () , вы можете преобразовать строку в верхний регистр.