Строки в питоне: работа со строками, форматирование,методы split, strip

Содержание

Строки в Python. Создание, объединение, повторение.

Введение

Строки (strings) в Python представляют собой последовательности из одного или более знаков (букв, цифр, символов). И хотя мы можем использовать эту последовательность в каких-то операциях, сама она является неизменной. То есть строку нельзя изменить, не создав при этом другой объект, занимающий иной адрес в памяти.

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

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

Создание строк и вывод их на экран

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

'Это строка заключена в одинарные кавычки'
"Это строка заключена в двойные кавычки"

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

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

print("Давайте выведем на экран эту строку!")

Давайте выведем на экран эту строку!

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

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

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

Давайте соединим строки "Sammy" и "Shark" вместе с помощью функции print():

 print("Sammy" + "Shark")

SammyShark

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

print("Sammy" + 27)

TypeError: Can't convert 'int' object to str implicitly

Если бы мы захотели создать строку "Sammy27", мы могли бы это сделать поставив число 27 в кавычки "27", таким образом превратив его из целого числа в строку. Преобразование числа в строку может быть полезным, когда мы, например, имеем дело с индексами или телефонными номерами. Например, когда нам нужно объединить телефонный код страны и телефонный номер, но при этом мы не хотим их складывать .

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

Как работает конкатенация строк в Python 3? Примеры.

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

Однажды у вас могут возникнуть обстоятельства, при которых вы захотите использовать Python для автоматизации некоторых задач. И одной из таких задач может стать многократное повторение строки в тексте. Для того чтобы это осуществить, потребуется воспользоваться оператором *, который, как и оператор +, отличается от того, что используется вместе с числами. При использовании с одной строкой и одним числом * становится оператором повторения, а не умножения. Он лишь повторяет заданный текст указанное число раз.

Давайте выведем на экран "Sammy" 9 раз с помощью оператора *.

print("Sammy" * 9) SammySammySammySammySammySammySammySammySammy

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

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

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

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

my_str в качестве нашей переменной:

my_str = "Sammy likes declaring strings."

Теперь, когда у нас есть переменная my_str, назначенная нужной нам строке, мы можем вывести ее на экран:

print(my_str)

И получим следующий вывод:

Sammy likes declaring strings.

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

Заключение

Итак, в этом руководстве мы рассмотрели основы работы со строковыми данными в Python 3. А именно, научились создавать и выводить на экран строки, объединять их и повторять, а также сохранять строки в переменных. Но все это конечно же является лишь самыми начальными знаниями о возможностях использования строк в Python 3.

Что такое f строки и как их использовать ~ PythonRu

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

Вступление

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

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

f-строки исполняются при исполнении самой программы. Это работает быстрее других методов.

У f-строк более простой синтаксис в сравнении с другими техниками форматирования Python. Эта особенность будет рассмотрена на примерах.

Синтаксис

Каждая инструкция f-строки состоит из двух частей: символа f (или F) и строки, которую нужно форматировать. Строка должна быть в одинарных, двойных или тройных кавычках.

Синтаксис следующий.


f"string"

На месте string нужно написать предложение, которое требуется отформатировать.

Отображение переменных

Раньше для форматирования использовался метод str.format()

. Новый подход делает все вдвое быстрее.

Подписывайтесь на телеграм каналы

Переменные в фигурных {} скобках отображаются в выводе как обычно в print. Стоит посмотреть на примере.


name = "Pythonru" 
type_of_site = "Блог"  


print(f"{name} это {type_of_site}.")
Pythonru это Блог.

Все значения переменных отобразились в выводе. С этим все понятно. Вместо f можно написать F.


name = "Pythonru" 
type_of_site = "Блог"  


print(F"{name} это {type_of_site}?")
Pythonru это Блог?

Выражения

Что, если можно было бы выполнять арифметические выражения или вызовы функций в строке? Это удобно. И f-строки позволяют делать это.

Просто вставьте выражение в {} для исполнения. Оно выполнится при запуске программы. Экономит время и код.

Вот примеры отдельных выражений.


print(f"{2 * 2}")  

Также в {} можно вызвать функцию. Определим функцию greet() и вызовем ее в f-строке.

def greet(name):  
    return "Привет, " + name

name = "Олег" 
print(f"{greet(name)}")
Привет, Олег

Также можно вызвать определенные заранее методы.


string = "pythonru это блог." 
print(f"{string.title()}")
Pythonru Это Блог.

Что еще умеет f-строка? Отображать объект? Да. Работает это так же, как и при выводе переменных.

class Sample:  
    def __init__(self, name, age): 
        self.name = name 
        self.age = age 

    
    def __str__(self):  
        return  f'Имя: {self.name}. Возвраст: {self.age}.'
user= Sample("Игорь", 19) print(f"{user}")
Имя: Игорь. Возвраст: 19.

Специальные символы

Что делать, если нужно отобразить специальные символы, такие как {}, \', \"? Они ведь используются в Python для определенных целей. Можно ли использовать экранирование внутри f-строки? Вот ответы на все вопросы.

Кавычки

Можно использовать любые кавычки (одинарные, двойные или тройные) в f-строке. Для их вывода потребуется использовать экранирование. Выражение f-строки не позволяет использовать обратную косую черту. Ее нужно размещать вне {}.

Рассмотрим на примерах.

name = "Pythonru"


print(f"Привет, \'{name}\'")

print()


print(f"Привет, \"{name}\"")
Привет, 'Pythonru'

Привет, "Pythonru"

Другие кавычки в f-строках.

f'{"Привет, Pythonru"}'  
f"{'Привет, Pythonru'}"  
f"""Привет, Pythonru"""  
f'''Привет, Pythonru'''  

{} также можно включать в тройные кавычки.

В f-строках нельзя использовать обратную косую черту в {}. Если попробовать, то будет ошибка.

print(f"{\"Pythonru\"}")  

Скобки

Двойные скобки нужны, чтобы вывести одни фигурные скобки в f-строке.

print(f"{{Pythonru}}")
{Pythonru}

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

print(f"{{{{Pythonru}}}}")
{{Pythonru}}

Словари

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

person = {"name": "Игорь", "age": 19} 
print(f"{person['name']}, {person['age']} лет.")
Игорь, 19 лет.

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

person = {"name": "Игорь", "age": 19} 
print(f'{person['name']}, {person['age']} лет.')
File "<ipython-input-65-6849ff0810ae>", line 2
    print(f'{person['name']}, {person['age']} лет.')
                        ^
SyntaxError: invalid syntax

Лучшие примеры форматирования строк в Python

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

Содержание:

Помните Дзен Python, где должен быть “один очевидный способ сделать что-то в Python”? Можете почесать голову перед тем, как понять, что зачастую есть целых 4 эффективных способа выполнить форматирование строк в Python.

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

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

Telegram Чат & Канал

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

Паблик VK

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

Давайте приступим к делу, работы много! Чтобы иметь в распоряжении простой пример для эксперимента, представим, что у вас есть следующие переменные (или константы, не важно) для работы:

errno = 50159747054 name = ‘Bob’

errno = 50159747054

name = ‘Bob’

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

‘Hey Bob, there is a 0xbadc0ffee error!’

‘Hey Bob, there is a 0xbadc0ffee error!’

Эта ошибка может немного подпортить понедельник вашему разрабу… Но мы здесь за тем, чтобы обсудить форматирование строк. Так что приступим к делу.

Строки в Python содержат уникальную встроенную операцию, доступ к которой можно получить через оператор %. Это позволяет заметно упростить позиционное форматирование. Если вы когда-либо работали с функцией printf в С, вы сразу узнаете, как это работает. Вот простой пример:

print(‘Hello, %s’ % name) # Вывод: «Hello, Bob»

print(‘Hello, %s’ % name)

 

# Вывод: «Hello, Bob»

Я использую определитель формата %s в данном случае, чтобы сказать Python, где именно заменить значение имени, представленного в виде строки.

Существуют другие определители формата, которые позволяют вам контролировать формат выдачи. Например, возможно конвертировать числа в шестнадцатеричную нотацию или добавлять пробелы для создания хорошо отформатированных таблиц и отчетов. (См Python Docs: ““printf-style String Formatting”.)

Здесь, вы можете использовать определитель формата %x для конвертации значения int в строку и представить его в качестве шестнадцатеричного числа:

errno = 50159747054 print(‘%x’ % errno) # Вывод: ‘badc0ffee’

errno = 50159747054

print(‘%x’ % errno)

 

# Вывод: ‘badc0ffee’

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

errno = 50159747054 name = ‘Bob’ print(‘Hey %s, there is a 0x%x error!’ % (name, errno)) # ‘Hey Bob, there is a 0xbadc0ffee error!’

errno = 50159747054

name = ‘Bob’

 

print(‘Hey %s, there is a 0x%x error!’ % (name, errno))

 

# ‘Hey Bob, there is a 0xbadc0ffee error!’

Также возможно сослаться на заменители переменных по имени в вашей строке формата, если вы передадите сопоставление оператору %:

print( ‘Hey %(name)s, there is a 0x%(errno)x error!’ % { «name»: name, «errno»: errno } ) # Вывод: ‘Hey Bob, there is a 0xbadc0ffee error!’

print(

    ‘Hey %(name)s, there is a 0x%(errno)x error!’ % {

        «name»: name, «errno»: errno

    }

)

 

# Вывод: ‘Hey Bob, there is a 0xbadc0ffee error!’

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

Я уверен, что вы думаете, почему это printf форматирование считается старым форматированием строк. Технически, оно было заменено новым подходом к форматированию в “Python 3”, которое мы сейчас и рассмотрим!

Python 3 предоставил новый способ форматирования, который также был внесен в раннюю версию Python 2.7. Этот “новый стиль” форматирования строк избавляется от специального синтаксиса оператора % и делает синтаксис для форматирования строк более регулярным. Теперь форматирование обрабатывается вызовом .format() в объекте строки.

Вы можете использовать format(), чтобы выполнить простое позиционное форматирование, также, как мы делали это по старинке:

print(‘Hello, {}’.format(name)) # Вывод: ‘Hello, Bob’

print(‘Hello, {}’.format(name))

# Вывод: ‘Hello, Bob’

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

print( ‘Hey {name}, there is a 0x{errno:x} error!’.format( name=name, errno=errno ) ) # Вывод: ‘Hey Bob, there is a 0xbadc0ffee error!’

print(

    ‘Hey {name}, there is a 0x{errno:x} error!’.format(

        name=name, errno=errno

    )

)

 

# Вывод: ‘Hey Bob, there is a 0xbadc0ffee error!’

Это также демонстрирует, что синтаксис формата переменной int — это шестнадцатеричная измененная строка. Теперь вам нужно передать формат spec, внеся суффикс :x. Синтаксис формата строки стал более сильным, не усложняя при этом более простые варианты использования. Не лишним будет ознакомиться с этим мини-языком форматирования строк в документации Python.

В Python 3, этот “новый стиль” форматирования строк более предпочитаем, чем форматирование с оператором %. Хотя метод по старинке и остался в стороне, он не устарел. Он все еще поддерживается последними версиями Python. Согласно этой переписке разработчиков Python и связанной с этим проблемой поисков багов у разработчиков, форматирование с оператором % будет поддерживаться еще долго.

Однако, официальная документация Python 3 не делает явных рекомендаций по использованию старого форматирования:

“Упомянутые операции форматирования демонстрируют ряд неувязок, которые могут привести к распространенным ошибкам (таким, как неспособность правильно отображать кортежи и словари). Использовать новые литералы форматирования строк или интерфейс str.format() помогает избежать этих ошибок. Эти альтернативы также предоставляют более сильные, гибкие и расширяемые подходы в форматировании текста.”

По этому я лично пытаюсь работать str.format при продвижении нового кода. Начав с Python 3.6, есть еще один способ форматирования ваших строк. Рассмотрим его в следующем разделе!

Python 3.6 Добавил новый подход форматирования строк под названием форматированные строчные литералы, или “f-строки”. Этот новый способ форматирования строк позволяет вам использовать встроенные выражения Python внутрь строковых констант. Вот простой, наглядный пример:

name = ‘Bob’ print(f’Hello, {name}!’) # Вывод: ‘Hello, Bob!’

name = ‘Bob’

print(f’Hello, {name}!’)

 

# Вывод: ‘Hello, Bob!’

Как вы видите, это добавляет префикс к константе строки с буквой “f” — следовательно, названием становится “f-strings”. Этот новый синтаксис форматирования — очень мощный. Так как вы можете вставлять произвольные выражения Python, вы можете даже проводить встроенную арифметику. Посмотрим на пример:

a = 5 b = 10 print(f’Five plus ten is {a + b} and not {2 * (a + b)}.’) # Вывод: ‘Five plus ten is 15 and not 30.’

a = 5

b = 10

print(f’Five plus ten is {a + b} and not {2 * (a + b)}.’)

 

# Вывод: ‘Five plus ten is 15 and not 30.’

Форматированные строчные литералы — это особенность парсера Python, которая конвертирует f-строки в серию строчных констант и выражений. Затем, они соединяются и составляют итоговую строку.

Представьте, что у вас есть следующая функция greet(), которая содержит f-строку:

def greet(name, question): return f»Hello, {name}! How’s it {question}?» print(greet(‘Bob’, ‘going’)) # Вывод: «Hello, Bob! How’s it going?»

def greet(name, question):

    return f»Hello, {name}! How’s it {question}?»

 

 

print(greet(‘Bob’, ‘going’))

 

# Вывод: «Hello, Bob! How’s it going?»

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

def greet(name, question): return «Hello, » + name + «! How’s it » + question + «?»

def greet(name, question):

    return «Hello, » + name + «! How’s it » + question + «?»

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

>>> import dis >>> dis.dis(greet) 2 0 LOAD_CONST 1 (‘Hello, ‘) 2 LOAD_FAST 0 (name) 4 FORMAT_VALUE 0 6 LOAD_CONST 2 («! How’s it «) 8 LOAD_FAST 1 (question) 10 FORMAT_VALUE 0 12 LOAD_CONST 3 (‘?’) 14 BUILD_STRING 5 16 RETURN_VALUE

>>> import dis

>>> dis.dis(greet)

  2           0 LOAD_CONST               1 (‘Hello, ‘)

              2 LOAD_FAST                0 (name)

              4 FORMAT_VALUE             0

              6 LOAD_CONST               2 («! How’s it «)

              8 LOAD_FAST                1 (question)

             10 FORMAT_VALUE             0

             12 LOAD_CONST               3 (‘?’)

             14 BUILD_STRING             5

             16 RETURN_VALUE

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

print(f»Hey {name}, there’s a {errno:#x} error!») # Вывод: «Hey Bob, there’s a 0xbadc0ffee error!»

print(f»Hey {name}, there’s a {errno:#x} error!»)

 

# Вывод: «Hey Bob, there’s a 0xbadc0ffee error!»

Новые форматированные строчные литералы аналогичны шаблонным литералам (Template Literals) в JavaScript, которые были добавлены в ES2015. Я думаю это достаточно хорошее нововведение в Python, и я бы с радостью пользовался ими на каждодневной основе (в Python 3). Вы можете узнать больше о форматированных строчных литералах в интернете.

Рассмотрим еще один инструмент для форматирования строк в Python: template strings. Это более простой и менее мощный механизм, но в ряде случаев он может быть именно тем, что вам нужно.

Давайте посмотрим на простой пример:

from string import Template t = Template(‘Hey, $name!’) print(t.substitute(name=name)) # Вывод: ‘Hey, Bob!’

from string import Template

t = Template(‘Hey, $name!’)

 

print(t.substitute(name=name))

 

# Вывод: ‘Hey, Bob!’

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

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

templ_string = ‘Hey $name, there is a $error error!’ print( Template(templ_string).substitute( name=name, error=hex(errno) ) ) # Вывод: ‘Hey Bob, there is a 0xbadc0ffee error!’

templ_string = ‘Hey $name, there is a $error error!’

 

print(

    Template(templ_string).substitute(

        name=name, error=hex(errno)

    )

)

 

# Вывод: ‘Hey Bob, there is a 0xbadc0ffee error!’

Это сработало отлично!

Так когда нам стоит использовать шаблонные строки в программах Python?

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

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

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

# Вот ваш супер-секретный ключ: SECRET = ‘this-is-a-secret’ class Error: def __init__(self): pass # Злоумышленник может создать форматную строку, которая # может считать данные из общего словаря: user_input = ‘{error.__init__.__globals__[SECRET]}’ # Это позволяет ему профильтровать конфиденциальную информацию # такую, как секретный ключ: err = Error() print(user_input.format(error=err)) # Вывод: ‘this-is-a-secret’

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

# Вот ваш супер-секретный ключ:

SECRET = ‘this-is-a-secret’

 

class Error:

    def __init__(self):

        pass

 

# Злоумышленник может создать форматную строку, которая

# может считать данные из общего словаря:

user_input = ‘{error.__init__.__globals__[SECRET]}’

 

# Это позволяет ему профильтровать конфиденциальную информацию

# такую, как секретный ключ:

err = Error()

 

print(user_input.format(error=err))

 

# Вывод: ‘this-is-a-secret’

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

Страшно, да? Шаблонные строки закрывают этот вектор атаки. Это делает их более безопасным выбором, если вы обрабатываете строки форматирования, созданные в вводе пользователя:

print(user_input = ‘${error.__init__.__globals__[SECRET]}’) print(Template(user_input).substitute(error=err)) ValueError: «Invalid placeholder in string: line 1, col 1»

print(user_input = ‘${error.__init__.__globals__[SECRET]}’)

print(Template(user_input).substitute(error=err))

 

ValueError:

    «Invalid placeholder in string: line 1, col 1»

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

Эта блок-схема основана на эмпирическом правиле, которое я применяю, когда пишу в Python:

Если ваши строки форматирования поддерживаются пользователями, используйте шаблонные строки (способ 4), чтобы избежать проблем с уязвимостью программы. В противном случае, воспользуйтесь литеральной интерполяцией строк / f-строками (способ 3), если вы используете Python 3.6+ и “новым способом” с str.format (способ 2), если не пользуетесь Python 3.6.

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

Новый улучшенный способ форматирования строк в Python

У нас для вас хорошие новости: f-строки вступают в дело, чтобы помочь с форматированием. Также известные как «форматированные строковые литералы», f-strings являются строковыми литералами с «f» в начале и фигурные скобки, содержащие выражения, которые в дальнейшем будут заменены своими значениями. Выражения оцениваются по мере выполнения и затем форматируются при помощи протокола __format__ . Как всегда, документация Python может помочь, если хотите узнать больше.

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

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

Telegram Чат & Канал

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

Паблик VK

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

Рассмотрим подробнее, как именно f-strings могут упростить вам жизнь.

Простой синтаксис

Синтаксис аналогичен тому, который вы используете в str.format(), но не такой перегруженный. Посмотрите на эту читабельность:

name = «Eric» age = 74 print(f»Hello, {name}. You are {age}.») # Вывод: ‘Hello, Eric. You are 74.’

name = «Eric»

age = 74

 

print(f»Hello, {name}. You are {age}.»)

# Вывод: ‘Hello, Eric. You are 74.’

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

print(F»Hello, {name}. You are {age}.») # Вывод: ‘Hello, Eric. You are 74.’

print(F»Hello, {name}. You are {age}.»)

# Вывод: ‘Hello, Eric. You are 74.’

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

Произвольные выражения

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

print(f»{2 * 37}») # Вывод: ’74’

print(f»{2 * 37}»)

# Вывод: ’74’

Также вы можете вызывать функции. Пример:

def to_lowercase(input): return input.lower() name = «Eric Idle» print(f»{to_lowercase(name)} is funny.») # Вывод: ‘eric idle is funny.’

def to_lowercase(input):

    return input.lower()

 

name = «Eric Idle»

 

print(f»{to_lowercase(name)} is funny.»)

# Вывод: ‘eric idle is funny.’

Также вы можете вызывать метод напрямую:

print(f»{name.lower()} is funny.») # Вывод: ‘eric idle is funny.’

print(f»{name.lower()} is funny.»)

# Вывод: ‘eric idle is funny.’

Вы даже можете использовать объекты, созданные из классов при помощи f-строки. Представим, что у вас есть следующий класс:

class Comedian: def __init__(self, first_name, last_name, age): self.first_name = first_name self.last_name = last_name self.age = age def __str__(self): return f»{self.first_name} {self.last_name} is {self.age}.» def __repr__(self): return f»{self.first_name} {self.last_name} is {self.age}. Surprise!»

class Comedian:

    def __init__(self, first_name, last_name, age):

        self.first_name = first_name

        self.last_name = last_name

        self.age = age

 

    def __str__(self):

        return f»{self.first_name} {self.last_name} is {self.age}.»

 

    def __repr__(self):

        return f»{self.first_name} {self.last_name} is {self.age}. Surprise!»

Вы могли бы сделать следующее:

new_comedian = Comedian(«Eric», «Idle», «74») print(f»{new_comedian}») # Вывод: ‘Eric Idle is 74.’

new_comedian = Comedian(«Eric», «Idle», «74»)

 

print(f»{new_comedian}»)

# Вывод: ‘Eric Idle is 74.’

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

Строка, которая возвращается __str__() является неформальным строковым представлением объекта и должна быть читаемой. Строка, которую вернул __str__() — это официальное выражение и должно быть однозначным. При вызове str() и repr(), предпочтительнее использовать __str__() и __repr__() напрямую.

По умолчанию, f-строки будут использовать __str__(), но вы должны убедиться в том, что они используют __repr__(), если вы включаете флаг преобразования !r:

print(f»{new_comedian}») # Вывод: ‘Eric Idle is 74.’ print(f»{new_comedian!r}») # Вывод: ‘Eric Idle is 74. Surprise!’

print(f»{new_comedian}»)

# Вывод: ‘Eric Idle is 74.’

 

print(f»{new_comedian!r}»)

# Вывод: ‘Eric Idle is 74. Surprise!’

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

Многострочные F-Strings

У вас могут быть многострочные f-strings:

name = «Eric» profession = «comedian» affiliation = «Monty Python» message = ( f»Hi {name}. « f»You are a {profession}. « f»You were in {affiliation}.» ) print(message) # Вывод: ‘Hi Eric. You are a comedian. You were in Monty Python.’

name = «Eric»

profession = «comedian»

affiliation = «Monty Python»

 

message = (

    f»Hi {name}. «

    f»You are a {profession}. «

    f»You were in {affiliation}.»

)

 

print(message)

# Вывод: ‘Hi Eric. You are a comedian. You were in Monty Python.’

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

message = ( f»Hi {name}. « «You are a {profession}. « «You were in {affiliation}.» ) print(message) # Вывод: ‘Hi Eric. You are a {profession}. You were in {affiliation}.’

message = (

    f»Hi {name}. «

    «You are a {profession}. «

    «You were in {affiliation}.»

)

 

print(message)

# Вывод: ‘Hi Eric. You are a {profession}. You were in {affiliation}.’

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

Если вы хотите размножить строки по нескольким линиям, у вас также есть возможность избежать возвратов при помощи \:

message = f»Hi {name}. » \ f»You are a {profession}. » \ f»You were in {affiliation}.» print(message) # Вывод: ‘Hi Eric. You are a comedian. You were in Monty Python.’

message = f»Hi {name}. » \

          f»You are a {profession}. » \

          f»You were in {affiliation}.»

 

print(message)

# Вывод: ‘Hi Eric. You are a comedian. You were in Monty Python.’

Но вот что произойдет, если вы используете «»»:

message = f»»» Hi {name}. You are a {profession}. You were in {affiliation}. «»» print(message) # Вывод: ‘\n Hi Eric.\n You are a comedian.\n You were in Monty Python.\n’

message = f»»»

    Hi {name}.

    You are a {profession}.

    You were in {affiliation}.

«»»

 

print(message)

# Вывод: ‘\n    Hi Eric.\n    You are a comedian.\n    You were in Monty Python.\n’

Инструкция по отступам доступна в PEP 8.

Скорость

Буква f в f-strings может также означать и “fast”. Наши f-строки заметно быстрее чем % и str.format() форматирования. Как мы уже видели, f-строки являются выражениями, которые оцениваются по мере выполнения, а не постоянные значения. Вот выдержка из документации:

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

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

Рассмотрим сравнение скорости:

>>> import timeit >>> timeit.timeit(«»»name = «Eric» … age = 74 … ‘%s is %s.’ % (name, age)»»», number = 10000) 0.003324444866599663

>>> import timeit

>>> timeit.timeit(«»»name = «Eric»

… age = 74

… ‘%s is %s.’ % (name, age)»»», number = 10000)

 

0.003324444866599663

>>> timeit.timeit(«»»name = «Eric» … age = 74 … ‘{} is {}.’.format(name, age)»»», number = 10000) 0.004242089427570761

>>> timeit.timeit(«»»name = «Eric»

… age = 74

… ‘{} is {}.’.format(name, age)»»», number = 10000)

 

0.004242089427570761

>>> timeit.timeit(«»»name = «Eric» … age = 74 … f'{name} is {age}.'»»», number = 10000) 0.0024820892040722242

>>> timeit.timeit(«»»name = «Eric»

… age = 74

… f'{name} is {age}.'»»», number = 10000)

 

0.0024820892040722242

Как вы видите, f-строки являются самыми быстрыми.

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

Python F-Строки: Детали

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

Кавычки

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

Этот код будет работать:

print(f»{‘Eric Idle’}») # Вывод: ‘Eric Idle’

print(f»{‘Eric Idle’}»)

# Вывод: ‘Eric Idle’

И этот тоже:

print(f'{«Eric Idle»}’) # Вывод: ‘Eric Idle’

print(f'{«Eric Idle»}’)

# Вывод: ‘Eric Idle’

Вы также можете использовать тройные кавычки:

print(f»»»Eric Idle»»») # Вывод: ‘Eric Idle’

print(f»»»Eric Idle»»»)

# Вывод: ‘Eric Idle’

print(f»’Eric Idle»’) # Вывод: ‘Eric Idle’

print(f»’Eric Idle»’)

# Вывод: ‘Eric Idle’

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

print(f»The \»comedian\» is {name}, aged {age}.») # Вывод: ‘The «comedian» is Eric Idle, aged 74.’

print(f»The \»comedian\» is {name}, aged {age}.»)

# Вывод: ‘The «comedian» is Eric Idle, aged 74.’

Словари

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

Вот так:

comedian = {‘name’: ‘Eric Idle’, ‘age’: 74} print(f»The comedian is {comedian[‘name’]}, aged {comedian[‘age’]}.») # Вывод: The comedian is Eric Idle, aged 74.

comedian = {‘name’: ‘Eric Idle’, ‘age’: 74}

 

print(f»The comedian is {comedian[‘name’]}, aged {comedian[‘age’]}.»)

# Вывод: The comedian is Eric Idle, aged 74.

Обратите внимание на количество возможных проблем, если допустить ошибку в синтаксисе SyntaxError:

>>> comedian = {‘name’: ‘Eric Idle’, ‘age’: 74} >>> f’The comedian is {comedian[‘name’]}, aged {comedian[‘age’]}.’ File «<stdin>», line 1 f’The comedian is {comedian[‘name’]}, aged {comedian[‘age’]}.’ ^ SyntaxError: invalid syntax

>>> comedian = {‘name’: ‘Eric Idle’, ‘age’: 74}

>>> f’The comedian is {comedian[‘name’]}, aged {comedian[‘age’]}.’

  File «<stdin>», line 1

    f’The comedian is {comedian[‘name’]}, aged {comedian[‘age’]}.’

                                    ^

SyntaxError: invalid syntax

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

Скобки

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

print(f»{{74}}») # Вывод: ‘{ 74 }’

print(f»{{74}}»)

 

# Вывод: ‘{ 74 }’

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

print( f»{{{74}}}» ) # Вывод: ‘{ 74 }’

print( f»{{{74}}}» )

 

# Вывод: ‘{ 74 }’

Однако, вы можете получить больше отображаемых скобок, если вы используете больше, чем три скобки:

print(f»{{{{74}}}}») # Вывод: ‘{{74}}’

print(f»{{{{74}}}}»)

 

# Вывод: ‘{{74}}’

Бэкслеши

Как вы видели ранее, вы можете использовать бэкслеши в части строки f-string. Однако, вы не можете использовать бэкслеши в части выражения f-string:

>>> f»{\»Eric Idle\»}» File «<stdin>», line 1 f»{\»Eric Idle\»}» ^ SyntaxError: f-string expression part cannot include a backslash

>>> f»{\»Eric Idle\»}»

  File «<stdin>», line 1

    f»{\»Eric Idle\»}»

                      ^

SyntaxError: f-string expression part cannot include a backslash

Вы можете проработать это, оценивая выражение заранее и используя результат в f-строк:

name = «Eric Idle» print(f»{name}») # Вывод: ‘Eric Idle’

name = «Eric Idle»

print(f»{name}»)

 

# Вывод: ‘Eric Idle’

Междустрочные комментарии

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

>>> f»Eric is {2 * 37 #Oh my!}.» File «<stdin>», line 1 f»Eric is {2 * 37 #Oh my!}.» ^ SyntaxError: f-string expression part cannot include ‘#’

>>> f»Eric is {2 * 37 #Oh my!}.»

  File «<stdin>», line 1

    f»Eric is {2 * 37 #Oh my!}.»

                                ^

SyntaxError: f-string expression part cannot include ‘#’

Идите с миром и форматируйте!

Разумеется, вы можете использовать старые методы форматирования строк, но с f-строками у вас есть более лаконичный, читаемый и удобный способ, который одновременно и быстрее, и менее вероятно приведет к ошибке. Упростить свою жизнь используя f-строки — отлична причина пользоваться Python 3.6, если вы еще не перешли к этой версии. (Если вы все еще пользуетесь Python 2.7, не беспокойтесь, 2020 год не за горами!)

Согласно дзену Python, когда вам нужно выбрать способ решения задачи, всегда “есть один — и желательно только один очевидный способ сделать это”. Кстати, f-строки не являются единственным способом форматирования строк. Однако, их использование вполне может стать единственным адекватным способом.

Форматирование строк. Оператор % | Python 3 для начинающих и чайников

Иногда (а точнее, довольно часто) возникают ситуации, когда нужно сделать строку, подставив в неё некоторые данные, полученные в процессе выполнения программы (пользовательский ввод, данные из файлов и т. д.). Подстановку данных можно сделать с помощью форматирования строк. Форматирование можно сделать с помощью оператора %, и метода format.

Метод format является наиболее правильным, но часто можно встретить программный код с форматированием строк в форме оператора %.

Форматирование строк с помощью оператора %

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

>>> 'Hello, %s!' % 'Vasya'
'Hello, Vasya!'

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

>>> '%d %s, %d %s' % (6, 'bananas', 10, 'lemons')
'6 bananas, 10 lemons'

Теперь, а почему я пишу то %d, то %s? А всё зависит от того, что мы используем в качестве подстановки и что мы хотим получить в итоге.

ФорматЧто получится
‘%d’, ‘%i’, ‘%u’Десятичное число.
‘%o’Число в восьмеричной системе счисления.
‘%x’Число в шестнадцатеричной системе счисления (буквы в нижнем регистре).
‘%X’Число в шестнадцатеричной системе счисления (буквы в верхнем регистре).
‘%e’Число с плавающей точкой с экспонентой (экспонента в нижнем регистре).
‘%E’Число с плавающей точкой с экспонентой (экспонента в верхнем регистре).
‘%f’, ‘%F’Число с плавающей точкой (обычный формат).
‘%g’Число с плавающей точкой. с экспонентой (экспонента в нижнем регистре), если она меньше, чем -4 или точности, иначе обычный формат.
‘%G’Число с плавающей точкой. с экспонентой (экспонента в верхнем регистре), если она меньше, чем -4 или точности, иначе обычный формат.
‘%c’Символ (строка из одного символа или число — код символа).
‘%r’Строка (литерал python).
‘%s’Строка (как обычно воспринимается пользователем).
‘%%’Знак ‘%’.

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

  1. %.
  2. Ключ (опционально), определяет, какой аргумент из значения будет подставляться.
  3. Флаги преобразования.
  4. Минимальная ширина поля. Если *, значение берётся из кортежа.
  5. Точность, начинается с ‘.’, затем — желаемая точность.
  6. Модификатор длины (опционально).
  7. Тип (см. таблицу выше).
>>> print ('%(language)s has %(number)03d quote types.' % {"language": "Python", "number": 2})
Python has 002 quote types.

Флаги преобразования:

ФлагЗначение
«#»Значение будет использовать альтернативную форму.
«0»Свободное место будет заполнено нулями.
«-«Свободное место будет заполнено пробелами справа.
» «Свободное место будет заполнено пробелами справа.
«+»Свободное место будет заполнено пробелами слева.
>>> '%.2s' % 'Hello!'
'He'
>>> '%.*s' % (2, 'Hello!')
'He'
>>> '%-10d' % 25
'25        '
>>> '%+10f' % 25
'+25.000000'
>>> '%+10s' % 'Hello'
'     Hello'

Разворачиваем строку в Python (5 разных способов)

Библиотека строк Python не поддерживает встроенный метод reverse(), как это делают другие контейнеры python, такие как list, поэтому знание других методов обращения строки может оказаться полезным. В этой статье рассматриваются несколько способов достижения этого.

Используем циклы

# Python code to reverse a string  
# using loop 
  
def reverse(s): 
    str = "" 
    for i in s: 
        str = i + str
    return str
  
s = "Pythonist"
  
print ("The original string  is : ",end="") 
print (s) 
  
print ("The reversed string(using loops) is : ",end="") 
print (reverse(s))
The original string  is : Pythonist
The reversed string(using loops) is : tsinohtyP 

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

Используем рекурсию

# Python code to reverse a string  
# using recursion 
  
def reverse(s): 
    if len(s) == 0: 
        return s 
    else: 
        return reverse(s[1:]) + s[0] 
  
s = "Pythonist"
  
print ("The original string  is : ",end="") 
print (s) 
  
print ("The reversed string(using recursion) is : ",end="") 
print (reverse(s)) 
The original string  is : Pythonist
The reversed string(using recursion) is : tsinohtyP  

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

Используем стек

# Python code to reverse a string  
# using stack 
  
# Function to create an empty stack. It  
# initializes size of stack as 0 
def createStack(): 
    stack=[] 
    return stack 
   
# Function to determine the size of the stack 
def size(stack): 
    return len(stack) 
   
# Stack is empty if the size is 0 
def isEmpty(stack): 
    if size(stack) == 0: 
        return true 
   
# Function to add an item to stack . It 
# increases size by 1     
def push(stack,item): 
    stack.append(item) 
   
# Function to remove an item from stack.  
# It decreases size by 1 
def pop(stack): 
    if isEmpty(stack): return
    return stack.pop() 
   
# A stack based function to reverse a string 
def reverse(string): 
    n = len(string) 
       
    # Create a empty stack 
    stack = createStack() 
   
    # Push all characters of string to stack 
    for i in range(0,n,1): 
        push(stack,string[i]) 
   
    # Making the string empty since all 
    # characters are saved in stack     
    string="" 
   
    # Pop all characters of string and put 
    # them back to string 
    for i in range(0,n,1): 
        string+=pop(stack) 
           
    return string 
  
# Driver code 
s = "Pythonist"
print ("The original string  is : ",end="") 
print (s) 
print ("The reversed string(using stack) is : ",end="") 
print (reverse(s)) 
The original string  is : Pythonist
The reversed string(using stack) is : tsinohtyP   

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

Используем расширенный синтаксис слайсинга

# Python code to reverse a string  
# using extended slice syntax 
  
# Function to reverse a string 
def reverse(string): 
    string = string[::-1] 
    return string 
  
s = "Pythonist"
  
print ("The original string  is : ",end="") 
print (s) 
  
print ("The reversed string(using extended slice syntax) is : ",end="") 
print (reverse(s)) 
The original string  is : Pythonist
The reversed string(using extended slice syntax) is : tsinohtyP   

Объяснение: Расширенный срез предлагает поместить поле «шаг» в срез [начало, конец, шаг], а пустое поле в качестве начала и конца указывает по умолчанию на 0, а с шагом в -1 срез соберет как раз перевернутую исходную строку.

Используем reversed

# Python code to reverse a string  
# using reversed() 
  
# Function to reverse a string 
def reverse(string): 
    string = "".join(reversed(string)) 
    return string 
  
s = "Pythonist"
  
print("The original string  is : ",end="") 
print(s) 
  
print("The reversed string(using reversed) is : ",end="") 
print (reverse(s)) 
The original string  is : Pythonist
The reversed string(using reversed) is : tsinohtyP    

Объяснение: Метод reversed() возвращает обратный итератор данной строки, а затем его элементы объединяются в пустую строку, разделенную с помощью join(). И так формируется обратная строка.

Форматирование строк. Метод format | Python 3 для начинающих и чайников

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

Форматирование строк с помощью метода format

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

>>> 'Hello, {}!'.format('Vasya')
'Hello, Vasya!'

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

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc')
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad')
'abracadabra'
>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
'Coordinates: 37.24N, -115.81W'

Однако метод format умеет большее. Вот его синтаксис:

поле замены     ::=  "{" [имя поля] ["!" преобразование] [":" спецификация] "}"
имя поля        ::=  arg_name ("." имя атрибута | "[" индекс "]")*
преобразование  ::=  "r" (внутреннее представление) | "s" (человеческое представление)
спецификация    ::=  см. ниже

Например:

>>> "Units destroyed: {players[0]}".format(players = [1, 2, 3])
'Units destroyed: 1'
>>> "Units destroyed: {players[0]!r}".format(players = ['1', '2', '3'])
"Units destroyed: '1'"

Теперь спецификация формата:

спецификация ::=  [[fill]align][sign][#][0][width][,][.precision][type]
заполнитель  ::=  символ кроме '{' или '}'
выравнивание ::=  "<" | ">" | "=" | "^"
знак         ::=  "+" | "-" | " "
ширина       ::=  integer
точность     ::=  integer
тип          ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" |
                  "n" | "o" | "s" | "x" | "X" | "%"

Выравнивание производится при помощи символа-заполнителя. Доступны следующие варианты выравнивания:

ФлагЗначение
‘<‘Символы-заполнители будут справа (выравнивание объекта по левому краю) (по умолчанию).
‘>’выравнивание объекта по правому краю.
‘=’Заполнитель будет после знака, но перед цифрами. Работает только с числовыми типами.
‘^’Выравнивание по центру.

Опция «знак» используется только для чисел и может принимать следующие значения:

ФлагЗначение
‘+’Знак должен быть использован для всех чисел.
‘-‘‘-‘ для отрицательных, ничего для положительных.
‘Пробел’‘-‘ для отрицательных, пробел для положительных.

Поле «тип» может принимать следующие значения:

ТипЗначение
‘d’, ‘i’, ‘u’Десятичное число.
‘o’Число в восьмеричной системе счисления.
‘x’Число в шестнадцатеричной системе счисления (буквы в нижнем регистре).
‘X’Число в шестнадцатеричной системе счисления (буквы в верхнем регистре).
‘e’Число с плавающей точкой с экспонентой (экспонента в нижнем регистре).
‘E’Число с плавающей точкой с экспонентой (экспонента в верхнем регистре).
‘f’, ‘F’Число с плавающей точкой (обычный формат).
‘g’Число с плавающей точкой. с экспонентой (экспонента в нижнем регистре), если она меньше, чем -4 или точности, иначе обычный формат.
‘G’Число с плавающей точкой. с экспонентой (экспонента в верхнем регистре), если она меньше, чем -4 или точности, иначе обычный формат.
‘c’Символ (строка из одного символа или число — код символа).
‘s’Строка.
‘%’Число умножается на 100, отображается число с плавающей точкой, а за ним знак %.

И напоследок, несколько примеров:

>>> coord = (3, 5)
>>> 'X: {0[0]};  Y: {0[1]}'.format(coord)
'X: 3;  Y: 5'
>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
"repr() shows quotes: 'test1'; str() doesn't: test2"
>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'
>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'
>>> # format also supports binary numbers
>>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)
'int: 42;  hex: 2a;  oct: 52;  bin: 101010'
>>> # with 0x, 0o, or 0b as prefix:
>>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)
'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'
>>> points = 19.5
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 88.64%'

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

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


Модуль string содержит ряд полезных констант и классы, а также некоторые устаревшие устаревшие функции, которые также доступны как методы для строк. Кроме того, встроенная строка Python классы поддерживают методы типа последовательности, описанные в Типы последовательностей — str, unicode, list, tuple, bytearray, buffer, xrange section, а также описанные строковые методы в разделе Строковые методы.Для вывода отформатированных строк используйте строки шаблона или оператор % , описанный в Раздел «Операции форматирования строк». Также см. Модуль re для строковые функции на основе регулярных выражений.

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

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

строка. ascii_letters

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

строка. ascii_lowercase

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

строка. ascii_uppercase

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

строка. цифр

Строка '0123456789' .

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

Строка '0123456789abcdefABCDEF' .

строка. букв

Объединение строк в нижнем регистре и в верхнем регистре описано ниже. Конкретное значение зависит от локали и будет обновлено. когда locale.setlocale () вызывается.

строка. строчная

Строка, содержащая все символы, которые считаются строчной буквой

.

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# с помощью *
print ('стр1 * 3 =', стр1 * 3)  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  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.

Колокол
Последовательность выхода Описание
\ новая строка Обратный слэш и новая строка игнорируются
\ Обратная косая черта
\ ‘ Одиночная цитата
\ « Двойная кавычка
\ ASCII
\ b ASCII Backspace
\ f ASCII Formfeed
\ п ASCII перевод строки
\ r возврат каретки ASCII
\ т Горизонтальная вкладка ASCII
\ v Вертикальная вкладка ASCII
\ ooo Знак с восьмеричным числом ооо
\ xHH Символ с шестнадцатеричным значением HH

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

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

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

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

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

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

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

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

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

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

  # Метод Python String format ()

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

# порядок с использованием позиционного аргумента
positional_order = "{1}, {0} и {2}". format ('Джон', 'Билл', 'Шон')
print ('\ n --- Позиционный порядок ---')
печать (positional_order)

# заказ с использованием аргумента ключевого слова
keyword_order = "{s}, {b} и {j}".формат (j = 'Джон', b = 'Билл', s = 'Шон')
print ('\ n --- Порядок ключевых слов ---')
печать (keyword_order)  

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

  --- Порядок по умолчанию ---
Джон, Билл и Шон

--- Позиционный порядок ---
Билл, Джон и Шон

--- Порядок ключевых слов ---
Шон, Билл и Джон  

Метод format () может иметь дополнительные спецификации формата. Они отделяются от имени поля двоеточием. Например, мы можем выровнять по левому краю <, выровнять по правому краю > или центрировать ^ строку в заданном пространстве.

Мы также можем форматировать целые числа как двоичные, шестнадцатеричные и т. Д., А числа с плавающей запятой можно округлять или отображать в формате экспоненты. Вы можете использовать множество вариантов форматирования. Посетите здесь, чтобы ознакомиться со всем форматированием строк, доступным с помощью метода 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 - ThePythonGuru.com

  1. Дом
  2. Блог
  3. Строки Python

(Спонсоры) Начните изучать Python с помощью DataCamp's бесплатный вводный курс по Python. Изучите науку о данных, выполняя интерактивные задания по кодированию и просматривая видео опытных инструкторов. Начать сейчас!