Class2_lists-and-loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QiUXutelB5Kr"
   },
   "source": [
    "# Lists and loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sP3d9R8qB5Ku"
   },
   "source": [
    "A list is the first type of **data structure** that we meet in this course. While \"data structure\" may sound complicated, is just a collection of data elements (e.g. numbers or strings) that is structured in some way (e.g. by numbering the elements). The list is a sequence, where each element has an index, i.e. its position in the list.\n",
    "\n",
    "You can create a new list using the square brackets ```[]```, or the ```list()``` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 640,
     "status": "ok",
     "timestamp": 1594708600913,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "0dXpryMBB5Ky"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['first', 'second', 'third']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [\"first\", \"second\", \"third\"] # 대괄호\n",
    "# sequence, array, matrix of data\n",
    "print(list1)\n",
    "type(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b=(1,2,3) # not a list, tuple\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list=list(b) # 형변환\n",
    "type(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 651,
     "status": "ok",
     "timestamp": 1594708564166,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "3fQaCzuzB5LC",
    "outputId": "9b3526a8-f47a-4746-e1a5-fa490afaeac0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2 = list((\"a\", \"b\")) #as.matrix as.value\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5HEn3OX7B5LN",
    "outputId": "d7cebf9b-7b98-49bb-f883-3539b31c4e8c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cake', 4, 7.9, 'apple']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list3 = ['cake', 4, 7.9, \"apple\"]\n",
    "list3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JvfkDKLbB5LW"
   },
   "source": [
    "Properties of lists to remember:\n",
    "+ Values don't have to be of the same type (see ```list3```)\n",
    "+ You can modify lists **after** you create them (they are *mutable*)\n",
    "+ Elements can be **changed, added and deleted**\n",
    "+ Lists are versatile and are used extensively in typical Python code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KBu55OWAB5LZ"
   },
   "source": [
    "## Accessing elements in a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AVAQetSnB5Lb"
   },
   "source": [
    "Just like you did this morning - accessing elements of strings - elements in a list are accessed by their index.\n",
    "\n",
    "Remember:\n",
    "+ index by **square brackets```[]```**\n",
    "+ note how **index starts at zero!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 600,
     "status": "ok",
     "timestamp": 1594708604250,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "XtTq93TLB5Ld",
    "outputId": "421713bd-086a-40af-a092-95933f715ca3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second', 'third']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 629,
     "status": "ok",
     "timestamp": 1594708626967,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "_j-ehZF8B5Lm",
    "outputId": "6bda8500-c86a-4e0f-bab4-8b259f76c43f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second', 'third']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[0:3] # 0,1,2 번째 값 출력\n",
    "# -3, -2, -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 636,
     "status": "ok",
     "timestamp": 1594708630038,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "MqG1XrQfB5Lz",
    "outputId": "ac2f3659-c069-4f82-e16d-857026b41661"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic": {
       "type": "string"
      },
      "text/plain": [
       "'first'"
      ]
     },
     "execution_count": 11,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0j4AeTEoB5L-"
   },
   "source": [
    "negative indexes go back from the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 658,
     "status": "ok",
     "timestamp": 1594708639399,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "XoePlB4DB5L-",
    "outputId": "ed6528ec-cd20-4e8b-c238-b7c7ca44da46"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'third'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KIBxFIVnB5ME"
   },
   "source": [
    "Trying to access an element in a list that is out of range throws an ```IndexError```; good to know how long the list is ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 597,
     "status": "ok",
     "timestamp": 1594708664126,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "lBkiGN6hB5MG",
    "outputId": "8301313e-e247-498e-c3fa-9bf9a06aa41e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nu2wRlJxB5MZ"
   },
   "source": [
    "## Modify your list!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oWfbZznhB5Mb"
   },
   "source": [
    "Remember that lists are **mutable**? This means that we can **change**, **add** and **remove** items from a list!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2loMbrzOB5Mc"
   },
   "source": [
    "### 1. Changing Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 589,
     "status": "ok",
     "timestamp": 1594708676857,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "y1DRiL3qB5Me",
    "outputId": "6fc48bf1-a742-487b-95bf-5f645d6e12e7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2 =[1,2,3]\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 639,
     "status": "ok",
     "timestamp": 1594708682230,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "PLt820jcB5Ml"
   },
   "outputs": [],
   "source": [
    "list2[0] = 4 # 값 수정"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 597,
     "status": "ok",
     "timestamp": 1594708685027,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "XMHz1V5XB5Mr",
    "outputId": "94d21601-76b3-4f5c-9e6c-c46db848dfca"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 2, 3]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vDpHSRYEB5Mw"
   },
   "source": [
    "Assigning to a position past the end of the list also throws an ```IndexError```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 176
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 596,
     "status": "error",
     "timestamp": 1594708700811,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "7Av56E_DB5My",
    "outputId": "6408973a-bacb-42ee-e1f5-9d86d42334a3"
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list assignment 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-14-58d110677fb5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mlist2\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list assignment index out of range"
     ]
    }
   ],
   "source": [
    "list2[3] = 4 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5Fjo0g7YB5M5"
   },
   "source": [
    "### 2. Appending and Extending"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.exp(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 798,
     "status": "ok",
     "timestamp": 1594708749879,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "1x_VCWWrB5M6"
   },
   "outputs": [],
   "source": [
    "list1.append([1,2,3]) # r : append(list1, [1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 659,
     "status": "ok",
     "timestamp": 1594708750140,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "ewBfN4eKB5M9",
    "outputId": "6c438239-bc39-458d-d142-4f22f2ef95dc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second', 'third', [1, 2, 3]]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 641,
     "status": "ok",
     "timestamp": 1594708778935,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "5dSpx-aEDIXS",
    "outputId": "1b6849f5-ca01-4d8a-90d3-03ebac9f1ac7",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'second'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(list1[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(list1[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[3][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example of append function\n",
    "list2=[1,2,3]\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2.append(4) # only one argument\n",
    "list2.append(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2.remove(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, [4, 5]]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2.append([4,5]) #하나의 원소로 반영\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, [4, 5], [4]]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2.append([4]) #1,2,3,[4]\n",
    "list2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "q8aspTrpB5NB"
   },
   "source": [
    "If you want to append more than one item, you can use the ```extend ``` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 634,
     "status": "ok",
     "timestamp": 1594708841352,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "_zvJ335oB5NC"
   },
   "outputs": [],
   "source": [
    "list1.extend([\"a\", \"2\"])   #list1.append([\"a\", \"2\"]) :      ['first', 'second', 'third', [1, 2, 3], [\"a\", \"2\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 640,
     "status": "ok",
     "timestamp": 1594708844160,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "OJQDPgCyB5NH",
    "outputId": "c9ac9f43-4b86-40d6-f761-d22773b71901"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second', 'third', [1, 2, 3], 'a', '2']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make [1,2,3,4,5] using extend fucntion\n",
    "list2 = [1,2,3]\n",
    "list2.extend([4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 4, 5]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make [1,2,3,4,5] using + fucntion\n",
    "list3= list2+[4,5]\n",
    "list3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: \n",
    "\n",
    "1> Create a list of [1,2,3,4,5] and name it as \"numbers\"\n",
    "\n",
    "2> Use \"extend\" to extend to a list of [1,2,3,4,5,6,7,8,9,10]\n",
    "\n",
    "3> replace the last last item with 100\n",
    "\n",
    "4> Use \"append\" to extend to a list of [1,2,3,4,5,6,7,8,9,100,200]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers.extend([6,7,8,9,10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers[-1]=100 # numbers[10-1]=100 # 마지막 원소를 100으로 바꿈"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers.append(200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 100, 200]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Toawe6kJB5NK"
   },
   "source": [
    "### 3. Removing and Inserting Items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7Feh37g1B5NL"
   },
   "source": [
    "Items at arbitrary positions can be removed using the ```del``` statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 627,
     "status": "ok",
     "timestamp": 1594708868665,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "hR8sHxYvB5NL",
    "outputId": "26ad6266-115e-4c28-e7b3-9ee823204bf4"
   },
   "outputs": [],
   "source": [
    "list1 = [1,2,3,4,5,6,7,8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 638,
     "status": "ok",
     "timestamp": 1594708882451,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "4J0EIP66B5NQ"
   },
   "outputs": [],
   "source": [
    "del(list1[2:4]) #del(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use del to create [1,2,5,6,7,8] from list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 649,
     "status": "ok",
     "timestamp": 1594708885536,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "y3UQvYyFB5NU",
    "outputId": "dfc1e33d-4137-4ef4-dd8c-67f09285ca54"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mtydncKCB5Nd"
   },
   "source": [
    "Alternatively, you can use the ```pop``` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 582,
     "status": "ok",
     "timestamp": 1594708904663,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "ShRelvCVB5Ne",
    "outputId": "ce2303b2-386a-47b9-d459-4c9fcc278ac4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1.pop() # 가장 마지막 index의 값 제거"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 610,
     "status": "ok",
     "timestamp": 1594708910028,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "BC0pHCUXB5Ni",
    "outputId": "9b6ec93e-d3f2-4bce-fefb-51e40cfc80f1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 5, 6, 7]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 657,
     "status": "ok",
     "timestamp": 1594708920887,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "nl_QQqHDB5Nr",
    "outputId": "f6b32447-7ebf-469e-eec7-48e36424ba04",
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 607,
     "status": "ok",
     "timestamp": 1594708925710,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "tvQJ9uefB5Nu",
    "outputId": "b83180be-a504-40d3-d1e6-e554906361a1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 5, 6]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1666,
     "status": "ok",
     "timestamp": 1594708953396,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "boBkXONTD0sU",
    "outputId": "6369b63b-f5ca-4e8c-cd5e-4fc795c8b599"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1074,
     "status": "ok",
     "timestamp": 1594708963424,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "pFfYrU_1D5ku",
    "outputId": "6476fb12-90dc-4b4f-dcee-27977ee6a154"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 5, 6]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1567,
     "status": "ok",
     "timestamp": 1594708979016,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "lQNX030TB5N5",
    "outputId": "36003d52-9702-4e84-b0d0-eb6eba8e88e4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 12, 14, 15, 16, 17]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [11, 12, 14, 15, 16, 17]\n",
    "list1 # 대체"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eJ_dyKNsB5N8"
   },
   "source": [
    "```insert``` function: ```insert(index, item)```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 501,
     "status": "ok",
     "timestamp": 1594709012740,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "N-ha3ZLnB5N8",
    "outputId": "9520f686-33f9-4bf2-d6b6-b0b0eb582427"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 12, '10 + 3', 14, 15, 16, 17]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1.insert(2, \"10 + 3\") # 0:3   \n",
    "#   (0) a, (1) b, ('2') c (3)      0:2\n",
    "list1\n",
    "# index 2 자리에 대입\n",
    "# 2번째 원소 이후, 0,1,'2' 원소 이전에 삽입"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 624,
     "status": "ok",
     "timestamp": 1594709089434,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "_yxCwsfWB5OC",
    "outputId": "69539047-15a8-4f59-8dc8-8f6e328a34fa",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'e', 'c', 'd']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [\"a\", \"b\", \"c\", \"d\"]\n",
    "list1.insert(2, \"e\") # between b and c\n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2 = [ 1 , 2 ,3 , 4,5,6,7] # make it into [1,2,3 ,5, 4,5,6,7] use insert funciton\n",
    "list2.insert(3,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KuRRnQFiB5OF"
   },
   "source": [
    "note: appending items to the end of the list using ```append``` is more efficient than inserting at the end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aLGCtjYXB5OF"
   },
   "source": [
    "### 4. Adding lists = concatenating lists = extending"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1047,
     "status": "ok",
     "timestamp": 1594709127612,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "l615NsTHB5OG",
    "outputId": "a071b4b3-f2f8-412e-857b-28ab54896cfd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1=[1,2]\n",
    "list2=[3,4]\n",
    "list3=[5,6]\n",
    "list4 = list1 + list2 + list3\n",
    "list4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "F-R4SCVoB5OJ"
   },
   "source": [
    "### 5. Multiplying lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yPBPf39gB5OK"
   },
   "source": [
    "Multiplying a list by a number *does not* multiply the elements of the list, but **the whole list**:\n",
    "\n",
    "(NB: this is specific to sequences. Other data structures have element-wise multiplication as you will see later in the course)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 612,
     "status": "ok",
     "timestamp": 1594709140171,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "55yBWPIcB5OL",
    "outputId": "27693f5b-988c-49d8-9e9f-d7fcf8f8d165"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list5 = [1,2,3] * 5 # r : rep(c(1,2,3), 5)\n",
    "list5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example:\n",
    "\n",
    "1> Create the list of [1,2,4,5] and name it as \"numbers.\"\n",
    "\n",
    "2> Change the \"numbers\" to [1,2,3,4,5] by using the command \"insert\".\n",
    "\n",
    "3> Change the \"numbers\" to [1,3,5] by using the command \"pop\".\n",
    "\n",
    "4> Repeat the procedure in 3> by using the command \"del\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers.insert(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers.pop(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers.pop(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(numbers[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list assignment 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-60-cdc371e1e9fe>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mdel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnumbers\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list assignment index out of range"
     ]
    }
   ],
   "source": [
    "del(numbers[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "16gE1FhOB5ON"
   },
   "source": [
    "## List slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2KlyiVBWB5OO"
   },
   "source": [
    "A copy of a sublist can be created using the **slice operator** ```list[start:end]```\n",
    "The element at the index **start is included**, the one at **end is excluded** (remember slicing strings with Fabian this morning?)\n",
    "\n",
    "Both indices can be ommitted, defaulting to the start and end of the list respectively"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 658,
     "status": "ok",
     "timestamp": 1594709195932,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "WGboeX3gB5OQ",
    "outputId": "64861fcf-d4ef-482a-b5ce-0b831232e7e4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4=[1,2,3,4,5,6,7]\n",
    "list4[0:5] # 0th부터 4th까지"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "sJ3TQyMKE0UT"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(list4[0:5])\n",
    "# list4[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8-UKfyX5B5OT",
    "outputId": "beb64a32-470d-4bdc-dc92-739aeeb7949a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4[4:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Q4-bD-ohB5OY",
    "outputId": "ed777cc1-a9c2-40a3-c625-1fdcd20f9087"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4[:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qlHhz2MGB5Ob",
    "outputId": "07dc1acb-60ae-4735-ce68-61864a3a5d9d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4[ : ] # all"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JDkwnkQaB5Oe"
   },
   "source": [
    "to slice in bigger steps, include a stepsize:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 608,
     "status": "ok",
     "timestamp": 1594709270332,
     "user": {
      "displayName": "﻿안재윤(전임교원/통계학과)",
      "photoUrl": "",
      "userId": "02619146530199681853"
     },
     "user_tz": -540
    },
    "id": "tSQ5ZwBBB5Oe",
    "outputId": "c8a62160-44bb-42a9-9d2a-6cb9086ebb55",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 7]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4[0::3] # 간격 두 칸 띄고 세 번째씩"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# odd numbers only\n",
    "# R : seq(1,7, step=2) -> 1,3,5,7\n",
    "list4[0::2] # step size = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4[0:5:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example:\n",
    "\n",
    "You are given \"list = [10,20,30,40,50,60,70,80,90,100]\".\n",
    "\n",
    "1> Change the \"list\" to [20,40,60,80,100].\n",
    "\n",
    "2> Select [30, 40, 50, 60, 70] in \"list\" using slicing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [10,20,30,40,50,60,70,80,90,100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[20, 40, 60, 80, 100]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_rev=list1[1::2] # same with [1:10:2]\n",
    "list_rev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[30, 40, 50, 60, 70]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_new=list1[2:7]\n",
    "list_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "list indices must be integers or slices, not tuple",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-74-501e13f03d82>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mdel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# Error... index should be single / slice\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: list indices must be integers or slices, not tuple"
     ]
    }
   ],
   "source": [
    "del(list1[1,2]) # Error... index should be single / slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 30, 50, 70, 90]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del(list1[1::2])\n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[3-1] # 2nd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3T0xU3EjB5Oi"
   },
   "source": [
    "## Tuple:\n",
    "\n",
    "Tuple is very similar to list except\n",
    "    * Use () instead of []\n",
    "    * Cannot change the values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HFNPxXJ1B5Oi",
    "outputId": "7bfe0869-643e-4d56-c04c-5fb3f180ade4"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' 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-77-e742ac64aa49>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mt1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"a\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"b\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mt1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t1 = (1,2,\"a\",\"b\")\n",
    "t1[0]=100\n",
    "print(t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' 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-78-4fcb1775ef2c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mt1\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m30\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m40\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m50\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mt1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m100\u001b[0m \u001b[1;31m# 특정 index 값 교환 불가 , tuple : more like constant\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t1=(10,20,30,40,50)\n",
    "t1[2]=100 # 특정 index 값 교환 불가 , tuple : more like constant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1=(1,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=(1,2,3,4,5)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wkNeCd70B5Ol",
    "outputId": "686c3b6b-d771-4fcf-8376-247061df5b51"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 2, 'a', 'b']\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,2,\"a\",\"b\"]\n",
    "L1[0]=100 # list는 가능\n",
    "print(L1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wM9aRd1GB5Oo"
   },
   "source": [
    "## Set:\n",
    "\n",
    "Set does not have an order : similar to list and string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "duQdetbkB5Oo",
    "outputId": "2a4aed94-d9e3-4b68-9217-df7d7b3f0842"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'H', 'e', 'l', 'o'}"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = set(\"Hello\") # use {}, list : [], tuple : ()\n",
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HfkuaSOEB5Or",
    "outputId": "ef3a7c25-53f1-4c60-e3ee-f10ac233dd93"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n",
      "{3}\n"
     ]
    }
   ],
   "source": [
    "s1=set([1,2,3])\n",
    "s2=set([3,4,5])\n",
    "print(s1|s2) # | means or/union\n",
    "print(s1 & s2) # & means and/intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "i5gRmfDQB5Ov",
    "outputId": "4fd59fd6-4df6-4131-f85d-334d4a97d684"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 5}\n",
      "{5}\n"
     ]
    }
   ],
   "source": [
    "s3 = {1,3,5}\n",
    "print(s1|s3)\n",
    "print(s3-s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QfH1moswB5O0",
    "outputId": "dfc1b56c-7656-4167-ca2e-c1443c64ecc6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 5, 10, 11, 12}"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.add(5)\n",
    "s1.update([10,11,12])\n",
    "s1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example: \n",
    "\n",
    "You are given list2=[110, 105, 110, 104, 107, 120, 107].\n",
    "\n",
    "Calculate how many unique items in \"list2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{104, 105, 107, 110, 120}"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2=[110, 105, 110, 104, 107, 120, 107]\n",
    "set1 = set(list2)\n",
    "set1\n",
    "# unique item -> set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2WDlqZuDB5O4"
   },
   "source": [
    "## Variables and References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C6FhV8FLB5O5"
   },
   "source": [
    "NB: in Python, **all variables are references**\n",
    "The ```=``` operator does not copy an object, it just creates another reference (name) for the *same* object!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7SzwZtazB5O5",
    "outputId": "937cd28d-b717-4c74-8ab8-63e471607181"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4 = [1, 2, 3, 4, 5, 6, 7]\n",
    "list4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Oq5kWcPQB5O8"
   },
   "outputs": [],
   "source": [
    "list5 = list4 #R과 다름\n",
    "list50 = list4[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "x8L5D8KFB5PA",
    "outputId": "e0c0690c-dd1d-4fc7-e088-1ef631088471"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7]\n",
      "[1, 2, 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "print(list50)\n",
    "print(list5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "12Zw6cXsB5PF"
   },
   "outputs": [],
   "source": [
    "list4[-1]=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "G58jETLuB5PK",
    "outputId": "4d654a40-2bf5-4aec-fd95-bf866465c5a2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 100]\n",
      "[1, 2, 3, 4, 5, 6, 7]\n",
      "[1, 2, 3, 4, 5, 6, 100]\n"
     ]
    }
   ],
   "source": [
    "print(list4)\n",
    "print(list50) # 항목만 복사\n",
    "print(list5) # 아예 대입 ... index 값 하나 바꿔도 동시에 수정"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "diA2w0hTB5PN",
    "outputId": "8377e868-dd16-4c4b-df8c-d79a1ed02f00"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 100]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rtQ7P3mqB5PQ",
    "outputId": "ad3ccb91-cc28-4fb3-f5a4-dc17627176f0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'apple'"
      ]
     },
     "execution_count": 32,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list5.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HL72W7ubB5PU"
   },
   "outputs": [],
   "source": [
    "list5 = list4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "b3zZgox6B5PZ",
    "outputId": "8c85fce0-ea67-41bd-ddf8-2afd97dabbd0",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2020336075632\n",
      "2020335368016\n",
      "1708944464\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "300"
      ]
     },
     "execution_count": 107,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple1 = (1,2,3) #\"절대\"상수\n",
    "mytuple2 = mytuple1\n",
    "mytuple3 = mytuple1[2] # 값 하나만 빼옴\n",
    "mytuple1[-1] = 300 #create error - 값 변경 불가\n",
    "#print(mytuple1)\n",
    "#print(mytuple2)\n",
    "#print(mytuple3)\n",
    "print(id(mytuple1))\n",
    "print(id(mytuple2))\n",
    "print(id(mytuple3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' 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-99-f7880d5c2c2a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mmytuple2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmytuple1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mmytuple3\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmytuple1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mmytuple1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m300\u001b[0m \u001b[1;31m#create error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m \u001b[1;31m#print(mytuple1)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;31m#print(mytuple2)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "mytuple1 = (1,2,3) #\"절대\"상수\n",
    "mytuple2 = mytuple1\n",
    "mytuple3 = mytuple1[2]\n",
    "mytuple1[-1] = 300 #create error\n",
    "#print(mytuple1)\n",
    "#print(mytuple2)\n",
    "#print(mytuple3)\n",
    "print(id(mytuple1))\n",
    "print(id(mytuple2))\n",
    "print(id(mytuple3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YWHh5wucB5Pd"
   },
   "source": [
    "Check: they both point to the same memory address; i.e. both ```list1``` and ```list5``` **refer** to the same list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5lltJxqYB5Pd",
    "outputId": "560f06a2-b077-4030-f5fd-bea0cf9cbf1f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2106631833864\n",
      "2106631833864\n",
      "2106631919432\n"
     ]
    }
   ],
   "source": [
    "print(id(list5))\n",
    "print(id(list4))\n",
    "print(id(list50))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C0lnQ95dB5Ph"
   },
   "source": [
    "-> if you want to create a new list with the same contents as another list, you need to **copy** it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k7AsRTEGB5Ph"
   },
   "source": [
    "* Example 1: Copying lists\n",
    "    \n",
    "(a) Create a list a with some entries.\n",
    "\n",
    "(b) Now set b = a\n",
    "\n",
    "(c) Change b[1]\n",
    "\n",
    "(d) What happened to a?\n",
    "\n",
    "(e) Now set c = a[:]\n",
    "\n",
    "(f) Change c[2]\n",
    "\n",
    "(g) What happened to a?\n",
    "\n",
    "Now create a function set_first_elem_to_zero(l) that takes a list, sets its first entry to zero, and\n",
    "returns the list.\n",
    "What happens to the original list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aIZzMB13B5Pi"
   },
   "outputs": [],
   "source": [
    "a=[1, 8, 'apple', 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "b[1]='banana'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'banana', 'apple', 5]"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=a[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "c[2]='carrot'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'banana', 'apple', 5]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0STkrNasB5Pl"
   },
   "source": [
    "* Example 2: Write a function that takes a list and an index, and sets the value of the list at the given index to 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "c--fhSiPB5Pl"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'banana', 0, 5]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def func(list, index):\n",
    "    list[index]=0\n",
    "    return list\n",
    "\n",
    "func(a, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "n3anhLC5B5Pn"
   },
   "source": [
    "### ```range()```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Od8YN_1fB5Po"
   },
   "source": [
    "+ One very commonly needed list is the list of consecutive integers (e.g. for looping – more about that in a bit)\n",
    "+ The built-in ```range([start], end)``` function creates such lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_tMxiDtgB5Po",
    "outputId": "02447307-dca1-4be5-da3c-d0eb8bb414cd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5g3BvdB2B5Pr",
    "outputId": "d3323fd2-2b9b-46d3-d5af-25c872f34300"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myrange = list(range(3, 10))\n",
    "myrange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7VTzwOJSB5Pt",
    "outputId": "75c8f136-ba83-4dfa-d631-3cad3baedf79"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(3, 15)"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(3,15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zyTGholpB5Pw",
    "outputId": "d1089397-4528-4669-d071-3c04cd6a0eda"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5, 7, 9, 11, 13]"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(3,15,2)) #sequence, step =2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PLMPH4iAB5P8"
   },
   "source": [
    "# `For` Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "R9gW1unXB5P8"
   },
   "source": [
    "When programming, you often want to do the same task for each point in a data set. Some examples:\n",
    "+ You have the attendance list of the Python course and for each participant, you want to print their department\n",
    "+ You have two lists, for each item in list A check whether it is also in list B\n",
    "+ You want to call a function for each element of an array\n",
    "\n",
    "Notice how the structure of the programming command follows a natural logic: **FOR** each item**:** **DO** some action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pODgFo0WB5P8",
    "outputId": "be19bd1c-dcc4-4caa-fc50-a9542ee4d2b3"
   },
   "outputs": [],
   "source": [
    "tutors = ['Fabian', 'Lea', 'Dimitris', 'Joe', 'Ingolf']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "for ttt in [(1,2,3), (4, 5, 6)]:\n",
    "    print (ttt[0]+ttt[1]+ttt[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PWf_iou6B5P9",
    "outputId": "bfc65300-63e3-40ab-d194-5d33323c36a7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'Fabian'), (1, 'Lea'), (2, 'Dimitris'), (3, 'Joe'), (4, 'Ingolf')]"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(tutors))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "R0djAaa_B5QA",
    "outputId": "8455a5ed-df1f-403a-a9b1-4d31e82c1876"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<enumerate object at 0x000001EA7D0DD318>\n"
     ]
    }
   ],
   "source": [
    "tutors=[\"a\", \"b\"]\n",
    "print(enumerate(tutors))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'a'), (1, 'b')]"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(tutors))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ImNPFaUAB5QD",
    "outputId": "de2442fa-917e-4b23-ce22-4ea5066a8aab"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fabian\n",
      "6\n",
      "Lea\n",
      "3\n",
      "Dimitris\n",
      "8\n",
      "Joe\n",
      "3\n",
      "Ingolf\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "tutors = ['Fabian', 'Lea', 'Dimitris', 'Joe', 'Ingolf']\n",
    "for name in tutors:\n",
    "    print(name)\n",
    "    print(len(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FWadlopzB5QF"
   },
   "source": [
    "## Different ways of iterating"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cXHfaV3sB5QG"
   },
   "source": [
    "### 1. `range()`\n",
    "`range()` returns a list of plain integers. \n",
    "Thus, one way to loop over a sequence is to use `range()` on the length of a sequence -> the returned list are the **indexes** of the sequence. You can then **access each element by index**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cWfA_4NVB5QG",
    "outputId": "21a4a14e-ae7b-447d-a368-9840cf43b67d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "d51kClKaB5QJ",
    "outputId": "c6d007b6-114d-47c8-f905-410bc7d581d3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fabian\n",
      "Lea\n",
      "Dimitris\n",
      "Joe\n",
      "Ingolf\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(tutors)):\n",
    "    print(tutors[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OQLtUW9UB5QP"
   },
   "source": [
    "### 2. `enumerate()`\n",
    "`enumerate()` returns a tuple containing a count and the values obtained from iterating over sequence. This is handy if you need both the item a sequence and its index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CFOJWMcbB5QQ",
    "outputId": "4f594563-97b7-4880-fa65-1abbd32ca130"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'Fabian'), (1, 'Lea'), (2, 'Dimitris'), (3, 'Joe'), (4, 'Ingolf')]"
      ]
     },
     "execution_count": 136,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(tutors))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1YNJwhLMB5QR"
   },
   "source": [
    "We have seen how `for` loops allow us to easily execute the same statement for each item in a list. But what if we want to **apply different statements, depending on the item?**\n",
    "In our earlier example, say you want to print the name, but only if it contains the letter i. So now when you initialize the iterator, there are actually 2 different options and we need to check which one is the case:\n",
    "\n",
    "**if** the name contains the letter i -> **print** the name *--> whiteboard*\n",
    "\n",
    "These check-points are called **conditionals**; you check whether a condition is met. And the whole concept is referred to as **flow control**, because at these check points, you control \"in which direction the programme is going to flow\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4c7SmHNZB5QR",
    "outputId": "f8d8db3b-725a-4714-d7c2-1204d22a8b33"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Fabian\n",
      "1 Lea\n",
      "2 Dimitris\n",
      "3 Joe\n",
      "4 Ingolf\n"
     ]
    }
   ],
   "source": [
    "for index,name in enumerate(tutors):\n",
    "    print(index, name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RGNmf5d8B5QT",
    "outputId": "768201d6-b711-488b-d3e3-e3029a2fe837"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 156,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3==5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_8GZmjw6B5QV",
    "outputId": "d251564d-d4f2-4c09-955d-7cd63491fac3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5005\n",
      "[1665, 1705, 1635]\n"
     ]
    }
   ],
   "source": [
    "#10~100 합을 프로그램?\n",
    "s=0\n",
    "for i in range(10, 101):\n",
    "    s=s+i\n",
    "print(s)    \n",
    "\n",
    "# S2=10, 13, 16, ..., 100의 합? Hint 8 % 2\n",
    "# S3=11, 13, 15, 98의합?\n",
    "# S=12, 15, 18\n",
    "s1=s2=s3=0\n",
    "for i in range(10, 101):\n",
    "    if i%3 ==0:\n",
    "        s1=s1+i\n",
    "    elif i%3 ==1:\n",
    "        s2=s2+i\n",
    "    else:\n",
    "        s3=s3+i\n",
    "print([s1, s2, s3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Os2Z48yUB5QX",
    "outputId": "b0e292c6-46a9-43d2-faf6-502bdfe163e2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2474113110344, 2474113110344]\n"
     ]
    }
   ],
   "source": [
    "s1=s2=[1,2,3]\n",
    "print([id(s1), id(s2)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KsJ1WQSVB5QZ",
    "outputId": "95486740-f9bb-4bdd-af09-7b95ab49c1a6",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 200, 300] [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "s1=[100,200,300] #다시정의\n",
    "print(s1, s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "s3=[1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "s4=s3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4] [100, 200, 300]\n"
     ]
    }
   ],
   "source": [
    "s4=[100, 200, 300]\n",
    "print(s3, s4) # s3 수정 안 됨"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "s4[1]=[100, 200, 300] \n",
    "# 항목 하나만 바꿨을 때 단독 - s3 수정됨, # 항목 전체 다 바꿨을 때는 index 하나 바꿔도 수정 안되고 다시 돌아옴"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, [100, 200, 300], 3, 4]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100, [100, 200, 300], 300]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4] [100, [100, 200, 300], 300]\n"
     ]
    }
   ],
   "source": [
    "print(s3,s4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "s3=[1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "s4=s3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "s4[1]=[100, 200, 300] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, [100, 200, 300], 3, 4]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, [100, 200, 300], 3, 4] [1, [100, 200, 300], 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(s3,s4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ErvaakOkB5Qb"
   },
   "source": [
    "# Flow control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9SffpGJGB5Qb"
   },
   "source": [
    "### 1. conditionals - keywords "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SJuMvDWmB5Qb"
   },
   "source": [
    "## `if`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Mz3JeLhlB5Qb"
   },
   "source": [
    "use the `if` keyword to check whether a condition is met:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kwoNubkNB5Qb",
    "outputId": "d2913774-4668-4baa-97aa-1e5b26aec560"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  is even\n",
      "100\n",
      "100\n",
      "2  is even\n",
      "100\n",
      "100\n",
      "4  is even\n",
      "100\n",
      "100\n",
      "6  is even\n",
      "100\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "for number in range(8):\n",
    "    if number % 2 == 0:\n",
    "        print(number, ' is even')\n",
    "    print(100)    # 4, 8\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "msY2a-JUB5Qe"
   },
   "source": [
    "use the `else` keyword to specify a statement that is executed when the condition is not true:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "A3PMzKKaB5Qe"
   },
   "source": [
    "## `else`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EUa5fWWBB5Qe",
    "outputId": "9752ba30-f07e-4210-b5af-67f041c1c22a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is even\n",
      "1 is odd\n",
      "2 is even\n",
      "3 is odd\n",
      "4 is even\n",
      "5 is odd\n",
      "6 is even\n",
      "7 is odd\n"
     ]
    }
   ],
   "source": [
    "for number in range(8):\n",
    "    if number % 2 == 0:\n",
    "        print(number, 'is even')\n",
    "    else:\n",
    "        print(number, 'is odd')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qBXqiR-nB5Qg"
   },
   "source": [
    "use the `elif` keyword to **check for several conditions**:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5KOQaH-EB5Qg"
   },
   "source": [
    "## `elif`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "y9OxePiTB5Qh",
    "outputId": "5a262c67-39c1-4b1d-be92-488e7ed654f8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is even\n",
      "1 is odd\n",
      "2 is even\n",
      "3 is my favourite number!\n",
      "4 is even\n",
      "5 is odd\n",
      "6 is even\n",
      "7 is odd\n"
     ]
    }
   ],
   "source": [
    "for number in range(8):\n",
    "    if number % 2 ==0:\n",
    "        print(number, 'is even')\n",
    "    elif number == 3:\n",
    "        print(number, 'is my favourite number!')\n",
    "    else:\n",
    "        print(number, 'is odd')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "y_ZB6H_GB5Qj"
   },
   "source": [
    "### 2. conditionals - expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "V-0x2LjbB5Qj"
   },
   "source": [
    "question: which expressions can you use as condition for an if statement?\n",
    "+ anything that evaluates to a **boolean value**\n",
    "+ Boolean values are `True` and `False`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oAnat_ZYB5Qk"
   },
   "source": [
    "#### e.g. comparison of numeric types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "e3d6P1EsB5Qk"
   },
   "source": [
    "Numeric types can be compared using the comparison operators, which yield True or False The operators are:\n",
    "    \n",
    "a < b | a less than b\n",
    "\n",
    "a > b | a greater than b\n",
    "\n",
    "a == b | a equal to b\n",
    "\n",
    "a <= b | a less than or equal to b\n",
    "\n",
    "a >= b | a greater than or equal to b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'banana', 'apple', 5]"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'banana', 'apple', 5]"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "g1uCz7JUB5Qk"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a<b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a>b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a==b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a<=b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a>=b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-yUSdgc1B5Qm"
   },
   "source": [
    "The boolean values `True` and `False` can be combined using the boolean operators **`and`, `or`,** and **`not`**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1H5ngiTdB5Qn"
   },
   "outputs": [],
   "source": [
    "a = True\n",
    "b = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DcNkUan4B5Qo",
    "outputId": "e9e1cfc0-f177-4b37-9bc9-c9044e4d50f3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a | b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a&3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "w6CWw1KsB5Qq",
    "outputId": "03fa420d-c31e-49c3-c770-3754718c9ad9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a & 3 <= 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1HUJA6NuB5Qs"
   },
   "source": [
    "#### e.g. testing for membership\n",
    "\n",
    "here the keyword is **`in`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3t_f3iu1B5Qs"
   },
   "outputs": [],
   "source": [
    "mondaytutors = [\"Fabian\", \"Lea\", \"Dimitris\", \"Ingolf\"]\n",
    "alltutors = [\"Fabian\", \"Joe\", \"Ingolf\", \"Lea\", \"Alison\", \"Matthias\", \"Michael\", \"Thanapong\", \"Peter\", \n",
    "             \"Dimitris\", \"Sheen\", \"Chris\", \"Auro\", \"Gaurav\", \"Ope\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Zaom_GKdB5Qu",
    "outputId": "d381b094-c539-4e19-c7be-9a8a63a34382"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Lea\" in mondaytutors "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Yx9wn0tCB5Qv",
    "outputId": "e4213a59-f06f-461d-850f-cb582eb2f041"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ahn\" in mondaytutors "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3Lpmd8vkB5Qx",
    "outputId": "0115d3d7-cd81-4bae-cfe0-fafe9bb029e3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fabian\n",
      "Ingolf\n",
      "Lea\n",
      "Dimitris\n"
     ]
    }
   ],
   "source": [
    "for tutor in alltutors:\n",
    "    if tutor in mondaytutors:\n",
    "        print(tutor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EiWDPWkHB5Qy"
   },
   "source": [
    "### Using `for` loops on lists and list comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "X_p2E0HuB5Qz"
   },
   "source": [
    "You commonly want to create a new list by transforming and filtering an old list:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "p5KmVp4QB5Q0",
    "outputId": "8ca52205-cc2f-4aa9-a775-ec3081756812"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even_numbers = []\n",
    "for x in range(10):\n",
    "    if x % 2 == 0:\n",
    "        even_numbers.append(x)\n",
    "even_numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "anJhihJKB5Q5"
   },
   "source": [
    "Because this is such a common operation Python also provides a shortcut in form of list comprehensions (they are truely great!)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vrq5BBNOB5Q6",
    "outputId": "48149279-622d-496c-96c8-1693e6a8fb32"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even_numbers = [x for x in range(10) if x % 2 == 0]\n",
    "        \n",
    "even_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Fabian', 'Ingolf', 'Lea', 'Dimitris']\n"
     ]
    }
   ],
   "source": [
    "my_monday = [x for x in alltutors if x in mondaytutors]\n",
    "print(my_monday)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "collapsed": true,
    "id": "F_YDRtSSB5Q8"
   },
   "source": [
    "* Example 3: Use a for loop to:\n",
    "        \n",
    "(a) Print the numbers 0 to 100\n",
    "\n",
    "(b) Print the numbers 0 to 100 that are divisible by 7\n",
    "\n",
    "(c) Print the numbers 1 to 100 that are divisible by 5 but not by 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZHCE1VDDB5Q9",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 7,\n",
       " 8,\n",
       " 9,\n",
       " 10,\n",
       " 11,\n",
       " 12,\n",
       " 13,\n",
       " 14,\n",
       " 15,\n",
       " 16,\n",
       " 17,\n",
       " 18,\n",
       " 19,\n",
       " 20,\n",
       " 21,\n",
       " 22,\n",
       " 23,\n",
       " 24,\n",
       " 25,\n",
       " 26,\n",
       " 27,\n",
       " 28,\n",
       " 29,\n",
       " 30,\n",
       " 31,\n",
       " 32,\n",
       " 33,\n",
       " 34,\n",
       " 35,\n",
       " 36,\n",
       " 37,\n",
       " 38,\n",
       " 39,\n",
       " 40,\n",
       " 41,\n",
       " 42,\n",
       " 43,\n",
       " 44,\n",
       " 45,\n",
       " 46,\n",
       " 47,\n",
       " 48,\n",
       " 49,\n",
       " 50,\n",
       " 51,\n",
       " 52,\n",
       " 53,\n",
       " 54,\n",
       " 55,\n",
       " 56,\n",
       " 57,\n",
       " 58,\n",
       " 59,\n",
       " 60,\n",
       " 61,\n",
       " 62,\n",
       " 63,\n",
       " 64,\n",
       " 65,\n",
       " 66,\n",
       " 67,\n",
       " 68,\n",
       " 69,\n",
       " 70,\n",
       " 71,\n",
       " 72,\n",
       " 73,\n",
       " 74,\n",
       " 75,\n",
       " 76,\n",
       " 77,\n",
       " 78,\n",
       " 79,\n",
       " 80,\n",
       " 81,\n",
       " 82,\n",
       " 83,\n",
       " 84,\n",
       " 85,\n",
       " 86,\n",
       " 87,\n",
       " 88,\n",
       " 89,\n",
       " 90,\n",
       " 91,\n",
       " 92,\n",
       " 93,\n",
       " 94,\n",
       " 95,\n",
       " 96,\n",
       " 97,\n",
       " 98,\n",
       " 99,\n",
       " 100]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1=[]\n",
    "list1=[x for x in range(0, 101)]\n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2=[]\n",
    "list2=[x for x in range(0, 101) if x%7==0]\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 10, 20, 25, 35, 40, 50, 55, 65, 70, 80, 85, 95, 100]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list3=[]\n",
    "list3=[x for x in range(1, 101) if (x%5==0) & (x%3!=0)]\n",
    "list3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TOLwcqlAB5Q-"
   },
   "source": [
    "* Example 4: Instead of using a for loop, use a while loop to:\n",
    "        \n",
    "(a) Print the numbers 0 to 100\n",
    "\n",
    "(b) Print the numbers 0 to 100 that are divisible by 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "12flXE35B5Q_",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "24\n",
      "25\n",
      "26\n",
      "27\n",
      "28\n",
      "29\n",
      "30\n",
      "31\n",
      "32\n",
      "33\n",
      "34\n",
      "35\n",
      "36\n",
      "37\n",
      "38\n",
      "39\n",
      "40\n",
      "41\n",
      "42\n",
      "43\n",
      "44\n",
      "45\n",
      "46\n",
      "47\n",
      "48\n",
      "49\n",
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "55\n",
      "56\n",
      "57\n",
      "58\n",
      "59\n",
      "60\n",
      "61\n",
      "62\n",
      "63\n",
      "64\n",
      "65\n",
      "66\n",
      "67\n",
      "68\n",
      "69\n",
      "70\n",
      "71\n",
      "72\n",
      "73\n",
      "74\n",
      "75\n",
      "76\n",
      "77\n",
      "78\n",
      "79\n",
      "80\n",
      "81\n",
      "82\n",
      "83\n",
      "84\n",
      "85\n",
      "86\n",
      "87\n",
      "88\n",
      "89\n",
      "90\n",
      "91\n",
      "92\n",
      "93\n",
      "94\n",
      "95\n",
      "96\n",
      "97\n",
      "98\n",
      "99\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "x=0\n",
    "while x<101:\n",
    "    print(x) # 100까지 찍히고 증가 : 101 -> loop out\n",
    "    x=x+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "7\n",
      "14\n",
      "21\n",
      "28\n",
      "35\n",
      "42\n",
      "49\n",
      "56\n",
      "63\n",
      "70\n",
      "77\n",
      "84\n",
      "91\n",
      "98\n"
     ]
    }
   ],
   "source": [
    "x=0\n",
    "while x<101:\n",
    "    if x%7==0:\n",
    "        print(x)\n",
    "    x=x+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KQELBerNB5RA"
   },
   "source": [
    "* Example 5: Use a while loop to find the first 20 numbers that are divisible by 5, 7 and 11, and print them Hint:\n",
    "store the number found so far in a variable.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XSqPcy6FB5RA"
   },
   "outputs": [],
   "source": [
    "#Pseudo-code:\n",
    "\n",
    "#number found = 0\n",
    "#x = 11\n",
    "#while number found is less than 20:\n",
    "#    if x is divisible by 5, 7 and 11:\n",
    "#        print x\n",
    "#        increase number found by 1\n",
    "#    increase x by 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 385,\n",
       " 770,\n",
       " 1155,\n",
       " 1540,\n",
       " 1925,\n",
       " 2310,\n",
       " 2695,\n",
       " 3080,\n",
       " 3465,\n",
       " 3850,\n",
       " 4235,\n",
       " 4620,\n",
       " 5005,\n",
       " 5390,\n",
       " 5775,\n",
       " 6160,\n",
       " 6545,\n",
       " 6930,\n",
       " 7315]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_n=[]\n",
    "i=0\n",
    "while len(list_n)<20:\n",
    "    if (i%5==0) & (i%7==0) & (i%11==0):\n",
    "        list_n.append(i) # append되는게 len 측정보다 나중이므로 20번째까지 찍고 loop out\n",
    "    i=i+1\n",
    "list_n\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XW6Lb_XTB5RB"
   },
   "source": [
    "*  Example 6: \n",
    "    \n",
    "(a) Write a function is_prime(n) that returns True only if n is prime.\n",
    "\n",
    "(b) Write a function that returns all primes up to n.\n",
    "\n",
    "(c) Write a function that returns the first n primes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dmf0T-m2B5RB"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def is_prime(n):\n",
    "    for i in range(2,n):\n",
    "        if n%i==0:\n",
    "            return False\n",
    "        else:\n",
    "            return True\n",
    "        \n",
    "print(is_prime(16))\n",
    "print(is_prime(17))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "crRzuOgRB5RD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "def is_prime1(n):\n",
    "    for i in range(2, n):\n",
    "        for j in range(2, i):\n",
    "            if i%j==0:\n",
    "                break \n",
    "        else:\n",
    "            print(i)\n",
    "            \n",
    "is_prime1(16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_prime3(n):\n",
    "    for i in range(2, n):\n",
    "        for j in range(2, i):\n",
    "            if i%j ==0:\n",
    "                break\n",
    "        else:\n",
    "            return i\n",
    "        break\n",
    "is_prime3(16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DhdXREKoB5RD"
   },
   "source": [
    "* Example 7: In Example 6, you wrote a function that prints all primes up to n, and a function that prints the first n\n",
    "primes. Update these functions such that they return lists instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 5, 7, 11, 13]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_p=[]\n",
    "def is_prime2(n):\n",
    "    for i in range(2, n):\n",
    "        for j in range(2, i):\n",
    "            if i%j ==0:\n",
    "                break\n",
    "        else:\n",
    "            list_p.append(i)\n",
    "    #list_p.sort()\n",
    "    return list_p\n",
    "is_prime2(16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qkeE952nB5RF"
   },
   "source": [
    "* Example 8: Consider having a list with lists as elements, e.g. [[1,3], [3,6]].\n",
    "Write a function that takes such a list, and returns a list with as elements the elements of the sublists,\n",
    "e.g. [1, 3, 3, 6]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "E2mHwspZB5RF"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 3, 6]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=[[1,3], [3,6]]\n",
    "mylist=[]\n",
    "for x in range(len(a)):\n",
    "    mylist.extend(a[x])\n",
    "    \n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, [3, 4]]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist=[1,2]\n",
    "mylist.append([3,4])\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist=[1,2]\n",
    "mylist.extend([3,4])\n",
    "mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hw2mM8hLB5RG"
   },
   "source": [
    "* Example 9: \n",
    "    \n",
    "Write a function that takes a value x and a list ys, and returns a list that contains the value x and all\n",
    "elements of ys such that all values y in ys that are smaller than x come first, then we element x and\n",
    "then the rest of the values in ys.\n",
    "\n",
    "For example, the output of f(3, [6, 4, 1, 7]) should be [1, 3, 6, 4, 7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "u5WmtusfB5RG"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 6, 4, 7]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#x=3\n",
    "#ys=[6,4,1,7]\n",
    "\n",
    "def arrange_f(x, ys):\n",
    "    myleft=[]\n",
    "    myright=[]\n",
    "    for y in ys:\n",
    "        if y<=x:\n",
    "            myleft.append(y)\n",
    "        else:\n",
    "            myright.append(y)\n",
    "    ret=myleft+[x]+myright\n",
    "    return ret\n",
    "\n",
    "arrange_f(3, [6,4,1,7])    "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "Class2_lists-and-loops.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
}