{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Python\n",
"\n",
"## Вводная лекция\n",
"\n",
"### Раздел 1. Общие соображения\n",
"\n",
"#### Мотивация для изучения Python\n",
"\n",
"Несколько плюсов языка Python:\n",
"\n",
"- Python - один из самых широко используеммых языков программирования. В рейтингах популярности и востребованности языков он давно уже не опускается ниже 5 позиции.\n",
"\n",
"- Python очень гибкий с точки зрения используеммых конструкций и подходов. Он позволяет вам писать классический императивный (процедурный код), объектно-ориентированный код, функциональный код или любую их комбинацию. Эта особенность способствует очень высокой скорости разработки (при этом, на мой взгляд, снижает читаемость по сравнению с \"чистыми\" языками программирования, где есть возможность придерживаться только одной парадигмы).\n",
"\n",
"- Python очень требователен к оформлению кода по сравнению с другими языками программирования. К тому же, есть документ [PEP 8](https://www.python.org/dev/peps/pep-0008/), который содержит соглашения относительно оформления кода, которые не являются обязательными, но строго рекомендуются к исполнению. Все это влечет к простоте прочтения кода на Python.\n",
"\n",
"- Python обладает невероятно большим списком областей применения: утилитарные скрипты; анализ, обработка, хранение, визуализация и передача данных; web- и сетевое программирование; программирование приложений для desktop- и mobile-систем; web-scrapping, offensive-security и тестирование приложений; программирование микроконтроллеров — и многие другие задачи могут быть эффективно решены при помощи Python.\n",
"\n",
"Основными недостатками Python можно назвать:\n",
"\n",
"- Ограниченный набор базовых конструкций языка и ограниченный функционал стандартной библиотеки.\n",
"\n",
"- Низкая скорость выполнения кода.\n",
"\n",
"- Реализация многих реальных механизмов взаимодействия в коде скрывается \"под капотом\" от пользователя.\n",
"\n",
"#### Литература для этого курса\n",
"\n",
"Единственная книга, которая является обязательной для этого курса:\n",
"\n",
"**Programming in Python 3 : a complete introduction to the Python language / Mark Summerfield. — 2nd ed.**\n",
"\n",
"В природе существует ее *перевод на русский язык*.\n",
"\n",
"Еще книги, которые будут полезны:\n",
"\n",
"- **Learning Python, Fifth Edition by Mark Lutz** — какое-то издание точно переведено на русский.\n",
"\n",
"- **Python Pocket Reference, Fifth Edition by Mark Lutz** — какое-то издание точно переведено на русский.\n",
"\n",
"- **Python Cookbook, Second Edition Edited by Alex Martelli, Anna Martelli Ravenscroft, and David Ascher** — не встречал, но наверняка есть перевод.\n",
"\n",
"- Любая другая литература, которую найдете (с некоторыми оговорками).\n",
"\n",
"#### Темы и модули, которые будут затронуты в этом курсе.\n",
"\n",
"В ходе этих лекций мы постараемся затронуть как можно больше областей и модулей, поэтому характер изучения конкретных модулей может оказаться весьма поверхностным. Приведенный ниже список не является исчерпывающим.\n",
"\n",
"##### Работа с данными (получение, передача, хранение, выборка, визуализация)\n",
"\n",
"- sqlite3;\n",
"- MySQLdb;\n",
"- psycopg2;\n",
"- pymongo;\n",
"- Pandas;\n",
"- Vedis;\n",
"- matplotlib;\n",
"- bokeh.\n",
"\n",
"##### Обработка данных\n",
"\n",
"- NumPy;\n",
"- SymPy;\n",
"- SciPy.\n",
"\n",
"*Более подробное изучение этой области смотрите в курсе \"Машинное обучение на Python\" (ссылка появится позже)*\n",
"\n",
"##### Web\n",
"\n",
"- pika;\n",
"- CherryPy;\n",
"- Django;\n",
"- Flask;\n",
"- Sphinx.\n",
"\n",
"##### Тестирование\n",
"\n",
"- selenium.\n",
"\n",
"##### Web-scrapping\n",
"\n",
"- BeautifulSoup;\n",
"- scrapy.\n",
"\n",
"#### Варианты установки и запуска Python\n",
"\n",
"На момент написания курса у меня стоит версия Python 3.6.5, на нее и будем ориентироваться.\n",
"\n",
"Основных способов написания Python-кода 3:\n",
"\n",
"1. Скачать один из дистрибутивов, который будет содержать сразу IDE и интерпретатор.\n",
"\n",
"2. Скачать отдельно интерпретатор и писать код в текстовом редакторе или IDE по выбору.\n",
"\n",
"3. Пользоваться сервисом Jupyter с онлайн-доступом, ничего не скачивая.\n",
"\n",
"##### 1. Дистрибутивы\n",
"\n",
"- [Официальный дистрибутив с IDLE](https://www.python.org/downloads/).\n",
"- [Anaconda — очень популярный дистрибутив](https://www.anaconda.com/download/).\n",
"- [Python(x, y) — дистрибутив, ориентированный на научные вычисления и визуализацию](https://python-xy.github.io/).\n",
"\n",
"##### 2. Интерпретатор\n",
"\n",
"В Windows скачиваем [официальный дистрибутив](https://www.python.org/downloads/), после чего создаем свои файлы с расширением .py и запускаем в командной строке команду python, передавая ей в качестве аргумента путь (абсолютный или относительный) к файлу .py.\n",
"\n",
"В Linux-based системах, скачиваем пакет python3 (иногда называется python) с помощью своего пакетного менеджера, после чего создаем свои файлы с расширением .py и запускаем в командной строке команду python3 (или python), передавая ей в качестве аргумента путь (абсолютный или относительный) к файлу .py. Также необходимо поставить менеджер пакетов для python — pip (как правило, пакет python3-pip).\n",
"\n",
"Сам интерпретатор можно запустить и без аргументов, тогда он запустится в интерактивном режиме.\n",
"\n",
"После того, как вы установили интерпретатор, вы можете воспользоваться любым удобным IDE (самые популярные: PyCharm и Visual Studio) или текстовым редактором (neovim, spacemacs, Sublime, Atom, Visual Studio Code и др.).\n",
"\n",
"##### 3. Jupyter notebook\n",
"\n",
"Jupyter можно [использовать онлайн без установки](http://jupyter.org/try). Просто загрузите свой iPython notebook файл и эксперементируйте!\n",
"\n",
"#### Где искать информацию?\n",
"\n",
"Загугли!\n",
"\n",
"Если не получилось загуглить — спроси в канале Slack #python.\n",
"\n",
"Стесняешься спросить — напиши мне в личку в ВК, телеге, твиттере или слаке (@devsagul).\n",
"\n",
"Совсем не стесняешься спросить — сделай mention в твиттере, может отвечу :)\n",
"\n",
"#### Куда слать домашку?\n",
"\n",
"Если ты вдруг что-то сделал и хочешь похвастаться — залей на github или gitlab, а ссылку присылай мне. Как прислать? Смотри пункт выше + почта [s.guliaev@lambda-it.ru](mailto:s.guliaev@lambda-it.ru)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Раздел 2. It's time to get our hands dirty или императивное (процедурное) программирование в Python\n",
"\n",
"#### Hello, World!\n",
"\n",
"Изучение любого языка программирования начинается с программы \"Hello, World!\", давайте не отходить от этой славной традиции:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello, World!\n"
]
}
],
"source": [
"print(\"Hello, World!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Сразу можно отметить, что функция вывода сообщения на экран в Python вызывается как совершенно обычная функция. Также видно, что никаких точек запятой после завершения утверждения нет. В Python точка с запятой используется только для разделения нескольких утверждений на одной строке."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Типы данных в Python\n",
"\n",
"Python содержит огромное количество разнообразных типов данных, но пока мы сосредоточим свое внимание на двух из них:\n",
"целочисленный и строковый тип. Целочисленный тип обозначается ключевым словом int, а строковый — ключевым словом str. Исходя из названия, легко понять, что целочисленный тип предназначен для хранения целых чисел, а строковый — строковых литералов. Вот примеры нескольких литералов:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'It is really useful, что можно использовать символы Юникода в строковых литералах. Εύρηκα!'"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"123\n",
"3141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067\n",
"0\n",
"-12\n",
"\"Hello, World!\"\n",
"'I prefer Python over PHP'\n",
"''\n",
"'It is really useful, что можно использовать символы Юникода в строковых литералах. Εύρηκα!'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Как можно заключить по второму числу, тип int в Python не ограничен каким-то конкретным размером, а зависит от объема памяти на вашем компьютере. Строковые литералы можно заключать в одинарные или двойные кавычки и использовать в них символы Юникода. Пустая строка обозначается просто парой кавычек."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Строки в Python можно рассматривать как массивы символов. Следовательно, для них есть операции получения элемента по индексу и получения среза:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"N\n",
"Do\n",
"P\n"
]
}
],
"source": [
"print(\"The New York Times\"[4])\n",
"print(\"Hot Dogs\"[4:6])\n",
"print(\"Python\"[0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Нумерация индексов начинается с нуля, отрицательные индексы отсчитываются с конца в обратном направлении. Более подробно операция получения среза будет рассмотрена позже."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Для перевода данных их одного типа в другой, нужно вызвать этот тип данных в качестве функции и передать ему значение, которое будем переводить:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1605"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"int('45')\n",
"str(10000)\n",
"int(' 1605 ')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Как видно из последнего примера, int при переводе строкового литерала удаляет все лидирующие и завершающие пробельные символы."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Переменные\n",
"\n",
"Python — язык со слабой (утиной) типизацией. Более того, нет необходимости указывать тип переменной. Более того, переменная может принять значение любого другого типа в любой момент:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"x = 1605\n",
"x = \"November fifth\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Соглашения относительно именования различных сущностей можно посмотреть в [PEP 8](https://www.python.org/dev/peps/pep-0008/#naming-conventions)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Типы данных-коллекции\n",
"\n",
"Все типы данных в Python делятся на *изменяемые* и *неизменяемые*. Многие типы, которые мы будем рассматривать, можно будет разделить на пары, очень близкие по смыслу, но отличающиеся только тем, что одни изменяемы, а другие — нет. С практической точки зрения, неизменяемые типы необходимы для того, чтобы их можно было хешировать.\n",
"\n",
"Первая коллекция которую мы рассмотрим — *кортежи*. Кортежи — неизменяемые упорядоченные последовательности элементов. Для получения кортежа можно просто выражения через запятую:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('HTML', 'CSS', 'JavaScript')"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"HTML\", \"CSS\", \"JavaScript\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Также кортежи могут быть заключены в скобки. Для создания кортежа из одного элемента необходимо поставить запятую, даже если мы заключаем его в скобки:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('React',)"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"React\","
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('Vue',)"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(\"Vue\", )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Для создания пустого кортежа необходимо поставить скобки:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"()"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Списки — очень близкие родственники кортежей, но они изменяемы. Для создания списка необходимо перечислить его элементы в квадратных скобках через запятую:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[4, 8, 15, 16, 23, 42]\n",
"['Rust', 'Haskell', 'Racket']\n",
"[-12, 'Farenheit', 451]\n",
"[]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Последний пример — создание пустого списка."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Для получения количества элементов в коллекции используется функция len:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(['Rust', 'Haskell', 'Racket'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Для добавления элемента в список можно использовать метод append:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Harris', 'Summerfield', 'Tanenbaum', 'Ritchie']\n"
]
}
],
"source": [
"x = ['Harris', 'Summerfield']\n",
"x.append('Tanenbaum')\n",
"list.append(x, 'Ritchie')\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Как и было сказано выше, у коллекций есть возможность обращаться к элементу по индексу:"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Summerfield'"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = ['Harris', 'Summerfield']\n",
"x[1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Логические операторы\n",
"\n",
"Оператор тождественности (идентичности), или оператор is, проверяет, являются ли две сущности ссылками на один объект:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"True\n"
]
}
],
"source": [
"a = [451, \"Farenheit\"]\n",
"b = [451, \"Farenheit\"]\n",
"print(a is b)\n",
"b = a\n",
"print(a is b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Наиболее распространенный способ использования оператора is — сравнение со встроенным Null-объектом, None:"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False True\n"
]
}
],
"source": [
"a = 100\n",
"b = None\n",
"print(a is None, b is None)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Операторы сравнения\n",
"\n",
"В питоне присутствует вполне обычный набор операторов сравнения:\n",
"\n",
"- < — меньше;\n",
"\n",
"- <= — меньше или равно;\n",
"\n",
"- == — равно;\n",
"\n",
"- != — не равно;\n",
"\n",
"- \\>= — больше или равно;\n",
"\n",
"- \\> — больше."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(True, True, False, False)"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2 < 3, 4 != 16, 1 >= 8, 8 > 12"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Оператор вхождения\n",
"\n",
"Для типов данных, которые являются наборами данных, существует проверка на вхождение:"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True False True False\n"
]
}
],
"source": [
"Nebuchadnezzar = ['Neo', 'Trinity', 'Morpheus', 'Mouse',\n",
" 'Dozer', 'Tank', 'Cypher', 'Apoc', 'Switch']\n",
"print('Neo' in Nebuchadnezzar, 'Smith' in Nebuchadnezzar,\n",
" 'V' in 'Vendetta', 'Я' in 'Команда')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Логические операторы\n",
"\n",
"В Python есть следующие логические операторы:\n",
"\n",
"- not — логическое НЕ;\n",
"\n",
"- or — логическое ИЛИ;\n",
"\n",
"- and — логическое И;"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True False\n",
"False True True\n",
"False False True\n"
]
}
],
"source": [
"print(not False, not True)\n",
"print(False or False, False or True, True or True)\n",
"print(False and False, False and True, True and True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Выражения, контролирующие порядок выполнения программы\n",
"\n",
"Конструкции, которые мы изучили на данный момент, хоть и позволяют строить простейшие программы, но все же предоставляют весьма ограниченный инструментарий. Нам необходимы конструкции, которые позволяют анализировать ход выполнения программы и передавать управления тем или иным инструкциям. Сейчас мы рассмотрим ветвление, циклы и исключения.\n",
"\n",
"\n",
"##### Ветвление (if, if-else, if-elif, if-elif-else)\n",
"\n",
"Конструкция ветвления if позволяет проверить выполнение условия и, в зависимости от того, является ли утверждение истинным, выполнить тот или иной блок операторов:"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Don't worry, everythin is alright!\n"
]
}
],
"source": [
"if 'PHP' is 'Viable Programming Language':\n",
" print('It must be snowing!')\n",
"else:\n",
" print(\"Don't worry, everythin is alright!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Обратите внимание, что вложенный блок отделяется четыремя пробелами. Так в Python форматируются все вложенные блоки, что позволяет писать крайне читаемый код без каких-либо фигурных скобок.\n",
"\n",
"Конструкция if предусматривает использование без else. К тому же между if и else можно расположить любое количество elif (сокращенный вариант словосочетания \"else if\"). В таком случае также можно опустить последний else:"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"I don't know that color!\n"
]
}
],
"source": [
"color = 'magenta'\n",
"\n",
"if color == 'blue':\n",
" print('Color is blue!')\n",
"elif color == 'red':\n",
" print('Color is red!')\n",
"elif color == 'green':\n",
" print('Color is green!')\n",
"else:\n",
" print(\"I don't know that color!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Цикл с предусловием (while)\n",
"\n",
"Конструкция while позволяет проверять на истинность некоторое выражение и выполнять некоторый блок кода, пока это выражение является истинным:"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"100\n"
]
}
],
"source": [
"i = 1\n",
"while i < 100:\n",
" i += 1\n",
"print(i)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Итеративный цикл (for ... in ...)\n",
"\n",
"Итеративный цикл позволяет проходить все члены некоторой последовательности, например мы задались целью перечислить всех членов экипажа Навуходоносора:"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Neo\n",
"Trinity\n",
"Morpheus\n",
"Mouse\n",
"Dozer\n",
"Tank\n",
"Cypher\n",
"Apoc\n",
"Switch\n"
]
}
],
"source": [
"Nebuchadnezzar = ['Neo', 'Trinity', 'Morpheus', 'Mouse',\n",
" 'Dozer', 'Tank', 'Cypher', 'Apoc', 'Switch']\n",
"for crew_member in Nebuchadnezzar:\n",
" print(crew_member)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Обработка исключительных ситуаций\n",
"\n",
"Python содержит в себе механизм исключений. Это специальный механизм, который позволяет обрабатывать исключительные ситуации, возникающие в ходе выполнения программы не вместе, где эта исключительная ситуация возникла, а там, где нам это удобно. Например, давайте попробуем привести пользовательский ввод к целому числу, а если не получится — сообщим ему, что именно нас не устраивает:"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Введите целое число: 3.1415\n",
"Не было введено целое число\n",
"invalid literal for int() with base 10: '3.1415'\n"
]
}
],
"source": [
"in_s = input(\"Введите целое число: \")\n",
"try:\n",
" i = int(in_s)\n",
" print(\"Все верно, введено число \", i)\n",
"except ValueError as e:\n",
" print(\"Не было введено целое число\")\n",
" print(e)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Пока остановися на такой базовой обработке исключений. Отметим, что ValueError — специальный класс исключений, предназначений для обработки ошибок значений, передаваемых в некоторую функцию. Более подробно исключения будут рассмотрены позже."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Арифметические операторы\n",
"\n",
"Очевидно, в Python есть базовые арифметические операторы:\n",
"\n",
"- \\+ — сложение;\n",
"\n",
"- \\- — вычитание;\n",
"\n",
"- \\* — умножение;\n",
"\n",
"- / — деление.\n",
"\n",
"К тому же для каждого из этих операторов есть комбинированный оператор присваивания:\n",
"\n",
"- += — присваивание с суммированием;\n",
"\n",
"- -= — присваивание с вычитанием;\n",
"\n",
"- \\*= — присваивание с умножением;\n",
"\n",
"- /= — присваивание с делением.\n",
"\n",
"Есть и другие арифметические операторы, а также модуль math, содержащий много всего интересного, но пока мы остановимся на этом."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7\n",
"3\n",
"10\n",
"2.5\n",
"11\n",
"7\n",
"70\n",
"35.0\n"
]
}
],
"source": [
"a = 5\n",
"b = 2\n",
"\n",
"print(a + b)\n",
"print(a - b)\n",
"print(a * b)\n",
"print(a / b)\n",
"\n",
"a += 6\n",
"print(a)\n",
"\n",
"a -= 4\n",
"print(a)\n",
"\n",
"a *= 10\n",
"print(a)\n",
"\n",
"a /= 2\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Хотелось бы отметить, что в отношении последовательностий операция + имеет смысл \"конкатенации\", а операция * — повторения. Например, рассмотрим на строках:"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"I love Python\n",
"I love Python 3\n",
"Python Python \n",
"Python Python Python Python Python Python Python Python Python Python \n"
]
}
],
"source": [
"s = \"I love \" + \"Python\"\n",
"print(s)\n",
"\n",
"s += \" 3\"\n",
"print(s)\n",
"\n",
"s = \"Python \" * 2\n",
"print(s)\n",
"\n",
"s *= 5\n",
"print(s)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Ввод и вывод данных\n",
"\n",
"Мы уже столкнулись с фукциями input и print, но давайте рассмотрим их подробно. Функция input может вызываться с аргументом или без аргументов. Смысл этого аргумента в том, что это будет строка подсказки при вводе. Например:"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Как тебя зовут: Семен\n",
"Приветствую тебя, Семен!\n"
]
}
],
"source": [
"name = input('Как тебя зовут: ')\n",
"print('Приветствую тебя, ' + name + '!')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Функция считает строку с потока чтения, пока не встретит последовательность символов, означающую конец строки или символ конца файла (EOF)\n",
"\n",
"Для вывода данных используется функция print, которой передается любое количество аргументов, которые будут приведены к строкам:"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"None True False 12 Просто строка ('Кортеж', 'из', '4', 'строк')\n"
]
}
],
"source": [
"print(None, True, False, 12, 'Просто строка', ('Кортеж', 'из', '4', 'строк'))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Написание и вызов функций\n",
"\n",
"Функции предназначены для тех ситуациий, когда один и тот же участок программного кода необходимо выполнить, но с разными входными параметрами. Для определения функции используется конструкция def, после нее идет имя функции, потом в скобках ее аргументы и во вложенном блоке тело функции. Соединим все знания, которые мы получили за сегодня и напишем функцию, которая считывает целое число, ввобдимое пользователем. При этом в качестве аргумента мы ей передадим строку-подсказку. Если пользователь не вводит целое число, то мы выведем ему сообщение о том, что это необходимо. Наша функция будет выполняться, пока число не будет получено:"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Введите количество дверей в вашем автомобиле: 3\n",
"Количество дверей равно 3\n"
]
}
],
"source": [
"def get_int_from_input(message):\n",
" while True:\n",
" try:\n",
" i = input(message)\n",
" i = int(i)\n",
" return i\n",
" except ValueError as e:\n",
" print('Не было введено целое число!')\n",
" print(e)\n",
" \n",
"doors = get_int_from_input('Введите количество дверей в вашем автомобиле: ')\n",
"print('Количество дверей равно ', doors)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Обратите внимание, что для возвращения значения из функции используется конструкция return."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Раздел 3. Домашнее задание\n",
"\n",
"Прочитать первую главу Саммерфилда, выполнить упражения из нее.\n",
"\n",
"Написать игру 'быки и коровы'.\n",
"\n",
"Решить [задачу](https://lambda-it.ru/post/20).\n",
"\n",
"Почитать на вики про циклы, рекурсию.\n",
"\n",
"Найти информацию о классификациях языков программирования.\n",
"\n",
"Поискать сравнительный анализ интерпретируемых, частично-интерпретируемых и компилируемых языков программирования.\n",
"\n",
"Прочитать [PEP 8](https://www.python.org/dev/peps/pep-0008/?)\n",
"\n",
"Дойти до нашего Slack. Задавать все вопросы мне, либо своим пирам (товарищам, проходящим этот курс), либо просто в канале #python. Не согласен с чем-то — напиши мне. Хочешь помочь — тоже пиши."
]
}
],
"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
}