Mengakses Database Dengan Ptyhon

Python merupakan bahasa pemrograman yang mendukung hampir semua platform seperti desktop, web dan yang terbaru yaitu mobile android dengan kivy, selain itu kebanyakan penggunan python sebagai dasar scripting untuk berbagai aplikasi.

Tentu sebagai bahasa scripting, python juga mensupport koneksi dengan database, sebagai contoh, python secara default mendukung penggunaan SQLite, dan tentu juga mensupport database lainnya seperti postgresql, mysql, ataupun database nosql seperti mongoDB dan sebagainya.

Persiapan Environtment

Untuk menggunakan Mysql pada Python, tentunya harus menginstall mysql server. Setelah itu, dapat menyiapkan mysql driver sebagai penghubung antara python dengan mysql-server. Ada banyak jenis driver untuk mysql, seperti Mysql-Connector, PyMysql, ataupun MysqlClient.

Install MysqlClient

Sebelum memulai, untuk pengguna linux berbasis linux, windows ataupun macOS, harus menginstall python dan mysql headers development dengan cara sebagai berikut :

sudo apt-get install python3-dev libmysqlclient-dev

atau pada MacOS

brew install mysql-connector-c

setelah menginstall development header dilanjutkan dengan menginstall mysqlclient melalu pip

pip install mysqlclient

Note Bagi pengguna Windows, jika mengalami eror dapat mecoba beberapa cara berikut :

• Install visual c++ (biasanya terjadi jika belum menginstall visual c++2010 atau ikuti requirement pada pesan erornya)
• Install menggunakan file whl 
• downgrade versi mysqlclient dengan

> pip install mysqlclient==1.3.9 > atau > pip install mysqlclient==1.3.4 >

Tentu secara umum python dapat menggunakan berbagai macam metode untuk memanggil suatu library, dengan metode direct, fungction ataupun model Objek orientasi.

Dalam bagian ini, akan menunjukkan 2 cara, menggunakan metode langsung dan metode OOP

Membuat Database

Untuk cara pertama, menggunakan cara koneksi langsung. Sebelumnya kita harus membuat database terlebih dahulu yaaaa XD,

ketikkan script berikut

CREATE TABLE `product` ( `id` int(45) NOT NULL, `name` varchar(45) NOT NULL, `price` int(11) NOT NULL, `stock` int(11) NOT NULL, PRIMARY KEY (`id`));

lalu isikan dengan data menggunakan script berikut,

INSERT INTO `product`(`id`,`name`,`price`,`stock`) VALUES (1, 'Sabun Mandi Lux', 3500, 10), (2, 'Marlboro Black Filter', 20700, 12), (3, 'Sabun cuci Muka', 15000, 100);

Direct Connection SELECT

Setelah data masuk kedalam database, langkah berikutnya akan melakukan query menggunakan python. Dalam contoh ini menggunakan metode direct connection yang artinya cara mengkoneksikannya langsung tanpa menggunakan kelas.

berikut ini contohnya :

import MySQLdb as db connection = db.connect('127.0.0.1', 'root', '', 'pos') cursor = connection.cursor() query = "SELECT * from product" cursor.execute(query) result = cursor.fetchall() for items in result: print(items)

pertama kali harus memanggil MysqlDB menggunakan syntax import.

kemudian mengkonekkan dengan database dan menyimpannya pada variabel connection.

Setelah itu mendefinisikan cursor pada object connection dan menyimpannya dengan nama yang sama yaitu cursor dimana cursor ini akan digunakan untuk mengesekusi query.

ketika query di eksekusi oleh kursor, maka dapat menampilnya dengan beberapa cara, fetchall yaitu mengambil semua baris pada database, kemudian ada fetchone yang mengambil data paling teratas.

dan result dari kode diatas adalah sebagai berikut

Direct Connection INSERT dan DELETE

Seperti umummnya koneksi dengan database, tentu ada yang namanya CRUD atau CREATE, READ, UPDATE Delete, maka kali ini akan mencoba untuk insert dan delete database.

Berikut contoh insert database ;

import MySQLdb as db connection = db.connect('127.0.0.1', 'root', '', 'pos') cursor = connection.cursor() cursor.execute("INSERT INTO `product` VALUES (%s, %s, %s, %s)", ('', 'Chiki', '5000', '50',)) connection.commit()

pada insert database , menggunakan syntax dasar mysql yaitu insert, yang diikuti string lateral dengan metode bind paramater, yaitu membuat paramater menggunakan list, bukan mempassing string, karena hal ini akan mudah di SQL Injection.

untuk contoh delete :

import MySQLdb as db connection = db.connect('127.0.0.1', 'root', '', 'pos') cursor.execute("DELETE FROM `product` WHERE `product`.`id` = 12") connection.commit()

Direct Connection UPDATE

selanjutnya adalah update data pada database,

import MySQLdb as db connection = db.connect('127.0.0.1', 'root', '', 'pos') cursor.execute("UPDATE product SET name= (% s), price= (%s), stock= (%s)" "Where id= ( % s)", ("Permen", "500", "10", "1")) connection.commit()

sama seperti sebelum-sebelumnya, memanfaatkan bind paramater, dengan membuat isinya menjadi bentuk list sebagai salah satu upaya menghindari sql injection,

Connection Class

Metode selanjutnya adalah menggunakan kelas untuk menginisialisasi koneksi pada database. Pada contoh ini hanya menggunakan kelas sebagai inisiator untuk menghubungkan ke database, untuk querynya tetap menggunakan metode biasa, sebagai catatan, ada 1 tools yang lebih baik dari segi efesiensi kode dan keamanan yaitu dengan menggunakan orm seperti sql-alchemy yang akan dibahas dalam tutorial Flask Versi 2.

Implementasi langsugn, pertama membuat kelas koneksi, dalam hal ini saya menamakan filenya connection.py

import MySQLdb as mysql import hashlib import sys import warnings class MysqlUserDB: # initialization Connection Database # Init Start warnings.filterwarnings('error') def __init__(self, DBrootHost, DBrootUser, DBrootPass, DBrootDatabase): self.DBrootHost = DBrootHost self.DBrootUser = DBrootUser self.DBrootPass = DBrootPass self.DBrootDatabase = DBrootDatabase try: print("Checking connection of MYSQL ...") self.con = mysql.connect(DBrootHost, DBrootUser, DBrootPass, DBrootDatabase) self.cursor = self.con.cursor() self.cursor.execute('Select version()') print("Connected to Mysql Database\n") # except mysql.Error as error: # print("Error %s\n Stop.\n" % error) # sys.exit() except Warning as warn: print("Warning", warn) def CreateDB(self, DBrootDatabase): print("Creating database...") try: self.cursor.execute('CREATE database if NOT exists ' + DBrootDatabase) self.cursor.execute("SHOW DATABASES LIKE %s", (DBrootDatabase,)) dbs = self.cursor.fetchone() print("Database created: ", dbs[0]) except Warning as warn: print("Warning: %s \nStopping Process.\n" % warn) sys.exit() def GrantsAccess(self, DBrootDatabase): print("Accessing Account ...") try: self.cursor.execute("SHOW DATABASES LIKE %s", (DBrootDatabase,)) result = self.cursor.fetchone() print("Access Granted for Database", result[0]) except Warning as warn: print("Warningg %s" % warn) def getDB(self): return self.cursor def delCon(self): print("Finishing operation ...") self.cursor.close() self.con.close() print("Finished") # Init End

dalam kelas fungsi diatas, menginisialisasi paramater untuk koneksi yang dinisialisasi pada method init, Sedangkan untuk me-return hasil koneksi, menggunakan method getDB hal ini untuk mereturn cursor untuk dipanggil saat melakukan eksekusi, dan untuk memutuskan koneksi menggunakan method delcon, sedangkan sisa method lainnya hanya sebagai method pendukung, sebenernya untuk lebih memudahkan lagi, bisa membuat method-method khusus crud seperti method untuk melakukan select dan sebagainya, namun karena keterbatasan waktu, maka hanya membuat dasarnya saja.

Setelah itu, membuat file baru untuk mengetes apakah koneksi berhasil dan melakukan query.
dalam hal ini menggunakan connectionTes.py

import connection as dbs import warnings warnings.filterwarnings('error') mysqli = dbs.MysqlUserDB(DBrootHost='127.0.0.1', DBrootUser='root', DBrootPass='', DBrootDatabase='pos') db = mysqli.getDB() try: db.execute("select * from product") results = db.fetchall() for result in results: print(result) except db.Error as error: print(error) mysqli.delCon()

dalam hal ini, mengimport kelas connection sebagai db. Setelah itu di inisialisasi dengan variabel baru bernaman mysqli.

dan membuat object cursor pada db dengan memanggil object kelas mysql.getDB()

untuk querynya hampir sama dengan yang sebelumnya. perbedannya adalah mengkoneksikannya menggunakan kelas

Contoh Program Dengan Python tkinter

1. Membuat perhitungan

sintax :

from tkinter import *

class MembuatKolomTeks(Frame) :

    def __init__(self) :

        self.buatTeks()

        self.buatKolom()

        self.buatTombol()

    def buatTeks(self):

        self.teks = Label(text="")

        self.teks.grid(row = 1, column=0)

    def buatKolom(self):

        self.kolom1 = Entry()

        self.kolom1.bind("", self.hitung)

        self.kolom1.grid(row=0, column=0)

    def buatTombol(self):

        Button(text='cetak', command=self.hitungCetak).grid(row=0, column=1)

    def hitung(self, event):

        try :

            self.teks.configure(text="hasil: " + str(eval(self.kolom1.get())))

        except :

            self.teks.configure(text="ada yang salah pada kolom")

    def hitungCetak(self):

        try :

            print("hasil: " + str(eval(self.kolom1.get())))

        except :

            print("ada yang salah pada kolom")

master = Tk()

MembuatKolomTeks()

mainloop()

tampilan :

2. Membuat kalkulator sederhana

sintax :

from functools import partial

import tkinter as tk

class applikasiKalkulator(tk.Tk):

    def __init__(self):

        tk.Tk.__init__(self)

        self.title("Kalkulator tkinter")

        self.membuatTombol()

        self.penentu = False

    def membuatTombol(self):

        self.layar = tk.Entry(self, width=25)

        self.layar.grid(row=0, column=0, columnspan=5)

        btn_list = [

            '1', '2', '3',

            '4', '5', '6',

            '7', '8', '9',

            '0', '+', '-',

            'C', '/', '*',

            '='

        ]

        baris = 1

        kolom = 0

        for penampung in btn_list:

            perintah = partial(self.hitung, penampung)

            if penampung == '=':

                tk.Button(self, text='=', width=22, command=perintah).grid(row=baris, column=kolom, columnspan=5)

            else :

                tk.Button(self, text=penampung, width=5, command=perintah).grid(row=baris, column=kolom)

            kolom += 1

            if kolom > 2:

                kolom = 0

                baris += 1

    def hitung(self, key):

        if key == '=':

            self.penentu = True

            try:

                result = eval(self.layar.get())

                self.layar.delete(0, tk.END)

                self.layar.insert(tk.END, str(result))

            except:

                self.layar.insert(tk.END, "-> Error!")

        elif key == 'C':

            self.layar.delete(0, tk.END)

        else:

            if self.penentu :

                self.layar.delete(0, tk.END)

                self.penentu = False

            self.layar.insert(tk.END, key)

panggil = applikasiKalkulator()

panggil.mainloop()

tampilan :

3. Membuat Stopwatch.

sintax :

import tkinter as tk

penghitung = 0

def hitung(teks):

    def count():

        global penghitung

        penghitung += 1

        teks.config(text=str(penghitung))

        teks.after(1000, count)

    count()

root = tk.Tk()

teks = tk.Label(root, font = "Verdana 16 bold")

teks.pack()

hitung(teks)

tombol = tk.Button(root, text='Stop', width=25, command=root.destroy)

tombol.pack()

root.mainloop()

tampilan :

mereset nilai ketika mencapai angka 60 pada penghitung detik

sintax :

import tkinter as tk

detik = 0

menit = 0

def hitung(teks1, teks2):

    def count():

        global detik

        global menit

        if detik >= 59 :

            detik = 0

            menit += 1

        detik += 1

        teks1.config(text="detik : "+str(detik))

        teks2.config(text="menit : "+str(menit))

        teks1.after(1000, count)

    count()

root = tk.Tk()

teksDetik = tk.Label(root, font = "Verdana 16 bold")

teksMenit = tk.Label(root, font = "Verdana 16 bold")

teksDetik.pack()

teksMenit.pack()

hitung(teksDetik, teksMenit)

tombol = tk.Button(root, text='Stop', width=25, command=root.destroy)

tombol.pack()

root.mainloop()

tampilan :

4. Membuat Games Ular Simple

sintax :

""" 

nilai keycode arah kanan, kiri, atas dan bawah pada keybord memiliki nilai yang berbeda

#untuk pengguna windows, silahkan ubah nilai pengecekan keycode nya seperti di bawa  ini

            if event.keycode == 38:

                self.direction = "up"

            elif event.keycode == 39:

                self.direction = "right"

            elif event.keycode == 40:

                self.direction = "down"

            elif event.keycode == 37:

                self.direction = "left"

#untuk pengguna linux, silahkan ubah nilai pengecekan keycode nya seperti di bawa  ini

            if event.keycode == 111:

                self.direction = "up"

            elif event.keycode == 114:

                self.direction = "right"

            elif event.keycode == 116:

                self.direction = "down"

            elif event.keycode == 113:

                self.direction = "left"

"""

import threading

import random

import os.path

from tkinter import *

WIDTH = 500

HEIGHT = 500

class Snake(Frame):

    def __init__(self):

        Frame.__init__(self)

        self.master.title("Permainan ular. mn-belajarpython.blogspot.com")

        self.grid()

        frame1 = Frame(self)

        frame1.grid()

        self.canvas = Canvas(frame1, width = WIDTH, height = HEIGHT, bg ="white")

        self.canvas.grid(columnspan = 3)

        self.canvas.focus_set()

        self.canvas.bind("", self.create)

        self.canvas.bind("", self.create)

        newGame = Button(frame1, text = "Permainan Baru", command = self.new_game)

        newGame.grid(row = 1, column = 0, sticky = E)

        self.score_label = Label(frame1)

        self.score_label.grid(row = 1, column = 1)

        self.high_score_label = Label(frame1)

        self.high_score_label.grid(row = 1, column = 2)

        self.new_game()

    def new_game(self):

        self.canvas.delete(ALL)

        self.canvas.create_text(WIDTH/2,HEIGHT/2-50,text="selamat datang di game ular ini!"\

                                + "\nklik window atau tekan salah satu tombol arah"

                                + "\nuntuk memulai game ini..", tag="welcome_text")

        rectWidth = WIDTH/25

        rect1 = self.canvas.create_rectangle(WIDTH/2-rectWidth/2, HEIGHT/2-rectWidth/2, WIDTH/2+rectWidth/2\

                                             , HEIGHT/2+rectWidth/2, outline="#dbf", fill="#dbf"\

                                             , tag="rect1")

        rect2 = self.canvas.create_rectangle(WIDTH/2-rectWidth/2, HEIGHT/2-rectWidth/2, WIDTH/2+rectWidth/2\

                                             , HEIGHT/2+rectWidth/2, outline="#dbf", fill="#dbf"\

                                             , tag="rect2")

        rect3 = self.canvas.create_rectangle(WIDTH/2-rectWidth/2, HEIGHT/2-rectWidth/2, WIDTH/2+rectWidth/2\

                                             , HEIGHT/2+rectWidth/2, outline="#dbf", fill="#dbf"\

                                             , tag="rect3")

        self.rectWidth = rectWidth

        self.lastDirection = None

        self.direction = None

        self.started = False

        self.game_over = False

        self.score = 0

        if (os.path.isfile("high_score.txt")):

            scoreFile = open("high_score.txt")

            self.high_score = int(scoreFile.read())

            scoreFile.close()

        else:

            self.high_score = 0

        self.high_score_label["text"] = "Score tertinggi: " + str(self.high_score)

        self.rectangles = [rect1,rect2,rect3]

        self.dot = None

        self.move()

    def create(self, event):

        self.lastDirection = self.direction

        if self.game_over == False:

            if event.keycode == 38: #untuk linux nilai nya adalah 111

                self.direction = "up"

            elif event.keycode == 39: #untuk linux nilai nya adalah 114

                self.direction = "right"

            elif event.keycode == 40: #untuk linux nilai nya adalah 116

                self.direction = "down"

            elif event.keycode == 37: #untuk linux nilai nya adalah 113

                self.direction = "left"

            elif event.x < WIDTH/2 and HEIGHT/3 < event.y < HEIGHT-HEIGHT/3:

                self.direction = "left"

            elif event.x > WIDTH/2 and HEIGHT/3 < event.y < HEIGHT-HEIGHT/3:

                self.direction= "right"

            elif WIDTH/3 < event.x < WIDTH-WIDTH/3 and event.y < HEIGHT/2:

                self.direction = "up"

            elif WIDTH/3 < event.x < WIDTH-WIDTH/3 and event.y > HEIGHT/2:

                self.direction= "down"

    def first_movement(self):

        w = self.rectWidth

        self.canvas.delete("welcome_text")

        if self.direction == "left":

                self.canvas.move("rect1",-w,0)

                self.canvas.after(100)

                self.canvas.move("rect1",-w,0)

                self.canvas.move("rect2",-w,0)

        elif self.direction == "down":

                self.canvas.move("rect1",0,w)

                self.canvas.after(100)

                self.canvas.move("rect1",0,w)

                self.canvas.move("rect2",0,w)

        elif self.direction == "right":

                self.canvas.move("rect1",w,0)

                self.canvas.after(100)

                self.canvas.move("rect1",w,0)

                self.canvas.move("rect2",w,0)

        elif self.direction == "up":

            self.canvas.move("rect1",0,-w)

            self.canvas.after(100)

            self.canvas.move("rect1",0,-w)

            self.canvas.move("rect2",0,-w)

        self.canvas.after(100)

    def _move(self):

        w = self.rectWidth

        while True:

            self.score_label["text"] = "Score: " + str(self.score)

            if self.started == False and self.direction != None:

                self.first_movement()

                self.started = True

            elif self.started == True and self.game_over == False:

                if self.dot == None:

                    self.make_new_dot()

                lock = threading.Lock()

                lock.acquire()

                endRect = self.rectangles.pop()

                frontCoords = self.canvas.coords(self.rectangles[0])

                endCoords = self.canvas.coords(endRect)

                if self.direction == "left":

                    self.canvas.move(self.canvas.gettags(endRect), int(frontCoords[0]-endCoords[0])-w,\

                                     int(frontCoords[1]-endCoords[1]))

                elif self.direction == "down":

                    self.canvas.move(self.canvas.gettags(endRect), int(frontCoords[0]-endCoords[0]),\

                                     int(frontCoords[1]-endCoords[1])+w)

                elif self.direction == "right":

                    self.canvas.move(self.canvas.gettags(endRect), int(frontCoords[0]-endCoords[0])+w,\

                                     int(frontCoords[1]-endCoords[1]))

                elif self.direction == "up":

                    self.canvas.move(self.canvas.gettags(endRect), int(frontCoords[0]-endCoords[0]),\

                                     int(frontCoords[1]-endCoords[1])-w)

                self.canvas.after(100)

                self.rectangles.insert(0, endRect)

                lock.release()

                self.check_bounds()

                self.check_collide()

            elif self.game_over == True:

                break;

    def move(self):

        threading.Thread(target=self._move).start()

    def make_new_dot(self):

        if self.dot != None:

            self.canvas.delete(self.dot)

            self.dot = None

        dotX = random.random()*(WIDTH-self.rectWidth*2) + self.rectWidth

        dotY = random.random()*(HEIGHT-self.rectWidth*2) + self.rectWidth

        self.dot = self.canvas.create_rectangle(dotX,dotY,dotX+self.rectWidth,dotY+self.rectWidth\

                                                ,outline="#ddd", fill="#ddd", tag="dot")

    def grow(self):

        w = self.rectWidth

        lock = threading.Lock()

        lock.acquire()

        self.score += 100

        endCoords = self.canvas.coords(self.rectangles[len(self.rectangles)-1])

        thisTag = "rect" + str(len(self.rectangles) + 1)

        x1 = int(endCoords[0])

        y1 = int(endCoords[1])

        x2 = int(endCoords[2])

        y2 = int(endCoords[3])

        if self.direction == "left":

            x1 += w

            x2 += w

        elif self.direction == "right":

            x1 -= w

            x2 -= w

        elif self.direction == "down":

            y1 -= w

            y2 -= w

        elif self.direction == "up":

            y1 += w

            y2 += w

        thisRect = self.canvas.create_rectangle(x1, y1, x2, y2, outline="#dbf",\

                                     fill="#dbf", tag=thisTag)

        self.rectangles.append(thisRect)

        lock.release()

    def check_bounds(self):

        coordinates = self.canvas.coords(self.rectangles[0])

        if len(coordinates) > 0:

            if coordinates[0] < 0 or coordinates[1] < 0 or coordinates[2] > WIDTH\

               or coordinates[3] > HEIGHT:

                self.end_game()

    def check_collide(self):

        frontCoords = self.canvas.coords(self.rectangles[0])

        overlapping = self.canvas.find_overlapping(frontCoords[0],frontCoords[1]\

                                                         ,frontCoords[2],frontCoords[3])

        for item in overlapping:

            if item == self.dot:

                #Snake collided with dot, grow snake and move dot

                self.grow()

                self.make_new_dot()

            if item in self.rectangles[3:]:

                #Snake has collided with its body, end game

                self.end_game()

        if (self.lastDirection == "left" and self.direction == "right") or\

           (self.lastDirection == "right" and self.direction == "left") or\

           (self.lastDirection == "up" and self.direction == "down") or\

           (self.lastDirection == "down" and self.direction == "up"):

            self.end_game()

    def end_game(self):

        self.game_over = True

        self.canvas.create_text(WIDTH/2,HEIGHT/2,text="GAME OVER!")

        if self.score > self.high_score:

            scoreFile = open("high_score.txt", "w")

            scoreFile.write(str(self.score))

            scoreFile.close()

            self.canvas.create_text(WIDTH/2,HEIGHT/2+20,text=\

                                    "wew.... Kamu mendapatkan Score tinggi baru!")

Snake().mainloop()

tampilan :

pertama kali program dijalankan

setelah ditekan salah satu tombol arah

kalau kalah dalam permainan

mengambarkan perolehan nilai

Menggambar di python dengan window tkinter

1. Menambahkan gambar di window tkinter.
sintax :
from tkinter import *

root = Tk()
gambar = PhotoImage(file="/home/moham/moham.png")
w1 = Label(root, image=gambar).pack(side="right")

root.mainloop()

tampilan;

menampilkan teks di tengah gambar

sintax :

from tkinter import *

root = Tk()

gambar = PhotoImage(file="/home/moham/moham.png")

teks = """hey hey... arahkan pandangan kalia ke sini ya...

gimana ? ini teks nya temen - temen..

sudah berada di tengah ya....

berati program yang saya bagikan ini bisa kita katakan sukses ya..

makanya simak terus tutorial - tutorial lainnya

di mn-belajarpython.blogspot.co.id ini ya.. hehe

"""

w = Label(root, fg = "white",

          compound = CENTER,

          text=teks,

          image=gambar).pack(side="right")

root.mainloop()

tampilan :

2. Membuat garis di window tkinter.
sintax :
from tkinter import Tk, Canvas, Frame, BOTH

class MembuatGaris(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent)

        self.window = parent
        self.initUI()

    def initUI(self):
        self.window.title("Lines")
        self.pack(fill=BOTH, expand=1)
        self.window.geometry("400x250")

        self.buatGaris()
    
    def buatGaris(self):
        kanvas = Canvas(self)
        kanvas.create_line(15, 25, 200, 25)
        
        kanvas.pack(fill=BOTH, expand=1)

if __name__ == '__main__':
    root = Tk()
    ex = MembuatGaris(root)
    root.mainloop()

tampilan;

membuat garis putus - putus

sintax :

from tkinter import Tk, Canvas, Frame, BOTH

class MembuatGaris(Frame):

    def __init__(self, parent):

        Frame.__init__(self, parent)

        self.window = parent

        self.initUI()

    def initUI(self):

        self.window.title("Lines")

        self.pack(fill=BOTH, expand=1)

        self.window.geometry("400x250")

        self.buatGaris()

   

    def buatGaris(self):

        kanvas = Canvas(self)

        kanvas.create_line(300, 35, 300, 200, dash=(4, 2))

        kanvas.pack(fill=BOTH, expand=1)

if __name__ == '__main__':

    root = Tk()

    ex = MembuatGaris(root)

    root.mainloop()

tampilan :

3. Membuat Bintang di tkinter.
sintax :
from tkinter import *

class MembuatBintang():
    def __init__(self):
        self.buatBintang()
    def buatBintang(self):
        kanvas = Canvas(width=200, height=200)
        kanvas.pack()
        koordinat = [100, 140, 110, 110, 140, 100, 110, 90, 100, 60, 90, 90, 60, 100, 90, 110]
        kanvas.create_polygon(koordinat, outline='green', fill='yellow', width=3)

Tk()
MembuatBintang()
mainloop()

tampilan;




4. Membuat lingkaran, oval, kotak dan lain - lain.
sintax :
from tkinter import Tk, Canvas, Frame, BOTH

class MembuatBerbagaiBentuk(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent)

        self.window = parent
        self.initUI()

    def initUI(self):
        self.window.title("Shapes")
        self.pack(fill=BOTH, expand=1)
        self.window.geometry("330x220+300+300")
        self.buatBentuk()

    def buatBentuk(self):
        canvas = Canvas(self)
        canvas.create_oval(10, 10, 80, 80, outline="green", fill="blue", width=2)
        canvas.create_oval(110, 10, 210, 80, outline="green", fill="blue", width=2)
        canvas.create_rectangle(230, 10, 290, 60, outline="green", fill="blue", width=2)
        canvas.create_arc(30, 200, 90, 100, start=0, extent=210, outline="green", fill="blue", width=2)

        points = [150, 100, 200, 120, 240, 180, 210, 200, 150, 150, 100, 200]
        canvas.create_polygon(points, outline='green', fill='blue', width=2)

        canvas.pack(fill=BOTH, expand=1)

if __name__ == '__main__':
    root = Tk()
    ex = MembuatBerbagaiBentuk(root)
    root.mainloop()

tampilan;



5. Menampilkan 3 kotak warna.
sintax :
from tkinter import Tk, Canvas, Frame, BOTH

class MembuatWarna(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent)

        self.window = parent
        self.initUI()

    def initUI(self):
        self.window.title("Colours")
        self.pack(fill=BOTH, expand=1)
        self.window.geometry("400x100+300+300")

        self.buatWarna()

    def buatWarna(self):
        kanvas = Canvas(self)
        kanvas.create_rectangle(30, 10, 120, 80, outline="#f50", fill="#fb0")
        kanvas.create_rectangle(150, 10, 240, 80, outline="#fb0", fill="#f50")
        kanvas.create_rectangle(270, 10, 370, 80, outline="#0f5", fill="#05f")
        kanvas.pack(fill=BOTH, expand=1)

if __name__ == '__main__':
    root = Tk()
    ex = MembuatWarna(root)
    root.mainloop()

tampilan;



6. Membuat window tikinter seperti buku kotak.
sintax :
from tkinter import *

class BuatKotak():
    def __init__(self):
        self.buatCanvas()
        
    def buatCanvas(self):
        kanvas = Canvas(master, width=200, height=200)
        kanvas.pack()
        self.pembuatKotak(kanvas, 12)
    def pembuatKotak(self, canvas, jarak):
       for x in range(jarak,200,jarak):
          canvas.create_line(x, 0, x, 200)
       for y in range(jarak,200,jarak):
          canvas.create_line(0, y, 200, y)
            
master = Tk()
BuatKotak()
mainloop()

tampilan;



7. Membuat window tkinter seperti terowongan.
sintax :
from tkinter import *

class Terowongan():
    def __init__(self):
        self.buatKanvas()
        self.buatTerowongan()
        
    def buatKanvas(self):
        self.kanvas = Canvas(width=200, height=100)
        self.kanvas.pack()
        
    def buatTerowongan(self):
        self.kanvas.create_rectangle(50, 20, 150, 80, fill="green")
        self.kanvas.create_rectangle(65, 35, 135, 65, fill="yellow")
        self.kanvas.create_line(0, 0, 50, 20, fill="green", width=3)
        self.kanvas.create_line(0, 100, 50, 80, fill="green", width=3)
        self.kanvas.create_line(150, 20, 200, 0, fill="green", width=3)
        self.kanvas.create_line(150, 80, 200, 100, fill="green", width=3)

Tk()
Terowongan()
mainloop()

tampilan;




8. Membuat teks keren di window tkinter.
sintax :
from tkinter import Tk, Canvas, Frame, BOTH, W


class MembuatTeks(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent)

        self.window = parent
        self.initUI()

    def initUI(self):
        self.window.title("membuat tulisan keren")
        self.pack(fill=BOTH, expand=1)
        self.window.geometry("580x250")
        self.buatTeks()
        
    def buatTeks(self):
        kanvas = Canvas(self)
        kanvas.create_text(20, 30, anchor=W, font="Purisa", text="oke, ini dia temen - temen teks nya...")
        kanvas.create_text(20, 60, anchor=W, font="Purisa", text="gimana ? ya cukup keren lah ya...")
        kanvas.create_text(20, 130, anchor=W, font="Purisa", text="tentu lebih keren bila kita bandingkan dengan teks biasa pada")
        kanvas.create_text(20, 160, anchor=W, font="Purisa", text="umumnya yang cendrung standard dan membosankan..")
        kanvas.create_text(20, 190, anchor=W, font="Purisa", text="jangan lupa simak tutorial menarik lainnya ya..")
        kanvas.create_text(20, 220, anchor=W, font="Purisa", text="tentu saja di mn-belajarpython.blogspot.co.id ini ya...")
        kanvas.pack(fill=BOTH, expand=1)

if __name__ == '__main__':
    root = Tk()
    ex = MembuatTeks(root)
    root.mainloop()

tampilan;



9. Menggambar dengan kursor di window tkinter.
sintax :
from tkinter import *

class Menggambar():
    def __init__(self):
        self.buatKanvas()
        self.pesan()

    def buatKanvas(self):
        self.kanvas = Canvas(master, width=500, height=150)
        self.kanvas.pack(expand=YES, fill=BOTH)
        self.kanvas.bind("", self.gambar)

    def pesan(self):
        message = Label(master, text="klik dan seret untuk menggambar")
        message.pack(side=BOTTOM)

    def gambar(self,event):
        x1, y1 = (event.x - 1), (event.y - 1)
        x2, y2 = (event.x + 1), (event.y + 1)
        self.kanvas.create_oval(x1, y1, x2, y2, fill="green")

master = Tk()
Menggambar()
mainloop()

tampilan;


10. Menampilkan Ikon bawaan tkinter.
sintax :
from tkinter import *

class MenampilkanIkon():
    def __init__(self):
        self.buatKanvas()
        self.panggilIkon()
        self.tampilIkon()

    def buatKanvas(self):
        self.kanvas = Canvas(master, width=300, height=80)
        self.kanvas.pack()

    def panggilIkon(self):
        self.ikon = ["error", "gray75", "gray50", "gray25", "gray12", "hourglass", "info", "questhead", "question",
                "warning"]

    def tampilIkon(self):
        jmlIkon = len(self.ikon)
        posisi = int(300 / jmlIkon)

        for i in range(0, jmlIkon):
            self.kanvas.create_bitmap((i + 1) * posisi - posisi / 2, 50, bitmap=self.ikon[i])

master = Tk()
MenampilkanIkon()
mainloop()

tampilan;