Python is a high-level, general-purpose programming language. Its design philosophy emphasizes code readability with the use of significant indentation

Guide to Programming with Python 2
Objectives
• Work with a GUI toolkit
• Create and fill frames
• Create and use buttons
• Create and use text entries and text boxes
• Create and use check buttons
• Create and use radio buttons

The Mad Lib Program
Figure 10.1: Sample run of the Mad Lib program
A nicely laid-out GUI awaits the user’s creativity.

The Mad Lib Program (continued)
The user has entered all of the necessary information.

The Mad Lib Program (continued)
After clicking Click for story button, text box displays masterpiece.

Examining A GUI
Figure 10.4: Examining a GUI
You’ll learn to create all of these GUI elements.

Examining A GUI (continued)
Table 10.1: Selected GUI Elements

Understanding Event-Driven
Programming
• Event-driven program: A program that responds
to actions regardless of the order in which they
occur
• Event: Something that happens involving a
program's objects
• Event handler: Code that runs when a specific
event occurs
• Bind: To associate an event with an event handler
• Event loop: A loop that checks for events and calls
appropriate event handlers when they occur

Understanding Event-Driven
Programming (continued)
• GUI programs traditionally event-driven
• Mad Lib without event-driven programming
– Ask series of questions with raw_input() function
– Ask for name of a person, plural noun...
– User must provide each piece of information, in order
• Mad Lib with event-driven programming
– Can use a GUI
– User can enter the information in any order

Using A Root Window
• Root Window
– Foundation of GUI program
– Foundation upon which to add all other GUI
elements
– Like root of tree, anchors all other parts

The Simple GUI Program
Figure 10.5: Sample run of the Simple GUI program
The program creates only a lone window. simple_gui.py

The Simple GUI Program (continued)
• GUI programs can generate console window too
• Console window helpful to see error messages
• On Windows machine can suppress console
window by changing program extension from py to
pyw

Importing the Tkinter Module
from Tkinter import *
• Tkinter is a GUI module
• Imports all Tkinter into global scope
• Normally, avoid this kind of import
• Some modules designed to be imported this way
• Saves typing and makes for cleaner code

Creating a Root Window
root = Tk()
• To create a root window, instantiate object of the
Tkinter class Tk
• Because of from Tkinter import *, no need to prefix
the module name

Modifying a Root Window
root.title("Simple GUI")
root.geometry("200x100")
• title()
– Sets title of root window
– Takes string
• geometry()
– Sets size of the root window
– Takes string (not integers) for window’s width and
height, separated by the "x" character

Entering a Root Window’s Event Loop
root.mainloop()
• Root window's event loop entered
• Window stays open, waiting to handle events

Using Labels
• Widget: GUI elements (short for "window gadget")
• Label widget
– Uneditable text or icons (or both)
– Often used to label other widgets
– Unlike most other widgets, labels aren’t interactive

The Labeler Program
Figure 10.7: Sample run of the Labeler program
A label can provide information about a GUI.
labeler.py

Creating a Frame
app = Frame(root)
• Master: A widget that contains other widgets
• Layout Manager: Controls arrangement of widgets
• Frame is widget that can hold other widgets
• When creating widget, must pass its master to
constructor of new object
• Here, root is master that contains app

Creating a Frame (continued)
app.grid()
• grid()
– Method that all widgets have
– Associated with grid layout manager
– Can be used to create desired layout of widgets

Creating a Label
lbl = Label(app, text = "I'm a label!")
lbl.grid()
• Label Class
– For a label widget
– Master is first argument passed to constructor
– text parameter for widget's text
– grid() method invoked ensures widget visible
(places widget at a default location in frame if called
with no arguments)

Using Buttons
• Button widget
– Is a button in GUI
– Can be activated by user to perform some action

The Lazy Buttons Program
Figure 10.8: Sample run of the Lazy Buttons program
You can click these lazy buttons all you want; they won’t do a thing.
lazy_buttons.py

Creating Buttons
bttn1 = Button(app, text = "I do nothing!")
bttn1.grid()
• Button Class
– For a button widget
– Master is first argument passed to constructor
– text parameter for widget's text
– grid() method invoked ensures widget visible

Creating Buttons (continued)
bttn2 = Button(app)
bttn2.grid()
bttn2.configure(text = "Me too!")
• Can add blank button to the frame
• configure() method sets or changes widget options
– Useful for changing widget after it has been
instantiated

Creating Buttons (continued)
bttn3 = Button(app)
bttn3.grid()
bttn3["text"] = "Same here!"
• Can access widget's options through dictionary-like
interface
• Key for option is name of the option as a string
• Here, set third button's text option to "Same here!”
• Useful for changing widget after it has been
instantiated (like .config())

Creating a GUI Using a Class
• Organizing code into classes can make
programming easier
• Often beneficial to write larger GUI programs in
OOP style

The Lazy Buttons 2 Program
Figure 10.9: Sample run of the Lazy Buttons 2 program
Program appears the same but significant changes under the hood.

Defining the Application Class
class Application(Frame):
""" A GUI application with three buttons. """
def __init__(self, master):
• Instead of instantiating Frame object, will instantiate
Application object
• Application object becomes just a specialized
type of Frame object
• master will be the Tk window that the frame
belongs to (root in all our examples so far)

Defining a Constructor Method
Frame.__init__(self, master)
self.grid()
self.create_widgets()
• Frame constructor called first
– This is what is used instead of super() for old object classes
• Pass Application object’s master, so it gets
properly set as master
• Invoke Application object’s create_widgets()
method

Defining a Method to Create the
Widgets
def create_widgets(self):
self.bttn1 = Button(self,
text = "I do nothing!")
self.bttn1.grid()
self.bttn2 = Button(self)
self.bttn2.grid()
self.bttn2.configure(text = "Me too!")
self.bttn3 = Button(self)
self.bttn3.grid()
self.bttn3["text"] = "Same here!"

Creating the Application Object
# main
root = Tk()
root.title("Lazy Buttons 2")
root.geometry("200x85")
app = Application(root)
root.mainloop()
• Application object created here, not Frame object
• root is still master of object
• root.mainloop() still invoked
lazy_buttons2.py

Binding Widgets and Event Handlers
• So far, GUI programs haven't had event handlers
• Widgets are like light fixtures without electrical
wiring
• Write event handlers and bind them with events

The Click Counter Program
Figure 10.10: Sample run of the Click Counter program
Button’s event handler updates number of times button clicked.

Setting Up the Program
from Tkinter import *
class Application(Frame):
Frame.__init__(self, master)
self.grid()
self.bttn_clicks = 0 # number clicks
self.create_widget()

Binding the Event Handler
def create_widget(self):
self.bttn = Button(self)
self.bttn["text"]= "Total Clicks: 0"
self.bttn["command"] = self.update_count
self.bttn.grid()
• Set widget’s command option to bind activation of
widget with event handler
• command option bound to update_count() method
• When button clicked, update_count() invoked

Creating the Event Handler
def update_count(self):
self.bttn_clicks += 1
self.bttn["text"] = "Total Clicks: " +
str(self.bttn_clicks)
• update_count() increments total number of button
clicks and changes text to reflect new total
click_counter.py

Using Text and Entry Widgets and
the Grid Layout Manager
• Entry widget is good for single line of text
• Text widget is great for multi-line blocks of text
• Can read contents of either
• Can insert text into either
• Grid layout manager lets you place widgets at
specific locations by treating frame as a grid

The Longevity Program
Figure 10.11: Sample run of the Longevity Program
With incorrect password, program politely refuses to divulge its secret.

The Longevity Program (continued)
Figure 10.12: Sample run of the Longevity Program
With correct password, program shares its knowledge to long life.

Placing a Widget with the Grid Layout
Manager
Figure 10.13: Illustrates placement of button widgets
Frame can be seen as a grid of cells at row and column numbers.

Placing a Widget with the
Grid Layout Manager
self.inst_lbl = Label(self, text = "Enter
password for the secret of longevity")
self.inst_lbl.grid(row = 0, column = 0,
columnspan = 2, sticky = W)
• grid() method
– row takes integer; defines the row in which the object
is placed (within the widget’s master)
– column takes integer; defines the column in which
the object is placed (within the widget’s master)
– columnspan takes integer; defines width in columns
– sticky takes constants (N, S, E, W); positions
widget at specified edge of cell (centered by default)

Placing a Widget with the
Grid Layout Manager
# create label for password
self.pw_lbl = Label(self, text = "Password: ")
self.pw_lbl.grid(row = 1, column = 0, sticky = W)
• Creates a label that appears in row 1, left-justified

Creating an Entry Widget
# create entry widget to accept password
self.pw_ent = Entry(self)
self.pw_ent.grid(row = 1, column = 1, sticky = W)
• Entry widget accepts and displays line of text

Creating a Button Widget
# create submit button
self.submit_bttn = Button(self, text = "Submit",
command = self.reveal)
self.submit_bttn.grid(row = 2, column = 0,
sticky = W)
• Bind the activation of button with reveal() method
• Place button in next row, left-justified

Creating a Text Widget
# create text widget to display message
self.secret_txt = Text(self, width = 35,
height = 5, wrap = WORD)
self.secret_txt.grid(row = 3, column = 0,
columnspan = 2, sticky = W)
• wrap parameter determines how text in the box is
wrapped
– WORD wraps entire words
– CHAR wraps characters
– NONE no wrapping (can only write text on the first line)

Getting and Inserting Text with Text-
Based Widgets
def reveal(self):
""" Display message based on password. """
contents = self.pw_ent.get()
if contents == "secret":
message = "Here's the secret..."
else:
message = "That's not the correct..."
self.secret_txt.delete(0.0, END)
self.secret_txt.insert(0.0, message)

Getting and Inserting Text with Text-
Based Widgets (continued)
• get() returns text from text-based widget
• delete() deletes text from text-based widget
– Can take single index or beginning and ending point
– Pass floating-point number for row and column
– Tkinter provides constants, such as END
• insert() inserts a string into a text-based widget
– Takes an insertion position and a string
– Pass floating-point number for row and column
longevity.py

Using Check Buttons
• Check buttons allow user to select any number of
choices from a group
• Provides flexibility for user and control of limiting
choices for programmer

The Movie Chooser Program
Figure 10.14: Sample run of the Movie Chooser program
The results of the user’s selections show up in the text box.

Allowing a Widget’s Master to Be Its
Only Reference
Label(self,
text = "Choose your favorite movie types"
).grid(row = 0, column = 0, sticky = W)
• Label object
– Not assigned to variable
– Can't be directly accessed
– Connected to the program by its master

Creating Check Buttons
# create Comedy check button
self.likes_comedy = BooleanVar()
• BooleanVar
– Special class from Tkinter module
– Can reflect check button’s status
– Required by Checkbutton object

Creating Check Buttons (continued)
Checkbutton(self,
text = "Comedy",
variable = self.likes_comedy,
command = self.update_text
• variable takes BooleanVar for status of check button
• command takes function or method to call when
check button is checked or unchecked

Getting the Status of a Check Button
def update_text(self):
likes = ""
if self.likes_comedy.get():
likes += "You like comedic movies.n"
• BooleanVar
– Can’t access the value directly
– Must invoke object’s get() method
movie_chooser.py

Using Radio Buttons
• Radio buttons allow user to select one from a
group of choices
• Provides programmer control by limiting range of
choices and allowing only single choice

The Movie Chooser 2 Program
Figure 10.15: Sample run of the Movie Chooser program
The user can select only a single movie type.

Creating Radio Buttons
# create variable for single, favorite type
self.favorite = StringVar()
• StringVar
– Special class from Tkinter module
– Can reflect status of a group of radio buttons
– Required by Radiobutton objects

Creating Radio Buttons (continued)
Radiobutton(self,
text = "Comedy",
variable = self.favorite,
value = "comedy.",
command = self.update_text
• variable parameter gets StringVar self.favorite
• When radio button is selected, StringVar assigned
string referenced by object’s value option
• When Comedy radio button selected, StringVar
self.favorite assigned "comedy."

Getting a Value from a Group of Radio
Buttons
message = "Your favorite type of movie is "
message += self.favorite.get()
• get() method returns string referenced by the
StringVar that all Radiobutton objects share
• When Comedy radio button selected,
self.favorite.get() returns "comedy "
movie_chooser2.py

The Mad Lib Program
mad_lib.py

Summary
• A GUI is a graphical user interface
• A widget, short for window gadget, is a GUI
element
• A master widget contains other widgets
• A layout manager controls the arrangement of
widgets
• An event-driven program responds to actions
regardless of the order in which they occur
• An event is something that happens involving a
program’s objects

Summary (continued)
• An event handler is code that runs when a specific
event occurs
• To bind is to associate an event with an event
handler
• An event loop checks for events and, based on
them, calls the appropriate event handlers
• Tkinter is a GUI module
• A Label object represents a label widget
• A Frame object represents a frame widget

Summary (continued)
• A Button object represents a button widget
• An Entry object represents a text entry widget
• A Text object represents a text box widget
• A Checkbutton object represents a check button
widget
• A Radiobutton object represents a radio button
widget

Python is a high-level, general-purpose programming language. Its design philosophy emphasizes code readability with the use of significant indentation

More Related Content

Similar to Python is a high-level, general-purpose programming language. Its design philosophy emphasizes code readability with the use of significant indentation (20)

More from bhargavi804095 (20)

Recently uploaded (20)

Python is a high-level, general-purpose programming language. Its design philosophy emphasizes code readability with the use of significant indentation