Python_basics.ipynb

{
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.10.0",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat_minor": 0,
  "nbformat": 4,
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/OJB-Quantum/Notebooks/blob/main/Python_basics.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Python basics\n",
        "\n",
        "The purpose of this tutorial is to introduce some basic Python syntax, which can help understand simulations."
      ],
      "metadata": {
        "editable": true,
        "tags": [],
        "id": "XCsNNQPE1tuT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To install desired single or multiple compatible packages or libraries in the general environment, follow the command below and remove the hash symbol.\n",
        "\n",
        "Double-check the name of the package you are trying to install by going to PyPl: https://pypi.org"
      ],
      "metadata": {
        "id": "_Avj5Y0c4HWv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# !pip install <name of 1st package> <name of 2nd package> <name of 3rd package>"
      ],
      "metadata": {
        "id": "dWxe2KaQ4gTS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Variables\n",
        "Variables (such as the object with name `a` in the examples below) are created through assignment of a value. We can check the type of the variable using the `type()` function:"
      ],
      "metadata": {
        "id": "6TkYr9CE1tuX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 10\n",
        "type(a)"
      ],
      "metadata": {
        "id": "rihDfizy1tuY",
        "outputId": "8ae6ccae-3e22-4633-975f-c04238879216"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 1,
          "output_type": "execute_result",
          "data": {
            "text/plain": "int"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 3.14  # decimal point present makes this a float type\n",
        "type(a)"
      ],
      "metadata": {
        "id": "uHGn3GP91tua",
        "outputId": "86cedb33-eec4-4b31-de1c-f08f94ffed6d"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 2,
          "output_type": "execute_result",
          "data": {
            "text/plain": "float"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 'Python'  # single or double quotes define a string\n",
        "type(a)"
      ],
      "metadata": {
        "id": "wtnVFthV1tua",
        "outputId": "4c7656d8-217c-4261-a61f-94707b6003dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 3,
          "output_type": "execute_result",
          "data": {
            "text/plain": "str"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = (1, 2, 3)  # tuple: round brackets\n",
        "type(a)"
      ],
      "metadata": {
        "id": "bRwEoJRC1tub",
        "outputId": "d9c87c08-763d-42cb-d26b-6fc281b4759e"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 4,
          "output_type": "execute_result",
          "data": {
            "text/plain": "tuple"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = ['a', 2, 3.14]  # list: square brackets\n",
        "type(a)"
      ],
      "metadata": {
        "id": "Nte6nyx_1tub",
        "outputId": "28c9f4e8-d580-4eb5-aaab-0c3989f29302"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 5,
          "output_type": "execute_result",
          "data": {
            "text/plain": "list"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Large/small values, e.g. $a = 2.1 \\times 10^{6}$"
      ],
      "metadata": {
        "id": "pet5vfgd1tub"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 2.1e-6\n",
        "a"
      ],
      "metadata": {
        "id": "j7Y7Jycl1tuc",
        "outputId": "facdb234-e5fb-44ad-db09-6db55079bced"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 6,
          "output_type": "execute_result",
          "data": {
            "text/plain": "2.1e-06"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Basic arithmetic operations\n",
        "\n",
        "#### 1. Addition $c = a + b$"
      ],
      "metadata": {
        "id": "kYgrMcH-1tuc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 10\n",
        "b = 3\n",
        "c = a + b"
      ],
      "metadata": {
        "id": "ZsxRaHcN1tuc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To inspect an object, we can just type its name if it is in the last line of a notebook cell:"
      ],
      "metadata": {
        "id": "C24hHKm81tud"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "c"
      ],
      "metadata": {
        "id": "TJS1TWpC1tud",
        "outputId": "5f922741-ac82-4fec-bb6f-60fac6d52ba8"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 8,
          "output_type": "execute_result",
          "data": {
            "text/plain": "13"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `print()` function can be used to send information to the standard output (typically the display):"
      ],
      "metadata": {
        "id": "XEUwD8tb1tue"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('The value of c is:', c)"
      ],
      "metadata": {
        "id": "KHFKivwF1tue",
        "outputId": "22190ac1-e2b6-409c-9c46-71d22452a20a"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "The value of c is: 13\n"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 2. Subtraction: $a - b$"
      ],
      "metadata": {
        "id": "wwejSYVy1tue"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a - b"
      ],
      "metadata": {
        "id": "bhSDZSMA1tue",
        "outputId": "58b33fd1-5671-46e5-e0a8-95e6e3b25e1b"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 10,
          "output_type": "execute_result",
          "data": {
            "text/plain": "7"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 3. Multiplication: $a \\times b$"
      ],
      "metadata": {
        "id": "Ij4dhkol1tuf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a * b"
      ],
      "metadata": {
        "id": "SytK16rP1tuf",
        "outputId": "d385f21a-cbb9-43de-fc7c-328be8655341"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 11,
          "output_type": "execute_result",
          "data": {
            "text/plain": "30"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 4. Division: $a / b$"
      ],
      "metadata": {
        "id": "cM7N5oBy1tuf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a / b"
      ],
      "metadata": {
        "id": "FcG2mX701tuf",
        "outputId": "b973239d-df6e-408f-a42f-dc20df94a76d"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 12,
          "output_type": "execute_result",
          "data": {
            "text/plain": "3.3333333333333335"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In Python 3, if we divide two `int` variables, we are going to get `float`:"
      ],
      "metadata": {
        "id": "Z0c5J4JX1tuf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "5/2"
      ],
      "metadata": {
        "id": "FHt5VT-i1tuf",
        "outputId": "6d2111b4-5c02-44d1-fd26-de073def6d2f"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 13,
          "output_type": "execute_result",
          "data": {
            "text/plain": "2.5"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 5. Power $a^{b}$"
      ],
      "metadata": {
        "id": "UOJ5YwBZ1tuf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 5\n",
        "b = 3\n",
        "a ** b  # Common mistake to write a^b"
      ],
      "metadata": {
        "id": "BJR5HLkX1tuf",
        "outputId": "f121f7cf-2381-4fc0-ecad-41f4c20a8161"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 14,
          "output_type": "execute_result",
          "data": {
            "text/plain": "125"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 6. More complicated operations\n",
        "\n",
        "Other \"more complicated\" operations generally live in `math` or `numpy`. Before `math` can be used, it must be imported."
      ],
      "metadata": {
        "id": "TbEN33Yd1tug"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math"
      ],
      "metadata": {
        "id": "bGjtdemx1tug"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "All functions living in `math` or any other module, can be accessed using `.` operator."
      ],
      "metadata": {
        "id": "5X8fsEri1tug"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "theta = 3.14159  # theta is approximately pi\n",
        "math.sin(theta)"
      ],
      "metadata": {
        "tags": [
          "nbval-ignore-output"
        ],
        "id": "sp4wfHT41tug",
        "outputId": "3a1e18fe-d85b-4d10-a283-312d1c19dc96"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 16,
          "output_type": "execute_result",
          "data": {
            "text/plain": "2.65358979335273e-06"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "math.cos(theta)"
      ],
      "metadata": {
        "id": "JIC9pfSS1tug",
        "outputId": "cd20bd1e-5e23-48e4-ba39-ca10331f9d67"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 17,
          "output_type": "execute_result",
          "data": {
            "text/plain": "-0.9999999999964793"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "math.sin(math.pi/2)"
      ],
      "metadata": {
        "id": "-uDbeVzj1tuh",
        "outputId": "4acc2118-dc1f-4f86-c0b0-95fecd2074de"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 18,
          "output_type": "execute_result",
          "data": {
            "text/plain": "1.0"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 10\n",
        "math.log10(a)"
      ],
      "metadata": {
        "id": "JdHRmtcs1tuh",
        "outputId": "a6cad7ef-b0fd-4735-c23f-b4c1851ae7b8"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 19,
          "output_type": "execute_result",
          "data": {
            "text/plain": "1.0"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "math.log(math.e)  # natural log"
      ],
      "metadata": {
        "id": "icLrcpqm1tuh",
        "outputId": "66e1f199-acbb-486c-cc2b-311e1827f71e"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 20,
          "output_type": "execute_result",
          "data": {
            "text/plain": "1.0"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Sequences: lists and tuples\n",
        "\n",
        "A collection of values can be represented using lists and tuples."
      ],
      "metadata": {
        "id": "S3BCPZ3z1tuh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3, 5.1e4]  # list -> square bracket\n",
        "a"
      ],
      "metadata": {
        "id": "S-pwAvxm1tuh",
        "outputId": "4967dc5e-bc84-435b-fe42-6c81830eede8"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 21,
          "output_type": "execute_result",
          "data": {
            "text/plain": "[1, 2, 3, 51000.0]"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b = (1, 2, 3, 5.1e4)  # tuple -> round bracket\n",
        "b"
      ],
      "metadata": {
        "id": "D03EBjry1tuh",
        "outputId": "28b122e2-0dc7-4f86-98c5-372b5f6a4fb3"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 22,
          "output_type": "execute_result",
          "data": {
            "text/plain": "(1, 2, 3, 51000.0)"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Indexing"
      ],
      "metadata": {
        "id": "uITff4R_1tuh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a[0]  # the first element"
      ],
      "metadata": {
        "id": "CkEoqK0_1tui",
        "outputId": "cbf65a87-5afc-44af-ec47-c05c0e27a325"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 23,
          "output_type": "execute_result",
          "data": {
            "text/plain": "1"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a[0] = 5\n",
        "a"
      ],
      "metadata": {
        "id": "A-roIhZZ1tui",
        "outputId": "fb148769-08b3-4001-be4f-f7086bd99f30"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 24,
          "output_type": "execute_result",
          "data": {
            "text/plain": "[5, 2, 3, 51000.0]"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b[3]  # the last element"
      ],
      "metadata": {
        "id": "X0fkx7nW1tur",
        "outputId": "c414d131-fb70-4e6e-9db2-454368edd1f0"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 25,
          "output_type": "execute_result",
          "data": {
            "text/plain": "51000.0"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Alternatively `-1` can be used as an index to get the last element"
      ],
      "metadata": {
        "id": "jxNIv_d51tur"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a[-1]"
      ],
      "metadata": {
        "id": "0ndnPw6f1tur",
        "outputId": "d6174757-57d9-475e-eec0-5a958e11302b"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 26,
          "output_type": "execute_result",
          "data": {
            "text/plain": "51000.0"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Length (the number of elements in a sequence)"
      ],
      "metadata": {
        "id": "YYfj30PF1tur"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "len(a)"
      ],
      "metadata": {
        "id": "UjQyWByP1tur",
        "outputId": "c2a48230-2ee2-4732-ddfa-0e2c43d4ddbc"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 27,
          "output_type": "execute_result",
          "data": {
            "text/plain": "4"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(b)"
      ],
      "metadata": {
        "id": "Lb8k_2n-1tur",
        "outputId": "ad5f5589-6485-4cbf-cb91-0189575ce6c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 28,
          "output_type": "execute_result",
          "data": {
            "text/plain": "4"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "What is the difference between list and tuple? Tuples are not mutable."
      ],
      "metadata": {
        "id": "m_hlReDG1tus"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "b[2] = 3"
      ],
      "metadata": {
        "tags": [
          "raises-exception"
        ],
        "id": "1WtJhNtU1tus",
        "outputId": "22fc5076-f268-4c2d-c010-760b64e3e1da"
      },
      "execution_count": null,
      "outputs": [
        {
          "ename": "TypeError",
          "evalue": "'tuple' object does not support item assignment",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "Cell \u001b[0;32mIn[29], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mb\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m3\u001b[39m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Unpacking\n",
        "\n",
        "If we have a point which is defined as a tuple and want to unpack the values into x, y, and z, we can write:"
      ],
      "metadata": {
        "id": "vLFB36L01tus"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "point = (-1, 2, 0)\n",
        "x = point[0]\n",
        "y = point[1]\n",
        "z = point[2]\n",
        "print(f'x={x}, y={y}, z={z}')"
      ],
      "metadata": {
        "id": "A2Vp-HII1tus",
        "outputId": "92c090b8-c817-4c76-9f16-98c05e2a9c4c"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "x=-1, y=2, z=0\n"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A more convenient way is:"
      ],
      "metadata": {
        "id": "gcYhac0Q1tus"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x, y, z = point\n",
        "print(f'x={x}, y={y}, z={z}')"
      ],
      "metadata": {
        "id": "R7Wo7qmC1tus",
        "outputId": "1d4fa467-cd8d-4b0e-bac8-9e123165f658"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "x=-1, y=2, z=0\n"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Adding an element to the list:"
      ],
      "metadata": {
        "id": "LHyU2Mko1tus"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a.append('new_element')\n",
        "a"
      ],
      "metadata": {
        "id": "zJQGUvCH1tus",
        "outputId": "f8c54808-9f6c-44a7-b20e-719f1922e761"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 32,
          "output_type": "execute_result",
          "data": {
            "text/plain": "[5, 2, 3, 51000.0, 'new_element']"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Sequences: numpy arrays\n",
        "\n",
        "Another sequence type that is used a lot in computational work is the `ndarray` type (n-dimensional array) from the `numpy` package. We can create a numpy array from other sequences, such as a list:"
      ],
      "metadata": {
        "id": "_vKQ1Vtw1tut"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np  # by convention `np` is used as the alias for numpy"
      ],
      "metadata": {
        "id": "tPjKKgRr1tut"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "c = np.array([5, 2, 10, 100])\n",
        "c"
      ],
      "metadata": {
        "id": "OZS5oTho1tut",
        "outputId": "b49a6892-91f1-4190-c586-0b314e15d3af"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 34,
          "output_type": "execute_result",
          "data": {
            "text/plain": "array([  5,   2,  10, 100])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(c)"
      ],
      "metadata": {
        "id": "C4pZD5eR1tut",
        "outputId": "66d4cf5b-72e6-49c6-8b50-839e9d92bf80"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 35,
          "output_type": "execute_result",
          "data": {
            "text/plain": "numpy.ndarray"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `ndarray` data type has been designed for numeric work. It is fast in execution and allows to carry out the same operation on all elements of the array at the same time:"
      ],
      "metadata": {
        "id": "7iAGV92q1tut"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "3*c"
      ],
      "metadata": {
        "id": "7NKJkaT61tuu",
        "outputId": "6018801b-552f-419a-f3e0-fd44ca3d2d86"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 36,
          "output_type": "execute_result",
          "data": {
            "text/plain": "array([ 15,   6,  30, 300])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.sqrt(c)  # element-wise square root"
      ],
      "metadata": {
        "id": "vTY-nk2z1tuu",
        "outputId": "47c8c3e8-e394-4004-fe08-cc4ce3b1109c"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 37,
          "output_type": "execute_result",
          "data": {
            "text/plain": "array([ 2.23606798,  1.41421356,  3.16227766, 10.        ])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "c.sum()"
      ],
      "metadata": {
        "id": "z-k-LAsa1tuu",
        "outputId": "2792b9e2-5269-493f-d6a0-f67e60f76e87"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 38,
          "output_type": "execute_result",
          "data": {
            "text/plain": "117"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The Ubermag modules, such as `discretisedfield`, often return numpy arrays."
      ],
      "metadata": {
        "id": "UWm8v9tN1tuu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Dictionaries\n",
        "\n",
        "Dictionaries map keys (such as `region1`) to values (such as `1e-12`):"
      ],
      "metadata": {
        "id": "6IKfG3N11tuu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d = {'region1': 1e-12, 'region797': 5e-11}\n",
        "d"
      ],
      "metadata": {
        "id": "ZWcJqFQw1tuu",
        "outputId": "0796820d-9f5b-4c2c-cab4-2e2880c361ba"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 39,
          "output_type": "execute_result",
          "data": {
            "text/plain": "{'region1': 1e-12, 'region797': 5e-11}"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Accessing an element in a dictionary"
      ],
      "metadata": {
        "id": "N9IV5_zF1tuv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d['region1']  # string in quotes"
      ],
      "metadata": {
        "id": "WKyEKnJP1tuv",
        "outputId": "3aaa6a1b-fa54-485e-da2d-8b4b1e628a88"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 40,
          "output_type": "execute_result",
          "data": {
            "text/plain": "1e-12"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conditional execution\n",
        "\n",
        "All lines belonging to one execution branch must be indented."
      ],
      "metadata": {
        "id": "zsOGUN5g1tuv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 5\n",
        "b = 4\n",
        "\n",
        "if a == 5 and b < 10:\n",
        "    # indented lines\n",
        "    print(\"I'm in!\")  # single and double quotes\n",
        "    a += 1  # a = a + 1\n",
        "\n",
        "a  # output the value"
      ],
      "metadata": {
        "id": "0LdzfPjp1tuv",
        "outputId": "cc17bdaa-3d11-4466-8302-65fb66fffb1f"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "I'm in!\n"
        },
        {
          "execution_count": 41,
          "output_type": "execute_result",
          "data": {
            "text/plain": "6"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if a == 10:\n",
        "    print('A')\n",
        "elif a <= 4:\n",
        "    print('B')\n",
        "else:\n",
        "    print('C')"
      ],
      "metadata": {
        "id": "XBPt2W_m1tuv",
        "outputId": "48be314d-a175-4926-b668-772d40be1b70"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "C\n"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Iteration"
      ],
      "metadata": {
        "id": "MZB8SCk01tuv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in [1, 2, 3, 5.1]:\n",
        "    print(i)"
      ],
      "metadata": {
        "id": "_zlJy6Al1tuv",
        "outputId": "fdde4c04-fc0d-455d-cc2a-2912c9fc8fd8"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "1\n2\n3\n5.1\n"
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = [0, 5, 9, 4]\n",
        "for i in range(len(a)):\n",
        "    print(f'{a[i]} + 1 = {a[i] + 1}')  # f-string"
      ],
      "metadata": {
        "id": "M6lRpuzh1tuv",
        "outputId": "7b85979d-1316-41d3-ba8e-64cba29b4504"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "0 + 1 = 1\n5 + 1 = 6\n9 + 1 = 10\n4 + 1 = 5\n"
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in a:\n",
        "    print(f'{i} + 1 = {i + 1}')"
      ],
      "metadata": {
        "id": "NrQBpj7o1tuw",
        "outputId": "23782ec9-0bd5-4fdf-bc2a-b6d53f0c5191"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "0 + 1 = 1\n5 + 1 = 6\n9 + 1 = 10\n4 + 1 = 5\n"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Functions"
      ],
      "metadata": {
        "id": "Bo_Y2Jwm1tuw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def area(a, b):\n",
        "    # indented\n",
        "    return a * b\n",
        "\n",
        "area(5, 2)"
      ],
      "metadata": {
        "id": "923Pl7Wf1tuw",
        "outputId": "dcffe754-66e1-45ad-91f7-a0d017177c29"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 46,
          "output_type": "execute_result",
          "data": {
            "text/plain": "10"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_of_elements(a):\n",
        "    s = 0\n",
        "    for i in a:\n",
        "        s = s + i\n",
        "\n",
        "    return s\n",
        "\n",
        "sum_of_elements([1, 2, 3])"
      ],
      "metadata": {
        "id": "IMykR05A1tuw",
        "outputId": "ed851e46-5122-49e1-c7a7-dec8b2a3cf04"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 47,
          "output_type": "execute_result",
          "data": {
            "text/plain": "6"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Default values for arguments"
      ],
      "metadata": {
        "id": "IsvhBHdk1tuw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def volume(a, b, c):\n",
        "    return a * b * c\n",
        "\n",
        "volume(1, 2, 3)"
      ],
      "metadata": {
        "id": "b5JQZ2fl1tuw",
        "outputId": "4cf74fd8-74f2-46c8-f350-c64c2a331f9f"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 48,
          "output_type": "execute_result",
          "data": {
            "text/plain": "6"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def volume(a, b=2, c=3):\n",
        "    return a * b * c\n",
        "\n",
        "volume(1)"
      ],
      "metadata": {
        "id": "xUeLJiRb1tuw",
        "outputId": "3f9fd958-d5ee-49f2-8809-7427f66bf8be"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 49,
          "output_type": "execute_result",
          "data": {
            "text/plain": "6"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Accessing modules through `import`"
      ],
      "metadata": {
        "id": "FEY9Eqf51tuw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy\n",
        "\n",
        "numpy.pi"
      ],
      "metadata": {
        "id": "zQPSC7a71tux",
        "outputId": "6f4fe524-5066-474b-bdfc-cb7ad81211e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 50,
          "output_type": "execute_result",
          "data": {
            "text/plain": "3.141592653589793"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Often we specify an alias"
      ],
      "metadata": {
        "id": "7mLwzunQ1tux"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "np.pi"
      ],
      "metadata": {
        "id": "mecz6C-O1tux",
        "outputId": "dc07e1c6-b581-4c8f-dd3f-ce2e746cde70"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 51,
          "output_type": "execute_result",
          "data": {
            "text/plain": "3.141592653589793"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Common mistakes\n",
        "\n",
        "#### 1. No colon"
      ],
      "metadata": {
        "id": "f2-mPuc31tux"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def speed(s, t)\n",
        "    return s/t"
      ],
      "metadata": {
        "editable": true,
        "tags": [
          "raises-exception",
          "nbval-ignore-output"
        ],
        "id": "NS66DRtv1tux",
        "outputId": "38356899-5f55-41e8-c6ca-4603720be0ef"
      },
      "execution_count": null,
      "outputs": [
        {
          "ename": "SyntaxError",
          "evalue": "expected ':' (1951381238.py, line 1)",
          "output_type": "error",
          "traceback": [
            "\u001b[0;36m  Cell \u001b[0;32mIn[52], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m    def speed(s, t)\u001b[0m\n\u001b[0m                   ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m expected ':'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 2. Lack of indentation"
      ],
      "metadata": {
        "id": "fyhYlA7f1tux"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def speed(s, t):\n",
        "return s/t"
      ],
      "metadata": {
        "editable": true,
        "tags": [
          "raises-exception",
          "nbval-ignore-output"
        ],
        "id": "2hnq7ILO1tux",
        "outputId": "5180cee6-ed62-4bdf-a4cb-e9cb34511fc0"
      },
      "execution_count": null,
      "outputs": [
        {
          "ename": "IndentationError",
          "evalue": "expected an indented block after function definition on line 1 (3863715070.py, line 2)",
          "output_type": "error",
          "traceback": [
            "\u001b[0;36m  Cell \u001b[0;32mIn[53], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m    return s/t\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block after function definition on line 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 3. Mixing incompatible types"
      ],
      "metadata": {
        "id": "uV9v57np1tux"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 10\n",
        "b = 'a'\n",
        "a + b"
      ],
      "metadata": {
        "tags": [
          "raises-exception"
        ],
        "id": "t6EGa3Wf1tuy",
        "outputId": "d14030c7-790c-4700-ec52-9730cc295d33"
      },
      "execution_count": null,
      "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)",
            "Cell \u001b[0;32mIn[54], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m a \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10\u001b[39m\n\u001b[1;32m      2\u001b[0m b \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m----> 3\u001b[0m \u001b[43ma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mb\u001b[49m\n",
            "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 4. Using an undefined variable"
      ],
      "metadata": {
        "id": "i8wO3lga1tuy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_var + 5"
      ],
      "metadata": {
        "tags": [
          "raises-exception"
        ],
        "id": "MqVUiouZ1tuy",
        "outputId": "f73041e7-e18e-4250-dba0-668de044e995"
      },
      "execution_count": null,
      "outputs": [
        {
          "ename": "NameError",
          "evalue": "name 'my_var' is not defined",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "Cell \u001b[0;32mIn[55], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mmy_var\u001b[49m \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m5\u001b[39m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'my_var' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 5. Module is not imported"
      ],
      "metadata": {
        "id": "fG3DznuG1tuy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import scipy\n",
        "scpy.fft.fft()  # typo: scpy instead of scipy"
      ],
      "metadata": {
        "tags": [
          "raises-exception"
        ],
        "id": "11wAwA8l1tuy",
        "outputId": "78598b04-85e3-4b16-c362-9fec1d3c51e3"
      },
      "execution_count": null,
      "outputs": [
        {
          "ename": "NameError",
          "evalue": "name 'scpy' is not defined",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "Cell \u001b[0;32mIn[56], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mscipy\u001b[39;00m \n\u001b[0;32m----> 2\u001b[0m \u001b[43mscpy\u001b[49m\u001b[38;5;241m.\u001b[39mfft\u001b[38;5;241m.\u001b[39mfft()  \u001b[38;5;66;03m# typo: scpy instead of scipy\u001b[39;00m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'scpy' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Object oriented programming basics\n",
        "\n",
        "In Python, everything is an object. Each object contains attributes and methods (functions). When we define an object, using `.` we can access its different methods. For instance, if we define a string:"
      ],
      "metadata": {
        "id": "qfCE61AK1tuy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_object = \"Ubermag\""
      ],
      "metadata": {
        "id": "CMOeO7uw1tuy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we can access some of its methods:"
      ],
      "metadata": {
        "id": "FyRGKzBO1tuy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_object.lower()"
      ],
      "metadata": {
        "id": "hiHLlbb31tuy",
        "outputId": "eabc8cbe-e176-4921-a91d-7a81dcea08b4"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 58,
          "output_type": "execute_result",
          "data": {
            "text/plain": "'ubermag'"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can see all methods and attributes of an object using the `dir()` function:"
      ],
      "metadata": {
        "id": "USL9v_jZ1tuy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Getting help\n",
        "\n",
        "In Jupyter notebooks, it is often enough to append a question mark to the function name:"
      ],
      "metadata": {
        "id": "gJJAiz261tuy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "math.sqrt?"
      ],
      "metadata": {
        "tags": [
          "nbval-ignore-output"
        ],
        "id": "S1klPf791tuz",
        "outputId": "84ae36de-74e4-4da3-bbca-a34624e53634"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "\u001b[0;31mSignature:\u001b[0m \u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\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[0;31mDocstring:\u001b[0m Return the square root of x.\n\u001b[0;31mType:\u001b[0m      builtin_function_or_method"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Alternatively, use the `help()` function to get more information about an object or method:"
      ],
      "metadata": {
        "id": "qnpekGbh1tuz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "help(math.sqrt)"
      ],
      "metadata": {
        "id": "cM77n_C31tuz",
        "outputId": "6c239a9b-2fe0-4e20-d743-cdfd051971a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "Help on built-in function sqrt in module math:\n\nsqrt(x, /)\n    Return the square root of x.\n\n"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Further reading\n",
        "\n",
        "- A more detailed [Introduction to Python for scientists and engineers is available](https://github.com/fangohr/introduction-to-python-for-computational-science-and-engineering/blob/master/Readme.md)\n",
        "\n",
        "- More generic documentation and tutorials can be found on the Python home page at https://www.python.org/"
      ],
      "metadata": {
        "id": "DX-Oii-x1tuz"
      }
    }
  ]
}