Class 01 Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Introduction to Python\n",
    "\n",
    "## 2.1 Program Output, the print statment and 'hello world!'\n",
    "\n",
    "### 2.1.1 Difference between `print` and expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    ">>> myString = 'Hello World!'\n",
    "\n",
    ">>> print(myString)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World!'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> myString"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.2 Usage of `_`\n",
    "\n",
    "The underscore (\\_) also has special meaning in the interactive interpreter: the last evaluated expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World!'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> _"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Program Input and the raw_input() Built-in Function\n",
    "\n",
    "### 2.2.1 Get function info by using `help`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method raw_input in module ipykernel.kernelbase:\n",
      "\n",
      "raw_input(self, prompt='') method of ipykernel.ipkernel.IPythonKernel instance\n",
      "    Forward raw_input to frontends\n",
      "    \n",
      "    Raises\n",
      "    ------\n",
      "    StdinNotImplentedError if active frontend doesn't support stdin.\n",
      "\n"
     ]
    }
   ],
   "source": [
    ">>> help(raw_input) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2 Do not be addicted to `print`\n",
    "\n",
    "1. remove all `print` in production code;\n",
    "2. use `info` instead.\n",
    "3. separate functions into two categories: \n",
    "    1. those that do things (i.e. , interact with the user or set variables)\n",
    "    2. those that calculate things (usually returning results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def cal(list1):\n",
    "    result = []\n",
    "    for i in list1:\n",
    "        for j in i:\n",
    "            y = j/0.9712\n",
    "            result.append(str(y **3))\n",
    "            \n",
    "    return result\n",
    "\n",
    "\n",
    "#########\n",
    "            \n",
    "\n",
    "def simple_calc(j):\n",
    "    result = []\n",
    "    y = j/0.9712\n",
    "    result.append(str(y **3)))\n",
    "    return result\n",
    "\n",
    "def comlex_calc(j):\n",
    "    final = []\n",
    "    for i in list1:\n",
    "        for j in i:\n",
    "            final.append(simple_calc(j))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Operators\n",
    "\n",
    "### 2.4.1 Difference of `/` and `//`\n",
    "\n",
    "`/`: division\n",
    "\n",
    "`//`: floor division\n",
    "\n",
    "### 2.4.1 Difference of `=` and `==`\n",
    "\n",
    "`=`: assignment\n",
    "\n",
    "`==`: is equal to\n",
    "\n",
    "### 2.4.1 Difference of `*` and `**`\n",
    "\n",
    "`*`: product\n",
    "\n",
    "`**`: power\n",
    "\n",
    "\n",
    "## 2.5 Variables and Assignment\n",
    "\n",
    "### 2.5.1 Python is dynamically typed\n",
    "\n",
    "1. Python is flexible to use.\n",
    "2. Python is slow for interpretor to interprete (compare to C).\n",
    "\n",
    "\n",
    "## 2.6 Numbers\n",
    "\n",
    "### 2.6.1 Python starts with `0`\n",
    "\n",
    "The first element in any Python object starts with 0, not 1.\n",
    "\n",
    "\n",
    "## 2.7 Strings\n",
    "\n",
    "### Difference between `6` and `'6'`\n",
    "\n",
    "6: int\n",
    "\n",
    "'6': str\n",
    "\n",
    "\"6\": str\n",
    "\n",
    "## 2.9 Dictionaries\n",
    "\n",
    "### 2.9.1 Dictionaries are special\n",
    "\n",
    "We cannot use slicing to get a element in dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 7, 8]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3, 7, 8][0:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{'a': 1, 'b': 2, 'c': 3, 'd': 7, 'e':8}['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'c'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{'a': 1, 'b': 2, 'c': 3, 'd': 7, 'e':8}.keys()[1]  # dictionaries do't keep order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.11, 2.12 `if` loop VS. `while` loop\n",
    "\n",
    "\n",
    "1. If the expression is non-zero or True, the if_suite is executed; then execution continues on the first statement after.\n",
    "\n",
    "`if expression: \n",
    "    if_suite`\n",
    "\n",
    "\n",
    "2. The statement while_suite is executed continuously in a loop until the expression becomes zero or false; execution then continues  on the first succeeding statement.\n",
    "\n",
    "`while expression:\n",
    "    while_suite`\n",
    "    \n",
    "3. Avoid using `while` loop whenever possible.\n",
    "\n",
    "## 2.14 Comprehension\n",
    "\n",
    "\n",
    "### 2.14.1 List comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [2, 4, 7]\n",
    "result = []\n",
    "for i in l1:\n",
    "    result.append(i * 2)\n",
    "\n",
    "\n",
    "l1 = [i*2 for i in [2, 4, 7]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.14.2 Dicionary comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = {str(i): i*2 for i in [2, 4, 7]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.14.3 Set comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = {i*2 for i in [2, 4, 7, 7]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.14.4 Generator comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "g1 = (i*2 for i in [2, 4, 7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}