00 Basic Python3/02_List_Tuple.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fast Python3 for Beginners\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The basic data structure in python: Sequence.\n",
    "## List [ ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Two ways to initialize a empty list\n",
    "l = []\n",
    "# or\n",
    "l = list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a:  [[], [], [], [], [], [], [], [], [], []]\n",
      "b:  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
      "c:  [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]\n"
     ]
    }
   ],
   "source": [
    "# If you want to initialize a multi-dimension list\n",
    "a = [[]] * 10\n",
    "print('a: ', a)\n",
    "b = [0] * 10\n",
    "print('b: ', b)\n",
    "c = [[0] * 4] * 4\n",
    "print('c: ', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**But the above initialization method has a latent problem that, for example:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0]]\n"
     ]
    }
   ],
   "source": [
    "# we change an element of c\n",
    "c[0][0] = 1\n",
    "# then, all the elements which are on the corresponding position will be changed togehter\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]\n"
     ]
    }
   ],
   "source": [
    "# so, the correct initialization method is: take c for example\n",
    "c = [[0] * 4 for _ in range(4)]\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]\n"
     ]
    }
   ],
   "source": [
    "c[0][0] = 1\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add two or more lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l:  ['hello', 3, 'wor', 'ld', 1, 2]\n"
     ]
    }
   ],
   "source": [
    "# First example:\n",
    "l1 = ['hello', 3]\n",
    "l2 = ['wor', 'ld']\n",
    "l3 = [1, 2]\n",
    "l = l1 + l2 + l3 # it will return a new list, means new memory\n",
    "print('l: ', l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lab:  [1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# Second example:\n",
    "la = [1, 2, 3]\n",
    "lb = [1, 2, 3]\n",
    "lab = la + lb\n",
    "print('lab: ', lab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***NOTE:*** **It is different with the add operation in `numpy`, which we will talk about later.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nab:  [2 4 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "na = np.array([1, 2, 3])\n",
    "nb = np.array([1, 2, 3])\n",
    "nab = na + nb\n",
    "print('nab: ', nab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x for x in dir(list) if not x.startswith('_')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`list` is changeable(varient), so we can do `assignment` and `delete` to a list in-place.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "assignment: [2, 3, 2]\n",
      "delete: [2, 3]\n"
     ]
    }
   ],
   "source": [
    "# assignment\n",
    "x = [1, 3, 2]\n",
    "x[0] = 2\n",
    "print('assignment:', x)\n",
    "\n",
    "# delete\n",
    "del x[2]\n",
    "print('delete:', x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### slice()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nums[2:5]:  [3, 4, 5]\n",
      "nums[: 3]:  [1, 2, 3]\n",
      "nums[::2]:  [1, 3, 5, 7]\n",
      "nums[::-1]:  [7, 6, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "nums = [1, 2, 3, 4, 5, 6, 7]\n",
    "print('nums[2:5]: ', nums[2:5])   # [nums[2], nums[3], nums[4]] --> [3, 4, 5], the index range is [2, 5)\n",
    "print('nums[: 3]: ', nums[:3])    # [nums[0], nums[1], nums[2]] --> [1, 2, 3]\n",
    "print('nums[::2]: ', nums[::2])   # 2 is the step size\n",
    "print('nums[::-1]: ', nums[::-1]) # reverse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***NOTE:*** **When `step size` is positive, it iterate from start to end; when it is negative, it iterate from end to start.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### append()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3]\n",
    "l.append(4)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3]\n",
    "l.clear()\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### copy() vs deepcopy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c: [0, 2, 3]\n",
      "l: [0, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3]\n",
    "c = l # just associate a new name c to the list l, so if you change c, l is also changed.\n",
    "c[0] = 0\n",
    "print('c:', c)\n",
    "print('l:', l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c: [0, 2, 3]\n",
      "l: [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# so you need a copy\n",
    "l = [1, 2, 3]\n",
    "c = l.copy()\n",
    "c[0] = 0\n",
    "print('c:', c)\n",
    "print('l:', l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shallow copy of x: \n",
      " [[0, 2], 2, [4, 5, 6]]\n",
      "x:\n",
      " [[0, 2], 2, [4, 5, 6]]\n"
     ]
    }
   ],
   "source": [
    "# vs deepcopy\n",
    "import copy\n",
    "x = [[1, 2], 2, [4, 5, 6]]\n",
    "cx = x.copy()\n",
    "cx[0][0] = 0\n",
    "print('shallow copy of x: \\n', cx)\n",
    "print('x:\\n', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deep copy of x: \n",
      " [[0, 2], 2, [4, 5, 6]]\n",
      "x:\n",
      " [[1, 2], 2, [4, 5, 6]]\n"
     ]
    }
   ],
   "source": [
    "x = [[1, 2], 2, [4, 5, 6]]\n",
    "cx = copy.deepcopy(x)\n",
    "cx[0][0] = 0\n",
    "print('deep copy of x: \\n', cx)\n",
    "print('x:\\n', x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['to', 'be', 'or', 'not', 'to', 'be'].count('to')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### extend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "l1 = [1, 2, 3]\n",
    "l2 = [4, 5]\n",
    "l1.extend(l2)\n",
    "print(l1) # l1 is changed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "l1 = [1, 2, 3]\n",
    "l2 = [4, 5]\n",
    "print(l1 + l2)\n",
    "print(l1) # l1 is not changed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### index()\n",
    "`list.index(element)`, return the first element index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = ['to', 'be', 'or', 'not', 'to', 'be']\n",
    "x.index('to')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### insert()\n",
    "`list.insert(index, element)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 4, 5]\n",
    "x.insert(2, 3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n",
      "[2]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "x.pop() # pop the last element \n",
    "print(x)\n",
    "x.pop(0) # pop the 0-index element\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### remove()\n",
    "`list.remove(element)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['to', 'be', 'or', 'to', 'be']\n"
     ]
    }
   ],
   "source": [
    "x = ['to', 'be', 'or', 'not', 'to', 'be']\n",
    "x.remove('not')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "x.reverse()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sort() vs sorted()\n",
    "**The sort method used in python `sort()` is stable, which means it keeps the element's original relative position after the sort.**\n",
    "* `list.sort()` return `None`, sort the list in-place\n",
    "* `sorted(list)` return a new sorted list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sort():\n",
      " x: [1, 2, 3, 4, 5]\n",
      "sorted():\n",
      "y: [1, 2, 3, 4, 5]\n",
      "x: [3, 2, 1, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "x = [3, 2, 1, 4, 5]\n",
    "x.sort()\n",
    "print('sort():\\n x:', x)\n",
    "\n",
    "x = [3, 2, 1, 4, 5]\n",
    "y = sorted(x)\n",
    "print('sorted():\\ny:', y)\n",
    "print('x:', x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple ( )\n",
    "`tuple` is a kind of sequence, and like `string`, it is also `invariant`, so you can do any change to a `tuple`.  \n",
    "Also, `tuple` and `string` are `hashable` and could be used as a `key` in `dict`, but `list` can not be used as a `key`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Three ways to initialize a tuple\n",
    "l = ()\n",
    "# or\n",
    "l = tuple()\n",
    "# or\n",
    "l = 1, 2, 3 # pay attention to the ','"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x for x in dir(tuple) if not x.startswith('_')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Done!🐈'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Done!\\N{Cat}'"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}