2.1.

1 Questions and answers

A programmer writes a program and the program asks questions.

A computer executes the program and provides the answers. The
program must be able to react according to the received answers.
Fortunately, computers know only two kinds of answers:

yes, this is true

or
no, this is false.

You will never get a response like Let me think....I don’t

know or Probably yes, but I don’t know for sure.

To ask questions, Python uses a set of very special operators.

Let’s go through them one after another, illustrating their effects on
some simple examples.

2.1.2 Questions and answers

Question: are two values equal?

To ask this question, you use the == (equal equal) operator.

Don’t forget this important distinction:

1. = is an assignment operator (a = b assigns awith the value

of b)

2. == is the question are these values equal? (a ==

b compares a and b)
It is a binary operator with left-sided binding. It needs two
arguments and checks if they are equal.
Now let’s ask a few questions. Try to guess the answers.

2.1.3 Equality

This question is easy. Of course, 2 is equal to 2.

Python will answer True (remember this pair of predefined
literals, True and False – they’re Python keywords, too).

2.1.4 Equality

This question is not as easy as the first one.

Luckily, Python is able to convert the integer value into its real
equivalent, and consequently, the answer is True.

2.1.5 Equality

This is easy, too. The answer will be (or rather, always is) False.
2.1.6 Equality

Note that we cannot find the answer if we do not know what value
is currently stored in the variable var.

If the variable has been changed many times during the execution
of your program, or its initial value is entered from the console, the
answer to this question can be given only by Python and only at
runtime.
2.1.7 Equality

Imagine a programmer who suffers from insomnia, and has to count

black and white sheep separately as long as there are exactly twice
as many black sheep as white ones.
The question will be as follows →

Due to the low priority of the == operator, the question shall be

treated as equivalent to this one:

BlackSheep == (2 * WhiteSheep)

2.1.8 Greater than

You can also ask this question using the > (greater than) operator.
If you want to know if there are more black sheep than white ones,
you can write it as follows →
True confirms it; False denies it.

2.1.9 Greater than or equal to

The greater than operator has another special, non-strict variant,

but it’s denoted differently than in classical arithmetic
notation: >= (greater than or equal to).
There are two subsequent signs, not one.
Both of these operators (strict and non-strict), as well as the two
others discussed in the next section, are binary operators with left-
sided binding, and their priority is greater than that shown
by == and !=.
If we want to find out whether or not we have to wear a warm hat,
we ask the following question →

2.1.10 Less than or equal to

As you’ve probably already guessed, the operators used in this case

are: the < (less than) operator and its non-strict sibling <= (less
than or equal to). Look at this simple example →
We’re going to check if there’s a risk of being fined by the highway
police (the first question is strict, the second isn’t).

2.1.11 Making use of the answers

What can you do with the answer you get from the computer?
There are at least two possibilities: first, you can memorize it (store
it in a variable) and make use of it later. How do you do that? Well,
you would use an arbitrary variable like this →

The content of the variable will tell you the answer to the question
asked.

2.1.12 Priorities updated

The second possibility is more convenient and far more common:

you can use the answer you get to make a decision about the future
of the program.
You need a special instruction for this purpose, and we’ll discuss it
very soon.
Now we need to update our priority table, and put all the new
operators into it. It now looks as follows →
Practice Lab

 Lab PCA_2_1_12_1_A Questions and Answers:

Launch in Edube | Launch Sample Solution

2.1.13 Conditions and conditional execution

You already know how to ask Python questions, but you still don’t
know how to make reasonable use of the answers. You have to
have a mechanism which will allow you to do something if a
condition is met, and not do it if it isn’t.
It’s just like in real life: you do certain things or you don’t when a
specific condition is met or not, e.g., you go for a walk if the
weather is good, or stay home if it’s wet and cold.
To make such decisions, Python offers a special instruction. Due to
its nature and its application, it’s called a conditional instruction (or
conditional statement).
There are several variants of it. We’ll start with the simplest,
increasing the difficulty slowly.
The first form of a conditional statement, which you can see to the
side, is written very informally but figuratively →

This conditional statement consists of the following, strictly

necessary, elements in this and this order only:

 the if keyword;

 one or more white spaces;

 an expression (a question or an answer) whose value will be

interpreted solely in terms of True(when its value is non-zero)
and False (when it is equal to zero);

 a colon followed by a newline;

 an intended instruction or instructions (at least one instruction is

absolutely required); the indentation may be achieved in two
ways – by inserting a particular number of spaces, or by using
the tab character (the latter way is recommended); note: if there
is more than one instruction in the indented part, the indentation
should be the same in all lines; it may look the same if you use
tabs mixed with spaces, but it’s important to make all
indentations exactly the same)

How does that statement work?

 If the true_or_not expression represents the truth (i.e., its

value is not equal to zero), the indented statement(s) will be
executed;

 if the true_or_not expression does not represent the truth (i.e.,

its value is equal to zero), the indented statement(s) will be
 omitted (ignored), and the next executed instruction will be the
one after the original indentation level.

2.1.14 Conditions and conditional execution

In real life, we often express a desire:

if the weather is good, we’ll go for a walk

then, we’ll have lunch

As you can see, having lunch is not a conditional activity and

doesn’t depend on the weather.
Knowing what conditions influence our behavior, and assuming that
we have the parameterless
functions GoForAWalk() and HaveLunch(), we can write the
following snippet →

2.1.15 Conditions and conditional execution

If a particular sleepless Python developer falls asleep when he or

she counts 120 sheep, and the sleep-inducing procedure may be
implemented as a special function named SleepAndDream(), the
whole code takes the following shape →
You can read it as: if SheepCounter is greater than or equal to 120,
then fall asleep and dream.

2.1.16 Conditions and conditional execution

We’ve said that conditionally executed statements have to be

indented. This creates a very legible structure, clearly
demonstrating all possible execution paths in the code.
Take a look at the following code →

As you can see, making a bed, taking a shower and falling asleep
are all executed conditionally – when SheepCounter reaches the
desired limit.
Feeding the sheepdogs, however, is always done.
Now we’re going to discuss another variant of the conditional
statement, which also allows you to perform an additional action
when the condition is not met.

2.1.17 More conditional execution

We started out with a simple phrase which read: If the weather is
good, we will go for a walk.

Note – there is not a word about what will happen if it rains. We

only know that we won’t go outdoors, but what we could do instead
is not known. We may want to plan something in case of bad
weather, too.
We can say, for example: If the weather is good, we will go for a
walk, otherwise we will go to a theater.

Now we know what we’ll do if the conditions are met, and we know
what we’ll do if not everything goes our way. In other words, we
have a “Plan B”.
Python allows us to express such alternative plans. This is done with
a second, slightly more complex form of the conditional statement –
here it is →

Thus, there is a new word: else – this is a keyword.

The part of the code which begins with else says what to do if the
condition specified for the if is not met (note the colon after the
word).

The if-else execution goes as follows:

 if the condition evaluates to True (its value is not equal to zero),

the perform_if_condition_true statement is executed, and the
conditional statement comes to an end;
 if the condition evaluates to False (it is equal to zero),
the perform_if_condition_falsestatement is executed, and the
conditional statement comes to an end.

2.1.18 More conditional execution

By using this form of conditional statement, we can describe our

plans as follows →

2.1.19 More conditional execution

Everything we’ve said about indentation works in the same manner

inside the else branch.
This how it looks →
2.1.20 More conditional execution

Now let’s discuss two special cases of the conditional statement.

First, consider the case where the instruction placed after the if is
another if.
Read what we have planned for this Sunday. If the weather is fine,
we’ll go for a walk. If we find a nice restaurant, we’ll have lunch
there. Otherwise, we’ll eat a sandwich. If the weather is poor, we’ll
go to the theater. If there are no tickets, we’ll go shopping in the
nearest mall.
Let’s write the same in Python. Consider carefully the code here →

Here are two important points:

 this use of the if statement is known as nesting; remember that

every else refers to the if which lies at the same indentation
level; you need to know this to determine how
the ifs and elses pair up;

 consider how the indentation improves readability, and makes

the code easier to understand and trace.
2.1.21 More conditional execution

The second special case introduces another new Python

keyword: elif. As you probably suspect, it’s a shorter form of else
if.
elif is used to check more than just one condition, and to stop
when the first statement which is true is found.

Our next example resembles nesting, but the similarities are very
slight. Again, we’ll change our plans and express them as follows: If
the weather is fine, we’ll go for a walk, otherwise if we get tickets,
we’ll go to the theater, otherwise if there are free tables at the
restaurant, we’ll go for lunch; if all else fails, we’ll return home and
play chess.
Have you noticed how many times we’ve used the word
“otherwise”? This is the stage where the elifkeyword plays its role.
Let’s write the same scenario using Python →

The way to assemble subsequent if-elif-elsestatements is

sometimes called a cascade.
Notice again how the indentation improves the readability of the
code.
Some additional attention has to be paid in this case:

 you mustn’t use else without a preceding if;

 else is always the last branch of the cascade, regardless of

whether you’ve used elif or not;

 else is an optional part of the cascade, and may be omitted;

 if there is an else branch in the cascade, only one of all the

branches is executed;

 if there is no else branch, it’s possible than none of the available

branches is executed.

This may sound a little puzzling, but hopefully some simple

examples will help shed more light.

2.1.22 Some simple examples

Now we’re going to show you some simple yet complete programs.
We won’t explain them in detail, because we consider the comments
inside the code to be sufficient guides.
All the programs solve the same problem – they find the largest of
several numbers and print it out. We’ll start with the simplest case –
how to identify the larger of two numbers →
This snippet should be clear – it reads two integer values, compares
them, and finds which is the larger.
Now we’re going to show you one intriguing fact.

Practice Lab

 Lab PCA_2_1_22_1_A Assignment operators and conditional

execution:
Launch in Edube | Launch Sample Solution

2.1.23 Some simple examples

Python has an interesting feature – this is it here →

Note: if any of the if-elif-else branches contains just one
instruction, you may code it in a more comprehensive form (you
don’t need to make an indented line after the keyword, but just
continue the line after the colon).

We personally think it’s ugly and misleading, and we’re not going to
use this style in our future programs, but it’s definitely worth
knowing if you want to read and understand someone else’s
programs.
There are no other differences in the code.
It’s time to complicate the code – let’s find the largest of three
numbers. Will it enlarge the code? A bit.

2.1.24 Some simple examples

Let’s try to find the largest of three numbers.

We assume that the first value is the largest. Then we verify this
hypothesis with the two remaining values.
Here we go →
This method is significantly simpler than trying to find the largest
number all at once, by comparing all possible pairs of numbers (i.e.,
first with second, second with third, third with first).
Try to rebuild the code for yourself.

2.1.25 Some simple examples

You should now be able to write a program which finds the largest
of four, five, six, or even ten numbers.
You already know the scheme, so extending the size of the problem
will not be particularly complex.
But what happens if we ask you to write a program that finds the
largest of two hundred numbers? Can you imagine the code?
You’ll need two hundred variables. If two hundred variables isn’t
bad enough, try to imagine searching for the largest of a million
numbers.
Imagine a code that contains 199 conditional statements and two
hundred invocations of the input() function.
Luckily, you don’t need to deal with that. There’s a simpler
approach.

2.1.26 Some simple examples

We’ll ignore the requirements of Python syntax for now, and try to
analyze the problem without thinking about the real programming.
In other words, we’ll try to write the algorithm, and when we’re
happy with it, we’ll implement it.
In this case, we’ll use a kind of notation which is not an actual
programming language (it can be neither compiled nor executed),
but it is formalized, concise and readable.
It’s called pseudocode.
There’s an example of pseudocode here →

Take a look at it. What’s happening in it?

Firstly, we can simplify the program if, at the very beginning of the
code, we assign the variable maxwith a value which will be smaller
than any of the entered numbers. We’ll use -999999999 for that
purpose.
Secondly, we assume that our algorithm will not know in advance
how many numbers will be delivered to the program. We expect
that the user will enter as many numbers as she/he wants – the
algorithm will work well with one hundred and with one thousand
numbers. How do we do that?

We make a deal with the user: when the value -1is entered, it will
be a sign that there are no more data and the program should end
its work.
Otherwise, if the entered value is not equal to -1, the program will
read another number, and so on.
The trick is based on the assumption that any part of the code can
be performed more than once – precisely, as many times as
needed.
Performing a certain part of the code more than once is called a
loop. The meaning of this term is probably obvious to you.
Lines 02 through 08 make a loop. We’ll pass through them as many
times as needed to review all the entered values.
Can you use a similar structure in a program written in Python?
Yes, you can.

Practice Labs

 Lab PCA_2_1_26_1_A-B Essentials of the if-else statement:

Launch in Edube | Launch Sample Solution
 Lab PCA_2_1_26_2_A-B Essentials of the if-elif-
else statement:
Launch in Edube | Launch Sample Solution

2.2.1 Looping your code with while

Do you agree with the statement presented here? →

Note that this record also declares that if there is nothing to do,
nothing at all will happen.

2.2.2 Looping your code with while

In general, in Python, a loop is as follows →

If you notice some similarities to the if instruction, that’s quite all

right. Indeed, the syntactic difference is only one: you use the
word while instead of the word if. The semantic difference is more
important: when the condition is met, if performs its statements
only once; while repeats the execution as long as the condition
evaluates to True.
Note: all the rules regarding indentation are applicable here, too.
We’ll show you this soon.
2.2.3 Looping your code with while

Let’s take a look at some specific comments:

 if you want to execute more than one statement inside

one while, you must (as with if) indent all the instructions in the
same way – take a look here →

 an instruction or set of instructions executed inside

the while loop is called the loop’s body;
 if the condition is False (equal to zero) as early as when it is
tested for the first time, the body is not executed even once
(note the analogy of not having to do anything if there is nothing
to do)
 the body should be able to change the condition’s value, because
if the condition is True at the beginning, the body might run
continuously to infinity – notice that doing a thing usually
decreases the number of things to do)

2.2.4 Looping your code with while

Here’s an example of a loop that is not able to finish its execution →

This loop will infinitely print “I’m stuck inside a loop” on the screen.
Let’s go back to the sketch of the algorithm we showed you
recently. We’re going to show you how to use this newly learned
loop to find the largest number from a large set of entered data.

2.2.5 Looping your code with while

Analyze the program carefully. Locate the loop’s body and find out
how the body is exited.
Check how this code implements the algorithm we showed you
earlier.
2.2.6 Looping your code with while

Let’s look at another example employing the whileloop →

Follow the comments to find out the idea and the solution.
Certain expressions can be simplified without changing the
program’s behavior. Take a look at the next slide.

Practice Lab
Lab PCA_2_2_6_1_A Essentials of the while loop - Guess the secret
number:
Launch in Edube | Launch Sample Solution
2.2.7 Looping your code with while

Try to recall how Python interprets the truth of a condition, and note
that these two forms are equivalent →

2.2.8 Looping your code with while

The condition that checks if a number is odd can be coded in these

equivalent forms →

2.2.9 Looping your code with while

This code is intended to repeat the introduction exactly five times.

But there’s one things that can be written more compactly – the
condition of the while loop.
2.2.10 Looping your code with while

Can you see the difference?

Is it more compact than previously? A bit.
Is it more legible? That’s disputable.
Don’t feel obliged to code your programs in a way that is always the
shortest and the most compact. Readability may be a more
important factor. Keep your code ready for a new programmer.

2.2.11 Looping your code with while

Another kind of loop available in Python comes from the observation

that sometimes it’s more important to count the “turns” of the loop
than to check the conditions.
Imagine that a loop’s body needs to be executed exactly one
hundred times. If you would like to use the while loop to do it, it
may look like this →

It would be nice if somebody could do this boring counting for you.

Is that possible?
Of course it is – there’s a special loop for these kinds of tasks, and it
is named for.
Actually, the for loop is designed to do more complicated tasks – it
can “browse” large collections of data item by item. We’ll show you
how to do that soon, but right now we’re going to present a simpler
variant of its application.

2.2.12 Looping your code with for

Take a look at the snippet →

There are some new elements. Let us tell you about them:

 the for keyword opens the for loop; note – there’s no condition
after it; you don’t have to think about conditions, as they’re
checked internally, without any intervention;
 any variable after the for keyword is the control variable of the
loop; it counts the loop’s turns, and does it automatically;
 the in keyword introduces a syntax element describing the range
of possible values being assigned to the control variable;
 the range() function (this is a very special function) is
responsible for generating all the desired values of the control
variable; in our example, the function will create (we can even
say that it will feed the loop with) subsequent values from the
following set: 0, 1, 2 .. 97, 98, 99; note: in this case,
the range() function starts its job from 0 and finishes it one step
(one integer number) before the value of its argument;
 note the pass keyword inside the loop body – it does nothing at
all; it’s an empty instruction – we put it here because
the for loop’s syntax demands at least one instruction inside the
 body (by the way – if, elif, else and while express the same
thing)

Our next examples will be a bit more modest in the number of loop
repetitions.
2.2.13 Looping your code with for

Take a look at the snippet →

Can you predict its output?

2.2.14 Looping your code with for

This is the answer →

Note:
 the loop has been executed ten times (it’s the range() function’s
argument)
 the last control variable’s value is 9 (not 10, as it starts from 0,
not from 1)

2.2.15 Looping your code with for

The range() function invocation may be equipped with two

arguments, not just one →

In this case, the first argument determines the initial (first) value of
the control variable.
The last argument shows the first value the control variable will not
be assigned.
Note: the range() function accepts only integers as its arguments,
and generates sequences of integers.
Can you guess the output of the program?

2.2.16 Looping your code with for

Here it is →
The first shown value is 2 (taken from the range()’s first argument)
The last is 7 (although the range()’s second argument is 8).

2.2.17 Looping your code with for

The range() function may also accept three arguments– take a

look →

The third argument is an increment – it’s a value added to control

the variable at every loop turn (as you may suspect, the default
value of the increment is 1).
Can you tell us how many lines will appear in the console and what
values they will contain?

2.2.18 Looping your code with for

These are the two expected lines →

2.2.19 Looping your code with for

Note: if the set generated by the range() function is empty, the

loop won’t execute its body at all.

Just like here – there will be no output →

2.2.20 Looping your code with for

Note: the set generated by the range() has to be sorted in

ascending order. There’s no way to force the range() to create a
set in a different form. This means that the range()’s second
argument must be greater than the first.
Thus, there will be no output here, either →

2.2.21 Looping your code with for

Let’s have a look at a short program whose task is to write some of

the first powers of two →
The exp variable is used as a control variable for the loop, and
indicates the current value of the exponent. The exponentiation
itself is replaced by multiplying by two. Since 2 0 is equal to 1, then 2
× 1 is equal to 21, 2 × 21 is equal to 22, and so on. What is the
greatest exponent for which our program still prints the result?

Practice Lab
Lab PCA_2_2_21_1_A Essentials of the for loop - counting
mississipply:
Launch in Edube | Launch Sample Solution

2.2.22 The break and continue statements

So far, we’ve treated the body of the loop as an indivisible and

inseparable sequence of instructions that are performed completely
at every turn of the loop. However, as developer, you could be
faced with the following choices:

 it appears that it’s unnecessary to continue the loop as a whole;

you should refrain from further execution of the loop’s body and
go further;
 it appears that you need to start the next turn of the loop without
completing the execution of the current turn.

Python provides two special instructions for the implementation of

both these tasks. Let’s say for the sake of accuracy that their
existence in the language is not necessary – an experienced
programmer is able to code any algorithm without these
instructions. Such additions, which don’t improve the language’s
expressive power, but only simplify the developer’s work, are
sometimes called syntactic candy,or syntactic sugar.
These two instructions are:

 break – exits the loop immediately, and unconditionally ends the

loop’s operation; the program begins to execute the nearest
instruction after the loop’s body;
 continue – behaves as if the program has suddenly reached the
end of the body; the next turn is started and the condition
expression is tested immediately.

Both these words are keywords.

Now we’ll show you two simple examples. Let’s return to our
program that recognizes the largest among the entered numbers.
We’ll convert it twice, using both instructions. Analyze the code, and
judge whether and how you would use either of them.
The break variant goes here →

Practice Lab
Lab PCA_2_2_22_1_A The break statement - stuck in a loop:
Launch in Edube | Launch Sample Solution

2.2.23 The break and continue statements

And now the continue variant →

Practice Lab
Lab PCA_2_2_23_1_A The continue statement - the Great Vowel
Eater:
Launch in Edube | Launch Sample Solution

2.2.24 Loops and else

Both loops, while and for, have one interesting (and rarely used)
feature.
We’ll show you how it works – try to judge for yourself if it’s usable
and whether you can live without it or not.
In other words, try to convince yourself if the feature is valuable
and useful, or is just syntactic sugar.
Take a look at the snippet →

There’s something strange at the end – the elsekeyword.

As you may have suspected, loops may have the else branch too,
like ifs.
The loop’s else branch is always executed once, regardless of
whether the loop has entered its body or not.
Can you guess the output?

2.2.25 Loops and else

This is what it looks like →

2.2.26 Loops and else

We’ve modified the snippet a bit – the loop has no chance to
execute its body even once →

The while’s condition is False at the beginning – can you see it?

2.2.27 Loops and else

As you can see, the else branch has been executed despite that →

2.2.28 Loops and else

for loops behave a bit differently – take a look at the snippet →

The output may be a bit surprising.

2.2.29 Loops and else

Here it is →

Note: the i variable retains its last value here.

2.2.30 Loops and else

This is our last experiment →

The loop’s body won’t be executed here at all.

Note: we’ve assigned the i variable before the loop.
2.2.31 Loops and else

Here’s the puzzle’s solution →

When the loop’s body isn’t executed, the control variable retains the
value it had before the loop.
Note: if the control variable doesn’t exist before the loop starts, it
won’t exist when the execution reaches the else branch.
How do you feel about this variant of else?
Now we’re going to tell you about some other kinds of variables.
Our current variables can only store one value at a time, but there
are variables that can do much more – they can store as many
values as you want.

Practice Labs

 Lab PCA_2_2_31_1_A-B Essentials of the whileloop:

Launch in Edube | Launch Sample Solution

 Lab PCA_2_2_31_2_A-B Collatz's hypothesis:

Launch in Edube | Launch Sample Solution

2.3.1 Computer logic

Have you noticed that the conditions we’ve used so far have been
very simple, not to say, quite primitive? The conditions we use in
real life are much more complex. Let’s look at this sentence:
If we have some free time, and the weather is good, we will go for a
walk.
We’ve used the conjunction “and”, which means that going for a
walk depends on the simultaneous fulfilment of these two
conditions. In the language of logic, such a connection of conditions
is called a conjunction. And now another example:
If you are in the mall or I am in the mall, one of us will buy a gift for
Mom.
The appearance of the word “or” means that the purchase depends
on at least one of these conditions. In logic, such a compound is
called a disjunction.
It’s clear that Python must have operators to build conjunctions and
disjunctions. Without them, the expressive power of the language
would be substantially weakened. They’re called logical operators.

2.3.2 Pride and Prejudice

One logical conjunction operator in Python is the word and. It’s a

binary operator with a priority that is lower than the one expressed
by the comparison operators. It allows us to code complex
conditions without the use of parentheses like this one →

The result provided by the and operator can be determined on the

basis of the truth table.
If we consider the conjunction of:
Left and Right
the set of possible values of arguments and corresponding values of
the conjunction looks as follows →
2.3.4 To be or not to be

A disjunction operator is the word or. It’s a binary operator with a

lower priority than and (just like +compared to *). Its truth table is
as follows →

2.3.5 To be or not to be

In addition, there’s another operator that can be applied for

constructing conditions. It’s a unary operator performing a logical
negation. Its operation is simple: it turns truth into falsehood and
falsehood into truth. This operator is written as the word not, and
its priority is very high: the same as the unary +/-. Its truth table is
simple →
2.3.6 Some logical expressions

Note that the following conditions are pairwise equivalent →

2.3.7 Some logical expressions

You may remember De Morgan’s laws from school. They say that:
The negation of a conjunction is the disjunction of the negations.
The negation of a disjunction is the conjunction of the negations.
Let’s write the same thing using Python →

Note how the parentheses have been used to code the expressions
– we put them there to improve readability.
We should add that none of these two-argument operators can be
used in the abbreviated form known as op=. This exception is worth
remembering.
2.3.8 Logical values vs. single bits

Logical operators take their arguments as a whole regardless of how

many bits they contain. The operators are aware only of the value:
zero (when all the bits are reset) means False; not zero (when at
least one bit is set) means True. The result of their operations is
one of these values: False or True. This means that this snippet
will assign the value True to the j variable if i is not zero; otherwise,
it will be False.

2.3.9 Logical values vs. single bits

However, there are four operators that allow you to manipulate

single bits of data. They are called bitwise operators. They cover
all the operations we mentioned before in the logical context, and
one additional operator. This is the xor (as in exclusive or)
operator, and is denoted as ^ (caret). Here are all of them:

 & (ampersand) bitwise conjunction

 | (bar) bitwise disjunction
 ~ (tilde) bitwise negation
 ^ (caret) bitwise exclusive or (xor)

Let’s make it easier:

 & requires exactly two 1s to provide 1 as the result;

 | requires at least one 1 to provide 1 as the result;
 ^ requires exactly one 1 to provide 1 as the result.
Let us add an important remark: the arguments of these
operators must be integers; we must not use floats here.
The difference in the operation of the logical and bit operators is
important: the logical operators do not penetrate into the bit level
of its argument. They’re only interested in the final integer value.
Bitwise operators are stricter: they deal with every bit
separately. If we assume that the integer variable occupies 64 bits
(which is common in modern computer systems), you can imagine
the bitwise operation as a 64-fold evaluation of the logical operator
for each pair of bits of the arguments. This analogy is obviously
imperfect, as in the real world all these 64 operations are performed
at the same time (simultaneously).

2.3.10 Logical values vs. single bits

We’ll now show you an example of the difference in operation

between the logical and bit operations. Let’s assume that the
following assignments have been performed:
i = 15
j = 22
If we assume that the integers are stored with 32 bits, the bitwise
image of the two variables will be as follows →

2.3.11 Logical values vs. single bits

The assignment is given:

log = i and j
We are dealing with a logical conjunction here. Let’s trace the
course of the calculations. Both variables iandj are not zeros, so
will be deemed to represent True. Consulting the truth table for
the and operator, we can see that the result will be True. No other
operations are performed.

2.3.12 Logical values vs. single bits

Now the bitwise operation – here it is:

bit = i & j
The & operator will operate with each pair of corresponding bits
separately, producing the values of the relevant bits of the result.
Therefore, the result will be as follows →
These bits correspond to the integer value of six.

2.3.13 Logical values vs. single bits

Let’s look at the negation operators now. First the logical one:
logneg = not i
The logneg variable will be set to False – nothing more needs to be
done.
The bitwise negation goes like this:
bitneg = ~i
It may be a bit surprising: the bitneg variable value is -16. This
may seem strange, but isn’t at all. If you wish to learn more, you
should check out the binary numeral system and the rules
governing two’s complement numbers.

2.3.14 Logical values vs. single bits

Each of these two-argument operators can be used in abbreviated

form. These are the examples of their equivalent notations →
2.3.15 How do we deal with single bits?

We’ll now show you what you can use bitwise operators for.
Imagine that you’re a developer obliged to write an important piece
of an operating system. You’ve been told that you’re allowed to use
a variable assigned in the following way →

2.3.16 How do we deal with single bits?

The variable stores the information about various aspects of system

operation. Each bit of the variable stores one yes/no value. You’ve
also been told that only one of these bits is yours – the third
(remember that bits are numbered from zero, and bit number zero
is the lowest one, while the highest is number 31). The remaining
bits are not allowed to change, because they’re intended to store
other data. Here’s your bit marked with the letter x→

2.3.17 How do we deal with single bits?

You may be faced with the following tasks:

 check the state of your bit – you want to find out the value of
your bit; comparing the whole variable to zero will not do
anything, because the remaining bits can have completely
unpredictable values, but you can use the following conjunction
property:

x & 1 = x
x & 0 = 0
If you apply the & operation to the FlagRegister variable
along with the following bit image:
0000000000000000000000000000001000
(note the 1 at your bit’s position) as the result, you obtain one
of the following bit strings:
0000000000000000000000000000001000if your bit was set to 1
0000000000000000000000000000000000if your bit was reset
to 0
Such a sequence of zeros and ones, whose task is to grab the
value or to change the selected bits, is called a bit mask. Let’s
build a bit mask to detect the state of your bit. It should point
to the third bit. That bit has the weight of 23 = 8. A suitable
mask could be created by the following declaration:
TheMask = 8
You can also make a sequence of instructions depending on the
state of your bit – here it is →
2.3.18 How do we deal with single bits?

 reset your bit – you assign a zero to the bit while all the other
bits must remain unchanged; let’s use the same property of the
conjunction as before, but let’s use a slightly different mask –
exactly as below:

1111111111111111111111111111110111
Note that the mask was created as a result of the negation of all the
bits of TheMask variable. Resetting the bit is simple, and looks like
this (choose the one you like more) →

2.3.19 How do we deal with single bits?

 set your bit – you assign a 1 to your bit, while all the remaining
bits must remain unchanged; use the following disjunction
property:

x | 1 = 1
x | 0 = x
You’re now ready to set your bit with one of the following
instructions →
2.3.20 How do we deal with single bits?

 Negate your bit – you replace a 1 with a 0 and a 0with a 1. You

can use an interesting property of the xor operator:

x ^ 1 = ~x
x ^ 0 = x
and negate your bit with the following instructions →

2.3.21 How do we deal with single bits?

Python offers yet another operation relating to single bits: shifting.

This is applied only to integer values, and you mustn’t use floats as
arguments for it. You already apply this operation very often and
quite unconsciously. How do you multiply any number by ten? Take
a look:
12345 × 10 = 123450
As you can see, multiplying by ten is in fact a shift of all the digits
to the left and filling the resulting gap with zero. Division by ten?
Take a look:
12340 ÷10 = 1234
Dividing by ten is nothing but shifting the digits to the right.
The same kind of operation is performed by the computer, but with
one difference: as two is the base for binary numbers (not 10),
shifting a value one bit to the left thus corresponds to multiplying it
by two; respectively, shifting one bit to the right is like dividing by
two (notice that the rightmost bit is lost).
The shift operators in Python are a pair of digraphs, << and >>,
clearly suggesting in which direction the shift will act. The left
argument of these operators is an integer value whose bits are
shifted. The right argument determines the size of the shift. It
shows that this operation is certainly not commutative.
The priority of these operators is very high. You’ll see them in the
updated table of priorities, which we’ll show you at the end of this
section.

2.3.22 How do we deal with single bits?

Take a look at these shifts →

The final print() invocation produces the following output:

17 68 8
Note:

 17 // 2 → 8 (shifting to the right by one bit is the same as

integer division by two)
 17 * 4 → 68 (shifting to the left by two bits is the same as
integer multiplication by four)
2.3.23 How do we deal with single bits?

And here is the updated priority table, containing all the operators
introduced so far →

2.4.1 Lists – why do we need them so much?

It may happen that you have to read, store, process, and finally,
print dozens, maybe hundreds, perhaps even thousands of
numbers. What then? Do you need to create a separate variable for
each value? Will you have to spend long hours writing statements
like the one here? →
If you don’t think that this is a complicated task, then take a piece
of paper and write a program that reads five numbers, prints them
in order from the smallest to the largest (NB, this kind of processing
is called sorting). You should find that you don’t even have enough
paper to complete the task.
So far, you’ve learned how to declare variables that are able to
store exactly one given value at a time. Such variables are
sometimes called scalars by analogy with mathematics. All the
variables you’ve used so far are actually scalars.
Think of how convenient it would be to declare a variable that could
store more than one value. For example, 100 or 1000 or even
10,000. It would still be one and the same variable, but very wide
and capacious. Sounds appealing? Perhaps, but how would it handle
such a container full of different values? How would it choose just
the one you need?
What if you could just number them? And then say: give me the
value number 2; assign the value number 15; increase the value
number 10000.
We’ll show you how to declare such multi-value variables. We’ll do
this with the example we just suggested. We’ll to write a program
that sorts a sequence of numbers. We won’t be particularly
ambitious – we’ll assume that there are exactly five numbers.
2.4.2 Lists – why do we need them so much?

We read this record as follows →

Let’s create a variable called numbers; it’s assigned with not just
one number, but is filled with a listconsisting of five values (note:
the list starts with an opening bracket and ends with a closing
bracket; the space between the brackets is filled with five numbers
separated by commas).
Let’s say the same thing using adequate terminology: numbers is a
list consisting of five values, all of them numbers. We can also say
that this statement creates a list of length equal to five (as in there
are five elements inside it).
The elements inside a list may have different types. Some of them
may be integers, others floats, and yet others may be lists.
Python has adopted a convention stating that the elements in a list
are always numbered starting from zero. This means that the item
stored at the beginning of the list will have the number zero. Since
there are five elements in our list, the last of them is assigned the
number four. Don’t forget this. You’ll soon get used to it, and it’ll
become second nature.
Before we go any further in our discussion, we have to state the
following: our list is a collection of elements, but each element is a
scalar.
Note: we’ll show you the current content of our list in the lower-
right corner of the slide – it should help you follow what is
happening.

2.4.3 Lists – why do we need them so much?

How do you change the value of a chosen element in the list?
Let’s assign a new value of 111 to the first element in the list. We
do it this way →

2.4.4 Lists – why do we need them so much?

And now we want the value of the fifth element to be copied to the
second element – can you guess how to do it?
The value inside the brackets which selects one element of the list is
called an index, while the operation of selecting an element from
the list is known as indexing.
Note: all the indices used so far are literals. Their values are fixed at
runtime, but any expression can be the index, too. This opens up
lots of possibilities.

2.4.5 Lists – why do we need them so much?

Each of the list’s elements may be accessed separately. For example,

it can be printed →

Assuming that all of the previous operation has been completed

successfully, the snippet will send 111 to the console.
2.4.6 Lists – why do we need them so much?

The list may also be printed as a whole – just like here →

Python will decorate the output in a way that suggests that all the
presented values form a list. The output from the example snippet
looks like this:
[111, 1, 7, 2, 1]

2.4.7 Lists – why do we need them so much?

The length of a list may vary during execution. New elements may
be added to the list, while others may be removed from it. This
means that the list is a very dynamic entity.
If you want to check the list’s current length, you can use a function
named len() (its name comes from ‘length’).
The function takes the list’s name as an argument, and returns the
number of elements currently stored inside the list (in other
words – the list’s length).
The following snippet will print 5 to the console.

2.4.8 Removing elements from a list

Any of the list’s elements may be removed at any time – this is

done with an instruction named del(delete). Note: it’s an
instruction, not a function.
You have to point to the element to be removed – it’ll vanish from
the list, and the list’s length will be reduced by one.
The example snippet will produce the following output:
4
[111, 7, 2, 1]

2.4.9 Don't try to access non-existent elements

You can’t access an element which doesn’t exist – you can neither
get its value nor assign it a value. Both of these instructions will
cause runtime errors →
Note: we’ve removed one of the list’s elements – there are only four
elements in the list now. This means that element number four
doesn’t exist.

2.4.10 Negative indices are legal!

It may look strange, but negative indices are legal, and can be very
useful.
An element with an index equal to -1 is the last one in the list.
The example snippet will output 1→
2.4.11 Negative indices are legal!

Similarly, the element with an index equal to -2 is the one before

last in the list.
The example snippet will output 2→

The last accessible element in our list is numbers[-4](the first one)

– don’t try to go any further!

Practice Lab
Lab PCA_2_4_11_1_A The basics of lists:
Launch in Edube | Launch Sample Solution

2.4.12 Methods vs. functions

A method is a specific kind of function – it behaves like a function

and looks like a function, but differs in the way in which it acts, and
in its invocation style.
A function doesn’t belong to any data – it gets data, it may create
new data and it (generally) produces a result.
A method does all these things, but is also able to change the state
of a selected entity. A method is owned by the data it works for,
while a function is owned by the whole code.
This also means that invoking a method requires some specification
of the data from which the method is invoked.
It may sound puzzling here, but we’ll deal with it in depth when we
delve into object-oriented programming.
In general, a typical function invocation may look like this →
The function takes an argument, does something, and returns a
result.

2.4.13 Methods vs. functions

A typical method invocation usually looks like this →

Note: the name of the method is preceded by the name of the data
which owns the method. Next, you add a dot, followed by the
method name, and a pair of parenthesis enclosing the arguments.
The method will behave like a function, but can do something more
– it can change the internal state of the data from which it has been
invoked.

2.4.14 Adding elements to a list

You may ask: why are we talking about methods, not about lists?
This is an essential issue right now, as we’re going to show you how
to add new elements to an existing list. This can be done with
methods owned by all the lists, not by functions.
A new element may be glued to the end of the existing list.
Such an operation is performed by a method named append(). It
takes its argument’s value and puts it at the end of the list which
owns the method.
The list’s length then increases by one.
2.4.15 Adding elements to a list

The insert() method is a bit smarter – it can add a new element at

any place in the list, not only at the end.
It takes two arguments →

 the first shows the required location of the element to be

inserted; note: all the existing elements that occupy locations to
the right of the new element (including the one at the indicated
position) are shifted to the right, in order to make space for the
new element;
 the second is the element to be inserted.

2.4.16 Adding elements to a list

The following snippet inserts 222 at the beginning of the list →

Note: the former first element is now the second, the second the
third, and so on.
2.4.17 Adding elements to a list

The following snippet inserts 333 into the list, making it the second
element →

The former second element becomes the third, the third the fourth,
and so on.

2.4.18 Adding elements to a list

You can start a list’s life by making it empty (this is done with an
empty pair of brackets) and then adding new elements to it as
needed.
Take a look at the snippet →

Try to guess its contents after the for loop execution.

2.4.19 Adding elements to a list

It’ll be a sequence of consecutive integer numbers starting

from 1 (you then add one to all the appended values) →
2.4.20 Adding elements to a list

We’ve modified the snippet a bit – what will happen now? →

2.4.21 Adding elements to a list

You get the same sequence, but in reverse order (this is the merit
of using the insert()method) →

2.4.22 Making use of lists

The for loop has a very special variant that can process lists very
effectively – let’s take a look at that.
Let’s assume that you want to calculate the sum of all the values
stored in the list list. You need a variable whose sum will be
stored and initially assigned a value of 0 – its name is sum. Then
you add to it all the elements of the list using the forloop. Take a
look at the snippet →
 Let’s comment on this example:
 the list is assigned a sequence of five integer values;
 the i variable takes the values 0, 1, 2, 3, and 4, and then it
indexes the list, selecting the subsequent elements: the first,
second, third, fourth and fifth;
 each of these elements is added together by the += operator to
the sum variable, giving the final result at the end of the loop;
 note the way in which the len() function has been employed – it
makes the code independent of any possible changes in the list’s
content.

2.4.23 The second face of the for loop

But the for loop can do much more. It can hide all the actions
connected to the list’s indexing, and deliver all the list’s elements in
a handy way.
This modified snippet shows how it works →
 the for instruction specifies the variable used to browse the list
(i here) followed by the inkeyword and the name of the list
being processed (list here)
 the i variable is assigned the values of all the subsequent list’s
elements, and the process occurs as many times as there are
elements in the list;
 this means that you use the i variable as a copy of the elements’
values, and you don’t need to use indices;
 the len() function is not needed here, either.

2.4.24 Lists in action

Let’s leave lists aside for a moment and look at one intriguing issue.
Imagine that you need to rearrange the elements of a list, i.e.,
reverse the order of the elements: the first and the fifth as well as
the second and fourth elements will be swapped. The third one will
remain untouched. Question: how can you swap the values of two
variables? Take a look at the snippet →

If you do something like this, you would lose the value previously
stored in variable2. Changing the order of the assignments will not
help. You need a third variable that serves as an auxiliary storage.
2.4.25 Lists in action

This is how you can do it →

2.4.26 Lists in action

Python offers a more convenient way of doing the swap – take a

look →

Clear, effective and elegant – isn’t it?

2.4.27 Lists in action

Now you can easily swap the list’s elements to reverse their order →
The snippet’s output looks like this:
[5, 3, 8, 1, 10]
It looks fine with five elements.
Will it still be acceptable with a list containing 100 elements? No, it
won’t.
Can you use the for loop to do the same thing automatically,
irrespective of the list’s length?
Yes, you can.

2.4.28 Lists in action

This is how we’ve done it →

Note:

 we’ve assigned the l variable with the current list’s length (this
makes our code a bit clearer and shorter)
 we’ve launched the for loop to run through its body l//2 times
(this works well for lists with both even and odd lengths, because
 when the list contains an odd number of elements, the middle
one remains untouched)
 we’ve swapped the ith element (from the beginning of the list)
with the one with an index equal to (l – i – 1) (from the end
of the list); in our example, for i equal to 0 the (l – i -
1) gives 4; for i equal to 1, it gives 3 – this is exactly what we
needed.

Lists are extremely useful, and you’ll encounter them very often.

Practice Lab
Lab PCA_2_4_28_1_A The basics of lists:
Launch in Edube | Launch Sample Solution

2.5.1 Sorting simple lists

Now that you can effectively juggle the elements of lists, it’s time to
learn how to sort them. Many sorting algorithms have been
invented so far, which differ a lot in speed, as well as in complexity.
We are going to show you a very simple algorithm, easy to
understand, but unfortunately not too efficient, either. It’s used
very rarely, and certainly not for large and extensive lists.
Let’s say that a list can be sorted in two ways:

 increasing (or more precisely – non-decreasing) – if in every pair

of adjacent elements, the former element is not greater than the
latter;
 decreasing (or more precisely – non-increasing) – if in every pair
of adjacent elements, the former element is not less than the
latter.

In the following sections, we’ll sort the list in increasing order, so

that the numbers will be ordered from the smallest to the largest.
Here’s the list →
We’ll try to use the following approach: we’ll take the first and the
second elements and compare them; if we determine that they’re in
the wrong order (i.e., the first is greater than the second), we’ll
swap them round; if their order is valid, we’ll do nothing. A glance
at our list confirms the latter – the elements 01 and 02 are in the
proper order, as in 8 < 10.
Now look at the second and the third elements. They’re in the
wrong positions. We have to swap them.

2.5.2 Sorting simple lists

We go further, and look at the third and the fourth elements. Again,
this is not what it’s supposed to be like. We have to swap them →

2.5.3 Sorting simple lists

Now we check the fourth and the fifth elements. Yes, they too are in
the wrong positions. Another swap occurs →
2.5.4 Sorting simple lists

The first pass through the list is already finished. We’re still far from
finishing our job, but something curious has happened in the
meantime. The largest element, 10, has already gone to the end of
the list. Note that this is the desired place for it. All the remaining
elements form a picturesque mess, but this one is already in
place →

2.5.5 Sorting simple lists

Now, for a moment, try to imagine the list in a slightly different way
– namely, like this →
Look – 10 is at the top. We could say that it floated up from the
bottom to the surface, just like the bubble in a glass of champagne.
The sorting method derives its name from the same observation –
it’s called a bubble sort.

2.5.6 Sorting simple lists

Now we start with the second pass through the list. We look at the
first and second elements – a swap is necessary →
2.5.7 Sorting simple lists

Time for the third and fourth elements: we have to swap them
too →

2.5.8 Sorting simple lists

The second pass is finished, as 8 is already in place. We start the

next pass immediately. Watch the first and the second elements
carefully – another swap is needed →

2.5.9 Sorting simple lists

Now 6 needs to go into place. We swap the second and the third
elements →
2.5.10 Sorting simple lists

The list is already sorted →

We have nothing more to do. This is exactly what we want.

As you can see, the essence of this algorithm is simple: we compare
the adjacent elements, and by swapping some of them, we achieve
our goal.
Let’s code in Python all the actions performed during a single pass
through the list, and then we’ll consider how many passes we
actually need to perform it. We haven’t explained this so far, and
we’ll do that a little later.

2.5.11 Sorting simple lists

How many passes do we need to sort the entire list?

We solve this issue in the following way: we introduce another
variable; its task is to observe if any swap has been done during the
pass or not; if there is no swap, then the list is already sorted, and
nothing more has to be done. We create a variable named swapped,
and we assign a value of False to it, to indicate that there are no
swaps. Otherwise, it will be assigned True.
2.5.12 Sorting simple lists

You should be able to read and understand this program without any
problems →

On the next slide, you can see a complete program, enriched by a

conversation with the user, and allowing the user to enter and to
print elements from the list.

2.5.13 Sorting simple lists

The bubble sort – final interactive version →

Python, however, has its own sorting mechanisms. No one needs to
write their own sorts, as there is a sufficient number of ready-to-use
tools.
We explained this sorting system to you because it’s important to
learn how to process a list’s contents, and to show you how real
sorting may work.
If you want Python to sort your list, you can do it like this . . .

2.5.14 Sorting simple lists

It is as simple as that →

The snippet’s output is as follows:

[2, 4, 6, 8, 10]
As you can see, all the lists have a method named sort(), which
sorts them as fast as possible.

2.6.1 The inner life of lists

Now we want to show you one important, and very surprising,

feature of lists, which strongly distinguishes them from ordinary
variables.
We want you to memorize it – it may affect your future programs,
and cause severe problems if forgotten or overlooked.
Take a look at the snippet →

The program:

 creates a one-element list named list1;

 assigns it to a new list named list2;
 changes the only element of list1;
 prints out list2.

The surprising part is the fact that the program will output:
[2]
not
[1]
which seems to be the obvious solution.
Lists (and many other complex Python entities) are stored in
different ways than ordinary (scalar) variables.
You could say that:

 the name of an ordinary variable is the name of its content;

 the name of a list is the name of a memory location where
the list is stored.

Read these two lines once more – the difference is essential for
understanding what we are going to talk about next.
The assignment:
list2 = list1
copies the name of the array, not its contents. In effect, the
two names (list1 and list2) identify the same location in the
computer memory. Modifying one of them affects the other, and
vice versa.
How do you cope with that?
2.6.2 Slices – a powerful tool

Fortunately, the solution is at your fingertips – its name is the slice.

A slice is an element of Python syntax that allows you to make a
brand new copy of a list, or parts of a list.
It actually copies the list’s contents, not the list’s name.
This is exactly what you need.
Take a look at the snippet →

Its output is:

[1]
This inconspicuous part of the code described as [:]is able to
produce a brand new list.

2.6.3 Slices – a powerful tool

One of the most general forms of the slice looks as follows →

As you can see, it resembles indexing, but the colon inside makes a
big difference.
A slice of this form makes a new (target) list, taking elements from
the source list – the elements of the indices from start to end-1.
Note: not to end but to end-1. An element with an index equal
to end is the first element which does not take part in the slicing.
Using negative values for both start and end is possible (just like in
indexing).

2.6.4 Slices – a powerful tool

Take a look at the snippet →

The new_list list will have end-start (3−1 = 2) elements – the

ones with indices equal to 1 and 2 (but not 3).
The snippet’s output is:
[8, 6]

2.6.5 Slices – a powerful tool

To repeat:

 start is the index of the first element included in the slice;

 end is the index of the first element not includedin the slice.

2.6.6 Slices – a powerful tool

This is how negative indices work with the slice →

The snippet’s output is:
[8, 6, 4]

2.6.7 Slices – a powerful tool

If the start specifies an element lying further than the one

described by the end (from the list’s beginning point of view), the
slice will be empty:
Just like here →
The snippet’s output is:
[]

2.6.8 Slices – a powerful tool

If you omit the start in your slice, it is assumed that you want to get
a slice beginning at the element with index 0.
In other words, the slice of this form:
list[:end]
is a more compact equivalent of:
list[0:end]
This is why this snippet’s output is:
[10, 8, 6]

2.6.9 Slices – a powerful tool

Similarly, if you omit the end in your slice, it is assumed that you
want the slice to end at the element with the index len(list).
In other words, the slice of this form:
list[start:]
is a more compact equivalent of:
list[start:len(list)]
The snippet’s output is:
[4, 2]

2.6.10 Slices – a powerful tool

Omitting both start and end makes a copy of the whole list →
The snippet’s output is:
[10, 8, 6, 4, 2]

2.6.11 Slices – a powerful tool

The previously described del instruction is able to delete more than

just a list’s element at once – is can delete slices too →
Note: in this case, the slice doesn’t produce any new list!
The snippet’s output is:
[10, 4, 2]
2.6.12 Slices – a powerful tool

Deleting all the elements at once is possible too →

The list becomes empty, and the output is:

[ ]

2.6.13 Slices – a powerful tool

Removing the slice from the code changes its meaning dramatically.
Take a look →

The del instruction will delete the list itself, not its content.
The print() function invocation from the last line of the code will
then cause a runtime error.
2.6.14 The in operator

Python offers two very powerful operators, able to look through the
list in order to check whether a specific value is stored inside the list
or not.
These operators are →

The first of them (in) checks if a given element (its left argument)
is currently stored somewhere inside the list (the right argument) –
the operator returns True in this case.
The second (not in) checks if a given element (its left argument) is
absent in a list – the operator returns True in this case.

2.6.15 The in operator

The snippet shows both operators in action →

The output is:

False
True
True
2.6.16 Some simple programs

Now we want to show you some simple programs utilizing lists.

The first of them tries to find the greater value in the list →

The concept is rather simple – we temporarily assume that the first

element is the largest one, and check the hypothesis against all the
remaining elements in the list.
The code outputs 17 (as expected).
2.6.17 Some simple programs

The code may be rewritten to make use of the newly introduced

form of the for loop.
It performs one unnecessary comparison, when the first element is
compared with itself, but this isn’t a problem at all →
The code outputs 17, too (nothing unusual).
2.6.18 Some simple programs

If you need to save computer power, you can use a slice →

The question is: which of these two actions consumes more

computer resources – just one comparison, or slicing almost all of a
list’s elements?

2.6.19 Some simple programs

Now let’s find the location of a given element inside a list →

Note:

 the target value is stored in the tofind variable;

 the current status of the search is stored in the found variable
(True/False)
 when found becomes True, the for loop is exited.

2.6.20 Some simple programs

Let’s assume that you’ve chosen the following numbers in the

lottery: 3, 7, 11, 42, 34, 49
The numbers that have been drawn are: 5, 11, 9, 42, 3, 49
The question is: how many numbers have you hit?
The program will give you the answer →
Note:

 the drawn list stores all the drawn numbers;

 the bets list stores your bets;
 the hits variable counts your hits.

The program output is:

4

Practice Lab

 Lab PCA_2_6_20_1_A Operating with lists - basics:

Launch in Edube | Launch Sample Solution

2.7.1 Lists in lists

So far, we’ve told you that lists consist of scalars (namely

numbers), but in fact lists can contain elements of a much more
complex structure. Let’s consider the case where a list’s elements
are just lists.
We often find such arrays in our lives. Probably the best example of
this is a chessboard.
A chessboard is composed of rows and columns. There are eight
rows and eight columns. Each column is marked with the letters A
through H. Each line is marked with a number from one to eight.
The location of each field is identified by letter–digit pairs. Thus, we
know that the bottom right corner of the board (the one with the
white rook) is A1, while the opposite corner is H8.
Let’s assume that we’re able to use the selected numbers to
represent any chess piece. We can also assume that every row on
the chessboard is a list.
Look at the snippets →

It builds a list containing eight elements representing the second

row of the chessboard – the one filled with pawns (assume
that WHITE_PAWNis a predefined symbol representing a white pawn).

2.7.2 Lists in lists

The same effect may be achieved by means of a list

comprehension, the special syntax used by Python in order to fill
massive lists.
A list comprehension is actually a list, but created on-the-fly during
program execution, and is not described statically.
Take a look at the snippet →

The part of the code placed inside the brackets specifies:

 the data to be used to fill the list (WHITE_PAWN)
 the clause specifying how many times the data occurs inside the
list (for i in range(8))

Let us show you some other list comprehension examples:

 squares = [ x ** 2 for x in range(10) ]

produces a ten-element list filled with squares of ten integer
numbers starting from zero (0, 1, 4, 9, 16, 25, 36, 49, 64, 81)
 twos = [ 2 ** i for i in range(8) ]
creates an eight-element array containing the first eight powers
of two (1, 2, 4, 8, 16, 32, 64, 128)
 odds = [x for x in squares if x % 2 != 0 ] makes a list
with only the odd elements of the squares list.

2.7.3 Lists in lists

Let’s also assume that a predefined symbol

named EMPTY designates an empty field on the chessboard.
So, if we want to create a list of lists representing the whole
chessboard, it may be done in the following way →

Note:

 the inner part of the loop creates a row consisting of eight

elements (each of them equal to EMPTY) and appends it to
the boardlist;
 the outer part repeats it eight times;
 in total, the board list consists of 64 elements (all equal
to EMPTY)
This model perfectly mimics the real chessboard, which is in fact an
eight-element list of elements, all being single rows. Let’s
summarize our observations:

 the elements of the rows are fields, eight of them per row;
 the elements of the chessboard are rows, eight of them per
chessboard.

The board variable is now a two-dimensional array. It’s also

called, by analogy to algebraic terms, a matrix.

2.7.4 Lists in lists

As list comprehensions can be nested, we can shorten the board

creation in the following way →

 the inner part creates a row;

 the outer part builds a list of rows.

2.7.5 Lists in lists

Access to the selected field of the board requires two indices – the
first selects the row, the second, the field number inside the row,
which is de facto a column number.
Take a look at the chessboard. Every field contains a pair of indices
which should be given to access the field’s content →
Glancing at the figure shown here → let’s set some chess pieces on
the board. First, let’s add all the rooks:
board[0][0] = ROOK
board[0][7] = ROOK
board[7][0] = ROOK
board[7][7] = ROOK
If you want to add a knight to C4, you do it as follows:
board[4][2] = KNIGHT
And now a pawn to E5:
board[3][4] = PAWN

2.7.6 Lists in lists

Let’s go deeper into the multidimensional nature of lists. To find any

element of a two-dimensional list, you have to use two
“coordinates”: a vertical one (row number) and a horizontal one
(column number). Imagine that you develop a piece of software for
an automatic weather station. The device records the air
temperature on an hourly basis and does it throughout the month.
This gives you a total of 24 × 31 = 744 values. Let’s try to design a
list capable of storing all these results. First, you have to decide
which data type would be adequate for this application. In this case,
a float would be best, since this thermometer is able to measure the
temperature with an accuracy of 0.1 ºC. Then you take an arbitrary
decision that the rows will record the readings every hour on the
hour (so the row will have 24 elements) and each of the rows will
be assigned to one day of the month (so you need 31 rows). Here’s
the appropriate pair of comprehensions (h is for hour, dfor day) →

The whole matrix is filled with zeros now. You can assume that it’s
updated automatically using special hardware agents. The thing you
have to do is to wait for the matrix to be filled with measurements.

2.7.7 Lists in lists

Now it’s time to determine the monthly average noon temperature.

Add up all 31 readings recorded at noon and divide the sum by 31.
You can assume that the midnight temperature is stored first.
Here’s the relevant code →
Note: the day variable used by the for loop is not a scalar – each
pass through the temps matrix assigns it with the subsequent rows
of the matrix; hence, it’s a list. It has to be indexed with 11 to
access the temperature value measured at noon.
2.7.8 Lists in lists

Now find the highest temperature during the whole month – see the
code →

Note:

 the day variable iterates through all the rows in

the temps matrix;
 the temp variable iterates through all the measurements taken in
one day.
2.7.9 Lists in lists

Now count the days when the temperature at noon was at least 20
ºC →

2.7.10 Lists in lists

Python does not limit the depth of list-in-list inclusion. Here you can
see an example of a three-dimensional array.
Imagine a hotel. It’s a huge hotel consisting of three buildings, 15
floors each. There are 20 rooms on each floor. For this, you need an
array which can collect and process information on the
occupied/free rooms.
First step – the type of the array’s elements. In this case, a Boolean
value (True/False) would fit.
Step two – calm analysis of the situation. Summarize the available
information: three buildings, 15 floors, 20 rooms.
Now you can create the array →
The first index (0 through 2) selects one of the buildings; the
second (0 through 14) selects the floor, the third (0 through 19)
selects the room number. All rooms are initially free.
Now you can book a room for two newlyweds: in the second
building, on the tenth floor, room 14:
rooms[1][9][13] = True
and release the second room on the fifth floor located in the first
building:
rooms[0][4][1] = False
Check if there are any vacancies on the 15th floor of the third
building:

vacancy = 0
for roomno in range(20):
if not rooms[2][14][roomno]:
vacancy += 1
The vacancy variable contains 0 if all the rooms are occupied, or the
number of available rooms otherwise.