Python Essentials

Python runs on many versions of Windows. There are some older, less-widely-used versions of Windows without an actively supported version of Python. For example, Windows 2000 is not supported.

The general procedure for installing Python is quite simple. We'll download an installer and do some preparation. Then we'll start the installer. Once that's finished, we'll be up and running.

To find the installer, start here:

https://www.python.org/downloads/

The web server should detect your OS and provide a big button with some variation of "Download Python 3.4.x" on it. Click on this button to start the download.

To look at the choices available, the https://www.python.org/downloads/windows/ path provides all of the actively-supported versions of Python. This will show a long list of older versions. There are two installers available:

If we have a very old computer, we might need the 32-bit version. Most modern computers will have a 64-bit CPU. When in doubt, 64-bit is the assumption to make.

Double-click the .msi file to start running the installer. This starts with a question about installing Python for yourself or for all users. If you have appropriate privileges, the all users option is appropriate. On a shared computer, without appropriate privileges, you'll have to install it for yourself only.

The second page will ask for an installation directory. Be careful about the path that you choose for the installation, and avoid spaces in filenames.

Spaces in filenames is not a general problem, but it is awkward when first starting. There are many ways to cope with spaces in filenames. When learning a new programming language, however, it's important to minimize the awkward problems so that we can focus on the important topics.

The next page will also show a menu of components that can be installed; it's easiest to request everything. There's no compelling reason to turn off any of the optional components. We'll be looking at the IDLE development tool, which requires the Tcl/Tk package, so it's important to be sure that this is part of the installation.

In many cases, the final option on this list updates the system environment variables to include Python on the PATH variable. This isn't enabled by default, but it can be helpful if you're going to write BAT files in Windows.

In addition to the basic Python interpreter, the Windows help installer is very helpful. This is a separate download and requires a quick installation. After we've installed this, we can use the F1 key to bring up all of the Python documentation.

Once Python is installed, the Using the Read-Evaluate-Print Loop (REPL) section will show how to start interacting with Python.

Python runs on all versions of Mac OS X. It turns out that Mac OS X relies on Python. However, it relies on Python 2.7, so we'll need to add Python 3.4.

The general procedure for installing Python on Mac OS X is quite simple. We'll download a disk image (.dmg) installer and do some preparation. Then we'll start the installer that's in the disk image. Once that's finished, we'll be up and running.

To find an installer, start here:

https://www.python.org/downloads/

The web server should detect your OS and provide a big button with some variation of "Download Python 3.4.x" on it. Click on this and download the .dmg file.

To look at the choices available, the https://www.python.org/downloads/mac-osx/ path provides all of the actively-supported versions of Python for Mac OS X. This will show alternatives for older versions of Python.

When the .dmg device becomes available after the download, double-click on the .mpkg installer file to start running the installer.

Clicking on Continue will step through the Read Me, License, Destination Select, and Installation Type windows. There's a Customize button that allows us to turn options on and off. We won't need to do this—the default installation is ideal.

We'll need to provide the username and password of a user who's authorized to administer this computer. This will not remove the existing Python that Mac OS X uses. It will add another version of Python. This means that we'll have at least two copies of Python. We'll focus on using Python 3, ignoring the built-in Python, which is Python 2.

To use Python 3, we have to enter python3 at the OS prompt in the Terminal window. If we have both Python 3.3 and Python 3.4, we can enter the even more specific python3.4 at the command prompt to specify which version of Python 3 we're using. Generally, the python3 command will be the latest-and-greatest version of Python 3. The python command—unadorned with a version number—will be the Python 2.x that Mac OS X requires.

Adding the Tkinter package

Python relies on a library named Tkinter to provide support for writing programs with a GUI. This package relies on Tcl/Tk. The details can be found here:

https://www.python.org/download/mac/tcltk/

The summary of this is that we need to install version 8.5.17 or newer. See https://www.python.org/download/mac/tcltk/#activetcl-8-5-17-0. This will provide a graphic environment that Python will use. We must install Tcl/Tk in order for the tkinter package to work.

After we download the .dmg file and open the .pkg file, we'll see this window:

We'll be looking at the IDLE development tool, which requires tkinter. Consequently, this additional installation is essential.

We can avoid this extra download if we avoid using tkinter. Some developers prefer to use the Active State Komodo editor as their development tool; this does not require Tcl/Tk. Also, there are numerous add-on GUI frameworks that don't require tkinter.

For Linux, the latest Python may already be installed. When we enter python3, we may see that we already have a useful version available. In this case, we're ready to roll. In some cases, the OS will only have an older Python (perhaps older than 2.7) installed. In this case, we'll need to upgrade.

For Linux distributions, there are two paths for upgrading Python:

When we use altinstall, we'll end up with two Pythons installed. We'll have an older Python, which we can run using the python command. The python3 command will, generally, be linked to the latest version of Python 3. If we need to be explicit, we can use the python3.4 command to select a specific version.

As with the Mac OS X installation, adding the Python tkinter package is important. Sometimes, this is separate from the basic package. This may lead to upgrading Tcl/Tk, which may lead to some more downloads and installs. At other times, the Linux distribution has an up-to-date Tcl/Tk environment and nothing more needs to be done.

We can avoid the extra Tcl/Tk download if we avoid using tkinter. As mentioned earlier, many developers prefer to use the Active State Komodo editor as their development tool; this does not require tkinter. Also, there are numerous GUI frameworks that aren't based on tkinter.

To confirm that things are working, we'll start the Python interpreter from a command-line prompt. It might similar to like this:

MacBookPro-SLott:~ slott$ python3
Python 3.3.4 (v3.3.4:7ff62415e426, Feb  9 2014, 00:29:34)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

The details of getting to a command prompt vary from OS to OS. We've shown the Mac OS X Terminal tool in this example. We entered the python3 command to be sure we ran our new version of Python, not the built-in Python 2.

The introductory message lists four special-purpose objects that are incorporated into the interactive Python environment. There are two more, quit and exit, which are also available. These are only present in the REPL interactive environment; they cannot be used in programs.

We'll look at how we get help later in a separate section, Interacting with the help subsystem. The other objects, however, produce useful tidbits of information and are the ideal way to be sure things are working. Enter copyright, credits, or license at the >>> prompt to confirm that Python is working.

The REPL loop prints the results of each statement, allowing us to work with Python interactively. To be clear on what this means, we should define what constitutes a statement in the language. We'll avoid the strict formality of the Python language definition and provide a quick, informal definition of the relevant statement type.

The Python language has 20 or so kinds of statements. An expression—by itself—is a statement. Unless the value of the expression is None, the REPL will show the value of the expression. We'll often use an expression statement to evaluate functions that perform input and output.

This simple expression statement allows us to do things such as the following at the Python >>> prompt:

>>> 355/113
3.1415929203539825

We can enter any arithmetic expression. Python evaluates the expression, and if the result isn't None, we'll see the result. We've shown the true division operator, /, in this example.

We'll look at the various data types and operators in Chapter 2, Simple Data Types. For the moment, we'll identify a few features of Python. We have numbers in a variety of flavors, including integers, floating point, and complex values. Most values will be properly coerced to add precision. Have a look at these examples:

>>> 2 * 3.14 * 8j
50.24j
>>> _ **2
(-2524.0576+0j)

The first expression computed a value that includes an integer, 2; a floating point value, 3.14; and a complex value, 8j. We used the * operator for multiplication. The result is complex, 50.24j.

The second expression uses the _ variable. This is a handy feature that's unique to the REPL. The result of each expression is implicitly assigned to this variable. We can use _ in an expression to refer to the result of the previous expression. This only works in the REPL; it's never a part of a script.

When we computed _ **2, we squared 50.24j. This is -2524.0576. Since the source value was a complex number, the result is also a complex value even though the imaginary component of that complex value is zero. This is typical of Python—the data types of the operand values generally dictate the data types of the result of the operator. When there are different kinds of numbers, values are coerced according to the rules we'll look at in Chapter 2, Simple Data Types.

There's one notable exception to the rule that the types of the operands match the type of the result. The true division operator, /, produces floating point results from integer operands. The floor division operator, //, on the other hand, reflects the types of the operands. For example:

>>> 355 / 113
3.1415929203539825
>>> 355 // 113
3

We have these two division operators so that we can unambiguously specify what kind of division we'd like to perform. It saves us from having to write extra code to explicitly coerce results.

The simple assignment statement produces no visible output:

>>> v = 23

This will create the variable v and assign the value of 23 to it. We can check this by using a very small expression statement. The expression is just the variable name:

>>> v
23

When we evaluate a very simple expression, such as v, we see the value of the variable.

Python's REPL has far-reaching consequences. Perhaps the most important consequence is that almost all examples of Python programming are provided as if we're entering the code at the >>> prompt. The documentation for very complex and sophisticated packages will be written as though we're going to use that package interactively. In most cases, we'll be writing application programs; we won't really do very much at the >>> prompt. But the idea of cutting through the complexity to arrive at something that can be done interactively is pervasive throughout the Python community.

One significant part of Python is the presence of a vast library of additional features. Using an external library means that the core language can be kept quite simple. We can import any additional features we need, avoiding the clutter and complication of unused features.

The import statement is used to incorporate additional functions, classes, and objects into a program or the interactive environment. There are a number of variations of this statement. For example, we might want to use some of the more sophisticated math functions. We can search the Python documentation and discover that these are defined in the math library. We can include and use them like this:

>>> import math
>>> math.pi
3.141592653589793
>>> math.sin( math.pi/6 )
0.49999999999999994

In this example, we imported the math library. We evaluated math.pi to see one of the constants defined in this library. We evaluated .The result was almost (but not exactly) 1/2.

This also shows us an important thing about floating point numbers—they're just an approximation. This has nothing to do with Python specifically—it's a general feature of digital computing. It's very important to emphasize this fact about floating point numbers.

We'll return to the topic of floating point numbers in Chapter 2, Simple Data Types. For now, we want to focus on external libraries.

One important library module that is part of Python is named this. To see the this module, enter import this at the >>> prompt, like so:

>>> import this

Another equally important module is antigravity.

>>> import antigravity

We'll leave the exploration of these modules as exercises for the reader. We don't want to spoil the fun! More handwaving explanation isn't as helpful as hands-on experience. See http://xkcd.com/413/ for more on this topic.

We'll summarize by noting that the name "Python" has much to do with Monty Python and nothing to do with serpents.

Python includes the pydoc application that we use to view documentation. This application is something that we run from the OS command prompt. We do not use this from the Python >>> prompt; we use it from the OS prompt. While developing, we might want to leave a Terminal window open just to display module documentation.

The pydoc program has two operating modes:

The second example will start a web server as well as a browser. The browser will show the pydoc-produced documentation. This is derived from the module and package structure as well as the documentation strings embedded in the Python code. When we were done reading the documentation, we entered q to quit the web server.

When we write Python packages, modules, classes, and functions, we can (and should) provide the content for pydoc/help() documentation. These documentation strings are part of our programming, and are as important as having programs that work correctly. We'll look at this embedded documentation in Chapter 14, Fit and Finish – Unit Testing, Packaging, and Documentation.

The syntax rules for Python are defined in section 2 of the Python Language Reference manual. We'll look at the rules in detail in Chapter 3, Expressions and Output.

Python has about 20 kinds of statements. Here's a quick summary of the rules:

In effect, Python programs consist of one-statement-one-line. The end of a line is the statement terminator. We have a few techniques for extending a statement. The most common technique is based on Python's requirement that the ( and ) characters must balance.

We can, for example, write code like this:

print(
   "Hello world",
   "π≈",
   355/113
)

We've spread a single logical line to four physical lines using ( and ). One consequence of this is that a simple statement that we enter at the REPL must not be indented. A leading space will cause problems because leading spaces are used to show which statements are inside a compound statement.

Another consequence of this is less direct. Python executes a script file one statement at a time from start to finish. This means that complex Python programs will have a number of definitions first, and the "main" part of the processing will generally be last.

A Python comment starts with # and ends at the end of the line. This follows the same rules as the various Linux shells. Because of the way Python documentation strings are processed by pydoc and help(), most documentation is actually presented in separate string literals at the start of a package, module, class, or function definition. We'll look at these documentation strings in Chapter 14, Fit and Finish – Unit Testing, Packaging, and Documentation. The # comment is used sparingly.

Python's design includes a small core language that can be extended by importing additional features. The Language Reference Manual describes 20 statements; there are only 19 operators. The idea is that we can have a great deal of confidence that a small language is correctly implemented, complete, and consistent.

The standard library documentation contains 37 chapters, and describes hundreds of extension packages. There are a lot of features available to help us solve our unique problem. It's typical to see Python programs that import numerous packages from the standard library.

We'll see two common variations of the import statement:

The first version imports the entire math module and creates the module as an object in the global namespace. The various classes and function names within that module must be properly qualified with the namespace to be used. A qualified name will look similar to math.sqrt() or math.sin().

While the second version also imports the math module, it only introduces the given names into the global namespace. These names do not require qualifiers. We can use sqrt() and sin() as if they were built-in functions. The math module object, however, is not available, since it was not introduced into the global namespace.

An import happens exactly once. Python tracks the imported modules and will not import a module a second time. This allows us to freely import modules as needed without worrying about the order or other obscure dependencies among modules.

For confirmation of this one-time-only rule for imports, try the following:

>>> import this
>>> import this

The behavior the second time is different because the module has already been imported once.

Many developers of Python modules will register their work with the PyPI. This is located at http://pypi.python.org/. This is the second place to look for a module that might help solve a particular problem.

The first place to look is always the standard library.

The PyPI web page has a handy search form as well as a browser that shows packages organized under nine different metadata variables. In many cases, a book or blog post may provide a direct path like this: https://pypi.python.org/pypi/Sphinx/1.3b2. This ensures that the proper version can be downloaded and installed.

There are three common ways to download and install software from the PyPI:

Generally, we'll use tools such as pip or easy_install for almost all of our installations. Once in a while, however, we may need to resort to a manual installation.

Some modules may involve binary extensions to Python. These are generally C-language-sources, so they must be compiled to be useful. For Windows—where C compilers are rare—it's often necessary to find an .msi installer that includes prebuilt binaries. For Mac OS X and Linux, the C source may be compiled as part of the installation process.

In the case of large, complex numeric and scientific packages—specifically, numpy and scipy—the build process can become quite complex: generally, more complex than pip or easy_install can handle. There are many additional high-performance libraries for these packages; the builds include modules in FORTRAN as well as C. In this case, a prebuilt OS-specific distribution is used; pip isn't part of the process.

Installing additional packages will require administrator privileges. Consequently, we'll show the sudo command as a reminder that this is required for Mac OS X and Linux. Windows users can simply ignore the presence of the sudo command.

prompt$ sudo pip3.4 install some-package

prompt$ sudo easy_install-3.3 some_package