U4: PRACTICA #21 JUEGO EN 3D

LINK: DESCARGAR

EJECUCIÓN DE CÓDIGO

import pygame
from pygame.locals import *
import math
import worldManager
import time
 
worldMap =[
  [8,8,8,8,8,8,8,8,8,8,8,4,4,6,4,4,6,4,6,4,4,4,6,4],#24
  [8,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,0,0,0,0,0,0,4],
  [8,0,3,3,0,0,0,0,0,8,8,4,0,0,0,0,0,0,0,0,0,0,0,6],
  [8,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6],
  [8,0,3,3,0,0,0,0,0,8,8,4,0,0,0,0,0,0,0,0,0,0,0,4],
  [8,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,6,6,6,0,6,4,6],
  [8,8,8,8,0,8,8,8,8,8,8,4,4,4,4,4,4,6,0,0,0,0,0,6],
  [7,7,7,7,0,7,7,7,7,0,8,0,8,0,8,0,8,4,0,4,0,6,0,6],
  [7,7,0,0,0,0,0,0,7,8,0,8,0,8,0,8,8,6,0,0,0,0,0,6],
  [7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,4],
  [7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,6,0,6,0,6],
  [7,7,0,0,0,0,0,0,7,8,0,8,0,8,0,8,8,6,4,6,0,6,6,6],
  [7,7,7,7,0,7,7,7,7,8,8,4,0,6,8,4,8,3,3,3,0,3,3,3],
  [2,2,2,2,0,2,2,2,2,4,6,4,0,0,6,0,6,3,0,0,0,0,0,3],
  [2,2,0,0,0,0,0,2,2,4,0,0,0,0,0,0,4,3,0,0,0,0,0,3],
  [2,0,0,0,0,0,0,0,2,4,0,0,0,0,0,0,4,3,0,0,0,0,0,3],
  [1,0,0,0,0,0,0,0,1,4,4,4,4,4,6,0,6,3,3,0,0,0,3,3],
  [2,0,0,0,0,0,0,0,2,2,2,1,2,2,2,6,6,0,0,5,0,5,0,5],
  [2,2,0,0,0,0,0,2,2,2,0,0,0,2,2,0,5,0,5,0,0,0,5,5],
  [2,0,0,0,0,0,0,0,2,0,0,0,0,0,2,5,0,5,0,5,0,5,0,5],
  [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5],
  [2,0,0,0,0,0,0,0,2,0,0,0,0,0,2,5,0,5,0,5,0,5,0,5],
  [2,2,0,0,0,0,0,2,2,2,0,0,0,2,2,0,5,0,5,0,0,0,5,5],
  [2,2,2,2,1,2,2,2,2,2,2,1,2,2,2,5,5,5,5,5,5,5,5,5]
];#24
 
#worldMap =[
#  [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],
#  [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
#];
 
sprite_positions=[
  (20.5, 11.5, 2), #green light in front of playerstart
  #green lights in every room
  (18.5,4.5, 2),
  (10.0,4.5, 2),
  (10.0,12.5,2),
  (3.5, 6.5, 2),
  (3.5, 20.5,2),
  (3.5, 14.5,2),
  (14.5,20.5,2),
   
  #row of pillars in front of wall: fisheye test
  (18.5, 10.5, 1),
  (18.5, 11.5, 1),
  (18.5, 12.5, 1),
   
  #some barrels around the map
  (21.5, 1.5, 0),
  (15.5, 1.5, 0),
  (16.0, 1.8, 0),
  (16.2, 1.2, 0),
  (3.5,  2.5, 0),
  (9.5, 15.5, 0),
  (10.0, 15.1,0),
  (10.5, 15.8,0),
]
 
def load_image(image, darken, colorKey = None):
    ret = []
    if colorKey is not None:
        image.set_colorkey(colorKey)
    if darken:
        image.set_alpha(127)
    for i in range(image.get_width()):
        s = pygame.Surface((1, image.get_height())).convert()
        #s.fill((0,0,0))
        s.blit(image, (- i, 0))
        if colorKey is not None:
            s.set_colorkey(colorKey)
        ret.append(s)
    return ret
 
def main():
   
    t = time.clock() #time of current frame
    oldTime = 0. #time of previous frame
    pygame.mixer.init()#inicializar el modulo mezclador
    pygame.mixer.music.load("MuseUprising.mp3")
    pygame.mixer.music.play(-1)
    size = w, h = 640,480
    pygame.init()
    window = pygame.display.set_mode(size)#Inicializa una ventana o pantalla para visualizar
    pygame.display.set_caption("Gh0stenstein")
    screen = pygame.display.get_surface()#toma una referencia de la superficie de visualizacion actualmente configurada
    #pixScreen = pygame.surfarray.pixels2d(screen)
    pygame.mouse.set_visible(False)
    clock = pygame.time.Clock()
    #crea un objeto para ayudar a rastrear el tiempo
    f = pygame.font.SysFont(pygame.font.get_default_font(), 20)
    #crear un objeto Font a partir de las fuentes del sistema
    wm = worldManager.WorldManager(worldMap,sprite_positions, 22, 11.5, -1, 0, 0, .66)
     
    weapons = [Weapon("fist"),
               Weapon("pistol"),
               Weapon("shotgun"),
               Weapon("dbshotgun"),
               Weapon("chaingun"),
               Weapon("plasma"),
               Weapon("rocket"),
               Weapon("bfg"),
               Weapon("chainsaw")
               ]
    weapon_numbers = [K_1,K_2,K_3,K_4,K_5,K_6,K_7,K_8,K_0]
    weapon = weapons[0]
    #creacion de un bucle infinito que no cierre la ventana
    while(True):
        clock.tick(60)#se le pasa como parametro es el framerate, 
        #con el nos aseguramos de que el juego no va a mas de esa velocidad. 
        wm.draw(screen)
         
         
        # tiempo de entrada y contador de FPS
         
        frameTime = float(clock.get_time()) / 1000.0 # frameTime is the time this frame has taken, in seconds
        t = time.clock()
        text = f.render(str(clock.get_fps()), False, (255, 255, 0))
        screen.blit(text, text.get_rect(), text.get_rect())
        weapon.draw(screen, t)
        pygame.display.flip()#Actualiza la pantalla completa de la superficie a la pantalla
 
        # speed modifiers
        moveSpeed = frameTime * 6.0 # the constant value is in squares / second
        rotSpeed = frameTime * 2.0 # el valor de la constante es en radianes / segundo
         
        for event in pygame.event.get(): #get events from the queue
            if event.type == QUIT: #si se preciona la x de la ventana se detandra el bucle y cerrara el juego
                return
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    return
                elif event.key == K_SPACE:
                    #shoot
                    weapon.play()
                elif event.key in weapon_numbers:
                    weapon.stop()
                    weapon = weapons[weapon_numbers.index(event.key)]
            elif event.type == KEYUP:
                if event.key == K_SPACE:
                    weapon.stop()
            else:
                pass
         
        keys = pygame.key.get_pressed() #obtiene el estado de todos los botones del teclado
        if keys[K_UP]:
            # move forward if no wall in front of you
            moveX = wm.camera.x + wm.camera.dirx * moveSpeed
            if(worldMap[int(moveX)][int(wm.camera.y)]==0 and worldMap[int(moveX + 0.1)][int(wm.camera.y)]==0):wm.camera.x += wm.camera.dirx * moveSpeed
            moveY = wm.camera.y + wm.camera.diry * moveSpeed
            if(worldMap[int(wm.camera.x)][int(moveY)]==0 and worldMap[int(wm.camera.x)][int(moveY + 0.1)]==0):wm.camera.y += wm.camera.diry * moveSpeed
        if keys[K_DOWN]:
            # move backwards if no wall behind you
            if(worldMap[int(wm.camera.x - wm.camera.dirx * moveSpeed)][int(wm.camera.y)] == 0):wm.camera.x -= wm.camera.dirx * moveSpeed
            if(worldMap[int(wm.camera.x)][int(wm.camera.y - wm.camera.diry * moveSpeed)] == 0):wm.camera.y -= wm.camera.diry * moveSpeed
        if (keys[K_RIGHT] and not keys[K_DOWN]) or (keys[K_LEFT] and keys[K_DOWN]):
            # gira hacia la derecha
            # tanto la direccion de la camara como el plano de la camara deben girarse
            oldDirX = wm.camera.dirx
            wm.camera.dirx = wm.camera.dirx * math.cos(- rotSpeed) - wm.camera.diry * math.sin(- rotSpeed)
            wm.camera.diry = oldDirX * math.sin(- rotSpeed) + wm.camera.diry * math.cos(- rotSpeed)
            oldPlaneX = wm.camera.planex
            wm.camera.planex = wm.camera.planex * math.cos(- rotSpeed) - wm.camera.planey * math.sin(- rotSpeed)
            wm.camera.planey = oldPlaneX * math.sin(- rotSpeed) + wm.camera.planey * math.cos(- rotSpeed)
        if (keys[K_LEFT] and not keys[K_DOWN]) or (keys[K_RIGHT] and keys[K_DOWN]): 
            # rotate to the left
            # both camera direction and camera plane must be rotated
            oldDirX = wm.camera.dirx
            wm.camera.dirx = wm.camera.dirx * math.cos(rotSpeed) - wm.camera.diry * math.sin(rotSpeed)
            wm.camera.diry = oldDirX * math.sin(rotSpeed) + wm.camera.diry * math.cos(rotSpeed)
            oldPlaneX = wm.camera.planex
            wm.camera.planex = wm.camera.planex * math.cos(rotSpeed) - wm.camera.planey * math.sin(rotSpeed)
            wm.camera.planey = oldPlaneX * math.sin(rotSpeed) + wm.camera.planey * math.cos(rotSpeed)
 
fps = 8
class Weapon(object):
     
    def __init__(self, weaponName="shotgun", frameCount = 5):
        self.images = []
        self.loop = False
        self.playing = False
        self.frame = 0
        self.oldTime = 0
        for i in range(frameCount):
            img = pygame.image.load("pics/weapons/%s%s.bmp" % (weaponName, i+1)).convert()
            img = pygame.transform.scale2x(img)
            img = pygame.transform.scale2x(img)
            img.set_colorkey(img.get_at((0,0)))
            self.images.append(img)
    def play(self):
        self.playing = True
        self.loop = True
    def stop(self):
        self.playing = False
        self.loop = False
    def draw(self, surface, time):
        if(self.playing or self.frame > 0):
            if(time > self.oldTime + 1./fps):
                self.frame = (self.frame+1) % len(self.images)
                if self.frame == 0: 
                    if self.loop:
                        self.frame = 1
                    else:
                        self.playing = False
                         
                self.oldTime = time
        img = self.images[self.frame]
        surface.blit(img, (surface.get_width()/2 - img.get_width()/2, surface.get_height()-img.get_height()))
             
if __name__ == '__main__':
    main()

U4: PRACTICA #20 TRIANGULO EN 3D

LINK: DECARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

import pygame
from pygame.locals import *
 
from OpenGL.GL import *
from OpenGL.GLU import *
 
verticies = (
    (1, -1, -1),
    (1, 1, -1),
    (-1, 1, -1),
    (-1, -1, -1),
    (0,0,1)
 
    )
 
edges = (
    (4,0),
    (4,1),
    (4,2),
    (4,3),
    (0,1),
    (0,3),
    (2,1),
    (2,3)
 
    )
 
 
def Cube():
    glBegin(GL_LINES)
    for edge in edges:
        for vertex in edge:
            glVertex3fv(verticies[vertex])
    glEnd()
 
 
def main():
    pygame.init()
    display = (800,600)
    pygame.display.set_mode(display, DOUBLEBUF|OPENGL)
 
    gluPerspective(45, (display[0]/display[1]), 0.1, 50.0)
 
    glTranslatef(0.0,0.0, -5)
 
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
 
        glRotatef(1, 3, 1, 1)
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
        Cube()
        pygame.display.flip()
        pygame.time.wait(10)
 
 
main()

U4: PRACTICA #19 CUBO DE COLORES EN 3D

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

import sys, math, pygame
from operator import itemgetter
class Point3D:
    def __init__(self, x=0, y=0, z=0):
        self.x, self.y, self.z = float(x), float(y), float(z)
    def rotateX(self, angle):
        """ Rotates the point around the X axis by the given angle in degrees. """
        rad = angle * math.pi / 180
        cosa = math.cos(rad)
        sina = math.sin(rad)
        y = self.y * cosa - self.z * sina
        z = self.y * sina + self.z * cosa
        return Point3D(self.x, y, z)
    def rotateY(self, angle):
        """ Rotates the point around the Y axis by the given angle in degrees. """
        rad = angle * math.pi / 180
        cosa = math.cos(rad)
        sina = math.sin(rad)
        z = self.z * cosa - self.x * sina
        x = self.z * sina + self.x * cosa
        return Point3D(x, self.y, z)

    def rotateZ(self, angle):
        """ Rotates the point around the Z axis by the given angle in degrees. """
        rad = angle * math.pi / 180
        cosa = math.cos(rad)
        sina = math.sin(rad)
        x = self.x * cosa - self.y * sina
        y = self.x * sina + self.y * cosa
        return Point3D(x, y, self.z)

    def project(self, win_width, win_height, fov, viewer_distance):
        """ Transforms this 3D point to 2D using a perspective projection. """
        factor = fov / (viewer_distance + self.z)
        x = self.x * factor + win_width / 2
        y = -self.y * factor + win_height / 2
        return Point3D(x, y, self.z)


class Simulation:
    def __init__(self, win_width=640, win_height=480):
        pygame.init()

        self.screen = pygame.display.set_mode((win_width, win_height))
        pygame.display.set_caption("Figura de cubo 3D en python")

        self.clock = pygame.time.Clock()

        self.vertices = [
            Point3D(-1, 1, -1),
            Point3D(1, 1, -1),
            Point3D(1, -1, -1),
            Point3D(-1, -1, -1),
            Point3D(-1, 1, 1),
            Point3D(1, 1, 1),
            Point3D(1, -1, 1),
            Point3D(-1, -1, 1)
        ]

        # Define the vertices that compose each of the 6 faces. These numbers are
        #  indices to the vertices list defined above.
        self.faces = [(0, 1, 2, 3), (1, 5, 6, 2), (5, 4, 7, 6), (4, 0, 3, 7), (0, 4, 5, 1), (3, 2, 6, 7)]

        # Define colors for each face
        self.colors = [(255, 0, 100), (100, 0, 0), (0, 25, 0), (0, 0, 255), (0, 255, 155), (255,5, 0)]

        self.angle = 0
    def run(self):
        """ Main Loop """
        while 1:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()

            self.clock.tick(50)
            self.screen.fill((0, 32, 0))

            # It will hold transformed vertices.            \
            t = []

            for v in self.vertices:
                # Rotate the point around X axis, then around Y axis, and finally around Z axis.
                r = v.rotateX(self.angle).rotateY(self.angle).rotateZ(self.angle)
                # Transform the point from 3D to 2D
                p = r.project(self.screen.get_width(), self.screen.get_height(), 256, 4)
                # Put the point in the list of transformed vertices
                t.append(p)

            # Calculate the average Z values of each face.
            avg_z = []
            i = 0
            for f in self.faces:
                z = (t[f[0]].z + t[f[1]].z + t[f[2]].z + t[f[3]].z) / 4.0
                avg_z.append([i, z])
                i = i + 1
            # Draw the faces using the Painter's algorithm:
            #  Distant faces are drawn before the closer ones.
            for tmp in sorted(avg_z, key=itemgetter(1), reverse=True):
                face_index = tmp[0]
                f = self.faces[face_index]
                pointlist = [(t[f[0]].x, t[f[0]].y), (t[f[1]].x, t[f[1]].y),
                             (t[f[1]].x, t[f[1]].y), (t[f[2]].x, t[f[2]].y),
                             (t[f[2]].x, t[f[2]].y), (t[f[3]].x, t[f[3]].y),
                             (t[f[3]].x, t[f[3]].y), (t[f[0]].x, t[f[0]].y)]
                pygame.draw.polygon(self.screen, self.colors[face_index], pointlist)

            self.angle += 1
            pygame.display.flip()


if __name__ == "__main__":
    Simulation().run()

U4: PRACTICA #18 CUBO 3D

LINK: DESCARGAR CODIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

import pygame
from pygame.locals import *

from OpenGL.GL import *
from OpenGL.GLU import *

verticies = (
    (1, -1, -1),
    (1, 1, -1),
    (-1, 1, -1),
    (-1, -1, -1),
    (1, -1, 1),
    (1, 1, 1),
    (-1, -1, 1),
    (-1, 1, 1)
)

edges = (
    (0, 1),
    (0, 3),
    (0, 4),
    (2, 1),
    (2, 3),
    (2, 7),
    (6, 3),
    (6, 4),
    (6, 7),
    (5, 1),
    (5, 4),
    (5, 7)
)


def Cube():
    glBegin(GL_LINES)
    for edge in edges:
        for vertex in edge:
            glVertex3fv(verticies[vertex])
    glEnd()


def main():
    pygame.init()
    display = (800, 600)
    pygame.display.set_mode(display, DOUBLEBUF | OPENGL)

    gluPerspective(45, (display[0] / display[1]), 0.1, 50.0)

    glTranslatef(0.0, 0.0, -5)

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

        glRotatef(1, 3, 1, 1)
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
        Cube()
        pygame.display.flip()
        pygame.time.wait(10)


main()

U4: PRACTICA #17 GRAFICACIÓN DE BARRAS EN 3D

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt


fig = plt.figure()
ax1 = fig.add_subplot(111, projection='3d')

xpos = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
ypos = [2,3,4,5,1,6,2,1,7,2,3,5,1,3,2]
num_elements = len(xpos)
zpos = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
dx = dy =dz = [20,2,3,4,5,6,7,8,9,10,11,12,13,14,15]

ax1.bar3d(xpos, ypos, zpos, dx, dy, dz, color='red')
plt.show()

U4: PRACTICA #16 ABRIR IMAGEN DESDE NAVEGADOR AUTOR BRUCELEE CAMPOS

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

import base64
try:
    # Python2
    import Tkinter as tk
    from urllib2 import urlopen
except ImportError:
    # Python3
    import tkinter as tk
    from urllib.request import urlopen
root = tk.Tk()
root.title("Implementar imagenes de web")
# margenes
w = 520
h = 320
x = 80
y = 100
# usar width x height + x_offset + y_offset (no spaces!)
root.geometry("%dx%d+%d+%d" % (w, h, x, y))
# cualquier imagen de la red
image_url = "https://eltallerdelaserenidad.files.wordpress.com/2016/05/loto-movimiento.gif?w=640"
image_byt = urlopen(image_url).read()
image_b64 = base64.encodestring(image_byt)
photo = tk.PhotoImage(data=image_b64)
# SE CREA UN CANVAS BLANCO
cv = tk.Canvas(bg='white')
cv.pack(side='top', fill='both', expand='yes')
# SE COLOCA LA IMAGEN EN EL CANVAS
# CREAR_IMAGEN(xpos, ypos, image, anchor)
cv.create_image(10, 10, image=photo, anchor='nw')
root.mainloop()

U4: PRACTICA #15 SALUDA!

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

from Tkinter import *
import tkMessageBox

root  = Tk()
root.geometry("400x300")
root.title("Saludador")




et1 = Label(root, text = "Escribe un nombre para saludar").place(x=160,y=130)
entrada =StringVar()
entrada.set('')
caja11 = Entry(root, textvariable = str (entrada)).place(x=170,y=180)
b1 = Button(root, text = "Saludar", command = lambda: tkMessageBox.showinfo("Message", "Hola " + entrada.get() + "!")) .place(x=200,y=230)

root.mainloop()

U4: PRACTICA #14 GENERADOR DE NÚMEROS

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

from Tkinter import *
from random import *

root = Tk()
root.geometry("500x350")
root.title("Generador de numeros")

def funcion():
    num = randint(int(aux.get()),int(aux2.get()))
    aux3.set(num)

et1 = Label(root, text = "Numero 1").place(x=100,y=100)
et2 = Label(root, text = "Numero 2").place(x=100,y=150)
et3 = Label(root, text = "Numero generado").place(x=100,y=250)

arr1=[1,2,3,4,5,6,7,8,9,10]
arr2 = [1,2,3,4,5,6,7,8,9,10]
aux = StringVar()
aux2 = StringVar()
aux3 = StringVar()
s1 = Spinbox(root,textvariable = aux, values = arr1).place(x=300,y=100)
s2 = Spinbox(root,textvariable = aux2, values = arr2).place(x=300,y=150)

caja = Entry(root, textvariable =aux3).place(x=300,y=250)
b1 = Button(root, text = "Generar",command = funcion).place(x=300,y=300)


root.mainloop()

U4: PRACTICA #13 LISTA DE PELICULAS.

LINK: DESCARGAR CÓDIGO.

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

from Tkinter import *

root = Tk()
root.geometry("500x400")
root.title("Peliculas")


def fun():
    x = aux2.get()
    pelis.append(x)
    lol = OptionMenu(root, aux, *pelis).place(x=350, y=140)


et1 = Label(root, text="Escribe el titulo de una pelicula").place(x=100, y=100)
et2 = Label(root, text="Peliculas").place(x=350, y=100)
aux = StringVar()
aux.set("")
aux2 = StringVar()
pelis = [""]
lol = OptionMenu(root, aux, *pelis).place(x=350, y=140)

c1 = Entry(root, textvariable=aux2).place(x=100, y=140)
b1 = Button(root, text="Ingresar", command=fun).place(x=100, y=170)


root.mainloop()

U4: PRACTICA #12 RUTA DE FICHERO

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

from Tkinter import *
from tkFileDialog import askopenfilename

root = Tk()
root.geometry("400x200")
root.title("Mostrar Ruta Fichero")

et1 = Label(root, text = "ELIGE UNA RUTA").place(x=150,y=70)


def llamada():
    nombre  = StringVar()
    nombre.set(askopenfilename())
    Entry(root, width = 40, textvariable=nombre).place(x=100, y=100)


Entry(root,width = 40).place(x=100, y=100)
Button(root, text ="Search", command = llamada).place(x=200, y=131)

root.mainloop()

U4: PRACTICA #11 MULTIPLICADOR

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

# -*- coding: utf-8 -*-

from Tkinter import *

def hacer_click():
    try:
        valor = int(entrada_texto.get())
        valor = valor * 5
        etiqueta.config(text = valor)

    except ValueError:
        etiqueta.config(text = "Introduzca un valor")

def hacer_click2():
    try:
        valor2 = int(entrada_texto2.get())
        valor2 = valor2 * 10
        etiqueta2.config(text = valor2)

    except ValueError:
        etiqueta2.config(text = "Introduzca un valor")


def hacer_click3():
    try:
        valor3 = int(entrada_texto3.get())
        valor3 = valor3 * 15
        etiqueta3.config(text = valor3)

    except ValueError:
        etiqueta3.config(text = "Introduzca un valor")


app = Tk() #marco de la aplicacion con el obj Tk
vp = Frame(app) #usamos el objeto frame
'''ahora le damos formato a nuestra ventana, y para eso
vamos a utilizar el metodo grid(), el cual nos va a permitir
posicionar los elementos graficos en nuestra ventana.

otro parametro que utilizaremos sera el margen: padx = (50,50)
lo cual indica 50 pixeles del lado izquierdo y 50 pixeles 
del lado derecho

luego utilizamos pady = (10,10), que son 10 pixeles en la parte
superior y 10 pixeles en la parte inferior'''

vp.grid(column = 0, row = 0, padx = (50,50), pady = (10,10))

'''luego vamos a utilizar los metodos columnconfigure()
y rowconfigure() los cuales nos van a servir para dar un
peso relativo del ancho y el alto de todos los elementos
 que se pongan en la ventana'''

vp.columnconfigure(0, weight = 1)
vp.rowconfigure(0, weight = 1)

'''creamos una etiqueta llamada valor y la posicionamos
con el metodo grid()'''

etiqueta = Label(vp, text = "valor") #creo un objeto etiqueta
etiqueta.grid(column = 100, row = 1)

etiqueta2 = Label(vp, text = "valor 2")
etiqueta2.grid(column = 100, row = 4)

etiqueta3 = Label(vp, text = "valor 3")
etiqueta3.grid(column = 100, row = 6)

'''creamos un boton de OK y posicionamos con grid '''

boton = Button(vp, text = "Multiplicar por 5", command = hacer_click)
boton.grid(column = 1, row = 1)

boton1 = Button(vp, text = "Multiplicar por 10", command = hacer_click2)
boton1.grid(column = 1, row = 4)

boton2 = Button(vp, text = "Multiplicar por 15", command = hacer_click3)
boton2.grid(column = 1, row = 6)

valor =""
entrada_texto = Entry(vp, width = 10, textvariable = valor)
entrada_texto.grid(column = 2, row = 1)

valor2 = ""
entrada_texto2 = Entry(vp, width = 10, textvariable = valor2)
entrada_texto2.grid(column = 2, row = 4)

valor3 = ""
entrada_texto3 = Entry(vp, width = 10, textvariable = valor3)
entrada_texto3.grid(column =2, row = 6)


app.mainloop() #es el metodo mainloop, lanza la ventana

UNIDAD 3: BLACKJACK CON INTERFAZ AUTOR ANTONIO HUERTA.

LINK: DESCARGAR ARCHIVOS

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

from Tkinter import *
from PIL import Image,ImageTk
import os
import random
import tkMessageBox
import time
import threading

carpetaraiz=os.path.dirname(__file__)
#print carpetaraiz

DirCartas = carpetaraiz+"/Poker Cards/PNG/"
continuar = 1
#----------------------------Variables Globales-------------------------------
imagendeck = []
allcards = ["A","2","3","4","5","6","7","8","9","10","J","Q","K"]
allsymbols = ["H","S","C","D"]
labelsarray = []
imagenes = []
indice = 0
#numerocolumna = 1
puntajetotal = 0
contadorposicion = 0
#print DirCartas

#----------Metodo para mostrar imagenes en Pantalla---------------------
def setimagen(nombre,x,y): #carga la imagen
    global imagen #Declaro el uso de una variable global
    img = Image.open(nombre) #cargo la imagen mandada como parametro
    img.thumbnail((x, y), Image.ANTIALIAS) #establezco sus dimensiones y la propiedad antialiasado
    return ImageTk.PhotoImage(img)
    #imagen = ImageTk.PhotoImage(img) #la convierto a un formato soportado por los widgets de tkinter
    #return imagen

def ReiniciarJuego():
    opcion = tkMessageBox.askyesno("Retry?", "Quisieras volver a Intentarlo?")

    if(opcion==True):
        global indice, puntajetotal, contadorposicion, totalmarcador
        del labelsarray[:]
        del imagenes[:]
        indice = 0
        puntajetotal = 0
        contadorposicion = 0
        totalmarcador.config(text = "0")

    else:
        exit()


def TerminarJugada():
    opcion=tkMessageBox.askokcancel("Terminar Jugada", "Si sales ahora perderas el juego...")

    if(opcion==True):
        ReiniciarJuego()

def InicioJuego():
    global TextoBoton, contenedor, numerocolumna, indice, puntajetotal, contadorposicion
    global Botoniniciar, totalmarcador

    Botoniniciar.config(width = 43)
    finishButton = Button(contenedor, text="Terminar", font=("Arial", 10), width=15, command = TerminarJugada)
    finishButton.place(x=567, y=376)

    card = random.choice(allcards)
    palo = random.choice(allsymbols)
    carta = card+palo
    imagenes.append(setimagen(DirCartas+carta+".png", 150, 180))
    labelcartas = Label(framecartas, image = imagenes[indice])
    #labelcartas.grid(row = 1, column = numerocolumna, padx = 10, pady = 10)
    labelcartas.place(x=contadorposicion, y=0)

    contadorposicion+=130
    #numerocolumna+= 1
    indice+=1
    labelsarray.append(labelcartas)

    if(card == "10" or card == "J" or card == "Q" or card == "K"):
        puntajetotal+=10
    elif(card == "A"):
        opcion = tkMessageBox.askquestion("Elija el valor del As", "Quiere que valga 11?\nYes = 11 | No = 1")
        if opcion=="yes":
            puntajetotal+=11
        else:
            puntajetotal+=1

    else:
        puntajetotal+= int(card)

    totalmarcador.config(text = str(puntajetotal))

    if(puntajetotal==21):
        tkMessageBox.showinfo("BLACKJACK!! FELICIDADES!", "Has hecho un BLACKJACK!\nTotal: 21")
        ReiniciarJuego()
    elif(puntajetotal>21):
        tkMessageBox.showerror("HAS PERDIDO!",'Te has pasado! Vuelve a Intentarlo')
        ReiniciarJuego()

#--------------Metodo para mostrar el Marcador al Ingresar el Nombre--------------------
def Marcador(nombre):
    global labelentry, BotonOK, entrynombre, Botoniniciar
    global nombrejugador, TextoBoton, totalmarcador
    #nombrejugador = nombre
    BotonOK.destroy()
    entrynombre.destroy()

    TextoBoton.set("Pedir Carta")
    Botoniniciar = Button(contenedor, textvariable=TextoBoton, font=("Arial", 10), width=45, command = InicioJuego)
    Botoniniciar.place(x=200, y=376)

    framemarcador = Frame(contenedor, bg="grey")
    framemarcador.config(bd=3, relief="ridge")
    framemarcador.place(width=154, height=316, x=18, y=90)

    titulomarcador = Label(framemarcador, text = "Marcador",font = ("Arial",20, "bold"), bg = "grey")
    titulomarcador.grid(row=1, column=1, padx = 10, pady = 10, columnspan=3)

    j1marcador = Label(framemarcador, text = "Jugador 1:", font = ("Arial",10), bg="grey")
    j1marcador.grid(row=2, column=1, sticky = "E")

    nombremarcador = Label(framemarcador, text = nombre, font = ("Arial",10), bg = "grey")
    nombremarcador.grid(row=2, column=2, sticky = "W")

    totallabel = Label(framemarcador, text = "Total:", font = ("Arial",10,"bold"), bg = "grey")
    totallabel.grid(row=3, column = 1, sticky = "E" )

    totalmarcador = Label(framemarcador, text= str(puntajetotal), font=("Arial", 10, "bold"), bg="grey")
    totalmarcador.grid(row=3, column=2, sticky="W")

    # Creacion de un Hilo para que tenga un minimo retraso entre cambio de texto
    #hilo=threading.Thread(target=mensaje, args=("Buenas, Jugadores, Vamos a empezar la Partida de BlackJack",))
    #hilo.start()
    labelentry.config(text = "Buenas, Jugadores, Vamos a empezar la Partida de BlackJack")
#----------------Metodo que contiene la funcionalidad del Hilo------------------------------
"""def mensaje(msg):
        global labelentry
        time.sleep(3)
        labelentry.config(text=msg)"""

#--------Metodo para mostrar la baraja y los componentes para Ingresar el nombre----------
def IniciarComponentes():
    global contenedor, nombrejugador, labelentry, TextoBoton
    global entrynombre, BotonOK

    DeckDir = carpetaraiz + "/Poker Cards/Images/Deck.png"
    imagendeck.append(setimagen(DeckDir,180,230))
    Decklabel = Label(contenedor, image = imagendeck[0])
    Decklabel.place(x=275,y=120)

    labelentry = Label(contenedor, text = "Ingrese el nombre del Jugador: ", font = ("Arial",10))
    labelentry.place(x=200, y=350)
    nombre = StringVar()
    entrynombre = Entry(contenedor, textvariable = nombre)
    entrynombre.place(x=200, y=380)
    entrynombre.config(width = 40, font = ("Arial",10))
    nombrejugador.set(nombre.get())
    print nombrejugador.get()

    TextoBoton = StringVar()
    TextoBoton.set("OK")
    BotonOK = Button(contenedor, textvariable = TextoBoton, font = ("Arial", 10), width = 10)
    BotonOK.place(x=489, y=376)
    #if(nombrejugador.get()!=""):
    BotonOK.config(command = lambda :Marcador(str(nombre.get())))

#----------------------Creacion de Ventana------------------------
ventana = Tk()
ventana.title("BlackJack Game v 0.1")
ventana.config(bg="grey")
ventana.iconbitmap(carpetaraiz+"\Poker Cards\Images\Poker Icon 1.ico")
contenedor = Frame(ventana, width = 720, height = 640)
contenedor.pack(fill = "y", expand = True)
"""bgimagen = Image.open(carpetaraiz + "/Poker Cards/Images/Poker Table (1).png")
ph = ImageTk.PhotoImage(bgimagen)
background_image = Label(contenedor, image = ph)
background_image.place(x=0,y=0)"""

framecartas = Frame(contenedor)
framecartas.place(width=680, height=210, x=18, y=417)
#framecartas.config(bd=3, relief="ridge")

Etitulo =Label(contenedor,text="BlackJack", font=("Arial",40,"bold"))
Etitulo.place(x=235,y=20)

BotonStart = Button(contenedor, text = "Start Game", font = ("Arial", 10), width = 30, bg = "grey",command=IniciarComponentes)
BotonStart.place(x=240, y=90)

nombrejugador= StringVar()
nombrejugador.set("")
#----------------------Metodo para saber las cordenadas de la pantalla haciendo un Click--------
def getorigin(eventorigin):
    global x0,y0
    x0 = eventorigin.x
    y0 = eventorigin.y
    print(x0,y0)
#mouseclick event
contenedor.bind( "

U4: PRACTICA #10 CALENDARIO.

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

#!/usr/bin/env phyton

#- * - coding: utf - 8 -*-
#Simple calendario con tkinter


import calendar
import Tkinter as tk
import datetime

# Obtenemos los valores del ano y mes a mostrar

ano = datetime.date.today ().year
mes = datetime.date.today ().month


def writeCalendar(ano, mes):
    # Asignamos el ano y mes al calendario

    str1 = calendar.month (ano, mes)
    label1.configure (text=str1)

def mesAnterior():
    global mes, ano
    mes -= 1

    if ano == 0:

     mes = 12

    ano -= 1
    writeCalendar (ano, mes)


def mesSiguiente():
    global mes, ano
    mes += 1

    if mes == 13:
     mes = 1

    ano += 1

    writeCalendar (ano, mes)


root = tk.Tk ()
root.title ("Calendario")

# Lo posicionamos en un label

label1 = tk.Label (root, text="", font=('courier', 40, 'bold'), bg='white', justify=tk.LEFT)
label1.grid (row=1, column=1)

# ponemos los botones dentro un Frame

frame = tk.Frame (root, bd=5)
anterior = tk.Button (frame, text="Anterior", command=mesAnterior)
anterior.grid (row=1, column=1, sticky=tk.W)
siguiente = tk.Button (frame, text="Siguiente", command=mesSiguiente)
siguiente.grid (row=1, column=2)
frame.grid (row=2, column=1)

writeCalendar (ano, mes)

# ejecutamos el evento loop

root.mainloop ()

U4: PRACTICA #9 ARCHIVO GIF.

LINK: DESCARGAR ARCHIVOS

EJECUCIÓN DE PROGRAMA.

CÓDIGO DE PYTHON:

#Aportacion.- Alan Hernandez Mijangos
#Programa.- que toma un archivo GIF y lo muestra al hacer clic en un boton
# -*- coding: utf-8 -*-import Tkinter as tk
from Tkinter import *

ventana = Tk()
ventana.geometry('500x500')
ventana.config(bg="black")
ventana.title("Mostrando y ocultando un boton con una imagen")

def btn_hide():
    if b1.winfo_ismapped():
        b1.place_forget()
        b2.configure(text="Mostrar carita", width=15)
    else:
        b1.place(x=100, y=50)
        b2.configure(text="Ocultar carita", width=15)

imgBoton = PhotoImage(file="Logo_ITM.gif")
b1 = Button(ventana, text="Boton 1", image=imgBoton, fg="black", width=300)
b1.place(x=90, y=50)
b2 = Button(ventana, text="Ocultar carita", command=btn_hide, fg="black", width=15)
b2.place(x=130, y=280)

ventana.mainloop()

U4: PRACTICA #8 ENCRIPTACIÓN DE TEXTO.

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA.

 CÓDIGO DE PYTHON:

# -*- coding: utf-8 -*-
from Tkinter import *

# Jesus Eduardo Martinez Hinojosa

# Ventana
ventana = Tk()
ventana.geometry("300x300+350+80")
ventana.title("Encriptador")
ventana.resizable(width=False, height=False)
try:
    ventana.iconbitmap("icono.ico")
except:
    print("no hay icono disponible")

# Clave
numclave = 1


# Funciones.
def boton1():
    # Cifrado Cesar
    TAM_MAX_CLAVE = 26

    def obtenerModo():
        modo = "e"
        return modo

    def obtenerMensaje():
        mensaje = text.get("0.0", END)
        return mensaje

    def obtenerClave():
        global numclave
        clave = numclave
        return clave

    def obtenerMensajeTraducido(modo, mensaje, clave):
        if modo[0] == 'd':
            clave = -clave
        traduccion = ''
        for simbolo in mensaje:
            if simbolo.isalpha():
                num = ord(simbolo)
                num += clave
                if simbolo.isupper():
                    if num > ord('Z'):
                        num -= 26
                    elif num < ord('A'):
                        num += 26
                elif simbolo.islower():
                    if num > ord('z'):
                        num -= 26
                    elif num < ord('a'):
                        num += 26
                traduccion += chr(num)
            else:
                traduccion += simbolo
        return traduccion

    modo = obtenerModo()
    mensaje = obtenerMensaje()
    if modo[0] != 'b':
        clave = obtenerClave()

    if modo[0] != 'b':
        texto = (obtenerMensajeTraducido(modo, mensaje, clave))
        text.delete("0.0", END)
        text.insert("0.0", texto)
        informe1.config(text="Texto Encriptado")
    else:
        for clave in range(1, TAM_MAX_CLAVE + 1):
            print(clave, obtenerMensajeTraducido('desencriptar', mensaje, clave))


def boton2():
    # Cifrado Cesar
    TAM_MAX_CLAVE = 26

    def obtenerModo():
        modo = "d"
        return modo

    def obtenerMensaje():
        mensaje = text.get("0.0", END)
        return mensaje

    def obtenerClave():
        global numclave
        clave = numclave
        return clave

    def obtenerMensajeTraducido(modo, mensaje, clave):
        if modo[0] == 'd':
            clave = -clave
        traduccion = ''
        for simbolo in mensaje:
            if simbolo.isalpha():
                num = ord(simbolo)
                num += clave
                if simbolo.isupper():
                    if num > ord('Z'):
                        num -= 26
                    elif num < ord('A'):
                        num += 26
                elif simbolo.islower():
                    if num > ord('z'):
                        num -= 26
                    elif num < ord('a'):
                        num += 26
                traduccion += chr(num)
            else:
                traduccion += simbolo
        return traduccion

    modo = obtenerModo()
    mensaje = obtenerMensaje()
    if modo[0] != 'b':
        clave = obtenerClave()

    if modo[0] != 'b':
        texto = (obtenerMensajeTraducido(modo, mensaje, clave))
        text.delete("0.0", END)
        text.insert("0.0", texto)
        informe1.config(text="Texto Desencriptado")
    else:
        for clave in range(1, TAM_MAX_CLAVE + 1):
            print(clave, obtenerMensajeTraducido('desencriptar', mensaje, clave))


def salir():
    ventana.destroy()


def menu_activacion(event):
    menu_despegable.post(event.x_root, event.y_root)


def cortar():
    text.clipboard_clear()
    text.clipboard_append(text.selection_get())
    sel = text.get(SEL_FIRST, SEL_LAST)
    text.delete(SEL_FIRST, SEL_LAST)


def copiar():
    text.clipboard_clear()
    text.clipboard_append(text.selection_get())


def pegar():
    tem = text.selection_get(selection="CLIPBOARD")
    text.insert(INSERT, tem)


# Widget
b1 = Button(ventana, text="Encriptar", bg='black', fg='white', activebackground='cyan',
            activeforeground='dark slate gray', command=boton1, font=("Courier New", 9))
b2 = Button(ventana, text="Desencriptar", bg='black', fg='white', activebackground='cyan',
            activeforeground='dark slate gray', command=boton2, font=("Courier New", 9))
text = Text(ventana, fg='lavender', bg='dark slate gray', font=("Courier New", 10))
informe1 = Label(ventana, text="Ingrese un texto", bg="turquoise", font=("Courier New", 10))

# Empaquetado de los widget
b1.place(x=10, y=260, width=120, height=30)
b2.place(x=167, y=260, width=120, height=30)

informe1.place(x=0, y=0, width=300, height=30)

text.place(x=0, y=30, height=218, width=300)

# Menu popup(menu despegable)
menu_despegable = Menu(ventana, tearoff=0)
menu_despegable.add_command(label="Cortar", command=cortar, font=("Courier New", 9))
menu_despegable.add_command(label="Copiar", command=copiar, font=("Courier New", 9))
menu_despegable.add_command(label="Pegar", command=pegar, font=("Courier New", 9))
menu_despegable.add_separator()
menu_despegable.add_command(label="Salir", command=salir, font=("Courier New", 9))

# Evento del menu despegable
text.bind("", menu_activacion)

# donde mantener el enfoque.
ventana.mainloop()

U4: PRACTICA #7 INTERÉS ANUAL.

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

#programa que calcula el interes anual

#!/usr/bin/env python
#  -*- coding: utf-8 -*-

import sys
from Tkinter import *
import tkMessageBox

def interes():

        v1 = int(ent1.get())
        v2 = int(ent2.get())
        v3 = int(ent3.get())
        r = v1 * v2 / 100
        g=(r * v3)
        f= g + v1
        print "Cuando pasen", v3, "anos, con un interes de", v2, " usted habra generado",f , "pesos"
v = Tk()
v.title("Interes")
v.geometry("400x250")

vp= Frame(v)
vp.grid(column=0, row=0, padx=(50,50), pady=(10,10))
vp.columnconfigure(0, weight=1)
vp.rowconfigure(0,weight=1)

e1 = Label(vp, text="Pesos:")
e1.grid(row=2, column=4, padx=(20, 20), pady=(20, 20))

e2 = Label(vp, text="Interes:")
e2.grid(row=3, column=4, padx=(20, 20), pady=(20, 20))

e3 = Label(vp, text="Anos:")
e3.grid(row=4, column=4, padx=(20, 20), pady=(20, 20))

val1 = ""
ent1 = Entry(vp, width=12, textvariable=val1)
ent1.grid(row=2, column=5)

val2 = ""
ent2 = Entry(vp, width=12, textvariable=val2)
ent2.grid(row=3, column=5)

val3 = ""
ent3 = Entry(vp, width=12, textvariable=val3)
ent3.grid(row=4, column=5)

b1 = Button(vp, text="Calcular", command=interes)
b1.grid(row=5, column=5, padx=(20, 20), pady=(20, 20))

v.mainloop()

U4: PRACTICA #6 AGREGAR DATOS.

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

#Aportacion.- Luis Angel Alonso Rojas
#programa que hace la interfaz
#programa que te pide tus datos basicos
#Luis Angel Alonso Rojas#15260607

from Tkinter import *
root = Tk()
root.title('formulario 1')
nombre_label = Label(root,text="Nombre :")
nombre_label.grid(row=1,column=1)
nombre_str = StringVar()
nombre_entry = Entry(root,textvariable=nombre_str)
nombre_entry.grid(row=1,column=2)
last_label= Label(root,text="Apellido : ")
last_label.grid(row=2,column=1)
last_str = StringVar()
last_entry = Entry(root,textvariable=last_str)
last_entry.grid(row=2,column=2)
mail_label = Label(root,text="Email : ")
mail_label.grid(row=3,column=1)
mail_str = StringVar()
mail_entry = Entry(root,textvariable=mail_str)
mail_entry.grid(row=3,column=2)
endfinish = Button(root,text="finalizar",relief=FLAT)
endfinish.grid(row=4,column=2)

root.mainloop()

U4: PRACTICA #5 LISTADO DE PELICULAS.

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA.

CÓDIGO DE PYTHON:

# coding=utf-8
#Aportacion de Brandon Asael Cerda Hernandez
#Programa: con listas, combo box, agrega a la lista las peliculas al guardar
#excelente programa en python!!!


# -*- coding: utf-8 -*-from Tkinter import Label,Entry,Button,Tk,Frame,W,N,S,E,END,HORIZONTAL,Spinbox

from ttk import *
from tkMessageBox import askyesno,showinfo,showerror;
from Tkinter import *
#en el import, solo estoy pidiendo importar los elementos que vamos a usar, para no usar el * sin necesidad de traer mas elementos
def AddEntryMovie():

    Movie = CatchMovie.get()
    if (CatchMovie.get()==""):
        CatchMovie.config(bg="red")
        showerror("What Movie it is?", "Por favor ingresa una pelicula! no dejes el campo en blanco!")
        CatchMovie.config(bg="white")


    if (Classes.get()==""):
            #otra pequeña "excepcion" por si la clasificación de la pelicula no tiene seleccionada una clasificacion
        showerror("What Movie it is?","Por favor selecciona una clasificacion!")

    if (askyesno("Are you sure?", "Deseas añadir esta pelicula: \n\""+Movie+"\"\nA la lista de peliculas?")==True):
                values = list(MoviesOnList["values"])
                #se crea dentro de la funcion la Variable "values" que sera una lista de los valores que se encuentran en la lista despegable
                MoviesOnList["values"] = values + [Movie]
                #de la lista despegalble agregamos el nuevo valor que esta en nuestro campo de texto, para esto debemos ponerlo entre                #  [] para que se interprete como el valor de una lista y pueda sumarse a la lista despegable de peliculas
                Classifications.insert(i,Classes.get())
                #añade la clasificiación a una lista, para asi tenerla disponible en la Lista Despegable de Peliculas disponibles
                Mov.insert(i,Movie)
                i+1
                CatchMovie.delete(0, END)
                #ya lo hemos visto antes pero lo explicare aun asi, .delete(0, END) borra el texto dentro del Entry
                CatchMovie.insert(0, "")
                #Aqui es casi lo mismo, pero deja el campo Vacio y usable, tambien para evitar errores de captura
                Classes.set("")
                #Reinicia la Lista Despegable de las clasificaciones

                showinfo("Exito!","Has anadido: \""+Movie+"\" A la lista de Peliculas")
    else:
                showinfo("Guess No","La Pelicula: "+Movie+" No sera anadida")
def firstDone():
    if (askyesno("Are you sure?","ADVERTENCIA: ESTA ACCION NO PUEDE SER DESHECHA" "\nSi de verdad ya terminaste te agregar peliculas, prosigue, si no, DETENTE!")==True):
        CatchMovie.config(state="disable")
        Classes.config(state="disable")
        AddMov.config(state="disable")
        Done.config(state="disable")
        #tambien se habia visto antes, pero explicare aun asi, el 'state' "disable" deshabilita el componente del frame        app.geometry("600x300")
        #se puede cambiar la dimension de una ventana, aunque se haya establecido un tamaño, esto nos permite controlar la ventana y los componentes a mostrar
        MovietoRent.grid()
        MoviesOnList.grid()
        ClassifiedAs.grid()
        AskRent.grid()
        Days4Rent.grid()
        Rent.grid()
        #simplemente con .grid() vuelvo a colocar en su respectivo lugar, los elementos que no son visibles para el usuario, ocultos con '.grid_remove()'
        showinfo("","Puedes seguir agregando peliculas si gustas!")
def MovieSel(self):
    ClassifiedAs.config(state="normal")
    #para que un Entry pueda mostrar un texto, es necesario que este en un estado normal (state="normal")
    ClassifiedAs.delete(0, END)
    ClassifiedAs.insert(0, Classifications.__getitem__(Mov.index(MoviesOnList.get())))
    #aqui se hace uso de la Lista [] y el atributo "__getitem__()" para obtener lo que este en la lista, para ello    #es necesario poner un indice numerico, asi que utilizando ".index()" puedo llamar solo el indice (numero en la lista)    #y .__getitem__() obtendra el objeto que este en ese indice de la lista, para asi poder mostrar la clasificación correecta    ClassifiedAs.config(state="readonly")
    #al cambiar el estado a "Solo Lectura" (state="readonly") el Entry solo mostrara Texto, pero no permitira la entrada de datos o textos
def RentAMovie():
    if (askyesno("You ready?","Deseas Rentar la pelicula: "+MoviesOnList.get()+
                              "\n por "+Days4Rent.get()+" Dia/s?")==True):
        if (ClassifiedAs.get()=="Adultos"):
            if(askyesno("Age Issue","Eres Mayor de Edad?")==True):
                showinfo("Ask for: ","Presente su Identificación")
            else:
                showerror("Get outta here","NO SE RENTAN PELICULAS A MENORES")
        else:
            showinfo("Have a nice day!","Disfruta de tu pelicula! \nQue tengas un Buen dia :)")
    else:
        showinfo("Ok?","De acuerdo, revisa tus opciones entonces :)")
app = Tk()
app.geometry("600x120")
app.title("Lista de Peliculas")
vp = Frame(app)
vp.grid(column=0,row=0,padx=(30,30), pady=(20,20))
vp.rowconfigure(0, weight=1)
vp.columnconfigure(0, weight=1)
Classified = Label(vp, text="Clasificación")
Classified.grid(column=2, row=1, padx=(10,10), pady=(10,10))
AskMov = Label(vp, text="Ingrese una Pelicula: ")
AskMov.grid(column=1, row=1, padx=(10,10), pady=(10,10), sticky=W)
cMovie=StringVar
CatchMovie = Entry(vp, textvariable=cMovie, width=35)
CatchMovie.grid(column=1, row=2, padx=(10,10), pady=(10,10))
AddMov = Button(vp, text="Añadir", command=AddEntryMovie)
AddMov.grid(column=3, row=2, padx=(10,10), pady=(10,10))
Done = Button(vp, text="Finalizar", command=firstDone)
Done.grid(column=4, row=2, padx=(10,10), pady=(10,10))
Classes = Combobox (vp, state="readonly")
Classes.grid(column=2, row=2, padx=(10,10), pady=(10,10))
Classes["values"]=["Para todas las Edades","Familiar","Mayores de 10","Adolescentes","Mayores de 15","Adultos"]
Separator(vp, orient=HORIZONTAL).grid(column=1,row=3,columnspan=4,sticky=W+E,pady=(10,10))
MovietoRent = Label(vp, text="Pelicula a Rentar: ")
MovietoRent.grid(column=1, row=4, padx=(10,10), pady=(30,10), stick=W)
MovietoRent.grid_remove()
MoviesOnList = Combobox (vp, state="readonly")
MoviesOnList.grid(column=1,row=5,padx=(10,10),pady=(10,10), sticky=W+E)
MoviesOnList.bind(MovieSel)
MoviesOnList.grid_remove()
ClassifiedAs = Entry (vp,state="readonly")
ClassifiedAs.grid(column=2, row=5, padx=(10,10), pady=(10,10), sticky=W+E)
ClassifiedAs.grid_remove()
AskRent = Label(vp, text="Dias\n a Rentar")
AskRent.grid(column=3, row=4, padx=(10,10), pady=(10,10))
AskRent.grid_remove()
Days4Rent = Spinbox(vp,width=5, from_=1, to=7)
Days4Rent.grid(column=3, row=5, padx=(10,10), pady=(10,10), sticky=N+S)
Days4Rent.grid_remove()
Rent = Button(vp, text="Rentar", command=RentAMovie)
Rent.grid(column=4, row=5, padx=(10,10), pady=(10,10))
Rent.grid_remove()
Classifications = []
Mov = []
i = int(0)
app.mainloop()

U4: PRACTICA #4 INDICE DE MASA CORPORAL.

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

#Aportacion de Cecilia Abigal Cantu Alcala
#programa que calcula IMC

# -*- coding: utf-8 -*-import sys
import Tkinter
from Tkinter import *
import tkMessageBox

def imc():
    num1 = float(entrada_peso.get())
    num2 = float(entrada_altura.get())
    imc = (num1 / (num2*num2))

    if imc == 0 or imc < 18:
        tkMessageBox.showinfo("Resultado", "Peso bajo. Necesario valorar signos de desnutricion")

    elif imc == 18 or imc < 25:
        tkMessageBox.showinfo("Resultado", "Usted tiene un peso normal")

    elif imc == 25 or imc < 27:
        tkMessageBox.showinfo("Resultado", "Usted padece sobrepeso")

    elif imc == 27 or imc < 30:
        tkMessageBox.showinfo("Resultado", "Usted padece obesidad grado I")

    elif imc == 30 or imc < 40:
        tkMessageBox.showinfo("Resultado", "Usted padece de obesidad grado II")

    else:
        tkMessageBox.showinfo("Resultado", "Usted padece de obesidad morbida")

ventana=Tk()
ventana.title("Calculo de IMC")
ventana.geometry("400x200")
ventana.config(bg="rosybrown")

vp = Frame(ventana)
vp.grid(column=0, row=0, padx=(50, 50), pady=(10, 10)) #para posicionar cualquier objetovp.columnconfigure(0, weight=1)
vp.rowconfigure(0, weight=1)

peso = IntVar()
altura = float()

etiqueta_peso = Label(ventana, text='Peso(kg):', bg='ivory')
etiqueta_peso.grid(row=1, column=1,  padx=(10, 10), pady=(10, 10), sticky=E)

entrada_peso = Entry(ventana, textvariable=peso)
entrada_peso.grid(row=1, column=2,  padx=(10, 10), pady=(10, 10), sticky=E)

etiqueta_altura = Label(ventana, text='Altura(mts): ', bg='ivory')
etiqueta_altura.grid(row=2, column=1, padx=(10, 10), pady=(10, 10), sticky=E)

entrada_altura = Entry(ventana, textvariable=altura)
entrada_altura.grid(row=2, column=2, padx=(10, 10), pady=(10, 10), sticky=E)

bconv = Button(ventana, bg='plum', fg='white', text='Calcular IMC', width=10, height=1, command=imc)
bconv.grid(row=4, column=2, padx=(10, 10), pady=(10, 10))

ventana.mainloop()

U4: PRACTICA #3 SIGNO ZODIACAL

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGAMA

CÓDIGO DE PYTHON:

#Aportacion de Cecilia Abigal Cantu Alcala
#programa que saca el signo zodiacal

import sys
import Tkinter as tk
from Tkinter import *
import tkMessageBox

ventana=Tk()
ventana.title("Signo Zodiacal")
ventana.geometry("400x200")
ventana.config(bg="rosybrown")

vp = Frame(ventana)
vp.grid(column=0, row=0, padx=(50, 50), pady=(10, 10)) #para posicionar cualquier objetovp.columnconfigure(0, weight=1)
vp.rowconfigure(0, weight=1)

var = StringVar(ventana)
ver=StringVar(ventana)
var.set("Enero")  # initial valuever = StringVar(ventana)
ver.set("1")  # initial value
etiqueta_mes = Label(ventana, text='Mes de nacimiento: ')
ent_mes = OptionMenu(ventana, var, "Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre", )
etiqueta_mes.grid(row=1, column=1, padx=(10, 10), pady=(10, 10), sticky=E)
ent_mes.grid(row=1, column=3)

etiqueta_dia = Label(ventana, text='Dia de nacimiento: ')
ent_dia = OptionMenu(ventana, ver, "1", "2", "3","4", "5", "6","7", "8", "9","10", "11", "12","13", "14", "15","16", "17", "18","19", "20", "21","22", "23", "24", "25", "26", "27", "28", "29", "30", "31")
etiqueta_dia.grid(row=4, column=1, padx=(10, 10), pady=(10, 10), sticky=E)
ent_dia.grid(row=4, column=3)

def signo():
    month= str(var.get())
    day= int(ver.get())
    if month=="Marzo" and day>=21 or month=="Abril" and day<=20:
        tkMessageBox.showinfo("Signo","Eres Aries")
    elif month == "Abril" and day >= 21 or month == "Mayo" and day <= 21:
        tkMessageBox.showinfo("Signo", "Eres Tauro")
    elif month == "Mayo" and day >= 22 or month == "Junio" and day <= 21:
        tkMessageBox.showinfo("Signo", "Eres Gemenis")
    elif month=="Junio" and day>=22 or month=="Julio" and day<=22:
        tkMessageBox.showinfo("Signo","Eres Cancer")
    if month=="Julio" and day>=23 or month=="Agosto" and day<=23:
        tkMessageBox.showinfo("Signo","Eres Leo")
    if month=="Agosto" and day>=24 or month=="Septiembre" and day<=23:
        tkMessageBox.showinfo("Signo","Eres Virgo")
    if month=="Septiembre" and day>=24 or month=="Octubre" and day<=23:
        tkMessageBox.showinfo("Signo","Eres Libra")
    if month=="Octubre" and day>=24 or month=="Noviembre" and day<=22:
        tkMessageBox.showinfo("Signo","Eres Escorpion")
    if month=="Noviembre" and day>=23 or month=="Diciembre" and day<=21:
        tkMessageBox.showinfo("Signo","Eres Sagitario")
    if month=="Diciembre" and day>=22 or month=="Enero" and day<=20:
        tkMessageBox.showinfo("Signo","Eres Capricornio")
    if month=="Enero" and day>=21 or month=="Febrero" and day<=18:
        tkMessageBox.showinfo("Signo","Eres Acuario")
    if month=="Febrero" and day>=19 or month=="Marzo" and day<=20:
        tkMessageBox.showinfo("Signo","Eres Piscis")

boton = Button(ventana, text='Signo', command=signo, width=20)
boton.grid(row=5, column=1, padx=(10, 10), pady=(10, 10), sticky=E)

ventana.mainloop()

U4: PRACTICA #2 PUNTO DE VENTA

LINK: DESCARGAR CÓDIGO

EJECUCIÓN DE PROGRAMA

CÓDIGO DE PYTHON:

#Programa punto de venta, cuenta billetes, monedas etc...
#Aportacion de: Jose Manuel Sanchez Izaguirre
from Tkinter import *
import tkMessageBox

def SumMul():
    try:
        _e0= int(v0.get())
        _e0=_e0*.50
        _e1 = int(v1.get())
        _e1 = _e1 * 1
        _e2 = int(v2.get())
        _e2 = _e2 * 2
        _e3 = int(v3.get())
        _e3 = _e3 * 5
        _e4 = int(v4.get())
        _e4 = _e4 * 10
        _e5 = int(v5.get())
        _e5 = _e5 * 20
        _e6 = int(v6.get())
        _e6 = _e6 * 50
        _e7 = int(v7.get())
        _e7 = _e7 * 100
        _e8 = int(v8.get())
        _e8 = _e8 * 200
        _e9 = int(v9.get())
        _e9 = _e9 * 500
        _e10= _e0 + _e1 + _e2 + _e3 + _e4 + _e5 + _e6 + _e7 + _e8 + _e9
        tkMessageBox.showinfo("El resultado es", _e10)
    except ValueError:
        etiqueta.config(text="Introduce un numero entero")


v=Tk()
v.title("")
v.geometry("200x350")

vp = Frame(v)
vp.grid(column=0, row=0, padx=(50,50), pady=(10,10))
vp.columnconfigure(0, weight=1)
vp.rowconfigure(0, weight =1)

ET0=Label(vp,text="MONEDAS")
ET0.grid(column=2, row=1)

e0=Label(vp,text="0.50")
e0.grid(column=1, row=3)

e1=Label(vp,text="1.00")
e1.grid(column=1, row=4)

e2=Label(vp,text="2.00")
e2.grid(column=1, row=5)

e3=Label(vp,text="5.00")
e3.grid(column=1, row=6)

e4=Label(vp,text="10.00")
e4.grid(column=1, row=7)

v0  = Entry(vp, width=5, textvariable=e0)
v0.grid(row=3, column=2)

v1  = Entry(vp, width=5, textvariable=e1)
v1.grid(row=4, column=2)

v2 = Entry(vp, width=5, textvariable=e2)
v2.grid(row=5, column=2)

v3  = Entry(vp, width=5, textvariable=e3)
v3.grid(row=6, column=2)

v4  = Entry(vp, width=5, textvariable=e4)
v4.grid(row=7, column=2)

ET1=Label(vp,text="BILLETES")
ET1.grid(column=2, row=9)

e5=Label(vp,text="20.00")
e5.grid(column=1, row=11)

e6=Label(vp,text="50.00")
e6.grid(column=1, row=12)

e7=Label(vp,text="100.00")
e7.grid(column=1, row=13)

e8=Label(vp,text="200.00")
e8.grid(column=1, row=14)

e9=Label(vp,text="500.00")
e9.grid(column=1, row=15)

v5  = Entry(vp, width=5, textvariable=e5)
v5.grid(row=11, column=2)

v6  = Entry(vp, width=5, textvariable=e6)
v6.grid(row=12, column=2)

v7  = Entry(vp, width=5, textvariable=e7)
v7.grid(row=13, column=2)

v8  = Entry(vp, width=5, textvariable=e8)
v8.grid(row=14, column=2)

v9  = Entry(vp, width=5, textvariable=e9)
v9.grid(row=15, column=2)

b = Button(vp, text="TOTAL", command=SumMul)
b.grid(row=17, column=2, padx=(20, 20), pady=(20, 20))

v.mainloop()

PRACTICA #20: INTERFAZ GRÁFICA, BOTONES, CAJAS DE TEXTO Y ETIQUETAS

# -*- coding: utf-8 -*-

from Tkinter import *

def hacer_click():
    try:
        valor = int(entrada_texto.get())
        valor = valor * 5
        etiqueta.config(text = valor)

    except ValueError:
        etiqueta.config(text = "Introduzca un valor")

def hacer_click2():
    try:
        valor2 = int(entrada_texto2.get())
        valor2 = valor2 * 10
        etiqueta2.config(text = valor2)

    except ValueError:
        etiqueta2.config(text = "Introduzca un valor")


def hacer_click3():
    try:
        valor3 = int(entrada_texto3.get())
        valor3 = valor3 * 15
        etiqueta3.config(text = valor3)

    except ValueError:
        etiqueta3.config(text = "Introduzca un valor")


app = Tk() #marco de la aplicacion con el obj Tk
vp = Frame(app) #usamos el objeto frame
'''ahora le damos formato a nuestra ventana, y para eso
vamos a utilizar el metodo grid(), el cual nos va a permitir
posicionar los elementos graficos en nuestra ventana.

otro parametro que utilizaremos sera el margen: padx = (50,50)
lo cual indica 50 pixeles del lado izquierdo y 50 pixeles 
del lado derecho

luego utilizamos pady = (10,10), que son 10 pixeles en la parte
superior y 10 pixeles en la parte inferior'''

vp.grid(column = 0, row = 0, padx = (50,50), pady = (10,10))

'''luego vamos a utilizar los metodos columnconfigure()
y rowconfigure() los cuales nos van a servir para dar un
peso relativo del ancho y el alto de todos los elementos
 que se pongan en la ventana'''

vp.columnconfigure(0, weight = 1)
vp.rowconfigure(0, weight = 1)

'''creamos una etiqueta llamada valor y la posicionamos
con el metodo grid()'''

etiqueta = Label(vp, text = "valor") #creo un objeto etiqueta
etiqueta.grid(column = 100, row = 1)

etiqueta2 = Label(vp, text = "valor 2")
etiqueta2.grid(column = 100, row = 4)

etiqueta3 = Label(vp, text = "valor 3")
etiqueta3.grid(column = 100, row = 6)

'''creamos un boton de OK y posicionamos con grid '''

boton = Button(vp, text = "Multiplicar por 5", command = hacer_click)
boton.grid(column = 1, row = 1)

boton1 = Button(vp, text = "Multiplicar por 10", command = hacer_click2)
boton1.grid(column = 1, row = 4)

boton2 = Button(vp, text = "Multiplicar por 15", command = hacer_click3)
boton2.grid(column = 1, row = 6)

valor =""
entrada_texto = Entry(vp, width = 10, textvariable = valor)
entrada_texto.grid(column = 2, row = 1)

valor2 = ""
entrada_texto2 = Entry(vp, width = 10, textvariable = valor2)
entrada_texto2.grid(column = 2, row = 4)

valor3 = ""
entrada_texto3 = Entry(vp, width = 10, textvariable = valor3)
entrada_texto3.grid(column =2, row = 6)


app.mainloop() #es el metodo mainloop, lanza la ventana

Ejecución de código

PRACTICA #19: FILE MÚLTIPLE

#!/usr/bin/python
# -*- coding: utf-8 -*-
# www.pythondiario.com

import sys #importacion de la libreria sys
from Tkinter import * #importacion del modulo tkinter


def hacer_click(): #se crea una funcion
    try: #funciona en caso de que se ingrese a la caja de texto un valor diferente a un numero
        _valor = int(entrada_texto.get()) #captura lo que se ingrese a la caja de texto y lo guarda en _valor
        _valor = _valor * 5 #multiplica por 5 lo capturado por la caja y lo guarda en _valor
        etiqueta.config(text=_valor) #modifica la etiqueta por el valor resultante al multiplicar por 5
    except ValueError: #es parte del try, y se utiliza en caso de que se ingrese un valor distinto a un numero
        etiqueta.config(text="Introduce un numero!") #muestra una etiqueta y manda un mensaje


app = Tk() #se crea la ventana de la app
app.title("Mi segunda App Grafica") #se le da titulo a la ventana

# Ventana Principal
vp = Frame(app) #organiza y da formato a la ventana
vp.grid(column=0, row=0, padx=(50, 50), pady=(10, 10)) #posiciona los elementos graficos en nuestra ventana
vp.columnconfigure(0, weight=1) #da un peso relativo al ancho y alto de todos los elementos que se pongan en la ventana
vp.rowconfigure(0, weight=1) #da un peso relativo al ancho y alto de todos los elementos que se pongan en la ventana

etiqueta = Label(vp, text="Valor") #se crea una etiqueta
etiqueta.grid(column=2, row=2, sticky=(W, E)) #se posiciona la etiqueta

boton = Button(vp, text="OK!", command=hacer_click) #se crea un boton que accionara la funcion hacer_click
boton.grid(column=1, row=1) #se posiciona el boton

valor = "" #se crea una variable
entrada_texto = Entry(vp, width=10, textvariable=valor) #se crea una caja de texto para ingresar datos
entrada_texto.grid(column=2, row=1) #se posiciona la caja de texto

app.mainloop() #ejecuta la ventana para que se pueda visualizar

Ejecución de código

PRACTICA #18: VENTANA CON BOTÓN Y ETIQUETA

#!/usr/bin/python
# -*- coding: utf-8 -*-
# www.pythondiario.com

from Tkinter import *

app = Tk()
app.title("Aplicacion grafica en python")
etiqueta = Label(app, text="Hola mundo!!!")
boton = Button(app, text="OK!!")

etiqueta.pack()
boton.pack()
app.mainloop()

Ejecución de código

PRACTICA #17: ABRIR ARCHIVOS DE MI COMPUTADORA MEDIANTE CODIGO

#!/usr/bin/python
# -*- coding: utf-8 -*-
# www.pythondiario.com

from Tkinter import *
from tkFileDialog import askopenfilename


def llamada():
    nombre = askopenfilename()
    print nombre


errmsg = 'Error!'
Button(text='Abrir archivo', command=llamada).pack(fill=X)
mainloop()

Ejecución de código

PRACTICA #16: CAJA DE DIALOGO

#!/usr/bin/python
# -*- coding: utf-8 -*-
# www.pythondiario.com

from Tkinter import *
from tkMessageBox import *


def pregunta():
    showerror("Pregunta", "Discuple, no hay preguntas disponibles")


def devolucion():
    if askyesno('Verificar', '¿Realmente quiere salir?'):
        showwarning('Si', exit())
    else:
        showinfo('No', 'Salir fue cancelado')


Button(text='Salir', command=devolucion).pack(fill=X)
Button(text='Pregunta', command=pregunta).pack(fill=X)
mainloop()

Ejecucion de codigo

PRACTICA #15: JUEGO PIEDRA,PAPEL O TIJERA, AUTOR CARLOS OLVERA

LINK: DESCARGAR CÓDIGO E IMÁGENES

from Tkinter import *  # libreria para utilizar las ventanas,labels,ventanasemergentes y botones
from tkMessageBox import *  # para poder utilizar el abra el cuadro de dialogo
import random  # para poder generar nuneros aleatorios


def funcion(opcion):
    tiposdemanos = ['piedra', 'papel', 'tijera']  # creo un arreglo con tres valores posibles
    eleccion_aleatoria = random.choice(
        tiposdemanos)  # a la variable le asigno un valor a traves de random utilizando uno de los tres valores que estan en el array
    decisioncpu = eleccion_aleatoria  # la variable decision cpu se iguala
    decision_usuario = opcion  # utilizo como parametro la variable opcion y la igualo a decision usuario para poder usarla en el if

    if decision_usuario == 1:  # el numero uno lo uso como tijera y ese valor se lo asigno al presionar el boton 'piedra'
        Decisionusuario = Label(ventana, text='elegiste piedra', font=("agency fb", 12)).place(x=50, y=220)
        imagen1 = PhotoImage(file='piedrausuario.gif')  # utilizo una imagen para mostrar mi seleccion
        lblusuario = Label(ventana, image=imagen1).place(x=50, y=300)  # muestro esa image a traves de un label
        DecisionCPU = Label(ventana, text=('la cpu eligio ' + decisioncpu), font=("agency fb", 12)).place(x=300,
                                                                                                          y=220)  # muestro en pantalla la decision random que genero
        if decisioncpu == "piedra":  # la decision random la comparo con cadenas de caracteres en los 3 casos
            imagen2 = PhotoImage(file='piedracpu.gif')  # eligo la imagen determinada
            lblcpu = Label(ventana, image=imagen2).place(x=250, y=300)  # y la muestro en pantalla
            showinfo(title='resultado',
                     message='empate')  # atravez de una ventana emergente muestro si gano,perdio o empato

        elif decisioncpu == 'papel':
            imagen2 = PhotoImage(file='papelcpu.gif')
            lblcpu = Label(ventana, image=imagen2).place(x=250, y=300)
            showinfo(title='resultado ', message='perdiste')

        else:
            imagen2 = PhotoImage(file='tijeracpu.gif')
            lblcpu = Label(ventana, image=imagen2).place(x=250, y=300)
            showinfo(title='resultado', message='Ganaste')



    elif decision_usuario == 2:
        imagen1 = PhotoImage(file='papelusuario.gif')
        lblusuario = Label(ventana, image=imagen1).place(x=50, y=300)
        Label10 = Label(ventana, text='elegiste papel', font=("agency fb", 12)).place(x=50, y=220)
        Label11 = Label(ventana, text=('la cpu eligio ' + decisioncpu), font=("agency fb", 12)).place(x=300, y=220)
        if decisioncpu == 'piedra':
            imagen2 = PhotoImage(file='piedracpu.gif')
            lblcpu = Label(ventana, image=imagen2).place(x=250, y=300)
            print 'haz ganado pax'
            showinfo(title='resultado ', message='Ganaste')
        elif decisioncpu == 'papel':
            imagen2 = PhotoImage(file='papelcpu.gif')
            lblcpu = Label(ventana, image=imagen2).place(x=250, y=300)
            print 'empate'
            showinfo(title='resultado', message='empate')

        else:
            imagen2 = PhotoImage(file='tijeracpu.gif')
            lblcpu = Label(ventana, image=imagen2).place(x=250, y=300)
            print 'haz perdido!!!!'
            showinfo(title='resultado ', message='perdiste')

    elif decision_usuario == 3:
        imagen1 = PhotoImage(file='tijerausuario.gif')
        lblusuario = Label(ventana, image=imagen1).place(x=50, y=300)
        Label10 = Label(ventana, text='elegiste tijera', font=("agency fb", 12)).place(x=50, y=220)
        Label11 = Label(ventana, text=('la cpu eligio ' + decisioncpu), font=("agency fb", 12)).place(x=300, y=220)
        if decisioncpu == 'piedra':
            imagen2 = PhotoImage(file='piedracpu.gif')
            lblcpu = Label(ventana, image=imagen2).place(x=250, y=300)
            showinfo(title='resultado ', message='perdiste')
        elif decisioncpu == 'papel':
            imagen2 = PhotoImage(file='papelcpu.gif')
            lblcpu = Label(ventana, image=imagen2).place(x=250, y=300)
            showinfo(title='resultado ', message='ganaste')
        else:
            imagen2 = PhotoImage(file='tijeracpu.gif')
            lblcpu = Label(ventana, image=imagen2).place(x=250, y=300)
            showinfo(title='resultado ', message='empate')


ventana = Tk()
ventana.geometry("500x500")
ventana.title('JUEGO DEL PIEDRA PAPEL O TIJERA')

label1 = Label(text="ELIGA UNO DE LOS 3", font=("agency fb", 18)).place(x=10, y=30)

label3 = Label(ventana, text='PIEDRA,PAPEL O TIJERA').place(x=0, y=0)
label2 = Label(ventana, text='un juego clasico y sencillo').place(x=0, y=0)
# boton para piedra
Piedra = Button(ventana, text='piedra', command=lambda: funcion(1)).place(x=50, y=100)
# boton para papel
Papel = Button(ventana, text='papel', command=lambda: funcion(2)).place(x=150, y=100)
# boton para tijera
Tijera1 = Button(ventana, text='tijera', command=lambda: funcion(3)).place(x=250, y=100)

ventana.mainloop()