Python Background

• Started as a side-project in 1989 by Guido van Rossum, BDFL (benevolent dictator for life) until 2018.
• Python 3, first released in 2008, is the current major version.
• Python 2 support stopped on 1 January 2020.

The Zen of Python

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Operators

• Objects and operators are combined to form expressions.
• Key operators are:
  • Assignment (=, +=, -=, *=, /=)
  • Arithmetic (+, -, *, **, /, //, %)
  • Boolean (and, or, not)
  • Relational (==, !=, >, >=, <, <=)
  • Membership (in)

Mathematical Operations

Arithmetic operations:

1 + 1

2

5 - 3

2

6 / 2

3.0

4 * 4

16

# As in R, Python comments start with #
# Exponentiation
2 ** 4

16

# Integer division (remainder is discarded)
7 // 3

2

# Modulo operation (only remainder is retained)
7 % 3

1

Logical Operations

3 != 1 # Not equal

True

3 > 3 # Greater than

False

3 >= 3 # Greater than or equal

True

# True if either first or second operand is True, False otherwise
# Analogous to R's | operator
False or True 

True

# True if both first and second operand are True, False otherwise
# Analogous to R's & operator
False and True 

False

3 > 3 or 3 >= 3 # Combining 3 Boolean expressions

True

Assignment Operations

• Assignments create object references.
• Target (or name) on the left is assigned to object on the right.

x = 3

x

3

flowchart LR
x[x] --> v["3️⃣"]
v ~~~ | Memory Address | v

x += 2 # Increment assignment, equivalent to x = x + 2

x

5

Divisibility & Mutability

• In Python it is useful to think of objects storing:
  • Individual values (scalars) or
  • Sequences of elements
• Scalar objects are indivisible and immutable.
• Sequences can be both mutable and immutable.
• 4 main types of scalar objects in Python:
  • Integer (int)
  • Real number (float)
  • Boolean (bool)
  • Null value (None)

Scalar Types

• All scalar types are indivisible and immutable

type(7)

<class 'int'>

type(3.14)

<class 'float'>

type(True)

<class 'bool'>

# None is the only object of NoneType
type(None)

<class 'NoneType'>

int(3.14) 

3

str(42) 

'42'

Non-scalar Types

• Non-scalar objects are all types of sequences.
• This allows indexing, slicing and other interesting operations.
• Most common sequences in Python are:
  • String (str) - immutable ordered sequence of Unicode characters
  • Tuple (tuple) - immutable ordered sequence of elements
  • List (list) - mutable ordered sequence of elements
  • Set (set) - mutable unordered collection of unique elements
  • Dictionary (dict) - mutable unordered collection of key-value pairs

Indexing in Python Starts from 0

xkcd

Method Chaining

• Methods can be chained together to perform multiple operations on the same object.
• The output of one method becomes the input of the next method.

s

'time flies like a banana'

s.replace(' a ', ' an ').replace('banana', 'arrow').capitalize().split(sep = ' ')

['Time', 'flies', 'like', 'an', 'arrow']

s_as_l = (
  s
  .replace(' a ', ' an ')
  .replace('banana', 'arrow')
  .capitalize()
  .split(sep = ' ')
)
s_as_l

['Time', 'flies', 'like', 'an', 'arrow']

Indexing and Slicing Lists

• Indexing and slicing lists (and other ordered sequences) is similar to using seq() function in R.
• The general syntax for slicing in Python is seq[start:stop:step].
• Note that the stop index is not included in the slice.
• If start or stop are omitted, they default to the beginning and end of the sequence respectively.
• If step is omitted, it defaults to 1.

Indexing and Slicing Lists: Example

l

[0, 1, 1, 2]

# Subset all elements starting from 2nd
l[1:]

[1, 1, 2]

# Subset the last element
l[-1]

2

# Subset every second element,
# list[start:stop:step]
l[::2]

[0, 1]

# Subset all elements in reverse order
l[::-1] 

[2, 1, 1, 0]

Sets

o

{'apple', 'watermelon', 'banana'}

# Sets retain only unique values
{'apple', 'apple', 'banana', 'watermelon'}

{'apple', 'watermelon', 'banana'}

# Sets also have methods
o.difference({'banana'})

{'apple', 'watermelon'}

# Some methods can be expressed as operators
o - {'banana'}

{'apple', 'watermelon'}

# Sets can be compared (e.g. one being subset of another)
{'apple'} < o

True

# Unlike strings, tuples and lists, sets are unordered
o[1]

TypeError: 'set' object is not subscriptable

Conversion of Non-scalar Types

## Tuple
t

(0, 'one', 1, 2)

## Convert to list with a `list` function
list(t)

[0, 'one', 1, 2]

## Conversion to set retains only unique values
set([0, 1, 1, 2])

{0, 1, 2}

[x for x in t]

[0, 'one', 1, 2]

[x for x in t if type(x) != str]

[0, 1, 2]

None Value

• None is a Python null object.
• It is often used to initialize objects.
• And it is a return value in some functions (more on that later).

# Initialization of some temporary variable, which can re-assigned to another value later
none = None
none

# Here we are initializing a list of length 10
none_l = [None] * 10
none_l

[None, None, None, None, None, None, None, None, None, None]

# Note the difference with R's NA 
None == None

True

Aliasing vs Copying in Python

• Assignment binds the name on the left of = sign to the object on the right.
• But the same object can have different names (aliases).
• If the expression on the right is a name, the name on the left becomes an alias.
• In R (almost) all objects behave the same as the vast majority are immutable.
• In Python the object’s type determines its behavior.
• Specifically, operations on immutable types overwrite the object if it gets modified.
• But for mutable types the object is modified in place.

Copying - Immutable Types

• Recall copy-on-modify semantics from R.
• Immutable types in Python behave similarly.

x = 'test' # Object of type string is assigned to variable `x`
id(x) # Function `id` returns the memory address of the object

125181036706864

y = x # `y` is created an alias (alternative name) of `x`
id(y)

125181036706864

x = 'rest' # Another object of type string is assigned to `x`
x

'rest'

id(x)

125181045579328

y

'test'

id(y)

125181036706864

Copying - Mutable Types

• Mutable types in Python, however, behave differently.
• Changing the object modifies it in place without copying.

d

{'apple': 150.0, 'banana': 120.0, 'watermelon': 3000.0, 'strawberry': 12.0}

d1 = d # Just an alias
d2 = d.copy() # Create a copy

d1['watermelon'] = 500 # Modify original dictionary

d1

{'apple': 150.0, 'banana': 120.0, 'watermelon': 500, 'strawberry': 12.0}

d

{'apple': 150.0, 'banana': 120.0, 'watermelon': 500, 'strawberry': 12.0}

d2

{'apple': 150.0, 'banana': 120.0, 'watermelon': 3000.0, 'strawberry': 12.0}

Summary of Built-in Object Types

Help!

Python has an inbuilt help facility which provides more information about any object:

?s

invalid syntax (<string>, line 1)

help(s.join)

Help on built-in function join:

join(iterable, /) method of builtins.str instance
    Concatenate any number of strings.

    The string whose method is called is inserted in between each given string.
    The result is returned as a new string.

    Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'