Randomizar preguntas y opciones de respuesta

[nanotime]

Estoy trabado en otro de esos juegos de práctica que me gusta hacer para ver como manejo algunas cosas. Este en teoría se me hacía simple, un juego que lanza preguntas de lógica y 3 posibles respuestas, el usuario elige una y pasa a la siguiente pregunta. Luego de 5 preguntas se muestran las preguntas con las respuestas correctas.

Mi problema es que, anduve tratando de hacer que las preguntas se lanzaran aleatoriamente junto con sus respectivas opciones de respuesta... cosa que al final ha terminado de enredarme completamente.

Antes lo que hacía era:

pregunta1 = "pregunta"
respuesta1 = ["respuestas"...]
print pregunta 1, respuesta1

y comprobaba.

Pero eso no me sirve si quiero randomizar. Estoy seguro de que debe ser con diccionarios pero no logro hacerme la idea, no logro ver la respuesta según entiendo los diccionarios relacionan un valor a una clave, pero solo a una ¿Entonces como le doy más de una opción?

No quiero que me hagan el programa, pero me gustaría ver ideas a ver si me refresco un poco y le consigo la vuelta al programa jaja

Gracias como siempre por adelantado.

[zz_sioux]

deberías estudiar el modulo random, y los métodos de los diccionarios,

import random

a = {'a':1,'b':2,'c':3,'d':4,'e':5}

claves = a.keys() # devuelve las claves

azar = random.choice(claves) #ya que necesita una secuencia

print a[azar]

############

no necesariamente una sola clave puedes hacer

diccionario = {'clave1':[n11,n12,n13],'clave2':[n21,n22,n23]}
y luego eliges con choice

[nanotime]

Ok voy entendiendo, no es por joder pero no conocerás algún artículo que hable al respecto? Si es en español genial, no se mucho inglés pero ahí veré. Gracias por responder

[zz_sioux]

Chequea la documentación que viene con el instalador de python, ahí están los módulos, sus clases y métodos, y revisa también un libro llamado "python para todos" http://mundogeek.net/tutorial-python/

[nanotime]

Ok perfecto estuve leyendo y más o menos entiendo el chiste de todo esto. La cosa es que cuando imprimo me imprime las claves pero no el valor... osea, me imprime las opciones pero no la pregunta xD...

No manejo bien los diccionarios aunque ya se como randomizarlos de cierta forma, este es el código que escribí para probar un poco:

Código Python:

import random
 
diccionario = {'Cuanto es 1+1':('a: 2','b: 5','c: 8'),'Tu mama te quiere?':['a: si', 'b: no', 'c: tal vez']}
claves = diccionario.keys()
azar = random.choice(claves)
print diccionario[azar]
 

una total tontería pero solo necesito entender mejor el funcionamiento.

[razpeitia]

Iniciado por nanotime

Ok perfecto estuve leyendo y más o menos entiendo el chiste de todo esto. La cosa es que cuando imprimo me imprime las claves pero no el valor... osea, me imprime las opciones pero no la pregunta xD...

No manejo bien los diccionarios aunque ya se como randomizarlos de cierta forma, este es el código que escribí para probar un poco:

Código Python:

import random
 
diccionario = {'Cuanto es 1+1':('a: 2','b: 5','c: 8'),'Tu mama te quiere?':['a: si', 'b: no', 'c: tal vez']}
claves = diccionario.keys()
azar = random.choice(claves)
print diccionario[azar]
 

una total tontería pero solo necesito entender mejor el funcionamiento.

Definitivamente, parece que lo estas copiando y pegando código (lo cual es una mala practica). Intenta leer sobre diccionarios por la verdad estas muy cerca de lograr lo que buscas.

[nanotime]

Sip copié el código para probar como funcionaba y traté algunas cosas pero no consigo mucho sobre diccionarios, o al menos no se como buscar correctamente. Algunas cosas en python para todos y algo en la wiki de python. Tocará buscar un poco más.

[zz_sioux]

La confusión puede venir en que el método choice no elige un clave/valor del diccionario porque solo actúa con una secuencia, entonces allí esta el método keys() que nos devuelve todas las claves de un diccionario en una lista, luego a esta lista le aplicas el método choice, y luego debes buscar con la clave al azar su valor en el dic, asi

Código Python:

import random
 
diccionario = {'Cuanto es 1+1':('a: 2','b: 5','c: 8'),'Tu mama te quiere?':['a: si', 'b: no', 'c: tal vez']}
 
claves = diccionario.keys()  # Ahora claves tiene el valor = ['Cuanto es 1+1','Tu mama te quiere?']
 
clavealazar = random.choice(claves) # clavealazar tendrá alguna de las dos claves, por ejem 'Tu mama te quiere?'
 
print diccionario[clavealazar]
 
>>>  ['a: si', 'b: no', 'c: tal vez']
 

[nanotime]

Claro, llevo leyendo un poco algunas cosas pero lo que necesito no es solo randomizar e imprimir las opciones sino el paquete de preguntas + opciones. Conseguí algo que quizá pueda usar, iteritems() pero necesito seguir leyendo a ver que mas puedo implementar.

La idea es que me lance algo como:

Tu mamá te quiere?

a: si
b: no
c: tal vez

elija una de las opciones a/b/c:

Pero mi problema como tal es lograr imprimir tanto la clave como el valor de forma que concuerden y que en cada corrida el orden de las preguntas/opciones sea aleatorio.

[razpeitia]

Esto se puede modelar muy bien con clases.

De hecho solo por diversión implemente las clases Opcion, Pregunta, Opciones y Preguntas.

Si hay que escribir mucho código, pero creo que mucho te lo puede autogenerar el editor.

Código Python:

from random import shuffle
 
class Opcion:
    def __init__(self, opcion, respuesta, es_valido=False):
        self.opcion = opcion
        self.respuesta = respuesta
        self.es_valido = es_valido
 
    def __eq__(self, other):
        if self is other:
            return True
        if other is None:
            return False
        if not isinstance(other, Opcion):
            return False
        return other.opcion == self.opcion
 
    def __cmp__(self, other):
        if self.__eq__(other):
            return 0
        if not isinstance(other, Opcion):
            return 1
        return cmp(other.opcion, self.opcion)
 
    def __hash__(self):
        return hash(self.opcion)
 
    def __str__(self):
        return "%s) %s" % (self.opcion, self.respuesta)
 
class Opciones:
    def __init__(self):
        self.opciones = set()
 
    def agregar(self, opcion):
        self.opciones.add(opcion)
 
    def borrar(self, opcion):
        self.opciones.pop(opcion)
 
    def limpiar(self):
        self.opciones = set()
 
    def __iter__(self):
        for opcion in self.opciones:
            yield opcion
 
    def __str__(self):
        return '\n'.join(str(opcion) for opcion in sorted(self.opciones, reverse=True))
            
 
class Pregunta:
    def __init__(self, pregunta, opciones):
        self.pregunta = pregunta
        self.opciones = opciones
 
    def es_correcto(self, opcion):
        for opcion_ in self.opciones:
            if opcion == opcion_.opcion and opcion_.es_valido:
                return True
        return False
 
    def __str__(self):
        return "%s\n%s" % (self.pregunta, self.opciones)
 
class Preguntas:
    def __init__(self):
        self.preguntas = set()
 
    def agregar(self, pregunta):
        self.preguntas.add(pregunta)
 
    def borrar(self, pregunta):
        self.preguntas.pop(pregunta)
 
    def limpiar(self):
        self.preguntas = set()
 
    def __iter__(self):
        aleatorio = sorted(self.preguntas)
        shuffle(aleatorio)
        for pregunta in aleatorio:
            yield pregunta
        
    def __str__(self):
        return '\n'.join(pregunta for pregunta in sorted(self.preguntas))
 
preguntas = Preguntas()
 
opciones = Opciones()
opciones.agregar(Opcion("a", "Azul", es_valido=True))
opciones.agregar(Opcion("b", "Verde"))
opciones.agregar(Opcion("c", "Rojo"))
pregunta = Pregunta("De que color es el cielo?", opciones)
preguntas.agregar(pregunta)
 
opciones = Opciones()
opciones.agregar(Opcion("a", "6"))
opciones.agregar(Opcion("b", "5", es_valido=True))
opciones.agregar(Opcion("c", "4"))
pregunta = Pregunta("Cuantos dedos regularmente tiene una mano?", opciones)
preguntas.agregar(pregunta)
 
opciones = Opciones()
opciones.agregar(Opcion("a", "No"))
opciones.agregar(Opcion("b", "Si", es_valido=True))
opciones.agregar(Opcion("c", "Solo en el dia"))
pregunta = Pregunta("Es el sol una estrella?", opciones)
preguntas.agregar(pregunta)
 
for pregunta in preguntas:
    print pregunta
    respuesta = raw_input()
    if pregunta.es_correcto(respuesta):
        print "Correcto"
    else:
        print "Incorrecto"
 

[nanotime]

Wow, queda bastante claro, o bueno entendible. No comprendo bien que hace cada una de las funciones en las clases porque solo conocía __init__ pero ahora toca investigar eso.

Tampoco conocía la palabra reservada yield ni atributos como add y pop, imagino que debe existir documentación para eso así que me pongo a buscar. De verdad gracias.

[nanotime]

Hay algunas cosas de las cuales no logro conseguir documentación, esas funciones __hash__ __eq__ __cmp__ y __str__ quizá porque no sepa como buscarlas exactamente... al menos str puedo comprenderla pero las demás no sé que hacen exactamente; alguien puede facilitarme una lista o cualquier cosa que aclare un poco la funcionalidad de (valga la redundancia) esas funciones?

[razpeitia]

__hash__, __eq__, __cmp__.

Es muy raro que algo no este documentado en python.

[nanotime]

No no, no es que no esté documentado, es que no se como buscarlo, eso es todo u.u