1.1-Modelando una Entidad

Las Entidades son sustantivos con un importante peso referencial dentro de la narrativa propuesta. A veces, las Entidades pueden estar cuantificadas: 4 manzanas, 3 perros, etc. Otra veces no se suministra ninguna cuantificación aunque suelen aparecer en plural. Normalmente, las entidades que buscamos modelar son aquellas que proponen contenido a la historia que se está contando. En programación, las Entidades son una abstracción del mundo real y permiten modelar componentes del modelo de datos.

1.2-Modelando Entidades

Dentro de una narrativa podemos tener varias Entidades. Normalmente en el contexto de PASAYO trabajaremos con dos Entidades, por eso es importante generar la experiencia de identificarlas y darles cuerpo en el formato de una cajita.

1.3-Asignando valores

Ahora que estamos familiarizadas/os con la representación de Entidades en el formato de cajitas, es hora de aprender a guardar cosas allí. Para ello, propondremos una variante en la narrativa, que cuantifique cada una de las entidades. Esto nos permitará utilizar la flecha para asignar esas cantidades en las cajitas y más importante: comenzamos a codificar!

#CAJITAS
cajitaAMIGOS = 3
cajitaZOMBIS = 5
		

1.4-Operaciones

En este punto, ya tenemos claro que las entidades pueden representarse como cajitas donde se almacenan valores. Ahora será intersante comprobar que es posible realizar operaciones con las cajitas. En esta actividad vamos a sumar dos cajitas. Para ello es importante utilizar una narrativa que transmita el sentido aditivo de la operación.

#CAJITAS
cajitaAMdIGOS = 3
cajitaZOMBIS = 5

#OPERACIÓN
cajitaSUMA = cajitaAMIGOS + cajitaZOMBIS
		

1.5-Entrada/Salida

Quizá uno de los aspectos más particulares de la programación textual es la incorporación de la interactividad con la figura del "usuario" del programa. En lugar de intentar explicar discursivamente qué es un usuario, en PASAYO Textual preferimos dejarle ese trabajo a la narrativa. Las narrativas que utilizan entrada/Salida pueden incoporar un personaje que visualize la escena. De esa manera, una vez que se haya escrito el código, se podrá teatralizar a este personaje observador y resultará natural la idea de que existe un usuario del programa que acabamos de desarrollar.

Por otro lado, PASAYO Textual utiliza algunos métodos que plantean el uso de la entrada/salida en términos didácticos. Esos métodos se describen a continuación:

        #CAJITAS
        cajitaAMdIGOS = 3
        cajitaZOMBIS = preguntarCajita("Señor jardinero ¿cuántos zombies vió en el parque?")

        #OPERACIÓN
        cajitaSUMA = cajitaAMIGOS + cajitaZOMBIS

        #SALIDA
        mostrarCajita(cajitaSUMA)
        

2.1-IF

Para introducir el concepto de alternativas, utilizaremos una narrativa nueva.

  #CAJITAS
  cajitaMARCIANOS = preguntarCajita("SEÑOR PORTERO ¿CUÁNTAS MARCIANOS VIÓ?")
  cajitaMAESTRAS = 8

  #ALTERNATIVA
  if (cajitaMAESTRAS > cajitaMAESTRAS ):
  	mostrarMensaje("GANARON LAS MAESTRAS!")

      

2.2-IF/ELSE

Ahora, vamos a presentar la sección else de la estructura alternativa.

  #CAJITAS
  cajitaMARCIANOS = preguntarCajita("SEÑOR PORTERO ¿CUÁNTAS MARCIANOS VIÓ?")
  cajitaMAESTRAS = 8

  #ALTERNATIVA
  if (cajitaMAESTRAS > cajitaMAESTRAS ):
  	mostrarMensaje("GANARON LAS MAESTRAS!")
  else: 
  	mostrarMensaje("GANARON LOS MARCIANOS!")

      

2.3-SECUENCIALES

Vamos a reforzar las alternativas en un contexto de programación secuencial.

 ##############################################################
# cajitas 
cajitaMARCIANOAZUL = pedirNUMERO ("SEÑOR PORTERO CUANTOS MARCIANAOS AZULES VIO")
cajitaMARCIANOVERDE = 5
cajitaMAESTRAS = pedirNUMERO ("SEÑOR PORTERO CUANTOS MAESTRAS VIO")
cajitaMAESTROS = 10
######################################################
# cajitas 
cajitaMALOS = cajitaMARCIANOAZUL+cajitaMARCIANOVERDE
cajitaBUENOS = cajitaMAESTRAS + cajitaMAESTROS

####################################################
if (cajitaBUENOS > cajitaMALOS):
  mostrarMensaje ("GANARON LAS MAESTRAS")
else:
  mostrarMensaje ("GANARON LOS MARCIANOS")


      

3.1- Tipo de dato lógico

Antes de comenzar con preguntas divertidas, es importante presentar el concepto de valor o tipo de dato lógico. Un tipo lógico es una cajita que adentro puede contener "VERDADERO" o "FALSO", pero nunca otra cosa. Para poder preguntar cosas al protagonista o expectador de la narrativa utilizaremos un nuevo método denominado pedirVERDADEROFALSO(mensaje). que retorna "VERDADERO" o "FALSO" en función del botón que se escoja.

Otro factor a considerar es que en esta actividad se incorpora un nuevo operador, el operador de igualdad ==. Este operador de igualdad puede ser presentado inicialmente como el operador "tiene", es decir, una cajita tiene "VERDADERO" o tiene "FALSO".

#CAJITAS 
cajitaTIENEHAMBRE = pedirVERDADEROFALSO ("Buba ¿tenes mucha hambre?")

######################################################
#PREGUNTA
if   (cajitaTIENEHAMBRE=="VERDADERO"):
  mostrarMensaje("TE VOY A DAR PAN CON DULCE DE LECHE")
else:   mostrarMensaje ("A JUGAR!") 

      

3.2- Operador and

Para introducir el concepto de expresión, podemos utilizar una narrativa donde se hagan dos preguntas al protagonista. Una narrativa que funciona muy bien es el Detector De... vampiros, momias, princesas, animales, etc. Podemos pedir un par de características del personaje y si son verdaderas ambas entonces el detector retorna un mensaje acorde.

#CAJITAS 
cajitaTIENECOLMILLOS = pedirVERDADEROFALSO ("TENES COLMILLOS?")
cajitaCHUPASANGRE = pedirVERDADEROFALSO ("TE GUSTA CHUPAR SANGRE?")
######################################################

#PREGUNTA
if   (cajitaCHUPASANGRE=="VERDADERO" and cajitaTIENECOLMILLOS == "VERDADERO"):
  mostrarMensaje("SOS UN VAMPIRO!!")
else:   mostrarMensaje ("NO SERIAS UN VAMPIRO, QUE BUENO!") 

      

4.1- Modularizando un saludo

Vamos a proponer el diseño de un módulo que simplemente lanzará un saludo por pantalla. Es importante apoyarnos en el uso del lenguaje visual para comenzar a adquirir habilidades de diseño modular.

#############################################################
#modulo
def saludo ():
  mostrarMensaje("Hola soy Buba!")
  
####################################################
#invocación
saludo()
####################################################
      

4.2- Invocando con parámetros

Introduciremos ahora el uso de Módulos con parámetros. Los parámetros permiten suministrar datos al módulo, y de esa forma, podemos rehusarlos en diversas situaciones.

#############################################################
def sumarCajitas (cajitaUNO, cajitaDOS):
  return (cajitaUNO + cajitaDOS)
  

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

cajitaINVITADAS = 7
cajitaINVITADOS = 12

cajitaSUMA = sumarCajitas (cajitaINVITADAS , cajitaINVITADOS)


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

mostrarCajita (cajitaSUMA)
####################################################