Data Structure - List, Truple.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "A = [1, 2, 3]\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "A = [0] * 5\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Add a element "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n"
     ]
    }
   ],
   "source": [
    "A = []\n",
    "A.append(1)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extend another arrary "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 1, 2, 3]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = [1,2,3]\n",
    "l2= [4,5]\n",
    "\n",
    "l2.extend(l1)\n",
    "l2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Remove a last element "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "del A[-1]\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3]\n"
     ]
    }
   ],
   "source": [
    "# make a copy \n",
    "B = [1, 3, 4]\n",
    "b = B[:-1]\n",
    "print(b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Access"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "A = [1, 3 ,4]\n",
    "print(A[0])\n",
    "print(A[-1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse a array \n",
    "Method #1: Slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 3, 5]\n",
      "[2, 3]\n"
     ]
    }
   ],
   "source": [
    "A = [1, 2, 4, 3, 5]\n",
    "print (A)\n",
    "A = A[::-1]\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Method #2: Build-in function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 5, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "A = [1, 3, 5, 6]\n",
    "A.reverse()\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse with a range "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 5]\n",
      "[1, 3, 2, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "A = [1, 2, 3, 4, 5, 6]\n",
    "print (A[-1:3:-1])\n",
    "print (A[:1] + A[2:0:-1] + A[3:])\n",
    "# 注意这里的链接必须都是array， 要是其中有一个是integer， 会出错的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List to string "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123\n",
      "Peter * Lu\n"
     ]
    }
   ],
   "source": [
    "A = [1, 2, 3]\n",
    "A = [str(s) for s in A] # 此处也可以用map\n",
    "s = (\"\").join(A)\n",
    "print(s)\n",
    "\n",
    "\n",
    "A = [\"Peter\",\"Lu\" ]\n",
    "s = \" * \".join(A)\n",
    "print(s)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[4]\n",
      "[6, 5]\n"
     ]
    }
   ],
   "source": [
    "#A = range(10)\n",
    "A = [1, 2, 3, 4, 5, 6]\n",
    "print (A[:])\n",
    "print (A[3:-1:3])\n",
    "print (A[-1:3:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sort array "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ascending order "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4, 6, 10]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 3, 4, 10, 6]\n",
    "a.sort() # in-place \n",
    "print(a) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "decending order "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 9, 8, 4, 1]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 9, 4, 10, 8]\n",
    "a.sort(reverse = True)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# key fucntion "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Peter', 'knows', 'what', 'to', 'work', 'on', 'this', 'project']\n",
      "['to', 'on', 'what', 'work', 'this', 'Peter', 'knows', 'project']\n",
      "['to', 'on', 'what', 'work', 'this', 'Peter', 'knows', 'project']\n",
      "['project', 'Peter', 'knows', 'this', 'what', 'work', 'on', 'to']\n",
      "['knows', 'on', 'Peter', 'project', 'this', 'to', 'what', 'work']\n",
      "['Peter', 'knows', 'on', 'project', 'this', 'to', 'what', 'work']\n"
     ]
    }
   ],
   "source": [
    "a = \"Peter knows what to work on this project\"\n",
    "arr = a.split(\" \")\n",
    "print(arr)\n",
    "arr.sort(key = lambda x : len(x))\n",
    "print(arr)\n",
    "\n",
    "arr.sort(key = len)\n",
    "print(arr)\n",
    "\n",
    "arr.sort(key = lambda x :(-len(x), x))# 如果len 一样， 按照alphabatic 排序\n",
    "print(arr)\n",
    "\n",
    "arr.sort(key = str.lower) # lower \n",
    "print(arr)\n",
    "arr.sort(key = lambda x: x)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sorted, return a new list: sorted(arr, key = , reverse = )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "student_tuples = [\n",
    "     ('john', 'A', 15),\n",
    "     ('jane', 'B', 12),\n",
    "     ('dave', 'B', 10),\n",
    " ]\n",
    "sorted(student_tuples, key=lambda student: student[2])   # sort by age\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1], [1, -1], [2, -1], [2, 1]]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = []\n",
    "p.append([1, -1])\n",
    "p.append([0, 1])\n",
    "p.append([2, 1])\n",
    "p.append([2,-1])\n",
    "sorted(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2-D Array 2 row and 5 col"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]\n"
     ]
    }
   ],
   "source": [
    "a = [[0] * 5 for _ in range(2)]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]\n"
     ]
    }
   ],
   "source": [
    "a = [[0 for x in range(5)] for y in range (2)]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 0, 0, 0, 0], [0, 0, 0, 0, 3]]\n"
     ]
    }
   ],
   "source": [
    "a[1][4] = 3\n",
    "print(a)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [3, 4, 6]\n",
    "import bisect\n",
    "i = bisect.bisect(a, 0)\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "a = [3, 4, 6]\n",
    "import bisect\n",
    "i = bisect.bisect(a, 3)\n",
    "print (i)\n",
    "\n",
    "j = bisect.bisect_left(a, 3)\n",
    "print (j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "a = [3, 4, 4, 6]\n",
    "import bisect\n",
    "i = bisect.bisect(a, 4)\n",
    "print (i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "a = [3, 4, 4, 6]\n",
    "import bisect\n",
    "i = bisect.bisect_left(a, 4)\n",
    "print (i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "a = [3, 4, 4, 6]\n",
    "import bisect\n",
    "i = bisect.bisect_right(a, 4)\n",
    "print (i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "a = [3, 4, 4, 6]\n",
    "import bisect\n",
    "i = bisect.bisect_left(a, 10)\n",
    "print (i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = []\n",
    "a + [1]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Difference between List and Truple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "5\n",
      "[3, 4, 6]\n",
      "[3, 4, 2, 6]\n"
     ]
    }
   ],
   "source": [
    "a = [3,4,5,6]\n",
    "print (str(type(a)))\n",
    "try:\n",
    "    print (a.pop(2))\n",
    "    print (a)\n",
    "    a.insert(2,2)\n",
    "    print (a)\n",
    "except:\n",
    "    print (str(type(a))+\" is not changable\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'> is not changable\n"
     ]
    }
   ],
   "source": [
    "a = (3,4,5,6)\n",
    "try:\n",
    "    print (a.pop(2))\n",
    "    print (a)\n",
    "    a.insert(2,2)\n",
    "    print (a)\n",
    "except:\n",
    "    print (str(type(a))+\" is not changable\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Filter\n",
    "filter(function, iterable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "data = list(range(10))\n",
    "print (data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "d1 = list (filter(lambda i: i%2 ==0, data))\n",
    "print (d1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Map\n",
    "map(function, iterable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "data = list (map(lambda i: i+1, data[2:5:1]))\n",
    "print (data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reduce\n",
    "1. combine the reuslt returned for each element together into a single result\n",
    "2. Need to import functools module\n",
    "3. functools.reduce(function, iterable[, initializer])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "data = list(range(5))\n",
    "res = reduce (lambda tot, val: tot + val, data)\n",
    "print (res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}