Intro Python - Data types 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LAB |  Intro Python Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![elgif](https://media.giphy.com/media/coxQHKASG60HrHtvkt/giphy.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this course, we will use Jupyter notebooks to write and execute Python code, so the first step will be to learn how to use them.\n",
    "Notebook documents (or \"notebooks\", all in lowercase) are documents created by the Jupyter Notebook application, which contain both computer code (for example, Python) and rich text elements (paragraphs, equations, figures, links, etc...).\n",
    "Notebooks are made up of cells, which are blocks of code or rich text. Each of these is editable, although you will primarily be modifying code cells to answer questions.\n",
    "\n",
    "### Technical Description of a Jupyter Notebook\n",
    "\n",
    "The Jupyter Notebook application is a server-client application that allows editing and executing notebook documents through a web browser. The IBM version of the Jupyter Notebook application is installed on a remote server and is accessed through the internet.\n",
    "\n",
    "A notebook kernel is a \"computational engine\" that executes the code contained in a notebook document. The ipython kernel, mentioned in this guide, runs Python code. There are kernels for many other languages (see the Kernels menu above).\n",
    "\n",
    "When you open a notebook document, the associated kernel starts automatically. By running the notebook (either cell by cell or through the Cell -> Run All menu), the kernel performs the calculations and produces the results. Depending on the type of calculations, the kernel can consume a significant amount of CPU and RAM. Keep in mind that the RAM is not released until the kernel is closed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction to PEP-8 and `import this`\n",
    "\n",
    "#### PEP-8\n",
    "\n",
    "[PEP-8](https://peps.python.org/pep-0008/), also known as \"Python Enhancement Proposal 8\", is the style guide for writing code in Python. It was conceived to facilitate the reading and understanding of code, promoting consistency in the way Python programmers write their code. Some of the key principles of PEP-8 include using indents of four spaces, lines that do not exceed 79 characters, and the definition of functions and variables in lowercase names separated by underscores. It is highly recommended to adhere to PEP-8 to maintain clean and readable Python code.\n",
    "\n",
    "#### `import this`\n",
    "\n",
    "The command `import this` or [PEP-20](https://peps.python.org/pep-0020/) in Python is a little \"easter egg\" included in the language, which when executed, displays the **\"Zen of Python\"**. The \"Zen of Python\" is a collection of 19 aphorisms that express the design philosophy of the Python language. Some of these aphorisms emphasize the importance of code readability and simplicity over complexity. You can see these aphorisms at any time while programming in Python by executing the command `import this` in your Python console or script.\n",
    "\n",
    "To use it, simply type the following command in your Python interpreter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![otrogif](https://media.giphy.com/media/MT5UUV1d4CXE2A37Dg/giphy.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Cell-types-in-Jupyter-Notebook\" data-toc-modified-id=\"Cell-types-in-Jupyter-Notebook-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Cell types in Jupyter Notebook</a></span></li><li><span><a href=\"#Sub-título\" data-toc-modified-id=\"Sub-título-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Sub-título</a></span><ul class=\"toc-item\"><li><span><a href=\"#Sub-título\" data-toc-modified-id=\"Sub-título-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Sub título</a></span></li><li><span><a href=\"#Code\" data-toc-modified-id=\"Code-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Code</a></span></li><li><span><a href=\"#Shortcuts\" data-toc-modified-id=\"Shortcuts-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Shortcuts</a></span></li></ul></li><li><span><a href=\"#Integer-numbers\" data-toc-modified-id=\"Integer-numbers-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Integer numbers</a></span></li><li><span><a href=\"#Real-numbers-(floats)\" data-toc-modified-id=\"Real-numbers-(floats)-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Real numbers (floats)</a></span></li><li><span><a href=\"#Basic-operations\" data-toc-modified-id=\"Basic-operations-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Basic operations</a></span><ul class=\"toc-item\"><li><span><a href=\"#built-in-and-imported-things\" data-toc-modified-id=\"built-in-and-imported-things-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>built-in and imported things</a></span></li></ul></li><li><span><a href=\"#Strings-(character-strings)\" data-toc-modified-id=\"Strings-(character-strings)-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Strings (character strings)</a></span><ul class=\"toc-item\"><li><ul class=\"toc-item\"><li><span><a href=\"#icons\" data-toc-modified-id=\"icons-6.0.1\"><span class=\"toc-item-num\">6.0.1&nbsp;&nbsp;</span>icons</a></span></li></ul></li></ul></li><li><span><a href=\"#Casting-in-Python\" data-toc-modified-id=\"Casting-in-Python-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Casting in Python</a></span><ul class=\"toc-item\"><li><span><a href=\"#Implicit-conversion\" data-toc-modified-id=\"Implicit-conversion-7.1\"><span class=\"toc-item-num\">7.1&nbsp;&nbsp;</span>Implicit conversion</a></span></li><li><span><a href=\"#explicit-conversion\" data-toc-modified-id=\"explicit-conversion-7.2\"><span class=\"toc-item-num\">7.2&nbsp;&nbsp;</span>explicit conversion</a></span><ul class=\"toc-item\"><li><span><a href=\"#Convert-float-to-int\" data-toc-modified-id=\"Convert-float-to-int-7.2.1\"><span class=\"toc-item-num\">7.2.1&nbsp;&nbsp;</span>Convert float to int</a></span></li><li><span><a href=\"#Convert-a-float-to-a-string\" data-toc-modified-id=\"Convert-a-float-to-a-string-7.2.2\"><span class=\"toc-item-num\">7.2.2&nbsp;&nbsp;</span>Convert a float to a string</a></span></li><li><span><a href=\"#Convert-int-to-str\" data-toc-modified-id=\"Convert-int-to-str-7.2.3\"><span class=\"toc-item-num\">7.2.3&nbsp;&nbsp;</span>Convert int to str</a></span></li></ul></li></ul></li><li><span><a href=\"#Input-and-output-data\" data-toc-modified-id=\"Input-and-output-data-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Input and output data</a></span><ul class=\"toc-item\"><li><span><a href=\"#Input\" data-toc-modified-id=\"Input-8.1\"><span class=\"toc-item-num\">8.1&nbsp;&nbsp;</span>Input</a></span></li><li><span><a href=\"#Print\" data-toc-modified-id=\"Print-8.2\"><span class=\"toc-item-num\">8.2&nbsp;&nbsp;</span>Print</a></span></li></ul></li><li><span><a href=\"#Format\" data-toc-modified-id=\"Format-9\"><span class=\"toc-item-num\">9&nbsp;&nbsp;</span>Format</a></span><ul class=\"toc-item\"><li><span><a href=\"#Format---1\" data-toc-modified-id=\"Format---1-9.1\"><span class=\"toc-item-num\">9.1&nbsp;&nbsp;</span>Format - 1</a></span></li><li><span><a href=\"#Format---2\" data-toc-modified-id=\"Format---2-9.2\"><span class=\"toc-item-num\">9.2&nbsp;&nbsp;</span>Format - 2</a></span></li></ul></li><li><span><a href=\"#Strings\" data-toc-modified-id=\"Strings-10\"><span class=\"toc-item-num\">10&nbsp;&nbsp;</span>Strings</a></span><ul class=\"toc-item\"><li><span><a href=\"#String-methods\" data-toc-modified-id=\"String-methods-10.1\"><span class=\"toc-item-num\">10.1&nbsp;&nbsp;</span>String methods</a></span></li></ul></li><li><span><a href=\"#Data-structures\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## 1. Cell types in Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ctrl-enter`: executes the active cell and stays in that cell\n",
    "\n",
    "`shift-enter`: executes the active cell and moves to the next cell\n",
    "\n",
    "*Try it* Execute the following cells:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print (\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Second line\n"
     ]
    }
   ],
   "source": [
    "print (\"Second line\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Changed the cell to a Markdown and then enter to confirm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Inserting New Cells:**\n",
    "When a cell is selected in blue (click on the left margin of the cell) or, if you are editing the cell, press the escape key, a blue box appears around it.\n",
    "\n",
    "Type:\n",
    "- `a` (above) to create a new empty cell above the active cell at that time\n",
    "- `b` (below) to create a new empty cell below the active cell at that time\n",
    "\n",
    "*Try it: Add a cell below and then a cell above*\n",
    "\n",
    "**Markdown Code:**\n",
    "The `m` shortcut (with the selection in blue) changes the computing cell to markdown. This allows creating rich text elements to document the code.\n",
    "Conversely, you can convert a cell into a code cell using the `y` shortcut.\n",
    "\n",
    "*Try it: Convert the first cell below into a code cell and run it, and the cell below into a markdown cell*\n",
    "\n",
    "#### **Not a code cell right now:**\n",
    "print(\"Now it is a code cell :)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testing a markdown cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### **This is a cell for coding**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Exercise: Converting Code to Markdown**\n",
    "\n",
    "In this exercise, your task will be to convert the following code cells that contain headings and rich text into markdown cells. This way, instead of appearing as a block of code, they will be displayed as formatted text.\n",
    "\n",
    "1. Select the first cell that contains the headings and the rich text written as code.\n",
    "2. Use the `m` shortcut (making sure the cell is highlighted in blue) to convert the code cell into a markdown cell.\n",
    "3. Press `Shift+Enter` or `Ctrl+Enter` to run the cell and see the result.\n",
    "4. If you've done the step correctly, you should see the headings and rich text (bold, italics, etc.) applied instead of as a block of code.\n",
    "\n",
    "*Try it: Convert the cells with the headings and rich text from code to markdown and run them to see the result.*\n",
    "\n",
    "Remember, the cells should look just like the example cells provided below.\n",
    "\n",
    "Good luck!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "# Header 1\n",
    "## Header 2\n",
    "### Header 3\n",
    "#### Header 4\n",
    "\n",
    "**bold**\n",
    "\n",
    "*italic*\n",
    "\n",
    "a blank line is a paragraph\n",
    "\n",
    "this is a new paragraph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (2994576558.py, line 7)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[15], line 7\u001b[0;36m\u001b[0m\n\u001b[0;31m    **bold**\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# I want to see this code\n",
    "# Header 1\n",
    "## Header 2\n",
    "### Header 3\n",
    "#### Header 4\n",
    "\n",
    "**bold**\n",
    "\n",
    "*italic*\n",
    "\n",
    "a blank line is a paragraph\n",
    "\n",
    "this is a new paragraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have successfully converted the cell to a markdown cell, it should be displayed just like the cell below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Header 1\n",
    "## Header 2\n",
    "### Header 3\n",
    "#### Header 4\n",
    "\n",
    "**bold**\n",
    "\n",
    "*italic*\n",
    "\n",
    "a blank line is a paragraph\n",
    "\n",
    "this is a new paragraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Explanation of Markdown Elements\n",
    "\n",
    "In the provided example, there are two very useful and common Markdown elements: links and images.\n",
    "\n",
    "1. **Link**\n",
    "   The first line `[name](url)` is a link. The syntax for creating a link is to place the link text between square brackets `[]` and the URL between parentheses `()`. Clicking on the text \"This is Google\" will take you to the Google Spain web page.\n",
    "\n",
    "2. **Image**\n",
    "   The second line `![name](url image)` is an image. The syntax for inserting an image is very similar to that of a link, but it starts with an exclamation mark `!`. The text between square brackets `[]` serves as an alternative description for the image, which is displayed if the image cannot be rendered for any reason. In this case, when running the cell, you will see the text \"This is an image (which will not render)\" if the image cannot be loaded from the provided URL.\n",
    "\n",
    "You can try these elements for yourself in any markdown cell. Give it a try!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Link**\n",
    "[This is google](https://www.google.com.ar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Image**:\n",
    "![This image (won't render)](https://m.facebook.com/IronhackSpain/photos/a.644771729221628/1108169482881848/?type=3&source=44&ref=py_c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shortcuts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Final Keyboard Shortcut Reminder**\n",
    "\n",
    "To execute the cell:\n",
    "\n",
    "- `ctrl + enter`\n",
    "- `shift + enter` # this executes the cell and moves to the next one\n",
    "\n",
    "To insert new cells:\n",
    "\n",
    "- `a` for a new cell above\n",
    "- `b` for a new cell below\n",
    "- `d + d` for shortcut mode (deletes the selected cell)\n",
    "\n",
    "To toggle between markdown and code:\n",
    "\n",
    "- `m` or `y` to switch between markdown and code\n",
    "\n",
    "# Type of Data\n",
    "In this section, we will explore different types of data you can encounter and use in Python. Understanding the different types of data is fundamental to working effectively with Python.\n",
    "\n",
    "- **Integers**: These are numbers without decimal points, and can be either positive or negative. For example, -3, 0, 42 are all integers.\n",
    "\n",
    "- **Floating-point Numbers (Float)**: These are numbers that contain decimal points or are written in scientific notation. They include values like 3.14, -0.001, or 2.5e2.\n",
    "\n",
    "- **Strings**: Strings are sequences of characters (letters, numbers, symbols, emojis) enclosed in single (`'`) or double (`\"`) quotes. For example, \"Hello, World\" or 'Python3' are strings.\n",
    "\n",
    "- **Booleans (Boolean)**: Boolean values can only be `True` (true) or `False` (false), and represent the outcome of logical operations.\n",
    "\n",
    "Remember, Python is a dynamically typed and strongly typed language, which means you do not need to explicitly declare the data type of a variable; Python will infer it for you.\n",
    "\n",
    "\n",
    "## Integer Numbers\n",
    "Integer numbers, also known as \"integers\" in English, are a type of data that represents whole numbers, that is, without decimals. They can be both positive and negative. In Python, you can assign an integer value to a variable simply by writing the number without any decimal or quotes. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "an_integer = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this cell, we are declaring a variable called `an_integer` and assigning it the value 4, which is an integer number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "an_integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we are simply writing the name of the variable. This will make the Jupyter notebook print its value, which is 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(an_integer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this cell, we are using the `print()` function to print the value of the variable `an_integer`. You will also see 4 as output here, but unlike the previous cell, you are specifically using a function to print the value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 10\n",
    "b = 20\n",
    "a\n",
    "b # Notebook prints last value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this set of lines, first we assign 10 to `a` and 20 to `b`. Then, we write `a` and `b` on separate lines, but the Jupyter notebook will only print the value of `b`, since it is the last one in the cell. This is indicated with the comment # Notebook prints the last value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 10\n",
    "b = 20\n",
    "print(a)\n",
    "b # Notebook prints last value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, it is similar to the previous cell, but this time we are using the `print()` function to print the value of `a` before simply writing `b`. You will see both 10 (the output of `print(a)`) and 20 (the value of `b`) in the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we are using the `type()` function to print the data type of the variable `a`, which in this case is `<class 'int'>`, indicating that it is an integer number."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Real numbers (floats)\n",
    "In this section, we are going to explore another data type in Python: real numbers, also known as \"floats.\" Floats can represent fractional numbers, meaning numbers that have both an integer part and a decimal part. They can be both positive and negative.\n",
    "\n",
    "In Python, you can create a float by simply including a decimal point in the number, or by using scientific notation for very large or very small numbers. Here are some examples:\n",
    "\n",
    "x = 5.67\n",
    "\n",
    "y = -0.23\n",
    "\n",
    "z = 3.0e8\n",
    "\n",
    "In this code:\n",
    "- `x` is a float representing the number 5.67.\n",
    "- `y` is a float representing the number -0.23.\n",
    "- `z` is a float representing the number 300,000,000 (or 3.0 × 10^8, using scientific notation).\n",
    "\n",
    "Just like with integers, you can use the `type()` function to check the data type of a variable. For example, `type(x)` will return `<class 'float'>`, indicating that `x` is a float.\n",
    "\n",
    "Floats are useful when you need to perform calculations that require decimal precision. Now, let's practice working with floats in Python with some exercises."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 12.34\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous cell, we assigned the float number 12.34 to the variable `a`. Now, let's print the value of `a` to verify it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.34\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's use the `type()` function to check the data type of the variable `a`. This should confirm that it is a float number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 12.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, try to predict the data type of the variable `b` before verifying it with the `type()` function. Do you think it is:\n",
    "- **int?**\n",
    "- **float?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this last cell, we verify the data type of `b` using the `type()` function. Although `b` has a value that could be an integer, it is considered a float because it includes a decimal point."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Basic operations\n",
    "In this section, we will explore some basic operations in Python. We will learn how to perform addition, subtraction, division, and how to obtain the modulus and floor division. We will also see how we can use the modulus to determine if a number is even or odd. Let's start with some practical exercises!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous cell, we simply added 10 and 3 directly in a code cell. Now, we will do the same, but using the variables `a` and `b` that we have defined previously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sum\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will proceed to perform a subtraction using the same variables, `a` and `b`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# difference\n",
    "\n",
    "a - b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will explore how to perform divisions in Python. First, we will perform a regular division and then check the data type of the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.3333333333333335\n"
     ]
    }
   ],
   "source": [
    "# division\n",
    "\n",
    "division = a / b\n",
    "print(division)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(division)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's learn about \"floor division,\" which rounds the result of the division down to the nearest integer. We will also check the data type of the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# division: floor division: rounded division\n",
    "\n",
    "floor_division = a // b\n",
    "floor_division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(floor_division)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will explore the modulo operator (`%`), which gives us the remainder of a division. First, we will find the modulo of `a` divided by `b`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Module: Remainder of the division\n",
    "\n",
    "a % b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To better understand how divisions and the modulo operator work, we will print the values of `a` and `b`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will use the modulo operator to determine if the numbers in a list are even or odd. If a number divided by 2 yields a remainder of 0, then it is even. Let's create a loop that iterates over a list of numbers and tells us if each number is even or odd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number 1 is NOT even\n",
      "the number 2 is even\n",
      "the number 3 is NOT even\n",
      "the number 4 is even\n",
      "the number 5 is NOT even\n",
      "the number 6 is even\n"
     ]
    }
   ],
   "source": [
    "# Even / odd -> modulo (remainder)\n",
    "# If the remainder of a division by two is zero: even\n",
    "\n",
    "\n",
    "list_ = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "for i in list_:\n",
    "    if i % 2 == 0:\n",
    "        print(f\"the number {i} is even\")\n",
    "    else:\n",
    "        print(f\"the number {i} is NOT even\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practical Exercise\n",
    "Now that we have explored some basic operations in Python, it's your turn to give it a try.\n",
    "\n",
    "**Instructions:**\n",
    "1. Create two new variables, `x` and `y`, and assign any integer number to each of them.\n",
    "2. Perform the following operations using these variables:\n",
    "   - Addition\n",
    "   - Subtraction\n",
    "   - Multiplication\n",
    "   - Division and check the type of result\n",
    "   - Floor division and check the type of result\n",
    "   - Find the modulo (remainder of division)\n",
    "3. Use a `for` loop to iterate over a list of numbers from 1 to 10 and print whether each number is even or odd.\n",
    "\n",
    "Don't forget to print the results to verify your solutions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "<class 'int'>\n",
      "the number 1 is NOT even\n",
      "the number 2 is even\n",
      "the number 3 is NOT even\n",
      "the number 4 is even\n",
      "the number 5 is NOT even\n",
      "the number 6 is even\n",
      "the number 7 is NOT even\n",
      "the number 8 is even\n",
      "the number 9 is NOT even\n",
      "the number 10 is even\n"
     ]
    }
   ],
   "source": [
    "# your solution here\n",
    "x = 30\n",
    "y = 20\n",
    "x + y\n",
    "x - y\n",
    "x * y\n",
    "x / y\n",
    "print (type(x / y))\n",
    "x // y\n",
    "print (type(x // y))\n",
    "x % y\n",
    "\n",
    "list_ = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "for i in list_:\n",
    "    if i % 2 == 0:\n",
    "        print(f\"the number {i} is even\")\n",
    "    else:\n",
    "        print(f\"the number {i} is NOT even\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### built-in and imported things\n",
    "\n",
    "In the world of Python, you will often work with different methods and functions to perform specific tasks in your code. \"Methods\" and \"functions\" are essentially things that perform actions (or, as we colloquially say, \"things that do things\"). Below, we'll explore two main categories of these: built-in things and imported things (*summary: methods = functions = things that do things*).\n",
    "\n",
    "- **Built-in methods:**\n",
    "These are functions or things that are already included in Python when you install it. You don't need to install anything extra to use them. Some examples are the `print` and `sum` methods.\n",
    "\n",
    "- **Imported things:**\n",
    "Sometimes, you might need to use functions or things that are not directly built into Python. In these cases, you'll need to import them from an external library. Before you can use these functions, you'll need to install the corresponding library with a `pip install` or `conda install` command, and then import it into your script.\n",
    "\n",
    "Below, we'll explore some examples of both types of \"things\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is built-in\n"
     ]
    }
   ],
   "source": [
    "# First, let's explore a built-in method: print\n",
    "# The print method allows us to print messages to the console.\n",
    "print(\"This is built-in\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THIS IS A STRING'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Another example of a built-in method is upper.\n",
    "# This method converts a string of text to uppercase.\n",
    "\"This is a string\".upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now, let's explore how to import and use things from an external library.\n",
    "# First, we need to import the library. In this case, we're importing the math library.\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8789"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Next, we use a function from the math library: floor.\n",
    "# The floor function rounds a number down to the nearest integer.\n",
    "math.floor(8789.098767)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Strings (character strings)\n",
    "\n",
    "Character strings, also known as \"strings,\" are a sequence of characters, which can include letters, numbers, symbols, and even emojis. Strings can be enclosed in double or single quotes, and we can even define multi-line strings using triple quotes. Below, we'll explore various examples and features of strings in Python.\n",
    "\n",
    "Examples of defining a string with different types of quotes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a string'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"This is a string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a string with simple quotes'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'This is a string with simple quotes'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a string with simple quotes'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"This is a string with simple quotes\" #End Of Line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign a string to a variable, as shown here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "this_is_also_a_string = \"4\"\n",
    "this_is_also_a_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check the type of a variable using the `type` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(this_is_also_a_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attempting to create a multi-line string without triple quotes will result in an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"This is a string\n",
    "with multiple lines\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create a multi-line `string` correctly, we should use triple quotes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThis is a string\\nwith multiple liness'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "This is a string\n",
    "with multiple liness\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also print a multi-line `string` using the print function and triple quotes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "This is a string\n",
      "with multiple liness\n"
     ]
    }
   ],
   "source": [
    "print(\"\"\"\n",
    "This is a string\n",
    "with multiple liness\"\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### icons\n",
    "Strings can contain emojis, as shown here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'😍'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"😍\" #emojis -> They are strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "heart_face = \"😍\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'😍'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heart_face"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(heart_face)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Casting in Python\n",
    "\n",
    "Type conversion, also known as \"casting,\" refers to the process of converting one data type to another. Previously, we have seen data types such as `int`, `string`, or `float`. Well, it turns out that it's possible to convert from one type to another. But first, let's look at the different types of conversions or type transformations that can be performed. There are two:\n",
    "\n",
    "**Implicit conversion:** This is done automatically by Python. It occurs when we perform certain operations with two different types, Python converts it in the background without the need for the programmer to explicitly indicate it.\n",
    "\n",
    "**Explicit conversion:** We do this explicitly, such as converting a `str` to `int` with `int()` or to `float` with `float()`. This type of conversion is done using predefined Python functions.\n",
    "\n",
    "It's important to note that not all data types can be safely converted between each other. For example, trying to convert a text string containing letters to an integer will result in an error. Therefore, it's always a good practice to handle potential errors using exception control structures, which we'll see later in the course.\n",
    "\n",
    "Let's see some examples of each to better understand how they work!\n",
    "\n",
    "### Implicit conversion\n",
    "This type of conversion is done automatically by Python, practically without us noticing. However, it's important to know what's happening under the hood to avoid future problems.\n",
    "\n",
    "The simplest example where we can see this behavior is as follows:\n",
    "- `a` is an `int`\n",
    "- `b` is a `float`\n",
    "\n",
    "But if we add `a` and `b` and store the result in `a`, we can see how Python has internally converted the `int` to `float` to perform the operation, and the resulting variable is a `float`. However, there are other cases where Python is not as smart and is unable to perform the conversion. If we try to add an `int` to a `string`, we'll get a `TypeError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5       # This is a int\n",
    "b = 4.5     # This is a float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a + b   # Python automatically converts a to float to perform the operation\n",
    "print(c)    # The result, 9.5, is a float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# But, if we try to perform an operation between a string and an integer:\n",
    "d = \"Hola\" + a  # This will cause a TypeError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### explicit conversion\n",
    "\n",
    "On the other hand, we can perform explicit conversions between types or castings using different functions provided by Python. The most commonly used ones are:\n",
    "\n",
    "`float()`, `str()`, `int()`, `list()`, `set()`\n",
    "\n",
    "#### Convert float to int\n",
    "\n",
    "To convert from float to int we should use `int()`. But be careful, because the integer type cannot store decimals, so we'll lose whatever comes after the decimal point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of explicit conversion\n",
    "float_number = 5.7\n",
    "int_number = int(float_number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.7\n"
     ]
    }
   ],
   "source": [
    "print(float_number)  # The result will be 5, losing the decimal part."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "#### Convert a float to a string\n",
    "Podemos convertir un float a un string de texto utilizando `str()`. Podemos ver en el siguiente código cómo cambia el tipo de `a` después de la conversión."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# Example of converting a float to a string\n",
    "a = 3.14159\n",
    "print(type(a))  # This will print: <class 'float'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "3.14159\n"
     ]
    }
   ],
   "source": [
    "a = str(a)\n",
    "print(type(a))  # This will print: <class 'str'>\n",
    "print(a)        # This will print: 3.14159, but now as a string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "#### Convert int to str\n",
    "Just like the conversion to float we saw earlier, we can convert from int to str using `str()`. Let's see an example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# Example of converting an integer to a string\n",
    "a = 42\n",
    "print(type(a))  # This will print: <class 'int'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "a = str(a)\n",
    "print(type(a))  # This will print: <class 'str'>\n",
    "print(a)        # This will print: \"42\", but now as a string.\n",
    "\n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "Now it's your turn to try converting from int to str. Perform the following tasks:\n",
    "\n",
    "1. Create a variable `age` and assign your age as an integer.\n",
    "2. Convert the variable `age` to a string using the `str()` function.\n",
    "3. Concatenate the string \"My age is: \" with the variable `age` (now a string) and store the result in a new variable called `message`.\n",
    "4. Print the variable `message` to the console.\n",
    "\n",
    "Below is a basic outline you can use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My age is: 41\n"
     ]
    }
   ],
   "source": [
    "# Step 1: Create a variable age with your age as an integer\n",
    "age = 41\n",
    "\n",
    "# Step 2: Convert the variable age to a string\n",
    "age = str(age)\n",
    "\n",
    "# Step 3: Concatenate \"My age is: \" with the variable age and store the result in a new variable called message\n",
    "message = \"My age is: \" + age\n",
    "\n",
    "# Step 4: Print the variable message\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Input and output data\n",
    "\n",
    "In the development of programs, we often need to interact with users by allowing them to input data and displaying results or messages. Python provides simple and straightforward methods to achieve this, making it easy to create interactive and user-friendly scripts. Below, we will explore how we can accomplish this using Python.\n",
    "\n",
    "### Input\n",
    "\n",
    "To assign a variable to a value entered by the user from the console, we use the `input()` function. This function can take an optional argument: the message or prompt that you want to display on the screen to guide the user on what type of information is expected to be entered. It's essential to note that, regardless of the type of data the user enters, the `input()` function will always return a string. Here's the basic outline of how it works:\n",
    "\n",
    "`input(message)`: Displays the message on the terminal and returns a string with the user's input.\n",
    "\n",
    "Often, it may be necessary to convert this string to a different data type, depending on how you plan to use the entered value in your script. This can be done using type conversion techniques, or \"casting,\" which we discussed in earlier sections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hu'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "salutation = input()\n",
    "salutation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora, vamos a personalizar el mensaje que aparece cuando pedimos una entrada al usuario utilizando el argumento `prompt` de la función `input()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "salutation = input(prompt = \"This is a prompt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's continue by requesting more information from the user, such as their name and a number. Then, we'll experiment with the operations we can perform with these inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'guille'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = input(\"Write here your name: \")\n",
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'guille'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number = input(\"Write here your number: \")\n",
    "number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When trying to operate with a string representing a number, we'll see that it doesn't behave like a real number. For example, if we try to multiply it by 10 or divide it by 2, we'll get errors or undesired behaviors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'guilleguilleguilleguilleguilleguilleguilleguilleguilleguille'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will generate an error because we're trying to divide a string.\n",
    "number / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To avoid these problems, we can convert the input to a number using the `int()` function. Once the input is an integer, we can perform numerical operations with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number = int(input(\"Write here your number: \"))\n",
    "number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(number / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Final Reflections**\n",
    "\n",
    "It's important to anticipate potential issues in user inputs and manage them properly to avoid errors during execution. One way to do this is through defensive programming, where the validity of inputs is checked before proceeding with operations. Additionally, we can use flow control structures, such as `if/else`, and error handling with `try/except` to handle unexpected situations more elegantly.\n",
    "\n",
    "Considerations:\n",
    "- Anticipate a potential problem -> Defensive programming.\n",
    "- Ensure the number is an integer before performing operations that require integers.\n",
    "- Use conditional logic (`if/else`) to handle different cases.\n",
    "- Proactively handle errors using `try/except` to prevent failures during execution.\n",
    "\n",
    "### Print\n",
    "\n",
    "The `print()` function is used to write the specified message to the screen or another standard output device.\n",
    "\n",
    "The message can be a string or any other object; the object will be converted to a string before being written to the screen. Let's explore some of the functionalities and peculiarities of the `print()` function.\n",
    "\n",
    "**Observations**:\n",
    "\n",
    "- **OUR FRIEND**: The `print()` function is a fundamental tool for debugging code. It allows us to visualize the values of different variables at various points in our code, making it easier to identify errors or \"bugs\".\n",
    "- **Debugging**: It's the process of identifying and fixing errors in the code. Using `print()` is one of the simplest ways to \"debug\", that is, to search for and fix errors in the code.\n",
    "\n",
    "Let's see how it works in the following code snippet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting = \"Hellooooo\"\n",
    "type(greeting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hellooooo\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(print(greeting))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reflections\n",
    "You'll notice that when we use `print()`, the type it returns is `NoneType`. This is because `print()` is a function that performs an action (printing something to the console) but does not return any value (its return is `None`). This is an important distinction, especially when compared with functions that do return values.\n",
    "\n",
    "#### Warning\n",
    "- It's crucial to remember that `print()` prints to the console but does not return a value that can be used in subsequent operations in the code.\n",
    "\n",
    "## Format\n",
    "In this section, we'll explore different ways to format strings in Python, which can be particularly useful when we want to include variable values within a string. There are several ways to do this in Python, including concatenating strings using `+`, using a comma `,`, using the `.format()` method, or through f-strings. Below, we will see examples of each of these methods and analyze the resulting data types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Format - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First Case: This Could Be a Use Case for Input and Output Functions\n",
    "name = \"Santi\"\n",
    "age = 24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using Concatenation with '+'\n",
    "greeting = \"Hello my name is \" + name + \" and my age is \" + str(age)\n",
    "greeting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using a Comma to Concatenate\n",
    "greeting = \"Hello my name is \", name, \" and my age is \", str(age)\n",
    "greeting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Checking the Type of the Variable `greeting`\n",
    "type(greeting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding Some Options to Reflect On What Type of Data We Have Here:\n",
    "# 1. String\n",
    "# 2. List\n",
    "# 3. Tuple\n",
    "# 4. CSV: Comma Separated Values?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using f-strings for cleaner formatting\n",
    "greeting = f\"Hello my name is {name} and my age is {age}\"\n",
    "greeting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Format - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Second case:\n",
    "name = \"Laura\"\n",
    "age = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello my name is guille and my age is 41'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using the .format() Method to Insert Values into a String\n",
    "greeting = \"Hello my name is {} and my age is {}\".format(name, age)\n",
    "greeting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**\n",
    "\n",
    "Now that we've learned several ways to format strings in Python, it's time to put our knowledge into practice. In this exercise, we'll ask you to use the `input()` function to request certain information from the user, and then format that information using at least two of the methods we've discussed previously (concatenation with '+', using commas, f-strings, or the `.format()` method).\n",
    "\n",
    "Instructions:\n",
    "1. Ask the user to enter their name and age using the `input()` function.\n",
    "2. Create a greeting message that includes the user's name and age, using two different string formatting methods.\n",
    "3. Print both messages on the console to verify your work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "# your code here\n",
    "name = input(\"What is your name?\")\n",
    "age = input(\"What is your age?\")\n",
    "print(name)\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "es"
   },
   "source": [
    "## Strings\n",
    "\n",
    "In Python, as we've seen before, a string is a sequence of characters enclosed in single (`'`), double (`\"`), or triple (`'''` or `\"\"\"`) quotes. Strings are immutable, which means that once created, we cannot modify their content directly, although we can create new strings from manipulations of the original through various methods and operations. These can contain letters, numbers, special characters, spaces, or a combination of all of them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### String Methods\n",
    "\n",
    "Methods are actions or functions that an object can perform. Just as Python offers us a number of \"built-in\" functions, it also provides us with a series of pre-created methods. These methods depend on the type of object we are working with, and in the case of strings, they allow us to perform a variety of operations to manipulate and inspect them.\n",
    "\n",
    "In this section, we will explore some of the most commonly used string methods during the bootcamp, using a `sample_string` to demonstrate their functionality. As we progress through the bootcamp, it is essential to become familiar with these methods, as they can significantly ease your coding process.\n",
    "\n",
    "For a more comprehensive view of string methods, feel free to consult the [Python documentation](https://docs.python.org/3/library/stdtypes.html#string-methods). I always use Google :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_string = \"this is a string\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `capitalize` Returns a copy of the string with its first character in uppercase and the rest in lowercase. It's ideal for when we want a sentence or title to begin with a more formal touch. Let's try it with the example!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a string'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_string.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `upper` Returns a copy of the string but with all characters in uppercase. It's perfect for emphasizing something strongly or simply to match the formatting of different texts. Let's put it to the test with a string we have here!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THIS IS A STRING'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_string.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also check if the string is in upper case format (uppercase letters)\n",
    "sample_string.upper().isupper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `lower` Returns a copy of the string but with all characters in lowercase. This method is great for when we want to maintain uniformity in our text or simply to avoid \"SHOUTING\" in a digital conversation. Let's see how it works with a practical example!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a string'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_string.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_string.lower().islower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `swapcase` This method is like swapping clothes at a costume party: it converts all uppercase characters to lowercase and vice versa in the string. It's especially useful if we want to quickly reverse the capitalization of a text string. Let's try it with an example!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THIS IS A STRING'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_string.swapcase()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `title` This method returns a version of the string where each word starts with an uppercase character, and the rest of the characters are in lowercase. It's as if it turns the string into a book or movie title, giving it a more formal and polished look. Let's see how it works with a practical example!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This Is A String'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_string.title()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `join(iterable)` This method returns a string that is the concatenation of the strings in the iterable. It's worth noting that a TypeError will be raised if there are non-string values in the iterable, including bytes objects. The separator between the elements is the string provided by this method. It's an effective way to join multiple strings into one, using a specific separator that the string itself defines. Let's see how we can use it with some examples!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# New example\n",
    "list_of_strings = [\"Santi\", \"Clara\", \"Laura\", \"Albert\"]\n",
    "\" 🥸 \".join(list_of_strings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `startswith` This method returns `True` if the string starts with the specified prefix; otherwise, it returns `False`. It's interesting to note that the prefix can also be a tuple of prefixes to look for. Moreover, it has two optional parameters: `start`, which allows specifying from which position in the string to start checking, and `end`, which indicates where to stop the check. Let's see some examples to better understand how it works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = \"3434567\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number.startswith(\"+\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number.startswith(\"34\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `endswith` This method works similarly to the `startswith` method, but in this case, it checks if the string ends with the specified suffix. If so, it returns `True`; otherwise, it returns `False`. Like `startswith`, this method allows specifying the optional parameters `start` and `end` to define the range of the string to perform the check. Below, we present some examples to illustrate how it works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number.endswith(\"67\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `str.lstrip([chars])` This method returns a copy of the original string but without the characters specified in the `chars` argument found at the beginning of it. If no argument is specified (that is, it's omitted or none is present), whitespace will be removed by default. It's important to note that the `chars` argument does not act as a prefix; instead, it removes all possible combinations of the values found within it. Here we show you some examples to better understand how this method works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "##This is an example.\n"
     ]
    }
   ],
   "source": [
    "# We define a string with some spaces and characters at the beginning\n",
    "original_string = \"   ##This is an example.\"\n",
    "\n",
    "# We use the lstrip method to remove the white spaces at the beginning\n",
    "modified_string = original_string.lstrip()\n",
    "print(modified_string)\n",
    "# Output: \"##This is an example.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also use lstrip to remove other characters by specifying an argument\n",
    "modified_string2 = original_string.lstrip(\" #\")\n",
    "print(modified_string2)\n",
    "# Output: \"This is an example.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `lstrip` The `lstrip` method in Python is used to remove unwanted characters found at the beginning of a string. You can use it in two ways: without arguments, which will remove all white spaces at the beginning of the string; or with a specific set of characters as an argument (indicated in parentheses), which will remove all instances of those characters found at the beginning of the string.\n",
    "\n",
    "- `rstrip` Similarly, the `rstrip` method is used to remove characters at the end of a string. It works in the same way as `lstrip`, but affects the end of the string instead of the beginning. If no set of characters is specified, it will remove all white spaces found at the end of the string.\n",
    "\n",
    "- `replace` The `replace` method is used to replace all occurrences of a specific substring (`old`) with a new substring (`new`). You can use it in two ways: without the optional `count` argument, which will replace all occurrences found in the string; or by specifying the `count` argument, which will limit the number of replacements to the amount indicated. This method returns a copy of the original string with the substitutions made, leaving the original string intact."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "original_string.replace(\"#\", \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `split` The `split` method is used to divide a string into a list of words based on a specified delimiter (the `sep` parameter). If no delimiter is specified (or is set to `None`), whitespace (spaces, tabs, new lines, etc.) will be used as the default delimiter. This method is especially useful when you want to break down a string into smaller components to perform additional operations or analysis on each individual fragment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = \"Hello my name is Santo\"\n",
    "sentence.split(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence.split(\"e\")"
   ]
  }
 ],
 "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.13.1"
  },
  "nbTranslate": {
   "displayLangs": [
    "en",
    "es"
   ],
   "hotkey": "alt-a",
   "langInMainMenu": true,
   "sourceLang": "es",
   "targetLang": "en",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "222.891px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}