Python Lecture 11

Creative Commons License This work is licensed under a Creative Commons Attribution 4.0 International License. BS GIS Instructor: Inzamam Baig Lecture 11 Fundamentals of Programming

Tuples A tuple is a sequence of values much like a list The values stored in a tuple can be any type, and they are indexed by integers Tuples are immutable Tuples are also comparable and hashable

Defining a tuple >>> t = 'a', 'b', 'c', 'd', ‘e’ >>> t = ('a', 'b', 'c', 'd', 'e')

To create a tuple with a single element, you have to include the final comma: >>> t1 = ('a',) >>> type(t1) <type 'tuple'>

Without the comma Python treats ('a') as an expression with a string in parentheses that evaluates to a string: >>> t2 = ('a') >>> type(t2) <type 'str'>

>>> t = tuple() >>> print(t) ()

>>> t = tuple('lupins’) >>> print(t) ('l', 'u', 'p', 'i', 'n', 's')

The bracket operator indexes an element: >>> t = ('a', 'b', 'c', 'd', 'e') >>> print(t[0]) 'a' >>> print(t[1:3]) ('b', 'c')

If you try to modify one of the elements of the tuple, you get an error: >>> t[0] = 'A' TypeError: object doesn't support item assignment

You can’t modify the elements of a tuple, but you can replace one tuple with another: >>> t = ('A',) + t[1:] >>> print(t) ('A', 'b', 'c', 'd', 'e')

Comparing tuples Python starts by comparing the first element from each sequence If they are equal, it goes on to the next element, and so on, until it finds elements that differ

Comparing tuples >>> (0, 1, 2) < (0, 3, 4) True >>> (0, 1, 2000000) < (0, 3, 4) True

txt = 'but soft what light in yonder window breaks' words = txt.split() t = list() for word in words: t.append((len(word), word)) t.sort(reverse=True) res = list() for length, word in t: res.append(word) print(res)

Tuple assignment >>> m = [ 'have', 'fun' ] >>> x, y = m >>> x 'have' >>> y 'fun' >>>

Tuple assignment >>> m = [ 'have', 'fun' ] >>> x = m[0] >>> y = m[1] >>> x 'have' >>> y 'fun'

Tuple assignment >>> m = [ 'have', 'fun' ] >>> (x, y) = m >>> x 'have' >>> y 'fun'

Tuple unpacking >>> a, b = b, a Both sides of this statement are tuples, but the left side is a tuple of variables; the right side is a tuple of expressions

>>> a, b = 1, 2, 3 ValueError: too many values to unpack

>>> addr = 'monty@python.org' >>> uname, domain = addr.split('@’) The return value from split is a list with two elements; the first element is assigned to uname, the second to domain

DICTIONARIES AND TUPLES Dictionaries have a method called items that returns a list of tuples, where each tuple is a key-value pair >>> d = {'a':10, 'b':1, 'c':22} >>> t = list(d.items()) >>> print(t) [('b', 1), ('a', 10), ('c', 22)] the items are in no particular order

Converting a dictionary to a list of tuples is a way for us to output the contents of a dictionary sorted by key >>> d = {'a':10, 'b':1, 'c':22} >>> t = list(d.items()) >>> t [('b', 1), ('a', 10), ('c', 22)] >>> t.sort() >>> t [('a', 10), ('b', 1), ('c', 22)]

Multiple assignment with dictionaries for key, val in list(d.items()): print(val, key) This loop has two iteration variables because items returns a list of tuples and key, val is a tuple assignment that successively iterates through each of the key-value pairs in the dictionary

>>> d = {'a':10, 'b':1, 'c':22} >>> l = list() >>> for key, val in d.items() : ... l.append( (val, key) ) ... >>> l [(10, 'a'), (22, 'c'), (1, 'b')] >>> l.sort(reverse=True) >>> l [(22, 'c'), (10, 'a'), (1, 'b')]

import string fhand = open('romeo-full.txt') counts = dict() for line in fhand: line = line.translate(str.maketrans('', '', string.punctuation)) line = line.lower() words = line.split() for word in words: if word not in counts: counts[word] = 1 else: counts[word] += 1 lst = list() for key, val in list(counts.items()): lst.append((val, key)) lst.sort(reverse=True) for key, val in lst[:10]: print(key, val)

Sets A set is an unordered collection of items Every set element is unique (no duplicates) and must be immutable (cannot be changed) Sets are mutable Sets can also be used to perform mathematical set operations like union, intersection, symmetric difference

Defining a Set s1 = set() my_set = {1, 2, 3} print(my_set) my_set = {1.0, "Hello", (1, 2, 3)} print(my_set)

Duplicate Values set cannot have duplicates my_set = {1, 2, 3, 4, 3, 2} print(my_set) {1, 2, 3, 4} my_set = set([1, 2, 3, 2]) print(my_set) {1, 2, 3} set cannot have mutable items my_set = {1, 2, [3, 4]}

Distinguish set and dictionary while creating empty set a = {} print(type(a)) a = set() print(type(a))

Sets are unordered therefore indexing has no meaning my_set = {1, 3} my_set[0] TypeError: 'set' object is not subscriptable

Add my_set.add(2) print(my_set) {1, 2, 3}

Update my_set.update([2, 3, 4]) print(my_set) {1, 2, 3, 4} my_set.update([4, 5], {1, 6, 8}) print(my_set) {1, 2, 3, 4, 5, 6, 8}

Removing Elements my_set = {1, 3, 4, 5, 6} my_set.discard(4) print(my_set) {1, 3, 5, 6}

Removing Elements my_set.remove(6) print(my_set) {1, 3, 5}

discard an element my_set.discard(2) print(my_set) {1, 3, 5} my_set.remove(2) KeyError: 2

discard vs remove discard() function leaves a set unchanged if the element is not present in the set On the other hand, the remove() function will raise an error in such a condition (if element is not present in the set)

Removing Elements my_set = set("HelloWorld") print(my_set) pop random element print(my_set.pop()) print(my_set)

Since set is an unordered data type, there is no way of determining which item will be popped. It is completely arbitrary

IN Operator my_set = set("apple") print('a' in my_set) True print('p' not in my_set) False

Iterating over a set >>> for letter in set("apple"): ... print(letter) ... a p e l

Set Operations >>> A = {1, 2, 3, 4, 5} >>> B = {4, 5, 6, 7, 8}

Union is performed using | operator A = {1, 2, 3, 4, 5} B = {4, 5, 6, 7, 8} print(A | B) {1, 2, 3, 4, 5, 6, 7, 8}

>>> A.union(B) {1, 2, 3, 4, 5, 6, 7, 8} >>> B.union(A) {1, 2, 3, 4, 5, 6, 7, 8}

A = {1, 2, 3, 4, 5} B = {4, 5, 6, 7, 8} print(A & B) {4, 5}

>>> A.intersection(B) {4, 5} >>> B.intersection(A) {4, 5}

A = {1, 2, 3, 4, 5} B = {4, 5, 6, 7, 8} print(A - B) {1, 2, 3}

>>> A.difference(B) {1, 2, 3} >>> B.difference(A) {8, 6, 7}

A = {1, 2, 3, 4, 5} B = {4, 5, 6, 7, 8} print(A ^ B) {1, 2, 3, 6, 7, 8}

>>> A.symmetric_difference(B) {1, 2, 3, 6, 7, 8} >>> B.symmetric_difference(A) {1, 2, 3, 6, 7, 8}

Python Lecture 11

More Related Content

What's hot

Similar to Python Lecture 11

More from Inzamam Baig

Recently uploaded

Python Lecture 11

Editor's Notes