Fundamentos CyP 14 10 21.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Fundamentos CyP.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4Cm1yQ-zwnQ9",
        "outputId": "15655d7c-d591-4375-d314-4916f085f219"
      },
      "source": [
        "nombre = 'Mauricio'  #Tipo de dato string (cadena de caracteres)\n",
        "\n",
        "print (nombre)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mauricio\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rMefxH-MwsqJ"
      },
      "source": [
        "# Tipos de datos en Phyton\n",
        "\n",
        "### Tipos simples \n",
        "- str --> string cadena de caracteres. \n",
        "- int --> Numeros enteros\n",
        "- float --> Numeros con notacion de punto flotante\n",
        "- complex --> Numeros Complejos \n",
        "- bool --> Boleano (True or False)\n",
        "- byte --> 8 bits\n",
        "\n",
        "### Tipos de datos estructurados (compuestos)\n",
        "- list --> Listas(Arreglos en otros leng)\n",
        "- tuple --> Listas no mutables\n",
        "- dict --> Diccionarios\n",
        "- set y frozenset --> Conjuntos\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oQxp1ZVHwwCr",
        "outputId": "889fe987-0985-428f-fc9d-eff5dd07d2a6"
      },
      "source": [
        "import sys\n",
        "\n",
        "edad = 19\n",
        "print (\"Tu edad es:\",edad) #Al final de una linea de codigo  \n",
        "#este es un comentario de linea simple\n",
        "\n",
        "\"\"\"\n",
        "Comentario de multiple linea\n",
        "En lenguaje C, C++ y Java es el comentario de multiple linea es con\n",
        "/*  .....  */\n",
        "\n",
        "En lenguaje C,C++ y Java el comentario de una sola linea es con\n",
        "//\n",
        "\n",
        "Aqui puedes explicar en prosa el segmento de un codigo para futura revision\n",
        "\n",
        "\"\"\"\n",
        "# tipos de datos numericos int y float\n",
        "\n",
        "print (sys.getsizeof(edad))\n",
        "# el tipo de dato INT utiliza diferente cantidad de bits segun el lenguaje de prog. \n",
        "# por ejemplo en c utiliza 16 bis.\n",
        "\n",
        "edad=edad + 1\n",
        "print (edad)\n",
        "\n",
        "estatura = 1.56\n",
        "print( estatura )\n",
        "print( sys.getsizeof(estatura))\n",
        "estatura= estatura +0.1\n",
        "print(estatura)\n",
        "print(round(estatura,2))\n",
        "\n",
        "edad += 1  #edad = edad +1 \n",
        "print(\"Tu edad es:\",edad)\n",
        "\n",
        "edad -= 1  #edad = edad -1 \n",
        "print(\"Tu edad es:\",edad)\n",
        "\n",
        "edad += 1  # vuelve a 21\n",
        "edad /= 2  #edad = edad /2 \n",
        "print(\"La mitad de tu edad es:\",edad)\n",
        "\n",
        "edad=21\n",
        "#volver a calcular la mitad de la edad pero solo dejar la parte entera\n",
        "edad = edad // 2 # para que te de numeros enteros se ocupa \"//\"\n",
        "print(\"La mitad de tu edad es:\",edad)\n",
        "\n",
        "#En la mayoria de los lenguajes no permite operaciones entre diferentes tipos\n",
        "#de datos, en phyton no es el caso\n",
        "\n",
        "numero = edad / 2.0\n",
        "print(numero)\n",
        "\n",
        "numero *=3  #numero= numero * 3\n",
        "print(numero)\n",
        "\n",
        "numero = 5.0\n",
        "numero **= 2 #numero= numero **2 (solo phyton)\n",
        "print(numero)\n",
        "\n",
        "#operador modulo \n",
        "numero = 21\n",
        "print(numero / 2)\n",
        "print(numero // 2)\n",
        "\n",
        "#el operador modulo da el residuo de una divison entera\n",
        "print(numero %2)\n",
        "\n",
        "numero=24\n",
        "print(\"Residuo de 24/5:\",numero %5)\n",
        "\n",
        "#operadores relacionales (logicos)\n",
        "print(\"24 es par\",numero %2 == 0)\n",
        "\n",
        "#diferencia\n",
        "print(\"24 es diferente de 23\",numero != 23) \n",
        "print(\"24 es mayor que 23\",numero > 23)\n",
        "print(\"24 es menor que 23\",numero < 23)\n",
        "\n",
        "print(\"24 es mayor o igual que 24\",numero >= 24)\n",
        "print(\"24 es menor o igual que 23\",numero < 23)\n",
        "\n",
        "print(\"El tipo de dato de la variable numero es:\", type(numero))\n",
        "print(\"El tipo de dato de la variable numero / 2.0 es:\", type(numero/2.0))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tu edad es: 19\n",
            "28\n",
            "20\n",
            "1.56\n",
            "24\n",
            "1.6600000000000001\n",
            "1.66\n",
            "Tu edad es: 21\n",
            "Tu edad es: 20\n",
            "La mitad de tu edad es: 10.5\n",
            "La mitad de tu edad es: 10\n",
            "5.0\n",
            "15.0\n",
            "25.0\n",
            "10.5\n",
            "10\n",
            "1\n",
            "Residuo de 24/5: 4\n",
            "24 es par True\n",
            "24 es diferente de 23 True\n",
            "24 es mayor que 23 True\n",
            "24 es menor que 23 False\n",
            "24 es mayor o igual que 24 True\n",
            "24 es menor o igual que 23 False\n",
            "El tipo de dato de la variable numero es: <class 'int'>\n",
            "El tipo de dato de la variable numero / 2.0 es: <class 'float'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tD_SnOvzw_TK"
      },
      "source": [
        "# tipo de dato String (str) en Phyton\n",
        "\n",
        "- Se maneja como un arreglo (tipo de dato compuesto)\n",
        "- Se puede acceder a los elementos de el string por medio del indice del caracter.\n",
        "- Mutable\n",
        "- Tiene metodos utiles (potentes)\n",
        "- slicing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zRJC5Q3-xCnT",
        "outputId": "50016cda-f31c-423b-bc78-881402282e0d"
      },
      "source": [
        "nombre = 'jose'\n",
        "carrera = \"ingenieria en computacion\"\n",
        "frase = \"\"\" El conocimiento \n",
        "me persigue,....\n",
        "pero\n",
        "yo soy mas rapido\n",
        "\"\"\"\n",
        "#cuando son solo una palabra se recomienda con comilla simple''\n",
        "#\"\" para cuando son muchas palabras y \"\"\" cuando son muchas lineas\n",
        "\n",
        "print(nombre)\n",
        "print(carrera)\n",
        "print(frase)\n",
        "\n",
        "# La funcion Type de Phyton te lo devuelve el tipo de dato de una variable\n",
        "print(type(nombre))\n",
        "\n",
        "paterno= str('Perez')\n",
        "print(paterno)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "jose\n",
            "ingenieria en computacion\n",
            " El conocimiento \n",
            "me persigue,....\n",
            "pero\n",
            "yo soy mas rapido\n",
            "\n",
            "<class 'str'>\n",
            "Perez\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P61f4YfTpBNs"
      },
      "source": [
        "#Una clase (class) es un tipo de dato compuesto."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kBU7zPDLpNU8",
        "outputId": "80d93c53-f32f-4c0a-b98b-777a028aaf5d"
      },
      "source": [
        "carrera = \"ingenieria en computacion\"\n",
        "print(carrera)\n",
        "print(carrera[2])"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ingenieria en computacion\n",
            "g\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TK4C1smPrg4T"
      },
      "source": [
        "# a la sintaxis escrita para elegir un elemento de un grupo de datos se le llama selector \n",
        "\n",
        "en el caso de strings y listas (lst) se usan los caracteres '[' y ']'\n",
        "\n",
        "1. en todos los lenguajes los arreglos inician en 0\n",
        "2. en phyton no existe como tal el tipo de dato arregl. el conceptto es sustituido por las listas\n",
        "3. los strings se comportan como un arreglo en la mayoria de los lenguajes\n",
        "4. en python se acepta en indexado, en otros lenguajes NO"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fuMvdWomsWw0",
        "outputId": "b10c5a89-8fd0-4ecd-9ce2-22e04f683eff"
      },
      "source": [
        "carrera = \"ingenieria en computacion\"\n",
        "print(carrera [8])\n",
        "print(carrera [24])\n",
        "print(carrera [-1])\n",
        "print(carrera [-25])\n",
        "\n",
        "\n",
        "#adelantando el tema ciclo FOR\n",
        "\n",
        "for letra in carrera:\n",
        "  print(\"-->\",letra,\"<--\")"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i\n",
            "n\n",
            "n\n",
            "i\n",
            "--> i <--\n",
            "--> n <--\n",
            "--> g <--\n",
            "--> e <--\n",
            "--> n <--\n",
            "--> i <--\n",
            "--> e <--\n",
            "--> r <--\n",
            "--> i <--\n",
            "--> a <--\n",
            "-->   <--\n",
            "--> e <--\n",
            "--> n <--\n",
            "-->   <--\n",
            "--> c <--\n",
            "--> o <--\n",
            "--> m <--\n",
            "--> p <--\n",
            "--> u <--\n",
            "--> t <--\n",
            "--> a <--\n",
            "--> c <--\n",
            "--> i <--\n",
            "--> o <--\n",
            "--> n <--\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KTS7pioTuwAj"
      },
      "source": [
        "# Slicing (rebanado) de cadenas\n",
        "\n",
        "Permite seleccionar subcadenas con el operador [ inicio : stop : incremento ]\n",
        "El stop no se incluye, es por eso que debemos agregar una posicion extra.\n",
        "### Slicing y valores por defecto\n",
        "Inicio por defecto siempre sera 0 \n",
        "\n",
        "Stop: tamaño del arreglo (indexado positivo)\n",
        "\n",
        "  0 (en un indexado negativo)\n",
        "  \n",
        "  Incremento: es 1 (indexado positivo)\n",
        "\n",
        "Solo Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_t-Eowmzvo26",
        "outputId": "bba7310e-8a9c-4445-b510-308fa37cb5a5"
      },
      "source": [
        "carrera = \"ingenieria en computacion\"\n",
        "print(carrera[0:10:1] )\n",
        "print(carrera[14:25:1] )\n",
        "#lo mismo pero con indexado negativo\n",
        "print(carrera[-11:-1:1])\n",
        "print(carrera[:10:])\n",
        "print(carrera[14:25:])\n",
        "print(carrera[-11::1])\n",
        "\n",
        "#solucion previa\n",
        "print(\"----------\")\n",
        "print(carrera[-11:-1:1])\n",
        "print(carrera[-11::1])\n",
        "\n",
        "# un ejercicio mas para ver incremento\n",
        "print(carrera[0:10:2])\n",
        "print(carrera[-1:-12:-1])\n",
        "#lo mismo pero usando indexado positivo\n",
        "print(carrera[25:13:-1])"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ingenieria\n",
            "computacion\n",
            "computacio\n",
            "ingenieria\n",
            "computacion\n",
            "computacion\n",
            "----------\n",
            "computacio\n",
            "computacion\n",
            "ignei\n",
            "noicatupmoc\n",
            "noicatupmoc\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P-g9rG_90eCy"
      },
      "source": [
        "# String y sus metodos\n",
        "#Todos los tipos de datos en Python son objetos (CLASES DE LA POO)\n",
        "###Lo cual significa que tiene atributos y metodos \n",
        "### dir() y help() funciones para obtener ayuda del lenguaje Python\n",
        "### dir muestra las funciones de un tipo de dato como resumen.\n",
        "### help muestra la misma ayuda pero con detalle. ej \"help(str)\"\n",
        "\n",
        "Los metodos que inician con doble guiin bajo son privados de uso interno de la clase y no deberiamos usarlos. \n",
        "\n",
        "Todos los demas son para uso exterior(usuario). "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4XTNRVw_02qD",
        "outputId": "b66c903f-93f8-4a94-c659-af07f0e33995"
      },
      "source": [
        "frutas= \" limon , fresa ,  manzana  , aguacate  \"\n",
        "nombre = \"jose\"\n",
        "print(frutas)\n",
        "\n",
        "print( nombre.capitalize() )\n",
        "print( nombre.upper ())\n",
        "print( frutas.replace('a', '4').replace ('e' , '3').upper())\n",
        "#para remplazar el significado de la variable se copia el codigo a la variable\n",
        "#se le asigna otro valor\n",
        "frutas= frutas.replace('a', '4').replace ('e' , '3').upper()\n",
        "print(frutas)\n",
        "print(\"-------------------------------------------------------------\")\n",
        "frutas= \"  limon , fresa ,  manzana  , aguacate  \"\n",
        "print( frutas.strip ())\n",
        "#strip quita la \"basura que hay enfrente y atras\"\n",
        "print( frutas.split(',' ))\n",
        "#split separa los valores de la variable\n",
        "print( frutas.index (\"n\"))\n",
        "#index busca la posicion en que esta una letra"
      ],
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " limon , fresa ,  manzana  , aguacate  \n",
            "Jose\n",
            "JOSE\n",
            " LIMON , FR3S4 ,  M4NZ4N4  , 4GU4C4T3  \n",
            " LIMON , FR3S4 ,  M4NZ4N4  , 4GU4C4T3  \n",
            "-------------------------------------------------------------\n",
            "limon , fresa ,  manzana  , aguacate\n",
            "['  limon ', ' fresa ', '  manzana  ', ' aguacate  ']\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3TvmAbbX8OF4"
      },
      "source": [
        "# String y caracteres de escape\n",
        "\n",
        "\"Jose\"\n",
        "- \\\" --> \"\n",
        "- \\\" --> '\n",
        "- \\n --> Salto de linea (tecla enter)\n",
        "- \\t --> Tabulador espacios a la izquierda\n",
        "- \\uxxxx --> Caracteres unicode \n",
        "- \\uxxxxxxxx --> Unicode extendido"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CbcJMvQU8xDP",
        "outputId": "e7be4baa-e0a2-48a0-b189-e76a00eba361"
      },
      "source": [
        "print(\"\\\"Jose\\\"\")\n",
        "nombre=\"\\\"Jose\\\"\"\n",
        "print(nombre)\n",
        "carrera= \"Ingenieria \\n\\t en \\n\\t\\tcomputacion\"\n",
        "print(carrera)\n"
      ],
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\"Jose\"\n",
            "\"Jose\"\n",
            "Ingenieria \n",
            "\t en \n",
            "\t\tcomputacion\n"
          ]
        }
      ]
    }
  ]
}