strings

strings
definition

• an immutable (unchangeable) sequence of characters

• accessed by offset (position)
• its characters are "code point ordinals" in the
character set (characters are strings of length 1)
• written as a sequence of characters in quotes
• "python's string"
Some string constant escape codes
• 'python"s string' \t tab
• 'python\'s string' \n newline
\0 Null
• """this is a multi \\ backslash (\)
\' single quote
line string""" \" double quote
…
 strings

index/position

0 1 2 3 4 5 6 7 8 9 10

t h i s i s i t !

seq[1]
seq[-1]
seq[-2]
 strings

index/position

0 1 2 3 4 5 6 7 8 9 10

t h i s i s i t !

seq[1] # => 'h'

seq[-1] # => '!'
seq[-2] # => 't'
 strings

index/position

0 1 2 3 4 5 6 7 8 9 10

t h i s i s i t !

slice seq[1]
seq[-1]
seq[-2]
seq[0:3]
seq[3:]
seq[:5]
 strings

index/position

0 1 2 3 4 5 6 7 8 9 10

t h i s i s i t !

slice seq[1] # => 'h'

seq[-1] # => '!'
seq[-2] # => 't'
seq[0:3] # => 'thi'
seq[3:] # => 's is it!'
seq[:5] # => 'this '
 strings

index/position

0 1 2 3 4 5 6 7 8 9 10

t h i s i s i t !

slice seq[1] # => 'h'

seq[-1] # => '!'
seq[-2] # => 't'
seq[0:3] # => 'thi'
seq[3:] # => 's is it!'
seq[:5] # => 'this '
 sequence operations
strings, lists, tuples, bytes and bytearray

x in seq # => True /False

x not in seq # => True /False
seq1 + seq2 # concatenation
seq * num, num * seq # repetition
seq[i] # index
seq[i:j] # slice
len(seq) # length
min(seq) # minimum
max(seq) # maximum
iter(seq) # iteration
for x in seq: # iteration
[expr for x in seq] # iteration
 string methods

seq.capitalize() seq.isalpha() seq.ljust(width[, fillchar]) seq.rsplit(sep=None, maxsplit=-1)

seq.casefold() seq.isascii() seq.lower() seq.rstrip([chars])

seq.center(width [,fill]) seq.isdecimal() seq.lstrip([chars]) seq.split(sep=None, maxsplit=-1)

seq.count(sub [,start[, end]]) seq.isdigit() seq.maketrans(x[, y[, z]]) seq.splitlines(keepends=False)

seq.encode(encoding[, errors]) seq.isidentifier() seq.partition(sep) seq.startswith(prefix[, start[, end]])

seq.endswith(suffix [,start[, end]]) seq.islower() seq.removeprefix(prefix, /) seq.strip([chars])

seq.expandtabs([tabsize]) seq.isnumeric() seq.removesuffix(suffix, /) seq.swapcase()

seq.find(sub[, start[, end]]) seq.isprintable() seq.replace(old, new, count=-1) seq.title()

seq.format(*args, **kwargs) seq.isspace() seq.rfind(sub[, start[, end]]) seq.translate(table)

seq.format_map(mapping, /) seq.istitle() seq.rindex(sub[, start[, end]]) seq.upper()

seq.index(sub[, start[, end]]) seq.isupper() seq.rjust(width[, fillchar]) seq.zfill(width)

seq.isalnum() seq.join(iterable) seq.rpartition(sep)

format methods search methods split/join methods

in all calls that return a string result, the result is a new string (because strings are immutable)
 string methods
immutable

seq = "this is a test"

print(seq.title())
 string methods
immutable

seq = "this is a test"

print(seq.title())

'This Is A Test'
 string methods
immutable

seq = "this is a test"

print(seq.title())

'This Is A Test'

print(seq)
 string methods
immutable

seq = "this is a test"

print(seq.title())

'This Is A Test'

print(seq)

'this is a test'
 string methods
immutable

seq = "this is a test"

seq = seq.title()
print(seq)

'This Is A Test'
 strings
operations

• strings support all sequence operations, plus some

specific methods
• supports formatting % expressions
'_how_'.format(_variable_)
'%s is a sentence of %d
'%.2f'.format(s,dim,value)
lists
 lists
definition

• a mutable sequence of ordered elements

• accessed by offset (position)
• written as a sequence of comma-separated values,
enclosed in square brackets
• []
• [1, 4, -5, 8]
• ["dog", "cat", "horse"]
• [0, "home", 2.50]
• [12, ["a", "c", "g", "t"], ""]
 lists & strings

• similarity:
• sequences of elements and characters, same operators,
same access type (by index)

• differences:
• strings are sequences of characters (homogeneous),
lists are sequences of any type of elements
• lists are mutable, strings are immutable
 sequence operations
strings, lists, tuples, bytes and bytearray

x in seq # => True /False

x not in seq # => True /False
seq1 + seq2 # concatenation
seq * num, num * seq # repetition
seq[i] # index
seq[i:j] # slice
len(seq) # length
min(seq) # minimum
max(seq) # maximum
iter(seq) # iteration
for x in seq: # iteration
[expr for x in seq] # iteration
 mutable sequence operations
strings, lists, tuples, bytes and bytearray

seq[i] = el # index assignment: change item i

seq[i:j] = el # slice assignment
seq[i:j:k] = el # slice assignment, with stride k
del seq[i] # index deletion
del seq[i:j] # slice deletion
del seq[i:j:k] # slice deletion, with stride k
 list methods

lst.append(el) lst.count(el)

lst.extends(it) lst.remove(el) ***

lst.sort(key=None, reverse=False) lst.pop([pos])

lst.reverse() lst.clear()

lst.index(el[,i[,j]]) lst.copy()

lst.insert(pos, el)

all calls modify the list in-place

 list methods
immutable

lst = [1, 2, 3]
print(lst)
 list methods
immutable

lst = [1, 2, 3]
print(lst)

[1, 2, 3]
 list methods
immutable

lst = [1, 2, 3]
print(lst)

[1, 2, 3]

lstdup = lst.copy()
lst.append(6)
print(lst, lstdup)
 list methods
immutable

lst = [1, 2, 3]
print(lst)

[1, 2, 3]

lstdup = lst.copy()
lst.append(6)
print(lst, lstdup)
[1, 2, 3, 6] [1, 2, 3]
 list methods
immutable

lst = [1, 2, 3]
print(lst)

[1, 2, 3]

lstdupagain = lst
lst.append(6)
print(lst, lstdupagain)
 list methods
immutable

lst = [1, 2, 3]
print(lst)

[1, 2, 3]

lstdupagain = lst
lst.append(6)
print(lst, lstdupagain)
[1, 2, 3, 6] [1, 2, 3, 6]
 list of items from a string

seq = "this is a sentence"

words = seq.split(" ")

print(words)
 list of items from a string

seq = "this is a sentence"

words = seq.split(" ")

print(words)

['this', 'is', 'a', 'sentence']

 list of items from a string

seq = "1, 3, -3, 0, 4, 20, -1"

values = seq.split(",")
print(values)
 list of items from a string

seq = "1, 3, -3, 0, 4, 20, -1"

values = seq.split(",")
print(values)

['1', ' 3', ' -3', ' 0', ' 4', ' 20', ' -1']
 list of items from a string

seq = "1, 3, -3, 0, 4, 20, -1"

values_str = seq.split(",")
values_int = []
for val in values_str:
values_int.append(int(val))

print(values_int)
 list of items from a string

seq = "1, 3, -3, 0, 4, 20, -1"

values_str = seq.split(",")
values_int = []
for val in values_str:
values_int.append(int(val))

print(values_int)
[1, 3, -3, 0, 4, 20, -1]
 list of items from a string

seq = "1, 3, -3, 0, 4, 20, -1"

values_str = seq.split(",")
values_int = [int(val) for val in values_str]

print(values_int)
 list of items from a string

seq = "1, 3, -3, 0, 4, 20, -1"

values_str = seq.split(",")
values_int = [int(val) for val in values_str]

print(values_int)
[1, 3, -3, 0, 4, 20, -1]
 string <-> lists

seq = "this is a string"

lst = list(seq)

print(lst)
 string <-> lists

seq = "this is a string"

lst = list(seq)

print(lst)
['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ',
's', 't', 'r', 'i', 'n', 'g']
 string <-> lists

lst = [1, 2, 3, 4]
lststr = [str(x) for x in lst]

print(lststr)
 string <-> lists

lst = [1, 2, 3, 4]
lststr = [str(x) for x in lst]

print(lststr)
['1', '2', '3', '4']
 string <-> lists

lst = [1, 2, 3, 4]
lststr = [str(x) for x in lst]

print(lststr)
['1', '2', '3', '4']

seq = "".join(lststr)
print(seq)
 string <-> lists

lst = [1, 2, 3, 4]
lststr = [str(elem) for elem in lst]

print(lststr)
['1', '2', '3', '4']

seq = "".join(lststr)
print(seq)
'1234'
 string <-> lists

lst = [1, 2, 3, 4]
lststr = [str(elem) for elem in lst]

print(lststr)
['1', '2', '3', '4']

seq = "".join(lststr)
print(seq)
'1234' seq = "".join(str(elem) for elem in lst]
dictionaries
 dictionary
definition

• mutable (changeable) mapping of elements

• accessed by key (not position)
• unordered tables that map keys to values
• keys: immutable type
• values: any type
• Examples:
• empty dictionary: {}
• DNACOMP = {'A':'T', 'C':'G', 'G':'C', 'T':'A'}
• basefreq = {'A': 6, 'C': 2, 'G': 4, 'T': 6}
• info = {'fname':['mary', 'jane'], 'lname': ['white']}
 dictionary operations

d[k] # retrieves element by key k

d[k] = x # creates or updates element for key k
del d[k] # removes element by key
len(d) # number of keys
k in d # => True /False
k not in d # => True /False
iter(d) # iteration
for k in d: # iteration
 dictionary methods

d.keys() d.get(k[, default])

d.values() d.setdefault(k, [, default])

d.items() d.popitem()

d.clear() d.pop(k [, default]) ***

d.copy()

d.update(dx) k in d

for k in d

all calls modify the list in-place

 dictionary
example

H2B = {"0": "0000", "1": "0001", "2": "0010", "3":

"0011", "4": "0100", "5": "0101", "6": "0110", "7":
"0111", "8": "1000", "9": "1001", "A": "1010", "B":
"1011", "C": "1100", "D": "1101", "E": "1110", "F":
"1111"}