{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Object-Oriented Programming in Python"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Objects\n",
"\n",
"Everything that can be stored in a variable is an object.\n",
"\n",
"Attributes and methods are accessed via the `.` operator."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"'A STRING'"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = \"a string\"\n",
"a.upper() # function that acts on the object is called a method"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"4.0"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"c = 1 + 4j\n",
"c.imag # a non-function component of an object is called an attribute"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Comparing Objects"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list_1 = [\"a\", \"list\"]\n",
"list_2 = [\"a\", \"list\"]\n",
"list_1 == list_2\n",
"# The == operator for lists is defined as elementwise comparison."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list_1 is list_2 # The is operator checks if the two refer to the same object in memory."
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"`list_1` and `list_2` are identical but not the same."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"list_2[0] = \"another\""
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"['a', 'list']"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list_1"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"['another', 'list']"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list_2"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list_1 == list_2"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Assigning an object to multiple names"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"list_1 = [\"a\", \"list\"]\n",
"list_2 = list_1"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list_1 is list_2 # list_1 and list_2 are two names referring to the same object"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"list_2[0] = \"another\""
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"['another', 'list']"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list_1"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"#### Copying a list"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"list_1 = [\"a\", \"list\"]\n",
"list_2 = list_1[:] # This creates a (shallow) copy of the list"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"More options for copying arbirtrary objects in the `copy` module."
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"#### Simple Immutable Objects"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = 5\n",
"b = 5\n",
"a is b # Not necessarily True, but these immutable objects are often reused\n",
"# to save memory"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = \"abc\"\n",
"b = \"ab\" + \"c\"\n",
"a is b\n",
"# Strings are immutable, too. The + operator creates a new string and leaves the operands untouched."
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Classes"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Every object is an instance of a class. Classes provide an elegant way to group several variables and associated functions."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = 5\n",
"isinstance(a,int)"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Defining Custom Classes"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"class Incrementor:\n",
" def __init__(self, v=0): # The constructor is called when an instance of the class is created.\n",
" self.v = v # Attributes are created by simply assigning them.\n",
" \n",
" def get_value(self): # self is the instance of the class.\n",
" return self.v\n",
" \n",
" def inc(self, i): # self is passed implicitly when calling the method.\n",
" self.v += i"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"i = Incrementor()\n",
"i.inc(1)\n",
"i.inc(3)\n",
"i.get_value()"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"i.v = 5 # Attributes can also be accessed directly.\n",
"i.get_value()"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"<__main__.Incrementor at 0x7f1228c8fcf8>"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"i"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"class Incrementor:\n",
" def __init__(self, v=0): # The constructor is called when an instance of the class is created.\n",
" self.v = v\n",
" \n",
" def get_value(self): # self is the instance of the class.\n",
" return self.v\n",
" \n",
" def inc(self, i): # self is passed implicitly when calling the method.\n",
" self.v += i\n",
" \n",
" def __repr__(self): # __repr__ can optionally be defined to return a nice string representation of the class.\n",
" return \"Incrementor({})\".format(self.v)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"i = Incrementor(0)\n",
"i.inc(3)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"Incrementor(3)"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"i"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"The `dir` function shows the contents of an object. Many of these are automatically defined."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'get_value', 'inc', 'v']\n"
]
}
],
"source": [
"print(dir(i))"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"#### Overloading Operators"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"class Incrementor:\n",
" def __init__(self, v=0): # The constructor is called when an instance of the class is created.\n",
" self.v = v\n",
" \n",
" def get_value(self): # self is the instance of the class.\n",
" return self.v\n",
" \n",
" def inc(self, i): # self is passed implicitly when calling the method.\n",
" self.v += i\n",
" \n",
" def __add__(self, a): # This method is called when using the + operator.\n",
" v = self.get_value() + a.get_value()\n",
" return self.__class__(v=v) # The __class__ attribute contains the class of the object, Incrementor in this case.\n",
" \n",
" def __repr__(self): # __repr__ can optionally be defined to return a nice string representation of the class.\n",
" return \"{}(v={})\".format(self.__class__.__name__,self.v)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"Incrementor(v=8)"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Incrementor(1) + Incrementor(7)"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Other operators can be overloaded with the repective methods `__sub__`, `__mul__`, `__lt__`, …"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Inheritance\n",
"\n",
"A major feature of object-oriented programming is the ability to create slightly changed derived classes through inheritance. This allows us to reuse large parts of code without copying."
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Let's create a version of `Incrementor` that increments its value twice per call to `inc`."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"class DoubleIncrementor(Incrementor): # Specify the base class(es) in parentheses.\n",
" def inc(self, i): # This overrides the original inc method\n",
" self.v += i\n",
" self.v += i"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"10"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d = DoubleIncrementor()\n",
"d.inc(5)\n",
"d.get_value()"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"DoubleIncrementor(v=17)"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d + DoubleIncrementor(7) # This is why self.__class__ is useful."
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Let's create a version of `Incrementor` that increments an additional variable."
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"class Incrementor2(Incrementor):\n",
" def __init__(self, w=0, **kwargs):\n",
" super().__init__(**kwargs) # This calls the __init__ method of the superclass Incrementor.\n",
" # The Incremetor2 object is initialized like it was an Incrementor object.\n",
" self.w = w # This is specific to Incrementor2\n",
" \n",
" def inc(self, i):\n",
" super().inc(i)\n",
" self.w += i\n",
" \n",
" def get_value2(self): # New methods are possible.\n",
" return self.w\n",
" \n",
" def __add__(self, a): # This method is called when using the + operator.\n",
" v = self.get_value() + a.get_value()\n",
" w = self.get_value2() + a.get_value2()\n",
" return self.__class__(v=v,w=w)\n",
" \n",
" def __repr__(self):\n",
" return \"{}(v={},w={})\".format(self.__class__.__name__,self.v,self.w)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"i2 = Incrementor2(v=2,w=1)\n",
"i2.inc(1)"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"Incrementor2(v=3,w=2)"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"i2"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"Incrementor2(v=0,w=0)"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"i2 + Incrementor2(v=-3,w=-2)"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Decorators\n",
"Not a part of object-oriented programming but we need these to understand some of the syntax later."
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Think of a function that takes a function as an argument and returns a modified version of it."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def func_printer(fun):\n",
" \"\"\"This returns a function that prints the return values of fun every time it is called\"\"\"\n",
" def g(*args, **kwargs):\n",
" ret = fun(*args, **kwargs)\n",
" print(ret)\n",
" return ret\n",
" return g"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"def f(x): # example function\n",
" return x + 1\n",
"f = func_printer(f)"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n"
]
}
],
"source": [
"for i in range(3):\n",
" f(i)"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Decorator Syntax\n",
"The above can be simplified by using the decorator syntax."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"@func_printer\n",
"def f(x):\n",
" return x+1"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n"
]
}
],
"source": [
"for i in range(3):\n",
" f(i)"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Multiple decorators can be combined."
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"@func_printer\n",
"@func_printer\n",
"def f(x):\n",
" return x+1"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"1\n",
"2\n",
"2\n",
"3\n",
"3\n"
]
}
],
"source": [
"for i in range(3):\n",
" f(i)"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Properties\n",
"It can be useful to automatically call a function when getting or setting an attribute."
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"class Circle:\n",
" def __init__(self, radius):\n",
" self.radius = radius # This calls the property setter below.\n",
" \n",
" @property\n",
" def radius(self):\n",
" return self._r\n",
" # _r can still be changed externally but it should be avoided\n",
" \n",
" @radius.setter\n",
" def radius(self, r):\n",
" if r < 0:\n",
" raise ValueError(\"radius must not be negative\")\n",
" # This produces an error message.\n",
" # Details on syntax later.\n",
" self._r = r\n",
" \n",
" @property\n",
" def area(self):\n",
" from math import pi\n",
" return self.radius**2 * pi"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"c = Circle(2)"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"ename": "ValueError",
"evalue": "radius must not be negative",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-43-3e9149d199a3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mradius\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m \u001b[0;31m# This raises an error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;32m<ipython-input-41-40e18930e582>\u001b[0m in \u001b[0;36mradius\u001b[0;34m(self, r)\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mradius\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mr\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"radius must not be negative\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 14\u001b[0m \u001b[0;31m# This produces an error message.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;31m# Details on syntax later.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mValueError\u001b[0m: radius must not be negative"
]
}
],
"source": [
"c.radius = -1 # This raises an error"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"12.566370614359172"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"c.area # There is no setter so this is read-only"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Exceptions\n",
"When errors occur in a subfunction, they can often be handled at a higher level. Passing special return values in case of errors is often complicated and error prone. Exceptions make it possible to mark errors where they occur and either handle them at a higher level or expose them to the user."
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def faulty_function():\n",
" \"\"\"This function always raises an exception.\"\"\"\n",
" raise Exception(\"An error occured.\") # The message is optional.\n",
" print(\"You will not see this.\")"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"ename": "Exception",
"evalue": "An error occured.",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mException\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-46-03995ec90286>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfaulty_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;32m<ipython-input-45-1b72c5a124a6>\u001b[0m in \u001b[0;36mfaulty_function\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfaulty_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\"\"\"This function always raises an exception.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"An error occured.\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# The message is optional.\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[0;34m\"You will not see this.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mException\u001b[0m: An error occured."
]
}
],
"source": [
"faulty_function()"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"There are many other Exception types."
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"import numbers\n",
"def mysqrt(x):\n",
" if not isinstance(x, numbers.Number):\n",
" raise TypeError(\"x must be a number.\")\n",
" if x < 0:\n",
" raise ValueError(\"x must be non-negative.\")\n",
" return x**0.5"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"ename": "ValueError",
"evalue": "x must be non-negative.",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-48-8b7004e246c3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmysqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;32m<ipython-input-47-ea1c367be11f>\u001b[0m in \u001b[0;36mmysqrt\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"x must be a number.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"x must be non-negative.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m0.5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mValueError\u001b[0m: x must be non-negative."
]
}
],
"source": [
"mysqrt(-1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### `try` / `except` blocks\n",
"If an exception is raised somewhere in the `try` (also inside functions), execution is immediately stopped and continued at the first matching `except` block is executed. There can be an optional `finally` block which is always executed after the `try` if an exception occurs or not."
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true,
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"def another_function(x):\n",
" try:\n",
" a = mysqrt(x)\n",
" except:\n",
" # This is a catch-all block, which is executed if any exception occurs.\n",
" print(\"An error occured. A default of 0 will be returned.\")\n",
" a = 0.0\n",
" return a"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"An error occured. A default of 0 will be returned.\n"
]
},
{
"data": {
"text/plain": [
"0.0"
]
},
"execution_count": 50,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"another_function(-2)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"There can be several `except` blocks. The first match is executed on exception."
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def yet_another_function(x):\n",
" try:\n",
" a = mysqrt(x)\n",
" except ValueError:\n",
" print(\"Trying negative value\")\n",
" a = mysqrt(-x)\n",
" except:\n",
" # This is a catch-all block, which is executed if any exception occurs.\n",
" print(\"An error occured. A default of 0 will be returned.\")\n",
" a = 0.0\n",
" return a"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"collapsed": false,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Trying negative value\n"
]
},
{
"data": {
"text/plain": [
"2.0"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"yet_another_function(-4)"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"collapsed": false,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"An error occured. A default of 0 will be returned.\n"
]
},
{
"data": {
"text/plain": [
"0.0"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"yet_another_function(\"abc\")"
]
}
],
"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.5.3"
}
},
"nbformat": 4,
"nbformat_minor": 0
}