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

Introducción a Python

Introducción

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

Si buscas un curso MOOC complementario, prueba los de Udacity y Coursera (Introducción a la programación [principiantes] o Introducción a Python). Por último, si buscas aprendizaje en línea a tu propio ritmo sin mirar videos, prueba los que se enumeran hacia el final de esta publicación. Cada uno incluye contenido de aprendizaje de funciones y un intérprete interactivo de Python con el que puedes practicar. ¿A qué nos referimos con "intérprete"? Lo descubrirás en la siguiente sección.

Introducción al lenguaje

Python es un lenguaje dinámico, interpretado (compilado en bytecode). 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 verificación de tipos en tiempo de compilación del código fuente. Python hace un seguimiento de los tipos de todos los valores en el tiempo de ejecución y marca el código que no tiene sentido a medida que 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 int a un list?", escribirla en el intérprete de Python es una forma rápida y, probablemente, la mejor de ver qué sucede. (Consulta a continuación lo que sucede 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 del símbolo >>> te indican la versión de Python que estás usando y dónde se compiló. Siempre y cuando lo primero que se imprima 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 "genera" en términos de Python, un error de tiempo 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 entre mayúsculas y 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 un "#" y se extienden hasta el final de la línea.

Código fuente de Python

Los archivos fuente de Python usan la extensión ".py" y se denominan "módulos". Con un módulo de Python hello.py, la forma más sencilla 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 le pasa el argumento de línea de comandos "Alice". Consulta la página de documentación oficial sobre todas las opciones diferentes que tienes cuando ejecutas Python desde la línea de comandos.

Aquí tienes un programa hello.py muy simple (observa que los bloques de código se delimitan estrictamente con sangría en lugar de llaves; hablaremos más sobre 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 de la siguiente manera:

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

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

Las instrucciones más externas de un archivo de Python, o "módulo", realizan su configuración única. Estas instrucciones 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 mostró anteriormente con python3 hello.py Bob) o se puede importar y usar en otro módulo. Cuando un archivo de Python se ejecuta directamente, la variable especial "__name__" se establece en "__main__". Por lo tanto, es común tener el código estándar if __name__ ==... que se muestra arriba para llamar a una función main() cuando el módulo se ejecuta directamente, pero no cuando otro módulo lo importa.

En un programa de Python estándar, la lista sys.argv contiene los argumentos de la línea de comandos de la manera estándar, con sys.argv[0] como el programa en sí, sys.argv[1] como el primer argumento, y así sucesivamente. Si conoces argv o la cantidad de argumentos, puedes solicitar este valor a Python con len(sys.argv), al igual que lo hicimos en el código del intérprete interactivo anterior cuando solicitamos 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

También observa cómo las líneas que componen la función o la instrucción if se agrupan por tener todas el mismo nivel de sangría. También presentamos 2 formas diferentes de repetir cadenas, con el operador + que es más fácil de usar, pero * también funciona porque es el operador de "repetición" de Python, lo que significa que '-' * 10 da '----------', una forma ordenada de crear una "línea" en pantalla. En el comentario del código, sugerimos que * funciona más rápido que +, ya que * calcula el tamaño del objeto resultante una sola vez, mientras que con +, ese cálculo se realiza cada vez que se llama a +. Los operadores + y * se denominan "sobrecargados" porque significan cosas diferentes para los números y para las 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 cadena de documentación puede ser de una sola línea o una descripción de varias líneas, como en el ejemplo anterior. (Sí, esas son "comillas triples", una característica exclusiva de Python). Las variables definidas en la función son locales para esa función, por lo que el "resultado" en la función anterior es independiente de una variable "resultado" en otra función. La instrucción return puede tomar un argumento, en cuyo caso ese es el valor que se devuelve al llamador.

Este es el código que llama a la función repeat() anterior y muestra lo que devuelve:

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

En el tiempo de ejecución, las funciones deben definirse con la ejecución de un "def" antes de que se llamen. Es habitual definir una función main() cerca de la parte inferior del archivo con las funciones que llama arriba.

Sangría

Una característica inusual de Python es que la indentación de espacios en blanco de un fragmento de código afecta su significado. Un bloque lógico de instrucciones, como los que componen una función, debe 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 marcará como un error de sintaxis.

El uso de espacios en blanco en Python puede parecer un poco extraño al principio, pero es lógico y me acostumbré a él muy rápido. Evita usar TABULACIONES, ya que complican mucho el esquema de sangría (sin mencionar que las TABULACIONES pueden tener diferentes significados en diferentes plataformas). Configura tu editor para que inserte espacios en lugar de TABULACIONES para el código de Python.

Una pregunta común que hacen los principiantes es: "¿Cuántos espacios debo agregar en la sangría?". Según la guía de estilo oficial de Python (PEP 8), debes agregar una sangría de 4 espacios. (Dato curioso: La guía de estilo interna de Google indica que se debe agregar una sangría de 2 espacios).

Código verificado en el tiempo de ejecución

Python realiza muy pocas verificaciones en el tiempo de compilación y difiere casi todas las verificaciones de tipo, nombre, etcétera, en cada línea hasta que se ejecuta esa línea. Supongamos que la función 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 que la función repeat() se escribe accidentalmente como repeeeet(). Lo curioso de Python es que este código se compila y se ejecuta correctamente siempre y cuando el nombre en el tiempo 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: no se le asignó un valor a name antes de compararlo con "Guido". Python generará un "NameError" si intentas evaluar una variable no asignada. Estos son algunos ejemplos que demuestran que, cuando ejecutas un programa en Python por primera vez, algunos de los primeros errores que verás serán errores de escritura simples o variables no inicializadas como estas. Esta es un área en la que los lenguajes con un sistema de tipos más detallado, 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 tipos… es una compensación).

Python 3 introdujo las sugerencias de tipo. Las sugerencias de tipo te permiten indicar el tipo de cada argumento en una función, así como el tipo del objeto que devuelve la función. Por ejemplo, en la función anotada def is_positive(n: int) -> bool:, el argumento n es un int y el valor de retorno es un bool. Más adelante, analizaremos qué significan estos tipos. Sin embargo, las sugerencias de tipo son totalmente opcionales. Verás que cada vez más código adopta sugerencias de tipo porque, 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 argumentos correctos. Incluso pueden sugerir y validar argumentos a medida que editas el código. En este instructivo, no se tratarán las sugerencias de tipo, pero queremos asegurarnos de que las conozcas si las escuchas o las ves en la práctica.

Nombres de variables

Dado que las variables de Python no tienen ningún tipo especificado en el código fuente, es muy útil asignar nombres significativos a tus variables para recordar lo que sucede. Por lo tanto, usa "name" si es un solo nombre, "names" si es una lista de nombres y "tuples" si es una lista de tuplas. Muchos errores básicos de Python se deben a que se olvida qué tipo de valor hay en cada variable, por lo que debes usar los nombres de las variables (lo único que tienes realmente) para mantener todo en orden.

En cuanto a la nomenclatura real, algunos lenguajes prefieren partes_con_guiones_bajos para los nombres de variables que se componen de "más de una palabra", pero otros lenguajes prefieren camelCase. En general, Python prefiere el método de guion bajo, pero guía a los desarrolladores para que usen camelCase si se integran en código de Python existente que ya usa ese estilo. Recuentos de legibilidad. Obtén más información en la sección sobre convenciones de nomenclatura en PEP 8.

Como puedes suponer, las palabras clave como "if" y "while" no se pueden usar como nombres de variables. Si lo haces, recibirás un error de sintaxis. Sin embargo, ten cuidado de no usar elementos integrados como nombres de variables. Por ejemplo, si bien "cad", "lista" y "print" pueden parecer buenos nombres, anularías esas variables del sistema. Las funciones integradas no son palabras clave y, por lo tanto, los desarrolladores nuevos de Python pueden usarlas sin querer.

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

Supongamos que tienes un módulo "binky.py" que contiene un "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 nombres de variables a objetos.

Por ejemplo, tenemos el módulo estándar "sys" que contiene algunas utilidades estándar del sistema, como la lista argv y la función exit(). Con la instrucción "import sys", puedes acceder a las definiciones en el módulo sys y hacer que estén disponibles por 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 que se ve así: "from sys import argv, exit". Esto hace que argv y exit() estén disponibles por sus nombres cortos. Sin embargo, recomendamos la forma original con los nombres completos porque es mucho más fácil determinar de dónde proviene una función o un atributo.

Hay muchos módulos y paquetes incluidos en una instalación estándar del intérprete de Python, por lo que no tienes que hacer nada adicional para usarlos. En conjunto, se conocen como la "Biblioteca estándar de Python". Entre los módulos y paquetes de uso común, se incluyen los siguientes:

sys: Acceso a exit(), argv, stdin, stdout, …
re: expresiones regulares
os: 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.

Realiza una búsqueda en Google que comience con la palabra "python", como "lista de Python" o "cadena de Python en minúsculas". La primera coincidencia suele ser la respuesta. Por algún motivo, esta técnica parece funcionar mejor para Python que para otros lenguajes.
El sitio oficial de documentación de Python, docs.python.org, tiene documentación de alta calidad. Sin embargo, a menudo me resulta más rápido buscar un par de palabras en Google.
También hay una lista de correo oficial de Tutor diseñada específicamente para quienes son nuevos en Python o en la programación.
En StackOverflow y Quora, puedes encontrar muchas preguntas (y respuestas).
Usa 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 documentación son similares a las javadoc de Java. La función dir() te indica cuáles son los atributos de un objeto. A continuación, se muestran algunas formas de llamar a help() y dir() desde el intérprete:

help(len): Cadena de ayuda para la función integrada len(). Ten en cuenta que es "len" y no "len()", que es una llamada a la función, que no queremos.
help(sys): Cadena de ayuda para el módulo sys (primero se debe hacer un import sys)
dir(sys): dir() es similar a help(), pero solo proporciona una lista rápida de sus símbolos definidos, o "atributos".
help(sys.exit): Cadena de ayuda para la función exit() en el módulo sys
help('xyz'.split): Es la cadena de ayuda para el 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): Cadena de ayuda para objetos list
dir(list): Muestra los atributos del objeto list, incluidos sus métodos.
help(list.append): Cadena de ayuda para el método append() para objetos list

Introducción a Python Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.