{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Introduction to Python programming (Part 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Based on \"Introduction to Python programming\" by J.R. Johansson (CC-BY).\n", "\n", "Original available at [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Modules" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Most of the functionality in Python is provided by _modules_. The Python standard library is a large collection of modules that provide many functions such as file input/output, character processing and network communication." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To use a module in Python, it must first be imported. A module can be imported with the `import` instruction. For example, to import the module `math` (contains many standard mathematical functions):" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This imports the entire module:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Alternative: Import all symbols into the global namespace (not recommended)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "However, this quickly becomes a mess if you import many modules and then different functions may overwrite each other. Therefore, importing with `import math` is recommended.\n", "\n", "Alternatively, only individual symbols can be imported:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inspecting modules" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `dir`-function lists all fields of a module." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "print(dir(math))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With the function `help` you can get a description of (almost) any function." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "help(math.sqrt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Other useful modules are `os`, `sys` und `re`. See http://docs.python.org/3/library/ for the documentation." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Math related modules" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Problem: Floating point is not exact because certain numbers cannot be represented using a finite sum of powers of 2." ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.30000000000000004" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "0.1 + 0.2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Decimal\n", "\n", "If you need decimal digits with high accuracy use the ``Decimal`` type from the ``decimal`` module." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from decimal import Decimal" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Fractions\n", "\n", "If you want to work with accurate integer fractions, e.g. when working with proportions or probabilities, use the ``Fraction`` type from the ``fractions`` module." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from fractions import Fraction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Complex numbers\n", "\n", "The literal for complex numbers is ``j``, not ``i``." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "z = 2 + 1j" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Complex math is available in the ``cmath`` module." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import cmath" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Algorithms\n", "\n", "### Definition (according to Wikipedia)\n", "\n", "- Describes a general rule for solving a problem or a class of problems\n", "- Consists of a finite number of well-defined individual steps\n", "- Can be implemented in a computer program\n", "- A certain input results in a certain output\n", "\n", "### Definition (visual)\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Functions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A function in Python is defined using the keyword `def`, followed by a function name, a signature within parentheses `()`, and a colon `:`. The following code, with one additional level of indentation, is the function body." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Optionally, but highly recommended, you can define a so called \"docstring\", which is a description of the functions purpose and behaivor. The docstring should follow directly after the function definition, before the code in the function body." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Functions that returns a value use the `return` keyword:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can return multiple values from a function using tuples:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Example: Fibonacci Sequence\n", "\n", "The Fibonacci sequence starts with ``[1, 1]`` and the next number is always the sum of the last element and its predecessor.\n", "\n", "One step later the list is ``[1, 1, 2]``, then ``[1, 1, 2, 3]``, etc." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## ``while``-Loop" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A ``while`` loop is executed until the loop condition is false." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This program checks in a loop whether the numbers are even or odd:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Euclidian Algorithm\n", "\n", "Calculates the greatest common divisor (gcd).\n", "\n", "This works by substracting the smaller from the larger number until the result is 0." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Operations on lists using ``for`` loops\n", "\n", "Typical operations on lists are:\n", "\n", "* Transforming list elements\n", "* Filtering list elements\n", "\n", "This is possible, for example, with a ``for`` loop. However, using a ``for`` loop for this is not typical in Python. We will look at how to do it in a better way later." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Example (Function ``count_num``)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Example (Function ``count_even``)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Example (Function ``inc_one``)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Example (Function ``count_num``)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Lambda functions\n", "\n", "Lambda functions are \"anonymous functions\", i.e. functions without a function name. The term lambda has historical reasons: Lambda functions were first used in computer science in the so-called lambda calculus.\n", "\n", "In Python, ``lambda`` corresponds to a function that can contain one statement and the return is implicit." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Example (Function ``add``)\n", "\n", "The function ``add`` accepts two arguments and returns there sum.\n", "\n", "Shown are a function and a lambda function. Both are equivalent." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Transforming lists in a pythonic way\n", "\n", "The common ways to operate on lists in Python are:\n", "\n", "* List Comprehensions\n", "* Function ``map``\n", "* Function ``filter``\n", "\n", "List Comprehensions are directly evaluated. No call to ``list`` is necessary.\n", "\n", "``map`` and ``filter`` however return a generator which can only be used in a loop (or evaluation into a list with ``list()``)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Comprehensions and ``map``\n", "\n", "``map`` accepts two arguments:\n", "\n", "* A (lambda) function which accepts one parameter: The particular list element is passed here.\n", "* The list (and of course generators etc.).\n", "\n", "The function returns the new list." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Equivalent to this are List Comprehensions. The inventor of Python finds this the correct way to work with lists.\n", "\n", "It was planned to remove the ``map`` function (and also ``filter``) from Python but there was too much protest from other developers.\n", "\n", "The syntax is:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[ Output expression  for item in list ]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Filtering lists with comprehensions and ``filter``\n", "\n", "``filter`` accepts two arguments:\n", "\n", "* A (lambda) function which accepts one parameter: The respective list element is passed here.\n", "* The list (and of course generators etc.).\n", "\n", "If the lambda function returns a truth value (``True``), the element is part of the new list, otherwise it is removed.\n", "\n", "But first how to filter lists with ``for`` and ``if``. This is rather cumbersome:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Much more elegant is the ``filter``:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Or the pythonic way: An ``if`` statement in a list comprehension." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[ Output expression  for item in list  if condition ]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bonus: The filtering comprehension can be transformed directly. This is not possible with ``filter`` directly. A call to ``map`` is required afterwards." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The function ``zip``\n", "\n", "``zip(liste1, liste2, ..., listen)`` returns a new _generator_ consisting of the 1st element of each list, then the 2nd element of each list, and so on." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "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.9.2" } }, "nbformat": 4, "nbformat_minor": 4 }