python-tutorials/14-io.pd

# Input Output

There will be situations where your program has to interact with the user. For example, you would want to take input from the user and then print some results back. We can achieve this using the `input()` and `print()` functions respectively.

For output, we can also use the various methods of the `str` (string) class. For example, you can use the `rjust` method to get a string which is right justified to a specified width. See `help(str)` for more details.

Another common type of input/output is dealing with files. The ability to create, read and write files is essential to many programs and we will explore this aspect in this chapter.

## Input from user

Save this program as `user_input.py`:

~~~python
def reverse(text):
    return text[::-1]

def is_palindrome(text):
    return text == reverse(text)

something = input('Enter text: ')
if (is_palindrome(something)):
    print("Yes, it is a palindrome")
else:
    print("No, it is not a palindrome")
~~~

Output:

~~~
$ python3 user_input.py
Enter text: sir
No, it is not a palindrome

$ python3 user_input.py
Enter text: madam
Yes, it is a palindrome

$ python3 user_input.py
Enter text: racecar
Yes, it is a palindrome
~~~

How It Works:

We use the slicing feature to reverse the text. We've already seen how we can make [slices from sequences](#sequence) using the `seq[a:b]` code starting from position `a` to position `b`. We can also provide a third argument that determines the *step* by which the slicing is done. The default step is `1` because of which it returns a continuous part of the text. Giving a negative step, i.e., `-1` will return the text in reverse.

The `input()` function takes a string as argument and displays it to the user. Then it waits for the user to type something and press the return key. Once the user has entered and pressed the return key, the `input()` function will then return that text the user has entered.

We take that text and reverse it. If the original text and reversed text are equal, then the text is a [palindrome]([http://en.wiktionary.org/wiki/palindrome).

Homework exercise

:   Checking whether a text is a palindrome should also ignore punctuation, spaces and case. For example, "Rise to vote, sir." is also a palindrome but our current program doesn't say it is. Can you improve the above program to recognize this palindrome?

    *Hint (Don't read) below*

    Use a tuple (you can find a list of *all* punctuation marks here [punctuation](http://grammar.ccc.commnet.edu/grammar/marks/marks.htm)) to hold all the forbidden characters, then use the membership test to determine whether a character should be removed or not, i.e. forbidden = ('!', '?', '.', ...).

## Files 

You can open and use files for reading or writing by creating an object of the `file` class and using its `read`, `readline` or `write` methods appropriately to read from or write to the file. The ability to read or write to the file depends on the mode you have specified for the file opening. Then finally, when you are finished with the file, you call the `close` method to tell Python that we are done using the file.

Example (save as `using_file.py`):

~~~python
poem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
    use Python!
'''
 
f = open('poem.txt', 'w') # open for 'w'riting
f.write(poem) # write text to file
f.close() # close the file
 
f = open('poem.txt') # if no mode is specified, 'r'ead mode is assumed by default
while True:
    line = f.readline()
    if len(line) == 0: # Zero length indicates EOF
        break
    print(line, end='')
f.close() # close the file
~~~

Output:

~~~
$ python3 using_file.py
Programming is fun
When the work is done
if you wanna make your work also fun:
        use Python!
~~~

How It Works:

First, open a file by using the built-in `open` function and specifying the name of the file and the mode in which we want to open the file. The mode can be a read mode (`'r'`), write mode (`'w'`) or append mode (`'a'`). We can also specify whether we are reading, writing, or appending in text mode (`'t'`) or binary mode (`'b'`). There are actually many more modes available and `help(open)` will give you more details about them. By default, `open()` considers the file to be a 't'ext file and opens it in 'r'ead mode.

In our example, we first open the file in write text mode and use the `write` method of the file object to write to the file and then we finally `close` the file.

Next, we open the same file again for reading. We don't need to specify a mode because 'read text file' is the default mode. We read in each line of the file using the `readline` method in a loop. This method returns a complete line including the newline character at the end of the line. When an *empty* string is returned, it means that we have reached the end of the file and we 'break' out of the loop.

By default, the `print()` function prints the text as well as an automatic newline to the screen. We are suppressing the newline by specifying `end=''` because the line that is read from the file already ends with a newline character. Then, we finally `close`the file.

Now, check the contents of the `poem.txt` file to confirm that the program has indeed written to and read from that file.

## Pickle

Python provides a standard module called `pickle` using which you can store **any** Python object in a file and then get it back later. This is called storing the object *persistently*.

Example (save as `pickling.py`):

~~~python
import pickle
 
# the name of the file where we will store the object
shoplistfile = 'shoplist.data'
# the list of things to buy 
shoplist = ['apple', 'mango', 'carrot']
 
# Write to the file
f = open(shoplistfile, 'wb')
pickle.dump(shoplist, f) # dump the object to a file
f.close()
 
del shoplist # destroy the shoplist variable
 
# Read back from the storage
f = open(shoplistfile, 'rb')
storedlist = pickle.load(f) # load the object from the file
print(storedlist)
~~~

Output:

~~~
$ python3 pickling.py
['apple', 'mango', 'carrot']
~~~

How It Works:

To store an object in a file, we have to first `open` the file in 'w'rite 'b'inary mode and then call the `dump` function of the`pickle` module. This process is called *pickling*.

Next, we retrieve the object using the `load` function of the `pickle` module which returns the object. This process is called *unpickling*.

## Summary 

We have discussed various types of input/output and also file handling and using the pickle module.

Next, we will explore the concept of exceptions.