1. Software/1.1 Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción a Python\n",
    "\n",
    "En este cuaderno aprenderás:\n",
    "- Tipos de datos (listas, diccionarios, ...)\n",
    "- Control de flujo (condiciones, bucles, ...)\n",
    "- Funciones \n",
    "\n",
    "Python 2 está obsoleto desde 2020, comprobemos que usamos Python 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# Comprobar que usamos Python 3\n",
    "import sys\n",
    "print(sys.version[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Tipos de datos:\n",
    "\n",
    "- Números\n",
    "  - Enteros: `int`\n",
    "  - Decimales: `float`\n",
    "- **[Booleanos](https://es.wikipedia.org/wiki/Tipo_de_dato_l%C3%B3gico)**: `bool`\n",
    "- Cadena de texto: `str`\n",
    "\n",
    "## 1.1 Números"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "# Note: use the `type()` function to get the type of a variable\n",
    "# Numbers can be integers ('int'), such as 3, 5 and 3049, or floats\n",
    "# ('float'), such as 2.5, 3.1, and 2.34938493\n",
    "print(type(a))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "verdadero  = True\n",
    "falso      = False\n",
    "\n",
    "print(type(verdadero))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones matemáticas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suma: 6\n",
      "Resta: 4\n",
      "Multiplicación: 10\n",
      "División: 2.5\n",
      "División entera: 2\n",
      "Resto de la división: 1\n",
      "Exponente: 25\n"
     ]
    }
   ],
   "source": [
    "print(\"Suma:\",                 5 + 1)\n",
    "print(\"Resta:\",                5 - 1)\n",
    "print(\"Multiplicación:\",       5 * 2)\n",
    "print(\"División:\",             5 / 2)\n",
    "print(\"División entera:\",      5 // 2)\n",
    "print(\"Resto de la división:\", 5 % 2)\n",
    "print(\"Exponente:\",            5 ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones de comparación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(5 == 5)  # Comparador de igualdad\n",
    "print(5 != 3)  # Comparador de desigualdad\n",
    "print(5 > 3)   # Comparador mayor que\n",
    "print(3 < 5)   # Comparador menor que\n",
    "print(5 >= 3)  # Comparador mayor o igual qu\n",
    "print(3 <= 5)  # Comparador menor o igual que"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones lógicas\n",
    "- **`and`**: Para que sea verdadero -> **TODOS tienen que ser verdaderos**\n",
    "- **`or`**: Para que sea verdadero -> **Al menos UNO tiene que ser verdaderos**\n",
    "- **`not`**: Hace que sea lo contrario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "verdadero and verdadero: True\n",
      "verdadero and falso:     False\n",
      "verdadero or verdadero:  True\n",
      "verdadero or falso:      True\n",
      "not verdadero:           False\n",
      "not falso:               True\n"
     ]
    }
   ],
   "source": [
    "verdadero = True\n",
    "falso     = False\n",
    "print(\"verdadero and verdadero:\", verdadero and verdadero)\n",
    "print(\"verdadero and falso:    \", verdadero and falso)\n",
    "print(\"verdadero or verdadero: \", verdadero or verdadero)\n",
    "print(\"verdadero or falso:     \", verdadero or falso)\n",
    "print(\"not verdadero:          \", not verdadero)\n",
    "print(\"not falso:              \", not falso)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Cadenas de texto (Strings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "estoy aprendiendo\n"
     ]
    }
   ],
   "source": [
    "s1 = 'estoy'       # Pueden ser comillas simples\n",
    "s2 = \"aprendiendo\" # O comillas dobles\n",
    "print(s1, s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenación de strings:  `+`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola, estoy aprendiendo.\n"
     ]
    }
   ],
   "source": [
    "frase = 'Hola, ' + s1 + \" \" + s2 + \".\"\n",
    "print(frase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Longitud del string:  `len`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(frase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Separación por patrón:  `split`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hola,', 'estoy', 'aprendiendo.']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frase.split(' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Estructuras de datos\n",
    "son tipos de datos que contienen muchos datos simples\n",
    "- Listas\n",
    "- Tuplas\n",
    "- Diccionarios\n",
    "- Conjuntos\n",
    "\n",
    "## 2.1 Listas\n",
    "A Python `list` stores multiple elements, which can be different types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd']\n",
      "<class 'list'>\n",
      "a\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "mi_lista = [\"a\", \"b\", \"c\", \"d\"]\n",
    "\n",
    "print(mi_lista)\n",
    "print(type(mi_lista))\n",
    "print(mi_lista[0])    # 0: Primer elemento de la lista\n",
    "print(mi_lista[2])    # 2: Tercer elemento de la lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](../img/stair.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modificar elementos de la lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['primero', 'b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "mi_lista[0] = 'primero'\n",
    "print(mi_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Añadir/quitar elementos de la lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['primero', 'b', 'c', 'd', 'último']\n",
      "['primero', 'b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "mi_lista.append('último')\n",
    "print(mi_lista)\n",
    "\n",
    "mi_lista.pop()\n",
    "print(mi_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Acceder a varios elementos de la lista\n",
    "![](../img/slicing.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['o', 'g', 'r']\n",
      "['p', 'r', 'o', 'g']\n",
      "['a', 'm', 'i', 'z']\n",
      "['p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z']\n"
     ]
    }
   ],
   "source": [
    "l = ['p','r','o','g','r','a','m','i','z']\n",
    "\n",
    "print(l[2:5]) # Del 3o al 5o\n",
    "print(l[:-5]) # Del principio al 4o\n",
    "print(l[5:])  # Del 6o al final\n",
    "print(l[:])   # Del principio al final"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Diccionarios\n",
    "\n",
    "Guarda pares de **clave: valor**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = { 'clave':   'valor',\n",
    "     'nombre':   'Pedro',\n",
    "     'apellido': 'García'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Access a value from a dictionary by a key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "valor\n",
      "Pedro\n"
     ]
    }
   ],
   "source": [
    "print(d['clave'])\n",
    "print(d['nombre'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looping over values of a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La clave es clave\n",
      "La clave es nombre\n",
      "La clave es apellido\n"
     ]
    }
   ],
   "source": [
    "for clave in d:\n",
    "    print(\"La clave es \" + clave)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La clave es clave, y el valor es valor\n",
      "La clave es nombre, y el valor es Pedro\n",
      "La clave es apellido, y el valor es García\n"
     ]
    }
   ],
   "source": [
    "for clave, valor in d.items():\n",
    "    print(\"La clave es \" + clave + \", y el valor es \" + valor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Conjuntos\n",
    "Listas sin orden, que contiene elementos únicos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 'hello'}\n"
     ]
    }
   ],
   "source": [
    "c = {1, 2, 3, 'hello'}\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si repetimos, no pasa nada, internamente sólo se guarda uno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 'hello'}\n"
     ]
    }
   ],
   "source": [
    "repes = {1, 2, 2, 2, 2, 2, 3, 'hello'}\n",
    "print(repes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Functiones\n",
    "A function is a block of reusable code that performs a certain action. Once you've defined a function, you can use it anywhere in your code!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def am_i_happy(happiness_level):\n",
    "    if happiness_level >= 10:\n",
    "        return \"You're very happy.\"\n",
    "    elif happiness_level >= 5:\n",
    "        return \"You're happy.\"\n",
    "    else:\n",
    "        return \"You're not happy.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You're not happy.\n"
     ]
    }
   ],
   "source": [
    "print(am_i_happy(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You're happy.\n"
     ]
    }
   ],
   "source": [
    "print(am_i_happy(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Control Flow\n",
    "## 4.1 If/Else If/Else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Take a nap\n"
     ]
    }
   ],
   "source": [
    "sleepy = True\n",
    "hungry = False\n",
    "\n",
    "if sleepy and hungry:\n",
    "    print(\"Eat a snack and take a nap.\")\n",
    "elif sleepy and not hungry:\n",
    "    print(\"Take a nap\")\n",
    "elif hungry and not sleepy:\n",
    "    print(\"Eat a snack\")\n",
    "else:\n",
    "    print(\"Go on with your day\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 Loops\n",
    "### 4.2.1 'while' loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have counted to 0\n",
      "You have counted to 1\n",
      "You have counted to 2\n",
      "You have counted to 3\n",
      "You have counted to 4\n",
      "You have counted to 5\n",
      "You have counted to 6\n",
      "You have counted to 7\n",
      "You have counted to 8\n",
      "You have counted to 9\n",
      "You're finished counting\n"
     ]
    }
   ],
   "source": [
    "counter = 0\n",
    "while (counter < 10):\n",
    "    print(\"You have counted to\", counter)\n",
    "    counter = counter + 1 # Increment the counter\n",
    "    \n",
    "print(\"You're finished counting\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.2 'for' loops\n",
    "Loop over a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cats are cool\n",
      "dogs are cool\n",
      "lions are cool\n",
      "bears are cool\n"
     ]
    }
   ],
   "source": [
    "cool_animals = ['cat', 'dog', 'lion', 'bear']\n",
    "\n",
    "for animal in cool_animals:\n",
    "    print(animal + \"s are cool\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loop over a dict:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dog says bark!\n",
      "The cat says meow!\n",
      "The pig says oink!\n"
     ]
    }
   ],
   "source": [
    "animal_sounds = {\n",
    "    'dog': 'bark',\n",
    "    'cat': 'meow',\n",
    "    'pig': 'oink'\n",
    "}\n",
    "\n",
    "for animal, sound in animal_sounds.items():\n",
    "    print(\"The \" + animal + \" says \" + sound + \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br> \n",
    "<br>\n",
    "\n",
    "----"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}