08. Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, List is a data type. <br> It is square brackets [ ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The indexing of a list starts at 0.<br>\n",
    "Index for the list ['cat', 'bat' ,'rat' , 'dog'] is [0, 1, 2, 3] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The following is an example of how the indexing works\n",
    "\n",
    "spam = ['cat', 'bat', 'rat', 'elephant']\n",
    "\n",
    "print(spam[0])\n",
    "print(spam[1])\n",
    "print(spam[2])\n",
    "print(spam[3])\n",
    "print(['cat', 'bat', 'rat', 'elephant'][3])\n",
    "\n",
    "# Note that indexes can only be integers and not float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Negative index\n",
    "Putting a negative number goes backwards from the last value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Below is an example of using negative indexes\n",
    "\n",
    "spam = ['cat', 'bat', 'rat', 'elephant']\n",
    "\n",
    "print(spam[-1])\n",
    "print(spam[-2])\n",
    "print(spam[-3])\n",
    "print(spam[-4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More values using Slices\n",
    "\n",
    "In a slice, the first integer is the index where the slice starts. <br>\n",
    "The second integer is the index where the slice ends.<br>\n",
    " A slice goes up to, but will NOT include, the value at the second index. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code below shows use case for slices\n",
    "\n",
    "spam = ['cat', 'bat', 'rat', 'elephant']\n",
    "\n",
    "spam[1:3]\n",
    "\n",
    "# notice how it reads bat and rat, but doesn't include elephant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get a List's length with len() Function\n",
    "Use len(`list`) to get the number of items in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam = ['cat','dog','moose']\n",
    "len(spam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing values in a list with indexes\n",
    "We can assign a value in a list by referencing index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The code below is an example of of changing values in a list\n",
    "\n",
    "spam = ['cat', 'bat', 'rat', 'elephant']\n",
    "spam[1] = 'aardvark'\n",
    "print(spam)\n",
    "\n",
    "spam[2] = spam[1]\n",
    "print(spam)\n",
    "\n",
    "spam[-1] = 12345\n",
    "print(spam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List concatenation and replication\n",
    "We can combine two lists using `+` operator<br>\n",
    "We can replicate lists using `*` operator with an integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "concatenate_example = [1, 2, 3] + ['A', 'B', 'C']\n",
    "print(concatenate_example)\n",
    "\n",
    "duplication_example = ['X', 'Y', 'Z'] * 3\n",
    "print(duplication_example)\n",
    "\n",
    "spam = [1, 2, 3]\n",
    "spam = spam + ['A', 'B', 'C']\n",
    "print(spam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deleting values in lists\n",
    "Use the `del` statement and specify the position to delete the value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Below is an example of deleting a value from a list\n",
    "spam = ['cat', 'bat', 'rat', 'elephant']\n",
    "print(spam)\n",
    "del spam[2]\n",
    "print(spam)\n",
    "del spam[2]\n",
    "print(spam) \n",
    "\n",
    "# You can also use the `del` statement to delete variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reason for using a list\n",
    "We use a list so we don't have to assign so many variables for something that could be done in 1 line\n",
    "Eg.\n",
    "```\n",
    "catName1 = 'Zophie'\n",
    "catName2 = 'Pooka'\n",
    "catName3 = 'Simon'\n",
    "catName4 = 'Lady Macbeth'\n",
    "catName5 = 'Fat-tail'\n",
    "catName6 = 'Miss Cleo'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example of input to make list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Below is an example of how we can use lists and programming to manually input and make a list\n",
    "catNames = []\n",
    "while True:\n",
    "    print('Enter the name of the cat ' + str(len(catNames) + 1) + ' (or enter nothing to stop): ')\n",
    "    name = input()\n",
    "    if name == '':\n",
    "        break\n",
    "    catNames = catNames + [name] # add into the catnames list\n",
    "print('The cats'' names are: ')\n",
    "for name in catNames:\n",
    "    print(' ' + name)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using for Loops for Lists\n",
    "The for loop repeats the code blcok once for each item in a list. <br><br>\n",
    " We can use `range(len(someList))` with a `for` loop to iterate over the indexes of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index 0 in supplies: pens\n",
      "Index 1 in supplies: staplers\n",
      "Index 2 in supplies: flamethrowers\n",
      "Index 3 in supplies: binders\n"
     ]
    }
   ],
   "source": [
    "# Example below\n",
    "supplies = ['pens', 'staplers', 'flamethrowers', 'binders']\n",
    "for i in range(len(supplies)):\n",
    "    print('Index ' + str(i) + ' in supplies: ' + supplies[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `range(len(supplies))` in the previously shown for loop is handy because the code in the loop can access the index (as the variable `i`) and the value at that index (as `supplies[i]`). <br><br>\n",
    "Best of all, `range(len(supplies))` will iterate through all the indexes of supplies, no matter how many items it contains."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `in` & `not in` Operators\n",
    "You already know this. It's an operator to tell whether the specified value is in the list or not.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Eg of `in` and `not in`\n",
    "'howdy' in ['hello','hi','howdy','hey']\n",
    "print('howdy' in ['hello','hi','howdy','hey'])\n",
    "\n",
    "spam = ['hello','hi','howdy','hey']\n",
    "print('cat' in spam)\n",
    "\n",
    "print('howdy' not in spam)\n",
    "\n",
    "print('cat' not in spam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Program to let user type in a pet name and then checks to see whether the name is in a list of pets.\n",
    "\n",
    "myPets = ['Tux','Minerva','Butterscotch']\n",
    "print('Enter a pet name: ')\n",
    "name = input()\n",
    "if name not in myPets:\n",
    "    print('I do not have a pet named '+ name + '.')\n",
    "else:\n",
    "    print(name + ' is one of my pets.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple Unpacking aka The Multiple Assignment Trick\n",
    "Shortcut that lets you assign multiple variables with values in one line of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The below is the long way of assigning variables to values in a list.\n",
    "cat = ['fat','gray','loud']\n",
    "size = cat[0]\n",
    "colour = cat[1]\n",
    "disposition = cat[2]\n",
    "\n",
    "print(size,colour,disposition)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code is a one line version of the above \n",
    "cat = ['fat','gray','loud']\n",
    "\n",
    "size,colour,disposition = cat\n",
    "\n",
    "print(size,colour,disposition)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note when assigning multiple variables we must only specify the number in the list<br><br>\n",
    "If there are 3 values in the list, we can't specify 4 variables as we will get an error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `enumerate()` Function with Lists\n",
    "\n",
    "Instead of `for range(len('list'))` we can use `enumerate()`<br>\n",
    "This, combined with index, can help clarify which position the items in the list are positioned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Below is an example of using the enumerate\n",
    "supplies = ['pen','staplers','flamethrowers','binders']\n",
    "for index, item in enumerate(supplies):\n",
    "    print('Index ' + str(index) + ' in the supplies list is: ' + item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `random.choice()` and `random.shuffle()`\n",
    "Found in the random module.<br>\n",
    "`random.choice()` chooses one item from the list <br>\n",
    "`random.shuffle()` shuffles the items within the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of random.choice\n",
    "import random\n",
    "pets = ['Dog', 'Cat', 'Moose']\n",
    "random.choice(pets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of random.shuffle\n",
    "import random\n",
    "people = ['Alice', 'Bob,','Carol','David']\n",
    "random.shuffle(people)\n",
    "people"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Augmented Assignment Operators: A Different ways to show operators\n",
    "This is a shortcut in using variables. It i\n",
    "`spam = spam + 1` is the same as `spam += 1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Examples of this below\n",
    "spam = 'Hello,'\n",
    "spam += ' world'\n",
    "spam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bacon = ['duplicate']\n",
    "bacon *= 3\n",
    "bacon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods\n",
    "Same thing as a function but it's 'Called on' a value and not variables. <br>\n",
    "Eg. A list value was stored in spam. You can call the index() list method. `spam.index('hello')`<br>\n",
    "The method part comes after the full stop.<br><br>\n",
    "Methods can only belong to a single data type.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `index()` method\n",
    "Think of this like doing the reverse of listing and finding out which position in the list a certain value is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of a method\n",
    "spam = ['hello','howdy','hi','hey']\n",
    "spam.index('hello')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If there are duplicates in the list, it only returns the earliest value\n",
    "spam = ['andy','bob','cara','cara','david']\n",
    "spam.index('cara')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `append()` and `insert()` method\n",
    "`append()` adds to the end. <br>\n",
    "For `insert()` we need to specify the index value between the parentheses.<br><br>\n",
    "\n",
    "Please note we do not store it in a variable.<br>\n",
    "Eg. We can't do `spam = spam.insert(1,'chicken')`<br>\n",
    "Instead we have to right `spam.insert(1,'chicken')`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of append()\n",
    "animals = ['aardvark','bilby','cat','dog']\n",
    "animals.append('emu')\n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of insert()\n",
    "animals = ['aardvark','bilby','cat','dog']\n",
    "animals.insert(1,'emu')\n",
    "animals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `remove()` method to Remove Values in Lists\n",
    "We can remove a specific value provided it exists.<br>\n",
    "If there is more than one value then it removes the earliest one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of a remove\n",
    "animals = ['aardvark','bilby','cat','dog']\n",
    "animals.remove('dog')\n",
    "animals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `sort()` method\n",
    "This sorts the values in the lists in ascending order by default.<br>\n",
    "Can be done for numbers or strings (Must be one or the other. Can't have both numbers and strings)<br>\n",
    "If we want to reverse it, we must pass the `reverse=True` in the argument (aka in the parentheses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of sort in ascending order\n",
    "spam = [2,5,3.14,1,-7]\n",
    "spam.sort()\n",
    "spam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of sort in descending order\n",
    "spam = [2,5,3.14,1,-7]\n",
    "spam.sort(reverse = True)\n",
    "spam "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of trying to sort Numbers and Strings (should error)\n",
    "spam = [1,2,3,4,'Alice', 'Bob']\n",
    "spam.sort()\n",
    "spam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uppercase is sorted before lowercase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Upper case gets sorted before lowercase\n",
    "spam = ['Alice', 'ants', 'Bob', 'badgers', 'Carol', 'cats']\n",
    "spam.sort()\n",
    "spam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To force lowercase to be sorted first, pass `key=str.lower` in the argument "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sorted by value. Lowercase then uppercase of the value.\n",
    "spam = ['a','z','A','Z']\n",
    "spam.sort(key=str.lower)\n",
    "spam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example program: Magic 8 ball with List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "messages = ['It is certain.',\n",
    "            'Maybe. Maybe not.',\n",
    "            'This is true.',\n",
    "            'Not happening.',\n",
    "            'Unclear. Try again.',\n",
    "            'Ask again later.',\n",
    "            'Perhaps.',\n",
    "            'Very doubtful.',\n",
    "            'It''s not looking good.']\n",
    "while True:\n",
    "    print('Ask a question or press Enter to quit: ')\n",
    "    ask = input()\n",
    "    if ask != '':\n",
    "        print(messages[random.randint(0,len(messages) - 1 )])\n",
    "        continue\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note* The `messages[random.randint(0,len(messages) - 1 )]` part of the program is an easy way to pick a value.<br>\n",
    "It allows you to add or remove strings without changing other lines of code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sequence Data Types  \n",
    "Lists are a data type, but not the only ones that represent ordered sequence of values.<br>\n",
    "Strings are also basically a List of text characters. <br>\n",
    "Range objects returned by the `range()` <br>\n",
    "Tuples are also that<br><br>\n",
    "The things we do to a list can be done to the other data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of indexing a String data type\n",
    "name = \"Zelda\"\n",
    "print(name[0])\n",
    "print(name[-2])\n",
    "print(name[0:4])\n",
    "print('Zel' in name)\n",
    "print('Link' in name)\n",
    "for n in name:\n",
    "    print('* * * ' + n + ' * * *')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Mutable* and *Ummutable* Data Types\n",
    "Mutable = Can be changed<br>\n",
    "Immutable = Cannot be changed<br><br>\n",
    "A list value is mutable. <br> \n",
    "A string is immutable -> we cannot reassign a character in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of a string being immutable\n",
    "name = 'Tux a cat'\n",
    "name[7] = 'the'\n",
    "print(name)\n",
    "\n",
    "# It should print an error "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to \"mutate\" a string\n",
    "We can't change the string, but we can use slicing and concatentation to build a new string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of how we can \"mutate\" a string\n",
    "name = 'Tux a cat'\n",
    "name = name[0:4] + 'the' + name[5:]\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple Data type\n",
    "Like a list but with two key differences:\n",
    "- use parentheses instead\n",
    "- immutable\n",
    "\n",
    "We also cannot modify, append or remove anything"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of a Tuple\n",
    "eggs = ('hello', 42, 0.5)\n",
    "eggs[1] = 99\n",
    "eggs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change to tuple for one value\n",
    "If we have one valuein our tuple, we can assign it to be a tuple by putting a comma after that value inside the parentheses.<br>\n",
    "Eg.<br>\n",
    "`type(('hello',))`<br>\n",
    "`<class 'tuple'>`<br>\n",
    "`type(('hello'))`<br>\n",
    "`<class 'str'>`<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting list to tuples and vice versa\n",
    "We can use the `list()` and `tuple()` functions to convert them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Below is an example of converting list to tuple and vice versa\n",
    "convertListToTuple = tuple(['cat','dog',5])\n",
    "print(convertListToTuple)\n",
    "\n",
    "convertTupleToList = list(('cat','dog',5))\n",
    "print(convertTupleToList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## It's all References!\n",
    "When we 'copy' a list we aren't actually copying it. We are referencing an original list. So when we make changes to one, the same changes can apply to another.<br>\n",
    "See below code for an example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spam = [0,1,2,3]\n",
    "cheese = spam\n",
    "cheese[1] = 'Hello' # Here we've assigned the second value in the cheese list as Hello\n",
    "print(spam)\n",
    "print(cheese)\n",
    "# Note how spam also has had its second value changed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### id function\n",
    "All values in Pyton have a unique id (even strings) and they are stored on your machine.<br>\n",
    "Anything immutable can't be changed, so when we \"change\" the string in a variable, we actually create a new string object in a different id."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bacon = 'Hello'     # first id\n",
    "print(id(bacon))\n",
    "\n",
    "bacon += ' world!'  # second new id\n",
    "print(id(bacon))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are mutable so anything we change/modify to the list via functions will have the same id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eggs = ['cat','dog']\n",
    "print(id(eggs))\n",
    "\n",
    "eggs.append('cow')  # add a cow\n",
    "print(id(eggs))\n",
    "\n",
    "# Note how the eggs variable has the same ID even though we added/changed it.\n",
    "\n",
    "# A new list using the same variable will have a different ID though.\n",
    "\n",
    "eggs = ['bat','rat','pat']\n",
    "print(id(eggs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Passing references in Functions\n",
    "Take note of the flow and how things are referenced. <br>\n",
    "In the example below, the spam list is referenced by both the eggs function and spam function.<br>\n",
    "Any changes we make to the spam parameter list is saved and we that with the print."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eggs(someParameter):\n",
    "    someParameter.append('Hello')\n",
    "\n",
    "spam = [1, 2, 3]\n",
    "eggs(spam)    # At this point, the function runs and the append happens to the spam list. \n",
    "print(spam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `copy.copy()` and `copy.deepcopy()` Functions\n",
    "What if we don't want the changes to a list when we run it through a function?<br>\n",
    "That is when we might want to make a copy, which we can use with `copy()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of copy function\n",
    "import copy\n",
    "spam = ['A','B','C']\n",
    "print(id(spam))\n",
    "\n",
    "cheese = copy.copy(spam)\n",
    "print(id(cheese))  # Notice how they are different IDs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`deepcopy()` copies the lists inside a list as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of deepcopy function. Check the id for the A variable\n",
    "import copy\n",
    "A = [1,2]\n",
    "B = [3,4]\n",
    "C = [5,6]\n",
    "print(id(A))\n",
    "\n",
    "spam = [A,B,C]\n",
    "print(id(spam[0]))\n",
    "\n",
    "cheese = copy.deepcopy(spam)\n",
    "print(id(cheese[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conway's game of life\n",
    "Conway’s Game of Life is an example of cellular automata: a set of rules governing the behavior of a field made up of discrete cells. <br>\n",
    "In practice, it creates a pretty animation to look at. You can draw out each step on graph paper, using the squares as cells.<br> \n",
    "A filled-in square will be “alive” and an empty square will be “dead.” <br>\n",
    "If a living square has two or three living neighbors, it continues to live on the next step.<br> \n",
    "If a dead square has exactly three living neighbors, it comes alive on the next step. <br>\n",
    "Every other square dies or remains dead on the next step.<br><br>\n",
    "<img src =\"https://automatetheboringstuff.com/2e/images/000117.jpg\" alt=\"\" title=\"Four steps in a Conway's Game of Life simulation\" /><br>\n",
    "*Four steps in a Conway's Game of Life simulation*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conway's Game of Life\n",
    "import random, time, copy\n",
    "WIDTH = 60\n",
    "HEIGHT = 20\n",
    "\n",
    "# Create a list of list for the cells:\n",
    "nextCells = []\n",
    "for x in range(WIDTH):\n",
    "    column = [] # Create a new column.\n",
    "    for y in range(HEIGHT):\n",
    "        if random.randint(0, 1) == 0:\n",
    "            column.append('#') # Add a living cell.\n",
    "        else:\n",
    "            column.append(' ') # Add a dead cell.\n",
    "    nextCells.append(column) # nextCells is a list of column lists.\n",
    "\n",
    "while True: # Main program loop.\n",
    "    print('\\n\\n\\n\\n\\n') # Separate each step with newlines.\n",
    "    currentCells = copy.deepcopy(nextCells)\n",
    "\n",
    "    # Print currentCells on the screen:\n",
    "    for y in range(HEIGHT):\n",
    "        for x in range(WIDTH):\n",
    "            print(currentCells[x][y], end='') # Print the # or space.\n",
    "        print() # Print a newline at the end of the row.\n",
    "\n",
    "    # Calculate the next step's cells based on current step's cells:\n",
    "    for x in range(WIDTH):\n",
    "        for y in range(HEIGHT):\n",
    "            # Get neighboring coordinates:\n",
    "            # `% WIDTH` ensures leftCoord is always between 0 and WIDTH - 1\n",
    "            leftCoord  = (x - 1) % WIDTH\n",
    "            rightCoord = (x + 1) % WIDTH\n",
    "            aboveCoord = (y - 1) % HEIGHT\n",
    "            belowCoord = (y + 1) % HEIGHT\n",
    "\n",
    "            # Count number of living neighbors:\n",
    "            numNeighbors = 0\n",
    "            if currentCells[leftCoord][aboveCoord] == '#':\n",
    "                numNeighbors += 1 # Top-left neighbor is alive.\n",
    "            if currentCells[x][aboveCoord] == '#':\n",
    "                numNeighbors += 1 # Top neighbor is alive.\n",
    "            if currentCells[rightCoord][aboveCoord] == '#':\n",
    "                numNeighbors += 1 # Top-right neighbor is alive.\n",
    "            if currentCells[leftCoord][y] == '#':\n",
    "                numNeighbors += 1 # Left neighbor is alive.\n",
    "            if currentCells[rightCoord][y] == '#':\n",
    "                numNeighbors += 1 # Right neighbor is alive.\n",
    "            if currentCells[leftCoord][belowCoord] == '#':\n",
    "                numNeighbors += 1 # Bottom-left neighbor is alive.\n",
    "            if currentCells[x][belowCoord] == '#':\n",
    "                numNeighbors += 1 # Bottom neighbor is alive.\n",
    "            if currentCells[rightCoord][belowCoord] == '#':\n",
    "                numNeighbors += 1 # Bottom-right neighbor is alive.\n",
    "\n",
    "            # Set cell based on Conway's Game of Life rules:\n",
    "            if currentCells[x][y] == '#' and (numNeighbors == 2 or\n",
    "numNeighbors == 3):\n",
    "                # Living cells with 2 or 3 neighbors stay alive:\n",
    "                nextCells[x][y] = '#'\n",
    "            elif currentCells[x][y] == ' ' and numNeighbors == 3:\n",
    "                # Dead cells with 3 neighbors become alive:\n",
    "                nextCells[x][y] = '#'\n",
    "            else:\n",
    "                # Everything else dies or stays dead:\n",
    "                nextCells[x][y] = ' '\n",
    "    time.sleep(1) # Add a 1-second pause to reduce flickering."
   ]
  }
 ],
 "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.11.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}