Class 06 Python Tuples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class 6 Python Tuples\n",
    "\n",
    "\n",
    "## 6.1 Features of Tuples\n",
    "\n",
    "1. Tuples are immutable (same as numbers and strings).\n",
    "2. Tuples can be dictionary keys.\n",
    "3. Tuples can contain other Python data structures (container type).\n",
    "4. A single-element tuple must contain a tailing comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'tuple'>\n",
      "<type 'int'>\n",
      "<type 'list'>\n"
     ]
    }
   ],
   "source": [
    "tt1 = (1,)\n",
    "# Create an empty tuple\n",
    "print(type(tt1))\n",
    "\n",
    "tt2 = (1)\n",
    "print(type(tt2))\n",
    "\n",
    "ll1 = [1]\n",
    "print(type(ll1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.2 Special Features of Tuples\n",
    "\n",
    "1. Immutability: \n",
    "\n",
    "> A data type that is immutable simply means that once an object is defined, its value cannot be updated, unless, of course, a completely new object is allocated.\n",
    "\n",
    "2. But tuples are flexible:\n",
    "\n",
    "> Although tuple objects themselves are immutable, this fact does not preclude tuples from containing mutable objects that can be changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(['xyz', 123], 23, -103.4)\n",
      "123\n",
      "(['xyz', ['abc', 'def']], 23, -103.4)\n"
     ]
    }
   ],
   "source": [
    "t = (['xyz', 123], 23, -103.4)\n",
    "\n",
    "print(t)\n",
    "\n",
    "print(t[0][1])\n",
    "\n",
    "t[0][1] = ['abc', 'def']\n",
    "\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Any function returning multiple objects (also no enclosing symbols) is a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'tuple'>\n",
      "3\n",
      "2\n",
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "def calculate(a, b):\n",
    "    return a+b, a*b\n",
    "\n",
    "result = calculate(1, 2)\n",
    "print(type(result))\n",
    "\n",
    "sum_result, product_result = calculate(1, 2)\n",
    "\n",
    "print(sum_result, product_result)\n",
    "\n",
    "_, product_result = calculate(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Explicit grouping of parentheses for expressions or tuple creation is always recommended to avoid unpleasant side effects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, True, 5)\n",
      "False\n",
      "set([0, 9, 2])\n"
     ]
    }
   ],
   "source": [
    "print(4, 2 < 3, 5)\n",
    "\n",
    "print((4, 2) < (3, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Immutable objects have values that cannot be changed. That means that they will always hash to the same value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.3 Copying Python Objects and Shallow and Deep Copies\n",
    "\n",
    "object assignments = object references\n",
    "\n",
    "> This means that when you create an object, then assign that object to another variable, Python copies only a reference to the object.\n",
    "\n",
    "> A shallow copy of an object is defined to be a newly created object of the same type as the original object whose contents are references to the elements in the original object.\n",
    "\n",
    "    (1) taking a complete slice [:], \n",
    "    (2) using a factory function, e.g., list(), dict(), etc., \n",
    "    (3) using the copy() function of the copy module.\n",
    "    \n",
    "> When shallow copies are made, the string is explicitly copied and a new (string) object created while the list only has its reference copied, not its members.\n",
    "\n",
    "[Example](http://pythontutor.com/visualize.html#mode=display&togetherjs=6CNIwEC6L7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "asda\n",
      "['asd']\n"
     ]
    }
   ],
   "source": [
    "from copy import deepcopy\n",
    "\n",
    "a = 'asda'\n",
    "b = a\n",
    "print(b)\n",
    "\n",
    "l1 = ['asd']\n",
    "l2 = l1\n",
    "l3 = deepcopy(l1)\n",
    "print(l3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.3 Summary to Sequences\n",
    "\n",
    "### 6.3.1 Features of Python sequences\n",
    "\n",
    "1. Three data types: `str`, `list` and `tuples`.\n",
    "2. Immuntable data type: `str` and `tuple` VS. muttable data type: `list`.\n",
    "3. Singular data type: `str` VS. container data type: `list` and `tuple`.\n",
    "\n",
    "### 6.3.2 Commmon operations in sequences:\n",
    "\n",
    "1. Slicing: sequence[`begin_index:end_index`]\n",
    "2. `in`: item `in` sequence / item `not in` sequence\n",
    "3. Indexing: sequence[`index`]\n",
    "4. Concatenation: sequence1 + sequence2\n",
    "5. Repetition: Squence * `int`\n",
    "\n",
    "### 6.3.3 Important operations in `str`\n",
    "\n",
    "1. `str.split`\n",
    "2. `str.encode`\n",
    "3. `str.decode`\n",
    "4. `str.strip`\n",
    "5. `str.translate`\n",
    "\n",
    "\n",
    "### 6.3.4 Important operations in `list`\n",
    "\n",
    "1. `list.append`\n",
    "2. `list.extend`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}