Interrupting running code

Pressing Ctrl-C while any code is running, whether a script through %run or a long-running command, will cause a KeyboardInterrupt to be raised. This will cause nearly all Python programs to stop immediately except in certain unusual cases.

Indentation, not braces

Python uses whitespace (tabs or spaces) to structure code instead of using braces as in many other languages like R, C++, Java, and Perl. Consider a for loop from a sorting algorithm:

for x in array:
    if x < pivot:
        less.append(x)
    else:
        greater.append(x)

A colon denotes the start of an indented code block after which all of the code must be indented by the same amount until the end of the block.

Love it or hate it, significant whitespace is a fact of life for Python programmers. While it may seem foreign at first, you will hopefully grow accustomed in time.

As you can see by now, Python statements also do not need to be terminated by semicolons. Semicolons can be used, however, to separate multiple statements on a single line:

a = 5; b = 6; c = 7

Putting multiple statements on one line is generally discouraged in Python as it can make code less readable.

Everything is an object

An important characteristic of the Python language is the consistency of its object model. Every number, string, data structure, function, class, module, and so on exists in the Python interpreter in its own “box,” which is referred to as a Python object. Each object has an associated type (e.g., integer, string, or function) and internal data. In practice this makes the language very flexible, as even functions can be treated like any other object.

Comments

Any text preceded by the hash mark (pound sign) # is ignored by the Python interpreter. This is often used to add comments to code. At times you may also want to exclude certain blocks of code without deleting them. An easy solution is to comment out the code:

results = []
for line in file_handle:
    # keep the empty lines for now
    # if len(line) == 0:
    #   continue
    results.append(line.replace('foo', 'bar'))

Comments can also occur after a line of executed code. While some programmers prefer comments to be placed in the line preceding a particular line of code, this can be useful at times:

print("Reached this line")  # Simple status report

Function and object method calls

You call functions using parentheses and passing zero or more arguments, optionally assigning the returned value to a variable:

result = f(x, y, z)
g()

Almost every object in Python has attached functions, known as methods, that have access to the object’s internal contents. You can call them using the following syntax:

obj.some_method(x, y, z)

Functions can take both positional and keyword arguments:

result = f(a, b, c, d=5, e='foo')

More on this later.

Variables and argument passing

When assigning a variable (or name) in Python, you are creating a reference to the object on the righthand side of the equals sign. In practical terms, consider a list of integers:

In [8]: a = [1, 2, 3]

Suppose we assign a to a new variable b:

In [9]: b = a

In [10]: b
Out[10]: [1, 2, 3]

In some languages, the assignment if b will cause the data [1, 2, 3] to be copied. In Python, a and b actually now refer to the same object, the original list [1, 2, 3] (see Figure 2-7 for a mockup). You can prove this to yourself by appending an element to a and then examining b:

In [11]: a.append(4)

In [12]: b
Out[12]: [1, 2, 3, 4]

Figure 2-7. Two references for the same object

Understanding the semantics of references in Python and when, how, and why data is copied is especially critical when you are working with larger datasets in Python.

When you pass objects as arguments to a function, new local variables are created referencing the original objects without any copying. If you bind a new object to a variable inside a function, that will not overwrite a variable of the same name in the “scope” outside of the function (the “parent scope”). It is therefore possible to alter the internals of a mutable argument. Suppose we had the following function:

def append_element(some_list, element):
    some_list.append(element)

Then we have:

In [27]: data = [1, 2, 3]

In [28]: append_element(data, 4)

In [29]: data
Out[29]: [1, 2, 3, 4]

Dynamic references, strong types

In contrast with many compiled languages, such as Java and C++, object references in Python have no inherent type associated with them. There is no problem with the following:

In [13]: a = 5

In [14]: type(a)
Out[14]: int

In [15]: a = 'foo'

In [16]: type(a)
Out[16]: str

Variables are names for objects within a particular namespace; the type information is stored in the object itself. Some observers might hastily conclude that Python is not a “typed language.” This is not true; consider this example:

In [17]: '5' + 5
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-17-4dd8efb5fac1> in <module>
----> 1 '5' + 5
TypeError: can only concatenate str (not "int") to str

In some languages, such as Visual Basic, the string '5' might get implicitly converted (or casted) to an integer, thus yielding 10. Yet in other languages, such as JavaScript, the integer 5 might be casted to a string, yielding the concatenated string '55'. In this regard Python is considered a strongly typed language, which means that every object has a specific type (or class), and implicit conversions will occur only in certain obvious circumstances, such as the following:

In [18]: a = 4.5

In [19]: b = 2

# String formatting, to be visited later
In [20]: print('a is {0}, b is {1}'.format(type(a), type(b)))
a is <class 'float'>, b is <class 'int'>

In [21]: a / b
Out[21]: 2.25

Knowing the type of an object is important, and it’s useful to be able to write functions that can handle many different kinds of input. You can check that an object is an instance of a particular type using the isinstance function:

In [22]: a = 5

In [23]: isinstance(a, int)
Out[23]: True

isinstance can accept a tuple of types if you want to check that an object’s type is among those present in the tuple:

In [24]: a = 5; b = 4.5

In [25]: isinstance(a, (int, float))
Out[25]: True

In [26]: isinstance(b, (int, float))
Out[26]: True

Attributes and methods

Objects in Python typically have both attributes (other Python objects stored “inside” the object) and methods (functions associated with an object that can have access to the object’s internal data). Both of them are accessed via the syntax obj.attribute_name:

In [1]: a = 'foo'

In [2]: a.<Press Tab>
a.capitalize  a.format      a.isupper     a.rindex      a.strip
a.center      a.index       a.join        a.rjust       a.swapcase
a.count       a.isalnum     a.ljust       a.rpartition  a.title
a.decode      a.isalpha     a.lower       a.rsplit      a.translate
a.encode      a.isdigit     a.lstrip      a.rstrip      a.upper
a.endswith    a.islower     a.partition   a.split       a.zfill
a.expandtabs  a.isspace     a.replace     a.splitlines
a.find        a.istitle     a.rfind       a.startswith

Attributes and methods can also be accessed by name via the getattr function:

In [28]: getattr(a, 'split')
Out[28]: <function str.split(sep=None, maxsplit=-1)>

In other languages, accessing objects by name is often referred to as “reflection.” While we will not extensively use the functions getattr and related functions hasattr and setattr in this book, they can be used very effectively to write generic, reusable code.

Duck typing

Often you may not care about the type of an object but rather only whether it has certain methods or behavior. This is sometimes called “duck typing,” after the saying “If it walks like a duck and quacks like a duck, then it’s a duck.” For example, you can verify that an object is iterable if it implements the iterator protocol. For many objects, this means it has a __iter__ “magic method”, though an alternative and better way to check is to try using the iter function:

def isiterable(obj):
    try:
        iter(obj)
        return True
    except TypeError: # not iterable
        return False

This function would return True for strings as well as most Python collection types:

In [30]: isiterable('a string')
Out[30]: True

In [31]: isiterable([1, 2, 3])
Out[31]: True

In [32]: isiterable(5)
Out[32]: False

A place where I use this functionality all the time is to write functions that can accept multiple kinds of input. A common case is writing a function that can accept any kind of sequence (list, tuple, ndarray) or even an iterator. You can first check if the object is a list (or a NumPy array) and, if it is not, convert it to be one:

if not isinstance(x, list) and isiterable(x):
    x = list(x)

Imports

In Python a module is simply a file with the .py extension containing Python code. Suppose that we had the following module:

# some_module.py
PI = 3.14159

def f(x):
    return x + 2

def g(a, b):
    return a + b

If we wanted to access the variables and functions defined in some_module.py, from another file in the same directory we could do:

import some_module
result = some_module.f(5)
pi = some_module.PI

Or equivalently:

from some_module import f, g, PI
result = g(5, PI)

By using the as keyword you can give imports different variable names:

import some_module as sm
from some_module import PI as pi, g as gf

r1 = sm.f(pi)
r2 = gf(6, pi)

Binary operators and comparisons

Most of the binary math operations and comparisons use familiar mathematical syntax used in other programming langauges:

In [33]: 5 - 7
Out[33]: -2

In [34]: 12 + 21.5
Out[34]: 33.5

In [35]: 5 <= 2
Out[35]: False

See Table 2-3 for all of the available binary operators.

To check if two variables refer to the same object, use the is keyword. is not cann analogously be used to check that two objects are not the same:

In [36]: a = [1, 2, 3]

In [37]: b = a

In [38]: c = list(a)

In [39]: a is b
Out[39]: True

In [40]: a is not c
Out[40]: True

Since the list function always creates a new Python list (i.e., a copy), we can be sure that c is distinct from a. Comparing with is is not the same as the == operator, because in this case we have:

In [41]: a == c
Out[41]: True

A common use of is and is not is to check if a variable is None, since there is only one instance of None:

In [42]: a = None

In [43]: a is None
Out[43]: True

Mutable and immutable objects

Most objects in Python, such as lists, dicts, NumPy arrays, and most user-defined types (classes), are mutable. This means that the object or values that they contain can be modified:

In [44]: a_list = ['foo', 2, [4, 5]]

In [45]: a_list[2] = (3, 4)

In [46]: a_list
Out[46]: ['foo', 2, (3, 4)]

Others, like strings and tuples, are immutable, which means their internal data cannot be changed:

In [47]: a_tuple = (3, 5, (4, 5))

In [48]: a_tuple[1] = 'four'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-48-23fe12da1ba6> in <module>
----> 1 a_tuple[1] = 'four'
TypeError: 'tuple' object does not support item assignment

Remember that just because you can mutate an object does not mean that you always should. Such actions are known as side effects. For example, when writing a function, any side effects should be explicitly communicated to the user in the function’s documentation or comments. If possible, I recommend trying to avoid side effects and favor immutability, even though there may be mutable objects involved.

Numeric types

The primary Python types for numbers are int and float. An int can store arbitrarily large numbers:

In [49]: ival = 17239871

In [50]: ival ** 6
Out[50]: 26254519291092456596965462913230729701102721

Floating-point numbers are represented with the Python float type. Under the hood each one is a double-precision (64-bit) value. They can also be expressed with scientific notation:

In [51]: fval = 7.243

In [52]: fval2 = 6.78e-5

Integer division not resulting in a whole number will always yield a floating-point number:

In [53]: 3 / 2
Out[53]: 1.5

To get C-style integer division (which drops the fractional part if the result is not a whole number), use the floor division operator //:

In [54]: 3 // 2
Out[54]: 1

Strings

Many people use Python for its built-in string handling capabilities. You can write string literals using either single quotes ' or double quotes ":

a = 'one way of writing a string'
b = "another way"

For multiline strings with line breaks, you can use triple quotes, either ''' or """:

c = """
This is a longer string that
spans multiple lines
"""

It may surprise you that this string c actually contains four lines of text; the line breaks after """ and after lines are included in the string. We can count the new line characters with the count method on c:

In [56]: c.count('
')
Out[56]: 3

Python strings are immutable; you cannot modify a string:

In [57]: a = 'this is a string'

In [58]: a[10] = 'f'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-58-2151a30ed055> in <module>
----> 1 a[10] = 'f'
TypeError: 'str' object does not support item assignment

In [59]: b = a.replace('string', 'longer string')

In [60]: b
Out[60]: 'this is a longer string'

Afer this operation, the variable a is unmodified:

In [61]: a
Out[61]: 'this is a string'

Many Python objects can be converted to a string using the str function:

In [62]: a = 5.6

In [63]: s = str(a)

In [64]: print(s)
5.6

Strings are a sequence of Unicode characters and therefore can be treated like other sequences, such as lists and tuples (which we will explore in more detail in the next chapter):

In [65]: s = 'python'

In [66]: list(s)
Out[66]: ['p', 'y', 't', 'h', 'o', 'n']

In [67]: s[:3]
Out[67]: 'pyt'

The syntax s[:3] is called slicing and is implemented for many kinds of Python sequences. This will be explained in more detail later on, as it is used extensively in this book.

The backslash character is an escape character, meaning that it is used to specify special characters like newline or Unicode characters. To write a string literal with backslashes, you need to escape them:

In [68]: s = '12\34'

In [69]: print(s)
1234

If you have a string with a lot of backslashes and no special characters, you might find this a bit annoying. Fortunately you can preface the leading quote of the string with r, which means that the characters should be interpreted as is:

In [70]: s = r'thishas
ospecialcharacters'

In [71]: s
Out[71]: 'this\has\no\special\characters'

The r stands for raw.

Adding two strings together concatenates them and produces a new string:

In [72]: a = 'this is the first half '

In [73]: b = 'and this is the second half'

In [74]: a + b
Out[74]: 'this is the first half and this is the second half'

String templating or formatting is another important topic. The number of ways to do so has expanded with the advent of Python 3, and here I will briefly describe the mechanics of one of the main interfaces. String objects have a format method that can be used to substitute formatted arguments into the string, producing a new string:

In [75]: template = '{0:.2f} {1:s} are worth US${2:d}'

In this string,

• {0:.2f} means to format the first argument as a floating-point number with two decimal places.

• {1:s} means to format the second argument as a string.

• {2:d} means to format the third argument as an exact integer.

To substitute arguments for these format parameters, we pass a sequence of arguments to the format method:

In [76]: template.format(88.46, 'Argentine Pesos', 1)
Out[76]: '88.46 Argentine Pesos are worth US$1'

Python 3.6 introduced a new feature called “f-strings” (short for “Formatted string literals”) which can make creating formatted strings even more convenient. To create an f-string, write the character f immediately preceding a string literal. Within the string, enclose Python expressions in curly braces to substitute the value of the expression into the formatted string:

In [77]: amount = 10

In [78]: rate = 88.46

In [79]: currency = 'Pesos'

In [80]: result = f'{amount} {currency} is worth US${amount / rate}'

Format specifiers can be added after each expression using the same syntax as with the string templates above:

In [81]: f'{amount} {currency} is worth US${amount / rate:.2f}'
Out[81]: '10 Pesos is worth US$0.11'

String formatting is a deep topic; there are multiple methods and numerous options and tweaks available to control how values are formatted in the resulting string. To learn more, I recommend consulting the official Python documentation.

I discuss general string processing as it relates to data analysis in more detail in [Link to Come].

Bytes and Unicode

In modern Python (i.e., Python 3.0 and up), Unicode has become the first-class string type to enable more consistent handling of ASCII and non-ASCII text. In older versions of Python, strings were all bytes without any explicit Unicode encoding. You could convert to Unicode assuming you knew the character encoding. Let’s look at an example:

In [82]: val = "español"

In [83]: val
Out[83]: 'español'

We can convert this Unicode string to its UTF-8 bytes representation using the encode method:

In [84]: val_utf8 = val.encode('utf-8')

In [85]: val_utf8
Out[85]: b'espaxc3xb1ol'

In [86]: type(val_utf8)
Out[86]: bytes

Assuming you know the Unicode encoding of a bytes object, you can go back using the decode method:

In [87]: val_utf8.decode('utf-8')
Out[87]: 'español'

While it’s become preferred to use UTF-8 for any encoding, for historical reasons you may encounter data in any number of different encodings:

In [88]: val.encode('latin1')
Out[88]: b'espaxf1ol'

In [89]: val.encode('utf-16')
Out[89]: b'xffxfeex00sx00px00ax00xf1x00ox00lx00'

In [90]: val.encode('utf-16le')
Out[90]: b'ex00sx00px00ax00xf1x00ox00lx00'

It is most common to encounter bytes objects in the context of working with files, where implicitly decoding all data to Unicode strings may not be desired.

Though you may seldom need to do so, you can define your own byte literals by prefixing a string with b:

In [91]: bytes_val = b'this is bytes'

In [92]: bytes_val
Out[92]: b'this is bytes'

In [93]: decoded = bytes_val.decode('utf8')

In [94]: decoded  # this is str (Unicode) now
Out[94]: 'this is bytes'

Booleans

The two boolean values in Python are written as True and False. Comparisons and other conditional expressions evaluate to either True or False. Boolean values are combined with the and and or keywords:

In [95]: True and True
Out[95]: True

In [96]: False or True
Out[96]: True

When converted to numbers, False becomes 0 and True becomes 1:

In [97]: int(False)
Out[97]: 0

In [98]: int(True)
Out[98]: 1

Type casting

The str, bool, int, and float types are also functions that can be used to cast values to those types:

In [99]: s = '3.14159'

In [100]: fval = float(s)

In [101]: type(fval)
Out[101]: float

In [102]: int(fval)
Out[102]: 3

In [103]: bool(fval)
Out[103]: True

In [104]: bool(0)
Out[104]: False

None

None is the Python null value type. If a function does not explicitly return a value, it implicitly returns None:

In [105]: a = None

In [106]: a is None
Out[106]: True

In [107]: b = 5

In [108]: b is not None
Out[108]: True

None is also a common default value for function arguments:

def add_and_maybe_multiply(a, b, c=None):
    result = a + b

    if c is not None:
        result = result * c

    return result

While a technical point, it’s worth bearing in mind that None is not only a reserved keyword but also a singleton instance of NoneType:

In [109]: type(None)
Out[109]: NoneType

In [110]: None is None
Out[110]: True

Dates and times

The built-in Python datetime module provides datetime, date, and time types. The datetime type combines the information stored in date and time and is the most commonly used:

In [111]: from datetime import datetime, date, time

In [112]: dt = datetime(2011, 10, 29, 20, 30, 21)

In [113]: dt.day
Out[113]: 29

In [114]: dt.minute
Out[114]: 30

Given a datetime instance, you can extract the equivalent date and time objects by calling methods on the datetime of the same name:

In [115]: dt.date()
Out[115]: datetime.date(2011, 10, 29)

In [116]: dt.time()
Out[116]: datetime.time(20, 30, 21)

The strftime method formats a datetime as a string:

In [117]: dt.strftime('%m/%d/%Y %H:%M')
Out[117]: '10/29/2011 20:30'

Strings can be converted (parsed) into datetime objects with the strptime function:

In [118]: datetime.strptime('20091031', '%Y%m%d')
Out[118]: datetime.datetime(2009, 10, 31, 0, 0)

See Table 2-5 for a full list of format specifications.

When you are aggregating or otherwise grouping time series data, it will occasionally be useful to replace time fields of a series of datetimes—for example, replacing the minute and second fields with zero:

In [119]: dt_hour = dt.replace(minute=0, second=0)

In [120]: dt_hour
Out[120]: datetime.datetime(2011, 10, 29, 20, 0)

Since datetime.datetime is an immutable type, methods like these always produce new objects. So in the above, dt is not modified by replace:

In [121]: dt
Out[121]: datetime.datetime(2011, 10, 29, 20, 30, 21)

The difference of two datetime objects produces a datetime.timedelta type:

In [122]: dt2 = datetime(2011, 11, 15, 22, 30)

In [123]: delta = dt2 - dt

In [124]: delta
Out[124]: datetime.timedelta(days=17, seconds=7179)

In [125]: type(delta)
Out[125]: datetime.timedelta

The output timedelta(17, 7179) indicates that the timedelta encodes an offset of 17 days and 7,179 seconds.

Adding a timedelta to a datetime produces a new shifted datetime:

In [126]: dt
Out[126]: datetime.datetime(2011, 10, 29, 20, 30, 21)

In [127]: dt + delta
Out[127]: datetime.datetime(2011, 11, 15, 22, 30)

if, elif, and else

The if statement is one of the most well-known control flow statement types. It checks a condition that, if True, evaluates the code in the block that follows:

if x < 0:
    print("It's negative")

An if statement can be optionally followed by one or more elif blocks and a catch-all else block if all of the conditions are False:

if x < 0:
    print("It's negative")
elif x == 0:
    print("Equal to zero")
elif 0 < x < 5:
    print("Positive but smaller than 5")
else:
    print("Positive and larger than or equal to 5")

If any of the conditions is True, no further elif or else blocks will be reached. With a compound condition using and or or, conditions are evaluated left to right and will short-circuit:

In [128]: a = 5; b = 7

In [129]: c = 8; d = 4

In [130]: if a < b or c > d:
   .....:     print('Made it')
Made it

In this example, the comparison c > d never gets evaluated because the first comparison was True.

It is also possible to chain comparisons:

In [131]: 4 > 3 > 2 > 1
Out[131]: True

for loops

for loops are for iterating over a collection (like a list or tuple) or an iterater. The standard syntax for a for loop is:

for value in collection:
    # do something with value

You can advance a for loop to the next iteration, skipping the remainder of the block, using the continue keyword. Consider this code, which sums up integers in a list and skips None values:

sequence = [1, 2, None, 4, None, 5]
total = 0
for value in sequence:
    if value is None:
        continue
    total += value

A for loop can be exited altogether with the break keyword. This code sums elements of the list until a 5 is reached:

sequence = [1, 2, 0, 4, 6, 5, 2, 1]
total_until_5 = 0
for value in sequence:
    if value == 5:
        break
    total_until_5 += value

The break keyword only terminates the innermost for loop; any outer for loops will continue to run:

In [132]: for i in range(4):
   .....:     for j in range(4):
   .....:         if j > i:
   .....:             break
   .....:         print((i, j))
   .....:
(0, 0)
(1, 0)
(1, 1)
(2, 0)
(2, 1)
(2, 2)
(3, 0)
(3, 1)
(3, 2)
(3, 3)

As we will see in more detail, if the elements in the collection or iterator are sequences (tuples or lists, say), they can be conveniently unpacked into variables in the for loop statement:

for a, b, c in iterator:
    # do something

while loops

A while loop specifies a condition and a block of code that is to be executed until the condition evaluates to False or the loop is explicitly ended with break:

x = 256
total = 0
while x > 0:
    if total > 500:
        break
    total += x
    x = x // 2

pass

pass is the “no-op” (or “do nothing”) statement in Python. It can be used in blocks where no action is to be taken (or as a placeholder for code not yet implemented); it is only required because Python uses whitespace to delimit blocks:

if x < 0:
    print('negative!')
elif x == 0:
    # TODO: put something smart here
    pass
else:
    print('positive!')

range

The range function returns an iterator that yields a sequence of evenly spaced integers:

In [133]: range(10)
Out[133]: range(0, 10)

In [134]: list(range(10))
Out[134]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Both a start, end, and step (which may be negative) can be given:

In [135]: list(range(0, 20, 2))
Out[135]: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

In [136]: list(range(5, 0, -1))
Out[136]: [5, 4, 3, 2, 1]

As you can see, range produces integers up to but not including the endpoint. A common use of range is for iterating through sequences by index:

seq = [1, 2, 3, 4]
for i in range(len(seq)):
    val = seq[i]

While you can use functions like list to store all the integers generated by range in some other data structure, often the default iterator form will be what you want. This snippet sums all numbers from 0 to 99,999 that are multiples of 3 or 5:

sum = 0
for i in range(100000):
    # % is the modulo operator
    if i % 3 == 0 or i % 5 == 0:
        sum += i

While the range generated can be arbitrarily large, the memory use at any given time may be very small.

Ternary expressions

A ternary expression in Python allows you to combine an if-else block that produces a value into a single line or expression. The syntax for this in Python is:

value = true-expr if condition else false-expr

Here, true-expr and false-expr can be any Python expressions. It has the identical effect as the more verbose:

if condition:
    value = true-expr
else:
    value = false-expr

This is a more concrete example:

In [137]: x = 5

In [138]: 'Non-negative' if x >= 0 else 'Negative'
Out[138]: 'Non-negative'

As with if-else blocks, only one of the expressions will be executed. Thus, the “if” and “else” sides of the ternary expression could contain costly computations, but only the true branch is ever evaluated.

While it may be tempting to always use ternary expressions to condense your code, realize that you may sacrifice readability if the condition as well as the true and false expressions are very complex.