Writing your first program - Python Bootcamp
- Basic math
- Simple loops
- Reading from files
- Command-line arguments
- Running a program
- Putting it all together
To print something, just use
>>> x = 7 >>> print(x) 7
x = 7 y = 8 z = x + y print(z)
How can you run a program? If you’re using IDLE, hit F5. If you’re
working from the command line, run the file, for example:
It should produce the output
15. That was easy.
What if we divide instead? Change the crucial line to:
z = x / y
Check out the documentation on Python Numeric Types for a full list of the arithmetic operators in Python.
At some point, if you’ve worked with another language you’ll try to
x++ to add one to
x. This doesn’t work in Python. Instead,
x += 1. Note that Python similarly supports
For the moment, we’re going to explore the most basic loop in Python,
for loop. We’ll use it to iterate over a
list, a data type
that we’ll go over in more detail later. For now, think of a list as a
variable-sized array of ordered items. To initialize a list, we use
 with commas to separate the items.
letters = ['a', 'b', 'c']
This creates a list with three items in it. Python is zero-indexed, so
the first item is at position (index) zero, the second at position
0: 'a'; 1: 'b'; 2: 'c'.
So if we want to print each item in
letters, we can write a loop as
for item in letters: print(item)
Note that a
for statement ends with a colon. The code that is inside
the loop must be indented one level. This will output:
a b c
Note that each time you
end argument to an empty string:
` print(item, end=’’)`
Mini-exercise: Clear out the above program. Without copying the above example, write a program where you put a few objects in a list and print them.
Reading from files
One of the most common things we need to do is read data from
files. To open a file, simply use
open. For now, let’s work with the
the first chapter of Pride and Prejudice.
To open it, after downloading it do the following:
chapter = open("pp_ch1.txt", "U")
It’s tempting to use simple names such as
input; these are
both names of python built-in objects so best to leave them alone for
the moment. The first argument to
open is the path to the file, the
second tells it what we want to do with it. In this case we’re asked
for it to be opened in Universal newline mode, a way of reading files
that glosses over differences between Unix and Windows line endings.
As we saw with
open, we call a function in Python by using its name,
then following the name with parentheses which enclose the arguments.
Now we’re going to write a simple function that prints all the lines
in a file. We’re going to combine a
for loop, using
open to read a
file, and using
So, here’s what this function will look like:
def print_file(filename): """Print the contents of a file.""" for line in open(filename, "U"): print(line.rstrip())
A few things to note:
- We define a function by using the
defkeyword, then providing the name of the function and the variable names we want to use for the arguments given to it. Like
defcreates a block so we must indent below.
- Immediately after we declare the function, we write a triple-quoted string under it describing what it does. (Don’t worry about why it’s triple quotes right now.) This is called a docstring and it is used to explain what the function does.
- When we print, we call the method
rstripon the string. This removes any trailing whitespace. When reading a file, each line will end with a newline marker until we explicitly remove it.
Functions can also return a value, for example we may want to set a variable to the result of calling a function:
def increment(num): """Return the input number increased by one.""" return num + 1
Mini-exercise: Without copying the above example, write a function that takes two variables as arguments and returns the result of an arithmetic operation on them. For example, you could add two numbers together and return the result.
We may want to be able to take arguments on the command line, for
example the name of the file whose contents we want to print. This is
accomplished through a list called
argv available through the
Accessing this can be demonstrated by the following program, which
import sys print(sys.argv)
We need to test this from the command line, not inside another program such as IDLE:
$ python test.py a b c ['test.py', 'a', 'b', 'c']
We notice that the first item appears to be the name of the script as
it was called; this is generally of little use. So we almost always
start looking at index 1, the second item. The line
allows us to refer to the
sys module. Even though it is built-in to
Python, we need to explicitly state that we are going to use it.
Running a program
When you run a file like
test.py, Python will compile the entire
file and execute anything that is at the outer level of
indentation. If your file defines functions but you want them to run
when the program is executed, you need to specify that. Here’s a
modified version of the program above that demonstrates this:
import sys def print_args(): """Print the command line arguments.""" print(sys.argv) if __name__ == "__main__": print_args()
This file defines the
print_args function and then will run it the
file is run as a program. The purpose of the block under
if __name__ == "__main__"
is so that if the file is imported–used to define functions–rather
than run as a main program, it won’t run the
just define it.
Putting it all together
Now, to test your abilities, take on your first program. It is meant
to be a simplified version of
cat, a tool which concatenates the
files given to it. It should:
- Take a list of files to open as command line arguments.
- For each file specified, print its contents.
For example, if we call
cat on two files, the first of which
contains just the line
abc and the second of which contains just the
def, the output would be:
Try to do this without copy/pasting from the examples above. You’ll
need to get all but the first element out of
sys.argv. The easiest
way to do this is to do something like the following, which will be
filenames = sys.argv[1:]
When you’re done, take a look at cat.py which provides a solution.
If you want to write another simple program, write one that counts the
number of lines in a file. It should take the name of a single file as
a command line argument (which can be retrieved as
count the number of lines in it, and print that number at the end. For
$ python countlines.py pp_ch1.txt 111