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 Keyword Operator, Short Circuit Evaluation, Unary Expression, and Operator Precedence
Loading...
Do curso por University of Alberta
Problem Solving, Programming, and Video Games
5 classificações
Na lição
Module 4: Hacking Version 3
In Module 4, you will modify your game design to support multiple gameplay paths using a new problem decomposition criteria called case-based decomposition, which utilizes a selection control structure. You will learn one new Python statement (if), one new Python expression (unary expression), and one new Python type (bool). You will employ these Python constructs to write, test, and debug Hacking Version 3.
Conheça os instrutores
Duane SzafronProfessor
Computing Science
Paul LuProfessor
Computing Science
In this lesson, we introduce four concepts.
First, we describe keywords that behave as operators.
Second, we describe a special evaluation technique
used by Boolean operators called short-circuit evaluation.
Third, we introduce a new expression called a unary expression.
Finally, we described the operation order Python
uses for computations that contain more than one operator.
Recall that operator tokens,
such as plus and less than,
are used in binary expressions to apply an operator function to two operands.
There are 19 operator tokens.
Some Python keywords can also be used as operators.
Let's look more closely at all of the keywords.
You've seen that some keywords,
such as from, import,
and if, are used as delimiters to punctuate statements.
In fact, 26 of 33 keywords
are used as delimiters to separate different parts of statements.
You have also seen that some keywords,
such as true and false,
are used as literals that are bound to specific objects.
In fact, none is also used as a keyword literal,
and it is bound to an object whose type is NoneType,
which is returned by function calls that don't really need to return a meaningful object.
The other four keywords,
and, is, not, and or,
are used as operators,
and the keyword in can actually be used as an operator or delimiter depending on context.
I will revise the syntax diagram for binary operator by
adding the keyword operators that can be used as binary operators.
Notice that in addition to and,
in, is and or,
there are two keyword operator pairs: not in and is not.
They can each be used as a single binary operator.
I've added some new binary operators,
but the semantic rule for binary expressions does not change.
For example, I will apply
the binary expression semantics to the expression false and unbound.
In step one, the left expression is the keyword literal false,
which evaluates to the Boolean object false.
In step two, the operator is and.
Well, the type of the first operand is Boolean since the operand is false.
Normally, both the operator and
operand type are needed to identify the operator function.
However, when the operator is and,
the type of the first operand is actually ignored.
The and operator always invokes
the same operator function regardless of the first operand type.
In step three, the interpreter applies this operator function and.
The operator function and uses a technique called short-circuit evaluation,
where the result object may not depend on the second operand.
Here are the semantics of the and operator function.
One, if the first operand is interpreted as false,
the first operand is the result object.
Two, otherwise, evaluate the second expression as the result object.
In step one, the first operand is false,
so this first operand object false is returned.
Step two is skipped,
so the second expression is not even evaluated.
If the second expression was evaluated,
it would have displayed a semantic name error,
since I did not bind to the identifier unbound to any object.
The and operator function has another interesting property.
In step one, the first operand is the empty string,
which you may recall is interpreted as false in an if statement condition.
The and operator function semantics interpret non-Boolean objects the same way.
So, the empty string is interpreted as false.
Therefore, the empty string is the result object.
If I had used zero or 0.0 instead of the empty string,
the expression would evaluate to zero or 0.0 respectively.
Again, step two is skipped,
so the second expression is not evaluated and no semantic name error is displayed.
If the first operand is not interpreted as false,
the second expression is evaluated.
For example, if I evaluate hello and goodbye,
the interpreter returns goodbye.
In step one, the first operand is the string hello,
which is interpreted as true.
Since it is not interpreted as false,
the second step is applied.
In step two, the second expression evaluates to the string goodbye,
which is used as the result object.
The or operator function also uses short-circuit semantics,
if the first operand is interpreted as true,
the first operand is the result object.
Otherwise, evaluate the second expression as the result object.
Notice that neither of the operator token tilde nor the keyword operator not,
by itself, can be used as a binary operator.
Instead, both are unary operators that act on a single operand.
Here is the syntax diagram for a unary expression.
Here's a more general syntax diagram for expression that now includes unary expressions.
The plus and minus operator tokens can be used either as binary or unary operators.
The semantics of unary expressions is similar to the semantics of binary expressions,
except that there is only one operand to evaluate.
For example, I will apply the unary expression semantics to minus 27.
In step one, the expression is the literal integer 27,
which evaluates to the int object 27.
In step two, the unary operator minus and
the type int are used to identify the numerical negation function,
which reverses the sign of its integer operand object.
In step three, the numerical negation function is applied to the int object
27 to obtain the int object negative 27.
Notice that negative 27 is not a literal integer.
It is a unary expression that applies
the minus operator to an integer object to obtain a result object.
If more than one operator appears in an expression,
the Python interpreter must select in order for the operations.
For example, in the expression three plus four star five,
there are two operators: plus and star.
If the Python interpreter applies these operators in order from left to right,
then three plus four is seven and seven times five is 35.
Thirty-five is not the correct answer.
Twenty-three is.
Python applies the star operator before applying the plus operator,
analogist to the order of operations in mathematics.
Python has an operator precedence table that defines the order that should
be used to apply multiple operators in the same expression.
Operators that are below in the table have higher precedence,
and are applied before operations that are above in the table.
For example, star is applied before plus,
since it is below plus in the table.
That is why three plus four star five evaluates to 23 instead of 35.
You should recognize many of the operators in
this table such as the operator tokens plus,
times, and less than and the keyword operators and and or.
In this lesson, we described keywords that behave as operators.
We also described a special evaluation technique used
by Boolean operators called short-circuit evaluation,
a new kind of expression called the unary expression,
and what operation order Python uses for
computations that contain more than one operator.
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.
