ELEC0021 Programming 2023-24
1st PROGRAMMING ASSIGNMENT – Part 1A
Virtual Dice Throwing
This is an introductory programming exercise in order to refresh your last year’s knowledge of programming and get you introduced to Python. The program to write should emulate virtual dice throwing. It should get from the keyboard the number of sides of the virtual dice and the number of times to be thrown, the latter should be a multiple of the number of sides. The program should then throw the dice and print out the number of times each side occurred. Given that random numbers will be used, you should be able to see that the higher the number of throws, the closer the results will be towards approximately equal occurrence of all sides (same probability). The program should deal gracefully with incorrect type of arguments through checks and exceptions.
This program can be in fact an extension of the coin thrower program which can be found on the Week 2 Random Number Generation lecture material. You may implement it in a similar manner to the coin thrower program, i.e. if any user input is incorrect you could print out a diagnostic message and terminate the program. But the most sophisticated implementation is one in which you keep asking the user for a correct value when her input is wrong. In this case, you could use separate functions getNFaces() and getNThrows(nfaces) which use a loop to get the value correctly – see for example the getNDataFromKeyboard() static method of assignment part 1B.
You should start working on this assignment in the first lab session of the week commencing 15 January.
1st PROGRAMMING ASSIGNMENT – Part 1B
Calculating the Mean and Variance of a Data Set – “the Long Way”
This is another introductory programming exercise so that you start getting familiar with some more sophisticated aspects of Python. “The long way” is mentioned above because the description of this assignment also serves as a tutorial introduction to various aspects of structured and object-oriented programming in Python, and for this reason this description is 5 pages long. It also includes a good part of the assignment already implemented in order to show how things should be done properly. So please go through this description very carefully as it constitutes effectively an additional complementary lecture.
The program to be developed in this exercise should calculate the mean and variance of a set of numbers, i.e. “the data set”. This is something that could be easily done in C through a program that would have the following structure: two C functions mean and variance and a main program that initialises an array of numbers, invokes the two functions bypassing to them the array as parameter and prints the respective results. The “signature” of the two functions would be the following:
float mean (int ndata, float data[])
float variance (int ndata, float data[])
Note that in C we need to pass the size of the array, i.e. ndata, as a separate parameter, as the array is effectively only a pointer to its first element, no more than that.
We could write a similar program in Python by mirroring exactly the structure of the C program, but given that this year you will learn about object-oriented (O-O) programming, we will do it slightly differently. We will create a reusable class for the data set which will include various functions (or, more precisely, methodsin O-O terminology) for initialising the data in a number of ways: by getting it from the keyboard, by generating random values in a particular specified range or by reading the data values from a file. After the assignment, this class could be put aside and be possibly used in other contexts.
We will also write the mean and variance functions, which in Python will have the following simpler signature:
def mean (data)
def variance (data)
Finally, we will write a main program which will allow the initialisation of the data set in a number of ways and will then compute the mean and standard deviation.
We are now ready to implement our first simple object-oriented class and program in Python in an incremental manner, showing basic parts of it and its overall layout but omitting the complete implementation, which you should do.
import random # for Random class methods in the full version
class NumberList:
def__init__ (self): # the class constructor
self.__data = [] # initialises the __data “private” instance variable to an empty list
def getData (self):
return self.__data; # returns the contained data list to users of the class
def setData (self, data): # initialises the list with “externally-created” data
self.__data = data
# end class
def mean (data):
# function implementation goes here, you should do this
def variance (data):
# function implementation goes here, you should do this
def main ():
mydata = [0.1, 1.1, 2.1, 3.1, 4.1] # hardcoded data set values, list with 5 elements
nlist = NumberList() # create new empty NumberList object instance
nlist.setData(mydata) # fill it in with the data set
print("Numbers: " + str(nlist.getData())) # print the data set
print("Mean: " + str(mean(nlist.getData()))) # calculate and print mean
print("Variance: " + str(variance(nlist.getData()))) # calculate and print variance
if__name__ == "__main__":
main()
Note: in the main function above we could have passed directly mydata to the mean & variance functions. But we did it in an object-oriented manner by creating a NumberList object instance which contains mydata and then retrieved the contained data using the getData() method in order to to pass it to the mathematical functions. In a more complex program, such a data set object could have been created and filled in elsewhere and passed as parameter to a function in order to calculate the data set mean & variance, so we used this more general approach.
We have now implemented our first Python program which calculates the mean and variance of a data set with “hard-coded” values, with the data set implemented in an object-oriented manner through the NumberList class. It would be nice to extend this class to be able to get the data set size and values in various ways: by a human user from the keyboard, by randomly producing the values within a particular range, or by reading a file which contains the data values, one per line.
Considering the data-from-keyboard approach, we introduce the getNDataFromKeyboard() method which will read the number of data elements expected from the keyboard. It will also need to check that the number specified by the user is >= 2 as otherwise there is no point in running the program. This method should be private, given that it will be only called by another class method getDataFromKeyboard() which we will subsequently introduce. Hence we name the former __ getNDataFromKeyboard() according to the Python convention for naming private class members. We include the complete method implementation overleaf.
# additional NumberList class methods
def__getNDataFromKeyboard (self): # “private” method names in Python start with __ print("Enter the number of data set elements: ")
ndata = 0
gotNDataCorrectly = False # a flag to loop until we get ndata correctly
while gotNDataCorrectly == False:
try:
ndata = float(input()) # read from the keyboard, accept also strings & convert
if ndata % 1 == 0 and ndata >= 2: # check for integer input >= 2
gotNDataCorrectly = True
else:
print("__getNDataFromKeyboard: ndata should be >=2")
except (ValueError, SyntaxError):
print("__getNDataFromKeyboard: ndata should be an integer!")
# end while loop
return int(ndata) # return ndata as int
def getDataFromKeyboard (self):
ndata = self.__getNDataFromKeyboard()
# here you should write code that gets exactly ndata numbers from the keyboard # and adds them to the __data instance variable using the list append method;
# you will need a while loop in similar fashion to __getNDataFromKeyboard
Note that the getNDataFromKeyboard method does not use the __data instance variable. It could be made in fact a static class method, static methods are those that do not have access to the class instance variables and, in fact, can be called without creating an object instance by simply preceding them with the class name, e.g. NumberList. getNDataFromKeyboard(). In order to make this method static, we need to use the @staticmethod decorator and in this case the method would not take the self parameter while everything else would stay the same. Although it does not make any difference when running the program, it is better programming practice and you should do it that way.
@staticmethod # this decorator tells the interpreter that the following method is static
def__getNDataFromKeyboard (): # note the absence of self, static methods do not have it # normal method implementation follows
Let’s now introduce the getRandomData(ndata, range1, range2) method which will produce a random data set in [range1..range2). In Python, random numbers in [0..1) are produced by the random() method of the Random class which is accessible through the “hidden” random object reference - hidden means that it exists in the background without having to create it explicitly, i.e. random = Random(). See also lecture 2 on Random Number Generation.
By implementing this method, we will also get to learn another Python feature, that of optional parameters. By assigning the “default value” 0 to range2, it means that the range2 parameter maybe omitted by calling the method using getRandomData(ndata, range1) and its value will be 0; the method will then produce values in [0..range1). If on the other hand the range2 parameter is included by using getRandomData(ndata, range1, range2), then the method should produce values in [range1..range2); note it should be range1 < range2, otherwise the method should print out an error message and do nothing. Also note that the parameters ndata, range1 and range2 could be either integers or stringified integers, e.g. 10 or “10”, and the method code should cater for both cases.
def getRandomData (self, ndata, range1, range2=0):
# here you should write code that first checks the validity of the parameters
# then sets two variables low and high according to the range1 and range2 values # and finally produces random values and adds them to __data using list append
Finally, we can also add a final method to our NumberList class to initialise the data set by reading values from a file. By doing this, you will learn some elementary file manipulation, although more elaborate file handling will be taught in the second part of the term. You should use the open function to open the file in read mode and then in a for loop you should go through every line of the file, using the strip method of every text line by doing strip(‘\n’) to remove any spaces and the newline character and convert the resulting value to float, making sure that you catch exceptions if the value cannot be converted. The signature of the method will be:
def getDataFromFile (self, fileName):
# method implementation follows
Having introduced all these methods, we have now created a useful class NumberList. It includes the methods getDataFromKeyboard, getRandomData and getDataFromFile which can be easily reused in different contexts, saving development time.
We can now rewrite our main program to use the getDatatFromKeyboard method and make it more flexible than using a fixed size list with hard-coded values, which we did before:
def main ():
nlist = NumberList()
nlist.getDataFromKeyboard()
print("Numbers: " + str(nlist.getData()))
print("Mean: " + str(mean(nlist.getData())))
print("Variance: " + str(variance(nlist.getData())))
We can also rewrite our main program to use either the getRandomDataSet or getDataFromFile methods; in the first case, we will hardwire the values for ndata and upper bound while in the second case we will hardwire the name of the data file. In order to save space, we use one main function in which as can comment in/out the right method accordingly:
def main ():
nlist = NumberList()
# this version uses getRandomData, could comment out and comment in getDataFromFile nlist.getRandomData2(5, 10) # produce 5 random values in the [0, 10) range
# nlist.getDataFromFile(“dataFile”) # read values from file with name dataFile
print("Numbers: " + str(nlist.getData()))
print("Mean: " + str(mean(nlist.getData())))
print("Variance: " + str(variance(nlist.getData())))
So we implemented the two different main programs above in only a few lines of code by using the class NumberList which we can reuse anywhere. A key aspect of object-oriented programming is to design and implement highly reusable classes and this exercise demonstrated the benefit of doing this.
But in order to also demonstrate some other aspects of Python and programming languages in general, we will create a more sophisticated version of the main program. This will combine the three options we used above; it will also allow the user to pass the size and low/high of the random data set from the command line. So when the program is invoked with no arguments at all it will get the values from the keyboard; when it is invoked with one argument this should be the name of a file and it will read the data from a file; and when it is invoked with two or three arguments, it should produce the data set values randomly.
Also as NumberList is a reusable class, we will leave it in file NumberList.py which we have used until now and we will put the more sophisticated main program described above in file MeanAndVariance.py - see implementation below.
from NumberList import NumberList # NumberList class is in file NumberList.py import sys # for sys.argv and sys.exit()
def main ():
nlist = NumberList() # create an empty NumberList instance
nargs = len(sys.argv) # argv contains the program name and arguments, as in C
if nargs == 1: # no arguments, actually only the program name hence value 1
nlist.getDataFromKeyboard()
elifnargs == 2: # filename argument, get data from file
nlist.getDataFromFile(sys.argv[1])
elifnargs == 3 or nargs == 4: # produce data set randomly
if nargs == 3:
nlist.getRandomData(sys.argv[1], sys.argv[2])
else: # nargs = 4
nlist.getRandomData(sys.argv[1], sys.argv[2], sys.argv[3])
else:
print(“incorrect number of arguments, try again”);
sys.exit() # terminate program
print("Numbers: " + str(nlist.getData()))
print("Mean: " + str(mean(nlist.getData())))
print("Variance: " + str(variance(nlist.getData())))
By studying carefully the description of this assignment and by implementing this program you will get familiar with a number of Python features and get introduced to object-oriented programming. As already stated in the beginning, the detailed description of this assignment serves as an introductory tutorial to object-oriented programming. Another aspect of this assignment is that it introduces “incremental development”: you first implement a simple program that works with a fixed size / hard-coded values data set, then extend it to work with a data set that the user provides from the keyboard, then extend it to also work by producing the data set randomly with a user-specified size and range; then extend it to also work by reading the data set values from a file; and finally enhance the main function to enable running the program with all these options.
1st PROGRAMMING ASSIGNMENT – Part 1C
Shape Inheritance
This exercise has the purpose first to get you to implement the Shape, Point, Circle and Cylinder classes as in the lecture notes in order to get to understand better, assimilate and actually code the inheritance features taught in the lectures. Although you can simply copy the code from the notes, it would be certainly more beneficial to write the code yourselves by looking at the notes in order to realise how object-oriented features related to inheritance are exercised and understand / assimilate the relevant principles. In addition to the classes in the notes, you should also design and implement the following shape classes exploiting inheritance: Sphere, Rectangle, Square and Cube.
Having implemented these classes, you should write a program which gets input from the user/keyboard to create an instance of any one of these. The user should be able to create as many of these shapes and s/he wants. The menu should also allow the user to print out the created objects, either selecting a particular one or printing all of them. The user should also be allowed to remove/delete an existing shape from the list. Finally, the user should be allowed to modify a particular shape. The program should print the objects it keeps by using only the Shape getName(), toString(), getArea() and getVolume() methods, i.e. treating all these objects “polymorphically” as “shapes”. Note that modifying a shape cannot be done polymorphically, specific functions will be required to modify each type of shape. The program should deal gracefully with incorrect type of arguments through checks and exceptions.
ASSIGNMENT SUBMISSION AND EXAMINATION
You should also submit the following code files on Moodle by 9am on Monday 5 February:
1. VDiceThrower.py - the virtual dice thrower program
2. NumberList.py - the reusable NumberList class
3. MeanAndVariance.py - the mean and variance program
4. Shapes.py - the shape classes and the test program in one file
The file names above are indicative, you may use alternative names if you wish.
You should demonstrate the working programs to the lab TAs in a session during the week starting 5 February. You will be also asked questions about your code. Nicely structured, presented and commented code is very important and will affect the overall mark.