Python Keyword Operator, Short Circuit Evaluation, Unary Expression, and Operator Precedence

Loading...

Do curso por University of Alberta

Problem Solving, Programming, and Video Games

ratings

University of Alberta

Problem Solving, Programming, and Video Games

ratings

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.

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.

Python Keyword Operator, Short Circuit Evaluation, Unary Expression, and Operator Precedence7:39

Conheça os instrutores

Duane Szafron
Professor
Computing Science
Paul Lu
Professor
Computing Science

[MUSIC]

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 kind of expression called a unary expression.

Finally, we describe the operation order Python uses for

computations that contain more than one operator.

Recall that operator tokens such as + and

< 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 have seen that some keywords such as from, import, and

if are used as delimiters to punctuate statements.

In fact, 26 of the 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 objective whose type is non-type, which is returned by function

calls that don't really need to return a meaningful object.

The other four key words 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 operators

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, that 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 1, the left expression is the key word literal false,

which evaluates to the Boolean object false.

In step 2, the operator is and,

while 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 3, 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 1, the first operand is false.

So this first operand object, false is returned.

Step 2 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 the identifier unbound to any object.

The and operator function has another interesting property.

In step 1, 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 0 or 0.0 instead of the empty string,

the expression would evaluate to 0 or 0.0 respectively.

Again, step 2 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 1, 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 2, the second expression of values 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 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's the syntax diagram for a unary expressions.

And 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 -27.

In step 1, the expression is the literal integer 27,

which evaluates to the int object 27.

In step 2, 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 3, the numerical navigation is applied to the int

object 27 to obtain the int object -27.

Notice that -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 an order for the operations.

For example, in the expression 3 + 4 * 5,

there are two operators, + and *.

If the python interpreter applies these operators in order from

left to right, then 3 + 4 is 7, and 7 times 5 is 35.

35 is not the correct answer, 23 is.

Python applies the star operator before applying the plus operator,

analogous 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 3 + 4 * 5 evaluates to 23 instead of 35.

You should recognize many of the operators in this table such as the operator

tokens +, x and <, and the keyword operators and and or.

In this lesson, we described keywords or behavior operators.

We also describe 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.

Baixar na App Store

Baixar no Google Play