La versión más actualizada de este documento está disponible en: rip3.arielortiz.info

python

1. Básicos

Tema Descripción Ejemplos

Comentarios

Comienzan con un signo de numeral (#) y terminan hasta el final de la línea. Son ignorados por Python y sirven para que el programador coloque notas o explicaciones respecto al código fuente para que sea más fácil de entender.

# Esto es un comentario

Identificadores

Un identificador es un nombre que se utiliza para identificar una variable, función o módulo.

Un identificador comienza con una letra de la A a la Z (mayúscula o minúscula) o un guión bajo (_) seguido de cero o más letras, guiones bajos y dígitos del 0 al 9. No es válido definir un identificador que sea igual a una palabra clave del lenguaje.

x

spam7

REY_ARTURO

caballeros_que_dicen_ni

Palabras clave

Los siguientes nombres se utilizan como palabras reservadas o palabras clave de Python y no se pueden usar como identificadores comunes.

False      await      else       import     pass
None       break      except     in         raise
True       class      finally    is         return
and        continue   for        lambda     try
as         def        from       nonlocal   while
assert     del        global     not        with
async      elif       if         or         yield

Variables

Una variable es una localidad de memoria en la que se puede almacenar un valor. Toda variable debe tener un nombre, el cual debe ser un identificador. Las variables se crean en el momento en que se les asigna un valor.

>>> # Crear dos variables.
>>> nombre = 'Brian'
>>> edad = 33
>>> # Imprimir los valores de esas
>>> # dos variables.
>>> print(nombre, edad)
Brian 33

Bloques e indentación

Un grupo de estatutos relacionados (por ejemplo, los estatus correspondientes a un \(\texttt{if}\) o a un \(\texttt{else}\)) conforman un bloque y deben estar indentados al mismo nivel. La indentación comienza un bloque y su ausencia lo termina. Un bloque puede estar anidado dentro de otro bloque. Se recomienda usar cuatro espacios en cada nivel de indentación.

>>> if 1 < 2:
...     # Comienza bloque 1.
...     print('uno')
...     print('menor que')
...     print('dos')
...     # Termina bloque 1.
... else:
...     # Comienza bloque 2.
...     print('algo')
...     print('raro')
...     print('pasó')
...     if 2 + 2 == 5:
...         # Comienza bloque 3.
...         print('¡No puede ser!')
...         # Termina bloque 3.
...     print('fin')
...     # Termina bloque 2.
...
uno
menor que
dos

2. Obteniendo ayuda

Función Descripción Ejemplos

\(\texttt{help()}\)
\(\texttt{help}(x)\)

Función que invoca al sistema de ayuda que está diseñada para uso interactivo. Si se omite \(x\), el sistema de ayuda interactiva se inicia en la consola del intérprete. Si el argumento es una cadena, se busca la cadena como si fuera el nombre de un módulo, función, tipo, método, palabra clave o tema de documentación, y se imprime la página correspondiente de ayuda en la consola. Si el argumento es cualquier otro tipo de objeto, se genera una página de ayuda para ese objeto en particular.

Puede ser necesartio presionar la tecla q para salir de una pantalla interactiva.
>>> help('pass')

The "pass" statement
********************

   pass_stmt ::= "pass"

"pass" is a null operation — when it is executed, nothing happens. It is useful as a placeholder when a statement is required syntactically, but no code needs to be executed, for example:

   def f(arg): pass    # a function that
                       # does nothing (yet)

   class C: pass       # a class with no
                       # methods (yet)

>>> help(abs)
Help on built-in function abs in module builtins:

abs(x, /)
    Return the absolute value of the
    argument.

\(\texttt{dir}(x)\)

Función que devuelve una lista de cadenas que corresponden a los nombres de los atributos con los que cuenta el objeto \(x\).

>>> # ¿Qué atributos tiene el tipo str?
>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
Referencia completa: help, dir.

3. Tipos de datos

Tipo Descripción Ejemplos

int

Número entero. Puede ser positivo o negativo. El rango de estos valores es ilimitado, sujeto a la memoria disponible de la computadora.

Ver también la sección de números.

>>> 42
42
>>> -7
-7

float

Número real o de punto flotante. Usualmente contiene un punto decimal y puede ser positivo o negativo. Alternativamente, puede expresarse usando notación científica; por ejemplo, \(1.5 \times 10^{-3}\) se escribe así: 1.5e-3

Rango aproximado (con 15 dígitos decimales de precisión):

\[ \pm 2.225 \times 10^{-308} \cdots \pm 1.798 \times 10^{+308} \]

Ver también la sección de números.

>>> 3.1416
3.1416
>>> 6.62607015e-34
6.62607015e-34
>>> -1e6
-1000000.0

bool

Valor lógico o booleano. Tiene dos posibles valores: verdadero (True) y falso (False), los cuales son equivalentes e intercambiables por los valores enteros 1 y 0, respectivamente, en casi todos los contextos.

Ver también la sección de booleanos.

>>> True
True
>>> False
False

str

Cadena de caracteres. Secuencia de cero o más caracteres entre comillas, ya sean simples (') o dobles ("), en una misma línea. Una cadena es inmutable. Las cadenas pueden contener secuencias de escape.

Es posible tener cadenas multilíneas usando triples comillas (''' o """) como delimitadores.

Ver también la sección de cadenas.

>>> '¡Hola, mundo!'
'¡Hola, mundo!'
>>> ""  # Cadena vacía
''
>>> """Uno
... dos
... tres."""
'Uno\ndos\ntres.'
>>> '\N{Euro sign}'
'€'

list

Lista. Secuencia de cero o más valores separados por comas y delimitados por corchetes ([ y ]). Una lista es mutable. Los valores contenidos en una lista pueden ser todos del mismo tipo o de tipos diferentes.

Ver también la sección de listas.

>>> [4, 8, 15, 16, 23, 42]
[4, 8, 15, 16, 23, 42]
>>> ['uno', 1, 1.0, True]
['uno', 1, 1.0, True]
>>> []  # Lista vacía
[]

tuple

Tupla. Secuencia de cero o más valores separados por comas y delimitados por paréntesis. Una tupla es inmutable. Los valores contenidos en una tupla pueden ser todos del mismo tipo o de tipos diferentes.

Ver también la sección de tuplas.

>>> (4, 8, 15, 16, 23, 42)
[4, 8, 15, 16, 23, 42]
>>> ('uno', 1, 1.0, True)
['uno', 1, 1.0, True]
>>> ()  # Tupla vacía
()
>>> (42,)  # Con un elemento
(42,)

dict

Diccionario. Colección que permite asociar (o mapear) claves a valores. El diccionario se delimita usando los símbolos de llaves ({ y }). Cada clave se asocia a un valor determinado usando el símbolo de dos puntos (:). Las parejas clave/valor se separan entre sí usando comas. Un diccionario es mutable. Las claves deben ser de un tipo inmutable y deben ser únicas dentro de cada diccionario. Los valores asociados pueden ser de cualquier tipo.

Ver también la sección de diccionarios.

>>> {'a': 1, 'b': 2, 'c':3}
{'a': 1, 'b': 2, 'c': 3}
>>> {'x': True, 2: [3, 4]}
{'x': True, 2: [3, 4]}
>>> {}  # Diccionario vacío
{}

None

Valor nulo o inexistente. Representa la ausencia de un valor útil. Por omisión, las funciones devuelven None cuando carecen de una instrucción return con un valor explícito.

Usualmente el valor de None no se despliega en los shells o consolas interactivas de Python.
>>> None  # No se imprime resultado
>>> print(None)
None
Referencia completa: The standard type hierarchy.

4. Operadores

Un operador es un símbolo que realiza una operación en uno o más operandos. Un operando es una variable o un valor con el que realizamos la operación.

Por ejemplo, el símbolo + (más) es un operador que pemite realizar sumas, mientras que el símbolo * (asterisco) es un operador que permite realizar multiplicaciones.

Ejemplos:

>>> 1 + 1
2
>>> x = 5
>>> x * 2
10

4.1. Precedencia

Si una expresión contiene múltiples operadores, la precedencia determina el orden en el que se deben evaluar. Por ejemplo:

>>> 1 + 2 * 3
7

La expresión anterior da como resultado 7 en lugar de 9 debido a que la multiplicación tiene mayor precedencia (se realiza antes) que la suma. En la sección de lista de operadores se puede consultar la precedencia de todos los operadores descritos en esta referencia.

Sin embargo, es posible usar paréntesis para obligar a que una expresión se evalúe en un orden diferente. A partir del ejemplo anterior, si deseamos que la suma se realice antes que la multiplicación debemos reescribirla así:

>>> (1 + 2) * 3
9

Si una expresión tiene múltiples operadores con la misma precedencia, entonces se evalúan en orden de izquierda a derecha (la única excepción es el operador de potenciación). Ejemplos:

>>> 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10  (1)
55
>>> 1 / 2 / 3 / 4 / 5  (2)
0.008333333333333333
>>> 8 / 2 * (2 + 2)  (3)
16.0
1 En esta expresión primero se calcula \(1+2\), luego a ese resultado se le suma 3, y así sucesivamente hasta llegar al resultado final. Si las sumas se realizaran de derecha a izquierda el resultado sería el mismo, dado que la suma es asociativa, es decir “\((x + y) + z\)” produce el mismo resultado que “\(x + (y + z)\)”.
2 De manera similar, en esta expresión primero se calcula \(1 / 2\), luego a ese resultado se le divide entre 3, y así sucesivamente hasta llegar al resultado final. Si las divisiones se realizaran de derecha a izquierda el resultado sería otro (1.875 en esta caso) dado que, a diferencia de la suma, la división no es asociativa.
3 Lo que está en paréntesis se evalúa primero. Pero luego la división y la multiplicación están al mismo nivel y ambos operadores tienen la misma precedencia. Siguiendo la regla descrita, evaluamos de izquierda a derecha: primero se divide y luego se multiplica.

Dato curioso: a finales de julio de 2019 se viralizó en redes sociales el reto 8÷2(2+2) que polarizó a la gente con dos posibles respuestas: 1 y 16. Como se puede ver aquí, Python dice que el resultado es 16.

4.2. Lista de operadores

La siguiente tabla resume todos los operadores de Python descritos en esta referencia así como su precedencia, que va de mayor a menor. Los operadores que se encuentran en el mismo renglón tienen la misma precedencia.

Operador Nombre

Mayor precedencia

()
x[i], x[i:j], x(args...), x.atrib

Indexación, rebanada, invocación de función, referencia a atributo.

**
+x, -x
*, /, //, %
+, -
in, not in, is, is not, <, <=, >, >=, !=, ==
not
and

Menor precedencia

or
Referencia completa: Operator precedence.

5. Estatutos

Estatuto Descripción Ejemplos

Asignación

Sintaxis:

\(\; \; \; \; \textit{var} \; \texttt{=} \; \textit{exp}\)

Asigna a la variable \(\textit{var}\) el valor de la expresión \(\textit{exp}\).

Se pueden asignar \(n\) valores diferentes a \(n\) variables (separadas por comas) al mismo tiempo, siempre y cuando exp sea una colección (cadena, lista, tupla, diccionario o rango) con \(n\) elementos.

Se pueden asignar varias variables con el mismo valor usando la siguiente sintaxis:

\(\; \; \; \; \textit{v}_1 \, \texttt{=} \, \textit{v}_2 \, \texttt{=} \, \textit{v}_3 \, \texttt{=} \, \ldots \, \texttt{=} \, \textit{exp}\)

>>> edad = 6 * 3
>>> edad
18
>>> nombre = 'Juan'
>>> nombre
Juan
>>> a, b, c = [1, 10, 100]
>>> print(a, b, c)
1 10 100
>>> x = y = z = 0
>>> print(x, y, z)
0 0 0

Asignación compuesta

Sintaxis:

\(\; \; \; \; \textit{var} \; \texttt{⊕=} \; \textit{exp}\)

En donde \(\texttt{⊕}\) es alguno de los operadores +, -, *, /, //, % o **.

Este estatuto es básicamente equivalente a:

\(\; \; \; \; \textit{var} \texttt{ = } \textit{var} \texttt{ ⊕ } (\textit{exp})\)

>>> i = 10
>>> i += 1  # i = i + (1)
>>> i
11
>>> x = 1
>>> x /= 2  # x = x / (2)
>>> x
0.5
>>> a = 5
>>> a **= 2 + 1  # a = a ** (2 + 1)
>>> a
125

Importación de módulos

Sintaxis 1:

\(\; \; \; \; \texttt{import}\) módulo

Realiza la importación de módulo. En lo sucesivo, todo elemento id contenido en módulo puede ser referido usando la notación:

\(\; \; \; \; \)módulo . id


Sintaxis 2:

\(\; \; \; \; \texttt{from}\) módulo \(\texttt{import} \; \textit{id}, \ldots\)

Realiza la importación individual de cada id contenida en módulo. En lo sucesivo, todo elemento id puede ser referido directamente por su nombre.

>>> # Ejemplo sintaxis 1
>>> import math
>>> math.sqrt(100)
10.0
>>> math.pi
3.141592653589793
>>> # Ejemplo sintaxis 2
>>> from math import sqrt, pi
>>> sqrt(100)
10.0
>>> pi
3.141592653589793

Condicional if

Sintaxis:

\(\; \; \; \; \texttt{if} \; \textit{exp}_1\):
\(\; \; \; \; \; \; \; \; \; \; \textit{estats}_1\)
\(\; \; \; \; [ \texttt{elif} \; \textit{exp}_2\):
\(\; \; \; \; \; \; \; \; \; \; \textit{estats}_2\)
\(\; \; \; \; \texttt{elif} \; \textit{exp}_3\):
\(\; \; \; \; \; \; \; \; \; \; \textit{estats}_3\)
\(\; \; \; \; \; \; \; \; \; \; \vdots\)
\(\; \; \; \; ]\)
\(\; \; \; \; [ \texttt{else}:\)
\(\; \; \; \; \; \; \; \; \; \; \textit{estats}_n]\)

Los corchetes \([ \, ]\) usados arriba indican que dicho elemento es opcional.

Selecciona exactamente uno de los grupos de estatutos \(\textit{estats}_i\) mediante la evaluación de las expresiones \(\textit{exp}_i\) una por una hasta que se encuentra que una es verdadera; entonces ejecuta ese grupo de estatutos. Ninguna otra parte del estatuto \(\texttt{if}\) se ejecuta o evalúa. Si todas las expresiones \(\textit{exp}_i\) son falsas, se ejecuta el grupo de estatutos correspondientes al \(\texttt{else}\), en caso de estar presente.

>>> x = 10
>>> if x < 15:
...     print(f'{x} < 15')
...
10 < 15
>>> if x > 15:
...     print(f'{x} > 15')
... else:
...     print(f'{x} <= 15')
...
10 <= 15
>>> if x < 5:
...     print(f'{x} < 5')
... elif x < 10:
...     print(f'5 <= {x} < 10')
... elif x < 15:
...     print(f'10 <= {x} < 15')
... else:
...     print(f'{x} >= 15')
...
10 <= 10 < 15

Ciclo while

Sintaxis:

\(\; \; \; \; \texttt{while} \; \textit{exp}\):
\(\; \; \; \; \; \; \; \; \; \; \textit{estats}\)

Evalúa la expresión \(\textit{exp}\). Si resulta verdadera ejecuta el grupo de estatutos \(\textit{estats}\). Posteriormente se repite el proceso una y otra vez mientras \(\textit{exp}\) sea verdadera. El ciclo termina cuando el resultado de \(\textit{exp}\) es falso.

Es posible que el grupo de estatutos \(\textit{estats}\) nunca se ejecute si \(\textit{exp}\) resulta falsa desde el mero inicio del ciclo.

Se puede usar un estatuto break para salirse de un ciclo en cualquier momento.

>>> i = 1
>>> while i < 5:
...     print(i)
...     i += 1
...
1
2
3
4
>>> # El siguiente ciclo se ejecuta
>>> # cero veces.
>>> j = 5
>>> while j < 5:
...     print(j)
...     j += 1
...
>>> # Uso del estatuto break.
>>> k = 1
>>> while True:
...     print(k)
...     k += 1
...     if k > 5:
...         break
...
1
2
3
4
5

Ciclo for

Sintaxis:

\(\; \; \; \; \texttt{for} \; \textit{var} \; \texttt{in} \; s\):
\(\; \; \; \; \; \; \; \; \; \; \textit{estats}\)

La variable \(\textit{var}\) toma el valor del primer elemento de \(s\), el cual debe ser objeto iterable (cadena, lista, tupla, diccionario, rango o archivo). Posteriormente ejecuta el grupo de estatutos \(\textit{estats}\). Esto se repite con los demás elementos sucesivamente, uno por uno, hasta agotar todos los elementos de \(s\).

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
>>> for letra in 'hola':
...     print(letra)
...
h
o
l
a
>>> suma = 0
>>> for n in [4, 8, 15, 16, 23, 42]:
...     suma += n
...     print(n, suma)
...
4 4
8 12
15 27
16 43
23 66
42 108
>>> # El ciclo for sobre un diccionario
>>> # permite iterar sobre todas sus claves.
>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> for k in d:
...     print(k, d[k])
...
uno 1
dos 2
tres 3

Definición de función

Sintaxis:

\(\; \; \; \; \texttt{def} \; \textit{fun}(\textit{parm}_1, \textit{parm}_2, \ldots)\):
\(\; \; \; \; \; \; \; \; \; \; \texttt{"""}\) Documentación \(\texttt{"""}\)
\(\; \; \; \; \; \; \; \; \; \; \textit{estats}\)

Define una función llamada \(\textit{fun}\) con parámetros \(\textit{parm}_1, \textit{parm}_2, \ldots\) y un cuerpo conformado por el grupo de estatutos \(\textit{estats}\).

Si se desea que la función devuelva un valor específico, este se puede indicar usando el estatuto return. Si la función no devuelve explícitamente un valor, por omisión devuelve None.

Ver también el estatuto de invocación de función.

>>> def hola_mundo():
...     """Imprime hola mundo."""
...     print('¡Hola, mundo!')
...
>>> def discriminante(a, b, c):
...     """Calcula la discriminante.
...
...     Devuelve la discriminante de
...     una ecuación cuadrática de la
...     forma:
...
...         ax^2 + bx + c = 0
...     """
...     return b ** 2 - 4 * a * c
...

Invocación de función

Sintaxis:

\(\; \; \; \; \textit{fun}(\textit{exp}_1, \textit{exp}_2, \ldots)\)

Manda llamar a la función llamada \(fun\) con \(\textit{exp}_1, \textit{exp}_2, \ldots\) como argumentos.

Ver también el estatuto de definición de función.

>>> # Las funciones hola_mundo y
>>> # discriminante fueron definidas
>>> # en los ejemplos del estatuto de
>>> # definición de función.
>>> hola_mundo()
¡Hola, mundo!
>>> discriminante(6 - 2 * 2, 4 * 4, 8 * 4)
0

Estatuto with

Sintaxis:

\(\; \; \; \; \texttt{with} \; \textit{exp} \; \texttt{as} \; \textit{var}, \ldots\):
\(\; \; \; \; \; \; \; \; \; \; \textit{estats}\)

Se utiliza principalmente al momento de abrir y procesar archivos, pues se garantiza que estos quedan cerrados al concluir el estatuto.

>>> # Crear un archivo
... with open('original.txt', 'w') as a:
...     a.write('¡Uno, dos, cinco!')
...
>>> # Hacer una copia de original.txt
... with open('original.txt') as entrada, \
...      open('copia.txt', 'w') as salida:
...     info = entrada.read()
...     salida.write(info)
...
>>> # Ver contenido de copia.txt
... with open('copia.txt') as a:
...     print(a.read())
...
¡Uno, dos, cinco!

Estatuto nulo

Sintaxis:

\(\; \; \; \; \texttt{pass}\)

No hace nada cuando se ejecuta. Se puede usar cuando un estatuto es requerido sintácticamente pero no se necesita acción alguna en ese momento.

>>> if 1 < 2:
...     pass
...
>>> def alguna_funcion():
...     """No hace nada."""
...     pass
...
Referencia completa: Simple statements, Compound statements.

6. Conversiones y manejo de tipos

Función Descripción Ejemplos

\(\texttt{bool}(x)\)

Devuelve True si \(x\) tiene un valor verdadero, o False en caso contrario.

>>> bool(42)
True
>>> bool([])
False
>>> bool(0.0)
False
>>> bool([1, 2, 3])
True

\(\texttt{chr}(x)\)

Devuelve una cadena de caracteres cuyo punto de código de Unicode es \(x\). Es posible dibujar un carácter y obtener su punto de código en ShapeCatcher.

Esta es la función inversa de ord.

>>> chr(65)
'A'
>>> chr(128578)
'🙂'

\(\texttt{dict}(x)\)

Crea un nuevo diccionario. \(x\) debe ser una secuencia de parejas clave/valor o un diccionario. En este ultimo caso crea una copia superficial de \(x\).

>>> # Crea un nuevo diccionario a
>>> # partir de una secuencia de parejas
>>> # clave/valor.
>>> d = dict([('a', 1),
...     ('b', 2),
...     ('c', 3)])
>>> d
{'a': 1, 'b': 2, 'c': 3}
>>> # Crea una copia de un diccionario
>>> # existente.
>>> e = dict(d)
>>> e
{'a': 1, 'b': 2, 'c': 3}
>>> d is e
False

\(\texttt{float}(x)\)

Devuelve \(x\) convertido a un flotante. \(x\) debe ser una cadena de caracteres o un valor numérico.

Produce un error si no es posible realizar la conversión.

>>> float(42)
42.0
>>> float('4.5')
4.5
>>> float('hola')
ValueError: could not convert string to float: 'hola'

\(\texttt{id}(x)\)

Devuelve la “identidad” de \(x\). Este es un número entero que se garantiza que es único y constante para este objeto durante toda su vida útil.

En algunas implementaciones de Python esta función devuelve efectivamente la dirección en memoria de \(x\).

>>> id(42)
93850061868320
>>> id(None)
93850061503936
>>> id([1, 2, 3])
140048203470664

\(\texttt{int}(x)\)

Devuelve \(x\) convertido a un entero. \(x\) debe ser una cadena de caracteres o un valor numérico. Se trunca la parte fraccionaria si \(x\) es flotante.

Produce un error si no es posible realizar la conversión.

>>> int(7.8)
7
>>> int('42')
42
>>> int('hola')
ValueError: invalid literal for int(): 'hola'

\(\texttt{isinstance}(x, t)\)

Devuelve True si \(x\) es de tipo \(t\), o False en caso contrario.

>>> isinstance('hola', str)
True
>>> isinstance(42.0, float)
True
>>> isinstance((1, 2, 3), list)
False
>>> isinstance([1, 2, 3], dict)
False

\(\texttt{list}(x)\)

Devuelve \(x\) convertida a una lista. \(x\) debe ser un objeto iterable (cadena, lista, tupla, diccionario o rango).

>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list('hola')
['h', 'o', 'l', 'a']
>>> list((1, 2, 3))
[1, 2, 3]
>>> list({'a': 1, 'b': 2, 'c': 3})
['a', 'b', 'c']

\(\texttt{ord}(x)\)

Devuelve el punto de código de Unicode del carácter contenido en la cadena \(x\).

Esta es la función inversa de chr.

>>> ord('A')
65
>>> ord('Ñ')
209

\(\texttt{str}(x)\)

Devuelve \(x\) convertido a una cadena de caracteres.

>>> str(42)
'42'
>>> str('hola')
'hola'
>>> str([1, 2, 3])
'[1, 2, 3]'

\(\texttt{tuple}(x)\)

Devuelve \(x\) convertida a una tupla. \(x\) debe ser un objeto iterable, tal como una colección (cadena, lista, tupla, diccionario o rango).

>>> tuple(range(5))
(0, 1, 2, 3, 4)
>>> tuple('hola')
('h', 'o', 'l', 'a')
>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple({'a': 1, 'b': 2, 'c': 3})
('a', 'b', 'c')

\(\texttt{type}(x)\)

Devuelve el tipo de dato de \(x\).

>>> type(42)
<class 'int'>
>>> type('hola')
<class 'str'>
>>> type(True)
<class 'bool'>
>>> type([1, 2, 3])
<class 'list'>
Referencia completa: Built-in Functions.

7. Comparaciones

Los operadores ==, !=, <, <=, > y >= se pueden usar como se usan convencionalmente en matemáticas. Así pues, por ejemplo, la expresión matemática:

\[ 0 < a \le b \le c < 100 \]

se puede escribir en Python así:

0 < a <= b <= c < 100

y es básicamente equivalente a:

0 < a and a <= b and b <= c and c < 100

con la única diferencia de que las subexpresiones (0, a, b, c y 10) se evalúan a lo más una sola vez.

7.1. Operaciones de comparación

Operador Descripción Ejemplos

\(x \texttt{ is } y\)

Idéntico. Determina si \(x\) es idéntico a (es exactamente el mismo objeto que) \(y\).

Si la dirección en memoria del objeto \(x\) es la misma que la dirección de memoria del objeto \(y\), entonces se dice que \(x\) es idéntico a \(y\).

>>> a = [1, 2, 3, 4]
>>> b = [1, 2, 3, 4]
>>> c = a
>>> a is b
False
>>> a is c
True

\(x \texttt{ is not } y\)

No idéntico. Determina si \(x\) no es idéntico a (no es exactamente el mismo objeto que) \(y\).

Si la dirección en memoria del objeto \(x\) no es la misma que la dirección de memoria del objeto \(y\), entonces se dice que \(x\) no es idéntico a \(y\).

>>> a = [1, 2, 3, 4]
>>> b = [1, 2, 3, 4]
>>> c = a
>>> a is not b
True
>>> a is not c
False

\(x \texttt{ == } y\)

Igual. Determina si \(x\) es igual a (tiene el mismo valor que) \(y\).

Los tipos numéricos se comparan según su valor numérico, por lo que el 0 entero es igual al 0.0 flotante.

Se utiliza orden lexicográfico cuando se comparan colecciones.

Si se están comparando dos flotantes, es preferible usar la función isclose.

>>> 4 == 2 + 2
True
>>> 2 * 3 == 5
False
>>> 2.0 == 2
True
>>> a = [1, 2, 3, 4]
>>> b = [1, 2, 3, 4]
>>> c = [5, 6]
>>> a == b
True
>>> a == c
False

\(x \texttt{ != } y\)

Diferente. Determina si \(x\) es diferente a (no tiene el mismo valor que) \(y\).

Se utiliza orden lexicográfico cuando se comparan colecciones.

Si se están comparando dos flotantes, es preferible usar la función isclose.

>>> 5 != 2 * 3
True
>>> 2 + 2 != 4
False
>>> a = [1, 2, 3, 4]
>>> b = [1, 2, 3, 4]
>>> c = [5, 6]
>>> a != b
False
>>> a != c
True

\(x \texttt{ < } y\)

Menor. Determina si \(x\) es menor a \(y\).

Se utiliza orden lexicográfico cuando se comparan colecciones.

>>> 1 < 2
True
>>> 15 < 10
False
>>> 7 < 7
False
>>> [1, 2, 3, 4] < [5]
True

\(x \texttt{ <= } y\)

Menor o igual. Determina si \(x\) es menor o igual a \(y\).

Se utiliza orden lexicográfico cuando se comparan colecciones.

>>> 1 <= 2
True
>>> 15 <= 10
False
>>> 7 <= 7
True
>>> [1, 2] <= [3, 4, 5]
True

\(x \texttt{ > } y\)

Mayor. Determina si \(x\) es mayor a \(y\).

Se utiliza orden lexicográfico cuando se comparan colecciones.

>>> 1 > 2
False
>>> 15 > 10
True
>>> 7 > 7
False
>>> [5] > [1, 2, 3, 4]
True

\(x \texttt{ >= } y\)

Mayor o igual. Determina si \(x\) es mayor o igual a \(y\).

Se utiliza orden lexicográfico cuando se comparan colecciones.

>>> 1 >= 2
False
>>> 15 >= 10
True
>>> 7 >= 7
True
>>> [3, 4, 5] >= [1, 2]
True
Referencia completa: Comparisons.

7.2. Orden lexicográfico

Una colección (cadena, lista, tupla, diccionario y rango) se puede comparar con otra colección siempre y cuando sea del mismo tipo. En este caso se usa orden lexicográfico, el cual consiste en comparar el primer elemento de la primera colección con el primer elemento de la segunda colección. Si difieren, esto determina el resultado de la comparación. Si son iguales, se compara el siguiente par de elementos, y así sucesivamente hasta agotar cualquiera de las colecciones. Si dos elementos que deben compararse son a su vez colecciones del mismo tipo, la comparación lexicográfica se realiza de forma recursiva. Si todos los elementos de las dos colecciones son iguales, entonces ambas colecciones se consideran iguales. Si una colección es un prefijo de la otra, la colección más corta es la que se considera menor.

El orden lexicográfico de las cadenas de caracteres utiliza el valor del punto de código de Unicode (así como lo devuelve la función ord) para comparar caracteres individuales. Esto quiere decir, por ejemplo, que 'A' < 'B' produce True, ya que ord('A') < ord('B') también produce True.

Las cadenas, listas y tuplas pueden compararse usando los operadores ==, !=, <, <=, > y >=. Los diccionarios y rangos solo se pueden comparar con los operadores == y !=.

Ejemplos:

>>> (1, 2, 3) < (1, 2, 4)
True
>>> [1, 2, 3] < [1, 2, 4]
True
>>> 'ABC' < 'Python'
True
>>> (1, 2, 3, 4) < (1, 2, 4)
True
>>> (1, 2) < (1, 2, -1)
True
>>> (1, 2, 3) == (1.0, 2.0, 3.0)
True
>>> (1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
True
>>> {'a': 1, 'b': 2, 'c': 3} == {'b': 2, 'c': 3, 'a':1}
True
>>> range(10) == range(0, 10, 1)
True
Referencia completa: Comparing Sequences and Other Types.

8. Números

Ver también los tipos de datos int y float.

8.1. Opradores aritméticos

Operador Descripción Ejemplos

\(+x\)

Más unario. Produce el valor de \(x\). Existe por simetría con el menos unario.

>>> +5
5

\(-x\)

Menos unario. Calcula el valor negado de \(x\), es decir, \(x\) con el signo contrario.

>>> -5
-5
>>> -(-10)
10

\(x + y\)

Suma. Calcula la suma de \(x\) más \(y\).

>>> 1 + 2
3
>>> -10 + -5
-15

\(x - y\)

Resta. Calcula la resta de \(x\) menos \(y\).

>>> 10 - 3
7
>>> -10 - (-7)
-3

\(x * y\)

Multiplicación. Calcula el producto de \(x\) por \(y\).

>>> 2 * 5
10
>>> -10 * 12
-120

\(x \texttt{ / } y\)

División real. Calcula la división real o flotante de \(x\) entre \(y\). El resultado siempre es un número flotante. Produce un error cuando \(y\) es igual a cero.

>>> 10 / 3
3.3333333333333335
>>> 5 / 0
ZeroDivisionError: float division by zero

\(x \texttt{ // } y\)

División de piso. Calcula el cociente entero de la división de \(x\) entre \(y\). Produce un error cuando \(y\) es igual a cero.

>>> 10 // 3
3
>>> 5 // 0
ZeroDivisionError: float division by zero

\(x \texttt{ % } y\)

Módulo o residuo. Calcula el residuo de la división de \(x\) entre \(y\). Produce un error cuando \(y\) es igual a cero.

Si se tiene que:

\[ c = x \; \texttt{//} \; y \\ r = x \; \texttt{%} \; y \]

Entonces, se debe cumplir que:

\[ c \cdot y + r = x \]

>>> 10 % 3
1
>>> 5 % 0
ZeroDivisionError: float division by zero
>>> x = 20
>>> y = 6
>>> c = x // y
>>> c
3
>>> r = x % y
>>> r
2
>>> c * y + r == x
True

\(x \texttt{ ** } y\)

Potenciación. Calcula \(x^y\) (la base \(x\) elevada al exponente \(y\)).

Este operador se asocia de derecha a izquierda, a diferencia de los demás operadores que se asocian de izquierda a derecha. Esto quiere decir que la expresión:

x ** y ** z

es equivalente a:

(x ** (y ** z))
>>> 2 ** 7
128
>>> (-1) ** 4
1
>>> (-1) ** 3
-1
>>> 25 ** 0.5
5.0
>>> 2 ** 3 ** 2
512
>>> (2 ** 3) ** 2
64

8.2. Funciones numéricas

Función Descripción Ejemplos

\(\texttt{abs}(x)\)

Devuelve el valor absoluto de \(x\).

>>> abs(-10)
10
>>> abs(3.1416)
3.1416
>>> abs(-7.2)
7.2

\(\texttt{float}(x)\)

\(\texttt{int}(x)\)

\(\texttt{max}(x)\)
\(\texttt{max}(n_1, n_2, \ldots)\)

Con un solo argumento, \(x\) debe ser un objeto iterable (cadena, lista, tupla, diccionario o rango) y devuelve el valor más grande contenido en este. Con más de un argumento, devuelve el valor más grande de \(n_1, n_2, \ldots\).

>>> max([4, 1, 5, 0])
5
>>> max(-5, -1, -10, -8)
-1
>>> max('hola')
'o'

\(\texttt{min}(x)\)
\(\texttt{min}(n_1, n_2, \ldots)\)

Con un solo argumento, \(x\) debe ser un objeto iterable (cadena, lista, tupla, diccionario o rango) y devuelve el valor más pequeño contenido en este. Con más de un argumento, devuelve el valor más pequeño de \(n_1, n_2, \ldots\).

>>> min([4, 1, 5, 0])
0
>>> min(-5, -1, -10, -8)
-10
>>> min('hola')
'a'

\(\texttt{round}(x, \texttt{ndigits=None})\)

Redondea \(x\) a un cierto número de dígitos decimales establecidos por ndigits. La fracción 0.5 se redondea al número par más cercano.

>>> round(1.9)
2
>>> round(3.1415926535, 4)
3.1416
>>> round(3.5)
4
>>> round(2.5)
2

\(\texttt{sum}(x)\)

\(x\) debe ser un objeto iterable (lista, tupla, diccionario o rango) y devuelve la suma de todos sus elementos.

>>> sum([4, 8, 15, 16, 23, 42])
108
>>> sum([])
0
Referencia completa: Built-in Functions.

8.3. Módulo «math»

Función o constante Descripción Ejemplos

\(\texttt{acos}(x)\)

Función que devuelve el arco coseno de \(x\) en radianes.

Esta es la función inversa de cos.

>>> from math import acos
>>> acos(1)
0.0
>>> acos(-1)
3.141592653589793
>>> acos(0.5) * 3
3.1415926535897936

\(\texttt{asin}(x)\)

Función que devuelve el arco seno de \(x\) en radianes.

Esta es la función inversa de sin.

>>> from math import asin
>>> asin(0)
0.0
>>> asin(0.5) * 6
3.1415926535897936
>>> asin(1) * 2
3.141592653589793

\(\texttt{atan}(x)\)

Función que devuelve el arco tangente de \(x\) en radianes.

Esta es la función inversa de tan.

>>> from math import atan
>>> atan(0)
0.0
>>> atan(1) * 4
3.141592653589793
>>> atan(3 ** 0.5) * 3
3.141592653589793

\(\texttt{ceil}(x)\)

Función que devuelve el techo de \(x\), el entero más pequeño mayor o igual que \(x\). En otras palabras, redondea la parte fraccionaria de un flotante hacia el siguiente valor entero en sentido del infinito positivo.

>>> from math import ceil
>>> ceil(1.9)
2
>>> ceil(2.1)
3
>>> ceil(8.0)
8
>>> ceil(-1.9)
-1

\(\texttt{cos}(x)\)

Función que devuelve el coseno de \(x\) en radianes.

Esta es la función inversa de acos.

>>> from math import cos, pi
>>> cos(0)
1.0
>>> cos(pi / 3)
0.5000000000000001
>>> cos(pi)
-1.0

\(\texttt{degrees}(x)\)

Función que devuelve el ángulo \(x\) convertido de radianes a grados.

Esta es la función inversa de radians.

>>> from math import degrees, pi
>>> degrees(pi)
180.0
>>> degrees(pi / 2)
90.0
>>> degrees(2 * pi)
360.0

\(\texttt{e}\)

Constante matemática \(e\), conocida como número de Euler.

\[ e \approx 2.718281828459045 \ldots \]

>>> from math import e
>>> e
2.718281828459045

\(\texttt{exp}(x)\)

Función que devuelve \(e^x\), donde \(e\) es el número de Euler.

Esta es la función inversa de log.

>>> from math import exp
>>> exp(0)
1.0
>>> exp(1)
2.718281828459045
>>> exp(2)
7.38905609893065

\(\texttt{factorial}(x)\)

Función que devuelve \(x!\) (factorial de \(x\)) como un número entero. El factorial de \(x\) se define como el producto de todos los números enteros positivos desde 1 hasta \(x\). Por ejemplo:

\[ 5! = 1 \times 2 \times 3 \times 4 \times 5 = 120 \]

>>> from math import factorial
>>> factorial(5)
120
>>> factorial(0)
1
>>> factorial(30)
265252859812191058636308480000000

\(\texttt{floor}(x)\)

Función que devuelve el piso de \(x\), el entero más grande menor o igual que \(x\). En otras palabras, redondea la parte fraccionaria de un flotante hacia el siguiente valor entero en sentido del infinito negativo.

>>> from math import floor
>>> floor(1.9)
1
>>> floor(2.1)
2
>>> floor(8.0)
8
>>> floor(-1.9)
-2

\(\texttt{gcd}(x, y)\)

Función que devuelve el máximo común divisor de \(x\) y \(y\), es decir, el valor entero más grande que divide de forma exacta a ambos números.

>>> from math import gcd
>>> gcd(24, 16)
8
>>> gcd(30, 15)
15
>>> gcd(-20, -24)
4

\(\texttt{isclose}(x, y)\)

Función que devuelve True si se considera que el valor de \(x\) es suficientemente cercano (difiere solo 0.0000001%) al valor de \(y\), o False en caso contrario.

Dadas las imprecisiones que pueden ocurrir al comparar dos números de punto flotante, en lugar de los operadores == y != se recomienda usar la función isclose:

# Sean x, y de tipo float.

# No recomendable:
x == y
# Preferible:
isclose(x, y)

# No recomendable:
x != y
# Preferible:
not isclose(x, y)
>>> from math import isclose
>>> isclose(1.0, 0.999)
False
>>> isclose(1.0, 0.999999999)
True
>>> 0.3 == 0.1 * 3
False
>>> 0.1 * 3
0.30000000000000004
>>> isclose(0.3, 0.1 * 3)
True

\(\texttt{log}(x)\)

Función que devuelve el logaritmo natural (base \(e\)) de \(x\), donde \(e\) es el número de Euler.

Esta es la función inversa de exp.

>>> from math import log
>>> log(1)
0.0
>>> log(2.718281828459045)
1.0
>>> log(7.38905609893065)
2.0

\(\texttt{pi}\)

Constante matemática \(\pi\), la cual representa la relación entre la longitud de una circunferencia y su diámetro.

\[ \pi \approx 3.141592653589793 \ldots \]

>>> from math import pi
>>> pi
3.141592653589793

\(\texttt{radians}(x)\)

Función que devuelve el ángulo \(x\) convertido de grados a radianes.

Esta es la función inversa de degrees.

>>> from math import radians
>>> radians(180)
3.141592653589793
>>> radians(90) * 2
3.141592653589793
>>> radians(360) / 2
3.141592653589793

\(\texttt{sin}(x)\)

Función que devuelve el seno de \(x\) en radianes.

Esta es la función inversa de asin.

>>> from math import sin, pi
>>> sin(0)
0.0
>>> sin(pi / 6)
0.49999999999999994
>>> sin(pi / 2)
1.0

\(\texttt{sqrt}(x)\)

Función que devuelve \(\sqrt{x}\) (raíz cuadrada de \(x\)).

>>> from math import sqrt
>>> sqrt(0)
0.0
>>> sqrt(25)
5.0
>>> sqrt(3) ** 2
2.9999999999999996

\(\texttt{tan}(x)\)

Función que devuelve la tangente de \(x\) en radianes.

Esta es la función inversa de atan.

>>> from math import tan, pi
>>> tan(0)
0.0
>>> tan(pi / 4)
0.9999999999999999
>>> tan(pi / 3) ** 2
2.9999999999999982
Referencia completa: Mathematical functions.

9. Booleanos

Ver también el tipo de dato bool.

9.1. Valores de verdad

En Python solamente se consideran falsos los siguientes valores:

  • Valor booleano False.

  • Valor nulo None.

  • Cero numérico: entero (0) y flotante (0.0).

  • Colecciones de longitud 0: cadena vacía (''), lista vacía ([]), tupla vacía (()), diccionario vacío ({}) y rango nulo (range(0)).

Cualquier otro valor distinto a los listados arriba se considera verdadero.

Referencia completa: Truth Value Testing.

9.2. Operaciones lógicas

Operador Descripción Ejemplos

\(\texttt{not } x\)

Negación lógica. Produce True si \(x\) es falso, o False en caso en contrario.

La negación obedece a la siguiente tabla de verdad:

\(x\) \(\texttt{not }x\)

True

False

False

True

>>> not True
False
>>> not False
True
>>> not 0
True
>>> not 5
False

\(x \texttt{ and } y\)

Conjunción lógica. Produce \(y\) si \(x\) es verdadero, de lo contrario produce \(x\). Utiliza evaluación de cortocircuito: no evalúa \(y\) si \(x\) es falso.

La conjunción obedece a la siguiente tabla de verdad:

\(x\) \(y\) \(x \texttt{ and }y\)

True

True

True

True

False

False

False

True

False

False

False

False

>>> True and True
True
>>> False and True
False
>>> 4 and 5
5
>>> 0 and 7
0

\(x \texttt{ or } y\)

Disyunción lógica. Produce \(x\) si \(x\) es verdadero, en caso contrario produce \(y\). Utiliza evaluación de cortocircuito: no evalúa \(y\) si \(x\) es verdadero.

La disyunción obedece a la siguiente tabla de verdad:

\(x\) \(y\) \(x \texttt{ or }y\)

True

True

True

True

False

True

False

True

True

False

False

False

>>> True or False
True
>>> False or False
False
>>> 4 or 5
4
>>> 0 or 7
7
Referencia completa: Boolean Operations.

10. Colecciones

10.1. Secuencias

Las siguientes operaciones son comunes para todas las secuencias (cadenas, listas, tuplas y rangos).

Operador, función o método Descripción Ejemplos

\(x \; \texttt{in} \; \textit{s}\)

Pertenencia. Operador que produce True si \(x\) está contenido en \(\textit{s}\), de otra forma produce False.

>>> 23 in [4, 8, 15, 16, 23, 42]
True
>>> 'pr' in 'una prueba'
True
>>> 10 in range(5)
False

\(x \texttt{ not in } \textit{s}\)

Exclusión. Operador que produce True si \(x\) no está contenido en \(\textit{s}\), de otra forma produce False.

>>> 20 not in [4, 8, 15, 16, 23, 42]
True
>>> 'pe' not in 'una prueba'
True
>>> 2 not in range(5)
False

\(s \; \texttt{+} \; t\)

Concatenación. Operador que produce una nueva secuencia conformada por \(s\) concatenada (unido) con \(t\), siempre y cuando sean del mismo tipo.

Esta operación no se puede efectuar utilizando rangos.

>>> 'jamón ' + 'y spam'
'jamón y spam'
>>> [1, 2, 3] + [4, 5]
[1, 2, 3, 4, 5]
>>> ('a', 'b') + ('c',)
('a', 'b', 'c')

\(s \; \texttt{*} \; n\)
\(n \; \texttt{*} \; s\)

Replicación. Operador que produce una nueva secuencia conformada por \(s\) concatenada consigo mismo \(n\) veces. Se produce una secuencia vacía si \(n \le 0\).

Esta operación no se puede efectuar utilizando rangos.

>>> 'ja' * 3
'jajaja'
>>> 4 * ['spam']
['spam', 'spam', 'spam', 'spam']
>>> (1, 2, 3) * 2
(1, 2, 3, 1, 2, 3)
>>> 'Ni' * -10
''

\(s [i]\)

Indexación. Operador que produce el \(i\)-ésimo elemento de \(s\), comenzando en el índice 0.

Si \(i < 0\), entonces produce el elemento en el índice \(\texttt{len}(s) + i\).

>>> s = 'spam'
>>> s[2]
'a'
>>> t = (4, 8, 15, 16, 23, 42)
>>> t[-1]
42

\(s [i:j]\)
\(s [i:j:k]\)

Rebanada. Operador que produce una rebanada (subsecuencia) conformada por los elementos de la secuencia \(s\) que se encuentran comenzando en el índice \(i\) y hasta justo antes del índice \(j\), con un paso de tamaño \(k\).

Es válido omitir los valores de \(i\), \(j\) y \(k\), tomando los siguientes valores por omisión:

  • \(i \leftarrow 0\)

  • \(j \leftarrow \texttt{len}(s)\)

  • \(k \leftarrow 1\)

Para valores de índices negativos de \(i\) o \(j\) se aplica la misma regla que para el operador de indexación.

>>> s = 'el conejo asesino'
>>> s[5:9]
'nejo'
>>> s[-12:-8]
'nejo'
>>> s[4:15:3]
'ojas'
>>> s[13:1:-3]
'sajo'
>>> s[10:]
'asesino'
>>> s[:2]
'el'
>>> s[::-1]  # La cadena invertida.
'onisesa ojenoc le'
>>> (4, 8, 15, 16, 23, 42)[1::2]
(8, 16, 42)

\(s.\texttt{count}(x)\)

Método que devuelve el número de veces que aparece \(x\) dentro de la secuencia \(s\).

>>> [5, 6, 8, 8, 7, 2, 2].count(8)
2
>>> 'tres tristes tigres'.count('t')
4
>>> range(4).count(7)
0

\(\texttt{enumerate}(s, \\ \; \; \; \; \texttt{start=0})\)

Función que devuelve un objeto iterable con tuplas que contienen dos elementos: un contador (que inicia con el valor de \(\texttt{start}\)) y el valor correspondiente que se obtienen al iterar sobre \(s\).

>>> enumerate('hola')
<enumerate at 0x7f5028083240>
>>> list(enumerate('hola'))
[(0, 'h'), (1, 'o'), (2, 'l'), (3, 'a')]
>>> for i, c in enumerate('hola', 10):
...     print(i, c)
...
10 h
11 o
12 l
13 a

\(s.\texttt{index}(x)\)
\(s.\texttt{index}(x, i)\) \(s.\texttt{index}(x, i, j)\)

Método que devuelve el índice en el que aparece por primera vez \(x\) dentro de la rebanada \(s[i:j]\). El primer índice es 0. Produce un error si \(x\) no pertenece a \(s\).

Valores por omisión:

  • \(i \leftarrow 0\)

  • \(j \leftarrow \texttt{len}(s)\)

Contrastar con los métodos find y rfind para cadenas.

>>> s = 'parangaricutirimicuaro'
>>> s.index('ar')
1
>>> s.index('ar', 5)
6
>>> s.index('ar', 15, 21)
19
>>> [4, 8, 15, 16, 23, 42].index(42)
5
>>> range(10).index(10)
ValueError: 10 is not in range

\(\texttt{len}(s)\)

Función que devuelve el número de elementos que contiene la secuencia \(s\).

>>> len([4, 8, 15, 16, 23, 42])
6
>>> len('una prueba')
10
>>> len(range(6, 10, 2))
2

\(\texttt{reversed}(s)\)

Función que devuelve un objeto iterable con todos los elementos de la secuencia \(s\) pero en orden inverso.

Contrastar con el método reverse para listas.

>>> reversed('hola')
<reversed object at 0x7f0b31477550>
>>> list(reversed('hola'))
['a', 'l', 'o', 'h']
>>> for i in reversed([1, 2, 3]):
...     print(i)
...
3
2
1

\(\texttt{sorted}(s, \\ \; \; \; \; \texttt{key=None}, \\ \; \; \; \; \texttt{reverse=False})\)

Función que devuelve una nueva lista con todos los elementos contenidos en la secuencia \(s\) en orden ascendente. Se utiliza orden lexicográfico al momento de comparar los elementos de \(s\).

De estar presente, el valor del parámetro \(\texttt{key}\) debe ser una función que se aplica a cada elemento antes de realizar las respectivas comparaciones durante el ordenamiento. Si se indica verdadero en el parámetro \(\texttt{reverse}\) el resultado se devuelve en orden descendente.

Está garantizado que el algoritmo de ordenamiento utilizado es estable, es decir, no se cambia el orden relativo de los elementos que resultan iguales al ser comparados. Lo anterior es útil para ordenar en varias pasadas (por ejemplo, ordenar primero por calificaciones, luego por nombre).

Contrastar con el método sort para listas.

>>> s = ['lunes', 'martes', 'miércoles',
...     'jueves', 'viernes', 'sábado',
...     'domingo']
>>> # Ordenar alfabéticamente.
>>> sorted(s)
['domingo', 'jueves', 'lunes', 'martes', 'miércoles', 'sábado', 'viernes']
>>> # Ordenar por tamaño de palabra.
>>> sorted(s, key=len)
['lunes', 'martes', 'jueves', 'sábado', 'viernes', 'domingo', 'miércoles']
>>> # Ordenar alfabéticamente
>>> # en orden inverso.
>>> sorted(s, reverse=True)
['viernes', 'sábado', 'miércoles', 'martes', 'lunes', 'jueves', 'domingo']
>>> # Ordenar por tamaño de palabra
>>> # en orden inverso.
>>> sorted(s, key=len, reverse=True)
['miércoles', 'viernes', 'domingo', 'martes', 'jueves', 'sábado', 'lunes']
>>> # La lista original no
>>> # se ha modificado.
>>> s
['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo']

\(\texttt{zip}(s_1, s_2, \ldots, s_n)\)

Función que agrupa los elementos de las secuencias que recibe como argumentos. Devuelve un objeto iterable compuesto de \(m\) tuplas, en donde la i-ésima tupla contiene el i-ésimo elemento de cada una de las secuencias \(s_1, s_2, \ldots, s_n\). El valor de \(m\) es igual al tamaño de la secuencia de entrada más corta.

>>> a = [4, 8, 15, 16, 23, 42]
>>> b = 'jamón con spam'
>>> c = ('alfa', 'beta', 'gamma')
>>> zip(a, b)
<zip object at 0x7ff34beb2dc0>
>>> list(zip(a, b))
[(4, 'j'), (8, 'a'), (15, 'm'), (16, 'ó'), (23, 'n'), (42, ' ')]
>>> list(zip(a, b, c))
[(4, 'j', 'alfa'), (8, 'a', 'beta'), (15, 'm', 'gamma')]
>>> for x, y, z in zip(a, b, c):
...     print(x, y, z)
...
4 j alfa
8 a beta
15 m gamma

10.2. Cadenas

Ver también el tipo de dato str.

10.2.1. Operaciones con cadenas

Operador, función o método Descripción Ejemplos

\(x \; \texttt{in} \; \textit{s}\)

\(x \texttt{ not in } \textit{s}\)

\(s \; \texttt{+} \; t\)

\(s \; \texttt{*} \; n\)

\(s [i]\)

\(s [i:j:k]\)

\(s.\texttt{capitalize}()\)

Método que devuelve una copia de la cadena \(s\) con su primer carácter en mayúscula y el resto en minúscula.

>>> 'sir LANCELOT'.capitalize()
'Sir lancelot'

\(\texttt{chr}(x)\)

\(s.\texttt{count}(x)\)

\(s.\texttt{endswith}(t)\)

Método que devuelve True si la cadena \(s\) termina con el sufijo \(t\), de lo contrario, devuelve False. \(t\) también puede ser una tupla con varios sufijos a buscar.

>>> s = 'jamón y spam'
>>> s.endswith('spam')
True
>>> s.endswith('ni')
False
>>> s.endswith(('ni', 'am', 'ón'))
True

\(s.\texttt{find}(t)\)
\(s.\texttt{find}(t, i)\)
\(s.\texttt{find}(t, i, j)\)

Método que devuelve el índice de la cadena \(s\) donde se encuentra la primera ocurrencia de la subcadena \(t\) dentro de la rebanada \(s[i:j]\). Devuelve -1 si no se encuentra \(t\).

Valores por omisión:

  • \(i \leftarrow 0\)

  • \(j \leftarrow \texttt{len}(s)\)

Ver también los métodos rfind e index.

>>> s = 'jamón y spam'
>>> s.find('ja')
0
>>> s.find('spa')
8
>>> s.find('ja', 8)
-1
>>> s.find('m')
2
>>> s.find('m', 8)
11
>>> s.find('m', 3, 8)
-1

\(s.\texttt{index}(x)\)

\(s.\texttt{isalpha}()\)

Método que devuelve True si todos los caracteres de \(s\) son alfabéticos (letras) y \(\texttt{len}(s) \ge 1\), de otra forma devuelve False.

>>> 'x'.isalpha()
True
>>> 'jamón'.isalpha()
True
>>> 'huevo con spam'.isalpha()
False
>>> '42'.isalpha()
False
>>> ''.isalpha()
False

\(s.\texttt{isdigit}()\)

Método que devuelve True si todos los caracteres de \(s\) son dígitos del 0 al 9 y \(\texttt{len}(s) \ge 1\), de otra forma devuelve False.

>>> '7'.isdigit()
True
>>> '123'.isdigit()
True
>>> 'x'.isdigit()
False
>>> '1,024'.isdigit()
False
>>> ''.isdigit()
False

\(s.\texttt{islower}()\)

Método que devuelve True si todas las letras contenidas en \(s\) son minúsculas y \(\texttt{len}(s) \ge 1\), de otra forma devuelve False.

>>> 'a'.islower()
True
>>> 'huevo con jamón'.islower()
True
>>> 'Spam'.islower()
False
>>> ''.islower()
False

\(s.\texttt{isupper}()\)

Método que devuelve True si todas las letras contenidas en \(s\) son mayúsculas y \(\texttt{len}(s) \ge 1\), de otra forma devuelve False.

>>> 'A'.isupper()
True
>>> 'HUEVO CON JAMÓN'.isupper()
True
>>> 'Spam'.isupper()
False
>>> ''.isupper()
False

\(s.\texttt{join}(x)\)

Método que devuelve una cadena que es la concatenación de las cadenas contenidas en el objeto iterable \(x\) (cadena, lista, tupla o diccionario). El separador entre elementos es la cadena \(s\). Produce un error si hay valores en \(x\) que no sean cadenas.

>>> ', '.join(('uno', 'dos', 'cinco'))
'uno, dos, cinco'
>>> '.'.join('abc123')
'a.b.c.1.2.3'
>>> ''.join(['A', 'B', 'C'])
'ABC'

\(s.\texttt{lower}()\)

Método que devuelve una copia de la cadena \(s\) con todas sus letras convertidas a minúsculas.

>>> '¡Uno, Dos, Cinco!'.lower()
'¡uno, dos, cinco!'

\(\texttt{len}(s)\)

\(s.\texttt{lstrip}()\)

Método que devuelve una copia de la cadena \(s\) pero eliminando todos los caracteres en blanco (espacios, tabuladores y saltos de línea) que aparecen al inicio (left strip).

Ver también los métodos strip y rstrip.

>>> '     jamón y spam '.lstrip()
'jamón y spam '
>>> '\n\t¡Ni!\t \n\n'.lstrip()
'¡Ni!\t \n\n'

\(\texttt{max}(s)\)

\(\texttt{min}(s)\)

\(\texttt{ord}(x)\)

\(s.\texttt{replace}(t, u)\)

Método que devuelve una copia de la cadena \(s\) en donde todas las ocurrencias de la subcadena \(t\) son reemplazadas por \(u\).

>>> 'una mosca'.replace('a', 'o')
'uno mosco'
>>> s = 'parangaricutirimicuaro'
>>> s.replace('ar', 'yx')
'pyxangyxicutirimicuyxo'

\(\texttt{reversed}(s)\)

\(s.\texttt{rfind}(t)\)
\(s.\texttt{rfind}(t, i)\)
\(s.\texttt{rfind}(t, i, j)\)

Método que devuelve el índice de la cadena \(s\) donde se encuentra la última ocurrencia de la subcadena \(t\) dentro de la rebanada \(s[i:j]\). Similar al método find pero iniciando la búsqueda por la derecha (right find). Devuelve -1 si no se encuentra \(t\).

Valores por omisión:

  • \(i \leftarrow 0\)

  • \(j \leftarrow \texttt{len}(s)\)

Ver también el método index.

>>> s = 'jamón y spam'
>>> s.rfind('am')
10
>>> s.rfind('ja')
0
>>> s.rfind('am', 1)
10
>>> s.rfind('am', 0, 9)
1
>>> s.rfind('am', 2, 9)
-1

\(s.\texttt{rstrip}()\)

Método que devuelve una copia de la cadena \(s\) pero eliminando todos los caracteres en blanco (espacios, tabuladores y saltos de línea) que aparecen al final.

Ver también los métodos strip y lstrip.

>>> '     jamón y spam '.rstrip()
'     jamón y spam'
>>> '\n\t¡Ni!\t \n\n'.rstrip()
'\n\t¡Ni!'

\(\texttt{sorted}(s)\)

\(s.\texttt{split}()\)
\(s.\texttt{split}(x)\)

Método que devuelve una lista con las palabras contenidas en \(s\) delimitadas por \(x\). Si se omite \(x\) considera como delimitador a cualquier sequencia consecutiva de caracteres en blanco (espacios, tabuladores y saltos de línea).

>>> '1 10 100'.split()
['1', '10', '100']
>>> '4,8,15,16,23,42'.split(',')
['4', '8', '15', '16', '23', '42']
>>> 'a-b-c-d e-f'.split('-')
['a', 'b', 'c', 'd e', 'f']
>>> 'a\n\tb\t c  \nd'.split()
['a', 'b', 'c', 'd']

\(s.\texttt{startswith}(t)\)

Método que devuelve True si la cadena \(s\) inicia con el prefijo \(t\), de lo contrario, devuelve False. \(t\) también puede ser una tupla con varios prefijos a buscar.

>>> s = 'jamón y spam'
>>> s.startswith('jamón')
True
>>> s.startswith('ni')
False
>>> s.startswith(('ni', 'ja', 'sp'))
True

\(\texttt{str}(x)\)

\(s.\texttt{strip}()\)

Método que devuelve una copia de la cadena \(s\) pero eliminando todos los caracteres en blanco (espacios, tabuladores y saltos de línea) que aparecen al inicio y al final.

Ver también los métodos lstrip y rstrip.

>>> '     jamón y spam '.strip()
'jamón y spam'
>>> '\n\t¡Ni!\t \n\n'.strip()
'¡Ni!'

\(s.\texttt{title}()\)

Método que devuelve una copia de la cadena \(s\) en donde el primer carácter de cada palabra inicia con una letra mayúscula y el resto de las letras están en minúscula.

>>> '¡uno, dos, cinco!'.title()
'¡Uno, Dos, Cinco!'

\(s.\texttt{upper}()\)

Método que devuelve una copia de la cadena \(s\) con todas sus letras convertidas a mayúsculas.

>>> '¡Uno, Dos, Cinco!'.upper()
'¡UNO, DOS, CINCO!'

10.2.2. Secuencias de escape

Las secuencias de escape se utilizan para definir ciertos caracteres especiales dentro de las cadenas de caracteres.

Secuencia de escape Descripción Punto de código

\\

Diagonal invertida

92

\'

Comilla simple

39

\"

Comillas dobles

34

\n

Salto de línea

10

\r

Retorno de carro

13

\t

Tabulador

9

\N{nombre}

Carácter llamado nombre según Unicode. Es posible dibujar un carácter y obtener su nombre en ShapeCatcher.

Depende de nombre

\Uxxxxxxxx

Carácter de Unicode de 32 bits representado como ocho dígitos en hexadecimal.

xxxxxxxx

Referencia completa: String and Bytes literals.

10.2.3. Cadenas con formato

Una cadena con formato es una cadena de caracteres que tiene el prefijo 'f' o 'F'. Estas cadenas pueden contener campos de reemplazo, que son expresiones delimitadas por llaves {} y que se evalúan a tiempo de ejecución.

Las partes de la cadena que se encuentran fuera de las llaves se toman literalmente, excepto que las llaves dobles '{{' o '}}' se reemplazan con la llave individual correspondiente.

Ejemplos:

>>> x = 42
>>> f'El valor de x es: {x}.'
'El valor de x es: 42.'
>>> F'{{x}} = {x}'
'{x} = 42'
>>> f"Un kibibyte es igual a {2**10} bytes."
'Un kibibyte es igual a 1024 bytes.'
>>> primera_parte = 'nadie espera la'
>>> segunda_parte = 'inquisición española'
>>> f'''
... {primera_parte.title()}
... {segunda_parte.upper()}
... '''
'\nNadie Espera La\nINQUISICIÓN ESPAÑOLA\n'

Los campos de reemplazo tienen la siguiente sintaxis que permite dar formato al resultado de \(\textit{exp}\):

\[ \{ \textit{exp} [: [ [ \textit{relleno} ] \textit{alin} ] [ \textit{ancho} ] [ \textit{coma} ] [ \texttt{.} \textit{prec} ] [ \textit{tipo} ]]\} \]

Los corchetes \([ \, ]\) usados arriba indican que dicho elemento es opcional.

Elemento Descripción Ejemplo

\(\textit{ancho}\)

Debe ser un número entero que establece el ancho mínimo del campo.

Si se omite, se utiliza el ancho exacto que ocupa el valor de \(\textit{exp}\).

>>> f'{2+2:10}'
'         4'
>>> f'{"hola":8}'
'hola    '

\(\textit{alin}\)

Puede ser '<' para alinear a la izquierda, '>' para alinear a la derecha o '^' para centrar.

Si se omite, los valores numéricos de \(\textit{exp}\) se alinean por omisión a la derecha y todos los demás se alinean a la izquierda.

>>> f'{2+2:<10}'
'4         '
>>> f'{2+2:>10}'
'         4'
>>> f'{2+2:^10}'
'    4     '

\(\textit{relleno}\)

Puede ser cualquier carácter distinto a las llaves '{' o '}' y se utiliza para rellenar según la alineación.

Si se omite, se utiliza el carácter de espacio en blanco como relleno.

>>> f'{2+2:*>10}'
'*********4'
>>> f'{2+2:~<10}'
'4~~~~~~~~~'
>>> f'{2+2:%^10}'
'%%%%4%%%%%'

\(\textit{coma}\)

Debe ser el carácter de coma ','. Si está presente y \(\textit{exp}\) es un valor numérico, indica que se usarán comas para separar los dígitos en grupos de tres, de derecha a izquierda y a partir del punto decimal.

>>> f'{10000:,}'
'10,000'
>>> f'{1234567.89:,}'
'1,234,567.89'

\(\texttt{.} \textit{prec}\)

Debe ser un número entero que indica cuántos dígitos se deben mostrar después del punto decimal para un valor de \(\textit{exp}\) de punto flotante.

Si se omite, se utilizan 6 dígitos de precisión por omisión cuando el tipo es 'f' o 'e'.

>>> f'{3.141592:.4f}'
'3.1416'
>>> f'{1/3:.3e}'
'3.333e-01'

\(\textit{tipo}\)

Determina cómo se debe presentar el valor de \(\textit{exp}\):

  • 's': cadena de caracteres.

  • 'd': número entero.

  • 'f': número de punto flotante.

  • 'e': número de punto flotante en notación científica.

Si se omite, se utiliza el tipo de \(\textit{exp}\) a tiempo de ejecución. Se utiliza la notación que resulte más compacta si \(\textit{exp}\) es de tipo flotante.

>>> f'{"hola":s}'
'hola'
>>> f'{42:d}'
'42'
>>> f'{1.2:f}'
'1.200000'
>>> f'{1.2:e}'
'1.200000e+00'

Es posible combinar todas los elementos en un mismo campo de reemplazo, por ejemplo:

>>> MEBIBYTE = 2 ** 20
>>> GIBIBYTE = 2 ** 30
>>> print(f'''
... 1 Mebibyte = {MEBIBYTE:*>20,.1f} bytes
... 1 Gibibyte = {GIBIBYTE:*>20,.1f} bytes
... ''')

1 Mebibyte = *********1,048,576.0 bytes
1 Gibibyte = *****1,073,741,824.0 bytes

Se pueden usar llaves {} anidadas dentro de un campo de reemplazo para determinar a tiempo de ejecución el valor de uno o más de sus elementos. Por ejemplo:

>>> PLANCK = 6.62607015e-34
>>> relleno = '~'
>>> alin = '>'
>>> ancho = 15
>>> prec = 4
>>> tipo = 'e'
>>> f'h = {PLANCK:{relleno}{alin}{ancho}.{prec}{tipo}} J\N{Middle Dot}s'
'h = ~~~~~6.6261e-34 J·s'

10.3. Listas

Ver también el tipo de dato list.

Estatuto, operador, función o método Descripción Ejemplos

\(x \; \texttt{in} \; \textit{s}\)

\(x \texttt{ not in } \textit{s}\)

\(s \; \texttt{+} \; t\)

\(s \; \texttt{*} \; n\)

\(s [i]\)

\(s [i] \; \texttt{=} \; x\)

Asignar con índice. Estatuto que asigna \(x\) a la \(i\)-ésima localidad de la lista \(s\). El primer índice es 0.

Si \(i < 0\), entonce el índice utilizado es: \(\texttt{len}(s) + i\).

Este estatuto altera el contenido de \(s\).
>>> s = [1, 2, 3, 4]
>>> s[2] = 5
>>> s
[1, 2, 5, 4]
>>> s[-3] = 6
>>> s
[1, 6, 5, 4]

\(s \texttt{ += } t\)
\(s.\texttt{extend}(t)\)

Extender. Estatuto/método que añade al final de \(s\) cada uno de los elementos contenidos en \(t\), el cual debe ser un objeto iterable (cadena, lista, tupla, diccionario o rango). El método extend devuelve None.

Equivale a:

\[ s[\texttt{len}(s):\texttt{len}(s)] \texttt{ = } t \]

Comparar con el método append.

Este estatuto/método altera el contenido de \(s\).
>>> s = [1, 2, 3, 4]
>>> t = (5, 6, 7)
>>> s += t
>>> s
[1, 2, 3, 4, 5, 6, 7]
>>> s.extend('abc')
>>> s
[1, 2, 3, 4, 5, 6, 7, 'a', 'b', 'c']

\(s \texttt{ *= } n\)

Replicar y actualizar. Estatuto que replica la secuencia \(s\) un total de \(n\) veces dejando el resultado en \(s\).

Equivale a:

\[ s \texttt{ = } s * (n) \]

Este estatuto altera el contenido de \(s\).
>>> s = [1, 2]
>>> s *= 3
>>> s
[1, 2, 1, 2, 1, 2]

\(s [i:j:k]\)

\(s [i:j] \texttt{ = } t\)
\(s [i:j:k] \texttt{ = } t\)

Asignar rebanada. Estatuto que reemplaza la rebanada \(s [i:j:k]\) por \(t\), el cual debe ser un objeto iterable (cadena, lista, tupla, diccionario o rango). Si \(k \ne 1\), entonces \(t\) debe ser del mismo tamaño que la rebanada que está reemplazando.

Este estatuto altera el contenido de \(s\).
>>> s = ['a', 'b', 'c', 'd']
>>> s[1:3] = [1, 2, 3]
>>> s
['a', 1, 2, 3, 'd']
>>> s[:2] = []
>>> s
[2, 3, 'd']
>>> t = [1, 2, 3, 4, 5]
>>> t[1::2] = [6, 7]
>>> t
[1, 6, 3, 7, 5]

\(s.\texttt{append}(x)\)

Método que añade \(x\) al final de la lista \(s\). Devuelve None.

Equivale a:

\[ s[\texttt{len}(s):\texttt{len}(s)] \texttt{ = } [x] \]

Comparar con el método extend.

Este método altera el contenido de \(s\).
>>> s = ['a', 'b', 'c', 'd']
>>> s.append('e')
>>> s
['a', 'b', 'c', 'd', 'e']
>>> # Si el argumento es una lista,
>>> # añade dicha lista completa como
>>> # un solo elemento al final.
>>> s.append([1, 2, 3])
>>> s
['a', 'b', 'c', 'd', 'e', [1, 2, 3]]

\(s.\texttt{clear}()\)

Método que elimina todos los elementos de la lista \(s\). Devuelve None.

Equivale a:

\[ \texttt{del} \; s[:] \]

Este método altera el contenido de \(s\).
>>> t = [1, 2, 3, 4, 5]
>>> t.clear()
>>> t
[]

\(s.\texttt{copy}()\)

Método que devuelve una nueva lista que contiene una copia superficial de \(s\).

Equivale a:

\[ s[:] \]

>>> s = [4, 8, 15, 16, 23, 42]
>>> t = s.copy()
>>> s is t
False
>>> s[1] = 108
>>> s
[4, 108, 15, 16, 23, 42]
>>> t
[4, 8, 15, 16, 23, 42]
>>> # Crear copia superficial.
>>> a = [[1, 2], [3, 4]]
>>> b = a.copy()
>>> a is b
False
>>> a[0] is b[0]
True
>>> a[0][0] = 108
>>> a
[[108, 2], [3, 4]]
>>> b
[[108, 2], [3, 4]]
>>> a[0] = 42
>>> a
[42, [3, 4]]
>>> b
[[108, 2], [3, 4]]

\(s.\texttt{count}(x)\)

\(\texttt{del } s [i]\)

Borrar con índice. Estatuto que elimina de la lista \(s\) el elemento contenido en el índice \(i\).

Equivale a:

\[ s[i:i+1] \texttt{ = } [ \;] \]

Este estatuto altera el contenido de \(s\).
>>> s = ['a', 'b', 'c', 'd']
>>> del s[2]
>>> s
['a', 'b', 'd']

\(\texttt{del } s [i:j]\)
\(\texttt{del } s [i:j:k]\)

Borrar rebanada. Estatuto que elimina de la lista \(s\) todos los elementos que corresponden a la rebanada \(s [i:j:k]\).

Si \(k = 1\), entonces equivale a:

\[ s[i:j] \texttt{ = } [ \;] \]

Este estatuto altera el contenido de \(s\).
>>> s = ['a', 'b', 'c', 'd']
>>> del s[1:3]
>>> s
['a', 'd']
>>> t = [1, 2, 3, 4, 5]
>>> del t[::2]
>>> t
[2, 4]
>>> del t[:]
>>> t
[]

\(s.\texttt{index}(x)\)

\(s.\texttt{insert}(i, x)\)

Método que inserta en el índice \(i\) de la lista \(s\) el elemento \(x\). El primer índice es 0. Devuelve None.

Equivale a:

\[ s[i:i] \texttt{ = } [x] \]

Este método altera el contenido de \(s\).
>>> s = [8, 16, 23, 42]
>>> s.insert(0, 4)
>>> s
[4, 8, 16, 23, 42]
>>> s.insert(2, 15)
>>> s
[4, 8, 15, 16, 23, 42]
>>> t = ['a', 'c']
>>> t.insert(1, 'b')
>>> t
['a', 'b', 'c']

\(\texttt{len}(s)\)

\(\texttt{list}(s)\)

\(\texttt{max}(s)\)

\(\texttt{min}(s)\)

\(s.\texttt{pop}()\)
\(s.\texttt{pop}(i)\)

Método que remueve y devuelve el elemento \(i\)-ésimo de la lista \(s\). El primer índice es 0. Si se omite \(i\) se remueve y devuelve el elemento del final de la lista \(s\).

Este método altera el contenido de \(s\).
>>> s = [4, 8, 15, 16, 23, 42]
>>> s.pop()
42
>>> s.pop()
23
>>> s.pop(2)
15
>>> s
[4, 8, 16]

\(s.\texttt{remove}(x)\)

Método que remueve la primera ocurrencia de \(x\) en la lista \(s\). Produce un error si \(x\) no pertenece a \(s\). Devuelve None.

Equivale a:

\[ \texttt{del } s [ s.\texttt{index}(x)] \]

Ver el método index.

Este método altera el contenido de \(s\).
>>> s = [4, 8, 15, 16, 23, 42]
>>> s.remove(15)
>>> s
[4, 8, 16, 23, 42]
>>> s.remove(108)
ValueError: list.remove(x): x not in list

\(s.\texttt{reverse}()\)

Método que invierte en su mismo lugar el orden de los elementos de la lista \(s\).

Contrastar con la función reversed.

Este método altera el contenido de \(s\).
>>> s = [4, 8, 15, 16, 23, 42]
>>> s.reverse()
>>> s
[42, 23, 16, 15, 8, 4]

\(\texttt{reversed}(s)\)

\(s.\texttt{sort}(\\ \; \; \; \; \texttt{key=None}, \\ \; \; \; \; \texttt{reverse=False})\)

Método que ordena en su mismo lugar los elementos contenidos en la lista \(s\) en orden ascendente. Se utiliza orden lexicográfico al momento de comparar los elementos de \(s\).

De estar presente, el valor del parámetro \(\texttt{key}\) debe ser una función que se aplica a cada elemento antes de realizar las respectivas comparaciones durante el ordenamiento. Si se indica verdadero en el parámetro \(\texttt{reverse}\) los elementos quedan en orden descendente.

Está garantizado que el algoritmo de ordenamiento utilizado es estable, es decir, no se cambia el orden relativo de los elementos que resultan iguales al ser comparados. Lo anterior es útil para ordenar en varias pasadas (por ejemplo, ordenar primero por calificaciones, luego por nombre).

Contrastar con la función sorted.

Este método altera el contenido de \(s\).
>>> s = ['lunes', 'martes',
...     'miércoles', 'jueves',
...     'viernes', 'sábado',
...     'domingo']
>>> # Ordenar alfabéticamente.
>>> s.sort()
>>> s
['domingo', 'jueves', 'lunes', 'martes', 'miércoles', 'sábado', 'viernes']
>>> # Ordenar por tamaño de palabra.
>>> s.sort(key=len)
>>> s
['lunes', 'jueves', 'martes', 'sábado', 'domingo', 'viernes', 'miércoles']
>>> # Ordenar alfabéticamente
>>> # en orden inverso.
>>> s.sort(reverse=True)
>>> s
['viernes', 'sábado', 'miércoles', 'martes', 'lunes', 'jueves', 'domingo']
>>> # Ordenar por tamaño de palabra
>>> # en orden inverso.
>>> s.sort(key=len, reverse=True)
>>> s
['miércoles', 'viernes', 'domingo', 'sábado', 'martes', 'jueves', 'lunes']

\(\texttt{sorted}(s)\)

\(\texttt{sum}(s)\)

Referencia completa: Mutable Sequence Types, Lists.

10.4. Tuplas

Ver también el tipo de dato tuple.

Operador, función o método Descripción

\(x \; \texttt{in} \; \textit{s}\)

\(x \texttt{ not in } \textit{s}\)

\(s \; \texttt{+} \; t\)

\(s \; \texttt{*} \; n\)

\(s [i]\)

\(s [i:j:k]\)

\(s.\texttt{count}(x)\)

\(s.\texttt{index}(x)\)

\(\texttt{len}(s)\)

\(\texttt{max}(s)\)

\(\texttt{min}(s)\)

\(\texttt{reversed}(s)\)

\(\texttt{sorted}(s)\)

\(\texttt{sum}(s)\)

\(\texttt{tuple}(s)\)

10.5. Rangos

El tipo range representa una secuencia inmutable de números enteros. Se usa comúnmente para efectuar un ciclo un cierto número de veces a través del estatuto del ciclo for. Por ejemplo:

>>> for i in range(25):
...     print(i, end=' ')
...
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
Operador, función o método Descripción Ejemplos

\(x \; \texttt{in} \; \textit{s}\)

\(x \texttt{ not in } \textit{s}\)

\(s [i]\)

\(s [i:j:k]\)

\(s.\texttt{count}(x)\)

\(s.\texttt{index}(x)\)

\(\texttt{len}(s)\)

\(\texttt{max}(s)\)

\(\texttt{min}(s)\)

\(\texttt{range}( \textit{j} )\)
\(\texttt{range}(\textit{i}, \textit{j})\)
\(\texttt{range}(\textit{i}, \textit{j}, \textit{k})\)

Devuelve un rango que principia en \(i\) y termina justo antes de llegar a \(j\), avanzando en incrementos de \(k\).

Valores por omisión:

  • \(i \leftarrow 0\)

  • \(k \leftarrow 1\)

Es posible producir rangos descendientes, siempre y cuando \(\textit{i} > \textit{j} \,\) y \(\, \textit{k} < 0\).

>>> range(5)
range(0, 5)
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(4, 8))
[4, 5, 6, 7]
>>> list(range(-5, 0))
[-5, -4, -3, -2, -1]
>>> list(range(10, 50, 5))
[10, 15, 20, 25, 30, 35, 40, 45]
>>> list(range(10, -1, -2))
[10, 8, 6, 4, 2, 0]

\(\texttt{reversed}(s)\)

\(\texttt{sorted}(s)\)

\(\texttt{sum}(s)\)

10.6. Diccionarios

Ver también el tipo de dato dict.

Estatuto, operador, función o método Descripción Ejemplos

\(x \; \texttt{in} \; \textit{d}\)

Pertenencia. Operador que produce True si \(x\) es una clave contenida en el diccionario \(\textit{d}\), de otra forma produce False.

>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> 'dos' in d
True
>>> 'cuatro' in d
False
>>> 2 in d
False

\(x \texttt{ not in } \textit{d}\)

Exclusión. Operador que produce True si \(x\) no es una clave contenida en el diccionario \(\textit{d}\), de otra forma produce False.

>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> 'cuatro' not in d
True
>>> 'dos' not in d
False
>>> 2 not in d
True

\(d [k]\)

Acceso a elemento. Operador que produce el valor asociado a la clave \(k\) del diccionario \(d\). Genera un error si dicha clave no existe en el diccionario.

>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> d['dos']
2
>>> d[2]
KeyError: 2

\(d [k] \; \texttt{=} \; x\)

Asignación con clave. Estatuto que asocia la clave \(k\) con el valor \(x\) dentro del diccionario \(d\). Si \(k\) existía previamente en \(d\), su valor anterior es sobrescrito.

Este estatuto altera el contenido de \(d\).
>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> d['diez'] = 10
>>> d
{'uno': 1, 'dos': 2, 'tres': 3, 'diez': 10}
>>> d['dos'] = 0
>>> d
{'uno': 1, 'dos': 0, 'tres': 3, 'diez': 10}

\(d.\texttt{clear}()\)

Método que elimina todas las parejas clave/valor contenidas en el diccionario \(d\). Devuelve None.

Este método altera el contenido de \(d\).
>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> d.clear()
>>> d
{}

\(d.\texttt{copy}()\)

Método que devuelve un nuevo diccionario que contiene una copia superficial de \(d\).

>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> e = d.copy()
>>> d is e
False
>>> d['dos'] = 0
>>> d
{'uno': 1, 'dos': 0, 'tres': 3}
>>> e
{'uno': 1, 'dos': 2, 'tres': 3}
>>> # Crear copia superficial.
>>> a = {'x': 1, 'y': [1, 2]}
>>> b = a.copy()
>>> a is b
False
>>> a['y'] is b['y']
True
>>> a
{'x': 1, 'y': [42, 2]}
>>> b
{'x': 1, 'y': [42, 2]}
>>> a['y'] = 0
>>> a
{'x': 1, 'y': 0}
>>> b
{'x': 1, 'y': [1, 2]}

\(\texttt{del } d [k]\)

Borrar con clave. Estatuto que elimina del diccionario \(d\) la clave \(k\) junto con su valor asociado.

Este estatuto altera el contenido de \(d\).
>>> s = ['a', 'b', 'c', 'd']
>>> del s[2]
>>> s
['a', 'b', 'd']

\(\texttt{dict}(x)\)

\(d.\texttt{get}(k, x)\)

Método que devuelve el valor asociado a la clave \(k\) del diccionario \(d\). Sin embargo, si dicha clave no existe, devuelve a \(x\).

>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> d.get('dos', 0)
2
>>> d.get('cuatro', 4)
4

\(d.\texttt{items}()\)

Método que devuelve una secuencia con las parejas clave/valor, en forma de tuplas, contenidas en el diccionario \(d\).

>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> list(d.items())
[('uno', 1), ('dos', 2), ('tres', 3)]
>>> for k, v in d.items():
...     print(k, v)
...
uno 1
dos 2
tres 3

\(d.\texttt{keys}()\)

Método que devuelve una secuencia con las claves (sin sus valores asociados) contenidas en el diccionario \(d\).

>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> list(d.keys())
['uno', 'dos', 'tres']
>>> for k in d.keys():
...     print(k)
...
uno
dos
tres

\(\texttt{len}(d)\)

Función que devuelve el número de parejas clave/valor que contiene el diccionario \(d\).

>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> len(d)
3
>>> d['diez'] = 10
>>> len(d)
4
>>> len({})
0

\(d.\texttt{setdefault}(\\ \; \; \; \; k, x)\)

Método que funciona así: Si la clave \(k\) está en el diccionario \(d\), devuelve su correspondiente valor asociado. De otra forma, asocia la clave \(k\) con el valor \(x\) y devuelve a \(x\).

Este método altera el contenido de \(d\).
>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> d.setdefault('dos', 0)
2
>>> d
{'uno': 1, 'dos': 2, 'tres': 3}
>>> d.setdefault('cuatro', 4)
4
>>> d
{'uno': 1, 'dos': 2, 'tres': 3, 'cuatro': 4}

\(\texttt{sorted}(d)\)

Función que devuelve una nueva lista con todas las claves contenidas en el diccionario \(d\) en orden ascendente. Ver descripción completa.

>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> sorted(d)
['dos', 'tres', 'uno']

\(d.\texttt{update}(e)\)

Método que actualiza el diccionario \(d\) a partir del contenido de \(e\), el cual debe ser un diccionario o una secuencia de parejas clave/valor. Devuelve None.

Este método altera el contenido de \(d\).
>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> e = {'dos': 0, 'cuatro': 4, 'cinco': 5}
>>> d.update(e)
>>> d
{'uno': 1, 'dos': 0, 'tres': 3, 'cuatro': 4, 'cinco': 5}
>>> a = {}
>>> a.update([('one', 'uno'), ('two', 'dos')])
>>> a
{'one': 'uno', 'two': 'dos'}

\(d.\texttt{values}()\)

Método que devuelve una secuencia con los valores (sin sus claves) contenidos en el diccionario \(d\).

>>> d = {'uno': 1, 'dos': 2, 'tres': 3}
>>> list(d.values())
[1, 2, 3]
>>> for v in d.values():
...     print(v)
...
1
2
3

11. Entrada y salida

11.1. Impresión y lectura

Función Descripción Ejemplos

\(\texttt{print}(\textit{valores},\\ \; \; \; \; \texttt{sep=' '}, \\ \; \; \; \; \texttt{end='\n'}, \\ \; \; \; \; \texttt{file=sys.stdout})\)

Imprime valores en file usando sep como separador entre elementos y terminando con end. El valor de sep por omisión es un espacio en blanco. El valor de end por omisión es un salto de línea. El valor de file por omisión es la salida estándar (típicamente la pantalla).

>>> print(1, 2, 3)
1 2 3
>>> print(1, 2, 3, sep='...')
1...2...3
>>> print(1, 2, 3, end='!\n')
1 2 3!
>>> with open('nums.txt', 'w') as f:
...     print(1, 2, 3,
...           sep=',', end='!', file=f)
...
>>> with open('nums.txt') as f:
...     print(f.read())
...
1,2,3!

\(\texttt{input}()\)
\(\texttt{input}(p)\)

Si \(p\) está presente, lo despliega en la salida estándar (típicamente la pantalla). Posteriormente la función lee y devuelve una línea de la entrada estándar (típicamente el teclado) como una cadena de caracteres pero sin el salto de línea final.

>>> nombre = input('¿Cómo te llamas? ')
¿Cómo te llamas? Brian
>>> nombre
'Brian'
Referencia completa: Built-in Functions.

11.2. Archivos

Función o método Descripción Ejemplos

\(\texttt{open}(\textit{nombre},\\ \; \; \; \; \texttt{mode='r'})\)

Función que abre y devuelve el archivo llamado \(nombre\) usando la modalidad establecida en mode.

Es muy recomendable abrir un archivo usando el estatuto with, puesto que así se garantiza que dicho archivo queda cerrado al final sin importar que sus respectivas operaciones se hayan efectuado exitosamente o hayan producido algún error. Si no se usa el estatuto with entonces se debe cerrar explícitamente el archivo usando su método close.

La modalidad puede ser alguna de las siguientes:

\(\texttt{mode}\)

Descripción

'r'

Abre el archivo en modalidad de lectura (read). El archivo ya debe existir, de otra forma genera un error. Esta es la opción por omisión en caso de que no se proporcione una modalidad explícita.

'w'

Abre el archivo en modalidad de escritura (write). Crea el archivo si no existe, de otra forma elimina su contenido antes de comenzar a escribir.

'a'

Abre el archivo en modalidad de añadir (append). Crea el archivo si no existe, de otra forma añade al final de este lo que se le vaya escribiendo.

>>> with open('info.txt', 'w') as a:
...     print('Hola', file=a)
...
>>> with open('info.txt', 'a') as a:
...     print('Adios', file=a)
...
>>> with open('info.txt', 'r') as a:
...     print(a.read())
...
Hola
Adios

\(a.\texttt{read}()\)

Método que lee el contenido completo del archivo \(a\) (el cual debe estar abierto en modalidad de lectura) y lo devuelve como una cadena de caracteres.

>>> # NOTA: El archivo info.txt fue
... # creado en los ejemplos de la
... # función open.
... with open('info.txt') as a:
...     s = a.read()
...
>>> s
'Hola\nAdios\n'

\(a.\texttt{readlines}()\)

Método que devuelve una lista de cadenas de caracteres, en donde cada cadena es una línea de texto contenida en el archivo \(a\) (el cual debe estar abierto en modalidad de lectura). Cada cadena de la lista resultante incluye al final su correspondiente salto de línea.

Es posible iterar sobre todas las líneas de texto de un archivo usando el estatuto del ciclo for directamente sin necesidad de utilizar el método readlines.

>>> # NOTA: El archivo info.txt fue
... # creado en los ejemplos de la
... # función open.
... with open('info.txt') as a:
...     lineas = a.readlines()
...     for linea in lineas:
...         print(linea, end='')
...
Hola
Adios

>>> lineas
['Hola\n', 'Adios\n']
>>> # Iterando sobre cada línea del
... # archivo sin necesidad de usar
... # el método readlines.
... with open('info.txt') as a:
...     for linea in a:
...         print(linea, end='')
...
Hola
Adios

\(a.\texttt{write}(\textit{s})\)

Método que escribe la cadena \(s\) en el archivo \(a\) (el cual debe estar abierto en modalidad de escritura o de añadir). Devuelve el número de caracteres escritos.

En muchos casos puede resultar más conveniente usar la función print cuando se requiera escribir a un archivo de texto.

>>> with open('dato.txt', 'w') as a:
...     n = a.write('Un dato')
...
>>> n
7

12. Valores pseudoaleatorios

Un valor pseudoaleatorio es un valor generado por un algoritmo que parece producir números al azar, pero que en realidad no es así. Las secuencias de valores pseudoaleatorios no muestran ningún patrón o regularidad aparente desde un punto de vista estadístico. El módulo random contiene funciones para generar una variedad valores pseudoaleatorios.

Función Descripción Ejemplos

\(\texttt{choice}(s)\)

Devuelve un elemento aleatorio tomado de la secuencia \(s\) (cadena, tupla, lista o rango). Al menos debe haber un elemento en secuencia.

>>> from random import choice
>>> choice([4, 8, 15, 16, 23, 42])
23
>>> choice('spam')
'p'
>>> choice(('piedra', 'papel',
...     'tijeras'))
'tijeras'

\(\texttt{random}()\)

Devuelve un flotante aleatorio \(N\), tal que \(0.0 \le N < 1.0\).

>>> from random import random
>>> random()
0.1031660342307158
>>> random()
0.396058242610681

\(\texttt{randrange}(j)\)
\(\texttt{randrange}(i, j)\)
\(\texttt{randrange}(i, j, k)\)

Devuelve un entero aleatorio dentro de un rango que principia en \(i\) y termina justo antes de llegar a \(j\), avanzando en incrementos de \(k\).

Valores por omisión:

  • \(i \leftarrow 0\)

  • \(k \leftarrow 1\)

>>> from random import randrange
>>> randrange(1, 10)
4
>>> randrange(1000, 2000)
1310
>>> randrange(10, 100, 5)
65

\(\texttt{sample}(s, k)\)

Devuelve una nueva lista con una muestra aleatoria de \(k\) elementos únicos tomados de la secuencia \(s\) (cadena, tupla, lista o rango) en donde \(k \le \texttt{len}(s)\).

>>> from random import sample
>>> sample(range(100), 5)
[49, 11, 55, 26, 73]
>>> sample(('Arthur', 'Lancelot', 'Zoot',
...     'Dingo'), 2)
['Lancelot', 'Dingo']
>>> sample('Los caballeros que dicen Ni',
...     5)
['c', 'b', 'o', 'o', 'd']

\(\texttt{seed}\)(a=\(\texttt{None}\))

Inicializa la semilla del generador de números aleatorios con el valor de a. Esto es útil cuando se quiere repetir la misma secuencia de valores aleatorios.

El valor por omisión de a es None, y en ese caso se usa la hora actual del sistema como semilla.

>>> from random import seed, sample
>>> seed(42)  # Un número arbitrario
>>> sample(range(100), 5)
[81, 14, 3, 94, 35]
>>> sample(range(100), 5)
[31, 28, 17, 94, 13]
>>> # Volver a generar los mismos valores
... # aleatorios.
... seed(42)  # El mismo número arbitrario
>>> sample(range(100), 5)
[81, 14, 3, 94, 35]

\(\texttt{shuffle}(s)\)

Revuelve de manera aleatoria todos los elementos contenidos en la lista \(s\). Devuelve None.

Esta función altera el contenido de \(s\).
>>> from random import shuffle
>>> estaciones = ['primavera',
...     'verano', 'otoño', 'invierno']
>>> shuffle(estaciones)
>>> estaciones
['otoño', 'primavera', 'invierno', 'verano']
>>> numeros = list(range(10))
>>> shuffle(numeros)
>>> numeros
[6, 7, 8, 9, 3, 1, 2, 4, 5, 0]
Referencia completa: Generate pseudo-random numbers.

13. Gráficas de tortuga

Las gráficas de tortuga permiten dibujar todo tipo de figuras en la pantalla de la computadora usando comandos que controlan las acciones de una “tortuga”, equipada con una “pluma” o “bolígrafo”, y que deja un rastro según se vaya desplazando.

Al inicio de un programa la tortuga aparece como un pequeño triángulo negro apuntando hacia el este (hacia la derecha) en el centro de una nueva ventana. Los movimientos se efectúan relativos hacia donde apunta la tortuga.

El siguiente ejemplo es un programa que dibuja un cuadrado de \(100 \times 100\) píxeles.

import turtle

for i in range(4):
    turtle.forward(100)
    turtle.right(90)

# Esta debe ser la última operación con la tortuga.
turtle.done()

El programa produce la siguiente salida:

cuadrado

13.1. Operaciones con la tortuga

Función Descripción

\(\texttt{backward}(p)\)

Retrocede la tortuga \(p\) pasos. Cada paso equivale a un píxel de la pantalla.

Esta es la función inversa de forward.

\(\texttt{circle}(r)\)
\(\texttt{circle}(r, g)\)

Dibuja un arco (o círculo) de radio \(r\) que se extiende \(g\) grados. En caso de omitirse, el valor por omisión de \(g\) es 360, por lo que se dibuja un círculo completo.

\(\texttt{done}()\)

Indica que se terminó de dibujar.

Esta debe ser la última operación de la tortuga en un programa que usa gráficas de tortuga. Su omisión puede provocar que la ventana de dibujo no responda correctamente al momento de intentar cerrarla.

\(\texttt{forward}(p)\)

Avanza la tortuga \(p\) pasos. Cada paso equivale a un píxel de la pantalla.

Esta es la función inversa de backward.

\(\texttt{hideturtle}()\)

Hace invisible a la tortuga.

Esta es la función inversa de showturtle.

\(\texttt{home}()\)

Mueve la tortuga a su posición inicial (centro de la pantalla) y la apunta hacia el este (hacia la derecha).

\(\texttt{left}(g)\)

Gira la tortuga a la izquierda \(g\) grados.

Esta es la función inversa de right.

\(\texttt{pendown}()\)

Baja la pluma. En lo sucesivo la tortuga deja un rastro al avanzar o retroceder.

Esta es la función inversa de penup.

\(\texttt{pensize}(x)\)

Establece a \(x\) como el tamaño de la pluma en píxeles.

\(\texttt{penup}()\)

Sube la pluma. En lo sucesivo la tortuga no deja un rastro al avanzar o retroceder.

Esta es la función inversa de pendown.

\(\texttt{right}(g)\)

Gira la tortuga a la derecha \(g\) grados.

Esta es la función inversa de left.

\(\texttt{showturtle}()\)

Hace visible a la tortuga.

Esta es la función inversa de hideturtle.

\(\texttt{speed}(v)\)

Establece la velocidad de la tortuga. Los posibles valores de \(v\) son las cadenas:

  • 'slowest'

  • 'slow'

  • 'normal'

  • 'fast'

  • 'fastest'

Referencia completa: Turtle graphics.

13.2. Manejo de colores

Para las funciones documentadas a continuación, el parámetro del color \(c\) debe ser una cadena con el nombre de un color (por ejemplo: 'red') o un valor RGB (por ejemplo: '#FF0000').

Función Descripción

\(\texttt{begin_fill}()\)

Se debe invocar justo antes de dibujar una figura a rellenar.

\(\texttt{bgcolor}(c)\)

Establece a \(c\) como el color de fondo de la ventana de dibujo.

\(\texttt{end_fill}()\)

Se debe invocar justo después de dibujar una figura a rellenar.

\(\texttt{fillcolor}(c)\)

Establece a \(c\) como el color para rellenar.

\(\texttt{pencolor}(c)\)

Establece a \(c\) como el color de la pluma.

Referencia completa: Turtle graphics.

El ejemplo que sigue demuestra la manera de dibujar la bandera de Suiza.

import turtle

turtle.hideturtle()
turtle.speed('fastest')
turtle.bgcolor('red')
turtle.pencolor('white')
turtle.fillcolor('white')
turtle.left(90)

turtle.begin_fill()
for i in range(4):
    for j in range(3):
        turtle.forward(25)
        turtle.right(90)
    turtle.right(180)
turtle.end_fill()

turtle.done()

La salida correspondiente es similar a lo siguiente:

suiza

14. Convenciones de codificación

Esta sección fue elaborada de manera conjunta con la profesora Yolanda Martínez Treviño.

Las convenciones de codificación son guías de estilo utilizadas por los programadores para tener una manera consistente de escribir programas. Su objetivo principal es mejorar la legibilidad del código. La guía que se presenta en esta sección está diseñada para ser utilizada en un curso básico de programación. Su contenido está basada, salvo pequeñas adecuaciones, en la guía de estilo oficial del lenguaje Python PEP 8.

14.1. Identificadores y constantes

  • Utilizar identificadores descriptivos para nombres de variables, funciones, parámetros y constantes nombradas.

    Ejemplos:

    # No recomendable: utiliza nombres de variables que no describen
    # adecuadamente su intención.
    temp = 68
    xx = 9.8
    conejo_asesino = temp * xx
    
    # Preferible: utiliza nombres descriptivos para todas las variables.
    masa = 68
    gravedad = 9.8
    peso = masa * gravedad
  • Los identificadores para nombrar variables, funciones y parámetros deben utilizar solamente letras minúsculas, dígitos y guión bajo (_). Las letras solo deben ser las pertenecientes al abecedario inglés; es decir, no deben contener acentos (´), diéresis (¨) ni tildes (~), aunque técnicamente Python sí lo permite. Si un identificador está compuesto por dos o más palabras estas se deben separar utilizando el carácter de guión bajo (_). Se recomienda evitar el uso de abreviaciones, salvo que resulten muy conocidas.

    Ejemplos:

    # Una variable común y corriente.
    empleado = 'Srinivasa Ramanujan'
    
    # No recomendable: utiliza mayúsculas.
    numeroDeNomina = 1729
    
    # Preferible: utiliza guión bajo como separador entre palabras.
    numero_de_nomina = 1729
    
    # No recomendable: utiliza el carácter 'ñ'.
    año_de_nacimiento = 1887
    
    # Preferible: utiliza solo letras del abecedario inglés.
    anio_de_nacimiento = 1887
    
    # No recomendable: utiliza abreviaciones.
    nummaxemps = 14
    
    # Preferible: no utiliza abreviaciones.
    numero_maximo_empleados = 14
  • Los identificadores que se usan como constantes nombradas (también llamadas constantes simbólicas) deben definirse a nivel de módulo (afuera de cualquier función) y se deben escribir con letras mayúsculas usando un guión bajo (_) como separador entre palabras. Se supone que al ser constantes su valor no debe cambiar una vez que ya fue asignado, pero esto es solo una convención.

    Ejemplos:

    PLANCK = 6.62607015e-34
    SERVIDOR_CORREO_ELECTRONICO = 'gmail.com'
    AREA_TOTAL = 150
    
    # No recomendable: se supone que AREA_TOTAL es constante. Al modificarse
    # su valor se está violando la convención de las constantes nombradas.
    AREA_TOTAL += 1
  • Solamente es válido utilizar identificadores de un solo carácter en los siguientes casos:

    • Cuando sea por una convención muy bien establecida.

      Ejemplos:

      • Índices en un ciclo (i, j, k)

      • Coordenadas (x, y)

    • Cuando la variable se utiliza en máximo dos líneas de código consecutivo.

      Ejemplos:

      # No recomendable: la variable 'p' se utiliza en más de dos líneas de
      # código.
      for p in "Uno dos cinco".split():
          print(p)
          print(len(p))
      
      # Preferible: la variable 'palabra' es mejor que 'p' por ser más
      # descriptiva y por utilizarse en más de dos líneas de código.
      for palabra in "Uno dos cinco".split():
          print(palabra)
          print(len(palabra))
      
      # Aceptable: la variable 'p' solo se utiliza en dos líneas de código
      # consecutivo. Sigue siendo preferible utilizar un nombre más
      # descriptivo.
      for p in "Uno dos cinco".split():
          print(p, len(p), sep='\n')
  • Las siguientes letras no deben usarse como identificadores:

    • I (i mayúscula)

    • l (ele minúscula)

    • O (o mayúscula)

    Esto es debido a que es muy fácil confundirlos con los números 1 (uno) y 0 (cero) en ciertos tipos de letra (fonts).

    Ejemplo:

    # No recomendable: las variables 'l', 'I', 'O' se pueden confundir con
    # números.
    l = 10
    I = 1
    O = 1
    while l > O:
        print(l)
        l -= I
  • Una literal numérica con punto decimal (constante de tipo flotante) debe estar formada por al menos un dígito antes y un dígito después del punto.

    Ejemplos:

    >>> 3.  # No recomendable: falta dígito después del punto.
    3.0
    >>> 3.0  # Preferible: dígito antes y después del punto.
    3.0
    >>> .5  # No recomendable: falta dígito antes del punto.
    0.5
    >>> 0.5  # Preferible: dígito antes y después del punto.
    0.5
    >>> 1.e20  # No recomendable: falta dígito después del punto.
    1e+20
    >>> 1.0e20  # Preferible: dígito antes y después del punto.
    1e+20
    >>> 1e20  # Aceptable: notación científica permite omitir el punto.
    1e+20

14.2. Disposición del código

  • Usar cuatro espacios consecutivos para indicar un nivel de indentación. No se debe utilizar el carácter de tabulador (código ASCII 9), también conocido como “hard tab”. Los editores modernos permiten ser configurados para solamente usar “soft tabs” en lugar de “hard tabs”. El uso de “soft tabs” significa que se insertan siempre espacios al momento de indentar cuando se presiona la tecla de tabulación (Tab). Por omisión, los editores de Python más populares (por ejemplo IDLE, Thonny, Spyder, Visual Studio Code y PyCharm) funcionan de esta manera, por lo que no es necesario hacerles ajustes.

    Ejemplos:

    # No recomendable: utiliza dos espacios de indentación.
    for i in range(10):
      potencia = 10 ** i
      if i % 4 == 0:
        print(potencia)
    
    # Preferible: utiliza cuatro espacios de indentación.
    for i in range(10):
        potencia = 10 ** i
        if i % 4 == 0:
            print(potencia)
  • En un archivo fuente, los estatutos de importación de módulos se deben colocar en la parte superior, justo después de cualquier comentario inicial en dicho archivo, y antes de la definición de las constantes nombradas y las funciones.

    Ejemplo:

    # ---------------------------------------------------------
    # Autor: Ariel Ortiz Ramírez
    # Fecha: 7 de septiembre, 2019
    # Licencia: WTFPL v2.0
    # ---------------------------------------------------------
    
    # Aquí van todos los imports:
    
    from math import floor
    from random import randrange
    
    
    # Constantes nombradas:
    
    NUMERO_DE_HARDY_RAMANUJAN = (9 ** 3) + (10 ** 3)
    CONSTANTE_DE_AVOGADRO = 6.022140857e23
    LA_VIDA_EL_UNIVERSO_Y_TODO_LO_DEMAS = 42
    
    
    # Funciones:
    
    def spam():
        """Devuelve un valor aleatorio inservible."""
        return randrange(
                floor(CONSTANTE_DE_AVOGADRO / NUMERO_DE_HARDY_RAMANUJAN))
    
    
    def spamalot():
        """Imprime muchos valores aleatorios inservibles."""
        for i in range(randrange(LA_VIDA_EL_UNIVERSO_Y_TODO_LO_DEMAS)):
            print(spam())
    
    
    spamalot()
  • El límite máximo de caracteres en una línea es de 79. Si una línea rebasa este tamaño es necesario partirla en dos o más partes. Para ello existen dos opciones:

    • La diagonal invertida (\) para indicar una continuación de línea.

      En este contexto solo puede haber un salto de línea inmediatamente después de una diagonal invertida. La presencia de caracteres adicionales, incluyendo espacios y comentarios, produce un error.
    • La continuación de línea implícita que ocurre cuando está pendiente cerrar un paréntesis, corchete o llave. Esta opción se considera preferible a la anterior.

    Ejemplos:

    # Línea de código original.
    suma = primer_dato + segundo_dato + tercer_dato
    
    # Aceptable: utiliza '\' como indicador de continuación de línea.
    suma = primer_dato \
           + segundo_dato \
           + tercer_dato
    
    # Preferible: utiliza la continuación de línea implícita que ocurre
    # cuando se usan paréntesis.
    suma = (primer_dato
            + segundo_dato
            + tercer_dato)
  • No debe haber más de un estatuto por línea de código.

    Ejemplos:

    # No recomendable: dos estatus en la misma línea.
    for i in range(3): print(i)
    
    # Preferible: cada estatuto en su propia línea.
    for i in range(3):
        print(i)
  • Usar las siguientes reglas respecto a la ausencia o presencia de espacios en blanco:

    • No debe haber espacios antes de una coma pero sí después de esta. La única excepción son las tuplas que contienen un elemento. En este caso no debe haber espacio después de la coma.

      Ejemplos:

      # No recomendable:
      print(1,True,['a','b','c'])
      
      # No recomendable:
      print(1 , True , ['a' , 'b' , 'c'])
      
      # Preferible:
      print(1, True, ['a', 'b', 'c'])
      
      # Excepción: Tuplas de un solo elemento
      x = (42,)
    • Debe haber un espacio antes y otro después de un operador binario (un operador binario es aquel que requiere dos operandos).

      Ejemplos:

      # No recomendable:
      print(8/2*(2+2)<=2**4)
      
      # Preferible:
      print(8 / 2 * (2 + 2) <= 2 ** 4)
    • No debe haber espacios entre un operador unario (más unario o menos unario) y su correspondiente operando.

      Ejemplos:

      # No recomendable:
      print(- 4 < - 2 * + 5)
      
      # Preferible:
      print(-4 < -2 * +5)
    • Debe haber un espacio antes y otro después de los símbolos de asignación y de asignación compuesta.

      Ejemplos:

      # No recomendable:
      x=y=z=0
      
      # Preferible:
      x = y = z = 0
      
      # No recomendable:
      x+=1
      
      # Preferible:
      x += 1
    • Al momento de invocar una función no bebe haber espacios antes ni después del signo de igual (=) en argumentos de palabra clave.

      Ejemplos:

      # No recomendable:
      print(1, 2, 3, sep = '*', end = '#')
      
      # Preferible:
      print(1, 2, 3, sep='*', end='#')
    • No debe haber espacios después de un paréntesis, corchete o llave que abre ni antes de su correspondiente símbolo de cierre.

      Ejemplos:

      # No recomendable:
      print( [ 1, 2, 3 ], ( 'a', 'b', 'c' ), { 'uno': 1, 'dos': 2 } )
      
      # Preferible:
      print([1, 2, 3], ('a', 'b', 'c'), {'uno': 1, 'dos': 2})
    • No debe haber espacios antes del signo de dos puntos (:) que va al final de un estatuto.

      Ejemplos:

      # No recomendable:
      if 1 < 5 :
          while True :
              print('*')
      else :
          pass
      
      # Preferible:
      if 1 < 5:
          while True:
              print('*')
      else:
          pass
    • En rebanadas, no debe haber espacios antes ni después del signo de dos puntos (:).

      Ejemplos:

      # No recomendable:
      c = '¡Uno, dos, cinco!'[3 : 8 : 2]
      
      # Preferible:
      c = '¡Uno, dos, cinco!'[3:8:2]
    • En diccionarios, no debe haber espacios antes de un signo de dos puntos (:), pero sí debe haber un espacio después.

      Ejemplos:

      # No recomendable:
      d = {'uno':1, 'dos':2, 'cinco':5}
      
      # No recomendable:
      d = {'uno' : 1, 'dos' : 2, 'cinco' : 5}
      
      # Preferible:
      d = {'uno': 1, 'dos': 2, 'cinco': 5}
    • Al invocar una función no debe haber espacios antes del paréntesis que indica el inicio de la lista de argumentos.

      Ejemplos:

      # No recomendable:
      print (1, 2, 5)
      
      # Preferible:
      print(1, 2, 5)
    • Al indexar una lista, cadena o tupla, o al acceder a un elemento de un diccionario no debe haber espacios antes del corchete que abre.

      Ejemplos:

      # No recomendable:
      diccionario ['clave'] = lista [indice]
      
      # Preferible:
      diccionario['clave'] = lista[indice]
  • Las definiciones de función deben estar separadas entre sí usando dos líneas en blanco.

    Ejemplo:

    def fun1():
        """Función ejemplo 1."""
        pass
    
    
    def fun2():
        """Función ejemplo 2."""
        pass
    
    
    def fun3():
        """Función ejemplo 3."""
        pass
  • Usar, con moderación, líneas en blanco dentro de las funciones para destacar secciones lógicas.

    Ejemplo:

    def ordenamiento_por_seleccion(secuencia):
        """Ordena los elementos de secuencia.
    
        Devuelve una nueva lista con los elementos de secuencia
        ordenados de manera ascendente. Utiliza el algoritmo de
        ordenamiento por selección directa.
    
        Referencia:
        George Heineman, Gary Pollice & Stanley Selkow.
        "Algorithms in a Nutshell, 2nd Edition"
        O'Reilly, 2016.
        ISBN: 978-1491948927
    
        Forma de usarse:
    
        >>> ordenamiento_por_seleccion([6, 1, 4, 2, 0, 3, 7, 5])
        [0, 1, 2, 3, 4, 5, 6, 7]
        >>> ordenamiento_por_seleccion('MURCIELAGO')
        ['A', 'C', 'E', 'G', 'I', 'L', 'M', 'O', 'R', 'U']
        >>> ordenamiento_por_seleccion((23, 15, 8, 42, 4, 16))
        [4, 8, 15, 16, 23, 42]
        """
    
        # Inicializar variables.
        copia = list(secuencia)
        resultado = []
    
        # Repetir mientras existan elementos en la copia.
        while len(copia) > 0:
    
            # Buscar el elemento más chico de la copia y su respectivo índice.
            menor = min(copia)
            indice = copia.index(menor)
    
            # Añadir ese elemento al resultado y borrarlo de la copia.
            resultado.append(menor)
            del copia[indice]
    
        return resultado

14.3. Comentarios y documentación

  • Todas las funciones deben contener una cadena de documentación para describir lo que hace.

    Ejemplo:

    def velocidad(distancia, tiempo):
        """Calcula la velocidad a partir de la distancia y el tiempo."""
        return distancia / tiempo
  • Se deben eliminar todos aquellos comentarios que contengan código, a menos de que sean parte de la documentación.

15. Licencia y créditos

  • © 2019 por Ariel Ortiz Ramírez, Tecnológico de Monterrey.

  • Este material está disponible bajo la licencia de Atribución-NoComercial de Creative Commons CC BY-NC 4.0.

  • El uso libre y gratuito del código fuente presentado aquí se concede bajo los términos de la GPL, versión 3.

  • Este documento fue preparado usando el lenguaje de marcado de texto AsciiDoctor con íconos de Flaticon.

  • Gracias a las siguientes personas por su colaboración con correcciones y/o sugerencias a este documento:

    • Yolanda Martínez Treviño.

    • Angélica Sofía Ramírez Porras