Python_key_points_homework.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python key points homework",
      "provenance": [],
      "collapsed_sections": [
        "HG8uZJrln4kz",
        "TAmAx1ZDlXjT",
        "iqyBKVXmfHvn",
        "dvIWHnPdJT3w",
        "bbfroLuAnlce",
        "uRAvV9F1ouiV",
        "x7VLnpW3ywdE"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LphCkL_heC3f"
      },
      "source": [
        "# Homework: Python for machine learning and Data Analysis\n",
        "#### Here are listed the most common Python & NumPy methods used in the course, as well as usage examples. This sheet doesn't contain extensive information. Please refer to the documentation for details.\n",
        "\n",
        "\n",
        "Prepared by Mykhailo Vladymyrov,\n",
        "Science IT Support, University of Bern, 2023\n",
        "\n",
        "This work is licensed under <a href=\"https://creativecommons.org/share-your-work/public-domain/cc0/\">CC0</a>.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "When solving exercises, try not to use copypastig: by typing you reinforce your brain to learn better."
      ],
      "metadata": {
        "id": "9ywZ9QhN9QfQ"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HG8uZJrln4kz"
      },
      "source": [
        "# 0. List, tuple, set, dict"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# A `tuple` can contain any number of any element and can't be modified\n",
        "x_coordinates = (0, 1, 2, 3)\n",
        "\n",
        "#               ^ ---------^ tuple is written in normal brackets"
      ],
      "metadata": {
        "id": "_WoGFvYlej7w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# To see what any object is, it's a good idea to print it:\n",
        "print(x_coordinates)"
      ],
      "metadata": {
        "id": "B_0hJbH2e2NV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# or just:\n",
        "x_coordinates"
      ],
      "metadata": {
        "id": "YDUxG2tdfEUF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# As well as check it's type:\n",
        "type(x_coordinates)"
      ],
      "metadata": {
        "id": "rjRceVMWfG84"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# and available methods and properties\n",
        "dir(x_coordinates)"
      ],
      "metadata": {
        "id": "6JXaYnPhkHEK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# the `__doc__` property often contains useful info\n",
        "print(x_coordinates.__doc__)"
      ],
      "metadata": {
        "id": "85mENGBBkMcR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        " ---"
      ],
      "metadata": {
        "id": "8JqHksKLfY9l"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BP7PCSQsoAPQ"
      },
      "source": [
        "# Function len called on any collection — array like object — will return it's length\n",
        "\n",
        "x_coordinates_length = len(x_coordinates)\n",
        "print('length of the `x_coordinates` is', x_coordinates_length)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print('Also it is handy to use so-called f-strings (formatted string): they allow to easily format the output:')\n",
        "print(f'For example:\\n\\tlength of the `x_coordinates={x_coordinates}` is {x_coordinates_length}')\n",
        "\n",
        "#     ^------- f before string marks an f-string\n"
      ],
      "metadata": {
        "id": "3n-L1q4egLCS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# `list` is similar to `tuple`, but can be modified:\n",
        "\n",
        "y_coordinates = [1, 1, 4]\n",
        "\n",
        "#               ^ ---------^ list is written in square brackets"
      ],
      "metadata": {
        "id": "q2DFllByhrBz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ehJvl7fLoBtL"
      },
      "source": [
        "# One can loop through elements of a collection:\n",
        "\n",
        "for x in x_coordinates:\n",
        "  print (x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xn7tgZnAiZEW"
      },
      "source": [
        "# Or also obtain the index of the element:\n",
        "\n",
        "for idx, y in enumerate(y_coordinates):\n",
        "  print (f'y[{idx}] = {y}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "npPC3AIyng6e"
      },
      "source": [
        "# Several collections can be iterated together by zipping them:\n",
        "\n",
        "for x, y in zip(x_coordinates, y_coordinates):\n",
        "  print (x, y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Elements of the list can be modified:\n",
        "print(y_coordinates[0])\n",
        "y_coordinates[0] = 0\n",
        "print(y_coordinates[1])\n",
        "print(y_coordinates)"
      ],
      "metadata": {
        "id": "iP0ZE9KEjXXy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# `list` can be created from another collection:\n",
        "\n",
        "x_coordinates = list(x_coordinates)\n",
        "print(f'now `x_coordinates` is {type(x_coordinates)}')"
      ],
      "metadata": {
        "id": "KrK_a1e4lDAk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Elements can be appended to a list\n",
        "\n",
        "\n",
        "y_coordinates.append(9)\n",
        "print(y_coordinates)\n",
        "\n",
        "y_coordinates.append(16)\n",
        "print(y_coordinates)\n",
        "\n",
        "y_coordinates.append(25)\n",
        "print(y_coordinates)\n"
      ],
      "metadata": {
        "id": "aSIod_Rxk2aC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lVIWxE6FoDcm"
      },
      "source": [
        "# Extended with another list:\n",
        "x_coordinates.extend([4, 5])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# or added\n",
        "\n",
        "all_numbers = x_coordinates + y_coordinates\n",
        "print(all_numbers)"
      ],
      "metadata": {
        "id": "S00vbLWWlyeV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RIeE7l2Gpg1E"
      },
      "source": [
        "# `set` - is a collection of unique elements:\n",
        "unique_numbers = set(all_numbers)\n",
        "print(unique_numbers)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# `dictionary` is a collection where the values are assigned to unique keys and can be accessed by the key:\n",
        "\n",
        "uptime_hours = {'jupyter': 10, 'chrome': 30}"
      ],
      "metadata": {
        "id": "Va8RWA0vmdjL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(uptime_hours['jupyter'])"
      ],
      "metadata": {
        "id": "lDkXouaBoE6j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w2XKXUUrpkQU"
      },
      "source": [
        "# `list` comprehensions are a quick way to define a list:\n",
        "\n",
        "y_coordinates = [x**2 for x in x_coordinates]\n",
        "print(y_coordinates)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# `set`:\n",
        "values = {v%7 for v in y_coordinates}\n",
        "print(values)"
      ],
      "metadata": {
        "id": "OVGGeg_QodDc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# `dictionary`\n",
        "\n",
        "x_at_y = {y:x for x, y in zip(x_coordinates, y_coordinates)}\n",
        "print(x_at_y)\n",
        "print(x_at_y[25])"
      ],
      "metadata": {
        "id": "SRLIn6wQot8b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TAmAx1ZDlXjT"
      },
      "source": [
        "# 1. Pyplot"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "x_vlxByweeEE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x_coordinates = list(range(6))\n",
        "y_coordinates = [x**2 for x in x_coordinates]"
      ],
      "metadata": {
        "id": "1hOOzT0ZN3xO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Simple plot\n",
        "\n",
        "plt.plot(x_coordinates, y_coordinates)"
      ],
      "metadata": {
        "id": "o5Wqm89oOGu2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f0gwwI_ilrgQ"
      },
      "source": [
        "# Scatter plot\n",
        "plt.scatter(x_coordinates, y_coordinates, marker='x', color='b', s=10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Scatter plot with axes range\n",
        "plt.scatter(x_coordinates, y_coordinates, marker='x', color='b', s=10)\n",
        "plt.xlim(0, 10)\n",
        "plt.ylim(0, 10)"
      ],
      "metadata": {
        "id": "LFeRVBCARbQw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot with isotropic axes\n",
        "\n",
        "plt.scatter(x_coordinates, y_coordinates, marker='x', color='b', s=10)\n",
        "\n",
        "current_axis = plt.gca()\n",
        "current_axis.set_aspect('equal')"
      ],
      "metadata": {
        "id": "5mqZY6hFReu5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rtkv_YUolfld"
      },
      "source": [
        "# Big plot, with details\n",
        "\n",
        "plt.figure(figsize=(8,8))  # plot size\n",
        "\n",
        "plt.plot(x_coordinates, y_coordinates)\n",
        "\n",
        "plt.xlabel('x coordinate')\n",
        "plt.ylabel('y coordinate')\n",
        "plt.title('x=y^2')\n",
        "\n",
        "plt.show()\n",
        "plt.close()  # It is always a good idea to close the plot to save memory"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QY_T2HmRl9Mw"
      },
      "source": [
        "# Multiple plots can be combined with subplots:\n",
        "\n",
        "fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(8, 8))\n",
        "\n",
        "ax[0][0].scatter(x_coordinates, y_coordinates, marker='x', color='b', s=30)\n",
        "ax[0][1].scatter(x_coordinates, y_coordinates, marker='o', c=y_coordinates, s=30)\n",
        "\n",
        "ax[1][0].plot(x_coordinates, y_coordinates)\n",
        "ax[1][1].scatter(x_coordinates, y_coordinates, marker='^', c=y_coordinates, s=30, cmap=plt.cm.Accent)\n",
        "\n",
        "plt.show()\n",
        "plt.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0CKMn1PPmp9E"
      },
      "source": [
        "# To make a plot in 3D\n",
        "\n",
        "fig = plt.figure(figsize=(8,8))\n",
        "ax = fig.add_subplot(111, projection='3d')\n",
        "z_coordinates = y_coordinates\n",
        "\n",
        "ax.scatter3D(x_coordinates, y_coordinates, z_coordinates, marker='x', s=20)\n",
        "\n",
        "plt.show()\n",
        "plt.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iqyBKVXmfHvn"
      },
      "source": [
        "# 1. NumPy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SM4lpuQTZE8U"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# `numpy` arrays are similar to `list`s mutable containers with much richer functionality"
      ],
      "metadata": {
        "id": "FuSAC_PYql5-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rTNRdQvlpMAq"
      },
      "source": [
        "# Array-like objects can be converted to `numpy` array:\n",
        "arr = np.array(x_coordinates)\n",
        "print(arr)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tU2F9DBNpP9j"
      },
      "source": [
        "# Attribute `shape` shows the size of an array.\n",
        "print(arr.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Shape is a `tuple` because an array can have more than one dimension:\n",
        "\n",
        "arr2d = np.asarray([[1,2,3], [4, 5, 6]])\n",
        "print(arr2d)\n",
        "print(arr2d.shape)  # last element of the shape - most inner dimension of the array"
      ],
      "metadata": {
        "id": "bf0WtJruTCbY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Multidimensional array can be reshaped to different a shape, preserving the total number of elements and their order\n",
        "\n",
        "arr2d_r1 = arr2d.reshape((3, 2))\n",
        "print(arr2d_r1)"
      ],
      "metadata": {
        "id": "Pe5Rr_zeXCen"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# or turned into 1-d with flatten method:\n",
        "\n",
        "arr2d_1d = arr2d.flatten()\n",
        "print(arr2d_1d, arr2d_1d.shape)"
      ],
      "metadata": {
        "id": "KSD5HQ0dXYcC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "YS9oh2nuXjyT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Slicing of an array:\n",
        "# start:stop - elements from start (included) till stop (excluded)\n",
        "\n",
        "print(arr[1:3])"
      ],
      "metadata": {
        "id": "GTGugOCbToZE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Slicing of an array:\n",
        "# start:stop:step - elements from start (included) till stop (excluded) with stride step\n",
        "\n",
        "print(arr[1:6:2])"
      ],
      "metadata": {
        "id": "1-UMIkjlUKkT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Similarly for a multidimensional array:\n",
        "#\n",
        "print(arr2d[0:1, 1:3])"
      ],
      "metadata": {
        "id": "ezZWjdifUPlG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# `:` means take elements along the axis\n",
        "#\n",
        "print(arr2d[:, 1:3])"
      ],
      "metadata": {
        "id": "21yoWRYRUhdf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# To take elements over several sequential axes - use ellipsis (...):\n",
        "#\n",
        "print(arr2d[..., 1:3])"
      ],
      "metadata": {
        "id": "Lcp7R64EUrRU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# To generate sequential integers (similar to `range`):\n",
        "numbers = np.arange(0, 20, 2)\n",
        "print(numbers)"
      ],
      "metadata": {
        "id": "8xAcxvn4U9rm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# For floating point values\n",
        "\n",
        "x_coord = np.linspace(start=-1, stop=1, num=5)\n",
        "print (x_coord)"
      ],
      "metadata": {
        "id": "-Vjm0nkMVP6_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Operations on the numpy arrays can be performed in a pythonic way:\n",
        "\n",
        "y_coord = 2*x_coord**2 + 3\n",
        "\n",
        "plt.plot(x_coord, y_coord)\n",
        "plt.gca().set_aspect('equal')"
      ],
      "metadata": {
        "id": "XMa31sIQVl0L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "K52uOtJOncOJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# To generate uniformly distributed random numbers:\n",
        "rnd = np.random.uniform(0, 10, size=10)\n",
        "print(rnd)\n",
        "print(rnd.shape)"
      ],
      "metadata": {
        "id": "KR5RK_ExV7aB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# or normally distributed, 3D array:\n",
        "rnd = np.random.normal(loc=0.5, scale=2, size=(3, 4, 5))\n",
        "print(rnd)\n",
        "print(rnd.shape)"
      ],
      "metadata": {
        "id": "SdrRHq1tWRue"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's check distribution:\n",
        "plt.hist(rnd.flatten(), 10);"
      ],
      "metadata": {
        "id": "rZXXQ7joWtK1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xfx4gLbEmTZA"
      },
      "source": [
        "# Arrays statistics can be obtained like:\n",
        "print('array `rnd` mean = ', rnd.mean())\n",
        "print('array `rnd` standard deviation = ', rnd.std())\n",
        "print('array `rnd` minimum = ', rnd.min())\n",
        "print('array `rnd` maximum = ', rnd.max())\n",
        "print('array `rnd` maximum 40th percentile= ', np.percentile(rnd, 40))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# To get an element from a 1D array:\n",
        "print(np.random.choice(arr))"
      ],
      "metadata": {
        "id": "oVhGYgE6YJJS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# or several elements:\n",
        "mtx = np.random.choice(arr, size=(2,2))\n",
        "print(mtx)"
      ],
      "metadata": {
        "id": "04TaJO8RYaf1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e7WySajre_xb"
      },
      "source": [
        "# Matrix multiplication\n",
        "np.dot([1, 2], mtx)  # can be also written as [1, 2]@ mtx"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "SWxvCDPKnjIT"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KJ3npk1vmcwu"
      },
      "source": [
        "# Sometimes it's needed to obtain a grid of values, given a set of values along each axis,\n",
        "# e.g. for a grid search or visualization. `meshgrid` does it so\n",
        "\n",
        "\n",
        "# define set of values along x, y axes\n",
        "x_coords = np.linspace(0, 4.5, 10)      # 10 values between 0 and 45\n",
        "y_coords = np.linspace(-10, -5.5, 10)   # 10 values between -10 and -6.5\n",
        "\n",
        "# create the meshgrid\n",
        "meshgrid_x, meshgrid_y = np.meshgrid(x_coords, y_coords)\n",
        "print(meshgrid_x.shape, meshgrid_y.shape)  # all x, y coordinates of the mesh"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(meshgrid_x)"
      ],
      "metadata": {
        "id": "DSk3KARGc_Yu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(meshgrid_y)"
      ],
      "metadata": {
        "id": "EzqBiwAucs3H"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# To plot the points created by the meshgrid we need to flatten them:\n",
        "x_coordinates = meshgrid_x.flatten()\n",
        "y_coordinates = meshgrid_y.flatten()\n",
        "index = np.arange(len(x_coordinates))\n",
        "\n",
        "sc = plt.scatter(x_coordinates, y_coordinates, c=index, cmap=plt.cm.gist_earth)\n",
        "plt.colorbar(sc, ax=plt.gca())"
      ],
      "metadata": {
        "id": "o0xTiQl2cQ5k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "HW-Nw2FenYia"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Arrays can be concatenated along a specific axis, provided the other dimensions are same\n",
        "\n",
        "arr_1 = np.zeros(shape=(5, 3, 6))\n",
        "arr_2 = np.ones(shape=(5, 4, 6))\n",
        "\n",
        "print(arr_1.shape, arr_2.shape)\n",
        "#print(arr_1)\n",
        "#print(arr_2)"
      ],
      "metadata": {
        "id": "g--l6v-cj-pS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_PDW38NTmdza"
      },
      "source": [
        "arr_conc = np.concatenate((arr_1, arr_2), axis=1)\n",
        "\n",
        "print(arr_conc.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# stack along new last axis\n",
        "arr_stack = np.stack((arr_1, arr_2[:, :-1]), axis=-1)\n",
        "\n",
        "print(arr_stack.shape)"
      ],
      "metadata": {
        "id": "WXwDyLYjoOWg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Similarly to indexing one element, multiple elements of an array can be obtained\n",
        "y = np.arange(6)**2\n",
        "print(y)\n",
        "\n",
        "print(f'y[2] = {y[2]}')\n",
        "print(f'y[4] = {y[4]}')\n",
        "print(f'y[[2,4]] = {y[[2,4]]}')"
      ],
      "metadata": {
        "id": "OqkjxZxgpPti"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P0QdU3ggmiBC"
      },
      "source": [
        "# This can be useful to shuffle several arrays of elements coherently:\n",
        "\n",
        "shuffled_indexes = np.random.permutation(len(y))\n",
        "y_shuffled = y[shuffled_indexes]\n",
        "print(f'{y}[{shuffled_indexes}] = {y_shuffled}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G2Xi9wBLm6aw"
      },
      "source": [
        "# Boolean arrays of the same dimensions can be used as masks\n",
        "mask = [True, False, False, False, False, True]\n",
        "print(f'{y}[{mask}] = {y[mask]}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# This is useful to select a group of elements:\n",
        "mask_above_2 = y > 2\n",
        "print(mask_above_2)\n",
        "\n",
        "mask_less_17 = y <17\n",
        "print(mask_less_17)\n",
        "\n",
        "mask = mask_above_2 * mask_less_17  # elementwise `and` operation on Boolean numpy arrays\n",
        "print(mask)\n",
        "\n",
        "print('values between 2 and 17:', y[mask])"
      ],
      "metadata": {
        "id": "OESo1PsNrQXM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "EByo3G2NsD3q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# To get index of first smallest or largest element use `argmin` and `argmax`:\n",
        "\n",
        "print(y_shuffled)\n",
        "\n",
        "ixd_smallest = y_shuffled.argmin()\n",
        "ixd_largest = y_shuffled.argmax()\n",
        "\n",
        "print(f'index of smallest element: {ixd_smallest}. {y_shuffled}[{ixd_smallest}] = {y_shuffled[ixd_smallest]}')\n",
        "print(f'index of largest element: {ixd_largest}. {y_shuffled}[{ixd_largest}] = {y_shuffled[ixd_largest]}')"
      ],
      "metadata": {
        "id": "fyCLpDiPsTXt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Form a multidimensional array, or if more the one element has to be found - use argwhere:\n",
        "coords_elements_above_3 = np.argwhere(rnd > 3)\n",
        "print(coords_elements_above_3)\n",
        "\n",
        "for i, j, k in coords_elements_above_3:\n",
        "  print(f'rnd[{i}, {j}, {k}] = {rnd[i, j, k]}')"
      ],
      "metadata": {
        "id": "uxnZuhd8tDYq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Transposing index groups allows to obtain index arrays for each axis\n",
        "arr_i, arr_j, arr_k = coords_elements_above_3.T\n",
        "print(arr_i)\n",
        "print(arr_j)\n",
        "print(arr_k)"
      ],
      "metadata": {
        "id": "mfUt89BMXi_f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2. Image"
      ],
      "metadata": {
        "id": "dvIWHnPdJT3w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Loading an image from a file or a URL\n",
        "from skimage import io\n",
        "\n",
        "image = io.imread('https://github.com/neworldemancer/DSF5/raw/master/figures/unibe.jpg')\n",
        "print(image.shape)"
      ],
      "metadata": {
        "id": "VN2wP54lJaTk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Display an image with pyplot\n",
        "plt.imshow(image);"
      ],
      "metadata": {
        "id": "l-UqZTNKaShx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Any 2D map can be visualized similarly, e.g. a 2D histogram:\n",
        "\n",
        "values = np.random.multivariate_normal([0, 0], [[1, 0.3],[ 0.3, 0.2]], size=1000)\n",
        "plt.scatter(*values.T, s=5)\n",
        "\n",
        "h, bx, by = np.histogram2d(*values.T, bins = 20)\n",
        "plt.show()\n",
        "\n",
        "plt.imshow(h, origin='lower')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "9VNAkONjVXPt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bbfroLuAnlce"
      },
      "source": [
        "# 3. Object methods"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Methods of objects are called by writing object_name.method_name similarly to how we do for modules:\n",
        "\n",
        "```xx.yy(smth=value, smth2=v0)```\n",
        "\n",
        "E.g. `plt.plot` and `np.max` - method of modules `plt` and `np`; `arr_i.max` - method of object `arr_i`.\n",
        "\n",
        "When you start typing anything in the brackets or press `Shift + Tab` in Colab or Jupyter - a `__doc__` string of the function will be shown. You can see all the parameters, their description, and often examples. Don't even need to google it;)"
      ],
      "metadata": {
        "id": "atmbseuVoktZ"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uRAvV9F1ouiV"
      },
      "source": [
        "# 4. Interactive & Animation"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from ipywidgets import interact"
      ],
      "metadata": {
        "id": "g7nebfVWxHbA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8z2YQCJZBYEW"
      },
      "source": [
        "# You can often get much better intuition if you explore a range of parameters.\n",
        "# One way to do it - is with interactive widgets\n",
        "\n",
        "# Here we plot a line with a different slope and intercept depending on the parameters set\n",
        "\n",
        "@interact  # creates widgets according to function parameters (see https://ipywidgets.readthedocs.io/en/latest/examples/Widget%20Basics.html)\n",
        "def plot(a=(-5, 5, 0.1), b=(-5, 5, 0.1)): # each parameter will be interactive\n",
        "    # parameters for each variable are in range() format: start:stop:step\n",
        "\n",
        "    f = lambda x: a*x+b\n",
        "    x0 = -10\n",
        "    x1 = 10\n",
        "\n",
        "    y0 = f(x0)\n",
        "    y1 = f(x1)\n",
        "\n",
        "    plt.plot([x0, x1], [y0, y1])\n",
        "\n",
        "    plt.gca().set_aspect('equal')\n",
        "    plt.xlim(-10, 10)\n",
        "    plt.ylim(-10, 10)\n",
        "    plt.title(f'y={a:.1f}x+{b:.1f}')\n",
        "    plt.grid(True)\n",
        "    plt.show()\n",
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The function above is called on each parameter update. This means, that if the function takes too long to compute such an approach might be not usable.\n",
        "\n",
        "Animation serves a similar purpose, but all frames are pre-rendered. It is fast for visualization, but can take long to render all frames, and will have a large memory footprint with many frames."
      ],
      "metadata": {
        "id": "rOTrVWs-aWGl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from matplotlib import animation\n",
        "plt.rcParams[\"animation.html\"] = \"jshtml\"  # for matplotlib 2.1 and above, uses JavaScript"
      ],
      "metadata": {
        "id": "1WTt9Xu1YOi0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "%%capture\n",
        "# cell magic `capture` suppresses output of this cell\n",
        "\n",
        "f = lambda x, a: a*x+1\n",
        "x0 = -10\n",
        "x1 = 10\n",
        "\n",
        "a = 0\n",
        "y0 = f(x0, a)\n",
        "y1 = f(x1, a)\n",
        "\n",
        "fig = plt.figure()\n",
        "lines = plt.plot( [x0, x1], [y0, y1])\n",
        "\n",
        "plt.gca().set_aspect('equal')\n",
        "plt.xlim(-10, 10)\n",
        "plt.ylim(-10, 10)\n",
        "plt.grid(True)\n",
        "\n",
        "\n",
        "def animate(i):\n",
        "    a = 0.1 * i\n",
        "    y0 = f(x0, a)\n",
        "    y1 = f(x1, a)\n",
        "\n",
        "    l = lines[0]\n",
        "    l.set_data([x0, x1], [y0, y1])\n",
        "    return lines\n",
        "\n",
        "ani = animation.FuncAnimation(fig, animate, frames=10)\n"
      ],
      "metadata": {
        "id": "124vSPn4YyqK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Show animation\n",
        "ani"
      ],
      "metadata": {
        "id": "rHZVR_YEZyZK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 5.Exercises:"
      ],
      "metadata": {
        "id": "x7VLnpW3ywdE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. create a list of names and list of ages\n",
        "2. make a dictionary using dictionary comprehension from these lists\n",
        "\n",
        "\n",
        "3. convert ages to np.array\n",
        "4. find biggest values, and it's index\n",
        "\n",
        "\n",
        "5. download an image from the URL\n",
        "6. crop any area 100x100 pixels, all channels\n",
        "7. flatten and plot histogram\n",
        "8. find the value of the darkest and brightest pixel\n",
        "9. find the coordinates and channel of the brightest pixel value\n",
        "\n",
        "\n",
        "10. find all unique pixel values with a set\n",
        "11. create arrays of x and y coordinates of all pixels with meshgrid\n",
        "12. make a 3D surface plot of red channel values (z) with plot_surface.\n",
        "\n",
        "\n",
        "13. find all elements in the green channel smaller than the 30th percentile\n",
        "14. set corresponding elements in the red channel to 255, show the image\n",
        "\n",
        "\n",
        "15. make an interactive plot that crops a 100x100 area at coordinates given by a slider\n",
        "\n",
        "\n",
        "16. make an animation of 13-14 animating the resulting image with percentiles 9,10, ...90, 95\n",
        "\n"
      ],
      "metadata": {
        "id": "-MtEp_SlnfwA"
      }
    }
  ]
}