Summer of code 2017: Python, Day 29 Else after For and While loops

As explained in my Summer of code 2017: Python post I decided to pick up Python

This is officially day 29. today I decided to take a look at how an Else block works with For and While loops in Python. This is not how you would expect it to work if you are coming to Python from another language.


Take a look at the following code

for i in range(5):
    print(i)
else:
    print('else')

What do you think will happen? Will the else part be printed?

Let's run it

    >>> for i in range(5):
...     print(i)
... else:
...     print('else')
... 
0
1
2
3
4
else
>>> 

So after the for loop finished, the else block gets executed. To me that was very surprising, I had not expected this.


What will happen if we put a break in the loop, now the code looks like this

for i in range(5):
    print(i)
    if i == 2:
        break
else:
    print('else')

What do you think happens now? Let's executed it

>>> for i in range(5):
...     print(i)
...     if i == 2:
...         break
... else:
...     print('else')
... 
0
1
2
>>> 

Interestingly the else block did not get executed, this is because the else will only execute if the loop completed

From the docs(I have made the relevant part bold)

The for statement is used to iterate over the elements of a sequence (such as a string, tuple or list) or other iterable object:
for_stmt ::= "for" target_list "in" expression_list ":" suite ["else" ":" suite]
The expression list is evaluated once; it should yield an iterable object. An iterator is created for the result of the expression_list. The suite is then executed once for each item provided by the iterator, in the order of ascending indices. Each item in turn is assigned to the target list using the standard rules for assignments, and then the suite is executed.

When the items are exhausted (which is immediately when the sequence is empty), the suite in the else clause, if present, is executed, and the loop terminates.
A break statement executed in the first suite terminates the loop without executing the else clause's suite. A continue statement executed in the first suite skips the rest of the suite and continues with the next item, or with the else clause if there was no next item.

Let's look at what happens when the sequence is empty now

>>> for i in []:
...     print(i)
... else:
...     print('else')
... 
else
>>> 

As you can see the else block get executed

If you have a while loop that is initially false, the else block will also get executed

>>> while False:
...     print('it is false')
... else:
...     print('else')
... 
else
>>> 

So why does Python have this? One way is to know that you have executed the loop all the way to the end of the loop without having run a break statement.

Take a look at this silly example

>>> x = 10
>>> for i in range(5):
...     if i == x:
...         print('x found')
...         break
... else:
...     print('x not found')
... 
x not found
>>> 

As you can see the else block is executed and we can see that x was not found. Now normally you would store the state in a variable or you would have a helper function that would return false instead.

So that is all for today. Next up is unit testing in Python

Summer of code 2017: Python, Day 23 Files

As explained in my Summer of code 2017: Python post I decided to pick up Python

This is officially day 23. today I will take a look at files

First lets take a look at the open() function, you need to pass in the path, everything else is optional

You should always pass in the mode for clarity

Here are all the open() modes

Character	Meaning
'r'	open for reading (default)
'w'	open for writing, truncating the file first
'x'	open for exclusive creation, failing if the file already exists
'a'	open for writing, appending to the end of the file if it exists
'b'	binary mode
't'	text mode (default)
'+'	open a disk file for updating (reading and writing)
'U'	universal newlines mode (deprecated)

Writing to a file in Python

Here is an example of how to write to a file

f = open('boo.txt', mode ='wt', encoding='utf=8')
f.write('the first line')
f.write('line 2\n')
f.write('line 3')
f.write('line 4')
f.close()

Here is what the file looks like after running the example above

As you can see if you don't supply line breaks, there won't be any line breaks in the file, this is why there is only 1 line break in the file

If you run the same example again, the same exact file will be created, this is because mode w will truncate the file first

If you change the mode from wt to at, then the text will be appended

f = open('boo.txt', mode ='at', encoding='utf=8')
f.write('the first line')
f.write('line 2\n')
f.write('line 3')
f.write('line 4')

Reading a file in Python

Reading files is similar to writing files, you still use open and specify mode and encoding
To read the first 10 characters, you can specify read(10)
If you want to read the whole file, you can just specify read(), if you specify read() again, you will get back an empty string. To start reading from the beginning again, you can use seek(0)
To read a line at a time, use readline()

Here is how all this above looks inside the REPL

>>> f = open('boo.txt', mode ='rt', encoding='utf=8')
>>> f.read(10)
'the first '
>>> f.read()
'lineline 2\nline 3line 4the first lineline 2\nline 3line 4the first lineline 2\nline 3line 4'
>>> f.read()
''
>>> f.seek(0)
0
>>> f.readline()
'the first lineline 2\n'
>>> f.readline()
'line 3line 4the first lineline 2\n'
>>> f.readline()
'line 3line 4the first lineline 2\n'
>>> f.readline()
'line 3line 4'
>>> f.readline()
'' 

That is all for today,  short and sweet....

Summer of code 2017: Python, Day 20 Classes

As explained in my Summer of code 2017: Python post I decided to pick up Python

This is officially day 20. today I will take a look at classes

All types in Python have a class
Class instances are created by calling the class as if it were a function

Here is the simplest form of a class

class Test:
    """description of class"""
 
   
 
    def val(self, val):
        return val

If we now instantiate the class and pass in the string "denis' to the val method, the string is returned

>>> f = Test()
>>> print(f.val("denis"))
denis
>>> 

In Python self is similar to this in Java or c#

Implementation details are denoted by a leading underscore, in Python there are no public, protected or private access modifiers like in Java or c#

Here is an example of the class where we added __init__ and we are also returning _val instead of val

class Test:
    """description of class"""
 
    def __init__(self, val):
        self._val = val
 
    def val(self):
        return self._val

Here is what the output looks like now

>>> f = Test("denis")
>>> print(f.val())
denis
>>> f = Test("yo")
>>> print(f.val())
yo
>>> 

As you can see it is all pretty simple stuff at this point

To do inheritance, you add the base class name in parentheses after the class name. So if a class SomeTest inherits from Test, you would specify it like this:  class SomeTest(Test)

Here is what the code looks like for both classes

class Test:
    """description of class"""
 
    def __init__(self, val):
        self._val = val
 
    def val(self):
        return self._val
 
 
class SomeTest(Test):
    """description of class"""
 
 
    def someVal(self):
        return self._val

Now we can call both the val and someVal methods from the SomeTest class because the val method exists in the test class from which the SomeTest class inherits

Here is the output

>>> f = Test("yo")
>>> print(f.val())
yo
>>> g = SomeTest("Den")
>>> print(g.val())
Den
>>> print(g.someVal())
Den
>>> 

I am sure I will be revisiting and adding to my notes when I start messing around with classes more

That is it.. a short post for a short Holiday week in the US

Summer of code 2017: Python, Day 18 Iterables

As explained in my Summer of code 2017: Python post I decided to pick up Python

This is officially day 18. today I will take a look at iterables


Comprehensions

A comprehension is a list, a set or a dictionary that is computed via a set of looping and filtering instructions. The comprehension consists of a single expression followed by at least one for clause and zero or more for or if clauses

List Comprehensions

The basic syntax for list comprehensions looks like this

[expr(item) for item in iterable]

Here is an example in code, the code below returns the length for each item in the list

>>> words= "A comprehension is a list, a set or a dictionary that is computed via a set
 of looping and filtering instructions".split()
>>> words
['A', 'comprehension', 'is', 'a', 'list,', 'a', 'set', 'or', 'a', 'dictionary', 'that',
 'is', 'computed', 'via', 'a', 'set', 'of', 'looping', 'and', 'filtering', 'instructions']
>>> [len(word) for word in words]
[1, 13, 2, 1, 5, 1, 3, 2, 1, 10, 4, 2, 8, 3, 1, 3, 2, 7, 3, 9, 12]
>>> 

Pretty simple stuff, nothing too complicated here


Set Comprehensions

The basic syntax for set comprehensions looks like this

{expr(item) for item in iterable}

Here is an example in code, the code below returns the length as well as the max character for each item of the set

>>> x = {'abc','def','vvv','nnn'}
>>> type(x)
<class 'set'>
>>> {len(str(x)) for x in x}
{3}
>>> {max(str(x)) for x in x}
{'f', 'v', 'n', 'c'}
>>> 

As you can see the set is distinct, the number 3 is only returned once. Also the set is unordered



Dictionary Comprehensions


The basic syntax for dictionary comprehensions looks like this

{ key_expr:value_expr  for item in iterable }

Here is an example in code, the code below will swap the key value pair

>>> stocks ={
'TGT' :  '51.33', 
'AAPL': '147.48',
'MSFT':  '71.49',
'F'   :  '11.12', 
'INTC':  '34.37'}
>>> stocks
{'TGT': '51.33', 'AAPL': '147.48', 'MSFT': '71.49', 'F': '11.12', 'INTC': '34.37'}
>>> price_to_stock = {ticker: price for price, ticker in stocks.items()}
>>> price_to_stock
{'51.33': 'TGT', '147.48': 'AAPL', '71.49': 'MSFT', '11.12': 'F', '34.37': 'INTC'}
>>> 

We can make it more interesting by using a condition and only return the key value pair if the price is the max price for that ticker. I added a price of 1000 for AAPL and a price of 5000 for F. As you can see in the code below, I have used a filtering predicate if max(price)

>>> stocks ={
'TGT' :  '51.33', 
'AAPL': '147.48',
'AAPL': '1000',
'MSFT':  '71.49',
'F'   :  '11.12', 
'F'   :  '5000',
'INTC':  '34.37'}
>>> price_to_stock = {price: ticker for ticker, price in stocks.items() if max(price)}
>>> price_to_stock
{'51.33': 'TGT', '1000': 'AAPL', '71.49': 'MSFT', '5000': 'F', '34.37': 'INTC'}
>>> 

As you can see for Apple (AAPL), we return the pair with the price of 1000, for F (Ford), we return the pair with the price of 5000, the other prices for AAPL and F are not returned

Generators

Iterator

An object representing a stream of data. Repeated calls to the iterator’s __next__() method (or passing it to the built-in function next()) return successive items in the stream.

>>> i = ['a', 'b', 'c', 'd' ]
>>> iterator =iter(i)
>>> next(iterator)
'a'
>>> next(iterator)
'b'
>>> next(iterator)
'c'
>>> 

When no more data is available a StopIteration exception is raised instead. At this point, the iterator object is exhausted and any further calls to its __next__() method just raise StopIteration again.

Here is what that looks like

>>> next(iterator)
'd'
>>> next(iterator)
Traceback (most recent call last):
  File "", line 1, in 
    next(iterator)
StopIteration
>>> 

We can trap this by checking for the StopIteration exception, here is an example

>>> try:
 next(iterator)
except(StopIteration):
    print ('max value reached')

    
max value reached
>>> 

I also looked at itertools, itertools  implements a number of iterator building blocks inspired by constructs from APL, Haskell, and SML. Each has been recast in a form suitable for Python.

Here are some of these iterators

count()

cycle()

repeat()

accumulate()

chain()

chain.from_iterable()

compress()

dropwhile()

filterfalse()

groupby()

islice()

starmap()

takewhile()

tee()

zip_longest()

That was all for today, next I will look at classes

Summer of code 2017: Python, Day 16 Exceptions

As explained in my Summer of code 2017: Python post I decided to pick up Python

This is officially day 16. I took a couple of days off but today I looked at exceptions in Python, here are my notes


A couple of things to keep in mind when getting into exceptions

• You can raise an exception to interrupt the flow of your program
• You can handle an exception to resume control instead of the program being terminated
• If you do not handle exceptions, unhandled exceptions will terminate the program.
• Information about exception events will be contained in exception objects

Here is a simple function that converts an input to an integer, there is no exception handling done

>>> def converter(s):


    x = int(s)
    return x


>>> converter("33")
33
>>> converter("A")
Traceback (most recent call last):
  File "", line 1, in 
    converter("A")
  File "", line 4, in converter
    x = int(s)
ValueError: invalid literal for int() with base 10: 'A'
>>> 

As you can see it blows up with a ValueError exception

To catch an exception, you wrap a try except block around your statements, here is an example

>>> def converter(s):
 try:
  x = int(s)
 except ValueError:
  x = -1
 return x

>>> converter("33")
33
>>> converter("A")
-1
>>> 

As you can see no exceptions are displayed

You can also check for more than one exceptions like shown in the code below

>>> def converter(s):
    '''Convert to an integer.'''
    x = -1
    try:
        x = int(s)
        print("Conversion successful! x =", x)
    except ValueError:
        print("Conversion doomed!")
    except TypeError:
        print("Conversion doomed!")
    return x

>>> converter(33)
Conversion succesful! x = 33
33
>>> converter("a")
Conversion doomed!
-1
>>> converter(1.5555555)
Conversion succesful! x = 1
1
>>> converter([1,2])
Conversion doomed!
-1
>>>

We can simplify the code above by combining two exceptions into one check, you can see that in the code below

>>> 
def converter(s):
    '''Convert to an integer.'''
    x = -1
    try:
        x = int(s)
        print("Conversion successful! x =", x)
    except (ValueError, TypeError):
        print("Conversion doomed!")
    return x

>>> converter(33)
Conversion succesful! x = 33
33
>>> converter("a")
Conversion doomed!
-1
>>> converter([1,2])
Conversion doomed!
-1
>>> 

You need to have a statement after except, if you were to do the following, you will get a syntax error

>>> def converter(s):
    '''Convert to an integer.'''
    x = -1
    try:
        x = int(s)
        print("Conversion succesful! x =", x)
    except (ValueError, TypeError):
    return x
SyntaxError: expected an indented block

In Python to deal with a need for placeholder statement a pass statement can be used. Pass is a null operation, when it is executed, nothing happens. It is useful as a placeholder when a statement is required syntactically, but no code needs to be executed, for example:

>>> def converter(s):
    '''Convert to an integer.'''
    x = -1
    try:
        x = int(s)
        print("Conversion succesful! x =", x)
    except (ValueError, TypeError):
        pass
    return x

>>> 

These 3 errors should be handled during development and not at runtime

• IndentationError
• SyntaxError
• NameError

If we want to print the exception that has been caught, you can assign it to a variable

Here is an example, e will hold the exception and then a print with a conversion to a string and format is used to print the exception to the console

>>> def converter(s):
    '''Convert to an integer.'''
    x = -1
    try:
        x = int(s)
        print("Conversion succesful! x =", x)
    except (ValueError, TypeError) as e:
        print("Conversion error: {}"\
        .format(str(e)),
        file=sys.stderr)
    return x

>>> import sys
>>> converter(10)
Conversion succesful! x = 10
10
>>> converter('a')
Conversion error: invalid literal for int() with base 10: 'a'
-1
>>> converter([1,2])
Conversion error: int() argument must be a string, a bytes-like object or a number, not 'list'
-1
>>> 

If you want to print the statement to the console but also raise the exception, you can use raise. Raise re-raises the last exception that was active in the current scope. Here is an example

def converter(s):
    '''Convert to an integer.'''
    x = -1
    try:
        x = int(s)
        print("Conversion succesful! x =", x)
    except (ValueError, TypeError) as e:
        print("Conversion error: {}"\
        .format(str(e)),
        file=sys.stderr)
        raise
    return x

>>> import sys
>>> converter(1)
Conversion succesful! x = 1
1
>>> converter('a')
Conversion error: invalid literal for int() with base 10: 'a'
Traceback (most recent call last):
  File "", line 1, in 
    converter('a')
  File "", line 5, in converter
    x = int(s)
ValueError: invalid literal for int() with base 10: 'a'
>>> 

If you have code that you want to run no matter what happens for example to 'cleanup' anything, you can use the finally keyword. Keep in mind that if you have multiple return statements, the one on the finally block is the one that will be returned.

Here is an example

>>> def foo():
 try:
  return 'trying...'
 finally:
  return 'finally'

 
>>> foo()
'finally'

That is all for today, I will continue with iterables next

Summer of code 2017: Python, Day 9 Collections: list, dictionary and set

As explained in my Summer of code 2017: Python post I decided to pick up Python

This is officially day 9, today, I looked at Collections in Python, here are my notes

Lists

Lists are mutable sequences, typically used to store collections of homogeneous items

Lists may be constructed in several ways:

• Using a pair of square brackets to denote the empty list: [] 
• Using square brackets, separating items with commas: [a], [a, b, c] 
• Using a list comprehension: [x for x in iterable] 
• Using the type constructor: list() or list(iterable) 

Lists implement all of the common and mutable sequence operations. Lists also provide the following additional method: sort

Here is what a list looks like in Python before and after the sort method is called

>>> a = [ [2],[4], [1]]
>>> a
[[2], [4], [1]]
>>> a.sort()
>>> a
[[1], [2], [4]]
>>> 

I also played around with making copies of lists

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

>>> a = [[1], [2], [4]] >>> a [[1], [2], [4]] >>> b =a[0:1] >>> b [[1]] >>> b =a[0:2] >>> b [[1], [2]] >>> b=a[:] >>> b [[1], [2], [4]] >>> a is b False >>> a == b True >>> a[0] [1] >>> b[0] [1] >>> a[0] is b[0] True >>> a[2].append(9) >>> a [[1], [2], [4, 9]] >>> b [[1], [2], [4, 9]] >>>

Here is what is going on (I added line numbers so it is easier to look at the code)
On line 1 made a new list a
On line 5 I made a list b with 1 element of list a
On line 9 I made list b have the first 2 elements of list a
On line 13 I made list be be a copy of list a by supplying just the colon
On line 17 you will see that list a and b are not the same, on line 29 you will see that the first element of both lists are the same
If I now append 9 to the 3 rd element of the list, you will see that both list a and b now have the same 3rd element. The reason for this is that the copies are shallow


I decided to try some more things, this time I created a list of words

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

>>> l ="SpaceX successfully launches and recovers second Falcon 9 in 48 hours".split() >>> l ['SpaceX', 'successfully', 'launches', 'and', 'recovers', 'second', 'Falcon', '9', 'in', '48', 'hours'] >>> i=l.index('Falcon') >>> i 6 >>> 'launches' in l True >>> l.reverse() >>> l ['hours', '48', 'in', '9', 'Falcon', 'second', 'recovers', 'and', 'launches', 'successfully', 'SpaceX'] >>> l.sort() >>> l ['48', '9', 'Falcon', 'SpaceX', 'and', 'hours', 'in', 'launches', 'recovers', 'second', 'successfully'] >>> l.sort(reverse=True) >>> l ['successfully', 'second', 'recovers', 'launches', 'in', 'hours', 'and', 'SpaceX', 'Falcon', '9', '48'] >>>

On line 1 I created a list by using the split method on a function
On line 6 I am grabbing the index of the item with the value Falcon
On line 10 I am checking if the value launches is part of this list
On line 13 I am reversing the list
On Line 18 I am sorting the list
On Line 23 I am sorting the list in reversed order

Make sure to type True and not true, otherwise you will get the error NameError: name 'true' is not defined
Here is what the error looks like in the console

>>> l.sort(reverse=true)
Traceback (most recent call last):
  File "", line 1, in 
    l.sort(reverse=true)
NameError: name 'true' is not defined

I then decided to play around with deleting items from the list

1 2 3 4 5 6 7 8 9 10 11

>>> l ="SpaceX successfully launches and recovers second Falcon 9 in 48 hours".split() >>> l ['SpaceX', 'successfully', 'launches', 'and', 'recovers', 'second', 'Falcon', '9', 'in', '48', 'hours'] >>> del l[1] >>> l ['SpaceX', 'launches', 'and', 'recovers', 'second', 'Falcon', '9', 'in', '48', 'hours'] >>> l.remove('recovers') >>> l ['SpaceX', 'launches', 'and', 'second', 'Falcon', '9', 'in', '48', 'hours']

On line 5 I deleted an item by supplying the index
On line 9 I removed an item by supplying the value

What would happen if the same value is more than once in the list and I removed it by supplying the value?
Let's take a look

1 2 3 4 5 6 7 8 9 10 11

>>> x = ['and', 'and', 'and','boo'] >>> x ['and', 'and', 'and', 'boo'] >>> x.count('and') 3 >>> x.remove('and') >>> x ['and', 'and', 'boo'] >>> x.count('and') 2 >>>

On line 1 I created a list with a value of and 3 times
On line 4 we count this value and it returns 3
On line 6 we call the remove method
On line 9 we call count again and the count is now 2, only 1 item got removed.

Here is what the docs have to say

s.remove(x)
remove the first item from s where s[i] == x

As you can see, only the first item will be removed, not all of them with that value


You can grab the last element of a list by using -1

1 2 3 4 5 6 7 8 9 10

>>> l ="SpaceX successfully launches and recovers second Falcon 9 in 48 hours".split() >>> l ['SpaceX', 'successfully', 'launches', 'and', 'recovers', 'second', 'Falcon', '9', 'in', '48', 'hours'] >>> l[0] 'SpaceX' >>> l[-1] 'hours' >>>

As you can see, on line 8 we use [-1] and the last element from the list is returned

To insert an item into a list at a specific place, you can use insert

1 2 3 4 5 6 7 8 9

>>> l ="SpaceX successfully and recovers second Falcon 9 in 48 hours".split() >>> l ['SpaceX', 'successfully', 'and', 'recovers', 'second', 'Falcon', '9', 'in', '48', 'hours'] >>> l.insert(2, 'launches') >>> l ['SpaceX', 'successfully', 'launches', 'and', 'recovers', 'second', 'Falcon', '9', 'in', '48', 'hours'] >>>

As you can see from line 5, we are inserting the value launches as the 3rd item (0 based, so index =2). now the whole list makes sense again

Dict

I also took a look at dictionaries/dicts, a dict in other languages is an associative array. Most likely you will think of dicts as key value pairs

Let's take a look what it looks like, I created a dictionary of stocks with tickers and prices

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

>>> stocks ={ 'TGT' : '51.33', 'AAPL': '147.48', 'MSFT': '71.49', 'F' : '11.12', 'INTC': '34.37'} >>> stocks {'TGT': '51.33', 'AAPL': '147.48', 'MSFT': '71.49', 'F': '11.12', 'INTC': '34.37'} >>> stocks['AAPL'] '147.48' >>> stocks.update({'AAPL': '147.25', 'MSFT': '71.45'}) >>> stocks['AAPL'] '147.25' >>> stocks['MSFT'] '71.45' >>>

On lines 1 till 6 I created a dictionary with 5 items
On line 8 I wanted to see what would be returned if I asked back for it
On line 11 I just asked for the value of key AAPL
On line 15 I updated the value of key AAPL and MSFT
On lines 16 and 19 I asked for the values that I just updated and you can see the values have changed

I also decided to print the dictionary, here is what that looks like

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

>>> stocks ={ 'TGT' : '51.33', 'AAPL': '147.48', 'MSFT': '71.49', 'F' : '11.12', 'INTC': '34.37'} >>> for key in stocks: print("{key} = {value}".format(key=key, value=stocks[key])) TGT = 51.33 AAPL = 147.48 MSFT = 71.49 F = 11.12 INTC = 34.37 >>>

Python also includes a module for pretty printing pprint, I played around with pprint and wrote a separate post about it here: Summer of code 2017: Python, Pretty printing with pprint in Python

Sets

A set is an unordered collection of unique, immutable objects
A set is delimited by { and }

>>> s ={1, 2, 3, 4, 5}
>>> print(s)
{1, 2, 3, 4, 5}

If you just do something like {} it will actually be a dict

>>> y ={}
>>> type(y)
<class 'dict'>
>>> 

To create an empty set use the set() constructor.

>>> x =set()
>>> x
set()
>>> print(x)
set()
>>> type(x)
<class 'set'>

>>> x.add(1)
>>> x
{1}

Printing an empty set just prints set()
As you can see from the output you can use add to add an item to a set


Sets are unique, to quickly remove duplicates, you can convert it to a set

Here is an example

>>> t =[1, 2, 2, 2, 2, 3, 4, 5]
>>> set(t)
{1, 2, 3, 4, 5}

Adding the same value to a set will just ignore it

>>> x={1}
>>> x
{1}
>>> x.add(2)
>>> x
{1, 2}
>>> x.add(2)
>>> x
{1, 2}

To remove items from a set you can user remove or discard, remove will throw an error if the item doesn't exist, discard will not throw an error

Here is an example

>>> x={1}
>>> x
{1}
>>> x.discard(3)
>>> x.remove(3)
Traceback (most recent call last):
  File "", line 1, in 
    x.remove(3)
KeyError: 3
>>> x.discard(3)
>>> 

Set Algebra

If you come from the database/SQL world, the following will look very familiar to you

Here is what sets support

union
Return a new set with elements from the set and all others

intersection
Return a new set with elements common to the set and all others

difference
Return a new set with elements in the set that are not in the others

symmetric_difference
Return a new set with elements in either the set or other but not both

issubset
Test whether every element in the set is in other

issuperset
Test whether every element in other is in the set

isdisjoint

Return True if the set has no elements in common with other. Sets are disjoint if and only if their intersection is the empty set

Here is some code that shows some of these

>>> s1 = {1,2,3,4,5}
>>> s2 = {3,4,5}

>>> s1.union(s2)
{1, 2, 3, 4, 5}

>>> s1.intersection(s2)
{3, 4, 5}

>>> s1.difference(s2)
{1, 2}

>>> s1.symmetric_difference(s2)
{1, 2}

>>> s1.issubset(s2)
False

>>> s1.issuperset(s2)
True

>>> s1.isdisjoint(s2)
False

We need to create some more examples for disjoint and symmetric_difference with different values so you can see what is returned

>>> s1 = {1,2,3,4,5}
>>> s2 ={0,8}

>>> s1.isdisjoint(s2)
True

>>> s1 = {1,2,3,4,5}
>>> s2 ={4,5,6,7}

>>> s1.symmetric_difference(s2)
{1, 2, 3, 6, 7}

That is all for this post... next time I will take a look at are exceptions