Configuring Ubuntu for Python Development — How to Think Like a Computer Scientist: Learning with Python 3
http://openbookproject.net/thinkcs/python/english3e/app_c.html[1/4/2012 9:39:05 PM]
GASP
Several of the case studies use GASP (Graphics API for Students for Python), which is the only
additional library needed to use this book.
To install GASP on Ubuntu 9.04 (Jaunty) or later, run the following command at a unix command
prompt:
or use the synaptic package manager.
Getting GASP from Launchpad
To install the latest version of GASP into your home directory, run the following commands at a unix
command prompt:
$HOME environment
The following creates a useful environment in your home directory for adding your own Python
libraries and executable scripts:
1.  From the command prompt in your home directory, create bin and lib/python subdirectories by
running the following commands:
2.  Add the following lines to the bottom of your .bashrc in your home directory:
This will set your prefered editor to Vim, add your own lib/python subdirectory for your Python
libraries to your Python path, and add your own bin directory as a place to put executable
scripts. You need to logout and log back in before your local bin directory will be in your 
search
path.
Making a python script executable and runnable from anywhere
On unix systems, Python scripts can be made 
executable
using the following process:
1.  Add this line as the first line in the script:
2.  At the unix command prompt, type the following to make myscript.py executable:
$ sudo apt-get install python-gasp
$ sudo apt-get install bzr
$ bzr branch lp:gasp-code
$ mkdir bin lib
$ mkdir lib/python
PYTHONPATH=$HOME/lib/python
EDITOR=vim
export PYTHONPATH EDITOR
#!/usr/bin/env python
$ chmod +x myscript.py
Pdf password online - C# PDF Password Library: add, remove, edit PDF file password in C#.net, ASP.NET, MVC, WinForms, WPF
Help to Improve the Security of Your PDF Document by Setting Password
create password protected pdf; pdf password protect
Pdf password online - VB.NET PDF Password Library: add, remove, edit PDF file password in vb.net, ASP.NET, MVC, WinForms, WPF
Help to Improve the Security of Your PDF Document by Setting Password
copy protection pdf; pdf password
Configuring Ubuntu for Python Development — How to Think Like a Computer Scientist: Learning with Python 3
http://openbookproject.net/thinkcs/python/english3e/app_c.html[1/4/2012 9:39:05 PM]
index
next |
previous  |
How to Think Like a Computer Scientist: Learning with Python 3 »
3.  Move myscript.py into your bin directory, and it will be runnable from anywhere.
© 
Copyright 2011, Peter Wentworth, Jeffrey Elkner, Allen B. Downey and Chris Meyers. Created using 
Sphinx 1.0.7.
Online Remove password from protected PDF file
Online Remove Password from Protected PDF file. Download Free Trial. Remove password from protected PDF file. Find your password-protected PDF and upload it.
pdf print protection; pdf protection remover
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
RasterEdge. PRODUCTS: ONLINE DEMOS: Online HTML5 Document Viewer; Online XDoc.PDF PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF
copy protecting pdf files; convert password protected pdf to excel
Customizing and Contributing to the Book — How to Think Like a Computer Scientist: Learning with Python 3
http://openbookproject.net/thinkcs/python/english3e/app_d.html[1/4/2012 9:39:09 PM]
index
next |
previous  |
How to Think Like a Computer Scientist: Learning with Python 3 »
Customizing and Contributing to the Book
Note:
the following instructions assume that you are connected to the Internet and that
you have both the 
main and 
universe package repositories enabled. All unix shell
commands are assumed to be running from your home directory ($HOME). Finally, any
command that begins with 
sudo assums that you have administrative rights on your
machine. If you do not — please ask your system administrator about installing the
software you need.
This book is free as in freedom, which means you have the right to modify it to suite your needs, and
to redistribute your modifications so that our whole community can benefit.
That freedom lacks meaning, however, if you the tools needed to make a custom version or to
contribute corrections and additions are not within your reach. This appendix attempts to put those
tools in your hands.
Thanks!
Jeffrey Elkner
Governor’s Career and Technical Academy in Arlington
Arlington, Virginia
Getting the Source
This book is 
marked up in 
ReStructuredText using a document generation system called 
Sphinx.
The source code is located on the 
Launchpad website at
http://bazaar.launchpad.net/~thinkcspy/thinkcspy/english2e/files.
The easiest way to get the source code on an Ubuntu 9.10 computer is:
1.  run 
sudo apt-get install bzr on your system to install 
bzr.
2.  run 
bzr branch lp:thinkcspy.
The last command above will download the book source from Launchpad into a directory named
thinkcspy which contains the Sphinx source and configuration information needed to build the book.
Making the HTML Version
To generate the html version of the book:
1.  run 
sudo apt-get install python-sphinx to install the Sphinx documentation system.
2. 
cd thinkcspy - change into the 
thinkcspy directory containing the book source.
3. 
make html.
The last command will run sphinx and create a directory named 
build containing the html verion of
the text.
Note
: Sphinx supports building other output types as well, such as 
PDF. This requires that
LaTeX be present on your system. Since I only personally use the html version, I will not
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
RasterEdge. PRODUCTS: ONLINE DEMOS: Online HTML5 Document Viewer; Online XDoc.PDF PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF
copy text from protected pdf; pdf password unlock
C# HTML5 PDF Viewer SDK to view, annotate, create and convert PDF
document protection. Users are able to set a password to PDF online directly in ASPX webpage. C#.NET: Edit PDF Permission in ASP.NET.
add password to pdf; convert pdf password protected to word online
Customizing and Contributing to the Book — How to Think Like a Computer Scientist: Learning with Python 3
http://openbookproject.net/thinkcs/python/english3e/app_d.html[1/4/2012 9:39:09 PM]
index
next |
previous  |
How to Think Like a Computer Scientist: Learning with Python 3 »
attempt to document that process here.
© 
Copyright 2011, Peter Wentworth, Jeffrey Elkner, Allen B. Downey and Chris Meyers. Created using 
Sphinx 1.0.7.
C# HTML5 PDF Viewer SDK to create PDF document from other file
RasterEdge. PRODUCTS: ONLINE DEMOS: Online HTML5 Document Viewer; Online XDoc.PDF PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF
create pdf password; convert password protected pdf to excel online
VB.NET PDF - Convert PDF Online with VB.NET HTML5 PDF Viewer
RasterEdge. PRODUCTS: ONLINE DEMOS: Online HTML5 Document Viewer; Online XDoc.PDF PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF
acrobat password protect pdf; change password on pdf
Some Tips, Tricks, and Common Errors — How to Think Like a Computer Scientist: Learning with Python 3
http://openbookproject.net/thinkcs/python/english3e/app_e.html[1/4/2012 9:39:12 PM]
index
next |
previous  |
How to Think Like a Computer Scientist: Learning with Python 3 »
Some Tips, Tricks, and Common Errors
These are small summaries of ideas, tips, and commonly seen errors that might be helpful to those
beginning Python.
Functions
Functions help us with our mental chunking: they allow us to group together statements for a high-
level purpose, e.g. a function to sort a list of items, a function to make the turtle draw a spiral, or a
function to compute the mean and standard deviation of some measurements.
There are two kinds of functions: fruitful functions 
calculate and return a value
, and we use them
because we’re primarily interested in the value they’ll return. Non-fruitful functions are used because
they 
perform actions
that we want done — e.g. make a turtle draw a rectangle, or print the first
thousand prime numbers. They always return None — a special dummy value.
Tip: None is not a string
Values like None, True and False are not strings: they are special values in Python, and are in the list of
keywords we gave in chapter 2. Keywords are special in the language: they are part of the syntax. So we
cannot create our own variable or function with a name True — we’ll get a syntax error. (Built-in
functions are not priviledged like keywords: we can define our own variable or function called 
len, but
we’d be silly to do so!)
Along with the fruitful/non-fruitful division, there are two flavours of the 
return statement in Python
- one that returns a useful value, and the other that returns nothing, or None. And if we get to the end
of any function and we have not explicitly executed any 
return statement, Python automatically
returns the value None.
Tip: Understand what the function needs to return
Perhaps nothing — some functions exists purely to perform actions rather than to calculate and return a
result.
To make functions more useful, they are given 
parameters
. So a function to make a turtle draw a
square might have two parameters — one for the turtle that needs to do the drawing, and another for
the size of the square. See the first example in Chapter 4 — that function can be used with any turtle,
and for any size square. So it is much more general than a function that always uses a specific turtle,
say 
tess to draw a square of a specific size, say 30.
Tip: Use parameters to generalize functions
Understand which parts of the function will be hard-coded and unchangeable, and which parts should
become parameters so that they can be customized by the caller of the function.
Tip: Try to relate Python functions to ideas we already know
In math, we’re familiar with functions like 
f(x) = 3x + 5. We already understand that when we call the
VB.NET PDF - Create PDF Online with VB.NET HTML5 PDF Viewer
RasterEdge. PRODUCTS: ONLINE DEMOS: Online HTML5 Document Viewer; Online XDoc.PDF PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF
break pdf password online; pdf password online
VB.NET PDF - Annotate PDF Online with VB.NET HTML5 PDF Viewer
VB.NET PDF - Annotate PDF Online with VB.NET HTML5 PDF Viewer. Explanation about transparency. VB.NET HTML5 PDF Viewer: Annotate PDF Online. This
convert pdf password protected to word online; a pdf password online
Some Tips, Tricks, and Common Errors — How to Think Like a Computer Scientist: Learning with Python 3
http://openbookproject.net/thinkcs/python/english3e/app_e.html[1/4/2012 9:39:12 PM]
function 
f(3) we make some association between the parameter x and the argument 3. Try to draw
parallels to argument passing in Python.
Quiz: Is the function 
f(z) = 3z + 5 the same as function 
f above?
Problems with logic and flow of control
We often want to know if some condition holds for any item in a list, e.g. “does the list have any odd
numbers?” This is a common mistake:
Can we spot what’s wrong here? As soon as we execute a 
return, we’ll leave the function. So the logic
of saying “If I find an odd number I can return True” is fine. However, we cannot return False after
only looking at one item — we can only return False if we’ve been through all the items, and none of
them are odd. So line 6 should not be there, and line 7 has to be outside the loop. Here is a corrected
version:
This “eureka”, or “short-circuit” style of returning from a function as soon as we are certain what the
outcome will be was first seen in Section 8.10, in the chapter on strings.
It is preferred over this one, which also works correctly:
The performance disadvantage of this one is that it traverses the whole list, even if it knows the
outcome very early on.
Tip: Think about the return conditions of the function
Do I need to look at all elements in all cases? Can I shortcut and take an early exit? Under what
1
2
3
4
5
6
7
def anyOdd(xs):
''' Return True if there is an odd number in xs, a list of integers. '''
for v in xs:
if v % 2 == 1:
return True
else:
return False
1
2
3
4
5
6
def anyOdd(xs):
''' Return True if there is an odd number in xs, a list of integers. '''
for v in xs:
if v % 2 == 1:
return True
return False
1
2
3
4
5
6
7
8
9
10
def anyOdd(xs):
''' Return True if there is an odd number in xs, a list of integers. '''
count = 0
for v in xs:
if v % 2 == 1:
count += 1    # count the odd numbers
if count > 0:
return True
else:
return False
Some Tips, Tricks, and Common Errors — How to Think Like a Computer Scientist: Learning with Python 3
http://openbookproject.net/thinkcs/python/english3e/app_e.html[1/4/2012 9:39:12 PM]
conditions? When will I have to examine all the items in the list?
The code in lines 7-10 can also be tightened up. The expression 
count > 0 evaluates to a boolean
value, either True or False. The value can be used directly in the 
return statement. So we could cut out
that code and simply have the following:
Although this code is tighter, it is not as nice as the one that did the short-circuit return as soon as
the first odd number was found.
Tip: Generalize your use of booleans
Mature programmers won’t write 
if isPrime(n) == True: when they could say instead 
if isPrime(n):
Think more generally about boolean values, not just in the context of 
if or 
while statements. Like
arithmetic expressions, they have their own set of operators (
and
or
not) and values (TrueFalse) and
can be assigned to variables, put into lists, etc. A good resource for improving your use of booleans is
http://en.wikibooks.org/wiki/Non-Programmer%27s_Tutorial_for_Python_3/Boolean_Expressions
Exercise time:
How would we adapt this to make another function which returns True if 
all
the numbers are
odd? Can you still use a short-circuit style?
How would we adapt it to return True if at least three of the numbers are odd? Short-circuit the
traversal when the third odd number is found — don’t traverse the whole list unless we have to.
Local variables
Functions are called, or activated, and while they’re busy they create their own stack frame which
holds local variables. A local variable is one that belongs to the current activation. As soon as the
function returns (whether from an explicit return statement or because Python reached the last
statement), the stack frame and its local variables are all destroyed. The important consquence of this
is that a function cannot use its own variables to remember any kind of state between different
activations. It cannot count how many times it has been called, or remember to switch colours
between red and blue UNLESS it makes use of variables that are global. Global variables will survive
even after our function has exited, so they are the correct way maintain information between calls.
1
2
3
4
5
6
7
8
def anyOdd(xs):
''' Return True if there is an odd number in xs, a list of integers. '''
count = 0
for v in xs:
if v % 2 == 1:
count += 1   # count the odd numbers
return count > 0   # Aha! a programmer who understands that boolean
# expressions are not just used in if statements!
1
2
3
4
5
6
7
sz = 2
def h2():
''' Draw the next step of a spiral on each call. '''
global sz
tess.turn(42)
tess.forward(sz)
sz = sz + 1
Some Tips, Tricks, and Common Errors — How to Think Like a Computer Scientist: Learning with Python 3
http://openbookproject.net/thinkcs/python/english3e/app_e.html[1/4/2012 9:39:12 PM]
This fragment assumes our turtle is 
tess. Each time we call 
h2() it turns, draws, and increases the
global variable 
sz. Python always assumes that an assignment to a variable (as in line 7) means that
we want a new local variable, unless we’ve provided a 
global declaration (on line 4). So leaving out the
global declaration means this does not work.
Tip: Local variables do not survive when you exit the function
Use a Python visualizer like the one at 
http://netserv.ict.ru.ac.za/python3_viz to build a strong
understanding of function calls, stack frames, local variables, and function returns.
Tip: Assigment in a function creates a local variable
Any assignment to a variable within a function means Python will make a local variable, unless we
override with 
global.
Event handler functions
Our chapter on event handling showed three different kinds of events that we could handle. They
each have their own subtle points that can trip us up.
Event handlers are non-fruitful functions — they don’t return any values.
They’re automatically called by the Python interpreter in response to an event, so we don’t get
to see the code that calls them.
A mouse-click event passes two coordinate arguments to its handler, so when we write this
handler we have to provide for two parameters (usually named 
x and 
y). This is how the handler
knows where the mouse click occurred.
A keypress event handler has to be bound to the key it responds to. There is a messy extra step
when using keypresses - we have to remember to issue a 
wn.listen() before our program will
receive any keypresses. But if the user presses the key 10 times, the handler will be called ten
times.
Using a timer to create a future-dated event only causes one call to the handler. If we want
repeated periodic handler activations, then from within the handler we call 
wn.ontimer(....) to
set up the next event.
String handling
There are only four 
really
important operations on strings, and we’ll be able to do just about
anything. There are many more nice-to-have methods (we’ll call them sugar coating) that can make
life easier, but if we can work with the basic four operations smoothly, we’ll have a great grounding.
len(str) finds the length of a string.
str[i] the subscript operation extracts the i’th character of the string, as a new string.
str[i:j] the slice operation extracts a substring out of a string.
str.find(target) returns the index where target occurs within the string, or -1 if it is not found.
So if we need to know if “snake” occurs as a substring within 
s, we could write
It would be wrong to split the string into words unless we were asked whether the 
word
“snake”
1
2
if s.find("snake">= 0 ...
if "snake" in s: ...           # also works, nice-to-know sugar coating!
Some Tips, Tricks, and Common Errors — How to Think Like a Computer Scientist: Learning with Python 3
http://openbookproject.net/thinkcs/python/english3e/app_e.html[1/4/2012 9:39:12 PM]
occurred in the string.
Suppose we’re asked to read some lines of data and find function definitions, e.g.: 
def
someFunctionName(x, y):, and we are further asked to isolate and work with the name of the function.
(Let’s say, print it.)
One can extend these ideas:
What if the function def was indented, and didn’t start at column 0? The code would need a bit
of adjustment, and we’d probably want to be sure that all the characters in front of the defpos
were spaces. We would not want to do the wrong thing on data like this: `` # I def initely like
Python!
We’ve assumed on line 3 that we will find an open parenthesis. It may need to be checked that
we did!
We have also assumed that there was exactly one space between the keyword 
def and the start
of the function name. It will not work nicely for 
def       f(x)
As we’ve already mentioned, there are many more “sugar-coated” methods that let us work more
easily with strings. There is an 
rfind method, like 
find, that searches from the end of the string
backwards. It is useful if we want to find the last occurrence of something. The 
lower and 
upper
methods can do case conversion. And the 
split method is great for breaking a string into a list of
words, or into a list of lines. We’ve also made extensive use in this book of the 
format method. In fact,
if we want to practice reading the python documentation and learning some new methods on our
own, the string methods are an excellent resource.
Exercises:
Suppose any line of text can contain at most one url that starts with “
http://” and ends at the
next space in the line. Write a fragment of code to extract and print the full url if it is present.
(Hint: read the documentation for 
find. It takes some extra arguments, so you can set a starting
point from which it will search.)
Suppose a string contains at most one substring “< ... >”. Write a fragment of code to extract
and print the portion of the string between the angle brackets.
Looping and lists
Computers are useful because they can repeat computation, accurately and fast. So loops are going
to be a central feature of almost all programs you encounter.
Tip: Don’t create unnecessary lists
Lists are useful if you need to keep data for later computation. But if you don’t need lists, it is probably
better not to generate them.
Here are two functions that both generate ten million random numbers, and return the sum of the
1
2
3
4
5
6
= "..."                         # somehow get the next line to work with
defPos = s.find("def ")           # look for "def " in the line
if defPos == 0:                   # if it occurs at the left margin
opIndex = s.find('(')           # find the index of the open parenthesis
fnname = s[4:opIndex]           # slice out the function name
print(fnname)                   # and work with it.
Some Tips, Tricks, and Common Errors — How to Think Like a Computer Scientist: Learning with Python 3
http://openbookproject.net/thinkcs/python/english3e/app_e.html[1/4/2012 9:39:12 PM]
index
next |
previous  |
How to Think Like a Computer Scientist: Learning with Python 3 »
numbers. They both work.
What reasons are there for preferring the second version here? (Hint: open a tool like the Performance
Monitor on your computer, and watch the memory usage. How big can you make the list before you
get a fatal memory error in 
sum1?)
In a similar way, when working with files, we often have an option to read the whole file contents into
a single string, or we can read one line at a time and process each line as we read it. Line-at-a-time
is the more traditional and perhaps safer way to do things — you’ll be able to work comfortably no
matter how large the file is. But you may find whole-file-at-once is sometimes more convenient!
© 
Copyright 2011, Peter Wentworth, Jeffrey Elkner, Allen B. Downey and Chris Meyers. Created using 
Sphinx 1.0.7.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import random
joe = random.Random()
def sum1():
''' Build a list of random numbers, then sum them '''
xs = []
for i in range(10000000):
num = joe.randrange(1000)  # generate one random number
xs.append(num)             # save it in our list
tot = sum(xs)
return tot
def sum2():
''' Sum the random numbers as we generate them '''
tot = 0
for i in range(10000000):
num = joe.randrange(1000)
tot += num
return tot
print(sum1())
print(sum2())
Documents you may be interested
Documents you may be interested