Bytes
- Immutable sequence of bytes.
Lists
- Mutable sequences of objects.
- e.g a = [1, 2, 3 ,4]
- Get or set value using index
- e.g a[1] = 20 and print(a[1])
- Negative integers index from the end.
- The last element is at index -1
- Slicing extracts part of a list.
- Slice = seq[start:stop]
- Slice range is half open-stop not included.
- >>> s = [1, 2, 3, 4, 5, 6]
- >>> s[1:4]
- 2, 3, 4
- Slicing works with negative indexes.
- >>> s[1:-1]
- 2, 3, 4, 5
- Omitting the stop index slices to the end.
- Slice_to_end = seq[start:]
- Omitting the start index slices from the beginning.
- Slice_from_beginning = seq[:stop]
- Half open ranges give complementary.
- slices S[:x] + s[x:] == s
- Omitting the start and stop indexes slices from beginning to the end – a full slice.
- Full_slice = seq[:]
- Important idiom for copying lists:
- Copy list using
- Copy() method
- U = seq.copy()
- List() constructor
- V = list(seq)
- All of these techniques create shallow copies, mean create new list containing same object reference to source list.
Shallow copies: Examples
- >>> A = [[1, 2], [3, 4]]
- >>> B = A[:] (copy using full slice)
- >>> A is B (both objects have different identities.)
- False
- >>> A == B
- True
- >>> A[0]
- [1, 2]
- >>> B[0]
- [1, 2]
- A[0] is B[0] (both objects have same identities.)
- True
- >>> A[0] = [8, 9] (This create a new list and set reference of A[0] to this.)
- >>> A[0]
- [8, 9]
- >>> B[0] (B[0] is unchanged because it has reference to old list.)
- [1, 2]
- >>> A[1].append(5) (A[1] and B[1] still have reference to same list. So changes reflects in both places.)
- >>> A[1]
- [3, 4, 5]
- >>> B[1]
- [3, 4, 5]
- >>> A (Now both lists look like this)
- [[8, 9], [3, 4, 5]]
- >>> B
- [[1, 2], [3, 4, 5]]
- Repeat lists using the * operator.
- Most often used for initializing a list of known size with a constant.
- S = [constant] * size
- Multiple references to one instance of the constant in the produced list.
- Repetition is shallow.
- >>> S = [[1, 2]] * 5
- [[1, 2], [1, 2], [1, 2], [1, 2], [1, 2]]
- >>> S[3].append(7)
- >>> S
- [[1, 2, 7], [1, 2, 7], [1, 2, 7], [1, 2, 7], [1, 2, 7]]
- Index(item) returns the integer index of the first equivalent element raises value error if not found.
- I = w.index(‘the’)
- Count(item) returns the number of matching elements.
- W.count(‘the’)
- The in and not in operators test for membership.
- 5 in [1, 2, 3]
- 5 not in [1, 2, 3]
- Del seq[index] to remove by index.
- Seq.remove(item) to remove by value. Raises value error if not found.
- Insert items with seq.insert(index, item)
- Concatenate lists with + operator
- >>> M = [1, 2]
- >>> N = [3, 4]
- >>> K = m + n
- >>> k
- [1, 2, 3, 4]
- In-place extension with += operator or extend method.
- >>> K += [6, 7]
- >>> K
- [1, 2, 3, 4, 6, 7]
- >>> K.entend([11, 12])
- >>> K
- [1, 2, 3, 4, 6, 7, 11, 12]
- K.reverse() reverses in place.
- K.sort() sorts in place.
- K.sort(reverse=true) gives descending sort.
Dictionaries
- Unordered mapping from unique, immutable keys to mutable values.
- Recap literals:
- Delimited by { and }
- Key-value pairs comma separated
- Corresponding keys and values joined by colon.
- Keys must be unique
- Urls = {'google':'http://google.com', 'microsoft':'http://Microsoft.com' }
- >>> url['google']
- http://google.com
- Dict() constructor accepts:
- Iterable series of key-value 2-tuples.
- >>> Names_and_ages = [('Alice', 32), ('Bob', 48)]
- >>> d = dict(Names_and_ages)
- >>> d
- {'Alice':32, 'Bob':48}
- Keyword arguments-requires keys are valid python identifiers.
- A mapping, such as another dict.
- >>> Phonetic = dict(a='alfa', b='bravo')
- >>> phonetic
- {'a':'alfa', 'b':'bravo'}
- d.copy() for copying dictionaries.
- >>> e = d.copy()
- >>> e
- {'Alice':32, 'Bob':48}
- Or simply dict(d) constructor
- >>> f = dict(e)
- >>> f
- {'Alice':32, 'Bob':48}
- Extend a dictionary with update()
- >>> g = dict('c':'charle', 'f':'fort')
- >>> f.update(g)
- >>> f
- {'a':'alfa', 'b':'bravo', 'c':'charle', 'f':'fort'}
- Update replaces values corresponding to duplicate keys.
- Iteration is over keys.
- Get corresponding value with d[key] lookup.
- >>> for key in f:
- print("{key} => {value}".format(key= key, value=f[key]))
- Use values() for an iterable view onto the series of values
- No efficient way to get the key corresponding to a value.
- >>> for value in f.values():
- print(value)
- Keys() method gives iterable view onto keys – not often needed.
- >>> for key in f.keys():
- print(key)
- Use items for an iterable view onto the series of key-value tuples.
- Use with tuple unpacking.
- >>> for key, value in f.items():
- print("{key} => {value}".format(key=key, value=value))
- The in and not in operators work on the keys.
- >>> 'a' in f
- >>> 'h' in f
- Use del keyword to remove by key. del d[key]
- >>> del f['a']
- Keys must be immutable.
- Values may be mutable.
- The dictionary itself is mutable.
