Containers

This is all one line.
This is a second.

The string class contains many useful methods for processing strings. (Methods being functions belonging to the class.) For example, strings can be split into a list using a delimiter. As it is a method, this functionality can be used in a couple of ways:

s = "A simple string to split."
delimiter = " " # What is used to split the String into parts
# Split by accessing the function and passing the string to be split as a parameter.
split0 = str.split(s, delimiter)
print(split0)
# Split by accessing the function from the string instance.
split1 = s.split(delimiter)
print(split1)

The two ways produce the same result. The delimeter is optional, by default it is any blank space (a continuous sequence of spaces, tabs and/or newlines).

Search and replace is a common string operation as is finding out if a string starts or ends with a particular string.

2.3. Tuples

a = () # A new empty tuple
print(len(a)) # <-- Prints 0
b = (1, "two", 4) # Pack 3 things into b
print(len(b)) # Prints 3
c, d, e = b # unpack b into three things (c will refer to 1, d to "two" and e to 4)
print(c) # <-- Prints 1
print(d) # <-- Prints 'two'
singleton = 'hello', # <-- Note the trailing comma.
print(len(singleton)) # Prints 1

Try the code yourself, then consider the following code snippet which generates part of a Fibonacci series of integer numbers:

# Fibonacci series - the sum of the last two numbers in a sequence defines the next
a, b = 0, 1
print(a)
while b < 10:
    print(b)
    a, b = b, a+b
print(b)

The while statement is a loop with an expression that is evaluated each time around the loop. While this expression 'b < 10' evaluates as 'True' the loop continues to run, when it evaluates as 'False', the program continues by executing the next line after the loop. Notice in the example how things are packed and unpacked in the tuples. Such packing/unpacking is is not common in other languages (currently).

2.4. Ranges

Ranges are a special type of immutable sequence created as follows:

range(start, stop, step) # start and step are optional and default to 0 and 1 repectively

The parameters: start, stop and step should be integers. The range function generates numbers up to but not including stop, for example:

for x in range(4):
    print(x)

Results in:

0
1
2
3

for x in range(2,8,2):
    print(x)

Results in:

2
4
6

for x in range(0,-5,-1)
    print(x)

Results in:

0
-1
-2
-3
-4

Try the code for yourself and then try to generate the following using range and a for loop:

-10
-5
0
5
10

A tuple can be constructed from a range or another sequence producer:

There are various built-in functions that process sequences, for example min will return the minimum value, max will return the minimum value, and sum will add up all the values in a sequence.

Additionally, there are a number of common sequence methods: The method 'index' will return the index of the first occurrence of an object equal to a given value. The method 'count' will return the number of occurrences instances of objects equal to a given value. For a sequence of boolean values ('True' or 'False') the method 'any' will return 'True' if any of the items in the sequence are 'True'.

a = (1, 6, 9, 0, 6)
print(min(a))
print(max(a))
print(sum(a))
print(a.index(6,0,4)) # Print the first index of item equal to 6 at or after index 0 and before index 4
print(a.count(6)) # Print the count of items equal to 6 in a.
b = (True, False)
print(any(b)) # Print if any of the items in b are True.

2.5. Lists

Lists are the mutable form of tuples. Lists have an order, different types of thing can be stored in them, things can be appended, inserted and removed from them. The elements within a list can be reordered and there are various methods that help with this.

Lists are initialised with square brackets or using the constructor that can take in some other container as an argument. For example:

a = [] # Create an empty list called a.
a.append("apple") # Append the String "apple" to the list a
print(len(a)) # Print the length of a
print(a[0]) # Print the first element of a
a.insert(0, 2) # Insert the Integer 2 into a at index 0
a.reverse() # Reverse the order of elements in a
del a[1] # Remove the element of a at index 1
a.remove('apple') # Remove the first occurance of 'apple' in the list
b = list((1, 2, 4, 8))
print(type(b))
print(b)

Run this code and check if the output is what you expect and then have a play around trying some different things.

A 'slice' of a sequence contains all those items at the indexes given by a range:

a = [0, 1, 2, 3, 4]
print("a", a)
i = 1
j = 3
b = a[i:j] # a between and including a[i] and a[j - 1]
print("b", b)
k = 2
c = a[i:j:k] # a between and including a[i] and a[j - 1], but stepping k indexes each time.
print("c", c)
d = a[:] # A complete slice i.e. all items of a
print("d", d)

In slicing a list a using a[i:j:k]:

• If j > len(a), the last position is used.
• If i is None or omitted, zero is used.
• If i > j, the slice is empty.

Negative indexes can be used:

• a[:2] # First two values.
• a[-2:] # Last two values.

Slices can be used with mutable sequences like lists for assignment. Consider the following example that replaces values from one list with the values from another:

a = [0,1,2,3,4]
b = [10,20,30]
a[1:3] = b
print(a) # <-- Prints [0,10,20,30,3,4]

Notice that the values '1' and '2' originally in index positions 1 and 2 of 'a' are replaced by the three values in 'b'. It is perhaps easier to thing of replacements as deletions and insertions.

The following example replaces 4 values with 2:

a = [0,1,2,3,4]
b = [10,20]
a[1:5] = b
print(a) # <-- Prints [0,10,20]

The builtin module function zip can be used to combine lists into a sequence of tuples as follows:

a = [1,2,3,4,5]
b = [10,20,30,40,50]
c = zip(a,b)
d = list(c)
print(d) # <-- Prints [(1,10),(2,20),(3,30),(4,40),(5,50)]

The zip function pairs up the values by index. If the sequences have different lengths then the paired up list is the length of the shorter sequence and does not contain the end of the longer sequence.

Command line arguments are passed in a list. For example, the following command passes the filename 'HelloWorld.py' to the Python interpreter which then loads the file of commands to execute:

python HelloWorld.py

More command line arguments can be passed, each one separated by a space.

The Python program receives the command line arguments as a list. The first item in the list is the program filename. For example, the following Python run command passes in four arguments:

python model.py arg1 arg2 arg3

Inside the program, these are made available in a list called 'sys.argv'. In the last example, sys.argv[0] is "model.py", sys.argv[1] is "arg1", sys.argv[2] is "arg2" and sys.argv[3] is "arg3".

2.6. Arrays

Arrays are for storing and processing large collections of things of the same type. Typically those things are numbers. An array is like a list but it cannot be used to store anything, it can only store things of a specific type.

The following creates an array containing signed Integers and inserts a new Integer value into the array. The attempts to insert a Float into the array which results in a TypeError:

import array
a = array.array('i', [1, 2, 3, 4])
print(a)
a.insert(2, 4)
print(a)
a.insert(2, 2.5)

3. Sets

Sets are unordered collections. Adding something into a set which already contains that thing will not change the set. It is easy to test whether or not something is in a set. The following code creates an empty set, adds some things into it and then tests if something is in the set.

a = set() # Empty set
a.add("apple") # Add "apple" to a
a.add("orange") # Add "orange" to a
if "orange" in a:
    print('"orange" is in a')

Traditional mathemetical set functions like union() and intersection() are available for sets which can also be compared. Two sets are equal if they contain all of the same elements.

4. Dictionaries

Dictionaries hold key-value pairs. The keys are unique, the values can be anything. Dictionaries can be created using curly braces and colons to separate the keys, which are given first, and the values, which are given second. Different pairs are separated with commas. Alternatively the dict() constructor method can be used. The following code creates a dictionary and retrieves a value for a particular key and prints it:

alias = dict([("rm", "remove"), ("cd", "change directory"), ("ls", "list")])
print(alias.get("rm")) # <-- This should print 'remove'.

There are functions that help with modifying and processing dictionaries.

Further reading

Python documentation tutorial about data structures.