advanced-topics/mutability.ipynb

{
 "metadata": {
  "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.8.5-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "Python 3.8.5 64-bit",
   "display_name": "Python 3.8.5 64-bit",
   "metadata": {
    "interpreter": {
     "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Mutability\n",
    "\n",
    "Python data can be one of two types: mutable data and immutable data. \n",
    "\n",
    "- Immutable data can not be changed. Everytime you want to change it, you get a new data. \n",
    "- Mutable data can be changed. Whenever you change a mutable data, all variables point to the data can see the change.\n",
    "\n",
    "Knowing the mutability of the data is important because mutable data can cause hard-to-find bugs in your software.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## 1 Immutable Data Types\n",
    "\n",
    "The built-in data types `int`, `float`, `string` and `tuple` are immutable data types,i.e., you can not change the data once it is created.\n",
    "\n",
    "For example, all methods of a string that change the string will return a new string. The old string stays untouched."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "original_name = 'Alice'\n",
    "original_alias = original_name\n",
    "\n",
    "uppercase_name = original_name.upper()\n",
    "replaced_name = original_name.replace('ce', 'da')\n",
    "\n",
    "print(f'Original name: {original_name}. Uppercase name: {uppercase_name}')\n",
    "print(f'Original alias: {original_alias}. Replaced name: {replaced_name}')"
   ]
  },
  {
   "source": [
    "In the above code, the original and its alias have the same oringal value. Both the `upper()` and `replace()` methods create a new string."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## 2 Mutable Data Types\n",
    "\n",
    "The built-in types such as `list`, `dictionary` and `set` are mutable types. They have methods that change the original data."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "original_names = ['Alice', 'Bob', 'Cindy']\n",
    "original_alias = original_names\n",
    "\n",
    "original_names.append('David')\n",
    "appended_names = original_names\n",
    "\n",
    "original_names.reverse()\n",
    "reversed_names = original_names\n",
    "\n",
    "print(f'Original names: {original_names}. Appended names: {appended_names}')\n",
    "print(f'Original alias: {original_alias}. Reversed names: {reversed_names}')"
   ]
  },
  {
   "source": [
    "In the above code, once the list of original names changes, all the variables pointing to the data can see the changes."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## 3 Copy Data\n",
    "\n",
    "Sharing mutable data could be dangerous because you may accidently change the data that used by another variable. If you want to use and change data, it is a good idea to make a copy of the original data."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [1, 2, 3]\n",
    "l2 = l1\n",
    "\n",
    "l3 = l1.copy()\n",
    "\n",
    "l1[2] = 'three'\n",
    "\n",
    "print(l1, l2, l3)"
   ]
  },
  {
   "source": [
    "In the above code, we have `l1` and `l2` point to the same list and `l3` is a copy of `l1`. When `l1` changes, both `l1` and `l2` change but `l3` is not changed.\n",
    "\n",
    "![mutable list](images/mutable-list.png)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "However, the copy of list is a shallow copy. If you have nested mutable data inside a list, it is still shared at the nested level."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "l1 = [1, 2, {'id': 5, 'name': 'alice'}]\n",
    "l2 = l1\n",
    "\n",
    "l3 = l1.copy()\n",
    "\n",
    "l1[1] = 20\n",
    "l1[2]['name'] = 'bob'\n",
    "\n",
    "print(l1, l2, l3)"
   ],
   "cell_type": "code",
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "source": [
    "In the above example, `l1` and `l2` have the same value. The second element o f `l3` is not changed, however, the third element is changed. The reason for this is that the third element is a dictionary -- a mutable data. To get a deep copy, use the `copy.deepcopy` from the `copy` module."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "l1 = [1, 2, {'id': 5, 'name': 'alice'}]\n",
    "l2 = l1\n",
    "\n",
    "l3 = copy.deepcopy(l1)\n",
    "\n",
    "l1[1] = 20\n",
    "l1[2]['name'] = 'bob'\n",
    "\n",
    "print(l1, l2, l3)"
   ]
  },
  {
   "source": [
    "## 4 Mutable Data as Argument\n",
    "\n",
    "When a variable of mutable data is passed as an argument, the data could be changed inside a function and it could risky. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(numbers):\n",
    "    numbers[2] = 'three'\n",
    "    print(numbers)\n",
    "\n",
    "l1 = [1, 2, 3]\n",
    "test(l1)\n",
    "print(l1)"
   ]
  },
  {
   "source": [
    "In the above code, the `l1` was changed inside the `test()` function and it might be unexpected. To avoid it, you should pass a deep copy. It might hurt the performance but safety is more important than performance in most cases."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "import copy\n",
    "def test(numbers):\n",
    "    numbers[2] = 'three'\n",
    "    print(numbers)\n",
    "\n",
    "l1 = [1, 2, 3]\n",
    "test(copy.deepcopy(l1))\n",
    "print(l1)"
   ],
   "cell_type": "code",
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}