Learning Python

The Ultimate Guide for Beginners to

Coding with Python with Useful Tools

Author Name
Oliver Soranson
 Table of Contents

Introduction
Who Is This Book For?
Brief History of Python Language
Why Python
Features of Python Language
How Python Runs Program
Python Implementations
Installation and Configuration on a Different Operating System
Installing Python on the Mac Operating System
Window Installation
Linux and UNIX installation
Chapter 1: Basics in Python
Keywords
Indentation and Lines
Multiple Line Statements
Variables
Rules to Variable Naming
Avoiding Variable Name Errors
Data Types in Python
String
Using Quotes Inside Strings
Using Methods to Change Case in String
Using Variables in Strings
Comments
How to Avoid Syntax Errors When Using Strings
Operators in Python
Arithmetic Operators
 Comparison Operators
Assignment Operators
Logical Operators
Membership Operators
Summary
Sample Program to Illustrate Operators in Python
Numbers in Python
Integers
Summary of Number Data Types
Floating-Point Numbers
Complex Numbers
Chapter Review
Chapter 2: List & Tuples in Python
Definition of List
Accessing a List Item
Index Positions
Adding, Changing, and Removing Elements in a List
Modifying Elements
Adding Elements
Append an Element to the List End
Inserting Elements
Removing Elements
Remove Items Using del Statement
Using the pop() Method to Remove an Item
How to Remove an Item Using Value
Organizing a List in Python
Using the sort() Method
List Length
Summary
Looping Through a Complete List
 Looping in Python
More actions on a “for Loop”
Performing Actions After a for Loop
Dealing with Indentation Errors
Forgetting to Indent
Numerical Lists
range() Function
Making a List Using range() Function
Performing Statistics on Number List
List Comprehensions
Working with List Part
Slicing a List in Python
Using Loop in a Slice
Tuples
What is a Tuple?
Using loop in a Tuple
Writing Through a Tuple
Summary
Chapter 3: Dictionary
What is a Dictionary?
How to Access Values
Adding Key-Value Pairs
How to Modify Values
How to Remove key-value Pairs
Dictionary with Similar Objects
Looping Through Dictionaries
Looping Through Keys Only
Looping Through Values Only
Nesting Dictionary
How to Use a List Inside a Dictionary
 Summary
Chapter 4: Conditional or Decision Statements
Introduction
Conditional Tests in Python
Checking Equality
Numerical Comparison in Python
Creating Multiple Conditions
Using “AND”
Using “OR”
Boolean Expressions in Python
If Statements
Simple if Statements
if-else Statements
The if-elif-else Chain
Chapter 5: User’s Input and Loop
Using the input() Function
Compare the Two Programs Below
Multi-Line String When Using input() Function
Accepting Numerical Input in Python
Modulo Operator
Closing and Opening Files
Open Function
Introduction to While Loops
Using While Loop
Giving the Users a Choice
Flag in a Program
Exiting a Loop
Using “continue” in a Loop
Avoiding Endless Loop
Using While Loop Condition with Dictionaries and Lists
 How to Move Items from a List to Another
How to Remove Instances of Particular Values from a List
Using User Input to Fill a Dictionary
Summary
Chapter 6: Functions
Defining a Function
How to Pass Information to a Function
Arguments and Parameters
How to Pass an Argument in Python
Positional Arguments
Calling Multiple Functions
Keyword Arguments
Default Value
Chapter 7: Classes in Python
Creating a Class
Example – Creating the Cat Class
__int__() Method
Key Terms
Conclusion
 Introduction

Congratulations on your decision to purchase this book, it is the best

decision you have taken. You are a step away from becoming a professional
Python programmer. If you are new to coding, it can be challenging.
Perhaps you have considered programming languages such as Java, C++, or
COBOL, and this has scared the “hell” out of you. I am in no way trying to
make you scared, but this book contains symbols and letters that initially
you may not understand. Don’t worry because that is not the case with
Python programming because it is much easier than you can ever imagine.
At the end of this book, you will program like a professional with over ten
years of experience.
Learning Python: The Ultimate Guide for Beginners to Coding with
Python with Useful Tools doesn’t many any assumptions regarding your
knowledge of the Python language or any computer programming language.
You don’t require any prior knowledge to get the best from this book. I will
guide you by following a step-by-step approach. Furthermore, every new
jargon, code, or concepts in this book are explained such that even a seven
years old lad will understand. In the course of this book, you will encounter
numerous programs and examples to improve your Python programming
skills.
Let’s Get Started!

Who Is This Book For?

This book is specifically for those with the intention of learning the basics
of Python programming. Learning Python is ideal for both middle and high
school educators whose desire is to guide their students into the
programming world.
The purpose of this book is to equip you with the knowledge of Python
programming and make you a more efficient programmer. You will also
learn advanced Python techniques that will enable you to create whatever
program and web application you envision.
Brief History of Python Language
Python programming language began in December 1989. Guido Van
Rossum created the language, who started programming as a hobby. During
that period, he was busy with a project with the Dutch CWI research
Institute. However, the project was later terminated, which enable him to
start learning the fundamentals of the language.
The major advantage of the language is its ability to extend into more
complex codes and supports multiple platforms. During the beginning days,
these two features were important when personal computers became
popular.
In 2000, Python 2.0 was released to make it a community-oriented
programming language. However, since the introduction of the Python 3
version, not many seems to use the previous version.

Why Python
Interestingly, a beginner can choose from various programming languages.
In spite of this, Python is an important option to consider because it is easy
for anyone to use. Additionally, it can be used on various platforms without
any need to change things. The following are benefits that make people love
using Python.
Readability: The language is designed in such a way that it
works with the English Language. This makes it easier for
anyone to read without requiring any aid. Python also has strict
rules as regards the punctuations.
Libraries: The language has been in existence for over 30 years
and contains codes that other programmers can use effectively.
Community: The community for Python is large because of its
popularity. There are workshops where you can meet people to
ask questions and learn more about the language. As a beginner,
such a community can help you to learn faster and meet others
who are experienced more than you are.
 Different platform: Python works on various operating systems
such as Mac, UNIX, Windows, etc.

Features of Python Language

There are a lot of features that make Python Language one of the most
sought languages to learn. These features include:
It has a great library, which works with other programming tasks
Platform compatibility – it can work on various platforms such
as Mac OS X, Windows, Linux, and Unix
Expandable to other programming languages
Free to download
Contain advanced features such as list generators and
comprehensions
Codes can be grouped into modules and packages
There are varieties of basics data types to choose from, such as
strings, lists, dictionaries, and numbers.

How Python Runs Program

Every programming language has its way of working in order to execute the
program. They all work differently, which is you must learn the process of
organizing these words, and the various statements required by the
programming language in order to avoid any issue or errors. In this section,
I will briefly explore the way python executes its commands.
When you work with this language, you must understand that this is
through an interpreter language. Therefore, you need a text interpreter to
execute the programs line by line before converting into the language the
computer can understand. Since python is a scripting language, you can
directly write your code and execute it through the Python shell or decides
to write the code and save it with its file extension.
What python does is to work on your source code and convert them into a
byte code, which has the extension as .pyc; this makes it easier for your
code to be executed, and within few seconds, you see the output.
Each time you try to call a program you wrote, what python does is to
check if it has a compiled version already with .pyc suffix. Python will
check if a compiled version already exists with the .pyc suffix. If it does, it
will load the code, but if it doesn’t, a new code will be created before the
program executes.

Python Implementations
Don’t get confused about python implementation because is the program or
environment that provides the support needed for the execution of your
program. This is represented by the CPython reference implementation.
What this does is to help you while executing the various statements and
codes needed in the program. We have various variants of CPython, with
each making a big difference. The following are some features, which are
available in these various variants. They include:
Stackless Python – This has an importance on concurrency while
using tasklets and channels. It is mostly used programs such as
Nintendo DS
CrossTwine Linker – This is a combinational feature between
any add-on library you choose and CPython. It offers better
performance, especially when the codes come with it.
Wypthon – This involves the re-implementation of certain
aspects of Python that doesn’t allow the use of byte code.

Installation and Configuration on a Different

Operating System
Since you know the benefits of learning Python, you are ready to get things
started. However, before you begin to learn how to code, it is imperative for
you to understand how to install and configure Python on the different
operating systems. In this book, I will look at how you can install the
language on various operating systems.

Installing Python on the Mac Operating System

Currently, the latest version of Python for the Mac operating system is
Python 3.7.4. However, you can check the Python website
(https//www.Python.org/downloads) if there is any latest update. On the
website, click on “Download Python 3.7.4,” then double-click on the file
once the download is complete. This will give you access to the content of
the disk image. After that, you have to run the installer by right-clicking on
the file “Python.mpkg” and select open from the drop-down menu. If you
get an error message indicating that, “Python.mpkg can’t be opened because
it is from an unidentified developer,” then you have to click on the file, and
select “Open with…” and then click on “Installer.”
The diagrams below will help you install Python on Mac OS properly.
Ensure to adhere to the instructions in the diagram below.
Window Installation
If you are using Windows 7, 8, or 10, adhere to the basic steps to install the
Python interpreter on your machine.
Open your internet browser (Chrome, Firefox, Opera, or Internet
Explorer) and insert this link –
https://www.Python.org/download
Click on the Window links, and the installer will pop up. You
can select the version you want.
In order for the installer to work, your system must meet the
basic requirement of having Microsoft Installer 2.0. Then save
the file before running it.
Then you can run the file you downloaded. Then run the
downloaded file and follow the installation wizard, which is easy
for anyone to follow. Additionally, accept all the default settings,
 and once the installation is complete, you are ready to begin your
programming with Python.

Linux and UNIX installation

Similar to the windows and Mac OS platforms, you can install Python on
your Linux and UNIX OS. To do that, follow these steps below.
Open your internet browser (Chrome, Firefox, Opera, or Internet
Explorer) and insert this link –
https://www.Python.org/download
Click on the Unix/Linux link and down the zipped source code
Once the file in question has finished downloading, you can
extract the file using a file extracting software like WinZip.
Edit the setup files to perform any form of personalization to suit
your use.
Run the ./configure script to install.

With this, Python will be installed. The standard location and libraries are
located at /usr/local/bin and /usr/local/lib/Python respectively
 Chapter 1: Basics in Python

Once you have the software installed on your system, it is time to begin
your programming adventure with Python. I will start with the
fundamentals such as variables, strings, and keywords. In this chapter, you
will learn and write your very first program in Python, the different data
you can work with, how to use variables, and keywords. Let us begin with
the basics to get your coding started right away.

Keywords
Some terms don’t require much explanation. The word represents what they
mean. The same applies to keywords. Keywords are reserved words that are
used specifically by the programming language. Each programming
language has its unique keyword, which is meant for a particular purpose.
Furthermore, avoid using these keywords elsewhere in your code. If you
decide to neglect this instruction, you will end up with your program not
working properly or receive an error alert. The following are reserved
keywords used in Python Programming Language:
async assert as and
def from nonlocal while
continue for lambda try
elif if or yield
else import pass
global not with del
in raise false await
return none break except
true class finally Is

Let us begin with the fundamental “Hello” program that is the first step for
any programmer.
Print (“Hello, Welcome to Python Programming!”)

When this program code is run, your output will be:

Hello, Welcome to Python Programming!

Python programs always end with the extension .py Let us save this
program as Hello.py. Please always remember to save each example
using its name in order to recall them when necessary . When you use
your editor or IDE, the file is run via the interpreter, which then determines
the words used in the program. For instance, in the program below, the
interpreter will see the word encircled in parenthesis and prints what is
inside the parentheses. In the course of writing Python codes, the editor
may highlight certain parts of the program. For instance, it recognizes that
print () is a function name and uses a particular color to differentiate it.
However, when it gets to the word “Hello Welcome to Python
Programming!” it recognizes that it is a Python program code. Therefore, it
uses a different color to differentiate it from the other code. This unique
feature is known as syntax highlighting and is useful for beginners.

Indentation and Lines

There is nothing like braces to indicate a block of code for function and
class in Python. Normally, a block of code is represented by a line
indentation that gets enforced in a strong manner. Importantly, the spaces in
the indentation vary; however, every statement in the block must have the
same amount of indentation. For instance,

if False:
print "False"
else:
print "True"

However, the block of the statement below will generate an error

if False:
print "Result"
print "False"
else:
print "Result"
print "True"

Consequently, all continuous lines you indent using the same number of
spaces will for a block. Let us use another example to show various
statement blocks. I will advise you not to try to understand the logic of the
program. However, your aim is to understand the various blocks
irrespective of their structure.

import sys

try:
# open file stream
file = open(fileName, "w")
except IOError:
print "Error when writing to", fileName
sys.exit()
print "Enter '", fileFinish,
print "' When finished"
while fileText != fileFinish:
fileText = real_input("Enter text you want: ")
if fileText == fileFinish:
# close the file
file.close
 break
file.write(file_text)
file.write("\n")
file.close()
fileText = real_input("Enter filename: ")
if len(fileName) == 0:
print "Next time input something"
sys.exit()
try:
file = open(fileName, "r")
except IOError:
print "Error reading file requested"
sys.exit()
fileText = file.read()
file.close()
print fileText

Multiple Line Statements

These statements normally terminate with a new line. Though, it allows you
to use a special character (\) to continue a statement. Check the code below:

Total_Number = number1 + \
number2 + \
number3

Notwithstanding, there is an exception to this situation if such statements

contain brackets such as (), {}, or []. For instance;
 months = [‘December’, ‘November,’ ‘October,’ ‘September,’ ‘August,’
‘July,’ ‘June,’ ‘May,’ ‘April,’ ‘March,’ ‘February,’
‘January’]

Variables
A variable is a storage location, which has a name assigned to it. In Python,
we can assign a value to a variable and recall these variables. I believe an
example will make things clearer. Remember our first program (hello.py),
let us add an additional two lines. Consider the program below:

outcome= “Hello, Welcome to Python Programming!”

print(outcome)

When you run the program, your output will be the same as the previous
one, which was:

Hello, Welcome to Python Programming!

The only difference is that we added a variable called “outcome.” Each

variable always has a value assigned to it. In this situation, the value of
“outcome” is “Hello Welcome to Python Programming!”
Let us add two additional lines to the previous code. However, ensure to
insert a blank line in the first code before adding the new codes.

outcome= “Hello, Welcome to Python Programming!”

print(outcome)

outcome = “Hello, Welcome to Learning Python!”

print(outcome)
After adding the two lines, save the file and run the program again. Your
output will be as follows:

Hello, Welcome to Python Programming!

Hello, Welcome to Learning Python!

Rules to Variable Naming

There are important rules to adhere to when naming variables in Python. If
you break any of these rules, you will get an error message. Therefore,
ensure to keep them in your mind when writing your programs.
Variable names must have only numbers, underscores, and
letters. You can begin your variable names with an underscore or
a letter; however, it must not begin with a number. For example,
your variable name can be outcome_1, but using 1_outcome is
completely wrong.
A variable name must not contain space between them.
Notwithstanding, you can use underscores to separate two
words. For instance, outcome_program will work; however, the
outcome program will cause errors in your program.
Avoid using function names and keywords as variable names
Variable names must be short and descriptive when used. For
instance, score is preferable than using s, serial_name is better
than sn.

Avoiding Variable Name Errors

As a beginner, you will make mistakes. Professionals aren’t exempted from
this situation, but they know how to tackle these errors efficiently. Let us
look at a more likely mistake you will make as you beginning your Python-
programming course. I will intentionally write an error code by misspelling
the word “outcome.”

outcome = “Hello, Welcome to Learning Python!”

#program will generate an error
print(outcom )

When such an error occurs, the Python interpreter figures the best way to
solve the problem. It provides a traceback once the program cannot run
successfully. Not many programming languages have this feature to
traceback an error. Let us look at how the interpreter will respond to our
program above

Trackback (most recent call last):

1. File “hello.py,” line 3, in <module>
2. Print(outcome)
3. NameError: name ‘outcom’ is not
defined

Line 1 reports the presence of an error in line 3 with filename “hello.py”

however, the interpreter quickly identifies the error and informs us what
particular type of error it is in line 3 . In a situation like this, it will signify a
name error. Additionally, it will reports that our variable hasn’t been
properly defined. Whenever you see a name error, it means there is a
spelling error, or we didn’t set a value to the variable. However, in this
example, it was a wrong spelling where we didn’t include the letter “e”
from our variable name.
Note that the interpreter does not check the code for spelling; rather, it
ensures the variable names are consistent when used. For instance, if we use
the variable “outcom” in our previous program, it will print out the result
successfully. Check the code below.

outcom= “Hello, Welcome to Python Programming!”

print(outcome)

outcom = “Hello, Welcome to Learning Python!”

print(outcome)
The program output will be:

Hello, Welcome to Python Programming!

Hello, Welcome to Learning Python!

You must understand that programming languages are strict; however, they
disregard bad and good spellings. Because of this, you don’t need to
contemplate about grammatical and spelling procedures when creating a
variable name.

Exercises to Try
Write a program that intends to perform the following things. Ensure to
save the file and following the variable naming rules.
Write a program that assigns a message to a variable name of
your choice and print the message
In this second program, change the value and use a new
message. Then print the message.
Tick the wrong variable names from the list below
1_school
Fred Love
Fred_love
_exercises
Firsttwoletters

Data Types in Python

When writing codes, we need to store data into memory. These data cannot
be stored in the same memory because a number will be different from a
letter. For instance, a person’s name is alphabetic; address can be
alphanumeric characters, whereas age can be stored as a numerical value.
Python has data types to define various operations and methods of storing
these data types. There are five data types in Python; these are:
String
Numbers
Tuple
List
Dictionary

Note, I will emphasize on the first two while the list, tuple, and dictionary
will be included in a single chapter.
String
This is a series of characters, which is enclosed in quotes. In Python,
anything in quotes is regarded as a unique character. Both single and double
quotes can be used to form a string in Python.

‘Hello World’
“Hello World”

The two statements would produce the same output if we were to run it.

Using Quotes Inside Strings

In Python programming, when using strings, an opening string with a quote
must match the ending quote. When you begin a string using a double
quotation mark, Python takes the next double quotation mark as the ending
of the string. This applies to a single quotation mark.
If you decide to use double quotes inside a string, you have to place them
inside single quotes. The example below will show it better.
statement = ‘Fred is “a boy that lives in New York”’
let’s assume you want to use both single and double quotes in a string. In
this situation, you have to escape the single, and double quote misses up by
using a backslash (\). The example below will demonstrate it.

statement_in_single = ‘Fred “own\’s a wonderful car in his garage”’

statement_in_double = “Fred \ ‘own’s a wonderful car in his garage\””

Using Methods to Change Case in String

One simple task you can perform when using strings is to change the case
of a particular word. What do you think the output will be for the code
below?

Full_name = “johnson boris”

print(full_name.title())

Once you write the code, save the file as name.py before running it. The
output will be as follow:

Johnson Boris

If you observe, the variable full_name refers to the string in lowercase

“johnson boris.” After the variable name comes to the method title(). In
Python, a method is an action upon which certain manipulation can be taken
on a piece of data. Furthermore, the dot (.) that comes after the variable
name informs the interpreter to allow the title() method to interact with our
variable name. parentheses always follow a method because they require
additional information to perform their function. The function of the title()
method is to change the first letter of each word to capital letter.
Furthermore, Python allows us to change string to all lowercase or
uppercase.

Full_name = “Johnson Boris”

print(full_name.lower())
print (full_name.upper))

The output will be as follows:

johnson boris
JOHNSON BORIS

Using Variables in Strings

In certain scenarios, you may decide to use a variable, which contains a
value in a string. For instance, you may want to use two variables to hold
the first name and last name of a person, respectively. Additionally, these
two variables must be combined to produce the individual’s full name. Let
us consider how that is possible in Python.

first_name = “johnson”
last_name = “boris”
1. full_name = f “{first_name}
{last_name}”

print(full_name)

If you want to insert a variable value to a string, you have to add the letter
“f” directly before the opening quotation mark
Consider the code below

state = 'United Nation!' #Assign the variable “state” to a string ‘New

York’

print state # Prints the complete string

print state[0] # Prints the first character of the string
print state[0:4] # Prints characters starting from 1st to 4th
print state[3:] # Prints string starting from 4th character
print state * 3 # Prints string three times
print state + " United State" # Prints concatenated string

The output will be –

United Nation!
U
United
Nations!
United Nation! United Nation!
United Nation! United State

Comments
If you observe in the program above, we use the symbol # to begin a
statement after declaring a variable. Nevertheless, it shouldn’t be used
within a string literal. The Python interpreter ignores comments because
they are not part of the program but provide an explanatory note for the
programmer. Let us look at this example below:

#Learning about Comments in Python

print “Learning Python Language isn’t complicated.”
#Another comment to make things better

When you run this program, the output will be:

Learning Python Language isn’t complicated.

How to Avoid Syntax Errors When Using Strings

A syntax error is a common error you will encounter when using Python. It
normally occurs when the interpreter doesn’t identify a particular section of
the program. For instance, you wanted to use an apostrophe in a single
quote; this will result in an error. Here is an example to show how you can
easily use both single and double quotes properly.

statement = “One of American’s problem is the lack of unity”’

print(statement)

In this situation, the apostrophe is inside the double quote. The interpreter
won’t see anything wrong with this program. However, consider the code
below.

statement = ‘One of American’s problems is the lack of unity’

print(statement)

If you run it, the interpreter will indicate a syntax error. Ensure you avoid
this kind of mistake
Exercise to try
1. Use a variable name of your choice to represent your name and
print the message “Python Language is the best!”
2. Declare a variable name and assign a name to it. Furthermore,
print the name in title case, uppercase, and lowercase.
3. Write a simple program, which uses four variables. The variables
must be address, phone_number, age, and sex. Then assign
values to each variable in the program.
Bonus Answer for Exercise 3

address = “23 London Street, New York”

phone_number = “0123456789”
age = “26”
sex = “Male”
print (address)
print (phone_number)
print (age)
print (sex)

Simple and short, your program is ready for execution. Remember to save it first before running.
If you have done that, your output will be as follows:

23 London Street, New York

0123456789
26
Male

Operators in Python
Operators in a programming language are used to carry out various operations on variables and
values. These operators allow programmers to manipulate variables and return results based on
the operator used. In this section, you will learn various operators you need to manipulate
operands.

Arithmetic Operators
These operators are by far the simplest you will find in any programming language. With these
operators, you can perform arithmetic calculations such as addition, division, subtraction,
multiplication, exponent, modulus, etc. Let us see how these operators can be used in a python
program.

number1 = 6
number2 = 3
print(number1 + number2)
print(number1 –number2)
print(number1 * number2)
print(number1 / number2)
print(number1 % number2)
print (number1 **2)

The output will be as follow:

9
6
1
8
2
0
2
5

Arithmetic operators are very easy to use and straightforward for any beginner to understand.

Comparison Operators
From the name, you can easily understand what these operators are used for. They compare
values on both side of an operand and determine the relationship between them. At times, they
are known as relational operators. These operators include <>, <=, >=, !=, == etc. They compare
values and return the results in true or false. let us rewrite our previous arithmetical operator
example.

number1 = 6
number2 = 3
print(“number1 > number2”, number1 >number2)
print(“number1 < number2”, number1 <number2)
print(“number1 != number2”, number1 !=number2)
print(“number1 >= number2”, number1 >= number2)
print(“number1 <= number2”, number1 <= number2)

Output

True
False
True
True
False
Assignment Operators
The primary function of these operators is to assign a value to a variable. You assign what is on
the left-hand side to the right. These operators include +=, *=, -=, /=, etc.

number1 = 6
number2 = 3
print(("The value of number1 is : ", number1))
print(("The value of number2 is : ", number2))

6
3

There are also compound assignment operators where you can subtract, add, multiply a right
operand to the left before assigning it to the left. In the next program, we will add the value of
number1 and number 2 before assigning the results to another variable and print out the output.

number1 = 6
number2 = 3
result = number1 + number2
print((“ The result of number1 and number2 is:”, result))

In the program above, we just perform a simple assignment. Our output will be 9.

Logical Operators
These operators are used to test if a particular conditional statement is true or false. They include,
NOT, OR, and AND. However, there are rules that apply to these operators for them to either
return true or false. These rules are:
A NOT operator will return True only when the operand is false
An OR operator returns true if one of the operands is true
The AND operator returns true when both the operands are true

Here is an example. We will use number1 and number2 to represent true and false respectively.

number 1 = True
number2 = False
print ((“NOT number2 is: ” NOT number2))
print ((“number1 OR number2 is: ” number1 OR number2))
 print ((“number1 AND number2 is: ” number1 AND number2))

The output will be as follow

True
True
False

Membership Operators
Although not commonly used, however, they are used in sequences like strings, lists, and tuples.
In Python, we have two membership operators – “not in” and “in.” The operators give you the
result depending on the variable available in the string or sequence you specified. Let us see how
you can use them in a program.

number1 = 15
number2 =56
new_list = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ];
if ( number1 in new_list ):
print("number1 is available in our given list.")
else:
print("number1 is unavailable in our given list")
if ( number2 not in new_list ):
print("Number2 is not available in our given list.")
else:
print("number2 is available in our given list")

Let see how the program runs line by line. In the first and second lines, we declare two variables
and assign values for them. In the third line, we created a list “new_list” before using an if-else
statement to test the membership operator on our list. we check if number1 is available in our
list; depending on the number, it prints the expression based on the condition it fulfills. It does
the same for number2 before printing out the desired result. In our program above, our output
will be:

number1 is available in our given list.

number2 is not available in our given list.

Summary
Operators are important functions used in programming languages to perform various operations
on operands. However, in Python, we use operations such as:
 Arithmetic operators to perform operations on operands; these operators include
addition, subtraction, multiplication, division, exponent, and modulus. Python also
uses the call functions, declare variable $ calculate, and eval function.
Comparison operators used to compare operands on both sides before determining
the relationship between them
Assignment operators to assign values to variables; we also have a compound
assignment operator, which allow you to assign the result of an operand
Logical operators, which include NOT, OR, and AND. They are used to return
either true or false, depending on the condition set.

Sample Program to Illustrate Operators in Python

# Arithmetic Operators

number1 = 8
number2 = 4
print(number1 + number2)
print(number1 –number2)
print(number1 * number2)
print(number1 / number2)
print(number1 % number2)
print (number1 **2)

#Comparison Operators
number3 = 13
number4 = 9
print(“number3 > number4”, number3 >number4)
print(“number3 < number4”, number3 <number4)
print(“number3 != number4”, number3 !=number4)
print(“number3 >= number4”, number3 >= number4)
print(“number3 <= number4”, number <= number4)

#Assignment Operators
number5 = 9
number6 = 6
print(("The value of number5 is : ", number5))
print(("The value of number6 is : ", number6))

#Logical Operators
number7 = True
number8 = False
print ((“NOT number8 is: ” NOT number8))
print ((“number7 OR number8 is: ” number7 OR number8))
print ((“number7 AND number8 is: ” number7 AND number8))

#Membership Operators
number9 = 5
number10 =63
new_list = [17, 5, 9, 7, 20, 63 ];
if ( number9 in new_list ):
print("number9 is available in our given list.")
else:
print("number9 is unavailable in our given list")
if ( number10 not in new_list ):
print("Number10 is not available in our given list.")
else:
print("number10 is available in our given list")

Numbers in Python
Numbers are used in programming to store information, represent data, and keep scores, etc., In
Python, numbers are treated in several ways, depending on what they are used for. In this
section, we will look at how Python supports various numerical types, such as integer, float, and
complex numbers. Integers are easier to work with when writing programs.

Integers
You can perform operations such as addition, subtraction, multiplication, and division on
integers. In the later chapter, we will explore more on these operators. I just want you to be
familiar with them. For instance:
>>> 3+8
>>> 8 -7
>>>8*2
>>>8/4

If you want to use an exponent, then you have to use two multiplication symbol.

>>5**2
>> 12**5

Python follows the order of precedence when performing operation; with this, you can use
several operations in a single expression. Additionally, if you want to modify an order of
operation, you can use parentheses. Python evaluates the expression in the order you specify.

>>3+2*4
>>(3 + 2) * 4

In the first expression, the output will be 11. However, for the second, it will be 20. Note that
spacing doesn’t have an effect on how expressions are evaluated in Python. Notwithstanding, it
allows you to identify the operation with the highest priority when going through the code.

Summary of Number Data Types

int long float complex
-786 0122L -21.9 9.322e-36j
0x69 -4721885298529L 70.2-E12 4.53e-7
-0x260 -052318172735L -32.54e100 3e+26J
10 51924361L 0.0 3.14j
100 -0x19323L 15.20 45.j
-0490 535633629843L -90. -.6545+0J
080 0xDEFABCECBDAECBFBAEl 32.3+e18 .876j

Floating-Point Numbers
A float is a number with a decimal point, and Python language has its way of managing decimal
numbers. They can be written in scientific notation; the letter “e” represents the 10th power.
Examples of floating numbers include 4.5e2, 0.25, 154.05588 etc. An important advantage of
using floating-point values instead of integers is that they allow bigger storage space than
integers. Additionally, they can also store numbers of smaller value. You can consider floating
point numbers as those with unlimited storage space. Interestingly, they can contain numbers as
much as 2.4548899981236585 X 10-452 and as little as ± 4.4879541268971562 × 10-452
There are various ways of allocating values when using floating-point values. You can assign
them directly or decide to use scientific notation. Don’t forget that negative exponents will result
in fraction equivalents.

Complex Numbers
Another type of number data types we have in Python is complex numbers, which include both
real and imaginary numbers. They are usually in this form – a + cJ where “a” represents a float
and a real part of the complex number. Alternatively, the “cJ” comprises of the float “c” whereas
“J” is the square root of an imaginary number. In this situation, this makes c to be the imaginary
part of the number.
This may look complex but let us use an example to make it simple

x = 5 + 9j
y= 9 – 5j
z=x+y
print(z)

The output will be as follow:

(14 + 4j)

Chapter Review
A variable is a storage location, which has a name assigned to it
Variables must begin with a letter. However, they can have underscores and
numbers
Variable declaration: variable_name = value
Strings are a series of characters enclosed in quotation marks
Python data types include numbers, tuple, dictionary, list, and string.
Python number data types comprise of integer, floating numbers, and complex
numbers.
 Chapter 2: List & Tuples in Python

In this chapter, you will learn everything you need to learn about a list in
Python programming. Lists give you the opportunity to store a particular set
of information in a place irrespective of the number of items in such a list.
They are important features in Python that are accessible to programmers.

Definition of List
A list refers to a data type that contains a collection of items in an orderly
manner. For instance, a list can comprise the alphabets, digits, or names of
the street in a country. Below is the syntax structure for a list:
list = [item1, item2, item3, itemN]
Consider the list of items in a kitchen in this code.

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,”

“knife,” “bowls”]
print(kitchen_item)

If you decide to print this code, the output will be as follows:

[“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,” “knife,” “bowls”]

Accessing a List Item

Perhaps, you don’t want the users to see certain items in a list; you can
decide to access only the items you want. To have access to a particular
element in a list, you have to write the list name then followed by the index
of the item, which is enclosed in squared brackets. For instance, we can pull
the third item in our list of items in the kitchen.

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,”

“knife,” “bowls”]
 print(kitchen_item [3])

The output will be as follow:

dishwashe
r

Index Positions
The first index position in Python is not 1 but 0. If you observe in the
example above, you will see that when indexed the third item, we started
counting from 0. You can see that pot (0), kettle (1), fridge (2), while
dishwasher (3). Peradventure, you run a Python program and get a different
result; you have to check if you are making a number error.
Always remember that the second element in any list starts with an index of
1. A simple way of knowing what the particular index number will be is to
substrate one from the item you want to index. Does that sound simple?

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,”

“knife,” “bowls”]
print(kitchen_item)

For instance, we want to access only the item “microwave. To do that, you
have to count the number of items to get to “microwave” and subtract one.
from the code, if you count first, you will discover that “microwave” is the
5th element. However, to index it to print only “microwave,” you have to
substrate one from the element. Your code will be like this:

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,”

“knife,” “bowls”]
print(kitchen_item [4])

Let us use another example to index the third and sixth items.

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,”

“knife,” “bowls”]
 print(kitchen_item [3])
print(kitchen_item [6])

The output will be as follows:

dishwashe
r
bowls

Assuming you only want to access the last element, Python has a unique
way of doing that. You can do this by using an index of -1. With this,
Python returns the last item.

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,”

“knife,” “bowls”]
print(kitchen_item [-1])

In this example, the code will return “bowls.” It is easy to remember this
syntax. You do not have to know the particular length of the list. This also
applies to other negative index values. It is like going backward. You can
use the negative index to access the second or third items in a list. For
instance,

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,”

“knife,” “bowls”]
print(kitchen_item [-2])
print(kitchen_item [-3])

The output will be as follows

knife
microwav
e
Exercise to Try
Write a Python program, which contains a list of all your special
friends. Then print their names by accessing each element in
your list.
From the list, you created above, print a greeting message to
each name you access in the list.
Think of any means of transportation you can remember and
write a list of items used within them. Then make a statement on
some of these elements in the list and print it.

Adding, Changing, and Removing Elements in a

List
The lists you will mostly create in Python are dynamic in nature. This
means you have to build the list, add elements to it, and remove it in the
course of running your program. For instance, you may decide to create a
game where the player must shoot birds flying. You may record the first set
of birds in a particular list before removing each bird that is shot down.
Once a new bird appears, it is added to the screen. Your bird lists will
increase, whereas the length will decrease throughout the game.

Modifying Elements
You can modify elements in an element similar to how you can access it.
Furthermore, the same syntax applies to when you want to access an
element. To modify an element, you will use the list name, followed by the
index element that you want to modify, and then provide the new value to
want to change. Well, this may sound foreign; however, let me use a simple
example to illustrate how you can do this. For instance, we want to change
dishwasher to spoon in the example below, how can you do that.
kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,”
“knife,” “bowls”]
print(kitchen_item)
 kitchen_item[3] = “spoon”
print(kitchen_item)

The first two lines of code define our original list, which contains the word
“dishwasher.” The third line changes the element from dishwasher to spoon.
If you do it correctly, you will get the output as:

[“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,” “knife,” “bowls”]

[“pot,” “kettle,” “fridge,” “spoon,” “microwave,” “knife,” “bowls”]

You can change any element irrespective of where it is positioned.

Adding Elements
At times, you may want to add an element in a list to expand your program.
Remember the bird scenario, where you have additional new birds each
time you shoot. It doesn’t apply to that alone; you may want to expand your
database to include new users or add new items to a list. Python provides
various means of adding elements in a list. In this section, we will focus on
two ways you can do this as a beginner.

Append an Element to the List End

This method is the simplest to use when adding an element to a list. By
appending the element, you add the item to the list end. Remember, we use
the word “append” to add new items. However, for consistency purposes, I
will use our previous kitchen_item example to explain. In this example, we
will add cooking gas to the list.

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,”

“knife,” “bowls”]
print(kitchen_item)

kitchen_item.append(“spoon”)
print(kitchen_item)
The append()method allows us to add an element at the end of the list. The
output will be:

[“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,” “knife,” “bowls,”

“spoon”]

If you have an empty list, you can utilize the append() method to add a new
list. Assuming we want to add a new list element such as pot, kettle, and
microwave, we can do that as follows:

kitchen_item []

kitchen_item.append(“pot”)
kitchen_item.append(“kettle”)
kitchen_item.append(microwave”)

print(kitchen_item)

This code will produce:

[“pot,” “kettle,” “microwave,”]

It is very common to build the list this way because you may not know the
particular data type the users want to keep track of in the program.
However, to give the users full control, first define an empty list, which will
hold values of the users. With this, you can use the append method to add
new elements to the list created.

Inserting Elements
The second way of adding an element in a list is by inserting the element to
the position you want through the insert() method. You have to specify the
index of both the new element and the value, respectively. For instance, we
want to insert a “spoon” after the microwave item on the list.

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,”

 “knife,” “bowls”]
print(kitchen_item)

kitchen_item.insert(3, “spoon”)
print(kitchen_item)

Your output will be:

[“pot,” “kettle,” “fridge,” “dishwasher,” “spoon” “microwave,” “knife,”

“bowls”]

What happened in the example above is that I inserted the value “spoon” at
the third index. The insert method enables us to create a space between the
“dishwasher” and the “microwave” while storing the value “spoon” to the
location created.
Removing Elements
There are situations that may warrant you to remove an item in a list. For
instance, a player may decide to remove a bird; he shoots down from the
sky from the active list. Perhaps, you want to delete a customer’s account or
cancel their account. You can remove such detail from the list. You can use
the following two ways to remove elements in a list.

Remove Items Using del Statement

Python provides a unique way of removing or deleting an item if you know
the position of such an item from the list. Look at the code below:

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,”

“knife,” “bowls”]
print(kitchen_item)

del kitchen_item [4]

 print(kitchen_item)

What did you think will be deleted from the snippet above? If your answer
is a dishwasher, then you are wrong. Remember that Python index begins at
0. This means we start counting 0 from the first element. Therefore, the
final output will be:

[“pot,” “kettle,” “dishwasher,” “microwave,” “knife,” “bowls”]

You can remove any item from the position of your choice.
Using the pop() Method to Remove an Item
There are situations where you want to use an item value after removing it from the list. For
instance, you want to know the coordinates of the bird you shot, to enable you to draw an
explosion in such a position. The function of the pop()method is to remove the last item in the list.
For clarity, let us pop an example.

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,” “knife,” “bowls”]

print(kitchen_item)

popped.kitchen_item = kitchen_item.pop()
print(kitchen_item)
print(popped.kitchen_item

I won’t explain the first two lines since you are already conversant with it. However, if you forget,
I will refresh your memory. The first line begins by declaring “kitchen_item” as a variable with
values including pop, kettle, fridge, dishwasher, microwave, knife, and bowls. The second line
prints out the items in the kitchen_item list.
In the third line, we popped a value from our list and store the value to the new variable
“popped.kitchen_item” additionally, we print out the remaining items in the kitchen_item list.
From the code above, our output will be:

[“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,” “knife,” “bowls”]

[“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,” “knife”]

bowls

The first line shows the complete kitchen_items, whereas the second shows the remaining items
after the popped method was used. Finally, line three shows the item removed from our list.

How to Remove an Item Using Value

It is not in every situation that you will know the exact position of a value you want to remove
from your list. Remember, if you identify the value, then you can use the remove()method because
it serves the best option in this situation. Do you remember our previous example where we use the
del function? However, this is different. Let's remove an item from the list of our kitchen_item.

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,” “knife,” “bowls”]

print(kitchen_item)

kitchen_item.remove(kettle)
print(kitchen_item)
In the example above, our aim was to remove the kettle from the list of kitchen items. The output
will be as follow:

[“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,” “knife,” “bowls”]

[“pot,” “fridge,” “dishwasher,” “microwave,” “knife,” “bowls”]

Exercise to Try
The following exercises to try may seem complex; however, the offer you a huge opportunity to
include all the lists we have described in this section.
First list – If you are given the opportunity to invite 10 persons (dead or alive) for a
love feast, who will you invite. Then print a message for each individual, inviting him
or her to your love feast.
Alter the first list – Due to unforeseen circumstances, two of your invitees fell ill and
won’t make it. It means you have to send a new invite to replace the absentees. Using
a print call, list the invitees that won’t make it. Furthermore, replace the list with new
invitees and print out the full list.
Special list – Now create a new list by using the insert() method to add your best five
invitees to the love feast.

Organizing a List in Python

Most times, you may create your list in an unorderly manner because you link the ability to control
what the user is providing. However, you can avoid such a situation and organize the list properly.
You can preserve the order in the list or change it from its original order. There are ways of doing
this, depending on your particular situation.

Using the sort() Method

An easier means of organizing a list in Python is by using the sort method. Consider our kitchen
items in previous examples, and you want to sort them alphabetically. To make it easier, we assume
all the items are in lowercase.

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,” “knife,” “bowls”]

kitchen_item.sort
print(kitchen_item)

The output will be as follows when the sort method operates on the list items. Remember, it sorts
the item in alphabetical order.

[“bowls,” “dishwasher,” “fridge,” “kettle,” “knife,” “microwave,” “pot”]

Look at the code below:

kitchen_item = [“pot”, “kettle”, “fridge”, “dishwasher”]
kitchen_item.sort(reverse=true)
print(kitchen_item)

What do you think will happen to our list? Well, the kitchen items will be reversed, and your
output will be:

[ “fridge,” “dishwasher,” “pot,” “kettle”]

List Length
Another important thing you can do with a list is to determine the length. To do this, you have to
use the len() function. Using our kitchen item list, we can demonstrate this.

kitchen_item = [“pot,” “kettle,” “fridge,” “dishwasher,” “microwave,” “knife,” “bowls”]

len(kitchen_item)
print(kitchen_item)

The output will be

This function comes handy, especially when you want to determine the number of birds that
remains to be shot.

Summary
I am convinced that you know what lists are, how to work with them, including adding and
removing elements in a list. Furthermore, you know how to determine the length of a list; however,
I want to go a step higher by introducing how you can work with items in a given list effectively.
We will loop through these items with a few line codes. With looping, you can work with any list,
irrespective of how many items contained in it.

Looping Through a Complete List

At times, you may want to go through all elements in a list in order to perform the same activity on
each item. For instance, you might want to perform certain statistical operatives on all elements in
a list or display every headline contained in a list on your website. Well, you can do this and more
activities on items in a list by using a loop.
For instance, the list below comprises of famous magicians’ name and our aim is to print their
names from the list. There are several ways of doing this; it could be by retrieving each name
individually or allow Python to perform the magic. Nevertheless, the problem with the first option
is that it can create numerous problems for us because it can be repetitive to do this if the list is
long. Furthermore, there is a need to change the code whenever the length of the list changes. You
see how tedious it could be if we decide to take the first approach. To save you the stress, let me
show you the easier way of printing out the list individually.

magicians_name =[“Greg,” “Perpetual,” “Amos”]

magician in magicians_name:
print(magician)

In the first line, we began by assigning elements to the variable name “magicians_name.” You
should be familiar with this by now if you have been following. The second line tells the
interpreter to bring a name from our magicians_name list and assign the element to the variable
magician. Then the third line prints the name assigned to the variable magician. The interpreter
repeats the process for the remaining items in the list and produces the output. If you type the code
properly, your output will be as follow:

Greg
Perpetual
Amos

Note: Always remember to save your programs.

Looping in Python
The theory of looping is significant in any programming language, including Python, because it
provides an easier way for a computer to perform automatic repetitive tasks. For instance, in our
previous magician program, in the second line, the interpreter reads the line (magician in
magicians_name). The line informs the interpreter to retrieve the first value of the magicians_name
list. It further assigns it to the variable magician. The first value is “Greg,” and the interpreter goes
to read the next line – print(magician) .
The interpreter goes back to the second line and retrieves the second name “Perpetual” before
assigning it to the variable magician. Then the last line is executed, which prints the name
“Perpetual.” Once this is completed, the interpreter repeats the loop again to evaluate the last value
and print “Amos.” Since that is the last loop, there is no more instruction to execute, the program
halts. In the course of using a loop in Python, remember that the steps are repeated once for each
element in the list, irrespective of the number of elements in the list you created. Additionally, you
have the liberty to select the name you desire to store your values in the program. However, it is
important to use a meaningful name. For instance, let us use a list of lions, horses, and cars.

for lion in lions

for horse in horses
for car in cars

This kind of naming convention will enable you to follow the actions performed on each item in
the loop. You can also identify the section of the code with errors when you use singular and plural
names.
More actions on a “for Loop”
You can perform whatever thing you want on each item when using a for loop. Instead of using a
new example, I will use our magician example. In this example, I will print a message indicating
that each magician did perfectly well.

magicians_names =[“Greg,” “Perpetual,” “Amos”]

for magician in magicians_names:
print(f “{magician.title()}, you did an excellent trick today!”)

The first two lines do not require any explanation. However, the only alteration in the code is the
third line, where we created a piece of unique information to every single magician, beginning with
his or her name. During the loop, it goes through the first value, which is “Greg” and prints the
message after the name. it does the same thing for the value “Perpetual” before running through the
loop for the third time to print the value “Amos” with the message. The output will show a
customized message as follows:

Greg, you did an excellent trick today!

Perpetual, you did an excellent trick today!
Amos, you did an excellent trick today!

You can write many codes as possible inside a for loop. Each indented line that follows the line
“for magician in magicians_name” is regarded to be within the loop with each indented line
performed once for every single item. For instance, let us add another line to our previous example,
telling the magicians to keep the good work going every day.

magicians_names =[“Greg,” “Perpetual,” “Amos”]

for magician in magicians_names:
print(f “{magician.title()}, you did an excellent trick today!”)
print(f “Keep the good work going every day, (magician.title()}. \n”)

If you observe clearly, each print() method is properly indented; therefore, each line will be
executed once for the element in the list. However, (\n) in the second print line is a newline, which
requests for a blank line to be inserted after the last statement before going through the loop. With
this newline, the message becomes neatly grouped for the magician list. Let us see how the output
of the program will be.

Greg, you did an excellent trick today!

Keep the good work going every day

Perpetual, you did an excellent trick today!

Keep the good work going every day

Amos, you did an excellent trick today!

Keep the good work going every day

You see how neatly the output is; this makes your program understandable. You can add as many
lines of codes you want in a “for loop.” Ensure to include some lines of codes in this program to
understand the concept behind looping in Python.

Performing Actions After a for Loop

What will happen when a “for loop” finishes execution? Normally, you may want to summarize an
output or continue with other work that your code must complete. Well, in our previous example,
the code is well indented; however, if the code is after the loop, then it will be executed once since
it wasn’t indented. Let us include an appreciation message to the magicians for their wonderful
work. This message will be a group message instead of the personalized messages we have written
before. To do that, we have to place our message after the for loop. Additionally, we won’t indent
this line of code. An example will clarify these properly.

magicians_names =[“Greg,” “Perpetual,” “Amos”]

for magician in magicians_names:
print(f “{magician.title()}, you did an excellent trick today!”)
print(f “Keep the good work going every day, (magician.title()}. \n”)
print(“We appreciate your wonderful work. It was a masterpiece performance!”)

The only inclusion of this line of codes is the last statement. If you look closely, the first two
print() methods were properly indented. However, the third one is different; hence, it will be
printed once. The output will be as follows.

Greg, you did an excellent trick today!

Keep the good work going every day

Perpetual, you did an excellent trick today!

Keep the good work going every day

Amos, you did an excellent trick today!

Keep the good work going every day

We appreciate your wonderful work. It was a masterpiece performance!

Dealing with Indentation Errors

The importance of indentation in Python is that it helps to determine the relationship(s) between a
line or group of lines from the rest of the program. Furthermore, it makes the program easier to
read for anyone. However, Python introduces whitespace to format your code neatly in order to
have a clear visual structure of your codes. As you continue writing Python programs, you will
observe the line of codes is indented at different levels. Through this, one can have a general
structure of the program. Well, while Python helps with indentation, it is important to watch out for
common errors. For instance, some beginners indent a line of codes that don’t require indentation
or may also forget to indent them. I will write some indentation errors and provide ways of dealing
with such a situation in the future. The following are common indentation errors that most
beginners commit when starting their Python programming course.

Forgetting to Indent
A for loop always require indentation; however, if you forget it, Python will remind you. save this
program with magic.py Let us look at the example below.

magicians_name =[“Greg,” “Perpetual,” “Amos”]

magician in magicians_name:
print(magician)

In this code, the third line should be indented but wasn’t. Once the Python interpreter encounters
such statement that should have an indented block but didn’t find any, it indicates an error with the
code as follows:

File “magic.py,” line 3

print(magician)
^
IndentationError: expected an indented block

To solve this error, you have to indent the line of code properly. As simple as this mistake may be,
it can keep you from getting an error each time you run a program.
Besides forgetting to indent, you may forget to indent statements in a loop. Your loop may run
successfully without any errors, but your output will be different from what you expected. When
this happens, it signifies you are doing several tasks inside your loop and didn’t indent some of the
lines of codes. For instance, you didn’t indent the second line in the magician code that says, “keep
the good work going every day, (magician.title()}. \n”)

magicians_names =[“Greg,” “Perpetual,” “Amos”]

for magician in magicians_names:
print(f “{magician.title()}, you did an excellent trick today!”)
print(f “Keep the good work going every day, (magician.title()}. \n”)

The line in bold and italicize should have been indented, but the interpreter finds at least a
statement indented after the “for magician in magicians_name” a statement. However, it doesn’t
indicate any error; when the first print() method takes action for each name contained in our
magician list, it prints the same message to the names. However, for the second print() method,
because it is not indented, it executes the loop once before halting the program. Among the three
magicians (Greg, Perpetual, and Amos), only Amos will receive the message, “Keep the good
work going every day.” The output of this program will be as follow:

Greg, you did an excellent trick today!

Perpetual, you did an excellent trick today!
Amos, you did an excellent trick today!
Keep the good work going every day

This error is also known as a logical error because the syntax is an acceptable Python code.
However, it doesn’t produce the result we expected because of the logic error in the code.
Therefore, if your goal is to repeat a certain code once for every item in a list, then you can do that
with indentation.

Exercise to Try
Fruits – Consider at least four of your much-loved fruits. Store these preferred fruit
names in the list of your choice and use a “for loop” to generate each fruit’s name.
Then modify the “for loop” to produce a statement using the fruit name rather than
printing the name of your favorite fruit only. Additionally, for every fruit in the list,
you should generate an output that says, I like apple fruit.
Animals – Think of four animals with common features in life. Store their names in a
list of your choice. Furthermore, implement a conditional test using “for loop” to
display every animal you on your list.
Modify your line of code to produce a sentence about each animal. For
instance, you can say, A lion is the bravest animal I have ever known
Add another line to your program, indicating the unique features of these
animals. For instance, you can print a general statement like; these
animals are dangerous to human beings.

Note: These programs are very simple to write if you have followed our previous examples above.
Study them properly and write your own code. Practice more, and you will be perfect when it
comes to writing Python programs.

Numerical Lists
So far, we have been dealing with string as it relates to the list. However, in this section, you will
learn how to perform certain operations on numerical values. In Python, there are many reasons
that may warrant us to store a number. For storing numbers, lists are very important, and Python
provides various tools to perform such action effectively. If you can understand these tools
effectively, you can work perfectly well even if the list contains thousands of items in it. let us look
at certain operations you can perform on a number as it relates to the list.

range() Function
This function is a unique function that allows a programmer to easily generate a sequence of
numbers. In the example below, we can print a range of numbers from 6 to 15.

for scores in range(6, 15):

print(scores)

In as much as the code seems like printing the numbers from 6 to 15, however, it doesn’t print the
number 15. Our output will be as follow:

6
7
8
9
1
0
11
1
2
1
3
1
4

In our example below, the range() function prints only the numbers from 6 to 15. Well, this is the
product of the off-by-one behavior, which exists in most programming languages. The function
makes the interpreted to start the counting process at the initial number but stops at the second
number before reaching the number indicated. However, if you wanted to print out the number 15,
that means you have to extend the stopping point by one. In this case, it is 16. Therefore, your code
will be as follows:

for scores in range(6, 16):

print(scores)

Moreover, your output will be:

6
7
8
9
1
0
11
1
2
1
3
1
4
1
5

If your output doesn’t match what you wanted when using the range() function, then you have to
adjust the ending value by 1.
Making a List Using range() Function
You can exchange a number list by using the list() function. Nevertheless, you need to wrap the
list() within the range() function. With this, your final outcome will be similar to a number list. We
will use our previous example of a number range to illustrate this example. You will see the
difference between the previous program code and this new one.

num = list(range(1, 16))

print(num)

Our output will be as follows:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

It is also possible to skip some numbers in the list by using range() function. If we add a third
argument to the range(), the interpreter uses that value to perform a step size. For instance, we want
to print even numbers from 1 to 16. What the program does is, to begin with, the value 2 and
increases that value by 2. In order words, it starts at 2 and repeatedly adds 2 to the initial number
and continue until it reaches the last number.

Even_num = list(range(2, 16, 2))

print(even_num)

The output will be as follows:

2, 4, 6, 8, 10, 12, 14

Let us try another example.

odd_num = list(range(1, 16, 2))

print(even_num)

The output will be as follows:

1, 3, 5, 7, 9, 11, 13, 15
 number_squares=[]
for numb in range(1, 15)
numbers = numb**2
number_squares.append(numbers)
print(number_squares)

Besides getting even and odd numbers, you can generate any set of numbers or operations you can
envision. Programming is about thinking outside the box. For instance, you can find the square of
any number of your choice. In this example below, we will make a list comprising of the first 15
square numbers. When you want to represent exponents in Python, we use double asterisks (**).
This is the program to illustrate the first 15 square numbers.
Initially, the program will look confusing; however, I will explain it line by line. We began by
creating an empty list and called it “number_squares.” In line two, we created a loop and request
each “numb,” ranging from 1 to 15, by using the range() function. Then, in line three, we raised the
current “numb” to its second power before assigning it to the variable “numbers”; in line four,
every new “numb” of numbers is joined to our list number_squares. Lastly, the list of
number_squares is printed when the loop is finished. Then, the outcome of the program will be:

1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225

We can rewrite this code concisely by omitting the variable “numbers” while appending each new
“numb” directly to our list. Let us see how that is possible.

number_squares=[]
for numb in range(1, 15)
number_squares.append(numb**2)
print(number_squares)

As you can see, the two different approaches create a complex list. Remember, we omitted the
temporary variable “numbers” in the last approach. With this method, you make your program
easier to read. However, the goal is to focus on the one you understand and not to rush things.
Review the two approaches and look for the one that is more efficient.
Performing Statistics on Number List
Python has certain functions that allow you to perform statistics operation on a number list. For
instance, you can execute operations such as finding the sum, minimum, and maximum numbers in
a particular list.

>>>numbers= [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>>min(numbers)
11
>>>max(numbers)
20
>>>sum(numbers)
155

This example is just to show you how possible you can manipulate numbers in a list. You can do
the same even if the list contains a million numbers.

List Comprehensions
Previously, I explained how you could create a list of squares using four lines of code. However,
there is a simpler approach, which allows you to use a single line. A list comprehension comprises
of a “for loop” with the creation of new elements in the list, and repeatedly append each new
element. Although it is advisable for beginners to use the list comprehension, however, I included
them for you to be aware of them. let us use an example to show you how you can rewrite this
program on a line to create a square of the first 15 numbers.

number_squares = [numbers**2 for numb in range(1, 15)]

print(number_squares)

We started by creating a descriptive name (number_squares) for our list. We then open a set of
square brackets, which allows us to define the expression “[numbers**2 for numb in range(1, 15)]”
for the numbers we want to keep track of in our new list. Furthermore, a loop is created to repeat
the expression pending when the condition is completed. The loop goes through the
range()function, with values from 1 to 15. If you observe carefully, we didn’t include a colon at the
end of the loop. When we run the program after saving it, our output will be as what we got in our
previous example.

1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225

Because the list comprehension isn’t advisable for beginners, it doesn’t mean you can’t give it a
try. It takes consistent practice to understand the list comprehension before it will be worthwhile to
create lists comfortably.

Exercise to Try
Counting to forty – Write a program using a “for loop” to create and output numbers
ranging from 10 to 60 with 60 inclusive.
One hundred – Create a list of numbers ranging from 1 to 100. Furthermore, use the
conditional test “for loop” to display the numbers on the screen.
Summing one hundred numbers – After creating your 100 numbers, save using
another name, and perform the following tasks on it. Find the minimum, maximum,
and sum of the 100 numbers with 100 excluded.
Four – Compile a list of multiples of 4 from 4 to 40. Ensure to use a for loop for this
program and print the output
Cube – Calculate the cube of the first 10 numbers. A cube is the third power of a
number. Use a “for loop” to generate the number and print the value of the cube.
Working with List Part
In the course of learning this tutorial, you have understood how to easily access single elements in
a list, perform manipulations on numbers, and strings. However, I want to go a step ahead into
ways how you can work with specific elements in a list. In Python, we call them a slice. Consider a
full loaf of bread, which is in slices. Depending on the same, you may not finish a full loaf;
therefore, when you take four slices and wrap up the other, you have taken a specific number of
slice instead of all the slices in the full loaf.

Slicing a List in Python

If you want to perform a slice in Python, you have to stipulate the first and last index of the
elements in the list. Similar to the range() function we use previously, Python halts at one item
before the second index you stipulate. To display the first five elements, you have to request
indices from 0 to 5. In this situation, this would return the following elements 0, 1, 2, 3, 4, and 5.
The following are team members in Manchester United Football club

united_players =[ “Rashford,” “Young,” “Pogba,” “James,” “De Gea”]

print(united_players [1:4]

The second line prints a slice of the element in the list, which comprises of the following players.

“Young,” “Pogba,” “James,” “De Gea”

If you mistakenly forget the first index when slicing a list, Python spontaneously begins your slice
at the start of your list. For instance,

united_players =[ “Rashford,” “Young,” “Pogba,” “James,” “De Gea”]

print(united_players [:4]

Since there is no starting index, the output will be:

“Young,” “Pogba,” “James,” “De Gea”

The same thing applies if you omit the last index of the list. For instance, you want to start your
index at 2 while omitting the second index.

united_players =[ “Rashford,” “Young,” “Pogba,” “James,” “De Gea”]

print(united_players [2:]

Python will return the following value:

“Pogba,” “James,” “De Gea”

With this, you can print out all elements in a list irrespective of the length and its position. You can
use a negative index, but it recalls a number from list end. For instance, our goal to display the last
four United players in our list
 united_players =[ “Rashford,” “Young,” “Pogba,” “James,” “De Gea”]
print(united_players [-4:]

This will print the last four players

“Young,” “Pogba,” “James,” “De Gea”

Using Loop in a Slice

Python allows the use of for loop in a slice to go through a subset of elements in the list. We can
create a loop to pass through the first four players on our list and display their names. Let us see
how that works.

united_players =[ “Rashford,” “Young,” “Pogba,” “James,” “De Gea”]

print (“My favorite Manchester United Players are:”)

for players in united_players [ :4]:
print(players.title())

Rather than the interpreter looping through the full list of players in line 3, it loops only through
the first four players in the team. Then our output will be:

My favorite Manchester United Players are:

Rashford
Young
Pogba
James

Slice comes handy in various situations, such as when you want to add the final score of a player in
a game when working with data or building a website application.

Tuples
If you want to store items, which can change during the course of the program, then the list works
perfectly for this situation. Modifying data or a list is very important when working with various
applications or creating web applications. Notwithstanding, at times, you may want a list of items
whose value doesn’t change throughout the program. In such a situation, you can use a tuple to
replace using a list. In Python, we call values, which cannot change throughout the life of the
program as immutable. Therefore, an immutable list can also be known as a tuple.

What is a Tuple?
A tuple is similar to the list I explained earlier. However, we use parentheses for tuple as an
alternative to square brackets used in a list. You can access each element after defining a tuple by
using each index. It is similar to what you would do if you want to access a list.
For instance, let us take the length and width of a room to be 200 by 100, which will always remain
the same size unless the building is destroyed. Therefore, putting the length and width into a tuple,
we have ensured that its size won’t change.

size = (200, 100)

print(size[0])
print(size[1])

What we have done in the first line is to define the tuple size by using parentheses rather than
square brackets. Then in the second and third lines, we print the elements individually. Then save
and run the program, your output will be:

20
0
10
0

Let me modify the program to show you when Python recognizes an error when you try to alter the
tuple value.

size = (200, 100)

size[0] = 220

In the second line, I try to change the value from 200 to 220. However, Python will return an error.
We try to change a tuple, which isn’t possible with such an object.

Using loop in a Tuple

Similar to what we did in a list using the “for loop,” tuple allows us to loop through the elements in
it. For instance,

sizes =(200, 100)

for size in sizes:
print(size)

The output will be:

20
0
10
0
Writing Through a Tuple
As already stated, you cannot modify or alter a tuple; however, you can allocate new values to the
variable representing the tuple. Assuming something happens and you decide to change the size of
the room, you can redefine the entire tuple.

sizes =(200, 100)

print(“This is our original room size:”
for size in sizes:
print(size)

sizes = (300, 150)

print(“Our new room size:”)
for size in sizes
print(size)

The output will be as follows:

This is our original room size:

200
100

Our new room size:

300
150

Summary
So far, in this chapter, you have learned everything you need to know as it concerns lists and tuple.
I am convinced that you can efficiently work with elements in a list. We also went through how to
use a “for loop” in a list, the structure of indenting a Python program, and popular indentation
errors to avoid. You learned how to make numerical lists and perform certain operations such as
finding the maximum, minimum, and sum in a list. Additionally, we learned more about slicing a
list and getting only the details you want in a list.
Finally, you learned about tuples. You also know what makes it different from a list. The values of
a tuple cannot change, whereas that of a list can be changed in the course of the program. In the
next chapter, you will learn about using various conditional statements in Python. Endeavor to
practice the exercise provided in this chapter, as it will enhance your programming skills in Python.
If peradventure you encounter an error, take your time to go through the line indicated.
Congratulations on your promotion to the next chapter of this course.
 Chapter 3: Dictionary

Dictionary offers programmers a whole lot of options, especially in storing

limitless volume of information. In this chapter, you will understand what
dictionaries are, how you can use them in a loop, build lists inside them,
and create a dictionary insider another dictionary. If you can understand the
concept of dictionaries in Python, it will equip you in various ways and give
you the opportunity to model different live situation situations. You can
create a simple dictionary, which represents an individual. With this, you
can store various information, including the person’s name, location, age,
phone details, security number, anything you can think of as it concerns the
person. You can do so much a dictionary in Python, such as storing people’s
names with their best food, words with their meaning, countries and their
presidents, etc.
Let us look at a game with teams having different scores and colors. This
code stores information as it relates to a particular team.
team1 ={‘color’: ‘red’, ‘scores’ : 3}

print(team1 [‘color’])
print(team1 [‘scores’])

The dictionary team1 stores the color and scores whereas the last two lines
access the dictionary before displaying the information as seen below
red
3
New programming concepts require consistent practicing to perfect it. Since
you are learning a new language, it is important to painstakingly understand
this concept. If you understand it, you can apply it in all real-world
situations.

What is a Dictionary?
From the program above, you can have an idea of what dictionaries are. A
dictionary is a group of key-value pairs. Every single key in the dictionary
has its corresponding value; the key enables you to have access to the value,
and it can be a list, string, number, or dictionary. Dictionaries are usually
enclosed in braces with the keys and values placed inside the braces. For
instance:
team1 ={‘color’: ‘red’, ‘scores’ : 3}

A key to value pair always have values corresponding to each other. Once
you provide the key in a dictionary, Python returns the value corresponding
with such key. Each key is linked to a value by a colon, whereas individual
key-value pairs are disconnected by a comma.
team1 ={‘color’: ‘red’, ‘scores’ : 3}

The program above has only one pair, with each matching its value,
respectively. The color matches red, whereas scores match the value 0.

How to Access Values

If you want to access the value of a key, you have to include the dictionary
name before placing the key in square brackets.
team1 ={‘color’: ‘red’, ‘scores’ : 3}
print(team1[‘color’])

The output for this code will return the corresponding key value from the
dictionary “team1,” which in this situation is red.
Python allows us to have an unlimited number of key-value pairs. We can
add more codes to illustrate this. Additionally, we can decide the particular
key-pair to print or display on the screen. In this code, it will display
‘London’
team1 ={‘color’: ‘red’, ‘scores’ : 3, ‘S/N’ : 1, ‘place’ : ‘London’}
print(team1[‘place’])

London

Adding Key-Value Pairs

Since dictionaries are structurally dynamic, we can add new pairs to them
whenever we want. For instance, we can add additional information to our
original program to include positions, which will display the position the
score is taken. Let the home team be on the left position while the away
team be on the right.
team1 ={‘color’: ‘red’, ‘scores’ : 3}
print(team1)

team1[‘home_team’] = left
team1[‘away_team’] = right
print(team1)

We began by defining a dictionary “team1” and included its key and values,
respectively, before printing the dictionary. In the second phase of the code,
we assign the home team to be on the left position while the away team is
on the right. If we print the program, our output will be:
{‘color’: ‘red,’ ‘scores’ : 3}
{‘color’: ‘red’, ‘scores’ : 3, ‘home_team’: left, ‘away_team’ : right}
In our final program, we have four key-value pairs, where we added two
positions, whereas the original two specifies only color and score.
At times, most programmers find it convenient, to begin with, empty
dictionary unlike what we did by adding elements first. To fill an empty
dictionary, you have to define the dictionary without adding any key-value
pairs. The dictionary will be empty with a set of braces. For instance, if we
are to define the color and scores dictionary, that will be as follows:
team1 = {}
team1[‘color’] = ‘red’
team1[‘score’] = 3

print(team1)
What we did here is to define an empty team1 dictionary before adding
color and score values, respectively. We will get the same results as what
we got in our previous examples.
{‘color’: ‘red,’ ‘scores’ : 3}
How to Modify Values
Besides adding and creating an empty dictionary list, you can also modify a
value in your dictionary. To do this, you have to specify the dictionary name
before adding the new value. Let us change the color from red to blue.
team1 ={‘color’: ‘red’}
print(f “The color of the team is {team1[‘color’]}.”)

team1 = [‘color’] = ‘blue’

print(f “The team’s new color is {team1[‘color’]}.”)

What we did is to first define the team1 dictionary, which contains only the
team’s color. We then print the team’s color before changing the value of
the corresponding key from red to blue. The output shows that we have
changed the team color from red to blue.
The color of the team is red.
The team’s new color is blue.

To make the program more interesting, I will track the position of the team
based on their speed in the opponent’s direction. With the ball speed, we
can determine if the team is on the left or right.
team1 = {‘home_team’ : ‘left’, ‘away_team’: ‘right’, ‘ball’: ‘ neutral’
print(f “Original direction: {team1(‘home_team’)}”)
#The team is on the left position
#Current speed of the team
if team1[‘ball’] == ‘slow’:
home_incre = 1
elif team1[‘ball’] == ‘medium’:
home_incre = 2
else:
#in opposition half
home_incre = 3

team1[‘home_team’] = team[‘home_team’] + home_incre

print(f “Position of team: {team1[‘home_team’]}”)

If you observe, I intentionally avoided the color and its point value in order
to make the program simple. We began by defining a team with the left and
right position, a ball speed set medium.
In the line “if team1[‘ball’] == ‘home’:” we use an if-elif-else conditional
statement to test the position of the ball. If the ball is slow, then it is on the
home team, if it is medium, then it is positioned in the middle. Run the
program and notice what the output will be. Towards the end of this chapter,
I will unveil the outcome of this program.

How to Remove key-value Pairs

So far, you have learned how to add, modify, and create an empty
dictionary list. what if you decide to remove a piece of information in your
dictionary? You can take advantage of the “del” statement to remove your
information. Let us use our original program to illustrate how you can
easily remove a key-value pair in Python.
team1 = {‘color’: ‘red’, ‘scores’ : 3}
print(team1)

del team1[‘color’]
print(team1)

The only difference to our original program is the last two lines we added.
We use the del statement to delete the “color” key from our team1
dictionary. This will eventually remove the corresponding value of the key.
Our initial output will display the keys and its corresponding value, but
after the “del” statement, it will print only the scores. Let’s see how that
will be:
{‘color’: ‘red,’ ‘scores’ : 3}
{‘scores’ : 3}

Dictionary with Similar Objects

Throughout this chapter, we have only stored different information as it
relates to a single object, which in this case, is our team1. However, you are
not limited to a particular team as you can store information on different
objects. For instance, we want to conduct an election for a community. We
can use a dictionary to store the list of candidates, along with their parties.
election_list = {
‘John Campbell’ : ‘Freedom Party,’
‘Eric Longman’: ‘Sovereign Nation Party,’
‘Amanda Drill’: ‘ Women Liberation
Movement,’
‘Condolence Rice’: ‘Democratic Party,’
‘Donald Trump’: ‘Republican Party,’
}

If you observe, there is a difference from our previous list as we broke this
list into several lines, unlike the team1 dictionary, where everything is
written on a single line. Each candidate corresponds to his or her party;
additionally, there is always an opening and closing brace. Don’t forget to
add a comma to signify the end of a pair. With this, you can add another
key-value pair. Let us pick a candidate of our choice
list = election_list[‘Donald Trump’].title()
print(“Our Vote will be for {list}.”)
In this portion, we see that the user picked Donald Trump as their favorite
candidate.
Our Vote will be for Donald Trump.

Exercise to Try
Create a new dictionary to keep information about people you
know about living in your country. Then store the last name, first
name, city, and age of each individual. Ensure you use a unique
key for this information and print each information in the
dictionary.
Store the favorite food of 8 people in a dictionary, you know.
Print their names and corresponding food.

Looping Through Dictionaries

A dictionary can have a single key-value pair and even up to millions of
pairs due to its capability of accommodating large amounts of data. With
this, you can loop through a dictionary. Since we have different ways of
storing information when using dictionaries, it makes it possible to loop
through the dictionary in various ways. In this section, we will explore
ways of looping through dictionaries.
However, before we begin to explore the various ways of approaching
looping through dictionaries, let us look at a dictionary that saves the
information of users visiting a website. The dictionary stores the last name,
first name, and username of the person.
user = {
‘last_name’:
‘Trump,’
‘first_name’:
‘Donald,’
‘username’:
‘dotrum,’
}

If you remembered what you have learned, you could easily access every
information in our user dictionary. However, what will you do if you want
to see all the information stored in our dictionary? Well, to do that, you
have to use a “for loop” to go through the dictionary. Let see how you can
put that into action.
user = {
‘last_name’:
‘Trump,’
‘first_name’:
‘Donald,’
‘username’:
‘dotrum,’
}
for k, v in user.item():
print(f “\nK: {k}”)
print(f “V: {v}”)

As you can see, for you to loop through a dictionary, you have to create
names for our two variables, which will hold last and first names in our
key-value pair. You can use any variable name of your choice. In this case,
we use k and v to represent key and value, respectively. Our output will be:
K: last_name
V: Trump
K:
first_name
V: Donald

K: username
V: dotrum
Looping through a dictionary works perfectly for a program like the list of
candidates in an election we wrote previously. Remember, it stores the
name and party of candidates approved to participate in the election. If we
were to loop through the list, we will get the names of every candidate and
generate their respective parties. Since the keys represent the person’s
name, whereas the value is the party, we can use variable names such as
name and party in our loop rather than using key and value. This will make
it easier for you to fully understand.

election_list = {
‘John Campbell’ : ‘Freedom Party’,
‘Eric Longman’: ‘Sovereign Nation Party’,
‘Amanda Drill’: ‘ Women Liberation
Movement’,
‘Condolence Rice’: ‘Democratic Party’,
‘Donald Trump’: ‘Republican Party’,
}
for name, party in election_list.item():
print(f “{name.title()}’s party is the
{party.title()}.”)
The program loops through every key-value pair in our election_list. As it
goes through, every pair of the key is assigned to the name variable while
the value is assigned the party variable. With only the last two lines, we can
generate a full list of all candidates in the election.
John Campbell’s party is the Freedom Party.
Eric Longman’s party is the Sovereign Nation Party.
Amanda Drill’s party is the Women Liberation Movement.
Condolence Rice’s party is the Democratic Party.
Donald Trump’s party is the Republican Party.

With this, you can display from a single name to millions of names in a list
to the screen.
Looping Through Keys Only
We can use the keys() method to display only the key values while omitting
the values contained in the dictionary. Let us use our election_list to
demonstrate this feat.
election_list = {
‘John Campbell’ : ‘Freedom Party,’
‘Eric Longman’: ‘Sovereign Nation Party,’
‘Amanda Drill’: ‘ Women Liberation
Movement,’
‘Condolence Rice’: ‘Democratic Party,’
‘Donald Trump’: ‘Republican Party,’
}
for name in election_list.keys():
print(name.title())

The line after the closing brace is the beginning of the “for loop,” which
tells the interpreter to pull only the keys from our election_list. Remember,
we assign names as the key. The output will be as follows:
John Campbell
Eric Longman
Amanda Drill
Condolence Rice
Donald Trump

Looping Through Values Only

In the same manner that we can easily loop through the keys in a given
dictionary, we can also loop through the value and display the value list. We
can use the values() method to achieve this feat. Remember, in the previous
example, we use the keys() method.
election_list = {
‘John Campbell’ : ‘Freedom Party,’
‘Eric Longman’: ‘Sovereign Nation Party,’
‘Amanda Drill’: ‘ Women Liberation Movement,’
‘Condolence Rice’: ‘Democratic Party,’
‘Donald Trump’: ‘Republican Party,’
}
print(“This is the list of Political Party for the election:”)
for party in election_list.values():
print(party.title())

The “for” statement pulls all the value in our dictionary list and assigns it to
the party. The print statement then prints all the values in the election_list.
This is the list of Political Party for the election:
Freedom Party
Sovereign Nation Party
Women Liberation Movement
Democratic Party
Republican Party
This approach prints all the value available in the dictionary without
verifying any repetition. Although this may work perfectly in a small list,
however, when you have to pull a large name or item, there may be room
for repetition. To avoid such repetition, there is a way out. We can use a set,
which is a group where every item is unique.
election_list = {
‘John Campbell’ : ‘Freedom Party,’
‘Eric Longman’: ‘Sovereign Nation Party,’
‘Amanda Drill’: ‘ Women Liberation Movement,’
‘Condolence Rice’: ‘Democratic Party,’
‘Donald Trump’: ‘Republican Party,’
‘Nicolas Fred’: ‘ Sovereign Nation Party,’
}
print(“The following Political Parties have been mentioned already:”)
for party in set(election_list.values()):
print(party.title())

We added another name and party to the list – Nicolas Fred. Assuming we
are printing only the value list and don’t want a repetition of the party. Once
you use the set() around the list, you don’t want duplicate; python identifies
this as a unique item in the list. In the end, there won’t be any repeated
detail.
The following Political Parties have been mentioned already.
Freedom Party
Sovereign Nation Party
Women Liberation Movement
Democratic Party
Republican Party

Nesting Dictionary
There are situations that may warrant you to store several dictionaries on a
particular list. This is referred to like nesting in Python because you can
include a dictionary in another dictionary. Nesting is very powerful if you
understand them properly, and we will use an example to explain it better.
The team1 dictionary list comprises of a single team but doesn’t have the
space to store additional information concerning a second team. How can
you control a group of teams? You can do this by making a list, which has
each team in a dictionary. Consider the program below:
team1 = {‘color’: ‘red’, ‘scores’ : 3}
team2 = {‘color’: ‘black’, ‘scores’ : 5}
team3 = {‘color’: ‘blue’, ‘scores’ : 0}
team4 = {‘color’: ‘brown’, ‘scores’ : 9}

teams = [team1, team2, team3]

for team in teams:

print(team)

First, we create four dictionaries with each representing a different team. In

the fourth line, we stored each of the dictionaries in a particular list called
teams. Then, we loop through our list before printing each team.
{‘color’: ‘red,’ ‘scores’ : 3}
{‘color’: ‘black,’ ‘scores’ : 5}
{‘color’: ‘blue’, ‘scores’ : 0}
{‘color’: ‘brown,’ ‘scores’ : 9}
This example looks simple and very straightforward. Let us look at a
realistic one that will involve over four teams with code, which
automatically creates each team. In the example below, we use range() to
generate 40 teams.
#Create an empty list to store the teams.
teams =[]
#create 40 teams.
for team_num in range(40):
new_team = {‘color’: ‘red’, ‘scores’: 3, ‘position’:
‘middle’}
teams.append(new_team)

#display the first 6 teams.

for team in teams[:6]:
print[team]
print[“…”]
#display the number of teams we have in our dictionary
print(f “Total teams available in our list: {len(teams)}”)

In this example, we began by creating an empty list comprising of all teams

to be created in our dictionary. We use the range() method to determine the
number of times the loop will repeat. Whenever the loop goes through the
range() method, it creates a new team and appends the new team to our list
“teams.” In the line “for team in teams [:6]:”, we use a slice to print our first
six teams. Finally, the last statement prints the length of the teams, which in
this case is 40 teams.
{‘color’: ‘red,’ ‘scores’: 3, ‘position’: ‘middle’}
{‘color’: ‘red,’ ‘scores’: 3, ‘position’: ‘middle’}
{‘color’: ‘red,’ ‘scores’: 3, ‘position’: ‘middle’}
{‘color’: ‘red,’ ‘scores’: 3, ‘position’: ‘middle’}
{‘color’: ‘red,’ ‘scores’: 3, ‘position’: ‘middle’}
{‘color’: ‘red,’ ‘scores’: 3, ‘position’: ‘middle’}
…

Total teams available in our list:40

If you observe, the teams all have the same features – color, scores, and
positions. However, it doesn’t mean that Python sees them as one item
rather a separate object. With this, we can modify any team of our choice
without affecting the other.
How possible is it to work with a collection of teams like we have?
Assuming a particular team decides to change their color and scores, how
can you do this? If you decide to change the color of a team, you can use
the “for loop” conditional test with an if statement. For instance, let us
change the first four teams' colors to black, scores to 5, and position to
center.
#Create an empty list to store the teams.
teams =[]

#create 40 teams.
for team_num in range(40):
new_team = {‘color’: ‘red’, ‘scores’: 3, ‘position’:
‘middle’}
teams.append(new_team)

for team in teams[:4]:

if team[‘color’] == ‘red’”
team[‘color’] = ‘black’
team [‘scores’] = 5
team [‘middle] = ‘center’

#display the first 6 teams.

for team in teams[:6]:
print[team]
print[“…”]
#display the number of teams we have in our dictionary
print(f “Total teams available in our list: {len(teams)}”)

When you run the program, your output should be:

{‘color’: ‘black,’ ‘scores’: 5, ‘position’: ‘center}
{‘color’: ‘black,’ ‘scores’: 5, ‘position’: ‘center’}
{‘color’: ‘black,’ ‘scores’: 5, ‘position’: ‘center’}
{‘color’: ‘black,’ ‘scores’: 5, ‘position’: ‘center’}
{‘color’: ‘red,’ ‘scores’: 3, ‘position’: ‘center’}
{‘color’: ‘red,’ ‘scores’: 3, ‘position’: ‘center’}
…

Total teams available in our list:40

How to Use a List Inside a Dictionary

In our previous examples, our dictionary is inside a list; however, we can
also use a list inside our dictionary depending on what you want. For
instance, you may decide to react to a particular way to describe when
ordering a meal. If you use a list, all you need is to store the meals. In the
program below, we only stored two-piece of information for each meal
meal = {
‘food’ : ‘ beans,’
‘drink’: [‘Fanta,’ ‘Water’],
}
#summary of the order
print(f “You ordered {meal [‘food’]} with the following drink:”]

for drink in meal[‘drink’]:

print(“\t” + drink)

We begin by creating a dictionary “meal” to hold information about the

food you ordered. Remember, every list has a key-value pair, respectively.
In this case, the key for food is beans, whereas that of the drink includes
Fanta and Water. Then we summarize our order before creating the meal. In
order to access our drink list, we use the “for loop” to print the drink list.
Let us see how the output for this program will be:
You ordered beans with the following drinks:
Fanta
Water

Easily done in such a way that you can understand each line. Besides this,
you can also nest your list in a dictionary when you want a key to have
more than one value. Let us look at our previous election_list program,
where candidates can choose two political parties. Assuming we have to
store their responses in a list, a particular person can belong to more than
one political party.
election_list = {
‘John Campbell’ : [‘Freedom Party’],
‘Eric Longman’: [‘Sovereign Nation Party’],
‘Amanda Drill’: [‘Freedom Party,’ ‘ Women Liberation
Movement’],
‘Condolence Rice’: [‘Democratic Party,’ ‘ Sovereign Nation
Party’],
‘Donald Trump’: [‘Republican Party,’ ‘Democratic Party’],
‘Nicolas Fred’: [‘Sovereign Nation Party’],
}
for name, party in election_list.items():
print(f “\n{name.title()}’s party are: ”)
for party in parties:
print (f “\t{party.title()}”)

In the first bolded line, we create a list. If you observe, some names have
one political party, while others have two. We then loop through the
dictionary to run through the political party of each candidate.
John Campbell’s party are:
Freedom Party

Eric Longman’s party are:

Sovereign Nation Party

Amanda Drill’s party are:

Freedom Party
Women Liberation
Movement

Condolence Rice’s party are:

Democratic Party
Sovereign Nation Party

Donald Trump’s party are:

Republican Party
Democratic Party

Nicolas Fred’s party are:

Sovereign Nation Party

Exercise to Try
Write a program that creates three dictionaries, which represent
three different meals with each person choosing at least a meal
of their choice. Use “for loop” to scan through the list and prints
the choice of each individual.
Make a dictionary list comprising of your favorite pets. The
dictionary must contain the type of pet, owner’s name, best food,
and unique sound. Next, loop through your pest list and display
two of this information in the list.
 Create a list of your favorite cities in the world. Create a key-
value dictionary system that includes the name of the city,
population, currency, and contact details of the mayor.
Furthermore, print each city with at least three of the information
you want people to know.

Summary
In this section, you have learned what dictionaries are, how to work with
them and store information in it. Undoubtedly, you can write a program that
can access and modify each item in a dictionary. Additionally, you can loop
through the information contained in your dictionary. You can also loop
through a dictionary key, value, and key-value pairs. Furthermore, you can
nest multiple dictionaries in a list, nest dictionary in a dictionary, and nest
list in your dictionary.
 Chapter 4: Conditional or Decision Statements

Introduction
In programming, we normally set certain conditions and decide which
particular action to perform depending on the conditions. To do this, Python
uses the “if statement” to check the program current state before responding
suitably to that state. However, in this chapter, you will be exposed to
various ways to write conditional statements. Furthermore, you will learn
basic “if statements,” create complex if statements and write loops to
handle items in a list. There is so much more loaded in this chapter for you
to learn. Without further ado, let us begin with a simple example.
The program below shows how you can use “if statement” to respond to a
particular situation correctly. For instance, we have a list of colors and want
to generate an output of different colors. Furthermore, the first letter should
be in the title case of the lower case.

colors =[“green,” “blue,” “red,” “yellow”]

for color in colors:
print(color.title())

The output will be as follows:

Green
Blue
Red
Yello
w

Consider another example where we want to print a list of cars. We have to

print them in the title case since it is a proper name. Additionally, the value
“kia” must be in uppercase.

cars = [“toyota,” “kia,” “audi,” “infinity”]

for car1 in cars:
if car1 == “kia”:
print(car1.upper())
else:
print(car1.title())

The loop first verifies if whether the current value of the car is “kia.” If that
is true, it then prints the value in uppercase. However, if it is not kia, it
prints it in title case. The output will look like this:

Toyota
KIA
Audi
Infinit
y

The example above combines different concepts, which at the end of this
chapter, you will learn. However, let us begin with the various conditional
tests.

Conditional Tests in Python

The center of any if statement lies an expression, which must be evaluated
to be either true or false. This is what is normally known as a conditional
test because Python uses both values to determine if a particular code
should be executed. If the particular statement is true, Python executes the
code that follows it. However, if it is false, it ignores the code after it.

Checking Equality
At times, we may test for the equality of a particular condition. In this
situation, we test if the value of the variable is equal to the other variable
we decide. For instance:

>>>color = “green”
>>> color == “green”
True

In this example, we first assign the variable color with the value “green by
using the single equal sign. This is not something new, as we have been
using it throughout this book. However, the second line checks if the value
of color is green, which has a double equal sign. It will return true if the
value on the left side and that on the right side are both true. If it doesn’t
match, then the result will be false. When the value of the color is anything
besides green, then this condition equates to false. The example below will
clarify that.

>>>color = “green”
>>> color == “blue”
False

Note: When you test for equality, you should know that it is case sensitive.
For instance, two values that have different capitalizations won’t be
regarded as equal. For instance,

>>>color = “Green”
>>> color == “green”
False

If the case is important, then this is advantageous. However, if the case of

the variable isn’t important, and you want to check the values, then you can
convert the value of the variable to lowercase before checking for equality.

>>>color = “Green”
>>> color.lower() == “green”
True
This code will return True irrespective of how to format the value “Green”
is because the conditional tests aren’t case sensitive. Please note that the
lower() function we used in the program does not change the value
originally stored in color.
In the same way, we can check for equality; we can also check for
inequality in a program code. In checking for inequality, we verify if two
values are not equal and then return it as true. To check for inequality,
Python has its own unique symbol, which is a combination of the
exclamation sign with an equal sign (!=). Most programming language uses
these signs to represent inequality. The example below shows the use of if
statement to test for inequality

color = “green”

if color != “blue”
print(“The color doesn’t match”)

In the second line, the interpreter matches the value of color to that of
“blue.” If the values match, then Python return false; however, if it is true,
Python returns true before executing the statement following it “The color
doesn’t match”

The color doesn’t match

Numerical Comparison in Python

We can also test numerical values in Python, but it is very straightforward.
For instance, the code below determines if a person’s age is 25 years old:

>>>myage = 25
>>>myage == 25
True
Additionally, we can also test if two numbers are unequal. Consider the
code below.

number = 34

if number != 54:
print(“The number does not match. Please retry!”)

The first line declares number as a variable and stores the number “34” in it.
The conditional statement begins in line two and passes through the line
because the number 34 is not equal to 54. Since the code is indented, the
code is then executed to produce

The number does not match. Please retry!

Besides this, you can perform various mathematical comparison inside your
conditional expressions including greater than, greater than or equal to , less
than, and less than or equal to.

>>> number = 22
>>> number <25
True
>>> number <= 25
True
>>> number > 25
False
>>> number >= 25
False

Every mathematical comparison you want can be included as part of an “if

statement” that allows you to detect the particular condition in question.
Creating Multiple Conditions
When writing code, there are situations that may warrant you to verify
multiple conditions simultaneously. For instance, you require conditions to
be false in order to take action. At times, you may want only one condition
to be satisfied. In this situation, you can use the keyword “or” and “and.”
Let first use the “and” keyword to check multiple conditions in Python
programming.

Using “AND”
If you want to verify that two expressions are both true at the same time, the
keyword “and” serves that purpose. The expression is evaluated to be true
when both conditions test to return true. However, if one of the condition
falls, then the expression returns false. For instance, you want to ascertain if
two students in a class have over 45 score marks.

>>> score_1 = 46
>>> score_2 = 30
>>> score_1 >=45 and score_2 >= 45
False
>>> score_2 = 47
>>> score_1 >= 45 and score_2 >= 45
True

The program looks complicated but lets me explain it step-by-step. In the

first two lines, we define two scores, score_1, and score_2. However, in line
3, we perform a check to ascertain if both scores are equal to or above 45.
The condition on the right-hand side is false, but that of the left-hand side is
true. Then in the line after the false statement, I changed the value of
score_2 from 30 to 47. In this instant, the value of score_2 is now greater
than 46; therefore, both conditions will evaluate to true.
In order to make the code more readable, we can use parentheses in each
test. However, it is not compulsory to do such but makes it simpler. Let us
use parentheses to demonstrate the difference between the previous code
and the one below.

(score_1 >= 45) and (score_2 >=45)

Using “OR”
The “OR” keyword allows you to check multiple conditions as the “AND”
keyword. However, the difference here is that the “OR” keyword is used
when you want to ascertain that one expression is true for multiple
conditions. In this situation, if one of the expression is false, the condition
returns true. It returns false when both conditions are false.
Let us consider our previous example using the “OR” keyword. For
instance, you want to ascertain if two students in a class have over 45 score
mark.

>>> score_1 = 46
>>> score_2 = 30
>>> score_1 >=45 or score_2 >= 45
True
>>> score_1 = 30
>>> score_1 >= 45 or score_2 >= 45
False

We began by declaring two variables score_1 and score_2 and assign values
to them. In the third line, we test the OR condition using the two variables.
The test in that line satisfies the condition because one of the expressions is
true. Then, it changed the value of the variable score to 30; however, it fails
both conditions and therefore evaluates false.
Besides using the “And” and “OR” conditional statements to check multiple
conditions, we can also test the availability of a value in a particular list.
For instance, you want to verify if a username requested is already in
existence from a list of usernames before the completion of online
registration on a website.
To do this, we can use the “in” keyword in such a situation. For instance, let
us use a list of animals in the zoo and check if it already on the list.

>>>animals = [“zebra”, “lion”, “crocodile”, “monkey”]

>>> “monkey” in animals
True
>>> “rat” in animals
False

In the second and fourth lines, we use the “in” keyword to test if the request
word in a double quote exists in our list of animals. The first test ascertains
that “monkey” exists in our list, whereas the second test returns false
because the rat is not in the animal's list. This method is significant because
we can generate lists of important values and check the existence of the
values in the list.
There are situations where you want to check if a value isn’t in a list. In
such a case, instead of using the “in” keyword to return false, we can use
the “not” keyword. For instance, let us consider a list of Manchester United
players before allowing them to be part of their next match. In order words,
we want to scan the real players and ensure that the club does not field an
illegible player.

united_player = [“Rashford,” “Young,” “Pogba,” “Mata,” “De Gea”]

player = “Messi”

if player not in united_player:

print(f “{player.title()}, you are not qualified to play for Manchester
United.”)

The line “if player, not in united_player:” reads quite clearly. Peradventure,
the value of the player isn’t in the list united_player, Python returns the
expression to be True and then executed the line indented under it. The
player “Messi” isn’t part of the list united_player; therefore, he will receive
a message about his qualification status. The output will be as follow:

Messi, you are not qualified to play for Manchester United.

Boolean Expressions in Python

If you have learned any programming language, you might have come
across the term “Boolean Expression” because they are very important. A
Boolean expression is another term to describe the conditional test. When
evaluated, the outcome can only be either True or False. However, they are
essential if your goal is to keep track of specific conditions like if a user can
change content or light is switched on or not. For instance,

change_content =
False
light_on = False
light_off = True

Boolean values provide the best means of tracking the particular condition
of a program.
Exercises to Try
Conditional Testing – Write various conditional expressions.
Furthermore, print a statement to describe each condition and
what the likely output of each test will be. for instance, your
code can be like this:

car = “Toyota”
print(“Is car == ‘Toyota’? My prediction is True.”(
print (car == “Toyota”)

print(“\nIs car == ‘KIA’? My prediction is False.”)

print(car== “KIA”)

Test the following condition to evaluate either True or false

using any things of your choice to form a list.
1. Test for both inequality and equality using strings and
numbers
2. Test for the condition using the “or” and “and”
keywords
3. Test if an item exists in the above list
4. Test if an item doesn’t exist in the list.

If Statements
Since you now know conditional tests, it will be easier for you to under if
statements. There are various types of if statements to use in Python,
depending on your choice. In this section, you will learn the different if
statements possible and the best situation to apply them, respectively.

Simple if Statements
In any programming language, the “if statement” is the simplest to come
across. It only requires a test or condition with a single action following it,
respectively. The syntax for this statement is as follows:

if condition:
perform action

The first line can contain any conditional statement with the second
following the action to take. Ensure to indent the second line for clarity
purposes. If the conditional statement is true, then the code under the
condition is executed. However, if it is false, the code is ignored.
For instance, we have set a standard that the minimum score for a person to
qualify for a football match is 20. We want to test if such a person is
qualified to participate.

person =21
if person >= 20
print(“You are qualified for the football match against Valencia.”)

In the first line, we define the person’s age to 21 in order to qualify. Then
the second line evaluates if the person is greater than or equal to 20. Python
then executes the statement below because it fulfills the condition that the
person is above 20.

You are qualified for the football match against Valencia.

Indentation is very significant when using the “if statement” like we did in
the “for loop” situations. All indented lines are executed once the condition
is satisfied after the if statement. However, if the statement returns false,
then the whole code under it is ignored, and the program halted.
We can also include more code inside the if statements to display what we
want. Let us add another line to display that the match is between Chelsea
and Valencia at the Standford Bridge.

person =21
 if person >= 20
print(“You are qualified for the football match against Valencia.”)
print(“The match is between Arsenal and Valencia.”)
Print(“The Venue is at the Emirate Stadium in England.”)

The conditional statement passes through the condition and prints the
indented actions once the condition is satisfied. The output will be as
follow:

You are qualified for the football match against Valencia.

The match is between Arsenal and Valencia.
The Venue is at the Emirate Stadium in England.

Assuming the age is less than 20, and then there won’t be any output for
this program. let us try another example before going into another
conditional statement.

name = “Abraham Lincoln”

if name = “Abraham Lincoln”
print(“Abraham Lincoln was a great United State President.”)
print(“He is an icon that many presidents try to emulate in the world.”)

The output will be:

Abraham Lincoln was a great United State President.

He is an icon that many presidents try to emulate in the world.

if-else Statements
At times, you may want to take certain actions if a particular condition isn’t
met. For example, you may decide what will happen if a person isn’t
qualified to play a match. Python provides the if-else statements to make
this possible. The syntax is as follows:
if conditional test
perform statement_1
else
perform statement_2

Let us use our football match qualification to illustrate how to use the if-
else statement.

person =18
if person >= 20:
print(“You are qualified for the football match against Valencia.”)
print(“The match is between Arsenal and Valencia.”)
Print(“The Venue is at the Emirate Stadium in England.”)
else:
print(“Unfortunately, you are not qualified to participate in the match.”)
print(“Sorry, you have to wait until you are qualified.”)

The conditional test (if person>=20) is first evaluated to ascertain that the
person is above 20 before it passes to the first indented line of code. If it is
true, then it prints the statements beneath the condition. However, in our
example, the conditional test will evaluate to false then passes control to the
else section. Finally, it prints the statement below it since it fulfills that part
of the condition.

Unfortunately, you are not qualified to participate in the match.

(“Sorry, you have to wait until you are qualified.

This program works because of the two possible scenarios to evaluate – a

person must be qualified to play or not play. In this situation, the if-else
statement works perfectly when you want Python to execute one action in
two possible situations.
Let us try another.

station_numbers = 10
if station_numbers >=12:
print(“We need additional 3 stations in this company.”)
else:
print(“We need additional 5 stations to meet the demands of our
audience.”)

The output will be:

We need an additional 5 stations to meet the demands of our audience.

The if-elif-else Chain

At times, you may want to test three different conditions based on certain
criteria. In such a situation, Python allows us to use the if-elif-else
conditional statement to execute such a task. We have many real-life
situations require more than two possibilities. For instance, think of a
cinema hall with different charge rates for different sets of people.
Children under 5 years are free
Children between 5 years and 17 years are $30
People older than 18 years is $50

As you can see, there are three possible situations because the following set
of people can attend the cinema to watch the movie of their choice. In this
situation, how can you ascertain a person’s rate? Well, the following code
will illustrate that point and print out specific price rates for each category
of people.

person_age = 13
if person_age < 5:
print(“Your ticket cost is $0.”)
elif person_age < 17:
print(“Your ticket cost is $30.”)
else:
print(“Your ticket cost is $50)

The first line declares a variable “person_age” with value 13. Then we
perform the first conditional statement to test if the person is below the age
of 5. If it fulfills the condition, it prints the appropriate message, and the
program halts. However, if it returns false, it passes to the elif line, which
tests if the person_age is less than 17. At this post, the person’s minimum
age must be 5 years and not above 17. If the person is above 17, then
Python skips the instruction and goes to the next condition.
In the example, we fix the person_age to 13. Therefore, the first test will
evaluate false and won’t execute the block of line. It then tests the elif
condition, which in this case is true, and will print the message. The output
will be:

Your ticket cost is $30.”)

Nevertheless, if the age is above 17, then it will pass through the first two
tests because it will evaluate to false. Then the next command will be the
else condition, which will print the statement below.
We can rewrite this program in such a way that we won’t have to include
the message “Your ticket cost is..”. all we need is to put the prince inside
the if-elif-else chain with a simple print() method to execute after the
evaluation of the chain. Look at the line of code below:

person_age = 13
if person_age < 5:
cost = 0
elif person_age < 17:
cost =30
else:
cost = 50
print(f “Your ticket cost is ${cost}.”)

In the third, fifth, and seventh lines, we defined the cost based on the
person’s age. The cost price is already set within the if-elif-else statement.
However, the last line uses the cost of each age to form the final cost of the
ticket.
This new code will produce the same result as the previous example.
However, the latter is more concise and straightforward. Instead of using
three different print statement, our reverse code only use a single print
statement to print the cost of the ticket.
Multiple elif Blocks
You can also have more than one elif block in your program. For instance,
if the manager of the cinema decides to implement special discounts for
workers, this will require additional, conditional tests to the program to
ascertain whether the person in question is qualified for such a discount.
Assuming those above 55 years will pay 70% of the initial cost of each
ticket. Then the program code will be as follows:

person_age = 13

if person_age < 5:
cost = 0
elif person_age < 17:
cost =30
elif person_age < 55
cost = 50
else:
cost = 35
print(f “Your ticket cost is ${cost}.”)

The cost is identical to our previous example; however, the only including
is the “elif person_age < 55” and is respective else condition. This second
elif block checks if the person’s age is less than 55 before assigning them
the cost of the ticket for $50. However, the statement after the else needs to
be changed. In this situation, it is applicable if the person’s age is above 55
years, which is this situation fulfills the condition we want.
The “else” statement isn’t compulsory because you can omit it and use the
elif statement instead. At times, it is better to use additional elif statements
to capture specific interests. Let us see how to implement it without using
the else statement.

person_age = 13
if person_age < 5:
cost = 0
elif person_age < 17:
cost =30
elif person_age < 55:
cost = 50
elif person_age >= 55:
cost = 35
print(f “Your ticket cost is ${cost}.”)

The additional elif statement helps to assign the ticket cost of “$30” to those
above 30 years. This format is a bit clearer when compared with the else
block.

Performing Multiple Conditions

Using the if-elif-else statement comes handy when especially when you
want to pass only one test. Once the interpreter discovers that this test is
passed, it skips other tests and halts the program. With this feature, you test
a specific condition in a line of code.
Nevertheless, there are situations that may warrant you to check all the
conditions available. In such a scenario, you can use multiple if statements
without adding the elif or else blocks. This method becomes relevant when
more than one of the condition returns true. For instance, let us consider the
previous example of players in Manchester United to illustrate this. In this,
we want to include the players in an upcoming match against their rivals
Manchester City.

united_players = [“Rashford,” “Young,” “Pogba,” “Mata,” “De Gea”]

if “Young” in united_players:
print(“Adding Young to the team list.”)
 if “De Gea” in united_players:
print(“Adding Dea Gea to the team list.”)
if “Messi” in united_players:
print(“Adding Messi to the team list.”)

print( “\ Team list completed for the match against Manchester City!”)

In the first line, we defined united_players as a variable with values

Rashford, Young, Pogba, Mata, and De Gea. The second line uses the “if
statement” to check if the person requested for Young. The same applies to
the lines with the “if statement” and the condition is run regardless of the
outcome of the previous tests. For this program above, the output will be:

Adding Young to the team list.

Adding Dea Gea to the team list.

Team list completed for the match against Manchester City!

If we decide to use the if-elif-else block, the code won’t function properly
because once a particular test returns true, the program will stop. Let us try
it and see.

united_players = [“Rashford,” “Young,” “Pogba,” “Mata,” “De Gea”]

if “Young” in united_players:
print(“Adding Young to the team list.”)
elif “De Gea” in united_players:
print(“Adding Dea Gea to the team list.”)
elif “Messi” in united_players:
print(“Adding Messi to the team list.”)
 print( “\ Team list completed for the match against Manchester City!”)

In this code, Python will evaluate the first condition, and once it is true, the
program stops. The output for this program will be:

Adding Young to the team list.

Team list completed for the match against Manchester City!

Exercise to Try
Consider the list of colors we have in the world. Create a
variable name color and assign the following colors to it – blue,
red, black, orange, white, yellow, indigo, green.
Use an “if statement” to check if the color is blue. If
the color is blue, then print a message indicating a
score of 5 points.
Write a problem using the if-else chain to print if a
particular selected is green.
Write another program using the if-elif-else chain to determine
the scores of students in a class. Set a variable “score” to store
the student’s score.
If the student’s score is below 40, indicate an output a
message that such student has failed
If the student’s score is above 41 but less than 55, print
a message that the student has passed.
If the student’s score is above 56 but less than 75, print
a message that the student did well
If the student scores above 76, print a message that the
student did excellently.
 Chapter 5: User’s Input and Loop

The primary purpose why most programs are written is to solve a particular
problem. In order to solve these problems, users must input certain
information while interacting with the program. For instance, a player that
determines if someone is eligible to vote or not will require input from the
user. Such a program will request the user to input their age, which will
enable the program to compare their value with the laid down condition of
the program before displaying the outcome.
In this chapter, you will learn the different ways of accepting input from the
users and how it works. Additionally, you will learn how to prompt users to
provide input by using the input() function. Furthermore, I will guide on the
way to keep your code running using a while loop pending when the
condition becomes false. If you can learn how to ask for input from users
and control how long a program should run, then you can effectively write
interactive programs that will solve many problems.
The simplest means of displaying output on the screen in Python is through
the “print” statement, which allows you to pass expression or zero separated
by commas. It can also convert expressions passed through a string and
returns the results. For instance, consider the string below.

print “Learning is part of Life. Python is life”, “Does that sound good?”

When you run the program, your output will be:

Learning is part of Life. Python is life, Does that sound good?

Besides this, python provides two means of accepting keyboard input into
the program. You can either use the raw_input function or the input()
function. Let us begin with the input function, as it is the most widely used
input function in Python.
Using the input() Function
Have you ever stopped a moving vehicle? Do you remember what
happened? You waved your hand, and the vehicle stopped. The driver opens
the door, and you enter before he zoomed off. Yes, as simple as that
illustration is, that is what the input() function works. It pauses and waits
for an input from the user. In a similar pattern, the driver stops, the car door
opens before you hop into it. In Python, the moment the user inputs the
information, the value or information is assigned to a variable.
For instance, the program below requests the user to insert their first name
and surname. It further displays both names on the screen.

full_name = input(“Please, what is your first name and surname?”

print(full_name)

The input() function here prompts a message on what the user should do. In
this situation, it requests the users to enter their first name and surname. The
program will wait pending when the user has responded to the prompt, and
once the “Enter” key is pressed, the information is assigned to the variable
“full_name” before printing the content of the information. Assuming the
user's inputs, “Amanda Norman,” the output will be:

Please, what is your first name and surname?

Amanda Norman

As simple as this, you have created your first program that requests input
from the user. Whenever you use the input() function, endeavor to include
an understandable prompt message on what the user should do or what
particular type of information you want. Additionally, it should be as brief
as possible and very instructive.
Compare the Two Programs Below
full_name = input(“Enter Name:”) full_name = input(“Please what is your first
print(full_name) name and surname?”
print(full_name)
If you observe clearly, the first program on the left hand requires a name but doesn’t explain what
type of name. it could be the full name of a street, football team, business, or drink. The instruction
isn’t concise. However, the code on the right hand clearly states what is required from the user. This
makes it easy for the user to input the information required from him or her.

Multi-Line String When Using input() Function

At times, when writing a program, the prompt you wanted to write may exceed a line. For instance,
you may decide to tell your user whey you are requesting the specific information from them. In this
situation, you can assign the message to a variable before passing the variable to the input() function.
With this method, you can build numerous prompts through different lines. Let us use an example to
illustrate it:

message = “Please tells us your full name, to enable us to provide a personalized message.”
message += “\nWrite your full name”

full_name = input(message)
print(f “\Welcome, {full_name}!”)

This example simply shows you a way of building a multi-line string. In the first line, we assign the
variable message with the information we want the user to respond to. however, the second line
included the += operator to take the first string stored in a message and attach it with this second
one. With this, our message spans two lines. When you run the program, you should have something
like this, depending on the name you insert.

Please tells us your full name to enable us to provide a personalized message.

Write your full name
Welcome, Amanda Norman!

You can include as many messages you want on different lines. You can begin by practicing this
little exercise. Create a Python program that allows you to write a multi-line string with input
requests for the names of your family members.

Accepting Numerical Input in Python

The input() function is used when you want the user to input string; however, if you want to input
numerical value from the user, then you have to use the int() function. Let us consider the program
below that requires the user to input their age.

>>> my_age = input (“Please, What is your current age?”)

When you write this code, the interpreter will wait until it gets a response from you. Assuming your
age is 45, the program will look like this:

>>> my_age = input (“Please, What is your current age?”)

Please, What is your current age? 45
>>> my_age
“45”

The users enter 45; however, when we request for the value of the age from the interpreter, it returns
“45”, which is an illustration of the string value we inputted. As we already know, Python interprets
the input() function as a string since the number has double-quotes. Notwithstanding, if you decide
to print only the input, that will work well. However, printing the input as a number when it is in
string format will generate an error.

>>> my_age = input (“Please, What is your current age?”)

Please, What is your current age? 45
>>> my_age
40

If you run this program, you will get an error. This is what you will see.

>>> my_age = input (“Please, What is your current age?”)

Please, What is your current age? 45
>>> my_age >=40
Traceback (most recent call last):
File “<stdin>”, line 1, <module>
TypeError: unorderable types: str() >= int()

What happened in this code is that you try to use the input() function to perform a numerical
evaluation in line 3. Python generates an error message because you are trying to compare a string
with an integer type. The string in this situation is 45, which is assigned to the variable my_age,
which can’t be compared to the number value of 40.
To solve this issue, we have to use the int() function then informs the Python interpreter to accept it
as a numerical value. Therefore, it then converts the “number string” into a numerical value, as
shown below.

>>> my_age = input (“Please, What is your current age?”)

Please, What is your current age? 45
>>> my_age >=int(my_age)
>>>my_age >= 40
True
In the code above, when prompted to enter how old the person is, we entered 45. However, the
number is interpreted as a string, but the inclusion of the int() function helps to convert the number
string to a numerical value. With this, the interpreter then runs a conditional test to compare the age
to see if it is greater than or equal to 40. In this case, our age “45” returns true because it is greater
than 40.
How then can we use the int() function in a real program? Well, let us use a program that checks if
people are tall enough to participate in a basketball match.

basketball_height = input(“What is your current height? It should be in feet’s:”)

basketball_height = int(basketball_height)

if basketball_height >= 7:
print( “\nYou have what it takes to participate in a basketball match!”)
else:
print(“\nYou do not meet up with the requirement for this match!”)

This program compares the height of the person to 7 inches because we already convert as a
numerical value. If the user inserts anything below 7, the message “You do not meet up with the
requirement for this match!” will display. However, let us assume the user input 8, the output will be
as follow:

What is your current height? It should be in feet’s: 8

You have what it takes to participate in a basketball match!

Modulo Operator
Already, you should know that we have an important operator to use in manipulating numerical
values. Besides the popular addition, subtraction, multiplication, and division, we also have a unique
operator called the “modulo operator.” It is represented by the percentage (%) sign and returns the
remainder of a number divided by another.

>>> 10 % 4
2
>>> 7 % 4
3
>>> 20 % 5
0
>>> 5 % 4
1
>>> 3 % 3
0

Note: The operator does not tell us the number of times the number fits in the other number, rather
it tells us the reminder of the operator. For instance, the first example, which is 10 divided by 4, what
the module operator does here is to return the reminder when the division takes place. In this
situation, it returns the value 2 because 4 can only go into 10 twice and with 2 remaining.
Interestingly, you can use this to ascertain if a particular number is odd or even. Let see how that
works out:

num = input(“Key in a number of your choice, and I will let you know if it is odd or even: “)
num = int(num)

if num % 2 == 0:
print (f “\nThe number you enter {num} is an even number.”)
else
print( f “\nThe number you enter {num} is an odd number. “)

Even numbers are numbers we can divide by two. Therefore, when a number modulo and two are
equivalent to zero, then the number is even. However, if it turns out otherwise, then it is even. Let us
run the program and assume that you insert 46.

Key in a number of your choice, and I will let you know if it is odd or even: 46
The number you entered is an even number
Closing and Opening Files
Since you have been learning how to use the input and output functions to
display output on the screen. It is time to learn how to use data files when
writing a program. Python has basic methods and functions, which are
essential to manipulate files without you performing any operation on them.
We will explore some of these functions:

Open Function
Before you think of writing or reading a file in Python, you have to open it
through the inbuilt open() function. This creates a file object, which you can
use to call other methods related to it. The syntax is as follow:

file object = open(file_name [, access_mode][, buffering])

file_name: This is a string value, which contains the particular

file you want to access
access_mode: This determines the mode by which the file in
question will be opened. For instance, append, write, or read.
Buffering: If you set this value to 0, nothing will take place.
However, setting the buffering value to 1 will perform line
buffering when accessing the file. For buffering values greater
than 1, the action will be performed alongside the indicated
buffer size.

Modes for Opening a File in Python

Modes Meaning
r This opens a file for reading
purposes only. The default mode is
to place the file pointer at the
beginning of the file
r+ This opens a file for both writing and
reading. Similar to the r mode, the
 pointer is at the beginning of the file
rb If you want to open a file in binary
format, then you have to use the rb
mode. Furthermore, you place the
point at the starting point of the file
rb+ Open files for both writing and
reading in binary format
w Open files for writing purposes only.
if the file doesn’t exist, it will create
a new file, but if it does exist, it will
overwrite the file
wb This opens a file for writing in
binary format. It also overwrites and
creates new files depending on the
existence of the file
w+ This opens a file for both writing and
reading purposes. It also overwrites
and creates new files depending on
the existence of the file.
wb+ Both write and read files in binary
format. Overwrites and create new
files based on the existence of the
file.
a This opens a file for appending. If
the file exists, the pointer is
positioned at the end of the file
a+ Opens file for both reading and
appending purposes.
ab Opens file for appending in binary
format.
ab+ If you want to read and append files
in binary format, then the ab+ mode
is relevant. If the file exists, the
pointer is positioned at the file end.
Exercise to Try
Write a program, which requests a particular user to insert the
choice of their rental car. Print a message that displays the choice
of their rental car.
Write another program, which requests for a number and print if
the number is a multiple of 9 or not
Write a simple program that asks a user the number of a person
in a queue in a bank. If the user's reply is above 8, it should print
a message that they have to wait or go home and return
tomorrow.

Introduction to While Loops

Initially, I have introduced you to “for loop” in the chapter on lists. The
purpose of the “for loop” is to execute a line of code once for every item in
a list. However, the while loop is different because it runs continuously
pending when a particular condition returns true. I hope that is clear enough
for you to understand the basic difference that exists between the “for and
while loops.”

Using While Loop

As stated already, the while loop is used to repeat a block of lines pending
when the condition is true. For instance, here is a while loop that counts
from 10 to 20:

number1 = 10
while number1 <= 20:
print(number1)
number1 += 1

Before generating the output of how the program will be, let me explain
what happens in each line of code. In the first line, we assigned the variable
number with the value 10. This is where the number begins counting. In the
second line, the while loop takes operation and runs pending when the
number is less than or equal to 20; in each loop, it prints the number to the
screen. However, the last line adds 1 to the number and returns to the loop.
In Python, to perform increment, we can use the “+=” operator. It is akin to
saying number = number + 1.
Therefore, the loop repeats because the first number 1 is less than 20. It
then prints 1 and adds 1 to test the next line. It continues this process up to
the tenth number before stopping. Finally, our output becomes:

1
0
11
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
The various programs you use nowadays involves the use of while loops.
For instance, the game you play contains or uses a while loop to continue
playing pending when you want to quit it. It would be awkward and painful
when playing a game, and it abruptly stopped without you making any
request.

Giving the Users a Choice

We can write a program that runs continuously, depending on the choice of
the user. We can do this by putting the program inside the while loop.
However, we will define an exit value that will quit the program. if the user
doesn’t input that number, the program will continue to run. Consider the
program below:

request = “\nSay something to me, and I will rephrase it perfectly:”

request += “\nIf you want to exit, Enter ‘stop’ to terminate the program!”
prompt1 = “”
while prompt1 != ‘stop’ :
prompt1 = input(request)
print(prompt1)

In the first line, we define a variable request and give them two options on
what to do. The first is to enter a message, whereas the second is to exit the
program by entering stop. Them in line three, we defined any variable
“prompt” with an empty string. During the first time, the interpreter checks
on the variable and compare the value of the prompt1 to see if the user has
input “stop.” However, the user hasn’t inputted any value yet. The while
loop will continue to run as long as the prompt isn’t equal to ‘stop.’
During the first loop, a prompt1 is just a string without any value, so the
loop begins. Then at prompt1 = input(request), it shows the request and
waits on the user to respond. Whatever message the user enter is printed out
on the screen, and the interpreter reevaluates the condition to ascertain that
the condition is still within the while loop statement. Since the user hasn’t
entered the word ‘quit,’ the program further asks the user to make an input.
However, once the user enters “stop,” the program stops executing the loop
and halts the program.
Let assume the users in his interaction with the program entered the
following statements.
I am new to Python Programming!
Programming in Python is the best for beginners!
I am in an advanced learning phase in Python Programming!
My Python course will soon end!
stop

Then the output will be as follows:

Say something to me, and I will rephrase it perfectly:

If you want to exit, Enter ‘quit’ to terminate the program!
I am new to Python Programming

Say something to me, and I will rephrase it perfectly:

If you want to exit, Enter ‘quit’ to terminate the program!
Programming in Python is the best for beginners!

Say something to me, and I will rephrase it perfectly:

If you want to exit, Enter ‘quit’ to terminate the program!
I am in an advanced learning phase I Python in Python Programming!

Say something to me, and I will rephrase it perfectly:

If you want to exit, Enter ‘quit’ to terminate the program!
stop
If you observe, the program included the “quit” word. Naturally, we don’t
want that word printed out on the screen. Well, to avoid such a situation, we
can use the simple if statement to fix it.

request = “\nSay something to me, and I will rephrase it perfectly:”

request += “\nIf you want to exit, Enter ‘stop’ to terminate the program!”

prompt1 = “”
while prompt1 != ‘stop’ :
prompt1 = input(request)

if prompt1 != ‘stop’:
print(prompt1)

Now reenter the statements you entered the first time and observed the
difference. If properly done, your output will be as follow

Say something to me, and I will rephrase it perfectly:

If you want to exit, Enter ‘stop’ to terminate the program!
I am new to Python Programming

Say something to me, and I will rephrase it perfectly:

If you want to exit, Enter ‘stop’ to terminate the program!
Programming in Python is the best for beginners!

Say something to me, and I will rephrase it perfectly:

If you want to exit, Enter ‘stop’ to terminate the program!
I am in an advanced learning phase I Python in Python Programming!

Say something to me, and I will rephrase it perfectly:

 If you want to exit, Enter ‘stop’ to terminate the program!

Flag in a Program
In our last example, we performed a task pending when the condition is
true. However, what if it is a more complicated program, which has
numerous events that can make the program stop?
For instance, a game can have several exit points. Do you remember the
famous snake game in Nokia phones? Remember each time the snake
touches the wall or touches itself, the game terminates. The game can also
terminate if you intentionally or mistakenly exit the game application. All
of these come with different possible events that might terminate the games.
Therefore, in testing these different conditions using a while loop statement
becomes difficult and complicated.
If you want to run a program that continues running pending when the
condition is false, then you have to define a variable, which will determine
if the program is active or not. This kind of variable is known as a flag
because it acts as a pointer to the program. With this, we can create codes
that run while the variable “flag” is positioned to be True and stops when
any of the different event's value of the flag is False. All of these sound
complicated, however, let us upgrade our previous example by using the
flag in the program.

request = “\nSay something to me, and I will rephrase it perfectly:”

request += “\nIf you want to exit, Enter ‘stop’ to terminate the program!”

start = True
while start:
prompt1 = input(request)

if prompt1 == ‘stop’ :
start = False
 else:
print(prompt1)

In the program above, we set “start” to be “True,” and this is where the
program begins. This makes the while loop easier because there is no
comparison tested within our while statement. However, the logic of the
program is done in another part of the program. The loop will continue to
run pending when the expression becomes false.
The if a statement is contained within the while loop, which checks the
value of the prompt1 whenever the user enters their request. However, once
someone enters “stop,” we set the variable “start” to False thereby
triggering the loop to stop. Notwithstanding, anything besides the quit
statement will print the request, which the user enters.
The program here will produce the same output as the previous one, where
we directly test the condition inside the while loop. However, with the flag,
we indicate when the program is an inactive state and makes it simpler to
include additional, conditional tests.
Exiting a Loop
Well, Python allows us to use the break statement to direct the flow of our
program. For instance, let us look at a program, which asks the user about
the country they have visited in their life. In our previous program, we can
use the “break” statement to halt the program once the user enters ‘quit.’
Let see how that works.

request = “\nPlease enter the country you have visited recently:”

request += “\nIf you want to exit, Enter ‘quit’ to terminate the program!”

while True
country = input(request)

if country == ‘quit’ :
break
else:
print(f “ I have visited {country.title()}.”)

The loop begins with the “while True” statement, which runs continually
pending when it reaches the break statement. The loop will continue to ask
the user to input the country they have visited pending when they enter
“quit.” The break statement takes effect when the user enters “quit” and
causes the program to exit the loop. Our output will be as followed if the
user entered Canada, Hungry, and Portugal.

Please enter the country you have visited recently:

If you want to exit, Enter ‘quit’ to terminate the program!
I have visited Canada.

Please enter the country you have visited recently:

If you want to exit, Enter ‘quit’ to terminate the program!
I have visited Hungry.

Please enter the country you have visited recently:

If you want to exit, Enter ‘quit’ to terminate the program!
I have visited Portugal.

Using “continue” in a Loop

Instead of using the break statement to completely exit a loop without
executing the remaining code, the continue statement can be used to return
to the starting point of a loop. However, this depends on the outcome of the
conditional test in question. For instance, let us look at the program, which
counts from 10 to 20 but display only the even numbers.

even_number = 10
while even_number < 20:
even_number +=1
if even_number %2 == 0:
continue
print(even_number)

Firstly, we assigned an even_number to 10. However, since the number is

less than 20, it goes through the while loop. In the loop, we increase the
value of the number by 1, which now becomes 11. Then the if statement
verifies if the modulo of the number is 0. This means there is no remainder
when we divide the number by 2. Nevertheless, the continue statement
informs the interpreter to overlook the loop while returning to the starting
point of the statement. However, if the number isn’t divisible by 2, the
remaining part of the program is executed and displays the number:

1
0
1
2
1
4
1
6
1
8
2
0

Avoiding Endless Loop

Have you ever encountered a situation where your phone cannot respond
irrespective of what you do? You even allowed it to stay for hours, yet no
solution. You decided to charge it, yet to no avail. Finally, you have the
instinct to remove the battery of the phone. And you pressed the power
button and “boom” the phone came alive and responded perfectly. At least,
you had a way out.
What if after writing your program and decides to run it and suddenly your
key developed a fault? Or you forget the particular word to enter to exit the
program. Besides this, you can even face one of the worst challenge most
beginner face when using conditional statement – an endless loop. How do
you override this situation?
In a while loop, you must have a way of stopping it from running
continuously. For instance, the loop below counts from 10 to 15:

number = 10
while number <= 15:
print(number)
number +=1
When this program is run, you will get the output as follow:

1
0
11
1
2
1
3
1
4
1
5

However, let us assume that you accidentally forget to include the line
“number+=1) in the program. What will happen when Python encounters
this program?

number = 10
while number <= 15:
print(number

The program will run continuously and never stop. The value of the number
will start at 10 but won’t change. Because of this, the conditional statement
number <=15 will evaluate to True at all times. Additionally, the while loop
will not stop because it will be printing 1o upon 10 throughout the program.
Don’t beat yourself up if you face such an issue because virtually all
programmers have accidentally written an infinite loop. If you find yourself
stuck in such a situation, take a glass of cooled water and quench your taste.
There is nothing to stress yourself about; you can use the CTRL+C button
to escape from this endless loop. Additionally, you can close the Python
program. To avoid such an endless loop, you should test each while loop
and ensure the loop ends where it should.
Exercises to Try
Write a simple looping program, which asks the user to input the
names of their family members pending when the user input a
“stop” value to halt the program. In each name, it should print
what makes that person special.
Write a program that offers four different meals to customers
depending on their choice. If a person decides to take water, then
the meal should be $20. If the meal is a plate of rice, then the
ticket is $30. If the meal is a chicken pile, then the ticket is $40.
If the person doesn’t choose anything, then the ticket should be
$0. Write a loop to ask the user what meal they want and print
the price of the meal on the screen.
Use a conditional statement on the above program within the
while statement to halt the loop
When writing the second program, use a break statement to stop
the loop whenever the users enter “stop”

Using While Loop Condition with Dictionaries and Lists

So far, you have only worked on the user requests for information at a time.
Once the user enters their response, the response is printed out. However,
how can you keep track if we have numerous users and information? Well,
in this situation, you will need to use the while loop in dictionaries and lists.
An effective way of looping through a list is using a “for loop” conditional
statement. However, don’t try to change a list contained in a “for loop”
because it will be hard for Python to keep track of the items on your list.
Nevertheless, if you want to change a list while working on the items, you
need a while loop test. With this, you can collect, store, and arrange
different inputs to report or examine later.

How to Move Items from a List to Another

Let us consider a list comprising of students registered but not approved to
participate in the upcoming campus queen. Once we verify their
registration, we can transfer them to the list of registered students. To do
this, we can use a while loop test to move users from our unapproved lists
to approved lists. Let us see how the code will be:

#starts with students that should be approved,

# and an empty list to store approved students
unapproved_student = [“Moses,” “Sarah,” “Abigail,” “Benson”]
approved_student = []
#check if the user pending when there are no more unapproved students
#transfer each approved students to the approved list.

while unapproved_student:
user = unapproved_student.pop()

print(f “Checking student: {user.title()}”)

approved_student.apend(user)

#Prints all the list of approved student

print(“\nThe following students have been approved:”
for approved_students in approved_student:
print(approved.title))

Let us analyze the program before giving a sample of the output. We

declare a variable unapproved_student with values as Moses, Sarah,
Abigail, and Benson. Then we also declared another variable as
approved_student but with an empty list. furthermore, we use the while
loop, which runs as far as our unapproved_student list isn’t empty. Insider
the loop, we use the pop() function, which removes any
unapproved_student starting from the end of the list.
Here, because Benson is the last name in our unapproved_student list, his
name will be taken off from the list before assigned to a user before it is
added to our approved list. Then it will go back to the while loop and
continue the process from Abigail, to Sarah and finally to Moses.
We check each student to ascertain their approval statues before adding
them to our list of approved students. As the unapproved student list
decreases, so does, the approved list increases. However, once the
unapproved student list becomes empty, the loop stops and the approved
student list is printed. Let us check our output:

Checking student: Benson

Checking Student: Abigail
Checking Student: Sarah
Checking Student: Moses

The following students have been approved:

Benson
Abigail
Sarah
Moses

How to Remove Instances of Particular Values from a List

At times, you may decide to remove a particular value from a list. Well, you
remember the remove() function we talked about? This works perfectly
well; however, what if we want to remove values that appear twice in a list.
That also is possible to do in Python.
For instance, here is a list of footballers' names with “Oscar” repeated
thrice. You can use a while loop to remove all instances of the name
pending when there is no “Oscar.” Check the code to see as that is possible.

footballers = [“Oscar,” “Messi,” “Vardy,” “Oscar,” “Ronaldo,” “Oscar,”

 “Fred,” “Lampard,” “Terry”]
print(footballers)

while “Oscar” in footballers:

footballers.remove(“Oscar”)
print(footballers)

The logic of the program is very easy to understand. We assign the variable
footballers with various value, but “Oscar” repeated thrice. It prints the
names of the footballers. Then the code enters the while loop because we
have Oscar in our list in more than one instance. Inside the loop, the first
instance of Oscar returns to the while line before it reenters the loop to
ascertain if there is another Oscar. It continues in such a manner until the
list is empty. The output for our program will be”:

[“Oscar,” “Messi,” “Vardy,” “Oscar,” “Ronaldo,” “Oscar,” “Fred,”

“Lampard,” “Terry”]
[“Messi,” “Vardy,” “Ronaldo,” “Fred,” “Lampard,” “Terry”]

Using User Input to Fill a Dictionary

You can request for input as much as required from a user to pass through a
while loop. The program below is a polling program whereby whenever we
pass through the while loop, it requests input from the user. We will then
store the information we gather from the users in a dictionary. The idea
behind this is to enable us to link each response we get to a particular user’s
input.

remarks ={}
# let set a flag to indicate that the polling is active
poll_active = True

while poll_active
 # request for the name of the user and their remark
fullname = input(“\Enter your full name:”)
remark = input(“What is your country of residence?”)

#store the remark in the dictionary.

remarks[fullname] = remark

#Let us know if someone is still available to take the poll.

next = input(“Is there anyone else available to answer a question? (yes/
no)”)
if next == “no”:
poll_active = False

# Our Poll is complete. Therefore, display the results.

Print(“\n**** Poll Results ****”)
for fullname, remark in remarks.item():
print (f “{fullname}, [remark] is my country of residence. “)

In the program above, we defined an empty dictionary (remarks) while

setting a flag to indicate when the poll is active. The program will continue
to run within the while loop as long as the poll_active is True.
Inside the while loop, the user is requested to enter their full name and their
current country of residence. The information inserted by the user is then
stored in the remarks dictionary. Additionally, the program then asks the
user if they are any person available to take the poll. If the response is yes,
the programs go back to the while loop. However, if it is no, the poll-active
flag becomes false with the loop stops. The final line is the code that will
display the results of the program. let us run the program with the following
input:
Luis Gracious
 Herbert Franklin
Lilian Cosmos

Enter your full name: Luis Gracious

What is your country of residence? South Africa
Is there anyone else available to answer a question? (yes/ no) yes

Enter your full name: Lilian Cosmos

What is your country of residence? Turkey
Is there anyone else available to answer a question? (yes/ no) yes

Enter your full name: Herbert Franklin

What is your country of residence? Canada
Is there anyone else available to answer a question? (yes/ no) no

**** Poll Results ****

Luis Gracious, South Africa is my country of residence.

Lilian Cosmos, Turkey is my country of residence.
Herbert Franklin, Canada is my country of residence.
Exercises to Try
Write a simple program that polls teachers about their best
subject to teach in class. Use a prompt to request for their best
subject. Then use the print statement to display their response to
the question.
Make a list of famous places to visit before you reach 50 years.
write the names of different places. Make an empty list called
Places_visit. Use a while loop to go through the list of places
visited and display the result of their choice.

Summary
In this User’s input and loop, you have learned how Python language
accepts inputs from users by using the input() function. Furthermore, you
have been equipped with the knowledge of how to work with both
numerical and text inputs. Additionally, with the looping lessons you
learned in this chapter, you could easily write programs to control a
decision. With the while loop conditional test, you can move items from a
particular list to another. Then, you learned how to create your own
dictionary using the while loop.
In the next chapter, you will learn about functions in Python. Functions give
you the opportunity to break your programs into parts; each of these parts
carries out a specific job. Additionally, functions can be called as many as
you want in the program. I know you are excited, so see you in the next
chapter.
 Chapter 6: Functions

In this chapter, you will know how to write functions easily in Python.
Functions are a line of codes, which are designed to perform a particular
job. When you want to write a program that will perform a specific task,
then you have to define the function and call the function. Furthermore, I
will teach you how to pass information to functions and display them on the
screen.

Defining a Function
At times, the best way to explain a thing is to provide an example. The
program below is a welcome program that prints a message.

def welcome_user():
“ “ “ Transmit a Welcome Message.”””
Print (“Welcome to Learning Python Programming.”)

welcome_user()

In this example, it shows the simplest structure of how a function works.

The first line uses the keyword “def” to tell the interpreter that you want to
define a function. Therefore, whenever you see the word “def” and the
word following it, it signifies a function definition. The parenthesis does the
job of holding the information you need. Then after the parentheses, the
function definition ends with a colon.
Whenever you see an indented line after defining a function, which is the
body of the function. The second line is known as a docstring, although it is
a comment and describes the purpose of the function. Docstring is usually
enclosed with three quotes. Furthermore, the third line prints the statement
“Welcome to Learning Python Programming.” This line contains the main
message of the function. This means welcome_user has the primary job of
printing “Welcome to Learning Python Programming.”
If you want to call a function, you have to write the function name before
following it with parentheses and a colon. Our program output will be as
follow:

Welcome to Learning Python Programming.

How to Pass Information to a Function

We will modify our previous example to explain how you can pass
information to a function. We can do it in such a way that the program will
not only say “Welcome to Learning Python Programming” but also include
the user name. To do that, we have to request a user to enter their name.

def welcome_user(name):
“““Transmit a Welcome Message.”””
Print (“Welcome to Learning Python Programming, {name.title()}!”)

welcome_user(“Thomas”)

When we enter welcome_user(“Thomas”) it calls the function

welcome_user() and passes the name “Thomas” to the function to execute
the print command. With this, our output will be:

Welcome to Learning Python Programming, Thomas!

Arguments and Parameters

In our previous example, we defined a function, which requires the user to
input a value for the variable username. Immediately, you call the function
and assign a value to it; it prints the message in the print() function. Our
function has a variable inside it. the variable is an example of what a
parameter is in Python, whereas Thomas is the argument. Arguments are
values that contained information and pass from a function call to the
function. For instance, when we call the function, we placed a value inside
the function. In this scenario, our argument is “Thomas,” and we passed the
information to the function.
Note: people interchangeably use both terms. Therefore, when you see
a definition of a function referred to as an argument or vice-versa.
How to Pass an Argument in Python
Since a function definition can have several parameters, a function call may
also require several arguments. It means you can pass your argument to a
function in multiple ways. You can use either keyword argument or
positional arguments. In the latter, the argument must be of the same order
as your parameter, whereas, in the former, each argument comprises a
variable name and its equivalent value.

Positional Arguments
This argument is the simplest way of passing an argument in Python
because each argument in the function must match with a parameter in the
function declaring section. To see how this works, let us write a program
that shows information about animals. The function in this situation tells us
the particular type of animal and the name of the pet.

def animal_list(animal_kind, pet_name):

“““ Display Details About Animal.”””
print(f “\nThis is a {animal_kind}.”)
print (f “My {animal_kind}’s name is {pet_name.title()}.”)

animal_list (“Cat,” “Lucy”)

The first block of line defines a function. It indicates that the function
requires a particular animal’s type and its pet name. After defining the
function, we provided the animal kind and pet name. for instance, in the
function call (animal_list), we assign Cat as animal kind while Lucy is the
pet’s name. Our output will display the detail about the animal Cat with the
pet name Lucy.

This is a Cat.
My Cat’s name is Lucy.
Calling Multiple Functions
We can call the function as many times as we want. All we need is to add
another parameter to our function. Check the code below:

def animal_list(animal_kind, pet_name):

“““ Display Details About Animal.”””
print(f “\nThis is a {animal_kind}.”)
print (f “My {animal_kind}’s name is {pet_name.title()}.”)

animal_list (“Cat”, “Lucy”)

animal_list (“Dog,” “Bruce”)
animal_list (“Rat,” “Chase”)

The program follows the same sequence and performs the output. However,
in this situation, we added two more parameters to the list. Therefore, our
output will look like this:

This is a Cat.
My Cat’s name is Lucy.

This is a Dog.
My Dog’s name is Bruce.

This is a Rat.
My Rat’s name is Chase.

Calling a function several times is an efficient way when you have several
parameters. The code about the details of the animal is written once inside
the function. However, whenever you want to describe a new animal, all
you need is to call the function by providing information about the animal.
Keyword Arguments
This is a name/value pair, which you pass to a function. You have to
directly link the value and the variable name inside the argument. With this,
there won’t be any confusion when you pass the argument to the function.
let’s rewrite our previous code using the keyword arguments to call our
animal_list()

def animal_list(animal_kind, pet_name):

“““ Display Details About Animal.”””
print(f “\nThis is a {animal_kind}.”)
print (f “My {animal_kind}’s name is {pet_name.title()}.”)

animal_list (animal_kind =“Cat”, pet_name= “Lucy”)

animal_list (pet_name= “Chase”, animal_kind =“Rat”)
Our first four lines haven’t changed. However, there is a difference between
the last two lines. When the interpreter reads the fourth line, it calls the
function and assigns the parameter Cat to animal_kind and Lucy to
pet_name respectively. For the next line, it will perform the same operation
because the order doesn’t matter when dealing with keyword arguments.
Therefore, the last two lines of codes are equivalent and produce the same
output. Our program above will display:

This is a Cat.
My Cat’s name is Lucy.

This is a Rat.
My Rat’s name is Chase.
When using keyword arguments, ensure that the right parameter names are
used in the function definition to avoid any error.
Default Value
Besides using the keyword parameter and position argument, each
parameter can have a default value in a function. if you provide a parameter
that is providing in the function, Python uses the value. However, if there is
no parameter value, then Python uses a default value for the parameter.

def animal_list(pet_name, animal_kind = “Cat”):

“““ Display Details About Animal.”””
print(f “\nThis is a {animal_kind}.”)
print (f “My {animal_kind}’s name is {pet_name.title()}.”)

animal_list (pet_name= “Lucy”)

Compare this program with the previous code. Did you notice anything
from the first and last line? Well, animal_list function is used to describe a
particular animal kind where we set the default value as Cat.

I have a Cat.
My name is Lucy.
Observe that the parameter order inside the function definition must be
changed since the default value makes it pointless to stipulate the particular
animal kind as an argument. Therefore, the only argument available in the
function is the name of the pet.
 Chapter 7: Classes in Python

One of the effective methods of writing software is object-oriented

programming. It allows you to write classes, which represent real-world
situations and things. Furthermore, you create these objects based on these
classes. In writing a class, you define the overall behavior of the entire
object in that program. Perhaps you may have heard of the term
“instantiation” if you haven’t, it means making an object from a class. The
knowledge of classes is very important in programming, and in this chapter,
you will learn how to write and create instances of a class. Furthermore,
you will learn how to specify the kind of information you want your
instance to store.
Having a comprehensive knowledge of object-oriented programming will
fine-tune your learning process as a programmer. It will help you
understand your entire code instead of what is happening on each line. Once
you understand the logic behind classes, you can think logically to write
effective programs that will address any problem you face in life.

Creating a Class
You can model anything you want using classes. The best way to explain it
is to show you an example. Let us write a simple class, Cat, which
represents a cat. Note this is not just a particular cat in question but also any
cat. What information do you want to know about the cat? Cats all have a
name; some can sit while others can spit. With this, we have important
information such as their names, ages, and behaviors (sitting and spitting).
We can use this to create a class since it is common with most cats. Once
we write our class, we can use it to make individual instances.

Example – Creating the Cat Class

Every instance we create from the Cat class will have a name and age.
Additionally, we will give their behavior as spit() and sit():
class Cat:
“““ A Sample Program to Model a Cat.”””
def __int__(data, name, age):
“”” Let us initialize the age and name attributes of the Cat.”””
data.name = name
data.age = age
def spit(data):
“““ Stimulate the Cat to spit saliva.”””
print(f “{data.name} is spitting saliva.”””
def (sit):
“““ Make the Cat to sit.”””
print(f “{data.name} is sitting on the floor.”

There are many things you will notice in this program, but don’t worry
because, at the end of this chapter, you will be familiar with this structure.
The first line of code is a class definition called Cat. The second line is a
docstring, which describes the role of the class.

__int__() Method
You may be surprised because this is the first time we are using this method
in this book. Well, a function that is part of a class is called a method. All
you have learned about functions is applicable to methods.
Notwithstanding, the primary difference between them is how a method is
called. The __int__() method is a unique method, which runs automatically
once an instance is created in a class. A method has the keyword “int” being
preceded and succeeded by two underscores. It is important to use two
underscores on both sides because if Python sees only one, the method
won’t be automatically called when you need to use the class. As a result,
may cause errors in your program.
Our __int__ () method has three parameters, which are data, name, and age.
We need the data parameter, and it must come before other parameters. You
have to include it in the definition because when the software calls this
method, it will automatically pass the data argument. In our program, we
will pass Cat() a name and an age argument. With this, whenever we make
an instance of the Cat class, we will only provide values for the name and
age parameters.
The line “data.name=name and data.age=age” contains two variable
definitions, with each having the prefix data. Any variable that is prefixed
with data is available to all methods in the class and can access them
through any instance we create in the class. What happens in
“data.name=name” is that it takes the value connected with the parameter
name and assigns it to the variable name. The same thing happens to the
data.age=age. Our cat class contains two methods – spit() and sit().

class NewClass:
"This is another example of a class"
area = 15
def room(size):
print('To ascertain the size of a room’)

# Output: 15
print(NewClass.area)

The output will be:

1
5

Exercises To Try
 Write a function known as Television(), which accepts different
television names and names of the television to be printed.
Additionally, use a positional argument to make the television.
Also, use keyword argument to call the function
Write a function called country() that accepts the capital and
country name. Your function must print a simple sentence such
as New York is in the United State of America. Call at least four
different cities

General Exercises to Try

Which tool will you use in Python to find any bug in a program?
Does Python have a double data-type?
Is string in Python mutable or immutable?
Is python platform-dependent?
How can you get the length of a list in Python?

Key Terms
Learning a new programming language comes with the knowledge of new
terms as it relates to this language. Understanding these terms will help fast
track your learning process. This section contains some important but
common Python programming terms that will equip you in his quest. To
avoid any form of confusion, and help you kick-start your learning process,
let us begin with the key terms.
Dictionary - A dictionary is a group of key-value pairs. Every
single key in the dictionary has its corresponding value; the key
enables you to have access to the value, and it can be a list,
string, number, or dictionary
Floating point - A float is a number with a decimal
 Function - Functions are a line of codes, which are designed to
perform a particular job.
Keywords - Keywords are reserved words that are used
specifically by the programming language. Each programming
language has its unique keyword, which is meant for a particular
purpose
List - A list refers to a data type that contains a collection of
items in an orderly manner
String - This is a series of characters, which is enclosed in
quotes. In Python, anything in quotes is regarded as a unique
character
Tuple – A tuple is similar to the list I explained earlier; however,
we use parentheses for tuple as an alternative to square brackets
used in a list. You can access each element after defining a tuple
by using each index
Variable - A variable is a storage location, which has a name
assigned to it. In Python, we can assign a value to a variable and
recall these variables

General Exercises to Try

Which tool will you use in Python to find any bug in a program?
Does Python have a double data-type?
Is string in Python mutable or immutable?
Is python platform-dependent?
How can you get the length of a list in Python?
 Conclusion

Congratulations on completing this book – Learning Python: The

Ultimate Guide for Beginners to Coding with Python with Useful Tools
. You have learned the fundamentals of the language and can apply this
knowledge in various meaningful projects. Firstly, don’t rush into all
projects but only those which interest you because programming is more
appealing when it is aimed at solving relevant and important problems. I am
convinced you can apply your skills to various projects. Furthermore, I
believe
You have a comprehensive knowledge of Python
You can install Python on various operating systems
You can create your own first program
You can use Python to create a calculator program
You can use control flow tools such as elif statement, if-else, and
if statements effectively.
You can easily manipulate various loops – for, while, and while
true loop
You understand what a function is and how to use it in a program
You know how to pass a statement in a program

Congratulations on the sleepless night and mistakes you had to accomplish

this feat. However, continuous learning is important to sharpen your skill to
become a more efficient and productive programmer with Python. One of
the best choices you can ever make is to learn Python programming
language because it is the simplest language for anyone to learn without
requiring a tutor. As simple as it is, it has great power behind it to generate
massive programs that will revolutionize the programming world. There are
a thousand things you can do when writing Python programs. Additionally,
you can integrate with some programming languages to create web
applications or games.
Programming is easy, but we all get stuck as time goes on. This is even
stressful when you are just starting new. Therefore, don’t despair because
the best programmers have learned to unstuck themselves from any code
that gives them a headache.
If you find yourself stuck, the first step is to asses your current situation.
Ensure to reevaluate your situation by asking these three important
questions:
What is my goal? (What am I trying to achieve?)
What steps have I taken? (What have I tried and haven’t tried?)
What result am I getting?

Before thinking of giving up, try one more. Take a step backward to retrace
where you got it wrong. If you are trying to write a program to achieve
using “for loop,” it won’t harm you to check through similar examples. Go
through your codes, perhaps you have omitted a colon, inserted a single
quote where there should be double. Review your work carefully.
If, after this, there is no solution, it is time to take a break. Maybe, you are
stressed and cannot stay focus when looking for the solution. When we
work for a long period, our brain gets tired, and we need to refresh or reboot
the brain. In this situation, take a nice shower, nap, or go have fun. Most
programmers take a long break because once they resume, they become
filled with enthusiasm to find what the problem was. Programming is
interesting and shouldn’t stress the hell out of your life.