Like most computer languages, Python allows one to work with numbers and text. Let's start with numbers. The following is not intended to be comprehensive; it is intended to give you enough information and examples to get started. Then it is up to you to learn by experimenting, by looking in the documentation, by looking at more code examples, and by asking questions.
Note: in this notebook we are working with functionality that comes with Python itself; we will introduce the numpy package and other key components for scientific computing in the subsequent notebooks.
Python's system of numbers is quite simple: there are integers, floating point numbers, complex numbers, and Boolean (True or False) types, together with their associated operations. The types are determined dynamically, so operations involving integers and floating point numbers yield floating point numbers.
print("1 + 2 = ", 1 + 2)
print("1.0 + 2 =", 1.0 + 2)
Division can be tricky because traditional computer languages use integer division on integers. This was the case by default with Python 2, but there it can be changed via the first line in the following block, which you will often see in code written for both Python versions. Python 3 uses "true division" for '/' and integer division only with the explicit integer division operator, '//'. Notice that the even with '//' the type of the number returned is a float if either of the arguments is a float.
from __future__ import division # get Py3 behavior if on Py2
print("4 / 3 = ", 4 / 3) # would return 1 on Py2 without the import
print("4.0 / 3 =", 4.0 / 3)
print("4 // 3 = ", 4 // 3)
print("4.0 // 3 = ", 4.0 // 3)
There are some built-in functions that operate on numbers, e.g.:
print(int(4/3))
print(round(4/3, 1))
print(abs(4.2 - 5)) # Note binary floating point inability
# to represent a decimal number exactly.
print(pow(2, 3))
Arithmetic operators include exponentiation with the following notation as an alternative to the pow() function:
print(2**3)
For more math functions, one can import the math module from the standard library:
import math
print(math.sin(1))
print(math.sqrt(2))
We will rarely use the math module, however, because numpy provides the same functionality and much more.
Complex numbers use this notation:
print("complex number:", 1.0 + 2.3j)
Boolean values are either True or False, and result from conditional expressions like this:
print("1 > 2 is", 1 > 2, "but 1 < 2 is", 1 < 2)
Here is a more complex conditional expression:
print(1 > 2 or 3 < 4)
Much computer programming requires working with text. A piece of text is held in an object called a string. There is an additional layer of complexity, and of difference between Python 2 and 3, associated with how text is represented internally (in memory) versus externally (on the page or screen). This is the dreaded "unicode". We will blissfully ignore it for now.
Python strings can be created with the str() function, and as literals using single quotes, double quotes, triple single quotes, or triple double quotes. The triples can enclose blocks of text spanning multiple lines. The following are all valid strings, each assigned to a variable name:
a = 'Single quotes'
b = "Double quotes"
c = "a string that has 'single quotes' inside it"
d = """This is a multiline
sentence string, ending with a linefeed.
"""
e = '''
This is also valid. It starts and ends with a linefeed.
'''
for example in (a, b, c, d, 3):
print(example)
Strings can be added (concatenated):
print(d + e)
Jargon alert: Any particular string is an object that is an instance of a class (or type), and therefore operations on it can be performed by invoking methods of that class (str).
Methods are invoked using "dot" syntax, e.g.:
print("The variable '%s' is an instance of the %s class" % ('a', a.__class__))
print("Converted to upper case:", a.upper())
print("Does it end with 'quotes'?", a.endswith("quotes"))
print("Split into a list of words:", a.split())
Reminder: to see a list of methods for "a", you can enter "a." and then hit the Tab key. Try it in the cell above, or make a new cell for testing.
A string is a sequence of characters; as with any Python sequence, we can use indexing to access parts of the sequence:
print(a)
print(a[:2])
print(a[-2:])
print(a[0])
print(a[-1])
print(a[::2])
More jargon: Strings are immutable--that is, unchangeable--so you cannot alter an existing string object, but you can make a new string object out of parts of an old one. That is what indexing is doing in the example above.
Based on these examples, see if you can figure out how Python's indexing syntax works.
Now let's consider two other sequence objects.
Tuples and lists are very general sequences--that is, they are containers that preserve order, and they can contain any kind of object at all. There is one big practical difference: tuples are immutable, lists are mutable. One might wonder why we need tuples at all. In most cases, if you need a general sequence type in your program, you can use a list, regardless of whether you plan to change its contents. It turns out that in more advanced work there are situations where only a tuple will do, however---specifically, dictionary keys must be immutable, so a tuple can be used as a dictionary key but a list cannot. We will introduce dictionaries shortly, but first we need to become comfortable with tuples and lists.
To create a tuple from scratch, use round parentheses and commas; for lists, use square parentheses:
print("empty tuple:", tuple())
print("tuple with one element (the comma is required):", (1,))
print("tuple:", (1, 2))
print("tuple:", (3, (4, 5), 7, 8, "some string"))
print("list with one element (trailing comma is optional):", [1])
print("another list:", ["first element", 2, 3, "last element"])
Lists have many methods, and support addition and multiplication:
a = ["list1", 1, 2]
b = ["list2", 3, 4]
print("adding is concatenation:", a + b)
print("multiplication is repetition:", a * 2)
c = a.extend(b) # assigning to c only to suppress printing
print("We extended a by tacking list b on the end:", a)
print(" (This is identical to the sum, a + b, above.")
c = a.append("added to end")
print("Then we added a string:", a)
Lists, tuples, and strings all support the same indexing syntax.
The zero-based indexing and the exclusion of the end of a range may seem odd if you are coming from Matlab, but they work very well in practice, often leading to simpler code.
# Using the built-in "range" function,
# make a list on which we can practice indexing:
x = list(range(0, 100, 10))
print(x)
Take the first 5 values, then the last 5 values:
print(x[:5])
print(x[-5:])
See how easy that was? Now take every second value starting from the second (index 1):
print(x[1::2])
So the order is start, stop, step, separated by colons. If a value is the default, it can be omitted. The default step is 1. When the step is positive, the default start is 0, and the default stop is one past the last. Remember, the slice includes the start, but not the stop.
When the step is negative, the indices are selected in descending order, so the default start is the highest index. The default stop, to include the zero index, is None. (One might guess it would be 0 minus 1, so -1, but that would not work, because the index -1 refers to the last element in the array.)
Let's illustrate the negative step first with a string:
print('abcd'[::-1])
print('abcd'[:None:-1])
print('abcd'[-1:None:-1])
print('abcd'[-2:0:-1])
Back to the list, showing indexing backwards by two, then a case with only one element, and then with none:
print(x[::-2])
print(x[1:2])
print(x[1:1])
In the above examples we are indexing a list with a slice, so we are getting a list back, even if it has only one element in it, or if it is empty. If we want to get an element from the list, then we index with a single integer:
print(x[0])
print(x[-1])
There is one thing that you might like to do, but cannot do directly with native Python types (though you can with Numpy arrays, as we will see later): that is to index with an arbitrary set of indices.
You can do it indirectly, however, using a powerful construct called a list comprehension, which is easier to understand and use than its name might suggest. Here are some examples:
xlist = list(range(0, 100, 10))
print(xlist)
# arbitrary set of indices we want to select:
ilist = [3, 7, 2, 1]
xi = [xlist[i] for i in ilist]
print(xi)
# More list comprehension examples:
print([x for x in xlist if x < 30 or x > 70])
print([x ** 2 for x in xlist if x % 20 == 0])
Because lists are mutable, you can alter an element in a list:
xlist = list(range(20, 50, 10))
print(xlist)
xlist[-1] = - xlist[-1] # flipped the sign
print(xlist)
Items in tuples and lists can be found easily only based on their locations, that is, their indices. In a dictionary, items can be located efficiently based on their keys--and this is as true of a Python dict as it is of the Oxford English Dictionary. Dictionaries are central to the internal workings of Python, and to much code written in Python. They can be very small, very large, or anywhere in between. Keys are usually strings (text), but can be any immutable Python object, such as a tuple. Here are some examples of dictionary creation and indexing:
yesno = dict(yes=True, no=False)
print(yesno)
print(yesno['yes'])
print(yesno['no'])
# Use an alternative syntax for initializing a dictionary:
responses = {1 : True, 0 : False, 'yes' : True, 'no' : False}
print(responses)
print(responses[1], responses['yes'])
The two examples above illustrate the two basic ways of creating a dictionary. The first calls a function with keyword arguments; it works only when the keys are strings. The second uses curly brackets, and works for any valid keys (immutable objects).
month_by_abbrev = dict(Jan="January", Feb="February", Mar="March",
Apr="April", May="May", Jun="June") # etc...
print(month_by_abbrev)
Entries can be retrieved, and new entries added, by indexing:
print(month_by_abbrev["Apr"])
month_by_abbrev["Jul"] = "July"
print(month_by_abbrev)
Dictionaries have their own methods, of course; refer to the Python docs for a full list. Here is just one example:
print("list of keys:", month_by_abbrev.keys())
Note: dictionaries do not preserve the order in which the key-value pairs were added. Usually this doesn't matter; but if it does, then you can use an OrderedDict.
Strings, tuples, lists, and dictionaries all support a simple syntax for testing whether a given item is present. In the case of dictionaries, it is sought in the keys, not the values:
# membership in strings: looks for substrings
print("any" in "many")
print("few" in "many")
# membership in a dictionary tests the presence of a key:
print("Apr" in month_by_abbrev)
# To check for a value in a dictionary, use the values() method:
print("April" in month_by_abbrev.values())
print("Mars" in month_by_abbrev.values())