Introduction to Computer Programming for Non-Majors

Transcription

1 Introduction to Computer Programming for Non-Majors CSC 2301, Fall 2016 Review Chap Instructor: Long Ma The Department of Computer Science

2 Chapter 11 Data Collections understand the use of lists (arrays) to represent a collection of related data. be familiar with the functions and methods available for manipulating Python lists. write programs that use lists to manage a collection of information. -2-

3 Example Problem: Simple Statistics Many programs deal with large collections of similar information. Words in a document Students in a course Data from an experiment Customers of a business Graphics objects drawn on the screen Cards in a deck -3-

4 Lists and Arrays Python lists are ordered sequences of items. For instance, a sequence of n numbers might be called S: S = s 0, s 1, s 2, s 3,, s n-1 Specific values in the sequence can be referenced using subscripts. -4-

5 Lists and Arrays Suppose the sequence is stored in a variable s. We could write a loop to calculate the sum of the items in the sequence like this: sum = 0 for i in range(n): sum = sum + s[i] Almost all computer languages have a sequence structure like this, sometimes called an array. -5-

6 Lists and Arrays A list or array is a sequence of items where the entire sequence is referred to by a single name (i.e. s) and individual items can be selected by indexing (i.e. s[i]). In other programming languages, arrays are generally a fixed size, meaning that when you create the array, you have to specify how many items it can hold. e.g. lst = [None] * 5 e.g. x = numpy.zeros((3,4)) Arrays are generally also homogeneous, meaning they can hold only one data type. a = numpy.ndarray((5,),int) -6-

7 Lists and Arrays Python lists are dynamic. They can grow and shrink on demand. Python lists are also heterogeneous, a single list can hold arbitrary data types. Python lists are mutable sequences of arbitrary objects. -7-

8 Sequence Operations, also can be applied to List Operator <seq> + <seq> <seq> * <int-expr> <seq>[] len(<seq>) <seq>[:] for <var> in <seq>: <expr> in <seq> Meaning Concatenation Repetition Indexing Length Slicing Iteration Membership (Boolean) -8-

9 List Operations The membership operation can be used to see if a certain value appears anywhere in a sequence. >>> lst = [1,2,3,4] >>> 3 in lst True The summing example from earlier can be written like this: sum = 0 for x in s: sum = sum + x -9-

10 List Operations Unlike strings, lists are mutable: >>> lst = [1,2,3,4] >>> lst[3] 4 >>> lst[3] = "Hello >>> lst [1, 2, 3, 'Hello'] >>> lst[2] = 7 >>> lst [1, 2, 7, 'Hello'] A list of identical items can be created using the repetition operator. This command produces a list containing 50 zeroes: zeroes = [0] *

11 List Operations Lists are often built up one piece at a time using append. nums = [] x = eval(input('enter a number: ')) while x >= 0: nums.append(x) x = eval(input('enter a number: ')) Here, nums is being used as an accumulator, starting out empty, and each time through the loop a new value is tacked on. -11-

12 List Operations Method <list>.append(x) <list>.sort() <list>.reverse() Meaning Add element x to end of list. Sort (order) the list. A comparison function may be passed as a parameter. Reverse the list. <list>.index(x) Returns index of first occurrence of x. <list>.insert(i, x) Insert x into list at index i. <list>.count(x) <list>.remove(x) <list>.pop(i) Returns the number of occurrences of x in list. Deletes the first occurrence of x in list. Deletes the ith element of the list and returns its value. -12-

13 List Operations >>> lst = [3, 1, 4, 1, 5, 9] >>> lst.append(2) >>> lst [3, 1, 4, 1, 5, 9, 2] >>> lst.sort() >>> lst [1, 1, 2, 3, 4, 5, 9] >>> lst.reverse() >>> lst [9, 5, 4, 3, 2, 1, 1] >>> lst.index(4) 2 >>> lst.insert(4, "Hello") >>> lst [9, 5, 4, 3, 'Hello', 2, 1, 1] >>> lst.count(1)s 2 >>> lst.remove(1) >>> lst [9, 5, 4, 3, 'Hello', 2, 1] >>> lst.pop(3) 3 >>> lst [9, 5, 4, 'Hello', 2, 1] -13-

14 List Operations Most of these methods don t return a value they change the contents of the list in some way. Lists can grow by appending new items, and shrink when items are deleted. Individual items or entire slices can be removed from a list using the del operator. del isn t a list method, but a built-in operation that can be used on list items. -14-

15 List Operations >>> mylist=[34, 26, 0, 10] >>> del mylist[1] >>> mylist [34, 0, 10] >>> del mylist[1:3] >>> mylist [34] >>> li = [1,2,3,3] >>> del(li) >>> li Traceback (most recent call last): File "<stdin>", line 1, in <module>nameerror: name 'li' is not defined >>> -15-

16 List Operations Basic list principles: A list is a sequence of items stored as a single object. Items in a list can be accessed by indexing, and sublists can be accessed by slicing. Lists are mutable; individual items or entire slices can be replaced through assignment statements. Lists support a number of convenient and frequently used methods. Lists will grow and shrink as needed. -16-

17 Lists of Objects All of the list examples we ve looked at so far have involved simple data types like numbers and strings. We can also use lists to store more complex data types, like our student information from chap.10. Our grade processing program read through a file of student grade information and then printed out information about the student with the highest GPA. A common operation on data like this is to sort it, perhaps alphabetically, perhaps by credit-hours, or even by GPA. -17-

18 Lists of Objects Let s write a program that sorts students according to GPA using our Sutdent class from the last chapter. Get the name of the input file from the user Read student information into a list Sort the list by GPA Get the name of the output file from the user Write the student information from the list into a file -18-

19 Lists of Objects Let s begin with the file processing. The following code reads through the data file and creates a list of students. def readstudents(filename): infile = open(filename, 'r') students = [] for line in infile: students.append(makestudent(line)) infile.close() return students We re using the makestudent from the gpa program, so we ll need to remember to import it. -19-

20 Lists of Objects Let s also write a function to write the list of students back to a file. Each line should contain three pieces of information, separated by tabs: name, credit hours, and quality points. def writestudents(students, filename): # students is a list of Student objects outfile = open(filename, 'w') for s in students: print((s.getname(),s.gethours(),s.getqpoints(), sep="\t", file=outfile) outfile.close() -20-

21 Lists of Objects Using the functions readstudents and writestudents, we can convert our data file into a list of students and then write them back to a file. All we need to do now is sort the records by GPA. In the statistics program, we used the sort method to sort a list of numbers. How does Python sort lists of objects? -21-

22 Lists of Objects To make sorting work with our objects, we need to tell sort how the objects should be compared. Can supply a function to produce the key for an object using: <list>.sort(key=<somefunc>) To sort by GPA, we need a function that takes a Student as parameter and returns the student's GPA. def use_gpa(astudent): return astudent.gpa() -22-

23 Lists of Objects We can now sort the data by calling sort with the key function as a keyword parameter. data.sort(key=use_gpa) Notice that we didn t put () s after the function name. This is because we don t want to call use_gpa, but rather, we want to send use_gpa to the sort method. -23-

24 Lists of Objects Actually, defining use_gpa was unnecessary. The gpa method in the Student class is a function that takes a student as a parameter (formally, self) and returns GPA. Can use it: data.sort(key=student.gpa) -24-

25 Lists of Objects # gpasort.py # A program to sort student information into GPA order. from gpa import Student, makestudent def readstudents(filename): infile = open(filename, 'r') students = [] for line in infile: students.append(makestudent(line)) infile.close() return students def main(): print ("This program sorts student grade information by GPA") filename = input("enter the name of the data file: ") data = readstudents(filename) data.sort(student.gpa) filename = input("enter a name for the output file: ") writestudents(data, filename) print("the data has been written to", filename) if name == ' main ': main() def writestudents(students, filename): outfile = open(filename, 'w') for s in students: print(s.getname(), s.gethours(), s.getqpoints(), sep="\t", file=outfile) outfile.close() -25-

26 Chap.12 Objectives To understand the process of object-oriented design. To be able to read and understand object-oriented programs. To understand the concepts of encapsulation, polymorphism and inheritance as they pertain to object-oriented design and programming. -26-

27 The Process of OOD Most modern computer applications are designed using a data-centered view of computing called objectoriented design (OOD). The essence of OOD is describing a system in terms of black boxes and their interfaces. -27-

28 The Process of OOD The component providing the service should NOT have to consider how the service is used This separation of concerns makes the design of complex systems possible. In top-down design, functions serve the role of the black box. Client programs can use the functions as long as it understands what the function does. How the function accomplishes its task is encapsulated within the function. -28-

29 The Process of OOD In OOD, the black boxes are objects. The magic behind the objects is in the class definitions. Once a class definition is written, we can ignore how the class works and rely on the external interface, its methods. We ve seen this when using the graphics library we were able to draw a circle without having to know any of the nitty-gritty details encapsulated in class definitions for GraphWin and Circle. -29-

30 The Process of OOD Breaking a large problem into a set of cooperating classes reduces the complexity. Each class stands on its own! OOD is the process of finding and defining a useful set of classes for a given problem. -30-

31 The Process of OOD Here are some guidelines for OOD: Look for object candidates Define a set of objects that will be helpful in solving the problem. Start with a consideration of the problem statement objects are usually described by nouns. Identify instance variables Once you think of some possible objects, think of the kinds of information each object will need to do its job. Some object attributes will have primitive data types(string, number), while others may be complex types that suggest other useful objects/classes. -31-

32 The Process of OOD Think about interfaces Consider the verbs in the problem statement; they describe actions to be done. List the methods that the class will require. Remember all of the manipulation of the object s data should be done through the methods you provide. -32-

33 The Process of OOD Design iteratively Bounce back and forth between designing new classes and adding methods to existing classes. Make progress wherever progress needs to be made. -33-

34 The Process of OOD Refine the nontrivial methods Use top-down design and stepwise refinement to flesh out the details of the more difficult methods. As you re programming, you may discover that some new interactions with other classes are needed, and you may need to add new methods to other classes. Sometimes you may discover a need for a brand-new kind of object that calls for the definition of another class. -34-

35 The Process of OOD Try out alternatives Good design involves a lot of trial and error! Well-designed programs are not the result of a first try. Keep it simple stupid At each step in the design, try to find the simplest approach that will solve the problem. Don t design in extra complexity until it is clear that a more complex approach is absolutely necessary. -35-

36 Object Oriented (OO) Concepts The OO approach helps us to produce complex software that is more reliable and cost-effective. OO is comprised of three principles: Encapsulation Polymorphism Inheritance -36-

37 Encapsulation As you ll recall, objects combine data and operations. This packaging of data with a set of operations that can be performed on the data is called encapsulation. Encapsulation provides a convenient way to compose complex problems that corresponds to our intuitive view of how the world works world is made up of interacting objects. -37-

38 Encapsulation From a design standpoint, encapsulation separates the concerns of what vs. how. The implementation of an object is independent of its use. The implementation can change, but as long as the interface is preserved, the object will not break. Encapsulation allows us to isolate major design decisions, especially ones subject to change. -38-

39 Encapsulation Another advantage is that it promotes code reuse. It allows to package up general components that can be used from one program to the next. The DieView and Button classes are good examples of this. Encapsulation alone makes a system object-based. To be object-oriented, we must also have the properties of polymorphism and inheritance. -39-

40 Polymorphism Literally, polymorphism means many forms. What an object does in response to a message (a method call) depends on the type or class of the object. With polymorphism, a given line in a program may invoke a completely different method from one moment to the next. Suppose you had a list of graphics objects to draw on the screen a mixture of Circle, Rectangle, Polygon, etc. -40-

41 Polymorphism You could draw all the items with this simple code: for obj in objects: obj.draw(win) When obj is a circle, it executes the draw method from the circle class, then from rectangle class etc. Polymorphism gives object-oriented systems the flexibility for each object to perform an action just the way that it should be performed for that object. -41-

42 Inheritance The idea behind inheritance is that a new class can be defined to borrow behavior from another class. The new class (the one doing the borrowing) is called a subclass, and the other (the one being borrowed from) is called a superclass. This is an idea our examples have not included. -42-

43 Inheritance Say we re building an employee management system. We might have a class called Employee that contains general information common to all employees. There might be a method called homeaddress that returns an employee s home address. -43-

44 Inheritance Each subclass could have its own monthlypay function, since pay is computed differently for each class of employee. Inheritance has two benefits: We can structure the classes of a system to avoid duplication of operations, e.g. there is one homeaddress method for HourlyEmployee and SalariedEmployee. New classes can be based on existing classes, promoting code reuse. -44-

45 Inheritance We could have used inheritance to build the DieView class. Our first DieView class did not provide a way to change the appearance of the die. Rather than modifying the original class definition, we could have left the original alone and created a new subclass called ColorDieView. -45-

46 Inheritance A ColorDieView is just like DieView, except it has an additional method! class ColorDieView(DieView): def setvalue(self, value): self.value = value DieView.setValue(self, value) def setcolor(self, color): self.foreground = color self.setvalue(self.value) -46-

47 Inheritance The first line (class ColorDieView(DieView): ) says that we are defining a new class ColorDieView that is based on (i.e. is a subclass of) DieView. Inside the new class we define two methods. The second method, setcolor, adds the new operation. To make it work, setvalue also needed to be slightly modified. -47-

48 Inheritance The setvalue method in ColorDieView redefines or overrides the definition of setvalue that was provided in the DieView class. The setvalue method in the new class first stores the value and then relies on the setvalue method of the superclass DieView to actually draw the pips. -48-

49 Inheritance The normal approach to set the value, self.setvalue(value), would refer to the setvalue method of the ColorDieView class, since self is an instance of ColorDieView. To call the superclass s setvalue method, it s necessary to put the class name where the object would normally go: DieView.setValue(self,value) -49-

50 Inheritance DieView.setValue(self,value) The actual object to which the method is applied is sent as the first parameter. -50-

51 Inheritance class Person(object): pass class Child(Person): pass May = Child() Peter = Person() print(isinstance(may,person)) print(isinstance(peter,child)) print(issubclass(child,person)) # True # False # True -51-

52 Inheritance class Person(object): def init (self,name,sex): self.name = name self.sex = sex def print_title(self): if self.sex == "male": print("man") elif self.sex == "female": print("woman") class Child(Person): Pass May = Child("May","female") Peter =Person("Peter","male") print(may.name,may.sex, Peter.name,Peter.sex) May.print_title() Peter.print_title() -52-

53 Inheritance & polymorphism class Animal: def init (self, name): # Constructor of the class self.name = name def talk(self): # Abstract method, defined by convention only raise NotImplementedError("Subclass must implement abstract method") class Cat(Animal): def talk(self): return 'Meow!' class Dog(Animal): def talk(self): return 'Woof! Woof!' animals = [Cat('Missy'), Cat('Mr.Mistoffelees'), Dog('Lassie')] for animal in animals: print animal.name + ': ' + animal.talk() # prints the following: # Missy: Meow! # Mr. Mistoffelees: Meow! # Lassie: Woof! Woof! -53-

54 Questions Thank You!