Common Features of Sequences

1What is a sequence?

A sequence is a collection of items kept in order, one after another. That order is the whole point: the items have positions, and the positions never wander about on their own.

21 · len() — how many items?

len() is your third function. (A word, then parentheses — you know the drill.) Give it a sequence and it tells you how many items are inside: characters for a string, elements for a list or a tuple.

word = 'hello'
marks = [10, 4.5, 'hi']
point = (100, 4.25, 'hi')

print(len(word))
print(len(marks))
print(len(point))

5
3
3

32 · Indexing — reaching one item

Every item in a sequence has a position, also called its index. You reach an item by writing its index inside square brackets after the sequence.

And there are two kinds of index. Positive indexes count from the left and start at 0. Negative indexes count from the right and start at -1. Tap any letter below — it has both.

Indexing works the same way on all three sequence types:

word = 'PYTHON'
marks = [10, 4.5, 'hi']
point = (100, 4.25, 'hi')

print(word[0])
print(word[-1])
print(marks[1])
print(point[-1])

# you can index a value directly too, without a variable
print('PYTHON'[0])

P
N
4.5
hi
P

Sometimes the item you reach is itself a sequence — a list can hold another list, and that inner list can hold a string. Then you index again, with a second pair of brackets. And a third, if you want one character out of that string.

school = ['Class 11', ['Ravi', 'Meera', 'Amit'], 3]

print(school[1])          # a list lives at position 1
print(school[1][0])       # position 0 of THAT list — a string
print(school[1][0][0])    # position 0 of THAT string — one character
print(school[1][-1][-1])  # last name, last character

['Ravi', 'Meera', 'Amit']
Ravi
R
t

43 · Slicing — taking a piece

Indexing gives you one item. Slicing gives you a piece — several items at once. The full form has three parts, separated by colons:

Slicing is the process of getting a new sequence out of an existing one. For the rest of this section we will use one string, and both of its rulers:

s = 'good morning'

#    g  o  o  d     m  o  r  n  i  n  g
#    0  1  2  3  4  5  6  7  8  9 10 11
#  -12-11-10 -9 -8 -7 -6 -5 -4 -3 -2 -1

First, the step

You do not have to write all three parts. Settle the step first, because it is the easy one. If you do not write a step, Python uses 1.

So s[1:6] and s[1:6:1] mean the same thing. Any slice below with only two parts moves forwards, one item at a time.

start is included. stop is excluded.

This is the rule that costs marks every single year. In s[2:9:2], the walk starts at 2 and jumps in twos — 2, 4, 6, 8 — and it must stop before 9.

s = 'good morning'

print(s[2:9:2])

o on

s = 'good morning'

print(s[1:6])
print(s[1:7])

ood m
ood mo

A neat side effect (when the step is 1): stop − start is exactly how many items you get. [1:6] gives 6 − 1 = 5 characters. No counting on fingers.

What if you leave a part out?

Every part is optional. When you leave one out, Python fills it in for you. You already know the first rule: a missing step is 1.

That leaves the start and the stop. And here is the part most books skip: what Python fills in for those two depends on the direction of the step. So read the box that matches your step.

s = 'good morning'

print(s[1:6])     # step missing  -> same as s[1:6:1]
print(s[2::3])    # stop missing  -> same as s[2:len(s):3]
print(s[:6:2])    # start missing -> same as s[0:6:2]
print(s[:3:-2])   # start missing, step -ve -> same as s[-1:3:-2]
print(s[-2::-3])

ood m
omng
go 
girm
nr o

Because the stop is excluded — so the stop must land on a position that does not exist. Watch what goes wrong otherwise:

s = 'good morning'

# If the default stop were -1 (the LAST character) — the final 'g' is lost:
print(s[0:-1])

# If the default stop were 0 (the FIRST character) — the first 'g' is lost:
print(s[-1:0:-1])

good mornin
gninrom doo

Both are real positions, so excluding them chops a character off the end of your answer. Python instead stops at a position just past the edge — one that no character occupies — so nothing is lost.

Play with all three below. The panel shows you exactly what Python filled in for the parts you left blank — and the little numbers under the letters show the order it visits them in.

Why [::-1] reverses anything

This is the famous one, and it looks like a magic spell. It is not — you have already learnt every piece of it. Set the step to -1 in the widget above and read the “what Python fills in” panel.

In s[::-1] you gave Python only the step: -1, meaning walk backwards, one at a time. So it fills in the other two from the rules above:

The same reasoning is why the defaults must flip for a negative step. Starting at position 0 and walking backwards would fall off the front immediately, and you would get nothing at all:

s = 'good morning'
print(s[::-1])

# a slice does not need a variable — you can slice a value where it stands
print([1, 2, 3][::-1])
print((1, 2, 3)[::-1])

gninrom doog
[3, 2, 1]
(3, 2, 1)

And watch a slice go the wrong way and return nothing at all — no error, just an empty result. s[4:-2:-2] asks to start at 4 and walk backwards to position 10. You cannot walk backwards from 4 and arrive at 10, so Python hands back an empty string:

s = 'good morning'

nothing = s[4:-2:-2]

print(nothing)        # an empty line — there is nothing to show
print(len(nothing))   # and here is the proof

0

54 · Concatenation — joining with +

Concatenation means joining two sequences end to end with + to make one new sequence. You have already seen + add two numbers. On sequences it does something else entirely: it joins.

greeting = 'hi' + 'hello'
numbers = [2, 3, 4] + [7.5, -3, 'hello']
pairs = (20, 40) + ('hi', 'bye')

print(greeting)
print(numbers)
print(pairs)

hihello
[2, 3, 4, 7.5, -3, 'hello']
(20, 40, 'hi', 'bye')

65 · Replication — repeating with *

Replication (also called repetition) means repeating a sequence a given number of times, using * and a whole number. Again, a brand new sequence comes back.

chant = 'hi' * 3
numbers = [1, 2, 3] * 3

print(chant)
print(numbers)
print((1, 2, 'hi') * 2)

hihihi
[1, 2, 3, 1, 2, 3, 1, 2, 3]
(1, 2, 'hi', 1, 2, 'hi')

76 · Membership — in and not in

The last shared trick answers one question: is this thing inside that sequence? Write in between the two. The answer is always True or False. It does not tell you where the item is, only whether it is there.

word = 'hello'
marks = [10, 20, 30]
point = (100, 4.25, 'hi')

print('e' in word)
print('z' in word)
print(20 in marks)
print('hi' in point)

True
False
True
True

not in is its opposite, and it is two words, not not-in or notin. It gives True when the item is missing.

word = 'hello'
marks = [10, 20, 30]

print('z' not in word)
print('e' not in word)
print(50 not in marks)

True
False
True

The one place strings behave differently

On a list or a tuple, in checks whole items only. On a string it also finds a piece of the text, even part of a word. Compare these two carefully — this is the exam question.

word = 'hello'
words = ['hi', 'bye']

print('ell' in word)     # a piece of the text — found
print('hlo' in word)     # those letters are scattered
print('h' in words)      # the list holds 'hi' and 'bye', not 'h'
print(30 in [10, 20, 30])
print(3 in [10, 20, 30])

True
False
False
True
False

8Try all six at the prompt

9Recap