FIGURA 3D EN 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)
    )
#triangulo
#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)

#visual python
main() 

       

MI FIGURA EN 2D EN PYTHON UTILIZANDO CANVAS

CAPTURA

CODIGO

       
from Tkinter import *
canvas = Canvas(width=600, height=600, bg='white')
canvas.create_polygon(300, 10,270,60,270,60,330,60, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(270, 70,330,70,330,70,300,120, fill='aqua',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(260, 70,290,120,290,120,230,120, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(310,120,370,120,370,120,340,70, fill='cornflowerblue',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(230,130,290,130,290,130,260,180, fill='aquamarine',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(310,130,370,130,370,130,340,180, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(220,130,250,180,250,180,190,180, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(380,130,350,180,350,180,410,180, fill='paleturquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(190,190,250,190,250,190,220,240, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(190,190,250,190,250,190,220,240, fill='lightblue',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(180,190,210,240,210,240,150,240, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(350,190,410,190,410,190,380,240, fill='cornflowerblue',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(420,190,390,240,390,240,450,240, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(150,250,210,250,210,250,180,300, fill='darkcyan',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(390,250,450,250,450,250,420,300, fill='powderblue',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(140,250,110,300,110,300,170,300, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(460,250,490,300,490,300,430,300, fill='royalblue',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(110,310,170,310,170,310,140,360, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(430,310,490,310,490,310,460,360, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(100,310,130,360,130,360,70,360, fill='skyblue',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(70,370,130,370,130,370,100,420, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(60,370,90,420,90,420,30,420, fill='powderblue',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(110,420,170,420,170,420,140,370, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(190,420,250,420,250,420,220,370, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(270,420,330,420,330,420,300,370, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(350,420,410,420,410,420,380,370, fill='deepskyblue',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(430,420,490,420,490,420,460,370, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(510,420,570,420,570,420,540,370, fill='powderblue',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(150,370,210,370,210,370,180,420, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(230,370,290,370,290,370,260,420, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(310,370,370,370,370,370,340,420, fill='paleturquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(390,370,450,370,450,370,420,420, fill='mediumturquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(470,370,530,370,530,370,500,420, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

canvas.create_polygon(530,360,470,360,470,360,500,310, fill='turquoise',outline='black', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)


mainloop()

       

PROGRAMAS CON FIGURAS CANVAS

CAPTURA

CODIGO

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

v0 = Tk()
v0.title("Ventana madre")
v0.config(bg="black")
v0.geometry("1400x200")
def mostrar(num):
    v1 = Toplevel(v0)
    v1.title("Ventana hija")
    v1.protocol("WM_DELETE_WINDOW", "onexit")
    v1.config(bg="black")
    v1.geometry("500x500")
    if  num==1:
     hola = Canvas(v1, width=300, height=210, bg='white')
     hola.pack(expand=YES, fill=BOTH)
     hola.create_oval(10, 10, 200, 200, width=5, fill='blue')
     b3 = Button(hola, text="ocultar", command=lambda: ejecutar(ocultar(v1)))
     b3.grid(row=1, column=3)
    elif num == 2:
     canvas = Canvas(v1,width=300, height=210, bg='white')
     canvas.pack(expand=YES, fill=BOTH)
     canvas.create_rectangle(10, 10, 200, 200, width=5, fill='red')
     b3 = Button(canvas, text="ocultar", command=lambda: ejecutar(ocultar(v1)))
     b3.grid(row=1, column=3)
    elif num == 3:
     canvas2 = Canvas(v1,width=300, height=210, bg='white')
     canvas2.pack(expand=YES, fill=BOTH)
     canvas2.create_line(0, 200, 200, 0, width=10, fill='green')
     canvas2.create_line(0, 0, 200, 200, width=10, fill='red')
     b3 = Button(canvas2, text="ocultar", command=lambda: ejecutar(ocultar(v1)))
     b3.grid(row=1, column=3)
     v1.deiconify()
    elif num == 4:
     canvas = Canvas(v1, width=300, height=200, bg='white')
     canvas.pack(expand=YES, fill=BOTH)
     xy = 10, 10, 190, 190     
     canvas.create_arc(xy, start=0, extent=270, fill='gray60')
     b3 = Button(canvas, text="ocultar", command=lambda: ejecutar(ocultar(v1)))
     b3.grid(row=1, column=3)
     v1.deiconify()
    elif num == 5:
     canvas123 = Canvas(v1,width=300, height=200, bg='white')
     canvas123.pack(expand=YES, fill=BOTH)
     canvas123.create_arc(10, 10, 190, 190, start=270, extent=90, fill='gray90')
     b3 = Button(canvas123, text="ocultar", command=lambda: ejecutar(ocultar(v1)))
     b3.grid(row=1, column=3)
     v1.deiconify()
    elif num == 6:
     canvas = Canvas(v1, width=300, height=200, bg='white')
     canvas.pack(expand=YES, fill=BOTH)
     xy = 10, 10, 190, 190     
     canvas.create_arc(xy, start=0, extent=270, fill='gray60')
     canvas.create_arc(10, 10, 190, 190, start=270, extent=90, fill='gray90')
     b3 = Button(canvas, text="ocultar", command=lambda: ejecutar(ocultar(v1)))
     b3.grid(row=1, column=3)
     v1.deiconify()
    elif num == 7:
     canvas = Canvas(v1, width=300, height=200, bg='white')
     canvas.pack(expand=YES, fill=BOTH)
     canvas.create_text(150,70,fill="Red",font="Times",text="Hola \nmundo")
     b3 = Button(canvas, text="ocultar", command=lambda: ejecutar(ocultar(v1)))
     b3.grid(row=1, column=3)
    elif num == 8:
     canvas = Canvas(v1, width=300, height=200, bg='white')
     canvas.pack(expand=YES, fill=BOTH)
     canvas.create_polygon(40, 40, 40, 140, 140, 140, 140, 100,fill="lightblue", outline="brown", width=6)
     b3 = Button(canvas, text="ocultar", command=lambda: ejecutar(ocultar(v1)))
     b3.grid(row=1, column=3)
     v1.deiconify()
    elif num == 9:
     canvas = Canvas(v1, width=300, height=200, bg='white')
     canvas.pack(expand=YES, fill=BOTH)
     canvas.create_polygon(420,180,
                           420,60,
                           380,100,
                           300,100,
                           260,60,
                           260,140,
                           220,100,
                           180,100,
                           140,140,
                           140,80,
                           150,80,
                           200,40,
                           200,20,
                           160,20,
                           90,80,
                           100,160,
                           120,270,
                           200,270,
                           200,230,
                           160,230,
                           160,210,
                           180,190,
                           220,190,
                           220,270,
                           280,270,
                           280,230,
                           260,230,
                           260,180,
                           400,200,
                           360,220,
                           320,220,
                           280, 180,
                           fill="lightblue", outline="brown", width=6)
     b3 = Button(canvas, text="ocultar Gato de Eduardo Aquino Sanchez", command=lambda: ejecutar(ocultar(v1)))
     b3.grid(row=1, column=3)
     v1.deiconify()
    elif num == 10:
       canvas = Canvas(v1, width=300, height=200, bg='white')
       canvas.pack(expand=YES, fill=BOTH)
       canvas.create_polygon(130,20,
                           150,90,
                           210,90,
                           160,130,
                           180,200,
                           130,160,
                           80,200,
                           100,130                             ,50,90                             ,110,90,
                           fill="lightblue", outline="brown", width=6)
       b3 = Button(canvas, text="ocultar", command=lambda: ejecutar(ocultar(v1)))
       b3.grid(row=1, column=3)
       v1.deiconify()
    elif num == 11:
        canvas = Canvas(v1, width=300, height=200, bg='white')
        canvas.pack(expand=YES, fill=BOTH)
        canvas.create_polygon(160,160,
                              199.5,121.5,
                              240,120,
                              260,140,
                              340,140,
                              360,120,
                              359.7,101.8,
                              340,100,
                              320.4,81.4,
                              360,80,
                              380,100,
                              380.1,121.5,
                              360,140,
                              360,240,
                              340,240,
                              340,200,
                              258.6,198.9,
                              260,241.6,
                              237.6,238.9,
                              240,200,
                              220,160,
                              200,200,

                              fill="lightblue", outline="brown", width=6)
        b3 = Button(canvas, text="ocultar", command=lambda: ejecutar(ocultar(v1)))
        b3.grid(row=1, column=3)
        v1.deiconify()
    elif num == 12:
         canvas = Canvas(v1, width=390, height=350, bg='black')
         canvas.pack(expand=YES, fill=BOTH)
         puntos = [00, 20, 60, 20, 80, 80, 120, 80, 160, 20, 220, 40, 180, 40, 140, 80, 160, 100, 160, 120, 160, 140,
                  140, 160, 180, 180, 200, 200, 200, 240, 180, 280, 140, 300, 180, 320, 180, 340, 120, 340, 100, 320,
                  80, 340, 20, 340, 20, 320, 60, 300, 20, 280, 00, 240, 00, 200, 20, 180, 60, 160, 40, 140, 40, 120, 40,
                  100, 60, 80, 40, 40]
         canvas.create_polygon(puntos, fill="white", outline="white", width=9)

         b3 = Button(canvas, text="ocultar poligono de Lourdes Brito Martinez", command=lambda: ejecutar(ocultar(v1)))
         b3.grid(row=1, column=3)
         v1.deiconify()
    elif num == 13:
        canvas = Canvas(v1, width=390, height=350, bg='black')
        canvas.pack(expand=YES, fill=BOTH)

        canvas.create_polygon(52.5, 14.5, 37, 59.1, 51, 59.1, fill="#5C554E", outline="#5C554E", width=1)
        canvas.create_polygon(19.3, 56.8, 58, 59.1, 67, 91, 37.5, 83, fill="#C3BAB5", outline="#C3BAB5", width=1)
        canvas.create_polygon(58, 57.8, 78, 77, 71, 103, fill="#D4CCC1", outline="#D4CCC1", width=1)
        canvas.create_polygon(37.5, 83, 67.4, 91, 71, 103, fill="#998C8A", outline="#998C8A", width=1)
        canvas.create_polygon(71, 103, 71, 104.8, 59.1, 104.8, 53.2, 91, fill="#665B57", outline="#665B57", width=1)

        canvas.create_polygon(86, 105.6, 98.2, 148.6, 47, 133.6, 24.2, 103.6, fill="#C3BAB5", outline="#C3BAB5",
                              width=1)
        canvas.create_polygon(98.2, 148.6, 102, 165.2, 47, 133.6, fill="#9B8D8A", outline="#9B8D8A", width=1)
        canvas.create_polygon(86, 105.6, 124, 169, 120, 196, 110.8, 196, fill="#D5CDC2", outline="#D5CDC2", width=1)
        canvas.create_polygon(102, 165.2, 110.8, 196, 99, 196, 80.6, 153, fill="#605550", outline="#605550", width=1)

        canvas.create_polygon(139.5, 197, 147, 241, 71, 220.4, 46, 193, fill="#C3BAB5", outline="#C3BAB5", width=1)
        canvas.create_polygon(147, 241, 150, 261.4, 71, 220.4, fill="#968B87", outline="#968B87", width=1)
        canvas.create_polygon(139.5, 197, 193, 274.2, 189, 307.8, 176, 321, 161.6, 321, fill="#D4CCC1",
                              outline="#D4CCC1", width=1)
        canvas.create_polygon(150, 261.4, 161.6, 321, 126.8, 249, fill="#605551", outline="#605551", width=1)

        canvas.create_polygon(199.4, 307.8, 189, 307.8, 176, 321, 186.6, 461, 184, 448.8, 171, 479.5, 199.4, 503,
                              fill="#C2AD9C", outline="#C2AD9C", width=1)
        canvas.create_polygon(176, 321, 161.6, 321, 186.6, 461, fill="#615652", outline="#615652", width=1)
        canvas.create_polygon(161.6, 321, 136, 359.4, 177.2, 409, fill="#D9C6B7", outline="#D9C6B7", width=1)
        canvas.create_polygon(144.4, 369.8, 139.6, 384.6, 160, 389.4, fill="#443232", outline="#443232", width=1)
        canvas.create_polygon(139.6, 384.6, 160, 389.4, 177.2, 409, 169.2, 450, fill="#826E65", outline="#826E65",
                              width=1)
        canvas.create_polygon(171, 479.5, 180.6, 497.8, 191.2, 496.8, fill="#463334", outline="#463334", width=1)
        canvas.create_polygon(177.2, 409, 164.8, 475, 176.5, 511, 199.4, 522, 199.4, 502.8, 191.2, 496.8, 180.6, 497.8,
                              171, 479.5, 184, 448.8, fill="#9B7F79", outline="#9B7F79", width=1)

        canvas.create_polygon(151.8, 335.4, 109.6, 280, 142.2, 349.2, fill="#5F5150", outline="#5F5150", width=1)
        canvas.create_polygon(109.6, 280, 70.3, 266, 94.3, 329, 131.3, 326, fill="#483636", outline="#483636", width=1)
        canvas.create_polygon(94.3, 329, 137, 336, 132, 326.8, fill="#C2AF9D", outline="#C2AF9D", width=1)
        canvas.create_polygon(115, 333, 136, 359.4, 142.2, 349.2, 137, 336, fill="#826E65", outline="#826E65", width=1)

        canvas.create_polygon(346.5, 14.5, 347.5, 59.1, 361, 59.1, fill="#2E2621", outline="#2E2621", width=1)
        canvas.create_polygon(379.4, 56.8, 341.8, 59.1, 332, 91, 361, 83, fill="#908782", outline="#908782", width=1)
        canvas.create_polygon(341.5, 57.8, 324, 75, 327.6, 103, fill="#A29B8F", outline="#A29B8F", width=1)
        canvas.create_polygon(361, 83, 332.4, 91, 329, 103, fill="#685D59", outline="#685D59", width=1)
        canvas.create_polygon(329, 103, 326.8, 104.8, 340, 104.8, 345.6, 91, fill="#2D2220", outline="#2D2220", width=1)

        canvas.create_polygon(313, 105.6, 301, 148.6, 352, 133.6, 374.5, 103.6, fill="#908782", outline="#908782",
                              width=1)
        canvas.create_polygon(301, 148.6, 297, 165.2, 352, 133.6, fill="#625755", outline="#625755", width=1)
        canvas.create_polygon(313, 105.6, 274, 169, 279, 196, 288, 196, fill="#A1998E", outline="#A1998E", width=1)
        canvas.create_polygon(297, 165.2, 288, 196, 300, 196, 318, 153, fill="#2D221E", outline="#2D221E", width=1)

        canvas.create_polygon(260, 197, 252, 241, 331, 220.4, 352.4, 193, fill="#908782", outline="#908782", width=1)
        canvas.create_polygon(252, 241, 249, 261.4, 331, 220.4, fill="#645955", outline="#645955", width=1)
        canvas.create_polygon(260, 197, 205, 274.2, 209.8, 307.8, 223, 321, 238, 321, fill="#A1998E", outline="#A1998E",
                              width=1)
        canvas.create_polygon(249, 261.4, 238.6, 321, 271.8, 249, fill="#2D221E", outline="#2D221E", width=1)

        canvas.create_polygon(199.4, 307.8, 209.8, 307.8, 223, 321, 212.6, 461, 215, 448.8, 228, 479.5, 199.4, 503,
                              fill="#8E7968", outline="#8E7968", width=1)
        canvas.create_polygon(223, 321, 238.6, 321, 212.6, 461, fill="#302722", outline="#302722", width=1)
        canvas.create_polygon(238, 321, 262.8, 359.4, 222.5, 409, fill="#A69384", outline="#A69384", width=1)
        canvas.create_polygon(254.4, 369.8, 259.6, 384.6, 238, 389.4, fill="#120001", outline="#120001", width=1)
        canvas.create_polygon(259.6, 384.6, 238, 389.4, 222.5, 409, 229.5, 450, fill="#4F3B32", outline="#4F3B32",
                              width=1)
        canvas.create_polygon(228, 479.5, 218.3, 497.8, 207.5, 496.8, fill="#180A04", outline="#180A04", width=1)
        canvas.create_polygon(222.5, 409, 234, 475, 223, 511, 199.4, 522, 199.4, 502.8, 207.5, 496.8, 218.3, 497.8, 228,
                              479.5, 215, 448.8, fill="#674C45", outline="#674C45", width=1)

        canvas.create_polygon(247, 335.4, 290.6, 280, 256.8, 349.2, fill="#281F1D", outline="#281F1D", width=1)
        canvas.create_polygon(290.6, 280, 328, 266, 304.8, 329, 267.5, 326, fill="#140202", outline="#140202", width=1)
        canvas.create_polygon(304.8, 329, 262.5, 336, 267.5, 326.8, fill="#8D7B66", outline="#8D7B66", width=1)
        canvas.create_polygon(283, 333, 262.8, 359.4, 256.8, 349.2, 262.5, 336, fill="#4D3930", outline="#4D3930",
                              width=1)
        b3 = Button(canvas, text="ocultar poligono de David Mendoza Martinez", command=lambda: ejecutar(ocultar(v1)))
        b3.grid(row=1, column=3)
        v1.deiconify()
    elif num == 14:
        poligono = Canvas(v1, width=1000, height=1000, bg='white')
        poligono.pack(expand=YES, fill=BOTH)
        poligono.create_polygon((200, 400), (100, 500), (100, 600), (200, 500), (300, 600), (300, 500), (200, 400),
                                (300, 300), fill="green", outline="brown", width=2)
        poligono.create_polygon((200, 200), (300, 100), (500, 100), (500, 300), (400, 400), (300, 300), fill="red",
                                outline="brown", width=2)
        b3 = Button(poligono, text="ocultar poligono de Mendez Ruiz Edgar Manuel", command=lambda: ejecutar(ocultar(v1)))
        b3.grid(row=1, column=3)
        v1.deiconify()

    elif num == 15:


        po = Canvas(v1, width=1000, height=1000)
        po.pack()
        p0 = Canvas(v1, width=180, height=150)
        p0.place(x=102, y=30)
        p0.create_polygon(100, 10, 10, 140, 140, 140, 180, 140, fill="#FCFF00", outline="#FFF715", width=6)
        p0 = Canvas(v1, width=180, height=150)
        p0.place(x=185, y=170)
        p0.create_polygon(100, 5, 10, 140, 140, 140, 180, 140, fill="#FCFF00", outline="#FFF715", width=6)
        p0 = Canvas(v1, width=180, height=150)
        p0.place(x=8, y=170)
        p0.create_polygon(100, 5, 10, 140, 140, 140, 180, 140, fill="#FCFF00", outline="#FFF715", width=6)

        #b3 = Button(p0, text="ocultar", command=lambda: ejecutar(ocultar(v1)))        #b3.grid(row=1, column=1)        v1.deiconify()

    elif num == 16:
        figura = Canvas(v1, width=500, height=500, bg='white')
        figura.pack(expand=YES, fill=BOTH)
        puntos = [226, 42, 198, 42, 170, 50, 141, 71, 127, 60, 108, 52, 94, 57, 85, 71, 85, 85, 95, 99, 108, 106, 120,
                  109, 127, 113, 127, 123, 142, 119, 161, 119, 178, 122, 189, 134, 192, 148, 189, 161, 176, 166, 160,
                  165, 142, 162, 156, 178, 170, 192, 192, 198, 207, 198, 198, 212, 170, 209, 151, 205, 132, 202, 113,
                  195, 108, 180, 99, 164, 80, 153, 57, 156, 38, 170, 34, 183, 35, 198, 42, 212, 56, 221, 71, 226, 85,
                  221, 104, 212, 127, 223, 152, 226, 175, 232, 189, 234, 184, 250, 184, 270, 184, 283, 190, 297, 196,
                  306, 184, 321, 180, 334, 178, 346, 180, 353, 188, 372, 212, 390, 194, 402, 181, 411, 170, 425, 170,
                  443, 176, 456, 190, 467, 208, 468, 227, 456, 275, 419, 276, 404, 269, 393, 252, 383, 236, 382, 221,
                  371, 206, 361, 201, 350, 203, 340, 209, 333, 221, 326, 237, 326, 255, 322, 270, 314, 280, 305, 297,
                  291, 311, 288, 335, 288, 354, 293, 368, 301, 378, 311, 386, 326, 403, 330, 411, 330, 462, 265, 461,
                  240, 450, 230, 435, 226, 421, 226, 406, 230, 396, 240, 380, 270, 354, 265, 332, 260, 311, 263, 297,
                  263, 283, 263, 278, 250, 264, 226, 283, 226, 297, 221, 312, 212, 330, 198, 346, 198, 363, 198, 375,
                  188, 382, 175, 386, 160, 382, 141, 362, 127, 334, 127, 326, 133, 312, 148, 312, 163, 315, 180, 304,
                  192, 290, 204, 273, 206, 255, 205, 241, 204, 234, 198, 255, 189, 269, 180, 278, 166, 286, 151, 291,
                  132, 292, 113, 289, 99, 283, 85, 280, 74, 269, 63, 255, 51, 234, 42]
        figura.create_polygon(puntos, fill="black", outline="white", width=6)
        b4 = Button(figura, text="Cerrar figura monito de Castillo Ledezma Ricardo", command=lambda: v1.destroy())
        b4.pack()






def ocultar(ventana):ventana.destroy()
def ejecutar(f): v0.after(200, f)
b1 = Button(v0, text="Abrir ventana con Circulo", command=lambda: ejecutar(mostrar(1)) )
b1.grid(row=1, column=1)
b3 = Button(v0, text="Abrir ventana con cuadrado", command=lambda: ejecutar(mostrar(2)))
b3.grid(row=1, column=2)
b3 = Button(v0, text="Abrir ventana con linea", command=lambda: ejecutar(mostrar(3)))
b3.grid(row=1, column=3)
b4 = Button(v0, text="Abrir ventana con arco", command=lambda: ejecutar(mostrar(4)))
b4.grid(row=1, column=4)
b5 = Button(v0, text="Abrir ventana con quesito", command=lambda: ejecutar(mostrar(5)))
b5.grid(row=1, column=5)
b6 = Button(v0, text="Abrir ventana con quesito y arco", command=lambda: ejecutar(mostrar(6)))
b6.grid(row=1, column=6)
b7 = Button(v0, text="Abrir ventana con texto", command=lambda: ejecutar(mostrar(7)))
b7.grid(row=1, column=7)
b8 = Button(v0, text="Abrir ventana con poligono", command=lambda: ejecutar(mostrar(8)))
b8.grid(row=1, column=8)
b9 = Button(v0, text="Abrir ventana con poligono gato", command=lambda: ejecutar(mostrar(9)))
b9.grid(row=2, column=1)
b10 = Button(v0, text="Abrir ventana con poligono estrella", command=lambda: ejecutar(mostrar(10)))
b10.grid(row=2, column=2)
b11 = Button(v0, text="Abrir ventana con poligono perro", command=lambda: ejecutar(mostrar(11)))
b11.grid(row=2, column=3)
b12 = Button(v0, text="Abrir ventana con poligono conejo", command=lambda: ejecutar(mostrar(12)))
b12.grid(row=2, column=4)
b13 = Button(v0, text="Abrir ventana con poligono antilope", command=lambda: ejecutar(mostrar(13)))
b13.grid(row=2, column=5)
b14 = Button(v0, text="Abrir ventana con poligono manzana", command=lambda: ejecutar(mostrar(14)))
b14.grid(row=2, column=6)
b15 = Button(v0, text="Abrir ventana con poligono TRIFUERZA", command=lambda: ejecutar(mostrar(15)))
b15.grid(row=2, column=7)
b16 = Button(v0, text="Abrir ventana con poligono monito", command=lambda: ejecutar(mostrar(16)))
b16.grid(row=3, column=1)




v0.mainloop()

       

ESTRELLA EN PYTHON

CAPTURA ESTRELLA

       

from Tkinter import *
canvas = Canvas(width=400, height=350, bg='white')
canvas.create_polygon(200, 10,380, 280,10, 100,380, 100,10, 280, fill='turquoise',outline='brown', dash=(5, 10))
canvas.pack(expand=YES, fill=BOTH)

mainloop()

       

FIGURA PYTHON 7: VARIAS FORMAS GEOMETRICAS

CAPTURA

       

from Tkinter import *

canvas = Canvas(width=400, height=300, bg='white')
canvas.pack(expand=YES, fill=BOTH)
canvas.create_line(10, 10, 80, 80)
canvas.create_line(10, 80, 80, 10)

canvas.create_oval(100, 10, 180, 80, width=2, fill='blue')
canvas.create_arc(200, 10, 280, 100)
canvas.create_rectangle(10, 100, 200, 200, width=5, fill='red')
canvas.create_text(100, 280, text='tkinter canvas', fill='green')
mainloop()


       

PYTHON FIGURA 6: DOS LINEAS

CAPTURA

       
from Tkinter import *

canvas = Canvas(width=400, height=300, bg='white')
canvas.pack(expand=YES, fill=BOTH)
canvas.create_line(10, 10, 80, 80)
canvas.create_line(10, 80, 80, 10)

mainloop()


       

FUGURA 2D PROGRAMA 5

CAPTURA

       

import Tkinter
import tkMessageBox

top = Tkinter.Tk()

C = Tkinter.Canvas(top, bg="blue", height=250, width=300)

coord = 10, 50, 240, 210
arc = C.create_arc(coord, start=0, extent=150, fill="red")

C.pack()
top.mainloop()
       

FUGURA DE CANGURO PYTHON 2D: USANDO TURTLE

CAPTURA DE LA FIGURA

       
from turtle import *

setup(500,400,0,0)
screensize(400,350)
title("Figura de Canguro")

pensize(2)

penup()
goto(-30,72)
pendown()
goto(-30,72)
goto(21,79)
goto(26,76)
goto(60,133)
goto(80,137)
goto(66,114)
goto(60,110)

penup()
goto(73,125)
pendown()
goto(73,125)
goto(102,89)
goto(94,78)
goto(62,99)
goto(63,36)
goto(55,2)
goto(57,-16)

goto(39,-3)
goto(24,6)
goto(-4,-17)
goto(-21,-68)
goto(22,-96)
goto(-32,-89)
goto(-39,-73)
goto(-41,-40)
goto(-59,-66)
goto(-237,-17)
goto(-67,-34)
goto(-67,-26)
goto(-30,72)

penup()
goto(13,-4)
pendown()
goto(13,-4)
pendown()
goto(13,-4)
goto(9,-45)
goto(63,-73)
goto(6,-66)
goto(-7,-49)
goto(-9,-31)
goto(-4,-17)
goto(13,-4)

penup()
goto(79,119)
pendown()
goto(79,119)
goto(84,121)
goto(97,144)
goto(80,137)
goto(73,125)
goto(81,117)

penup()
goto(58,9)
pendown()
goto(58,9)
goto(62,-11)
goto(56,-7)

hideturtle()
done()


       

PYTHON 2D PROGRAMA 3

cvxcvxcv
vxcvxcvxc
v

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

from Tkinter import *

ventanaPrincipal= Tk() #Tk() es la evntana principal
ventanaPrincipal.title("Ventana de figura con boton") #titulo d ela ventana
ventanaPrincipal.config(bg="orange") #le da color al fondo
ventanaPrincipal.geometry("500x500") #cambia el tamaño de la ventana

def ejecutar(f):
 ventanaPrincipal.after(200,f) #una forma de ejecutar las funciones

def circulo(ventana):

 circulo= Canvas(width=210, height=210,bg='red') #lienzo con las medidas y color sobre el que se dibujara la figura
 circulo.pack(expand=YES, fill=BOTH) #sirve para cargar la figura
 circulo.create_oval(10,10,200,200,width=3,fill='blue') #coordenadas y caracteristicas de la figura

 botonCirculo= Button(ventanaPrincipal, text="Mostrar circulo", command=lambda:ejecutar(circulo(ventanaPrincipal))) #primer boton
 botonCirculo.grid(row=1,column=1) #el boton es cargado

 ventanaPrincipal.mainloop()

       

PYTHON FIGURAS 2D 2

VSDFVFDVF DD GVDFGDFG

       

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

from Tkinter import *

ventanaPrincipal= Tk() #Tk() es la evntana principal
ventanaPrincipal.title("Ventana de figura con boton") #titulo d ela ventana
ventanaPrincipal.config(bg="brown") #le da color al fondo
ventanaPrincipal.geometry("500x500") #cambia el tamaño de la ventana

def ejecutar(f):
 ventanaPrincipal.after(200,f) #una forma de ejecutar las funciones

def rectangulo(ventana):

 rectangulo= Canvas(width=210, height=210,bg='white') #lienzo con las medidas y color sobre el que se dibujara la figura
 rectangulo.pack(expand=YES, fill=BOTH) #sirve para cargar la figura
 rectangulo.create_rectangle(10,10,200,200,width=5,fill='yellow') #coordenadas y caracteristicas de la figura

 botonRectangulo= Button(ventanaPrincipal, text="Mostrar CUADRO", command=lambda:ejecutar(rectangulo(ventanaPrincipal))) #primer boton
 botonRectangulo.grid(row=1,column=1) #el boton es cargado

 ventanaPrincipal.mainloop()


       

PYTHON PROGRAMA FIGURAS 1

gdfgdfgdfg
fgdfgdfg
fdgdfgdfgdfg
dfgdfgdfg

       

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

from Tkinter import *

ventanaPrincipal= Tk() #Tk() es la evntana principal
ventanaPrincipal.title("Ventana de figura con boton") #titulo d ela ventana
ventanaPrincipal.config(bg="pink") #le da color al fondo
ventanaPrincipal.geometry("500x500") #cambia el tamaño de la ventana

def ejecutar(f):
 ventanaPrincipal.after(200,f) #una forma de ejecutar las funciones

def lineas(ventana):

 lineas= Canvas(width=210, height=210,bg='gray') #lienzo con las medidas y color sobre el que se dibujara la figura
 lineas.pack(expand=YES, fill=BOTH) #sirve para cargar la figura
 lineas.create_line(0,200,200,0,width=10,fill='purple') #coordenadas y caracteristicas de la figura

 botonLinea= Button(ventanaPrincipal, text="Mostrar linea", command=lambda:ejecutar(lineas(ventanaPrincipal))) #primer boton
 botonLinea.grid(row=1,column=1) #el boton es cargado

 ventanaPrincipal.mainloop()

       

FORMULARIO PYTHON-MYSQL EN PYTHON 2

       

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

#import pymysql
from pymysql import *
import tkMessageBox


def Limpiar():
    rollno.set('')
    nombre.set('')
    edad.set('')
    añostrabajo.set('')
    puesto.set('')
    reputacion.set('')
    salud.set('')
    ID.configure(state='normal')


def buscar():
    try:
        con = pymysql.connect(user='root', password='olmoswilson', \
                              host='localhost', database='libreria')
        cur = con.cursor()
        sql = "Select * from trabajadores where rollno='%s'" % rollno.get()
        cur.execute(sql)
        result = cur.fetchone()
        nombre.set(result[1])
        edad.set(result[2])
        añostrabajo.set(result[3])
        puesto.set(result[4])
        reputacion.set(result[5])
        salud.set(result[6])
        ID.configure(state='disabled')
        con.close()
    except:
        tkMessageBox.showinfo('Sin Datos', 'NO HAY DATOS DISPONIBLES...')
        Limpiar()


def insertar():
    try:
        con = pymysql.connect(user='root', password='olmoswilson', \
                              host='localhost', database='libreria')
        cur = con.cursor()
        sql = "insert into trabajadores values('%s','%s',%s,%s,'%s','%s','%s')" \
              % (rollno.get(), nombre.get(), edad.get(), añostrabajo.get(), puesto.get(), reputacion.get(), salud.get())
        cur.execute(sql)
        con.commit()
        con.close()
        tkMessageBox.showinfo('Exito', 'DATOS INSERTADOS..')
    except:
        tkMessageBox.showinfo('Error', 'Error en los datos...')
    finally:
        Limpiar()


def actualizar():
    try:
        con = pymysql.connect(user='root', password='olmoswilson', \
                              host='localhost', database='libreria')
        cur = con.cursor()
        sql = "update trabajadores set Nombre='%s', Edad=%s, Añostrabajo=%s, Puesto='%s', Reputacion='%s', Salud='%s' where rollno='%s'" \
              % (nombre.get(), edad.get(), añostrabajo.get(), puesto.get(), reputacion.get(), salud.get(), rollno.get())
        cur.execute(sql)
        con.commit()
        con.close()
        tkMessageBox.showinfo('Exito', 'DATOS ACTUALIZADOS..')
    except:
        tkMessageBox.showinfo('Error', 'Error en los datos...')
    finally:
        Limpiar()


def borrar():
    try:
        con = pymysql.connect(user='root', password='olmoswilson', \
                              host='localhost', database='libreria')
        cur = con.cursor()
        sql = "delete from trabajadores where rollno='%s'" \
              % (rollno.get())
        cur.execute(sql)
        con.commit()
        con.close()
        tkMessageBox.showinfo('Exito', 'DATOS BORRADOS..')
    except:
        tkMessageBox.showinfo('Error', 'Error en los datos...')
    finally:
        Limpiar()


ventana = Tk()
ventana.geometry("600x640+350+80")
ventana.title("FORMULARIO LIBRERIA")
ventana.resizable(width=False, height=False)
try:
    ventana.iconbitmap("C:\icono.ico")
except:
    print("no hay icono disponible")

TITULO = Label(ventana, text="FORMULARIO PARA MODIFICAR DATOS A UNA DB ", fg='brown', font=("Courier New", 15))
ETIQUETA1 = Label(ventana, text="ID", font=("Courier New", 15), fg='red')
ETIQUETA2 = Label(ventana, text="NOMBRE", font=("Courier New", 15))
ETIQUETA3 = Label(ventana, text="EDAD", font=("Courier New", 15))
ETIQUETA4 = Label(ventana, text="AÑOS", font=("Courier New", 15))
ETIQUETA5 = Label(ventana, text="PUESTO", font=("Courier New", 15))
ETIQUETA6 = Label(ventana, text="REPUTACION", font=("Courier New", 15))
ETIQUETA7 = Label(ventana, text="SALUD", font=("Courier New", 15))

canvas = Canvas(ventana, width=500, height=500)
img = PhotoImage(file="C:\LOGO2.gif")
canvas.create_image(0, 0, anchor=NW, image=img)

rollno = StringVar()
nombre = StringVar()
edad = StringVar()
añostrabajo = StringVar()
puesto = StringVar()
reputacion = StringVar()
salud = StringVar()

ID = Entry(ventana, width=150, textvariable=rollno, bg='dark turquoise', fg='dark slate gray', font=("Courier New", 15))
NOMBRE = Entry(ventana, width=160, textvariable=nombre, bg='dark turquoise', fg='dark slate gray',
               font=("Courier New", 15))
EDAD = Entry(ventana, width=160, textvariable=edad, bg='dark turquoise', fg='dark slate gray', font=("Courier New", 15))
AÑOSTRABAJO = Entry(ventana, width=160, textvariable=añostrabajo, bg='dark turquoise', fg='dark slate gray',
                    font=("Courier New", 15))
PUESTO = Entry(ventana, width=160, textvariable=puesto, bg='dark turquoise', fg='dark slate gray',
               font=("Courier New", 15))
REPUTACION = Entry(ventana, width=160, textvariable=reputacion, bg='dark turquoise', fg='dark slate gray',
                   font=("Courier New", 15))
SALUD = Entry(ventana, width=160, textvariable=salud, bg='dark turquoise', fg='dark slate gray',
              font=("Courier New", 15))

BUSCAR = Button(ventana, text="BUSCAR", command=buscar, bg='dark slate gray', fg='white',
                activebackground='dodger blue', activeforeground='black', font=("Courier New", 15))
INSERTAR = Button(ventana, text="INSERTAR", command=insertar, bg='dark slate gray', fg='white',
                  activebackground='dodger blue', activeforeground='black', font=("Courier New", 15))
ACTUALIZAR = Button(ventana, text="ACTUALIZAR", command=actualizar, bg='dark slate gray', fg='white',
                    activebackground='dodger blue', activeforeground='black', font=("Courier New", 15))
BORRAR = Button(ventana, text="BORRAR", command=borrar, bg='dark slate gray', fg='white',
                activebackground='dodger blue', activeforeground='black', font=("Courier New", 15))
LIMPIAR = Button(ventana, text="LIMPIAR", command=Limpiar, bg='dark slate gray', fg='white',
                 activebackground='dodger blue', activeforeground='black', font=("Courier New", 15))

TITULO.place(x=20, y=10, width=600, height=30)
ETIQUETA1.place(x=10, y=50, width=150, height=30)
ETIQUETA2.place(x=10, y=100, width=150, height=30)
ETIQUETA3.place(x=10, y=150, width=150, height=30)
ETIQUETA4.place(x=10, y=200, width=150, height=30)
ETIQUETA5.place(x=10, y=250, width=150, height=30)
ETIQUETA6.place(x=10, y=300, width=150, height=30)
ETIQUETA7.place(x=10, y=350, width=150, height=30)

ID.place(x=170, y=50, width=370, height=30)
NOMBRE.place(x=170, y=100, width=370, height=30)
EDAD.place(x=170, y=150, width=370, height=30)
AÑOSTRABAJO.place(x=170, y=200, width=370, height=30)
PUESTO.place(x=170, y=250, width=370, height=30)
REPUTACION.place(x=170, y=300, width=370, height=30)
SALUD.place(x=170, y=350, width=370, height=30)

BUSCAR.place(x=250, y=480, width=130, height=40)
INSERTAR.place(x=30, y=420, width=130, height=40)
ACTUALIZAR.place(x=170, y=420, width=130, height=40)
BORRAR.place(x=310, y=420, width=130, height=40)
LIMPIAR.place(x=450, y=420, width=130, height=40)

ventana.mainloop()

       

CONSULTAS SQL PARA LA TABLA DEL PROYECTO PYTHON

create database libreria;
use libreria
CREATE TABLE trabajadores(
 rollno varchar(3)not null,
 Nombre varchar(50),
 Edad integer(15),
 Añostrabajo integer(15),
 Puesto varchar(20),
 Reputacion varchar(25),
 Salud varchar(25),
 PRIMARY KEY (rollno));

INSERT INTO trabajadores (rollno, Nombre, Edad, Añostrabajo, Puesto, Reputacion, Salud)
VALUES ('101','Juan',32,1,'vendedor','confiable','estable');

INSERT INTO trabajadores (rollno, Nombre, Edad, Añostrabajo, Puesto, Reputacion, Salud)
VALUES ('102','Julio',24,2,'cajero','problematico','saludable');

Select * from trabajadores
       

CODIGO DE CONEXION PYTHON Y MYSQL

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

import pymysql
from tkinter import messagebox

def Limpiar():
    rollno.set('')
    nombre.set('')
    edad.set('')
    añostrabajo.set('')
    puesto.set('')
    reputacion.set('')
    salud.set('')
    ID.configure(state='normal')


def buscar():
    try:
        con = pymysql.connect(user='root', password='olmoswilson',\
                              host='localhost', database='libreria')
        cur = con.cursor()
        sql = "Select * from trabajadores where rollno='%s'" %rollno.get()
        cur.execute(sql)
        result = cur.fetchone()
        nombre.set(result[1])
        edad.set(result[2])
        añostrabajo.set(result[3])
        puesto.set(result[4])
        reputacion.set(result[5])
        salud.set(result[6])
        ID.configure(state='disabled')
        con.close()
    except:
        messagebox.showinfo('Sin Datos','NO HAY DATOS DISPONIBLES...')
        Limpiar()

def insertar():
    try:
        con = pymysql.connect(user='root', password='olmoswilson',\
                              host='localhost', database='libreria')
        cur = con.cursor()
        sql = "insert into trabajadores values('%s','%s',%s,%s,'%s','%s','%s')" \
              %(rollno.get(),nombre.get(), edad.get(), añostrabajo.get(), puesto.get(), reputacion.get(), salud.get())
        cur.execute(sql)
        con.commit()
        con.close()
        messagebox.showinfo('Exito','DATOS INSERTADOS..')
    except:
        messagebox.showinfo('Error', 'Error en los datos...')
    finally:
        Limpiar()

def actualizar():
    try:
        con = pymysql.connect(user='root', password='olmoswilson',\
                              host='localhost', database='libreria')
        cur = con.cursor()
        sql = "update trabajadores set Nombre='%s', Edad=%s, Añostrabajo=%s, Puesto='%s', Reputacion='%s', Salud='%s' where rollno='%s'"\
              %(nombre.get(), edad.get(), añostrabajo.get(), puesto.get(), reputacion.get(), salud.get(), rollno.get())
        cur.execute(sql)
        con.commit()
        con.close()
        messagebox.showinfo('Exito','DATOS ACTUALIZADOS..')
    except:
        messagebox.showinfo('Error', 'Error en los datos...')
    finally:
        Limpiar()

def borrar():
    try:
        con = pymysql.connect(user='root', password='olmoswilson', \
                            host= 'localhost', database='libreria')
        cur = con.cursor()
        sql = "delete from trabajadores where rollno='%s'"\
              %(rollno.get())
        cur.execute(sql)
        con.commit()
        con.close()
        messagebox.showinfo('Exito','DATOS BORRADOS..')
    except:
        messagebox.showinfo('Error', 'Error en los datos...')
    finally:
        Limpiar()



ventana = Tk()
ventana.geometry("600x640+350+80")
ventana.title("FORMULARIO LIBRERIA")
ventana.resizable(width=False,height=False)
try:
    ventana.iconbitmap("C:\icono.ico")
except:
    print("no hay icono disponible")

TITULO = Label (ventana, text="FORMULARIO PARA MODIFICAR DATOS A UNA DB ",fg='brown', font=("Courier New", 15))
ETIQUETA1 = Label (ventana, text="ID", font=("Courier New", 15), fg='red')
ETIQUETA2 = Label (ventana, text="NOMBRE", font=("Courier New", 15))
ETIQUETA3 = Label (ventana, text="EDAD", font=("Courier New", 15))
ETIQUETA4 = Label (ventana, text="AÑOS", font=("Courier New", 15))
ETIQUETA5 = Label (ventana, text="PUESTO", font=("Courier New", 15))
ETIQUETA6 = Label (ventana, text="REPUTACION", font=("Courier New", 15))
ETIQUETA7 = Label (ventana, text="SALUD", font=("Courier New", 15))


canvas = Canvas(ventana, width=500, height=500)
img = PhotoImage(file="C:\LOGO2.gif")
canvas.create_image(0, 0, anchor = NW, image=img)

rollno= StringVar()
nombre= StringVar()
edad= StringVar()
añostrabajo= StringVar()
puesto= StringVar()
reputacion= StringVar()
salud= StringVar()

ID= Entry(ventana, width=150, textvariable=rollno, bg='dark turquoise', fg='dark slate gray',font=("Courier New", 15))
NOMBRE= Entry(ventana, width=160, textvariable=nombre, bg='dark turquoise', fg='dark slate gray',font=("Courier New", 15))
EDAD= Entry(ventana, width=160, textvariable=edad, bg='dark turquoise', fg='dark slate gray',font=("Courier New", 15))
AÑOSTRABAJO= Entry(ventana, width=160, textvariable=añostrabajo, bg='dark turquoise', fg='dark slate gray', font=("Courier New", 15))
PUESTO= Entry(ventana, width=160, textvariable=puesto, bg='dark turquoise', fg='dark slate gray',font=("Courier New", 15))
REPUTACION= Entry(ventana, width=160, textvariable=reputacion, bg='dark turquoise', fg='dark slate gray', font=("Courier New", 15))
SALUD= Entry(ventana, width=160, textvariable=salud, bg='dark turquoise', fg='dark slate gray',font=("Courier New", 15))


BUSCAR = Button (ventana, text="BUSCAR", command=buscar, bg='dark slate gray', fg='white', activebackground='dodger blue', activeforeground='black', font=("Courier New", 15))
INSERTAR = Button (ventana, text="INSERTAR", command=insertar, bg='dark slate gray', fg='white', activebackground='dodger blue', activeforeground='black', font=("Courier New", 15))
ACTUALIZAR = Button (ventana, text="ACTUALIZAR", command=actualizar, bg='dark slate gray', fg='white', activebackground='dodger blue', activeforeground='black', font=("Courier New", 15))
BORRAR = Button (ventana, text="BORRAR", command=borrar, bg='dark slate gray', fg='white', activebackground='dodger blue', activeforeground='black', font=("Courier New", 15))
LIMPIAR = Button (ventana, text="LIMPIAR", command=Limpiar, bg='dark slate gray', fg='white', activebackground='dodger blue', activeforeground='black', font=("Courier New", 15))

TITULO.place(x=20,y=10,width=600,height=30)
ETIQUETA1.place(x=10,y=50,width=150,height=30)
ETIQUETA2.place(x=10,y=100,width=150,height=30)
ETIQUETA3.place(x=10,y=150,width=150,height=30)
ETIQUETA4.place(x=10,y=200,width=150,height=30)
ETIQUETA5.place(x=10,y=250,width=150,height=30)
ETIQUETA6.place(x=10,y=300,width=150,height=30)
ETIQUETA7.place(x=10,y=350,width=150,height=30)


ID.place(x=170,y=50,width=370,height=30)
NOMBRE.place(x=170,y=100,width=370,height=30)
EDAD.place(x=170,y=150,width=370,height=30)
AÑOSTRABAJO.place(x=170,y=200,width=370,height=30)
PUESTO.place(x=170,y=250,width=370,height=30)
REPUTACION.place(x=170,y=300,width=370,height=30)
SALUD.place(x=170,y=350,width=370,height=30)

BUSCAR.place(x=250,y=480,width=130,height=40)
INSERTAR.place(x=30,y=420,width=130,height=40)
ACTUALIZAR.place(x=170,y=420,width=130,height=40)
BORRAR.place(x=310,y=420,width=130,height=40)
LIMPIAR.place(x=450,y=420,width=130,height=40)

ventana.mainloop()
       

UNIDAD 4: OPERACION Y MANTENIBILIDAD

Unidad 4 Operación y Mantenibilidad

Trata acerca de como se hacen las bitacoras.
Que funcion tienen y porque son tan importantes, ademas es necesario conocer porque son importante a la hora de realizar cambios o conocr un poco mas del sistema de base de datos que se esta manejando.


4.1 Bitacoras de trabajo del DBMS.


 En muchos DBMS la bitácora incluye todo tipo de consulta incluyendo aquellas que no modifican los datos.

La operación ROLLBACK está basada en el uso de una bitácora. El DBMS (Sistema Manejador de Bases de Datos) mantiene una bitácora o diario en cinta o en disco, comúnmente, en el cual se registran los detalles de todas las operaciones de actualización, en particular, los valores iniciales y final del objeto modificado. Por tanto, si resulta necesario anular alguna modificación específica, el sistema puede utilizar la entrada correspondiente de la bitácora para restaurar el valor original del objeto restaurado.



4.1.1. Funciones especifica de las bitacoras.

La estructura más ampliamente usada para grabar las modificaciones de la base de datos es la Bitácora. Cada registro de la bitácora escribe una única escritura de base de datos y tiene lo siguiente.

Ø  Nombre de la Transaccion

Ø  Valor antiguo

Ø  Valor Nuevo



Es fundamental que siempre se cree un registro en la bitácora cuando se realice una escritura antes de que se modifique la base de datos.



También tenemos la posibilidad de deshacer una modificación que ya se ha escrito en la base de datos, esto se realizará usando el campo del valor antiguo de los registros de la bitácora.



Los registros de la bitácora deben residir en memoria estable como resultado el volumen de datos en la bitácora puede ser exageradamente grande.



Las operaciones COMMIT y ROLLBACK establecen lo que se le conoce como punto de sincronización lo cual representa el límite entre dos transacciones consecutivas, o el final de una unidad lógica de trabajo, y por tanto al punto en el cual la base de datos esta (o debería estar) en un estado de consistencia. Las únicas operaciones que establecen un punto de sincronización son COMMIT, ROLLBACK y el inicio de un programa. Cuando se establece un punto de sincronización:



Se comprometen o anulan todas las modificaciones realizadas por el programa desde el punto de sincronización anterior.



Se pierde todo posible posicionamiento en la base de datos. Se liberan todos los registros bloqueados. Es importante advertir que COMMIT y ROLLBACK terminan las transacción, no el programa.

 
4.1.2 Recuperacion rollback


En tecnologías de base de datos, un rollback es una operación que devuelve a la base de datos a algún estado previo. Los Rollbacks son importantes para la integridad de la base de datos, a causa de que significan que la base de datos puede ser restaurada a una copia limpia incluso después de que se han realizado operaciones erróneas. Son cruciales para la recuperación de crashes de un servidor de base de datos; realizando rollback(devuelto) cualquier transacción que estuviera activa en el tiempo del crash, la base de datos es restaurada a un estado consistente.



En SQL, ROLLBACK es un comando que causa que todos los cambios de datos desde la última sentencia BEGIN WORK, o START TRANSACTION sean descartados por el sistema de gestión de base de datos relacional (RDBMS), para que el estado de los datos sea "rolled back"(devuelto) a la forma en que estaba antes de que aquellos cambios tuvieran lugar.



Una sentencia ROLLBACK también publicará cualquier savepoint existente que puediera estar en uso.



En muchos dialectos de SQL, ROLLBACKs son específicos de la conexión. Esto significa que si se hicieron dos conexiones a la misma base de datos, un ROLLBACK hecho sobre una conexión no afectará a cualesquiera otras conexiones. Esto es vital para el buen funcionamiento de la Concurrencia.



La funcionalidad de rollback está normalmente implementada con un Log de transacciones, pero puede también estar implementada mediante control de concurrencia multiversión.



En el proceso de “Rollback”, SQL Server comienza a hacer un rollback de todas las transacciones que no fueron confirmadas además de las que fueron rechazadas, dejando de esta manera la base de datos en un estado consistente.



Este proceso de recuperación en algunos casos puede tardar mucho tiempo debido a la gran cantidad de información que tienen que replicar desde el log de transacciones. Es por eso que la frecuencia con la que se hacen los checkpoints dentro de la base de datos es crucial para el tiempo que tardara el servidor en ejecutar el proceso de recuperación.



Adicionalmente cabe mencionar que en algunas pocas ocasiones el terminar el servicio de SQL Server de manera inesperada puede causar corrupciones de datos, y esto sí es grave debido a que en algunos casos puede ser recuperable la información, pero siempre con un riesgo de perder algo de data, y en otros no es posible arreglar la base de datos, entonces lo único que queda en estas situaciones es la restauración de backups y es ahí donde si se tiene una buena estrategia de backups se puede llegar a recuperar absolutamente toda la información hasta el momento del desastre.

4.1.3 Permanencia commit

 En cualquier momento, el programa podría decidir que es necesario hacer fallar la transacción, con lo que el sistema deberá revertir todos los cambios hechos por las operaciones ya hechas. En el lenguaje SQL se denomina COMMIT a aplicar_cambios y ROLLBACK a cancelar_cambios.

Las transacciones suelen verse implementadas en sistemas de bases de datos y, más recientemente, se han visto incorporadas a como gestiona un sistema operativo la interacción con un sistema de archivos (como varias características de las bases de datos, debido a que son muy similares arquitectónicamente).


Una sentencia COMMIT en SQL finaliza una transacción de base de datos dentro de un sistema gestor de base de datos relacional (RDBMS) y pone visibles todos los cambios a otros usuarios. El formato general es emitir una sentencia BEGIN WORK, una o más sentencias SQL, y entonces la sentencia COMMIT. Alternativamente, una sentencia ROLLBACK se puede emitir, la cual deshace todo el trabajo realizado desde que se emitió BEGIN WORK. Una sentencia COMMIT publicará cualquiera de los savepoints(puntos de recuperación) existentes que puedan estar en uso.

En términos de transacciones, lo opuesto de commit para descartar los cambios "en tentativa" de una transacción, es un rollback.


4.2 Definicion de los modos de operacion de un DBMS. (alta, baja, recovery)


El sistema de gestión de bases de datos es esencial para el adecuado funcionamiento y manipulación de los datos contenidos en la base. Se puede definir como: "El Conjunto de programas, procedimientos, lenguajes, etc. que suministra, tanto a los usuarios no informáticos como a los analistas, programadores o al administrador, los medios necesarios para describir, recuperar y manipular los datos almacenados en la base, manteniendo su integridad, confidencialidad y seguridad".



Las funciones esenciales de un SGDB son la descripción, manipulación y utilización de los datos.



Descripción: Incluye la descripción de: Los elementos de datos, su estructura, sus interrelaciones, sus validaciones. Tanto a nivel externo como lógico global e interno esta descripción es realizada mediante un LDD o Lenguaje de Descripción de Datos.



Manipulación: Permite: Buscar, Añadir, Suprimir y Modificar los datos contenidos en la Base de Datos.



La manipulación misma supone: Definir un criterio de selección, Definir la estructura lógica a recuperar, Acceder a la estructura física. Esta manipulación es realizada mediante un LMD o Lenguaje de Manipulación de Datos.



Utilización: La utilización permite acceder a la base de datos, no a nivel de datos sino a la base como tal, para lo cual: Reúne las interfaces de los usuarios y suministra procedimientos para el administrador.



En términos ideales, un DBMS debe contar con estas funciones, sin embargo, no todos las poseen, así existen algunos manejadores que no cumplen la función de respaldo o de seguridad, dejándola al usuario o administrador; sin embargo un DBMS que sea completo y que deba manejar una base de datos multiusuario grande, es conveniente que cuente con todas estas operaciones.


4.3 Comandos de activacion de los modos de operacion


 Los índices son "estructuras" alternativa a la organización de los datos en una tabla. El propósito de los índices es acelerar el acceso a los datos mediante operaciones físicas más rápidas y efectivas. Para entender mejor la importancia de un índice pongamos un ejemplo; imagínate que tienes delante las páginas amarillas, y deseas buscar el teléfono de Manuel Salazar que vive en Alicante. Lo que harás será buscar en ese pesado libro la población Alicante, y guiándote por la cabecera de las páginas buscarás los apellidos que empiezan por S de Salazar. De esa forma localizarás más rápido el apellido Salazar. Pues bien, enhorabuena, has estado usando un índice.


4.4. Manejo de indices


 En MySQL se tienen dos tipos de índices, los cuales son:

Índices agrupados

Los índices agrupados, definen el orden en que almacenan las filas de la tabla (nodos hoja/página de datos de la imagen anterior). La clave del índice agrupado es el elemento clave para esta ordenación; el índice agrupado se implementa como una estructura de árbol b que ayuda a que la recuperación de las filas a partir de los valores de las claves del índice agrupado sea más rápida. Las páginas de cada nivel del índice, incluidas las páginas de datos del nivel hoja, se vinculan en una lista con vínculos dobles. Además, el desplazamiento de un nivel a otro se produce recorriendo los valores de claves.

Consideraciones para usar índices agrupados

Ø  Columnas selectivas

Ø  columnas afectadas en consultas

Ø  Columnas accedidas "secuencialmente"

Ø  Columnas implicadas en JOIN, GROUP BY

Ø  Acceso muy rápido a filas: lookups

Indices No Agrupados





Los índices no agrupados tienen la misma estructura de árbol b que los índices agrupados, con algunos matices; como hemos visto antes, en los índices agrupados, en el último nivel del índice (nivel de hoja) están los datos; en los índices no-agrupados, en el nivel de hoja del índice, hay un puntero a la localización física de la fila correspondiente en el índice agrupado. Además, la ordenación de las filas del índice está construida en base a la(s) columna(s) indexadas, lo cual no quiere decir (a diferencia de los índices agrupados), que la organización física de las páginas de datos corresponda con el índice.

Consideraciones para usar índices agrupados




4.4.1 Tipos de indices



 En MySQL se tienen dos tipos de índices, los cuales son:

Índices agrupados


Los índices agrupados, definen el orden en que almacenan las filas de la tabla (nodos hoja/página de datos de la imagen anterior). La clave del índice agrupado es el elemento clave para esta ordenación; el índice agrupado se implementa como una estructura de árbol b que ayuda a que la recuperación de las filas a partir de los valores de las claves del índice agrupado sea más rápida. Las páginas de cada nivel del índice, incluidas las páginas de datos del nivel hoja, se vinculan en una lista con vínculos dobles. Además, el desplazamiento de un nivel a otro se produce recorriendo los valores de claves.

Consideraciones para usar índices agrupados

Ø  ·         Columnas selectivas

Ø  ·        columnas afectadas en consultas

Ø  ·         Columnas accedidas "secuencialmente"

Ø  ·         Columnas implicadas en JOIN, GROUP BY

Ø  ·         Acceso muy rápido a filas: lookups

Indices No Agrupados



Los índices no agrupados tienen la misma estructura de árbol b que los índices agrupados, con algunos matices; como hemos visto antes, en los índices agrupados, en el último nivel del índice (nivel de hoja) están los datos; en los índices no-agrupados, en el nivel de hoja del índice, hay un puntero a la localización física de la fila correspondiente en el índice agrupado. Además, la ordenación de las filas del índice está construida en base a la(s) columna(s) indexadas, lo cual no quiere decir (a diferencia de los índices agrupados), que la organización física de las páginas de datos corresponda con el índice.

Consideraciones para usar índices agrupados



4.4.2 Reorganizacion de indices



  Un paquete puede usar la tarea Reorganizar índice para reorganizar los índices de una base de datos individual o de varias bases de datos. Si la tarea solo reorganiza los índices de una base de datos individual, puede elegir las vistas o las tablas cuyos índices reorganiza la tarea. La tarea Reorganizar índice también incluye la opción de compactar datos de objetos grandes. Los datos de objetos grandes son datos de tipo image, text, ntext, varchar(max), nvarchar(max), varbinary(max) o xml.



La tarea Reorganizar índice encapsula la instrucción ALTER INDEX de Transact-SQL. Si elige compactar datos de objetos grandes, la instrucción utiliza la cláusula REORGANIZE WITH (LOB_COMPACTION = ON); en caso contrario, se establece LOB_COMPACTION en OFF



Dentro de las tareas habituales de Mantenimiento de las Bases de Datos se encuentran aquellas destinadas al control y respaldo de las mismas como ser: Control de Integridad, Chequeo de Consistencia, Copias de Seguridad o Compactación de las bases.



Pero también es necesario ejecutar trabajos de mantenimiento cuyos objetivos sean el de mantener la performance de las bases de datos y evitar su degradación.



Esos trabajos son la Reorganización de Índices y la Actualización de Estadísticas.



Estos trabajos son independientes del estado de la base de datos. Puede ocurrir que a la base le falten estudios de optimización pero, al menos, mantendremos la performance actual.



Si la base se encuentra optimizada, entonces más aún, son necesarios para evitar la degradación producto del uso continuo.



Cualquiera de estos trabajos deben realizarse fuera de línea por motivos de: alto consumo de recurso y bloqueo de las tablas en el momento de ejecución.



Las tablas que contienen índices al ser actualizadas o por inserción de nuevos datos, generan fragmentación de estos índices. Estas fragmentaciones conllevan a la pérdida de performance al acceder a ellas.



La instrucción DBCC DBREINDEX reorganiza el índice de una tabla o todos los índices definidos para una tabla. La reorganización de realiza dinámicamente sin necesidad de conocer la estructura de la misma o las restricciones que ella tenga. Por lo tanto no es necesario conocer si una tabla tiene clave primaria o si esta clave es única y además pertenece a algún índice, ya que la reorganización no necesita eliminar y recrear éstas restricciones para realizar su trabajo.



La sintaxis de esta instrucción es:



DBCC DBREINDEX



   (   ’basededatos.dueño.nombre_de_tabla‘



           [ , índice



               [ , fillfactor ]



           ]



   )   [ WITH NO_INFOMSGS ]







Fillfactor es el porcentaje de espacio de página destinado a ser ocupado. El valor definido reemplaza al que fue generado en el momento de la creación del índice. Si se quiere mantener el valor original, entonces se utiliza el valor 0.



WITH NO_INFOMSGS se suprimen los mensajes generados en la ejecución.



No es necesario conocer los nombres de todos los índices de todas las tablas, ya que si utilizamos la instrucción de la siguiente forma:



DBCC RBINDEX (Movimientos, ‘’, 0)



Se reorganizarán todos los índices que contengan la tabla Movimientos, conservándose el fillfactor original de cada índice en particular.



Una de las formas de utilizarlo es, escribir un script con una sentencia DBCC RBINDEX por cada tabla que necesitemos reorganizar y agendarlas en forma periódica mediante un trabajo de mantenimiento dentro de algún horario disponible.



Por lo tanto, la recomendación será: elegir las tablas más accedidas y/o actualizadas, y reorganizarlas una vez entre semana. Para reorganizar todas las tablas que contengan índices se utiliza el mismo concepto, pero dentro de un procedimiento que recorra todas la tablas de la base y las reorganice, sin necesidad que escribamos todas la tablas que contiene la base de datos. Estos procedimientos se pueden encontrar en el Forum bajo el nombre de Tips, y la idea es generar un trabajo de mantenimiento que se ejecute, por ejemplo, en el fin de semana



4.4.3 Reconstruccion de indices



Es importante periódicamente examinar y determinar qué índices son susceptibles de ser reconstruidos. Cuando un Índice está descompensado puede ser porque algunas partes de Éste han sido accedidas con mayor frecuencia que otras. Como resultado de este suceso podemos obtener problemas de contención de disco o cuellos de botella en el sistema. Normalmente reconstruimos un Índice con el comando ALTER INDEX.

Es importante tener actualizadas las estadísticas de la base de datos. Para saber si las estadísticas se están lanzando correctamente podemos hacer una consulta sobre la tabla dba_indexes y ver el campo last_analyzed para observar cuando se ejecutaron sobre ese Índice las estadísticas.

SELECT index_name, last_analyzed
FROM dba_indexed
WHERE table_owner=’nb_usuario’

Nota: Siendo nb_usuario el nombre del esquema del usuario para el que queramos validar las estadísticas. (Lanzar con usuario SYS)

Para actualizar las estadísticas utilizamos el paquete DBM_STATS. Podemos actualizar las estadísticas de todos los objetos de un esquema de la siguiente forma:

Execute DBMS_STATS.gather_schema_stats(‘Esquema’);

Nota: Sustituimos esquema por el nombre de nuestro esquema a actualizar (lanzar con usuario SYS)

Una vez actualizadas las estadísticas de los Índices de la base de datos lanzamos la siguiente consulta:

SELECT index_name, blevel,
DECODE(blevel,0,'OK BLEVEL',1,'OK BLEVEL',2,
'OK BLEVEL',3,'OK BLEVEL',4,'OK BLEVEL','BLEVEL HIGH') OK
FROM dba_indexes where table_owner='Propietario';

Nota: Sustituimos Propietario por el esquema o propietario que queramos verificar (lanzar con usuario SYS)

Con esta sentencia obtendremos el nombre del Índice, el blevel y si es correcto.

INDEX_NAME
  

BLEVEL
  

OK

INX_CUENTA
  

1
  

OK BLEVEL

INX_TRABAJO
  

0
  

OK BLEVEL

INX_DINERO
        

BLEVEL HIGH

Los Índices que deberíamos de reconstruir son los que en la columna ok aparecen como BLEVEL HIGH.

Blevel (branch level) es parte del formato del B-tree del Índice e indica el número de veces que ORACLE ha tenido que reducir la búsqueda en ese Índice. Si este valor está por encima de 4 el Índice deberá de ser reconstruido.

Comando ALTER INDEX

Como hemos comentado esta sentencia se utiliza para cambiar o reconstruir un Índice existente en la base de datos.

Para poder ejecutar este comando el Índice debe de estar en el propio esquema donde intentes ejecutarlo o deberías de tener el privilegio alter any index. También tenemos que tener en cuenta que para realizar la reconstrucción de un Índice deberíamos de tener cuota suficiente sobre el tablespace que lo lanzamos.


Para reconstruir un Índice bastaría con lazar la siguiente sentencia:

ALTER INDEX REBUILD;


Para reconstruir una partición de un Índice podríamos hacer lo siguiente

ALTER INDEX REBUILD PARTITION NOLOGGING;

Nota: En algunos casos cuando alguno de los Índices tiene algún tipo de corrupción no es posible reconstruirlo. La solución en este caso es borrar el Índice y recrearlo.

UNIDAD 3 ADMINISTRACION DE BASES DE DATOS

 UNIDAD 3: CONFIGURACIÓN Y ADMINISTRACIÓN DEL ESPACIO EN DISCO

3.1 ESTRUCTURAS LÓGICAS DE ALMACENAMIENTO

 La arquitectura interna de una base de datos en SQL está compuesta por 2 tipos de estructura, la estrucutra lógica y la estrucutra física.

Uno de los propósitos de los “FileGroups” es poder distribuir la data a través de varios discos duros físicos, de esta manera se puede obtener mayor rendimiento en las operaciones de I/O debido a que más de un disco trabajara al mismo tiempo.

Otro de los propósitos es poder esconder la ubicación física real de la información a los programadores, ya que para ellos la tabla “X” pertenece al “FileGroup” “A”, pero no saben en que data files físicamente se encuentra la información de la tabla “X”.

Si se tiene dos o mas unidades en el Grupo de almacenamiento, pueden crear espacios de almacenamiento que no se verán afectados por un Error en la unidad, o incluso en dos unidades, si crea un espacio de almacenamiento de reflejo Triple.
Definición de Espacio De Almacenamiento
La arquitectura interna de las bases de datos en SQL Server están compuestas por 2 tipos de estructura, la estructura lógica y la estructura física.

Es muy importante conocer cómo es que estas estructuras están compuestas y cuál es la relación que tienen los objetos de base de datos con cada una de estas estructuras.

Las Bases de datos se almacenan en ficheros o archivos.
Existen diferentes formas de organizaciones primarias de archivos que determinan la forma en que los registros de un archivo se colocan físicamente en el disco y, por lo tanto, como se accede a estos.

3.1.1 DEFINICIÓN DE ESPACIO DE ALMACENAMIENTO

Para la gestión del almacenamiento de una base de datos existen 4 conceptos bien definidos que deben ser conocidos para poder comprender la forma en la que se almacenan los datos. Vamos a ver la diferencia entre bloque, extensión, segmento y espacio de tablas.

Bloques: Se tratan de la unidad más pequeña. Generalmente debe múltiple del tamaño de bloque del sistema operativo, ya que es la unidad mínima que va a pedir Oracle al sistema operativo. Si no fuera múltiple del bloque del sistema se añadiría un trabajo extra ya que el sistema debería obtener más datos de los estrictamente necesarios. Se especifica mediante DB_BLOCK_SIZE

Extensiones: Se forma con uno o más bloques. Cuando se aumenta tamaño de un objeto se usa una extensión para incrementar el espacio.

Segmentos: Grupo de extensiones que forman un objeto de la base de datos, como por ejemplo una tabla o un índice.

Espacio de Tablas: Formado por uno o más datafiles, cada datafile solo puede pertenecer a un determinado tablespace

En general, el almacenamiento de los objetos de la base de datos (tablas e índices fundamentalmente) no se realiza sobre el archivo o archivos físicos de la base de datos, sino que se hace a través de estructuras lógicas de almacenamiento que tienen por debajo a esos archivos físicos, y que independizan por tanto las sentencias de creación de objetos de las estructuras físicas de almacenamiento. Esto es útil porque permite que a esos "espacios de objetos " les sean asociados nuevos dispositivos físicos (es decir, más espacio en disco) de forma dinámica cuando la base de datos crece de tamaño más de lo previsto. Posibilita además otra serie de operaciones como las siguientes:

Asignar cuotas específicas de espacio a usuarios de la base de datos.

Controlar la disponibilidad de los datos de la base de datos, poniendo fuera de uso alguno de esos espacios de tablas individualmente.

Realizar copias de seguridad o recuperaciones parciales de la base de datos.
Reservar espacio para almacenamiento de datos de forma cooperativa entre distintos dispositivos.

El administrador de la base de datos puede crear o borrar nuevos espacios lógicos de objetos, añadir o eliminar ficheros físicos de soporte, utilizados como espacio temporal de trabajo, definir parámetros de almacenamiento para objetos destinados a ese espacio de datos, todos los gestores relacionales que venimos introduciendo como ejemplos siguen esta filosofía. En el caso de Oracle, sobre los ficheros físicos de datos (datafiles) se definen los tablespaces. Por lo tanto, una base de datos Oracle se compone lógicamente de tablespaces, y físicamente de datafiles. Su creación es sencilla, con la sentencia GREAT'', TABLESPACE: CREATE TABLESPACE usuarios DATAFILE `datal.ora' SIZE 50M

Cada base de datos contiene un tablespace llamado SYSTEM que es creado automáticamente al crear la base de datos. Contiene las tablas del diccionario de datos para la base de datos en cuestión. Es recomendable no cargar datos de usuario en SYSTEM, para dejarlos como espacio de objetos del sistema.

Si además los datos de usuario están en tablespaces sitos en otros dispositivos, el rendimiento mejorará porque las tablas del diccionario de datos se acceden frecuentemente y por lo tanto son un cuello de botella potencial desde el punto de vista del acceso a disco. A la hora de estimar el espacio necesario para cl tablespace sys-nsm hay que tener en cuenta que las unidades de programación PL-SQL (entorno de programación SQL proporcionado por Oracle) almacenadas en la base de datos (procedimientos, paquetes, disparos y funciones) almacenan sus datos en SYSTEM. 

 

3.1.2 DEFINICIÓN Y CREACIÓN DEL ESPACIO ASIGNADO PARA CADA BASE DE DATOS

Las bases de datos se almacenan en ficheros o archivos. Existen diferentes formas de organizaciones primarias de archivos que determinan la forma en que los registros de un archivo se colocan físicamente en el disco y, por lo tanto, cómo se accede a éstos

Las distintas formas de organizaciones primarias de archivos son:

 Archivos de Montículos (o no Ordenados): esta técnica coloca los registros en el disco sin un orden específico, añadiendo nuevos registros al final del archivo.

  Archivos Ordenados (o Secuenciales): mantiene el orden de los registros con respecto a algún valor de algún campo (clave de ordenación).

 Archivos de Direccionamiento Calculado: utilizan una función de direccionamiento calculado aplicada a un campo específico para determinar la colocación de los registros en disco.

 Árboles B: se vale de la estructura de árbol para las colocaciones de registros.

 Organización Secundaria o Estructura de Acceso Auxiliar: Estas permiten que los accesos a los registros de un archivo basado en campos alternativos, sean más eficientes que los que han sido utilizados para la organización primaria de archivos.

El DBMS asigna espacio de almacenamiento a las bases de datos cuando los usuarios introducen create database o alter database. El primero de los comandos puede especificar uno o más dispositivos de base de datos, junto con la cantidad de espacio en cada uno de ellos que será asignado a la nueva base de datos.

Si se utiliza la palabra clave default o se omite completamente la cláusula on, el DBMS pone la base de datos en uno o más de los dispositivos predeterminados de base de datos especificados en master.sysdevices.

Para especificar un tamaño (por ejemplo, 4MB) para una base de datos que se va a almacenar en una ubicación predeterminada, se utiliza: on default = size de esta forma:

create database newpubs  on default = 4

3.1.3 BOTÁCORA

Son estructuras ampliamente utilizadas para grabar las modificaciones de la base de datos.

Cada registro de la bitácora escribe una única escritura de base de datos y tiene lo siguiente:

Nombre de la Transacción: Nombre de la transacción que realizó la operación de escritura.

Nombre del Dato: El nombre único del dato escrito.

Valor Antiguo: El valor del dato antes de la escritura.

Valor Nuevo: El valor que tendrá el dato después de la escritura.

Es fundamental que siempre se cree un registro en la bitácora cuando se realice una escritura antes de que se modifique la base de datos.

También tenemos la posibilidad de deshacer una modificación que ya se ha escrito en la base de datos, esto se realizará usando el campo del valor antiguo de los registros de la bitácora.

Los registros de la bitácora deben residir en memoria estable como resultado el volumen de datos en la bitácora puede ser exageradamente grande.

La instrucción en MySQL para crear una bitácora en .txt se crea antes de acceder a la base de datos con la instrucción:

"xampp>mysql>bin>mysql -hlocalhost -uroot --tee=C:bitacora.txt"

La bitácora debe registrar todos los movimientos (insertar, eliminar y modificar) que se realicen en las tablas de la base de datos. Para lograr lo anterior es necesario crear un trigger para que se ejecute después de la operación de insertar, otro para después de eliminar y el último para después de modificar para cada una de las 3 tablas de la base de datos. 

 

3.1.4 PARTICIPACIONES

Una partición es una división de una base de datos lógica o sus elementos constituyentes en partes independientes.
Las particiones de bases de datos se hacen normalmente por razones de mantenimiento, rendimiento o manejo.
Esta partición puede hacerse creando bases de datos mas pequeñas separadas (cada una con sus propias tablas, índices y registros de transacciones) o dividiendo elementos seleccionados

particiones
la partición de base de datos se hace normalmente por razones de mantenimiento, rendimiento o manejo.
esta partición puede creando bases de datos mas pequeñas separadas ( cada una con sus propias, índices, etc ) 

 

3.1.5 ESPACIOS PRIVADOS

permiten que los administradores y redactores gestionen el conjunto de datos del sitio, algunas bases de datos tienen estos espacios privados llamados comúnmente paneles de control.
Que son formularios que aparecen al abrir la base de datos

 

3.1.6 ESPCIOS PARA OBJETOS

 Los DBMS se basan en archivos para almacenar datos, y estos archivos, o conjuntos de datos, residen en medios de almacenamiento, o dispositivos. Una buena parte del trabajo del DBA implicará la planificación para el almacenamiento real de la base de datos.

El rendimiento de la base de datos depende de la entrada y salida a disco. La cantidad de datos almacenados es mayor que nunca antes, y los datos son almacenados por más tiempo.

Algunos DBMS permiten al tamaño de los archivos temporales de expandirse y contraerse de forma automática. Dependiendo del tipo y la naturaleza de las operaciones de base de datos en proceso, esta fluctuación puede provocar picos de uso del disco.

Hay muchos problemas de almacenamiento que deben ser resueltos antes de que un DBA pueda crear una base de datos. Uno de los temas más importantes es la cantidad de espacio para permitir la base de datos.

El cálculo espacial debe tener en cuenta no sólo tablas, índices, sino también, y dependiendo del DBMS, el registro de transacciones. Cada una de estas entidades probablemente requerirá un archivo separado o conjunto de datos, para el almacenamiento persistente.

El DBA debe separar en diferentes discos a los archivos para:

Mejorar el rendimiento
Separar índices de datos
Aislar los logros en otro disco.

3.2 SEGMENTOS

Los datos en la BD son almacenados físicamente en bloques Oracle: la mínima unidad de espacio físico, y es un múltiplo del bloque del SO (2 Kb usualmente). El tamaño del bloque Oracle se fija por el parámetro DB_BLOCK_SIZE del fichero init.ora. Un tamaño grande de bloque mejora la eficiencia del cache de E/S, pero el tamaño de la SGA aumentará para contener los mismos DB_BLOCK_BUFFERS, lo que significa un problema de memoria.

Una serie de bloques contiguos es una extensión, que es una unidad lógica de almacenamiento. Una serie de extensiones es un segmento. Cuando un objeto es creado, se reserva una extensión en su segmento. Cuando el objeto crezca, necesitará más espacio y se reservarán más extensiones.

Cada segmento tiene un conjunto de parámetros de almacenamiento que controla su crecimiento:

initial: tamaño de la extensión inicial (10k).

next: tamaño de la siguiente extensión a asignar (10k).

minextents: número de extensiones asignadas en el momento de la creación del segmento (1).

maxextents: número máximo de extensiones (99).

pctincrease: Porcentaje en el que crecerá la siguiente extensión antes de que se asigne, en relación con la última extensión utilizada (50).

pctfree: porcentaje de espacio libre para actualizaciones de filas que se reserva dentro de cada bloque asignado al segmento (10).

pctused: porcentaje de utilización del bloque por debajo del cual Oracle considera que un bloque puede ser utilizado para insertar filas nuevas en él.

tablespace: nombre del espacio de tablas donde se creará el segmento.

Cuando se diseña una BD se ha de tener mucho cuidado a la hora de dimensionar la BD y prever el crecimiento de las tablas. A continuación se hacen algunas consideraciones sobre la gestión del espacio para los diferentes segmentos.

Segmentos de Datos
El espacio del diccionario de datos se suele mantener más o menos constante, aunque es crítico que tenga suficiente espacio para crecer en el espacio de tablas SYSTEM. Así, hay que tener cuidado de colocar las tablas de usuario, los índices, segmentos temporales y los segmentos de rollback en otros espacios de tablas.

Además, es recomendable que el espacio de tablas SYSTEM esté al 50% o 75% de su espacio disponible. Finalmente, asegurarse que los usuarios no tienen privilegios de escritura en el espacio de tablas SYSTEM.

Las tablas crecen proporcionalmente con el número de filas, ya que se puede suponer que la longitud de las filas es constante.

Segmentos de Índice

Los índices crecen en tamaño en mayor proporción que las tablas asociadas si los datos en la tabla son modificados frecuentemente. La gestión del espacio es mejor si se mantienen los índices de tablas grandes en espacios de tablas separados.

Segmentos de Rollback

Los segmentos de rollback almacenan la imagen anterior a una modificación de un bloque. La información en el segmento de rollback se utiliza para asegurar la consistencia en lectura, el rollback (el valor en el segmento de rollback se copia en el bloque de datos) y la recuperación.

Es importante comprender cuál es el contenido de un segmento de rollback. No almacenan el bloque de datos modificado entero, sólo la imagen previa de la fila o filas modificadas. La información del segmento de roolback consiste en varias entradas llamadas undo. Por ejemplo, si se inserta una fila en una tabla, el undo necesitará sólo el rowid de la fila insertada, ya que para volver atrás la insercion sólo hay que realizar un delete. En las operación de actualización, se almacenará el valor antiguo de las columnas modificadas. El segmento de rollback asegura que la información undo se guardan durante la vida de la transacción.

Un segmento de rollback como cualquier otro segmento consiste en una serie de extensiones. Sin embargo, la mayor diferencia entre un segmento de datos y otro rollback es que en este último las extensiones se utilizan de manera circular. Así, habrá que tener cuidado a la hora de fijar el tamaño del segmento de rollback para que la cabeza no pille a la cola.

Segmentos Temporales

Los segmentos temporales se crean cuando se efectuan las siguientes operaciones:

Create Index

Select con distinct, order by, union, intersect y minus.

uniones no indexadas.

Ciertas subconsultas correlacionadas.

Si las tablas a ordenar son pequeñas la ordenación se realiza en memoria principal, pero si la tabla es grande se realiza en disco. El parámetro SORT_AREA_SIZE determina el lugar donde se hace la ordenación. Incrementándole se reduce la creación de segmentos temporales. 

 

3.3 MEMORIA COMPARTIDA

Un servidor Oracle es un sistema que permite administrar bases de datos y que ofrece un medio de gestión de información abierto, completo e integrado.

Un servidor Oracle está constituido de una instancia y una base de datos.

Instancia de Oracle

Una instancia de Oracle permite acceder a la base de datos Oracle y permite abrir únicamente una sola base de datos.

La instancia de Oracle está compuesta de:

Procesos en segundo plano que administran y aplican las relaciones entre las estructuras físicas y las estructuras de memoria. Existen dos categorías:
 

Procesos en Segundo Plano Obligatorios: DBWN, PMON, CKPT, LGWR, SMON
Procesos en Segundo Plano Facultativos: ARCn, LMDn, RECO, CJQ0, LMON, Snnn, Dnnn, Pnnn, LCKn, QMNn

Estructuras de Memoria: compuestas básicamente de dos áreas de memoria: el área de memoria asignada a la SGA (System Global Area): asignada al inicio de la instancia y representa un componente fundamental de una instancia de Oracle.

Está compuesta de varias áreas de memoria:

Área de memoria compartida

Buffer caché de la base de datos

Log buffer

Así como otras estructuras para la gestión de bloqueos externos (lock), internos (match), datos estadísticos, etc.

Eventualmente también es posible configurar al nivel de la SGA

Área de memoria LARGE POOL

Área de memoria Java

Área de Memoria Asignada a la PGA (Program Global Area): Ésta es asignada al inicio del proceso de servidor. Es reservada a cada proceso de usuario que se conecte a la base de datos Oracle y liberada al final del proceso.

El Proceso de Usuario: Es el programa que solicita una interacción con la base de datos iniciando una conexión. Se comunica únicamente con el proceso de servidor correspondiente.

El Proceso de Servidor

Representa el programa que entra directamente en interacción con el servidor Oracle. Responde a todas las peticiones y envía los resultados. Puede estar dedicado a un servidor cliente o compartido por varios. 

 

3.4 INSTANCIAS MÚLTIPLES 

Cuando comenzamos a trabajar con Oracle una de las primeras cosas que aprendemos es a diferenciar entre estos conceptos: base de datos, instancia e instancia de base de datos.

Una instancia es el conjunto de procesos que se ejecutan en el servidor así como la memoria que comparten para ello.

Cuando se habla de base de datos, nos referimos a los archivos físicos que componen nuestra base de datos.

Si queremos referirnos a los procesos que se ejecutan en memoria como a los archivos de base de datos tendremos que utilizar el término instancia de base de datos.

La instancia en Oracle describe varios procesos residentes en la memoria del computador(es) y un área de memoria compartida por aquellos procesos. En arquitecturas de bases de datos tales como, Microsoft SQL Server e IBM BD2, la palabra instancia indica una colección de bases de datos que comparten recursos de memoria en común, o sea, la relación entre instancia y bases de datos es 1 a N. Pero la relación entre la instancia de Oracle y la base de datos es 1 a 1 o n a 1. Cuando hay una relación N a 1, la configuración es llamada RAC (Real Application CLuster), donde la base de datos reside en discos compartidos y las instancias en múltiples computadores anexados a la base de datos.

La instancia de Oracle es el motor que procesa los requerimientos de datos desde la base de datos. Está compuesta por procesos en primer plano, en segundo plano y un área de memoria compartida (SGA).

CONCLUSIONES:

Una base de datos, desde que se crea hasta que se administran todos los puntos ya vistos como lo son la memoria compartida, los segmentos de datos, los espacios privados, así como los múltiples problemas de almacenamiento sigue una serie de complicaciones que dependen de nosotros como encargados de una base de datos el poder medir todas éstas cuestiones y saber en qué momento es necesario aplicar cada una de las sentencias que vimos aquí.

Hay que tener en cuenta que administrar una base de datos de manera profesional cuesta mucho tiempo y conocimiento para poder llevarlo a cabo.

Los espacios asignados son tan importantes como lo son las instrucciones básicas d euna base de datos.