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 Semantics of Literals and Identifiers
Loading...
Do curso por University of Alberta
Problem Solving, Programming, and Video Games
5 classificações
Na lição
Module 2: Program Hacking Version 1
In Module 2, you will discover how lexics, syntax, and semantics can be used to understand and describe programming languages. You will use these concepts to understand your first Python statement (expression statement), first three Python expressions (literal, identifier, function call), and first five Python types (int, str, float, function, NoneType). You will use these Python constructs to write, test, and debug Hacking Version 1, a text-based game version. You will then reflect on your game version by using a third problem-solving technique called abstraction, including the specific technique of solution generalization, to solve similar problems.
Conheça os instrutores
Duane SzafronProfessor
Computing Science
Paul LuProfessor
Computing Science
[MUSIC]
This video introduces the Python programming language semantics of
literals and identifiers.
Recall the interpretation process that Python uses to evaluate a statement.
Lexical analysis creates tokens, syntax analysis validates the token order.
And semantic analysis defines the meaning of a statement by evaluating it.
We will use simplified semantic rules to define the meaning of Python statements.
Recall that an expression statement consists of a single expression
that can be either a literal, identifier, or a function call.
We have already defined literal and identifier tokens.
We have also defined the syntax of an expression that consists
of a single literal token or a single identifier token.
To define the semantics of literals and identifiers,
we need to first examine why they are used in python expressions.
Human readable representations of objects are used in expressions,
so that people can understand these objects.
The interpreter must translate these human readable object representations into
objects in the computer memory, so computations can be performed on them.
The simplest way to represent an object in an expression is to use a literal.
A literal represents an object by describing it.
The literal contains all of the information necessary to create an object.
The semantics of a literal expression are simple,
create a new object for the literal.
For example, when the interpreter evaluates the literal token 300,
it creates a new integer object.
A literal in an expression is analogous to a coupon or
a voucher in the real world that can be exchanged for an item.
The coupon is just a representation of the item, it is not actually the item.
Once the coupon is exchanged for the item, the coupon is no longer necessary.
Similarly, a literal is not an object,
it just represents that object in the expression.
Once the literal is used to create an object in memory,
the literal is no longer necessary, only the object is needed.
If the interpreter encounters the literal token 300 in
another expression, it creates another integer object.
Recall that the id function returns a different identity number for
each different object.
The id function can be used to determine whether another use of
the same literal actually creates another object,
or reuses the object that was previously created.
For example, using the literal 300 twice,
Creates two different objects, since their ids are different.
Each Python interpreter has its own strategy for reusing objects created for
literals, and the strategy depends on the literal.
For example, this interpreter reuses the integer objects for
all literal integers between -5 and 256, but
creates new objects each time any other literal integer is used.
To simplify the semantics of literals, we ignore whether or
not a particular interpreter reuses the same object for
multiple appearances of the same literal.
We define the semantics of a literal as creating a new object each time
the literal is evaluated.
Reusing objects for literals only affects how fast Python code is evaluated,
it does not usually affect the code results.
In addition to literals, Python uses identifiers,
also called names, to represent objects in an expression.
An identifier represents an object in an expression by referencing that object.
We say that an identifier is bound to an object, and
use an arrow to denote the binding.
For example, the identifier len represents a function object.
An identifier in an expression is analogous to the name or role of a person.
People refer to us by name or role, but the name or
role is just a label, it is not actually a person.
Just as people can use a name or role to refer to the same person more than once,
an identifier can refer to the same object more than once.
An identifier is a persistent representation of an object,
while all of the expressions in a shell or program are evaluated.
A literal is only a temporary representation,
until the object it represents is created.
Python uses a namespace to allow identifiers to persist during evaluation.
A namespace associates each name that
appears in a Python expression with the object that it is bound to.
Thus the len identifier is associated or bound to a function object.
A namespace is like a dictionary, except instead of looking up a word and finding
a definition, the interpreter looks up a name and finds the object it is bound to.
This step is called dereferencing.
Dereferencing is the act of translating an identifier into
the memory object it is bound to during Python code evaluation.
This process is like looking for a restaurant name online.
You enter the name of the restaurant in your browser or app, and
you are given its location, which you use to find the restaurant in the real world.
When we open a Python shell, or run a Python program, the interpreter creates
a namespace and pre-binds many identifiers before evaluating our code.
For example,
the interpreter creates a function object that computes the length of a sequence.
It then adds the name len to the namespace, and
binds this name to the function object.
The interpreter pre-binds the names of all the built in functions.
For example, it binds the id and type function names as well.
If the names of he built in functions weren't pre-bound,
we would have no way to refer to them, so we could not use them.
The interpreter also pre-binds the name of each built in type to
a type object, and pre-binds many other identifiers as well.
You can use the built in function dir to see all of the built-in identifiers.
Notice the built-in function names len and
id, and the built-in type names str, int and float.
Also notice the names of some familiar errors, such as SyntaxError and NameError.
In our diagrams, we won't show all of the pre-bound identifiers,
we will only show the pre-bound names that we will use for
a particular Python shell example or program.
Here are the semantics of an identifier expression.
If the identifier is in the namespace,
dereference it to get the result object, otherwise report an error.
For example, if we evaluate an expression containing the identifier len,
the interpreter finds len in the namespace and
dereferences it to obtain the function object.
Let's evaluate an identifier hello that is not in the namespace.
This expression contains one token, the identifier hello.
The interpreter applies a semantic rule for identifier expressions.
It checks if the identifier hello is in the namespace.
Since hello is not prebound to a built-in function, type, or
any other kind of object, it is not in the namespace.
The interpreter reports a semantic error.
Since there is no result object, only the error is displayed.
We will discuss how to bind identifiers that are not pre-bound in later lessons.
A name tag can be worn by one person, and then worn by a different person later.
For example,
while driving a bus a person may wear a driver name tag to represent their role.
When a different person replaces the first driver, the driver name tag
can be detached from the first person and used by the second person.
An identifier is like a name tag, since we will discover in a future lesson
that an identifier can be bound to different objects at different times.
However, an identifier in a namespace
cannot be bound to two different objects at the same time.
As an analogy, there cannot be two people with the same driver role on one bus.
There is only one driver name tag on the bus, and
it can only be attached to one person at a time.
This video introduced the Python programming language semantics for
literals and identifiers.
Python places identifiers in a namespace and
reuses them when multiple expressions are evaluated.
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2018 Coursera Inc. Todos os direitos reservados.
