1.1 Introduction to Python

Created by Dutch developer Guido van Rossum (Figure 1.2),⁴ Python was originally designed as a high-level, general-purpose programming language. The name Python is a reference, not directly to the snake of that name, but rather to the British comedy troupe Monty Python. This speaks to a certain lightheartedness at the core of Python, but Python is also an elegant, powerful language useful for serious work. Indeed, although I am probably better known for my contributions to the Ruby community (especially the Ruby on Rails Tutorial), Python has long had a special place in my heart (Box 1.4).

Figure 1.2: Guido van Rossum, the creator of Python.

In order to give you the best broad-range introduction to programming with Python, Learn Enough Python to Be Dangerous uses four main methods:

1. An interactive prompt with a Read-Eval-Print Loop (REPL)
2. Standalone Python files
3. Shell scripts (as introduced in Learn Enough Text Editor to Be Dangerous)
4. Python web applications running in a web server

We’ll begin our study of Python with four variations on the time-honored theme of a “hello, world” program, a tradition that dates back to the early days of the C programming language. The main purpose of “hello, world” is to confirm that our system is correctly configured to execute a simple program that prints the string "hello, world!" (or some close variant) to the screen. By design, the program is simple, allowing us to focus on the challenge of getting the program to run in the first place.

Because one of the most common applications of Python is writing shell scripts for execution at the command line, we’ll start by writing a series of programs to display a greeting in a command-line terminal: first in a REPL; then in a standalone file called hello.py; and finally in an executable shell script called hello. We’ll then write (and deploy!) a simple proof-of-concept web application using the Flask web framework (a lightweight framework that serves as good preparation for a heavier framework like Django).

1.2 Python in a REPL

Our first example of a “hello, world” program involves a Read-Eval-Print Loop, or REPL (pronounced “repple”). A REPL is a program that reads input, evaluates it, prints out the result (if any), and then loops back to the read step. Most modern programming languages provide a REPL, and Python is no exception; in Python’s case, the REPL is often known as the Python interpreter because it directly executes (or “interprets”) user commands. (A third common term is the Python shell, in analogy with the Bash and Zsh programs used to run command-line shell programs.)

Learning to use the REPL well is a valuable skill for every aspiring Python programmer. As noted Python author David Beazley put it:

Although there are many non-shell environments where you can code Python, you will be a stronger Python programmer if you are able to run, debug, and interact with Python at the terminal [i.e., the REPL]. This is Python’s native environment. If you are able to use Python here, you will be able to use it everywhere else.

The Python REPL can be started with the Python command python3, so we can run it at the command line as shown in Listing 1.4.

$ python3
>>>

Here >>> represents a generic Python prompt waiting for input from the user.

We’re now ready to write our first Python program using the print() command, as seen in Listing 1.5. (Here "hello, world!" is a string; we’ll start learning more about strings in Chapter 2.)

>>> print("hello, world!")
hello, world!

That’s it! That’s how easy it is to print “hello, world!” interactively with Python.

If you’re familiar with other programming languages (such as PHP or JavaScript), you may have noticed that Listing 1.5 lacks a terminating semicolon to mark the end of the line. Indeed, Python is unusual among programming languages in that its syntax depends on things like newlines (Section 1.2.1) and spaces. We’ll see many more examples of Python’s unique syntax as this tutorial progresses.

1.3 Python in a file

As convenient as it is to be able to explore Python interactively, most Real Programming™ takes place in text files created with a text editor. In this section, we’ll show how to create and execute a Python file with the same “hello, world” program we’ve discussed in Section 1.2. The result will be a simplified prototype of the reusable Python files we’ll start learning about in Section 5.2.

We’ll start by creating a directory for this tutorial and a Python file (with a .py file extension) for our hello program (be sure to exit the interpreter first if you’re still in the REPL, which you can do using exit or Ctrl-D):

$ cd    # Make sure we're in the home directory.
$ mkdir -p repos/python_tutorial
$ cd repos/python_tutorial

Here the -p option to mkdir arranges to create intermediate directories if necessary. Note: Throughout this tutorial, if you’re using the cloud IDE recommended in Learn Enough Dev Environment to Be Dangerous, you should replace the home directory ~ with the directory ~/environment.

Because Python is so widely used, many systems come preinstalled with Python, and default programs often use it extensively. This introduces the possibility of interactions between the version of Python we’re using and the versions used by other programs, and the results can be nasty and confusing. To avoid this headache, one common practice is to use self-contained virtual environments, which allow us to use the exact version of Python we want, and to install whatever Python packages we want, without affecting the rest of the system.

We’ll be using the venv package combined with pip to install additional packages. This solution is especially suitable for a tutorial like this one because all of the specifics of the setup are contained in a single directory, which can be deleted and recreated if anything goes wrong. There is another powerful solution called Conda, though, which has a large and enthusiastic following among Python programmers. In my experience, Conda is just a little more difficult to use than venv/pip (e.g., the first time I tried using the conda utility it took over my system and replaced the default Python, which was tricky to reverse), but as you level up you might find yourself switching over to Conda.⁶

To create a virtual environment, we’ll use the python3 command with -m (for “module”) and venv (the name of the virtual environment module):

$ python3 -m venv venv

Note that the second occurrence of venv is our choice; we could write python3 -m venv foobar to create a virtual environment called foobar, but venv is the conventional choice. N.B. If you ever completely screw up your Python configuration, you can simply remove the venv directory using rm -rf venv/ and start again (but don’t run that command right now or the rest of the chapter might not work!).

Once the virtual environment is installed, we need to activate it to use it:

$ source venv/bin/activate
(venv) $

Note that many shell programs will insert (venv) before the prompt $ to remind us that we’re working in a virtual environment. The activate step is frequently required when using virtual environments, so I suggest creating a shell alias for it, such as va.⁷

To deactivate a virtual environment, use the deactivate command:

(venv) $ deactivate
$

Note that the (venv) in front of the prompt disappears upon deactivation.

Now let’s reactivate the virtual environment and create a file called hello.py using the touch command (as discussed in Learn Enough Command Line to Be Dangerous):

$ source venv/bin/activate
(venv) $ touch hello.py

Next, using our favorite text editor, we’ll fill the file with the contents shown in Listing 1.7. Note that the code is exactly the same as in Listing 1.5, with the difference that in a Python file there’s no command prompt >>>.

print("hello, world!")

At this point, we’re ready to execute our program using the python3 command we used in Listing 1.1 to check the Python version number. The only difference is that this time we omit the --version option and instead include an argument with the name of our file:

(venv) $ python3 hello.py
hello, world!

As in Listing 1.5, the result is to print “hello, world!” out to the terminal screen, only now it’s the raw shell instead of a Python REPL.

Although this example is simple, it’s a huge step forward, as we’re now in the position to write Python programs much longer than could comfortably fit in an interactive session.

1.4 Python in a shell script

Although the code in Section 1.3 is perfectly functional, when writing a program to be executed in the command-line shell it’s often better to use an executable script of the sort discussed in Learn Enough Text Editor to Be Dangerous.

Let’s see how to make an executable script using Python. We’ll start by creating a file called hello:

(venv) $ touch hello

Note that we didn’t include the .py extension—this is because the filename itself is the user interface, and there’s no reason to expose the implementation language to the user. Indeed, there’s a reason not to: by using the name hello, we give ourselves the option to rewrite our script in a different language down the line, without changing the command our program’s users have to type. (Not that it matters in this simple case, but the principle should be clear. We’ll see a more realistic example in Section 9.3.)

There are two steps to writing a working script. The first is to use the same command we’ve seen before (Listing 1.7), preceded by a “shebang” line telling our system to use Python to execute the script.

Ordinarily, the exact shebang line is system-dependent (as seen with Bash in Learn Enough Text Editor to Be Dangerous and with JavaScript in Learn Enough JavaScript to Be Dangerous), but with Python we can ask the shell itself to supply the proper command. The trick is to use the following line to use the python executable available as part of the shell’s environment (env):

#!/usr/bin/env python3

Using this for the shebang line gives the shell script shown in Listing 1.9.

#!/usr/bin/env python3

print("hello, world!")

We could execute this file directly using the python command as in Section 1.3, but a true shell script should be executable without the use of an auxiliary program. (That’s what the shebang line is for.) Instead, we’ll follow the second of the two steps mentioned above and make the file itself executable using the chmod (“change mode”) command combined with +x (“plus executable”):

(venv) $ chmod +x hello

At this point, the file should be executable, and we can execute it by preceding the command with ./, which tells our system to look in the current directory (dot = .) for the executable file. (Putting the hello script on the PATH, so that it can be called from any directory, is left as an exercise.) The result looks like this:

(venv) $ ./hello
hello, world!

Success! We’ve now written a working Python shell script suitable for extension and elaboration. As mentioned briefly above, we’ll see an example of a real-life utility script in Section 9.3.

Throughout the rest of this tutorial, we’ll mainly use the Python interpreter for initial investigations, but the eventual goal will almost always be to create a file containing Python.

1.5 Python in a web browser

Although it wasn’t initially designed for web development, Python’s elegant and powerful design has led to its widespread use in making web applications. In recognition of this, our final example of a “hello, world” program will be a live web application, written in the simple but powerful Flask micro-framework (Figure 1.3).⁸ Because of its simplicity, Flask is a perfect introduction to web development with Python while also serving as excellent preparation for a “batteries included” framework like Django.

Figure 1.3: A traditional drinking-horn flask.

We’ll begin by installing the Flask package using pip (a recursive acronym that stands for “pip installs packages”). The pip command comes automatically as part of the virtual environment, so we can access it by typing pip at the command line (or pip3 on some systems—try the latter if the former doesn’t work). As a first step, it’s a good idea to upgrade pip to ensure we’re running the latest version:

(venv) $ pip install --upgrade pip

Next, install Flask (Listing 1.10).

(venv) $ pip install Flask==2.2.2

We’ve included an exact version number in Listing 1.10 in case future versions of Flask don’t happen to work with this tutorial; this is similar to our decision to use python3 instead of plain python. As you get more advanced, though, you’ll probably just run things like pip install Flask, secure in the knowledge that you can figure out what went wrong if the version number doesn’t happen to work.

Believe it or not, the one command in Listing 1.10 installs all of the software needed to run a simple but full-strength web application on our local system (where “local” might refer to the cloud if you’re using the cloud IDE recommended in Learn Enough Dev Environment to Be Dangerous).

Although the code for the “hello, world” web app uses some commands that we haven’t covered yet, it’s a straightforward adaptation of the example program on the Flask home page (Figure 1.4). Being able to adapt code you don’t necessarily understand is a classic hallmark of technical sophistication (Box 1.2).

Figure 1.4: A sample program from the Flask home page.

We’ll put our “hello, world” app in a file called hello_app.py:

(venv) $ touch hello_app.py

The code itself closely parallels the program in Figure 1.4, as seen in Listing 1.11.

from flask import Flask


app = Flask(__name__)

@app.route("/")
def hello_world():
    return "<p>hello, world!</p>"

The code in Listing 1.11 defines the behavior for the root URL / when responding to an ordinary browser request (known as GET). The response itself is the required “hello, world!” string, which will be returned to the browser as a (very simple) web page.

To run the web application in Listing 1.11, all we need to do is run the hello_app.py file using the flask command (Listing 1.12). (Do make sure you’re running in the virtual environment; weird things can happen if you try running the flask command on the default system.) In Listing 1.12, the --app option specifies the app and the --debug option arranges to update the app when we change the code (which saves us from having to restart the Flask server every time we make a change).

(venv) $ flask --app hello_app.py --debug run
 * Running on http://127.0.0.1:5000/

At this point, visiting the given URL (which consists of the local address 127.0.0.1 and the port number) shows the application running on the local machine.⁹

Figure 1.5: The hello app running locally.

If you’re using the cloud IDE, the commands are nearly identical to the ones shown in Listing 1.12; the only difference is that you have to include a different port number using the --port option (Listing 1.13).

(venv) $ flask --app hello_app.py --debug run --port $PORT
 * Running on http://127.0.0.1:8080/

To preview the app and replicate the result shown in Figure 1.5, we have to follow a few more steps. First, we need to preview the app as shown in Figure 1.6. The result typically shows up in a small window inside the IDE (details may vary); by clicking the icon shown in Figure 1.7, we can pop out into a new window. The result should appear as in Figure 1.8 (the only difference with Figure 1.5 is the URL).

Figure 1.6: The “local” server running on the cloud IDE.

Figure 1.7: Previewing the hello app.

Figure 1.8: The hello app running on the cloud IDE.

Just getting a web app to work, even locally, is a huge accomplishment. But the real pièce de résistance is deploying the app to the live Web. This is the goal of Section 1.5.1.