📦 Репозиторий занятия 22

Урок 22. Строки: форматирование

Как работать с репозиторием

Каждая карточка говорит, о чём файл, что он выводит и что в нём искать. Код виден прямо здесь: его можно скопировать одной кнопкой, скачать файл или открыть его целиком.

Маршрут изучения

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

Файлы: рекомендуемый порядок

MarkdownРазбор концепции72 строк

C-style форматирование через % и оператор %

less_12__str_formatting/theory_01__c_style.md

Разбирает старейший способ форматирования строк в Python, унаследованный от C: спецификаторы %s/%d/%f/%x внутри строки и оператор % справа, с кортежем значений при их множественности. Таблица покрывает все основные спецификаторы плюс приёмы ширины/выравнивания/нулей (%10s, %-10s, %05d). Показаны две частые ошибки — несовпадение типа со спецификатором (TypeError) и забытые скобки вокруг кортежа значений — с реальными трассировками.

Таблица спецификаторов: %s, %d, %f, %e, %x, %X, %o, %c, %%
'%10s' % "hi" и '%-10s' % "hi" — ширина и выравнивание
'%05d' % 7 — дополнение нулями
"Name: %d" % ("Alice", 30) → TypeError (тип не совпал со спецификатором)
"..." % "Alice", 30 без скобок → TypeError: not enough arguments
Плюс формата: шаблон можно сохранить в переменную и применять % позже

Показать начало файла (72 строк всего)

# C-style 

## Правило C-style форматирования (%)

- В строке пишутся спецификаторы вида `%s`, `%d`, `%f`, `%x` и т. д.
- После строки ставится оператор `%` 
- Справа от него указываются значения, которые должны подставиться на место спецификаторов:
  - Если одно значение → можно без скобок.
  - Если несколько значений → обязательно кортеж (…). 
- Тип значения должен совпадать со спецификатором.

## Таблица спецификаторов

| Спецификатор | Описание                                 | Пример кода                     | Результат           |
|--------------|------------------------------------------|----------------------------------|---------------------|
| %s           | Строка                                   | `"Hello %s" % "World"`          | Hello World         |
| %d           | Целое число (десятичное)                 | `"Возраст: %d" % 25`            | Возраст: 25         |
| %i           | Целое число (то же, что и %d)            | `"%i" % 42`                     | 42                  |
| %f           | Число с плавающей точкой (6 знаков)      | `"%.2f" % 3.14159`              | 3.14                |
| %e           | Экспоненциальная форма (с `e`)           | `"%e" % 1500`                   | 1.500000e+03        |
| %E           | Экспоненциальная форма (с `E`)           | `"%E" % 1500`                   | 1.500000E+03        |
| %x           | Целое в шестнадцатеричном (строчные)     | `"%x" % 255`                    | ff                  |
| %X           | Целое в шестнадцатеричном (заглавные)    | `"%X" % 255`                    | FF                  |
| %o           | Целое в восьмеричной системе             | `"%o" % 10`                     | 12                  |
| %c           | Один символ (по коду Unicode/числу)      | `"%c" % 65`                     | A                   |
| %%           | Символ процента                          | `"Скидка 50%%"`                 | Скидка 50%          |



## Дополнительно: ширина, выравнивание, нули

```python
print("'%10s'" % "hi")   # '        hi' (справа, ширина 10)
print("'%-10s'" % "hi")  # 'hi        ' (слева, ширина 10)
print("'%05d'" % 7)      # '00007' (число с нулями до 5 символов)
```

## Примеры

```python
s1 = "Hello %s" % "World"
print(s1)  # Hello World


s2 = "Name: %s, Age: %d" % ("Alice", 30)
print(s2)  # Name: Alice, Age: 30


s3 = "Name: %d, Age: %d" % ("Alice", 30)
print(s3)  # Name: Alice, Age: 30
#     s3 = "Name: %d, Age: %d" % ("Alice", 30)
#          ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~
# TypeError: %d format: a real number is required, not str


s4 = "Name: %s, Age: %d" % "Alice", 30
print(s4)
#     s4 = "Name: %s, Age: %d" % "Alice", 30
#          ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~
# TypeError: not enough arguments for format string
…

Проверьте себя: Почему s4 = "Name: %s, Age: %d" % "Alice", 30 падает с ошибкой «not enough arguments», хотя аргументов формально указано два?

Открыть файл →

MarkdownРазбор концепции69 строк

Метод str.format(): плейсхолдеры {} и спецификаторы

less_12__str_formatting/theory_02__method_format.md

Представляет .format() как более гибкую и безопасную замену C-style форматирования. Обширная таблица спецификаторов покрывает позиционные/именованные плейсхолдеры, ширину, выравнивание (>, <, ^), заполнение произвольным символом, форматирование чисел (:.2f, :,.2f с разделителем тысяч, :x, :e) и экранирование фигурных скобок {{ }}. Примеры показывают позиционные индексы {0}/{1} (в том числе в обратном порядке) и именованные {name}/{age}.

"{}".format("World") — базовая подстановка
"{0}, {1}".format(...) и "{1}, {0}".format(...) — позиционные индексы
"{name}, {age}".format(name=..., age=...) — именованные аргументы
":>10", ":<10", ":^10", ":*>10" — выравнивание и заполнение
":.2f", ":,.2f", ":06.2f" — форматирование чисел с плавающей точкой
Плюс формата: шаблон можно сохранить в переменную, тип указывать не нужно

Показать начало файла (69 строк всего)

# Метод `.format()`

Позволяет вставлять значения в строку, используя фигурные скобки `{}` как плейсхолдеры.
Считается более гибкий и безопасный (в плане ошибок), чем C-style (`%`).


## Таблица спецификаторов форматирования


| Формат     | Описание                                                                       | Пример кода                    | Результат    |
|------------|--------------------------------------------------------------------------------|--------------------------------|--------------|
| {var}      | Подставляет значение переменной                                                | `"{}" .format(name)`           | Alice        |
| {var:2}    | Минимальная ширина 2 символа, если значение шире — не обрезается               | `"{:2}".format('Alice')`       | 'Alice'      |
| {var:10}   | Минимальная ширина 10 символов, пробелы слева по умолчанию                     | `"{:10}".format('hi')`         | 'hi        ' |
| {var:>10}  | Выравнивание по правому краю, ширина 10                                        | `"{:>10}".format('hi')`        | '        hi' |
| {var:<10}  | Выравнивание по левому краю, ширина 10                                         | `"{:<10}".format('hi')`        | 'hi        ' |
| {var:^10}  | Выравнивание по центру, ширина 10                                              | `"{:^10}".format('hi')`        | '    hi    ' |
| {var:0>5}  | Число или строка, заполнение нулями слева, ширина 5                            | `"{:0>5}".format(7)`           | '00007'      |
| {var:*>10} | Заполнение любым символом (например `*`), ширина 10                            | `"{:*>10}".format('hi')`       | '********hi' |
| {expr}     | Любое выражение Python                                                         | `"{}".format(2+3)`             | 5            |
| {:2d}      | Целое число, минимальная ширина 2 символа, пробелы слева                       | `"{:2d}".format(5)`            | ' 5'         |
| {:02d}     | Целое число, ширина 2 символа, ведущие нули                                    | `"{:02d}".format(5)`           | '05'         |
| {:.2f}     | Число с плавающей точкой, 2 знака после точки                                  | `"{:.2f}".format(3.14159)`     | '3.14'       |
| {:,.2f}    | Число с плавающей точкой, 2 знака после точки, запятая - разделитель тысяч     | `"{:,.2f}".format(123456.789)` | '123,456.79' |
| {:6.2f}    | Число с плавающей точкой, ширина 6 символов, 2 знака после точки               | `"{:6.2f}".format(3.14159)`    | '  3.14'     |
| {:06.2f}   | Число с плавающей точкой, ширина 6 символов, 2 знака после точки, ведущие нули | `"{:06.2f}".format(3.14159)`   | '003.14'     |
| {:e}       | Экспоненциальная форма (с `e`)                                                 | `"{:e}".format(1500)`          | 1.500000e+03 |
| {:E}       | Экспоненциальная форма (с `E`)                                                 | `"{:E}".format(1500)`          | 1.500000E+03 |
| {:x}       | Шестнадцатеричное число (строчные)                                             | `"{:x}".format(255)`           | ff           |
| {:X}       | Шестнадцатеричное число (заглавные)                                            | `"{:X}".format(255)`           | FF           |
| {:o}       | Восьмеричное число                                                             | `"{:o}".format(10)`            | 12           |
| {:c}       | Символ Unicode по коду                                                         | `"{:c}".format(65)`            | A            |
| {{ }}      | Экранированные фигурные скобки                                                 | `"{{}}" .format()`             | {}           |
| {:05d}     | Целое число, ширина 5, ведущие нули                                            | `"{:05d}".format(7)`           | 00007        |


### Примеры:

```python
s1 = "Hello, {}".format("World")
print(s1)  # Hello, World


s2 = "Name: {0}, Age: {1}".format("Alice", 30)
print(s2)  # Name: Alice, Age: 30


s3 = "Name: {1}, Age: {0}".format(30, "Alice")
print(s3)  # Name: Alice, Age: 30


s4 = "Name: {name}, Age: {age}".format(name="Alice", age=30)
print(s4)  # Name: Alice, Age: 30


s5 = "Pi = {:.2f}".format(3.14159)   # 2 знака после точки
print(s5)  # Pi = 3.14
```

## Важные плюсы этого формата:
…

Проверьте себя: В чём разница между "{:2}".format('Alice') и "{:.2}".format('Alice') — что выведет каждый из них?

Открыть файл →

MarkdownРазбор концепции61 строк

f-строки: форматирование, вычисляемое сразу (Python 3.6+)

less_12__str_formatting/theory_03__f-string.md

Вводит f-строки как способ подставлять переменные и любые выражения Python прямо в плейсхолдер ({2+3}, {name.upper()}). Таблица спецификаторов почти идентична .format(), но записывается компактнее (f"{var:.2f}"). Ключевое отличие, выделенное отдельно, — f-строка вычисляется НЕМЕДЛЕННО в момент создания, поэтому в отличие от % и .format() её нельзя сохранить как шаблон для отложенной подстановки значений.

f"{name}", f"{2 + 3}" — переменные и произвольные выражения
f"{name.upper()} is {age} years" — вызов метода прямо в плейсхолдере
f"{pi:.2f}", f"{7:0>5}" — те же спецификаторы, что у .format()
Ключевое отличие: f-строка вычисляется сразу, шаблон отложенно не сохранить

Показать начало файла (61 строк всего)

# f-strings

Впервые появилось в Python 3.6. (2016)

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



## Таблица спецификаторов форматирования


| Формат     | Описание                                                                       | Пример кода            | Результат               |
|------------|--------------------------------------------------------------------------------|------------------------|-------------------------|
| {var}      | Подставляет значение переменной                                                | `f"{name}"`            | Alice                   |
| {var:2}    | Минимальная ширина 2 символа, если > 2 — игнорируется                          | `f"{'Alice':2}"`       | 'Alice'                 |
| {var:10}   | Минимальная ширина 10 символов, пробелы слева по умолчанию                     | `f"{'hi':10}"`         | <pre>'hi        '</pre> |
| {var:>10}  | Выравнивание по правому краю, ширина 10                                        | `f"{'hi':>10}"`        | <pre>'        hi'</pre> |
| {var:<10}  | Выравнивание по левому краю, ширина 10                                         | `f"{'hi':<10}"`        | <pre>'hi        '</pre> |
| {var:^10}  | Выравнивание по центру, ширина 10                                              | `f"{'hi':^10}"`        | <pre>'    hi    '</pre> |
| {var:0>5}  | Число или строка, заполнение нулями слева, ширина 5                            | `f"{7:0>5}"`           | '00007'                 |
| {var:*>10} | Заполнение любым символом (например `*`), ширина 10                            | `f"{'hi':*>10}"`       | '********hi'            |
| {expr}     | Любое выражение Python                                                         | `f"{2+3}"`             | 5                       |
| {:2d}      | Целое число, мин ширина 2 символа, пробелы слева                               | `f"{5:2d}"`            | ' 5'                    |
| {:03d}     | Целое число, ширина 2 символа, ведущие нули                                    | `f"{5:03d}"`           | '005'                   |
| {:.2f}     | Число с плавающей точкой, 2 знака после точки                                  | `f"{3.14159:.2f}"`     | '3.14'                  |
| {:,.2f}    | Число с плавающей точкой, 2 знака после точки, запятая - разделитель тысяч     | `f"{123456.789:,.2f}"` | '123,456.79'            |
| {:6.2f}    | Число с плавающей точкой, ширина 6 символов, 2 знака после точки               | `f"{3.14159:6.2f}"`    | '  3.14'                |
| {:06.2f}   | Число с плавающей точкой, ширина 6 символов, 2 знака после точки, ведущие нули | `f"{3.14159:06.2f}"`   | '003.14'                |
| {:e}       | Экспоненциальная форма (с `e`)                                                 | `f"{1500:e}"`          | 1.500000e+03            |
| {:E}       | Экспоненциальная форма (с `E`)                                                 | `f"{1500:E}"`          | 1.500000E+03            |
| {:x}       | Шестнадцатеричное число (строчные)                                             | `f"{255:x}"`           | ff                      |
| {:X}       | Шестнадцатеричное число (заглавные)                                            | `f"{255:X}"`           | FF                      |
| {:o}       | Восьмеричное число                                                             | `f"{10:o}"`            | 12                      |
| {:c}       | Символ Unicode по коду                                                         | `f"{65:c}"`            | A                       |
| {{ }}      | Экранированные фигурные скобки                                                 | `f"{{}}"`              | {}                      |




### Примеры:

```python
name = "Alice"
age = 30
f"Name: {name}, Age: {age}"

pi = 3.14159
f"Pi rounded: {pi:.2f}"          # Pi rounded: 3.14
f"2 + 3 = {2 + 3}"                # 2 + 3 = 5
f"{name.upper()} is {age} years"  # ALICE is 30 years
```

---

## Важное отличие от `%` и `.format()`

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

Попытка сохранить шаблон `template = f"Hello, {name}"` без предварительного объявления  переменной `name`  
…

Проверьте себя: Почему нельзя написать template = f"Hello, {name}" до объявления переменной name, и получится ли это сделать с обычной строкой и .format()?

Открыть файл →

MarkdownРазбор концепции56 строк

center/ljust/rjust: выравнивание строки в поле фиксированной ширины

less_12__str_formatting/theory_04__methods__center__ljust__rjust.md

Три метода выравнивания текста в поле заданной ширины с опциональным символом заполнения (по умолчанию пробел): center() по центру, ljust() по левому краю (заполнение справа), rjust() по правому краю (заполнение слева). В конце файла те же результаты получены альтернативным способом — через спецификаторы f-строк (:*^10, :*<10, :*>10), чтобы показать эквивалентность двух подходов.

"hi".center(10) и "hi".center(10, '*') — центрирование
"hi".ljust(10, '*') — левое выравнивание, заполнение справа
"hi".rjust(10, '*') — правое выравнивание, заполнение слева
f"{s:*^10}", f"{s:*<10}", f"{s:*>10}" — та же логика через f-строки

Показать начало файла (56 строк всего)

## Таблица методов выравнивания строк


| Метод             | Описание                                                        | Пример кода                       | Результат      |
|------------------|-----------------------------------------------------------------|-----------------------------------|----------------|
| str.center(width) | Центрирование строки в поле ширины `width`, пробелы слева и справа | `"hi".center(10)`                | `'    hi    '` |
| str.center(width, fillchar) | Центрирование с заполнением символом `fillchar`          | `"hi".center(10, '*')`           | `'****hi****'` |
| str.ljust(width)  | Выравнивание по левому краю, пробелы справа                     | `"hi".ljust(10)`                  | `'hi        '` |
| str.ljust(width, fillchar) | Левое выравнивание с заполнением символом `fillchar`      | `"hi".ljust(10, '*')`             | `'hi********'` |
| str.rjust(width)  | Выравнивание по правому краю, пробелы слева                     | `"hi".rjust(10)`                  | `'        hi'` |
| str.rjust(width, fillchar) | Правое выравнивание с заполнением символом `fillchar`     | `"hi".rjust(10, '*')`             | `'********hi'` |



## Примеры

```python
s = "hi"

# Центрирование
print(s.center(10))          # '    hi    '
print(s.center(10, '*'))     # '****hi****'

# Левое выравнивание
print(s.ljust(10))           # 'hi        '
print(s.ljust(10, '*'))      # 'hi********'

# Правое выравнивание
print(s.rjust(10))           # '        hi'
print(s.rjust(10, '*'))      # '********hi'
```

---

## Альтернатива через f-строки

В f-строках есть аналогичные спецификаторы выравнивания и заполнения:

```python
s = "hi"

# Центрирование
print(f"{s:*^10}")   # '****hi****'

# Левое выравнивание
print(f"{s:*<10}")   # 'hi********'

# Правое выравнивание
print(f"{s:*>10}")   # '********hi'
```

* `^` → центр
* `<` → слева
* `>` → справа
* символ перед выравниванием → заполнение (по умолчанию пробел)

Проверьте себя: Что означают символы ^, < и > в спецификаторе f-строки f"{s:*^10}" и как они связаны с методами center/ljust/rjust?

Открыть файл →