Introduction to Python - Data Types (part 2).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "54209634",
   "metadata": {},
   "source": [
    "# Learning the Basics with Python (part 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc2d80db",
   "metadata": {},
   "source": [
    "## Part 1: Data Types (cont'd)\n",
    "<span style=\"font-size:1.2em;\">In the last lesson, we were introduced to data types. Remember: data types tell the computer how to interpret a variable's value. Previously, we learned about numbers, booleans, strings, and lists. This week we will discuss tuples, dictionaries, sets, and classes.The first three are data types built into Python. Classes are user-defined data types, but we will discuss more later in the lesson.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e47882bb",
   "metadata": {},
   "source": [
    "## Part 2: Tuples\n",
    "<span style=\"font-size:1.2em;\"> In the last lesson, we introduced lists. As you may remember, lists are mutable arrays. Tuples are pretty much the exact same thing; HOWEVER, they are immutable, meaning that once you define a tuple, you cannot manipulate its size or contents.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7a4bb81",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize a tuple with two elements -> similar to how you would create a list\n",
    "x = (0 , 1)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ee7e4ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "# By running this code block, you will get a type error\n",
    "x[0] = 2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2fa6940",
   "metadata": {},
   "source": [
    "<span style=\"font-size:1.2em;\">Other than that, tuples are pretty much like lists. You can assign them in a similar way (we use parentheses **()** or **tuple()** to create a tuple) and access elements by indexing into the tuple or slicing. You can also concatenate tuples with the **+** operator and use the **len()** function to get the number of elements.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a5c9d6e",
   "metadata": {},
   "source": [
    "### Creating tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e15f16b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The following two lines of code create empty tuples\n",
    "empty_tuple = ()\n",
    "empty_tuple_2 = tuple()\n",
    "print(empty_tuple)\n",
    "print(empty_tuple_2)\n",
    "\n",
    "# This line creates a populated tuple of various objects\n",
    "regular_tuple = ('x', 1, 'hello world', [0, 1], (2, 3))\n",
    "print(regular_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ae009ce",
   "metadata": {},
   "source": [
    "### Indexing, Slicing, and Concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "042e59b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(regular_tuple[0])  # Get element at index 0\n",
    "print(regular_tuple[2])  # Get element at index 2\n",
    "print(\"- - - - - - - - - -\")\n",
    "print(regular_tuple[3:])  # Get elements starting at index 3 until the end\n",
    "print(\"- - - - - - - - - -\")\n",
    "print(\"There are %d elements in the regular_tuple\" % (len(regular_tuple)))\n",
    "print(\"- - - - - - - - - -\")\n",
    "regular_tuple_2 = (3, 'world!')\n",
    "regular_tuple_3 = regular_tuple + regular_tuple_2\n",
    "print(regular_tuple_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fb5ad6e",
   "metadata": {},
   "source": [
    "<span style=\"font-size:1.2em;\">You have the option in Python to turn tuples into lists and vice versa. To do that, we simply call **list()** and pass in the tuple we want to convert. Same goes for converting a list to a tuple. We can call **tuple()** and pass in the list we want to convert.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63343a4b",
   "metadata": {},
   "source": [
    "### Converting tuples to lists using list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f78c0fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "example_tuple = (1, 2, 3)\n",
    "print(example_tuple)\n",
    "print(type(example_tuple))\n",
    "\n",
    "example_list = list(example_tuple)\n",
    "print(example_list)\n",
    "print(type(example_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "925b3ea6",
   "metadata": {},
   "source": [
    "### Converting lists to tuples using tuple()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5925a765",
   "metadata": {},
   "outputs": [],
   "source": [
    "example_list_2 = [4, 5, 6]\n",
    "print(example_list_2)\n",
    "print(type(example_list_2))\n",
    "\n",
    "example_tuple_2 = tuple(example_list_2)\n",
    "print(example_tuple_2)\n",
    "print(type(example_tuple_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb57195c",
   "metadata": {},
   "source": [
    "<span style=\"font-size:1.2em;\">While tuples are similar to lists, tuples are still immutable and cannot use the same built-in functions as a list (e.g., **.append()**, **.pop()**, etc.). However, there are two useful, built-in functions that we can use: **.count()** and **.index()**.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2a59693",
   "metadata": {},
   "source": [
    "### .count()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74c4dffe",
   "metadata": {},
   "source": [
    "<span style=\"font-size:1.2em;\">You can pass an object into the **.count()** function and it returns the number of times that object appears in a tuple.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fee6268f",
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple_count = (1, 3, 'a', 1, 'a', 2, 2, 'b', 1, 6, 1, 'c')\n",
    "print(tuple_count.count(1))\n",
    "print(tuple_count.count('a'))\n",
    "print(tuple_count.count('z'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e65a5ad",
   "metadata": {},
   "source": [
    "### .index()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecb7fb7a",
   "metadata": {},
   "source": [
    "<span style=\"font-size:1.2em;\">You can pass an object into the **.index()** function and it returns the index of the first instance of the object in the tuple. If there are no instances of the object in the tuple, the function throws a value error.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8240c421",
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple_count = (1, 3, 'a', 1, 'a', 2, 2, 'b', 1, 6, 1, 'c')\n",
    "print(tuple_count.index(2))\n",
    "print(tuple_count.index('b'))\n",
    "print(tuple_count.index('z'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e43ee7aa",
   "metadata": {},
   "source": [
    "<span style=\"font-size:1.2em;\">Tuples are very useful to use. They're memory efficient and immutable, so they help in situations where your data shouldn't be modified by the user. If you're ever wondering if you ever need to use a tuple or list, just consider the data you are handling and whether or not users should be able to manipulate it. </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05bbe520",
   "metadata": {},
   "source": [
    "## Part 3: Dictionaries\n",
    "<span style=\"font-size:1.2em;\">Dictionaries are a special and power data type to use. They are associative arrays that are a collection of key-value pairs and each key is a hashable object that maps to an object in the dictionary. Essentially, think of a regular dictionary of words. Each word in the dictionary (**key**) is always associated to the word's etomology, definition, and examples on how to use it (**value**). </span>\n",
    "    \n",
    "<span style=\"font-size:1.2em;\">Each key within a dictionary in Python is unique, but the values associated with each key don't have to be. So while you can have multiple values of the same thing for different keys, you cannot have multiple keys with the same name. The key has to be an immutable data type, such as a number, a string, or a tuple. </span>\n",
    "\n",
    "<span style=\"font-size:1.2em;\">   Dictionaries can be created using curly braces ( **{}** ) or **dict()**. We use colons ( **:** ) to associate a unique key with a value and we use commas to separate different entries.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2335b0c",
   "metadata": {},
   "source": [
    "### Creating dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbb5ca55",
   "metadata": {},
   "outputs": [],
   "source": [
    "ex_dict = {}\n",
    "print(ex_dict, type(ex_dict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c0961c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "ex_dict = dict()\n",
    "print(ex_dict, type(ex_dict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c77d4e1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "ex_dict = {\"hello\": \"world\", 1: 2, (2,1): (1,2), \"Emily\": 26, 2:4}\n",
    "print(ex_dict, type(ex_dict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57c26ad7",
   "metadata": {},
   "outputs": [],
   "source": [
    "ex_dict = {\"hello\": \"world\", \"hello\": \"hey\"}\n",
    "print(ex_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "313b347d",
   "metadata": {},
   "source": [
    "<span style=\"font-size:1.2em;\"> Notice how even though I specified two keys with the same name, but only one key showed up. Because every key has to be unique, Python will take the most recent assignment of a key (i.e., **\"hello\":\"hey\"**).</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb19d922",
   "metadata": {},
   "source": [
    "### Indexing\n",
    "<span style=\"font-size:1.2em;\"> Similar to lists and tuples, you can use indexing to retrieve entries in a dictionary; however, we use the keys as the index.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "484effe9",
   "metadata": {},
   "outputs": [],
   "source": [
    "ex_dict = {\"hello\": \"world\", 1: 2, (2,1): (1,2), \"Emily\": 26, 2:4}\n",
    "print(ex_dict[\"hello\"])\n",
    "print(ex_dict[1])\n",
    "print(ex_dict[(2,1)])\n",
    "print(ex_dict[\"emily\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "400aa38b",
   "metadata": {},
   "source": [
    "<span style=\"font-size:1.2em;\"> Notice how we get an error. That's because the key **\"emily\"** doesn't exist. Keys are case-sensitive, so **\"Emily\"** is not the same as **\"emily\"**.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f81cdfc",
   "metadata": {},
   "source": [
    "### Built-in functions\n",
    "<span style=\"font-size:1.2em;\"> Just like lists and tuples, dictionaries have their own built-in functions. They are **.keys()**, **.values()**, and **.items()**.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1341c27b",
   "metadata": {},
   "source": [
    "#### .keys()\n",
    "The **.keys()** functions returns a list of all the keys within a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94fa9907",
   "metadata": {},
   "outputs": [],
   "source": [
    "ex_dict = {\"hello\": \"world\", 1: 2, (2,1): (1,2), \"Emily\": 26, 2:4}\n",
    "dict_keys = ex_dict.keys()\n",
    "print(dict_keys)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccd9bb0b",
   "metadata": {},
   "source": [
    "#### .values()\n",
    "The function **.values()** returns a list of all the values within a dictionary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf600ebf",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_values = ex_dict.values()\n",
    "print(dict_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "977d9ca9",
   "metadata": {},
   "source": [
    "#### .items()\n",
    "The function **.items()** returns all the key-value pairs within a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8d08d6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_items = ex_dict.items()\n",
    "print(dict_items)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c8088e4",
   "metadata": {},
   "source": [
    "## Part 4: Sets\n",
    "<span style=\"font-size:1.2em;\">Sets are unordered collections of hashable Python objects. This means that since we don't care about the order in which objects are stored, we don't need indexing to retrieve an object in a set. In fact, we can't retrieve items in a set at all. All we can do is check to see if an object exists in a set or not. Additionally, sets are mutable, so we can add and remove objects from a set, if needed. </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f32fd510",
   "metadata": {},
   "source": [
    "### Set Creation\n",
    "<span style=\"font-size:1.2em;\"> There are three ways to create sets in Python. You can use curly braces (similar to creating a dictionary), but we don't use key-pairs here, so you can just list your objects as normal. You can also convert lists and tuples into sets using the **set()** function. Lastly, you can create an empty set by just calling **set()** by itself.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59b86473",
   "metadata": {},
   "outputs": [],
   "source": [
    "set_example = {\"Emily\", \"Josh\", \"Jamie\"}\n",
    "print(set_example, type(set_example))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90c17ea2",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_example = [\"hello\", \"world\"]\n",
    "set_example = set(list_example)\n",
    "print(set_example, type(set_example))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2f97899",
   "metadata": {},
   "outputs": [],
   "source": [
    "set_example = set()\n",
    "print(set_example, type(set_example))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1acc987",
   "metadata": {},
   "source": [
    "### Set Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "479b7e27",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = set([1, 2, 3, 4, 5, 6])\n",
    "B = set([5, 6, 7, 8, 9, 10])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e79f687b",
   "metadata": {},
   "source": [
    "#### Union ( **|** )\n",
    "<span style=\"font-size:1.2em;\">Finding the union between two sets means to find all unique objects that exist in set **A** OR set **B**. To find the union between set A and set B, we simply do **A | B**.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8381ed29",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A | B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fda89e94",
   "metadata": {},
   "source": [
    "#### Intersection ( **&** )\n",
    "<span style=\"font-size:1.2em;\">Finding the intersection between two sets means to find all unique objects that exist in set **A** AND set **B**. To find the intersection between set A and set B, we simply do **A & B**.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a0c2ae6",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A & B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da1cf34c",
   "metadata": {},
   "source": [
    "#### Difference ( **-** )\n",
    "<span style=\"font-size:1.2em;\">Finding the difference between two sets means to find all unique objects that exist in set **A** but not set **B**. To find the difference between set A and set B, we simply do **A - B**.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42a70838",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A - B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc38bf1b",
   "metadata": {},
   "source": [
    "#### .add() & .remove()\n",
    "<span style=\"font-size:1.2em;\">If we want to add or remove elements to sets, we simply call the built-in functions **.add()** or **.remove()**.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e90c31d",
   "metadata": {},
   "outputs": [],
   "source": [
    "A.add(11)\n",
    "print(A)\n",
    "B.remove(6)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fb3b522",
   "metadata": {},
   "source": [
    "### Uniqueness\n",
    "<span style=\"font-size:1.2em;\">One final note about sets is that they are most useful for removing duplicate values in iterable objects, such as a list. Therefore, sets are a collection of **unique** objects as well. When lists or tuples are converted to sets, duplicate items are removed and only one instance of each object appears in the new set.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c990b7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "set_example = set([1,1,1,2,2,3,4,5,5,6,7,7,7,8])\n",
    "print(set_example)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7748cd84",
   "metadata": {},
   "source": [
    "## Part 5: Classes\n",
    "<span style=\"font-size:1.2em;\">Unlike the other built-in data types we have talked about so far, classes are user-defined. This means that we have to manually create them using the **class** keyword. For the purposes of basic Python, they are not super important to learn: they are more useful when discussing object-oriented topics. However, I will give a brief introduction to the amount of power a class can hold in your program.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e9477df",
   "metadata": {},
   "source": [
    "### Defining a Class\n",
    "<span style=\"font-size:1.2em;\">When we define a class, we have to use the **class** keyword along with a custom name for the class. The function **__init__** is known as the class constructor. This function is called automatically whenever we instantiate a class object(i.e., we create an object of that class type). The **self** keyword is similar to the **this** parameter in other programming languages. All this means is that it refers to the current class object(i.e., itself) if there were multiple objects of the same class type. Other functions defined in the class are known as member functions (i.e., it's a member of the class) and they must always have **self** in the parenthesis.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3d86497",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    # Class construtor\n",
    "    # Whenever a class is instantiated, the constructor is automatically called\n",
    "    # The constructor creates the necessary class variables and runs whatever\n",
    "    # other code is inside\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        print(\"Hello World\")\n",
    "        \n",
    "    # Member functions must always have self as the first parameter in parenthesis\n",
    "    def greeting(self):\n",
    "        print(\"Hello! My name is %s\\n\" % self.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc0555ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "myObj1 = MyClass(\"Emily\", 26)  # Instantiates class object with name \"Emily\" and age 26\n",
    "myObj2 = MyClass(\"Josh\", 23)  # Instantiates class object with name \"Josh\" and age 23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6160288",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The name for this object should be Emily and the age should be 26\n",
    "print(myObj1.name, myObj1.age)\n",
    "myObj1.greeting()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b201043a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The name for this object should be Josh and the age should be 23\n",
    "print(myObj2.name, myObj2.age)\n",
    "myObj2.greeting()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71768830",
   "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}