Introduction to Python for Science, Release 0.9.23

2.4 Interactive Python as a calculator

You can use the IPython shell to perform simple arithmatic calculations. For example, to find the product 3 15, you type 3*15 at the In prompt and press RETURN:

In [1]: 3*15

Out[1]: 45

Python returns the correct product, as expected. You can do more complicated calculations:

In [2]: 6+21/3

Out[2]: 13.0

Let’s try some more arithmetic:

In [3]: (6+21)/3

Out[3]: 9.0

Notice that the effect of the parentheses in In [3]: (6+21)/3 is to cause the addition to be performed first and then the division. Without the parentheses, Python will always perform the multiplication and division operations before performing the addition and subtraction operations. The order in which arithmetic operations are performed is the same as for most calculators: exponentiation first, then multiplication or division, then addition or subtraction, then left to right.

2.4.1 Binary arithmetic operations in Python

The table below lists the binary arithmatic operations in Python. It has all the standard binary operators for arithmetic, plus a few you may not have seen before.

“Floor division,” designated by the symbols //, means divide and keep only the integer part without rounding. “Remainder,” designated by the symbols %, gives the remainder of after a floor division.

Introduction to Python for Science, Release 0.9.23

2.4.2 Types of numbers

There are four different types of numbers in Python: plain integers, long integers, floating point numbers, and complex numbers.

Plain integers, or simply integers, are 32 bits (binary digits) long, which means they extend from 231 = 2147483648 to 231 1 = 2147483647. One bit is used to store the sign of the integer so there are only 31 bits left—hence, the power of 31. In Python, a number is automatically treated as an integer if is written without a decimal point and it is within the bounds given above. This means that 23, written without a decimal point, is an integer and 23., written with a decimal point, is a floating point number. If an integer extends beyond the bounds of a simple integer, the it becomes a long integer, and is designated as such by an L following the last digit. Here are some examples of integer arithmetic:

In [4]: 12*3

Out[4]: 36

In [5]: 4+5*6-(21*8)

Out[5]: -134

In [6]: 11/5

Out[6]: 2.2

For the binary operators +, -, *, and //, the output is an integer if the inputs are integers. The only exception is if the result of the calculation is out of the bounds of Python integers, in which case Python automatically converts the result to a long integer. The output of the division operator / is a floating point as of version 3 of Python. If an integer output is desired when two integers are divided, the floor division operator // must be used. See

Important note on integer division in Python.

Floating point numbers are essentially rational numbers and can have a fractional part; integers, by their very nature, have no fractional part. In most versions of Python running on PCs or Macs, floating point numbers go between approximately 2 10 308 and2 10308. Here are some examples of integer arithmetic:

In [9]: 12.*3.

Out[9]: 36.0

Introduction to Python for Science, Release 0.9.23

In [10]: 123.4*(-53.9)/sqrt(5.)

Out[10]: -2974.5338992050501

In [11]: 11./5.

Out[11]: 2.2

In [12]: 11.//5.

Out[12]: 2.0

In [13]: 11.%5.

Out[13]: 1.0

In [14]: 6.022e23*300.

Out[14]: 1.8066e+26

Note that the result of any operation involving only floating point numbers as inputs is a real number, even in the cases where the floor division // or remainder % operators are used. The last output also illustrates an alternative way of writing floating point numbers

as a mantissa followed by and e or E followed by a power of 10: so 1.23e-12 is equivalent to 1:23 10 12.

We also sneaked into our calculations sqrt, the square root function. We will have more to say about functions in a few pages.

Complex numbers are written in Python as a sum of a real and imaginary part. For

example, the complex number 3 2i is represented as 3-2j in Python where j represents p

1. Here are some examples of complex arithmetic:

In [15]: (2+3j)*(-4+9j)

Out[15]: (-35+6j)

In [16]: (2+3j)/(-4+9j)

Out[16]: (0.1958762886597938-0.3092783505154639j)

In [17]: sqrt(-3)

Out[17]: nan

In [18]: sqrt(-3+0j)

Out[18]: 1.7320508075688772j

p

Notice that to obtain the expected result or 3, you must write the argument of the square root function as a complex number. Otherwise, Python returns nan (not a number).

If you multiply an integer by a floating point number, the result is a floating point number. Similarly, if you multiply a floating point number by a complex number, the result is a

Introduction to Python for Science, Release 0.9.23

complex number. Python always promotes the result to the most complex of the inputs.

2.4.3 Important note on integer division in Python

One peculiarity of all versions of Python prior to version 3 is that dividing two integers by each other yields the “floor division” result—another integer. Therefore 3/2 yields 1 whereas 3./2 or 3/2. or 3./2. all yield 1.5. Starting with version 3 of Python, all of the above expressions, including 3/2 yield 1.5. Unfortunately, we are using version 2.7 of Python so 3/2 yields 1. You can force versions of Python prior to version 3 to divide integers like version 3 does by typing from __future__ import division at the beginning of an IPython session. You only need to type it once and it works for the entire session.

2.5 Python Modules

The Python computer language consists of a “core” language plus a vast collection of supplementary software that is contained in modules. Many of these modules come with the standard Python distribution and provide added functionality for performing computer system tasks. Other modules provide more specialized capabilities that not every user may want. You can think of these modules as a kind of library from which you can borrow according to your needs.

We will need three Python modules that are not part of the core Python distribution, but are nevertheless widely used for scientific computing. The three modules are

NumPy is the standard Python package for scientific computing with Python. It provides the all-important array data structure, which is at the very heart of NumPy. In also provides tools for creating and manipulating arrays, including indexing and sorting, as well as basic logical operations and element-by-element arithmetic operations like addition, subtraction, multiplication, division, and exponentiation. It includes the basic mathematical functions of trigonometry, exponentials, and logarithms, as well vast collection of special functions (Bessel functions, etc.), statistical functions, and random number generators. It also includes a large number of linear algebra routines that overlap with those in SciPy, although the SciPy routines tend to be more complete. You can find more information about NumPy at http://docs.scipy.org/doc/numpy/reference/index.html.

Introduction to Python for Science, Release 0.9.23

SciPy provides a wide spectrum of mathematical functions and numerical routines for Python. SciPy makes extensive use of NumPy arrays so when you import SciPy, you should always import NumPy too. In addition to providing basic mathematical functions, SciPy provides Python “wrappers” for numerical software written in other languages, like Fortran, C, or C++. A “wrapper” provides a transparent easy-to- use Python interface to standard numerical software, such as routines for doing curve fitting and numerically solving differential equations. SciPy greatly extends the power of Python and saves you the trouble of writing software in Python that someone else has already written and optimized in some other language. You can find more information about SciPy at http://docs.scipy.org/doc/scipy/reference/.

MatPlotLib is the standard Python package for making two and three dimensional plots. MatPlotLib makes extensive use of NumPy arrays. You will make all of your plots in Python using this package. You can find more information about MatPlotLib at http://MatPlotLib.sourceforge.net/.

We will use these three modules extensively and therefore will provide introductions to their capabilities as we develop Python in this manual. The links above provide much more extensive information and you will certainly want to refer to them from time to time.

These modules, NumPy, MatPlotLib, and SciPy, are built into the IPython shell so we can use them freely in that environment. Later, when we introduce Python programs (or scripts), we will see that in those cases you must explicitly load these modules using the import command to have access to them.

Finally, we note that you can write your own Python modules. They are a convenient way of packaging and storing Python code so that you can reuse it. We defer learning about how to write modules until after we have learned about Python.

2.6 Python functions: a first look

A function in Python is similar to a mathematical function. In consists of a name and and one or more arguments contained inside parentheses, and it produces some output. For example, the NumPy function sin(x) calculates the sine of the number x (where x is expressed in radians). Let’s try it out in the IPython shell:

In [1]: sin(0.5)

Out[1]: 0.47942553860420301

Introduction to Python for Science, Release 0.9.23

The argument of the function can be a number or any kind of expression whose output produces a number. For example, the function log(x) calculates the nature logarithm. All of the following expressions are legal and produce the expected output:

In [2]: log(sin(0.5))

Out[2]: -0.73516668638531424

In [3]: log(sin(0.5)+1.0)

Out[3]: 0.39165386283471759

In [4]: log(5.5/1.2)

Out[4]: 1.5224265354444708

2.6.1 Some NumPy functions

NumPy includes an extensive library of mathematical functions. In the table below, we list some of the most useful ones. A much more complete list is available at http://docs.scipy.org/doc/numpy/reference/ufuncs.html#math-operations.

The functions discussed here all have one input and one output. Python functions can, in general, have multiple inputs and multiple outputs. We will discuss these and other features of functions later when we take up functions in the context of user-defined functions.