Pygame!

Dra Elisa Schaeffer
Lab de lenguajes de progra    Jueves V1

Bueno sigamos con lo que hasta el momento teniamos de nuestra animacion con pygame.

Lo que realizaremos sera que en vez de que Tux se mueva con el cursor del mouse, se mueva a donde nosotros demos click. Esto es muy sencillo en unos cuantos pasos lo realizaremos

Lo que hay que hacer es llevar la línea de código

mx,my = pygame.mouse.get_pos()  que esta dentro del while, hay que colocarlo fuera de éste. Y si gustan pueden borrar la línea print mx  eso ya es de uds

recuerden que esta linea es la detecta la posicion en la que se encuentra el mouse en nuestra ventana.

Ahora lo que sigue por hacer es agregar esa misma linea de codigo en el elif que tiene el evento de que al hacer click se reproduce un sonido.
elif cerrar.type == MOUSEBUTTONDOWN:
            salto.play()   

Bueno agregamos la linea dentro de este elif, y con esto al hacer click en la pantalla Tux se movera a donde nosotros agamos click.

Ahora ejecutemos nuestro programa y al dar click en la pantalla el tux mas pequeño se movera a donde demos click

Esto puede ayudar mucho cuando se quiere programar juegos, es una buena instruccion


Ahora lo que haremos sera colocar una imagen como fondo, se hace de la siguiente manera:

primero cargamos la imagen como la de Tux con la siguiente instruccion que debe ir donde cargamos la inagen de Tux.

fondo = pygame.image.load("bg.jpg")  fondo asi fue como llame a la variable, pygame.image.load es la instruccion para cargar la imagen ("bg.jpg") es la imagen que utilizare como fondo, uds pueden elegir la imagen que deseen pero recuerden que debe estar en la misma carpeta y al cargarla deben escribir la extension tambien

Ahora hay que hacer que la imagen forme parte de la pantalla esto con la instruccion siguiente, debe  de ir despues del while con las demas instrucciones donde hicimos a Tux parte de la pantalla.

ventana.blit(fondo,(0,0))    ventana la variable que crea nuestra ventana,  .blit es para que forme parte de nuestra ventana,  fondo es la variable que carga la imagen de fondo (0,0)  son las coordenandas para que aparezca en la esquina superior izquierda.

Al tener nuestra imagen de fondo ya no necesitamos que este cambiando de color la pantalla,  removemos las lineas  r = 0   y lo siguiente

if r == 255:   
        r1 = -1
       
    elif r == 0:
        r1 = 1
       
    r = r + r1

Y la instruccion con la que se llena el fondo es decir

ventana.fill((r,0,0))  la cambiamos por   ventana.fill(negro)   negro es una variable que habiamos creado anteriormente con los valores 0,0,0.

Ahora para que nuestro fondo ocupe la pantalla completa lo que debemos hacer es editarla a escala como hicimos con Tux anteriormente, esto es poniendo la siguiente linea debajo de donde cargamos la imagen de nuestro fondo

fondo = pygame.transform.scale(fondo,tamano)   fondo que es la variable para nuestra imagen de fondo ,  pygame.transform.scale  para poner a escala la imagen,  fondo que es la variable que carga la imagen y tamano que son las medidas de nuestra ventana que ya hemos definido antes.

Ahora ejecutamos el programa y nos quedara algo parecido a lo siguiente:

 

Esto seria todo espero sea de gran ayuda. Saludos a todos

Fortran 90

Dra Elisa Schaeffer
Lab de lenguajes de programacion

En pasados posts sobre Fortran 90 se me olvido mencionar de donde habia consultado para obtenr  la informacion para hablar sobre este lenguaje y realizar los programas. Los links son los siguientes

http://fismat.umich.mx/mn1/tutor_fort/index.html
Este tutorial es online, viene separado por secciones explicando desde lo basico sobre Fortran y sobre cada sentencia hasta subprogramas, abrir archivos, etc

http://manuales.astalaweb.com/_inicio/Marco.asp?dir=http://www.sisoft.ucm.es/Manuales/Fort90.pdf
Este es un tutorial en pdf, aqui entran y dan clik en la liga para descargar, este tutorial viene un opco mas detallado sobre cada sentencia, es sencillo de comprender, y es de mucha ayuda para cuando necesiten consultar algo y lo puedan tener a la mano

http://www.cesga.es/telecursos/F90/
Este es otro tutorial, aqui viene un poco menos de informacion pero contiene lo esencial para empezar a trabajar con Fortran

espero les sea de ayuda, saludos!

Fortran 90

Dra Elisa Schaeffer
Lab de lenguajes de programacion     Jueves V1

Serie de Fibonacci en Fortran 90

  

Bueno explicare el codigo...

El programa se empieza con la linea program fibonacci, siempre se debe empezar con esta linea asignandole el nombre que se desee

Declare las variables como enteros con la instruccion integer

nmax le di un valor de 10, s y a las inicialize en 1

cree un ciclo Do, el cual inicia en 1 y llegara a nmax es decir a 10

En cada vuelta del ciclo se imprimira la posicion en la que va el elemento y el numero de la serie de fibonacci

La variable aux tomara el valor de s en cada vuelta del Do

s en cada ciclo sera igual a la suma de s + a (s es por siguiente y a por anterior)

al realizar la suma, ahora a tomara el valor de aux, que era el valor anterior de s

cerramos el Do con end do al igual que debemos cerrar el programa con end program fibonacci

Fortran 90

Para Dra. Schaeffer
Lab de lenguajes de programacion   jueves V1

Numeros primos en Fortran 90

Program Primosss es el nombre del programa
integer  son para las variables que utilize qie son de tipo entero
x = 2 y c =1 son variables que inicialice

Despues utilize un ciclo Do el cual empieza en i =1 y terminara hasta llegar a 100, incrementandose de 1 en 1

las variables q y p utilizan la funcion mod, la cual lo qe hace es regresar como respuesta el residuo de la division que se indica

utilice 2 if anidados para imprimir los numeros primos, en los cuales las condiciones son que el residuo de dividir x / 2 debe ser mayor a 0 y el residuo de dividir x / 3 debe ser maor a 0 tambien para que pueda ser numero primo. Si las condiciones se cumplen, entonces se imprime el numero

Cerramos los dos if  con end if, y al salir de los if incrementamos la x en 1, para que se realize el siguiente ciclo

Cerramos el Do con end Do y tambien cerramos el programa con end program.

Saludoss!

Fortran 90

Para Dra Schaeffer

Clase: Lab de lenguajes de proframacion   Hora: Jueves V1

Bueno les hablare un poco sobre Fortran 90.

Fortran es un lenguaje de programación desarrollado en los años 50 y activamente utilizado desde entonces. Fortran es el acrónimo de "Formula Translation". Se considero un lenguaje de alto nivel que se usaba principalmente en Ingeniería y Ciencias exactas don de se involucran cálculos matemáticos complejos. 

Fortran es muy utlizado en aplicaciones sientificas y de ingenieria.

Como dato les puedo decir que Fortran se desarrollo inicialmente como un proyecto que desarrollaria un sistema de programacion automatico que estarian escritos de notacion matematica a lenguaje maquina

 Cuando iniciaba Fortran, habia muchos compiladores de este lenguaje, cada uno con sus propias caracteristicas y no todos estaban para los mismos sistemas operativos. Debido a esto nacio Fortran-66 como proyecto para estandarizar Fortran.

 De esta version Fortran surgio Fortran 77, el se caracterizo por el uso de las sentencia If-Then-Else y las facilidades para abrir ficheros.

 Por ultimo surge Fortran90 el cual combina la potencia de los lenguajes C++ y Ada

Las caracteristicas que sobresalen de Fortran 90 son  que se pueden realizar operaciones con matrices, se permite el acceso dinamico a memoria, se pueden utilizar la recursividad, tiene un formato de fuente libre, los bucles tienen un diferente manejo

Bueno les hablare ahora un poco sobre la estructura al momento de programar. Fortran permite tener en una sola linea 132 caracteres, los espacios en blanco tienen relevancia con excepcion de que sea hacer mas leible el programa.

El simbolo & permite al programador interrumpir la sentencia en una linea y poder continuarla en la siguiente, una sentencia no puede abarcar mas de 39 lineas) .   El simnolo ! se utiliza para realizar comentarios, todo aquello que este despues de este simbolo ! sera tomado como comentario. Una linea en blanco es tomada como una linea de comentario

Todo programa de Fortran 90 debe comenzar con la linea  program nombre   donde nombre debe empezar con una letra y puede tener hasta 31 caracteres. Y para terminar el programa se debe cerrar con la linea   end program

Se deben de declarar todas las variables entre el principio del programa y la parte que se ejecutara. Para declararlas se utilizan las sentencias  integer x    ,  para enteros, donde x es la variable que se quiera utilizar,   real x   , para numeros reales;   y para caracteres se indica la longitud y el nombre de la variable character(len=15) nombre.   Tambien se pueden inicializar las variables al momento de ser declaradas

Para imprimir se utiliza la sentencia write(*,*)  y ya sea que vayamos a escribir algo para el usuario o imprimamos una variable,  para imprimir algo para el usuario el texto se pone entre comillas ' ' o " "  ,  y para imprimir una variable basta con escribir la variable enseguida de la sentencia

Para leer o recibir un dato se utiliza la sentencia read (*,*)   y enseguida en el nombre de la variable en la cual estara almacenado el dato.

A continuacion les dejare una tabla con operadores que pueden utilizarse en Fortran 90

OPERADOR INTRINSECO	SIGNIFICADO
* *	Exponente
*	Multiplicación
/	División
+	Adición
-	Sustracción
/ /	Concatenación de cadenas
. EQ .	Igual
. NE .	Distinto
>	Mayor
> =	Mayor o igual
<	Menor
< =	Menor o igual
. NOT .	Negación
. AND .	y
. OR .	o
. EQV .	Equivalente
. NEQV .	No equivalente

 La sentencia if se utiliza de la siguiente manera:

IF (expresión lógica ) THEN

        Bloque de sentencias

ELSE

    Bloque de sentencias

END IF

Sentencia DO

DO ( sentencia de control )

                  Bloque de sentencias

END DO

En la sentencia de control se indica el numero de veces que se ejecutara el Do

Sentencia while

do
    sentencias
    if (expr lógica) exit
    sentencias
    end do

Aqui lo que varia es la instruccion exit que es para indicar cuando debe salir del bucle.

Arreglos

Tipo del arreglo, Dimension ( n:m )  nombre del array  

n y m son las dimensiones del arreglo 

Espero esta pequeña informacion sobre este lenguaje les sea de ayuda, la verdad al principio

si es un poco dificil de manejar, porque la estructura es un poco diferente a python, se parece mas

C pero se maneja diferente, pero una vez que te vas a acostumbrando se vuelve mas facil su 

manejo.

Para descargar el compilador de python, en la terminal deben escribir lo siguiente:

sudo apt-get install gfortran
y para compilar se utiliza la instruccion gfortran nombre.f   
y ya para ejecutarlo se escribe ./a.out

Les dejare un ejemplo de numeros primos en Fortran 90.

Bueno esto seria todo, Saludos.

Pygame!

para: Dra. Schaeffer
Lab de lenguajes de programacion   hora: jueves V1

Bueno aqui otro post sobre el tutorial que he estado siguiendo en la red

Esta vez haremos que nuestra ventana detecte los cliks del mouse y reproduzca un sonido, editaremos a Tux para que aparezca mas pequeño, controlaremos la velocidad de nuestra animacion y tambien algo divertido como tomar screenshots(impresiones de pantalla) al dar click con el mouse y mover a Tux con el mouse :P

Empezemoos...

Bueno para comenzar yo quite el sonido de las burbujas porque era algo molesto estarlo escuchando cada vez qe la pantalla estuviera cambiando de color. para esto quite la linea sonido.play() de los bucles if y elif que estan casi al final de nuestro código. a mi me quedaron de la siguiente manera

Con esto ya solo escucharemos el sonido al principio de la animacion. Bueno continuemos

Creemos la variable con nuestro sonido. Los sonidos los pueden descargar de la siguiente pagina http://www.soundbible.com/. En mi caso descargue un sonido de salto de mario :P, de esa pagina podran descargar los sonidos que gusten. bueno agregemos el sonido esto se hace agregando donde primero agregamos nuestro sonido cuando aparece Tux, con la siguiente instruccion





salto = pygame.mixer.Sound('mariosalto.wav') salto es una variable, pygame.mixer.Sound es la instruccion para agregar el sonido y 'mariosalto.wav' es el nombre del archivo de audio.

Ahora crearemos otro evento este detectara al dar click con el mouse y producira un sonido. Esto lo haremos con lo siguiente  elif cerrar.type == MOUSEBUTTONDOWN:  elif porque es otra de las opciones de nuestro ciclo, cerrar que es la variable, .type para el tipo de evento que recibira MOUSSEBUTTONDOWN es el evento que detectara.

Ahora haremos que se reproduzca el sonido con la siguiente instruccion:
salto.play() salto que es la variable, play() es para que se reproduzca

Ahora al ejecutar nuestro programa, aparecera Tux desde la esquina, se escuchara un sonido y cada vez que demos click en la pantalla se escuchara el sonido que hallamos escogido.


Continuemoos.. editemos el tamaño de Tux. Lo primero que haremos sera cargar otra imagen de Tux para que podamos comprobar la diferencia esto lo haremos colocando despues de nuestro bucle for y antes de donde cargamos el otro Tux  con lo siguiente  ventana.blit(tux,(200,200))   ventana.blit es para hacer que la imagen que aparazca forme parte de la pantalla (200,200) son las coordenadas

Y al Tux pasado con las coordenadas x,y  lo llamaremos Tux2 asi como esta en la imagen anterior. Luego, colocaremos lo siguiente despues de donde tenemos la variable de Tux que carga la imagen  tux2 = pygame.transform.scale(tux,(100,100))  tux2 es la variable, pygame.transform.scale es la instruccion para poner a escala la imagen, (100, 100) es la resolucion a la cual queremos la imagen.

Con esto hacemos que el Tux que se esta moviendo de lugar este mas pequeño y esto provoca que la animacion tanto del cambio de color como de el moviemiento de Tux sea mas rapido ya que esta mas pequeño.

Ahora controlaremos el tiempo con el cual se mueve Tux. La velocidad que le pondremos sera de 60 marcos por segundo, esto para que en maquinas mas lentas no sea tan pesado. Lo primero que haremos sera crear una variable la cual llame tiempo y tenre la siguiente instruccion donde tenemos nuestras demas variables de la ventana, Tux, etc
tiempo = pygame.time.Clock()   pygame.time.Clock() es la instruccion para controlar el tiempo

Despues colocaremos lo siguiente donde tenemos las lineas de codigo que hacen que Tux forme parte de la pantalla, es decir despues de nuestro bucle for
tiempo.tick(60)  esta instruccion hace que la animacion este a 60 cuadros por segundo. provocando que sea mas lenta

Ahora juguemos con nuestro programa :P.. tomaremos screenshots al dar click, la verdad no se muy bien para nos pueda servir pero cuando lo vi dije puede ser divertido y podre encontrarle algun uso duespues...

Lo unico que necesitamos hacer es crear dentro del bucle for otra opcion, es decir un elif con lo siguiente
elif cerrar.type == KEYDOWN and cerrar.key == K_SPACE:  esto crea en la variable cerrar un evento con .type que recibe como entrada el teclado que es especifico es la barra espaciadora, esto con la instruccion cerrar.key==K_SPACE

Debajo de esta linea de codigo pondremos esto:
pygame.image.save(ventana, "screenshot.png")   la instruccion pygame.image.save es para guardar una imagen, (ventana, "screenshot.png") es para establecer que lo que se guardara sera la pantalla completa junto con el nombre que se le quiere dar y su extension.

 

Ahora cada vez qe ejecutemos el programa y presionemos la barra espaciadora tomaremos una impresion de pantalla y se guardara en la misma carpeta donde este nuestro programa

Por ultimo moveremos a Tux con el mouse. esto se hace asi..

es algo sencillo lo que tenemos que hacer es crear unas variables que detecten la posicion del cursor del mouse. Se hace con lo siguiente:
mx,my = pygame.mouse.get_pos()

si queremos saber la posicion del cursor podemos poner una impresion y en la terminal aparecera la posicion, esto es simple solo hay qe colocar
print mx  debajo de lo que acabamos de hacer, esto nos dara la coordenada de x pero tambien podemos tener la de y agregando mx en esa linea

ahora solo hay que hacer que Tux se mueva con nuestro cursor esto es asi:
donde tenemos la linea ventana.blit(tux2,(x,y)) por
ventana.blit(tux2,(mx-50,my-50))  mx - 50, my-50 para tener el cursor en el centro de Tux  es -50 porque como a ese Tux lo reducimos a 100,100 pues es la mitad

Ahora ya al ejecutar nuestro programa podremos mover a Tux con nuestro cursor

Bueno eso es todo en este post. Espero les sea de ayuda. Saludos

Pygame!

Dra. Elisa Schaeffer
Lab de Lenguajes de Programación

Aquí otro post sobre el módulo pygame, en este post veremos como agegar sonidos a nuestra ventana y como hacer que nuestra ventana se cierre al presionar ciertos botonoes del teclado.

Para hacer esto abrimos el código que hasta ahorita hemos realizado con los posts anteriores e importamos el módulo pygame.mixer ,  para esto iremos a la línea

import sys, pygame

Agregaremos una coma y pondremos pygame.mixer.

Despues debemos tener un sonido para agregarselo a nuestra ventana. Lo que hice fue descargar un sonido de la siguietne página: http://soundbible.com/  aquí vienen muchos sonidos que podemos descargar pero debemos descargarlos o tenerlos en formato .wav porque es el formato que pygame puede reproducir. Y recuerden que debemos tenerlo en la misma carpeta dondese encuentra nuestro código.

Ahora creamos una variable, ya sea antes o despues de las variables tamano o ventana, la cual llame sonido = pygame.mixer.Sound()

sonido = pygame.mixer.Sound('bubbles.wav')

pygame.mixer.Sound es la instrucción para cargar el sonido,  'bubbles.wav' es el nombre de nuestro sonido junto con su extensión.

Ahora para reproducir el sonido usaremos la instrucción

sonido.play()

sonido es el nombre de nuestra variable y .play() es para reproducirlo.

El resto de nuestro código queda igual con el ciclo que habiamos hecho y todo eso. Ahora lo ejecutamos y tendremos a Tux moviendose en diagonal y el sonido se reproducirá desde que Tux empieze a moverse.

Si queremos que el sonido se reproduzca cada vez qu la pantalla cambie de rojo a negro y de negro a rojo haremos lo siguiente

Dentro de nuestro ciclo, especificamente en el if debajo de la linea r1 = -1 y en el elif debajo de  la linea r1 = 1, colocaremos la intrucción para reproducir nuestro sonido que es 

sonido.play()

Ahora ya nuestro sonido se reproducirá cada vez que el fondo de nuestra ventana cambie de negro a rojo y rojo a negro.

Bueno, ya hecho esto les explicaré como hacer que nuestra ventana se cierre al preionar ciertos botones del teclado


Lo que necesitamos hacer es importar un módulo de pygame para que reconozca las instrucciones al presionar los botones del teclado. Debe ir debajo de import sys, pygame, pygame.mixer

from pygame.locals import *

Luego, iremos a nuestro ciclo y donde tenemos la línea if cerrar.type == pygame.QUIT: sys.exit()
Despues de los dos puntos el pedazo de línea sys.exit() la colocaremos dentro del if.   Ahora hacemos un elif con lo siguiente 

elif cerrar.type == KEYDOWN and cerrar.key == K_ESCAPE:
            sys.exit()

Que este elif lo que hace es que para cerrar la ventana sys.exit() debemos preionar un boton del teclado cerrar.type  pero tambien debe ser igual al boton Esc cerrar.key == K_ESCAPE:

Ahora copiaremos y pegaremos esta misma línea debajo y cambiaremos cerrar.key == K_ESCAPE:   por   cerrar.key == K_q:

elif cerrar.type == KEYDOWN and cerrar.key == K_q:
            sys.exit()

Y ahora al ejecutar el código par acerrar la ventana lo podemos hacer de 3 formas diferentes presionando la Cruz en los botones de control, presionando el botón Esc o con la letra q.

Bueno eso es todo en este post, espero les ayudee y cualquier duda comenten (Y).
Saludos...

Pygame!

Dra. Elisa Schaeffer
Lab de Lenguajes de Programación    jueves v1

Continuemos con esta serie de posts sobre pygame....

En el post anterior terminamos con el código de la siguiente manera:

Lo que haremos ahora será que nuestra imagen se mueva en la pantalla y haremos que el fondo de nuestra pantalla cambie de colores :P

Lo primero que haremos es tomar las líneas que cargan nuestra imagen y redibujan nuestra pantalla para que aparezca Tux en la pantalla

ventana.blit(tux,(200,200))

pygame.display.flip()

y las colocamos dentro del for,esto para que nuestra imagen obtenga movimiento.

Despues insertaremos dos variables x = 0 y  y=0 estas variables irán fuera del while.  Las coordenadas 200,200 dentro de ventana.blit  las cambiaremos por "x" y "y".

Nuestro código quedará de la siguiente manera:

Hasta este paso si ejecutamos nuestro programa seguira pasando lo mismo tendremos nuestra pantalla con la imagen de Tux solo que en la posicion 0,0

Ahora debajo de  pygame.display.flip() y dentro del for colocaremos lo siguiente

x = x+1

Esto para que las cordenadas dentro de ventana.blit(tux,(x,y)) vayan aumentando en 1 y la imagen se mueva. Si ejecutamos el código Tux se movera pero dejara rastro. Se veria algo asi:

Esto pasa porque no estamos limpiando la pantalla cada vez que Tux cambia de posición, lo que haremos es lo siguiente

Creamos una variable que la llame negro = 0,0,0  esta variable irá debajo de tamano = ancho, alto = 600, 40. 0,0,0 porque es el codigo de colores rgb. Estos valores los pueden cambiar para obtener distintos colroes de fondo.

Despues colocaremos:

ventana.fill(negro)

Dentro de nuestro for, esta instrucción debe ir antes de  ventana.blit(tux,(x,y)). Y lo que hace esta instrucción es que rellena la pantalla con color negro cada vez que la imagen se mueve.

Por último debajo de x = x+1 y dentro del for colocaremos y = y+1 esto hará que Tux se mueva en diagonal.  El código quedó de la siguiente manera:

Al ejecutar el código obtendriamos a Tux moviendose desde la esquina superior izquierda en diagonal hasta la esquina inferior derecha

Para hacer que el fondo de nuestra pantalla cambie en dos colores distintos lo que haremos será lo siguiente.

Agregaremos una variable r = 0  debajo de y = 0   y en nuestra instrucción

ventana.fill(negro)

cambiaremos la variable negro por (r,0,0)
Despues dentro de nuestro for tenemos y = y+1, debajo de esta linea pondremos
r = r+1

El código estaría como el siguiente:

Si ejecutamos el código lo que pasara será que la pantalla cambiara de negro a rojo pero llegara a un color rojo que la máquina no puede establecer y marcara error. Esto lo corregiremos con lo siguiente

Borraremos la instrucción r = r+1 y en su lugar colocaremos lo siguiente
    if r == 255:   
           r1 = -1
    elif r == 0:
          r1 = 1
    r = r + r1

Este if servirá para que cuando el valor de r llegue a 255 este vaya en retroceso y produzca un color negro, ya que con r1=-1 se lo irá restando según vaya avanzando en el for.

Ahora si el fondo de nuestra pantalla irá de negro a rojo y de rojo a negro.

De este post es todo... espero les halla gustado y les sea de ayuda,, saludoss

Pygame!

Dra. Elisa Schaeffer

Lab de lenguajes de Programacion Hora: V1

Pygame 1ra Parte

Bueno este post es sobre el modulo Pygame de Python que lo podemos utilizar para realizar animaciones, juegos, etc... 

En este primer tutorial lo que haremos será crear una pantalla y cargar una imagen en ella.

Empezamos como todo programa en python poniendo la ubicacion del intérprete de python

#!/usr/bin/python

Despues importamos el modulo pygame y  sys que lo necesitamos para limpiar y redibujar la pantalla

import sys, pygame

Iniciamos pygame

pygame.init()

Definiremos una variable con los valores del ancho y alto de la ventana que crearemos :

tamano = ancho, alto = 600, 400

Ahora en una variable crearemos nuestra ventana con la instrucción pygame.display.set_mode(), dentro de los paréntesis se define el tamaño de la ventana pero en nuestro caso ya tenemos una variable con las medidas:

ventana = pygame.display.set_mode(tamano)

Nuestro código hasta el momento esta asi:

Si lo ejecutamos asi lo que pasara es que la ventana que creamos se abrirá y se cerrara ya que no hemos creado un ciclo par aque la ventana se mantenga abierta hasta que nosotros la cerremos

El ciclo que ocupamos quedaría de la siguiente manera

while 1:

          for cerrar in pygame.event.get():

                  if cerrar.type == pygame.QUIT:sys.exit()

iniciamos nuestro ciclo con un while 1: esto quiere decir que cera constante hasta que nosotros lo terminemos.

for cerrar in pygame.event.get(): cerrar es una variable y con la instrucción pygame.event.get() le indicamos al programa que se cerrara cuando el usuario indique mediante el teclado, mouse, etc que quiere cerrar la ventana

if cerrar.type == pygame.QUIT:sys.exit() con la intrucción pygame.QUIT:sys.exit() indicamos que lo que el usuario va a hacer para salir de la ventana sera dar click en la tachita de cerrar.

El código hasta el momento esta asi:

Con esto ya ejecutamos nuestro código y podremos tener nuestra ventana y se quedara abierta 

 

Bueno ahora cargaremos una imagen en nuestra ventana

Para realizar esto yo descarge una imagen de Tux en formato .png y debemos tener la imagen en la misma carpeta donde se encuentra nuestro código

Ahora para cargar a nuestra imagen de Tux utilizaremos la instrucción pygame.image.load() esta instrucción debe estar despues de donde creamos nuestra ventana ventana = pygame.display.set_mode(tamano)

tux = pygame.image.load("Tux.png")

aqui cree una variable con esta instrucción, dentro del paréntesis se escribe el nombre de la imagen junto con su extensión

si ejecutamos nuestro código como lo tenemos ahorita la imagen de Tux no se cargara ya que no forma parte de la superficie de la pantalla lo que necesitamos hacer es que forme parte de la superficie de la pantalla eso lo hacemos son lo siguiente debajo de dond cargamos la imagen

ventana.blit(tux,(200,200))

ventana es nuestra variable donde creamos nuestra pantalla, blit indica que la imagen formara parte de la superficie de la pantalla, tux es nuestra imagen cargada y (200 , 200) son las coordenadas donde queremos que aparezca nuestra imagen.

Ahora lo que haremos es redibujar la pantalla pantalla para que la imagen aparezca de manera correcta esto se hace con la siguiente instruccion

pygame.display.flip()

Listo ya tenemos nuestro código terminado, que queda asi:

 

Ahora ejecutemos nuestro código y podremos ver a tux en nuestra pantalla

Pueden cargar las imagenes que uds quieran simplemente repitan la instrucción

ventana.blit(tux,(200,200)) y cambien las coordenadas

Solo que el orden en el cual apareceran en la pantalla será segun como esten en el código. Esto es que si la segunda imagen coincide en las coordenadas con la primera, la segunda estara sobre la primera.

Bueno esto es todo, espero les sea de gran ayuda, Saludos a todoss....

python TK!

Dra Elisa Schaeffer
Lab de Lenguajes de Programación Hora: V1

Bueno aquí les dejare otro post sobre Tkinter, en este post veremos como cambiar el nombre de nuestra ventana, establecer dimensiones máximas y mínimas a nuestra ventana y utilizaremos Canvas, que se usa para realizar gráficos en 2D, tales como líneas, circulos, etc, es decir dibujos sencillos.

Empezemos....

Bueno primero que nada como en todo programa de python establecemos la ruta en dond se encuentra nuestro intérprete:

#!/usr/bin/python

Despues importamos el modulo de python Tk:

from Tkinter import*


Y por último definimos una variable global llamada canv que igualaremos a 0, esta variable la utilizaremos en la funciones que realizaremos despues:

canv = 0

Nuestro código se encuentra de la siguiente manera:

Ahora definiremos nuestras funciones....

Definimos nuestra función principal, yo la defini como función main y dentro de la función llamamos a nuestra variable global canv, esto para definir que utilizaremos la variable global dentro de nuestra función cuando nosotros queramos.

def main():

    global canv


Creamos nuestra ventana y definimos las dimensiones maximas y minimas que tendra con las funciones minsize y maxsize, además le asignamos un nombre con la función title

root = Tk() # creamos nuestra ventana

root.title("Tkinter") #nombre de nuestra ventana

root.minsize(250,300) # dimensiones máximas

root.maxsize(640,480) # dimensiones minimas

Lo que sigue es crear nuestro canvas con el método canv(), dentro de los parentesis escribiremos root, para definir que pertenece a nuestra ventana, despues definimos ancho y alto con with=, y heigth=, que seran igual a las dimensiones máximas que tendra nuestra ventana. Y por ultimo pueden definir un fondo con background= " " en mi caso elegí el color azul y cierran los paréntesis, y le damos pack() a nuestro canvas tal como los botones o menús que realizamos antes

canv = Canvas(root, width = 640, height = 480, background = "blue")
canv.pack()

Luego haremos con nuestro programa detecte el movimiento del mouse, tal como lo hicimos anteriormente. con la funcion bind la cual toma el argumento de motion y una funcion que sera dibuja... la cual mostrara el dibujo que tendra nuestro canvas... y ciclamos nuestro programa.

root.bind("<Motion>", dibuja) #funcion para detectar el movimiento del mouse y el dibujo que tendra nuestro canvas
root.mainloop() # cicla el programa

Nuestro codigo estaria asi por el momento:

Ahora relizaremos la funcion dibuja....

definimos nuestra funcion con def dibuja(dib): recibira el argumento dib y dentro de nuestra funcion como lo hicimos en la funcion main llamaremos a nuestra variable global con global canv

def dibuja(dib):
    global canv

Ahora usaremos la instruccion delete para borrar el rastro que dejemos al mover nuestro canvas con el mouse, de no tenerla veriamos el rastro y la pantalla se llenaria de nuestro canvas.

canv.delete(ALL)


Ya para terminar le daremos una forma a nuestro canvas, yo realize un circulo. Utilizamos la intruccion canv.create_oval() , la cual lleva 5 argumentos, los primeros dos son coordenadas, yo lo centre en el cursor dib.x-20, dib.y-20, los siguientes dos argumentos son para definir la forma dib.x+20, dib.y+20, y el ultimo argumento el color que le queramos asignar en este caso lo puse rojo fill = "red"

canv.create_oval(dib.x-20, dib.y-20, dib.x+20, dib.y+20, fill = "red")

Por ultimo al final de nuestro codigo llamamos a nuestra funcion main para que el programa corra

main()

El código quedó de la siguiente manera:

Ahora ejecutamos nuestro programa:

Ahora podremos hacer nuestra ventana mas grande o pequeña y mover el cursor con nuestra pelota :P

Bueno esto es todo, espero les sea de gran ayuda. Saludos

python TK!

Dra Schaeffer

Lab de Lenguajes de Programación   Jueves V1

Aqui les dejare un link para que juegen con el programa :P  consiste en  una tabla con los comandos que pueden utilizar para las rutinas del mouse en la pantalla hecha en Tk. Lo unico que puede ser malo es que esta en ingles ya que asi esta en el tutorial que estoy siguiendo

http://www.mediafire.com/?nn1nz5jtzq3

Ese es el link espero les sirva y juegen con el programa :P

saludoss

python TK!

Para la Dra Schaeffer 
Lab de lenguajes    Jueves V1


aqui les dejare un código de python utilizando el modulo TK para realizar diseños gráficos. Realize el código viendo tutoriales en internet. Hasta el momento no he realizado mucho pero les puede ser de gran ayuda para sus proyectos. El programa lo que hasta el momento hace es que crea la ventana tiene una barra de menu, pestañas y botones, tambien detecta el movimiento del mouse y los clicks del mouse. El código ciene con comentarios para que lo puedan entender mejor.


#!/usr/bin/python

from Tkinter import*  #importamos el modulo Tkinter de python
import os

root = Tk()  # realiza la base de nuestro programa en Tk


frame = Frame(root, width = 500, height = 500) # creamos una ventana


root.mainloop() # ciclamos el programa para que la ventana se mantenga abierta

Hasta aqui obtendran una ventana como la siguiente:

Despues de --> frame = Frame(root, width = 500, height = 500) agregamos el siguiente codigo:


frame.pack()  # se anade para cuando se cicle el programa

  # x, y y z son clases
x = Label(root,text='pestana') # root es para cuando el programa se cicle; text es el texto que aparecera en la pestana
x.pack() # se debe unir al pack o paquete de frame
y = Button(root,text='boton') # de igual forma root es para ciclar y text es el texto del boton. No hace nada al darle clik porque no tiene comando
y.pack()
z = Button(root,text='salir', command = frame.quit) # aqui tiene el comando de salida que es frame.quit, que cierra el programa
z.pack()

Esto debe ir antes de --> root.mainloop()   para que el programa se cicle y la ventana siga abierta. ejecuntenlo y tendran una ventana con una etiqueta y dos botones. La ventana sera como la siguiente:

Despues de la linea --> z.pack()   agregaremos el siguiente codigo:


#crear una barra de menu
menu = Menu(root) # menu es una variable y Menu es ela clase
root.config(menu=menu)
primerMenu = Menu(menu) # se declara que primermenu es un menu
menu.add_cascade(label = 'nuevo', menu = primerMenu) # hace que la barra de menu tenga menus en forma de cascada. label =  el nombre que desees

primerMenu.add_command(label = 'crear', command = 0) # primerMenu.add_command () es para anadir un comando al submenu en cascada
primerMenu.add_command(label = 'abrir', command = 0) # label =  para el nombre que se desee poner
primerMenu.add_command(label = 'editar', command = 0) # command = 0 porque no hace nada hasta ahorita
primerMenu.add_separator() # para separar ciertos submenus de otros
primerMenu.add_command(label = 'salir', command = frame.quit) # command = frame.quit  para salir


De igual manera este codigo debe estar antes de --> z.pack()

Lo que hicimos ahora fue crear una barra de menus. El menu estara en forma de cascada y tendra algunos botones. Se vera de la siguiente manera:

Donde al darle click al menu llamado nuevo se abriran los submenus

Por ultimo crearemos las funciones para que el programa detecte el movimiento del mouse y sus clicks

Despues de --> primerMenu.add_command(label = 'salir', command = frame.quit) , agregaremos lo siguiente:

#funciones de mouse
def mousemov(pos):
    os.system("clear") #limpia la pantalla
    print"posicion del mouse: ", pos.x, pos.y

def click(pos):
    os.system("clear")
    print "posicion al dar click: ", pos.x, pos.y  # pos.x y pos.y indicaran la posicion en la que se encuentra el cursor

def dobclick(pos):
    os.system("clear")
    print "Posicion al dar doble click: ", pos.x, pos.y  # imprime en la consola la posicion del mouse

def tripclick(pos):
    os.system("clear")
    print "posicion al dar triple click: ", pos.x, pos.y

def enter(pos):
    os.system("clear")
    print "enter"

def salir(pos):
    os.system("clear")
    print "salir"

# rutinas del mouse en el programa
#el metodo frame.bin se compone de dos partes, una etiqueta y una funcion
frame.bind("<Motion>",mousemov) # la etiqueta <Motion> es para detectar movimientos del mouse en la ventana
frame.bind("<Button-1>",click)
frame.bind("<Double-Button-1>",dobclick)
frame.bind("<Triple-Button-1>",tripclick)
frame.bind("<Enter>", enter)
frame.bind("<Leave>", )


De igual manera esto va antes de --> root.mainloop()

En mi caso yo puse las funciones del mouse despues de --> root = Tk()

Lo que tendremos ahora sera que en la consola se imprimira la posicion del cursor asi como tambien la posicion del cursor al darle click, doble click, triple click o click derecho

es lo que hasta el momento he realizado con los tutoriales que he leido. Espero les sea de gran ayuda y seguire subiendo post sobre este tema a medida que vaya avanzando. cualquier duda comenten