tutorials/01_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python Basics – Quick Start Guide**\n",
    "\n",
    "Python was created by Guido van Rossum in the early 90s. It is a high-level, general-purpose programming language. It is known for its clear and concise syntax, which makes it easy to read and write. Python is also dynamically typed, which means that it is not necessary to declare variable types in advance. This makes Python code more flexible and easier to write. Today, it's one of the most popular languages around. We fell in love with Python for its syntactic clarity. It is essentially executable pseudocode. \n",
    "\n",
    "It is the most used programming language for [data analytics, data science, machine learning algorithms, but also in power grid analytics](https://storage.googleapis.com/kaggle-media/surveys/Kaggle%20State%20of%20Machine%20Learning%20and%20Data%20Science%20Report%202022.pdf). Also, it is a good replacement for MATLAB users and people who do not want to much strain with the coding syntax. According to the last [Stack Overflow Survey (2030)](https://survey.stackoverflow.co/2023/#section-most-popular-technologies-other-tools), the language is amongst the most desired and used programming languages. This is certainly due to is simplicity of usage and learning path.\n",
    "\n",
    "> For data analysis and interactive computing and data visualization, Python will inevitably draw comparisons with other open source and commercial programming languages and tools in wide use, such as R, MATLAB, SAS, Stata, and others. In recent years, Python’s improved open source libraries (such as pandas and scikit-learn) have made it a popular choice for data analysis tasks. Combined with Python’s overall strength for general-purpose software engineering, it is an excellent option as a primary language for building data applications.\n",
    "\n",
    "— Wes McKinney, the creator of Python pandas project and author of [*Python for data analysis: Data wrangling with Pandas, NumPy, and IPython*](https://wesmckinney.com/book/#whats-new-in-the-3rd-edition).\n",
    "\n",
    "In this part, we are going to tackle the most important concepts of Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Primitive datatypes and operators\n",
    "\n",
    "The first thing we'll look at is the different types of data in Python (integer, float, boolean, and string)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Integer\n",
    "\n",
    "An integer often refered to as an `int`, is a data type used to represent whole numbers, both positive and negative, without fractional or decimal part.\n",
    "In Python, integers are used for performing arithmetic operations, counting, indexing, and more – for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:50.458543600Z",
     "start_time": "2023-08-28T08:50:49.583469900Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:50.458543600Z",
     "start_time": "2023-08-28T08:50:49.583469900Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Float\n",
    "\n",
    "A floating-point number, often referred to as a `float`, is a data type used to represent numbers with decimal points or fractional parts. Floats are used for representing real numbers. \n",
    "They can include both integers and non-integers. They are commonly used for calculations involving measurements, scientific computations, and more – for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:50.906376Z",
     "start_time": "2023-08-28T08:50:49.599103600Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "**Remark**: `print()` function is not mandatory to obtain results in a notebook, but if you want to print everything from the same cell, you must use it. Otherwise, you will only get the last result printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Boolean\n",
    "\n",
    "A boolean is a data type that represents one of two values: `True` or `False`. Booleans are used for logical operations, comparisons, and decision-making in programming. \n",
    "They are integral for creating conditions and controlling the flow of a program. Boolean values are essential for creating conditional statements, loops, and controlling program execution based on certain conditions. Understanding these types is crucial for writing effective and accurate Python programs – we can use them as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:50.959772300Z",
     "start_time": "2023-08-28T08:50:49.625753Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(True)\n",
    "print(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remark**: boolean values are primitives (capitalization is important)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String\n",
    "\n",
    "A string, often referred to as a `str`, is a data type used to represent a sequence of characters. Strings can contain letters, numbers, symbols, and even spaces. \n",
    "They are commonly used for working with textual data, such as words, sentences, and more complex text-based information. \n",
    "Strings are enclosed in either single quotes (`'`) or double quotes (`\"`) – for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:50.959772300Z",
     "start_time": "2023-08-28T08:50:49.672628Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('hello')\n",
    "'1'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remark**: Strings are versatile and can be manipulated, concatenated, and formatted in various ways. They play a crucial role in handling textual information within a Python program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `type()` method\n",
    "\n",
    "In order to ckeck variable type you can use `type()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:50.991025600Z",
     "start_time": "2023-08-28T08:50:49.703879400Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'bool'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(3))\n",
    "print(type(3.0))\n",
    "print(type(True))\n",
    "print(type('hello'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a nutshell, with Python, there are more or less 4 types of basic data types:\n",
    "\n",
    "- Integer: a whole number, positive or negative. For example, `1`, `2`, `3`, `-1`, `-2`, `-3` are integers.\n",
    "- Float is a number with a decimal point. For example, `3.14`, `2.5`, `-1.23` are floats.\n",
    "- Boolean is a value that can be either `True` or `False`.\n",
    "\n",
    "Here is a comple example of how to declare variables of each data type in a Jupyter Notebook with Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.013166100Z",
     "start_time": "2023-08-28T08:50:49.710389100Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "integer_var = 10\n",
    "float_var = 3.14\n",
    "boolean_var = True\n",
    "string_var = \"grids\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have just seen above, we can also use `type()` function to check the data type of a variable. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.060057500Z",
     "start_time": "2023-08-28T08:50:49.726029100Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'bool'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(integer_var))\n",
    "print(type(float_var))\n",
    "print(type(boolean_var))\n",
    "print(type(string_var))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Basic operations\n",
    "\n",
    "The maths is what you would expect, including integer division that rounds down for positive and negative numbers – for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.091340500Z",
     "start_time": "2023-08-28T08:50:49.741653900Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "7\n",
      "20\n",
      "7.0\n",
      "1\n",
      "-2\n",
      "1.0\n",
      "-2.0\n"
     ]
    }
   ],
   "source": [
    "# Integers\n",
    "print(1+1) # => 2\n",
    "print(8-1) # => 7\n",
    "print(10*2) # => 20\n",
    "print(35/5) # => 7.0\n",
    "\n",
    "# Integer division rounds down\n",
    "print(5//3)      # => 1\n",
    "print(-5//3)      # => -2\n",
    "print(5.0//3.0)   # => 1.0 # works on floats too\n",
    "print(-5.0//3.0)  # => -2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result of division is always a float:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.106965500Z",
     "start_time": "2023-08-28T08:50:49.757278800Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(10.0/3))\n",
    "print(type(9/3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A modulo operation is also possible, as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.113543900Z",
     "start_time": "2023-08-28T08:50:49.772902500Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(7%3) # => 1\n",
    "# i % j have the same sign as j, unlike C\n",
    "print(-7%3)  # => 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The modulo operator is widely used in programming languages because it can be used to solve a variety of problems. For example, it can be used to:\n",
    "\n",
    "- Check if a number is even or odd.\n",
    "- Find the remainder of a number when it is divided by a certain number.\n",
    "- Generate pseudorandom numbers.\n",
    "- Encrypt and decrypt data.\n",
    "\n",
    "Here is an example of how the modulo operator can be used in Python:\n",
    "\n",
    "**Remark**: the modulo operator, also called the remainder operator, is used to find the remainder when one integer is divided by another. For example, `5` mod `3` is `2`, because `5` divided by `3` has a quotient of `1` and a remainder of `2`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exponentiation (`x**y`, `x` to the $y^{th}$ power):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.129218600Z",
     "start_time": "2023-08-28T08:50:49.788527600Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**3 # => 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enforce precedence with parentheses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.160464300Z",
     "start_time": "2023-08-28T08:50:49.810681200Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "print(1 + 3 * 2)    # => 7\n",
    "print((1 + 3) * 2)  # => 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean logic operations are also possible, as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.176086500Z",
     "start_time": "2023-08-28T08:50:49.810681200Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(True & False) # And\n",
    "print(True | False) # Or"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use `+` and `*` operators, but the result would be 1 or 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.191714300Z",
     "start_time": "2023-08-28T08:50:49.826322700Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "print(True + False)\n",
    "print(True * False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String concatenation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.213845100Z",
     "start_time": "2023-08-28T08:50:49.841947100Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "print('hello' + ' world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists\n",
    "\n",
    "Python has different ways to group values together. One of them is called a _list_. A list is a collection of values separated by commas and enclosed in square brackets. Lists can contain different types of values but usually contain values of the same type. Python knows a number of _compound_ data types, used to group together other values. One of the most versatile is the list, which can be written as a list of comma-separated values (items) between square brackets. Lists might contain items of different types, but usually the items all have the same type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.229509Z",
     "start_time": "2023-08-28T08:50:49.857570300Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "squares = [1, 4, 9, 16, 25, 36, 49, 64]\n",
    "print(squares)\n",
    "print(type(squares))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The items in the list do not have to be of the same type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.245135500Z",
     "start_time": "2023-08-28T08:50:49.873197200Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'A', 1.0, True]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 'A', 1.0, True]\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The built-in function `len()` return the number of elements of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.260762200Z",
     "start_time": "2023-08-28T08:50:49.888819Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing and slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like strings (and all other built-in [sequence](https://docs.python.org/3.10/glossary.html#term-sequence) types), lists can be indexed and sliced:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.292010400Z",
     "start_time": "2023-08-28T08:50:49.910954600Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "print(squares[0]) # indexing returns the item\n",
    "print(squares[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remark**: Pay attention the 0 is the first index. It is a choice in the programming language design (and different from MATLAB). The main reasons are the following: memory location, compatibility with C, relationship simplification between indices and lengths, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the n<sup>th</sup> last element of the list use -n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.307635Z",
     "start_time": "2023-08-28T08:50:49.926589600Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n",
      "49\n"
     ]
    }
   ],
   "source": [
    "print(squares[-1])\n",
    "print(squares[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get every element between to boundaries, you can use `:` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.326645300Z",
     "start_time": "2023-08-28T08:50:49.942233900Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 16, 25]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First and last index are not needed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.347149200Z",
     "start_time": "2023-08-28T08:50:49.942233900Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9]\n",
      "[36, 49, 64]\n"
     ]
    }
   ],
   "source": [
    "print(squares[:3])\n",
    "print(squares[-3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To filter a list to get every n-element add `:n`, as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.367639500Z",
     "start_time": "2023-08-28T08:50:49.957844Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 49]\n",
      "[4, 16, 36, 64]\n",
      "[4, 16]\n"
     ]
    }
   ],
   "source": [
    "print(squares[::2])\n",
    "print(squares[1::2])\n",
    "print(squares[1:-3:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All slice operations return a new list containing the requested elements. This means that the following slice returns a [shallow copy](https://docs.python.org/3.10/library/copy.html#shallow-vs-deep-copy) of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.388144400Z",
     "start_time": "2023-08-28T08:50:49.973467500Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25, 36, 49, 64]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List concatenation and mutation\n",
    "\n",
    "Lists are a [mutable](https://docs.python.org/3.10/glossary.html#term-mutable) type, i.e. it is possible to change their content, like concatenation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.398402300Z",
     "start_time": "2023-08-28T08:50:49.989090600Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares + [81, 100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add new items at the end of the list, by using the `append()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.439428100Z",
     "start_time": "2023-08-28T08:50:50.004716200Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25, 36, 49, 64, 121, 144]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares.append(121) # add 11 squared\n",
    "squares.append(12 ** 2)  # add 12 squared\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also modify an element in a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.439428100Z",
     "start_time": "2023-08-28T08:50:50.011229700Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'x', 'e', 'f', 'g']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters = ['a', 'b', 'c', 'x', 'e', 'f', 'g']\n",
    "letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.459938500Z",
     "start_time": "2023-08-28T08:50:50.011229700Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'd', 'e', 'f', 'g']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters[3] = 'd' \n",
    "letters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assignment to slices is also possible, and this can even change the size of the list or clear it entirely:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.478202700Z",
     "start_time": "2023-08-28T08:50:50.026870400Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can replace some values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.508748700Z",
     "start_time": "2023-08-28T08:50:50.032299800Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'X', 'f', 'g']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters[2:5] = ['X']\n",
    "letters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can remove them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.561832100Z",
     "start_time": "2023-08-28T08:50:50.047938300Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters[2:5] = []\n",
    "letters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then clear the list by replacing all the elements with an empty list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.602945400Z",
     "start_time": "2023-08-28T08:50:50.047938300Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters[:] = []\n",
    "letters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested list\n",
    "\n",
    "It is possible to nest lists (create lists containing other lists) – for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.602945400Z",
     "start_time": "2023-08-28T08:50:50.063559100Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['a', 'b', 'c'], [1, 2, 3]]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['a', 'b', 'c']\n",
    "n = [1, 2, 3]\n",
    "x = [a, n]\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.602945400Z",
     "start_time": "2023-08-28T08:50:50.079188Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c']\n",
      "b\n"
     ]
    }
   ],
   "source": [
    "print(x[0])\n",
    "print(x[0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To go further, we can find other [list build-in function](https://docs.python.org/3.10/tutorial/datastructures.html#tut-structures)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionnary\n",
    "\n",
    "Dictionaries are Python’s implementation of a data structure that is more generally known as an associative array. A dictionary consists of a collection of key-value pairs. Each key-value pair maps the key to its associated value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.643873300Z",
     "start_time": "2023-08-28T08:50:50.090668500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7}\n",
    "print(type(my_dict))\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remark**: pay attention that evey key has to be unique."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The built-in function `len()` also return the number of element's pairs of a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.703177800Z",
     "start_time": "2023-08-28T08:50:50.111314200Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionnay data access\n",
    "\n",
    "To have acess to the values call the specified keys from the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.705215300Z",
     "start_time": "2023-08-28T08:50:50.126995100Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print(my_dict['A'])\n",
    "print(my_dict['E'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.705303900Z",
     "start_time": "2023-08-28T08:50:50.142580500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['A', 'B', 'C', 'D', 'E', 'F', 'G'])\n",
      "dict_values([1, 2, 3, 4, 5, 6, 7])\n"
     ]
    }
   ],
   "source": [
    "print(my_dict.keys())\n",
    "print(my_dict.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.705303900Z",
     "start_time": "2023-08-28T08:50:50.142580500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'C', 'D', 'E', 'F', 'G']\n",
      "[1, 2, 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "print(list(my_dict.keys()))\n",
    "print(list(my_dict.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionnary concatenation and mutation\n",
    "\n",
    "The `update()` function allows to concatenate one dictionary to another:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.744185300Z",
     "start_time": "2023-08-28T08:50:50.158989300Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 1,\n",
       " 'B': 2,\n",
       " 'C': 3,\n",
       " 'D': 4,\n",
       " 'E': 5,\n",
       " 'F': 6,\n",
       " 'G': 7,\n",
       " 'H': 8,\n",
       " 'I': 9,\n",
       " 'J': 10}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict.update({'H': 8, 'I': 9, 'J': 10})\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remark**: pay attention this function returns nothing and automatically update the dictionary**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add one key, value pair:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.764643600Z",
     "start_time": "2023-08-28T08:50:50.174630Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 1,\n",
       " 'B': 2,\n",
       " 'C': 3,\n",
       " 'D': 4,\n",
       " 'E': 5,\n",
       " 'F': 6,\n",
       " 'G': 7,\n",
       " 'H': 8,\n",
       " 'I': 9,\n",
       " 'J': 10,\n",
       " 'K': 11}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict['K'] = 11\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To remove one key, value pair use  `del` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.785101300Z",
     "start_time": "2023-08-28T08:50:50.174630Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'B': 2,\n",
       " 'C': 3,\n",
       " 'D': 4,\n",
       " 'E': 5,\n",
       " 'F': 6,\n",
       " 'G': 7,\n",
       " 'H': 8,\n",
       " 'I': 9,\n",
       " 'J': 10,\n",
       " 'K': 11}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del my_dict['A']\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested dictionary\n",
    "\n",
    "It is also possible to nest dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.807634200Z",
     "start_time": "2023-08-28T08:50:50.205879500Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7},\n",
       " 'other_dict': {'a': 'A', 'b': 'B', 1: 'A', 2: 'B'}}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nested_dict = {\n",
    "    1: {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7},\n",
    "    'other_dict': {'a': 'A', 'b': 'B', 1: 'A', 2: 'B'}\n",
    "}\n",
    "nested_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python basis programming function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## `if` statements\n",
    "\n",
    "Perhaps the most well-known statement type is the [`if`](https://docs.python.org/3.10/reference/compound_stmts.html#if) statement – for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.828199800Z",
     "start_time": "2023-08-28T08:50:50.227031400Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "More\n"
     ]
    }
   ],
   "source": [
    "x = 42\n",
    "if x < 0:\n",
    "    x = 0\n",
    "    print('Negative changed to zero')\n",
    "elif x == 0:\n",
    "    print('Zero')\n",
    "elif x == 1:\n",
    "    print('Single')\n",
    "else:\n",
    "    print('More')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remark**: pay attention to the systax: there is not end to if statements, every lines bellow aan if and containing a tab are within the if statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There can be zero or more [`elif`](https://docs.python.org/3.10/reference/compound_stmts.html#elif) parts, and the [`else`](https://docs.python.org/3.10/reference/compound_stmts.html#else) part is optional. The keyword `elif` is short for 'else if', and is useful to avoid excessive indentation. An `if` ... `elif` ... `elif` ... sequence is a substitute for the `switch` or `case` statements found in other languages.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.848718300Z",
     "start_time": "2023-08-28T08:50:50.242656900Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x gater than 3 or smaller than -4\n"
     ]
    }
   ],
   "source": [
    "x = 42\n",
    "if (x >= 0) & (x <= 1):\n",
    "    x = 0\n",
    "    print('x between 0 and 1')\n",
    "elif (x >= 3) | (x <= -4):\n",
    "    print('x gater than 3 or smaller than -4')\n",
    "else:\n",
    "    print('other')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## `while` statements\n",
    "\n",
    "With the while statement, we can execute a set of statements as long as a condition is true. For instance, we can write an initial sub-sequence of the [Fibonacci series](https://en.wikipedia.org/wiki/Fibonacci_number) as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.869218Z",
     "start_time": "2023-08-28T08:50:50.258311300Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# The sum of two elements defines the next\n",
    "a, b = 0, 1\n",
    "while a < 10:\n",
    "    print(a)\n",
    "    a, b = b, a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example introduces new features, let's go through them:\n",
    "\n",
    "- The first line contains a *multiple assignment*: the variables a and b simultaneously get the new values 0 and 1. On the last line this is used again, demonstrating that the expressions on the right-hand side are all evaluated first before any of the assignments take place. The right-hand side expressions are evaluated from the left to the right.\n",
    "\n",
    "- The [`while`](https://docs.python.org/3.10/reference/compound_stmts.html#while) loop executes as long as the condition (here: `a < 10`) remains true. The condition may also be a string or list value; anything with a non-zero length is true, empty sequences are false. The test used in the above example, is a simple comparison and the standard comparison operators are written the same as in C. The standard comparison operators are written the same as in C: `<` (less than), `>` (greater than), `==` (equal to), `<=` (less than or equal to), `>=` (greater than or equal to) and `!=` (not equal to).\n",
    "\n",
    "- The body of this loop is indented and each line within a basic block must be indented by the same amount (this is Python's way of grouping statements). At the interactive prompt, you have to type a <kbd>Tab</kbd> or space(s) for each indented line. In practice you will prepare more complicated input for python with a text editor & IDE (VS Code, Jupyter, etc.); all decent text editors have an auto-indent facility. When a compound statement is entered interactively, it must be followed by a blank line in order to indicate completion (since the parser cannot guess when you have typed the last line). Note that each line within a basic block must be indented by the same amount.\n",
    "\n",
    "- The `print()` function writes the value of the argument(s) it is given and differs from just writing the expression you want to write in the way it handles multiple arguments, floating point quantities, and strings. Strings are printed without quotes and a space is inserted between items so you can format things nicely."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keyword argument _end_ can be used to avoid the newline after the output, or end the output with a different string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.889653100Z",
     "start_time": "2023-08-28T08:50:50.273906100Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, "
     ]
    }
   ],
   "source": [
    "a, b = 0, 1\n",
    "while a < 1000:\n",
    "    print(a, end=', ')\n",
    "    a, b = b, a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` statements\n",
    "\n",
    "The [`for`](https://docs.python.org/3.10/reference/compound_stmts.html#for) statement in Python iterates over the items of any sequence (list, dictionary, string, ...), in the order that they appear in the sequence. This differs from what you may be used to in C or Pascal where you always iterate over an arithmetic progression of numbers (like in Pascal), or give the user the ability to define both the iteration step and halting condition (as C)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.930560600Z",
     "start_time": "2023-08-28T08:50:50.289532400Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat 3\n",
      "window 6\n",
      "defenestrate 12\n"
     ]
    }
   ],
   "source": [
    "# Measure some strings\n",
    "words = ['cat', 'window', 'defenestrate']\n",
    "for w in words:\n",
    "    print(w, len(w))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You get the colection elements number using `enumerate()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.930560600Z",
     "start_time": "2023-08-28T08:50:50.305157300Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 cat\n",
      "1 window\n",
      "2 defenestrate\n"
     ]
    }
   ],
   "source": [
    "for i, w in enumerate(words):\n",
    "    print(i, w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.951006400Z",
     "start_time": "2023-08-28T08:50:50.305157300Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hans :  active\n",
      "Éléonore :  inactive\n",
      "Charles :  active\n"
     ]
    }
   ],
   "source": [
    "# Create a sample collection\n",
    "users = {'Hans': 'active', 'Éléonore': 'inactive', 'Charles': 'active'}\n",
    "\n",
    "for user, status in users.items():\n",
    "    print(user, \": \", status)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be carfull in code that modifies a collection while iterating over that same collection, it is safer to create a new collection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.951006400Z",
     "start_time": "2023-08-28T08:50:50.311673900Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Hans': 'active', 'Charles': 'active'}"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Strategy:  Create a new collection\n",
    "active_users = {}\n",
    "for user, status in users.items():\n",
    "    if status == 'active':\n",
    "        active_users[user] = status\n",
    "\n",
    "active_users"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To go further, You can find other [Looping Techniques](https://docs.python.org/3.10/tutorial/datastructures.html#tut-loopidioms)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `range()` function\n",
    "\n",
    "If you need to iterate over a sequence of numbers, the built-in function `range()` will come in handy. It generates arithmetic progressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:51.989789500Z",
     "start_time": "2023-08-28T08:50:50.340237500Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:52.015462100Z",
     "start_time": "2023-08-28T08:50:50.340237500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The given end point is never part of the generated sequence; `range(10)` generates 10 values, the legal indices for items of a sequence of length 10. It is possible to let the range start at another number, or to specify a different increment (even negative; sometimes this is called the 'step'):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:52.015462100Z",
     "start_time": "2023-08-28T08:50:50.355858500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 6, 7, 8, 9]\n",
      "[0, 3, 6, 9]\n",
      "[-10, -40, -70]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(5, 10)))\n",
    "print(list(range(0, 10, 3)))\n",
    "print(list(range(-10, -100, -30)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To iterate over the indices of a sequence, you can combine [`range()`](https://docs.python.org/3.10/library/stdtypes.html#range) and [`len()`](https://docs.python.org/3.10/library/functions.html#len) as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:52.031092900Z",
     "start_time": "2023-08-28T08:50:50.355858500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 I\n",
      "1 like\n",
      "2 the\n",
      "3 power\n",
      "4 grid\n",
      "5 studies\n"
     ]
    }
   ],
   "source": [
    "a = ['I', 'like', 'the', 'power', 'grid', 'studies']\n",
    "my_dict = dict()\n",
    "for i in range(len(a)):\n",
    "    print(i, a[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In many ways the object returned by `range()` behaves as if it is a list, but in fact it isn’t. It is an object which returns the successive items of the desired sequence when you iterate over it, but it doesn’t really make the list, thus saving space.\n",
    "\n",
    "We say that such an object is [iterable](https://docs.python.org/3.10/glossary.html#term-iterable), meaning that it is suitable as a target for functions and constructs that expect something from which they can obtain successive elements until the supply is exhausted. We've seen that the [`for`](https://docs.python.org/3.10/reference/compound_stmts.html#for) statement is such a construct, while an example of a function that takes an iterable object is [`sum()`](https://docs.python.org/3.10/library/functions.html#sum):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-28T08:50:52.062310700Z",
     "start_time": "2023-08-28T08:50:50.370883300Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(4)) # 0 + 1 + 2 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Later we will see more functions that return iterables and take iterables as arguments. In chapter [Data Structures](https://docs.python.org/3.10/tutorial/datastructures.html#tut-structures), we will discuss in more detail about [`list()`](https://docs.python.org/3.10/library/stdtypes.html#list).\n",
    "\n",
    "Coming soon ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shallow copy and deep copy in Python\n",
    "\n",
    "We will go through the different way of copying a dataset correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [1, 2, 3]\n",
    "B = A\n",
    "B.append(4)\n",
    "\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case `B` and `A` are both references to the list, so when we modified the list by `B`, the `A` was also changed. Therefore, how to copy the list `A` to `B`? In other words, how could we modify `B` without changing `A` values?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shallow copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "A = [1, 2, 3]\n",
    "# B = A.copy()\n",
    "B = copy.copy(A)  # The same as `B = A.copy()`\n",
    "B.append(4)\n",
    "\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the above example shown, we can use `B = A.copy()` or `B = copy.copy(A)` to implement the copy operation. After that, `B` and `A` are independent with each other. We can modify `B` without affecting `A`.\n",
    "\n",
    "In the previous case, we were assigning operation in python. Meaning that operation on `B` will assign values to `A`. In the assignment case, we do not really create a new list in memory address, it just created a new reference `B` for the list. In other words, `A` and `B` are two references for the same list.\n",
    "\n",
    "With the `copy()` method we do not assign anything. It really created a new list with the same value of the original list. Therefore, we can modify `A` or `B` independently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What does the 'shallow' mean?\n",
    "\n",
    "It means that `B = A.copy()` or `B = copy.copy(A)` are both shallow copy. This term means they can't create a 100 % copy of nested objects, instead it just copies the first level of the nested objects. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [[1, 2], ['a', 'b']]\n",
    "B = copy.copy(A)  # The same as `B = A.copy()`\n",
    "B.append(4)\n",
    "print(A)\n",
    "print(B)\n",
    "\n",
    "B[0].append(3)\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now, the list has two levels. The above results show that the first level was copied, but the second level was still assigned by reference. We can observe that by modifying `B[0]`, the `A[0]` was changed as well. In a nutshell, the `copy.copy()` function only applies to the first level of a nested object. The deep levels are still assigned by reference.\n",
    "\n",
    "This 'lazy' performance can improve efficiency of copy operations and it conforms to Python's design philosophy. Because the copy method needs to create new lists, which costs time.\n",
    "\n",
    "However, what can we do if we really want to totally copy operation?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deep copy\n",
    "\n",
    "We can use `copy.deepcopy()` to copy a nested object completely no matter how many nested levels of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [[1, 2], ['a', 'b']]\n",
    "B = copy.deepcopy(A)\n",
    "\n",
    "B.append(4)\n",
    "print(A)\n",
    "# [[1, 2], ['a', 'b']]\n",
    "print(B)\n",
    "# [[1, 2], ['a', 'b'], 4]\n",
    "\n",
    "B[0].append(3)\n",
    "print(A)\n",
    "# [[1, 2], ['a', 'b']]\n",
    "print(B)\n",
    "# [[1, 2, 3], ['a', 'b'], 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the above example shown, no matter how we modified `B` , `A` will never be affected. Because the `B` is a 100 % copy of `A` , there is no assignment by reference in a `deepcopy()` operation.\n",
    "\n",
    "NB: Because a `deepcopy()` operation always totally copies all nested objects, it will cost lots of time if the objects are too large.\n",
    "\n",
    "In order to improve the efficiency, the `=` operation in Python is designed to pass by reference rather than by value. If we really need to copy objects (pass by value), we should use the `copy.copy()` method for shallow copy or the `copy.deepcopy()` method for deep copy. We must be careful when using `deepcopy()` for large objects, cause it costs lots of time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To go in more details, please check the following short tutorial which can explain in details:\n",
    "- [Shallow Copy and Deep Copy in Python](https://medium.com/techtofreedom/shallow-copy-and-deep-copy-in-python-78c3e7cf2617)\n",
    "- [Shallow and deep copy operations](https://docs.python.org/3.10/library/copy.html#shallow-vs-deep-copy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References for Python's basics\n",
    "\n",
    "If you want to get more insights and learn the basics in Python, please visit the following two very good references:\n",
    "\n",
    "- [Learn X in Y minutes](https://learnxinyminutes.com/docs/python/)\n",
    "- [The Python Tutorial](https://docs.python.org/3/tutorial/)"
   ]
  }
 ],
 "metadata": {
  "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}