basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6955d5fc",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d9498e23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['to wong foo', [3, 5, 7]]\n"
     ]
    }
   ],
   "source": [
    "mylist = [] # This is an empty list. Lists are the most basic mutable type, and \n",
    "            #   are what you should use anytime you will need to add or remove things.\n",
    "            #   They can hold any combination of any type of object, including\n",
    "            #   other lists.\n",
    "mylist.append('to wong foo') # this appends a string\n",
    "mylist.append([3,5,7]) # this appends a list of numbers\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f130fbff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is a great movie', 'to wong foo', 0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "# Because lists are mutable, you can assign to them and there are methods which \n",
    "#   alter them in-place.\n",
    "mylist[1] = 'is a great movie'\n",
    "mylist.reverse()\n",
    "# Addition concatenates lists\n",
    "print(mylist+[0,0,0,0,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08b5dc09",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7b0a5392",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, (2, 3), 'wow')\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "mytup = (1,(2,3),'wow') # Tuples are immutable container types. They are just\n",
    "                        #   like lists, but they can't be changed once created.\n",
    "                        #   So: no appending or assignment!\n",
    "\n",
    "print(mytup)\n",
    "print(mytup[2][1])\n",
    "# These are useful if you want to be sure the contents don't change."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cccf613f",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a2da433a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Have some spam.\n"
     ]
    }
   ],
   "source": [
    "spam = 'Have some spam.' # This is a string. It's an immutable type.\n",
    "eggs = \"Have some eggs.\" # You can use double or single quotes for strings\n",
    "                         \n",
    "print(spam) # Prints the string to the terminal and starts a new line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "17d7dc8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Have Have some \n"
     ]
    }
   ],
   "source": [
    "# Remember that Python is base 0.\n",
    "# Like lists and tuples, strings are \"iterables\". You can index into them.\n",
    "# All intervals in Python include the left endpoint and exclude the right one.\n",
    "# Also: addition concatenates strings\n",
    "print(spam[0:5] + spam[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "841d4e0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aesm \n",
      ".sgge emos evaH\n"
     ]
    }
   ],
   "source": [
    "# You can use indexing to go through iterables in different ways\n",
    "print(eggs[1:10:2])\n",
    "print(eggs[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3fdce27c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The pirate says 7, win!!!\n"
     ]
    }
   ],
   "source": [
    "# You can use the format property of a string to replace {} with text, etc.\n",
    "pirate_call = 'The pirate says {}, {}!!!'.format(2+5,'win')\n",
    "print(pirate_call)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "745ae98f",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "94001215",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'blue', 'number': 3}\n",
      "blue\n"
     ]
    }
   ],
   "source": [
    "mydict = {} # This is an empty dict. It's mutable.\n",
    "            #   Dicts are made up of key-value pairs. Keys can be any immutable,\n",
    "            #   and they point to a value which can be any object.\n",
    "            #   While they are iterable (you can iterate through them using \n",
    "            #   techniques TBD later), they are NOT ordered in any way.\n",
    "mydict['color'] = 'blue' # color points to 'blue'\n",
    "mydict['number'] = 3 # 'number' points to 3\n",
    "print(mydict)\n",
    "print(mydict['color'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0b239c1",
   "metadata": {},
   "source": [
    "## Numpy Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8cab97c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A = [[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "4\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# (Nearly) everything in NumPy uses the array datatype.\n",
    "# It is mutable, but has a fixed shape and should only contain a single datatype\n",
    "#   (usually numbers, and most usually floating point numbers)\n",
    "# You can create an array out of a list, or a list of lists.\n",
    "A = np.array([[1,2,3],[4,5,6],[7,8,9]]) # 3x3 array of integers\n",
    "print(f'A = {A}')\n",
    "print(A[1,0])\n",
    "print(A[0,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b3dba06e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3)\n",
      "The shape of A is 3 by 3.\n"
     ]
    }
   ],
   "source": [
    "# Arrays have a number of attributes\n",
    "print(A.shape)\n",
    "x,y = A.shape\n",
    "print(f'The shape of A is {x} by {y}.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4ac114f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are a number of routines to create arrays.\n",
    "#  NOTE: Arrays must be created with a certain shape and maintain that shape.\n",
    "#  Any change to the shape is essentially destroying the array and recreating it from scratch.\n",
    "#  Often, an array of zeros is created and then filled in later.\n",
    "myarray = np.zeros((4,5))\n",
    "print(myarray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2438590",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arrays can be of any dimension\n",
    "array3 = np.ones((4,3,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f3bd1c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.random.rand(3,3) # 3x3 array of floating point numbers between 0 and 1\n",
    "print(f'B = {B}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7378c11e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# All operations are elementwise.\n",
    "print('Element-wise multiplication:')\n",
    "print(A*B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01a1e084",
   "metadata": {},
   "outputs": [],
   "source": [
    "# In Python 3.5+, we also have @ which is matrix multiplication\n",
    "print('Matrix multiplicaton:')\n",
    "print(A@B)\n",
    "# That doesn't always work well for matrix-vector multiplication, \n",
    "#   because vectors are typically rows (Python is a row-major language).\n",
    "#   Instead, use np.dot\n",
    "v = np.array([2,1,2])\n",
    "print(np.dot(A,v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5be4a02",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tons of other routines can be found in the numpy library. The docs are fantastic!!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed7f60c3-70eb-43d9-8c37-ee762d02f494",
   "metadata": {},
   "source": [
    "# Key facts about mutable/immutable objects (assignment)\n",
    "\n",
    "- If you use assignment (=) to make a copy of an *immutable* object, the assignment will do what you expect because the underlying data cannot be changed.\n",
    "- If you use assignment to make a copy of a *mutable* object, **only a shallow copy is made**. That means the copy is merely a reference to the same data as contained in the original (it is essentially just a link to that data). This is much faster and uses less memory than a \"deep copy\", where all the data is duplicated into a new area of memory, but it means that if you change the data with one of the variables, you have also changed it for the other one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c28e208a-83c4-4664-8828-c51b5761576a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_tuple = (4, 5, 6)\n",
      "my_tuple_cpy = (1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1,2,3) # tuples are immutable collection of objects\n",
    "my_tuple_cpy = my_tuple \n",
    "# you cannot alter immutable data without erasing it and replacing with completely new data\n",
    "my_tuple = (4,5,6) # this overwrites my_tuple, but not my_tuple_cpy\n",
    "print('my_tuple = {}'.format(my_tuple))\n",
    "print('my_tuple_cpy = {}'.format(my_tuple_cpy))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c836445-43ff-4bd5-b3ac-636e3eb12943",
   "metadata": {},
   "source": [
    "Re-assigning the original variable will also work the same way with mutable objects \n",
    "because you are essentially just re-assigning/re-using one of the labels for the original data. \n",
    "Another label (variable) still points to the data, so it isn't erased from memory.\n",
    "\n",
    "As a side note, this is how automatic *garbage collection* works in Python. Any data that becomes orphened/unreachable because \n",
    "the last variable pointing was removed or reassigned is marked for deletion. Then, at some unannounced point when the program isn't \n",
    "otherwise too busy, the garbage collector will act and free up the memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6974cd86-a590-4f7c-a467-8523b62d94ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_list = [4, 5, 6]\n",
      "my_list_ref = [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3] # mutable\n",
    "my_list_ref = my_list # this now refers to the same object in memory as my_list\n",
    "my_list = [4,5,6] # a new object is created, and my_list refers to it.\n",
    "                  #   but my_list_ref still refers to [1,2,3]\n",
    "print('my_list = {}'.format(my_list))\n",
    "print('my_list_ref = {}'.format(my_list_ref))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08c39cee-a162-48cb-8c2f-e6663147e1cd",
   "metadata": {},
   "source": [
    "**But here is the key point:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2acf242e-2a3e-499a-8b71-75eaa0b45e4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_list = [0, 2, 3]\n",
      "my_list_ref = [0, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "my_list_ref = my_list # both my_list and my_list_ref point to the same object in memory\n",
    "my_list[0] = 0 # so when I alter my_list, my_list_ref is altered too!\n",
    "print('my_list = {}'.format(my_list))\n",
    "print('my_list_ref = {}'.format(my_list_ref))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01d33f9e-77d5-4574-9cfb-405b107c104f",
   "metadata": {},
   "source": [
    "If you don't want this behavior, you can force a deep copy as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "04773af5-e2e9-499c-b4e7-658b4da176c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_list = [0, 2, 3]\n",
      "my_list_cpy = [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "my_list_cpy = list(my_list) # the list function makes a true copy\n",
    "my_list[0] = 0 # so when I alter my_list, my_list_cpy remains the same\n",
    "print('my_list = {}'.format(my_list))\n",
    "print('my_list_cpy = {}'.format(my_list_cpy))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1ea734d-e2d7-4366-af7b-dccadbea9885",
   "metadata": {},
   "source": [
    "This works in general: just call the corresponding type function on the data you want to copy. \n",
    "E.g., to create a deep copy of a numpy array, use np.array(). For numpy arrays, you can also use \n",
    "the array method .copy().\n",
    "\n",
    "Not sure if you have a shallow copy or a deep copy? You can test for this using the keyword \"is\". \n",
    "In Python, there are two different types of equivalency tests. \"==\" tests for elementwise data equivalency. \n",
    "\"is\" tests to see if they are actually the same object in memory. \n",
    "\n",
    "**Note** that with immutable objects, these two comparisons will always correspond because an immutable type is considered fundamentally itself. That is, the number 2 is the number 2 everywhere. There aren't copies of the number 2, there exists only one immutable one and \n",
    "many variables can utilize it. This remains true with more complicated immutable types, like tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "aa463ad9-eea0-4461-b9cb-9f21c5609547",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "my_list_cpy = my_list\n",
    "print(my_list == my_list_cpy)\n",
    "print(my_list is my_list_cpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f3a99073-1d7f-42cd-895c-6e3a98baff85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "my_list_cpy = list(my_list)\n",
    "print(my_list == my_list_cpy)\n",
    "print(my_list is my_list_cpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "da7d54c2-1771-4397-bc02-cee8e44f2367",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1,2,3) # tuples are immutable collection of objects\n",
    "my_tuple_cpy = my_tuple # they point to the same unchangable object that is (1,2,3). This poses no issue, \n",
    "                        #    just as if you had made two variables equal to the number 2.\n",
    "print(my_tuple == my_tuple_cpy)\n",
    "print(my_tuple is my_tuple_cpy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cdba945-8ec2-410a-aa51-e68500c2b7d4",
   "metadata": {},
   "source": [
    "For built-in Python types, == returns True if they are all the same and False otherwise. \n",
    "In numpy, you instead get a boolean array with the elementwise results. So, if you want to \n",
    "see if they are all equivalent, you have to call the .all() method on the resulting array. \n",
    "There is also a .any() method that will check to see if *any* of the data is elementwise the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8919a2bc-2138-46bb-8caf-0a5cfc01860c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True  True]\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "A = np.array([1,2,3])\n",
    "B = A\n",
    "print(A == B)\n",
    "print((A==B).all())\n",
    "print(A is B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5ef228dd-96f1-478c-9a5a-e28c5408b8b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "B = A.copy()\n",
    "print((A==B).all())\n",
    "print(A is B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61fb4ac6-d5a6-4b62-9ff7-44ae6ff5d9d9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}