Can We Get Your Input?¶
In Getting Raw Input we’ll introduce a primitive interactive input function. This will finish up the statements we need to fill out the “input-process-output” pattern for simple programs. We’ll provide some additional notes in Additional Notes and Caveats.
To make complete use of this, we’ll need to digress on the standard input, output and error files in The Standard Files.
The material on the del statement in The del Statement is here for completeness. Logically, there’s a nice symmetry between creating variables with the assignment statement, setting values with input functions and removing variables with the del statement. As a practical matter, however, we rarely need to remove a variable.
We’ll answer some additional questions in Input FAQ.
Getting Raw Input¶
Python provides simplistic built-in functions to accept input and set the value of variables. These are not really suitable for a all applications, but they will help us learn the language. The more robust and reliable input functions are generally embedded in a web-based application, or a sophisticated GUI, both of which are way beyond what we can cover in this book.
These input functions will gather data from a file called standard input. Generally, this standard input file is your keyboard, and the results will show on the Python Shell window in IDLE. If you run Python directly, the Terminal (or Command Prompt) where Python was started will manage reading characters from your keyboard.
Raw Input. By “raw”, we mean one line of input. The input is what the person typed after handling backspaces. It isn’t every keystroke, it’s the finished product of typing and backspacing.
The details of how backspacing is handled is actually part of the operating system. Python depends on the OS to provide the line of input via the standard input file, making sure that the backspace operates as we expect.
We have to talk about the raw_input() from two distinct points of view.
- What you see. You will see a prompt on standard output – usually the console – and you can respond to that prompt by typing on standard input. This console will usually be the Python Shell window of IDLE, or the terminal window, depending on how you are running Python.
- What you say in Python. The Python script evaluates a function; the value of that function will be a string that contains the characters someone typed. We’ll take a very close look at strings in Sequences of Characters : str and Unicode. For now, we do a few simple things with strings.
An Example Script. Here’s a very small script that uses raw_input() that produces a prompt, reads and prints the result. This will give you a sense of the two worlds in which this function lives: the world of user interaction as well as the world of Python function evaluation.
Create the following file, named rawdemo.py. Save it and then run it in IDLE using the Run Module item in the Run menu.
rawdemo.py
# get the user's answer
from __future__ import print_function
answer= raw_input( "continue?" )
print("You said:", answer)
When we run this script, it looks like the following.
continue? why not?
You said: why not?
This program begins by evaluating the raw_input() function. When raw_input() is applied to the parameter of "continue?", it writes the prompt on standard output, and waits for a line of input.
We entered why not?. When we hit enter, we told the operating system that our input line was complete. The OS hands the completed input line to Python. Python then returns this string as the value of the raw_input() function.
Our program saved the value from raw_input() int the variable answer. The second statement printed that variable.
Definition. Here’s a formal definition for the raw_input() function.
- raw_input([prompt]) → string¶
Read a string from standard input. If a prompt is given, it is printed before reading. If the user hits end-of-file (Ctrl-D in GNU/Linux or MacOS; Ctrl-Z in Windows), an exception is raised.
There’s a second input function, named input(). It will be removed from Python 3 because it’s worse than useless. It’s confusing and a potential security nightmare.
Making Raw Input Useful. If we want a numeric value, we must convert the resulting string to a number. In the following example, we’ll use the int() and float() functions to convert the strings we got from the raw_input() function into numbers that we can use for calculation.
We’ll use the raw_input() and int() functions to get a number of shares. The resulting number is assigned the name shares. Then the program uses the raw_input() and float() functions to get the price.
Create the following file, named stock.py. Save it and then run it in IDLE using the Run Module item in the Run menu.
stock.py
# Compute the value of a block of stock
from __future__ import print_function
shares = int( raw_input("shares: ") )
price = float( raw_input("dollars: ") )
print("value", shares * price)
Here’s what we saw when we ran this program in IDLE.
shares: 150
dollars: 24.18
value 3627.0
Exceptional Input. Exceptions, in Python, often mean exceptionally bad. The raw_input() mechanism has some limitations. If the string returned by raw_input() is not suitable for use by int() function, an exception is raised and the program stops running.
Here’s what it looks like when we ran stock.py and provided inappropriate input values.
We’ll look at ways to handle this in The Unexpected : The try and except statements.
Additional Notes and Caveats¶
If you try to run these examples from TextPad, you’ll see that TextPad doesn’t have any place for you to type your input. You’ll get an immediate end-of-file error. Why does this happen? It happens because TextPad doesn’t have a proper file for standard input. Since the file doesn’t exist, we get an immediate error when we try to use it.
For MacOS users using tools like BBEdit, you’ll can use the Run In Terminal item in the #! menu to create a Terminal window for your interaction. This new window appears when your run your script, showing your standard input and giving you a place for standard input.
Tip
Debugging the raw_input() Function
There are two kinds of mistakes that occur. The first kind of mistake are basic syntax errors in the raw_input() function call itself.
The other mistake, which is more difficult to prevent, is to provide invalid input to the script when it runs. Currently, we don’t quite have all of the language facilities necessary to recover from improper input values. When we cover the try statement and exception processing in The Unexpected : The try and except statements we’ll see how we can handle invalid input.
In the long run, we’ll see that the raw_input() function is not the most reliable tool. For simple programs, problems with raw_input() are easily solved. If you give your software to someone else, the vagaries of what is legal and how Python responds to things that are not legal can be frustrating for them to learn.
Professional quality software doesn’t make much use of these functions. Typically, interactive programs use a complete graphic user interface (GUI), often written with the Tkinter module or the pyGTK module. Both of these are beyond the scope of this book: they aren’t newbie-friendly modules.
The Standard Files¶
We need to take a quick digression to look at how your keyboard really works. Generally, we take our keyboard for granted: we start an application, we type and the letters appear. After a while, you get used to letters only showing up in the front-most window. Our operating system tells us which window is active by providing a number of visual cues like bringing the window to the font, showing a blinking cursor and a fancier frame around the window.
Under the hood, your operating system is watching your keyboard device for activity. Most of the buttons on your keyboard generate an “event`. Some of the buttons are “modifiers”: the shift, alt, command, and control keys modify the basic key event. The operating system routes these key events to the front-most window. The application program that displays the front-most window is responsible for making sense of the events.
Why “events”? Why not just “characters”? The reason is that some programs don’t have characters. A game, for example, doesn’t want characters, it wants events that will make the pinball flippers flip, or the person walk.
For many programs, most of these events will be interpreted as characters. There are two really common events that are not characters: the backspace event and the enter event are not letters; instead, they change the sequence of characters being accumulated. The front-most window has to do something with events like backspace. What most of us expect is that backspace removes the previously accumulated character. The enter key alerts the program that you are finished typing and are ready for the program to see the input letters.
Plus, when you look at your keyboard, you’ve got a dozen (or more) F-keys, plus keys with names like Insert, Delete, Home, End, etc. These are not characters in the same sense as the other keys. These extra keys are used by IDLE to control your interactive Python session. When you run Python from the Command Prompt or Terminal tool, you’ll see that these extra F-keys do little or nothing. In the Windows Command Prompt, you can use a program named doskey to define actions for these non-letter keys. In the MacOS, there are a number of programs that use these additional F-keys for a variety of purposes; for instance, F12 brings up my dashboard.
Redirection. Each shell also has ways to change the origin of the characters available on standard input. When you redirect standard input, it means that your program will wind up reading from a disk file instead of the keyboard. In The print() Function, we mentioned the file called standard output. Standard output is like standard input: it was opened for you, and it can be redirected outside your program.
This shell redirection technology allows a single program to read from a disk file or read from the keyboard without any changes to the program; there is just a small change to the shell command that starts the program. Similarly, it also allows a program to write the terminal window, or write to a disk file depending on settings provided to the shell. While the details of controlling the shell are outside the scope of this book, the idea is that one program can do any of the preceding, with no change to the program. This gives us a lot of flexibility for no real cost or complexity in our programming.
Simple Input Exercises¶
Refer back to the exercises in Expression Exercises for formulas and other details. Each of these can be rewritten to use variables and an input conversion. For example, if you want to tackle the Fahrenheit to Celsius problem, you might write something like this:
C = input('Celsius: ')
F = 32+C*float(9/5)
print("celsius", C, "fahrenheit", F)
Stock Value.
Input the number of shares, dollar price and number of 8th’s. From these three inputs, compute the total dollar value of the block of stock.
Convert from ° C to ° F.
Write a short program that will input ° C and output ° F. A second program will input ° F and output ° C.
Periodic Payment.
Input the principal, annual percentage rate and number of payments. Compute the monthly payment. Be sure to divide rate by 12 and multiple payments by 12.
Surface Air Consumption Rate.
Write a short program will input the starting pressure, final pressure, time and maximum depth. Compute and print the SACR.
A second program will input a SACR, starting pressure, final pressure and depth. It will print the time at that depth, and the time at 10 feet more depth.
Wind Chill.
Input a temperature and a wind speed. Output the wind chill.
Force from a Sail.
Input the height of the sail and the length. The surface area is
. For a wind speed of 25 MPH, compute the force on the
sail. Small boat sails are 25-35 feet high and 6-10 feet
long.
The del Statement¶
An assignment statement creates a variable, or assigns a new object to an existing variable. This change in state is how our program advances from beginning to termination. Python also provides a mechanism for removing variables, the del statement. This version of the statement is used rarely; we describe it here to close the circle of the life for a variable.
The most common use for the del statement is to remove individual elements from a list object. We’ll revist this statement when we look at lists in Flexible Sequences : The list. There, we’ll find a more practical use for this statement.
The del statement looks like this:
del target [ , ... ]
A target is a name of a Python object: a variable, function, module or other object. The variable is removed. Generally, this also means the target object is removed from memory.
The del statement works by unbinding the name, removing it from the set of names known to the Python interpreter. If this variable was the only reference to an object, the object will be removed from memory also. If, on the other hand, other variables still refer to this object, the object won’t be deleted.
Tip
Debugging the del statement
If we misspell a variable name, or attempt to delete a variable that doesn’t exist, we’ll get an error like NameError: name 'hack' is not defined.
Input FAQ¶
- If there is no use for the del statement, why cover it?
- The del statement isn’t completely useless for newbies. We cover it for a number of reasons. First, we’ll return to it in the chapter on lists and use it to remove an item from a list. Second, when you see it in someone else’s program, you’ll be able to interpret it. And third, we can say that we covered all the language, identifying the parts that meet more advanced needs.
- If raw_input() is so poor, what’s better?
We’ll take a quick survey of four overall architectures where you will be interacting with your computer. What we want to emphasize is the tremendous differences between these architectures. Since there is so little in common, Python doesn’t have a newbie-friendly, reliable, flexible, and richly interactive input mechanism.
- A command-line utility. These are programs like the GNU/Linux grep program, where all of the interaction is centered around running the program from the command line or as part of a processing pipeline. These programs read from standard input and write to standard output. They typically use file-oriented read() and write() methods, not the raw_input() function.
- A GUI program. These are programs like those in MS-Office or Open Office; this group also includes all games. These programs generally rely on a “framework” that provides basic graphics capabilities. Python programmers use Tkinter or pyGTK for this kind of program. The framework handles keyboard and mouse events and provides specialized functions for interacting with the GUI objects.
- A Web program. These are programs like eBay or Yahoo!. In this case, the program exists on a web server and does its processing in response to web requests. These programs rely on the HTTP protocol and HTML web pages for their interaction. There are a number of Python-oriented frameworks for running Python programs from a web server.
- An embedded program. These are programs like those in your microwave oven, thermostat or coffee-maker. You interact with these programs through specially-engineered devices like membrane keyboards, buttons and LED’s. These programs often rely on specialized mini-operating system to handle the devices.
With these styles of programming having so little in common, there’s very little built-in to the Python language to support a user interface. For all but the first case (command-line utilities), you’ll have to master some kind of add-on package appropriate to the kind of programs you want to write.