02. Интенсивный курс языка Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Интенсивный курс языка Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Основы языка Python\n",
    "#### на примере Python 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Пробельные символы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1 2 2 3 3 4 4 5 5 6 1\n",
      "2\n",
      "1 3 2 4 3 5 4 6 5 7 2\n",
      "3\n",
      "1 4 2 5 3 6 4 7 5 8 3\n",
      "4\n",
      "1 5 2 6 3 7 4 8 5 9 4\n",
      "5\n",
      "1 6 2 7 3 8 4 9 5 10 5\n",
      "циклы закончились\n"
     ]
    }
   ],
   "source": [
    "# пример отступов во вложенных циклах for\n",
    "for i in [1, 2, 3, 4, 5]:\n",
    "    print(i)                   # первая строка в блоке for i\n",
    "    for j in [1, 2, 3, 4, 5]:\n",
    "        print(j, end=\" \")        # первая строка в блоке for j\n",
    "        print(i + j, end=\" \")    # последняя строка в блоке for j\n",
    "    print(i)                   # последняя строка в блоке for i\n",
    "print(\"циклы закончились\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# пример многословного выражения\n",
    "long_winded_computation = (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 +\n",
    "                          11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# список списков\n",
    "list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "\n",
    "# такой список списков легче читается\n",
    "easier_to_read_list_of_lists = [ [1, 2, 3],\n",
    "                                 [4, 5, 6],\n",
    "                                 [7, 8, 9] ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "two_plus_three = 2 + \\\n",
    "                 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in [1, 2, 3, 4, 5]:\n",
    "\n",
    "    # обратите внимание на пустую строку (в консоли интерпретатора поднимает исключение!)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Модули"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re\n",
    "my_regex = re.compile(\"[0-9]+\", re.I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re as regex\n",
    "my_regex = regex.compile(\"[0-9]+\", regex.I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from collections import defaultdict, Counter\n",
    "lookup = defaultdict(int)\n",
    "my_counter = Counter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "match = 10\n",
    "from re import *   # в модуле re есть функция match\n",
    "print match        # \"<function re.match>\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Арифметические операции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# в Python 2 частное округляется вниз, \n",
    "# поэтому в случае вещественного результата деления \n",
    "# следует импортировать division\n",
    "from __future__ import division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Функции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def double(x):\n",
    "    \"\"\"здесь, когда нужно, размещают\n",
    "    многострочный документирующий комментарий docstring,\n",
    "    который поясняет, что именно функция вычисляет.\n",
    "    Например, данная функция умножает входящее значение на 2\"\"\"\n",
    "    return x * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# применить функцию f к единице\n",
    "def apply_to_one(f):\n",
    "    \"\"\"вызывает функцию f с единицей в качестве аргумента\"\"\"\n",
    "    return f(1)\n",
    "\n",
    "my_double = double           # ссылка на ранее определенную функцию\n",
    "x = apply_to_one(my_double)  # = 2\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "y = apply_to_one(lambda x: x + 4)     # = 5\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "another_double = lambda x: 2 * x      # так не делать\n",
    "def another_double(x): return 2 * x   # лучше так"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "привет\n",
      "мое сообщение по умолчанию\n"
     ]
    }
   ],
   "source": [
    "def my_print(message=\"мое сообщение по умолчанию\"):\n",
    "    print(message)\n",
    "\n",
    "my_print(\"привет\")  # напечатает 'привет'\n",
    "my_print()          # напечатает 'мое сообщение по умолчанию'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# функция вычитания\n",
    "def subtract(a=0, b=0):\n",
    "    return a - b\n",
    "\n",
    "subtract(10, 5)    # возвращает 5\n",
    "subtract(0, 5)     # возвращает -5\n",
    "subtract(b=5)      # то же, что и в предыдущем примере"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Строки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "single_quoted_string = 'наука о данных'   # одинарные\n",
    "double_quoted_string = \"наука о данных\"   # двойные"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tab_string = \"\\t\"        # обозначает символ табуляции\n",
    "len(tab_string)          # = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not_tab_string = r\"\\t\"   # обозначает символы '\\' и 't'\n",
    "len(not_tab_string)      # = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "multi_line_string = \"\"\"Это первая строка.\n",
    "это вторая строка\n",
    "а это третья строка\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Исключения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "нельзя делить на ноль\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(0 / 0)\n",
    "except ZeroDivisionError:\n",
    "    print(\"нельзя делить на ноль\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Списки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "integer_list = [1, 2, 3]                       # список целых чисел\n",
    "heterogeneous_list = [\"строка\", 0.1, True]     # разнородный список\n",
    "list_of_lists = [ integer_list, heterogeneous_list, [] ]  # список списков\n",
    "\n",
    "list_length = len(integer_list)  # длина списка = 3\n",
    "list_sum    = sum(integer_list)  # сумма значений в списке = 6\n",
    "\n",
    "print(list_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "x = list(range(10)) # задает список [0, 1, ..., 9]\n",
    "zero = x[0]   # = 0, списки нуль-индексные, т. е. индекс 1-го элемента = 0\n",
    "one = x[1]    # = 1\n",
    "nine = x[-1]  # = 9, по-питоновски взять последний элемент\n",
    "eight = x[-2] # = 8, по-питоновски взять предпоследний элемент\n",
    "x[0] = -1     # теперь x = [-1, 1, 2, 3, ..., 9]\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "first_three  = x[:3]   # первые три = [-1, 1, 2]\n",
    "three_to_end = x[3:]   # с третьего до конца = [3, 4, ..., 9]\n",
    "one_to_four  = x[1:5]  # с первого по четвертый = [1, 2, 3, 4]\n",
    "last_three   = x[-3:]  # последние три = [7, 8, 9]\n",
    "without_first_and_last = x[1:-1]  # без первого и последнего = [1, 2, ..., 8]\n",
    "copy_of_x = x[:]       # копия списка x = [-1, 1, 2, ..., 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 in [1, 2, 3]    # True\n",
    "0 in [1, 2, 3]    # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "x.extend([4, 5, 6])  # теперь x = [1, 2, 3, 4, 5, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = x + [4, 5, 6]    # y = [1, 2, 3, 4, 5, 6]; x не изменился"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "x.append(0)          # теперь x = [1, 2, 3, 0]\n",
    "y = x[-1]            # = 0\n",
    "z = len(x)           # = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x, y = [1, 2]        # теперь x = 1, y = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "_, y = [1, 2]        # теперь y == 2, первый элемент не нужен"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Кортежи"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "кортеж изменять нельзя\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2]    # задать список\n",
    "my_tuple = (1, 2)   # задать кортеж\n",
    "other_tuple = 3, 4  # еще один кортеж\n",
    "my_list[1] = 3      # теперь my_list = [1, 3]\n",
    "\n",
    "try:\n",
    "    my_tuple[1] = 3\n",
    "except TypeError:\n",
    "    print(\"кортеж изменять нельзя\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# функция возвращает сумму и произведение двух параметров\n",
    "def sum_and_product(x, y):\n",
    "    return (x + y),(x * y)\n",
    "\n",
    "sp = sum_and_product(2, 3)     # = (5, 6)\n",
    "s, p = sum_and_product(5, 10)  # s = 15, p = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x, y = 1, 2   # теперь x = 1, y = 2\n",
    "x, y = y, x   # обмен переменными по-питоновски; теперь x = 2, y = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Словари"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "empty_dict = {}              # задать словарь по-питоновски\n",
    "empty_dict2 = dict()         # не совсем по-питоновски\n",
    "grades = {\"Joel\" : 80, \"Tim\" : 95}  # литерал словаря (оценки за экзамены)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "joels_grade = grades[\"Joel\"]        # = 80"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "оценки для Кэйт отсутствуют!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    kates_grade = grades[\"Kate\"]\n",
    "except KeyError:\n",
    "    print(\"оценки для Кэйт отсутствуют!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "joel_has_grade = \"Joel\" in grades      # True\n",
    "kate_has_grade = \"Kate\" in grades      # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "joels_grade = grades.get(\"Joel\", 0)    # = 80\n",
    "kates_grade = grades.get(\"Kate\", 0)    # = 0\n",
    "no_ones_grade = grades.get(\"No One\")   # значение по умолчанию = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "grades[\"Tim\"] = 99             # заменяет старое значение\n",
    "grades[\"Kate\"] = 100           # добавляет третью запись\n",
    "num_students = len(grades)     # = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tweet = {\n",
    "    \"user\" : \"joelgrus\",\n",
    "    \"text\" : \"Наука о данных - потрясающая тема\",\n",
    "    \"retweet_count\" : 100,\n",
    "    \"hashtags\" : [\"#data\", \"#science\", \"#datascience\", \"#awesome\", \"#yolo\"]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tweet_keys   = tweet.keys()    # список ключей\n",
    "tweet_values = tweet.values()  # список значений\n",
    "tweet_items  = tweet.items()   # список кортежей (ключ, значение)\n",
    "\n",
    "\"user\" in tweet_keys        # True, но использует медленное in списка\n",
    "\"user\" in tweet             # по-питоновски, использует быстрое in словаря\n",
    "\"joelgrus\" in tweet_values  # True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Словарь defaultdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# частотности слов\n",
    "word_counts = {}   \n",
    "document = {}  # некий документ, здесь он пустой\n",
    "for word in document:\n",
    "    if word in word_counts:\n",
    "        word_counts[word] += 1\n",
    "    else:\n",
    "        word_counts[word] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word_counts = {}\n",
    "for word in document:\n",
    "    try:\n",
    "        word_counts[word] += 1\n",
    "    except KeyError:\n",
    "        word_counts[word] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word_counts = {}\n",
    "for word in document:\n",
    "    previous_count = word_counts.get(word, 0)\n",
    "    word_counts[word] = previous_count + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "word_counts = defaultdict(int)     # int() возвращает 0\n",
    "for word in document:\n",
    "    word_counts[word] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "Seattle\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "dd_list = defaultdict(list)  # list() возвращает пустой список\n",
    "dd_list[2].append(1)         # теперь dd_list содержит {2: [1]}\n",
    "print(dd_list[2])\n",
    "\n",
    "dd_dict = defaultdict(dict)  # dict() возвращает пустой словарь dict\n",
    "dd_dict[\"Joel\"][\"City\"] = \"Seattle\"  # { \"Joel\" : { \"City\" : Seattle\"}}\n",
    "print(dd_dict[\"Joel\"][\"City\"])\n",
    "\n",
    "dd_pair = defaultdict(lambda: [0, 0])\n",
    "dd_pair[2][1] = 1            # теперь dd_pair содержит {2: [0,1]}\n",
    "print(dd_pair[2][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Словарь Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({0: 2, 1: 1, 2: 1})\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "c = Counter([0, 1, 2, 0])    # в результате c = { 0 : 2, 1 : 1, 2 : 1 }\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# лучший вариант подсчета частотностей слов\n",
    "word_counts = Counter(document)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# напечатать 10 наиболее встречаемых слов и их частотность (встречаемость)\n",
    "for word, count in word_counts.most_common(10):\n",
    "    print(word, count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Множества"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 True False\n"
     ]
    }
   ],
   "source": [
    "s = set()     # задать пустое множество\n",
    "\n",
    "s.add(1)      # теперь s = { 1 }\n",
    "s.add(2)      # теперь s = { 1, 2 }\n",
    "s.add(2)      # s как и прежде = { 1, 2 }\n",
    "\n",
    "x = len(s)    # = 2\n",
    "y = 2 in s    # = True\n",
    "z = 3 in s    # = False\n",
    "\n",
    "print(x,y,z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# некий список слов\n",
    "hundreds_of_other_words = []  # здесь это множество пустое\n",
    "# список стоп-слов\n",
    "stopwords_list = [\"a\",\"an\",\"at\"] + hundreds_of_other_words + [\"yet\", \"you\"]\n",
    "\"zip\" in stopwords_list    # False, но проверяется каждый элемент\n",
    "\n",
    "# множество стоп-слов\n",
    "stopwords_set = set(stopwords_list)\n",
    "\"zip\" in stopwords_set     # очень быстрая проверка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "item_list = [1, 2, 3, 1, 2, 3]         # список\n",
    "num_items = len(item_list)             # количество = 6\n",
    "item_set = set(item_list)              # вернет множество {1, 2, 3}\n",
    "num_distinct_items = len(item_set)     # число недублирующихся = 3\n",
    "distinct_item_list = list(item_set)    # назад в список = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Управляющие конструкции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if 1 > 2:\n",
    "    message = \"если 1 была бы больше 2...\"\n",
    "elif 1 > 3:\n",
    "    message = \"elif означает 'else if'\"\n",
    "else:\n",
    "    message = \"когда все предыдущие условия не выполняются, используется else\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "parity = \"четное\" if x % 2 == 0 else \"нечетное\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 меньше 10\n",
      "1 меньше 10\n",
      "2 меньше 10\n",
      "3 меньше 10\n",
      "4 меньше 10\n",
      "5 меньше 10\n",
      "6 меньше 10\n",
      "7 меньше 10\n",
      "8 меньше 10\n",
      "9 меньше 10\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 10:\n",
    "    print(x, \"меньше 10\")\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 меньше 10\n",
      "1 меньше 10\n",
      "2 меньше 10\n",
      "3 меньше 10\n",
      "4 меньше 10\n",
      "5 меньше 10\n",
      "6 меньше 10\n",
      "7 меньше 10\n",
      "8 меньше 10\n",
      "9 меньше 10\n"
     ]
    }
   ],
   "source": [
    "for x in range(10):\n",
    "    print(x, \"меньше 10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for x in range(10):\n",
    "    if x == 3:\n",
    "        continue  # перейти сразу к следующей итерации\n",
    "    if x == 5:\n",
    "        break     # выйти из цикла\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Истинность"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "one_is_less_than_two = 1 < 2         # = True\n",
    "true_equals_false = True == False    # = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = None\n",
    "print(x == None)    # напечатает True, но это не по-питоновски\n",
    "print(x is None)    # напечатает True по-питоновски"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def some_function_that_returns_a_string(): return \"\"\n",
    "\n",
    "s = some_function_that_returns_a_string() # возвращает строковое значение\n",
    "if s:\n",
    "    first_char = s[0]   # первый символ в строке\n",
    "else:\n",
    "    first_char = \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "first_char = s and s[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "safe_x = x or 0     # безопасный способ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all([True, 1, { 3 }])    # True\n",
    "all([True, 1, {}])       # False, {} = ложное\n",
    "any([True, 1, {}])       # True, True = истинное\n",
    "all([])      # True, ложные элементы в списке отсутствуют\n",
    "any([])      # False, истинные элементы в списке отсутствуют"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Не совсем основы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Сортировка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "x = [4,1,2,3]\n",
    "y = sorted(x)    # после сортировки = [1, 2, 3, 4], x не изменился\n",
    "x.sort()         # теперь x = [1, 2, 3, 4]\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-4, 3, -2, 1]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "# сортировать список по абсолютному значению в убывающем порядке\n",
    "x = sorted([-4,1,-2,3], key=abs, reverse=True)    # = [-4,3,-2,1]\n",
    "\n",
    "print(x)\n",
    "\n",
    "# сортировать слова и их частотности по убывающему значению частот\n",
    "wc = sorted(word_counts.items(), key=lambda word, count: count, reverse=True)\n",
    "\n",
    "print(wc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Генераторы последовательностей"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# четные числа\n",
    "even_numbers = [x for x in range(5) if x % 2 == 0]  # [0, 2, 4]\n",
    "# квадраты чисел\n",
    "squares    = [x * x for x in range(5)]              # [0, 1, 4, 9, 16]\n",
    "# квадраты четных чисел\n",
    "even_squares = [x * x for x in even_numbers]        # [0, 4, 16]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# словарь с квадратами чисел\n",
    "square_dict = { x : x * x for x in range(5) } # { 0:0, 1:1, 2:4, 3:9, 4:16 }\n",
    "# множество с квадратами чисел\n",
    "square_set  = { x * x for x in [1, -1] }    # { 1 }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# нули\n",
    "zeroes = [0 for _ in even_numbers] # имеет ту же длину, что и even_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# пары\n",
    "pairs = [(x, y)\n",
    "         for x in range(10)\n",
    "         for y in range(10)]    # 100 пар (0,0) (0,1)... (9,8), (9,9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# пары с возрастающим значением\n",
    "increasing_pairs = [(x, y)    # только пары с x < y,\n",
    "                    for x in range(10)            # range(мин, макс) равен\n",
    "                    for y in range(x + 1, 10)]    # [мин, мин + 1, ..., макс - 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Функции-генераторы и генераторные выражения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def lazy_range(n):\n",
    "    \"\"\"ленивая версия диапазона range\"\"\"\n",
    "    i = 0\n",
    "    while i < n:\n",
    "        yield i \n",
    "        i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "def do_something_with(i): print(i, end=\" \")\n",
    "    \n",
    "for i in lazy_range(10): do_something_with(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# натуральные числа\n",
    "def natural_numbers():\n",
    "    \"\"\"возвращает 1, 2, 3, ...\"\"\"\n",
    "    n = 1\n",
    "    while True:\n",
    "        yield n \n",
    "        n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# ленивый список четных чисел меньше 20\n",
    "lazy_evens_below_20 = (i for i in lazy_range(20) if i % 2 == 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Случайные числа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.435218721551486, 0.6119633399453078, 0.15171958416931242, 0.5225938866173602]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# четыре равномерные случайные величины\n",
    "four_uniform_randoms = [random.random() for _ in range(4)]\n",
    "\n",
    "# [0.8444218515250481,     # random.random() производит числа\n",
    "#  0.7579544029403025,     # равномерно в интервале между 0 и 1\n",
    "#  0.420571580830845,      # функция random будет применяться\n",
    "#  0.25891675029296335]    # наиболее часто\n",
    "\n",
    "print(four_uniform_randoms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5714025946899135\n",
      "0.5714025946899135\n"
     ]
    }
   ],
   "source": [
    "random.seed(10)    # задать случайную последовательность, установив в 10\n",
    "print(random.random())      # 0.57140259469\n",
    "random.seed(10)             # переустановить seed в 10\n",
    "print(random.random())      # опять 0.57140259469"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "random.randrange(10)        # произвольно выбрать из range(10) = [0, 1, ..., 9]\n",
    "random.randrange(3, 6)      # произвольно выбрать из range(3, 6) = [3, 4, 5]\n",
    "\n",
    "print(random.randrange(10))\n",
    "print(random.randrange(3, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[7, 6, 8, 2, 4, 1, 9, 0, 5, 3]\n"
     ]
    }
   ],
   "source": [
    "up_to_ten = list(range(10))  # задать последовательность из 10 элементов\n",
    "print(up_to_ten)\n",
    "\n",
    "random.shuffle(up_to_ten)\n",
    "print(up_to_ten)\n",
    "# [2, 5, 1, 9, 7, 3, 8, 6, 4, 0] (фактические результаты могут отличаться)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Чарли\n"
     ]
    }
   ],
   "source": [
    "# мой лучший друг\n",
    "my_best_friend = random.choice([\"Алиса\", \"Боб\", \"Чарли\"])  # сейчас \"Боб\"\n",
    "\n",
    "print(my_best_friend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 29, 49, 55, 15, 28]\n"
     ]
    }
   ],
   "source": [
    "# лотерейные номера\n",
    "lottery_numbers = list(range(60))\n",
    "\n",
    "# выигрышные номера (пример выборки без возврата)\n",
    "winning_numbers = random.sample(lottery_numbers, 6)  # [16, 36, 10, 6, 25, 9]\n",
    "\n",
    "print(winning_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 6, 0, 9]\n"
     ]
    }
   ],
   "source": [
    "# список из четерех элементов (пример выборки с возвратом)\n",
    "four_with_replacement = [random.choice(list(range(10)))\n",
    "                         for _ in range(4)]\n",
    "\n",
    "print(four_with_replacement) # [9, 4, 4, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Регулярные выражения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "print(all([                              # все они - истинные, т. к.\n",
    "  not re.match(\"a\", \"cat\"),              # слово 'cat' не начинается с 'a'\n",
    "  re.search(\"a\", \"cat\"),                 # в слове 'cat' есть 'a'\n",
    "  not re.search(\"c\", \"dog\"),             # в слове 'dog' нет 'c'\n",
    "  3 == len(re.split(\"[ab]\", \"carbs\")),   # разбивка по a или b\n",
    "                                         # в ['c','r','s']\n",
    "  \"R-D-\" == re.sub(\"[0-9]\", \"-\", \"R2D2\") # замена цифр дефисами\n",
    "]))  # напечатает True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Объектно-ориентированное программирование"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# по традиции классам назначают имена с заглавной буквы\n",
    "class Set:\n",
    "\n",
    "    # ниже идут компонентные функции\n",
    "    # каждая берет первый параметр \"self\" (еще одно правило),\n",
    "    # который ссылается на конкретный используемый объект класса Set\n",
    "    def __init__(self, values=None):\n",
    "        \"\"\"Это конструктор.\n",
    "        Вызывается при создании нового объекта класса Set и\n",
    "        используется следующим образом:\n",
    "        s1 = Set()           # пустое множество\n",
    "        s2 = Set([1,2,2,3])  # инициализировать значениями\"\"\"\n",
    "\n",
    "        self.dict = {} # каждый экземпляр имеет собственное свойство dict,\n",
    "                       # которое используется для проверки\n",
    "                       # на принадлежность элементов множеству\n",
    "\n",
    "        if values is not None:\n",
    "            for value in values: self.add(value)\n",
    "\n",
    "    def __repr__(self):\n",
    "        \"\"\"это строковое представление объекта Set,\n",
    "        которое выводится в оболочке или передается в функцию str()\"\"\"\n",
    "        return \"Set: \" + str(self.dict.keys())\n",
    "\n",
    "    # принадлежность представлена ключом в словаре self.dict\n",
    "    # со значением True\n",
    "    def add(self, value):\n",
    "        self.dict[value] = True\n",
    "\n",
    "    # значение принадлежит множеству, если его ключ имеется в словаре\n",
    "    def contains(self, value):\n",
    "        return value in self.dict\n",
    "\n",
    "    def remove(self, value):\n",
    "        del self.dict[value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s = Set([1,2,3])\n",
    "\n",
    "s.add(4)\n",
    "print(s.contains(4))    # True\n",
    "\n",
    "s.remove(3)\n",
    "print(s.contains(3))    # False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Инструменты функционального программирования"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# возведение в степень power\n",
    "def exp(base, power):\n",
    "    return base ** power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# двойка в степени power\n",
    "def two_to_the(power):\n",
    "    return exp(2, power)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "from functools import partial\n",
    "# возвращает функцию с частичным приложением аргументов\n",
    "two_to_the = partial(exp, 2)     # теперь это функция одной переменной\n",
    "print(two_to_the(3))             # 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "square_of = partial(exp, power=2)   # квадрат числа\n",
    "print(square_of(3))                 # 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n",
      "[2, 4, 6, 8]\n",
      "[2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "def double(x):\n",
    "    return 2 * x\n",
    "\n",
    "xs = [1, 2, 3, 4]\n",
    "twice_xs = [double(x) for x in xs]     # [2, 4, 6, 8]\n",
    "print(twice_xs)\n",
    "\n",
    "twice_xs = list(map(double, xs))       # то же, что и выше\n",
    "print(twice_xs)\n",
    "\n",
    "list_doubler = partial(map, double)    # удвоитель списка\n",
    "twice_xs = list(list_doubler(xs))      # снова [2, 4, 6, 8]\n",
    "print(twice_xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 10]\n"
     ]
    }
   ],
   "source": [
    "# перемножить аргументы\n",
    "def multiply(x, y): return x * y\n",
    "\n",
    "products = list(map(multiply, [1, 2], [4, 5]))  # [1 * 4, 2 * 5] = [4, 10]\n",
    "print(products)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4]\n",
      "[2, 4]\n",
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "# проверка четности\n",
    "def is_even(x):\n",
    "    \"\"\"True, если x – четное; False, если x - нечетное\"\"\"\n",
    "    return x % 2 == 0\n",
    "\n",
    "x_evens = [x for x in xs if is_even(x)]    # список четных чисел = [2, 4]\n",
    "print(x_evens)\n",
    "\n",
    "x_evens = list(filter(is_even, xs))        # то же, что и выше\n",
    "print(x_evens)\n",
    "\n",
    "list_evener = partial(filter, is_even)     # функция, которая фильтрует список\n",
    "x_evens = list(list_evener(xs))            # снова [2, 4]\n",
    "print(x_evens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "24\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "xs = [1, 2, 3, 4]\n",
    "x_product = reduce(multiply, xs)          # = 1 * 2 * 3 * 4 = 24\n",
    "print(x_product)\n",
    "\n",
    "list_product = partial(reduce, multiply)   # функция, которая упрощает список\n",
    "print(x_product)\n",
    "\n",
    "x_product = list_product(xs)               # снова = 24\n",
    "print(x_product)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Функция enumerate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "documents = []  # список неких документов; здесь он пустой\n",
    "\n",
    "# не по-питоновски\n",
    "for i in range(len(documents)):\n",
    "    document = documents[i]\n",
    "    do_something(i, document)\n",
    "\n",
    "def do_something(i, doc): print(i, doc)\n",
    "    \n",
    "# тоже не по-питоновски\n",
    "i = 0\n",
    "for document in documents:\n",
    "    do_something(i, document)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Функция zip и распаковка аргументов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('a', 1), ('b', 2), ('c', 3)]\n"
     ]
    }
   ],
   "source": [
    "list1 = ['a', 'b', 'c']\n",
    "list2 = [1, 2, 3]\n",
    "pairs = list(zip(list1, list2))    # = [('a', 1), ('b', 2), ('c', 3)]\n",
    "\n",
    "print(pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'b', 'c') (1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "pairs = [('a', 1), ('b', 2), ('c', 3)]\n",
    "letters, numbers = zip(*pairs)\n",
    "\n",
    "print(letters, numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('a', 'b', 'c'), (1, 2, 3)]\n"
     ]
    }
   ],
   "source": [
    "xs = list(zip(('a', 1), ('b', 2), ('c', 3)))\n",
    "\n",
    "print(xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "add() missing 1 required positional argument: 'b'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-7b01b825b9bb>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m      \u001b[1;31m# вернет 3\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m    \u001b[1;31m# ошибка TypeError!\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m \u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m# вернет 3\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: add() missing 1 required positional argument: 'b'"
     ]
    }
   ],
   "source": [
    "def add(a, b): return a + b\n",
    "\n",
    "add(1, 2)      # вернет 3\n",
    "add([1, 2])    # ошибка TypeError!\n",
    "add(*[1, 2])   # вернет 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Переменные args и kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# удвоитель\n",
    "def doubler(f):\n",
    "    def g(x):\n",
    "        return 2 * f(x)\n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "def f1(x):\n",
    "    return x + 1\n",
    "\n",
    "g = doubler(f1)\n",
    "print(g(3))       # 8 или ( 3 + 1) * 2\n",
    "print(g(-1))      # 0 или (-1 + 1) * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "g() takes 1 positional argument but 2 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-9a46d3a82e05>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdoubler\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mg\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m    \u001b[1;31m# TypeError: g() принимает ровно 1 аргумент (задано 2)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: g() takes 1 positional argument but 2 were given"
     ]
    }
   ],
   "source": [
    "def f2(x, y):\n",
    "    return x + y\n",
    "\n",
    "g = doubler(f2)\n",
    "print(g(1, 2))    # TypeError: g() принимает ровно 1 аргумент (задано 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "безымянные аргументы: (1, 2)\n",
      "аргументы по ключу: {'key2': 'word2', 'key': 'word'}\n"
     ]
    }
   ],
   "source": [
    "def magic(*args, **kwargs):\n",
    "    print(\"безымянные аргументы:\", args)\n",
    "    print(\"аргументы по ключу:\", kwargs)\n",
    "\n",
    "magic(1, 2, key=\"word\", key2=\"word2\")\n",
    "\n",
    "# напечатает\n",
    "# безымянные аргументы: (1, 2)\n",
    "# аргументы по ключу: {'key2': 'word2', 'key': 'word'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}