2_Guia_de_estilo_de_python_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "4b Guia de estilo de python.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4EDi0t6LmZRI"
      },
      "source": [
        "# PEP 8 -- Guía de estilo para programar en Python\n",
        "\n",
        "Una de las ideas claves de Guido es que el código es leído muchas\n",
        "más veces de lo que es escrito. El objetivo es mejorar la legibilidad del código y\n",
        "hacerlo consistente.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YlOBvkIxqQHq"
      },
      "source": [
        "#PEP8 Reglas de estilo\n",
        "\n",
        "\n",
        "\n",
        "Las normas de estilo son muy importantes en python\n",
        "\n",
        "##Indentación\n",
        "Indentación es un anglicismo que significa mover un bloque de texto a la derecha. En algunos manuales también ves escrito identación.\n",
        "\n",
        "En muchos lenguajes de programación para crear bloques, se usan llaves, por ejemplo como utilizamos en clase Java:\n",
        "\n",
        "if (edad < 18){\n",
        "System.out.println(“El alumno es menor de edad”);\n",
        "}else{\n",
        "System.out.println(“El alumno es mayor de edad”);\n",
        "\n",
        "}\n",
        "\n",
        "System.out.println(“Fin de la comprobación”);\n",
        "\n",
        " \n",
        "\n",
        "El indentado o sangrado se suele usar para que el código quede mas legible, sin embargo no es de uso obligado, funciona igual aunque no se indente y todo el código estuviera escrito pegado al inicio de la línea.\n",
        "\n",
        "En Python los bloques de código se crean mediante el indentado, nos ahorramos las llaves, sin embargo hay que prestar mucha atención al indentado, sería así:\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0brP5EFqpTWe",
        "outputId": "4c5cee90-b9a7-4dab-e784-03798ab7dffd"
      },
      "source": [
        "edad = 15\n",
        "if edad < 18: \n",
        "  print('El alumno es menor de edad')\n",
        "else:\n",
        "  print('El alumno es mayor de edad')\n",
        "print('Fin de la comprobación')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El alumno es menor de edad\n",
            "Fin de la comprobación\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7_fkZRNmqtcQ"
      },
      "source": [
        "REGLA DE ESTILO: Usa espacios por cada nivel de indentación o usa tabuladores, pero no uses ambos."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pgx_aTfVqO8X"
      },
      "source": [
        "Cada ‘nivel de indentado’ se refiere al anidamiento de bloques, por ejemplo: tienes un bloque for si dentro creas un bloque if, este tendrá un indentado doble:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pycz5Jsyp475",
        "outputId": "19839046-f7be-4405-fde0-af6645371412"
      },
      "source": [
        "for num in (7, 13, 22, 5, 16):\n",
        "  if num > 8:\n",
        "    print(num, \"Es mayor que 8\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "13 Es mayor que 8\n",
            "22 Es mayor que 8\n",
            "16 Es mayor que 8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gqy0GQhWnG_o"
      },
      "source": [
        "\n",
        "\n",
        " \n",
        "\n",
        "##Espacios en blanco en expresiones y sentencias\n",
        "Rodea siempre operadores de asignación (=) aritméticos (+ * – / % ** ) relacionales o de comparación (== != < > <= >=) y lógicos (and or not) con un espacio en cada lado\n",
        "\n",
        "i = i + 1\n",
        "\n",
        "c = (a + b) * (a - b)\n",
        "\n",
        "Usa siempre un espacio después de una coma\n",
        "\n",
        "aulas = (‘aula1′, ‘aula2′, ‘aula3′)\n",
        "\n",
        "Evita espacios en blanco extra.\n",
        "No uses espacios alrededor del signo ‘=’ cuando se use para indicar el valor de un parámetro por defecto.\n",
        "\n",
        "\n",
        "Inmediatamente antes de una coma, punto y coma, o dos puntos:\n",
        "\n",
        "x = 4; y = 6\n",
        "\n",
        "if x == 4:\n",
        "\n",
        "print(x, y)\n",
        "\n",
        "Más de un espacio alrededor de un operador de asignación (u otro operador) para alinearlo con otro.\n",
        "Evita los típicos espacios al final de cualquier línea. Estos espacios no son fáciles de detectar, spyder te mostrará el error con el triangulo amarillo.\n",
        "##Tamaño máximo de líneas\n",
        "79 caracteres. (Esta regla cuesta especialmente cumplirla)\n",
        " \n",
        "\n",
        "##Líneas en blanco\n",
        "Después de definir una función o una clase deja dos líneas en blanco.\n",
        "Las definiciones de métodos dentro de una clase se separan con una línea en blanco\n",
        "Al final del script deja una línea en blanco\n",
        "Generalmente se desaconsejan las sentencias compuestas (varias sentencias en la misma línea). Preferiblemente no escribir:\n",
        "\n",
        "if foo == ‘blah’: do_blah_thing()\n",
        "\n",
        "do_one(); do_two(); do_three()\n",
        "\n",
        "##Codificación de caracteres\n",
        "Para Python 3.0 y superiores, se recomienda UTF-8 en lugar de Latin-1 (también conocida como ISO-8859-1), se escribe la siguiente línea al inicio del script:\n",
        "\n",
        "# -*- coding: utf-8 -*-\n",
        " \n",
        "\n",
        "##Imports\n",
        "Para utilizar las librerías estándar de python o de terceros debemos previamente importarlas al inicio del script, con la palabra reservada import seguida del nombre de la librería:\n",
        "\n",
        "Normalmente los imports deberían colocarse en distintas líneas, por ejemplo:\n",
        "import os\n",
        "import sys\n",
        "\n",
        "Los imports se colocan siempre en la parte superior del archivo, justo después de cualquier comentario o cadena de documentación del módulo, y antes de las variables globales y las constantes del módulo. Los imports deberían agruparse siguiendo el siguiente orden:\n",
        "imports de la librería estándar\n",
        "imports de proyectos de terceras partes relacionados\n",
        "imports de aplicaciones locales/imports específicos de la librería\n",
        "Deberías añadir una línea en blanco después de cada grupo de imports.\n",
        "\n",
        "##Comentarios\n",
        "De una única línea, deben comenzar con un # y un espacio.\n",
        "Multilínea empiezan y acaban con tres comillas\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5sJrMemYrQs2"
      },
      "source": [
        "# Este es un comentario de una sola línea\n",
        "\n",
        "'''Este es un comentario de varias líneas\n",
        "bla bla bla\n",
        "otra línea\n",
        "'''\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IL6jqPozrCO0"
      },
      "source": [
        "##Documentación\n",
        "Docstrings o cadenas de documentación es una literal de cadena de caracteres que se coloca como primer enunciado de un módulo, clase, método o función, y cuyo propósito es explicar su intención.\n",
        "\n",
        "Siempre se utiliza “”\" para abrir y cerrar el docstring aunque sean de una sola línea.\n",
        "\n",
        "Escribe docstrings para todos los módulos, funciones, clases, y métodos públicos.\n",
        "\n",
        "##Como nombrar variables funciones o clases\n",
        "minusculas_con_guiones para variables, funciones, métodos y atributos\n",
        "minusculas_con_guiones oTODO_MAYUSCULAS para las constantes\n",
        "PalabrasEnMayusculas para las clases\n",
        "Atributos: interfaz, _interno, __privado"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jrYX_-_a3JHp"
      },
      "source": [
        "\n",
        "# El zen de Python, por Tim Peters\n",
        "Los usuarios de Python se refieren a menudo a la filosofía de Python que es bastante análoga a la filosofía de Unix. \n",
        "El código que siga los principios de Python se dice que es \"pythónico\". \n",
        "Estos principios fueron descritos por el desarrollador de Python Tim Peters en \n",
        "\n",
        "##El Zen de Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c2lMT2wM3SRn"
      },
      "source": [
        "Bello es mejor que feo.\n",
        "\n",
        "Explícito es mejor que implícito.\n",
        "\n",
        "Simple es mejor que complejo.\n",
        "\n",
        "Complejo es mejor que complicado.\n",
        "\n",
        "Plano es mejor que anidado.\n",
        "\n",
        "Disperso es mejor que denso.\n",
        "\n",
        "La legibilidad cuenta.\n",
        "\n",
        "Los casos especiales no son tan especiales como para quebrantar las reglas.\n",
        "\n",
        "Lo práctico gana a lo puro.\n",
        "\n",
        "Los errores nunca deberían dejarse pasar silenciosamente.\n",
        "\n",
        "A menos que hayan sido silenciados explícitamente.\n",
        "\n",
        "Frente a la ambigüedad, rechaza la tentación de adivinar.\n",
        "\n",
        "Debería haber una —y preferiblemente solo una— manera obvia de hacerlo.\n",
        "\n",
        "Aunque esa manera puede no ser obvia al principio a menos que usted sea holandés ;-)\n",
        "\n",
        "Ahora es mejor que nunca.\n",
        "\n",
        "Aunque nunca es a menudo mejor que ya mismo.\n",
        "\n",
        "Si la implementación es difícil de explicar, es una mala idea.\n",
        "\n",
        "Si la implementación es fácil de explicar, puede que sea una buena idea.\n",
        "\n",
        "Los espacios de nombres (namespaces) son una gran idea ¡Hagamos más de esas cosas!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EiV62oJ_jmpG",
        "outputId": "377ff2fa-b4ca-4b42-b76f-d48df3c48802"
      },
      "source": [
        "import this"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "95iQPjtemLhY"
      },
      "source": [
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fZIRy-KejnR3"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}