Se usó la API de Cloud Translation para traducir esta página.

Introducción a Python

Introducción

Te damos la bienvenida al tutorial en línea de Python de Google. Se basa en el curso introductorio de Python que se ofrece internamente. Como se mencionó en la página de configuración, este material abarca Python 3.

Si buscas un curso complementario de MOOC, prueba los de Udacity y Coursera (introducción a la programación [principiantes] o introducción a Python). Por último, si quieres aprender a tu propio ritmo en línea sin mirar videos, prueba los que se indican al final de esta publicación. Conoce cada función de aprendizaje en línea y un intérprete interactivo de Python con el que puedes practicar. ¿Qué es este "intérprete"? que mencionamos? Lo descubrirás en la siguiente sección.

Introducción al lenguaje

Python es un lenguaje dinámico, interpretado (compilado con código de bytes). No hay declaraciones de tipo de variables, parámetros, funciones o métodos en el código fuente. Esto hace que el código sea corto y flexible, y pierdes la comprobación del tipo de tiempo de compilación del código fuente. Python realiza un seguimiento de todos los tipos de valores en el entorno de ejecución y marca el código que no tiene sentido mientras se ejecuta.

Una excelente manera de ver cómo funciona el código de Python es ejecutar el intérprete de Python y escribir el código directamente en él. Si alguna vez tienes una pregunta como "¿Qué sucede si agrego un elemento int a una list?" Con solo escribirlo en el intérprete de Python, es una forma rápida y, probablemente, la mejor manera de ver lo que sucede. (A continuación, verás lo que ocurre realmente).

$ python3        ## Run the Python interpreter
Python 3.X.X (XXX, XXX XX XXXX, XX:XX:XX) [XXX] on XXX
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 6       ## set a variable in this interpreter session
>>> a           ## entering an expression prints its value
6
>>> a + 2
8
>>> a = 'hi'    ## 'a' can hold a string just as well
>>> a
'hi'
>>> len(a)      ## call the len() function on a string
2
>>> a + len(a)  ## try something that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
>>> a + str(len(a))  ## probably what you really wanted
'hi2'
>>> foo         ## try something else that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'foo' is not defined
>>> ^D          ## type CTRL-d to exit (CTRL-z in Windows/DOS terminal)

Las dos líneas que Python imprime después de que escribes python y antes de >>> mensaje te informa sobre la versión de Python que estás usando y dónde se compiló. Siempre que lo primero impreso sea "Python 3.", estos ejemplos deberían funcionar para ti.

Como puedes ver arriba, es fácil experimentar con variables y operadores. Además, el intérprete arroja o “aumenta” en Python, un error de entorno de ejecución si el código intenta leer una variable a la que no se le asignó un valor. Al igual que C++ y Java, Python distingue mayúsculas de minúsculas, por lo que "a" y “A” son variables diferentes. El final de una línea marca el final de una instrucción, por lo que, a diferencia de C++ y Java, Python no requiere un punto y coma al final de cada instrucción. Los comentarios comienzan con el símbolo '#'. y se extiende hasta el final de la línea.

Código fuente de Python

En los archivos de origen de Python, se usa el archivo y se denominan “módulos”. Con un módulo de Python hello.py, la forma más fácil de ejecutarlo es con el comando de shell “python hello.py Alice” que llama al intérprete de Python para ejecutar el código en hello.py y pasarle el argumento de línea de comandos "Alice". Consulta la página de documentos oficiales para conocer todas las opciones diferentes que tienes cuando ejecutas Python desde la línea de comandos.

Este es un programa hello.py muy simple (observa que los bloques de código están delimitados estrictamente con sangría, en lugar de llaves, hablaremos de esto más adelante):

#!/usr/bin/python3

# import modules used here -- sys is a very standard one
import sys

# Gather our code in a main() function
def main():
    print('Hello there', sys.argv[1])
    # Command line args are in sys.argv[1], sys.argv[2] ...
    # sys.argv[0] is the script name itself and can be ignored

# Standard boilerplate to call the main() function to begin
# the program.
if __name__ == '__main__':
    main()

La ejecución de este programa desde la línea de comandos se ve así:

$ python3 hello.py Guido
Hello there Guido
$ ./hello.py Alice  ## without needing 'python3' first (Unix)
Hello there Alice

Importaciones, argumentos de línea de comandos y `len()`

Las sentencias más externas en un archivo Python, o “módulo”, hacen su configuración única: esas sentencias se ejecutan de arriba hacia abajo la primera vez que se importa el módulo en algún lugar y configuran sus variables y funciones. Un módulo de Python se puede ejecutar directamente, como se muestra más arriba en python3 hello.py Bob, o lo puede importar y usar algún otro módulo. Cuando se ejecuta directamente un archivo de Python, la variable especial "__name__" esté establecido en "__main__". Por lo tanto, es común que el código estándar if __name__ ==... que se muestra arriba llame a una función main() cuando el módulo se ejecuta directamente, pero no cuando lo importa otro módulo.

En un programa estándar de Python, la lista sys.argv contiene los argumentos de la línea de comandos de la forma estándar, donde sys.argv[0] es el programa en sí, sys.argv[1] es el primer argumento, etcétera. Si conoces argc o la cantidad de argumentos, puedes solicitar este valor de Python con len(sys.argv), tal como lo hicimos en el código de intérprete interactivo anterior cuando solicitaste la longitud de una cadena. En general, len() puede indicarte la longitud de una cadena, la cantidad de elementos en listas y tuplas (otra estructura de datos similar a un array) y la cantidad de pares clave-valor en un diccionario.

Funciones definidas por el usuario

Las funciones en Python se definen de la siguiente manera:

# Defines a "repeat" function that takes 2 arguments.
def repeat(s, exclaim):
    """
    Returns the string 's' repeated 3 times.
    If exclaim is true, add exclamation marks.
    """

    result = s + s + s # can also use "s * 3" which is faster (Why?)
    if exclaim:
        result = result + '!!!'
    return result

Observa también cómo las líneas que conforman la función o la sentencia if se agrupan por todas con el mismo nivel de sangría. También presentamos 2 maneras diferentes de repetir cadenas, con el operador +, que es más fácil de usar, pero con * también funciona porque es la palabra “repetir” de Python lo que significa que '-' * 10 le da '----------', una forma ordenada de crear una "línea" en pantalla. En el comentario del código, insinuamos que * funciona más rápido que +. Esto se debe a que * calcula el tamaño del objeto resultante una vez, mientras que con +, ese cálculo se hace cada vez que se llama a +. Tanto el signo + como el * se denominan "sobrecargado". porque tienen distintos significados para números y para cadenas (y otros tipos de datos).

La palabra clave def define la función con sus parámetros entre paréntesis y su código con sangría. La primera línea de una función puede ser una cadena de documentación ("docstring") que describe lo que hace la función. La docstring puede ser una sola línea o una descripción de varias líneas, como en el ejemplo anterior. (Sí, son “comillas triples”, una característica exclusiva de Python). Las variables definidas en la función son locales para esa función. El “resultado” en la función anterior es independiente de un "resultado" variable en otra función. La sentencia return puede tener un argumento, en cuyo caso ese es el valor que se muestra al llamador.

A continuación, se muestra un código que llama a la función repeat() anterior e imprime lo que se muestra:

def main():
    print(repeat('Yay', False))      ## YayYayYay
    print(repeat('Woo Hoo', True))   ## Woo HooWoo HooWoo Hoo!!!

En el tiempo de ejecución, las funciones se deben definir con la ejecución de una “def” antes de llamarlos. Es habitual desactivar una función main() en la parte inferior del archivo con las funciones que llama encima de ella.

Sangría

Una característica inusual de Python es que la sangría del espacio en blanco de un fragmento de código afecta su significado. Un bloque lógico de sentencias, como los que conforman una función, deben tener la misma sangría, establecida a partir de la sangría de su función principal o "if" o lo que sea. Si una de las líneas de un grupo tiene una sangría diferente, se marca como error de sintaxis.

Al principio, el uso de espacios en blanco que hace Python parece un poco extraño, pero es lógico y descubrí que me acostumbré a él muy rápido. Evita usar pestañas, ya que complican enormemente el esquema de sangría (sin mencionar que las pestañas pueden significar diferentes cosas en diferentes plataformas). Configura tu editor para insertar espacios en lugar de PESTAÑAS para el código de Python.

Una pregunta común de los principiantes es: "¿Cuántos espacios debo agregar sangría?". Según la guía de estilo oficial de Python (PEP 8), debes tener una sangría de 4 espacios. (Dato curioso: Los lineamientos de estilo internos de Google indican la sangría de 2 espacios).

Código verificado en el entorno de ejecución

Python realiza muy pocas verificaciones en el tiempo de compilación y aplaza casi todas las verificaciones de tipo, nombre, etc. en cada línea hasta que se ejecute. Supongamos que el comando main() anterior llama a repeat() de la siguiente manera:

def main():
    if name == 'Guido':
        print(repeeeet(name) + '!!!')
    else:
        print(repeat(name))

La sentencia if contiene un error obvio, en el cual la función repeat() se escribe accidentalmente como repeeeet(). Lo gracioso de Python es que este código se compila y se ejecuta bien, siempre y cuando el nombre del entorno de ejecución no sea “Guido”. Solo cuando una ejecución intente ejecutar repeeeet() notará que no existe tal función y generará un error. También hay un segundo error en este fragmento. al nombre no se le asignó un valor antes de que se comparara con 'Guido'. Python generará un “NameError” si intentas evaluar una variable sin asignar. Estos son algunos ejemplos que demuestran que cuando ejecutas un programa Python por primera vez, algunos de los primeros errores que verás serán errores tipográficos simples o variables no inicializadas como estas. Esta es un área en la que los lenguajes con un sistema de tipos más detallados, como Java, tienen una ventaja ... pueden detectar esos errores en el tiempo de compilación (pero, por supuesto, debes mantener toda esa información de tipo ... es una compensación).

Python 3 introdujo las sugerencias de tipo. Las sugerencias de tipo te permiten indicar cuál es el tipo para cada argumento en una función y qué cuál es el tipo del objeto que devuelve la función. Por ejemplo, en la función con anotaciones def is_positive(n: int) -> bool:, el argumento n es int y el valor que se muestra es bool. Más adelante veremos qué significan estos tipos. Sin embargo, las sugerencias de tipo son totalmente opcionales. Verás cada vez más código que adopta sugerencias de tipo, ya que, si las usas, algunos editores, como cider-v y VS.code, pueden ejecutar verificaciones para comprobar que tus funciones se llamen con los tipos de argumento correctos. Incluso pueden sugerir y validar argumentos mientras editas el código. En este instructivo, no veremos las sugerencias de tipos, pero queremos asegurarnos de que las conozcas si te enteras de ni verlos en la naturaleza.

Nombres de variables

Dado que las variables de Python no tienen ningún tipo escrito en el código fuente, es muy útil asignarles nombres significativos a las variables para que recuerdes lo que sucede. Por eso, usa "nombre" si es un solo nombre, y "nombres" si es una lista de nombres y "tuplas" si es una lista de tuplas. Muchos errores básicos de Python son el resultado de olvidar qué tipo de valor hay en cada variable, así que usa los nombres de tus variables (todo lo que tienes en realidad) para no quedarte sin problemas.

En lo que respecta a la nomenclatura real, algunos idiomas prefieren usar partes_bajos para los nombres de variables compuestos por "más de una palabra", pero otros lenguajes prefieren el formato CamelCasing. En general, Python prefiere el método de guion bajo, pero guía a los desarrolladores a utilizar camelCasing si se integra en código existente de Python que ya usa ese estilo. La legibilidad cuenta. Obtén más información en la sección sobre convenciones de nombres en PEP 8.

Como pueden suponer, las palabras clave como y “mientras” no se pueden usar como nombres de variables; si lo haces, verás un error de sintaxis. Sin embargo, ten cuidado de no usar elementos integrados como nombres de variables. Por ejemplo, mientras que "str", "list" e "imprimir" pueden parecer buenos nombres, estarías anulando esas variables del sistema. Los elementos integrados no son palabras clave y, por lo tanto, los nuevos desarrolladores de Python pueden usarlos de forma involuntaria.

Más información sobre los módulos y sus espacios de nombres

Supongamos que tienes un módulo "binky.py". que contiene una “def foo()”. El nombre completamente calificado de esa función foo es “binky.foo”. De esta manera, varios módulos de Python pueden nombrar sus funciones y variables como quieran, y los nombres de las variables no entrarán en conflicto: module1.foo es diferente de module2.foo. En el vocabulario de Python, diríamos que binky, module1 y module2 tienen sus propios “espacios de nombres”, que, como puedes suponer, son vinculaciones de nombre a objeto de variables.

Por ejemplo, tenemos el estándar “sys” que contiene algunas instalaciones estándar del sistema, como la lista argv y la función exit(). Con la instrucción "import sys" puedes acceder a las definiciones del módulo sys y ponerlas a disposición con su nombre completamente calificado, p.ej., sys.exit(). (Sí, "sys" también tiene un espacio de nombres)

  import sys

  # Now can refer to sys.xxx facilities
  sys.exit(0)

Hay otro formulario de importación similar a este: “from sys import argv, exit”. Eso hace que argv y exit() estén disponibles por sus nombres cortos; Sin embargo, recomendamos el formulario original con los nombres completos porque es mucho más fácil determinar de dónde proviene una función o un atributo.

Existen muchos módulos y paquetes que se incluyen con una instalación estándar del intérprete de Python, por lo que no tienes que hacer nada más para usarlos. Estos se conocen colectivamente como la “Biblioteca estándar de Python”. Los módulos o paquetes que se usan con frecuencia incluyen:

sys — acceso a exit(), argv, stdin, stdout, ...
re — expresiones regulares
SO: interfaz del sistema operativo, sistema de archivos

Puedes encontrar la documentación de todos los módulos y paquetes de la Biblioteca estándar en http://docs.python.org/library.

Ayuda en línea, `help()` y `dir()`

Existen varias formas de obtener ayuda para Python.

Haz una búsqueda en Google, comenzando con la palabra “python”, como “lista de python” o “python string en minúscula”. A menudo, el primer hit es la respuesta. Por algún motivo, esta técnica parece funcionar mejor en Python que con otros lenguajes.
El sitio oficial de documentos de Python: docs.python.org: Tiene documentos de alta calidad. No obstante, a menudo encuentro una búsqueda de Google con un par de palabras que es más rápida.
También hay una lista de distribución oficial de Tutor diseñada específicamente para quienes son nuevos en Python o la programación.
Puedes encontrar muchas preguntas (y respuestas) en StackOverflow y Quora.
Utiliza las funciones help() y dir() (consulta a continuación).

Dentro del intérprete de Python, la función help() extrae cadenas de documentación para varios módulos, funciones y métodos. Estas cadenas de documentos son similares a javadoc de Java. La función dir() indica cuáles son los atributos de un objeto. Estas son algunas maneras de llamar a help() y dir() desde el intérprete:

help(len): Es la cadena de ayuda para la función len() integrada. ten en cuenta que es "len" no “len()”, que es una llamada a la función, que no queremos
help(sys): Es la cadena de ayuda para el módulo sys (primero debes hacer un import sys).
dir(sys): dir() es como help(), pero solo proporciona una lista rápida de sus símbolos definidos o "atributos".
help(sys.exit): Es la cadena de ayuda para la función exit() en el módulo sys.
help('xyz'.split): Es la cadena de ayuda del método split() para objetos de cadena. Puedes llamar a help() con ese objeto o con un ejemplo de ese objeto, además de su atributo. Por ejemplo, llamar a help('xyz'.split) es lo mismo que llamar a help(str.split).
help(list): Es la cadena de ayuda para objetos list.
dir(list): Muestra los atributos de objeto list, incluidos sus métodos
help(list.append): Es la cadena de ayuda del método append() para objetos list.