(Home)

SUPAPYT - Hands on Exercises

• Here're some suggested exercises to help familiarise you with python.
• We'll work through them in the labs, but you can of course try them in your own time too.

1)

• Make sure you can start the interactive interpreter from the commandline, as discussed in the Getting started guide.
• Start the interpeter, evaluate some simple maths expressions and then quit it.

2)

• Try writing a simple script and passing it to the interpreter via the commandline (see here).
• This can be as simple as the "Hello world!" example in the lectures.
• You can do the rest of the exercises at the commandline using a combination of the interactive interpreter and scripts, or using the Jupyter notebook format (if you have Jupyter installed). It's up to you which to use, so long as you know how to do both (or at least the use of the commandline).
• The main point is: there are several different ways of interacting with the python interpreter, but it's the same interpreter working in the background. Different use cases benefit from different means of interaction.

3)

• Convert 101010 from binary to base 10.

• Convert 2a from hexidecimal to base 10.

4)

• Write a function to calculate the length of the hypotenuse of a right angle triangle given the lengths of the other two sides.
• What's the hypotenuse of a right angle triangle with other sides of length 6 and 8?

• Here's an interesting aside on why even simple functions like calculating the hypotenuse can get complicated due to finite numerical precision: Hypot – A story of a ‘simple’ function

5)

• The above is an example of a Pythagorean triple, as all three sides are integers.
• Write a function which tests for Pythagorean triples:
  • Take the length of the other two sides as arguments.
  • Check if they're integers.
  • Calculate the hypotenuse.
  • Check if it's an integer.
  • Return True if all three are integers, else False.
• Verify that (6, 8) is a Pythagorean triple.
• Check (32, 46), (161, 240), and (372, 496).
• Note that you want to check if the value of the hypotenuse is an integer, not if it's of type int (since a float can have an integer value).

6)

• Using two nested for loops, find all Pythagorean triples with hypotenuse < 100.
• Put each triple into a tuple of length 3 and add it to a list containing all the triples.
• Loop over the list of all triples and print them in columns of width three, eg, (6, 8, 10) $\to$

6 8 10

7)

• Try overriding one of the built-in types, like list, int or str by making a variable with that name (eg, int = 3 - normally you should avoid doing this).
• Verify that the built-in type is lost.
• Can you recover it?

8)

• We've discussed briefly the idea of "mutable" and "immutable" objects in python.
• All basic types are immutable apart from lists and dictionaries.
• See what happens when you assign two variables to the same object, then change one of the variable.
  • Eg, assign two variables to the same int value, then change the value of one of the variables and check if it changes the value of the other variable.
  • Try doing the same but assign a list instead of an int. Modify the the list (change/delete/add an element) and check the values of both variables.

• In python the variable name and the object to which it refers are distinct.
• In C++ terms, every variable in python is like a pointer.
• For mutable objects you can access and modify the object via any variable assigned to it.
• For immutable objects any attempt to change the object either raises an exception or creates a new object and assigns it to the variable.
• The id built-in method returns a unique integer for every object (try help(id)) so you can use it to check if variables refer to the same object, or if an operation has modified an existing object or assigned a new object to the same variable.

9)

• Given the above, can you work out how you'd make a copy of a list, rather than creating a new variable that refers to the same list?
• There are a few different ways.

10)

• When slicing sequences (where supported) you can give a thrid int after a second colon

# Eg:
l = [1,2,3,4,5]
print(l[1:4:1])

[2, 3, 4]

• Try to work out what this third int means. What happens if you give it a negative value?

11)

• Define a string with your name with your name and write a script to provide your name in reverse with all vowels capitalised and all consonants lower case.
• Eg, 'Brave Sir Robin' => 'nIbOr rIs EvArb'

12)

• In addition to supporting function arguments of any type, python also has syntax for functions that can take a variable number of arguments.
• For unnamed arguments this is done like so:

# Eg:
def arguments(*args) :
    print('args =', args)

• Try calling this function with different numbers of arguments (including none).
• What is the type of args within the function?

• You can also give arbitrary named arguments to a function like so:

# Eg:

def named_args(**kwargs) :
    print('kwargs =', kwargs)

• Then try calling it in various ways:

# Eg:

named_args()
named_args(a = 1, b = 2)
named_args(t = ('a', 'b', 'c'), l = [1, 2, 3], f = 3.5)
named_args(1, n = 3)

kwargs = {}
kwargs = {'a': 1, 'b': 2}
kwargs = {'t': ('a', 'b', 'c'), 'l': [1, 2, 3], 'f': 3.5}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-1-5a07e324dc60> in <module>
      4 named_args(a = 1, b = 2)
      5 named_args(t = ('a', 'b', 'c'), l = [1, 2, 3], f = 3.5)
----> 6 named_args(1, n = 3)

TypeError: named_args() takes 0 positional arguments but 1 was given

• What type is kwargs within the method?
• The last call fails as the method only expects named arguments.

• The most flexible method, that takes an arbitrary number of unnamend and named arguments thus has this form:

# Eg:

def args_and_keywords(*args, **kwargs) :
    print('args =', args)
    print('kwargs =', kwargs)

• Give it a try and see what ways you can pass it arguments.

13)

• Write a class to represent a 3 component vector with x, y & z attributes.
• Write the __init__ member function to take values for x, y & z, with their default values being zero.
• Write a member function to return the dot product of the vector with another 3-vector, which is passed as an argument.
• Write a __add__ member function that returns a new 3-vector that's the sum of the vector with another given as an argument, so you can use the + operator on instances of your class.
• Write a member function to check if the vector is orthogonal to another 3-vector, ie, their dot product is zero.
• Use instances of your class to verify that the vectors (4, -7, 9) and (54, -18, -38) are orthogonal.
• Do the same for (890, 3254, 6404) + (542, -912, 834) and (1227, -484, -97) + (-8465, 7722, -813), making use of the + operator on instances of your class.

14)

• Use the date class from the datetime module to work out how old you are in days.
• On what date will you be/were you 10000 days old?

15)

• Use pickle to save the date on which you're 10000 days old to a file, then load it again and verify that it's the same date you started with.

16)

• Take this file, which has three integers per line, read each set of three into an instance of your 3-vector class defined in Q. 13, and add these to a list.
• Check each 3-vector in the list against every other 3-vector in the list to see if they're orthogonal, and count how many (unique) pairs of vectors are orthogonal.

(Home)