Skip to content

Instantly share code, notes, and snippets.

@jhale

jhale/02_some_basics.ipynb

Created May 7, 2019 14:31
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save jhale/4d3ee189636dd89b12ef36955a4a0eb6 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save jhale/4d3ee189636dd89b12ef36955a4a0eb6 to your computer and use it in GitHub Desktop.
Download ZIP
UL Scientific Python Draft Notebooks
Display the source blob
Display the rendered blob
Raw
02_some_basics.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Lecture 2\n",
"## Some basics"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Covered topics:\n",
"\n",
"* Variables.\n",
"* Types.\n",
" * Integers.\n",
" * Casting.\n",
" * Floating point numbers.\n",
"* Functions."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Variable assignment"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"8\n"
]
}
],
"source": [
"x = 3 # Assign the variable x the value of 3\n",
"y = 5 # Assign the variable y the value of 5\n",
"z = x + y # Add x any y then assign the variable z the result\n",
"print(z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Types and Casting"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"There are many basic *types* in Python. They are each specially designed for storing different *types of data*."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Basic types"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Booleans hold just two values `True` or `False`."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"x = True # Booleans\n",
"x = 3 # Integers (int)\n",
"x = 3.0 # Floating-point numbers (float)\n",
"x = 1.0 + 2.0j # Complex numbers (complex)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"*Exercise*: What is the output of the following code? Why?"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"8.5693\n",
"<class 'int'>\n"
]
}
],
"source": [
"x = 3\n",
"y = 5.5693\n",
"z = x + y\n",
"print(z)\n",
"print(type(x))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"We can ask Python for the `type` of a variable. This is called *introspection* (jargon)."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'int'>\n",
"<class 'float'>\n",
"<class 'float'>\n"
]
}
],
"source": [
"print(type(x))\n",
"print(type(y))\n",
"print(type(z))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## What happened?\n",
"\n",
"*Casting* - Changing a variable of one *type* to another *type*.\n",
"\n",
"*Implicit casting* - Python automatically performs a 'sensible' casting for you.\n",
"\n",
"When we asked Python to add 'x' to 'y', it implicitly cast 'x' 'on-the-fly' to be an 'float'."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Implicit casting is not always possible\n",
"\n",
"*Exercise*: What is the output of the following code? Why?"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"ename": "TypeError",
"evalue": "unsupported operand type(s) for +: 'int' and 'str'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-5-9961aa806c05>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"5\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
]
}
],
"source": [
"x = 3\n",
"y = \"5\"\n",
"z = x + y"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"*Exercise:* What are the types of `x` and `y`? (Use e.g. `type(x)`)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'int'>\n",
"<class 'str'>\n"
]
}
],
"source": [
"print(type(x))\n",
"print(type(y))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## How can we fix the problem?\n",
"\n",
"There are two logical ways to interpret adding `+` an integer `x` and a string `y`.\n",
"\n",
"1. Convert `x` (`int`) to a `str`, then `+` (concatenate) `x` onto the front of `y`.\n",
"2. Convert `y` (`str`) to an `int`, then `+` (add) `x` to `y`.\n",
"\n",
"Python is not magic! You need to tell Python what you really want by *explicitly casting*."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'int'>\n",
"5\n",
"<class 'str'>\n",
"5\n",
"<class 'int'>\n"
]
}
],
"source": [
"a = 5\n",
"print(type(a))\n",
"b = str(a)\n",
"print(b)\n",
"print(type(b))\n",
"c = int(b)\n",
"print(c)\n",
"print(type(c))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"*Exercise:* Modify line `3` using `int` make the following code run."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"ename": "TypeError",
"evalue": "unsupported operand type(s) for +: 'int' and 'str'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-9-d6e5848541f0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"5\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
]
}
],
"source": [
"x = 3\n",
"y = \"5\"\n",
"z = x + y\n",
"print(z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Solution:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"8\n"
]
}
],
"source": [
"x = 3\n",
"y = \"5\"\n",
"z = x + int(y)\n",
"print(z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"*Exercise:* Modify line `3` using the function `str` make the following code run."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"x = 3\n",
"y = \"5\"\n",
"z = x + y\n",
"print(z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Solution:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"35\n"
]
}
],
"source": [
"x = 3\n",
"y = \"5\"\n",
"z = str(x) + y\n",
"print(z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Some more complex types\n",
"\n",
"Data structures.\n",
"\n",
"### Lists\n",
"\n",
"A collection of values, possibly of different type."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[3, 4, 5, 6, 7]\n",
"[3, 'test', 4, 9]\n"
]
}
],
"source": [
"some_numbers = [3, 4, 5, 6, 7] \n",
"print(some_numbers)\n",
"mixed_types = [3, \"test\", 4, 9]\n",
"print(mixed_types)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Exercise: Write code to join the two lists `some_numbers` and `mixed_types` together (using `+`) and print the result."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[3, 4, 5, 6, 7, 3, 'test', 4, 9]"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"print(some_numbers + mixed_types)\n",
"print(len(some_numbers))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Tuples\n",
"\n",
"An *immutable* collection of values.\n",
" \n",
"*Immutable* something that cannot be changed after it is created."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n",
"4\n",
"6\n",
"7\n"
]
}
],
"source": [
"a_tuple = (3, 4, 5, 6, 7) # A tuple containing 5 values.\n",
"print(a_tuple[0]) # The first element of the tuple.\n",
"print(a_tuple[1]) # The second element of the tuple.\n",
"print(a_tuple[3]) # The fourth element of the tuple.\n",
"print(a_tuple[-1]) # The last element of the tuple."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"*Slicing* allows us to select *subsets* of a collection.\n",
"\n",
"We will look closer at slicing in Lecture 4.\n",
"\n",
"Exercise: What do the following commands do?"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(3, 4, 5, 6, 7)\n",
"(4, 5, 6, 7)\n",
"(3, 4)\n",
"(7,)\n"
]
}
],
"source": [
"a_tuple = (3, 4, 5, 6, 7) \n",
"print(a_tuple[:])\n",
"print(a_tuple[1:])\n",
"print(a_tuple[0:2])\n",
"print(a_tuple[-1:])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Exercise: Add code that uses slicing to:\n",
"* print the second last element of the list.\n",
"* print the second, third, fourth and fifth element of the list.\n",
"* bonus: every second element of the list `[start:stop:step]`\n",
"* bonus: set your neighbour a challenge!"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"76.85\n",
"76.85\n",
"76.85\n",
"[8.0, 12.0, 93.6, 23.2]\n",
"[3.0, 12.0, 23.2, 93.2]\n",
"[3.0, 12.0, 23.2, 93.2]\n",
"[3.0, 12.0, 23.2, 93.2]\n"
]
}
],
"source": [
"a_list = [3.0, 8.0, 12.0, 93.6, 23.2, 76.85, 93.2]\n",
"print(a_list[-2])\n",
"print(a_list[5])\n",
"print(a_list[len(a_list) - 2])\n",
"print(a_list[1:5])\n",
"print(a_list[::2])\n",
"print(a_list[0::2])\n",
"print(a_list[0:7:2])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Dictionaries\n",
"\n",
"A map between keys and values."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'Hale'"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_information = {\"age\": 33,\n",
" \"name\": \"Hale\"}\n",
"my_information\n",
"my_information[\"name\"]"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Iterating\n",
"\n",
"Passing over the *elements* of a list one at a time."
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n",
"3\n",
"4\n",
"5\n",
"2\n",
"3\n",
"4\n",
"5\n",
"0\n",
"2\n",
"1\n",
"3\n",
"2\n",
"4\n",
"3\n",
"5\n",
"0\n",
"2\n",
"1\n",
"3\n",
"2\n",
"4\n",
"3\n",
"5\n",
"\n",
"\n",
"\n",
"\n",
"2\n",
"10\n",
"3\n",
"11\n",
"4\n",
"12\n",
"5\n",
"13\n",
"0\n",
"2\n",
"10\n",
"bob\n",
"1\n",
"3\n",
"11\n",
"mary\n",
"2\n",
"4\n",
"12\n",
"gary\n"
]
}
],
"source": [
"# This way is preferred\n",
"bs = [2, 3, 4, 5]\n",
"for b in bs:\n",
" print(b)\n",
" \n",
"# Not pythonic\n",
"num_elements = len(bs)\n",
"for i in range(num_elements):\n",
" print(bs[i])\n",
"\n",
"# Very nice!\n",
"for i, b in enumerate(bs):\n",
" print(i)\n",
" print(b)\n",
"\n",
"# Also avoid, not pythonic.\n",
"i = 0\n",
"for b in bs:\n",
" print(i)\n",
" print(b)\n",
" i = i + 1\n",
"\n",
"# Avoid\n",
"cs = [10, 11, 12, 13]\n",
"for i, b in enumerate(bs):\n",
" b*cs[i]\n",
"\n",
"# Very nice\n",
"for b, c in zip(bs, cs):\n",
" print()\n",
"\n",
"# Good\n",
"bs = [2, 3, 4, 5]\n",
"cs = [10, 11, 12, 13, 14]\n",
"for b, c in zip(bs, cs):\n",
" print(b)\n",
" print(c)\n",
"\n",
"# Good\n",
"ds = (\"bob\", \"mary\", \"gary\")\n",
"for i, (b, c, d) in enumerate(zip(bs, cs, ds)):\n",
" print(i)\n",
" print(b)\n",
" print(c)\n",
" print(d)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Functions"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"We've already used some *built-in* functions!\n",
"\n",
"* `int(\"5\")`\n",
"* `print(\"string\")`\n",
"* `type(5)`\n",
"\n",
"*Functions* take zero or more *arguments* and returns zero or one variable.\n",
"\n",
"**Purpose of functions**: Split a computer program up into simple and re-usable blocks of functionality."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## A simple function\n",
"\n",
"Python uses indentation to define blocks of code, e.g. functions."
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"50\n",
"8\n",
"15.0\n"
]
}
],
"source": [
"def add(a, b):\n",
" c = a + b\n",
" return c\n",
"\n",
"c = add(20, 30)\n",
"print(c)\n",
"print(add(3, 5))\n",
"print(add(10, 5.0))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Exercise: Write a function `multiply` taking three arguments and returns the multiple (symbol: `*`) of the three arguments."
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"1000"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def multiply(a, b, c):\n",
" d = a * b * c\n",
" return d\n",
"\n",
"multiply(10, 10, 10)"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"assert(multiply(3, 4, 5) == 60)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Documenting functions\n",
"\n",
"It is important to document your functions!"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"def multiply(a, b, c):\n",
" \"\"\"Takes three arguments and returns their multiple.\n",
" \n",
" The string can have multiple lines.\n",
" \"\"\"\n",
" d = a * b * c\n",
" return d"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"In a Jupyter Notebook you can ask for the documentation of any function by typing `?` after its name:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"multiply?"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Exercise: Try typing `?` after `int`."
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"int?"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"The `Init signature` is `int(self, /, *args, **kwargs)`.\n",
"\n",
"What are `*args` and `**kwargs`?"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### `*args`: \n",
"\n",
"Purpose: Write *one* function that can take zero *or* more arguments."
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'tuple'>\n",
"()\n",
"<class 'tuple'>\n",
"(3, 4)\n",
"<class 'tuple'>\n",
"(5, 6, 7)\n"
]
}
],
"source": [
"def arg_demo_1(*args):\n",
" print(type(args))\n",
" print(args)\n",
" \n",
"arg_demo_1()\n",
"arg_demo_1(3, 4)\n",
"arg_demo_1(5, 6, 7)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
" Key point: args is of type *tuple*.\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"E"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Why is that useful?\n",
"\n",
"Consider the alternative:\n",
"\n",
"A function to add two variables, and three..."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"def add_two_variables(a, b):\n",
" return a + b\n",
"\n",
"def add_three_variables(a, b, c):\n",
" return a + b + c"
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n",
"9\n",
"0\n"
]
}
],
"source": [
"def accumulate(*args):\n",
" result = 0\n",
" for arg in args:\n",
" result = result + arg\n",
" return result\n",
"\n",
"print(accumulate(2, 3))\n",
"print(accumulate(2, 3, 4))\n",
"print(accumulate())"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"add(3, 4, 5)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"add(10, 11, 12, 14)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## `**kwargs`\n",
"\n",
"Purpose: Pass named arguments. Useful when function has *many* arguments."
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'dict'>\n",
"{'my_integer': 3, 'another_dict': {}, 'do_something': True}\n",
"True\n"
]
}
],
"source": [
"def kwarg_demo(**kwargs):\n",
" print(type(kwargs))\n",
" print(kwargs)\n",
" print(kwargs[\"do_something\"])\n",
"\n",
"kwarg_demo(my_integer=3, another_dict={}, do_something=True)"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"plt.plot?"
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7f2946c1b198>]"
]
},
"execution_count": 88,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.plot(2.0, 3.0, 'x')"
]
},
{
"cell_type": "code",
"execution_count": 89,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7f29466cbe10>]"
]
},
"execution_count": 89,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.plot(2.0, 3.0, 'x', color='tab:red')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"*Exercise*: Read the documentation of `plt.plot`. Change the size of the marker in the plot to be ten."
]
},
{
"cell_type": "code",
"execution_count": 90,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7f29466404a8>]"
]
},
"execution_count": 90,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.plot(2.0, 3.0, 'x', color='tab:red', markersize=10.0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Summary before exercises\n",
"\n",
"You have seen:\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Exercise 1\n",
"## Getting to grips with default arguments"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"What is the output of the following code?"
]
},
{
"cell_type": "code",
"execution_count": 92,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10264\n",
"102124\n",
"102812\n"
]
}
],
"source": [
"def numbers(first, second=2, third=6, fourth=4):\n",
" n = str(first) + str(second) + str(third) + str(fourth)\n",
" return n\n",
"\n",
"print(numbers(10))\n",
"print(numbers(10, third=12))\n",
"print(numbers(10, fourth=12, third=8))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Exercise 2\n",
"## Writing functions with style"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"The following function calculates the standard deviation of a list of numbers $p$.\n",
"\n",
"See: https://en.wikipedia.org/wiki/Standard_deviation Discrete Random Variables\n",
"\n",
"Discuss with your neighbour whether you think this is a well-written function. Can you identify things that could be improved?"
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The answer: 0.707107\n"
]
}
],
"source": [
"def s(ps):\n",
" \"\"\"A function to calculate the sample standard deviation of a collection\"\"\"\n",
" assert(len(ps) >= 2)\n",
" \n",
" # Accumulator for calculating sum\n",
" mean = 0.0\n",
" for p in ps:\n",
" #mean = mean + p\n",
" mean += p\n",
" mean = mean / len(ps)\n",
" \n",
" d = 0.0\n",
" for p in ps:\n",
" d += (p - mean)**2\n",
" return (d / (len(ps) - 1))**(1/2)\n",
"\n",
"print(\"The answer: {:f}\".format(s([2, 3])))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Things you could improve:\n",
"\n",
"1. Rename the function and the variables to be more descriptive, e.g. `m` to `mean`.\n",
"2. Add extra line breaks between logical sections. After an indented block of code, there should always be a blank line.\n",
"3. Add a documentation string.\n",
"4. Instead of using long-hand addition e.g. `a = a + b`, use the short-hand notation `a += b`.\n",
"4. Add a default argument `corrected=True`.\n",
"5. When `corrected` is `False`, instead compute the uncorrected estimate of the standard deviation (see Wikipedia).\n",
"6. What happens when you pass an empty list `p = []`? How could you fix it?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def std_dev(samples, corrected=True):\n",
" \"\"\"Calculate the standard deviation of the elements of the list samples.\n",
" \n",
" If corrected is `True` then compute the unbiased/corrected standard deviation.\n",
" If corrected is `False` then compute the uncorrected standard deviation.\n",
" \"\"\"\n",
" if len(samples) < 2:\n",
" raise ValueError\n",
" \n",
" sample_sum = 0.0\n",
" for sample in samples:\n",
" sample_sum += sample\n",
"\n",
" sample_mean = sample_sum / len(samples)\n",
"\n",
" sum_squared_devs = 0.0\n",
" for sample in samples:\n",
" sum_squared_devs += (sample - sample_mean)**2\n",
" \n",
" if corrected:\n",
" return (sum_squared_devs / (len(samples) - 1))**(1/2)\n",
" else:\n",
" return (sum_squared_devs / (len(samples)))**(1/2)\n",
" else:\n",
" raise RuntimeError"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Compare your answer with mine and your neighbours!"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Exercise 3\n",
"## Caution required: Floating point numbers"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Most problems in engineering, science and statistics require working with floating point numbers. However, computers do not work directly with floating point numbers or even base 10 numbers, but with their base 2 or binary representation."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Storing integers"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Base 10 representation of the number 342\n",
"\n",
"| $10^2$ | $10^1$ | $10^0$ |\n",
"|--------|--------|--------|\n",
"| 3 | 4 | 2 |\n",
"\n",
"$3 \\times 10^2 + 4 \\times 10^1 + 2 \\times 10^0 = 342$"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Base 2 (binary) representation of the number 342\n",
"\n",
"\n",
" | $2^8$ | $2^7$ | $2^6$ | $2^5$ | $2^4$ | $2^3$ | $2^2$ | $2^1$ | $2^0$ |\n",
" |-------|-------|-------|-------|-------|-------|-------|-------|-------|\n",
" | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 1 | 0 |\n",
"\n",
"$1 \\times 2^8 + 0 \\times 2^7 + 1 \\times 2^6 + 0 \\times 2^5 + 1 \\times 2^4 + 0 \\times 2^3 + 1 \\times 2^2 + 1 \\times 2^1 + 0 \\times 2^0= 342$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"bin(342) # The prefix 0b in the binary denotes that we are using a binary representation."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"print(10.45)\n",
"print(1045E-2)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"It is not possible to represent the number 0.1 *exactly* in the floating point representation (IEEE754) of the computer."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"print(1.0E-1)\n",
"print('{0:.30f}'.format(1.0E-1))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Example: inexact representation\n",
"#### Example from Garth N. Wells, CC Attribution Sharealike 4.0.\n",
"\n",
"It is trivial that\n",
"\n",
"$$\n",
"x = 11x - 10x\n",
"$$\n",
"\n",
"If $x = 0.1$, we can write\n",
"\n",
"$$\n",
"x = 11x - 1\n",
"$$\n",
"\n",
"Now, starting with $x = 0.1$ we evaluate the right-hand side to get a 'new' $x$, and use this new $x$ to then evaluate the right-hand side again. The arithmetic is trivial: $x$ should remain equal to $0.1$.\n",
"We test this in a program that repeats this process 20 times: "
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.10000000000000009\n",
"0.10000000000000098\n",
"0.10000000000001075\n",
"0.10000000000011822\n",
"0.10000000000130038\n",
"0.1000000000143042\n",
"0.10000000015734622\n",
"0.10000000173080847\n",
"0.10000001903889322\n",
"0.10000020942782539\n",
"0.10000230370607932\n",
"0.10002534076687253\n",
"0.10027874843559781\n",
"0.1030662327915759\n",
"0.13372856070733485\n",
"0.4710141677806834\n",
"4.181155845587517\n",
"44.992714301462684\n",
"493.9198573160895\n",
"5432.118430476985\n"
]
}
],
"source": [
"x = 0.1\n",
"for i in range(20):\n",
" x = x*11 - 1\n",
" print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Normally this is not a problem, but every programmer should be aware of it!"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Exercise**\n",
"\n",
"Compare the computed values of\n",
"\n",
"$$d_0 = ab + ac$$\n",
" \n",
"and\n",
"\n",
"$$d_1 = a(b + c)$$\n",
" \n",
"when $a=100$, $b=0.1$ and $c=0.2$. Store $d_0$ in the variable $d0$ and $d_1$ in the variable $d1$.\n",
"\n",
"Try checking for equality, e.g. `print(d0 == d1)`. Why are they not equal?"
]
},
{
"cell_type": "code",
"execution_count": 110,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"30.0\n",
"30.000000000000004\n"
]
}
],
"source": [
"a = 100\n",
"b = 0.1\n",
"c = 0.2\n",
"d0 = a*b + a*c\n",
"d1 = a*(b + c)\n",
"print(d0 == d1)\n",
"assert(abs(d1 - d0) < 1E-10)\n",
"print(d0)\n",
"print(d1)"
]
}
],
"metadata": {
"celltoolbar": "Slideshow",
"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.7.1"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Display the source blob
Display the rendered blob
Raw
03_numpy.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment