Class1_introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-L2yXEd0yM2r"
   },
   "source": [
    "# Scientific Programming in Python\n",
    "<center><small>February 2017</small></center>\n",
    "# Session 1: Basics\n",
    "(based on slides by Loic Matthey, UCL Graduate School)\n",
    "\n",
    "http://ucl-cs-grad.github.io/scipython/lectures.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-iCQ77IByM2t"
   },
   "source": [
    "## Agenda\n",
    "\n",
    "* Brief overview of the course\n",
    "* Python installation\n",
    "* Basic elements of Python programming\n",
    "* Python as a calculator\n",
    "* Working with strings\n",
    "* Working with lists\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9JbKrdB4yM2v"
   },
   "source": [
    "## Introduction\n",
    "\n",
    "### Things to know about programming\n",
    "\n",
    "* programming is not science\n",
    "* programming is a skill\n",
    "* programming takes a long time to master (longer than this week!)\n",
    "* programming is a tool commonly used by scientists, engineers and artists\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qO_9SuMQyM2w"
   },
   "source": [
    "### What is programming?\n",
    "\n",
    "* The process of creating computer programs.\n",
    "* Everything running on your computer is a program.\n",
    "* Every program is a piece of specifically written text, called the \"source code\".\n",
    "* Programming is simply writting text, which will get executed by your computer.\n",
    "\n",
    "### When is programming useful?\n",
    "\n",
    "* Automating a task, when they are repetitive or error prone\n",
    "* Analysing data, creating plots automatically\n",
    "* Mathematics/simulation heavy tasks\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "r9Pu7ZNPyM2x"
   },
   "source": [
    "### What is Python?\n",
    "\n",
    "* Created to be general-purpose, high-level programming language.\n",
    "* A \"fun to use\" language, hence named after Monty Python’s Flying Circus\n",
    "* Combines \"remarkable power with very clear syntax\" and provides a large and comprehensive standard library\n",
    "    * The \"standard library\" is a collection of code already written and directly available to you.\n",
    "    * That’s a good thing: it means people have written code for most applications you could be thinking of.\n",
    "\n",
    "* Multi-paradigm programming language permitting several styles:\n",
    "    * object-oriented\n",
    "    * structured\n",
    "    * functional\n",
    "    * aspect-oriented\n",
    "* Application domains: web development, database access,\n",
    "desktop GUIs, education, scientific and numeric computing,\n",
    "network programming, game and 3D graphics\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Td5lvf06yM2z"
   },
   "source": [
    "### Why learn Python?\n",
    "\n",
    "* very clear and readable syntax\n",
    "* extensive standard libraries and modules for virtually every task\n",
    "* high-level, easy to use datatypes, such as flexible arrays and dictionaries\n",
    "* interpreted language - no compilation is necessary\n",
    "* Easy to switch to another language later\n",
    "\n",
    "### I know Matlab, why Python?\n",
    "\n",
    "* Free.\n",
    "* More versatile, you can use it for different applications.\n",
    "* Input and output file manipulation better in Python. \n",
    "* Speedwise, they are about the same (when using Numpy/Scipy appropriately)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zFEQuHzXyM20"
   },
   "source": [
    "### Python installation\n",
    "Check: http://www.cs.ucl.ac.uk/scipython/help.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YCiXaqNYyM24"
   },
   "source": [
    "### HELP!\n",
    "\n",
    "* type `help()`, e.g. `help(sum)` will tell you how to use the Python function called `sum`\n",
    "* the official Python website: [www.python.org](www.python.org), and tutorial: [docs.python.org/tutorial](docs.python.org/tutorial)\n",
    "* attend one of the PyCon conferences, e.g. PyCon UK\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pt73-m7GyM25"
   },
   "source": [
    "### Python interpreter\n",
    "\n",
    "* A convenient option when using Python is to use `ipython`\n",
    "* It is a slightly changed interpreter, containing multiple tweaks and modifications to make your life easier.\n",
    "    * For example, it has colors by default, \n",
    "    * a great history,\n",
    "    * command completion\n",
    "    * and a way to launch scripts directly from it (%run, more on scripts later)\n",
    "\n",
    "* help/ documentation:\n",
    "    * typing `?` behind a function is an alias for `help()`, e.g.: `sum?` is the same as `help(sum)`. \n",
    "    * typing `??` behind a function shows the source code of the function\n",
    "\n",
    "### jupyter notebook\n",
    "* This page is a rendered (static) version of an IPython notebook.\n",
    "* interactive script environment inspired by Mathematica notebooks, that is run in a webbrowser\n",
    "* allows to write text, $LaTeX$ equations (something like $\\sqrt\\frac{3}{x}$), together with python code\n",
    "* very good way to do quick, but organized prototyping and developping\n",
    "* to start the ipython notebook interface launch it with `ipython notebook` in the terminal, this will:\n",
    "    * start an IPython kernel and a local http server that hosts the session locally\n",
    "    * open a webbrowser showing you the IPython notebooks in the folder you ran the command from\n",
    "    * then you can organize your notebooks with the web-browser and do all development\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3n-R3qEbyM26"
   },
   "source": [
    "## Python basics\n",
    "* the interpreter acts as a simple calculator, e.g.\n",
    "$\\sqrt{500 }$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lY9HxmALyM27"
   },
   "source": [
    "My first creature\n",
    "$ \\frac{3}{5} $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.1.0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EvgVWlclyM2-",
    "outputId": "24dd3f43-bb00-4ff7-a2ec-4c14ae5e9887"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "c5BbZjebyM3K"
   },
   "source": [
    "* parentheses can be used for grouping, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1272,
     "status": "ok",
     "timestamp": 1594705412719,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "p4MT2oL3yM3K",
    "outputId": "2a0e15c6-0d44-4cfb-ef61-67e49179c0e8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(50 - 5*6)/4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-xIeFvWGyM3S"
   },
   "source": [
    "* integer division returns the float (only in Python3!) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1285,
     "status": "ok",
     "timestamp": 1594705421946,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "72C7sKPPyM3V",
    "outputId": "32c4a7a9-6e7e-4cf8-f784-ae2bb9156ed6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.3333333333333335"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BkwXnBsMyM3e"
   },
   "source": [
    "* floor division can be used like this: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 964,
     "status": "ok",
     "timestamp": 1594705441480,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "k_HSA--ByM3e",
    "outputId": "ac6bf6f9-5bb8-492a-8e00-7b451b05a05d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9%4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 176
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 748,
     "status": "error",
     "timestamp": 1594705460587,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "i5d7tztL2fYs",
    "outputId": "37f68604-908e-4471-88ae-1dd59b0062d7"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'exp' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-7-fc3d3dec1ff8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mexp\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'exp' is not defined"
     ]
    }
   ],
   "source": [
    "exp(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20.085536923187668"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4Z-JktvQyM3k"
   },
   "source": [
    "### Operations\n",
    "<table>\n",
    "<tr>\n",
    "<th>Operator</th>\n",
    "<th>Operation</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>+</td>\n",
    "<td>plus</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>-</td>\n",
    "<td>minus</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>*</td>\n",
    "<td>multiplication</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>/</td>\n",
    "<td>division</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>**</td>\n",
    "<td>power (not ^ as in some other languages)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>%</td>\n",
    "<td>moldulo (remainder of integer division)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>==</td>\n",
    "<td>equal to (do not mix up with =)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>!=</td>\n",
    "<td>not equal</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>></td>\n",
    "<td>greater than</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;</td>\n",
    "<td>smaller than</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>>=</td>\n",
    "<td>greater than or equal to</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;=</td>\n",
    "<td>smaller than or equale to</td>\n",
    "</tr>\n",
    "</table>\n",
    "\n",
    "If you want more complex operations (e.g. `sin`, `sqrt`, `log`), you’ll need to use `math` or `numpy`. More on that later.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "D4_nFUhgyM3k"
   },
   "source": [
    "### Operators precedence\n",
    "\n",
    "The priority between operators is the same as you’d expect mathematically. From highest to lowest precedence:\n",
    "\n",
    "<table>\n",
    "<tr>\n",
    "<th>Operator</th>\n",
    "<th>Operation</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>()</td>\n",
    "<td>Terms in backets</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>**</td>\n",
    "<td>Exponentiation</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>+x, -x</td>\n",
    "<td>Unary plus and minus</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>*, /, %</td>\n",
    "<td>Multiply, divide, modulo</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>+, -</td>\n",
    "<td>Addition and subtraction</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;=, &lt;, >, >=</td>\n",
    "<td>Comparison operators</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>==, !=</td>\n",
    "<td>Equality operators</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>not, or, and</td>\n",
    "<td>Logical operators</td>\n",
    "</tr>\n",
    "</table>\n",
    "\n",
    "There are other operators that you will encounter later, check the Python Library Reference for the complete precedence table.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3ANY3gjwyM3m"
   },
   "source": [
    "### Variables\n",
    "\n",
    "* a variable are how values are stored in a computer\n",
    "* a variable can be a number, a character, a collection of numbers, etc.\n",
    "* the equal sign (`=`) is used to assign a value to a variable (again, be careful to not confuse with testing for equality `==`)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 763,
     "status": "ok",
     "timestamp": 1594705522649,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "M3GBNQeSyM3m"
   },
   "outputs": [],
   "source": [
    "width = 20\n",
    "pi = 3.14\n",
    "message = 'I have a bad feeling about this'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zxqdp_ekyM3u"
   },
   "source": [
    "A value can be assigned to several variables simultaneously:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Toe1lp77yM3v",
    "outputId": "ba8e7c18-5258-421d-d8ab-cb637af241d9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = y = z = 20\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1Th-e6NRyM35",
    "outputId": "b718c17a-e5c3-4a2f-a18f-f913fa053998"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "IofPunZRyM4D",
    "outputId": "afdee87f-6cdf-4675-d5bf-e71af68c9a14"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BrL6rqz3yM4J"
   },
   "source": [
    "Variables must be “defined” (assigned a value) before they can be used, or an error will occur:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lpEbfV7tyM4M",
    "outputId": "3a82f6d1-41e7-44e7-cd73-814bd9a7b4ac"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'n' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-fe13119fb084>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mn\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'n' is not defined"
     ]
    }
   ],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "for i in range(11,20):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DVsKGMpNyM4T"
   },
   "source": [
    "Variables are manipulated and combined with operators, forming “expressions”."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TRTEIBQTyM4T",
    "outputId": "ac04d466-6aca-45b0-849b-25a63d0c2d79",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "width = 20\n",
    "height = 5\n",
    "width * height"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6YwIa_rfyM4Z"
   },
   "source": [
    "* Example 1.1: Explain the output of the following statements:\n",
    "\n",
    "(a) 1 == 1\n",
    "\n",
    "(b) 1 == True\n",
    "\n",
    "(c) 0 == True\n",
    "\n",
    "(d) 0 == False\n",
    "\n",
    "(e) 3 == 1 * 3\n",
    "\n",
    "(f) (3 == 1) * 3\n",
    "\n",
    "(g) (3 == 3) * 4 + 3 == 1\n",
    "\n",
    "(h) 3**5 >= 4**4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1==1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1==True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0==True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0==False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3==1*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3==1)*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3==3)*4+3==1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3==3)*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 834,
     "status": "ok",
     "timestamp": 1594705680366,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "XCahBWgKyM4c",
    "outputId": "65a3ec4a-ccc9-4e66-8201-222c0510875e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "35 >= 44"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QYjlIUotyM4i"
   },
   "source": [
    "* Exercise 1.2: Explain the output of the following statements:\n",
    "    \n",
    "(a) 5 / 3\n",
    "\n",
    "(b) 5 % 3\n",
    "\n",
    "(c) 5.0 / 3\n",
    "\n",
    "(d) 5 / 3.0\n",
    "\n",
    "(e) 5.2 % 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6666666666666667"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5%3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6666666666666667"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5.0/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6666666666666667"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5/3.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 985,
     "status": "ok",
     "timestamp": 1594705743201,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "ibph9W94yM4j",
    "outputId": "4fb732b7-bc76-49b1-c9e9-0a8c9f997a77"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5.2 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Q0k9l5AvyM4o"
   },
   "source": [
    "* Example 1.3: Type casting\n",
    "    \n",
    "Very often, one wants to “cast” variables of a certain type into another type. Suppose we have variable x = ’123’, but really we would like x to be an integer.\n",
    "This is easy to do in Python, just use desiredtype(x), e.g. int(x) to obtain an integer. Try the following and explain the output\n",
    "\n",
    "(a) float(123)\n",
    "\n",
    "(b) float(’123’)\n",
    "\n",
    "(c) float(’123.23’)\n",
    "\n",
    "(d) int(123.23)\n",
    "\n",
    "(e) int(’123.23’)\n",
    "\n",
    "(f) int(float(’123.23’))\n",
    "\n",
    "(g) str(12)\n",
    "\n",
    "(h) str(12.2)\n",
    "\n",
    "(i) bool(’a’)\n",
    "\n",
    "(j) bool(0)\n",
    "\n",
    "(k) bool(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123.0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('123')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123.23"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('123.23')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(123.23)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: '123.23'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-32-a052266f23da>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'123.23'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: '123.23'"
     ]
    }
   ],
   "source": [
    "int('123.23') # string -> float는 가능하지만 string -> int는 불가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(float('123.23'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'12'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'12.2'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(12.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 747,
     "status": "ok",
     "timestamp": 1594705885809,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "Uc5oU4jwyM4p",
    "outputId": "caecd925-1b37-4539-fdf4-f8c7c20dbabe",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_QTFMY6hyM4u"
   },
   "source": [
    "### Functions\n",
    "\n",
    "More complex operations are provided by functions. For example, the absolute value of a number:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cWGsf193yM4w",
    "outputId": "3b92d69b-71a9-4b7c-99db-794f6ff1a42f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7WqgqG3byM4z"
   },
   "source": [
    "* `abs()` is an example of a function.\n",
    "* Functions have a name (here “`abs`”), followed by parentheses. They can take some input (here a number), do something with them and create some output (here it returns the absolute value of the number).\n",
    "    * Their name should usually be self-explanatory. \n",
    "    * But you can type `help(abs)` or `abs?` to see what any function does exactly.\n",
    "* They form the fundamental basis of any imperative programming language.\n",
    "    * Just think of them as providing you with advanced functionalities for free for now.\n",
    "    * We will cover more about functions as we move along the lectures\n",
    "* It is very easy to implement your own functions to structure your code or to reuse functions that have been written by others (like the `abs()` function!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MFpX_xq6yM40"
   },
   "source": [
    "Lets write a very simple function to calculate the area of a rectangle given as: $Area = width * height$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 884,
     "status": "ok",
     "timestamp": 1594706148915,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "-JV7vL8nyM40",
    "outputId": "288d80dd-867b-4673-8892-a2006baf741f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n",
      "50\n",
      "10.0\n"
     ]
    }
   ],
   "source": [
    "def 함수명(인풋1, 인풋2, 인풋3):\n",
    "    myv1 = 인풋1*인풋2*인풋3\n",
    "    myv2 = myv1*5\n",
    "    return myv2\n",
    "\n",
    "\n",
    "def area(width, height):\n",
    "    ret = width * height\n",
    "    return ret\n",
    "\n",
    "\n",
    "'''\n",
    "R: \n",
    "sqrt <- function(x){\n",
    "          ret=x^(1/2)\n",
    "    return = ret\n",
    "} #R code\n",
    "\n",
    "'''\n",
    "\n",
    "\n",
    "def sqrt(x):\n",
    "    \n",
    "    ret = x**(1/2)\n",
    "    return ret\n",
    "\n",
    "\n",
    "print(500)\n",
    "# Let's use the function!\n",
    "print(area(10,5))\n",
    "print(sqrt(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Mr9vPyCiyM47"
   },
   "source": [
    "* Example 1.4: Write a function that evaluates the polynomial \n",
    "$3x^2 − x + 2$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 964,
     "status": "ok",
     "timestamp": 1594706495429,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "DAlKGexYyM49",
    "outputId": "661d6e23-3bc7-47d7-ac27-01a6e3775cb2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "def myf(x):\n",
    "    ret = 3*x**2 -x +2\n",
    "    return ret\n",
    "\n",
    "\n",
    "print(myf(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qsHtEpjWyM5C"
   },
   "source": [
    "* Example 1.5: Write formulae to convert\n",
    "\n",
    "    1. temperature from Celcius to Farenheit\n",
    "$$\n",
    "F=C * (9/5) +32\n",
    "$$\n",
    "    2. weight from pounds into kilograms.\n",
    "$$\n",
    "KG = \\frac{LB}{ 2.2046}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6wiA82MNyM5C"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "102.2"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def celcius_to_fahrenheit(cel):\n",
    "    F=cel*(9/5)+32\n",
    "    return F\n",
    "\n",
    "celcius_to_fahrenheit(39)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.690283951737275"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def kilo(LB):\n",
    "    KG=LB/2.2046\n",
    "    return KG\n",
    "\n",
    "kilo(39)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nEcCii9XyM5G"
   },
   "source": [
    "### Errors\n",
    "#### Syntax errors\n",
    "\n",
    "If you type something into python by mistake and python can’t understand then that’s a syntax error.\n",
    "\n",
    "* Making mistakes like this is normal. It doesn’t mean that you are dumb or that the computer is dumb.\n",
    "* Computers are more precise than humans. When you make a mistake like this, you have to fix it.\n",
    "* You will learn how to look at an error message and figure out what the mistake is. This is a valuable skill."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TvYRR4ojyM5H",
    "outputId": "aa111739-d7d9-4273-a40e-b22ba5208f3e"
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-35-614748eaf116>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-35-614748eaf116>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    n = 50 - 5*6)/4\u001b[0m\n\u001b[1;37m                ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "n = 50 - 5*6)/4\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 어디가 오류인지 알려줌"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1T5PqPrEyM5K"
   },
   "source": [
    "* On the first line of python’s output, it says the file and line number where the mistake is.\n",
    "* On the second and third line, python prints the part of the line where the mistake is and a `^` under the mistake.\n",
    "* The last line tells us what type of mistake it is: invalid syntax means the code you wrote is not proper ‘grammar’ in the python language."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_OSeWXljyM5L"
   },
   "source": [
    "#### runtime error \n",
    "\n",
    "Sometimes the grammar of your code is right and python knows what it should do, but you’ve asked it to do something impossible. This is called a runtime error.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6bdO01WFyM5N",
    "outputId": "d47c438e-baca-4a7c-828e-f24cf952c0c3"
   },
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-36-ca37522af756>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;36m1\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mn\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "1 / n\n",
    "\n",
    "# 0으로 나누면 division by 0 -> runtime error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9BRT5FqSyM5R"
   },
   "source": [
    "* In this example, we’ve asked python to divide one by zero, which is impossible. The error message let’s us know what went wrong.\n",
    "* The first line says the file and line where the impossible command was.\n",
    "* The second line says the impossible command.\n",
    "\n",
    "#### logic error\n",
    "* Sometimes code is grammatically correct, but it doesn’t do what you want. This is called a logic error.\n",
    "* As long as it’s not impossible to do what your code says, python will do it anyway even though it’s not what you want (how would Python know?). In the example below, the programmer wanted the variable `even_number` to contain an even number, and the variable `zero` to contain the number 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9KQLFTJnyM5S"
   },
   "outputs": [],
   "source": [
    "even_number = 57\n",
    "sample_size = '20'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1]\n"
     ]
    }
   ],
   "source": [
    "ret=1\n",
    "ret2=1\n",
    "def myf(x,y):\n",
    "    ret = 3*x**2-x+2\n",
    "    ret2 = ret+y\n",
    "    return ret2\n",
    "print([ret, ret2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XyERKAm6yM5V"
   },
   "source": [
    "#### Summary of errors\n",
    "\n",
    "* **Syntax error**: your code is not ‘grammatically’ correct\n",
    "* **Runtime error**: you’ve asked python to do something impossible\n",
    "* **Logic errors**: your code doesn’t actually mean what you think it should.\n",
    "\n",
    "Errors in code are called bugs, and getting rid of them is called debugging. We will teach you how to debug throughout the course.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ya1MBtNnyM5W"
   },
   "source": [
    "### Variables\n",
    "\n",
    "Variables in Python are “typed”. Every variable has a given type, which you can check by writing `type(varname)`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 763,
     "status": "ok",
     "timestamp": 1594706653505,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "VwxJC1QnyM5W",
    "outputId": "48883ef9-87cf-4503-b9e6-39520cc7aff4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'> <class 'float'> <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "a = 10 # integer\n",
    "b = 20.0 # real number (float)\n",
    "c = 'Its just a flesh wound!ssfff' # string\n",
    "\n",
    "print(type(a), type(b), type(c))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VDZD3gRgyM5e",
    "outputId": "25c3b67d-d96f-46a1-a151-f5e9da1062ae"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 42,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aP-zNlZwyM5i",
    "outputId": "9cc375c3-8679-4405-9463-059dbc587e90"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 43,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZvLyL9seyM5k"
   },
   "source": [
    "Directly combining variables of different types usually creates a `TypeError`. Python can  automatically convert some of them, e.g. `int` to `float`. \n",
    "(Python is dynamically strongly typed)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 736,
     "status": "ok",
     "timestamp": 1594706681615,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "auTgzNTmyM5l",
    "outputId": "53e2b340-cfe5-47c2-e19d-1201f3852c7d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a / b # 자동 형변환 -> float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 176
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 699,
     "status": "error",
     "timestamp": 1594706692584,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "NlSBMDvWyM5o",
    "outputId": "26710afe-664d-4aae-94f8-e68c86fec13b"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-49-71dac0aef348>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mc\u001b[0m \u001b[1;31m# string으로 형변환 불가\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "a + c # string으로 형변환 불가"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WSPaXdvIyM5s"
   },
   "source": [
    "### Modules in Python (Library in R)\n",
    "\n",
    "* Module is a collection of definitions.\n",
    "* In order to use modules in your script or interpreter, you need to import them, e.g.:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 818,
     "status": "ok",
     "timestamp": 1594706737563,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "q9VK3SxxyM5t"
   },
   "outputs": [],
   "source": [
    "import math #r: library(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'log' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-8281727c9a18>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mlog\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'log' is not defined"
     ]
    }
   ],
   "source": [
    "log(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0986122886681098"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# r : install.packages('math') \n",
    "# a.3=5 -> r에서는 가능, python은 error -> library 받는 용으로 사용\n",
    "# r : library(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cmd prompt에서 설치\n",
    "import math\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "E-JW062WyM5w"
   },
   "source": [
    "Functions of imported modules can be accessed with a `.`, such as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 906,
     "status": "ok",
     "timestamp": 1594706777906,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "xGXaTNLmyM5x",
    "outputId": "03440dfc-18de-44c0-eec5-d6f7f80494af"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7320508075688772"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.sqrt(4)\n",
    "math.exp(1)\n",
    "exp100=math.exp\n",
    "sqrt100 = math.sqrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp100(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt100(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ANcU4Z4PyM50"
   },
   "source": [
    "You can import specific definitions from a module, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 764,
     "status": "ok",
     "timestamp": 1594706814403,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "cCME0xoQyM51",
    "outputId": "7d0a1876-4d85-4c6e-ad56-05f519e0a5b0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.302585092994046"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import math\n",
    "from math import log # only log function\n",
    "math.log(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XrfgMFG6yM56"
   },
   "source": [
    "You can also import all the definitions from a specific module, e.g.:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 738,
     "status": "ok",
     "timestamp": 1594706855338,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "x5LMwcR6yM57",
    "outputId": "8288afbf-ac0f-4560-d4c3-a0e005cbf3f4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.302585092994046"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import * # usually\n",
    "log(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7hl_PjqtyM5_"
   },
   "source": [
    "**This way is**, however, **disencouraged** because it clutters your namespace (an exception might be build-in modules, like math). If two modules that you import have a function that has the same name, you cannot be sure which function you are calling, nor can readers of your code! As an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 148
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 757,
     "status": "ok",
     "timestamp": 1594706922679,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "XOnams6JyM5_",
    "outputId": "c508b6c1-bd12-486b-b39d-7873e56994de"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sqrt in module math:\n",
      "\n",
      "sqrt(...)\n",
      "    sqrt(x)\n",
      "    \n",
      "    Return the square root of x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sqrt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "p1hWFCGvyM6C"
   },
   "source": [
    "If we import the `numpy` package which comes with a `sqrt()` function as well, we overwrite the old definition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 781,
     "status": "ok",
     "timestamp": 1594706957719,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "oozbq8NHyM6D"
   },
   "outputs": [],
   "source": [
    "from numpy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MJ5jLAWPyM6M"
   },
   "source": [
    "If you do not want to write out module names to access their functions, you can import an entire module by importing it with an alias. A better way of importing the `numpy` module is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "x7r9zm06yM6S",
    "outputId": "1c9522f3-5d27-4fd8-b7db-f402508a7b96"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7320508075688772"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.sqrt(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 961,
     "status": "ok",
     "timestamp": 1594707106912,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "T62BBncayM6a"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from math import sqrt\n",
    "#library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 772,
     "status": "ok",
     "timestamp": 1594707110279,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "3mwCLNM6yM6f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(4) # math modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 758,
     "status": "ok",
     "timestamp": 1594707115841,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "2vEgyblTyM6j"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(4) # np modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sqrt? # help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqrt??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sqrt in module math:\n",
      "\n",
      "sqrt(x, /)\n",
      "    Return the square root of x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sqrt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YT4W1KSXyM6n"
   },
   "source": [
    "type markdown and latex $α2$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "n8OtOvOtyM6n",
    "outputId": "27c16725-3b36-4823-910c-238a1355eeab"
   },
   "source": [
    "$k_{n+1}=n^2+k_n^2-k_{n-1}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VWenFHGLyM6s"
   },
   "source": [
    "### Strings\n",
    "\n",
    "* a string is a sequence of characters\n",
    "* strings must be enclosed in quotes (to distinguish them from variable names)\n",
    "* certain characters must be escaped by backlashes, e.g. `\"\\ \"`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Z9Iy3WiYyM6s",
    "outputId": "5af8bed6-caf3-4813-f3b4-4e40399945c0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "doesn\n",
      " a\t5\n"
     ]
    }
   ],
   "source": [
    "a =\"doesn\\n a\\t5\"    \n",
    "# \\n: 한줄 건너띄기 (enter), %t 일정한 간격만큼 오르쪽으로 이동 (tab)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a='''\n",
    "300\n",
    "''' # 다중 주석처리"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GL9_9sPNyM6x"
   },
   "source": [
    "certain characters are \"invisible\", e.g. use `\"\\n\"` to indicate the end of a line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6xZU6ZjmyM6z"
   },
   "source": [
    "### Strings and print\n",
    "\n",
    "The `print` statement produces a more readable output for strings, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 699,
     "status": "ok",
     "timestamp": 1594707229092,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "sEC4zDHwyM6z",
    "outputId": "aa46e94c-d1e1-47b3-8e19-039cacdd3bb4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a rather long string containing\n",
      " several lines of text just as you would do in C. \n",
      "         Whitespace at beginning of the line is  significant.\n"
     ]
    }
   ],
   "source": [
    "hello = \"This is a rather long string containing\\n several lines of text just as you would do in C. \\n         Whitespace at beginning of the line is  significant.\"\n",
    "print(hello)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RRPF_hNXyM63"
   },
   "source": [
    "* spaces are also characters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 746,
     "status": "ok",
     "timestamp": 1594707272087,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "zc19a36wyM63",
    "outputId": "8a5a6bcf-9e5d-4a43-fb5f-27d3e882022c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"dor ota\"\n",
    "len(a) #length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 717,
     "status": "ok",
     "timestamp": 1594707279352,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "HQt_rQQMyM67",
    "outputId": "d58b888c-44df-4b34-cd42-55f4d11736ea"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = \"dorota \"\n",
    "len(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = [1,2,3]\n",
    "len(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DJXHOo_RyM6_"
   },
   "source": [
    "* two (or more) strings can be merged into one by using ”+\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "whbYFS2QyM6_",
    "outputId": "c7379c39-09a4-491c-f517-76852f4b87d4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dorota dorota dorota dorota dorota dorota dorota dorota dorota dorota '"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dorota dorota '"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5KUST6DJyM7F"
   },
   "source": [
    "* elements of a strings can be subscripted (indexed)\n",
    "* the first character of a string has subscript (index) 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 763,
     "status": "ok",
     "timestamp": 1594707341685,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "jzDJIJQpyM7G",
    "outputId": "a39c4b69-e205-4b82-bff6-3bacf2222f6c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n"
     ]
    }
   ],
   "source": [
    "word = 'Help'\n",
    "print(word[0]) # 0번째부터 indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iDItPl2QyM7K"
   },
   "source": [
    "* substrings can be specified with the slice notation: two indices separated by a colon\n",
    "* the first index is inclusive, the terminating second index is exclusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 777,
     "status": "ok",
     "timestamp": 1594707401885,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "0mpSFN4tyM7K",
    "outputId": "8e7ded6f-a351-4ba9-bfa3-1802cd31ea87"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hel'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word[0:3] #불편함  #a:b --> a번째부터시작해서 b번째 바로 앞까지\n",
    "# index slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Help'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word[0:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Help'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-67-83d7e66dbb24>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mword\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;31m# okay\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mword\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;31m# error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "word[0:100] # okay\n",
    "word[100] # error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6kvzTjQ6yM7b"
   },
   "source": [
    "* indices may be negative numbers, to start counting from the right:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 763,
     "status": "ok",
     "timestamp": 1594707492099,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "uECN7OUhyM7c",
    "outputId": "36af3ece-8684-4e27-e50d-263b07594f93"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'l'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word[-2] #Help p is -1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XkSCEzB8yM7f"
   },
   "source": [
    "Omitting a slice index means \"start from beginning\" or \"end with (inlcuding) the last index\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 953,
     "status": "ok",
     "timestamp": 1594707617128,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "XTkrDzcFyM7f",
    "outputId": "3fabf46d-3b2b-4153-f9a9-6be901bea194"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lp'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word[-2:] #Help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'el'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word[-3:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 727,
     "status": "ok",
     "timestamp": 1594707654434,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "N61ERZwLyM7i",
    "outputId": "2f94eae7-174d-4da6-f862-c35420318c2f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e\n",
      "Hel\n",
      "p\n",
      "p\n"
     ]
    }
   ],
   "source": [
    "word[:-2] #Expect Hel #또한번 불편 #Output : He\n",
    "print(word[1])\n",
    "print(word[0:3]) #Help\n",
    "print(word[3]) # =\n",
    "print(word[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "biJjactTyM7m"
   },
   "source": [
    "Python strings cannot be changed - assigning to an indexed position in the string results in an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2kuYjy3myM7m",
    "outputId": "7552b2c9-7841-478c-d2de-3f5e0ee5713d"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-72-2ac82ee2f715>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mword\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'x'\u001b[0m \u001b[1;31m#xelp\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "word[0] = 'x' #xelp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4ny5v5N0yM7o"
   },
   "source": [
    "### Lists\n",
    "\n",
    "#### What are Lists?\n",
    "\n",
    "Compound data type used to group together other values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 733,
     "status": "ok",
     "timestamp": 1594708390924,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "N1a0DhabyM7p",
    "outputId": "0a90fcb5-2b27-4fe5-d94b-6bac4097ee27"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "list1 = [\"first\", \"second\", \"third\"] #c(1,5,2)\n",
    "list2 = [1, 2, 3]\n",
    "list3 = [\"pi\", 3.1415926, \"answer\", 42] \n",
    "# In R, everything is treated as strings.\n",
    "\n",
    "\n",
    "print(type(list3[0])) # pi\n",
    "print(type(list3[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "m4Gj6CRmyM7s"
   },
   "source": [
    "* Values don’t have to be of the same type\n",
    "* Lists can be modified after creation (they are *mutable* )\n",
    "* Elements can be changed, added, and deleted\n",
    "* Lists are versatile and are used extensively in typical Python code\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0-G8T59myM7s",
    "outputId": "804309aa-7384-4203-ffb5-44da426e6d21"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second', 'third']"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GByE3eKcyM7t",
    "outputId": "ae7d7488-e2fc-4645-9a2a-943b3454608b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 128,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(list3[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2oZnLyWAyM7w",
    "outputId": "fd1484ff-67ce-4738-a0ff-4dc58c0ea505"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.1415926"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list3[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5-9PCe6cyM7y",
    "outputId": "9283949b-9830-4f98-db2f-1428ac54bd81",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 130,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(list3[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ELiGmVOdyM70"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "colab": {
   "name": "Class1_introduction.ipynb",
   "provenance": []
  },
  "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}