{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table align=right>\n",
    "    <tr>\n",
    "        <td align=center>\n",
    "            <font size=4>Технология программирования и практикум на ЭВМ</font> \n",
    "        </td>\n",
    "        <td align=right>\n",
    "<img src=\"logoMM.png\" align=right width=120>\n",
    "        </td>\n",
    "    </tr>\n",
    "    </table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Элементы программы на Python\n",
    "\n",
    "Программа (или скрипт) представляет собой последовательность **определений** и **команд**\n",
    "- Определения обрабатываются и команды выполняются в специальной **среде** (оболочка, *shell*)\n",
    "- Они могут быть набраны прямо в оболочке, или сохранены в файле, который впоследствии может быть загружен в оболочку и выполнен\n",
    "\n",
    "**Команда** (или **оператор**) – инструкция интерпретатору осуществить то или иное действие"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Объекты\n",
    "\n",
    "Суть работы программы – манипулирование с данными, обработка объектов, содержащих данные.\n",
    "\n",
    "Каждый такой объект имеет важную характеристику – **тип**, определяющий, что за данные он содержит, и какие операции к нему применимы.\n",
    "\n",
    "Основная классификация объектов:\n",
    "- Скалярные (их нельзя разделить на составные части)\n",
    "- Не скалярные (составные, имеющие внутреннюю структуру, к которой можно получить доступ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Скалярные объекты\n",
    "\n",
    "`int` – целые числа (5, -23, 1234567890)  \n",
    "`float` – действительные числа (3.14, 9.81, 1.2e-5)  \n",
    "`bool` – используется для представления двух логических значений: `True` (истина) и `False` (ложь)  \n",
    "\n",
    "Встроенная функция `type` служит для определения типа объекта\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Выражения\n",
    "\n",
    "**Объекты** и **знаки операций** объединяются в **выражения**, каждое из которых представляет собой объект определенного типа\n",
    "\n",
    "Синтаксис простейшего выражения:  \n",
    "$<$ **объект** $>$\n",
    "$<$ **знак операции** $>$\n",
    "$<$ **объект** $>$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Операции с числовыми объектами\n",
    "\n",
    "`a + b` –  сумма. Если оба числа – целые, то результат – объект `int`, в остальных случаях результат – `float`\n",
    "\n",
    "`a – b` – разность\n",
    "\n",
    "`a * b` – произведение\n",
    "\n",
    "`a/b`   – частное (в Python 3 всегда `float`)\n",
    "\n",
    "`a//b`  – результат деления нацело  \n",
    "`a % b`   – остаток от деления\n",
    "\n",
    "В двух предыдущих операциях, как правило, `a` и `b` – `int`, результат - `int`\n",
    "\n",
    "`a**b`  – возведение в степень, $a^b$.\n",
    "\n",
    "**Порядок действий:**\n",
    "- Сначала выражения в скобках\n",
    "- Потом слева направо:\n",
    "\n",
    "```python\n",
    "**\n",
    "*, /\n",
    "+, -\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10**100//2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Исключение: возведение в степень выполняется справа налево:\n",
    "\n",
    "`2**3**2` $-$ это $2^{3^2}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "512"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**3**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2**3)**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Операции сравнения\n",
    "```python\n",
    "    a > b\n",
    "    a >= b\n",
    "    a < b\n",
    "    a <= b\n",
    "    a == b\n",
    "    a != b\n",
    "``` \n",
    "\n",
    "Результат сравнения - истина или ложь, `True`  или `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 == 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Операции с объектами логического типа\n",
    "\n",
    "```python\n",
    "    a and b  (результат True, если оба аргумента истинны)\n",
    "    a or b   (результат True, если хотя бы один аргумент истинен)\n",
    "    not a    (противоположное значение)\n",
    "``` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Преобразование типов (type casting)\n",
    "\n",
    "На основе объекта одного типа может быть создан объект другого типа. \n",
    "Для преобразования используется имя типа."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(3.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Что получится?\n",
    "bool(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Переменные и значения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "394.0810495999999"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi = 3.14159\n",
    "radius = 11.2\n",
    "area = pi*(radius**2)\n",
    "area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Что происходит с памятью:\n",
    "\n",
    "<img src='memory1.png' width=300>\n",
    "\n",
    "Сначала в памяти создается объект $-$ результат вычислений, а потом он получает **имя**, позволяющее программе получать доступ к этому объекту.\n",
    "\n",
    "**Важно**: имя, или переменная, получает тип в момент присваивания выражению в правой части. Это $-$ **динамическая типизация**.\n",
    "\n",
    "Другой вариант (в других языках программирования): тип переменной определяется в программе в момент ее описания и не может быть изменен. Область памяти для хранения значения такой переменной тоже выделяется в момент ее описания (с некоторыми оговорками). Это $-$ **статическая типизация**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Изменение значения переменной"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "394.0810495999999"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "radius = 14.3\n",
    "area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='memory2.png' width=300>\n",
    "\n",
    "Обратите внимание на оставшееся в памяти неиспользуемое значение 11.2. Оно \"засоряет память\", является \"мусором\". Его сборкой занимается специальная программа $-$ сборщик мусора (garbage collector)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!!! Про допустимые и недопустимые имена переменных поговорим чуть позже"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Пример нескалярного объекта: строки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'123'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc'\n",
    "\"abc\"\n",
    "'''Привет!\n",
    "В этой строке - \n",
    "сразу три строчки'''\n",
    "'123'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Некоторые операции\n",
    "\n",
    "(будем подробно изучать позже)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('123')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'мехмат'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'мех' + 'мат'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AAA'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'A'*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'100'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('100')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Оператор вывода\n",
    "\n",
    "Команды могут выполняться в shell, но **программой** будем называть текст на Питон, сохраненный в файле.\n",
    "\n",
    "*В виде исключения в дальнейшем программой часто будем\n",
    "называть и код, содержащийся в одной ячейке среды Jupyter Notebook.\n",
    "Обычно такой код должен удовлетворять дополнительным правилам: в\n",
    "нем должно быть несколько действий, в том числе получение каких-то\n",
    "данных от пользователя и вывод результатов расчетов.*\n",
    "\n",
    "В случае выполнения команды в shell результат выполнения сразу выводится на экран. В случае программы требуется специальный оператор: оператор вывода"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "1872\n",
      "I'll be back!\n",
      "Привет!\n",
      "В этой строке - \n",
      "сразу три строчки\n"
     ]
    }
   ],
   "source": [
    "# Примеры\n",
    "print('hello')\n",
    "print(156*12)\n",
    "print(\"I'll\", \"be\", \"back!\")\n",
    "print('''Привет!\n",
    "В этой строке - \n",
    "сразу три строчки''')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Общий вид\n",
    "\n",
    "```python\n",
    "print(a, b, ..., end='\\n', sep=' ')\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ввод данных\n",
    "\n",
    "- Простейший способ взаимодействия программы с пользователем: запрос ввода каких-то данных\n",
    "- Такой ввод осуществляется в Python с помощью функции `input()`\n",
    "- Ее результат имеет тип `str`, поэтому необходимо преобразование типа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Как Вас зовут?  М. И.\n",
      "Сколько Вам лет? 61\n",
      "Каков Ваш вес в кг? 91.5\n"
     ]
    }
   ],
   "source": [
    "name = input('Как Вас зовут?  ')\n",
    "age = int(input('Сколько Вам лет? '))\n",
    "weight = float(input('Каков Ваш вес в кг? '))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "61\n"
     ]
    }
   ],
   "source": [
    "print(age)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Перед тем, как начать программировать...\n",
    "\n",
    "<img src='monk.jpg' align=center width=400>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Дзен Питона\n",
    "\n",
    "- Красивое лучше, чем уродливое. \n",
    "- Явное лучше, чем неявное.\n",
    "- Простое лучше, чем сложное.\n",
    "- Сложное лучше, чем запутанное.\n",
    "- Плоское лучше, чем вложенное.\n",
    "- Разреженное лучше, чем плотное.\n",
    "- Читаемость имеет значение.\n",
    "- Особые случаи не настолько особые, чтобы нарушать правила.\n",
    "- При этом практичность важнее безупречности.\n",
    "- Ошибки никогда не должны замалчиваться.\n",
    "- Если они не замалчиваются явно.\n",
    "- Встретив двусмысленность, отбрось искушение угадать.\n",
    "- Должен существовать один и, желательно, только один очевидный способ сделать это.\n",
    "- Хотя он поначалу может быть и не очевиден, если вы не голландец.\n",
    "- Сейчас лучше, чем никогда.\n",
    "- Хотя никогда зачастую лучше, чем прямо сейчас.\n",
    "- Если реализацию сложно объяснить — идея плоха.\n",
    "- Если реализацию легко объяснить — идея, возможно, хороша.\n",
    "- Пространства имён — отличная штука! Будем делать их больше!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Стиль кода:\n",
    "\n",
    "<div align=center>\n",
    "    <a href = \"https://pep8.ru/doc/pep8/\">\n",
    "        PEP8 - стиль кода в языке Python</a> <br><br>\n",
    "   <a href = \"https://www.python.org/dev/peps/pep-0008/\"> \n",
    "    PEP 8 -- Style Guide for Python Code! </a> \n",
    "</div>    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Правила именования переменных\n",
    "\n",
    "<img src=\"camel.png\" align=right width=120>\n",
    "\n",
    "- Имена переменных, функций, методов:  \n",
    "`lower_case_with_underscores`\n",
    "- Константы:  \n",
    "`ALL_CAPS`\n",
    "- Имена Классов:  \n",
    "`CapitalizeWords` (он же `StudlyCaps`)\n",
    "- В крайнем случае (для совместимости с уже имеющимся кодом):  \n",
    "`mixedCase` (он же `camelCase`)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Имена, которых следует избегать\n",
    "**Никогда** не используйте символы   \n",
    "`l` (маленькая латинская буква «эль»),   \n",
    "`O` (заглавная латинская буква «о»),  \n",
    "`I` (заглавная латинская буква «ай») /   \n",
    "как однобуквенные идентификаторы.\n",
    "\n",
    "В некоторых шрифтах эти символы неотличимы от цифры один и нуля (и символа вертикальной палочки). \n",
    "\n",
    "Если очень-очень нужно использовать имя переменной из одной буквы `l`, пишите вместо неё заглавную `L`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Имена переменных ни в коем случае не должны совпадать с ключевыми словами языка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}