00_intro_to_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/ascarrambad/ml-21-22/blob/main/00_intro_to_python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kUod4PhQEUz1"
   },
   "source": [
    "# Machine Learning SP 2021/2022\n",
    "\n",
    "Prof. Cesare Alippi<br>\n",
    "Giorgia Adorni ([`giorgia.adorni@usi.ch`](mailto:giorgia.adorni@usi.ch))<br>\n",
    "Luca Butera ([`luca.butera@usi.ch`](mailto:luca.butera@usi.ch))<br>\n",
    "Matteo Riva ([`matteo.riva@usi.ch`](mailto:matteo.riva@usi.ch))\n",
    "\n",
    "---\n",
    "\n",
    "# Lab 00: Intro to Python\n",
    "\n",
    "![alt text](https://www.python.org/static/community_logos/python-logo-master-v3-TM.png)\n",
    "\n",
    "Among the most important things that you should learn from the beginning about Python language is that:\n",
    "\n",
    "- Python is interpreted,\n",
    "- Python is dynamically typed,\n",
    "- indentation matters.\n",
    "\n",
    "Python acts as a high-level interface to a low-level interpreter written in C, and is built for fast prototyping and readable code.\n",
    "The fact that the Python is interpreted, makes it less performant than compiled languages. However, programmers can build extensions in C and move high-load functions to external, compiled modules. \n",
    "\n",
    "In this course, we will use Python for all assignments, so make sure to familiarize with its syntax as soon as possible.\n",
    "Since Python is so simple and flexible, it shouldn't take you more than a week to get the basics down. \n",
    "\n",
    "Let's see some examples.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nUqVTs3aJICO"
   },
   "outputs": [],
   "source": [
    "# This is an inline comment. Anything after # is ignored by the interpreter\n",
    "\n",
    "a = 1          # Variable assignment\n",
    "b = 'string'   # This is a string\n",
    "c = 3.2        # This is a float\n",
    "d = True       # This is a bool\n",
    "e = [1, 2, 3]  # This is a list of integers\n",
    "g = (1, 2, 3)  # Tuples are immutable lists (can't be modified)\n",
    "f = {'a': 1}   # Hashmaps in Python are called `dictionaries`\n",
    "h = None       # This is a special object, equivalent to null in Java\n",
    "\n",
    "print('This is how you can print a string to stdout')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "leVVvmzGKzns"
   },
   "source": [
    "### More on data structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WouHzi0fKsDO"
   },
   "outputs": [],
   "source": [
    "i = [1, 2.0, ['a', 'b', 5], 6]  # This list contains mixed-type elements\n",
    "print(i[2])                     # This is how you access a data struct\n",
    "print(i[2:4])                   # Lists and tuples support slicing (start inclusive, end exclusive)\n",
    "\n",
    "f[123] = 'onetwothree'          # Anything can be a dictionary key\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "A7Tzcab-Llq0"
   },
   "source": [
    "### Dynamic typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hjnJMyAuLidy"
   },
   "outputs": [],
   "source": [
    "a = 10.        # Now a contains a float...\n",
    "print(a, type(a))\n",
    "a = [1, 2, 3]  # ...and now a list of integers.\n",
    "print(a, type(a))\n",
    "a = (1, 2, 3)  # Variables are just pointers to objects in memory\n",
    "print(a, type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Mjku9FI9LxDn"
   },
   "source": [
    "### Control statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "J6LKhjEJLwaR"
   },
   "outputs": [],
   "source": [
    "# For loop behaves as a foreach\n",
    "for i in [1, 4, 5]:\n",
    "    # After a ':', code must be indented\n",
    "    print(i)\n",
    "print(\"Out of the loop!\") # This statement is not indented as 'print(i)'\n",
    "\n",
    "# While loop\n",
    "a = 10\n",
    "while a > 0:  # Other operators: >=, <=, <, >, ==, !=\n",
    "    a = a - 1\n",
    "\n",
    "# If - else if - else\n",
    "if a == 0:\n",
    "    print('Zero')\n",
    "elif a < 0:\n",
    "    print('Negative')\n",
    "else:\n",
    "    print('Positive')\n",
    "    \n",
    "if not a == 0:  # 'not' is the keyword for negation\n",
    "    print('a is not 0')\n",
    "\n",
    "# Inline if - else\n",
    "a = 5\n",
    "print('spam' if a < 0 else 'ham')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "axKu1SmiMH_N"
   },
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UgZmX7KnMLNw"
   },
   "outputs": [],
   "source": [
    "def foo(x):\n",
    "    print(x)\n",
    "    \n",
    "foo('foo')\n",
    "\n",
    "# This is a function with optional parameters\n",
    "def bar(x, optional=-1):\n",
    "    print( x, optional)\n",
    "\n",
    "bar(1)               # Prints 1 -1\n",
    "bar(1, optional=2)   # Prints 1 2\n",
    "bar(1, 3)            # Prints 1 3\n",
    "bar(optional=3, x=1) # Prints 1 3\n",
    "#bar(optional=3)     # Does not work!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zIUvKctS1p0r"
   },
   "source": [
    "__Remark__: In Python everything is an object and variables are references to objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pUvoMchM1oDW"
   },
   "outputs": [],
   "source": [
    "def pippo(l):\n",
    "    l[1] = None \n",
    "\n",
    "s = [1, 2, 3]\n",
    "print(s)\n",
    "pippo(s)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "R6p-E8y95MDg"
   },
   "outputs": [],
   "source": [
    "def pluto(l):\n",
    "    l = [4, 5, 6]\n",
    "\n",
    "s = [1, 2, 3]\n",
    "print(s)\n",
    "pluto(s)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "In_lZVkO5wT5"
   },
   "source": [
    "- `pippo` changes the object not the variable\n",
    "(side effect, out of the function control), \n",
    "- `pluto` make variable `l` point to a different object (but `l` is local).\n",
    "\n",
    "__Take-away__: be careful of side effects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UU9pJprHMM7W"
   },
   "source": [
    "### Syntactic sugar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NawnmBzbMJS1"
   },
   "outputs": [],
   "source": [
    "h = None\n",
    "if h is None:  # Check equivalence with \"is\"\n",
    "    print('variable is None')\n",
    "    \n",
    "if 1 in [1, 2, 3]:  # Check membership with \"in\"\n",
    "    print('Element found')\n",
    "    \n",
    "if 1 not in [1, 2, 3]:\n",
    "    print('Element not found')\n",
    "\n",
    "e = [1, 2, 3]    \n",
    "e.append(4)  # Append to list\n",
    "print(e)\n",
    "e = [1, 2, 3] + [4, 5, 6]  # Concatenate two lists\n",
    "print(e)\n",
    "e = [1 for _ in range(1, 7)] # List comprehension\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4Bwb_OORNJf1"
   },
   "source": [
    "### Built-in functions\n",
    "Python has a lot of native methods to do all sorts of stuff."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CC6Gqw_CNLzG"
   },
   "outputs": [],
   "source": [
    "a = list()     # List constructor\n",
    "for i in range(10):  # Count from 0 to 10 \n",
    "    a.append(5-i)\n",
    "sorted(a)      # Return a sorted list\n",
    "max(a)         # Find the max\n",
    "min(a)         # Find the min\n",
    "f = open('test_file.txt', 'w')  # Open a file\n",
    "f.write(\"I don't know what to say...\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C80a9yVyPXOd"
   },
   "source": [
    "### Importing external libraries\n",
    "The true power of Python lies in the vast amount of libraries that are available to developers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "c15oCuXTPmkd"
   },
   "outputs": [],
   "source": [
    "import math  # Import the library (or \"module\") called \"math\"\n",
    "print(math.cos(1))\n",
    "\n",
    "from math import cos  # Import a single function from a module\n",
    "print(cos(1))\n",
    "\n",
    "import math as m  # Import a module and rename it\n",
    "m.cos(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rQjgtDHESVru"
   },
   "source": [
    "## Intro to Numpy\n",
    "The main library that we are going to use in the course is called Numpy, which the most popular Python library for scientific computing and array manipulation.   \n",
    "This notebook contains a primer on how to use some basic functions of Numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HMIpdm4kRWb0"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5DWwQO0HRWb3"
   },
   "source": [
    "## Numpy arrays\n",
    "\n",
    "The building block of numpy is the `ndarray`,  short for \"n-dimensional array\". Arrays in Numpy are objects with three main properties: \n",
    "1. the actual data\n",
    "2. shape (data dimensions) \n",
    "3. data type\n",
    "\n",
    "To create an array, we use the `np.array` constructor. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZJbIb7H6RWb4"
   },
   "outputs": [],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "\n",
    "print('Data:  ', a)\n",
    "print('Shape: ', a.shape)\n",
    "print('Data type:  ', a.dtype)\n",
    "print('Type of a:', type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "k_44YZSGV_Tn"
   },
   "source": [
    "We can also create arrays with a higher number of dimensions. An array with shape `(n, m)` is represented in classical notation with $\\mathbb{R}^{n \\times m}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dt-5JWQmRWb8"
   },
   "outputs": [],
   "source": [
    "b = np.array([[1., 2., 3.], \n",
    "              [4., 5., 6.]])  # a list of lists\n",
    "\n",
    "print('Data:  ')\n",
    "print(b)\n",
    "print('Shape: ', b.shape)\n",
    "print('Type:  ', b.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HBebfUWD15V_"
   },
   "outputs": [],
   "source": [
    "t = 2 * np.ones(shape=3)\n",
    "print('Shape: ', t.shape)\n",
    "print('Data:  ')\n",
    "print(t)\n",
    "\n",
    "print()\n",
    "\n",
    "z = np.zeros(shape=(3, 2, 5)) \n",
    "print('Shape: ', z.shape)\n",
    "print('Data:  ')\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QzIYlHMXYV2q"
   },
   "source": [
    "Data, shape, and type af an array can be manipulated (obviously, we are mostly interested in manipulating the data, but the other two can be very important)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_mtr6vRsYxIj"
   },
   "outputs": [],
   "source": [
    "a = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8])\n",
    "print('Original:    ', a)\n",
    "\n",
    "# Edit data\n",
    "a[2] = 9\n",
    "print('Change data: ', a)\n",
    "\n",
    "# Edit shape\n",
    "print('Change shape to (3, 3):')\n",
    "print(a.reshape((3, 3)))\n",
    "print(a.reshape((3, -1)))\n",
    "\n",
    "# Change type\n",
    "print('Change type: ', a.astype(np.float))\n",
    "print(a.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WS6ujOsiuJ2m"
   },
   "source": [
    "Arrays can be accessed like lists, but support an advanced slicing operator that allows for complex behaviours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Jl9qoDXZuWGR"
   },
   "outputs": [],
   "source": [
    "a = np.arange(9).reshape((3, 3))\n",
    "print(a)\n",
    "\n",
    "# Access element 0, 0\n",
    "print(\"a[0, 0]:\", a[0, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "J-qQCxBju5YX"
   },
   "outputs": [],
   "source": [
    "# Access first row\n",
    "print(a[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XdDzjeoX3VhD"
   },
   "outputs": [],
   "source": [
    "print(a[0, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KYA5izk-u6oK"
   },
   "outputs": [],
   "source": [
    "# Access first column\n",
    "print(a[:, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2nD5knaz3XKQ"
   },
   "outputs": [],
   "source": [
    "print(a[:, 0:1])\n",
    "print(\"shape:\", a[:, 0:1].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zTUcsC-Mu7tD"
   },
   "outputs": [],
   "source": [
    "# Access 2 x 2 submatrix\n",
    "print(a[0:2, 0:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zkiptDTb3j55"
   },
   "outputs": [],
   "source": [
    "print(a[:2, :2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bmlB1JnFa-H_"
   },
   "source": [
    "## Numpy operations\n",
    "Numpy implements hundreds of useful mathematical operations on and between arrays. \n",
    "\n",
    "### Operations on arrays\n",
    "\n",
    "Unary operations on arrays are applied element-wise, i.e., evaluated for each number saved in the array. Shape is usually not affected by unary operations, but type might. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "T6zhXrkecCYj"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Create a sequence of 1000 floats equally spaced between 0 and 2pi\n",
    "x = np.linspace(0, 2 * np.pi, 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dBDI8XKC3smv"
   },
   "source": [
    "__Trick__: in a code cell hold \"ctrl\" and point to a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m8YXAWdk0Yu7"
   },
   "source": [
    "This how we compute the sine function at all points defined in `x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "F-D9ZK6p0X7t"
   },
   "outputs": [],
   "source": [
    "y = np.sin(x)\n",
    "plt.plot(x, y);  # Plot a line graph built using (x[i], y[i]) pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IStSMhG70eR8"
   },
   "source": [
    "And similarly, $e^x$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "eleIv243c4Ja"
   },
   "outputs": [],
   "source": [
    "plt.plot(x, np.exp(x));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ymf97J5h0kui"
   },
   "source": [
    "Numpy offers a very large collection of functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CmJlDJ25dGW6"
   },
   "outputs": [],
   "source": [
    "y = np.square(x)   # Square\n",
    "y = np.sqrt(x)     # Square root\n",
    "y = np.floor(x)    # Flooring\n",
    "y = np.power(x, 3) # Exponentiation\n",
    "y = np.tan(x)      # Tangent\n",
    "y = np.arctan(x)   # Arctangent\n",
    "y = np.tanh(x)     # Hyperbolic tangent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Tta226gOhSrd"
   },
   "source": [
    "Arrays also support advanced manipulation via a process called **broadcasting**.  \n",
    "The following is a valid expression in Numpy, and gets evaluated at every point in the array x. This concept can also be applied to higher-rank arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NQ7zO2D1ik-o"
   },
   "outputs": [],
   "source": [
    "y = x + 2  # 2 gets summed to every point in x\n",
    "plt.plot(x, y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bjd4n5lniz29"
   },
   "source": [
    "This can be extended to arbitrarily complex functions!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ei-j36uNhgSu"
   },
   "outputs": [],
   "source": [
    "y1 = np.sin(x ** 2 + 3) + 3 * np.cos(x)\n",
    "plt.plot(x, y1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PlFw56uh6b_5"
   },
   "outputs": [],
   "source": [
    "# we can also draw multiple plots\n",
    "y2 = np.sin(x) * np.cos(10*x)\n",
    "\n",
    "plt.plot(x, y1, label=\"fun_2\");\n",
    "plt.plot(x, y2, label=\"fun_2\");\n",
    "plt.legend()\n",
    "\n",
    "plt.title(\"nothing to declare\")\n",
    "plt.xlabel(\"my x\")\n",
    "plt.ylabel(\"my y\")\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-mpyU8xgvX3J"
   },
   "source": [
    "### Operations between arrays\n",
    "Operations can also be computed between two or more arrays.  \n",
    "There are two equivalent notations to compute the dot product between arrays in Numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pplAIsswvilH"
   },
   "outputs": [],
   "source": [
    "# 1D arrays\n",
    "x = np.arange(9)\n",
    "y = np.arange(9)\n",
    "\n",
    "# Dot product\n",
    "xy = np.dot(x, y)\n",
    "print(xy)\n",
    "xy = x.dot(y)\n",
    "print(xy)\n",
    "xy = 0\n",
    "for i in range(9):\n",
    "    xy += x[i] * y[i]\n",
    "print(xy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JjZXZZUb11vb"
   },
   "outputs": [],
   "source": [
    "from time import time\n",
    "\n",
    "# 1D arrays\n",
    "x = np.arange(9999)\n",
    "y = np.arange(9999)\n",
    "\n",
    "start = time()\n",
    "xy = np.dot(x, y)\n",
    "np_time = time() - start\n",
    "print(\"xy = {} - numpy dot time: {:6.3f} ms\".format(xy, np_time * 1000))\n",
    "\n",
    "start = time()\n",
    "xy = 0\n",
    "for i in range(9999):\n",
    "    xy += x[i] * y[i]\n",
    "for_time = time() - start\n",
    "print(\"xy = {} - for cycle time: {:6.3f} ms\".format(xy, for_time * 1000))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-N8dV8MdwmTe"
   },
   "source": [
    "The same can be done for matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xIprDvRSv9_F"
   },
   "outputs": [],
   "source": [
    "# 2D arrays\n",
    "v = np.arange(9).reshape((3, 3))\n",
    "w = np.arange(9).reshape((3, 3))\n",
    "\n",
    "# Matrix multiplication between square matrices (row-column multiplication)\n",
    "vw = v.dot(w)\n",
    "print(vw)\n",
    "# The @ operator can be used as well\n",
    "print(v @ w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ACTpSvppxBNK"
   },
   "source": [
    "When multiplying non-square matrices, we have to be sure that their dimensions are aligned properly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uEMGozwMw2I4"
   },
   "outputs": [],
   "source": [
    "# Define two non-square matrices\n",
    "v = np.arange(6).reshape((3, 2))\n",
    "w = np.arange(6).reshape((3, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "L0fM3hA0xSJq"
   },
   "outputs": [],
   "source": [
    "# This will crash\n",
    "try:\n",
    "    vw = v.dot(w)\n",
    "except ValueError as e:\n",
    "    print('ValueError:', e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GB4mCXkyxTtq"
   },
   "outputs": [],
   "source": [
    "# Transpose the second matrix with w.T to compute the correct product\n",
    "vw = v.dot(w.T)\n",
    "print(vw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xAvvGF9S8AeH"
   },
   "outputs": [],
   "source": [
    "# which is very different from\n",
    "vw = v.T.dot(w)\n",
    "print(vw)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5aP0ls_3_iz_"
   },
   "source": [
    "Note that the usual multiplication opertaror does not work as a dot product, but as an element-wise operator. The same holds for `+`, `-`, and `/`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hc2Nlly0_tNF"
   },
   "outputs": [],
   "source": [
    "# Element-wise multiplication\n",
    "v = np.arange(9)\n",
    "w = np.arange(9)\n",
    "print(v + w)\n",
    "print(v * w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "k-NBLf0G1-po"
   },
   "source": [
    "Arrays can be stacked or concatenated together in several ways, along different **axes**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UUPx7kx_2KMf"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.arange(9)\n",
    "b = np.arange(9)\n",
    "\n",
    "# Concatenate together\n",
    "print('Concatenated')\n",
    "ab = np.concatenate((a, b))\n",
    "print(ab)\n",
    "\n",
    "# Stack as a matrix\n",
    "print('Stacked rows')\n",
    "ab = np.vstack((a, b))  # Short for \"vertical stack\"\n",
    "print(ab)\n",
    "\n",
    "# Stack two column vectors\n",
    "print('Stacked columns')\n",
    "a = a.reshape((9, 1))   # Column vector\n",
    "b = b.reshape((9, 1))   # Column vector\n",
    "ab = np.hstack((a, b))  # Short for \"horizontal stack\"\n",
    "print(ab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_UlI7Mz43UEM"
   },
   "source": [
    "## Resources\n",
    "\n",
    "- Python docs: [https://docs.python.org/](https://docs.python.org/)\n",
    "- [Python cheat sheet](https://perso.limsi.fr/pointal/_media/python:cours:mementopython3-english.pdf)\n",
    "- Numpy docs: [https://docs.scipy.org/doc/numpy/](https://docs.scipy.org/doc/numpy/)\n",
    "- [Cheat sheet for several scientific libraries](https://github.com/kailashahirwar/cheatsheets-ai/) (AI-oriented)\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "leVVvmzGKzns",
    "A7Tzcab-Llq0",
    "Mjku9FI9LxDn",
    "axKu1SmiMH_N",
    "UU9pJprHMM7W",
    "4Bwb_OORNJf1",
    "C80a9yVyPXOd",
    "rQjgtDHESVru",
    "5DWwQO0HRWb3",
    "bmlB1JnFa-H_"
   ],
   "include_colab_link": true,
   "name": "00_intro_to_python.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7.11"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}