learn-python-challenge-day-2.ipynb

{"cells":[{"metadata":{"_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5"},"cell_type":"markdown","source":"Welcome to day 2 of the Learn Python challenge! If you missed day 1, you can find the notebook [here](https://www.kaggle.com/colinmorris/learn-python-challenge-day-1/notebook). \n\nToday we'll be talking about functions: calling them, defining them, and looking them up using Python's built-in documentation.\n\nIn some languages, functions must be defined to always take a specific number of arguments, each having a particular type. Python functions are allowed much more flexibility. The `print` function is a good example of this:"},{"metadata":{"_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","trusted":true,"collapsed":true},"cell_type":"code","source":"print(\"The print function takes an input and prints it to the screen.\")\nprint(\"Each call to print starts on a new line.\")\nprint(\"You'll often call print with strings, but you can pass any kind of value. For example, a number:\")\nprint(2 + 2)\nprint(\"If print is called with multiple arguments...\", \"it joins them\",\n      \"(with spaces in between)\", \"before printing.\")\nprint('But', 'this', 'is', 'configurable', sep='!...')\nprint()\nprint(\"^^^ print can also be called with no arguments to print a blank line.\")","execution_count":1,"outputs":[]},{"metadata":{"_cell_guid":"13251958-f312-4629-b3a3-8a3d2a06143c","_uuid":"eec656fef8ff3c5ff6240f5a882429e85b5b4ef9"},"cell_type":"markdown","source":"## \"What does this function do again?\"\n\nI showed the `abs` function in the previous lesson, but what if you've forgotten what it does?\n\nThe `help()` function is possibly the most important Python function you can learn. If you can remember how to use `help()`, you hold the key to understanding just about any other function in Python."},{"metadata":{"_cell_guid":"e0a853f2-f559-436e-b901-f2adfb3ce081","_uuid":"97dde3ddd6ca6a1d084ceaba95582e89bb1c5ab9","trusted":true,"collapsed":true},"cell_type":"code","source":"help(abs)","execution_count":2,"outputs":[]},{"metadata":{"_cell_guid":"6739d23d-7a4c-4d97-93e1-6e42ac04c2ea","_uuid":"9448bd24dc4a2fd9c24d063bf9e74d78104a303c"},"cell_type":"markdown","source":"When applied to a function, `help()` displays...\n\n- the header of that function `abs(x, /)`. In this case, this tells us that `abs()` takes a single argument `x`. (The forward slash isn't important, but if you're curious, you can read about it [here](https://stackoverflow.com/questions/24735311/python-what-does-the-slash-mean-in-the-output-of-helprange))\n- A brief English description of what the function does."},{"metadata":{"_cell_guid":"e3494845-ed4e-4f3d-bbf2-9a54b2a56136","_uuid":"8569f5cd1f858dc0d08a91dc686058f165332e46"},"cell_type":"markdown","source":"**Common pitfall:** when you're looking up a function, remember to pass in the name of the function itself, and not the result of calling that function. \n\nWhat happens if we invoke help on a *call* to the function `abs()`? Unhide the output of the cell below to see."},{"metadata":{"_cell_guid":"9e677d50-b52e-449e-aa9f-11bd85ed38ff","_kg_hide-output":true,"_uuid":"8a7434d908fc880984d1a4fffd96f1c69affa327","trusted":true,"collapsed":true},"cell_type":"code","source":"help(abs(-2))","execution_count":3,"outputs":[]},{"metadata":{"_cell_guid":"3d4a6049-05bb-4d04-ad8a-2470c0886b43","_uuid":"0358f71efdbfe050c2cc45f64b8371f8aa312b54"},"cell_type":"markdown","source":"Python evaluates an expression like this from the inside out. First it calculates the value of `abs(-2)`, then it provides help on whatever the value of that expression is.\n\n<small>(And it turns out to have a lot to say about integers! In Python, even something as simple-seeming as an integer is actually an object with a fair amount of internal complexity. After we talk later about objects, methods, and attributes in Python, the voluminous help output above will make more sense.)</small>\n\n`abs` is a very simple function with a short docstring. `help` shines even more when dealing with more complex, configurable functions like `print`:"},{"metadata":{"trusted":true,"_uuid":"e2e8b14a9be7f5bec8968260799f5cab77767c9c","collapsed":true},"cell_type":"code","source":"help(print)","execution_count":4,"outputs":[]},{"metadata":{"_uuid":"b572fc9f113acdc2987f0edc6d06abbf43c85c9b"},"cell_type":"markdown","source":"Some of this might look inscrutable for now (what's `sys.stdout`?), but this docstring does shed some light on that `sep` parameter we used in one of our `print` examples at the beginning. "},{"metadata":{"_cell_guid":"7f816bb5-6007-4b54-9621-e187080cd193","_uuid":"ca3bcd824bf29325e403c26c882a02e133c96fb8"},"cell_type":"markdown","source":"## Defining functions\n\nBuiltin functions are great, but we can only get so far with them before we need to start defining our own functions. Below is a simple example."},{"metadata":{"_cell_guid":"5ba23af7-e8f9-43c3-bebb-0f64f5cbb703","_uuid":"b1c2595d8d4d13c06f21bba81b67258f66dddf15","trusted":true,"collapsed":true},"cell_type":"code","source":"def least_difference(a, b, c):\n    diff1 = abs(a - b)\n    diff2 = abs(b - c)\n    diff3 = abs(a - c)\n    return min(diff1, diff2, diff3)","execution_count":5,"outputs":[]},{"metadata":{"_cell_guid":"e9bb125b-ab88-451b-93c0-0a1ddb4bfade","_uuid":"4e38b53e5d82eccdffc825e9c02bfca87167fcfe"},"cell_type":"markdown","source":"This creates a function called `least_difference`, which takes three arguments, `a`, `b`, and `c`.\n\nFunctions start with a header introduced by the `def` keyword. The indented block of code following the `:` is run when the function is called.\n\n`return` is another keyword uniquely associated with functions. When Python encounters a `return` statement, it exits the function immediately, and passes the value on the right hand side to the calling context.\n\nIs it clear what `least_difference()` does from the source code? If we're not sure, we can always try it out on a few examples:"},{"metadata":{"_cell_guid":"1ffc23f1-271b-48d0-9d2c-c5ee8a569179","_uuid":"0dde36107ec44e5815041a071b287b3feda9d183","trusted":true,"collapsed":true},"cell_type":"code","source":"print(\n    least_difference(1, 10, 100),\n    least_difference(1, 10, 10),\n    least_difference(5, 6, 7), # Python allows trailing commas in argument lists. How nice is that?\n)","execution_count":6,"outputs":[]},{"metadata":{"_cell_guid":"d02b1f3a-07f8-4c6a-ac8c-03c209acfb6b","_uuid":"7c162c43132cbadc11e4d339d3006f0ffe2e4cdd"},"cell_type":"markdown","source":"Or maybe the `help()` function can tell us something about it."},{"metadata":{"_cell_guid":"ef38429f-8fb5-4de0-97d5-1cdd5d3d2cb9","_uuid":"740e755d187ccead4ad28da9a3a285883e2d113b","trusted":true,"collapsed":true},"cell_type":"code","source":"help(least_difference)","execution_count":7,"outputs":[]},{"metadata":{"_cell_guid":"47c5185b-db5b-4cd5-a713-9cf9796279da","_uuid":"fd1182b43ca6d2d17235fe7b15c97508b3689c48"},"cell_type":"markdown","source":"Unsurprisingly, Python isn't smart enough to read my code and turn it into a nice English description. However, when I write a function, I can provide a description in what's called the **docstring**.\n\n### Docstrings"},{"metadata":{"_cell_guid":"27c3a2f3-0ca2-44dd-9a40-47000a787cbb","_uuid":"0b3385e3965b7abc3466c5cf9122271d7e9d6171","trusted":true,"collapsed":true},"cell_type":"code","source":"def least_difference(a, b, c):\n    \"\"\"Return the smallest difference between any two numbers\n    among a, b and c.\n    \n    >>> least_difference(1, 5, -5)\n    4\n    \"\"\"\n    diff1 = abs(a - b)\n    diff2 = abs(b - c)\n    diff3 = abs(a - c)\n    return min(diff1, diff2, diff3)","execution_count":8,"outputs":[]},{"metadata":{"_cell_guid":"bd3bf80c-543a-448e-9c48-db9b9e6ade75","_uuid":"8488eeeaf06180b1739ce143e5220aa680a51f7a"},"cell_type":"markdown","source":"The docstring is a triple-quoted string (which may span multiple lines) that comes immediately after the header of a function. When we call `help()` on a function, it shows the docstring."},{"metadata":{"_cell_guid":"eb4e05c4-707f-47f1-b741-eb385c03a224","_uuid":"08a20d8a362d446128b5eb9def140ce2f51e3c6a","trusted":true,"collapsed":true},"cell_type":"code","source":"help(least_difference)","execution_count":9,"outputs":[]},{"metadata":{"_uuid":"f59ba61044b711bf48366d981844e478ac73a2c1"},"cell_type":"markdown","source":"> **Aside: example calls**\n> The last two lines of the docstring are an example function call and result. (The `>>>` is a reference to the command prompt used in Python interactive shells.) Python doesn't run the example call - it's just there for the benefit of the reader. The convention of including 1 or more example calls in a function's docstring is far from universally observed, but it can be very effective at helping someone understand your function. For a real-world example of, see [this docstring for the numpy function `np.eye`](https://github.com/numpy/numpy/blob/v1.14.2/numpy/lib/twodim_base.py#L140-L194)."},{"metadata":{"_cell_guid":"749d03e4-43bc-4d76-9376-1ae0e5a8d408","_uuid":"ccdff075cdad838050742679f6303ff6aab04a9a"},"cell_type":"markdown","source":"\n\nDocstrings are a nice way to document your code for others - or even for yourself. (How many times have you come back to some code you were working on a day ago and wondered \"what was I thinking?\")"},{"metadata":{"_cell_guid":"1251ce6e-4db3-4e46-99e5-bbae43020b4e","_uuid":"f1ac3cbbd8841bb44cf8c4af62c1ae60259d3ee4"},"cell_type":"markdown","source":"## Functions that don't return\n\nWhat would happen if we didn't include the `return` keyword in our function?"},{"metadata":{"_cell_guid":"76c92e58-9313-4224-87b2-7be29ab7cb60","_uuid":"73baa8c06bd6183ed319b19560cc09b2f58908ff","trusted":true,"collapsed":true},"cell_type":"code","source":"def least_difference(a, b, c):\n    \"\"\"Return the smallest difference between any two numbers\n    among a, b and c.\n    \"\"\"\n    diff1 = abs(a - b)\n    diff2 = abs(b - c)\n    diff3 = abs(a - c)\n    min(diff1, diff2, diff3)\n    \nprint(\n    least_difference(1, 10, 100),\n    least_difference(1, 10, 10),\n    least_difference(5, 6, 7),\n)","execution_count":10,"outputs":[]},{"metadata":{"_cell_guid":"ff5b411b-bbac-429e-83f6-49bc9184f322","_uuid":"f3a35afe9842d23be9d070d3e04724f683f7265a"},"cell_type":"markdown","source":"Python allows us to define such functions. The result of calling them is the special value `None`. (This is similar to the concept of \"null\" in other languages.)\n\nWithout a `return` statement, `least_difference` is completely pointless, but a function with side effects may do something useful without returning anything. We've already seen two examples of this: `print()` and `help()` don't return anything. We only call them for their side effects (putting some text on the screen). Other examples of useful side effects include writing to a file, or modifying an input."},{"metadata":{"_cell_guid":"b83da4c2-40a5-4f97-aec9-c090fe81ecba","_uuid":"b09cf01c4bf704fc48e289841f00909ed3171f5d","trusted":true,"collapsed":true},"cell_type":"code","source":"mystery = print()\nprint(mystery)","execution_count":11,"outputs":[]},{"metadata":{"_cell_guid":"8ef388f7-417b-4a06-839e-6157478719a3","_uuid":"5a2cb3b547290998e0e543427960579af7828ec6"},"cell_type":"markdown","source":"## Default arguments\n\nWhen we called `help(print)`, we saw that the `print` function has several optional arguments. For example, we can specify a value for `sep` to put some special string in between our printed arguments:"},{"metadata":{"trusted":true,"_uuid":"8f2bdaedda4fef17599a0ba85a40a8f3a96d29ca","collapsed":true},"cell_type":"code","source":"print(1, 2, 3, sep=' < ')","execution_count":12,"outputs":[]},{"metadata":{"_uuid":"623024773f0c569e3c4cd8dcf792666c101b1789"},"cell_type":"markdown","source":"But if we don't specify a value, `sep` is treated as having a default value of `' '` (a single space)."},{"metadata":{"trusted":true,"_uuid":"d2061e55c73086c999249b9f21374b0f1067e4d9","collapsed":true},"cell_type":"code","source":"print(1, 2, 3)","execution_count":13,"outputs":[]},{"metadata":{"_uuid":"faeb4763a14a08af8f4d3279073a0cbede3bf04d"},"cell_type":"markdown","source":"Adding optional arguments with default values to the functions we define turns out to be pretty easy:"},{"metadata":{"trusted":true,"_uuid":"98af588147ba255fe96be84965a0c89fb821ff6b","collapsed":true},"cell_type":"code","source":"def greet(who=\"Colin\"):\n    print(\"Hello,\", who)\n    \ngreet()\ngreet(who=\"Kaggle\")\n# (In this case, we don't need to specify the name of the argument, because it's unambiguous.)\ngreet(\"world\")","execution_count":14,"outputs":[]},{"metadata":{"_uuid":"c068cd98c8ca8cc9c41902ae1b97d2ffd463e0c0"},"cell_type":"markdown","source":"<!-- Mention that non-default args must come before default? -->\n\n## Functions are objects too"},{"metadata":{"trusted":true,"collapsed":true,"_uuid":"832ddb43884f177c07794afb489ed64babecddf5"},"cell_type":"code","source":"def f(n):\n    return n * 2\n\nx = 12.5","execution_count":15,"outputs":[]},{"metadata":{"_uuid":"03f2f9b254ea59cce2f6c8ecd234a7296a145f17"},"cell_type":"markdown","source":"The syntax for creating them may be different, but `f` and `x` in the code above aren't so fundamentally different. They're each variables that refer to objects. `x` refers to an object of type `float`, and `f` refers to an object of type... well, let's ask Python:"},{"metadata":{"trusted":true,"_uuid":"0a9dc4cfba49b584a8b6f1d98a14fd96fc26592d","collapsed":true},"cell_type":"code","source":"print(\n    type(x),\n    type(f), sep='\\n'\n)","execution_count":16,"outputs":[]},{"metadata":{"_uuid":"9e69d8ae51488c063d45b20c8abd62f622d7ceb5"},"cell_type":"markdown","source":"We can even ask Python to print `f` out:"},{"metadata":{"trusted":true,"_uuid":"1744219f227d551b20fed40371b1c06ef8058af6","collapsed":true},"cell_type":"code","source":"print(x)\nprint(f)","execution_count":17,"outputs":[]},{"metadata":{"_uuid":"0a00d0bcfc65a45e1bcdaa5bf9899b5adb1dfe8b"},"cell_type":"markdown","source":"...though what it shows isn't super useful.\n\nNotice that the code cells above have examples of functions (`type`, and `print`) taking *another function* as input. This opens up some interesting possibilities - we can *call* the function we receive as an argument."},{"metadata":{"trusted":true,"_uuid":"d6a9b7f3adbc14cfe10d911fb74f58532f03d067","collapsed":true},"cell_type":"code","source":"def call(fn, arg):\n    \"\"\"Call fn on arg\"\"\"\n    return fn(arg)\n\ndef squared_call(fn, arg):\n    \"\"\"Call fn on the result of calling fn on arg\"\"\"\n    return fn(fn(arg))\n\nprint(\n    call(f, 1),\n    squared_call(f, 1), \n    sep='\\n', # '\\n' is the newline character - it starts a new line\n)","execution_count":26,"outputs":[]},{"metadata":{"_uuid":"3bdbcbf5794c5b4ced9aa7a45fe3f51f203b742f"},"cell_type":"markdown","source":"You probably won't often define [higher order functions](https://en.wikipedia.org/wiki/Higher-order_function) like this yourself, but there are some existing ones (built in to Python and in libraries like pandas or numpy) that you might find useful to call. For example, `max`.\n\nBy default, `max` returns the largest of its arguments. But if we pass in a function using the optional `key` argument, it returns the argument `x` that maximizes `key(x)` (aka the 'argmax')."},{"metadata":{"trusted":true,"_uuid":"c2dbf680092d28cb4f13b4b0b52d4d8bddaa0780","collapsed":true},"cell_type":"code","source":"def mod_5(x):\n    \"\"\"Return the remainder of x after dividing by 5\"\"\"\n    return x % 5\n\nprint(\n    'Which number is biggest?',\n    max(100, 51, 14),\n    'Which number is the biggest modulo 5?',\n    max(100, 51, 14, key=mod_5),\n    sep='\\n',\n)","execution_count":19,"outputs":[]},{"metadata":{"_uuid":"1a33972fc677b6f9c1bd4e66278f9daa5f45b1fe"},"cell_type":"markdown","source":"### Lambda functions\n\nIf you're writing a short throwaway function whose body fits into a single line (like `mod_5` above), Python's `lambda` syntax is conveniently compact."},{"metadata":{"trusted":true,"_uuid":"f524e7cb50c44f5c810ffd2f70a86f195d57fe27","collapsed":true},"cell_type":"code","source":"mod_5 = lambda x: x % 5\n\n# Note that we don't use the \"return\" keyword above (it's implicit)\n# (The line below would produce a SyntaxError)\n#mod_5 = lambda x: return x % 5\n\nprint('101 mod 5 =', mod_5(101))","execution_count":20,"outputs":[]},{"metadata":{"trusted":true,"_uuid":"a9c9393b6132017aa057916114e89b5760834d6a","collapsed":true},"cell_type":"code","source":"# Lambdas can take multiple comma-separated arguments\nabs_diff = lambda a, b: abs(a-b)\nprint(\"Absolute difference of 5 and 7 is\", abs_diff(5, 7))","execution_count":21,"outputs":[]},{"metadata":{"trusted":true,"_uuid":"cb4061c92891fa8e824dc71d62b658f74c49cfd7","collapsed":true},"cell_type":"code","source":"# Or no arguments\nalways_32 = lambda: 32\nalways_32()","execution_count":22,"outputs":[]},{"metadata":{"_uuid":"5aeb6c37f540870196db9cca4f11eb605bbaef59"},"cell_type":"markdown","source":"With judicious use of lambdas, you can occasionally solve complex problems in a single line. "},{"metadata":{"trusted":true,"_uuid":"408aaa4c04e8a7cee693c5d578024706eed47b93","collapsed":true},"cell_type":"code","source":"# Preview of lists and strings. (We'll go in depth into both soon)\n# - len: return the length of a sequence (such as a string or list)\n# - sorted: return a sorted version of the given sequence (optional key \n#           function works similarly to max and min)\n# - s.lower() : return a lowercase version of string s\nnames = ['jacques', 'Ty', 'Mia', 'pui-wa']\nprint(\"Longest name is:\", max(names, key=lambda name: len(name))) # or just key=len\nprint(\"Names sorted case insensitive:\", sorted(names, key=lambda name: name.lower()))","execution_count":23,"outputs":[]},{"metadata":{"_cell_guid":"1db05b67-d0b6-4617-877b-83e6479ad787","_uuid":"ce043ef7d8c44cebac6ba2900664b1df7edca983"},"cell_type":"markdown","source":"## Your Turn\n\n<!-- [Click here to start the coding exercises for day 2!](https://www.kaggle.com/kernels/fork/934361) -->\n\nTo get started on the day 2 exercises, head over to [this notebook](https://www.kaggle.com/colinmorris/learn-python-challenge-day-2-exercises) and click the \"Fork Notebook\" button."},{"metadata":{"_cell_guid":"45165999-daf6-426c-81c2-7ee0a5012406","_uuid":"af99d081036fcec62bce858f19874171422ee79f"},"cell_type":"markdown","source":""}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.6.5","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":1}