{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python для сбора данных\n",
    "\n",
    "*Алла Тамбовцева, НИУ ВШЭ*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Форматирование строк (продолжение)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно выделить три способа форматировать строки (последний – достаточно новый):\n",
    "    \n",
    "* с помощью оператора `%` (разбирали на занятии)\n",
    "* с помощью метода `.format()`\n",
    "* с помощью *f-strings*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Форматирование с помощью метода `.format()`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Рассмотрим тот же пример, что и на занятии: попросим пользователя ввести с клавиатуры свое имя и возраст."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите Ваше имя: Алла\n",
      "Введите Ваш возраст: 24\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Введите Ваше имя: \")\n",
    "age = int(input(\"Введите Ваш возраст: \")) # возраст будет целочисленным"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А теперь подставим их в шаблон такого вида:\n",
    "\n",
    "    Ваше имя: `имя`. Ваш возраст: `возраст`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваше имя: Алла. Ваш возраст: 24.\n"
     ]
    }
   ],
   "source": [
    "result = \"Ваше имя: {}. Ваш возраст: {}.\".format(name, age)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как можно заметить, подстановка значений с помощью `.format()` выглядит чуть проще, чем базовая с использованием оператора `%`: достаточно поставить `{}` на место пропусков, которые необходимо заполнить, и перечислить соответствующие переменные в скобках в `.format()`. Этот способ удобен тем, что не нужно задумываться о типах переменных, Python сам все распознает и поставит. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваше имя: Алла. Ваш возраст: 24.\n"
     ]
    }
   ],
   "source": [
    "# то же, но без создания result\n",
    "print(\"Ваше имя: {}. Ваш возраст: {}.\".format(name, age))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А теперь добавим рост. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите Ваш рост (в метрах): 1.68\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.68"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "height = float(input(\"Введите Ваш рост (в метрах): \"))\n",
    "height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваше имя: Алла. Ваш возраст: 24. Ваш рост 1.68 м. \n"
     ]
    }
   ],
   "source": [
    "print(\"Ваше имя: {}. Ваш возраст: {}. Ваш рост {} м. \".format(name, age, height))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Интересно то, что при подстановке значений с плавающей точкой через `.format()` Python выводит число «как есть», без лишних нулей в дробной части. Но при желании число знаков после точки все же можно настроить."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваше имя: Алла. Ваш возраст: 24. Ваш рост 1.7 м. \n"
     ]
    }
   ],
   "source": [
    "print(\"Ваше имя: {}. Ваш возраст: {}. Ваш рост {:.1f} м. \".format(name, \n",
    "                                                        age, height)) # один знак {:.1f}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Удобство такого способа форматирования ещё в том, что соблюдать порядок аргументов в `format()` (переменных для подстановки в круглых скобках) совсем необязательно. Можно просто указать их названия внутри фигурных скобок на месте пропусков, и тогда перечислять переменные как угодно, но немного в ином виде:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваше имя: Алла. Ваш возраст: 24. Ваш рост 1.68 м. \n"
     ]
    }
   ],
   "source": [
    "# в строке: name age height\n",
    "# в format(): age name height\n",
    "\n",
    "print(\"Ваше имя: {name}. Ваш возраст: {age}. Ваш рост {height} м. \".format(age = age, \n",
    "                                                                 name = name,\n",
    "                                                                 height = height))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При таком формате подстановки мы приравниваем метки в левой части (в `{}`) к значениям переменных в правой части (в `format`). Отсюда эти равенства `age = age`, `name = name` и `height = height`. \n",
    "\n",
    "Рассмотрим еще один пример. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваше имя: Алла. Ваш рост 168 см.\n"
     ]
    }
   ],
   "source": [
    "height_cm = 168 # рост в см\n",
    "print(\"Ваше имя: {n}. Ваш рост {h} см.\".format(n = name, h = height_cm))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Этот пример показывает, что метки в фигурных скобках необязательно должны совпадать с названиями переменных (пары `n = name`, `h = height_cm`).  Об этих парах можно думать, используя такую аналогию: метки в фигурных скобках – это ярлыки, а сами переменные – это папки. Названия ярлыков не всегда совпадают с названиями папок: мы можем назвать ярлык *В поисках себя*, а ссылаться он будет на папку *Курсовая*. Однако, несмотря на разные названия, кликнув по ярлыку, мы придем в нужную папку, потому что при создании ярлыка было создано соответствие *В поисках себя* = *Курсовая*. Что и происходит в нашем случае с метками и переменными."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Еще одна интересная особенность форматирования строк таким способом – это возможность делать отступы и выравнивать текст. Для примера будем выводить на экран только имя. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваше имя: Алла\n"
     ]
    }
   ],
   "source": [
    "print('Ваше имя: {}'.format(name)) # просто выводим на экран"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью специального символа `>` мы выравниваем текст по правому краю. Достаточно указать, сколько символов в итоге должно быть выведено на экран (например, 20):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваше имя:                 Алла\n"
     ]
    }
   ],
   "source": [
    "print('Ваше имя: {:>20}'.format(name)) # 20 символов, из них четыре заняты именем"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваше имя: ::::::::::::::::::::\n",
      "Ваше имя:                 Алла\n"
     ]
    }
   ],
   "source": [
    "print('Ваше имя: ::::::::::::::::::::') # для сравнения 20 двоеточий (пробелов)\n",
    "print('Ваше имя: {:>20}'.format(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А с помощью символа `^` можно выравнивать текст по центру:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваше имя:         Алла        \n"
     ]
    }
   ],
   "source": [
    "print('Ваше имя: {:^20}'.format(name)) # выравнивание по центру"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С методом `.format()` связано много интересных вещей. Почитать и попрактиоваться можно, например, [здесь](https://pyformat.info/) и [здесь](https://pythonworld.ru/osnovy/formatirovanie-strok-metod-format.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Форматирование строк с помощью f-strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Строки *f-strings* (*formatted string literals*) – довольно новое изобретение, появились в Python 3.6. С их помощью подставлять значения в текстовый шаблон можно ещё более лаконичным образом: вписывать название переменной в фигурные скобки, не забыв поставить `f` прямо перед кавычками, открывающими строку."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Алла\"\n",
    "print(f\"Ваше имя: {name}.\") # просто подставляем название переменной в f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно про *f-strings* можно почитать [в официальной документации](https://docs.python.org/3/reference/lexical_analysis.html#f-strings)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Внимание:** этот способ доступен только в Python 3.6. Если у вас стоит более раняя версия, и Вы поняли, что жить не можете без *f-strings*, можно воспользоваться хитростью: поставить библиотеку [future-strings](https://github.com/asottile/future-fstrings). Единственное, этот обходной путь не работает в Jupyter Notebook, только в консоли. Но тут поможет магия:) В Jupyter Notebook есть magic-команды. Одна из таких команд ‒`%%bash` ‒ позволяет запускать ячейку Jupyter Notebook в режиме командной строки (как будто мы работаем не в Jupyter, а в командной строке). Далее по шагам:\n",
    "\n",
    "1. Создать файл fs.py (любой файл с расширением `.py`).\n",
    "2. Вписать в него строку с -*- coding и код, который нужно прогнать:\n",
    "\n",
    "   ``` \n",
    "   # -*- coding: future_fstrings -*-\n",
    "   name = \"Алла\"\n",
    "   print(f\"Ваше имя: {name}.\")```\n",
    "   \n",
    "3. Запустить следующую ячейку."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваше имя: Алла.\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "\n",
    "python3 fs.py"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}