Introducción a la programación en Python

clase 04b
Módulos de la biblioteca estándar

La biblioteca estándar de Python incluye un conjunto de módulos que agregan funciones especiales al lenguaje.

La referencia de los módulos disponibles en la biblioteca estándar de Python3 se puede encontrar en:

https://docs.python.org/3/library/index.html

Importando un módulo

Los módulos se importan mediante la instrucción import, de varias maneras posibles.

• la forma estándar de importar un módulo es mediante la instrucción import, de esta manera:
  
  import modulo
  
  Una vez importado el módulo, sus funciones se acceden poniendo el nombre del módulo seguido de un punto y el nombre de la función:
  
  modulo.funcion()

• al importarse un módulo se le puede asignar un nombre alias mediante la instrucción import ... as.
  
  import modulo_de_nombre_largo as mod
  
  Las funciones se accederán entonces de esta manera:
  
  mod.funcion()

• también de un módulo se puede importar una o más funciones específicas, mediante la instrucción from ... import:
  
  form modulo import func1, func2, ...., funcN
  
  En ese caso, las funciones se acceden directamente a través de su nombre.
  
  func1()

# el módulo time provee varias funciones relacionadas
# con el tiempo cronométrico y el reloj

from time import ctime

# la función ctime() devuelve la fecha completa
# indicada por el reloj del sistema
fecha = ctime()
print(fecha)

Sat Oct 24 21:25:52 2020

• de la manera anterior es posible importar todas las funciones de un módulo usando la estrella [ * ] como carácter comodín:
  
  from modulo import *
  
  En general este procedimiento es desaconsejado, porque puede generar conflictos entre funciones de mismo nombre pertenecientes a módulos diferentes. También dificulta ver a qué módulo pertenece una función utilizada en el código.
  Esta forma debe utilizarse con mucha precaución, y solamente cuando se esté seguro de que no genera conflictos.

Una vez que se importó un módulo, se puede obtener información sobre el mismo mediante la función help():

help(modulo)

También se puede obtener información sobre una función específica del módulo:

help(modulo.funcion)

La referencia de los módulos disponibles se puede encontrar en:

https://docs.python.org/3/library/index.html

math

El módulo math agrega un conjunto de funciones matemáticas (log, factorial, sqrt, funciones trigonométricas, etc), así como también algunas constantes tales como pi o e [ https://docs.python.org/3/library/math.html ].

import math

print("raíz cuadrada de 2:", math.sqrt(2))
print("factorial de 12:", math.factorial(12))
print("3/2 expresado en cents:", 1200 * math.log(3/2, 2))
print("valor de la constante π:", math.pi)
print("seno de π/2:", math.sin(math.pi/2))

raíz cuadrada de 2: 1.4142135623730951
factorial de 12: 479001600
3/2 expresado en cents: 701.9550008653874
valor de la constante π: 3.141592653589793
seno de π/2: 1.0

random

Otro módulo numérico es random, que incluye un conjunto de funciones para la generación de números pseudo-aleatorios de distintas características [ https://docs.python.org/3/library/random.html ].

El módulo random tiene funciones para operar sobre números enteros, sobre números de coma flotante, y sobre secuencias.

funciones para números enteros

• random.randrange()

La función puede invocarse con uno, dos, o tres argumentos:

    random.randrange(*stop*)
    random.randrange(*start, stop[, step]*)

y devuelve un entero aleatorio dentro del rango definido.

Los argumentos se comportan como en la función range():

     - con un único argumento, la función devuelve un entero aleatorio entre 0 y stop-1
     - con dos argumentos, devuelve un entero aleatorio entre start y stop-1
     - el tercer argumento opcional determina el incremento.

import random

print(random.randrange(10))
print(random.randrange(10, 20))
print(random.randrange(50, 100, 5))

4
16
70

• random.randint()

La función se invoca:

    random.randint(*a, b*)

y devuelve un número entero aleatorio N tal que a <= N <= b.

Es equivalente a randrange(a, b+1).

import random

print(random.randint(10, 20))

16

funciones para números de coma flotante

El módulo random dispone de una serie de funciones que generan números pseudo-aleatorios de diferentes distribuciones.

Algunas de las más importantes son:

• random.random()

Devuelve un número aleatorio de coma flotante (con distribución uniforme) en el rango [0.0, 1.0)

• random.uniform()

La función se invoca:

    random.uniform(*a, b*)

y devuelve un número aleatorio de coma flotante (con distribución uniforme) en el rango [a, b]

• random.triangular()

La función se invoca:

    random.triangular(*low, high, mode*)

Devuelve un número aleatorio de coma flotante con distribución triangular en el rango [low, high], que por defecto valen 0 y 1 respectivamente.

El argumento *mode* por defecto es el valor intermedio entre *low* y *high*, generando así una distribución simétrica.

Ejemplo 4.1

import random

# crea una lista invocando 50 veces la función random.triangular()
# por defecto: low = 0, high = 1, mode = 0.5
triangular_simetrica = [round(random.triangular(), 2) for i in range(50)]
print(triangular_simetrica)
triangular_simetrica.sort()
print(triangular_simetrica)

# distribución asimétrica com mode = 0.9
triangular_asimetrica = [round(random.triangular(0, 1, 0.9), 2) for i in range(50)]
print(triangular_asimetrica)
triangular_asimetrica.sort()
print(triangular_asimetrica)

[0.96, 0.33, 0.27, 0.73, 0.56, 0.15, 0.83, 0.32, 0.4, 0.61, 0.56, 0.59, 0.26, 0.79, 0.8, 0.59, 0.49, 0.42, 0.76, 0.08, 0.27, 0.4, 0.25, 0.69, 0.33, 0.46, 0.79, 0.46, 0.22, 0.23, 0.51, 0.91, 0.69, 0.29, 0.43, 0.15, 0.59, 0.55, 0.54, 0.6, 0.85, 0.36, 0.55, 0.42, 0.74, 0.83, 0.4, 0.29, 0.53, 0.38]
[0.08, 0.15, 0.15, 0.22, 0.23, 0.25, 0.26, 0.27, 0.27, 0.29, 0.29, 0.32, 0.33, 0.33, 0.36, 0.38, 0.4, 0.4, 0.4, 0.42, 0.42, 0.43, 0.46, 0.46, 0.49, 0.51, 0.53, 0.54, 0.55, 0.55, 0.56, 0.56, 0.59, 0.59, 0.59, 0.6, 0.61, 0.69, 0.69, 0.73, 0.74, 0.76, 0.79, 0.79, 0.8, 0.83, 0.83, 0.85, 0.91, 0.96]
[0.28, 0.84, 0.72, 0.54, 0.91, 0.74, 0.88, 0.5, 0.64, 0.85, 0.21, 0.5, 0.91, 0.95, 0.78, 0.71, 0.76, 0.93, 0.69, 0.9, 0.93, 0.68, 0.82, 0.1, 0.88, 0.72, 0.38, 0.92, 0.75, 0.65, 0.71, 0.29, 0.75, 0.51, 0.83, 0.93, 0.71, 0.83, 0.78, 0.6, 0.27, 0.58, 0.95, 0.66, 0.5, 0.71, 0.88, 0.74, 0.97, 0.55]
[0.1, 0.21, 0.27, 0.28, 0.29, 0.38, 0.5, 0.5, 0.5, 0.51, 0.54, 0.55, 0.58, 0.6, 0.64, 0.65, 0.66, 0.68, 0.69, 0.71, 0.71, 0.71, 0.71, 0.72, 0.72, 0.74, 0.74, 0.75, 0.75, 0.76, 0.78, 0.78, 0.82, 0.83, 0.83, 0.84, 0.85, 0.88, 0.88, 0.88, 0.9, 0.91, 0.91, 0.92, 0.93, 0.93, 0.93, 0.95, 0.95, 0.97]

• random.gauss()

La función se invoca:

    random.gauss(*mu, sigma*)

y devuelve un número aleatorio de coma flotante con distribución gaussiana (distribución normal), de media mu y desviación estándar sigma.

funciones para secuencias

• random.choice()

La función se invoca:

    random.choice(*secuencia*)

y devuelve un elemento aleatorio de la secuencia.

import random

lista = ["foo", 17, "bar", 23, "hola"]
cadena = "asldkfjowerldjf"
print(random.choice(lista))
print(random.choice(cadena))

foo
a

• random.shuffle()

La función se invoca:

    random.shuffle(*secuencia*)

Reordena aleatoriamente los elementos de una secuencia.

import random

lista = [x for x in range(10)]
print(lista)
random.shuffle(lista)
print(lista)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 3, 2, 5, 4, 1, 0, 6, 7, 8]

Modifica la secuencia en el lugar, y por lo tanto puede operar en listas pero no en cadenas, que son inmutables.

• random.sample()</tt>

La función se invoca:

    random.sample(*secuencia, k*)

Devuelve una lista de k elementos elegidos aleatoriamente de secuencia.

Si k == len(secuencia), el resultado es una permutación aleatoria de los elementos de la secuencia. A diferencia de random.shuffle(), la secuencia original no es modificada.

Ejemplo 4.2

Generar series dodecafónicas aleatorias a partir de una lista ordenada de las doce clases de altura.

import random

# lista ordenada de las 12 clases de altura
k = 12
total_cromatico = [x for x in range(k)]

# se generan permutaciones aleatorias del total cromático
serie1 = random.sample(total_cromatico, k)
serie2 = random.sample(total_cromatico, k)
serie3 = random.sample(total_cromatico, k)

print(total_cromatico)
print(serie1)
print(serie2)
print(serie3)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
[11, 4, 5, 6, 2, 3, 9, 0, 8, 7, 1, 10]
[6, 11, 10, 5, 0, 9, 1, 7, 3, 2, 4, 8]
[11, 5, 6, 4, 8, 2, 7, 1, 0, 3, 10, 9]

Como la función opera sobre la secuencia sin modificarla, puede aplicarse tanto a listas como a cadenas de caracteres. Siempre devuelve una lista.

import random

cadena = "asdlkjfh"
print(random.sample(cadena, 3))
print(random.sample(cadena, 6))

['f', 'd', 's']
['f', 'k', 'a', 'h', 'l', 'j']

funciones de estado

• random.seed()

Inicializa el generador de números aleatorios.

Si se le pasa un argumento entero, se usa como semilla, garantizando el mismo resultado cada vez que se ejecuta el código.
Si se deja vacío (o se usa un objeto de tipo None), se inicializa con el reloj del sistema

import random

random.seed(1)
print(random.randrange(1000))
print(random.randrange(1000))

random.seed()
print(random.randrange(1000))
print(random.randrange(1000))

137
582
441
646

---