python_lesson5_func_recursion/lesson5_part1_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=\"../img/python_theme.png\">\n",
    "# MLClass. \"Прикладной анализ данных\"\n",
    "# Модуль \"Инструментарий Data Science\"\n",
    "<img src=\"../img/mlclass_logo.jpg\" height=\"240\" width=\"240\">\n",
    "\n",
    "## Автор материала: Юрий Кашницкий, ФКН НИУ ВШЭ\n",
    "</center>\n",
    "Материал распространяется на условиях лицензии <a href=\"https://opensource.org/licenses/MS-RL\">Ms-RL</a>. Можно использовать в любых целях, кроме коммерческих, но с обязательным упоминанием автора материала."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Урок 5. Функции. Рекурсии\n",
    "## Часть 1. Функции"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## План\n",
    "\n",
    "Часть 1. Функции\n",
    "1. Объявление функции. Встроенные функции. Вызов функции. Передача аргументов.\n",
    "2. Глобальные и локальные переменные\n",
    "3. Функции и неизменяемые типы (int, string, tuple)\n",
    "4. Функции и изменяемые типы (list, dict, set)\n",
    "5. Именованные аргументы\n",
    "6. Обработка переменного числа аргументов\n",
    "7. Возврат данных из функции с помощью Return\n",
    "8. Лямбда-функции\n",
    "9. Генераторы\n",
    "\n",
    "Часть 2. Рекурсивные функции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Python 2 and 3 compatibility\n",
    "# pip install future\n",
    "from __future__ import (absolute_import, division,\n",
    "                        print_function, unicode_literals)\n",
    "from builtins import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Объявление функции\n",
    "\n",
    "def <название_функции> ( <параметр1>,<параметр2>,...,<параметрN>):\n",
    "\n",
    "    <Оператор1>\n",
    "    <Оператор2>\n",
    "    ....\n",
    "    <ОператорN>\n",
    "    return [Выражение]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi dear Andrew\n",
      "Hi dear me\n",
      "0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Простейшая функция. Ничего не принимает в качестве аргументов и ничего не делает\n",
    "def do_nothing():\n",
    "    pass\n",
    "\n",
    "# вызов функции\n",
    "do_nothing()\n",
    "\n",
    "# Передача параметра\n",
    "def say_hi_to(name): \n",
    "    print(\"Hi dear\", name)\n",
    "    return 0\n",
    "\n",
    "name = \"Andrew\"\n",
    "var1 = \"String\"\n",
    "say_hi_to(name)\n",
    "var1 = say_hi_to(\"me\")\n",
    "print(var1)\n",
    "\n",
    "# Существует большое количество встроенных функций (bult in) \n",
    "# Больше функций на https://docs.python.org/3/library/functions.html )\n",
    "# Например функция определения длины списка\n",
    "ls = [1,2,3]\n",
    "len(ls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Локальные переменные"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Внимание!!! Тут в тетрадках IPython можно запутаться с порядком выполнения кода. Например, переменная k не должна печататься в функции f() ниже, но может, если k была опеределена в другой клетке тетрадки IPython. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outside before f\n"
     ]
    }
   ],
   "source": [
    "# Функции имеют права на чтение к объявленным до функции переменным \n",
    "# и не имеют - к объявленным после вызова функции\n",
    "def f(): \n",
    "    print(s)\n",
    "    #s = \"Inside\" #Однако не могут их менять\n",
    "    #print(s)  #Error\n",
    "    #print(k) #Error\n",
    "    \n",
    "s = \"Outside before f\"\n",
    "f()\n",
    "k = \"Outside after f\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outside\n",
      "Inside\n",
      "===========\n",
      "Outside\n"
     ]
    }
   ],
   "source": [
    "# При объявлении в функции переменной с тем же именем создается новая (внутренняя) переменная, \n",
    "# не связанная с внешней\n",
    "def f(): \n",
    "    print(k) # Так можно. Тут переменная К не объявляется\n",
    "    #print(s) #Тем не менее попытка обращения к переменной которая потом будет создана вызывает ошибку\n",
    "    s = \"Inside\" \n",
    "    print(s)\n",
    "    print(\"===========\")\n",
    "    \n",
    "k = \"Outside\"\n",
    "s = \"Outside\" \n",
    "f()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outside\n",
      "Inside\n",
      "=======================\n",
      "Inside\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    global s # Для изменения внешних переменных внутри функции их надо объявить глобальной.\n",
    "    print(s)\n",
    "    s = \"Inside\"\n",
    "    print(s)\n",
    "    print(\"=======================\")\n",
    "\n",
    "\n",
    "s = \"Outside\"\n",
    "f()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Передача в функции неизменяемых типов (str, int, tuple, frozenset)\n",
    "\n",
    "Передача происходит по значению, т.е внешняя переменная не зависит от внутренней (локальной) функции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outside\n",
      "10\n",
      "Inside\n",
      "4\n",
      "=========\n",
      "Outside\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "def func(arg, arg2):\n",
    "    print(arg)\n",
    "    print(arg2)\n",
    "    arg = \"Inside\"\n",
    "    arg2 = 4\n",
    "    print(arg)\n",
    "    print(arg2)\n",
    "    print(\"=========\")\n",
    "\n",
    "\n",
    "var1 = \"Outside\"\n",
    "var2 = 10\n",
    "func(var1,var2)\n",
    "print(var1) # значение переменной вне функции не изменилось\n",
    "print(var2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Пример**. Хотим распечатать зарплаты по месяцам в порядке возрастания, но исходные данные не хотим менять"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 salary is 25000\n",
      "2 salary is 30000\n",
      "3 salary is 40000\n",
      "4 salary is 42000\n"
     ]
    }
   ],
   "source": [
    "salaries = (40000, 30000, 25000, 42000)\n",
    "\n",
    "def f(salaries):\n",
    "    for (i, salary) in enumerate(sorted(salaries)):\n",
    "        print(\"{0} salary is {1}\".format(i+1, salary))\n",
    "\n",
    "f(salaries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Передача в функции изменяемых типов (list, dict, set)\n",
    "\n",
    "Передача параметров изменяемых типов происходит по ссылке, т.е изменения в функции влияют на внешние переменные"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List outside:  [10, 20, 30]\n",
      "Dict outside:  {1: 'a', 2: 'b'}\n",
      "==================\n",
      "List inside:  [10, 20, 30, [1, 2, 3, 4]]\n",
      "Dict inside:  {1: 'ccc', 2: 'b'}\n",
      "====================\n",
      "List outside:  [10, 20, 30, [1, 2, 3, 4]]\n",
      "Dict outside:  {1: 'ccc', 2: 'b'}\n"
     ]
    }
   ],
   "source": [
    "def changeme(mylist, mydict):\n",
    "    mylist.append([1, 2, 3, 4])\n",
    "    mydict[1] = \"ccc\"\n",
    "    print(\"List inside: \", mylist)\n",
    "    print(\"Dict inside: \", mydict)\n",
    "    print(\"====================\")\n",
    "\n",
    "l1 = [10, 20, 30]\n",
    "d1 = {1: \"a\", 2: \"b\"}\n",
    "print(\"List outside: \", l1)\n",
    "print(\"Dict outside: \", d1)\n",
    "print(\"==================\")\n",
    "changeme(l1, d1)\n",
    "print(\"List outside: \", l1)\n",
    "print(\"Dict outside: \", d1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пример функции, которая изменит переданный ей список:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "salaries before calling f: [40000, 30000, 25000, 42000]\n",
      "1 salary is 25000\n",
      "2 salary is 30000\n",
      "3 salary is 40000\n",
      "4 salary is 42000\n",
      "salaries after calling f: [25000, 30000, 40000, 42000]\n"
     ]
    }
   ],
   "source": [
    "salaries = [40000, 30000, 25000, 42000]\n",
    "\n",
    "def f(salaries):\n",
    "    salaries.sort()\n",
    "    for (i, salary) in enumerate(salaries):\n",
    "        print(\"{0} salary is {1}\".format(i+1, salary))\n",
    "\n",
    "print(\"salaries before calling f: {0}\".format(salaries))\n",
    "f(salaries)\n",
    "print(\"salaries after calling f: {0}\".format(salaries))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Именованные аргументы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First name: Brian\n",
      "Last name: Kernighan\n",
      "Age: 71\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def describe_person(first_name, last_name, age):\n",
    "    print(\"First name: %s\" % first_name.title())\n",
    "    print(\"Last name: %s\" % last_name.title())\n",
    "    print(\"Age: %d\\n\" % age)\n",
    "\n",
    "describe_person(age=71, first_name='brian', last_name='kernighan')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно аргумент age сделать необязательным"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First name: Brian\n",
      "Last name: Kernighan\n",
      "Age: 10\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def describe_person(first_name, last_name, age=10):\n",
    "    print(\"First name: %s\" % first_name.title())\n",
    "    print(\"Last name: %s\" % last_name.title())\n",
    "    print(\"Age: %d\\n\" % age)\n",
    "\n",
    "describe_person(first_name='brian', last_name='kernighan')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Переменное число аргументов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- Do you have any Limburger ?\n",
      "-- I'm sorry, we're all out of Limburger\n",
      "It's very runny, sir.\n",
      "It's really very, very runny, sir.\n",
      "----------------------------------------\n",
      "client : John Cleese\n",
      "shopkeeper : Michael Palin\n",
      "sketch : Cheese Shop Sketch\n"
     ]
    }
   ],
   "source": [
    "def cheeseshop(kind, *arguments, **keywords):\n",
    "    print(\"-- Do you have any\", kind, \"?\")\n",
    "    print(\"-- I'm sorry, we're all out of\", kind)\n",
    "    for arg in arguments:\n",
    "        print(arg)\n",
    "    print(\"-\" * 40)\n",
    "    keys = sorted(keywords.keys())\n",
    "    for kw in keys:\n",
    "        print(kw, \":\", keywords[kw])\n",
    "\n",
    "cheeseshop(\"Limburger\", \"It's very runny, sir.\",\n",
    "           \"It's really very, very runny, sir.\",\n",
    "           shopkeeper=\"Michael Palin\",\n",
    "           client=\"John Cleese\",\n",
    "           sketch=\"Cheese Shop Sketch\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция, печатающая переданные ей значения и соответствующие аргументы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'person': 'Alex', 'lastname': 'Kollins', 'a': 2}\n",
      "person is Alex\n",
      "lastname is Kollins\n",
      "\n",
      "    prints its args and values\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "def simple_print(**kwargs):\n",
    "    \"\"\"\n",
    "    prints its args and values\n",
    "    \"\"\"\n",
    "    print(kwargs)\n",
    "    if 'person' in kwargs:\n",
    "        print(\"{0} is {1}\".format('person', \n",
    "                                  kwargs['person']))\n",
    "    if 'lastname' in kwargs:\n",
    "        print(\"{0} is {1}\".format('lastname', \n",
    "                                  kwargs['lastname']))\n",
    "    if set(kwargs.keys()).difference(\n",
    "               set(['person', 'lastname'])):\n",
    "        print(simple_print.__doc__)\n",
    "    \n",
    "simple_print(person=\"Alex\", lastname=\"Kollins\", a=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пример функции со множеством необязательных аргументов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function simple_print in module __main__:\n",
      "\n",
      "simple_print(**kwargs)\n",
      "    prints its args and values\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(simple_print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: pylab import has clobbered these variables: ['f']\n",
      "`%matplotlib` prevents importing * from pylab and numpy\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x106852be0>]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nBsYYY7BkYIwxBksGxhhjgP8HfgLJ8QA0sx8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x104bb6a58>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%pylab inline\n",
    "# from matplotlib import pylab as plt\n",
    "from math import sin\n",
    "\n",
    "x = range(1000)\n",
    "y = [sin(i / 100) for i in x]\n",
    "\n",
    "plot(x, y)\n",
    "# plot(x, y, color=\"green\")\n",
    "# help(plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1069afcc0>]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nUDEQERHg/wHUXCFiFSaohwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x106959978>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(x, y, color=\"red\", linestyle='dashed')\n",
    "#help(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 7. Возврат данных из функции с помощью Return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция может возвращать что угодно, в том числе и другую функцию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function f1 at 0x1069800d0>\n",
      "f1\n",
      "<function f1.<locals>.f2 at 0x106980840>\n",
      "f1\n",
      "Hello!\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def f1():\n",
    "    print(\"f1\")\n",
    "    def f2():\n",
    "        print(\"Hello!\")\n",
    "    return f2\n",
    "\n",
    "print(f1)\n",
    "print(f1())\n",
    "print(f1()())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Лямбда функции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function make_incrementor.<locals>.<lambda> at 0x106f580d0>\n",
      "44\n"
     ]
    }
   ],
   "source": [
    "def make_incrementor(n):\n",
    "    return lambda x: x + n\n",
    "\n",
    "f = make_incrementor(42)\n",
    "print(f)\n",
    "\n",
    "print(f(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пример применения одной функции ко всем элементам списка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<map object at 0x10696d7f0>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[45200, 33900, 28250, 47460]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "salaries = [40000, 30000, 25000, 42000]\n",
    "salaries_indexed = map(lambda sal: sal * 1.13, salaries)\n",
    "print(salaries_indexed)\n",
    "[round(sal) for sal in salaries_indexed]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пример фильтрации списка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<filter object at 0x106959c50>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[40000, 42000]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "salaries = [40000, 30000, 25000, 42000]\n",
    "filtered_salaries = filter(lambda sal: sal > 30000, \n",
    "                           salaries)\n",
    "print(filtered_salaries)\n",
    "[sal for sal in filtered_salaries]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Генератор"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def firstn(n):\n",
    "    num, nums = 0, []\n",
    "    while num < n:\n",
    "        nums.append(num)\n",
    "        num += 1\n",
    "    return nums\n",
    "\n",
    "sum_of_first_n = sum(firstn(10))\n",
    "print(sum_of_first_n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С сокращенной нотацией списков мы уже сталкивались. Такую конструкцию также называют генератором списка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]\n"
     ]
    }
   ],
   "source": [
    "doubles = [2 * n for n in range(50)]\n",
    "print(doubles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Но бывают и выражения-генераторы (синтаксис такой же, как для генератора списка, только скобки круглые). Это более эффективно, чем использование генератора списков."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object <genexpr> at 0x106973438>\n",
      "1, 4, 9, "
     ]
    }
   ],
   "source": [
    "numbers = (1, 2, 3, 4, 5)\n",
    "squares_under_10 = (number * number \n",
    "                    for number in numbers \n",
    "                    if number * number < 10)\n",
    "print(squares_under_10)\n",
    "for i in squares_under_10:\n",
    "    print(i, end=', ')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  },
  "name": "4_Functions.ipynb"
 },
 "nbformat": 4,
 "nbformat_minor": 0
}