python-for-you-and-me.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "Hello dear reader. This book is design for newcomers to Python with little knowledge on basic programming. Instructors can used it as a guide for teaching Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics\n",
    "\n",
    "* **Central Processing Unit**: Very very fast but simple calculator. It is always asking what to calculate next?\n",
    "* **Main Memory**: Very fast temporary storage that save all instruction and data for CPU.\n",
    "* **Input Devices**: Devices that is used to give computer any kind of information, like Keyboards, Mouses, Touch Screens, Microphones, ... .\n",
    "* **Output Devices**: Devices that computer use to give information to you with them, like Screens, Speakers, Printers, ... .\n",
    "* **Secondary Memory**: If power goes down, main memory erased immediately. That's where secondary memory walks in. It's stores huge data and won't lost them without power. Why we shouldn't use secondary memory instead of main memory? Because it is too slow!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Our Minds Vs. Computer Programs\n",
    "\n",
    "Read text below quickly:\n",
    "\n",
    "> Python has a deisgn philozophy which emphasizes code readebility (notably using whitespece indentetion to delimit code blucks rather than curly brackats or keywords), and a syntax which allows programmers to express concepts in fewer lines of code than might be used in langoages such as C++ or Java. The langoage provides constructs intended to enable writing clear progrems on both a small and large scale.\n",
    "\n",
    "There are many mistakes in the above text. Did you saw them? All of them?! If yes, good for you! If no, that is the most important difference between a computer and a human brain. Humans know how to solve problems automatically, we almost never see many of details, but computers are just fast and studpid calculators!\n",
    "\n",
    "Remember every thing that computer is doing should be told to it. Computers doesn't have a brain, they are just very advanced calculators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Python?\n",
    "\n",
    "[Python](https://www.python.org/) is an interpreted, general purposed language that is designed in 1991 by Guido Van Rossum. Python can be used for object oriented and functional programming. The language usage areas are tremendous. Some of them are, system programming, graphical user interfaces, game development, developing back-end, machine learning, visualizing data, media processing, scientific programming and many many more.\n",
    "\n",
    "Python have very readable and simple syntax to write code. Nowadays python frameworks and libraries are every where.\n",
    "\n",
    "There is only one drawback with python, runtime speed. But even this problem is almost solved by [PyPy](https://pypy.org/) project and many libararies like [numpy](http://www.numpy.org/) and [numby](https://numba.pydata.org/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is PyCharm?\n",
    "\n",
    "As a developer we need an environment to code in it. The best environment that I found is [PyCharm](https://www.jetbrains.com/pycharm/), it has many features like auto-completion, debugging, version controller support, ... ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Jupyter?\n",
    "\n",
    "An integrated development environment like pycharm isn't exactly what need for most of this course. We are dealing with watching effects of each line of code we write. [Jupyter](https://jupyter.org/) is what we use here.\n",
    "\n",
    "Python is a scripting language. This is an advantage that we will get familiar through the course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hello Python\n",
    "\n",
    "There is a tradition in learning programming languages, called _Hello World_ program. We are going to respect the traditions and do it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Mickey Mouse!\n"
     ]
    }
   ],
   "source": [
    "print('Hello Mickey Mouse!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "* Make Python write you name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comments\n",
    "\n",
    "Everything after a sharp will be commented out and will not considered by interpreter.\n",
    "\n",
    "You can even use strings as a comment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Mickey Mouse!\n",
      "Hello Mickey Mouse!\n"
     ]
    }
   ],
   "source": [
    "# A whole line commented out.\n",
    "\n",
    "\"This is a comment too!\"\n",
    "\n",
    "\"\"\"This is a comment with a little diference.\n",
    "This one is a multiline comment.\n",
    "Remember this strings are not saved in any variable!\n",
    "\"\"\"\n",
    "\n",
    "print('Hello Mickey Mouse!')  # Every thing after it will be commented, not before it.\n",
    "print('Hello Mickey Mouse!')  # Your code should be separated from sharps with two space characters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PEP8\n",
    "\n",
    "Python enhancement proposal documents are about everything that apply to python. New features, community input on an issue, ... . Probably the most famous and useful one for us, is PEP8.\n",
    "\n",
    "Development is not single handed anymore, it's a social effort. Groups of many people try to write a code for a same software. PEP8 helps for readability of code for reusing by other people.\n",
    "\n",
    "Most imporant ones:\n",
    "\n",
    "* Indentations are 4 spaces.\n",
    "* Maximum line length is 80 or 120.\n",
    "* Break long line before operators.\n",
    "\n",
    "```python\n",
    "# Yes: easy to match operators with operands\n",
    "income = (gross_wages\n",
    "          + taxable_interest\n",
    "          + (dividends - qualified_dividends)\n",
    "          - ira_deduction\n",
    "          - student_loan_interest)\n",
    "```\n",
    "\n",
    "* Surround top-level function and class definitions with two blank lines.\n",
    "* Method definitions inside a class are surrounded by a single blank line.\n",
    "* Use seperate imports.\n",
    "\n",
    "```python\n",
    "# This is good\n",
    "import os\n",
    "import sys\n",
    "\n",
    "# This is bad\n",
    "import os, sys\n",
    "```\n",
    "\n",
    "* Whitespaces in Expressions and Statements.\n",
    "\n",
    "```python\n",
    "# This is good\n",
    "spam(ham[1], {eggs: 2})\n",
    "foo = (0,)\n",
    "if x == 4: print x, y; x, y = y, x\n",
    "\n",
    "# This is bad\n",
    "spam( ham[ 1 ], { eggs: 2 } )\n",
    "bar = (0, )\n",
    "if x == 4 : print x , y ; x , y = y , x\n",
    "\n",
    "# This is good\n",
    "ham[1:9], ham[1:9:3], ham[:9:3], ham[1::3], ham[1:9:]\n",
    "ham[lower:upper], ham[lower:upper:], ham[lower::step]\n",
    "ham[lower+offset : upper+offset]\n",
    "ham[: upper_fn(x) : step_fn(x)], ham[:: step_fn(x)]\n",
    "ham[lower + offset : upper + offset]\n",
    "\n",
    "# This is bad\n",
    "ham[lower + offset:upper + offset]\n",
    "ham[1: 9], ham[1 :9], ham[1:9 :3]\n",
    "ham[lower : : upper]\n",
    "ham[ : upper]\n",
    "```\n",
    "\n",
    "* Naming Conventions:\n",
    "    * Modules should have short, all-lowercase, underscore (readability) separated names.\n",
    "    * Packages should have short, all-lowercase names. Underscore are discouraged.\n",
    "    * Class names follows CapWords convention.\n",
    "    * Functions should have short, all-lowercase, underscore (readability) separated names.\n",
    "    * Methods arguments:\n",
    "        * Always use `self` and `cls`.\n",
    "        * Group related function by one more blank line between each group.\n",
    "    * Contants should have all-uppercase, underscore (readability) separated names.\n",
    "    * Variables should have short, all-lowercase, underscore (readability) separated names."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables\n",
    "\n",
    "Variables are **labeled places** that you can store data in them. We use **all lowercase underscore separated** alphabets and numbers for variables. Never start a variable with a number. Python names are **case sensitive**. Variable names can't have spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Donald Duck\n"
     ]
    }
   ],
   "source": [
    "famous_disney_character = \"Donald Duck\"\n",
    "print(famous_disney_character)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numbers and Mathematics\n",
    "\n",
    "Python have **infinite integers**, **booleans**, **floating points**, ... for representing numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1044388881413152506691752710716624382579964249047383780384233483283953907971557456848826811934997558340890106714439262837987573438185793607263236087851365277945956976543709998340361590134383718314428070011855946226376318839397712745672334684344586617496807908705803704071284048740118609114467977783598029006686938976881787785946905630190260940599579453432823469303026696443059025015972399867714215541693835559885291486318237914434496734087811872639496475100189041349008417061675093668333850551032972088269550769983616369411933015213796825837188091833656751221318492846368125550225998300412344784862595674492194617023806505913245610825731835380087608622102834270197698202313169017678006675195485079921636419370285375124784014907159135459982790513399611551794271106831134090584272884279791554849782954323534517065223269061394905987693002122963395687782878948440616007412945674919823050571642377154816321380631045902916136926708342856440730447899971901781465763473223850267253059899795996090799469201774624817718449867455659250178329070473119433165550807568221846571746373296884912819520317457002440926616910874148385078411929804522981857338977648103126085903001302413467189726673216491511131602920781738033436090243804708340403154190336\n"
     ]
    }
   ],
   "source": [
    "print (2 ** 4096)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetics\n",
    "\n",
    "These operators are use for arithmetic purposes. Some of them have more priority upon others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ** 4:  16\n",
      "5 * 6:   30\n",
      "4 / 5:   0.8\n",
      "10 // 3: 3\n",
      "25 % 7:  4\n",
      "23 + 45: 68\n",
      "21 - 8:  -87\n",
      "number:  12\n"
     ]
    }
   ],
   "source": [
    "# Arithmetic operators. Upper operators group have higher priority.\n",
    "# Operators under a group have same priority.\n",
    "\n",
    "print(\"2 ** 4:  {}\".format(2 ** 4))   # Power operator\n",
    "\n",
    "print(\"5 * 6:   {}\".format(5 * 6))    # Multiplication operator\n",
    "print(\"4 / 5:   {}\".format(4 / 5))    # Real division operator\n",
    "print(\"10 // 3: {}\".format(10 // 3))  # Integer division operator\n",
    "print(\"25 % 7:  {}\".format(25 % 7))   # Reminder operator\n",
    "\n",
    "print(\"23 + 45: {}\".format(23 + 45))  # Addition operator\n",
    "print(\"21 - 8:  {}\".format(21 - 108))   # Subtraction operator\n",
    "\n",
    "number = 12     # Assignment operator\n",
    "print(\"number:  {}\".format(number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_1: 48, num_2: 312\n"
     ]
    }
   ],
   "source": [
    "# By using parentheses you can change order of operators.\n",
    "num_1 =  24 + 2  * 12\n",
    "num_2 = (24 + 2) * 12\n",
    "print(\"num_1: {}, num_2: {}\".format(num_1, num_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_3: 1.5, num_4: 2.6666666666666665\n"
     ]
    }
   ],
   "source": [
    "# Operators with same priority, get calculated from left to right.\n",
    "num_3 = 2 * 3 / 4\n",
    "num_4 = 2 / 3 * 4\n",
    "print(\"num_3: {}, num_4: {}\".format(num_3, num_4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Exercise\n",
    "\n",
    "* What is saved in variable `equation_result`?\n",
    "\n",
    "```python\n",
    "equation_result = 5 // 3 + 2 ** 3 / 4 * 5 % 7\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bigger is Better\n",
    "\n",
    "When you are doing arithmetic operations on numbers, the result is the type that have more precision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35 / 5      = 7.0\n",
      "35.0 / 5    = 7.0\n",
      "35 / 5.0    = 7.0\n",
      "35.0 / 5.0  = 7.0\n",
      "\n",
      "23 // 7     = 3\n",
      "23.0 // 7   = 3.0\n",
      "23 // 7.0   = 3.0\n",
      "23.0 // 7.0 = 3.0\n",
      "\n",
      "12 * 3      = 36\n",
      "12.0 * 3    = 36.0\n",
      "12 * 3.0    = 36.0\n",
      "12.0 * 3.0  = 36.0\n"
     ]
    }
   ],
   "source": [
    "print(\"35 / 5      = {}\".format(35 / 5))  # Result is a floating point number\n",
    "print(\"35.0 / 5    = {}\".format(35 / 5))  # Result is a floating point number\n",
    "print(\"35 / 5.0    = {}\".format(35 / 5))  # Result is a floating point number\n",
    "print(\"35.0 / 5.0  = {}\".format(35 / 5))  # Result is a floating point number\n",
    "print()\n",
    "print(\"23 // 7     = {}\".format(23 // 7))  # Result is an integer number\n",
    "print(\"23.0 // 7   = {}\".format(23.0 // 7))  # Result is a floating point number\n",
    "print(\"23 // 7.0   = {}\".format(23 // 7.0))  # Result is a floating point number\n",
    "print(\"23.0 // 7.0 = {}\".format(23.0 // 7.0))  # Result is a floating point number\n",
    "print()\n",
    "print(\"12 * 3      = {}\".format(12 * 3))  # Result is an integer number\n",
    "print(\"12.0 * 3    = {}\".format(12.0 * 3))  # Result is an integer number\n",
    "print(\"12 * 3.0    = {}\".format(12 * 3.0))  # Result is an integer number\n",
    "print(\"12.0 * 3.0  = {}\".format(12.0 * 3.0))  # Result is an integer number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Names\n",
    "\n",
    "Each variable need a name."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reserved Words\n",
    "\n",
    "They have special meaning for python, so never use reserved words for variable, function, class, ... names!\n",
    "\n",
    "```python\n",
    "from import as\n",
    "True False\n",
    "None\n",
    "and or not\n",
    "try except finally else raise assert\n",
    "while for break continue else in\n",
    "class\n",
    "def lambda return yield\n",
    "global nonlocal\n",
    "del\n",
    "if elif else pass is in\n",
    "with\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Readability\n",
    "\n",
    "There is a technique called **mnemonic**. It's about variables name that you choose. They should be **short**, **simple** and **sensible**. Variables names doesn't have any influence on how python execute your code, but it is very important for who wants to read your code!\n",
    "\n",
    "These three codes are the same thing to python. Python doesn't care about the meaning of your variables (Remember the fast, stupid calculator). It is just doing what we tell to do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "437.5\n",
      "437.5\n",
      "437.5\n"
     ]
    }
   ],
   "source": [
    "# VERY VERY bad code!\n",
    "hqpowiefhpqowi = 35.0\n",
    "poiwhgpoiqf = 12.5\n",
    "poiwhzpoiqf = hqpowiefhpqowi * poiwhgpoiqf\n",
    "print(poiwhzpoiqf)\n",
    "\n",
    "# Better, but it is not mnemonic.\n",
    "a = 35.0\n",
    "b = 12.5\n",
    "c = a * b\n",
    "print(c)\n",
    "\n",
    "# Mnemonic code. You can understand it's purpose.\n",
    "worked_hours = 35.0\n",
    "pay_rate = 12.5\n",
    "pay = worked_hours * pay_rate\n",
    "print(pay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings\n",
    "\n",
    "String are a sequence of characters that surrounded with single/double quote."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "book_author = 'Amir Khazaie'\n",
    "book_title = \"Python for You and Me\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiline string are possible with triple single/double quote."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "This book is about Python programming language.\n",
      "I started this book as a guideline for instructors\n",
      "and who wants to learn python not as a first programming language.\n"
     ]
    }
   ],
   "source": [
    "book_description = '''\n",
    "This book is about Python programming language.\n",
    "I started this book as a guideline for instructors\n",
    "and who wants to learn python not as a first programming language.'''\n",
    "\n",
    "book_license = \"\"\"\n",
    "This book is under Creative Common license.\n",
    "so feel free to contribute to it and read it.\"\"\"\n",
    "\n",
    "third_way = 'This is a\\\n",
    "very very long\\\n",
    "string'\n",
    "\n",
    "print(book_description)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "This book is under Creative Common license.\n",
      "so feel free to contribute to it and read it.\n"
     ]
    }
   ],
   "source": [
    "print(book_license)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is avery very longstring\n"
     ]
    }
   ],
   "source": [
    "print(third_way)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attaching two strings is easy as sum them up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greetings: HelloGoofy!\n",
      "Full Name: Felonius Gru\n"
     ]
    }
   ],
   "source": [
    "greetings = \"Hello\" + 'Goofy' + \"!\"\n",
    "print(\"Greetings: \" + greetings)\n",
    "\n",
    "firstname = \"Felonius\"\n",
    "lastname  = \"Gru\"\n",
    "fullname  = firstname + ' ' + lastname\n",
    "print('Full Name: {}, greeting: {}'.format(fullname, greetings))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each string have a length that is count of characters in the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "print(len(greetings))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(len(''))  # Empty String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Format\n",
    "\n",
    "As you have seen, there is a `format` method for string objects that will try to make a new string. This method try to put arguments passed to it in `{}`.\n",
    "\n",
    "This is somehow like `printf` structure in `C/C++`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You can put numbers: 125, strings: #TEST# in it to print.\n"
     ]
    }
   ],
   "source": [
    "print('You can put numbers: {},\\\n",
    "      strings: {} in it to print.'\\\n",
    "      .format(125, '#TEST#'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we explain later, any object can get passed to a format method and get a string representation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List: [110, 'Python'], Dictionary: {'a': 'hi', 'b': 12} and Set {1, 2, 3, 5}.\n"
     ]
    }
   ],
   "source": [
    "print('List: {}, Dictionary: {} and Set {}.'\\\n",
    "      .format([110, 'Python'], {'a': 'hi', 'b': 12},\\\n",
    "              {1, 2, 3, 2, 5, 1}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l\n"
     ]
    }
   ],
   "source": [
    "name = 'ali'\n",
    "print(name[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Second arg: SECOND, First arg: FIRST, Second arg again: SECOND\n"
     ]
    }
   ],
   "source": [
    "print('Second arg: {1}, First arg: {0},\\\n",
    "Second arg again: {1}'.format('FIRST', 'SECOND'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Named"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Name: Mike, Last Name: Wazowski\n"
     ]
    }
   ],
   "source": [
    "print('First Name: {firstname}, Last Name: {lastname}'\\\n",
    "      .format(firstname='Mike', lastname='Wazowski'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Template\n",
    "\n",
    "You can define a variable and put your template string in it and then get a proper string with `format` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Python for You and Me\n",
      "\n",
      "Author: Amir Khazaie\n",
      "\n",
      "\n",
      "This book is about Python programming language.\n",
      "I started this book as a guideline for instructors\n",
      "and who wants to learn python not as a first programming language.\n",
      "\n",
      "Book License: \n",
      "This book is under Creative Common license.\n",
      "so feel free to contribute to it and read it.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "book_template = '''\n",
    "{title}\n",
    "\n",
    "Author: {author}\n",
    "\n",
    "{description}\n",
    "\n",
    "Book License: {license}\n",
    "'''\n",
    "\n",
    "print(book_template.format(author=book_author,\n",
    "                           title=book_title,\n",
    "                           description=book_description,\n",
    "                           license=book_license))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escape Sequences\n",
    "\n",
    "Python interpret `'` as start or end for a strings. What happen if want to use it as a apostrophe? You use an escape sequence. They have a special meaning to Python.\n",
    "\n",
    "|Escape Sequence|Meaning                   |\n",
    "|:-------------:|:-------------------------|\n",
    "|`\\\\`           |Backslash (\\\\)            |\n",
    "|`\\'`           |Single quote (')          |\n",
    "|`\\\"`           |Double quote (\")          |\n",
    "|`\\a`           |ASCII Bell (BEL)          |\n",
    "|`\\b`           |ASCII Backspace (BS)      |\n",
    "|`\\f`           |ASCII Formfeed (FF)       |\n",
    "|`\\n`           |ASCII Linefeed (LF)       |\n",
    "|`\\r`           |ASCII Carriage Return (CR)|\n",
    "|`\\t`           |ASCII Horizontal Tab (TAB)|\n",
    "|`\\v`           |ASCII Vertical Tab (VT)   |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Baymax: \"On a scale of one to ten, how would you rate your pain?\"\n",
      "Hiro Hamada: \"What?!\"\n"
     ]
    }
   ],
   "source": [
    "print(\"Baymax: \\\"On a scale of one to ten, how would you rate your pain?\\\"\\nHiro Hamada: \\\"What?!\\\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student Results:\n",
      "\n",
      "Name\tMark\n",
      "Jodi\t80\n",
      "Frank\t30\n",
      "Bob\t67\n"
     ]
    }
   ],
   "source": [
    "print('Student Results:\\n\\nName\\tMark\\nJodi\\t80\\nFrank\\t30\\nBob\\t67')\n",
    "\n",
    "# Above and below have the same output.\n",
    "# In code below we use backsplash to tell python interpreter to ingnore newlines.\n",
    "\n",
    "print('Student Results:\\n\\\n",
    "\\n\\\n",
    "Name\\tMark\\n\\\n",
    "Jodi\\t80\\n\\\n",
    "Frank\\t30\\n\\\n",
    "Bob\\t67')\n",
    "\n",
    "print('''Student Results:\n",
    "\n",
    "Name\\tMark\n",
    "Jodi\\t80\n",
    "''')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input from user\n",
    "\n",
    "For terminal applications, there is a built-in function called `input` that you can prompt user to get data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "user input\n",
      "user input\n"
     ]
    }
   ],
   "source": [
    "string = input()  # The output is always a string.\n",
    "print(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your name? Tadashi Hamada\n",
      "Hello Tadashi Hamada.\n"
     ]
    }
   ],
   "source": [
    "name = input(\"What is your name? \")  # You can ask user for special kind of information.\n",
    "print(\"Hello {}.\".format(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Ask name and age of user and printing something nice for them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing\n",
    "\n",
    "We said strings are created from characters. You can select characters in a string in very customize way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "the_string = 'Hi. This is a simple string that we will use as an example.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First of all you can access each character. Remember in Python counting starts from `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1st character is: H\n",
      "5th character is: T\n"
     ]
    }
   ],
   "source": [
    "print('1st character is: {}\\n5th character is: {}'\\\n",
    "      .format(the_string[0], the_string[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You want last character? No problem. Use negative index!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last character is: .\n",
      "5th character from end of the string is: m\n"
     ]
    }
   ],
   "source": [
    "print('Last character is: {}\\n5th character from end of the string is: {}'\n",
    "      .format(the_string[-1], the_string[-5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String indexes are like:\n",
    "\n",
    "| H | e | l | l | o |   | W | o | r | l | d | ! |\n",
    "|---|---|---|---|---|---|---|---|---|---|---|---|\n",
    "| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11|\n",
    "|-12|-11|-10|-9 |-8 |-7 |-6 |-5 |-4 |-3 |-2 |-1 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing\n",
    "\n",
    "It's almost like indexing, but instead of selecting a single character, you can select mutiple characters. There is three things you use in here `Start`, `Stop`, `Step` and sperate them by a colon. In any of them missing, Python use their default value.\n",
    "\n",
    "|Variable|Default Value          |\n",
    "|:------:|:----------------------|\n",
    "|Start   |Beginning of the string|\n",
    "|Stop    |End of the string      |\n",
    "|Step    |Equals to 1            |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi. This is a simple string that we will use as an example.\n"
     ]
    }
   ],
   "source": [
    "print(the_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simple\n"
     ]
    }
   ],
   "source": [
    "print(the_string[14:20])  # [start stop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "we will use as an example.\n"
     ]
    }
   ],
   "source": [
    "print(the_string[33:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi. This is a simple string\n"
     ]
    }
   ],
   "source": [
    "print(the_string[:27])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ali\n"
     ]
    }
   ],
   "source": [
    "print(the_string[12:30:6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".elpmaxe na sa esu lliw ew taht gnirts elpmis a si sihT .iH\n"
     ]
    }
   ],
   "source": [
    "print(the_string[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Use message below and generate word **gun** with slice operator.\n",
    "\n",
    "```python\n",
    "message = '\"Simplicity is about subtracting the obvious and adding the meaningful.\" - John Maeda'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `in` Operator\n",
    "\n",
    "Checks for existence of string in another string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "the_string_contains_hi = 'hi' in the_string\n",
    "print(the_string_contains_hi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "greeting_contains_hi = 'hi' in 'Hi, how are you?'.lower()\n",
    "print(greeting_contains_hi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# None\n",
    "\n",
    "This is a special object that represent `Nothing` in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boolean\n",
    "\n",
    "Boolean types are actually intergers `0` and `1`. Boolean keywords are `True`, `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What you see when you print true: True and false: False\n"
     ]
    }
   ],
   "source": [
    "print(\"What you see when you print\\\n",
    "true: {} and false: {}\".format(True, False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will see, any object can have a boolean equal. But for now look at code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers: bool(814): True, bool(-38): True, bool(1.5): True, bool(0): False\n"
     ]
    }
   ],
   "source": [
    "print(\"Numbers: bool(814): {}, bool(-38): {}, bool(1.5): {}, bool(0): {}\"\n",
    "      .format(bool(814), bool(-38), bool(1.5), bool(0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Strings: bool('A'): True, bool('Python is a wonderful language.'): True, bool(''): False\n"
     ]
    }
   ],
   "source": [
    "print(\"Strings: bool('A'): {},\\\n",
    "bool('Python is a wonderful language.'): {},\\\n",
    "bool(''): {}\"\n",
    "      .format(bool('A'),\\\n",
    "              bool('Python is a wonderful language.'),\\\n",
    "              bool('')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All empty python datasets are evaluated to false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: False, '': False, []: False, {}: False, set(): False\n"
     ]
    }
   ],
   "source": [
    "print(\"0: {}, '': {}, []: {}, {}: {}, set(): {}\"\n",
    "      .format(bool(0), bool(''), bool([]), '{}', bool({}), bool(set())))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists\n",
    "\n",
    "A list is very similar to an array. You can put any data in a list and access them with indexing and slicing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3rd Prime Number: 5\n",
      "Even indexed Prime Numbers: [2, 5, 11, 17, 23]\n",
      "Last Prime Number: 23\n"
     ]
    }
   ],
   "source": [
    "primes = [2, 3, 5, 7, 11, 13, 17, 19, 23]\n",
    "print(\"3rd Prime Number: {}\".format(primes[2]))\n",
    "print(\"Even indexed Prime Numbers: {}\".format(primes[::2]))\n",
    "print(\"Last Prime Number: {}\".format(primes[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can have multiple data types at the same time! A list can have integers, floats, string and even other lists!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "stuff = ['Apple', 12, [1, 2, 3], {'a': 'Alice', 'b': 'Bob'}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `len` function return length of our list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(len(stuff))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The difference between normal arrays and Python lists is that Python lists can change!\n",
    "\n",
    "Add new values with `append` method and remove value with `del` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 27]\n"
     ]
    }
   ],
   "source": [
    "primes.append(27)\n",
    "print(primes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 27, 9, 31, 37]\n"
     ]
    }
   ],
   "source": [
    "primes.extend([9, 31, 37])\n",
    "print(primes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 31, 37]\n"
     ]
    }
   ],
   "source": [
    "del primes[9:11]\n",
    "print(primes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]\n"
     ]
    }
   ],
   "source": [
    "primes.insert(9, 29)\n",
    "print(primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With method `pop` you can get the last element of list and remove it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37\n"
     ]
    }
   ],
   "source": [
    "print(primes.pop())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]\n"
     ]
    }
   ],
   "source": [
    "print(primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`remove`/`index` methods get an object, search for it in the list and remove it/return index of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 7, 11, 13, 17, 19, 23, 29, 31]\n"
     ]
    }
   ],
   "source": [
    "primes.remove(2)\n",
    "print(primes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(primes.index(17))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add to lists together and get new one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1, -2, -3, -4, -5, 0, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "positive_nums = [1, 2, 3, 4, 5]\n",
    "negative_nums = [-1, -2, -3, -4, -5]\n",
    "integers = negative_nums + [0] + positive_nums\n",
    "print(integers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "sample_list = [1, 2, 'hi', 2, 'hello', 9, 3.14, 2]\n",
    "print(sample_list.count(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have `in` operators for lists too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3] in integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 in integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Packing & Unpacking\n",
    "\n",
    "These two concepts come with sequences. Unpacking means separate each part of a sequence and packing means gather them together in a place.\n",
    "\n",
    "In Python we have multiple assignments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bugs Bunny 77 White\n"
     ]
    }
   ],
   "source": [
    "name, age, color = 'Bugs Bunny', 77, 'White'  # Mixed types. No type limitations.\n",
    "print(name, age, color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even put multiple objects in a single variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Spongebob Squarepants', 18, 'Yellow')\n"
     ]
    }
   ],
   "source": [
    "character = 'Spongebob Squarepants', 18, 'Yellow'\n",
    "print(character)  # Character is a Tuple actually."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have a long list and you wanted to get head and tail of it, you can use this syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Head: Emma, Students: ['Noah', 'Olivia', 'Liam', 'Sophia', 'Mason', 'Ava', 'Jacob', 'William'], Tail: Isabella\n"
     ]
    }
   ],
   "source": [
    "students = ['Emma', 'Noah', 'Olivia', 'Liam', 'Sophia', 'Mason', 'Ava', 'Jacob', 'William', 'Isabella']\n",
    "\n",
    "head, *students, tail = students\n",
    "print('Head: {}, Students: {}, Tail: {}'.format(head, students, tail))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you use a star before variable name in a left side of assignment, it means packing variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Noah', 'Olivia', 'Liam', 'Sophia', 'Mason', 'Ava', 'Jacob', 'William']\n"
     ]
    }
   ],
   "source": [
    "print(students)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Noah Olivia Liam Sophia Mason Ava Jacob William\n"
     ]
    }
   ],
   "source": [
    "print(*students)  # Is equal to print('Noah', 'Olivia', ...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Packing and unpacking won't happen magically, you have to tell what python should do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3] == (1, 2, 3)  # No packing or unpacking. No usage here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprehension\n",
    "\n",
    "There is a faster and better way to define a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401, 2500, 2601, 2704, 2809, 2916, 3025, 3136, 3249, 3364, 3481, 3600, 3721, 3844, 3969, 4096, 4225, 4356, 4489, 4624, 4761, 4900, 5041, 5184, 5329, 5476, 5625, 5776, 5929, 6084, 6241, 6400, 6561, 6724, 6889, 7056, 7225, 7396, 7569, 7744, 7921, 8100, 8281, 8464, 8649, 8836, 9025, 9216, 9409, 9604, 9801]\n"
     ]
    }
   ],
   "source": [
    "squared = [num**2 for num in range(100)]\n",
    "print(squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To be or not to be\n",
    "\n",
    "A little more complex comprehension, let your code decide to add a value or not to add the value there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 64, 729, 4096]\n"
     ]
    }
   ],
   "source": [
    "squared_cubed = [num for num in squared if round(num ** (1/3)) ** 3 == num]\n",
    "print(squared_cubed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "Consider list below:\n",
    "\n",
    "```python\n",
    "countries = ['USA', 'Germany', 'France', 'Iran']\n",
    "```\n",
    "\n",
    "Write piece of code that change upper list to:\n",
    "\n",
    "```python\n",
    "countries = ['UK', 'USA', 'France', 'Iran', 'Canada']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['UK', 'USA', 'France', 'Iran', 'Canada']\n"
     ]
    }
   ],
   "source": [
    "countries = ['USA', 'Germany', 'France', 'Iran']\n",
    "\n",
    "countries.insert(0, 'UK')\n",
    "# countries = ['UK'] + countries\n",
    "\n",
    "del countries[2]\n",
    "# countries.remove('Germany')\n",
    "\n",
    "countries.append('Canada')\n",
    "\n",
    "print(countries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples\n",
    "\n",
    "Tuples are frozen Lists. It means when you define a tuple you can't add to it or remove an object from it. Even you can't change a object at specific index! It is freezed for ever. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "alvin_marks = (12, 10, 17, 14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now is you pass alvin marks to any function or method or ... they can only read it and not changing it!\n",
    "\n",
    "Tuples are much like lists. You can add two tuples and get *new* tuple. You can search for an object in it. You can do anything lists can do with tuples as long as what you want to do won't change it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12, 10, 17, 14, 19, 18.5, 20, 17)\n"
     ]
    }
   ],
   "source": [
    "woody_marks = (19, 18.5, 20, 17)\n",
    "alvin_woody_marks = alvin_marks + woody_marks\n",
    "print(alvin_woody_marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alving got 12? True\n"
     ]
    }
   ],
   "source": [
    "alvin_got_12 = 12 in alvin_marks\n",
    "print(\"Alving got 12? {}\".format(alvin_got_12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you wanted to define a tupe with only one value in it, you should write it like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "a = (12,)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries\n",
    "\n",
    "They are like lists with a little differences. One of differences is that programmer defines indexes here! Indexes are called keys. A dictionary is like a rope, you can connect a keys to its value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How are you?\n"
     ]
    }
   ],
   "source": [
    "per2eng_dict = {\n",
    "    'سلام': 'Hello',\n",
    "    'خوبی؟': 'How are you?',\n",
    "    'پایتون': 'Python',\n",
    "}\n",
    "\n",
    "print(per2eng_dict['خوبی؟'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding new value to a dictionary is so simple. Choose your key and value.\n",
    "\n",
    "Using the same syntax for adding, you can update value of keys that exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Goodbye\n"
     ]
    }
   ],
   "source": [
    "per2eng_dict['خدانگهدار'] = 'Goodbye'\n",
    "print(per2eng_dict['خدانگهدار'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How is it going?\n"
     ]
    }
   ],
   "source": [
    "per2eng_dict['خوبی؟'] = 'How is it going?'\n",
    "print(per2eng_dict['خوبی؟'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use any immutable datatype as a key for your dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'سلام': 'Hello', 1396: 2017, 'خدانگهدار': 'Goodbye', 'پایتون': 'Python', ('شنبه', 'یک شنبه', 'دو شنبه'): ('saturday', 'sunday', 'monday'), 'خوبی؟': 'How is it going?'}\n"
     ]
    }
   ],
   "source": [
    "per2eng_dict[1396] = 2017\n",
    "per2eng_dict[('شنبه', 'یک شنبه', 'دو شنبه')] = \\\n",
    "('saturday', 'sunday', 'monday')\n",
    "\n",
    "print(per2eng_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get all keys and values of a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['سلام', 1396, 'خدانگهدار', 'پایتون', ('شنبه', 'یک شنبه', 'دو شنبه'), 'خوبی؟'])\n"
     ]
    }
   ],
   "source": [
    "print(per2eng_dict.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['Hello', 2017, 'Goodbye', 'Python', ('saturday', 'sunday', 'monday'), 'How is it going?'])\n"
     ]
    }
   ],
   "source": [
    "print(per2eng_dict.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example for dictionaries is in simple cryptography algorithm called substitution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 'a'), (2, 'b'), (3, 'c')]\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('A', 'N'), ('B', 'O'), ('C', 'P'), ('D', 'Q'), ('E', 'R'), ('F', 'S'), ('G', 'T'), ('H', 'U'), ('I', 'V'), ('J', 'W'), ('K', 'X'), ('L', 'Y'), ('M', 'Z'), ('N', 'A'), ('O', 'B'), ('P', 'C'), ('Q', 'D'), ('R', 'E'), ('S', 'F'), ('T', 'G'), ('U', 'H'), ('V', 'I'), ('W', 'J'), ('X', 'K'), ('Y', 'L'), ('Z', 'M')]\n",
      "DEAR ALICE,\n",
      "\n",
      "I AM A SPY AND WORKING FOR UNITED KINGDOM. AS THE FIRST DAY I START MY WORK HERE YOU WAS ALWAYS KIND TO ME.\n",
      "I WILL NEVER FORGET YOUR HELPS.\n",
      "\n",
      "SINCERELY, SARA.\n"
     ]
    }
   ],
   "source": [
    "ciphertext = '''QRNE NYVPR,\n",
    "\n",
    "V NZ N FCL NAQ JBEXVAT SBE HAVGRQ XVATQBZ. NF GUR SVEFG QNL V FGNEG ZL JBEX URER LBH JNF NYJNLF XVAQ GB ZR.\n",
    "V JVYY ARIRE SBETRG LBHE URYCF.\n",
    "\n",
    "FVAPRERYL, FNEN.'''\n",
    "\n",
    "print(list(zip('ABCDEFGHIJKLMNOPQRSTUVWXYZ',\n",
    "               'NOPQRSTUVWXYZABCDEFGHIJKLM')))\n",
    "\n",
    "# Generate a dictionary with comprehension\n",
    "subs = {i: j for i, j in zip('ABCDEFGHIJKLMNOPQRSTUVWXYZ',\n",
    "                             'NOPQRSTUVWXYZABCDEFGHIJKLM')}\n",
    "\n",
    "# \n",
    "# subs = {'J': 'W', 'Y': 'L', 'I': 'V',\n",
    "#         'A': 'N', 'B': 'O', 'C': 'P',\n",
    "#         'D': 'Q', 'W': 'J', 'F': 'S',\n",
    "#         'U': 'H', 'Q': 'D', 'M': 'Z',\n",
    "#         'P': 'C', 'E': 'R', 'K': 'X',\n",
    "#         'Z': 'M', 'S': 'F', 'O': 'B',\n",
    "#         'R': 'E', 'H': 'U', 'X': 'K',\n",
    "#         'N': 'A', 'L': 'Y', 'G': 'T',\n",
    "#         'V': 'I', 'T': 'G'}\n",
    "\n",
    "# Characters that is not encrypted.\n",
    "subs.update({'.': '.', ' ': ' ',\n",
    "             ',': ',', '\\n': '\\n'})\n",
    "\n",
    "\n",
    "plaintext = ''.join([subs[char] for char in ciphertext])\n",
    "print(plaintext)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprehensions\n",
    "\n",
    "There is a better way to define dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'William': 7, 'Noah': 4, 'Ava': 3, 'Olivia': 6, 'Mason': 5, 'Liam': 4, 'Sophia': 6, 'Jacob': 5}\n"
     ]
    }
   ],
   "source": [
    "length_of_names = {name: len(name) for name in students}\n",
    "print(length_of_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like lists, here we can use `if` statement too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Olivia': 6, 'Sophia': 6, 'William': 7}\n"
     ]
    }
   ],
   "source": [
    "long_names = {name: len(name) for name in students if len(name) >= 6}\n",
    "print(long_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set\n",
    "\n",
    "You can put unique object in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "numbers = {1, 5, 4, 1, 3, 2, 5, 2, 3, 5, 1}\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 10}\n"
     ]
    }
   ],
   "source": [
    "numbers.add(10)\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 4, 5, 10}\n"
     ]
    }
   ],
   "source": [
    "numbers.remove(3)\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{10, 2, 4}\n"
     ]
    }
   ],
   "source": [
    "even_nums = {2, 4, 6, 8, 10}\n",
    "print(numbers & even_nums)  # "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 4, 5, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "print(numbers | even_nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 5}\n"
     ]
    }
   ],
   "source": [
    "print(numbers - even_nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprehensions\n",
    "\n",
    "Faster way to define a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{10, 12, 14, 17, 18.5, 19, 20}\n"
     ]
    }
   ],
   "source": [
    "all_marks = {mark for mark in alvin_woody_marks}\n",
    "print(all_marks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, you can use an `if`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{100, 92.5, 85, 95}\n"
     ]
    }
   ],
   "source": [
    "high_marks = {mark*5 for mark in alvin_woody_marks if mark >= 16}  # We change marks scale from 0 -> 20 to 0 -> 100\n",
    "print(high_marks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conversion\n",
    "\n",
    "There are function with same name as datatypes that try to convert you data from any datatype, to that you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "-45\n",
      "18.0\n",
      "3.14\n",
      "[1, 2, 3, 4]\n",
      "{1, 2, 4, 5, 9, 10}\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "print(int(3.14))\n",
    "print(int('-45'))\n",
    "\n",
    "print(float(18))\n",
    "print(float('3.14'))\n",
    "\n",
    "print(list({1, 2, 3, 1, 4, 1, 2}))\n",
    "print(set((10, 1, 5, 2, 9, 10, 4, 2, 1, 5)))\n",
    "\n",
    "set2str = str({1, 2, 3, 1, 4, 1, 2})\n",
    "print(type([]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutable Vs. Immutable\n",
    "\n",
    "Some of datatypes are mutable and some of them are immutable.\n",
    "\n",
    "If a datatype is mutable, if you change a copy of mutable datatype, you will change original variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Egg', 'Milk', 'Sugar']\n"
     ]
    }
   ],
   "source": [
    "shop_list = ['Egg', 'Milk']\n",
    "\n",
    "new_shop_list = shop_list\n",
    "new_shop_list.append('Sugar')\n",
    "\n",
    "print(shop_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But if a datatype is immutable, if you change a copy of immutable datatype, you will not change original variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python for You and Me\n"
     ]
    }
   ],
   "source": [
    "book_title = \"Python for You and Me\"\n",
    "\n",
    "new_book_title = book_title\n",
    "new_book_title = \"Python 4 U & Me\"\n",
    "\n",
    "print(book_title)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indentation\n",
    "\n",
    "Until now we had all of our code running sequentially. Now we need to group them, decide when to run what part of our code, or which part is going to be reused.\n",
    "\n",
    "To define sub-code, we use indentation. Indentation is a set of whitespaces before the actual code begins.\n",
    "\n",
    "```python\n",
    "password = input('Enter your password: ')\n",
    "\n",
    "if password == 'blah blah blah':\n",
    "    print('Correct.')\n",
    "```\n",
    "\n",
    "Considering PEP8 it if better to use 4 spaces for each step of indentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decision Making\n",
    "\n",
    "There will be a time that you need to make a decision about age of a user, or correctness of a password, or information on a website and ... .\n",
    "\n",
    "Decision making in Python is done with this three statements:\n",
    "* `if CONDITION:`\n",
    "* `elif CONDITION:`\n",
    "* `else:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is the secret knock? abc\n"
     ]
    }
   ],
   "source": [
    "secret_knock = input('What is the secret knock? ')\n",
    "\n",
    "if secret_knock == '1 2 1 3':\n",
    "    print('Correct, you can get in.')  # This is indented code. This code is sub-code of if statement.\n",
    "if secret_knock != '1 2 1 3':\n",
    "    print('Incorrect!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter an odd number: 7\n",
      "That is correct.\n"
     ]
    }
   ],
   "source": [
    "number = int(input('Enter an odd number: '))\n",
    "\n",
    "if number % 2 == 1:\n",
    "    print('That is correct.')\n",
    "else:\n",
    "    print('This is an even number!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How old are you? 5\n",
      "Then probabely you are going to kindergarten.\n"
     ]
    }
   ],
   "source": [
    "age = int(input('How old are you? '))  # input function return datatype is always a string.\n",
    "\n",
    "where_to_go = ''\n",
    "if age < 7:\n",
    "    where_to_go = 'kindergarten'\n",
    "elif age < 18:\n",
    "    where_to_go = 'school'\n",
    "elif age < 120:\n",
    "    where_to_go = 'college'\n",
    "else:\n",
    "    where_to_go = 'grave'\n",
    "\n",
    "print('Then probabely you are going to {}.'.format(where_to_go))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison Operators\n",
    "\n",
    "In above code, if user input is 5, then all of the conditions evaluate to true, but the first one will be used for printing. When you use `if`, `else` or `if`, `elif`, `else` there is a priority for conditions. If one of upper conditions comes true, none of conditions below the true one will be check or executed.\n",
    "\n",
    "Python have six comparison operators:\n",
    "\n",
    "|Operator|                Meaning                |\n",
    "|:------:|:--------------------------------------|\n",
    "|`a <  b`|`a` is smaller than `b`                |\n",
    "|`a <= b`|`a` is smaller than **or** equal to `b`|\n",
    "|`a >  b`|`a` is bigger than `b`                 |\n",
    "|`a >= b`|`a` is bigger than **or** equal to `b` |\n",
    "|`a == b`|`a` is equal to `b`                    |\n",
    "|`a != b`|`a` is not equal to `b`                |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combining Conditions\n",
    "\n",
    "You can combine conditions together with `and` and `or` operators.\n",
    "\n",
    "|     Condition     |Result|\n",
    "|:-----------------:|:----:|\n",
    "|True  **and** True | True |\n",
    "|True  **and** False| False|\n",
    "|False **and** True | False|\n",
    "|False **and** False| False|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ali and Amir are friends.\n"
     ]
    }
   ],
   "source": [
    "ali_age, ali_school, ali_friend = \\\n",
    "17, 'high school', {'mohammad', 'mahdi'}\n",
    "\n",
    "amir_age, amir_school, amir_friend = \\\n",
    "16, 'high school', {'reza', 'mohammad'}\n",
    "\n",
    "if ali_school == amir_school and ali_friend & amir_friend:\n",
    "    print('Ali and Amir are friends.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|     Condition    |Result|\n",
    "|:----------------:|:----:|\n",
    "|True  **or** True | True |\n",
    "|True  **or** False| True |\n",
    "|False **or** True | True |\n",
    "|False **or** False| False|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ali and Amir are probabely friends.\n"
     ]
    }
   ],
   "source": [
    "if ali_school == amir_school or ali_friend & amir_friend:\n",
    "    print('Ali and Amir are probabely friends.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chaining\n",
    "\n",
    "There is a very useful feature named **Chained comparsion**. In most programming languages like C, C++, Java, PHP, Drupal, ... this is not possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if 5 >= 2 <= 3:\n",
    "    print('Correct!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ali and Amir have same age range.\n"
     ]
    }
   ],
   "source": [
    "if -1 <= (ali_age - amir_age) <= 1:\n",
    "    print('Ali and Amir have same age range.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Condition Operator\n",
    "\n",
    "It like any operators, it have operands and a result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How old are you? 22\n",
      "You are so young.\n"
     ]
    }
   ],
   "source": [
    "age = int(input('How old are you? '))\n",
    "\n",
    "print('You are {} young.'\\\n",
    "      .format('so' if age < 25 else 'not so'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Special Cases\n",
    "\n",
    "If you were going to check if a variable is `None` or `True` or `False`, considering PEP8, you have to use `is` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We don't know anything.\n"
     ]
    }
   ],
   "source": [
    "information_about_bermuda_triangle = None\n",
    "\n",
    "if information_about_bermuda_triangle is None:\n",
    "    print('We don\\'t know anything.')\n",
    "\n",
    "rainy_day = False\n",
    "\n",
    "if rainy_day is not False:\n",
    "    print('Use an umbrella.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "There is another operator that you can use in condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your name? Mason\n",
      "Your name is on the list.\n"
     ]
    }
   ],
   "source": [
    "name = input('What is your name? ')  # Mason\n",
    "\n",
    "if name in students:\n",
    "    print('Your name is on the list.')\n",
    "else:\n",
    "    print('Your name is not on the list!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objects as Condition\n",
    "\n",
    "Any object is evaluated to `True` or `False`. In Python all empty built-in datatypes are evaluated to `False` and in other situations evaluated to `True`. As we told, `bool` function get the object and return evaluated result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List is true.\n"
     ]
    }
   ],
   "source": [
    "if [False]:\n",
    "    print('List is true.')\n",
    "else:\n",
    "    print('List is false.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops\n",
    "\n",
    "When you need to do repetitive tasks you have to use loops.\n",
    "\n",
    "Python have `for` and `while` loop.\n",
    "\n",
    "## For\n",
    "\n",
    "For loop is almost used for iterating over a sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We should buy Egg.\n",
      "This is another print function.\n",
      "We should buy Milk.\n",
      "This is another print function.\n",
      "We should buy ....\n",
      "This is another print function.\n"
     ]
    }
   ],
   "source": [
    "shop_list = ['Egg', 'Milk', '...']\n",
    "\n",
    "for item in shop_list:\n",
    "    print('We should buy {}.'.format(item))\n",
    "    print('This is another print function.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Which factorial number to calculate? 10\n",
      "Factorial of 10 is 3628800.\n"
     ]
    }
   ],
   "source": [
    "number = int(input('Which factorial number to calculate? '))\n",
    "\n",
    "total = 1\n",
    "for i in range(1, number + 1):\n",
    "    total *= i\n",
    "\n",
    "print('Factorial of {} is {}.'.format(number, total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "* Get a number from user and print all prime numbers less than that number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number to get all prime numbers less than that: 100\n",
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n"
     ]
    }
   ],
   "source": [
    "biggest_num = int(input('Enter a number to get all prime numbers less than that: '))\n",
    "\n",
    "primes = []\n",
    "for num in range(2, biggest_num):\n",
    "    is_prime = True\n",
    "    \n",
    "    for prime in primes:\n",
    "        if num % prime == 0:\n",
    "            is_prime = False\n",
    "    \n",
    "    if is_prime:\n",
    "        primes.append(num)\n",
    "\n",
    "print(primes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2305567963945518424753102147331756070\n"
     ]
    }
   ],
   "source": [
    "total = 1\n",
    "\n",
    "for prime in primes:\n",
    "    total *= prime\n",
    "    \n",
    "print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With key سلام we get value Hello.\n",
      "With key 1396 we get value 2017.\n",
      "With key خدانگهدار we get value Goodbye.\n",
      "With key پایتون we get value Python.\n",
      "With key ('شنبه', 'یک شنبه', 'دو شنبه') we get value ('saturday', 'sunday', 'monday').\n",
      "With key خوبی؟ we get value How is it going?.\n"
     ]
    }
   ],
   "source": [
    "for key in per2eng_dict:\n",
    "    print('With key {} we get value {}.'\\\n",
    "          .format(key, per2eng_dict[key]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While\n",
    "\n",
    "This loop is used for situation when we don't know exactly when we should stop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess a number: 500\n",
      "Bigger!\n",
      "Guess a number: 250\n",
      "Bigger!\n",
      "Guess a number: 125\n",
      "Smaller!\n",
      "Guess a number: 175\n",
      "Bigger!\n",
      "Guess a number: 150\n",
      "Smaller!\n",
      "Guess a number: 165\n",
      "Bigger!\n",
      "Guess a number: 160\n",
      "Smaller!\n",
      "Guess a number: 162\n",
      "Bigger!\n",
      "Guess a number: 161\n",
      "BINGO\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "selected_num = randint(1, 1000)\n",
    "\n",
    "num = 1\n",
    "while num != selected_num:\n",
    "    num = int(input('Guess a number: '))\n",
    "    if num < selected_num:\n",
    "        print('Smaller!')\n",
    "    elif num > selected_num:\n",
    "        print('Bigger!')\n",
    "    else:\n",
    "        print('BINGO')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the password: test\n",
      "Password was incorrect!\n",
      "Please enter correct password: password\n",
      "Password was incorrect!\n",
      "Please enter correct password: wonder woman\n"
     ]
    }
   ],
   "source": [
    "password = input('Enter the password: ')\n",
    "while password != 'wonder woman':\n",
    "    password = input('Password was incorrect!\\nPlease enter correct password: ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Break\n",
    "\n",
    "Maybe you have complex situation that need to be checked and if they come true, the loop should stop. For this purpose you can use `break` inside a loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter numbers to get total, finish with 0.\n",
      "Enter your number: 4\n",
      "Enter your number: 5\n",
      "Enter your number: 1\n",
      "Enter your number: -10\n",
      "Enter your number: 0\n",
      "Total: 0\n"
     ]
    }
   ],
   "source": [
    "print('Enter numbers to get total, finish with 0.')\n",
    "\n",
    "total = 0\n",
    "while True:\n",
    "    num = int(input('Enter your number: '))\n",
    "    if num == 0:\n",
    "        break\n",
    "    total += num\n",
    "\n",
    "print('Total: {}'.format(total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Continue\n",
    "\n",
    "If you wanted to skip rest of a loop execution, you can use `continue`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number to get total, finish with 0. Negative numbers are ignored.\n",
      "Enter your number: 4\n",
      "Enter your number: 5\n",
      "Enter your number: 1\n",
      "Enter your number: -10\n",
      "Enter your number: 0\n",
      "Total: 10\n"
     ]
    }
   ],
   "source": [
    "print('Enter number to get total, finish with 0. Negative numbers are ignored.')\n",
    "\n",
    "total = 0\n",
    "while True:\n",
    "    num = int(input('Enter your number: '))\n",
    "    if num < 0:\n",
    "        continue\n",
    "    elif num == 0:\n",
    "        break\n",
    "    total += num\n",
    "    \n",
    "print('Total: {}'.format(total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprehensions\n",
    "\n",
    "To create some of built-in datatypes you need use loops. For example to get students names and put them in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a name: Alice\n",
      "Enter a name: Bob\n",
      "Enter a name: Jack\n",
      "Enter a name: Sophia\n",
      "Enter a name: Sara\n",
      "['Alice', 'Bob', 'Jack', 'Sophia', 'Sara']\n"
     ]
    }
   ],
   "source": [
    "students = []\n",
    "\n",
    "for i in range(5):\n",
    "    student_name = input('Enter a name: ')\n",
    "    students.append(student_name)\n",
    "\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a name: 1\n",
      "Enter a name: 2\n",
      "Enter a name: 3\n",
      "Enter a name: 4\n",
      "Enter a name: 5\n",
      "['1', '2', '3', '4', '5']\n"
     ]
    }
   ],
   "source": [
    "students = [input('Enter a name: ') for i in range(5)]  # Shorter and faster way to do it.\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Get a number from user and create a list with comprehension that contains square of numbers in range [1, user_number)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 10\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "user_num = int(input('Enter a number: '))\n",
    "\n",
    "numbers = [num**2 for num in range(1, user_num + 1)]\n",
    "\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use comprehension with lists, set and dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many number you have? 5\n",
      "Enter a number: 1\n",
      "Enter a number: 2\n",
      "Enter a number: 1\n",
      "Enter a number: 2\n",
      "Enter a number: 3\n",
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "num_count = int(input('How many number you have? '))\n",
    "unique_nums = {int(input('Enter a number: '))\\\n",
    "               for i in range(num_count)}\n",
    "print(unique_nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many words you want in your dictionary? ۳\n",
      "Enter persian translation of your word: hi\n",
      "Enter english word: سلام\n",
      "Enter persian translation of your word: test\n",
      "Enter english word: تست\n",
      "Enter persian translation of your word: test2\n",
      "Enter english word: تست۲\n",
      "{'سلام': 'hi', 'تست': 'test', 'تست۲': 'test2'}\n"
     ]
    }
   ],
   "source": [
    "num_of_words = int(input('How many words you want in your dictionary? '))\n",
    "eng2per = {input('Enter english word: '):\\\n",
    "           input('Enter persian translation of your word: ')\\\n",
    "           for i in range(num_of_words)}\n",
    "print(eng2per)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Omiting\n",
    "\n",
    "Maybe you don't want all of the thing you have, get into your list, set or dictionary, well you can use if statement for that in comprehensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['restaurant', 'reviews', 'expectations', 'service', 'full']\n"
     ]
    }
   ],
   "source": [
    "words = [\"Trip\", \"restaurant\", \"GOOD\", \"reviews\", \"expectations\", \"hIGh\",\"service\", \"SLOW\", \"full\"]\n",
    "lowercase_words = [word for word in words if word.islower()]\n",
    "print(lowercase_words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nesting\n",
    "\n",
    "You can nest loops for complex results like multiplication table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size of multiplication table: 5\n",
      "[[1]]\n",
      "\n",
      "[[1, 2]]\n",
      "\n",
      "[[1, 2, 3]]\n",
      "\n",
      "[[1, 2, 3, 4]]\n",
      "\n",
      "[[1, 2, 3, 4, 5]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8, 12]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8, 12, 16]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8, 12, 16, 20]]\n",
      "\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8, 12, 16, 20], [5]]\n",
      "\n",
      "[[1, 2, 3, 4, 5],\n",
      " [2, 4, 6, 8, 10],\n",
      " [3, 6, 9, 12, 15],\n",
      " [4, 8, 12, 16, 20],\n",
      " [5, 10]]\n",
      "\n",
      "[[1, 2, 3, 4, 5],\n",
      " [2, 4, 6, 8, 10],\n",
      " [3, 6, 9, 12, 15],\n",
      " [4, 8, 12, 16, 20],\n",
      " [5, 10, 15]]\n",
      "\n",
      "[[1, 2, 3, 4, 5],\n",
      " [2, 4, 6, 8, 10],\n",
      " [3, 6, 9, 12, 15],\n",
      " [4, 8, 12, 16, 20],\n",
      " [5, 10, 15, 20]]\n",
      "\n",
      "[[1, 2, 3, 4, 5],\n",
      " [2, 4, 6, 8, 10],\n",
      " [3, 6, 9, 12, 15],\n",
      " [4, 8, 12, 16, 20],\n",
      " [5, 10, 15, 20, 25]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from pprint import pprint\n",
    "\n",
    "size = int(input('Enter size of multiplication table: '))\n",
    "mul_tab = []\n",
    "for row in range(1, size + 1):\n",
    "    mul_tab.append([])\n",
    "    for column in range(1, size + 1):\n",
    "        mul_tab[-1].append(row * column)\n",
    "        pprint(mul_tab)\n",
    "        print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can nest loops with comprehension too!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size of multiplication table: 5\n",
      "[[1, 2, 3, 4, 5],\n",
      " [2, 4, 6, 8, 10],\n",
      " [3, 6, 9, 12, 15],\n",
      " [4, 8, 12, 16, 20],\n",
      " [5, 10, 15, 20, 25]]\n"
     ]
    }
   ],
   "source": [
    "from pprint import pprint  # Better way\n",
    "\n",
    "size = int(input('Enter size of multiplication table: '))\n",
    "mul_tab = [[row*col for col in range(1, size + 1)] for row in range(1, size + 1)]\n",
    "\n",
    "pprint(mul_tab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way of nesting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 20, 25}\n"
     ]
    }
   ],
   "source": [
    "mul_tab_nums = {num for row in mul_tab for num in row}\n",
    "print(mul_tab_nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "* Write a program and generate fibonacci numbers.\n",
    "    * `1 1 2 3 5 8 13 21 34 55 ...`\n",
    "* Find greatest common divisor of two positive numbers.\n",
    "    * GCD of A and B == GCD of B and A%B (A>=B)\n",
    "* Generate a triangle with comprehensions.\n",
    "\n",
    "```python\n",
    "*\n",
    "**\n",
    "***\n",
    "****\n",
    "*****\n",
    "******\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter fibo count: 10\n",
      "[None, None, None, None, None, None, None, None]\n",
      "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n"
     ]
    }
   ],
   "source": [
    "fibo_num = [1, 1]\n",
    "\n",
    "fibo_count = int(input('Enter fibo count: '))\n",
    "\n",
    "# for i in range(2, fibo_count):\n",
    "#     fibo_num.append(fibo_num[-1] + fibo_num[-2])\n",
    "\n",
    "nothing = [fibo_num.append(fibo_num[-1] + fibo_num[-2])\n",
    " for i in range(2, fibo_count)]\n",
    "\n",
    "print(nothing)\n",
    "\n",
    "\n",
    "print(fibo_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number: 23\n",
      "Enter second number: 17\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "num1, num2 = int(input('Enter first number: ')), int(input('Enter second number: '))\n",
    "\n",
    "while num1 % num2 != 0:\n",
    "    num1, num2 = num2, num1 % num2\n",
    "\n",
    "print(num2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "JodiAliceBob\n"
     ]
    }
   ],
   "source": [
    "names = ['Jodi', 'Alice', 'Bob']\n",
    "print(''.join(names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of triangle: 5\n",
      "*\n",
      "**\n",
      "***\n",
      "****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "size = int(input('Size of triangle: '))\n",
    "\n",
    "for row in range(1, size + 1): # [start, stop)\n",
    "    stars = []\n",
    "    for i in range(row):\n",
    "        stars.append('*')\n",
    "#     print(stars)\n",
    "    print(''.join(stars))\n",
    "#     print('*' * row)\n",
    "\n",
    "# print('\\n'.join(['*' * row \n",
    "#                  for row in range(1, size + 1)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "Some parts of code is going to be reused again and again and again, we can't write them again and again and again! Remember don't repeat yourself (**DRY**). Function are reusable block of code that make coding easy. We can split tasks to function and use them any where. Functions improve readability and hide complexity.\n",
    "\n",
    "Generally in Python function take zero, one or more input (called arguments) and return exactly one output (called returned value)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Alice\n",
      "Hello Jack\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def greeting(name):\n",
    "    print('Hello {}'.format(name))\n",
    "\n",
    "greeting('Alice')\n",
    "print(greeting('Jack'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each function should have a very specific job and should not alter anything that is not necessary. So we can rewrite above code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Alice\n",
      "Hello Bob\n"
     ]
    }
   ],
   "source": [
    "def greeting(name):\n",
    "    return 'Hello {}'.format(name)\n",
    "\n",
    "print(greeting('Alice'))\n",
    "print(greeting('Bob'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arguments\n",
    "\n",
    "A function can take multiple arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3, 4, 5, 6, 7, 8],\n",
      " [2, 4, 6, 8, 10, 12, 14, 16],\n",
      " [3, 6, 9, 12, 15, 18, 21, 24],\n",
      " [4, 8, 12, 16, 20, 24, 28, 32]]\n"
     ]
    }
   ],
   "source": [
    "from pprint import pprint\n",
    "\n",
    "def multiplication_table(row, column):\n",
    "    return [[i*j for j in range(1, column + 1)] for i in range(1, row + 1)]\n",
    "\n",
    "pprint(multiplication_table(4, 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pass by Value or Refrence\n",
    "\n",
    "Mutable and immutable values behave different when passed to a function. Mutable variables is pass by refrence but immutable variables is pass by value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 2, 9, 1]\n",
      "a_string is \"TWO, ONE\"\n",
      "TWO, \n"
     ]
    }
   ],
   "source": [
    "def add_one(a_list):  # Mutable\n",
    "    a_list.append(1)\n",
    "\n",
    "num_list = [3, 2, 9]\n",
    "add_one(num_list)\n",
    "print(num_list)\n",
    "\n",
    "def add_one(a_string):  # Immutable\n",
    "    a_string += 'ONE'\n",
    "    print('a_string is \"{}\"'.format(a_string))\n",
    "\n",
    "numbers = 'TWO, '\n",
    "add_one(numbers)\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Labeled Arguments\n",
    "\n",
    "You can explicitly pass an argument by using name of that argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],\n",
      " [2, 4, 6, 8, 10, 12, 14, 16, 18, 20],\n",
      " [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]]\n"
     ]
    }
   ],
   "source": [
    "pprint(multiplication_table(column=10, row=3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default Values\n",
    "\n",
    "Function arguments can have default values. Remember all arguments with default values should be last arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],\n",
      " [2, 4, 6, 8, 10, 12, 14, 16, 18, 20],\n",
      " [3, 6, 9, 12, 15, 18, 21, 24, 27, 30],\n",
      " [4, 8, 12, 16, 20, 24, 28, 32, 36, 40],\n",
      " [5, 10, 15, 20, 25, 30, 35, 40, 45, 50],\n",
      " [6, 12, 18, 24, 30, 36, 42, 48, 54, 60],\n",
      " [7, 14, 21, 28, 35, 42, 49, 56, 63, 70],\n",
      " [8, 16, 24, 32, 40, 48, 56, 64, 72, 80],\n",
      " [9, 18, 27, 36, 45, 54, 63, 72, 81, 90],\n",
      " [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]]\n"
     ]
    }
   ],
   "source": [
    "def multiplication_table(row=10, column=10):\n",
    "    return [[i*j for j in range(1, column + 1)] for i in range(1, row + 1)]\n",
    "\n",
    "pprint(multiplication_table())  # Use default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3, 4, 5],\n",
      " [2, 4, 6, 8, 10],\n",
      " [3, 6, 9, 12, 15],\n",
      " [4, 8, 12, 16, 20],\n",
      " [5, 10, 15, 20, 25]]\n"
     ]
    }
   ],
   "source": [
    "pprint(multiplication_table(5, 5))  # Don't use default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],\n",
      " [2, 4, 6, 8, 10, 12, 14, 16, 18, 20],\n",
      " [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]]\n"
     ]
    }
   ],
   "source": [
    "pprint(multiplication_table(3))  # Pass first argument and use second default value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3],\n",
      " [2, 4, 6],\n",
      " [3, 6, 9],\n",
      " [4, 8, 12],\n",
      " [5, 10, 15],\n",
      " [6, 12, 18],\n",
      " [7, 14, 21],\n",
      " [8, 16, 24],\n",
      " [9, 18, 27],\n",
      " [10, 20, 30]]\n"
     ]
    }
   ],
   "source": [
    "pprint(multiplication_table(column=3))  # Even pass second value and use first default value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Arguments\n",
    "\n",
    "Function can get arguments of any count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "def total_of(*numbers):\n",
    "    total = 0\n",
    "    for number in numbers:\n",
    "        total += number\n",
    "    return total\n",
    "\n",
    "print(total_of(1, 2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1933951\n"
     ]
    }
   ],
   "source": [
    "print(total_of(9018, 8712, 2376, 19, 268, 683, 1912875))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(total_of())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword Arguments\n",
    "\n",
    "Function arguments even can be labeled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'hi': 'سلام', 'hello': 'سلام', 'goodbye': 'خداحافظ'}\n"
     ]
    }
   ],
   "source": [
    "def keywords(**kwargs):\n",
    "    return(kwargs)\n",
    "\n",
    "print(keywords(hi='سلام', hello='سلام', goodbye='خداحافظ'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function arguments have order to use, positional args, list args, keyword args."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First:  1\n",
      "Second: 2\n",
      "Third:  3\n",
      "Fourth: 4\n",
      "Fifth:  (5, 6)\n",
      "Sixth:  {'test': 123}\n"
     ]
    }
   ],
   "source": [
    "def function(first, second, third=3, fourth='four', *fifth, **sixth):\n",
    "    print('First:  {}'.format(first))\n",
    "    print('Second: {}'.format(second))\n",
    "    print('Third:  {}'.format(third))\n",
    "    print('Fourth: {}'.format(fourth))\n",
    "    print('Fifth:  {}'.format(fifth))\n",
    "    print('Sixth:  {}'.format(sixth))\n",
    "\n",
    "function(1, 2, 3, 4, 5, 6, test=123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First:  1\n",
      "Second: 2\n",
      "Third:  3\n",
      "Fourth: four\n",
      "Fifth:  ()\n",
      "Sixth:  {}\n"
     ]
    }
   ],
   "source": [
    "function(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First:  1\n",
      "Second: 2\n",
      "Third:  3\n",
      "Fourth: four\n",
      "Fifth:  ()\n",
      "Sixth:  {'test': 'keyword'}\n"
     ]
    }
   ],
   "source": [
    "function(1, 2, test='keyword')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Return\n",
    "\n",
    "Each function always return exactly one data even when you don't return anything!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def no_return():\n",
    "    pass\n",
    "\n",
    "result = no_return()\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With Python function you can simply return multiple values. They will be pack as a single tuple and returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Values: ('Lightning McQueen', 11, ['Mater', 'Chick Hicks', 'Sally Carrera', 'Doc Hudson'])\n",
      "Name: Lightning McQueen, Age: 11, Partners: ['Mater', 'Chick Hicks', 'Sally Carrera', 'Doc Hudson']\n"
     ]
    }
   ],
   "source": [
    "def multiple_value_returned():\n",
    "    return 'Lightning McQueen', 11, ['Mater', 'Chick Hicks', 'Sally Carrera', 'Doc Hudson']\n",
    "\n",
    "values = multiple_value_returned()               # Single variable to store.\n",
    "name, age, partners = multiple_value_returned()  # Multiple variables to store.\n",
    "\n",
    "print(\"Values: {}\".format(values))\n",
    "print(\"Name: {}, Age: {}, Partners: {}\".format(name, age, partners))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scope\n",
    "\n",
    "Each function have its one scope of variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age: 12\n",
      "Shopping List: ['Milk', 'Egg']\n",
      "Func -> Age: 13\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'var_in_func' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-defa0c0d63ec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvar_in_func\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'var_in_func' is not defined"
     ]
    }
   ],
   "source": [
    "name = 'Tonto'\n",
    "\n",
    "if name == 'Tonto':\n",
    "    age = 12\n",
    "\n",
    "print('Age: {}'.format(age))\n",
    "\n",
    "while age == 12:\n",
    "    age += 1\n",
    "    shopping_list = ['Milk', 'Egg']\n",
    "\n",
    "print('Shopping List: {}'.format(shopping_list))\n",
    "\n",
    "def func():\n",
    "    print('Func -> Age: {}'.format(age))\n",
    "#     print('Func -> Shopping List: {}'.format(shop_list))\n",
    "    var_in_func = 'Function'\n",
    "\n",
    "func()\n",
    "print(var_in_func)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Global and Nonlocal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Documentation\n",
    "\n",
    "Packages, modules, classes and functions all have docstrings. For complete information read docstring conventions, [PEP257](https://www.python.org/dev/peps/pep-0257/).\n",
    "\n",
    "A triple double quoted string at first line of the function is a docstring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function multiplication_table in module __main__:\n",
      "\n",
      "multiplication_table(row=10, column=10)\n",
      "    Get number of rows and columns of multiplication table then generate and returns a two dimensions list.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def multiplication_table(row=10, column=10):\n",
    "    \"\"\"Get number of rows and columns of multiplication table then generate and returns a two dimensions list.\"\"\"\n",
    "    return [[i*j for j in range(1, column + 1)] for i in range(1, row + 1)]\n",
    "\n",
    "help(multiplication_table)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## lambda\n",
    "\n",
    "We can define nameless functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "square = lambda x: x**2\n",
    "print(square(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Everything about function arguments works with lambda functions too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Hello', 3, {'keyword': 'argument'})\n"
     ]
    }
   ],
   "source": [
    "print((lambda a, b=3, **kwargs: (a, b, kwargs))('Hello', keyword='argument'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recursive Functions\n",
    "\n",
    "If you call a function inside itself, it is called recursive function. Recursive function are useful for solving some complex algorithmic problems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3628800\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    return factorial(n - 1) * n\n",
    "\n",
    "print(factorial(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First -> Third\n",
      "First -> Second\n",
      "Third -> Second\n",
      "First -> Third\n",
      "Second -> First\n",
      "Second -> Third\n",
      "First -> Third\n"
     ]
    }
   ],
   "source": [
    "def move_disks3(n, source, intermediate, destination):\n",
    "    \"\"\"Print movee needed to move disks in source tower to destination tower.\n",
    "    \n",
    "    @param int n: Number of disk in source tower.\n",
    "    @param int source: Name of the source tower.\n",
    "    @param int intermediate: Name of intermediate tower.\n",
    "    @param int destination: Name of destination tower.\n",
    "    @rtype: None\n",
    "    \"\"\"\n",
    "    if n > 1:\n",
    "        move_disks3(n - 1, source, destination, intermediate)\n",
    "        move_disks3(1, source, intermediate, destination)\n",
    "        move_disks3(n - 1, intermediate, source, destination)\n",
    "    else:\n",
    "        print(\"{} -> {}\".format(source,destination))\n",
    "\n",
    "move_disks3(3, 'First', 'Second', 'Third')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "* GCD recursive function.\n",
    "* All prime number between two intervals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "def gcd(num1, num2):\n",
    "    \"\"\"This function calculate GCD of two numbers with recursive function.\"\"\"\n",
    "    return gcd(num2, num1%num2) if num2 else num1\n",
    "\n",
    "print(gcd(45, 33))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1009 is a prime number.\n",
      "1013 is a prime number.\n",
      "1019 is a prime number.\n",
      "1021 is a prime number.\n",
      "1031 is a prime number.\n",
      "1033 is a prime number.\n",
      "1039 is a prime number.\n",
      "1049 is a prime number.\n"
     ]
    }
   ],
   "source": [
    "def prime_range(start, stop):\n",
    "    primes = []\n",
    "    \n",
    "    for number in range(start, stop):\n",
    "        is_prime = True\n",
    "        \n",
    "        for i in range(2, number):\n",
    "            if number % i == 0:\n",
    "                is_prime = False\n",
    "                break\n",
    "        \n",
    "        if is_prime:\n",
    "            primes.append(number)\n",
    "\n",
    "    return primes\n",
    "\n",
    "for prime in prime_range(1000, 1050):\n",
    "    print('{} is a prime number.'.format(prime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (stop)\n",
    "# (start, stop)\n",
    "# (start, stop, step)\n",
    "\n",
    "def prime_range(start=None, stop=None, step=None):\n",
    "    \"\"\"A function with parameter that is completely like\n",
    "    range function but instead of generate natural numbers\n",
    "    here the function generates prime numbers.\"\"\"\n",
    "    \n",
    "    # Evaluate start, stop and step by what user of this\n",
    "    # function code want it to do.\n",
    "    if start is None:\n",
    "        print('WRONG')\n",
    "        return\n",
    "    elif stop is None:\n",
    "        start, stop, step = 2, start, 1\n",
    "    elif step is None:\n",
    "        step = 1\n",
    "    \n",
    "    # A list to store all primes that I found.\n",
    "    primes = []\n",
    "    \n",
    "    # Generate all primes from start to stop.\n",
    "    for number in range(start, stop):\n",
    "        is_prime = True\n",
    "        \n",
    "        for i in range(2, number):\n",
    "            if number % i == 0:\n",
    "                is_prime = False\n",
    "                break\n",
    "        \n",
    "        if is_prime:\n",
    "            primes.append(number)\n",
    "\n",
    "    # Slice primes with step that user wants and return\n",
    "    # it.\n",
    "    return primes[::step]\n",
    "\n",
    "for prime in prime_range(1000, 1050):\n",
    "    print('{} is a prime number.'.format(prime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1009 is a prime number.\n",
      "1013 is a prime number.\n",
      "1019 is a prime number.\n",
      "1021 is a prime number.\n",
      "1031 is a prime number.\n",
      "1033 is a prime number.\n",
      "1039 is a prime number.\n",
      "1049 is a prime number.\n",
      "[2, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "print(prime_range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 7, 11, 13]\n"
     ]
    }
   ],
   "source": [
    "print(prime_range(5, 15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 29, 47, 71, 97]\n"
     ]
    }
   ],
   "source": [
    "print(prime_range(10, 100, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def prime_range(*args):\n",
    "    \"\"\"A function with parameter that is completely like\n",
    "    range function but instead of generate natural numbers\n",
    "    here the function generates prime numbers.\"\"\"\n",
    "    \n",
    "    # Evaluate start, stop and step by what user of this\n",
    "    # function code want it to do.\n",
    "    if len(args) == 1:\n",
    "        start, stop, step = 2, args[0], 1\n",
    "    elif len(args) == 2:\n",
    "        start, stop, step = args[0], args[1], 1\n",
    "    elif len(args) == 3:\n",
    "        start, stop, step = args\n",
    "    else:\n",
    "        print('WRONG')\n",
    "        return\n",
    "    \n",
    "    # A list to store all primes that I found.\n",
    "    primes = []\n",
    "    \n",
    "    # Generate all primes from start to stop.\n",
    "    for number in range(start, stop):\n",
    "        is_prime = True\n",
    "        \n",
    "        for i in range(2, number):\n",
    "            if number % i == 0:\n",
    "                is_prime = False\n",
    "                break\n",
    "        \n",
    "        if is_prime:\n",
    "            primes.append(number)\n",
    "\n",
    "    # Slice primes with step that user wants and return\n",
    "    # it.\n",
    "    return primes[::step]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in Functions\n",
    "\n",
    "Python have built-in functions to help easy coding."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### help\n",
    "\n",
    "Print a documentation on object passed to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on _Helper in module _sitebuiltins object:\n",
      "\n",
      "class _Helper(builtins.object)\n",
      " |  Define the builtin 'help'.\n",
      " |  \n",
      " |  This is a wrapper around pydoc.help that provides a helpful message\n",
      " |  when 'help' is typed at the Python interactive prompt.\n",
      " |  \n",
      " |  Calling help() at the Python prompt starts an interactive help session.\n",
      " |  Calling help(thing) prints help for the python object 'thing'.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __call__(self, *args, **kwds)\n",
      " |      Call self as a function.\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(help)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### print\n",
    "\n",
    "We work with this one so many times. Print function have 3 labeled arguments:\n",
    "* `end`: Specify how to end a printed text.\n",
    "* `sep`: Specify separation of each argument passed to `print` function.\n",
    "* `file`: Specify a file to print text into that file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "print(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(1, 2, 3, sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1, 2, 3.Hello\n"
     ]
    }
   ],
   "source": [
    "print(1, 2, 3, sep=', ', end='.')\n",
    "print('Hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### len\n",
    "\n",
    "Get length of an object. You can define length of each object you define. Sequences and collections have length."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### bool\n",
    "\n",
    "Return evaluted boolean value of an object. You can define boolean value of objects you define."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### str\n",
    "\n",
    "Convert object passed to it, to string representaion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### int\n",
    "\n",
    "Convert object passed to it, to integer values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### set\n",
    "\n",
    "Convert a sequence passed to it, to a set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### list\n",
    "\n",
    "Convert a sequence passed to it, to a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### dict\n",
    "\n",
    "Defining a dictionary with keyword argument of a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Bob': 'C', 'Joe': 'A', 'Alice': 'B+'}\n"
     ]
    }
   ],
   "source": [
    "marks = dict(Joe='A', Bob='C', Alice='B+')\n",
    "print(marks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tuple\n",
    "\n",
    "Convert a sequence passed to it, to a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### range\n",
    "\n",
    "Get three arguments, `start`, `stop` and `step` and return an iterable object that count from start (including) to stop (excluding) with specified steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(1, 10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 7]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(1, 10, 3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### zip\n",
    "\n",
    "Get any number of sequences and work exactly like a zip!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 'one'), (2, 'two'), (3, 'three')]\n"
     ]
    }
   ],
   "source": [
    "print(list(zip([1, 2, 3], ('one', 'two','three'))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 'a'), (2, 'is'), (3, 'set'), (4, 'this')]\n"
     ]
    }
   ],
   "source": [
    "print(list(zip(range(1, 5), {'this', 'is', 'a', 'set'})))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, '1', 'one'), (2, '2', 'two'), (3, '3', 'three')]\n"
     ]
    }
   ],
   "source": [
    " print(list(zip([1, 2, 3], ['1', '2', '3'], ['one', 'two', 'three'])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map\n",
    "\n",
    "You should give one function with `N` arguments, as the first argument of `map` function and then give it `N` sequences with same length. It will calculate function with those and save the output as a new sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1048576, 205891132094649]\n"
     ]
    }
   ],
   "source": [
    "print(list(map(lambda x, y: x**y, [1, 2, 3], [10, 20, 30])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### filter\n",
    "\n",
    "As the name says, it is used to filter some of object out. The first parameter would be a function that if returns `True` the object stays, it returns `false` the object is filtered."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n",
      "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n"
     ]
    }
   ],
   "source": [
    "numbers = list(range(1, 20))\n",
    "print(numbers)\n",
    "\n",
    "print(list(filter(lambda x: x%2, numbers)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### min/max\n",
    "\n",
    "Get a sequence and compare each of objects inside the sequence with each other and return minimum/maximum value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min: \" \", Max: \"r\"\n"
     ]
    }
   ],
   "source": [
    "greeting ='Hello World!'\n",
    "print('Min: \"{}\", Max: \"{}\"'.format(min(greeting), max(greeting)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min: -52, Max: 158\n"
     ]
    }
   ],
   "source": [
    "numbers = [12, 6, 47, -52, 158]\n",
    "print('Min: {}, Max: {}'.format(min(numbers), max(numbers)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min: -52, Max: 158\n"
     ]
    }
   ],
   "source": [
    "numbers = {12, 6, 47, -52, 158}\n",
    "print('Min: {}, Max: {}'.format(min(numbers), max(numbers)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min: John, Max: Sophia\n"
     ]
    }
   ],
   "source": [
    "marks = {'John': 18, 'Sophia': 12, 'Sara': 16.7}\n",
    "print('Min: {}, Max: {}'.format(min(marks), max(marks)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Useful Tips\n",
    "* Functions should do one thing.\n",
    "* Functions should be small.\n",
    "* The fewer input parameters, the better.\n",
    "* Functions should be consistent in their return values.\n",
    "Functions shouldn't have side effects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "* Create a function that take a number of digit for precision and calculate $\\pi$ with formula below.\n",
    "\n",
    "$$\\frac{\\pi}{2} = 1 + \\frac{1}{3} + \\frac{1 \\times 2}{3 \\times 5} + \\frac{1 \\times 2 \\times 3}{3 \\times 5 \\times 7} + \\dots$$\n",
    "\n",
    "Default precision should be 5 digits. You have to write proper documentation for your function.\n",
    "\n",
    "* Print factors of a number (You will need a prime number generator function).\n",
    "\n",
    "$$ 12 = 2^2 \\times 3^1 $$\n",
    "\n",
    "```python\n",
    "[(2, 2), (3, 1)]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1415926331440347\n"
     ]
    }
   ],
   "source": [
    "def fraction(frac_num):\n",
    "    result = 1.0\n",
    "    \n",
    "    for i in range(1, frac_num + 1):\n",
    "        result *= i/(2*i+1)\n",
    "    \n",
    "    return result\n",
    "\n",
    "    \n",
    "def pi(precision=5):\n",
    "    total = 0.0\n",
    "    \n",
    "    i = 0\n",
    "    while fraction(i) > 10**-precision:\n",
    "        total += fraction(i)\n",
    "        i += 1\n",
    "    \n",
    "    return total * 2\n",
    "\n",
    "print(pi(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(2017, 1)]\n"
     ]
    }
   ],
   "source": [
    "def factors(number):\n",
    "    result = []\n",
    "        \n",
    "    for prime in prime_range(number + 1):\n",
    "        # Find the right superscript for specific prime number.\n",
    "        superscript = 0\n",
    "        while number % prime == 0:\n",
    "            number /= prime\n",
    "            superscript += 1\n",
    "        # If superscript is bigger that zero, we add it to result\n",
    "        if superscript:\n",
    "            result.append((prime, superscript))\n",
    "    \n",
    "    return result\n",
    "\n",
    "print(factors(2017))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(2, 3), (3, 1), (5, 3), (7, 1)]\n"
     ]
    }
   ],
   "source": [
    "print(factors(21000))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Files\n",
    "\n",
    "All data we have is store in files. Even this document you are reading is store in a file. Python have very good API and very very libraries to work with files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First file operation.\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Simple reading from file.\n",
    "\n",
    "hello = open('hello')\n",
    "print(hello.read())\n",
    "print(hello.read())\n",
    "hello.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `open` function first argument is a path to file, second argument is to specify which mode to open the file.\n",
    "\n",
    "Modes to open a file is:\n",
    "\n",
    "|Character|                            Meaning                            |\n",
    "|:-------:|:--------------------------------------------------------------|\n",
    "|    r    |open for reading (default)                                     |\n",
    "|    w    |open for writing, truncating the file first                    |\n",
    "|    x    |open for exclusive creation, failing if the file already exists|\n",
    "|    a    |open for writing, appending to the end of the file if it exists|\n",
    "|    b    |binary mode                                                    |\n",
    "|    t    |text mode (default)                                            |\n",
    "|    +    |open a disk file for updating (reading and writing)            |\n",
    "|    U    |universal newlines mode (deprecated)                           |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line Number 1.\n",
      "Line Number 2.\n",
      "Line Number 3.\n",
      "Line Number 4.\n",
      "Line Number 5.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def rwfile_test():\n",
    "    rwfile = open('rwfile', 'a+')\n",
    "    rwfile.seek(0, 0)\n",
    "    data = rwfile.read()\n",
    "    line_count = data.count('\\n')\n",
    "    print('Line Number {}.'.format(line_count + 1), file=rwfile)\n",
    "    rwfile.close()\n",
    "\n",
    "open('rwfile', 'w').close()  # Clear file.\n",
    "for i in range(5):\n",
    "    rwfile_test()\n",
    "\n",
    "print(open('rwfile').read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save Objects\n",
    "\n",
    "You can even save your objects to a file. `pickle` module can do that for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milk\n"
     ]
    }
   ],
   "source": [
    "# Sample save and load binary object to a file in binary mode.\n",
    "\n",
    "from pickle import dump, load\n",
    "\n",
    "shopping_list = ['Milk', 'Egg', 'Bread', 'Sugar']\n",
    "\n",
    "shopping_list_file = open('shop-list-file', 'wb')\n",
    "dump(shopping_list, shopping_list_file)\n",
    "shopping_list_file.close()\n",
    "\n",
    "shopping_list_file = open('shop-list-file', 'rb')\n",
    "loaded_shopping_list = load(shopping_list_file)\n",
    "print(loaded_shopping_list[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Easier File Handeling\n",
    "\n",
    "For each file you should open it to use and then you have to close it. Without closing file, changes that you made to file will be ignored!\n",
    "\n",
    "It is easier to use `with` statement instead of opening and closing a file yourself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line Number 1.\n",
      "Line Number 2.\n",
      "Line Number 3.\n",
      "Line Number 4.\n",
      "Line Number 5.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open('rwfile') as rwfile:\n",
    "    print(rwfile.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "* Write program that if a file exists, read it and print the list in the file. Then get list of names from user and add names to the file.\n",
    "* Write a function that get a filename and return dictionary that keys are words in a file and values are number of occurences of that word.\n",
    "* Write a function that get a word and a filename and return number of occurences of the word in the filename."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Bob', 'Sara']\n",
      "Enter number of names: 3\n",
      "Name: 1\n",
      "Name: 2\n",
      "Name: 3\n"
     ]
    }
   ],
   "source": [
    "# Phase 1: Read information and write it to user.\n",
    "from pathlib import Path\n",
    "from pickle import load, dump\n",
    "\n",
    "data = Path(\"data\")\n",
    "if data.exists():\n",
    "    with open('data', 'rb') as data_file:\n",
    "        print(load(data_file))\n",
    "\n",
    "# Phase 2: Get information from user and write\n",
    "# them to file.\n",
    "\n",
    "num_of_names = int(input('Enter number of names: '))\n",
    "user_data = [input('Name: ') for i in range(num_of_names)]\n",
    "\n",
    "with open('data', 'wb') as data_file:\n",
    "    dump(user_data, data_file)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 1- Open file\n",
    "# 2- Read all of file\n",
    "# 3- Convert all file information to a words\n",
    "# 4- Count each word and create a dictionary\n",
    "# 5- Return it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "w = \"a b c d\"\n",
    "\n",
    "print(w.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'and': 2, 'like': 1, 'Programming': 1, 'comment': 3, 'Data': 1, 'names': 1, 'Oriented': 1, 'a': 2, 'Functions': 1, 'change': 1, 'book': 1, 'Search': 1, 'Write': 1, 'Sequences': 1, 'exercises': 1, 'line': 1, 'Types': 1, 'scientific': 1, 'loop': 1, 'for': 3, 'code': 1, 'proper': 1, 'Introduction': 1, 'Gather': 1, 'camel': 1, 'Separate': 1, 'Decision': 1, 'Making': 1, 'Add': 4, 'under': 1, 'lost': 1, 'front': 1, 'that': 1, 'should': 1, 'after': 1, 'each': 2, 'section': 3, 'of': 3, 'comprehension': 1, 'input': 1, 'Loops': 1, 'Move': 1, 'strings': 1, 'in': 1, 'with': 2, 'some': 1, 'see': 1, 'Object': 1, 'to': 2}\n"
     ]
    }
   ],
   "source": [
    "def frequency_of_words(filename):\n",
    "    with open(filename) as f:\n",
    "        words = f.read().split()\n",
    "        result = {word:words.count(word) for word in set(words) if word.isalpha()}\n",
    "    return result\n",
    "\n",
    "print(frequency_of_words('todo.md'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "def frequency_of_word(word, fname):\n",
    "    return frequency_of_words(filename=fname)[word]\n",
    "\n",
    "print(frequency_of_word('section', 'todo.md'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules\n",
    "\n",
    "When your project is getting bigger you have to organize your codes into different files and even different folders. To create new modules just create a file with anyname you want and then import it into your own code when you need it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3.5/datetime.py\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "print(datetime.__file__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "datetime\n"
     ]
    }
   ],
   "source": [
    "print(datetime.__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "from math import pi\n",
    "\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-08-19 10:36:33.719867\n"
     ]
    }
   ],
   "source": [
    "import datetime as dt\n",
    "print(dt.datetime.now())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module datetime:\n",
      "\n",
      "NAME\n",
      "    datetime - Fast implementation of the datetime type.\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.5/library/datetime.html\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "CLASSES\n",
      "    builtins.object\n",
      "        date\n",
      "            datetime\n",
      "        time\n",
      "        timedelta\n",
      "        tzinfo\n",
      "            timezone\n",
      "    \n",
      "    class date(builtins.object)\n",
      "     |  date(year, month, day) --> date object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __format__(...)\n",
      "     |      Formats self with strftime.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __hash__(self, /)\n",
      "     |      Return hash(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __radd__(self, value, /)\n",
      "     |      Return value+self.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      __reduce__() -> (cls, state)\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __rsub__(self, value, /)\n",
      "     |      Return value-self.\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  __sub__(self, value, /)\n",
      "     |      Return self-value.\n",
      "     |  \n",
      "     |  ctime(...)\n",
      "     |      Return ctime() style string.\n",
      "     |  \n",
      "     |  fromordinal(...) from builtins.type\n",
      "     |      int -> date corresponding to a proleptic Gregorian ordinal.\n",
      "     |  \n",
      "     |  fromtimestamp(...) from builtins.type\n",
      "     |      timestamp -> local date from a POSIX timestamp (like time.time()).\n",
      "     |  \n",
      "     |  isocalendar(...)\n",
      "     |      Return a 3-tuple containing ISO year, week number, and weekday.\n",
      "     |  \n",
      "     |  isoformat(...)\n",
      "     |      Return string in ISO 8601 format, YYYY-MM-DD.\n",
      "     |  \n",
      "     |  isoweekday(...)\n",
      "     |      Return the day of the week represented by the date.\n",
      "     |      Monday == 1 ... Sunday == 7\n",
      "     |  \n",
      "     |  replace(...)\n",
      "     |      Return date with new specified fields.\n",
      "     |  \n",
      "     |  strftime(...)\n",
      "     |      format -> strftime() style string.\n",
      "     |  \n",
      "     |  timetuple(...)\n",
      "     |      Return time tuple, compatible with time.localtime().\n",
      "     |  \n",
      "     |  today(...) from builtins.type\n",
      "     |      Current date or datetime:  same as self.__class__.fromtimestamp(time.time()).\n",
      "     |  \n",
      "     |  toordinal(...)\n",
      "     |      Return proleptic Gregorian ordinal.  January 1 of year 1 is day 1.\n",
      "     |  \n",
      "     |  weekday(...)\n",
      "     |      Return the day of the week represented by the date.\n",
      "     |      Monday == 0 ... Sunday == 6\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  day\n",
      "     |  \n",
      "     |  month\n",
      "     |  \n",
      "     |  year\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  max = datetime.date(9999, 12, 31)\n",
      "     |  \n",
      "     |  min = datetime.date(1, 1, 1)\n",
      "     |  \n",
      "     |  resolution = datetime.timedelta(1)\n",
      "    \n",
      "    class datetime(date)\n",
      "     |  datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])\n",
      "     |  \n",
      "     |  The year, month and day arguments are required. tzinfo may be None, or an\n",
      "     |  instance of a tzinfo subclass. The remaining arguments may be ints.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      datetime\n",
      "     |      date\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __hash__(self, /)\n",
      "     |      Return hash(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __radd__(self, value, /)\n",
      "     |      Return value+self.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      __reduce__() -> (cls, state)\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __rsub__(self, value, /)\n",
      "     |      Return value-self.\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  __sub__(self, value, /)\n",
      "     |      Return self-value.\n",
      "     |  \n",
      "     |  astimezone(...)\n",
      "     |      tz -> convert to local time in new timezone tz\n",
      "     |  \n",
      "     |  combine(...) from builtins.type\n",
      "     |      date, time -> datetime with same date and time fields\n",
      "     |  \n",
      "     |  ctime(...)\n",
      "     |      Return ctime() style string.\n",
      "     |  \n",
      "     |  date(...)\n",
      "     |      Return date object with same year, month and day.\n",
      "     |  \n",
      "     |  dst(...)\n",
      "     |      Return self.tzinfo.dst(self).\n",
      "     |  \n",
      "     |  fromtimestamp(...) from builtins.type\n",
      "     |      timestamp[, tz] -> tz's local time from POSIX timestamp.\n",
      "     |  \n",
      "     |  isoformat(...)\n",
      "     |      [sep] -> string in ISO 8601 format, YYYY-MM-DDTHH:MM:SS[.mmmmmm][+HH:MM].\n",
      "     |      \n",
      "     |      sep is used to separate the year from the time, and defaults to 'T'.\n",
      "     |  \n",
      "     |  now(tz=None) from builtins.type\n",
      "     |      Returns new datetime object representing current time local to tz.\n",
      "     |      \n",
      "     |        tz\n",
      "     |          Timezone object.\n",
      "     |      \n",
      "     |      If no tz is specified, uses local timezone.\n",
      "     |  \n",
      "     |  replace(...)\n",
      "     |      Return datetime with new specified fields.\n",
      "     |  \n",
      "     |  strptime(...) from builtins.type\n",
      "     |      string, format -> new datetime parsed from a string (like time.strptime()).\n",
      "     |  \n",
      "     |  time(...)\n",
      "     |      Return time object with same time but with tzinfo=None.\n",
      "     |  \n",
      "     |  timestamp(...)\n",
      "     |      Return POSIX timestamp as float.\n",
      "     |  \n",
      "     |  timetuple(...)\n",
      "     |      Return time tuple, compatible with time.localtime().\n",
      "     |  \n",
      "     |  timetz(...)\n",
      "     |      Return time object with same time and tzinfo.\n",
      "     |  \n",
      "     |  tzname(...)\n",
      "     |      Return self.tzinfo.tzname(self).\n",
      "     |  \n",
      "     |  utcfromtimestamp(...) from builtins.type\n",
      "     |      Construct a naive UTC datetime from a POSIX timestamp.\n",
      "     |  \n",
      "     |  utcnow(...) from builtins.type\n",
      "     |      Return a new datetime representing UTC day and time.\n",
      "     |  \n",
      "     |  utcoffset(...)\n",
      "     |      Return self.tzinfo.utcoffset(self).\n",
      "     |  \n",
      "     |  utctimetuple(...)\n",
      "     |      Return UTC time tuple, compatible with time.localtime().\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  hour\n",
      "     |  \n",
      "     |  microsecond\n",
      "     |  \n",
      "     |  minute\n",
      "     |  \n",
      "     |  second\n",
      "     |  \n",
      "     |  tzinfo\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  max = datetime.datetime(9999, 12, 31, 23, 59, 59, 999999)\n",
      "     |  \n",
      "     |  min = datetime.datetime(1, 1, 1, 0, 0)\n",
      "     |  \n",
      "     |  resolution = datetime.timedelta(0, 0, 1)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from date:\n",
      "     |  \n",
      "     |  __format__(...)\n",
      "     |      Formats self with strftime.\n",
      "     |  \n",
      "     |  fromordinal(...) from builtins.type\n",
      "     |      int -> date corresponding to a proleptic Gregorian ordinal.\n",
      "     |  \n",
      "     |  isocalendar(...)\n",
      "     |      Return a 3-tuple containing ISO year, week number, and weekday.\n",
      "     |  \n",
      "     |  isoweekday(...)\n",
      "     |      Return the day of the week represented by the date.\n",
      "     |      Monday == 1 ... Sunday == 7\n",
      "     |  \n",
      "     |  strftime(...)\n",
      "     |      format -> strftime() style string.\n",
      "     |  \n",
      "     |  today(...) from builtins.type\n",
      "     |      Current date or datetime:  same as self.__class__.fromtimestamp(time.time()).\n",
      "     |  \n",
      "     |  toordinal(...)\n",
      "     |      Return proleptic Gregorian ordinal.  January 1 of year 1 is day 1.\n",
      "     |  \n",
      "     |  weekday(...)\n",
      "     |      Return the day of the week represented by the date.\n",
      "     |      Monday == 0 ... Sunday == 6\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from date:\n",
      "     |  \n",
      "     |  day\n",
      "     |  \n",
      "     |  month\n",
      "     |  \n",
      "     |  year\n",
      "    \n",
      "    class time(builtins.object)\n",
      "     |  time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object\n",
      "     |  \n",
      "     |  All arguments are optional. tzinfo may be None, or an instance of\n",
      "     |  a tzinfo subclass. The remaining arguments may be ints.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __format__(...)\n",
      "     |      Formats self with strftime.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __hash__(self, /)\n",
      "     |      Return hash(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      __reduce__() -> (cls, state)\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  dst(...)\n",
      "     |      Return self.tzinfo.dst(self).\n",
      "     |  \n",
      "     |  isoformat(...)\n",
      "     |      Return string in ISO 8601 format, HH:MM:SS[.mmmmmm][+HH:MM].\n",
      "     |  \n",
      "     |  replace(...)\n",
      "     |      Return time with new specified fields.\n",
      "     |  \n",
      "     |  strftime(...)\n",
      "     |      format -> strftime() style string.\n",
      "     |  \n",
      "     |  tzname(...)\n",
      "     |      Return self.tzinfo.tzname(self).\n",
      "     |  \n",
      "     |  utcoffset(...)\n",
      "     |      Return self.tzinfo.utcoffset(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  hour\n",
      "     |  \n",
      "     |  microsecond\n",
      "     |  \n",
      "     |  minute\n",
      "     |  \n",
      "     |  second\n",
      "     |  \n",
      "     |  tzinfo\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  max = datetime.time(23, 59, 59, 999999)\n",
      "     |  \n",
      "     |  min = datetime.time(0, 0)\n",
      "     |  \n",
      "     |  resolution = datetime.timedelta(0, 0, 1)\n",
      "    \n",
      "    class timedelta(builtins.object)\n",
      "     |  Difference between two datetime values.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __abs__(self, /)\n",
      "     |      abs(self)\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __bool__(self, /)\n",
      "     |      self != 0\n",
      "     |  \n",
      "     |  __divmod__(self, value, /)\n",
      "     |      Return divmod(self, value).\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __floordiv__(self, value, /)\n",
      "     |      Return self//value.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __hash__(self, /)\n",
      "     |      Return hash(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __mod__(self, value, /)\n",
      "     |      Return self%value.\n",
      "     |  \n",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __neg__(self, /)\n",
      "     |      -self\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __pos__(self, /)\n",
      "     |      +self\n",
      "     |  \n",
      "     |  __radd__(self, value, /)\n",
      "     |      Return value+self.\n",
      "     |  \n",
      "     |  __rdivmod__(self, value, /)\n",
      "     |      Return divmod(value, self).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      __reduce__() -> (cls, state)\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __rfloordiv__(self, value, /)\n",
      "     |      Return value//self.\n",
      "     |  \n",
      "     |  __rmod__(self, value, /)\n",
      "     |      Return value%self.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return value*self.\n",
      "     |  \n",
      "     |  __rsub__(self, value, /)\n",
      "     |      Return value-self.\n",
      "     |  \n",
      "     |  __rtruediv__(self, value, /)\n",
      "     |      Return value/self.\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  __sub__(self, value, /)\n",
      "     |      Return self-value.\n",
      "     |  \n",
      "     |  __truediv__(self, value, /)\n",
      "     |      Return self/value.\n",
      "     |  \n",
      "     |  total_seconds(...)\n",
      "     |      Total seconds in the duration.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  days\n",
      "     |      Number of days.\n",
      "     |  \n",
      "     |  microseconds\n",
      "     |      Number of microseconds (>= 0 and less than 1 second).\n",
      "     |  \n",
      "     |  seconds\n",
      "     |      Number of seconds (>= 0 and less than 1 day).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  max = datetime.timedelta(999999999, 86399, 999999)\n",
      "     |  \n",
      "     |  min = datetime.timedelta(-999999999)\n",
      "     |  \n",
      "     |  resolution = datetime.timedelta(0, 0, 1)\n",
      "    \n",
      "    class timezone(tzinfo)\n",
      "     |  Fixed offset from UTC implementation of tzinfo.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      timezone\n",
      "     |      tzinfo\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getinitargs__(...)\n",
      "     |      pickle support\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __hash__(self, /)\n",
      "     |      Return hash(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  dst(...)\n",
      "     |      Return None.\n",
      "     |  \n",
      "     |  fromutc(...)\n",
      "     |      datetime in UTC -> datetime in local time.\n",
      "     |  \n",
      "     |  tzname(...)\n",
      "     |      If name is specified when timezone is created, returns the name.  Otherwise returns offset as 'UTC(+|-)HH:MM'.\n",
      "     |  \n",
      "     |  utcoffset(...)\n",
      "     |      Return fixed offset.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  max = datetime.timezone(datetime.timedelta(0, 86340))\n",
      "     |  \n",
      "     |  min = datetime.timezone(datetime.timedelta(-1, 60))\n",
      "     |  \n",
      "     |  utc = datetime.timezone.utc\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from tzinfo:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      -> (cls, state)\n",
      "    \n",
      "    class tzinfo(builtins.object)\n",
      "     |  Abstract base class for time zone info objects.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      -> (cls, state)\n",
      "     |  \n",
      "     |  dst(...)\n",
      "     |      datetime -> DST offset in minutes east of UTC.\n",
      "     |  \n",
      "     |  fromutc(...)\n",
      "     |      datetime in UTC -> datetime in local time.\n",
      "     |  \n",
      "     |  tzname(...)\n",
      "     |      datetime -> string name of time zone.\n",
      "     |  \n",
      "     |  utcoffset(...)\n",
      "     |      datetime -> timedelta showing offset from UTC, negative values indicating West of UTC\n",
      "\n",
      "DATA\n",
      "    MAXYEAR = 9999\n",
      "    MINYEAR = 1\n",
      "    datetime_CAPI = <capsule object \"datetime.datetime_CAPI\">\n",
      "\n",
      "FILE\n",
      "    /usr/lib/python3.5/datetime.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(datetime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n"
     ]
    }
   ],
   "source": [
    "from primes import prime_range\n",
    "\n",
    "print(prime_range(10, 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exceptions\n",
    "\n",
    "Errors happen. User error or logical error are not always avoidable. Standard way of error happening is called exceptions. An exception occures when an error is occured. You have to always be ready for exceptions and try the code for any exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "always execute\n",
      "Value Error occured.\n",
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "# How to try for exceptions.\n",
    "\n",
    "try:\n",
    "    print('always execute')\n",
    "    print(int('hi'))\n",
    "    print('end')\n",
    "except TypeError as e:\n",
    "    print('Type Error occured.')\n",
    "except ValueError as ve:\n",
    "    print('Value Error occured.')\n",
    "\n",
    "print('Hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different type of exceptions can happen. You can specify different section for each one of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 123\n",
      "Square of 123 is 15129.\n",
      "name 'some_name_that_does_not_exist' is not defined\n",
      "Running code continues.\n"
     ]
    }
   ],
   "source": [
    "# How to trye for different exceptions.\n",
    "\n",
    "number = input('Enter a number: ')  # hi\n",
    "\n",
    "try:\n",
    "    print('Square of {} is {}.'.format(number, int(number)**2))\n",
    "    print(some_name_that_does_not_exist)\n",
    "except ValueError as ve:\n",
    "    print(ve)\n",
    "except NameError as ne:\n",
    "    print(ne)\n",
    "except SyntaxError as se:\n",
    "    print(se)\n",
    "\n",
    "print('Running code continues.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are other sections:\n",
    "* `finally`: That will executed in any condition. If exception happened or didn't, if we try for it or we didn't and ... .\n",
    "* `else`: That will executed if no exception happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 123\n",
      "Square of 123 is 15129.\n",
      "No error from this part.\n",
      "Else Section\n",
      "Finally Section\n",
      "Running code continues.\n"
     ]
    }
   ],
   "source": [
    "# How to trye for different exceptions.\n",
    "\n",
    "number = input('Enter a number: ')  # 123\n",
    "some_name_that_exist = 'No error from this part.'\n",
    "\n",
    "try:\n",
    "    print('Square of {} is {}.'.format(number, int(number)**2))\n",
    "    print(some_name_that_exist)  # Change to some_name_that_does_not_exist\n",
    "except ValueError as ve:\n",
    "    print(ve)\n",
    "else:\n",
    "    print('Else Section')\n",
    "finally:\n",
    "    print('Finally Section')\n",
    "\n",
    "print('Running code continues.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "* Write a program that get two numbers from a user then print result of their division. Remember tow handle divide by zero exception!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num1: 123\n",
      "num2: abc\n",
      "ERROR: You should enter numbers!\n"
     ]
    }
   ],
   "source": [
    "num1, num2 = input('num1: '), input('num2: ')\n",
    "\n",
    "try:\n",
    "    num1, num2 = int(num1), int(num2)\n",
    "except ValueError as ve:\n",
    "    print('ERROR: You should enter numbers!')\n",
    "else:\n",
    "    try:\n",
    "        print(num1/num2)\n",
    "    except ZeroDivisionError as zde:\n",
    "        print('ERROR: Second number can not be zero!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate Error\n",
    "\n",
    "If you wanted to signal an error you can do it by using `Exception` object for now. After OOP section, we learn new and more standard way for defining our exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Column argument is -3. It should be bigger than zero!\n"
     ]
    }
   ],
   "source": [
    "def multiplication_table(row=10, column=10):\n",
    "    if (row <= 0 or column <= 0):\n",
    "        raise Exception('{} argument is {}. It should be bigger than zero!'\n",
    "                        .format(*(['Row', row] if row <= 0 else ['Column', column])))\n",
    "    return [[i*j for j in range(1, column + 1)] for i in range(1, row + 1)]\n",
    "\n",
    "# print(multiplication_table(-1, 5))\n",
    "\n",
    "try:\n",
    "    print(multiplication_table(2, -3))\n",
    "except Exception as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even make this code smaller and more readable by using `assert`. It gets a condition and an exception, if condition is `False`, the exception raised."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Row argument is -1. It should be bigger than zero!\n"
     ]
    }
   ],
   "source": [
    "def multiplication_table(row=10, column=10):\n",
    "    assert row >= 0 and column >= 0, Exception('{} argument is {}. It should be bigger than zero!'\n",
    "                                               .format(*(['Row', row] if row <= 0 else ['Column', column])))\n",
    "    return [[i*j for j in range(1, column + 1)] for i in range(1, row + 1)]\n",
    "\n",
    "try:\n",
    "    multiplication_table(-1, 5)\n",
    "except Exception as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object Oriented Programming\n",
    "\n",
    "Good for easy code designing, reusability and readability.\n",
    "\n",
    "Concepts:\n",
    "* Objects\n",
    "    * State\n",
    "    * Behavior\n",
    "* Class\n",
    "    * Attributes\n",
    "    * Methods\n",
    "* Instances\n",
    "\n",
    "Simplest python class:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# A Class (code blueprints) that represent an Object (real world concepts).\n",
    "class simple:\n",
    "    pass\n",
    "\n",
    "# Creating an Instance of the object.\n",
    "simple_var = simple()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    \"\"\"This is a simple Car class.\"\"\"\n",
    "    number_of_wheels = 4\n",
    "\n",
    "# It's defined withing the structures of our class.\n",
    "print(Car.number_of_wheels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# Each instance can see it from the class.\n",
    "simple_car = Car()\n",
    "print(simple_car.number_of_wheels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Class attributes updates through all instances.\n",
    "Car.number_of_wheels = 3\n",
    "not_so_simple_car = Car()\n",
    "print(not_so_simple_car.number_of_wheels)\n",
    "print(simple_car.number_of_wheels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Class attribute can have shadows for each object instances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    number_of_wheels = 4\n",
    "\n",
    "strange_car = Car()\n",
    "\n",
    "# Altering class attribute through instances make specific class attribute values for them.\n",
    "strange_car.number_of_wheels = 18\n",
    "print(Car.number_of_wheels)\n",
    "print(strange_car.number_of_wheels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "# But it will break updated through class structure.\n",
    "Car.number_of_wheels = 3\n",
    "print(strange_car.number_of_wheels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# Don't panic, you can bind your instance to your class again.\n",
    "del strange_car.number_of_wheels\n",
    "print(strange_car.number_of_wheels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "* Write a Circle class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Circle:\n",
    "    radius = 0\n",
    "\n",
    "a = Circle()\n",
    "a.radius = 13\n",
    "\n",
    "b = Circle()\n",
    "b.radius = 1.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Access to Instance\n",
    "\n",
    "Each method in a class have a default first argument that is not passed by what we code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nobody\n",
      "1 2 3\n",
      "john\n",
      "a b c\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    name = 'Nobody'\n",
    "    def print_name(self, a, b, c):\n",
    "        print(self.name)\n",
    "        print(a, b, c)\n",
    "\n",
    "david = Person()\n",
    "# david.name = 'David'\n",
    "david.print_name(1, 2, 3)\n",
    "\n",
    "john = Person()\n",
    "john.name = 'john'\n",
    "john.print_name('a', 'b', 'c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we can access instances, we can define instance attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Bod', 1992)\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def set(self, name, age):\n",
    "        self.name = name\n",
    "        self.birth_year = 2017 - age\n",
    "    \n",
    "    def get(self):\n",
    "        return self.name, self.birth_year\n",
    "\n",
    "bob = Person()\n",
    "bob.set(name='Bod', age=25)\n",
    "print(bob.get())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "* Write a circle class that have:\n",
    "    * A class attribute. One thing that is shared between all circles.\n",
    "    * An instance attribute. What makes two circle different?\n",
    "    * A method to set radius.\n",
    "    * A method to calculate area of circle using the class and instance attributes.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of a circle with redius 5 is 78.5398163375\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "class Circle:\n",
    "    PI = 3.1415926535\n",
    "    \n",
    "    def set(self, radius):\n",
    "        self.radius = radius\n",
    "    \n",
    "    def area(self):\n",
    "        return self.PI * self.radius ** 2\n",
    "\n",
    "\n",
    "c = Circle()\n",
    "c.set(5)\n",
    "print(\"Area of a circle with redius {} is {}\".format(c.radius, c.area()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Special Methods\n",
    "\n",
    "These methods have specific name and specific job. They have names that starts and ends with `__`\n",
    "\n",
    "When we are creating an instance, `__init__` is the very first method that get called automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Alice', 21)\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name, self.age = name, age\n",
    "\n",
    "    def get(self):\n",
    "        return self.name, self.age\n",
    "\n",
    "alice = Person('Alice', 21)\n",
    "print(alice.get())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operator Overloading\n",
    "\n",
    "Some of these special methods have is use by built-in operator like `len` function. By writing right special methods you can overload those behaviours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name, self.age = name, age\n",
    "        \n",
    "    def __len__(self):\n",
    "        return self.age\n",
    "    \n",
    "    def __bool__(self):\n",
    "        if self.age > 18:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "        # return True if self.age > 18 else False\n",
    "        # return self.age > 18\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return self.name.__iter__()\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"{} is {} year{} old.\".format(self.name, self.age, 's' if self.age > 1 else '')\n",
    "\n",
    "me = Person('Amir', 22)\n",
    "print(len(me))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Amir is 22 years old.'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(me)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are allowed to vote.\n"
     ]
    }
   ],
   "source": [
    "if me:\n",
    "    print('You are allowed to vote.')\n",
    "else:\n",
    "    print('You are not allowed to vote.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amir is 22 years old.\n"
     ]
    }
   ],
   "source": [
    "print(me)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "m\n",
      "i\n",
      "r\n"
     ]
    }
   ],
   "source": [
    "for p in me:\n",
    "    print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find all information on special methods in [Here](http://www.diveintopython3.net/special-method-names.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Static Methods\n",
    "\n",
    "Normal methods need an instance to do operation on it. Static methods on the other hand get called from class name. In this way you can categorize your function under a title."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['', 'a', 'ba', 'aa', 'aba', 'cba', 'aaa']\n",
      "[True, True, True, True, True, True, True, False, False]\n",
      "{'want', 'is', 'so', 'get', 'word,', 'unique', 'should', 'you', 'want!', 'what', 'What'}\n"
     ]
    }
   ],
   "source": [
    "class String:\n",
    "    @staticmethod\n",
    "    def reverse(string):\n",
    "        return string[::-1]\n",
    "    \n",
    "    @staticmethod\n",
    "    def is_upper_lower(string):\n",
    "        \"\"\"Checks for strings like ``, `A`, `a`, `Aa`, `aA`, `AaA`, `aAa`, ... .\"\"\"\n",
    "        last_upper, last_lower = False, False\n",
    "        for character in string:\n",
    "            if not last_upper and not last_lower:\n",
    "                if character.isupper():\n",
    "                    last_upper = True\n",
    "                else:\n",
    "                    last_lower = True\n",
    "            else:\n",
    "                if last_upper and not last_lower and character.islower():\n",
    "                    last_upper, last_lower = False, True\n",
    "                elif not last_upper and last_lower and character.isupper():\n",
    "                    last_upper, last_lower = True, False\n",
    "                elif (last_upper and last_lower) or (not last_upper and not last_lower):\n",
    "                    raise Exception(\"There is bug in the code! last_upper: {} and last_lower: {}\"\n",
    "                                    .format(last_upper, last_lower))\n",
    "                else:\n",
    "                    return False\n",
    "        return True\n",
    "    \n",
    "#         part1, part2 = string[::2], string[1::2]\n",
    "#         return part1.islower() and part2.isupper() or part1.isupper() and part2.islower()\n",
    "    \n",
    "    @staticmethod\n",
    "    def unique_words(string, case_sensitive=False):\n",
    "        return set([s if case_sensitive else s.lower() for s in string.split()])\n",
    "\n",
    "print(list(map(String.reverse, ['', 'a', 'ab', 'aa', 'aba', 'abc', 'aaa'])))\n",
    "print(list(map(String.is_upper_lower, ['', 'a', 'A', 'aA', 'Aa', 'aAa', 'AaA', 'ab', 'AB'])))\n",
    "print(String.unique_words('What you want is unique word, so you should get what you want!', True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Methods\n",
    "\n",
    "They are special creators. In some ways they are like `__init__`. They create an instance. The first parameter of a class method is always class itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temperature in celsius is 15.00°C.\n",
      "Temperature in celsius is 37.00°C.\n",
      "Temperature in celsius is 26.85°C.\n"
     ]
    }
   ],
   "source": [
    "class Celsius:\n",
    "    def __init__(self, temperature):\n",
    "        self.temperature = temperature\n",
    "    \n",
    "    @classmethod\n",
    "    def from_fahrenheit(cls, fahrenheit):\n",
    "        return cls((fahrenheit - 32) * 5 / 9)\n",
    "    \n",
    "    @classmethod\n",
    "    def from_kelvin(cls, kelvin):\n",
    "        return cls(kelvin - 273.15)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"Temperature in celsius is {:0.2f}°C.\".format(self.temperature)\n",
    "\n",
    "print(Celsius(15))\n",
    "print(Celsius.from_fahrenheit(98.6))\n",
    "print(Celsius.from_kelvin(300))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have mutiple static methods and use some of in other ones, you have to hardcode the class name. This is not so good, we have so make changes as small as possible when class name is going to change. Another usage of class methods are for this problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class String:\n",
    "    @classmethod\n",
    "    def is_palindrome(cls, string, case_insensitive=True):\n",
    "        string = cls._strip_string(string)\n",
    "        \n",
    "        # For case insensitive comparison, we lower-case string\n",
    "        if case_insensitive:\n",
    "            string = string.lower()\n",
    "            \n",
    "        return cls._is_palindrome(string)\n",
    "    \n",
    "    @staticmethod\n",
    "    def _strip_string(string):\n",
    "        return ''.join(c for c in string if c.isalnum())\n",
    "    \n",
    "    @staticmethod\n",
    "    def _is_palindrome(string):\n",
    "        for c in range(len(string) // 2):\n",
    "            if string[c] != string[-c -1]:\n",
    "                return False\n",
    "        return True\n",
    "    \n",
    "    @staticmethod\n",
    "    def get_unique_words(string):\n",
    "        return set(string.split())\n",
    "\n",
    "print(String.is_palindrome('A nut for a jar of tuna')) # True\n",
    "print(String.is_palindrome('A nut for a jar of beans')) # False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance & Composition\n",
    "\n",
    "Main purpose of OOP is reusing existing codes. Inheritance (is-a relationship) and composition (has-a relationship) are\n",
    "two main ways to reuse code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Engine started.\n",
      "Engine started.\n"
     ]
    }
   ],
   "source": [
    "class Engine:  # Base class, Parent class\n",
    "    def start(self):\n",
    "        return 'Engine started.'\n",
    "\n",
    "    def stop(self):\n",
    "        return 'Engine stopped.'\n",
    "\n",
    "class Car:\n",
    "    def __init__(self):\n",
    "        self.engine = Engine()  # Composition\n",
    "\n",
    "class MechanicalEngine(Engine):  # Inheritance\n",
    "    def __init__(self):\n",
    "        self.max_speed = 120\n",
    "\n",
    "# Above, Engine is called Parent, Base class and MechanicalEngine is called Child, Derived class.\n",
    "\n",
    "motorcycle_engine = MechanicalEngine()\n",
    "print(motorcycle_engine.start())  # MechanicalEngine class inherits attributes and methods of Engine class.\n",
    "\n",
    "c = Car()\n",
    "print(c.engine.start())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overwriting Methods\n",
    "\n",
    "If you overwrite a method of parent class, the functionality of that method from parent class is gone."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Title: Alice in Wonderlang, Author: Lewis Carroll, Online ID: 1298\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author):\n",
    "        self.title, self.author = title, author\n",
    "    \n",
    "    def get_info(self):\n",
    "        return \"Title: {}, Author: {}\".format(self.title, self.author)\n",
    "\n",
    "class EBook(Book):\n",
    "    def __init__(self, title, author, online_id):\n",
    "        # Not so good way! What if Book init changes? What if we didn't know Book init?\n",
    "        self.title, self.author, self.online_id = title, author, online_id\n",
    "\n",
    "        # Better solution BUT, what Book is not the only one we inherits? What if we\n",
    "        # wanted to change Book to Article?\n",
    "        Book.__init__(self, title, author)\n",
    "        self.online_id = online_id\n",
    "        \n",
    "        # Best solution!\n",
    "        super().__init__(title, author)\n",
    "        self.online_id = online_id\n",
    "    \n",
    "    def get_info(self):\n",
    "        book_info = super().get_info()\n",
    "        return \"{}, Online ID: {}\".format(book_info, self.online_id)\n",
    "\n",
    "alice_in_wonderland = EBook('Alice in Wonderlang', 'Lewis Carroll', 1298)\n",
    "print(alice_in_wonderland.get_info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "* Write Person (coord & walk) and Employee classes.\n",
    "* Write Point and Line classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ahmad at 4, 18\n",
      "Sara at 10, 5, S: 100\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, age, height, x, y):\n",
    "        self.name, self.age, self.height = name, age, height\n",
    "        self.x, self.y = x, y\n",
    "    \n",
    "    def walk(self, move_x, move_y):\n",
    "        self.x += move_x\n",
    "        self.y += move_y\n",
    "\n",
    "    def __str__(self):\n",
    "        return '{} at {}, {}'.format(self.name, self.x, self.y)\n",
    "\n",
    "class Employee(Person):\n",
    "    def __init__(self, name, age, height, x, y, salary):\n",
    "        super().__init__(name, age, height, x, y)\n",
    "        self.salary = salary\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"{}, S: {}\".format(super().__str__(), self.salary)\n",
    "\n",
    "\n",
    "ahmad = Person('Ahmad', 16, 180, 4, 18)\n",
    "print(ahmad)\n",
    "\n",
    "Sara = Employee('Sara', 25, 180, 10, 5, 100)\n",
    "print(Sara)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inf\n"
     ]
    }
   ],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x, self.y = x, y\n",
    "    \n",
    "    def move(self, move_x, move_y):\n",
    "        self.x += move_x\n",
    "        self.y += move_y\n",
    "\n",
    "        \n",
    "class Line:\n",
    "    def __init__(self, point_1, point_2):\n",
    "        self.point_1 = point_1\n",
    "        self.point_2 = point_2\n",
    "    \n",
    "    def gradient(self):\n",
    "        x1, y1 = self.point_1.x, self.point_1.y\n",
    "        x2, y2 = self.point_2.x, self.point_2.y\n",
    "        \n",
    "        if x1 - x2 == 0:\n",
    "            return float('inf')\n",
    "        \n",
    "        return (y1 - y2) / (x1 - x2)\n",
    "\n",
    "\n",
    "l = Line(Point(2, 3), Point(2, 4))\n",
    "print(l.gradient())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple Inheritance & Method Resolution Order\n",
    "\n",
    "Put names, comma seperated, and know that order of them matters (diamond problem)!\n",
    "\n",
    "As the following code shows, MRO like our class then parents of our class then grandparents of out class and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of our square is: 100 and Tag is: Rectangle\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "class Shape:\n",
    "    tag = 'Shape'\n",
    "    \n",
    "    def area():\n",
    "        return 0\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    tag = 'Rectangle'\n",
    "    \n",
    "    def __init__(self, a, b):\n",
    "        self.a, self.b = a, b\n",
    "    \n",
    "    def area(self):\n",
    "        return self.a * self.b\n",
    "\n",
    "class Rhombus(Shape):\n",
    "    tag = 'Rhombus'\n",
    "    \n",
    "    def __init__(self, a, theta):\n",
    "        self.a, self.theta = a, theta\n",
    "    \n",
    "    def area(self):\n",
    "        return self.a * self.a * math.sin(self.theta)\n",
    "\n",
    "class Square(Rectangle, Rhombus):\n",
    "    def __init__(self, a):\n",
    "        # For Rectangle\n",
    "        super().__init__(a, a)\n",
    "        \n",
    "        # For Rhombus\n",
    "#         super().__init__(a, math.pi / 2)\n",
    "\n",
    "my_square = Square(10)\n",
    "print(\"Area of our square is: {} and Tag is: {}\".format(my_square.area(), my_square.tag))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Private and Public\n",
    "\n",
    "Every thing in python is public! And everyone working with it without a single problem. But there is an agreement on it.\n",
    "\n",
    "If you use a single underscore at the beginning of names you use, means this is used for the inner workings of your code and it is better not to manipulate it.\n",
    "\n",
    "If you use two or more underscore at the beginning and at most one underscore at end of names you use, means this is more special name that even child classes should not manipulate it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A Private: Private value from A, Sensitive: Sensitive value from A\n",
      "B Private: Private value from B, Sensitive: Sensitive value from B\n",
      "B also include A sensitive to A works find.\n",
      "A sensitive value in B: Sensitive value from A\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self):\n",
    "        self._private = 'Private value from A'\n",
    "        self.__sensitive = 'Sensitive value from A'\n",
    "\n",
    "class B(A):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self._private = 'Private value from B'\n",
    "        self.__sensitive = 'Sensitive value from B'\n",
    "    \n",
    "    def how_to_change_private_values(self):\n",
    "        self.__sensitive = 'Use the name defined value with.'\n",
    "\n",
    "a, b = A(), B()\n",
    "\n",
    "print('A Private: {}, Sensitive: {}'.format(a._private, a._A__sensitive))\n",
    "print('B Private: {}, Sensitive: {}'.format(b._private, b._B__sensitive))\n",
    "print('B also include A sensitive to A works find.')\n",
    "print('A sensitive value in B: {}'.format(b._A__sensitive))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Name Mangling\n",
    "\n",
    "When you use two or more underscores at the beginning of a name, the actual name, that is reachable from outside class scope is mangled. Mangling is the process of adding class specific name to beginning of the name you defined. For example `__VARNAME` changes to `_CLASSNAME__VARNAME`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Useful Tips\n",
    "\n",
    "* Use `isinstance()` to find a varialble origins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(motorcycle_engine, MechanicalEngine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Use `issubclass()` to find examine inheritance relation between to classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(MechanicalEngine, Engine), issubclass(Engine, MechanicalEngine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Property decorators** are another thing to mention. They are like _setter_ and _getter_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nikola Tesla\n",
      "Thomas Alva Edison\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, firstname, lastname):\n",
    "        self.__firstname = firstname\n",
    "        self.__lastname = lastname\n",
    "        \n",
    "    @property\n",
    "    def full_name(self):\n",
    "        return '{} {}'.format(self.__firstname, self.__lastname)\n",
    "    \n",
    "    @full_name.setter\n",
    "    def full_name(self, full_name):\n",
    "        fname_splited = full_name.split()\n",
    "        self.__firstname = fname_splited[0]\n",
    "        self.__lastname = ' '.join(fname_splited[1:])\n",
    "\n",
    "p = Person('Nikola', 'Tesla')\n",
    "print(p.full_name)\n",
    "p.full_name = 'Thomas Alva Edison'\n",
    "print(p.full_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generators\n",
    "\n",
    "* `yield`\n",
    "* `yeild from`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decorators\n",
    "\n",
    "Example: Decorator to calculate up execution time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decorator Factory\n",
    "\n",
    "Homeworks:\n",
    "* Describing what some codes do.\n",
    "\n",
    "Notes to talk:\n",
    "* Printing structures and customization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PIP\n",
    "\n",
    "Python have libraries. `pip` is a program that can install and remove your packages. This a fast and safe way to get a python library for our projects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Virtualenv\n",
    "\n",
    "Consider situations like 2 projects with same dependencies of different versions. Like `pip`, `virtualenv`  helps you manage your packages but in different way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Installation\n",
    "\n",
    "```bash\n",
    "pip3 install virtualenv\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage\n",
    "\n",
    "```bash\n",
    "virtualenv .venv           # Creating python virtual environment\n",
    "source .venv/bin/activate  # Activating virtual environment\n",
    "deactivate                 # Deactivating virtual environment\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Database\n",
    "\n",
    "Python has many many libraries for managing databases. Here we use SQLite3 that comes with Python when you installed it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Immigrant Sont', 'Led Zeppelin', 8)\n",
      "('GOT', 'Ramin Djawadi', 9)\n",
      "('The map of reality', 'The New Smiths', 9)\n"
     ]
    }
   ],
   "source": [
    "import sqlite3\n",
    "import os\n",
    "\n",
    "try:\n",
    "    os.remove('simple-db')\n",
    "except FileNotFoundError as e:\n",
    "    pass\n",
    "\n",
    "db = sqlite3.connect('simple-db')\n",
    "\n",
    "# Create a new table.\n",
    "db.execute('create table music ( title text, artist text, rating int)')\n",
    "db.commit()\n",
    "\n",
    "# Insert new data to music table.\n",
    "db.execute('insert into music (title, artist, rating) values (\"Immigrant Sont\", \"Led Zeppelin\",8)')\n",
    "db.execute('insert into music (title, artist, rating) values (\"GOT\", \"Ramin Djawadi\",9)')\n",
    "db.execute('insert into music (title, artist, rating) values (\"The map of reality\", \"The New Smiths\",9)')\n",
    "db.commit()\n",
    "\n",
    "# Grab stored data from our database.\n",
    "table = db.execute('select * from music')\n",
    "for row in table:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Graphical User Interface with Tkinter\n",
    "\n",
    "We use `tkinter` module for this part of our course. To start we need to import the module first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 3 ways to import tkinter module\n",
    "\n",
    "from tkinter import *  # This is very bad way. We import everything in the module to global scope.\n",
    "# There is chance that we overwrite something imported from or to tkinter module.\n",
    "\n",
    "import tkinter  # This way is not best but works fine. The name is long to type.\n",
    "\n",
    "import tkinter as tk  # This is best way to do this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have problem with importing `tkinter` you might want to check the installation of it. Read the error completely there should be some clue to how to fix it or search the error online for more clues.\n",
    "\n",
    "Three components for GUI programming:\n",
    "* What to place on screen? -> Widgets\n",
    "* Where to place the widgets? -> Geometry Management\n",
    "* How do widgets behave? -> Events & Callbacks\n",
    "\n",
    "Every thing is part of a big tree structure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Root Window\n",
    "\n",
    "With `tkinter` there is no need to start from scratch and invent the wheel! The `root window` is what you have to start with. A window that have basic functionality that you need.\n",
    "\n",
    "The concept of a `mainloop` is like a manager. You are the one who write standards an law, but someone else know better how to execute those."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "root = tk.Tk()  # root variable is filled with a basic root window object.\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Widgets\n",
    "\n",
    "Widgets are building blocks of a GUI application. They work together to serve an application goal. Labels, text inputs, button, sliders, image viewer, tabs and even root window are widgets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "root = tk.Tk()\n",
    "\n",
    "greetings_label = tk.Label(root, text='Hello User!')  # Attaching a label to root with some text.\n",
    "greetings_label.pack()  # This method should be called to define a position for our new widget.\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember all widgets are objects that is created and returned by a specific functions like `Label`. Then you configure them as you like them to behave (OOP) and then call the manager to do dirty works!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ERROR: Wrong username and password. username: username, password: 123\n",
      "Correct username and password.\n"
     ]
    }
   ],
   "source": [
    "root = tk.Tk()\n",
    "\n",
    "username_frame = tk.Frame(root)\n",
    "tk.Label(username_frame, text='Username').pack(side=tk.LEFT)\n",
    "username_entry = tk.Entry(username_frame)\n",
    "username_entry.pack(side=tk.LEFT)\n",
    "username_frame.pack(fill=tk.X)\n",
    "\n",
    "password_frame = tk.Frame(root)\n",
    "tk.Label(password_frame, text='Password').pack(side=tk.LEFT)\n",
    "password_entry = tk.Entry(password_frame, show='*')\n",
    "password_entry.pack(side=tk.LEFT)\n",
    "password_frame.pack(fill=tk.X)\n",
    "\n",
    "def login():\n",
    "    username = username_entry.get()\n",
    "    password = password_entry.get()\n",
    "    if username == 'username' and password == 'password':\n",
    "        print('Correct username and password.')\n",
    "    else:\n",
    "        print('ERROR: Wrong username and password. username: {}, password: {}'.format(username, password))\n",
    "\n",
    "button_frame = tk.Frame(root)\n",
    "login_button = tk.Button(button_frame, text='Login', command=login)\n",
    "login_button.pack(fill=tk.X)\n",
    "button_frame.pack(fill=tk.X)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Geometry Management\n",
    "\n",
    "Three ways to manage:\n",
    "* Pack: Simple for simple layouts.\n",
    "* Grid: Most popular one. Manage a window as it is a table.\n",
    "* Place: Least popular one. Best control with absolute positioning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "root = tk.Tk()\n",
    "\n",
    "frame = tk.Frame(root)\n",
    "tk.Label(frame, text='Pack demo of side and fill.').pack()\n",
    "tk.Button(frame, text='A').pack(side=tk.LEFT, fill=tk.Y)\n",
    "tk.Button(frame, text='B').pack(side=tk.TOP, fill=tk.X)\n",
    "tk.Button(frame, text='C').pack(side=tk.RIGHT, fill=tk.NONE)\n",
    "tk.Button(frame, text='D').pack(side=tk.TOP, fill=tk.BOTH)\n",
    "frame.pack()\n",
    "\n",
    "tk.Label(root, text='Pack demo of expand.').pack()\n",
    "tk.Button(root, text='I do not expand').pack()\n",
    "tk.Button(root, text='I do not fill X but I expand').pack(expand=True)\n",
    "tk.Button(root, text='I fill X and expand.').pack(expand=True, fill=tk.X)\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Examples:\n",
    "\n",
    "* Count unique words of a file and write a json about it to another file.\n",
    "* Prime number function.\n",
    "* Prime number generator.\n",
    "* Fibonacci number recursive function.\n",
    "* Fibonacci number generator.\n",
    "* Iterator object.\n",
    "* Web crawler. (ircalendarevents)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project\n",
    "\n",
    "Now learning python syntax and usages is finished. Let us start our big project!\n",
    "\n",
    "The project is simple client chat. This applicatoin have 3 main parts.\n",
    "\n",
    "* Graphical User Interface\n",
    "* Network Programming\n",
    "* Database Management"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}