Python_Basic_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basic - part 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functional Basic Tools : Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "道\n",
      "道\n"
     ]
    }
   ],
   "source": [
    "my_string = \"道可道\"\n",
    "\n",
    "def is_dao(x):\n",
    "    return x == '道'\n",
    "\n",
    "for string in filter(is_dao, my_string):\n",
    "    print(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "禮拜一\n",
      "禮拜三\n"
     ]
    }
   ],
   "source": [
    "days_of_week = ['星期天', '禮拜一', '星期二', '禮拜三', '星期四', '星期五', '星期六']\n",
    "\n",
    "def is_li(string):\n",
    "    return '禮' in string\n",
    "\n",
    "for string in filter(is_li, days_of_week):\n",
    "    print(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re # import module using its name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re as X # import module as a name 'X'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "avoid to mix up the namespace with names in a modules and the names of variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function match at 0x101d819d8>\n"
     ]
    }
   ],
   "source": [
    "match = 10\n",
    "from re import * \n",
    "print (match)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add_two(x): return x + 2\n",
    "add_two(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# anonymous function\n",
    "add_two_lambda = lambda x : x + 2\n",
    "add_two_lambda(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# you can skip defining function name by using lambda\n",
    "(lambda x : x + 2)(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 3.6 up: Type annotations for variables. \n",
    "\n",
    "Nothing would happen. But it would be used by Mypy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add_two_annotation(x : int) -> int:\n",
    "    return x + 2 \n",
    "\n",
    "add_two_annotation(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'single quoted string'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'single quoted string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'double quoted string'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"double quoted string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "multiple lines \n",
      "string\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('multiple lines \\nstring\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`dir` could be used for checking the existing methods for `string` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']\n"
     ]
    }
   ],
   "source": [
    "print(dir(str))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "string = 'This is a Book.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "That is a Book.\n",
      "['This', 'is', 'a', 'Book.']\n",
      "this is a book.\n",
      "THIS IS A BOOK.\n",
      "0\n",
      "Xhis is a Dook.\n"
     ]
    }
   ],
   "source": [
    "print( string.replace('This', 'That') )\n",
    "print( string.split() )\n",
    "print( string.lower() )\n",
    "print( string.upper() )\n",
    "print( string.find('This') )\n",
    "print( string.translate({ord('T') : 'X', ord('B') : 'D'}) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables - about names and values\n",
    "\n",
    "https://nedbatchelder.com/text/names1.html\n",
    "\n",
    "Variable : a name refers to a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "var1 = 10\n",
    "var2 = var1\n",
    "print(var2 is var1)\n",
    "var1 = 11\n",
    "print(var2 is var1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "var2 is referring to 10, not var1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "var1 = 10\n",
    "var2 = var1\n",
    "var1 = 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We don't have to clarify the type of variable, which means we should keep in mind what type it is by ourselves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# Python is dynamic typing, keep in mind what the value \n",
    "# your name is referring to\n",
    "integer = 1\n",
    "print(type(integer))\n",
    "integer = 1.\n",
    "print(type(integer))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, it is useful to use `IDE` or `IPython` tab function to check the existence of the variable names: \n",
    "\n",
    "```python\n",
    "# tab this\n",
    "int<tab>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['星期天', '星期一', '星期二', '禮拜三', '星期四', '星期五', '星期六']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_week = [\"星期天\", \"星期一\", \"星期二\", \"星期三\", \"星期四\", \"星期五\", \"星期六\"]\n",
    "temp = days_of_week\n",
    "days_of_week[3] = '禮拜三'\n",
    "temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "days_of_week.append('星期八') # original list is mutated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['星期天', '星期一', '星期二', '禮拜三', '星期四', '星期五', '星期六', '星期八']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_week"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['星期天', '星期一', '星期二', '禮拜三', '星期四', '星期五', '星期六', '星期八']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp # yeah... temp is pointing to the original list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "immutable types -> `int`, `float`, `string`, `tuple`\n",
    "\n",
    "No method in Python can change their values!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_string = \"道可道\"\n",
    "temp = my_string\n",
    "my_string = my_string + \"，非常道。\"\n",
    "temp is my_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mutate a list, or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['道', '可', '道', '，'] ['道', '可', '道', '，']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [\"道\", \"可\", \"道\"]\n",
    "temp = my_list\n",
    "my_list.append('，')\n",
    "print (my_list, temp)\n",
    "temp is my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['道', '可', '道', '，'] ['道', '可', '道']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [\"道\", \"可\", \"道\"]\n",
    "temp = my_list\n",
    "my_list = my_list + ['，']\n",
    "print (my_list, temp)\n",
    "temp is my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "function's argument is an assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'道可道，非常道。，，，'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add(string):\n",
    "    return string + '，，，'\n",
    "\n",
    "add(my_string) # string = my_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['道', '可', '道', '，', '，，，']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['道', '可', '道', '，', '，，，']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mutation would happen inside the function\n",
    "def add(a_list):\n",
    "    a_list.append('，，，')\n",
    "    return a_list\n",
    "\n",
    "print(add(my_list)) # string = my_string\n",
    "my_list # the input is mutated !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# True and False\n",
    "\n",
    "In python, `True` is equal to integer 1, and `False` is equal to integer 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([True, False, True])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tricky things about if, elif, else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'道' in my_string\n",
      "'可' in my_string\n"
     ]
    }
   ],
   "source": [
    "my_string = \"道可道，非常道。\"\n",
    "\n",
    "if '道' in my_string:\n",
    "    print (\"'道' in my_string\")\n",
    "    \n",
    "if '可' in my_string:\n",
    "    print (\"'可' in my_string\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'道可道' in my_string\n",
      "'道可' in my_string\n",
      "'道' in my_string\n"
     ]
    }
   ],
   "source": [
    "# if will fire once the condition fits\n",
    "my_string = \"道可道，非常道。\"\n",
    "\n",
    "if '道可道' in my_string:\n",
    "    print (\"'道可道' in my_string\")\n",
    "    \n",
    "if '道可' in my_string:\n",
    "    print (\"'道可' in my_string\")\n",
    "    \n",
    "if '道' in my_string:\n",
    "    print (\"'道' in my_string\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'道可' in my_string\n"
     ]
    }
   ],
   "source": [
    "# But sometimes we want the condition fires only for the most \n",
    "# restricted one\n",
    "my_string = \"道可 道，非常道。\"\n",
    "\n",
    "if '道可道' in my_string:\n",
    "    print (\"'道可道' in my_string\")\n",
    "    \n",
    "elif '道可' in my_string:\n",
    "    print (\"'道可' in my_string\")\n",
    "    \n",
    "elif '道' in my_string:\n",
    "    print (\"'道' in my_string\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nothing happened\n"
     ]
    }
   ],
   "source": [
    "# Use else condition to make sure you know the control flow is fired\n",
    "my_string = \"名可名，非常名。\"\n",
    "\n",
    "if '道可道' in my_string:\n",
    "    print (\"'道可道' in my_string\")\n",
    "    \n",
    "elif '道可' in my_string:\n",
    "    print (\"'道可' in my_string\")\n",
    "    \n",
    "elif '道' in my_string:\n",
    "    print (\"'道' in my_string\")    \n",
    "\n",
    "else:\n",
    "    print(\"Nothing happened\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "道\n",
      "可\n",
      "道\n",
      "，\n",
      "非\n",
      "常\n",
      "道\n",
      "。\n"
     ]
    }
   ],
   "source": [
    "# while loop\n",
    "my_string = \"道可道，非常道。\"\n",
    "i = 0\n",
    "while i < len(my_string):\n",
    "    print(my_string[i])\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "道\n",
      "可\n",
      "道\n",
      "，\n",
      "非\n",
      "常\n",
      "道\n",
      "。\n"
     ]
    }
   ],
   "source": [
    "# while loop\n",
    "my_string = \"道可道，非常道。\"\n",
    "i = 0\n",
    "while True:\n",
    "    print(my_string[i])\n",
    "    i += 1\n",
    "    if i >= len(my_string):\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "道\n",
      "可\n",
      "道\n",
      "，\n",
      "非\n",
      "常\n",
      "道\n",
      "。\n"
     ]
    }
   ],
   "source": [
    "# range len for loop\n",
    "my_string = \"道可道，非常道。\"\n",
    "for i in range(len(my_string)):\n",
    "    print(my_string[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "道\n",
      "可\n",
      "道\n",
      "，\n",
      "非\n",
      "常\n",
      "道\n",
      "。\n"
     ]
    }
   ],
   "source": [
    "# my_string as a iterable\n",
    "my_string = \"道可道，非常道。\"\n",
    "for my_character in my_string:\n",
    "    print(my_character)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "道\n",
      "可\n",
      "道\n",
      "，\n",
      "非\n",
      "常\n",
      "道\n",
      "。\n"
     ]
    }
   ],
   "source": [
    "# list comprehension\n",
    "[print(my_character) for my_character in my_string];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "道\n",
      "可\n",
      "道\n",
      "，\n",
      "非\n",
      "常\n",
      "道\n",
      "。\n"
     ]
    }
   ],
   "source": [
    "# map\n",
    "list(map(print, my_string));"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}