Librerías incluida: `random`

Asi como hay funciones incluidas (built-ins) que se pueden usar sin estar declaradas tambien hay más herramientas de Python disponibles pero que requieren ser importadas.

Importar (con el comando import o de la forma from X import Y) en Python es disponibilizar nueva herramientas (fuenciones y otras) en nuestro código.

Python al azar: `random`

El módulo random incluye una serie de funciones que permiten darle aleatoriedad a nuestro código.

Veamos un ejemplo. La función randint genera numeros al alzar entre dos valores pasados como parámetros.

from random import randint

al_azar = randint(1, 100)
print(al_azar)

# otra forma de usarlo podría ser
import random
al_azar = random.randint(1, 100)
print(al_azar)

Asi como el . se usa en objeto.propiedad tambien se usa en modulo.objeto_en_modulo.

`choice`: Elegir un opción al azar de una lista.

La función choice recibe como parámetro una lista de la cual devolverá un elemento al azar.

from random import choice

opciones = ["piedra", "papel", "tijeras"]
opcion_elegida = choice(opciones)
print(opcion_elegida)
# tijeras

`shuffle`: Mezclar una lista

Otra función del módulo random es shuffle que recibe una lista como parámetro y la desordena aleatoriamente.

Ejemplo:

from random import shuffle

mazo = [
    {"numero": 1, "palo": "espada"},
    {"numero": 2, "palo": "espada"},
    # ...
    {"numero": 11, "palo": "oro"},
    {"numero": 12, "palo": "oro"},
]
suffle(mazo)
print(mazo[0])
# {"numero": 11, "palo": "oro"}

Tareas

Escribir un programa que elija un numero al azar entre 1 y 100 y le pida al usuario que lo adivine. El programa debe decirle al usuario si el numero que ingresó es mayor o menor al numero que se eligió al azar. El programa debe terminar cuando el usuario adivine el numero elegido al azar.
Hacer un PR con una propuesta de solución para el ejercicio 045 (contenido en este repositorio)

"""
La funcion "carta_poker_al_azar" ya funciona como es esperado
La tarea aquí es completar la funcion "carta_espaniola_al_azar"
para que devuleva resultados válidos.
Nota: se debe importar y usar la funcion "randint" de "random"
"""

from random import choice

def carta_poker_al_azar():
    palos = ['pica', 'trebol', 'corazon', 'diamante']
    numeros = list(range(1, 11)) + ['J', 'Q', 'K']
    nro = choice(numeros)
    palo = choice(palos)

    carta = {"numero": nro, "palo": palo}
    return carta

def carta_espaniola_al_azar():
    palos = ['oro', 'basto', 'espada', 'copa']
    
    # corregir estas dos lineas para devolver valores válidos
    nro = 0
    palo = ""

    carta = {"numero": nro, "palo": palo}
    return carta

# mirar ejemplos de ambas funciones
for n in range(20):
    carta1 = carta_poker_al_azar()
    carta2 = carta_espaniola_al_azar()
    print(carta1, carta2)


# ------------------------------------------------------------------------
# NO BORRAR O MODIFICAR LAS LINEAS QUE SIGUEN
# ------------------------------------------------------------------------
# Una vez terminada la tarea ejecutar este archivo.
# Si se ve la leyenda 'Ejercicio terminado OK' el ejercicio se considera completado.
# La instruccion "assert" de Python lanzará un error si lo que se indica a
#   continuacion es falso.
# Si usas GitHub (o similares) podes hacer una nueva rama con esta solución,
#   crear un "pull request" y solicitar revision de un tercero.

carta = carta_espaniola_al_azar()
assert type(carta['numero']) == int
assert carta['numero'] > 0
assert carta['numero'] <= 12
assert carta['palo'] in ['oro', 'basto', 'espada', 'copa']

print('Ejercicio terminado OK')

Hacer un PR con una propuesta de solución para el ejercicio 046

"""
La siguiente funcion pretende ser usada para generar
10 numeros como resultados del sorteo de quiniela.
Como podrán notar es bastante mala.
Tarea:
 - Asegurarse que los resultados sean aleatorios
 - Asegurarse que la función respete los tres parametros

"""


def generar_quiniela(minimo=0, maximo=9999, total_numeros=10):
    """ Generar varios numeros al azar definidos
        entre máximo y minimo (sin numeros duplicados) """
    return [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

numeros_quiniela = generar_quiniela()
print(f'Numeros resultantes {numeros_quiniela}')

# ------------------------------------------------------------------------
# NO BORRAR O MODIFICAR LAS LINEAS QUE SIGUEN
# ------------------------------------------------------------------------
# Una vez terminada la tarea ejecutar este archivo.
# Si se ve la leyenda 'Ejercicio terminado OK' el ejercicio se considera completado.
# La instruccion "assert" de Python lanzará un error si lo que se indica a
#   continuacion es falso.
# Si usas GitHub (o similares) podes hacer una nueva rama con esta solución,
#   crear un "pull request" y solicitar revision de un tercero.

# Prueba de resultados basicos
assert type(numeros_quiniela) == list
assert len(numeros_quiniela) == 10
for n in numeros_quiniela:
    assert type(n) == int
    assert n >= 0
    assert n <= 9999

# Pruebas con otros parametros
minimo = 90
maximo = 200
total_numeros = 7
numeros_quiniela = generar_quiniela(minimo=minimo, maximo=maximo, total_numeros=total_numeros)
assert type(numeros_quiniela) == list
assert len(numeros_quiniela) == total_numeros
for n in numeros_quiniela:
    assert type(n) == int
    assert n >= minimo
    assert n <= maximo

minimo = 0
maximo = 100
total_numeros = 3
numeros_quiniela = generar_quiniela(minimo=minimo, maximo=maximo, total_numeros=total_numeros)
assert type(numeros_quiniela) == list
assert len(numeros_quiniela) == total_numeros
for n in numeros_quiniela:
    assert type(n) == int
    assert n >= minimo
    assert n <= maximo

print('Ejercicio terminado OK')

Hacer un PR con una propuesta de solución para el ejercicio 047

"""
La funcion "detectar_escaleras" funciona bastante bien.
Toma una lista de numeros y busca escaleras ascendentes
dentro de la secuencia de numeros.
Esta funcion detecta casi todas las secuencias pero no todas
Tarea:
 - Arreglar la funcion para que pase los tests y encuentre
   todas las escaleras existentes
Nota: probablemente vas a necesitar depurar el código para
entender como funciona y por que falla.
"""

from random import randint

def tirar_dados(lados=6, veces=100):
    """ Generar aleatoriamente los tiros de un lado de cantidad
        de lados variable.
    """
    
    tiros = []
    for _ in range(veces):
        numero = randint(1, lados)
        tiros.append(numero)
    
    return tiros

def detectar_escaleras(lista_tiros):
    """ Detectar las escaleras ascendentes encontradas
        en los tiros de al menos 3 elementos """
    
    # aqui guardamos las escaleras que se consiguieron con 3 o más elementos
    escaleras_buenas = []
    # lista temporal para ir testeando todos los tiros
    escalera = []
    for tiro in lista_tiros:
        if len(escalera) == 0:
            # recien empiezo a buscar
            escalera.append(tiro)
        elif escalera[-1] == tiro - 1:
            # La escalera de prueba ya empezo y el numero actual
            # esta en escalera con el ultimo encontrado
            escalera.append(tiro)
        else:
            # este tiro no esta en escalera con el anterior
            # ver si la escalera conseguida tiene 3 o mas elementos
            # para guardarle
            if len(escalera) >= 3:
                escaleras_buenas.append(escalera)
            # como este número no sirve para la escalera anterior
            # es el que inicializa la deteccion de la nueva
            escalera = [tiro]

    return escaleras_buenas


tiros = tirar_dados(veces=10000)
escaleras = detectar_escaleras(tiros)
print(f'Escaleras encontradas {len(escaleras)}')


# ------------------------------------------------------------------------
# NO BORRAR O MODIFICAR LAS LINEAS QUE SIGUEN
# ------------------------------------------------------------------------
# Una vez terminada la tarea ejecutar este archivo.
# Si se ve la leyenda 'Ejercicio terminado OK' el ejercicio se considera completado.
# La instruccion "assert" de Python lanzará un error si lo que se indica a
#   continuacion es falso.
# Si usas GitHub (o similares) podes hacer una nueva rama con esta solución,
#   crear un "pull request" y solicitar revision de un tercero.

# Probar tiros donde yo ya conozco los resultados
tiros_test = [1, 5, 6,
              3, 4, 5,
              1, 5, 6,
              1, 2, 3,
              2, 2, 2]

escaleras = detectar_escaleras(tiros_test)
assert escaleras == [
    [3, 4, 5],
    [1, 2, 3],
]

tiros_test = [1, 5, 2, 3, 2, 1, 4, 5, 5, 1, 2, 6, 3, 3, 3, 1, 2, 5, 5, 2, 4,
              3, 4, 5,
              2, 3, 4, 5,
              1, 5, 2, 4, 2, 5, 6, 6, 5, 5, 4, 2, 6, 1, 4, 5, 3, 1, 6, 2, 2,
              1, 2, 3, 4, 5,
              3, 1, 2, 6, 5, 6, 2, 5, 1, 4, 4, 5, 4, 3, 2, 1, 1, 3, 5, 6, 1,
              1, 2, 3]

escaleras = detectar_escaleras(tiros_test)
assert escaleras == [
    [3, 4, 5],
    [2, 3, 4, 5],
    [1, 2, 3, 4, 5],
    [1, 2, 3]
]

tiros_test = [1, 2, 3]
escaleras = detectar_escaleras(tiros_test)
assert escaleras == [[1, 2, 3]]

print('Ejercicio terminado OK')

Librerías incluida: random

Python al azar: random

choice: Elegir un opción al azar de una lista.

shuffle: Mezclar una lista

Tareas

Librerías incluida: `random`

Python al azar: `random`

`choice`: Elegir un opción al azar de una lista.

`shuffle`: Mezclar una lista