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 Import Statement Variations
Loading...
En provenance du cours de University of Alberta
Problem Solving, Programming, and Video Games
notes
À partir de la leçon
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.
Rencontrer les enseignants
Duane SzafronProfessor
Computing Science
Paul LuProfessor
Computing Science
This video introduces a new variation of the import statement that can
be used to resolve name conflicts and import objects from submodules,
which are modules inside of other modules.
A name conflict occurs when you try to use
the same identifier to refer to different objects at the same time.
For example, here is a program that uses the identifier sleep
to refer to different sleep modes such as REM and non-REM.
Where REM stands for rapid eye movement.
I want to have a pause between printing the sleep mode and the dreams output.
I will import the sleep function from the time module and put a call
to this sleep function after the first print function call.
The Python interpreter reports a type error,
indicating that sleep is not a callable object. What happened?
When the program starts,
the main module namespace contains the identifier as
input and print each bound to a function object.
When the import statement is evaluated,
the identifier sleep is added to the namespace
and bound to the sleep function object from the time module.
Next, the input function returns
a REM string object and
the assignment statement binds the sleep identifier to this object.
The print function call displays the string object.
The next statement is a function call whose function name is sleep.
The interpreter dereferences the sleep identifier
to obtain a string object which is not a function,
so the function call fails.
When the assignment statement rebound, the identifier sleep.
The reference to the sleep function was lost,
this is a name conflict.
Python resolves name conflicts using the most recent binding rule.
Whichever binding occurred most recently,
is the binding that is used to dereference an identifier.
For example, I will move the import statement so that it occurs later in the program.
This time, the assignment statement is evaluated first,
the identifier sleep is added to the namespace and bound to
the result object of the input function call, which is REM.
Then, the print sleep function call displays REM.
Then, the import statement rebind sleep to the sleep function from the time module.
The function call to sleep works as intended.
When the condition of the if statement is evaluated,
the identifier sleep is dereferenced to obtain the sleep function object,
which is not equal to the string REM,
even though the user input the REM string.
There is still a name conflict and program output is incorrect.
You can resolve a name conflict,
by selecting a different identifier to bind to one of the conflicting objects.
I could bind a different identifier to the input string such as
sleep mode and keep the identifier sleep for the imported sleep function.
I need to change sleep to sleep mode
everywhere I want to refer to the string that was entered by the user.
In this case, sleep mode maybe more descriptive identifier for the input string.
However, in a program called sleep,
that is about the topic of sleep,
using the name sleep as the name of the pause function is not very descriptive.
Python provides the versatility to resolve conflicts due to
imported names using different variations of the import statement.
These variations allow you to use
the most appropriate local name in your program to represent each imported object.
You are not constrained by the names used in other modules.
Here is a generalization of our previous import statement that,
as an optional as claws,
to provide an alternate local name for each imported name.
This local name is often called an alias.
I will go back to using sleep instead of sleep mode to refer to the input string.
I will use this new variation of the imported statement to
change the imported local name from sleep to pause,
which is more descriptive in this program.
The program output is correct.
Here are the generalized semantics of the import statement.
When the program starts,
the main module namespace contains the identifier as input and print,
each bound to a function object.
When the import statement is evaluated,
the identifier pause is added to the namespace
and bound to the sleep function object from the time module.
Next, the import function returns
a REM string object and
the assignment statement binds the sleep identifier to this object.
The print function call displays the string object.
The next statement is a function call whose function name is pause.
The interpreter dereferences the pause identifier to obtain a function object.
So, the program continues as intended.
The name conflict has been eliminated.
Another variation of the import statement does not use the keyword from.
Here's a new syntax diagram for the import statement that supports both the
from variation that you have already seen and the new non-from variation.
Here's the from variation you have already seen.
Here is a syntax diagram for the new non-from variation.
If this new variation is used,
then when an identifier from an important module is used,
it must be used as an attribute of that module.
For example, here's a version of the sleep program that uses this variation,
and the program output is correct.
Here are the semantics of the non-from variation of the import statement.
When the program starts
the main module namespace contains the identifier's input and print,
each bound to a function object.
When the import statement is evaluated,
the identifier time is added to the namespace and bound to the time module object.
None of the identifiers in the time module are bound in the main modules namespace,
just the name of the module itself.
Next, the input function returns
a REM string object and
the assignment statement binds the sleep identifier to this object.
The print function call displays this string object.
The next statement is a function call whose function name is time.sleep.
This is an attribute reference.
An attribute reference is necessary because
only the module name is in the main modules namespace.
The name of the sleep function is not.
Recall the syntax and semantics of attribute reference from the method calls lesson.
First, the interpreter evaluates the expression time to obtain an object.
In this case, it is the time module object.
Second, the interpreter checks if
the attribute sleep is in the namespace of the time module object.
Since sleep is a function defined in the time module,
sleep is in time's namespace.
So, the sleep function object is attained.
The interpreter applies this function to the argument list,
which is a single integer object one,
and the sleep function pauses for one second.
The program continues as intended.
The name conflict has been eliminated.
In Python, modules can be defined inside of other modules.
A module inside another module is called a submodule.
To import objects from a submodule,
I will generalize the syntax diagram for module itself.
Previously, a module name was assumed to be a single identifier.
So, we used this syntax diagram for module.
To access objects from a submodule,
I can use this generalized syntax for module
as a sequence of identifiers separated by dots.
For example, the standard library contains a module called OS,
which provides access to operating system functions and other objects.
Inside the OS module,
is a submodule called path that contains a function called isFile.
The isFile function returns true if it's string argument is the name of
a file that exists in the folder that Python is run from and false otherwise.
I can use this generalized syntax for module to access this function.
I will call the isFile function on the string sleep.py
and the function returns true since the file that my programming is in certainly exists.
I will call the isFile function on the string snuvs.py and
the function returns false since there's no file
called snuvs.py in my Python program folder.
In this video, I generalize the import statements so it can be used to
resolve name conflicts and to import objects from submodules,
which are modules inside of other modules.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2018 Coursera Inc. Tous droits réservés.
