Intro

A programmer writes a program and the program asks questions.
A computer executes the program and provides the answers

• Yes, this is true.
• No, this is false.

Comparison: equality operator.

Question: are two values equal?

To ask this question, you use the == (equal equal) operator.
Don't forget this important distintion:

• = is an assignment operator, e.g. a=b assigns 'a' with the value of 'b'.
• == is the question are these values equal?, a==b compares 'a' and 'b'.

Exercises.

Now let's ask a few questions. try to guess the answers.

True of course, 2 is equal to 2. Python will answer True (remeber this pair of predefined literals, True and False - they're Python keywords, too).

This question is not as easy as their first one. Luckly, Python is able to convert the integer value into its real equivalent, andconsequently, the answer is True.

This should be easy. The answer will be (or rather, always is) False.

Equality: the equal to operator (==)

The == (equal to) operator compares the values of two operands. If they are equal, the result of the comparison is True. If they are not equal, the result of the comparison is False.
Look at the equality comparison below - what is the result of this operation?
var == 0
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.
Now 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:
black_sheep == 2 * white_sheep
Due to the low priority of the == operator, the question shall be treated as equivalent to this one:
black_sheep == (2 * white_sheep)
So, let's practice your understanding of the == operator now - can you guess the output of the code below?

	var = 0 # assigning 0 to var
	print(var == 0)
	var = 1 # assigning 1 to var
	print(var == 0)
	

Equal to operator.

Inequality: the not equal to operator (!=)

The != (not equal to) operator compares the values of two operands, too. Here is the difference: if they are equal, the result of the comparison is False. If they are not equal, the result of the comparison is True. Now take a look at the inequality comparison below - can you guess the result of this operation?

	var = 0 # assigning 0 to var
	print(var != 0)
	var = 1 # assigning 1 to var
	print(var != 0)														
													

Equal to operator.

Comparison operators: greater than

You can also ask a comparison 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:
black_sheep > white_sheep # greater than
True confirms it; False denies it.

Comparison operators: 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:
centigrade_outside ≥ 0.0 # greater than or equal to

Comparison operator: 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:

current_velocity_mph < 85 # less than current_velocity_mph ≤ 85 # less than or equal to

Lab: Question and answer.

Estimated time

5 minutes

Very Easy

Becoming familiar with the the input() function.
Becoming familiar with comparison operators in Python.

Using one of the comparison operators in Python, write a simple two-line program that takes the parameter n as input, which is an integer, and prints False if n is less than 100, and True if n is greater than or equal to 100.
Don't create any if blocks (we're going to talk about them very soon). Test your code using the data we've provided for you.

Sample input: 55
Expected output: False
Sample input: 99
Expected output: False
Sample input: 100
Expected output: True
Sample input: 101
Expected output: True
Sample input: -5
Expected output: False
Sample input: +123
Expected output: True

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 machanism which allow you to do something if a condition is met, and not do 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 decision, Python offers a special instruction. Due to its nature and its application, it's called a condition 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 below is written very informally but figuratively:

if true_or_not:
   do_this_if_true

• 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's equal to zero).
• A colon followed by a newline.
• An indented instruction or set of instructions (at least one instruction is absolutely required), the indentation may be achieved in two ways - by inserting a particular number of spaces (the recommedation is to use four spaces of indentation ), or by using the tab character; note: if there is more than one instruction in the indented part, the indentation should be the same in all lines, even though it may look the same if you use tabs mixed whit spaces, it's important to make all indentations exactly the same Python 3 does not allow mixing spaces and tabs for indentation.

• If the true_or_not expression represent the truth(i.e, its value 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.

if the weather is good, we'll go for a walk
then, we'll have lunch

if the_weather_is_good:
	go_for_a_walk()
have_lunch()

Conditional execution: the if statement

If s certain 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 sleep_and_dream(), the whole code takes the following shape:

if sheep_counter >= 120: # Evaluate a test expression
	sleep_and_dream() # execute if test expression is True

if sheep_counter >= 120:
	make_a_bed() 
	take_a_shower() 
	sleep_and_dream() 
feed_the_sheepdogs()

Conditional execution: the if-else statement

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 the weather is bad. 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, the if-else statement:

if true_or_false_condition:
	perform_if_condition_true
else:
	perform_if_condition_false

• 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_false statement is executed, and the conditional statement comes to an end.

The if-else statement: more conditional execution

By using this form of conditional statement, we can describe our plans as follows:

if the_weather_is_good:
    go_for_a_walk()
else:
    go_to_a_theater()
have_lunch()

if the_weather_is_good:
    go_for_a_walk()
    have_fun()
else:
    go_to_a_theater()
    enjoy_the_movie()
have_lunch()

Nested if-else statements

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:

if the_weather_is_good:
    if nice_restaurant_is_found:
        have_lunch()
    else:
        eat_a_sandwich()
else:
    if tickets_are_available:
        go_to_the_theater()
    else:
		go_shopping()

• This use of the if statement is know as nesting, remeber that every else refers to the if which lies at the same ondentation level, you need to know this to determine how the ifs and elses pair up
• Consider hot the indentation improves readability and makes the code easier to understantd and trace.

The elif statement

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 elif keyword plays its role.
Let's write the same scenario using Python:

if the_weather_is_good
    go_for_a_walk()
elif tickets_are_available:
    go_to_the_theater()
elif table_is_available:
    go_for_lunch()
else:
    play_chess_at_home()

• 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 that none of the available branches is executed.

Analyzing code samples

Now we're going to show you some simple yet complete programs. We won't explain them in detail, because we consider the comments (and the variable names) 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.

Example 1:

We'll start with the simplest case - how to identify the larger of two numbers:

# read two numbers
number1 = int(input("Enter the first number: "))
number2 = int(input("Enter the second number: "))

# choose the larger number
if number1 > number2:
	larger_number = number1
else:
	larger_number = number2

# print the result
print("The larger number is:", larger_number)

Example 2:

Now we're going to show you one intriguing fact. Python has an interesting feature, look at the code below:

# read two numbers
number1 = int(input("Enter the first number: "))
number2 = int(input("Enter the second number: "))

# choose the larger number
if number1 > number2: larger_number = number1
else: larger_number = number2

# print the result
print("The larger number is:", larger_number)

Example 3:

# read three numbers
number1 = int(input("Enter the first number: "))
number2 = int(input("Enter the second number: "))
number3 = int(input("Enter the third number: "))

# We temporarily assume that the first number
# is the largest one.
# We will verify this soon.
largest_number = number1

# we check if the second number is larger than current largest_number
# and update largest_number if needed
if number2 > largest_number:
	largest_number = number2

# we check if the third number is larger than current largest_number
# and update largest_number if needed
if number3 > largest_number:
	largest_number = number3

# print the result
print("The largest number is:", largest_number)

Pseudocode and introduction to loops

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.
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.
Let's look at our pseudocode below:

line 01 largest_number = -999999999
line 02 number = int(input())
line 03 if number == -1:
line 04     print(largest_number)
line 05     exit()
line 06 if number > largest_number:
line 07     largest_number = number
line 08 go to line 02

Extra info

Python often comes with a lot of built-in functions that will do the work for you. For example, to find the largest number of all, you can use a Python built-in function called max(). You can use it with multiple arguments. Analyze the code below:

# read three numbers
number1 = int(input("Enter the first number: "))
number2 = int(input("Enter the second number: "))
number3 = int(input("Enter the third number: "))

# check which one of the numbers is the greatest
# and pass it to the largest_number variable

largest_number = max(number1, number2, number3)

# print the result
print("The largest number is:", largest_number)

Using the Python function: max()

Using the Python function: min()

LAB- Comparison operators and conditional execution.

Estimated time

5-10 minutes

Level of difficulty

Easy

Objectives

Becoming familiar with the the input() function
Becoming familiar with comparison operators in Python
Becoming familiar with the concept of conditional execution

Scenario

Spathiphyllum, more commonly known as a peace lily or white sail plant, is one of the most popular indoor houseplants that filters out harmful toxins from the air. Some of the toxins that it neutralizes include benzene, formaldehyde, and ammonia. Imagine that your computer program loves these plants. Whenever it receives an input in the form of the word Spathiphyllum, it involuntarily shouts to the console the following string: "Spathiphyllum is the best plant ever!" Write a program that utilizes the concept of conditional execution, takes a string as input, and:

• prints the sentence "Yes - Spathiphyllum is the best plant ever!" to the screen if the inputted string is "Spathiphyllum" (upper-case).
• prints "No, I want a big Spathiphyllum!" if the inputted string is "spathiphyllum" (lower-case).
• prints "Spathiphyllum! Not [input]!" otherwise.
  Note: [input] is the string taken as input.

Test Data

Sample input: spathiphyllum
Expected output: No, I want a big Spathiphyllum!

My solution

LAB - Essentials of the if-else statement

Estimated time

Level of difficulty

Objectives

• Using the if-else instruction to branch the control path.
• Building a complete program that solves simple real-life problems.

Scenario

• If the citizen's income was not higher than 85,528 thalers, the tax was equal to 18% of the income minus 556 thalers and 2 cents (this was the so-called tax relief)
• If the income was higher than this amount, the tax was equal to 14,839 thalers and 2 cents, plus 32% of the surplus over 85,528 thalers.

• It should accept one floating-point value: the income.
• Next, it should print the calculated tax, rounded to full thalers. There's a function named round() which will do the rounding for you - you'll find it in the skeleton code in the editor.

Test Data

Solution Code.

Solution Data Test.

LAB - Essentials of the if-elif-else statement

Estimated time

Level of difficulty

Objectives

• Using the if-elif-else statement.
• Finding the proper implementation of verbally defined rules.
• Testing code using sample input and output.

Scenario

• If the year number isn't divisible by four, it's a common year.
• Otherwise, if the year number isn't divisible by 100, it's a leap year.
• Otherwise, if the year number isn't divisible by 400, it's a common year.
• Otherwise, it's a leap year.

Test Data

Solution

Key takeaways

• The comparison (or the so-called relational) operators are used to compare values. The table below illustrates how the comparison operators work, assuming that x = 0, y = 1, and z = 0:

  Operator	Description	Example
  ==	Returns if operands' values are equal, and False otherwise	x == y # False x == z # True
  !=	Returns True if operands' values are not equal, and False otherwise	x != y # True x != z # False
  >	True if the left operand's value is greater than the right operand's value, and False otherwise	x > y # False y > z # True
  <	True if the left operand's value is less than the right operand's value, and False otherwise	x < y # True y < z # False
  ≥	True if the left operand's value is greater than or equal to the right operand's value, and False otherwise	x >= y # False x >= z # True y >= z # True
  ≤	True if the left operand's value is less than or equal to the right operand's value, and False otherwise	x <= y # True x <= z # True y <= z # False

• When you want to execute some code only if a certain condition is met, you can use a conditional statement:
  - A single if statement, e.g.:
  

  x = 10
  if x == 10: # condition
  	print("x is equal to 10") # executed if the condition is True
  

  
  - A series of if statements, e.g.:
  

  x = 10
  if x > 5: # condition one
  	print("x is greater than 5") # executed if condition one is True
  if x < 10: # condition two
  	print("x is less than 10") # executed if condition two is True
  if x == 10: # condition three
  	print("x is equal to 10") # executed if condition three is True
  

  
  Each if statement is tested separately.
  - An if-else statement, e.g.:
  

  x = 10
  if x < 10: # condition
  	print("x is less than 10") # executed if the condition is True
  else:
  	print("x is greater than or equal to 10") # executed if the condition is False
  

  - A series of if statements followed by an else, e.g.:

  x = 10
  if x > 5: # True
  	print("x > 5")
  if x > 8: # True
  	print("x > 8")
  if x > 10: # False
  	print("x > 10")
  else:
  	print("else will be executed")
  

  
  Each if is tested separately. The body of else is executed if the last if is False.
  - The if-elif-else statement, e.g.:

  x = 10														
  if x == 10: # True
  	print("x == 10")
  if x > 15: # False
  	print("x > 15")
  elif x > 10: # False
  	print("x > 10")
  elif x > 5: # True
  	print("x > 5")
  else:
  	print("else will not be executed")
  

  
  If the condition for if is False, the program checks the conditions of the subsequent elif blocks - the first elif block that is True is executed. If all the conditions are False, the else block will be executed.
  - Nested conditional statements, e.g.:

  x = 10														
  if x > 5: # True
  	if x == 6: # False
  		print("nested: x == 6")
  	elif x == 10: # True
  		print("nested: x == 10")
  	else:
  		print("nested: else")
  else:
  	print("else")
  

Key takeaways: continued

Exercise nº 1
Exercise nº 2
Exercise nº 3
Exercise nº 4
Exercise nº 5
Exercise nº 6

Looping your code whit while

Do you agree with the statement presented below?

while there is something to do
   do it

while conditional_expression:
       instruction

while conditional_expression:       instruction_1
      instruction_2
      instruction_3
      ..
      ..
      instruction_n

• 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.
• 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).

An infinite loop

An infinite loop, also called an endless loop, is a sequence of instructions in a program which repeat indefinitely (loop endlessly). Here's an example of a loop that is not able to finish its execution:

while True:
    print("I'm stuck inside a loop.")

# we will store the current largest number here
largest_number = -999999999

# input the first value
number = int(input("Enter a number or type -1 to stop: "))

# if the number is not equal to -1, we will continue
while number != -1:
	# is number larger than largest_number?
	if number > largest_number:
		# yes, update largest_number
		largest_number = number
	# input the next number
	number = int(input("Enter a number or type -1 to stop: "))

# print the largest number
print("The largest number is:", largest_number)

The while loop: more examples.

LAB: Essential of the while loop - Gess the secret number.

Estimated time.

Level of difficulty.

Objectives.

• Using the while loop.
• Reflecting real-life situations in computer code.

Scenario.

• Will ask the user to enter an integer number.
• Will use a while loop.
• Will check whether the number entered by the user is the same as the number picked by the magician. If the number chosen by the user is different than the magician's secret number, the user should see the message "Ha ha! You're stuck in my loop!" and be prompted to enter a number again. If the number entered by the user matches the number picked by the magician, the number should be printed to the screen, and the magician should say the following words: "Well done, muggle! You are free now."

EXTRA INFO.

My solution

Looping your code with for

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:

i = 0
while i < 100:
	# do_something()
	i += 1

for i in range(100):
	# do_something()
	pass

• 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).

for i in range(24):
	print("The value of i is currently", i)

Note:

for i in range(5, 20):
	print("The value of i is currently", i)

More about the for loop and the range() function with three arguments.

The range() function may also accept three arguments- take a look at the code in the editor.
The third arguments is an increment - it's a value added to control the variable at every loop turn (as you may suspect, the defaultvalue of the increment is 1. ).
Can you tell us how many lines will appear in the console and what values they will contain?
Run the program to find ut if out if you were right.
You should be able to see the following lines in the console window:

The value of i is currently 2
The value of i is currently 5

for i in range (1, 1):
    print("The value of i is currently ", i)

for i in range (2,12, 3):
    print("The value of i is currently ", i )

pow = 1
for exp in range (16):
       print("2 to the power of ", exp, " is ", pow)
       pow *=2

Lab. Essentials of the for loop - counting mississippily.

Estimated time

Level of difficulty

Objectives

• Using the for loop.
• Reflecting real-life situations in computer code.

Scenario

EXTRA INFO

Expected output

1 Mississippi
2 Mississippi
3 Mississippi
4 Mississippi
5 Mississippi

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.

• 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.

More examples

Let's return to our program that recognizes the largest among the entered numbers. We'll convert it twice, using the break and continue instructions.
Analyze the code, and judge whether and how you would use either of them. The break variant goes here:

Lab. The break statement - Stuck in a loop

Estimated time

Level of difficulty

Objectives

• using the break statement in loops.
• reflecting real-life situations in computer code.

Scenario

(Aquí no limpio la pantalla para ver los intentos)

Lab. The continue statement - The Ugly Vowel Eater

Estimated time

Level of difficulty

Objectives

• Using the continue statement in loops.
• Reflecting real-life situations in computer code.

Scenario

• A for loop.
• The concept of conditional execution (if-elif-else).
• The continue statement.

• Ask the user to enter a word.
• Use userWord = userWord.upper() to convert the word entered by the user to upper case; we'll talk about the so-called string methods and the upper() method very soon - don't worry.
• Use conditional execution and the continue statement to "eat" the following vowels A, E, I, O, U from the inputted word.
• Print the uneaten letters to the screen, each one of them on a separate line.

Test data

G
R
G
R
Y

B
S
T
M
S

My solution

My solution code.

Outputs.

The while loop and else branch

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 in the editor. There's something strange at the end - the else keyword.
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? Run the program to check if you were right.
Modify the snippet a bit so that the loop has no chance to execute its body even once:

i = 5
while i < 5:
	print(i)
	i += 1
else:
	print("else: ", i)

The for loop ant the else branch

for loops behave a bit differently - take a look at the snippet in the editor and run it.
The output may be a bit surprising.
The i variable retains its last value.
Modify the code a bit to carry out one more experiment.

i = 111
for i in range(2, 1):
	print(i)
else:
	print("else:", i)

Lab. Essentials of the while loop

Estimated time

Level of difficulty

Objectives

• Using the while loop
• Finding the proper implementation of verbally defined rules
• Reflecting real-life situation in computer code.

Scenario

Test Data

My solution

Result. (Click for go in)

Lab. Collatz hypothesis

Estimated time

Level of difficulty

Objectives

• using the while loop.
• converting verbally defined loops into actual Python code.

Scenario

• Take any non-negative and non-zero integer number and name it c0
• If it's even, evaluate a new c0 as c0 ÷ 2
• Otherwise, if it's odd, evaluate a new c0 as 3 × c0 + 1
• If c0 ≠ 1, skip to point 2.The hypothesis says that regardless of the initial value of c0, it will always go to 1

Test Data

46
23
70
35
106
53
160
80
40
20
10
5
16
8
4
2
1
steps = 17

8
4
2
1
steps = 4

3070
1535
4606
2303
6910
3455
10366
5183
15550
7775
23326
11663
34990
17495
52486
26243
78730
39365
118096
59048
29524
14762
7381
22144
11072
5536
2768
1384
692
346
173
520
260
130
65
196
98
49
148
74
37
112
56
28
14
7
22
11
34
17
52
26
13
40
20
10
5
16
8
4
2
1
steps = 62

Solution

Code

Test Data

Key takeaways

1. There are two types of loops in Python: while and for:
- The while loop executes a statement or a set of statements as long as a specified boolean condition is true, e.g.:

# Example 1
while True:
	print("Stuck in an infinite loop.")

# Example 2
counter = 5
while counter > 2:
	print(counter)
	counter -= 1

# Example 1
word = "Python"
for letter in word:
	print(letter, end="*")

# Example 2
for i in range(1, 10):
	if i % 2 == 0:
		print(i)

text = "OpenEDG Python Institute"
for letter in text:
if letter == "P":
	break
print(letter, end="")

text = "pyxpyxpyx"
for letter in text:
	if letter == "x":
		continue
	print(letter, end="")

n = 0
while n != 3:
	print(n)
	n += 1
else:
	print(n, "else")
print()
for i in range(0, 3):
	print(i)
else:
	print(i, "else")

• Start is an optional parameter specifying the starting number of the sequence (0 by default).
• Stop is an optional parameter specifying the end of the sequence generated (it is not included).
• And step is an optional parameter specifying the difference between the numbers in the sequence (1 by default.).

for i in range(3):
	print(i, end=" ") # outputs: 0 1 2

for i in range(6, 1, -2):
	print(i, end=" ") # outputs: 6, 4, 2

Key takeaways: continued

Exercise 1

for i in range(1, 11):
# line of code
# line of code

for i in range(0, 11):
if i % 2 != 0:
	print(i)

Exercise 2

x = 1
while x < 11:
# line of code
# line of code
# line of code

x = 1
while x < 11:
	if x % 2 != 0:
		print(x)
	x += 1

Exercise 3

for ch in "john.smith@pythoninstitute.org":
if ch == "@":
# line of code
# line of code

for ch in "john.smith@python-institute.org":
if ch == "@":
	break
print(ch, end="")

Exercise 4

for digit in "0165031806510":
if digit == "0":
	# line of code
	# line of code
# line of code

for digit in "0165031806510":
if digit == "0":
	print("x", end="")
	continue
print(digit, end="")

Exercise 5

n = 3
while n > 0:
	print(n + 1)
	n -= 1
else:
	print(n)

4
3
2
0

Exercise 6

n = range(4)
for num in n:
	print(num - 1)
else:
	print(num)

-1
0
1
2
3

Exercise 7

for i in range(0, 6, 3):
	print(i)

0
3

Logic and bit operations in Python. | and, or, not

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.

and

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:

or

A disjunction 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.

not

In addition, there's another operator that can be applied for constructing conditions. It's a unarity operator performing a logical negotion. 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 + and -. Its truth table is simple.

Logical expressions

Let's create a variable named var and assign 1 to it. The following conditions are pairwise equivalent:

print(var > 0)
print(not (var <= 0))

print(var != 0)
print(not (var == 0))

not ( p and q ) == ( not p ) or (not q)
not (p or q) == (not p) and (not q)

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 ine bit is set) means True.
The result of their operations is one of these values: False or True. This means that snippet will assign the value True to the j variable if i is not zero, otherwise, it will be False.

i = 1
j = not not i

Bitwise operators

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 conjugation.
• |(bar)-Bitwise disjunction.
• ~(tilde)-Bitwise negation.
• ^(caret)-Bitwise exclusive or (xor).

Bitwise operations (&, | and ^)

Bitwise operations (~)

• & requires exactly two 1s to provide 1as the result.
• | requires at least one 1 to provide 1 as the result.
• ^ requires exactly one 1 to provide 1 as the result.

Logical vs. bit operations. Continued

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

i: 00000000000000000000000000001111
j: 00000000000000000000000000010110

log = i and j

log: True

bit = i & j

i 00000000000000000000000000001111
j 00000000000000000000000000010110
bit = i & j 00000000000000000000000000000110

logneg = not i

bitneg = ~i

i 00000000000000000000000000001111
bitneg = ~i 11111111111111111111111111110000

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:

flagRegister = 0x1234

flagRegister = 0000000000000000000000000000x000

x & 1 = x
x & 0 = 0

00000000000000000000000000001000

• 00000000000000000000000000001000 if your bit was set to 1
• 0000000000000000000000000000000 if your bit was reset to 0

if flagRegister & theMask:
	# my bit is set
else:
	# my bit is reset

11111111111111111111111111110111

flagRegister = flagRegister & ~theMask
													
 0flagregister &= ~theMask

x | 1 = 1
x | 0 = x

flagRegister = flagRegister | theMask
flagRegister |= theMask

x ^ 1 = ~x
x ^ 0 = x

flagRegister = flagRegister ^ theMask
	
flagRegister ^= theMask

Binary left shift and binary right shift

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.

value << bits value >> bits

17 68 8

• 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)

		Priority	 Operator	
			1			~, +, -					unary
			2			**	
			3			*, /, //, %	
			4			+, -						binary
			5			<<, >>	
			6			<, <=, >, >=	
			7			==, !=	
			8			&	
			9			|	
			10			=, +=, -=, *=, /=, %=, 
						&=, ^=, |=, >>=, <<=							

Key takeways

Why do we need list?

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 below?

var1 = int(input())
var2 = int(input())
var3 = int(input())
var4 = int(input())
var5 = int(input())
var6 = int(input())
:
:

• reads five numbers.
• prints them in order from the smallest to the largest (NB, this kind of processing is called sorting).

numbers = [10, 5, 7, 2, 1]

Indexing list

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:

numbers = [10,5,7,2,1]
print("Original list content: ", numbers) # print original list content
numbers[0] = 111
print("New list content: ", numbers) # current list content

# We copy the previous code and add the next lines
numbers[1] = numbers[4] # copying value of the fifth element to the second print ("New list content: ", numbers) # printing current list content

Accessing list content

Each of the list's elements may be accessed separately. For example, it can be printed:

print(numbers[0]) # accessing the list's first element

print(numbers) # printing the whole list

[111, 1, 7, 2, 1]

The len() function

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).
Look at the last line of code in the editor, run the program and check what value it will print to the console. Can you guess?

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's vanish from the list, and the list's length will be reduced by one.
Look at the snippet below. Can you guess what output it will produce? Run the program in the editor and check.

print(numbers[4])
numbers[4] = 1

Negative indices are legal

It may look strange, but negative indices are legal, and can be useful.
An element with an index equal to -1 is the last one in the list.

print(numbers[-1])

print(numbers[-2])

Lab. The basic of list

Estimated time

Level of difficulty

Objectives

• Using basic instructions related to lists;
• Creating and modifying lists.

Scenario

• Write a line of code that prompts the user to replace the middle number in the list with an integer number entered by the user (step 1)
• Write a line of code that removes the last element from the list (step 2)
• Write a line of code that prints the length of the existing list (step 3.)

My solution

Código

Functions vs methods

A methods 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, but is also able to change the state of a selected entity.
A method is owned by the data ir 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:

result = function(arg)

result = data.method(arg)

Adding elements to a list: append() and insert()

A new element may be glued to the end of the existing list:

list.append(value)

list.insert(location, value)

• 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.

numbers.insert(1, 333)

Adding elements to a list. Continued

You can start a list's life by making it empty (this is done with an empty pair of square brackets) and then adding new elements to it as needed.
Take a look at the snippet in the editor. Try to guess its output after the for loop execution. Run the program to check if you were right.
It'll be a sequence of consecutive integer numbers from 1 (you then add one to all the appended values) to 5.
We've modified the snippet a bit:

myList = [] # creating an empty list
for i in range(5):
	myList.insert(0, i + 1)
print(myList)

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 myList list.
You need a variable whose sum will be stored and initially assigned a value of 0 - Its name will be total.
Note: We're not going to name it sum as Python uses the same name for one of its built-in functions - sum(). Using the same name would generally be considered a bad practice.) Then you add to it all the elements of the list using the for loop. Take a look at the snippet in the editor.
Let's comment on this example:

• The list assigned a sequence of five integer values.
• The 'i' variable takes the value 0,1,2,3,4 and then it indexes the list, selecting the subsequent elements: the first, second, third, dourth and fifth.
• Each o f these elements is added together by the += operator to the total variable.
• 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

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:

mylist = [10,1,8,3,5]
total=0
for i in mylist:
	total += i 
print(total)

• The for instruction specifies the variable used to browse the list (i here) followed by the in keyword and the name of the list being processed(myList 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.

List in action

Let's leave lists aside for a short 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:

var1 = 1
var2 = 2

var2 = var1
var1 = var2

var1 = 1
var2 = 2 
aux = var1 
var1 = var2
var2 = aux

var1 = 1
var2 = 2
var1,var2 = var2, var1

Litst in action

Now you can easiy swap the list's elements to reverse their order.

myList = [10, 1, 8, 3, 5]
myList[0], myList[4] = myList[4], myList[0]
myList[1], myList[3] = myList[3], myList[1]
print(myList)

[5, 3, 8, 1, 10]

myList = [10, 1, 8, 3, 5]
length = len(myList)

for i in range(length // 2):
	myList[i], myList[length-i-1]=myList[length-i-1], myList[i]

print(myList)

• We've assigned the length 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 length // 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 i^th element (from the beginning of the list) with the one with an index equal to (length-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.

The basics of lists - the Beatles

Estimated time

Level of difficulty

Objectives

• creating and modifying simple lists.
• using methods to modify lists.

Scenario

• Step 1: create an empty list named beatles.
• Step 2: use the append() method to add the following members of the band to the list: John Lennon, Paul McCartney, and George Harrison.
• Step 3: use the for loop and the append() method to prompt the user to add the following members of the band to the list: Stu Sutcliffe, and Pete Best.
• Step 4: use the del instruction to remove Stu Sutcliffe and Pete Best from the list.
• Step 5: use the insert() method to add Ringo Starr to the beginning of the list.

Code

Data test.

Key takeaways

1. The list is a type of data in Python used to store multiple objects. It is an ordered and mutable collection of comma-separated items between square brackets, e.g.:

myList = [1, None, True, "I am a string", 256, 0]

myList = [1, None, True, 'I am a string', 256, 0]
print(myList[3]) # outputs: I am a string
print(myList[-1]) # outputs: 0

myList[1] = '?'
print(myList) # outputs: [1, '?', True, 'I am a string', 256, 0]

myList.insert(0, "first")
myList.append("last")
print(myList) # outputs: ['first', 1, '?', True, 'I am a string', 256, 0, 'last']

myList = [1, 2, 3, 4]
del myList[2]
print(myList) # outputs: [1, 2, 4]
del myList # deletes the whole list

myList = ["white", "purple", "blue", "yellow", "green"]
for color in myList:
	print(color)

myList = ["white", "purple", "blue", "yellow", "green"]
print(len(myList)) # outputs 5
del myList[2]
print(len(myList)) # outputs 4

Exercises

Exercise 1
Exercise 2
Exercise 3
Exercise 4

The bublle sort

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 grater 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.

Sorting a list

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.

myList  =  [8, 10, 6, 2, 4] # list to sort 

for i in range(len(myList) - 1): # we need (5 - 1) comparisons 

	if myList[i] > myList[i + 1]: # compare adjacent elements 

		myList[i], myList[i + 1] = myList[i + 1], myList[i] # if we end up here it means that we have to swap the elements 
		

myList = [8, 10, 6, 2, 4] # list to sort
swapped = True # it's a little fake - we need it to enter the while loop

while swapped:
	swapped = False # no swaps so far
	for i in range(len(myList) - 1):
		if myList[i] > myList[i + 1]:
			swapped = True # swap occured!
			myList[i], myList[i + 1] = myList[i + 1], myList[i]															
print(myList)

The bubble sort - interactive version.

In the editor you can see a complete program, enriched by a cinversation with the user, and allowing the user to enter and to print elements from the list: The bubble sort - final interactive version.
Python, however, has its own sorting mechanisms. No one needs to writes 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:

myList = [8, 10, 6, 2, 4]
myList.sort()
print(myList)	

[2,4,6,8,10]

Key takeaways

1. You can use the sort() method to sort elements of a list, e.g.:

lst = [5, 3, 1, 2, 4]
print(lst)


lst.sort()
print(lst) # outputs: [1, 2, 3, 4, 5]

lst = [5, 3, 1, 2, 4]
print(lst)


lst.reverse()
print(lst) # outputs: [4, 2, 1, 3, 5]

The inner life of list

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 in the editor.
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 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.

Powerful slices.

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 below:

list1 = [1]
list2 = list1[:]
list1[0] = 2
print(list2)

myList[start:end]

myList = [10, 8, 6, 4, 2]
newList = myList[1:3]
print(newList)

Slices - Negative indices.

Look at the snippet below:

myList[start:end]

• Start is the index of the first element included in the slice.
• End is the index of the first element not included in the slice.

myList = [10, 8, 6, 4, 2]
newList = myList[1:-1]
print(newList)

myList = [10, 8, 6, 4, 2]
	newList = myList[-1:1]
print(newList)

Slices: Continued

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:

myList[:end]

myList[0:end]

myList = [10, 8, 6, 4, 2]
newList = myList[:3]
print(newList)

myList[start:]

myList[start:len(myList)]

myList = [10, 8, 6, 4, 2]
newList = myList[3:]
print(newList)

Slices: continued.

As we've said before, omitting both start and end makes a copy of the whole list:

myList = [10, 8, 6, 4, 2]
newList = myList[:]
print(newList)

myList = [10, 8, 6, 4, 2]
del myList[1:3]
print(myList)													

myList = [10, 8, 6, 4, 2]
del myList[:]
print(myList)

myList = [10, 8, 6, 4, 2]
del myList
print(myList)

The in and not in operators

Python offers twi very powerful operators, ble to look through the lists in order to check whether a specific value is stored inside the list or not.
These operators are:

elem in myList
elem not in myList

List - Some simple programs

Now we want to show you some simple programs utilizing lists. The first of them tries the greater value in the list.Look at the code in the editor.
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).
The code may be rewritten to make use of the newly introduced form of the for loop:

myList = [17, 3, 11, 5, 1, 9, 7, 15, 13]
largest = myList[0]
for i in myList:
	if i > largest:
		largest = i 
print(largest)

myList = [17,,11,5,1,9,7,15,13]
largest = myList[0]
for i in myList[1:]: 
	if i > largest:
		largest = i 
print(largest)		

Lists - some simple programs

Now let's find the location of a given element inside a list:

myList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
toFind = 5
found = False

for i in range(len(myList)):
	found = myList[i] == toFind
	if found:
		break

if found:
	print("Element found at index", i)
else:
	print("absent")

• The target value is storedin 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 existed.

drawn = [5, 11, 9, 42, 3, 49]
bets = [3, 7, 11, 42, 34, 49]
hits = 0

for number in bets:
	if number in drawn:
		hits += 1

print(hits)

• The draw list stores all the drawn numbers.
• The bets list stores your bets.
• The hits variable counts your hots.

Lab. Operating with Lists

Estimated time

Level of difficulty

Objectives

• List indexing.
• Utilizing the in and not in operators.

Scenario

Key takeways

• If you have a list l1, then the following assignment: l2 = l1 does not make a copy of the l1 list, but makes the variables l1 and l2 point to one and the same list in memory. For example:

  vehiclesOne = ['car', 'bicycle', 'motor']
  print(vehiclesOne) # outputs: ['car', 'bicycle', 'motor']
  
  vehiclesTwo = vehiclesOne
  del vehiclesOne[0] # deletes 'car'
  print(vehiclesTwo) # outputs: ['bicycle', 'motor']
  

• If you want to copy a lists or part of the lists you can do it by performing slicing.

  colors = ['red', 'green', 'orange']
  copyWholeColors = colors[:] # copy the whole list
  copyPartColors = colors[0:2] # copy part of the list
  

• You can use negative indices to perform slices, too. For example:

  sampleList = ["A", "B", "C", "D", "E"]
  newList = sampleList[2:-1]
  print(newList) # outputs: ['C', 'D']
  

• The start and end parameters are optional when performing a slice: list[start:end, e.g.
• You can delete slices using the del instruction:

  myList = [1, 2, 3, 4, 5]
  del myList[0:2]
  print(myList) # outputs: [3, 4, 5]
  
  del myList[:]
  print(myList) # deletes the list content, outputs: []
  

• You can test if some items exist in a list or not using the keywords in and not in, e.g.

  myList = ["A", "B", 1, 2]
  
  print("A" in myList) # outputs: True
  print("C" not in myList) # outputs: True
  print(2 not in myList) # outputs: False
  

Exercise 1

What is the output of the following snippet?

l1 = ["A", "B", "C"]
l2 = l1
l3 = l2

del l1[0]
del l2[0]

print(l3)

Exercise 2

What is the output of the following snippet?

l1 = ["A", "B", "C"]
l2 = l1
l3 = l2

del l1[0]
del l2

print(l3)

Exercise 3

What is the output of the following snippet?

l1 = ["A", "B", "C"]
l2 = l1
l3 = l2

del l1[0]
del l2[:]

print(l3)