Text stringlengths 1 9.41k |
|---|
Here is an example:
filename=askopenfilename(initialdir='c:\\python31\\',
filetypes=[('Image files', '.jpg .png .gif'),
('All files', '*')])
**A short example** Here is an example that opens a file dialog that allows you to select a text file.
The program then displays the contents of the file in a textbox.
|hort... |
e program then displays the contents of the file in a textbox.|Col2|
|---|---|
|||
|from tkinter import * from tkinter.filedialog import * from tkinter.scrolledtext import ScrolledText root = Tk() textbox = ScrolledText() textbox.grid() filename=askopenfilename(initialdir='c:\\python31\\', filetypes=[('Text files', '.t... |
GUI PROGRAMMING III_
('All files', '*')])
s = open(filename).read()
textbox.insert(1.0, s)
mainloop()
###### 17.8 Menu bars
We can create a menu bar, like the one below, across the top of a window.
Here is an example that uses some of the dialogs from the previous section:
**from tkinter import ***
**from tkinte... |
Use the Toplevel function:
|re is an example that uses some of the dialogs from the previous section:|Col2|
|---|---|
|||
|from tkinter import * from tkinter.filedialog import * def open_callback(): filename = askopenfilename() # add code here to do something with filename def saveas_callback(): filename = asksaveasfi... |
PACK_ 175
You can add widgets to the new window. |
The first argument when you create the widget needs to
be the name of the window, like below
new_window = Toplevel()
label = Label(new_window, text='Hi')
label.grid(row=0, column=0)
###### 17.10 pack
There is an alternative to grid called pack. |
It is not as versatile as grid, but there are some places
where it is useful. It uses an argument called side, which allows you to specify four locations for
your widgets: TOP, BOTTOM, LEFT, and RIGHT. |
There are two useful optional arguments, fill and
expand. |
Here is an example.
button1=Button(text='Hi')
button1.pack(side=TOP, fill=X)
button2=Button(text='Hi')
button2.pack(side=BOTTOM)
The fill option causes the widget to fill up the available space given to it. |
It can be either X, Y or
BOTH. The expand option is used to allow the widget to expand when its window is resized. |
To
enable it, use expand=YES.
**Note** You can use pack for some frames, and grid for others; just don’t mix pack and grid
within the same frame, or Tkinter won’t know quite what to do.
###### 17.11 StringVar
In Section 16.5 we saw how to tie a Tkinter variable, called an IntVar, to a check button or a radio
button... |
Tkinter has another type of variable called a StringVar that holds strings. This type of
variable can be used to change the text in a label or a button or in some other widgets. |
We already
know how to change text using the configure method, and a StringVar provides another way
to do it.
To tie a widget to a StringVar, use the textvariable option of the widget. |
A StringVar has
get and set methods, just like an IntVar, and whenever you set the variable, any widgets that
are tied to it are automatically updated.
-----
176 _CHAPTER 17. |
GUI PROGRAMMING III_
Here is a simple example that ties two labels to the same StringVar. |
There is also a button that
when clicked will alternate the value of the StringVar (and hence the text in the labels).
**from tkinter import ***
**def callback():**
**global count**
s.set('Goodbye' if count%2==0 else 'Hello')
count +=1
root = Tk()
count = 0
s = StringVar()
s.set('Hello')
label1 = Label(textvariab... |
See Lundh’s Introduction to Tkinter [2] for more. |
Tkinter
is versatile and simple to work with, but if you need something more powerful, there are other
third-party GUIs for Python.
|re is a simple example that ties two labels to the same StringVar. |
There is also a button that en clicked will alternate the value of the StringVar (and hence the text in the labels).|Col2|
|---|---|
|||
|from tkinter import * def callback(): global count s.set('Goodbye' if count%2==0 else 'Hello') count +=1 root = Tk() count = 0 s = StringVar() s.set('Hello') label1 = Label(textvaria... |
The tricky thing is that as of version 3.0, Python broke compatibility with
older versions of Python. |
Code written in those older versions will not always work in Python 3.
The problem with this is there were a number of useful libraries written for Python 2 that, as of this
writing, have not yet been ported to Python 3. |
We want to use these libraries, so we will have to
learn a little about Python 2. |
Fortunately, there are only a few big differences that we have to worry
about.
**Division** The division operator, /, in Python 2, when used with integers, behaves like //. |
For
instance, 5/4 in Python 2 evaluates to 1, whereas 5/4 in Python 3 evaluates to 1.2. This is the
way the division operator behaves in a number of other programming languages. |
In Python 3, the
decision was made to make the division operator behave the way we are used from math.
In Python 2, if you want to get 1.25 by dividing 5 and 4, you need to do 5/4.0. |
At least one of the
arguments has to be a float in order for the result to be a float. |
If you are dividing two variables,
then instead of x/y, you may need to do x/float(y).
###### print The print function in Python 3 was actually the print statement in Python 2. |
So in
Python 2, you would write
**print 'Hello'**
without any parentheses. |
This code will no longer work in Python 3 because the print statement
is now the print function, and functions need parentheses. |
Also, the current print function has
those useful optional arguments, sep and end, that are not available in Python 2.
177
-----
178 _CHAPTER 18. |
FURTHER GRAPHICAL PROGRAMMING_
###### input The Python 2 equivalent of the input function is raw_input.
range The range function can be inefficient with very large ranges in Python 2. |
The reason is
that in Python 2, if you use range(10000000), Python will create a list of 10 million numbers.
The range statement in Python 3 is more efficient and instead of generating all 10 million things
at once, it only generates the numbers as it needs them. |
The Python 2 function that acts like the
Python 3 range is xrange.
**String formatting** String formatting in Python 2 is a little different than in Python 3. |
When using
the formatting codes inside curly braces, in Python 2, you need to specify an argument number.
Compare the examples below:
Python 2: 'x={0:3d},y={1:3d},z={2:3d}'.format(x,y,z)
Python 3: 'x={:3d},y={:3d},z={:3d}'.format(x,y,z)
As of Python 3.1, specifying the argument numbers was made optional.
There is al... |
Here are a few Tkinter name
changes:
Python 2 Python 3
Tkinter tkinter
ScrolledText tkinter.scrolledtext
tkMessageBox tkinter.messagebox
tkFileDialog tkinter.filedialog
There are a number of other modules we’ll see later that were renamed, mostly just changed to
lowercase. |
For instance, Queue in Python 2 is now queue in Python 3.
**Dictionary comprehensions** Dictionary comprehensions are not present in Python 2.
**Other changes** There are quite a few other changes in the language, but most of them are with
features more advanced than we consider here.
-----
_18.2. |
THE PYTHON IMAGING LIBRARY_ 179
**Importing future behavior** The following import allows us to use Python 3’s division behavior
in Python 2.
**from __future__ import division**
There are many other things you can import from the future.
###### 18.2 The Python Imaging Library
The Python Imaging Library (PIL) con... |
As of this writing,
the PIL is only available for Python 2.7 or earlier. The PIL is not part of the standard Python
distribution, so you’ll have to download and install it separately. |
It’s easy to install, though.
PIL hasn’t been maintained since 2009, but there is a project called Pillow that it nearly compatible
with PIL and works in Python 3.0 and later.
[We will cover just a few features of the PIL here. |
A good reference is The Python Imaging Library](http://effbot.org/imagingbook/)
_[Handbook.](http://effbot.org/imagingbook/)_
**Using images other than GIFs with Tkinter** Tkinter, as we’ve seen, can’t use JPEGs and PNGs.
But it can if we use it in conjunction with the PIL. |
Here is a simple example:
**from Tkinter import ***
**from PIL import Image, ImageTk**
root = Tk()
cheetah_image = ImageTk.PhotoImage(Image.open('cheetah.jpg'))
button = Button(image=cheetah_image)
button.grid(row=0, column=0)
mainloop()
The first line imports Tkinter. |
Remember that in Python 2 it’s an uppercase Tkinter. The next
line imports a few things from the PIL. |
Next, where we would have used Tkinter’s PhotoImage to
load an image, we instead use a combination of two PIL functions. |
We can then use the image like
normal in our widgets.
**Images** PIL is the Python Imaging Library, and so it contains a lot of facilities for working with
images. |
We will just show a simple example here. |
The program below displays a photo on a canvas
and when the user clicks a button, the image is converted to grayscale.
|ages PIL is the Python Imaging Library, and so it contains a lot of facilities for working with ages. |
We will just show a simple example here. |
The program below displays a photo on a canvas d when the user clicks a button, the image is converted to grayscale.|Col2|
|---|---|
|||
|from Tkinter import * from PIL import Image, ImageTk def change(): global image, photo pix = image.load()||
-----
180 _CHAPTER 18. |
FURTHER GRAPHICAL PROGRAMMING_
**for i in range(photo.width()):**
**for j in range(photo.height()):**
red,green,blue = pix[i,j]
avg = (red+green+blue)//3
pix[i,j] = (avg, avg, avg)
photo=ImageTk.PhotoImage(image)
canvas.create_image(0,0,image=photo,anchor=NW)
**def load_file(filename):**
**global image, photo**
i... |
Many of the image utilities are in the Image module. We
give a name, image, to the object created by the Image.open statement. |
We also use the convert
method to convert the image into RGB (Red-Green-Blue) format. We will see why in a minute. |
The
next line creates an ImageTk object called photo that gets drawn to the Tkinter canvas. |
The photo
object has methods that allow us to get its width and height so we can size the canvas appropriately.
Now look at the change function. |
The image object has a method called load that gives access to
the individual pixels that make up the image. |
This returns a two-dimensional array of RGB values.
For instance, if the pixel in the upper left corner of the image is pure white, then pix[0,0] will be
(255,255,255). |
If the next pixel to the right is pure black, pix[1,0] will be (0,0,0). |
To convert
the image to grayscale, for each pixel we take the average of its red, green, and blue components,
and reset the red, green, and blue components to all equal that average. |
Remember that if the red,
green, and blue are all the same, then the color is a shade of gray. |
After modifying all the pixels, we
create a new ImageTk object from the modified pixel data and display it on the canvas.
You can have a lot of fun with this. Try modifying the change function. |
For instance, if we use the
following line in the change function, we get an effect that looks like a photo negative:
pix[i,j] = (255-red, 255-green, 255-blue)
Try seeing what interesting effects you can come up with.
Note, though, that this way of manipulating images is the slow, manual way. |
PIL has a number of
much faster functions for modifying images. You can very easily change the brightness, hue, and
contrast of images, resize them, rotate them, and much more. |
See the PIL reference materials for
more on this.
-----
_18.2. |
THE PYTHON IMAGING LIBRARY_ 181
###### putdata If you are interested drawing mathematical objects like fractals, plotting points pixelby-pixel can be very slow in Python. |
One way to speed things up is to use the putdata method.
The way it works is you supply it with a list of RGB pixel values, and it will copy it into your image.
Here is a program that plots a 300 300 grid of random colors.
_×_
**from random import randint**
**from Tkinter import ***
**from PIL import Image, ImageTk**
... |
It can be used
to draw rectangles, circles, points, and more, just like Tkinter canvases, but it is faster. |
Here is a
short example that fills the image with a dark blue color and then 100 randomly distributed yellow
points.
**from random import randint**
**from Tkinter import ***
|tdata If you are interested drawing mathematical objects like fractals, plotting points pixel- pixel can be very slow in Python. |
One way to speed things up is to use the putdata method. e way it works is you supply it with a list of RGB pixel values, and it will copy it into your image. |
re is a program that plots a 300 × 300 grid of random colors.|Col2|
|---|---|
|||
|from random import randint from Tkinter import * from PIL import Image, ImageTk root = Tk() canvas = Canvas(width=300, height=300) canvas.grid() image=Image.new(mode='RGB',size=(300,300)) L = [(randint(0,255), randint(0,255), randint(0,2... |
It can be used draw rectangles, circles, points, and more, just like Tkinter canvases, but it is faster. |
Here is a rt example that fills the image with a dark blue color and then 100 randomly distributed yellow nts.|Col2|
|---|---|
|||
|from random import randint from Tkinter import *||
-----
182 _CHAPTER 18. |
FURTHER GRAPHICAL PROGRAMMING_
**from PIL import Image, ImageTk, ImageDraw**
root = Tk()
canvas = Canvas(width=300, height=300)
canvas.grid()
image=Image.new(mode='RGB',size=(300,300))
draw = ImageDraw.Draw(image)
draw.rectangle([(0,0),(300, 300)],fill='#000030')
L = [(randint(0,299), randint(0, 299)) for i in range... |
The
draw.rectangle method works similarly to the create_rectangle method of canvases, except
for a few differences with parentheses. |
The draw.point method is used to plot individual pixels.
A nice feature of it is we can pass a list of points instead of having to plot each thing in the list
separately. |
Passing a list is also much faster.
###### 18.3 Pygame
Pygame is a library for creating two-dimensional games in Python. It can be used to can make
games at the level of old arcade or Nintendo games. |
It can be downloaded and easily installed
[from www.pygame.org. There are a number of tutorials there to help you get started. |
I don’t know](http://www.pygame.org)
a whole lot about Pygame, so I won’t cover it here, though perhaps in a later edition I will.
-----
### Part III
## Intermediate Topics
183
-----
-----
### Chapter 19
## Miscellaneous topics III
In this chapter we examine a variety of useful topics.
###### 19.1 Mutabilit... |
If we want to change the first element of the list to 3, L[0]=3 will do it. But we cannot
change a string this way. The reason has to do with how Python treats lists and strings. |
Lists
(and dictionaries) are said to be mutable, which means their contents can change. Strings, on the
other hand, are immutable, which means they cannot be changed. |
The reason strings are immutable
is partly for performance (immutable objects are faster) and partly because strings are thought of
fundamental in the same way that numbers are. |
It makes some other aspects of the language easier
as well.
**Making copies** Another place that lists and strings differ is when we try to make copies. |
Consider
the following code:
s = 'Hello'
copy = s
s = s + '!!!'
**print('s is now:', s, '** Copy:', copy)
###### s is now: Hello!!! |
Copy: Hello
In the code above we make a copy of s and then change s. Everything works as we would intuitively expect. |
Now look at similar code with lists:
L = [1,2,3]
copy = L
185
|king copies Another place that lists and strings differ is when we try to make copies. |
Consider following code:|Col2|
|---|---|
|||
|s = 'Hello' copy = s s = s + '!!!' print('s is now:', s, ' Copy:', copy)||
|he code above we make a copy of s and then change s. |
Everything works as we would intu- ely expect. Now look at similar code with lists:|Col2|
|---|---|
|||
|L = [1,2,3] copy = L||
-----
186 _CHAPTER 19. |
MISCELLANEOUS TOPICS III_
L[0]=9
**print('L is now:', L, '** Copy:', copy)
###### L is now: [9, 2, 3] Copy: [9, 2, 3]
We can see that the list code did not work as we might have expected. |
When we changed L, the
copy got changed as well. As mentioned in Chapter 7, the proper way to make a copy of L is
copy=L[:]. |
The key to understanding these examples is references.
**References** Everything in Python is an object. This includes numbers, strings, and lists. |
When we
do a simple variable assignment, like x=487, what actually happens is Python creates an integer
object with the value 487, and the variable x acts as a reference to that object. |
It’s not that the value
4 is stored in a memory location named x, but rather that 487 is stored somewhere in memory,
and x points to that location. |
If we come along and declare y=487, then y also points to that same
memory location.
On the other hand, if we then come along and say x=721, what happens is we create a new integer
object with value 721 somewhere in memory and x now points at that. |
The 487 still exists in
memory where it was and it will stay there at least until there is nothing left pointing at it, at which
point its memory location will be free to use for something else.
All objects are treated the same way. |
When we set s='Hello', the string object Hello is somewhere in memory and s is a reference to it. When we then say copy=x, we are actually saying
that copy is another reference to 'Hello'. |
If we then do s=s+'!!!', what happens is a new
object 'Hello!!!' is created and because we assigned s to it, s is now a reference to that new
object, 'Hello!!!'. |
Remember that strings are immutable, so there is no changing 'Hello' into
something. |
Rather, Python creates a new object and points the variable s to it.
When we set L=[1,2,3], we create a list object [1,2,3] and a reference, L, to it. |
When we say
copy=L, we are making another reference to the object [1,2,3]. When we do L[0]=9, because
lists are mutable, the list [1,2,3] is changed, in place, to [9,2,3]. |
No new object is created.
The list [1,2,3] is now gone, and since copy is still pointing to the same location, it’s value is
[9,2,3].
On the other hand, if we instead use copy=L[:], we are actually creating a new list object somewhere else in memory so that there are two copies of [1,2,3] in memory. |
Then when we do
L[0]=9, we are only changing the thing that L points to, and copy still points to [1,2,3].
Just one further note to drive the point home. |
If we set x=487 and then set x=721, we are first
creating an integer object 487 and pointing x to it. When we then set x=721, we are creating a
new integer object 721 and pointing x to it. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.