Python functions.ipynb

{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Functions"},{"metadata":{},"cell_type":"markdown","source":"A function is a block of organized, reusable code. Functions provide better modularity for your application and a high degree of code reusing. In addition, they also make your code more readable, as they keep the main code simple by assigning tasks to auxiliary funtions. \n\nWe've seen some of Python's built-in functions like *int()*, *print()*, *type()*, etc., and object functions such as those belonging to **string**s. We will now learn how to create user-defined functions.\n\nA function receives input arguments and **returns** some output based on them. Both the input and the output can in general contain zero arguments, for example the function _print()_ returns no argument and the _bit\\_length()_ function if **int** receives no input. \n\nEvery function definition starts with a *signature*, containing the prefix **def** followed by the name of the function and parentheses, in which the input arguments are listed. Then, following a colon and an indentation, the function block is written, possibly containing a **return** statement(s). As python is dynamically typed, there is not declaration of return type for functions."},{"metadata":{"scrolled":true,"trusted":true},"cell_type":"code","source":"def add(a,b):\n    total = a + b\n    return total\nprint (add(12,-9))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def strToBool(s):\n    test = s.lower()\n    if test == \"false\" or test == \"f\":\n        return False\n    elif s.lower() == \"true\" or test == \"t\":\n        return True\n    return None\nprint(strToBool(\"FAlsE\"))\nprint(strToBool(\"true\"))\nprint(strToBool(\"t\"))\nprint(strToBool(\"F\"))\n\nprint(strToBool(\"Maybe\"))\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**None** is the Python equivalent of **null**. The comparison is not one to one, as Python's **None** is an object in its own right, however the use is similar."},{"metadata":{"trusted":true},"cell_type":"code","source":"print(type(None))\nprint(bool(None))\nprint(strToBool(\"fa\") is None)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"In Python, a function can return multiple values for a single function call. When calling such a function, we can accept all returned values into one variable, which will hold a Python **tuple** object. Alternatively, we can **unpack** the returned values accross multiple variables, each holding one value. For the latter option, we must know how many values are returned."},{"metadata":{"trusted":true},"cell_type":"code","source":"def calculate(a,b):\n    c1= a+b \n    c2= a-b \n    c3= a*b\n    c4= 0 if b == 0 else a/b\n    return c1, c2, c3, c4\ntup = calculate(80,15)\nv1,v2,v3,v4 = calculate(10,0)\n#p1,p2 = calculate(11,12) #error\nprint(\"tuple: \", tup)\nprint(\"values: \",v1,v2,v3,v4)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Functions can define default values for input parameters. All non-default params must come before default params.**"},{"metadata":{"trusted":true},"cell_type":"code","source":"def prints(s,caps=False):\n    s_ = str(s)\n    toPrint = s_.upper() if caps else s_\n    print(toPrint)\n\nprints(\"This sentence is printed as is.\")\nprints(\"this one is all caps\",True)\nprints(True,True)\nprints(False,True)\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Function input parameters are assigned in the order they are sent, however they can be explicitely defined in the function call**"},{"metadata":{"trusted":true},"cell_type":"code","source":"implicit=calculate(2,4)\nexplicit=calculate(b=2,a=4)\nprint(\"implicit:\",implicit)\nprint(\"explicit:\",explicit)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def poly(a,b=1,c=1,d=0):\n    return str(a)+\"x^3 + \" + str(b) + \"x^2 + \" + str(c) + \"x + \" + str(d)  \n\nprint(\"1:\",poly(2))\nprint(\"2:\",poly(2,3))\nprint(\"3:\",poly(2,3,4))\nprint(\"4:\",poly(2, d=9))\nprint(\"5:\",poly(10,11,d=17))\n##print(\"6:\",poly()) #error - at least 1 param required\n##print(\"7:\",poly(2, b=8, 15)) #error - can't have positional argument after keyword\n##print(\"8:\",poly(2, 7, b=12)) #error - b received multiple values: positional + keyword\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"What if we want to expand the above _polynomial_ function so that we can have more coeffiecents and degrees? Python uses the <font color=\"red\">**\\*args**</font> input parameter for variable length input. The input will be stored in a **tuple** object. We can *iterate* over this **tuple** using the <font color=\"blue\">**for**</font> statement. "},{"metadata":{"trusted":true},"cell_type":"code","source":"def polynom(*coefficients):\n    res=[]\n    p = len(coefficients) - 1 \n    for c in coefficients:\n        if type(c) in (int, float): #check if the type of c is s number\n            if c != 0:\n                if p!= 0 and p!=1:\n                    term = \"{}x^{}\".format(c,p)\n                elif p == 1:\n                    term = str(c)+\"x\"\n                else:\n                    term = str(c)\n                res.append(term)\n        p-=1\n    return \" + \".join(res)\n    ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"polynom(5,4,3,2,1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"polynom(5.5,4.4,3.3,2e-4,1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"polynom(0,13,0,37,0)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"polynom(17, \"6\", \"100\", 90, \"hello\", 80, (13,14,15), 0, 0, 7 )","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Logical errors can occur at runtime, these are called **Exceptions**. Python let's you catch and handle exceptions using the **try/except** statement:<br>\ntry:<br>\n&emsp;\\< unsafe_code \\><br>\nexcept \\< exception_type_1 \\>:<br>\n&emsp;\\< handle_exception \\>:<br>\nexcept \\< (exception_type_1, exception_type_3) \\>:<br>\n&emsp;\\< handle_exception \\>:<br>\nexcept:<br>\n&emsp;\\< handle_other_exceptiosn \\><br>\nelse:<br>\n&emsp;\\< handle_no_exceptions \\><br>\nfinally:<br>\n&emsp;\\< cleanup \\><br>\n<br>\n*Note: **else** and **finally** are optional. The **else** block is executed only if no exception was caught, the **finally** block is always executed*."},{"metadata":{"trusted":true},"cell_type":"code","source":"\"Exception\"[100]","execution_count":null,"outputs":[]},{"metadata":{"scrolled":true,"trusted":true},"cell_type":"code","source":"x = \"Exception\"\ntry:\n    print(x[100])\nexcept Exception as e:\n    print(type(e))\nelse:\n    print(x)\nfinally:\n    print(len(x))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def castNumber(param):\n    try:\n        fNum = float(param)\n        nNum = int(fNum)\n        \n    except:\n        return None\n    else:\n        return nNum if nNum == fNum else fNum\n    ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(castNumber(1))\nprint(castNumber(2.0))\nprint(castNumber(3.3))\nprint(castNumber(\"4\"))\nprint(castNumber(\"4.4\"))\nprint(castNumber(\"5e5\"))\nprint(castNumber(\"6 \"))\nprint(castNumber(\"seven\"))\nprint(castNumber((8,)))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def polynomial(*coefficients):\n    \"\"\"\n    Returns a string representing a polynomial expression with given coefficients.\n    With 'n' being the length of the input, the (i)th element in the tuple will\n    belong to the (n-i-1)th degree.\n    Arguments:\n    *coefficents - arbitrary length sequence of numeric or string representation of numeric values.\n    Returns:\n    string - representation of polynomial\n    \"\"\"\n    res=[]\n    for p,c in enumerate(reversed(coefficients)):\n        c_ = castNumber(c)\n        if c_ is not None: #check if the type of c is s number\n            if c != 0:\n                if p!= 0 and p!=1:\n                    term = \"{}x^{}\".format(c_,p)\n                elif p == 1:\n                    term = str(c_)+\"x\"\n                else:\n                    term = str(c_)\n                res.append(term)\n    res.reverse()\n    return \" + \".join(res)\n    ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"help(polynomial)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"polynomial(17, \"6\", \"100\", 90, \"hello\", 80, (13,14,15), 0, 0, 7 )","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Classes"},{"metadata":{},"cell_type":"markdown","source":"Python is an object oriented language, which uses classes as object templates. Classes are defined using the `class` keyword.\nObject instances are created by calling the class constructor method: `classInstance = className()`<br>\nIn python, there is not distinction between private/protected/public class variables. This means you can manually modify the internals of an object throught the program life cycle. Care must be taken so as not to damage the inner workings of a class."},{"metadata":{"trusted":true},"cell_type":"code","source":"class Dummy:\n    x = \"dummy\"\n    \n    def printMe(self):\n        print(self.x)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"d=Dummy()\nd.printMe()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"Dummy.x","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"d.x=99\nd.printMe()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"Dummy.x","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def printMe():\n    print(\"hello world\")\nd.printMe = printMe\nd.printMe()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"*Note: you can override a function inside an instance of a class, but you cannot bind it to the instance's \"self\" parameter.*"},{"metadata":{"trusted":true},"cell_type":"code","source":"d1 = Dummy()\nd1.printMe()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def printMore(self):\n    print(self.printMe)\nDummy.printMore = printMore","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"d2 = Dummy()\nprint(\"d2:\")\nd2.printMe()\nd2.printMore()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"d1:\")\nd1.printMe()\nd1.printMore()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Modifying the Class itself affects all previously created instances as well**"},{"metadata":{"trusted":true},"cell_type":"code","source":"Dummy.x = \"Another dummy\"\nprint(\"d2:\")\nd2.printMe()\nprint(\"d1:\")\nd1.printMe()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"d1.x = 100\nDummy.x = \"Yet another dummy\"\nprint(\"d2:\")\nd2.printMe()\nprint(\"d1:\")\nd1.printMe()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"*Once an instance variable has been overriden, it is no longer bound to the class variable.*"},{"metadata":{},"cell_type":"markdown","source":"### The class __init__() function\nThe `__init__()` function is one of Python's magic (dunder - double underscode) functions. There are functions that are implicitly called when performing specific actions in Python. The `__init__()` function is called when creating a new class instance (i.e. calling the class constructor). By default, any class functions, including `__init__()` accept the **self** parameter as their first argument. This must be explicitly defined in the function declaration.<br>\nWe use the `__init__()` function to initialize new instances."},{"metadata":{"trusted":true},"cell_type":"code","source":"class Vector:\n    import math\n    \"\"\"\n    Vector class defining a 3-dimensional Vector object with coordinates x,y,z.\n    \"\"\"\n    x,y,z = (0,0,0)\n    \n    def __init__(self,x=0,y=0,z=0):\n        if type(x) in (int,float):\n            self.x = x\n        if type(y) in (int,float):\n            self.y = y\n        if type(z) in (int,float):\n            self.z = z\n    \n    def multiply(self,m):\n        \"\"\"\n        Multiply vector by a given scalar value.\n        \"\"\"\n        if type(m) in (float,int):\n            self.x *= m\n            self.y *= m\n            self.z *= m\n    \n    def length(self):\n        return self.math.sqrt(self.x**2 + self.y**2 + self.z**2)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"v = Vector(2, 4, 4)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"v.multiply(3)\nprint(v)\nprint(v.x,v.y,v.z)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(v.length())\nprint(v)\nprint(v.x,v.y,v.z)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def VectorString(self):\n    \"\"\"\n    String representation of a Vector object.\n    \"\"\"\n    return \"({},{},{})\".format(self.x,self.y,self.z)\nVector.__str__ = VectorString","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(v)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"*The `__str__()` function of a class is called when the string representation of an instance is required.*"},{"metadata":{"trusted":true},"cell_type":"code","source":"def VectorAdd(self,other):\n    res = Vector()\n    if type(other) == Vector:\n        res.x = self.x + other.x\n        res.y = self.y + other.y\n        res.z = self.z + other.z\n    elif type(other) in (int,float):\n        res.x = self.x + other\n        res.y = self.y + other\n        res.z = self.z + other\n    else:\n        res = str(self) +\" \"+ str(other)\n    return res\nVector.__add__ = VectorAdd","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"v:\",v)\nv1 = Vector(100,100)\nprint (\"v1:\",v1)\nprint (\"v+v1:\", v+v1)\nprint(\"v:\",v)\nprint (\"v1:\",v1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"v1+5:\",v1 + 5)\nprint('v1+\"is a vector\":',v1 + \"is a vector\")\nprint('v1+True:',v1 + True)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#print(5+v1)\n#print(\"This is a vector:\"+v1)\n#print(True+v1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def VectorAccess(self,item):\n    res=None\n    vec = (self.x,self.y,self.z)\n    vecD = {\"x\":self.x, \"y\":self.y, \"z\":self.z}\n    if type(item)== int and -3 <= item < 3:\n        res= vec[item]\n    elif type(item) == str and item in tuple(\"xyz\"):\n        res= vecD[item]\n    return res\n\nVector.__getitem__ = VectorAccess\n\n        ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(v)\nprint(v[1])\nprint(v[8])\nprint(v[-3])\nprint(v[-7])\nprint(v[\"xy\"])\nprint(v[\"y\"])\nprint(v[\"z\"])\nprint(v[False])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"v1[2] = 100","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Short hop back to Iterables and iteration\nWe remember that there are some objects such as **strings** and **lists** that we can iterate over using `for` loops. We can also manually iterate over these object thanks to their `__iter__()` and `__next__()` functions. The `__iter__()` function returns an iterator object that implements the `__next__()` function, which allows iteration."},{"metadata":{"trusted":true},"cell_type":"code","source":"magicList = [1,1,2,3,5,8,13,21,34,55,89]\niterator = iter(magicList)\nprint(iterator)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(next(iterator))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(next(iterator))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(next(iterator))\nprint(next(iterator))\nprint(next(iterator))\nprint(next(iterator))\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(next(iterator))\nprint(next(iterator))\nprint(next(iterator))\nprint(next(iterator))\nprint(next(iterator))\nprint(next(iterator))\nprint(next(iterator))\nprint(next(iterator))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"*Note: when the iterator runs out of values, the **StopIteration** Exception is raised.*"},{"metadata":{},"cell_type":"markdown","source":"### We can make our class iterable by implementing the magic function `__iter__()`"},{"metadata":{"trusted":true},"cell_type":"code","source":"def VectorIter(self):\n    iterableVector = (self.x,self.y,self.z)\n    return iter(iterableVector)\nVector.__iter__ = VectorIter","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(v)\nfor i in v:\n    print(i)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"*In the above example, we do not create our own interable object, but rely on the tuple object's iteratation functionality*"},{"metadata":{"trusted":true},"cell_type":"code","source":"v2 = Vector(1,2,3)\nv3 = Vector(1,2,3)\nprint(\"Is v2 equal to v3?\",v2 == v3)\nprint(\"Is v2 equal to v2?\",v2 == v2)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def VectorEquals(self,other):\n    if type(other) != Vector:\n        return False\n    for i,c in enumerate(self):\n        if c != other[i]:\n            return False\n    return True\nVector.__eq__ = VectorEquals","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"Is v2 equal to v3?\",v2 == v3)\nprint(\"Is v2 equal to v2?\",v2 == v2)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"v4 = (3,2,1)\nprint(\"Is v2 equal to v4?\",v2 == v4)\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.7.8","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":4}