程序代写案例-CSCI 1133
时间：2022-05-08
Classes
CSCI 1133
1
What you should know by the end of lecture
● How to define your own class
● Why we define our own classes
● What the __init__ method does
● How to create objects from a user defined class
● What an instance variable is
● How to access and change instance variables
● How to define methods in a class
● How to call methods from a class
2
Classes
● Everything in Python is an object of a specific type
○ The type defines the object’s attributes and behaviors.
● A class is the blueprint from which objects are created
3
Classes (Types) vs. Objects
Classes:
● int
● str
● list
● dict
● Turtle
4
Objects:
● 6
● 'hello'
● [3, 5, 2, 1]
● {1133:'Python', 1113:'C++'}
● leo = turtle.Turtle()
Why bother defining our own Class?
5
Why bother defining our own Class?
● Organization!
○ This is an excellent way to do the “data representation” step of problem solving
○ Better than a dictionary, since you can keep the data (instance variables) and algorithms
(methods) relevant to a problem in the same place
■ Instance variables work across methods, avoiding the need to pass them between
functions with parameters and arguments.
○ Works very well for large-scale problems, where there are different types of interconnected
entities that have associated data and functions
■ Example: a video game might have a class for monsters, a class for levels, a class for
collectables, a class for obstacles, etc.
6
Attributes vs. Behaviors
Attributes:
● Weight
● Color
● Length
● Eye Color
● Shell Pattern
● Speed
7
Behaviors:
● Swim
● Walk
● Bite
● Look At
Multiple Objects, One Class
● An instance is an specific object created from the class blueprint
○ You may create multiple instances from the same class
8
Attributes (Instance Variables) vs. Behaviors (Methods)
Instance Variables:
● x
● y
● heading
● color
● size
9
Methods:
● .forward(dist)
● .right(angle)
● .pendown()
● .xcor()
10
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Consider the Student class.
● What are the instance
variables of Student?
● What are the methods of
Student?
● What will the code in global
scope print?
11
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Consider the Student class.
● What are the instance
variables of Student?
● What are the methods of
Student?
● What will the code in global
scope print?
12
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Consider the Student class.
● What are the instance
variables of Student?
● What are the methods of
Student?
● What will the code in global
scope print?
13
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
14
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
Student object
15
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
Student.__init__:
self
name: 'rin'
scores: [90, 70]
Student object
16
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
Student.__init__:
self
name: 'rin'
scores: [90, 70]
Student object
.name: 'rin'
17
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
Student.__init__:
self
name: 'rin'
scores: [90, 70]
Student object
.name: 'rin'
.scores: [90, 70]
18
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1 Student object
.name: 'rin'
.scores: [90, 70]
19
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
Student.__init__:
self
name: 'bob'
scores: [46]
Student object
.name: 'rin'
.scores: [90, 70]
Student object
20
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
Student.__init__:
self
name: 'bob'
scores: [46]
Student object
.name: 'rin'
.scores: [90, 70]
Student object
.name: 'bob'
21
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
Student.__init__:
self
name: 'bob'
scores: [46]
Student object
.name: 'rin'
.scores: [90, 70]
Student object
.name: 'bob'
.scores: [46]
22
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
s2
Student object
.name: 'rin'
.scores: [90, 70]
Student object
.name: 'bob'
.scores: [46]
23
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
s2
Student object
.name: 'rin'
.scores: [90, 70, 80]
Student object
.name: 'bob'
.scores: [46]
24
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
s2
Student object
.name: 'rin'
.scores: [90, 70, 80]
Student object
.name: 'bob'
.scores: [46, 99]
25
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
s2
Student object
.name: 'rin'
.scores: [90, 70, 80]
Student object
.name: 'bob'
.scores: [46, 99]
26
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
s2
Student.get_average:
self
Student object
.name: 'rin'
.scores: [90, 70, 80]
Student object
.name: 'bob'
.scores: [46, 99]
27
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
s2
Student.get_average:
self
Student object
.name: 'rin'
.scores: [90, 70, 80]
Student object
.name: 'bob'
.scores: [46, 99]
28
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
s2
Student.get_average:
self
Student object
.name: 'rin'
.scores: [90, 70, 80]
Student object
.name: 'bob'
.scores: [46, 99]
240 3
29
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
s2
Student.get_average:
self
Student object
.name: 'rin'
.scores: [90, 70, 80]
Student object
.name: 'bob'
.scores: [46, 99]
80
30
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
s1 = Student('rin', [90, 70])
s2 = Student('bob', [46])
s1.scores.append(80)
s2.scores.append(99)
print(s1.get_average())
Global:
Student
s1
s2
Student object
.name: 'rin'
.scores: [90, 70, 80]
Student object
.name: 'bob'
.scores: [46, 99]
80
User-Defined Class
● Use the class keyword to define a class
● Classes contain methods
31
class Quad:
def __init__(self,a,b,c):
self.a = a
self.b = b
self.c = c
def neg_root(self):
return (-self.b-(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
def pos_root(self):
return (-self.b+(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
Methods
● Special functions specific to a class
● Generally operate on or access objects within that class
● self is always a parameter to every method
32
class Quad:
def __init__(self,a,b,c):
self.a = a
self.b = b
self.c = c
def neg_root(self):
return (-self.b-(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
def pos_root(self):
return (-self.b+(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
Method signatures
The __init__ method: The Constructor
● __init__ runs whenever an object is created
● For example, bob = turtle.Turtle() runs the Turtle class’s __init__ method
● __init__ generally is used for setup, especially creating instance variables
33
class Quad:
def __init__(self,a,b,c):
self.a = a
self.b = b
self.c = c
def neg_root(self):
return (-self.b-(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
def pos_root(self):
return (-self.b+(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
Creating Objects of a User-Defined Class
● Syntax is = ( )
● Note that you don’t have to include self (since self is the object being created)
34
class Quad:
def __init__(self,a,b,c):
self.a = a
self.b = b
self.c = c
eqn1 = Quad(1,1,-6)
eqn2 = Quad(2,4,2)
self
● The first parameter for every method should be self
● This is a pointer to the object for which the method is being called, and can be
used to access instance variables, or other methods.
35
class Quad:
def __init__(self,a,b,c):
self.a = a
self.b = b
self.c = c
def neg_root(self):
return (-self.b-(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
def pos_root(self):
return (-self.b+(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
Instance/Member variables/attributes
● Special variables that are stored for a given object
● Can be used/altered by any method in that object
● Use self. to reference them from within the class
36
class Quad:
def __init__(self,a,b,c):
self.a = a
self.b = b
self.c = c
def neg_root(self):
return (-self.b-(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
def pos_root(self):
return (-self.b+(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
Accessing/Changing Instance Variables
● Use self. to reference them from within the class
● Use . to reference them on a particular object
from outside the class definition.
○ This does NOT change the instance variable for other instances of the same class
37
class Quad:
def alter_a(self, new_a):
self.a = new_a
eqn1 = Quad(1,1,-6)
eqn2 = Quad(2,4,2)
eqn1.b = 3
eqn2.c = 5
Accessing Methods
● Use self.() to reference from within the class
● Use .() to reference them on a
particular object from outside the class definition.
○ You don’t include self when calling a method
38
class Quad:
def alter_a(self, new_a):
self.a = self.alter_a(new_a) #This is a very bad idea
eqn1 = Quad(1,1,-6)
eqn2 = Quad(2,4,2)
eqn1.alter_a(3)
eqn2.alter_a(5)
Classes Practice
● Make two Quad objects, representing x2 + 7 = 0, and 2x2 + 2x - 1 = 0
● Change the constant coefficient of your first object to 9, and the x2 coefficient
of the second to 3.
39
class Quad:
def __init__(self,a,b,c):
self.a = a
self.b = b
self.c = c
def neg_root(self):
return (-self.b-(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
def pos_root(self):
return (-self.b+(self.b**2-4*self.a*self.c)**0.5)/(2*self.a)
Classes Practice
● Make two Quad objects, representing x2 + 7 = 0, and 2x2 + 2x - 1 = 0
● Change the constant coefficient of your first object to 9, and the x2 coefficient
of the second to 3.
quad1 = Quad(1, 0, 7)
quad2 = Quad(2, 2, -1)
quad1.c = 9
quad2.a = 3
40
What will this
code print?
41
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
What will this
code print?
42
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
What will this
code print?
43
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course object
What will this
code print?
44
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
Course object
['al', 'mai', 'din']
What will this
code print?
45
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
Course object
.students: []
['al', 'mai', 'din']
What will this
code print?
46
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'al'
Course object
.students: []
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
47
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'al'
Course object
.students: []
Student object
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
48
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'al'
Student.__init__:
self
name: 'al'
scores: [0, 0]
Course object
.students: []
Student object
['al', 'mai', 'din']
['al', 'mai', 'din']
' l' [0, 0]
What will this
code print?
49
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'al'
Student.__init__:
self
name: 'al'
scores: [0, 0]
Course object
.students: []
Student object
.name: 'al'
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
50
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'al'
Student.__init__:
self
name: 'al'
scores: [0, 0]
Course object
.students: []
Student object
.name: 'al'
.scores: [0, 0]
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
51
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'al'
stu:
Course object
.students: []
Student object
.name: 'al'
.scores: [0, 0]
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
52
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'al'
stu:
Course object
.students: [ ]
Student object
.name: 'al'
.scores: [0, 0]
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
53
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'mai'
stu:
Course object
.students: [ ]
Student object
.name: 'al'
.scores: [0, 0]
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
54
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'mai'
stu:
Course object
.students: [ ]
Student object
.name: 'al'
.scores: [0, 0]
Student object
.name: 'mai'
.scores: [0, 0]
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
55
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'mai'
stu:
Course object
.students: [ , ]
Student object
.name: 'al'
.scores: [0, 0]
Student object
.name: 'mai'
.scores: [0, 0]
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
56
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'din'
stu:
Course object
.students: [ , ]
Student object
.name: 'al'
.scores: [0, 0]
Student object
.name: 'mai'
.scores: [0, 0]
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
57
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'din'
stu:
Course object
.students: [ , ]
Student object
.name: 'al'
.scores: [0, 0]
Student object
.name: 'mai'
.scores: [0, 0]
Student object
.name: 'din'
.scores: [0, 0]
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
58
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
Course.__init__:
self
names:
num_assigns: 2
name: 'din'
stu:
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [0, 0]
Student object
.name: 'mai'
.scores: [0, 0]
Student object
.name: 'din'
.scores: [0, 0]
['al', 'mai', 'din']
['al', 'mai', 'din']
What will this
code print?
59
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [0, 0]
Student object
.name: 'mai'
.scores: [0, 0]
Student object
.name: 'din'
.scores: [0, 0]
What will this
code print?
60
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [0, 0]
Student object
.name: 'din'
.scores: [0, 0]
What will this
code print?
61
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [0, 95]
Student object
.name: 'din'
.scores: [0, 0]
What will this
code print?
62
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
What will this
code print?
63
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course.print_As:
self
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
What will this
code print?
64
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course.print_As:
self
student
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
What will this
code print?
65
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course.print_As:
self
student
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
What will this
code print?
66
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course.print_As:
self
student
Student.get_average
self
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
45.5
What will this
code print?
67
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course.print_As:
self
student
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
What will this
code print?
68
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course.print_As:
self
student
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
What will this
code print?
69
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course.print_As:
self
student
Student.get_average
self
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
90
What will this
code print?
70
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course.print_As:
self
student
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
90
What will this
code print?
71
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course.print_As:
self
student
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
What will this
code print?
72
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course.print_As:
self
student
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
What will this
code print?
73
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def get_average(self):
return sum(self.scores)/len(self.scores)
class Course:
def __init__(self, names, num_assigns):
self.students = []
for name in names:
stu = Student(name, num_assigns*[0])
self.students.append(stu)
def print_As(self):
for student in self.students:
if student.get_average() >= 90:
print(student.name)
c1 = Course(['al', 'mai', 'din'], 2)
c1.students[0].scores[0] = 91
c1.students[1].scores[1] = 95
c1.students[1].scores[0] = 85
c1.print_As()
Memory
Global:
c1
Course.print_As:
self
student
Student.get_average
self
Course object
.students: [ , , ]
Student object
.name: 'al'
.scores: [91, 0]
Student object
.name: 'mai'
.scores: [85, 95]
Student object
.name: 'din'
.scores: [0, 0]
0
Triangle Class
● Make a class Triangle, that has:
○ Four instance variables, all defined in __init__:
■ One for the side length of the triangle
■ One for the x coordinate of the lower left corner of the triangle
■ One for the y coordinate of the lower left corner of the triangle
■ One for the color of the triangle
○ One method other than __init__
■ draw(self, t) takes in a turtle object t (and self), and uses that turtle object to draw the
triangle that this Triangle object represents in turtle graphics.
74
75
class Triangle:
def __init__(self,length,x_coord,y_coord,fill_color):
self.side = length
self.x = x_coord
self.y = y_coord
self.color = fill_color
def draw(self,t):
t.speed(0)
t.penup()
t.setpos(self.x,self.y)
t.pendown()
t.color(self.color)
t.begin_fill()
for i in range(3):
t.forward(self.side)
t.left(120)
t.end_fill()
Acknowledgements
● This lecture was adapted from CSCI 1133 slides written by Stephen Guy,
Lana Yarosh, and Evan Suma Rosenberg.
76

学霸联盟
联系我们
3551 Trousdale Rkwy, University Park, Los Angeles, CA
留学生论文指导和课程辅导
论文代写：https://www.lunwen-daixie.com
课程辅导：https://www.vipeasydue.com
无忧GPA：https://www.essaygpa.com
工作时间：全年无休-早上8点到凌晨3点
essay、essay代写
微信客服：xiaoxionga100
essay、essay代写
微信客服：ITCS521
essay、essay代写