Python - Sequence (type)

The following data structure are sequence:

3 - Comparison

Sequence objects may be compared to other objects with the same sequence type. The comparison uses lexicographical ordering: first the first two items are compared, and if they differ this determines the outcome of the comparison; if they are equal, the next two items are compared, and so on, until either sequence is exhausted. If two items to be compared are themselves sequences of the same type, the lexicographical comparison is carried out recursively. If all items of two sequences compare equal, the sequences are considered equal. If one sequence is an initial sub-sequence of the other, the shorter sequence is the smaller (lesser) one. Lexicographical ordering for strings uses the ASCII ordering for individual characters.

Example

```(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)```

4 - Packing

• Sequence packing: The values 12345, 54321 and 'hello!' are packed together in a tuple
`t = 12345, 54321, 'hello!' `
• Sequence unpacking: The reverse packing operation
`x, y, z = t`

Sequence unpacking works for any sequence on the right-hand side. Sequence unpacking requires the list of variables on the left to have the same number of elements as the length of the sequence.

Multiple assignment is really just a combination of tuple packing and sequence unpacking

5 - Modification while iterating

To change a sequence you are iterating over while inside the loop (for example to duplicate certain items), it is recommended to first make a copy. The slice notation makes this especially convenient:

```words = ['cat', 'window', 'defenestrate']
for w in words[:]:  # Loop over a slice copy of the entire list.
if len(w) > 6:
words.insert(0, w)

words```
`['defenestrate', 'cat', 'window', 'defenestrate']`

6 - Iteration

6.1 - Enumerate (index and value)

When looping through a sequence, the position index and corresponding value can be retrieved at the same time using the enumerate() function.

```for i, v in enumerate(['tic', 'tac', 'toe']):
print i, v```
```0 tic
1 tac
2 toe```

6.2 - over two or more sequences

To loop over two or more sequences at the same time, the entries can be paired with the zip() function.

```questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
print 'What is your {0}?  It is {1}.'.format(q, a)```
```What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.```

6.3 - in reverse order

To loop over a sequence in reverse, first specify the sequence in a forward direction and then call the reversed() function.

```for i in reversed(xrange(1,10,2)):
print i```
```9
7
5
3
1```

6.4 - in sorted order

To loop over a sequence in sorted order, use the sorted() function which returns a new sorted list while leaving the source unaltered.

```basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
print f```
```apple
banana
orange
pear```