PYTHON

¿QUÉ ES Y PARA QUÉ SIRVE EL PYTHON?

Python es un lenguaje de programación ampliamente utilizado en las aplicaciones web, el desarrollo de software, la
ciencia de datos y el machine learning (ML). Los desarrolladores utilizan Python porque es eficiente y fácil de aprender,
además de que se puede ejecutar en muchas plataformas diferentes.

¿QUÉ SE PUEDE HACER CON PYTHON?

Usos principales de Python

 Desarrollo de aplicaciones de líneas de comandos. ...

 Desarrollo web. ...

 Scraping web. ...

 Ciencia de Datos y Visualización de datos. ...

 Aplicaciones de negocios. ...

 Aprendizaje Automático.

Historia
Guido van Rossum, creador de Python, en la convención OSCON 2006

Python fue creado a finales de los años ochenta4 por Guido van Rossum en Stichting Mathematisch Centrum (CWI), en
los Países Bajos, como un sucesor del lenguaje de programación ABC, capaz de manejar excepciones e interactuar con el
sistema operativo Amoeba.5

Guido van Rossum es el principal autor de Python, y su continuo rol central en decidir la dirección de Python es
reconocido, refiriéndose a él como Benevolente Dictador Vitalicio (en inglés: Benevolent Dictator for Life, BDFL);
sin embargo el 12 de julio de 2018 declinó de dicha situación de honor sin dejar un sucesor o sucesora y con una
declaración altisonante:

Elementos del lenguaje y sintaxis

Python está destinado a ser un lenguaje de fácil lectura. Su formato es visualmente ordenado y, a menudo, usa
palabras clave en inglés donde otros idiomas usan puntuación. A diferencia de muchos otros lenguajes, no utiliza
corchetes para delimitar bloques y se permiten puntos y coma después de las declaraciones, pero rara vez, si es
que alguna vez, se utilizan. Tiene menos excepciones sintácticas y casos especiales que C o Pascal.
Diseñado para ser leído con facilidad, una de sus características es el uso de palabras donde otros lenguajes
utilizarían símbolos. Por ejemplo, los operadores lógicos  ! ,  ||  y  &&  en Python se escriben  not ,  or  y  and ,
respectivamente. Curiosamente el lenguaje Pascal es junto con COBOL uno de los lenguajes con muy clara
sintaxis y ambos son de la década del 70. La idea del código claro y legible no es algo nuevo.
El contenido de los bloques de código (bucles, funciones, clases, etc.) es delimitado mediante espacios o
tabuladores, conocidos como indentación, antes de cada línea de órdenes pertenecientes al bloque. 28
Python se diferencia así de otros lenguajes de programación que mantienen como costumbre declarar los bloques
mediante un conjunto de caracteres, normalmente entre llaves  {} .2930 Se pueden utilizar tanto espacios como
tabuladores para sangrar el código, pero se recomienda no mezclarlos. 31

Función factorial en C (sangría opcional) Función factorial en Python (sangría obligatoria)

int factorial(int x) def factorial(x):

{ assert x >= 0 and x % 1 == 0, "x debe
if (x < 0 || x % 1 != 0) { ser un entero mayor o igual a 0."
printf("x debe ser un numero entero if x == 0:
mayor o igual a 0"); return 1
return -1; //Error else:
} return x * factorial(x - 1)
if (x == 0) {
return 1;
}
return x * factorial(x - 1);
}

Debido al significado sintáctico de la sangría, cada instrucción debe estar contenida en una sola línea. No obstante,
si por legibilidad se quiere dividir la instrucción en varias líneas, añadiendo una barra invertida  \  al final de una
línea, se indica que la instrucción continúa en la siguiente.
Estas instrucciones son equivalentes:

lista=['valor 1','valor 2','valor 3'] lista=['valor 1','valor 2' \

cadena='Esto es una cadena bastante larga' ,'valor 3']
cadena='Esto es una cadena ' \
'bastante larga'

Comentarios
Los comentarios se pueden poner de dos formas. La primera y más apropiada para comentarios largos es
utilizando la notación ''' comentario ''', tres apóstrofos de apertura y tres de cierre. La segunda notación utiliza el
símbolo  # , y se extienden hasta el final de la línea.
El intérprete no tiene en cuenta los comentarios, lo cual es útil si deseamos poner información adicional en el
código. Por ejemplo, una explicación sobre el comportamiento de una sección del programa.

'''
Comentario más largo en una línea en Python
'''
print("Hola mundo") # También es posible añadir un comentario al final de una línea de
código
Variables
Las variables se definen de forma dinámica, lo que significa que no se tiene que especificar cuál es su tipo de
antemano y puede tomar distintos valores en otro momento, incluso de un tipo diferente al que tenía previamente.
Se usa el símbolo  =  para asignar valores.

x = 1
x = "texto" # Esto es posible porque los tipos son asignados dinámicamente

Los nombres de variables pueden contener números y letras pero deben comenzar por una letra, además existen
28 palabras reservadas:32
 and  elif  global  or
 assert  else  if  pass
 break  except  import  print
 class  exec  in  raise
 continue  finally  is  return
 def  for  lambda  try
 del  from  not  while

Tipos de datos
Los tipos de datos se pueden resumir en esta tabla:

Tipo Clase Notas Ejemplo

str Cadena Inmutable 'Cadena'

unicode Cadena Versión Unicode de  str u'Cadena'

list Mutable, puede contener objetos de [4.0, 'Cadena', True]

Secuencia
diversos tipos

tuple Inmutable, puede contener objetos de (4.0, 'Cadena', True)

Secuencia
diversos tipos

set Mutable, sin orden, no contiene {4.0, 'Cadena', True}

Conjunto
duplicados

Inmutable, sin orden, no contiene frozenset([4.0, 'Cadena',

frozenset Conjunto
duplicados True])

dict Mapping Grupo de pares clave:valor {'key1': 1.0, 'key2': False}

int Número Precisión fija, convertido en long en caso 42

entero de overflow.

long Número 42L  o  456966786151987643L

Precisión arbitraria
entero

float Número 3.1415927

Coma flotante de doble precisión
decimal

complex Número (4.5 + 3j)

Parte real y parte imaginaria j.
complejo

bool Booleano Valor booleano verdadero o falso True o False

 Mutable: si su contenido (o dicho valor) puede cambiarse en tiempo de ejecución.

 Inmutable: si su contenido (o dicho valor) no puede cambiarse en tiempo de ejecución.
Condicionales
Una sentencia condicional (if) ejecuta su bloque de código interno solo si se cumple cierta condición. Se define
usando la palabra clave  if  seguida de la condición, y el bloque de código. Si existen condiciones adicionales, se
introducen usando la palabra clave  elif  seguida de la condición y su bloque de código. Las condiciones se
evalúan de manera secuencial hasta encontrar la primera que sea verdadera, y su bloque de código asociado es el
único que se ejecuta. Opcionalmente, puede haber un bloque final (la palabra clave  else  seguida de un bloque de
código) que se ejecuta solo cuando todas las condiciones anteriores fueron falsas.

>>> verdadero = True

>>> if verdadero: # No es necesario poner "verdadero == True"
... print("Verdadero")
... else:
... print("Falso")
...
Verdadero
>>> lenguaje = "Python"
>>> if lenguaje == "C": # lenguaje no es "C", por lo que este bloque se obviará y
evaluará la siguiente condición
... print("Lenguaje de programación: C")
... elif lenguaje == "Python": # Se pueden añadir tantos bloques "elif" como se quiera
... print("Lenguaje de programación: Python")
... else: # En caso de que ninguna de las anteriores condiciones fuera cierta, se
ejecutaría este bloque
... print("Lenguaje de programación: indefinido")
...
Lenguaje de programación: Python
>>> if verdadero and lenguaje == "Python": # Uso de "and" para comprobar que ambas
condiciones son verdaderas
... print("Verdadero y Lenguaje de programación: Python")
...
Verdadero y Lenguaje de programación: Python

Bucle for
El bucle for es similar a foreach en otros lenguajes. Recorre un objeto iterable, como una lista, una tupla o un
generador, y por cada elemento del iterable ejecuta el bloque de código interno. Se define con la palabra
clave  for  seguida de un nombre de variable, seguido de  in , seguido del iterable, y finalmente el bloque de código
interno. En cada iteración, el elemento siguiente del iterable se asigna al nombre de variable especificado:

>>> lista = ["a", "b", "c"]

>>> for i in lista: # Iteramos sobre una lista, que es iterable
... print(i)
...
a
b
c
>>> cadena = "abcdef"
>>> for i in cadena: # Iteramos sobre una cadena, que también es iterable
... print(i, end=', ') # Añadiendo end=', ' al final hacemos que no introduzca un
salto de línea, sino una coma y un espacio
...
a, b, c, d, e, f,
Bucle while
El bucle while evalúa una condición y, si es verdadera, ejecuta el bloque de código interno. Continúa evaluando y
ejecutando mientras la condición sea verdadera. Se define con la palabra clave  while  seguida de la condición, y a
continuación el bloque de código interno:

>>> numero = 0
>>> while numero < 10:
... print(numero, end=" ")
... numero += 1 # Un buen programador modificará las variables de control al
finalizar el ciclo while
...
0 1 2 3 4 5 6 7 8 9

Listas y Tuplas
 Para declarar una lista se usan los corchetes  [] , en cambio, para declarar una tupla se usan los
paréntesis  () . En ambas los elementos se separan por comas, y en el caso de las tuplas es necesario
que tengan como mínimo una coma.
 Tanto las listas como las tuplas pueden contener elementos de diferentes tipos. No obstante
las listas suelen usarse para elementos del mismo tipo en cantidad variable mientras que las tuplas se
reservan para elementos distintos en cantidad fija.
 Para acceder a los elementos de una lista o tupla se utiliza un índice entero (empezando por "0", no por
"1"). Se pueden utilizar índices negativos para acceder elementos a partir del final.
 Las listas se caracterizan por ser mutables, es decir, se puede cambiar su contenido en tiempo de
ejecución, mientras que las tuplas son inmutables ya que no es posible modificar el contenido una vez
creada.
Listas

>>> lista = ["abc", 42, 3.1415]

>>> lista[0] # Acceder a un elemento por su índice
'abc'
>>> lista[-1] # Acceder a un elemento usando un índice negativo
3.1415
>>> lista.append(True) # Añadir un elemento al final de la lista
>>> lista
['abc', 42, 3.1415, True]
>>> del lista[3] # Borra un elemento de la lista usando un índice (en este caso: True)
>>> lista[0] = "xyz" # Re-asignar el valor del primer elemento de la lista
>>> lista[0:2] # Mostrar los elementos de la lista del índice "0" al "2" (sin incluir
este último)
['xyz', 42]
>>> lista_anidada = [lista, [True, 42L]] # Es posible anidar listas
>>> lista_anidada
[['xyz', 42, 3.1415], [True, 42L]]
>>> lista_anidada[1][0] # Acceder a un elemento de una lista dentro de otra lista (del
segundo elemento, mostrar el primer elemento)
True
Tuplas

>>> tupla = ("abc", 42, 3.1415)

>>> tupla[0] # Acceder a un elemento por su índice
'abc'
>>> del tupla[0] # No es posible borrar (ni añadir) un elemento en una tupla, lo que
provocará una excepción
( Excepción )
>>> tupla[0] = "xyz" # Tampoco es posible re-asignar el valor de un elemento en una
tupla, lo que también provocará una excepción
( Excepción )
>>> tupla[0:2] # Mostrar los elementos de la tupla del índice "0" al "2" (sin incluir
este último)
('abc', 42)
>>> tupla_anidada = (tupla, (True, 3.1415)) # También es posible anidar tuplas
>>> 1, 2, 3, "abc" # Esto también es una tupla, aunque es recomendable ponerla entre
paréntesis (recuerda que requiere, al menos, una coma)
(1, 2, 3, 'abc')
>>> (1) # Aunque entre paréntesis, esto no es una tupla, ya que no posee al menos una
coma, por lo que únicamente aparecerá el valor
1
>>> (1,) # En cambio, en este otro caso, sí es una tupla
(1,)
>>> (1, 2) # Con más de un elemento no es necesaria la coma final
(1, 2)
>>> (1, 2,) # Aunque agregarla no modifica el resultado
(1, 2)

Diccionarios
 Para declarar un diccionario se usan las llaves  {} . Contienen elementos separados por comas, donde
cada elemento está formado por un par  clave:valor  (el símbolo  :  separa la clave de su valor
correspondiente).
 Los diccionarios son mutables, es decir, se puede cambiar el contenido de un  valor  en tiempo de
ejecución.
 En cambio, las  claves  de un diccionario deben ser inmutables. Esto quiere decir, por ejemplo, que no
podremos usar ni listas ni diccionarios como  claves .
 El  valor  asociado a una  clave  puede ser de cualquier tipo de dato, incluso un diccionario.

>>> diccionario = {"cadena": "abc", "numero": 42, "lista": [True, 42L]} # Diccionario que
tiene diferentes valores por cada clave, incluso una lista
>>> diccionario["cadena"] # Usando una clave, se accede a su valor
'abc'
>>> diccionario["lista"][0] # Acceder a un elemento de una lista dentro de un valor (del
valor de la clave "lista", mostrar el primer elemento)
True
>>> diccionario["cadena"] = "xyz" # Re-asignar el valor de una clave
>>> diccionario["cadena"]
'xyz'
>>> diccionario["decimal"] = 3.1415927 # Insertar un nuevo elemento clave:valor
>>> diccionario["decimal"]
3.1415927
>>> diccionario_mixto = {"tupla": (True, 3.1415), "diccionario": diccionario} # También
es posible que un valor sea un diccionario
>>> diccionario_mixto["diccionario"]["lista"][1] # Acceder a un elemento dentro de una
lista, que se encuentra dentro de un diccionario
42L
>>> diccionario = {("abc",): 42} # Sí es posible que una clave sea una tupla, pues es
inmutable
>>> diccionario = {["abc"]: 42} # No es posible que una clave sea una lista, pues es
mutable, lo que provocará una excepción
( Excepción )

Sentencia Switch Case

Python cuenta con la estructura switch-case desde la versión 3.10. Esta tiene el nombre de Structural Pattern
Matching.

match variable:
case condicion:
# codigo
case condicion:
# codigo
case condicion:
# codigo
case _:
# codigo

Cabe destacar que esta funcionalidad es considerablemente más compleja que el conocido switch-case de la
mayoría de lenguajes, ya que no solo permite realizar una comparación del valor, si no que también puede
comprobar el tipo del objeto, y sus atributos. Además que también puede realizar un desempaquetado directo de
secuencias de datos, y comprobarlos de forma específica.
En el siguiente ejemplo, se comprueban los atributos de nuestra instancia de  Punto . Si estos no son iguales
a  x10  e  y40 , se pasará a la siguiente condición.
Es importante anotar que  Punto(x=10, y=40)  no está construyendo un nuevo objeto, aunque pueda parecerlo.

from dataclasses import dataclass

@dataclass
class Punto:
x: int
y: int

coordenada = Punto(10, 34)

match coordenada:
case Punto(x=10, y=40): # los atributos "x" e "y" tienen el valor specificado
print("Coordenada 10, 40")
case Punto(): # si es una instancia de Punto
print("es un punto")
case _: # ninguna condición cumplida (default)
print("No es un punto")

En versiones anteriores, existen diferentes formas de realizar esta operación lógica de forma similar:
Usando if, elif, else
Podemos usar la estructura de la siguiente manera:

>>> if condicion1:
... hacer1
>>> elif condicion2:
... hacer2
>>> elif condicion3:
... hacer3
>>> else:
... hacer

En esa estructura se ejecutara controlando la condicion1, si no se cumple pasara a la siguiente y así

sucesivamente hasta entrar en el else. Un ejemplo práctico sería:

>>> def calculo(op,a,b):

... if 'sum' == op:
... return a + b
... elif 'rest' == op:
... return a - b
... elif 'mult' == op:
... return a * b
... elif 'div' == op:
... return a/b
... else:
... return None
>>>
>>> print(calculo('sum',3,4))
7

Podríamos decir que el lado negativo de la sentencia armada con if, elif y else es que si la lista de posibles
operaciones es muy larga, las tiene que recorrer una por una hasta llegar a la correcta.

Usando diccionario
Podemos usar un diccionario para el mismo ejemplo:

>>> def calculo(op,a,b):

... return {
... 'sum': lambda: a + b,
... 'rest': lambda: a - b,
... 'mult': lambda: a * b,
... 'div': lambda: a/b
... }.get(op, lambda: None)()
>>>
>>> print(calculo('sum',3,4))
7

De esta manera, si las opciones fueran muchas, no recorrería todas; solo iría directamente a la operación buscada
en la última línea .get(op, lambda: None)() estamos dando la opción por defecto.
Conjuntos
 Los conjuntos se construyen mediante  set(items)  donde items es cualquier objeto iterable,
como listas o tuplas. Los conjuntos no mantienen el orden ni contienen elementos duplicados.
 Se suelen utilizar para eliminar duplicados de una secuencia, o para operaciones matemáticas
como intersección, unión, diferencia y diferencia simétrica.

>>> conjunto_inmutable = frozenset(["a", "b", "a"]) # Se utiliza una lista como objeto
iterable
>>> conjunto_inmutable
frozenset(['a', 'b'])
>>> conjunto1 = set(["a", "b", "a"]) # Primer conjunto mutable
>>> conjunto1
set(['a', 'b'])
>>> conjunto2 = set(["a", "b", "c", "d"]) # Segundo conjunto mutable
>>> conjunto2
set(['a', 'c', 'b', 'd']) # Recuerda, no mantienen el orden, como los diccionarios
>>> conjunto1 & conjunto2 # Intersección
set(['a', 'b'])
>>> conjunto1 | conjunto2 # Unión
set(['a', 'c', 'b', 'd'])
>>> conjunto1 - conjunto2 # Diferencia (1)
set([])
>>> conjunto2 - conjunto1 # Diferencia (2)
set(['c', 'd'])
>>> conjunto1 ^ conjunto2 # Diferencia simétrica
set(['c', 'd'])

Listas por comprensión

Una lista por comprensión (en inglés: list comprehension) es una expresión compacta para definir listas. Al igual
que  lambda , aparece en lenguajes funcionales. Ejemplos:

>>> range(5) # La función "range" devuelve una lista, empezando en 0 y terminando con el
número indicado menos uno
[0, 1, 2, 3, 4]
>>> [i*i for i in range(5)] # Por cada elemento del rango, lo multiplica por sí mismo y
lo agrega al resultado
[0, 1, 4, 9, 16]
>>> lista = [(i, i + 2) for i in range(5)]
>>> lista
[(0, 2), (1, 3), (2, 4), (3, 5), (4, 6)]

Funciones
 Las funciones se definen con la palabra clave  def , seguida del nombre de la función y sus parámetros.
Otra forma de escribir funciones, aunque menos utilizada, es con la palabra clave  lambda  (que
aparece en lenguajes funcionales como Lisp).
 El valor devuelto en las funciones con  def  será el dado con la instrucción  return .
  Las funciones definidas con  def  pueden recibir parámetros especiales para manejar el exceso de
argumentos.
o El parámetro  *args  recibe como una tupla un número variable de argumentos
posicionales.
o El parámetro  **kwargs  recibe como un diccionario un número variable de argumentos por
palabras clave.
def :

>>> def suma(x, y=2):

... return x + y # Retornar la suma del valor de la variable "x" y el valor de "y"
...
>>> suma(4) # La variable "y" no se modifica, siendo su valor: 2
6
>>> suma(4, 10) # La variable "y" sí se modifica, siendo su nuevo valor: 10
14

*args :

>>> def suma(*args):

... resultado = 0
... # se itera la tupla de argumentos
... for num in args:
... resultado += num # suma todos los argumentos
... return resultado # retorna el resultado de la suma
...
>>>suma(2,4)
6
>>>suma(1,3,5,7,9) # no importa el número de variables posicionales que se pasen a la
función
25

**kwargs :

def suma(**kwargs):
... resultado = 0
... # se itera el diccionario de argumentos
... for key, value in kwargs.items():
... resultado += value # suma todos los valores de los argumentos
... return resultado
...
>>>suma(x=1, y=3)
4
>>>suma(x=2, y=4, z=6) # no importa el número de variables por clave que se pasen a la
función
12

lambda :

>>> suma = lambda x, y=2: x + y

>>> suma(4) # La variable "y" no se modifica, siendo su valor: 2
6
>>> suma(4, 10) # La variable "y" sí se modifica, siendo su nuevo valor: 10
14
Clases
 Las clases se definen con la palabra clave  class , seguida del nombre de la clase y, si hereda de
otra clase, el nombre de esta.
 En Python 2.x era recomendable que una clase heredase de "Object", en Python 3.x ya no hace falta.
 En una clase un "método" equivale a una "función", y un "atributo" equivale a una "variable". 33
 "__init__" es un método especial que se ejecuta al instanciar la clase, se usa generalmente para
inicializar atributos y ejecutar métodos necesarios. Al igual que todos los métodos en Python, debe
tener al menos un parámetro, generalmente se utiliza  self . El resto de parámetros serán los que se
indiquen al instanciar la clase.
 Los atributos que se desee que sean accesibles desde fuera de la clase se deben declarar
usando  self.  delante del nombre.
 En Python no existe el concepto de encapsulación, 34 por lo que el programador debe ser responsable
de asignar los valores a los atributos

>>> class Persona():

... def __init__(self, nombre, edad):
... self.nombre = nombre # Un atributo cualquiera
... self.edad = edad # Otro atributo cualquiera
... def mostrar_edad(self): # Es necesario que, al menos, tenga un parámetro,
generalmente: "self"
... print(self.edad) # mostrando un atributo
... def modificar_edad(self, edad): # Modificando Edad
... if edad < 0 or edad > 150: # Se comprueba que la edad no sea menor de 0 (algo
imposible), ni mayor de 150 (algo realmente difícil)
... return False
... else: # Si está en el rango 0-150, entonces se modifica la variable
... self.edad = edad # Se modifica la edad
...
>>> p = Persona('Alicia', 20) # Instanciar la clase, como se puede ver, no se especifica
el valor de "self"
>>> p.nombre # La variable "nombre" del objeto sí es accesible desde fuera
'Alicia'
>>> p.nombre = 'Andrea' # Y por tanto, se puede cambiar su contenido
>>> p.nombre
'Andrea'
>>> p.mostrar_edad() # Se llama a un método de la clase
20
>>> p.modificar_edad(21) # Es posible cambiar la edad usando el método específico que
hemos hecho para hacerlo de forma controlada
>>> p.mostrar_edad()
21

Módulos
Existen muchas propiedades que se pueden agregar al lenguaje importando módulos, que son "minicódigos" (la
mayoría escritos también en Python) que proveen de ciertas funciones y clases para realizar determinadas tareas.
Un ejemplo es el módulo Tkinter,35 que permite crear interfaces gráficas basadas en la biblioteca Tk. Otro ejemplo
es el módulo os, que provee acceso a muchas funciones del sistema operativo. Los módulos se agregan a los
códigos escribiendo  import  seguida del nombre del módulo que queramos usar.36

Instalación de módulos (pip)

La instalación de módulos en Python se puede realizar mediante la herramienta de software (suele venir incluida
con las instalaciones de Python) Pip. Esta herramienta permite la gestión de los distintos paquetes o módulos
instalables para Python, incluyendo así las siguientes características:

 Instalación de paquetes.
o Instalación de versiones concretas de paquetes.
o Instalación a partir de un archivo de configuración.
 Desinstalación.
 Actualización.
Interfaz al sistema operativo
El módulo os provee funciones para interactuar con el sistema operativo:

>>> import os # Módulo que provee funciones del sistema operativo

>>> os.name # Devuelve el nombre del sistema operativo
'posix'
>>> os.mkdir("/tmp/ejemplo") # Crea un directorio en la ruta especificada
>>> import time # Módulo para trabajar con fechas y horas
>>> time.strftime("%Y-%m-%d %H:%M:%S") # Dándole un cierto formato, devuelve la fecha y/u
hora actual
'2010-08-10 18:01:17'

Para tareas de administración de archivos, el módulo shutil provee una interfaz de más alto nivel:

>>> import shutil

>>> shutil.copyfile('datos.db', 'informacion.db')
'informacion.db'
>>> shutil.move('/build/programas', 'dir_progs')
'dir_progs'

Comodines de archivos
El módulo glob provee una función para crear listas de archivos a partir de búsquedas con comodines en carpetas:

>>> import glob

>>> glob.glob('*.py')
['numeros.py', 'ejemplo.py', 'ejemplo2.py']

Argumentos de línea de órdenes

Los argumentos de línea de órdenes se almacenan en el atributo argv del módulo sys como una lista.

>>> import sys

>>> print(sys.argv)
['demostracion.py', 'uno', 'dos', 'tres']
Matemática
El módulo math permite acceder a las funciones de matemática de punto flotante:

>>> import math

>>> math.cos(math.pi / 3)
0,494888338963
>>> math.log(1024, 2)
10.0

El módulo random se utiliza para realizar selecciones al azar:

>>> import random

>>> random.choice(['durazno', 'manzana', 'frutilla'])
'durazno'
>>> random.sample(range(100), 10) # elección sin reemplazo
[30, 23, 17, 24, 8, 81, 41, 80, 28, 13]
>>> random.random() # un float al azar
0.23370387692726126
>>> random.randrange(6) # un entero al azar tomado de range(6)
3

El módulo statistics se utiliza para estadística básica, por ejemplo: media, mediana, varianza, etc.:

>>> import statistics

>>> datos = [1.75, 2.75, 1.25, 0.5, 0.25, 1.25, 3.5]
>>> statistics.mean(datos)
1.6071428571428572
>>> statistics.median(datos)
1.25
>>> statistics.variance(datos)
1.3720238095238095

Fechas y Tiempos
El módulo datetime permite manejar fechas y tiempos:

>>> from datetime import date

>>> hoy = date.today()
>>> hoy
datetime.date(2017, 8, 16)

Módulo Turtle
El módulo turtle permite la implementación de gráficas tortuga:

>>> import turtle

>>> turtle.pensize(2)
>>> turtle.left(120)
>>> turtle.forward(100)
Sistema de objetos
En Python todo es un objeto (incluso las clases). Las clases, al ser objetos, son instancias de
una metaclase. Python además soporta herencia múltiple y polimorfismo.

>>> cadena = "abc" # Una cadena es un objeto de "str"

>>> cadena.upper() # Al ser un objeto, posee sus propios métodos
'ABC'
>>> lista = [True, 3.1415] # Una lista es un objeto de "list"
>>> lista.append(42L) # Una lista también (al igual que todo) es un objeto, y también
posee sus propios métodos
>>> lista
[True, 3.1415, 42L]