notebooks/01_native_python_data_structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&copy; Mirko Piani - *PhD student in Precision Orchard Management (POM), university of Bologna (IT)*\n",
    "___\n",
    "\n",
    "If you are having problems with the notebook, contact me at mirko.piani2@unibo.it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Python [variable](https://www.aees.gov.in/htmldocs/downloads/XI_Class_Content_Computer_Science/8-Handout.pdf) is a reserved memory location to store values within your Random Access Memory (RAM).\n",
    "\n",
    "Each variable has a specified data type, that could be:\n",
    "+ `str` - string\n",
    "+ `int` - integer number\n",
    "+ `float` - floating number\n",
    "+ `bool` - boolean\n",
    "+ native data structures\n",
    "+ non native data structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "variables could have any `<name>`, but it should start with a letter. A data type is assigned to the variable trough the `=` operator.\n",
    "\n",
    "    <name> = <data_type>\n",
    "\n",
    "for further informarion on variables, use this [link](https://www.aees.gov.in/htmldocs/downloads/XI_Class_Content_Computer_Science/8-Handout.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are textual data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a string variable\n",
      "The string this is a string variable is of data type: <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# basic string\n",
    "string_variable = 'this is a string variable'\n",
    "print(string_variable)\n",
    "\n",
    "\n",
    "# f-string - it includes variables data in a string. fo include variable initialize the string with 'f' (=format) and include variables between curcly brackets\n",
    "datatype = f'The string {string_variable} is of data type: {type(string_variable)}'\n",
    "print(datatype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "# string could aslo include numbers, BUT THOSE CANNOT BE DIRECTLY used as numbers\n",
    "\n",
    "numeric_string = '1'\n",
    "another_numeric_string = '2'\n",
    "\n",
    "# use '+' to add the two strings\n",
    "sum_string = numeric_string + another_numeric_string\n",
    "print(sum_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can notice 1 + 2 is not 12, but when using strings the `+` does **string concatenation** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ciao!-- Welcome\n"
     ]
    }
   ],
   "source": [
    "string1 = 'Ciao!'\n",
    "string2 = '-- Welcome'\n",
    "print(f'{string1 + string2}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To sum the numeric string as they have numeric values, it is possible to convert strings to intgeres with the `int()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# string could aslo include numbers, BUT THOSE CANNOT BE DIRECTLY used as numbers\n",
    "\n",
    "numeric_string = '1'\n",
    "another_numeric_string = '2'\n",
    "\n",
    "# use '+' to add the two integers 'int()'\n",
    "sum_int = int(numeric_string) + int(another_numeric_string)\n",
    "print(sum_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can notice  now 1 + 2 is equal to 3, that is right!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Integers** are numbers without decimal positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "int_variable = 1\n",
    "print(int_variable)\n",
    "\n",
    "# f-string - it includes variables data in a string. fo include variable initialize the string with 'f' (=format) and include variables between curcly brackets\n",
    "datatype = type(int_variable)\n",
    "print(datatype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum 5\n",
      "subtraction -1\n",
      "Multiplication 6\n",
      "Integer division 0\n",
      "Division 0.6666666666666666\n",
      "Exponential 8\n"
     ]
    }
   ],
   "source": [
    "# define two integers variables\n",
    "int1 = 2\n",
    "int2 = 3\n",
    "\n",
    "# sum\n",
    "sum_variable = int1 + int2\n",
    "print(f'Sum {sum_variable}')\n",
    "\n",
    "# subtract\n",
    "subtract_variable = int1 - int2\n",
    "print(f'subtraction {subtract_variable}')\n",
    "\n",
    "# multiply\n",
    "multiply_variable = int1 * int2\n",
    "print(f'Multiplication {multiply_variable}')\n",
    "\n",
    "# integer division\n",
    "integer_division_variable = int1 // int2\n",
    "print(f'Integer division {integer_division_variable}')\n",
    "\n",
    "# division\n",
    "division_variable = int1 / int2\n",
    "print(f'Division {division_variable}')\n",
    "\n",
    "# exponential\n",
    "exp_variable = int1 ** int2\n",
    "print(f'Exponential {exp_variable}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# floats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Floats** are numbers with decimal positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.46\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "float_variable = 1.46\n",
    "print(float_variable)\n",
    "\n",
    "# f-string - it includes variables data in a string. fo include variable initialize the string with 'f' (=format) and include variables between curcly brackets\n",
    "datatype = type(float_variable)\n",
    "print(datatype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum 12.304\n",
      "subtraction -8.296000000000001\n",
      "Multiplication 20.6412\n",
      "Integer division 0.0\n",
      "Division 0.1945631067961165\n",
      "Exponential 1286.904996647773\n"
     ]
    }
   ],
   "source": [
    "# define two variables as decimal numbers\n",
    "float1 = 2.004\n",
    "float2 = 10.3\n",
    "\n",
    "# sum\n",
    "sum_variable = float1 + float2\n",
    "print(f'Sum {sum_variable}')\n",
    "\n",
    "# subtract\n",
    "subtract_variable = float1 - float2\n",
    "print(f'subtraction {subtract_variable}')\n",
    "\n",
    "# multiply\n",
    "multiply_variable = float1 * float2\n",
    "print(f'Multiplication {multiply_variable}')\n",
    "\n",
    "# integer division\n",
    "integer_division_variable = float1 // float2\n",
    "print(f'Integer division {integer_division_variable}')\n",
    "\n",
    "# division\n",
    "division_variable = float1 / float2\n",
    "print(f'Division {division_variable}')\n",
    "\n",
    "# exponential\n",
    "exp_variable = float1 ** float2\n",
    "print(f'Exponential {exp_variable}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"data:image/png;base64,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\" />\n",
    "\n",
    "\n",
    "\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Booleans are `True`, `False` or 0 and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "bool_variable = True\n",
    "print(type(bool_variable))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*AND*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(True and False)\n",
    "print(True and True)\n",
    "print(False and False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*OR*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(True or False)\n",
    "print(True or True)\n",
    "print(False or False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are ordered elements, with data accessible trough their **index*, which is the position of the element in the list\n",
    "\n",
    "![list-index](https://i.ytimg.com/vi/KAXvMbD1Zac/maxresdefault.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "# define a list with square brackets\n",
    "list_variable = ['1', 1, 1.11, [1, 'a']]\n",
    "\n",
    "print(type(list_variable))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# access first element in the list\n",
    "print(list_variable[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1.11, [1, 'a']]\n"
     ]
    }
   ],
   "source": [
    "# access 2nd to 4th elements in the list\n",
    "print(list_variable[1 : 5])  # first ndex is included, last index is ALWAYS exclusinve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lists are mutable**, meaning you can change their content (add, remove, or modify elements)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', 1, 1.11, [1, 'a']]\n",
      "['1', 1, 1.11, [1, 'a'], 'new_string']\n"
     ]
    }
   ],
   "source": [
    "print(list_variable)\n",
    "\n",
    "# add a value to a list\n",
    "list_variable.append('new_string')\n",
    "\n",
    "print(list_variable)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 is type <class 'str'>\n",
      "1 is type <class 'int'>\n",
      "1.11 is type <class 'float'>\n",
      "[1, 'a'] is type <class 'list'>\n",
      "new_string is type <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# explore the type of each item in the list\n",
    "for item in list_variable:\n",
    "    # the indentation allows to perform the same operation for each loop\n",
    "    print(f'{item} is type {type(item)}')  # the indentation defines a second order algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before: ['1', 1, 1.11, [1, 'a'], 'new_string']\n",
      "\n",
      "after: ['1', 33, 1.11, [1, 'a'], 'new_string']\n"
     ]
    }
   ],
   "source": [
    "print(f'before: {list_variable}')\n",
    "\n",
    "# change value of the second indexed element\n",
    "list_variable[1] = 33\n",
    "\n",
    "print(f'\\nafter: {list_variable}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before: ['1', 33, 1.11, [1, 'a'], 'new_string']\n",
      "\n",
      "after: ['1', 33, 1.11, 'inserted_value', [1, 'a'], 'new_string']\n"
     ]
    }
   ],
   "source": [
    "print(f'before: {list_variable}')\n",
    "\n",
    "# introduce a new element at the index 3 without deleting other elements\n",
    "list_variable.insert(3, 'inserted_value')  # index, value to add\n",
    "\n",
    "print(f'\\nafter: {list_variable}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explore other possible operations with list [here](https://www.naukri.com/code360/library/what-are-the-python-list-operations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "# define a list with rounded brackets\n",
    "tuple_variable = ('1', 1, 1.11, [1, 'a'])\n",
    "print(type(tuple_variable))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explore operations with tuples at this [link](https://www.tutorialspoint.com/python/python_tuples.htm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tuples are NOT mutable**, meaning you can't change their content (add, remove, or modify elements)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before: ('1', 1, 1.11, [1, 'a'])\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[26], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbefore: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtuple_variable\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m      3\u001b[0m \u001b[38;5;66;03m# it will raise an error since we try to change the second value in the tuple (operation not allowed)\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m \u001b[43mtuple_variable\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m33\u001b[39m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "print(f'before: {tuple_variable}')\n",
    "\n",
    "# it will raise an error since we try to change the second value in the tuple (operation not allowed)\n",
    "tuple_variable[1] = 33\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see ***TypeError: 'tuple' object does not support item assignment***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "# initialise a dictionary with curly brackets\n",
    "dictionary_variable = {}\n",
    "\n",
    "print(dictionary_variable)\n",
    "print(type(dictionary_variable))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary is a particular data type that allows the assignment of **items** structured as **key : value** pairs.\n",
    "\n",
    "Keys and values could be of whatever data type: string, integers, float, list, tuples, dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key': 1}\n"
     ]
    }
   ],
   "source": [
    "dictionary_variable = {'key' : 1}\n",
    "\n",
    "print(dictionary_variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key': 1, 1: 0, 'list': [1, 2, 3, 4, 5, 6]}\n"
     ]
    }
   ],
   "source": [
    "# add an item to the dictionary\n",
    "dictionary_variable.update({1 : 0})\n",
    "dictionary_variable.update({'list' : [1,2,3,4,5,6]})\n",
    "\n",
    "print(dictionary_variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['key', 1, 'list'])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the dictionary keys\n",
    "dictionary_variable.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([1, 0, [1, 2, 3, 4, 5, 6]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the dictionary values\n",
    "dictionary_variable.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('key', 1), (1, 0), ('list', [1, 2, 3, 4, 5, 6])])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the dictionary items\n",
    "dictionary_variable.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as you can porbably noticed, by calling the methods `keys()`, `values()`, `items()` the output contains lists and tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# accessing data by 'key'\n",
    "my_value = dictionary_variable['list']\n",
    "print(my_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Sets](https://www.w3schools.com/python/python_sets.asp) are particular data type that **do not allow the presence of duplicated data**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'cherry', 'apple', 'banana'}\n"
     ]
    }
   ],
   "source": [
    "# a set is defined with curly brackets, but it is not structured in key : value pairs as dictionaries\n",
    "set_variable = {\"apple\", \"banana\", \"cherry\", \"apple\"}\n",
    "print(set_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you may notice, \"apple\" string was duplicated, but the set is showing the string just once. It tells that the data is at least once inside the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 7}\n"
     ]
    }
   ],
   "source": [
    "# get unique values in a list\n",
    "numeric_list = [5, 5, 5, 5, 5, 5, 5, 7, 7, 1, 1, 1, 1, 1, 2, 3, 4]\n",
    "set_list = set(numeric_list)\n",
    "print(set_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you may notice, the set gives also an order to its values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[47], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# access the fourth element in the set\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mset_list\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m]\u001b[49m)\n",
      "\u001b[0;31mTypeError\u001b[0m: 'set' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "# access the fourth element in the set\n",
    "print(set_list[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is not possible to directly access set's data, it is at first needed to convert the set into a list wich is indexed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "back_to_list = list(set_list)\n",
    "\n",
    "# access the fourth element in the set\n",
    "print(back_to_list[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Non-native python data structures\n",
    "+ [Numpy arrays](https://numpy.org/)\n",
    "+ [Pandas dataframes](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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": 2
}