100 Días de Código en Python — Día 11: Proyecto Final — Blackjack

🎯 Objetivo de aprendizaje#

• Entender las reglas del juego antes de programar.
• Convertir las reglas en una lista de requisitos, luego en un diagrama de flujo y finalmente en tareas pequeñas.

📖 Reglas del Blackjack (resumen del curso)#

• Objetivo: que tus cartas sumen lo más cerca posible de 21 sin pasarte. Si te pasas de 21, pierdes de inmediato (bust), sin importar por cuánto.
• Valores: las cartas del 2 al 10 valen su número; la J, la Q y la K valen 10; el As vale 11 o 1, lo que convenga.
• Reparto: cada jugador recibe 2 cartas. Del crupier (dealer) solo se ve la primera.
• Pedir carta: puedes pedir más cartas (hit) o plantarte (stand).
• Crupier: si tiene menos de 17, debe seguir pidiendo cartas.
• Empate: si ambos terminan con el mismo puntaje.
• Blackjack: un As y una carta de valor 10 con solo 2 cartas. Es la mejor mano posible.

📖 "Reglas de la casa" del curso (simplificaciones)#

1. La baraja es esta lista: cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]. Los tres 10 adicionales representan J, Q y K, así que el 10 es 4 veces más probable que las demás cartas.
2. El As empieza valiendo 11 y pasa a valer 1 si el jugador se pasa de 21.
3. Baraja infinita: las cartas no se retiran después de salir. En un casino real sí se retiran, y por eso existe el "conteo de cartas".

📝 Ejercicio original del curso: pistas 1 a 3 (niveles de dificultad)#

El curso propone elegir la dificultad según cuántas pistas se usen, como en un videojuego:

El archivo inicial del curso (con las pistas escritas, el diagrama en PDF y el arte ASCII) no está incluido entre los materiales suministrados. Esta adaptación reconstruye las pistas 4 a 13 a partir de las explicaciones de la solución.

🔍 Antes de programar (actividad central de esta fase)#

1. Juega Blackjack en línea (sin dinero) o con una baraja física en parejas, hasta entender las reglas.
2. Escribe tu propia lista de requisitos: ¿qué debe hacer el programa, paso a paso?
3. Dibuja tu diagrama de flujo. Debe mostrar: el reparto inicial, el ciclo del jugador, el ciclo del crupier y la comparación final.

flowchart TD
    A([Inicio]) --> B[Repartir 2 cartas a cada uno]
    B --> C[Calcular puntajes]
    C --> D{¿Blackjack de alguno<br/>o jugador > 21?}
    D -- Sí --> G
    D -- No --> E{¿El jugador pide carta?}
    E -- Sí --> F[Dar carta al jugador] --> C
    E -- No --> G[Turno del crupier:<br/>pedir mientras tenga < 17]
    G --> H[Comparar puntajes]
    H --> I([Mostrar resultado])

(Este diagrama es una versión propia de esta adaptación; el del curso viene en el PDF de la pista 3, que no está incluido.)

🎯 Objetivo de aprendizaje#

• Crear una función que devuelva una carta al azar.
• Agregar elementos a una lista con append, entendiendo por qué += falla con un solo número.

📝 Ejercicio original del curso: pista 4#

Enunciado: crea deal_card(), que devuelve una carta al azar de la lista cards. Conceptos: random.choice (Día 4), return (Día 10) y docstring.

📝 Ejercicio original del curso: pista 5#

Enunciado: reparte 2 cartas al usuario y 2 al computador, partiendo de las listas vacías user_cards = [] y computer_cards = [].

Técnica del curso: for _ in range(2):. El guion bajo _ indica que no se usa la variable del bucle: solo se quiere repetir dos veces.

Refactorización del curso: en lugar de new_card = deal_card() y después user_cards.append(new_card), se puede escribir directamente user_cards.append(deal_card()). Ojo con los tres paréntesis al final.

⚠️ El error clásico: += con listas (lo muestra el curso)#

user_cards += deal_card()     # ❌ TypeError: 'int' object is not iterable
user_cards.append(deal_card())  # ✅
user_cards += [deal_card()]   # ✅ también, porque ahora es una lista

Por qué: con listas, += equivale a extend(), que espera otra lista (algo "iterable"), no un número suelto (verificado).

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: llama deal_card() 20 veces e imprime los resultados. ¿Aparece más el 10? ¿Por qué?
• 🟡 Reto 2: crea deal_hand(n), que devuelve una lista con n cartas.
• 🟠 Reto 3: simula 1000 cartas y cuenta cuántas veces sale cada valor con un diccionario (Día 9). ¿Se acerca el 10 a 4/13 ≈ 30.8 %?
• 🔴 Reto 4: diseña una versión con baraja finita: una lista de 52 cartas de la que se retira cada carta repartida. (Investiga random.shuffle y lista.pop().) ¿Qué cambia en las probabilidades?

🎯 Objetivo de aprendizaje#

• Crear calculate_score(cards) con sum().
• Representar un Blackjack con un valor especial (0).
• Ajustar el valor del As de 11 a 1 con remove() y append().

📝 Ejercicio original del curso: pistas 6, 7 y 8#

Pista 6: calculate_score(cards) devuelve la suma de las cartas con sum(cards).

Pista 7: detectar un Blackjack. Una mano de 2 cartas con un As (11) y un 10. El curso muestra dos formas:

Si hay Blackjack, la función devuelve 0, un valor especial que el resto del programa interpreta como "Blackjack".

Pista 8: el As. Si hay un 11 en la mano y la suma pasa de 21, se reemplaza el 11 por un 1 con cards.remove(11) y cards.append(1).

🔍 Antes de programar#

• Calcula a mano: [11, 10], [5, 6, 10], [11, 5, 9], [11, 11], [11, 11, 10].
• ¿Qué debería pasar con dos Ases que hacen pasar la mano de 21?

🛠️ Nota técnica (verificada): la pista 8 usa un if, así que reemplaza solo un As. Con [11, 11, 10] la versión del curso devuelve 22 (se pasa), cuando la mano podría valer 12 (1 + 1 + 10). La corrección es cambiar if por while: "mientras haya un 11 y la suma pase de 21, cambia un 11 por 1".

💡 Diseño con "valores especiales": usar 0 para indicar un Blackjack funciona, pero obliga a recordarlo en todo el programa. Por ejemplo, el crupier debe pedir cartas "si tiene menos de 17 y no es 0". Discute: ¿qué alternativas habría? Por ejemplo, una función aparte es_blackjack(cards) que devuelva True o False.

⚠️ Errores frecuentes#

• Olvidar len(cards) == 2: una mano de tres cartas que suma 21 (por ejemplo [5, 6, 10]) no es Blackjack.
• remove sin verificar: cards.remove(11) produce ValueError si no hay ningún 11 en la lista. Por eso la condición 11 in cards es necesaria.
• La función modifica la lista original: calculate_score cambia la lista cards que recibe (el 11 pasa a ser 1). Por eso, al mostrar la mano, el jugador verá un 1. ¿Es aceptable? Discútelo.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: escribe una tabla de pruebas de calculate_score con 8 manos y el resultado esperado, antes de programar.
• 🟡 Reto 2: implementa la corrección con while y verifica [11, 11, 10] → 12.
• 🟠 Reto 3: escribe es_blackjack(cards) (devuelve un booleano) y una versión de calculate_score que no use el 0 especial.
• 🔴 Reto 4: escribe una versión de calculate_score que no modifique la lista original: cuenta los Ases y resta 10 por cada uno mientras haga falta.

🎯 Objetivo de aprendizaje#

• Ordenar el código: las funciones se definen antes de llamarlas.
• Controlar el juego con la bandera is_game_over dentro de un while.

📝 Ejercicio original del curso: pistas 9, 10 y 11#

Pista 9: calcula user_score y computer_score. Si alguno tiene Blackjack (0) o el usuario pasa de 21, el juego termina: is_game_over = True. Pista 10: si el juego no ha terminado, pregunta al usuario: 'y' para otra carta o 'n' para plantarse. Con 'y', dale otra carta; con 'n', is_game_over = True. Pista 11: repite la pista 9 después de cada carta nueva, hasta que termine el juego. Solución: un while not is_game_over:.

Buenas prácticas que muestra el curso:

• Mover la definición de calculate_score arriba, antes del código que la llama (Día 6).
• Agregar docstrings a cada función (Día 10).
• Probar después de cada pista. El curso imprime las cartas y el puntaje del usuario, y solo la primera carta del computador (computer_cards[0]), para comprobar que todo va bien.

🔍 Antes de programar#

• ¿Qué líneas deben ir dentro del while del jugador? ¿Cuáles fuera?
• ¿Qué pasa si el usuario escribe Y en mayúscula? (Día 3: .lower().)

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: muestra en cada ronda las cartas del jugador separadas por comas (10, 5, 6) en lugar de la lista con corchetes.
• 🟡 Reto 2: valida la respuesta: solo acepta y o n, y vuelve a preguntar si es otra cosa.
• 🟠 Reto 3: agrega un aviso cuando el puntaje sea 17 o más: "Cuidado: estás cerca de 21".
• 🔴 Reto 4: calcula, antes de preguntar, la probabilidad de pasarse si pides otra carta (cuántas cartas de la lista cards te harían superar 21, dividido entre 13) y muéstrala como ayuda al jugador.

🎯 Objetivo de aprendizaje#

• Programar la estrategia del crupier con un while.
• Evitar variables "posiblemente no definidas" y el sombreado de nombres.
• Ordenar correctamente las condiciones de compare().

📝 Ejercicio original del curso: pista 12, el crupier#

Enunciado: cuando el usuario termina, el computador pide cartas mientras su puntaje sea menor que 17 y no tenga Blackjack:

while computer_score != 0 and computer_score < 17:
    computer_cards.append(deal_card())
    computer_score = calculate_score(computer_cards)

Advertencia del editor que el curso resuelve: "Name 'computer_score' can be undefined". La variable solo se crea dentro del while del jugador; si ese bucle no se ejecutara, no existiría. Solución del curso: inicializar user_score = -1 y computer_score = -1 al inicio. No se usa 0, porque 0 significa Blackjack; un número negativo delata un error si algo sale mal.

📝 Ejercicio original del curso: pista 13, compare#

Enunciado: compare(u_score, c_score) devuelve un mensaje de resultado: empate, Blackjack de alguno, alguien se pasó, o quién tiene más puntos.

Sombreado de nombres (el curso lo corrige): si el parámetro se llama igual que la variable global (user_score), el editor advierte "Shadows name from outer scope". El curso usa Refactor → Rename para cambiarlos a u_score y c_score. (El ámbito o scope se estudia a fondo en el Día 12.)

El orden de las condiciones importa (Día 3): if/elif se evalúan de arriba hacia abajo y se detienen en la primera verdadera.

🛠️ Nota técnica (verificada): la transcripción acelera esta parte ("vamos añadiendo todas estas otras condiciones"). Si la primera condición es "u_score == c_score → Empate", una mano en la que ambos se pasan con 22 se declara empate, cuando el jugador ya había perdido al pasarse. La primera comprobación debe ser "el jugador se pasó" o "ambos se pasaron → pierdes".

Orden recomendado:

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: muestra la mano final de ambos jugadores con sus puntajes antes del resultado.
• 🟡 Reto 2: escribe una prueba por cada fila de la tabla de compare, llamando la función con valores fijos, sin jugar.
• 🟠 Reto 3: haz que el crupier no pida cartas si el jugador ya se pasó. ¿Cambia algún resultado? ¿Por qué es más realista?
• 🔴 Reto 4: en algunos casinos el crupier también pide carta con un 17 "suave" (17 con un As que vale 11). ¿Cómo lo detectarías con la lista de cartas? Implementa esta variante.

📝 Ejercicio original del curso: reiniciar#

Enunciado: pregunta "¿Quieres jugar una partida de Blackjack? y/n". Mientras la respuesta sea y: limpia la pantalla (print("\n" * 20)) y llama play_game().

Técnica del curso: todo el juego (desde las listas vacías hasta la comparación) queda dentro de una función play_game(), que se llama desde un while:

while input("¿Quieres jugar una partida de Blackjack? Escribe 'y' o 'n': ") == "y":
    print("\n" * 20)
    play_game()

Observa que la llamada a input va dentro de la condición del while: su salida reemplaza la llamada (Día 10) y se compara con "y" en cada vuelta.

El logo: from art import logo y print(logo) al inicio de play_game(). El archivo art.py no está incluido entre los materiales suministrados: crea tu propio logo.

Requisitos funcionales#

1. Mostrar el logo y preguntar si se quiere jugar.
2. Repartir 2 cartas a cada uno y mostrar la mano y el puntaje del jugador, y solo la primera carta del crupier.
3. Terminar de inmediato si hay un Blackjack o si el jugador se pasa.
4. Permitir pedir cartas hasta plantarse o pasarse.
5. Hacer que el crupier pida cartas mientras tenga menos de 17 (y no tenga Blackjack).
6. Mostrar ambas manos finales y el resultado.
7. Preguntar si se quiere jugar otra vez.

Pruebas (con manos fijas)#

Para probar, reemplaza temporalmente el reparto aleatorio por listas fijas, por ejemplo user_cards = [11, 10].

🧪 Prueba y depuración#

Este fragmento tiene cuatro errores:

def calculate_score(cards):
    if sum(cards) == 21 and len(cards) == 2:
        return 0
    if 11 in cards and sum(cards) > 21:
        cards.remove(11)
        cards.append(1)
    return sum(cards)

def play_game():
    user_cards = []
    computer_cards = []
    is_game_over = False
    for _ in range(2):
        user_cards += deal_card()
        computer_cards.append(deal_card())
    while not is_game_over:
        user_score = calculate_score(user_cards)
        computer_score = calculate_score(computer_cards)
        if user_score == 0 or computer_score == 0 or user_score > 21:
            is_game_over = True
        else:
            if input("¿Otra carta? y/n: ") == "y":
                user_cards.append(deal_card())
            else:
                is_game_over = True
    while computer_score < 17:
        computer_cards.append(deal_card())
        computer_score = calculate_score(computer_cards)

(Pistas: un if que debería ser while, un += con un número, un crupier que pide cartas aunque tenga Blackjack y una función que nunca se define en este fragmento.)

⭐ Extensión del proyecto#

• Mostrar las cartas con su nombre (As, J, Q, K) y un símbolo de palo (♠ ♥ ♦ ♣), guardando el valor y el nombre por separado.
• Implementar la baraja finita (Reto 4 de la Fase 2).
• Contar las victorias, derrotas y empates de la sesión.

Reglas#

• Baraja española de 40 cartas: del 1 al 7, más la sota, el caballo y el rey, en 4 palos.
• Valores: del 1 al 7, su número; las figuras (sota, caballo y rey) valen 0.5.
• Objetivo: acercarse a 7.5 sin pasarse.
• La banca pide cartas mientras tenga menos de 5.5 (regla de esta adaptación; hay variantes regionales).

Requisitos#

1. Una lista cartas = [1, 2, 3, 4, 5, 6, 7, 0.5, 0.5, 0.5] (baraja infinita, como en el curso).
2. Reutilizar la estructura del Blackjack: repartir(), calcular_puntaje(), comparar(), turno del jugador y turno de la banca.
3. Adaptar los valores: trabajar con float y comparar con 7.5.
4. Cada partida empieza con una carta por jugador, no con dos.

Pregunta de análisis#

¿Qué partes del código del Blackjack pudiste reutilizar sin cambios? ¿Cuáles tuviste que modificar? ¿Qué te dice eso sobre la calidad del diseño de tus funciones?

Casos de prueba#

Situación problema#

Queremos analizar qué tan buena es una estrategia de juego. Para eso, el programa debe llevar registros y resumir los resultados de muchas partidas.

Pregunta orientadora#

¿Cómo convertir un juego en una herramienta que registra datos y ayuda a sacar conclusiones?

Requerimientos#

1. El jugador empieza con 100 puntos virtuales. Antes de cada mano, elige cuántos arriesga, validando que sea un número entre 1 y su saldo.
2. Si gana, suma los puntos arriesgados; si gana con Blackjack, suma 1.5 veces lo arriesgado; si pierde, los resta; si empata, no hay cambio.
3. Un diccionario estadisticas = {"victorias": 0, "derrotas": 0, "empates": 0, "blackjacks": 0} que se actualiza después de cada mano.
4. El juego termina si el saldo llega a 0 o si el usuario decide salir.
5. Resumen final: manos jugadas, porcentaje de victorias con un decimal, saldo final y mejor racha de victorias seguidas.
6. Modo simulación: una función jugador_automatico(puntaje) que decide pedir carta si el puntaje es menor que un umbral (por ejemplo 16). Simula 1000 manos con umbrales de 12, 15 y 17, y compara el porcentaje de victorias.
7. Funciones con return, docstrings y las correcciones de las Fases 3 y 5.

Entregables#

• Código funcional.
• Tabla de resultados de la simulación con los 3 umbrales.
• Conclusión escrita: ¿qué umbral funcionó mejor en tus simulaciones?
• Reflexión: ¿por qué, a largo plazo, la casa siempre tiene ventaja en los juegos de azar?

Criterios técnicos#

• Sin errores con las entradas de la tabla de pruebas del proyecto del día.
• Las estadísticas suman el total de manos jugadas.
• La simulación usa exactamente la misma lógica que el juego interactivo: se reutilizan funciones, no se copia código.