Summer_Camp_Python_Syntax.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Summer_Camp_Python_Syntax.ipynb",
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/drive/1bOdVcjg0Oy8koXLRmiGDGPTKxagPaxWM#scrollTo=pPv1MCym6FZw\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rtn6Jd2CgnXK",
        "colab_type": "text"
      },
      "source": [
       
      ]
    },
     {
      "cell_type": "markdown",
      "source": [
        "# Empezemos! \n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "ti024WlbC46A"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "FUzNVtb6C00j"
      },
      "outputs": [],
      "source": [
        "# ¡Esto es una celda de código Python!\n",
        "# usa un hashtag al principio de cada línea para que el ordenador que se la salte\n",
        "# esto también se conoce como un \"comentario\" en tu código.\n",
        "\n",
        "# ¡Asegúrate de añadir comentarios para ayudarte a entender tu código!"
      ]
    },
    {
      
      "cell_type": "markdown",
      "source": [
        "## *Variables*\n",
        "  - Asignación de Variables:\n",
        "elija un nombre de variable que empiece por una letra minúscula. Se permiten guiones bajos _ y números después de la primera letra\n",
        "ejemplos: mi_variable, mi_Variable, miVariable2, ...\n",
        "  - Tipos de Variables: integers, float, string, boolean and list \n",
        "\n",
        "\n",
        "\n",
        "### *Integers and Floats*\n",
        "- `integers` son números enteros (1, 2, 3, 4, 5, ...)\n",
        "- `floats` son números con decimales (1.2, 3.8, 4.00, ...), ¡incluso si todos los decimales son 0!\n"
      ],
      "metadata": {
        "id": "JU9-ak_GbnwL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# el nombre de la variable va a la izquierda, el valor va a la derecha:\n",
        "\n",
        "x = 5  # x es ahora un entero de valor 5.\n",
        "z = 2\n",
        "\n",
        "y = 5.0 # y es ahora un float (tiene cifras significativas en los decimales)\n",
        "\n",
        "# Puedes utilizar los símbolos +, -, *, / para su significado matemático habitual:\n",
        "# % devuelve el resto de la división\n",
        "print(x+y)\n",
        "print(x%z)"
      ],
      "metadata": {
        "id": "XJcVFWWwfHtq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### *Strings* \n",
        "- Para crear un string, utilice comillas 'simples' o \"dobles\" alrededor de la palabra que desee asignar como string.\n",
        "- Strings pueden contener letras, espacios y números.\n",
        "- Se pueden realizar algunas operaciones con strings (+, [ : ], *)"
      ],
      "metadata": {
        "id": "vpIpYVOChbGj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# String concatenation \n",
        "\n",
        "my_String = \"Hola Python; \"\n",
        "my_second_String = my_String[0:1]\n",
        "my_third_String = my_String * 3\n",
        "my_fourth_String = my_String + my_second_String\n",
        "\n",
        "print(my_second_String)\n",
        "print(my_third_String)\n",
        "print(my_fourth_String)"
      ],
      "metadata": {
        "id": "5N2kb3WNhodp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Example function: input() function\n",
        "\n",
        "my_age = input(\"Usuario, por favor, escriba su edad y pulse enter: \")\n",
        "print(\"OK, tu tienes\",my_age,\"años.\")\n",
        "\n",
        "# Example function: .split() function \n",
        "\n",
        "animales_string = \"oso, perro, gato, caballo, pajaro\"\n",
        "animales_list = animales_string.split(\", \")\n",
        "print(animales_list)"
      ],
      "metadata": {
        "id": "Ab_IdtRL0OkM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####String Methods mas usadas: \n",
        "- s.lower(), s.upper() -- returns the lowercase or uppercase version of the string\n",
        "- s.strip() -- returns a string with whitespace removed from the start and end\n",
        "- s.isalpha()/s.isdigit()/s.isspace()... -- tests if all the string chars are in the various character classes\n",
        "- s.startswith('other'), s.endswith('other') -- tests if the string starts or ends with the given other string\n",
        "- s.find('other') -- searches for the given other string (not a regular expression) within s, and returns the first index where it begins or -1 if not found\n",
        "- s.replace('old', 'new') -- returns a string where all occurrences of 'old' have been replaced by 'new'\n",
        "- s.split('delim') -- returns a list of substrings separated by the given delimiter. The delimiter is not a regular expression, it's just text. 'aaa,bbb,ccc'.split(',') -> ['aaa', 'bbb', 'ccc']. As a convenient special case s.split() (with no arguments) splits on all whitespace chars.\n",
        "- s.join(list) -- opposite of split(), joins the elements in the given list together using the string as the delimiter. e.g. '---'.join(['aaa', 'bbb', 'ccc']) -> aaa---bbb---ccc"
      ],
      "metadata": {
        "id": "J35X1qdDlELz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### *List, Set and Dictionary*\n",
        "\n",
        "- Son un tipo de datos, igual que integers, strings, etc. \n",
        "- Puedes poner los tipos de datos que quieras en una lista"
      ],
      "metadata": {
        "id": "0BHqqF0u3IW5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Puedes juntar diferentes tipos de datos \n",
        "mixed_list = [\"Hola\", 1, 1, 2]\n",
        "\n",
        "# Despues de crear una lista puedes añadir mas elementos\n",
        "mixed_list.append(7)\n",
        "\n",
        "# Se puede convertir en un set (cada elemento aparece solo una vez)\n",
        "mixed_set = set(mixed_list)\n",
        "print(mixed_set)\n",
        "\n",
        "# Ordenar las listas \n",
        "sorting_list = [\"hola\", \"buenos dias\", \"adios\"]\n",
        "sorting_list = sorted(sorting_list)\n",
        "print(sorting_list)\n",
        "sorting_list = sorted(sorting_list, key = len)\n",
        "print(sorting_list)\n"
      ],
      "metadata": {
        "id": "VNUEA0lu4CSp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Logic, Loops and Functions\n",
        "\n",
        "\n",
        "### *Logic*\n",
        "\n",
        "- Boolean = True/False \n",
        "\n",
        "- a == b : a es igual a b\n",
        "    - 5 == 6 es `False`\n",
        "- a != b : a NO es igual a b\n",
        "    - 5 != 6 es `True`\n",
        "- a < b : a es menor que b\n",
        "    - 5 < 6 es `True`\n",
        "- a <= b : a es menor o igual que b\n",
        "    - 5 <= 6 es `True`\n",
        "- and : (a > b) and (a < c) --> a es mayor que b AND (y) a es menor que c\n",
        "    - (5 > 6 and 5 < 6) es `False` \n",
        "- or : (a > b) or (a < c) --> a es mayor que b OR (o) a es menor que c\n",
        "    - (5 > 6 or 5 < 6) es `True`\n",
        "- not: not a == b --> invierte/nega el valor de un bool \n",
        "    - not 5 == 6 es `True`\n",
        " \n",
        "\n"
      ],
      "metadata": {
        "id": "c-_K5Rrfy3aj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### *Loops*\n",
        "- For Loop \n",
        " - ***For*** (Durante) x repititions, haz algo \n",
        "  - x repeticiones\n",
        "- While Loop \n",
        "    - ***While*** (Mientras) also sea `True` (verdad), haz algo\n",
        "    - repeticiones infinitas hasta que algo en vez de ser `True`, sea `False`\n",
        "- If Statement\n",
        "    - ***If*** algo es `True`, entonces haz algo \n",
        "    - se repite solo una vez\n"
      ],
      "metadata": {
        "id": "GyayQryf46Po"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ejemplo For Loop\n",
        "my_list = [\"pie\",\"cake\",\"cookie\"]\n",
        "for item in my_list:\n",
        "  print(item)\n",
        "\n",
        "# Ejemplo While Loop\n",
        "x = 0\n",
        "while (x < 3):\n",
        "  print(x)\n",
        "  x = x + 1\n",
        "\n",
        "# Ejemplo If-Statement \n",
        "x = 5\n",
        "if x != 3:\n",
        "  print(\"x no es 3\")\n",
        "\n",
        "# Ejemplo mezcla \n",
        "for item in range(10):    #numeros de 0 a 9\n",
        "  if item % 2 != 0:       #el resto de la división por 2 NO es 0 \n",
        "    print(item, \"es un numero inpar\")\n",
        "  else: \n",
        "    print(item, \"es un numero par\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E4RPvf4z5Lka",
        "outputId": "17032857-33d5-4598-80d1-f4335ed23b25"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pie\n",
            "cake\n",
            "cookie\n",
            "0\n",
            "1\n",
            "2\n",
            "x no es 3\n",
            "0 es un numero par\n",
            "1 es un numero inpar\n",
            "2 es un numero par\n",
            "3 es un numero inpar\n",
            "4 es un numero par\n",
            "5 es un numero inpar\n",
            "6 es un numero par\n",
            "7 es un numero inpar\n",
            "8 es un numero par\n",
            "9 es un numero inpar\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### *Functions*\n",
        "\n",
        "Una función permite realizar una operación con cualquier input y devuelve el output deseado."
      ],
      "metadata": {
        "id": "TW74TJtBGLhu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Hay dos componentes necesarios para cada función:\n",
        "\n",
        "def mi_funcion(mi_entrada): # esta línea define la función y las variables de entrada, el input\n",
        "  return mi_entrada         # esta línea es la salida de la función, el output\n",
        "\n",
        "# nota la indentación, esto le dice al ordenador que `devolver mi_entrada` es parte de mi_función.\n",
        "\n",
        "# para testing: \n",
        "\n",
        "\n",
        "  \n",
        "  "
      ],
      "metadata": {
        "id": "d1Eci3YLHxBv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "## Dictionaries ans Sets\n",
        "- Sets es un tipo de datos para colección desordenada que es iterable, mutable y no tiene elementos duplicados.\n",
        "- Dictionaries es una estructura de key/value utilizada para guardar valores de datos como un String\n",
        "  - escrito como {key1:value1, key2:value2, key3:value3}\n",
        "  - buscar un valor: dict[key1]\n",
        "  - Strings, keys, tuples funcionan como keys \n",
        "  - error si no existe key1 --> usa get(key1, not found) "
      ],
      "metadata": {
        "id": "YA67q0nNkmYF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ejemplo Set \n",
        "ex_set = {1, 3, 2, 2, 2}\n",
        "print(\"es_set: \", ex_set)\n",
        "\n",
        "# Ejemplo Dictionary\n",
        "statuses = {\n",
        "    \"Alice\": \"online\",\n",
        "    \"Bob\": \"offline\",\n",
        "    \"Eve\": \"online\",\n",
        "}\n",
        "statuses[\"Maria\"] = \"online\" \n",
        "print(\"statuses: \", statuses) \n",
        "print(\"Alice: \", statuses[\"Alice\"])\n",
        "if (\"Juan\" in statuses): \n",
        "  print(statuses[\"Juan\"])\n",
        "else:\n",
        "  print(\"Juan not found\")\n",
        "\n",
        "#nos va a dar un error   \n",
        "print(statuses.get[\"Juan\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 270
        },
        "id": "e33nHYiLrnHB",
        "outputId": "baa8b6d1-69de-4fb9-e829-b64600057e56"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "es_set  {1, 2, 3}\n",
            "statuses  {'Alice': 'online', 'Bob': 'offline', 'Eve': 'online', 'Maria': 'online'}\n",
            "Alice  online\n",
            "Juan not found\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-5-addff8b2b027>\u001b[0m in \u001b[0;36m<cell line: 18>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Juan not found\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstatuses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"Juan\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'builtin_function_or_method' object is not subscriptable"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### More Dictionaries \n",
        "- dict.keys() o dict.values() devuelven lista de todos los values/ las keys\n",
        "- dict.items() nos devuelve una lista de (key1, value1) \n",
        "- sorted(dict.keys())"
      ],
      "metadata": {
        "id": "7ps-wkaN4fJB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# looping through dictionary \n",
        "dict = {}\n",
        "dict['word'] = 'garfield'\n",
        "dict['count'] = 42\n",
        "for x in sorted(dict.keys()): \n",
        "  print(dict[x])\n",
        "\n",
        "# formatting \n",
        "  s = 'I want %(count)d copies of %(word)s' % h  # %d for int, %s for string \n",
        "  #'I want 42 copies of garfield'\n",
        "\n",
        "# del \n",
        "list = ['a', 'b', 'c', 'd']\n",
        "  del list[0]     ## Delete first element\n",
        "  del list[-2:]   ## Delete last two elements\n",
        "  print(list)      ## ['b']\n",
        "\n",
        "  dict = {'a':1, 'b':2, 'c':3}\n",
        "  del dict['b']   ## Delete 'b' entry\n",
        "  print(dict)      ## {'a':1, 'c':3}"
      ],
      "metadata": {
        "id": "pPv1MCym6FZw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Dictionary Functions mas usadas: \n",
        "- d[key]\treturns the value associated with key, error if key not in dictionary d\n",
        "- d.get(key)\treturns value associated with key, returns None if key not in dictionary d\n",
        "- d.keys()\treturns a list/view of the keys in dictionary\n",
        "- d.values()\treturns a list/view of values in dictionary\n",
        "- d.items()\treturns a list/view of tuples, (key,item) pairs from dictionary\n",
        "- d.update(dict)\tupdates the dictionary with another dictionary dict"
      ],
      "metadata": {
        "id": "ej0EAbc-qt7C"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Files \n",
        "- La función open() abre y devuelve file que puede utilizarse para leer o escribir\n",
        "- El código f = open('nombre', 'r') abre el fichero en la variable f, listo para operaciones de lectura, f.close() se utiliza cuando termina. \n",
        "- En lugar de 'r', usa 'w' para write (escribir), y 'a' para append.\n",
        "- El for-loop para archivos de texto itera a través de las líneas del archivo (esto funciona sólo para archivos de texto, no archivos binarios). "
      ],
      "metadata": {
        "id": "HKG5iiVX771J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "  f = open('example.txt', 'r')\n",
        "  for line in f:   ## iterates over the lines of the file\n",
        "    words = line.split()\n",
        "    for word in words:\n",
        "      word = word.upper()\n",
        "    \n",
        "  f.close()"
      ],
      "metadata": {
        "id": "U56s_HdS9DXu"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}