This course is an introduction to computer science and programming in Python. Upon successful completion of this course, you will be able to: 1. Take a new computational problem and develop a plan to solve it through problem understanding and decomposition. 2. Follow a design creation process that includes specifications, algorithms, and testing. 3. Code, test, and debug a program in Python, based on your design. Important computer science concepts such as problem solving (computational thinking), problem decomposition, algorithms, abstraction, and software quality are emphasized throughout. The Python programming language and video games are used to demonstrate computer science concepts in a concrete and fun manner. However, a learner can take the knowledge and skills from this course and apply them to non-game problems, other programming languages, and other computer science courses. You do not need any previous programming, Python, or video game experience. However, some computer skills (e.g., mouse, keyboard, document editing), knowledge of algebra, attention to detail (as with many technical subjects), and a “just give it a try” spirit will be keys to your success. Despite the use of video games for all the programming examples, PVG is not about computer games. PVG will still provide valuable knowledge and skills for non-game computational problems. The interactive learning objects (ILO) of the course provide automatic, context-specific guidance and feedback, like a virtual teaching assistant, as you develop problem descriptions, algorithms, and functional test plans. The course forums will be supported by the creators of the course, to help you succeed. All videos, assessments, and ILOs are available free of charge. There is an optional certificate available for a fee.
Python Class Definition
Loading...
來自 University of Alberta 的課程
Problem Solving, Programming, and Video Games
個評分
從本節課中
Module 8: Poke the Dots Version 1 & 2
In Module 8, you will design and implement Version 1 of a new graphical game called Poke the Dots. You will then modify your game design using data abstraction to create user-defined classes. You will learn two new Python statements (class definition, pass) that will allow you to construct your own Python types. You will employ these Python constructs to implement Poke the Dots Version 2.
與講師見面
Duane SzafronProfessor
Computing Science
Paul LuProfessor
Computing Science
[MUSIC]
This video introduces a new statement called a class definition that creates
a new Python class, also called a type.
It also generalizes assignment statement syntax and
semantics to support attribute references as targets.
A user-defined class or
type allows us to group several objects into a single object.
A Python class definition statement creates a new user-defined class.
Consider this program that checks to see if two rectangles intersect or overlap.
The formula used to check for intersection is not the main point of this lesson, but
you might want to figure out how it works yourself.
I'll run the program.
The program reports that the first rectangle whose top left corner is at
the point (5,10), with width 15, and height 20,
does overlap the second rectangle whose top left corner is at the point (10,5),
with width 20, and height 15.
Even though I think of this program as computing whether two rectangle objects
intersect, there are no explicit rectangle objects in the program.
Instead the program uses eight integer objects to describe two
implicit rectangles.
This obscures both the intent and implementation code of the program.
For example, the argument list to the rectangles intersect function is so
long that it is easy to make typos when calling the function, and
when defining it as well.
The program would be much easier to read, write, and
modify if there were actually two explicit rectangular objects.
I have used a class definition statement to create a rectangle type and
have rewritten the program to use this type.
Running this program also displays overlap.
I used four attributes for each rectangle object, x, y, width, and height,
where x and y are integer coordinates of the top left corner of the rectangle.
Here is a simplified syntax diagram for a class definition statement.
The identifier is called the class name.
Here is the simplified semantic rule for class definition.
Evaluate the class's suite using a new local namespace and the global namespace.
Create a class object and
use the new local namespace as the namespace of the class object.
If the class name is not in the original local namespace, add it.
Bind the class name in the original local namespace to the new class object.
I will use the rectangle program to show you how the class definition semantics
work, and to highlight the difference between new local namespace and
original local namespace.
When the program starts the local block is the main module
whose namespace is both the local and global namespace.
The prebound identifier print is bound in this namespace.
The first statement in the main module is a function definition, so
the interpreter applies function definition semantics.
It creates a function object with its own namespace.
It adds the identifier main to the local namespace,
binds main to the function object, and
binds a reference to the main module namespace in the main function namespace.
Since the next two statement are also function definitions for
create rectangle and the rectangles intersect, the interpreter repeats
these function definition semantics for each of these functions.
The next statement is a class definition.
So the interpreter applies class definition semantics.
In step one, the interpreter creates a new empty namespace as the local namespace.
It uses this local namespace and
the current global namespace to evaluate the suit.
Recall that the suit in a function definition
is not evaluated when the function definition is evaluated.
Instead the suit of a function definition is only evaluated when the function is
called.
However, the semantics for class definition prescribes, that the suite
of a class definition is evaluated when the class definition is evaluated.
Since the suite only contains a past statement,
and the past statement does nothing, the suite is done.
In step two a new class object is created and
its namespace is the new empty local namespace.
In step three the class name rectangle is added to the original local namespace,
the namespace of the main module.
In step four rectangle is bound in this original local namespace,
main module, to the new class object.
The last statement in the main module is a function call to main, so
the interpreter applies the function call semantics.
The identifier main is de-referenced in the local namespace to obtain the main
function object.
The main function code is evaluated to obtain a result object.
The local block is now the main function and
the local namespace is the main function namespace.
The first statement is an assignment statement whose expression is a function
call to create_rectangle.
Familiar function call semantics are used to find the function object,
create_rectangle, in the global namespace.
Evaluate the four argument expressions, 5, 10, 15,
and 20, and put them in an argument list.
The interpreter then adds the parameters corner_x, corner_y, width, and height
to create rectangles namespace, binds each parameter to its corresponding argument,
and evaluates create_rectangle's code.
The local block is now the create rectangle function,
and the local namespace is the create rectangle function namespace.
The first statement of create_rectangle is an assignment statement,
whose expression is a function call to a function, whose name is rectangle.
When function call semantics are applied, the identifier rectangle is used in
the global namespace to find the rectangle object, which is a class.
In Python, classes are a kind of function.
So far you have seen several kinds of functions.
Built-in functions, like len, user-defined functions,
like create_rectangle, and built-in methods, like lower.
A class is another kind of function that returns a new object whose type
is that class.
For example, a call to int(), with no arguments, creates the int object zero,
and a call to str(), with no arguments, creates the empty string object.
A call to Rectangle, with no arguments, also creates a rectangle object, but
it doesn't have a very nice looking human readable form.
Most Python documentation uses the term callable, instead of function,
to describe classes and methods, however, whether we say that the class
is a function or a callable, it is evaluated like a function call, and
it creates a new object whose type is that class.
The assignment statement in create_rectangle, binds the identifier
rect to the new rectangle object that is created by that rectangle call.
The second statement is an assignment statement where the target,
rect.x is an attribute reference.
In the method calls lesson you saw the syntax and semantics of an attribute
reference used as an expression, such as 'hello'.lower.
In the alternate forms of the import statement lesson,
you used attribute references to access a function in a module, time.sleep,
and a module in a module, os.path, however, you have not seen
an attribute reference used as the target of an assignment statement in this course.
The current syntax diagrams for assignment support a target
that is either an identifier or a subscription expression.
Here is a generalized syntax diagram for the target in an assignment statement
that also supports an attribute reference as a target, and
the existing syntax diagram for attribute reference.
Finally, here is the semantic rule for
assignment when the target is an attribute reference.
Evaluate the assignment statement expression to obtain a result object.
Evaluate the attribute reference expression to obtain the base object.
If the identifier is not in the namespace of the base object add it.
Bind the identifier in the namespace of the base object to the result object.
I'll apply this semantic rule to the second assignment statement
in create_rectangle.
In step one, the expression corner_x is evaluated to obtain
the result object, integer 5.
In step two, the expression rect is evaluated to obtain the base object,
which is a rectangle.
In step three, the identifier x is not in the namespace of the base object,
which is an empty rectangle object, so x is added to this namespace.
In step four, the identifier x in the namespace of
the rectangle object is bound to the result object integer 5.
A new attribute called x has been added to the rectangle object, and
this new attribute has been bound to the int object 5.
Python lets a programmer create new attributes anywhere in the code that
the object containing the attribute can be referenced.
The next three assignment statements are interpreted similarly.
Notice that the parameter names width and height
happen to be the same as the attributes width and height, but this doesn't matter.
The other two attributes, x and y, are not the same as the parameters corner_x and
corner_y, which were used to access the argument objects.
The return statement returns the rectangle object to the calling function,
main(), which adds the identifier rect1 to its namespace, and
binds rect1 to this rectangle object.
The next assignment statement in function main is interpreted similarly so
that the identifier rect2 is bound to a second rectangle object.
The next statement in the main function is an if statement
whose condition calls the function rectangles intercept.
The identifier rectangles intersect is de-referenced in the global namespace.
Its two argument expressions are evaluated to obtain the two rectangle objects, and
they are put into argument list.
The interpreter then adds the parameters r1 and
r2 to the rectangle intersects namespace,
binds them to the argument rectangles, and evaluates the rectangles intersect code.
The local block is now the rectangle intersect function and
the local namespace is the rectangles intersect function namespace.
This function contains a single return statement with a complex expression.
Each attribute reference such as r1.x is evaluated using the semantic rule for
attribute reference from the method calls lesson.
In step one, the expression r1 is evaluated in the local namespace to obtain
the first rectangle object.
In step two, the attribute x is in the namespace of this rectangle object,
so it is the de-referenced to obtain the integer object 5.
Similarly, when the attribute reference r2.width is evaluated, the expression
r2 is evaluated in the local namespace to obtain the second rectangle object.
The attribute width is in the namespace of this rectangle object, so
it is de-referenced to obtain the integer object 20.
Evaluation of the expression in the return statement results in the Boolean
object true, so true is returned to the calling function main, and
the string overlap is displayed.
A class definition is used to define a new Python type.
Attributes in the namespace of objects of this type refer to component objects.
A rectangle object has four component integer objects, two that represent x and
y coordinates, and two that represent the width and height of the rectangle.
Programs that create explicit composite object types are easier to read, write,
and modify than programs that use many simpler objects to implicitly
represent composite objects.
You have already seen that a sequence can be used to reference multiple objects.
I could use lists in the program instead of creating a rectangle type.
Here is a program with the same functionality, but uses lists.
Although the list program is shorter,
the numerical indexes in the rectangle's intersect function are much harder to
understand than the attribute names x, y, width, and height.
In fact, it took me five tries to successfully translate the different
components from the pre-rectangle program to indexes before I got it right.
In the end,
I made a chart to increase my confidence that the translation was correct.
If I wanted to add more functions to this program, that operate on rectangles,
I would need to keep the chart to remember what index represent which component.
In a program where more functions are written that operate on composite objects,
the increased clarity of using attributes rather than lists
becomes even more apparent.
This video introduced a new statement,
called a class definition, that creates a new Python class or type.
It also generalized assignment statement syntax and
semantics to support attribute references as targets.
