We need a one line Python program that will prove that the Python interpreter is installed and working on our computer platform.
construction_work
or constr
for short. You will place all your Python programs inside this directory. In a text editor such as gedit on Linux or notepad on Windows. If we are working in Windows, there is a nice editor called "Context" that can be downloaded for free from http://www.contexteditor.org/ Context, that is sensitive to Python syntax and has a search-and-replace function that is useful.Print 'My wereld is "my world" in Dutch'
simple_1.py
, inside the directory called constr
. constr
- where simple_1.py
is located. python simple_1.py
and your program will execute. The result should look like the following screenshot:""" Program name: simplest_1.py Objective: Print text to the screen. Keywords: text, simplest ========================= Printed "mywereld" on terminal. Author: Mike Ohlson de Fine """ Print 'mywereld is "my world" in Dutch'
Any instructions you type into a Linux X terminal or DOS terminal in MS Windows are treated as operating system commands. By starting these commands from within the same directory where your Python program is stored you do not have to tell the Python and operating system where to search for your code. You could store the code in another directory but you would then need to precede the program name with the path.
Try the longer version of the same basic print instructions shown in the following program.
All the text between the """ (triple quotation marks) is purely for the sake of good documentation and record keeping. It is for the use of programmers, and that includes you. Alas, the human memory is imperfect. Bitter experience will persuade you that it is wise to provide fairly complete information as a header in your programs as well as comments inside the program.
However, in the interest of saving space and avoiding distractions, these header comments have been left out in the rest of this book.
Here is a slightly longer version of the previous program. However, the following modules are commanded to "report for duty" inside our program even though they are not actually used at this time: Tkinter, math, random, time, tkFont
.
We need the assurance that all the Python modules we will be using later are present and accessible to Python, and therefore, to our code. Each module is a self-contained library of code functions and objects that are called frequently by the commands in your programs.
simple_2.py
, inside the directory called constr
as we did previously. constr
- where simple_1.py
is located. python simple_2.py
and our program should execute. The result should look like the following screenshot:""" Program name: simplest_2.py Objective: Send more than one line of text to the screen. Keywords: text, simple ====================================== Author: Mike Ohlson de Fine """ import Tkinter import math import random import time import tkFont print "=======================================" print "A simple, apparently useless program like this does useful things:" print "Most importantly it checks whether your Python interpreter and " print "the accompanying operating system environment works" print " - including hardware and software" print "======================================" print " No matter how simple it is always a thrill" print " to get your first program to run"
The print
command is an instruction to write or print any text between quotation marks like "show these words" onto the monitor screen attached to your computer. It will also print the values of any named variables or expressions typed after print.
For example: print "dog's name:
", dog_name
. Where dog_name
is the name of a variable used to store some data.
The print
command is very useful when you are debugging a complicated sequence of code because even if the execution fails to complete because of errors, any print commands encountered before the error is reached will be respected. So by thoughtful placing of various print statements in your code, you are able to zero in on what is causing your program to crash.
When you are writing a piece of Python code for the first time, you are often a bit unsure if your understanding of the logic is completely correct. So we would like to watch the progress of instruction execution in an exploratory way. It is a great help to be able to see that at least part of the code works. A major strength of Python is the way it takes our instructions one at a time and executes them progressively. It will only stop when the end is reached or a when programming flaw halts progress. If we have a twenty line program and only the first five lines are bug-free and the rest are unexecutable garbage, the Python interpreter will at least execute the first five. This is where the print
command is a really potent little tool.
This is how you use print and the Python interpreter. When we are having trouble with our code and it just won't work and we are battling to figure out why, we can just insert print statements at various chosen points in our program. This way you can get some intermediate values of variables as your own private status reports. When we want to switch off our print watchdogs we simply type a hash (#) symbol in front, thus transforming them into passive comments. Later on, if you change your mind and want the prints to be active again you just remove the leading hash symbols.
Here we attempt to execute a Tkinter command inside the Python program. The Tkinter instruction will create a canvas and then draw a straight line on it.
simple_line_1.py
, inside the directory called constr
again. constr
- where simple_line_1.py
is located. python simple_line_1.py
and your program should execute. The command terminal result should look like the following screenshot:#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from Tkinter import * root = Tk() root.title('Very simple Tkinter line') canvas_1 = Canvas(root, width=300, height=200, background="#ffffff") canvas_1.grid(row=0, column=0) canvas_1.create_line(10,20 , 50,70) root.mainloop() #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
To draw a line, we only need to give the start point and the end point.
The start point is the first pair of numbers in canvas_1.create_line(10,20 , 50,70).In
another way, the start is given by the coordinates x_start=10
and y_start=20
. The end point of the line is specified by the second pair of numbers x_end=50
and y_end=70
. The units of measurement are pixels. A pixel is the smallest dot that can be displayed on our screen.
For all other properties like line thickness or color, default values of the create_line()
method are used.
However, should you want to change color or thickness, you just do it by specifying the settings.
How do we create and execute a.exe file that will run a compiled version of our Python and Tkinter programs? Can we make a self-contained folder that will run on an MS Windows or Linux distribution that uses a different version of Python from the ones we use? The answers to both questions are yes and the tool to achieve this is an Open Source program called cx_Freeze
. Often what we would like to do is have our working Python program on a memory stick or downloadable on a network and be able to demonstrate it to friends, colleagues, or clients without the need to download Python onto the client's system. cx_Freeze
allows us to create a distributable form of our Python graphic program.
You will need to download cx_Freeze
from http://cx-freeze.sourceforge.net/. We need to pick a version that has the same version number as the Python version we are using. Currently, there are versions available from version 2.4 up to 3.1.
cx_Freeze-4.2.win32-py2.6.msi
, the windows installer for Python 2.6. If we have another Python version, then we must choose the appropriate installer from http://cx-freeze.sourceforge.net/. cx_Freeze inside Python26Libsite-packages
. apt-get install cx-freeze
. apt-get install python-dev
. Then go back and repeat step 1. python
in a command terminal to invoke the Python interpreter.>>>
prompt, type import cx_Freeze
. If the interpreter returns a new line and the>>>
prompt again, without any complaints, we have been successful. walking_birdy_1.py
in a folder called /constr
, then we prepare a special setup file as follows.#setup.py from cx_Freeze import setup, Executable setup(executables=[Executable("/constr/walking_birdy_1.py")])
setup.py
.python /constr/setup.py build
build
. Under Linux, we will find it inside our home directory under /build/exe.linux-i686-2.6
. Under MS Windows, we will find it inside C:Python26uildexe.win-py2.6
. build
with all its contents to wherever we want to run our self-contained program.A word of caution. If we use external files like images inside our code, then the path addresses of the files must be absolute because they are coded into, or frozen, into the executable version of our Python program. There are ways of setting up search paths which can be read at http://cx-freeze.sourceforge.net/cx_Freeze.html.
For example, say we want to use some GIF
images in our program and then demonstrate them on other computers. First we place a folder called, for example, /birdy_pics
, onto a USB memory stick. In the original program, walking_birdy_1.py
, make sure the path addresses to the images point to the /birdy_pics
folder on the stick. After compilation, copy the folder build
onto the USB memory stick. Now when we double-click on the executable walking_birdy_1
it can locate the images on the USB memory stick when it needs to. These files include everything that is needed for your program, and you should distribute the whole directory contents to any user who wants to run your program without needing to install Python or Tkinter.
There is another program called py2exe
that will also create executables to run on MS Windows. However, it cannot create self-contained binary executables to run under Linux whereas cx_Freeze
3.16.76.138