Fluent Essays

8 Exercises Create a list of your favourite superheros and another list of their secret identities. Convert your two lists into a dictionary. (Can you do it in one line?) Remove one of your heroes and add a villain to your dictionary. Add a character that has multiple identities to your dictionary. (What kind of object should this be?) Demonstrate that you can look up one of your character's identities. SuperheroIdentityIron ManTony StarkThe ThingBen GrimmStormOroro MunroeSpider-ManPeter Parker, Miles MoralesIn [61]: # Add your solution here Use Hubble's law (????=????0????v=H0D) to calculate the distance (in Mpc) of the galaxies in the following table. GalaxyVelocity (km/s)NGC 1231320NGC 23425690NGC 44428200 Remember that ????0≈70H0≈70 km/s/Mpc. In [ ]: # Add your solution here Flatten the following list using list comprehension. mylist = [[[1, 2], [3, 4, 5]], [[6], [7, 8]]] In [ ]: # Add your solution here Write a generator function that can be used to calculate the Fibonacci sequence. In [ ]: # Add your solution here LAST 4 QUESTIONS ON THE ATTACHED FILE! { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "# Week 01 \n", "---\n", "\n", "\n", "\n", "---\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Contents\n", "---\n", "\n", "In this section, we will review the programming language Python and also provide some more detailed examples of the ideas from the previous section. If you are new to Python or find that you need more information about any of the topics presented, we recommend that you consult a resource such as the Python Language Reference or a Python Tutorial. Our goal here is to reacquaint you with the language and also reinforce some of the concepts that will be central to later chapters." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1 Set-Up\n", "---\n", "\n", "The following cell contains some set-up commands. Be sure to execute this cell before continuing." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Notebook Set-Up Commands\n", "\n", "import math\n", "\n", "def print_error(error):\n", " \"\"\" Print Error\n", " \n", " Function to print exceptions in red.\n", " \n", " Parameters\n", " ----------\n", " error : string\n", " Error message\n", " \n", " \"\"\"\n", " print('\\033[1;31m{}\\033[1;m'.format(error))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2 A Quick Recap\n", "---\n", "\n", "Before getting into the specifics of Pythonic coding, let's take a second to refresh the basics. In order to understand the topics covered in this notebook you will need to know the following:\n", "\n", "### Basic Python object types " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Object is of type: <class 'int'>\n", "Object is of type: <class 'float'>\n", "Object is of type: <class 'bool'>\n", "Object is of type: <class 'str'>\n", "Object is of type: <class 'list'>\n", "Object is of type: <class 'tuple'>\n", "Object is of type: <class 'set'>\n" ] } ], "source": [ "# Basic Python objects\n", "\n", "myint = 1\n", "print('Object is of type:', type(myint))\n", "\n", "myfloat = 1.0\n", "print('Object is of type:', type(myfloat))\n", "\n", "mybool = True\n", "print('Object is of type:', type(mybool))\n", "\n", "mystring = 'hello'\n", "print('Object is of type:', type(mystring))\n", "\n", "mylist = [1, 2, 3]\n", "print('Object is of type:', type(mylist))\n", "\n", "mytuple = (1, 2, 3)\n", "print('Object is of type:', type(mytuple))\n", "\n", "myset = set([1, 1, 2])\n", "print('Object is of type:', type(myset))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Standard operators" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Addition: 1 + 2 = 3\n", "Subtraction: 1 - 2 = -1\n", "Multiplication: 4 * 2 = 8\n", "Division: 4 / 2 = 2.0\n", "Floor Division: 4 // 2 = 2\n", "Exponentiation: 4 ** 2 = 16\n" ] } ], "source": [ "# Standard operators\n", "\n", "print('Addition: 1 + 2 = ', 1 + 2)\n", "print('Subtraction: 1 - 2 = ', 1 - 2)\n", "print('Multiplication: 4 * 2 = ', 4 * 2)\n", "print('Division: 4 / 2 = ', 4 / 2)\n", "print('Floor Division: 4 // 2 = ', 4 // 2)\n", "print('Exponentiation: 4 ** 2 = ', 4 ** 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Simple logic operations" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True and True = True\n", "True and False = False\n", "True or True = True\n", "True or False = True\n" ] } ], "source": [ "# Simple logic operations\n", "\n", "print('True and True = ', True and True)\n", "print('True and False = ', True and False)\n", "print('True or True = ', True or True)\n", "print('True or False = ', True or False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Functions" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello world!\n", "My value is 5.\n" ] } ], "source": [ "# Functions\n", "\n", "def say_hello():\n", " print('Hello world!')\n", " \n", "def show_value(value):\n", " print('My value is {}.'.format(value))\n", " \n", "say_hello()\n", "show_value(5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3 Lambda Functions\n", "---\n", "\n", "To get started, let's take second to remember how functions work in Python. Functions are defined with the keyword `def` followed by the function name, the function arguments in `()` and a colon `:` to end the definition. On the following lines the function behaviour is coded and if the function returns an object this is provided to the keyword `return`.\n", "\n", "Let's look at an example of a function that calculates the square of an input value." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Function to calculate the square of the input value\n", "def square_func(x):\n", " \n", " return x ** 2\n", "\n", "square_func(3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python provides a useful shorthand for writing simple functions of this type using the keyword `lambda`.\n", "\n", "Let's look at an example to perform the same squaring function." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Lambda function to calculate the square of the input value\n", "square_lambda = lambda x: x ** 2\n", "\n", "square_lambda(3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The syntax is `lambda` followed by the function arguments, a colon to end the definition, and finally the function behaviour is automatically returned. Like all Python functions, lambda functions are objects (we will come back to this idea) and since they are not named, they need to be assigned to an object in order to be used.\n", "\n", "Here is another example using multiple arguments." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Lambda function to calculate the sum of two input values\n", "add = lambda x, y: x + y\n", "\n", "add(1, 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While lambda functions are extremely useful, best practices dictate that they should be used sparingly. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4 Unpacking\n", "---\n", "\n", "A fundamental first step on your journey of Pythonic coding is understanding how handle array-like objects (*i.e.* lists and tuples).\n", "\n", "### Basic Unpacking\n", "\n", "As you are no doubt aware lists and tuples can be indexed by passing an element number inside `[]`..." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mytuple[1] = 2\n" ] } ], "source": [ "# Create a tuple\n", "mytuple = (1, 2, 3)\n", "\n", "# Get index 1 from the tuple\n", "print('mytuple[1] =', mytuple[1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "... however, it is also possible to *unpack* these objects." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "val1 = 1 ; val2 = 2 ; val3 = 3\n" ] } ], "source": [ "# Unpack a tuple\n", "val1, val2, val3 = (1, 2, 3)\n", "\n", "print('val1 = {} ; val2 = {} ; val3 = {}'.format(val1, val2, val3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice that when three objects are assigned to the tuple each value is unpacked automatically, but if we attempt to unpack three values into two objects we raise an exception." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1;31mtoo many values to unpack (expected 2)\u001b[1;m\n" ] } ], "source": [ "# Try to unpack values into two objects\n", "try:\n", " val1, val2 = (1, 2, 3)\n", "except Exception as error:\n", " print_error(error)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Positional Expansion\n", "\n", "We can bypass the problem using the *splat* (`*`) operator. In addition to be used as the standard operator for multiplication, `*` also has special unpacking features." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mytuple = (1, 2, 3)\n", "unpacked mytuple = 1 2 3\n" ] } ], "source": [ "# Print mytuple\n", "print('mytuple =', mytuple)\n", "\n", "# Print mytuple after unpacking\n", "print('unpacked mytuple =', *mytuple)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using this operator we can now unpack our three-element tuple into just two objects." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "val1 = 1 ; val2 = [2, 3]\n" ] } ], "source": [ "# Unpack a tuple\n", "val1, *val2 = mytuple\n", "\n", "print('val1 = {} ; val2 = {}'.format(val1, val2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see that the first value was unpacked and the remaining values were packed into a list.\n", "\n", "> **Puzzle 1:** Guess the value of `val2` in the following example." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# Create a list\n", "mylist = [7, 2, 8, 2, 6]\n", "\n", "# Unpack the list\n", "val1, *val2, val3 = mylist\n", "\n", "# Uncomment to see the answer\n", "# print(val2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also recursively unpack array-like objects.\n", "\n", "> **Puzzle 2:** Guess the value of `b` in the following cell." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# Create a list of tuples\n", "list_of_tuples = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]\n", "\n", "# Unpack the list\n", "*A, B = list_of_tuples\n", "\n", "# Unpack one of the tuples\n", "*a, b = A[1]\n", "\n", "# Uncomment to see the answer\n", "# print('b =', b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> Further Reading\n", "> - <a href=\"https://medium.com/understand-the-python/understanding-the-asterisk-of-python-8b9daaa4a558\" target=\"_blank\">Understanding the Asterisk of Python</a>" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Unpacking with Functions\n", "\n", "Unpacking can be particularly useful for passing arguments to functions. *e.g.* if you want to pass a single object to a function that expects multiple arguments." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The result of myfunc is 6.\n" ] } ], "source": [ "# Define a function that takes multiple arguments\n", "def myfunc(a, b, c):\n", " \n", " return a + b - c\n", "\n", "# Set a tuple of values\n", "myvalues = (4, 5, 3)\n", "\n", "# Unpack the values into the function\n", "print('The result of myfunc is {}.'.format(myfunc(*myvalues)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Alternatively, you could pass multiple values to a function that does not know how many arguments to expect." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "count_agrs received 3 arguments.\n" ] } ], "source": [ "# Define a function that has an unknown number of arguments\n", "def count_agrs(*args):\n", " \n", " return len(args)\n", "\n", "# Pass multiple values to the function\n", "print('count_agrs received {} arguments.'.format(count_agrs(1, 2, 3)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5 Dictionaries\n", "---\n", "\n", "Python provides many different ways of storing multiple values in a single object (*e.g.* lists, tuples, sets, *etc*). One of the most useful, and certainly one of the most important, are *<a href=\"https://docs.python.org/2/tutorial/datastructures.html#dictionaries\" target=\"_blank\">dictionaries</a>*. \n", "\n", "Dictionaries are designated with `{}` and are comprised of two main components: *keys* and *values*. The benefit that dictionaries provide with respect to simpler objects like lists is the ability to label values. This makes it a lot easier to store a large number of values in a single object without losing track of what they are.\n", "\n", "### First Example\n", "\n", "Let's look at a concrete example. Imagine we want to keep track of the colours associated to the Teenage Mutant Ninja Turtles.\n", "\n", "<img src=\"http://cdn.shopify.com/s/files/1/0342/0081/products/tmnt_1987_grande.jpg?v=1416367192\" width=\"800\">\n", "\n", "We could start by defining a unique object for each turtle." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Leonardo wears blue.\n" ] } ], "source": [ "# Unique objects for turtle colours\n", "Leonardo = 'blue'\n", "Raphael = 'red'\n", "Donatello = 'purple'\n", "Michelangelo = 'orange'\n", "\n", "print('Leonardo wears {}.'.format(Leonardo))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It might be nicer instead to define a single object." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Raphael wears red.\n" ] } ], "source": [ "# List of turtle colours\n", "turtles = ['blue', 'red', 'purple', 'orange']\n", "\n", "print('Raphael wears {}.'.format(turtles[1]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This, however, assume you will remember the order and names of the turtles. A dictionary makes it possible to retain both the simplicty of a list, but the details of the single objects.\n", "\n", "To define a dictionary object we need to specify a series of keys followed by a colon (`:`) and then the corresponding values, all comma separated and within `{}`." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# Dictionary of turtle names and colours\n", "turtles = {'Leo': 'blue', 'Raph': 'red', 'Donny': 'purple', 'Mickey': 'orange'}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can look at the pieces that make up the dictionary by looking at the `keys`, `values` and `items`." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict: {'Leo': 'blue', 'Raph': 'red', 'Donny': 'purple', 'Mickey': 'orange'}\n", "keys: dict_keys(['Leo', 'Raph', 'Donny', 'Mickey'])\n", "values: dict_values(['blue', 'red', 'purple', 'orange'])\n", "items: dict_items([('Leo', 'blue'), ('Raph', 'red'), ('Donny', 'purple'), ('Mickey', 'orange')])\n" ] } ], "source": [ "# Show dictionary components\n", "print('dict:', turtles)\n", "print('keys:', turtles.keys())\n", "print('values:', turtles.values())\n", "print('items:', turtles.items())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we can use the keys (*i.e.* the turtles' names) to look up the values (*i.e.* the corresponding colours). *e.g.* To look up what colour Donatello wears we simply need to pass the key `'Donny'` to the dictionary `turtles` as follows.\n", "\n", "```python\n", "turtles['Donny']\n", "```" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Donatello wears purple.\n" ] } ], "source": [ "# Look up dictionary value|\n", "print('Donatello wears {}.'.format(turtles['Donny']))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> Note that dictionary look up in Python is highly optimised, but it only works one way (*i.e.* keys &rarr; values).\n", "\n", "It is possible to add entries to a dictionary by specifying a new key and assigning a corresponding value." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'Leo': 'blue', 'Raph': 'red', 'Donny': 'purple', 'Mickey': 'orange', 'Splinter': 'wine'}\n" ] } ], "source": [ "# Add dictionary entry\n", "turtles['Splinter'] = 'wine'\n", "print(turtles)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It is also possible to modify existing entry values by takinging an existing key and assigning a new value." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'Leo': 'blue', 'Raph': 'red', 'Donny': 'purple', 'Mickey': 'orange', 'Splinter': 'yellow'}\n" ] } ], "source": [ "# Modify dictionary value\n", "turtles['Splinter'] = 'yellow'\n", "print(turtles)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You will raise an exception if you try to index a dictionary or look up a key for a entry that doesn't exist." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1;31mKeyError: 'Rocksteady'\u001b[1;m\n" ] } ], "source": [ "try:\n", " turtles['Rocksteady']\n", "except Exception as error:\n", " print_error('KeyError: {}'.format(error))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Dictionary Unpacking\n", "\n", "Similarly to array-like objects, dictionaries can be unpacked." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "val1 = a ; val2 = b ; val3 = c\n" ] } ], "source": [ "# Create a dictionary\n", "mydict = {'a' : 1, 'b' : 2, 'c' : 3}\n", "\n", "# Unpack the dictionary\n", "val1, val2, val3 = mydict\n", "\n", "print('val1 = {} ; val2 = {} ; val3 = {}'.format(val1, val2, val3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ …