# Basic math

To print something, just use `print`:

``````>>> x = 7
>>> print(x)
7
``````

`print` can work on any type. For our first program, we’ll do some simple arithmetic. Let’s add two variables together and print the output. Make a new file, enter this script, and run it:

``````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:
`python test.py`

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 write `x++` to add one to `x`. This doesn’t work in Python. Instead, write `x += 1`. Note that Python similarly supports `-=`, `*=`, and `/=`.

# Simple loops

For the moment, we’re going to explore the most basic loop in Python, the `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 one, etc.: `0: 'a'; 1: 'b'; 2: 'c'`.

So if we want to print each item in `letters`, we can write a loop as follows:

``````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 `print`, by default it puts each item on its own line. If you don’t want this, set the `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.

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.

``````chapter = open("pp_ch1.txt", "U")
``````

It’s tempting to use simple names such as `file` or `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.

# Functions

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 `print` to output each line.

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:

1. We define a function by using the `def` keyword, then providing the name of the function and the variable names we want to use for the arguments given to it. Like `for`, `def` creates a block so we must indent below.
2. 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.
3. When we print, we call the method `rstrip` on 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.

# Command-line arguments

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 `sys` module.

Accessing this can be demonstrated by the following program, which I’ll call `test.py`:

``````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 `import sys` 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 `print_args` function, 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:

1. Take a list of files to open as command line arguments.
2. 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 line `def`, the output would be:

```abc
def
```

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 explained soon:
`filenames = sys.argv[1:]`

You can use the first and second chapters of Pride and Prejudice as files to concatenate.

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 `sys.argv`), count the number of lines in it, and print that number at the end. For example:

``````\$ python countlines.py pp_ch1.txt
111
``````