Все важные фичи и изменения в python 3.10

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

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

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

Синтаксис

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

In : ip = '10.1.1.1'

In : mask = 24

In : f"IP: {ip}, mask: {mask}"
Out: 'IP: 10.1.1.1, mask: 24'

Аналогичный результат с format можно получить так:
``"IP: {ip}, mask: {mask}".format(ip=ip, mask=mask)``.

Очень важное отличие f-строк от format: f-строки — это выражение, которое
выполняется, а не просто строка. То есть, в случае с ipython, как только
мы написали выражение и нажали Enter, оно выполнилось и вместо выражений
и подставились значения переменных

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

In 1]: f"IP: {ip}, mask: {mask}"
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-1-e6f8e01ac9c4> in <module>()
----> 1 f"IP: {ip}, mask: {mask}"

NameError name 'ip' is not defined

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

In 5]: first_name = 'William'

In 6]: second_name = 'Shakespeare'

In 7]: f"{first_name.upper()}{second_name.upper()}"
Out7]: 'WILLIAM SHAKESPEARE'

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

In 9]: oct1, oct2, oct3, oct4 = 10, 1, 1, 1

In 10]: print(f'''
    ...: IP address:
{oct1<8}{oct2<8}{oct3<8}{oct4<8}
{oct108b}{oct208b}{oct308b}{oct408b}''')

IP address
10       1        1        1
00001010 00000001 00000001 00000001

Предупреждение

Так как для полноценного объяснения f-строк, надо показывать
примеры с циклами и работой с объектами, которые еще не рассматривались,
это тема также есть в разделе с дополнительными примерами и пояснениями.

4 – Template Strings (стандартная библиотека)

Ещё одним способом форматирования строк в Python является Template Strings. Он более простой и менее мощный механизм, но в некоторых случаях он может быть предпочтительным.

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

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

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

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

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

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

Посмотрите, как гипотетический злоумышленник смог извлечь нашу секретную строку, обратившись к словарю __globals__? Страшно, да? Template strings закрывают этот вектор атаки. И это делает их более безопасным выбором, если обрабатываются строки форматирования, созданные из пользовательского ввода:

Стилевое оформление

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

from openpyxl.styles import Font

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

import openpyxl
from openpyxl.styles import Font

# создаем новый excel-файл
wb = openpyxl.Workbook()
# добавляем новый лист
wb.create_sheet(title = 'Первый лист', index = )
# получаем лист, с которым будем работать
sheet = wb'Первый лист'

font = Font(name='Arial', size=24, italic=True, color='FF0000')
sheet'A1'.font = font
sheet'A1' = 'Здравствуй мир!'

# записываем файл
wb.save('example.xlsx')

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

import openpyxl
from openpyxl.styles import NamedStyle, Font, Border, Side

# создаем новый excel-файл
wb = openpyxl.Workbook()
# добавляем новый лист
wb.create_sheet(title = 'Первый лист', index = )
# получаем лист, с которым будем работать
sheet = wb'Первый лист'

# создаем именованный стиль
ns = NamedStyle(name='highlight')
ns.font = Font(bold=True, size=20)
border = Side(style='thick', color='000000')
ns.border = Border(left=border, top=border, right=border, bottom=border)

# вновь созданный именованный стиль надо зарегистрировать
# для дальнейшего использования
wb.add_named_style(ns)

# теперь можно использовать именованный стиль
sheet'A1'.style = 'highlight'

# записываем файл
wb.save('example.xlsx')

Method 4: Use the logging module

We can use Python’s logging module to print to the file. This is preferred over Method 2, where explicitly changing the file streams is not be the most optimal solution.

import logging

# Create the file
# and output every level since 'DEBUG' is used
# and remove all headers in the output
# using empty format=''
logging.basicConfig(filename='output.txt', level=logging.DEBUG, format='')

logging.debug('Hi')
logging.info('Hello from AskPython')
logging.warning('exit')

This will, by default, append the three lines to . We have thus printed to the file using , which is one of the recommended ways of printing to a file.

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

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

In 1]: "interface FastEthernet0/{}".format('1')
Out1]: 'interface FastEthernet0/1'

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

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

In 3]: print('{}'.format('10.1.1.1'))
10.1.1.1

In 4]: print('{}'.format(100))
100

In 5]: print('{}'.format())
10, 1, 1, 1

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

Например, таким образом можно вывести данные столбцами одинаковой ширины
по 15 символов с выравниванием по правой стороне:

In 3]: vlan, mac, intf = '100', 'aabb.cc80.7000', 'Gi0/1'

In 4]: print("{:>15}{:>15}{:>15}".format(vlan, mac, intf))
            100  aabb.cc80.7000           Gi01

Выравнивание по левой стороне:

In 5]: print("{:15}{:15}{:15}".format(vlan, mac, intf))
100             aabb.cc80.7000  Gi01

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

In 6]: ip_template = '''
   ...: IP address:
{}
   ...: '''

In 7]: print(ip_template.format('10.1.1.1'))

IP address
10.1.1.1

С помощью форматирования строк можно также влиять на отображение чисел.

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

In 9]: print("{:.3f}".format(10.03))
3.333

С помощью форматирования строк можно конвертировать числа в двоичный
формат:

In 11]: '{:b}{:b}{:b}{:b}'.format(192, 100, 1, 1)
Out11]: '11000000 1100100 1 1'

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

In 12]: '{:8b}{:8b}{:8b}{:8b}'.format(192, 100, 1, 1)
Out12]: '11000000  1100100        1        1'

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

In 13]: '{:08b}{:08b}{:08b}{:08b}'.format(192, 100, 1, 1)
Out13]: '11000000 01100100 00000001 00000001'

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

In 15]: '{ip}{mask}'.format(mask=24, ip='10.1.1.1')
Out15]: '10.1.1.1/24'

Еще одна полезная возможность форматирования строк — указание номера
аргумента:

In 16]: '{1}{0}'.format(24, '10.1.1.1')
Out16]: '10.1.1.1/24'

За счет этого, например, можно избавиться от повторной передачи одних и
тех же значений:

In 19]: ip_template = '''
    ...: IP address:
{:<8}{:<8}{:<8}{:<8}
{:08b}{:08b}{:08b}{:08b}
    ...: '''

In 20]: print(ip_template.format(192, 100, 1, 1, 192, 100, 1, 1))

IP address
192      100      1        1
11000000 01100100 00000001 00000001

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

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

Старый способ — строковый оператор форматирования

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

Такой способ форматирования считается старым видимо потому, что заимствован из функции printf() языка C, а в Python кроме него появились более продвинутые средства форматирования вывода. Однако в ряде случаев использование оператора % бывает удобнее, чем использование строкового метода format().

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

Как вывести вещественное число с необходимой точностью

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

Обычно требуется лишь определенное количество знаков. Для этого в строку записывают комбинацию символов, начинающуюся с %. Число после точки обозначает количество знаков после запятой. Символ f обозначает вещественный тип данных float.

Ставить скобки обязательно, иначе операция % выполняется раньше /:

Оператор форматирования строк выполняет округление, а не урезание:

С функцией print():

Вывод данных в поля заданной ширины

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

Рассмотрим пример. Допустим надо вывести числа второй строки под числами первой. Если выполнить функцию print() так:

результат будет таким:

10 235
1000 50

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

Результат:

   10     235
 1000      50

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

Форматы данных могут быть: d — целое число, s — строка, f — вещественное число, c — символ.

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

Вывод:

10       235
1000      50

Методы строк

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

Python

my_string = «This is a string!»

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

Python

my_string.upper()

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

Python

«This is a string!».upper()

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

Python

dir(my_string)

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

Python

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

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

Например, если вы хотите узнать, зачем вам capitalize, впишите следующее, чтобы узнать:

Python

help(my_string.capitalize)

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

Python

Help on built-in function capitalize:

capitalize(…)
S.capitalize() -> string

Выдача копии строки S только с заглавной буквой.

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

Python

type(my_string) # <type ‘str’>

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

Error handling

There are two classes of exceptions which can occur during formatting:
exceptions generated by the formatter code itself, and exceptions
generated by user code (such as a field object’s ‘getattr’ function).

In general, exceptions generated by the formatter code itself are
of the «ValueError» variety — there is an error in the actual «value»
of the format string. (This is not always true; for example, the
string.format() function might be passed a non-string as its first
parameter, which would result in a TypeError.)

The text associated with these internally generated ValueError
exceptions will indicate the location of the exception inside
the format string, as well as the nature of the exception.

For exceptions generated by user code, a trace record and
dummy frame will be added to the traceback stack to help
in determining the location in the string where the exception
occurred. The inserted traceback will indicate that the
error occurred at:

File "<format_string>;", line XX, in column_YY

where XX and YY represent the line and character position
information in the string, respectively.

Пример 1: Базовое форматирование для аргументов по умолчанию, позиционных и ключевых слов

# default arguments
print("Hello {}, your balance is {}.".format("Adam", 230.2346))

# positional arguments
print("Hello {0}, your balance is {1}.".format("Adam", 230.2346))

# keyword arguments
print("Hello {name}, your balance is {blc}.".format(name="Adam", blc=230.2346))

# mixed arguments
print("Hello {0}, your balance is {blc}.".format("Adam", blc=230.2346))

Выход

Hello Adam, your balance is 230.2346.
Hello Adam, your balance is 230.2346.
Hello Adam, your balance is 230.2346.
Hello Adam, your balance is 230.2346.

Примечание: В случае смешанных аргументов аргументы ключевого слова всегда должны следовать за позиционными аргументами.

Arguments as format codes using format()

You can also pass format codes like precision, alignment, fill character as positional or keyword arguments dynamically.

Example 10: Dynamic formatting using format()

Output

*cat*
123.24

Here,

• In the first example, ‘cat’ is the positional argument is to be formatted. Likewise, , and are keyword arguments.
• In the template string, these keyword arguments are not retrieved as normal strings to be printed but as the actual format codes .
  The arguments replaces the corresponding named placeholders and the string ‘cat’ is formatted accordingly.
• Likewise, in the second example, 123.236 is the positional argument and, align, width and precision are passed to the template string as format codes.

Method 3: Explicitly print to the file

We can directly specify the file to be printed in the call to , by mentioning the file keyword argument.

For example, the below snippet prints to the file .

print('Hi', file=open('output.txt', 'a'))
print('Hello from AskPython', file=open('output.txt', 'a'))
print('exit', file=open('output.txt', 'a'))

The file now has the three lines appended to it, and we have successfully printed to !

Using a context manager

However, this method isn’t the best way to resolve this situation, due to the repeated calls to on the same file. This wastes time, and we can do better!

The better way would be to explicitly use a context manager statement, which takes care of automatically closing the file and using the file object directly.

with open("output.txt", "a") as f:
    print('Hi', file=f)
    print('Hello from AskPython', file=f)
    print('exit', file=f)

This gives the same result as before, appending the three lines to , but is now much faster, since we don’t open the same file again and again.

Производительность

F-строки не только гибкие, но и быстрые. И для сравнения производительности разных подходов к форматированию я подготовил два шаблона:

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

Финальная простая строка получается такой:

Сложная строка на выходе такая:

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

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

На простых примерах f-строки показывают самые лучшие результаты.На 25% быстрее %-форматирования и метода format().

#4 Template Strings (Standard Library)

Here’s one more tool for string formatting in Python: template strings. It’s a simpler and less powerful mechanism, but in some cases this might be exactly what you’re looking for.

Let’s take a look at a simple greeting example:

>>>

You see here that we need to import the class from Python’s built-in module. Template strings are not a core language feature but they’re supplied by the module in the standard library.

Another difference is that template strings don’t allow format specifiers. So in order to get the previous error string example to work, you’ll need to manually transform the error number into a hex-string:

>>>

That worked great.

So when should you use template strings in your Python programs? In my opinion, the best time to use template strings is when you’re handling formatted strings generated by users of your program. Due to their reduced complexity, template strings are a safer choice.

The more complex formatting mini-languages of the other string formatting techniques might introduce security vulnerabilities to your programs. For example, it’s possible for format strings to access arbitrary variables in your program.

That means, if a malicious user can supply a format string, they can potentially leak secret keys and other sensitive information! Here’s a simple proof of concept of how this attack might be used against your code:

>>>

See how a hypothetical attacker was able to extract our secret string by accessing the dictionary from a malicious format string? Scary, huh? Template strings close this attack vector. This makes them a safer choice if you’re handling format strings generated from user input:

>>>

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

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

Python

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

a_long_string = »’А это у нас
новая строка
в троичных скобках»’

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

Python

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

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

Python

my_number = 123
my_string = str(my_number)

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

Python

int(‘ABC’)

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

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

Python

x = int(«123»)

То все должно работать

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

Давайте попробуем сделать это и посмотрим, что получится:

Python

my_string = «abc»
my_string = «d»

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

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

Python

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 перед вашей строкой

Пример:

Python

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

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

Ввод и вывод данных

• Вывод данных осуществляется при помощи оператора print:

1
2
3
4
5

a = 1
b = 2
print(a)
print(a + b)
print('сумма = ', a + b)

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

1
2
3

a = 1; b = 2; print(a)
print(a + b)
print('сумма = ', a + b)

Для функции print может задаваться так называемый сепаратор — разделитель между элементами вывода:

1
2
3

x=2
y=5
print ( x, "+", y, "=", x+y, sep = " " )

Результат отобразится с пробелами между элементами: 2 + 5 = 7

Для форматированного вывода используется format:

1
2

x = 11
print ( "{:4d}".format(x) )

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

Или с несколькими аргументами:

1
2

x = 2
print ( "{:4d}{:4d}{:4d}".format (x, x+x, x*x) )

В итоге каждое из значений выводится из расчета 4 знакоместа.

Ввод данных осуществляется при помощи оператора :

1
2

a = input()
print(a)

В скобках функции можно указать сообщение-комментарий к вводимым данным:

a = input ("Введите количество: ")

Функция input воспринимает входные данные, как поток символов. Поэтому, чтобы принять целочисленное значение, следует воспользоваться функцией int():

a = int (input())

Задание Python 1_1:
Используя операторы input и print, выведите значения целых переменных x=5 и y=3 в следующих форматах:
3+5=?
3 | 5 | 8
Z(5)=F(3)
x=5; y=3;
Ответ: (5;3)