CSC1201: PART 2 - INTRODUCTION TO

PROGRAMMING WITH PYTHON

1. Introduction
A program is a set of instructions executed sequentially by the computer that enable
it to perform a specific task. Computer programming can be divided into designing,
coding and testing.

i. Designing: In the design stage, a programmer either receives or writes the

detailed specifications of the problem definition and solution. The programmer
then represents detailed logical stages to the solutions in form of a Pseudocode
(descriptive statements outlining the operation of the program) or Flowchart.
The design must be checked to ensure its feasibility and that the program will
produce the required output.
ii. Coding: This is the process of translating the program design into statements of
the programming language being used to create the program. Coding is done
according to the syntax of the programming language and is carried out in a text
editor. The generated code (in high-level languages) has to be compiled before
execution in the case that interpreter programs like Python, BASIC, C,
JavaScript, etc. are not being used.
iii. Testing: The program must be tested using appropriate sample data to check
that correct results are produced. In the event of an error, the program code
and design have to be revisited and corrected until all errors are eliminated.
The process of checking and removing errors is known as debugging.

1.1 The Python Programming Language

Python is an easy to learn and powerful high-level programming language. It can be
used for a wide variety of tasks like text processing, physical programming and internet
related tasks amongst others. Python is an object-oriented language (OOL) with
efficient high-level data structures. Python has an elegant syntax which, together with
its interpreted nature, make it ideal for scripting and quick application development
on most platforms. The Python interpreter (including the extensive standard library),
third-party modules and associated documentation are freely available from the
Python website, https://www.python.org.

The Python language was developed by Guido van Rossum in the early 1990s in
Amsterdam. Python grew out of a project to design a computer language that would

1
be easy for beginners to learn and yet powerful enough for advanced programs.
Although pictures of serpents often appear on Python books and websites, the name
was actually derived from Guido van Rossum’s favourite TV show, “Monty Python’s
Flying Circus”.

Over the years, Python has gained a lot of popularity. The main reasons given for
Python’s increased popularity are:

i. It is relatively easy to learn.

ii. It is free (open source).
iii. Python offers more libraries for modern technologies like data science, artificial
intelligence and robotics than most other programming languages.

Python is an interpreted language, which can save significant time during program
development. This is because interpreted languages do not require compilation and
linking. The Python interpreter is also interactive, making it easy to test functions or
part of programs during development. Programs written in Python are generally
shorter than equivalent C, or Java programs. This is because of the high-level data
types in Python allow complex operations to be expressed in a single statement.
Moreover, grouping in Python is done by indentation instead of beginning and ending
curly brackets in C and Java or other group ending statements like END IF used to end
an IF block in the BASIC programming language.

Figure 1.1 shows Google search trends over a five-year period from 2013 to 2017. It is
obvious that Python has been gaining popularity whereas Java, C++ and C# have been
declining in popularity.

2
 Figure 1.1: Trends in Google searches

1.2 Versions of Python

Since the release of Python 1.0 in January 1994, the language has continued to evolve.
Python 2.0 was released in October 2000 while Python 3.0 was first released in
December 2008. At the same time as version 3.0, the Python team also produced
version 2.6, which is an upgraded version of Python 2 that benefited from general fixes
and some of the new features introduced in version 3.0. Python 3.7, released in June
2018 is the version used in this course.

1.3 Starting Python

To start Python programming, a version of Python must first be installed on the
machine. The latest version can be downloaded for free at the Python website. For
Windows PCs, Python can be started by typing “python” at the Command Prompt. The
command prompt can be launched by typing “cmd” in the Windows search tool. Once
the Python interpreter is launched, a message similar to the one below is displayed.
C:\Users\Adam>python

Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 27 2018, 04:06:47) [MSC v.1914 32 bit

(Intel)] on win32

Type "help", "copyright", "credits" or "license" for more information.

3
 >>>

 Note: The Python interpreter might not be found if it is not in the Windows
path.

The first line shows the current Windows path while the second line shows the Python
version (3.7.0) installed on the machine. The three greater-than signs (>>>) at the
Python prompt indicate where Python commands can be entered. Once an executable
statement is entered, Python executes it immediately and shows the result on the
screen in what is known as the interactive mode. For example, the print() statement
can be used to display text enclosed in inverted commas.
>>> print ("Bayero University.")
Bayero University.
>>>

The print() keyword can also be used to show the result of arithmetic operations. In
this case, however, the arguments are not enclosed in inverted commas. For instance,
the following Python command computes the value of Pi as 22/7.
>>> print (22/7)
3.142857142857143

The interactive mode of Python in Windows can be exited by typing exit() or pressing
CTRL + Z.
>>> exit()
C:\Users\Adam>

1.4 Python Editors and Integrated Development Environments (IDEs)

While the immediate (interactive) programming method demonstrated in the
previous section works, it is not an ideal or efficient method for writing (and saving)
long programs. An editor is a program that allows the user to type and save code.
There are many free editor programs for Python which allow coding in an efficient and
user friendly manner. There are also several Integrated Development Environments
(IDEs) for Python which give additional features like code completion, error
highlighting and debugging for instance. These features allow the user to detect and
correct errors in real time before running the code. Popular Python IDEs include IDLE,
Pycharm, Spyder, Anaconda, Thonny, etc. For the duration of this course, the Thonny
IDE, which is designed for beginners to Python, will be used. Thonny is freely available
and can be downloaded from the Thonny website https://thonny.org. The following
example written in the Thonny IDE calculates the final velocity (v) of an object using
the formular 𝑣 = 𝑢 + 𝑎𝑡.

4
 u = 5 #initial score
a = 10 #acceleration
t = 2 #time in seconds
v = u + a*t
print("The final velocity is")
print (v)

The # symbol indicates comments which are not executed by Python. The Thonny IDE
displays the result in the output window i.e.
The final velocity is
25

1.5 Python Core and Modules

Python is designed so that the basic language is simple to learn without so many
reserved keywords and structures. For example, there are only two looping commands
(for and while) in Python. This prevents the programmer from being overwhelmed
with too many choices. However, this does not limit the capabilities of Python. Python
rather relies on modules which are self-contained programs that define a variety of
functions and data types. These modules have to be imported (using the import
keyword) into the Python environment before they can be employed. However, before
a module can be imported, it must first be installed in Python. The core distribution of
Python contains preinstalled modules for basic mathematical functions, processing
files, accessing the computer’s operating system and the internet. Additional modules
can be installed from the Python website to provide a variety of functions like plotting
data (Matplotlib), computing arrays (numpy), etc. Modules can be installed in the
Thonny IDE by navigating to the Tools > Manage Libraries Menu. The following
example calculates the sine of an angle using the numpy module.
import numpy as np
angle = 90
sin_angle = np.sin(angle)
print (sin_angle)

The numpy module is imported with the alias np in the first line of the code.

1.6 Object Oriented Programming

Python employs an object oriented programming (OOP) design approach which has
become the most widely used programming language design. OOP is a design
philosophy that attempts to mimic the real world in the sense that it consists of objects
which consist of two things: data and functions (methods) that work with that data. In
Python, everything is an object. For example, strings, which are a collection of
characters, are objects in Python. The data of the string object is the actual characters
that make up that string. The methods are properties like lower, replace, and split

5
which are actions that can be performed on the object. One key benefit of OOP is
encapsulation i.e. the ability to define an object that contains data and all the
information a program needs to operate on that data. This allows a program to be
divided into pieces so that each piece internally operates independently of the others.
The pieces interact with each other, but they do not need to know exactly how each
one accomplishes its tasks. In OOP, a template for an object known as a class is used
to contain the code for all the object’s methods. Classes in OOP can be quickly built off
other classes in a concept known as inheritance.

1.7 Python Data Types

The main types of data in computer programming are numeric and string (text) data.
Every programming language including Python, stores and handles these different
data types differently. The main difference in these data types is that mathematical
operations can be carried out on numeric data which is not the case with string data.

1.7.1 Numeric Data

These are positive or negative numbers. They must start with a digit (0-9), a dot
(indicating a decimal point), or a hyphen for negative numbers. They are subdivided
further into:

i. Integers: These are whole numbers i.e. positive and negative numbers without
decimal points.
ii. Floating point numbers: These are referred to as ‘floats’ and are any valid
numbers containing decimal points. For example -1.234, 3.142 and 9.876 are
valid floats. An ‘e’ could also be used to indicate powers of 10 when
representing large scientific numbers. For example, 16 trillion could be
represented as 16e12.
iii. Complex Numbers: Python also supports complex numbers i.e. numbers that
have a real part and an imaginary part. A ‘j’ suffix is used to denote the
imaginary part of a complex number in Python. For example, the complex
number 3 + 4𝑖 is represented in Python as 3 + 4j.

1.7.2 String Data

These are combinations of alphanumeric characters enclosed in single or double
quotation marks. They are used to store things like names, addresses, etc. They are
called strings as they are a string of characters like letters, spaces, punctuation marks
and even numbers. Examples are: “Welcome!”, ‘Bayero University’, “Y / N”,
“CSC1201”. The main difference from numbers is that strings do not have a numeric

6
value and thus cannot be used to perform mathematical operations even though they
may contain numbers.

1.7.3 Boolean Data

There is a third data type in Python known as Boolean data which are neither numeric
nor string data types but represent one of two values, either True or False. They are
named after the mathematician George Boole and used to represent truth values of
logical mathematical operations.

1.8 Variables
A variable is a name representing a string or numeric quantity and refers to a location
in memory set aside to store the quantity. Thus, some amount of memory (the length
of which depends on the type of variable), is assigned to each variable which is
referenced by the variable name. As the name implies, the content stored in a variable
is allowed to vary or change. Variables in Python can either have a local (default) or
global scope. Local variables are visible (retain their values) only within the function in
which they are defined. Global variables on the other hand, have a global scope and
are visible throughout a Python script. This concept will be further discussed when
treating user defined functions. The following rules should be observed when naming
variables in Python:

i. The first character must not be a number.

ii. Python reserved keywords cannot be used as variable names.
iii. The number of characters in the variable name must not exceed 79.
iv. Spaces are not allowed in variable names.
v. Variable names in Python are case sensitive.

There are two stages to create a variable in Python. First, a container with an
identifying label is created in what is called initialization. The second stage involves
putting a value into the container known as assignment. Both the initialization and
assignment stages are performed with a single command in Python, using the ‘= ‘sign.
For example, the following lines of code create an integer, floating point and string
type variables in Python.
age = 18
pi = 3.142
name = “Bayero”

In addition, variables in Python could also be Boolean or contain structured data like
lists, tuples or dictionaries which shall be discussed later.

7
2. Programming in Python
As earlier mentioned, programming in Python can be done in the interactive mode or
written as a block of statements using a text editor. The statements in a Python
program will execute in the order they appear except a deliberate branch statement
is encountered.

2.1 Reserved Python Keywords

In all high-level programming languages, English-like keywords are set aside (reserved)
to perform specific tasks. For a programmer to efficiently solve a problem with a
particular programming language, knowledge of the reserved keywords needed to
perform the task must be had. Each time a reserved keyword occurs in a program, the
computer performs the task specified. Reserved keywords are used according to the
syntax of the programming language and normally begin a sentence of action called a
statement. A statement consists of a reserved word and the data to act on it. Some
Python reserved keywords are listed in Table 2.1 and form the basis of the language.
Reserved keywords may not be used as variable or function names in Python.

Table 2.1. Some Python reserved keywords

abs False int
and for is
as from print
def global return
divmode if True
elif import try
else in type
except input while

2.2 Adding Comments in Python

Comments are messages written within a program to describe what a line or section
of a code does. As such, comments are not executed and have no effect on the
program. Single line comments are added in Python using the # symbol while those
having multiple lines are added with triple quotes. The Thonny Python script below
illustrates this concept.
""" This program computes the product of
two numbers a and b and prints the result"""

a = 4 #fist number
b = 5 #second number
c = a*b #calculate the product and store in c
print(c) #display the result

8
2.3 Assigning Variables from User Input
In many programming situations, it is often necessary to get input data from the user.
This can be achieved in Python using the input() built-in function and then assigning
the data entered from the keyboard to a variable. The input()function treats the data
as a string so any variable used will be assigned as a string type variable. After typing
the input on the keyboard, the Enter key has to be pressed before the function reads
the input from the user. The syntax for the input() function is given below.
var = input(prompt)
Where var is a valid variable name used to store the input and prompt represents a
string to be displayed prompting the user on the value expected. The following
example prompts the user to enter his/her name and stores the result in the variable
name.
>>> name = input('Enter your name: ')
Enter your name: Bayero
>>> print(name)
Bayero
For mathematical operations to be performed on data read with the input()
function, it is necessary to convert the data from a string to numeric. This will be
discussed later.

2.4 Working with Strings

Strings are a collection of characters stored together to represent arbitrary text inside
a program. Since text is a common form of data, string manipulation is a very
important part of programming.

2.4.1 Creating and Printing Strings

In Python, strings exist within single or double quotation marks. To store a string inside
a variable, simply assign a valid variable name to the string. For example, the following
code creates string variables and stores the text enclosed within the double quotes.
my_uni = "Bayero University"
my_faculty = "Faculty of Engineering"

The values stored within the variables can be returned using the print() command as
illustrated earlier.

2.4.2 Concatenating Strings

String concatenation refers to joining strings together from end to end to create a new
string. In Python (just as in many other programming languages), strings can be
concatenated using the + operator.

9
 my_uni = "Bayero University"
my_faculty = "Faculy of Engineering"
print(my_faculty + my_uni)

Faculy of EngineeringBayero University

The output can be refined using with appropriate spacing and punctuation using the
statement;
print (my_faculty +", " + my_uni + ".")
So that the output now becomes;
Faculy of Engineering, Bayero University.

2.4.3 Replicating Strings

A string can be replicated a number of times in Python using the ‘*’ operator. The
following code prints the string ‘CSC1201’ stored in the variable crs_code five times.
>>>crs_code = 'CSC1201 '
>>>print(crs_code *5)

CSC1201 CSC1201 CSC1201 CSC1201 CSC1201

There are spaces between each repetition of the output string because a space is
included as the last character in the string variable.

2.4.4 Indexing and Slicing Strings

Python supports string indexing and slicing. To extract a range of characters from a
string, follow the string with the index of the first character then a colon and then the
index of the end position plus one. The indices and colon should be enclosed in square
brackets ([ ]), remembering that the first character of a string has an index of zero. The
following example slices the my_uni string variable.
>>> my_uni = "Bayero University"
>>> print(my_uni[7:8])
U
>>> print(my_uni[7:10])
Uni

2.4.5 String Functions and Methods

The only core Python function provided for strings is the len() function which returns
the number of characters contained in a string. Using the my_uni variable from the
previous example, the len() function can be used as below.
>>> len(my_uni)
17

10
There are, however, a number of methods provided in the Python core language for
strings. For example the methods str.upper() and str.lower() will return a string
with all the letters in the original string converted to upper and lower case
respectively.
>>> print(my_uni.upper())
BAYERO UNIVERSITY
>>> print(my_uni.lower())
bayero university

There are also several Boolean methods for strings. For instance, the methods
str.isalnum(), str.isalpha() and str.isnumeric() are respectively True if a string
consists of only alphanumeric (no symbols), alphabetic (no symbols) and numeric
characters.
>>> crs_code = 'CSC1201'
>>> print(crs_code.isalnum())
True
>>> print(crs_code.isalpha())
False
>>> print(crs_code.isnumeric())
False

2.5 Working with Numbers

Numbers are very important in programming, especially to the Engineer. This is
because an engineering solution usually involves a mathematical problem. The Python
core can perform basic mathematical operations and comes with a math module for
more scientific functions. To perform more complex tasks, however, external modules
have to be installed and imported to Python. For example, working with arrays
requires the numpy module.

11
2.5.1 Mathematical Operators
The core mathematical operators in Python are listed in Table 2.2

Table 2.2: Mathematical operators in Python

Mathematical Python
Operation Example
Notation symbol
Addition 𝑝 = 𝑚 + 𝑛 + p = m+n
Subtraction 𝑤 = 𝑣– 𝑢 - w = v -u
Multiplication 𝐴 = 𝐿𝐵 * A = L * B
Exponentiation 𝐸 = 𝑀𝐶 2 ** E= M*C**2
Division 𝑑 = 𝑠⁄𝑡 / d = s / t
Integer division 𝑞 // N = q//r
𝑁 = ⁄𝑟

Examples
>>> a = 5
>>> b = 4
>>> print(a + b)
9
>>> print(a * b)
20
>>> print(a**b)
625
>>> print(a / b)
1.25
>>> print(a // )
1
>>> print(a % b)
1

Python applies the operators in a precise sequence determined by the rules of

operator precedence similar to the BODMAS rule of algebra:

i. Parenthesis: Operators in expressions contained within a pair of parenthesis are

evaluated first i.e. they have the highest level of precedence.
ii. Exponentiation is next in the order of precedence after parenthesis.
iii. Division and multiplication have the same level of precedence and are next to
be evaluated.
iv. Addition and Subtraction are next to be evaluated and have the same level of
precedence.
v. The equality operator has the lowest level of precedence and is the last to be
applied.

12
Examples:

1. The following example calculates the mean of five values; a, b, c, d and e

𝑎+𝑏+𝑐+𝑑+𝑒
according to the algebraic expression: 𝑚 =
5
>>> m = (a + b + c + d + e) / 5
2. The following is the equation of a straight line expressed in the gradient
intercept form: 𝑦 = 𝑚𝑥 + 𝑐
>>> y = m * x + c
3. The expression for velocity in the equation of motion 𝑣 = √𝑢2 + 2𝑎𝑥 can be
stated in Python as.
>>> v = ((u**2 + 2*a*x))**0.5
Note that the above equation could have been implemented with a Python
square root function but this requires importation of the math module.
4. More Examples are given in the table below:

2.5.2 Relational Operators

Relational operators are used to compare two values in Python and return either a
True or False (Boolean) value. The symbols used for comparison are also given in Table
2.3.

Table 2.3. Relational Operators

Mathematical Python
Operator Example
Notation symbol
Equal to 𝑎=𝑏 == a==b
Less than 𝑎 < 𝑏 < a < b
Less than or equal to 𝑎≤𝑏 <= a <= b
Greater than 𝑎 > 𝑏 > a > b
Greater than or equal to 𝑎≥𝑏 >= a >= b
Not equal to 𝑎 ≠ 𝑏 != a != b

Examples

1. The following examples compares two variables a and b assigned to values 5

and 6 respectively.
>>> a = 5
>>> b = 6
>>> print(a>b)
False
>>> print(a < b)

13
 True
>>> print(a==b)
False
>>> print(a != b)
True
2. The relational operators can also be used to compare the alphabetical order of
string data.
>>> print ('A' < 'B')
True
>>> print('A' == 'a')
False

2.5.3 Mathematical Functions

There are very few mathematical functions that a part of the Python core. These
commands perform the basic mathematical functions. For instance, the abs() function
returns the absolute value of a number.
>>> a = -5
>>> print(abs(a))
5

Other Python core mathematical functions include round() which rounds an argument
to the nearest integer, int() which extracts the integer part of numeric data or
converts integer numbers in a string to numeric data. Another built-in Python
mathematical function is divmod(). This function takes two arguments (a dividend
and a divisor) and returns the quotient and remainder after division.
>>> a = 19
>>> b = 5
>>> c = divmod(a,b)
>>> print(c)
(3, 4)

To perform more complex mathematical functions, a module containing the

mathematical functions has to be imported into Python. As part of its standard library,
Python comes with a math module with a range of functions including number
representation, trigonometry, logarithms, etc. There are, however, external modules
like numpy and scipy with numerous mathematical functions. Table 2.4 lists some
commonly used functions in the Python math module.

14
 Table 2.4 Python math module functions

Math Function Description Python math module example

sin(𝑥) Calculates the sine of 𝑥 >>> math.sin(30)
math.sin(x) -0.9880316240928618
in radians
cos(𝑥) Calculates the cosine of >>> math.cos(60*3.142/180)
math.cos(x) 0.4998824046113711
𝑥 in radians
tan−1 (𝑥) Calculates the >>>math.atan(3.142)
math.atan(x) arctangent of 𝑥 1.2626647270019071
𝑒𝑥 Calculates the >>>math.exp(1)
math.exp(x) exponent of 𝑥 2.718281828459045
ln(𝑥) Calculates the natural >>>math.log(2.718281828459045)
math.log(x) 1.0
logarithm of 𝑥
log 𝑥 Calculates the >>> math.log10(100)
math.log10(x) logarithm of 𝑥 to base 2.0
10
√𝑥 Calculates the square >>> math.sqrt(25)
math.sqrt(x)
root of 𝑥 5.0

Note:
 The math module is assumed to be imported without any alias.
 For all trigonometric functions, 𝑥 is expressed in radians.
 For the result to be displayed, the print() statement should precede the
function in the example column.
 The math module functions do not operate with complex numbers. For complex
number functions, the cmath module needs to be imported.

Exercise: Express the following mathematical functions in Python

i. (𝑥 + 𝑦 )2
ii. 𝑎/𝑏 + 𝑐/𝑑
iii. (𝑚 + 𝑛)𝑘−1
iv. (4𝑡)1/4
−𝑏± √𝑏2 −4𝑎𝑐
v.
2𝑎
𝑠 4 √(𝑥+𝑦 𝑛 )𝑞
vi.
𝑗(𝑓−𝑡𝑧)

2.6 Conversion between string and numerical data

Since Python handles string and numeric data types differently, it often becomes
necessary to convert one to the other. A typical example is when the input() function
is used to get data from the user which is to be used for a numerical computation.
Since the input() function treats data as strings, it is necessary to convert the strings

15
to integers or floats before carrying out the mathematical operation. The following
Python script demonstrates this by calculating the square of a number read from the
user with the input() function.
N = input("Enter a number: ") #get the number from the user
n = int(N) #convert the string to an integer
n_sq = n * n #calculate the square
sqr = str(n_sq) #convert the result to a string
msg = "The square is " + sqr + "." #output message including the result
print(msg) #display the result

Enter a number: 19
The square is 361.

Notes:
 The int() function converts string or floating point numbers to integers.
 The str() function is used to convert from numerical data to strings. This is
usually done when a string operation like concatenation is to be performed on
numerical data.
 Since variables in Python are case sensitive, N and n are two different variables.
N in the above example is a string while n is a numeric (integer) variable.
 The type() function is used in Python to return the type (class) of data assigned
to a variable. In the case of the previous example, the following results are
obtained with the type() function.
>>> type(N)
<class 'str'>
>>> type(n)
<class 'int'>
>>>

3. Python Data Structures

Data structures provide a means of sorting and organising data efficiently. This allows
a programmer to easily access and performs operations on the data. Python has a host
of in-built data structures the most commonly used of which are Lists, Tuples and
Dictionaries. These data structures handle collections of data and easy data
management.

3.1 Lists
Lists provide a general tool for storing a collection of objects indexed by a number in
Python. Simply put, a List is any list of data items, separated by commas, inside square
brackets. The items may be numbers, strings or even other lists. Lists are mutable,
meaning items contained in a list can be changed.

16
3.1.1 Creating Lists
A list can be assigned using square brackets and commas as demonstrated below.
>>> courses = ['CSC1201', 'MTH1301', 'CHM1251','PHY1210', 'GSP1201']
>>> scores = [70, 38, 62, 55, 80]

The courses and scores lists above each contain five elements indexed from 0 – 4. Note
that the elements of the courses lists are enclosed in inverted commas. The print()
statement can be used to display elements in the list.
>>> print(courses)
['CSC1201', 'MTH1301', 'CHM1251', 'PHY1210', 'GSP1201']
>>> print(courses[0])
CSC1201
>>> print(scores[4])
80

Python returns an ‘out of range’ error if an attempt is made to access an item not in a
list. For example;
>>> print(scores[5])
Traceback (most recent call last):
File "<pyshell>", line 1, in <module>
IndexError: list index out of range

3.1.2 Similarities with Strings

There are a number of similarities when working with lists and strings in Python. For
instance, the len() function can be used to return the number of elements in a list.
>>> len(courses)
5

The methods for concatenating, indexing and slicing of strings also apply to lists.
>>> new_list = courses + scores
>>> print (new_list)
['CSC1201', 'MTH1301', 'CHM1251', 'PHY1210', 'GSP1201', 70, 38, 62, 55, 80]
>>> len(new_list)
10
>>> print(new_list[5:10])
[70, 38, 62, 55, 80]

17
3.1.3 The in Operator

The in operator provides a simple way of checking if an item is contained in a list. The
operator returns a Boolean result which is True if an item is contained in the list and
False otherwise.
>>> courses = ['CSC1201', 'MTH1301', 'CHM1251','PHY1210', 'GSP1201']
>>> 'CSC1201' in courses
True
>>> 'MTH' in courses
False

3.1.4 List Functions and Methods

Besides the len() function, there are several in-built Python list functions. A few are
listed below.
sum() - returns the sum of the items in the list
min() - returns the minimum of the items in the list
max() - returns the maximum of the items in the list

The example below calculates the mean of a numerical list using the sum() and len()
functions.
>>> scores = [70, 38, 62, 55, 80]
>>> mean = sum(scores)/len(scores)
>>> print(mean)
61.0

Many list operations are performed using methods instead of functions. Since lists are
mutable objects, many methods operating on lists will result in a change to the list.
The following are some common methods for lists.
list.append(x) - adds x to the end of the list
list.sort() - sorts the list
list.count(x) - returns the number of times x occurs in the list
list.index(x) - returns the location of the first occurrence of x in the list
list.remove(x) - removes first occurrence of x from the list in the list

Example
>>> courses.append('STA1311')
>>> print(courses)
['CSC1201', 'MTH1301', 'CHM1251', 'PHY1210', 'GSP1201', 'STA1311']

The value returned from a list method should not be assigned to any object as this will
not work in Python.

18
 >>> courses = ['CSC1201', 'MTH1301', 'CHM1251','PHY1210', 'GSP1201']
>>> courses.index('CSC1201')
0
>>> sorted_list = courses.sort()
>>> print(sorted_list)
None
>>> print(courses)
['CHM1251', 'CSC1201', 'GSP1201', 'MTH1301', 'PHY1210']
>>> courses.index('CSC1201')
1

3.2 Tuples

Tuples are quite similar with lists, except for one important difference. While lists are
mutable i.e. their contents can be modified, the contents of tuples cannot be changed.
Thus once a tuple is created its elements remain constant. This allows Python to
handle tuples more efficiently than lists.

Tuples are created in a similar manner with lists, only that in this case, parenthesis
(which are optional) are used instead of square brackets in the case of lists. Since
tuples are immutable, they do not support the list methods that result in a change in
the list like sort() for example. They however support functions and methods that do
not result in changes like len(), count() and index.

>>> ages = (19, 15, 16, 17, 17, 16, 19, 18, 16, 20)
>>>print(len(ages))
10
>>> ages.sort()
Traceback (most recent call last):
File "<pyshell>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'sort'

>>>print(ages.count(19))
2

The tuple() keyword can be used to convert an object into a tuple. The following
example illustrates this by converting the courses list into a tuple. Notice that the
result, which is now a tuple, is enclosed in parenthesis instead of square brackets.

>>> courses = ['CSC1201', 'MTH1301', 'CHM1251','PHY1210', 'GSP1201']

>>> ct = tuple(courses)
>>> print(ct)
('CSC1201', 'MTH1301', 'CHM1251', 'PHY1210', 'GSP1201')

19
3.3 Dictionaries

Dictionaries, also referred to as associative arrays, are similar to lists in that they can
contain mutable objects. However, instead of being indexed with integers, they are
indexed with immutable objects referred to as keys. Dictionaries are created by
specifying keys and their corresponding values separated by colons and enclosed
within curly braces ({}). An example of a dictionary could be a student’s courses and
their associated exam scores.
>>>result = {'CSC1201':70, 'MTH1301':35, 'CHM1251':50, 'PHY1210':66,
'GSP1201':84}
>>> print(result)
{'CSC1201': 70, 'MTH1301': 35, 'CHM1251': 50, 'PHY1210': 66, 'GSP1201': 84}
>>> print(result['CSC1201'])
70

The len() function returns the number of elements i.e. the number of key/value pairs
in a dictionary.
>>> len(result)
5

The contents of a dictionary can be modified with the following syntax.

>>> result['CSC1201'] = 90
>>> print(result)
{'CSC1201': 90, 'MTH1301': 35, 'CHM1251': 50, 'PHY1210': 66, 'GSP1201': 84}

An individual item can be removed from a dictionary using the del command.
>>> result = {'CSC1201':70, 'MTH1301':35, 'CHM1251':50, 'PHY1210':66,
'GSP1201':84}
>>> del result['GSP1201']
>>> print (result)
{'CSC1201': 70, 'MTH1301': 35, 'CHM1251': 50, 'PHY1210': 66}

There a several other functions and methods with dictionaries in Python but that is
beyond the scope of this course.

4. Conditional Statements
Conditional execution is performed in Python using the if statement along with
optional elif (else if) and else statements which together form an if block. Idents are
used in Python to indicate the start and end of if blocks. This is quite different from
other languages like BASIC (which uses End statements) and C or Java which use curly
brackets to indicate the end of program blocks. The syntax for the if block in Python is
given below.
20
 if expression :
statement(s)
elif expression:
statement(s)
elif expression:
statement(s)
...
else:
statements

i. if expression: This is a condition given usually with a comparison operator.

Python evaluates the given condition and executes the statement following
if when the given condition is True.
ii. elif expression: When the if expression is False, Python tests any successive
elif expressions in the if block and executes any of which is found to have a
True condition.
iii. else expression: Python executes the statements following else when none
of the prior conditions was True.
The following Thonny Python code saved as Run exam_score.py checks if a student has
passed an exam based on pass mark of 40.
scores = [70, 40, 35, 55, 60]
scr = scores[1]
if (scr > 40):
print(scr)
print("Passed")

>>> %Run exam_score.py

Passed

There is actually an error (bug) in the above code as a score of 40 will not be considered
a pass since the associated condition will be False. A correct way to state the condition
is given below.

scores = [70, 40, 35, 55, 60]

scr = scores[1]
if (scr >= 40):
print(scr)
print("Passed")

>>> %Run exam_score.py

40
Passed

21
The program above is modified with an else statement to indicate if a student has
failed.
1 scores = [70, 40, 35, 55, 60]
2 scr = scores[2]
3 if (scr >= 40):
4 print(scr)
5 print("Passed")
6 else:
7 print(scr)
8 print("Failed")

>>> %Run exam_score.py

35
Failed

A number of elif conditions can be used to modify the program so that the course
grade is displayed instead of a simple binary result of either a pass or fail.
scores = [70, 40, 35, 55, 60]
scr = scores[3]
print(scr)
if (scr >= 70):
print("A")
elif (scr >= 60):
print("B")
elif (scr >= 50):
print("C")
elif (scr >= 45):
print("D")
elif (scr >= 40):
print("D")
else:
print("F")

>>> %Run exam_score.py

55
C

Note that once a True expression associated with an if or elif statement is

encountered, Python carries out the statements associated with that if or elif, and
does not bother to check any other expressions. This makes execution of the code
more efficient as processor cycles are not wasted in checking the other statements.

5. Program Looping
One of the most powerful and useful things about computers is that they can carry out
repetitive tasks quickly and correctly. This is achieved in programming by running a

22
block of code repetitively in what is known as program looping. The two main methods
of looping in Python make use of for and while loops.

5.1 For Loops

The for loop allows iteration for a fixed number of times over a sequence. The
sequence can be a range of numbers, string, list or tuple. The syntax for the Python
for loop is given below where var represents a dummy variable defined within the
loop which points (indexes) to a value contained in the sequence. Statements
represent the Python commands to be repeated.
for var in sequence:
statements

The following example iterates through a string and prints the value of each character
by using c as the looping variable.
name ='Bayero'
for c in name:
print(c)
B
a
y
e
r
o

This approach also works with lists in Python. For example;

courses = ['CSC1201', 'MTH1301', 'CHM1251','PHY1210', 'GSP1201']
for i in courses:
print(i)
CSC1201
MTH1301
CHM1251
PHY1210
GSP1201

5.2 For Loops with the Range Function

The range function can be used in a for loop to generate a sequence of integer values
to be iterated over. Each value can be referred to within the loop to perform a desired
task. The range function takes one, two or three arguments. When only one argument
is used, a sequence of integers from 0 to 𝑛 − 1 is returned with 𝑛 representing the
value of the argument. The following program returns the squares of all integers
between 0 and 4.

for i in range(5):

23
 print(i, i*i)
>>>
0 0
1 1
2 4
3 9
4 16

When two arguments 𝑛 and 𝑚 are used, a sequence between 𝑛 and 𝑚 − 1 is returned
with 𝑛 and 𝑚 being the upper and lower limits of the sequence respectively. The
following Python script computes the squares and cubes of integers from 5 – 10.
Notice that the upper limit is set at 11.
for i in range(5, 11):
print(i, i**2, i**3)

5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>>

In the case of three arguments with the range function, the third argument indicates
the step increments instead of the default value of 1. The following example lists odd
numbers from 0 to 9 by using a step value of 2.
for i in range(1, 10,2):
print(i)
1
3
5
7
9
>>>

5.3 While loops

In high-level programming, while loops provide a method of repetition based on a
given condition. All statements within the loop are repeated so long as the given
condition is True. While loops are used when the number of required repetitions is not
known a priori. The syntax for the while loop in Python is given below.

while condition:
statements

24
The following script uses a while loop and random number module to simulate rolling
a single die with the objective of getting a six (6).
import random #import the random generator module
count = 0
d = 1
while (d != 6):
d = random.randint(1,6) #generate random integer from 1-6
count = count + 1 #count the number of rolls
print(count, d)
print() #print an empty line
print (count, 'roll(s) where required.')

Notes:

 The random number generator is first imported using the import random
statement.
 The program loops around the statements indented in the while loop so long
as the variable d, representing the value gotten from the die is NOT equal to six.
 The count variable is incremented by one during every loop so it stores the
number of rolls.
 Once a six is gotten, the while loop is exited and the total number of rolls
(stored in the count variable) is printed.

At times, it is necessary to implement an infinite loop. This might arise in the case of
physical programming where a computer (or microcontroller) is used to control a
device like a moving message display, for example. When controlling such hardware,
the program needs to run continuously to repeat the message on the display. This
requires an infinite loop which, can be achieved with a while True or while 1
statement in Python. The following Python script will continue to print integer values
until the ctrl+c keys (break) are pressed.

x = 0
while True:
x = x + 1
print(x)

6. User-defined Python functions

Functions form an important part of any programming language. They allow a
programmer to reuse code already written without modification. Another advantage
of functions is that they allow a program to be logically sectioned into different
subroutines in what is known as modular programming. This approach allows for
25
easier debugging and maintenance of programs. A number of built-in Python functions
like print(), len(), int(), etc. have already been introduced. When developing a
program, however, it often becomes necessary to develop user-defined functions.

6.1 Defining functions

Functions in Python are defined using the def statement followed by the function
name and a colon. The statements that form the function block are then indented
below the def statement. The following Python script (def_example.py) defines a
function named welcome() which prints “WELCOME!” whenever the function is
called.

def welcome():
print('WELCOME!')
welcome()
>>> %Run def_example.py
WELCOME!

6.2 Passing arguments

Arguments (values) can be passed to functions to work on. This is done by entering a
parameter (variable) name within the parenthesis when defining the function. The
following example reads an input number from the keyboard and returns its square
using a user-defined function named square().

def square(n):
n = n * n
print(n)
N = input("Enter a number: ")
n = int(N)
square(n)
print(n)

Enter a number: 12
144
12

Notes:
 The parameter n is passed to the square() function after first converting it to
an integer since the input() function assigns variables as strings.
 Variables defined within functions are local in scope i.e. their values are defined
only within the function.
 This is why the last statement (print(n)) results in 12 which is the value of n
outside the function.

26
  Variables can be made to retain their values outside a function by defining them
as global variables using the global keyword.

6.3 Returning values

The return statement can be used to exit functions and return results to the caller.
The following example used the math module to calculate and return the sine and
cosine of an angle (A) defined in degrees. Notice that printing of the result is done
outside the function.

import math as m #import the math module with alias m

def sin_cos(A): #define the function
A = A * m.pi/180 #convert from degrees to radians
sin_A = m.sin(A) #compute the sine
cos_A = m.cos(A) #compute the cosine
return sin_A, cos_A #return the results
A = 30
print(A)
result = sin_cos(A)
print(result)
A = 60
print(A)
result = sin_cos(A)
print(result)
>>>
30
(0.49999999999999994, 0.8660254037844387)
60
(0.8660254037844386, 0.5000000000000001)

7. Exception Handling
An exception in programming refers to an error that occurs not as a result of
programming fault but rather, as a result of other factors that can prevent the program
from running properly. For example, in a program that assigns the values of two
variables say a and b from the user and computes a / b, an exception will occur when
the value of the denominator (b) is 0 since the result is undefined. In addition, an
exception will also occur if the user enters alphabets instead of numbers. These
exceptions will cause the program to stop and display an error message. The following
Python script (saved as exeption_example.py) illustrates this point.
A = input('Enter a: ')
B = input('Enter b: ')
a = int(A)
c = (a/b)

27
 print(c)

Enter a: 5
Enter b: 0
Traceback (most recent call last):
File
"C:\Bayero_university\Mechatronics_Dept\CSC1201\CSC1201_2021\exception_e
xample.py", line 5, in <module>
c = (a/b)
ZeroDivisionError: division by zero

Python halts the program, displays the name of the file, the line in which the error
occurred and the type of exception i.e. a division by zero in this case. Exception
handling allows the error to be trapped and prevents the program from halting
thereby allowing it to recover from the error. In Python, the try/except keywords are
used to handle exceptions using the syntax:
try:
code to try out
except Exception:
code to execute in the case of an exception

The division by zero error in the previous example can be handled by the following
modification of the Python script.

A = input('Enter a: ')
B = input('Enter b: ')
a = int(A)
b = int(B)
try:
c = (a/b)
print(c)
except Exception:
print('Sorry division cannot be done on the values entered.')

8. Complete Python Programs

Using some of the reserved keywords learnt so far, complete programs that perform
specific tasks will now be written in the Python language using the Thonny IDE. It
should be noted that there are several ways to solve a programming problem and that
the code used is a matter of choice (design), experience and the programming
language.

Example 1:

In the triangle below, A = 105o, B = 35o and a = 17 cm.

28
 A

c
b

C a B

i. Given that the sum of angles in a triangle is 180o, write a Python program to
calculate the size of angle C.
ii. Using the result of (i) above, modify the program to calculate the length of
side b by applying the sine rule.
iii. Display the result of (ii) correct to two decimal places.

Solution
import math as m
AA = 105 #angle A
AB = 35 #angle C
SA = 17 #side a
AC = 180 - (AA + AB) #calculate angle C
print('Angle C =', AC) #display angle C
#calculate side B using sine rule
SB = SA * m.sin((AB * m.pi / 180)) / m.sin(AA *m.pi /180)
SB = round(SB,2) #round to 2 decimal places
print('Side B = ', SB) #display the result

Notes:
 The math module is imported (with the alias m) to perform trigonometric
functions.
 The trigonometric functions in the math module operate in radians, hence
angles expressed in degrees have first to be converted to radians.
 The round() function rounds the result to 2 decimal places

29
Example 2:

Write a program that calculates the roots of a quadratic equation 𝑎𝑥 2 + 𝑏𝑥 + 𝑐 = 0

using the formulae

−𝑏 + √𝑏2 − 4𝑎𝑐 −𝑏 − √𝑏2 − 4𝑎𝑐

𝑥1 𝑎𝑛𝑑 𝑥2
2𝑎 2𝑎
The program should allow the user to enter the values of the coefficients a, b and c.
The program should detect complex roots and inform the user when the roots are
complex.

Solution

A pseudocode of the required task is given below:

I. Get the values of a, b and c from the user.

II. Calculate the discriminant as 𝐷 = 𝑏2 − 4𝑎𝑐.
III. If 𝐷 < 0, state that the roots are complex and calculate 𝑥1 and 𝑥2 .
IV. If 𝐷 > 0, state that the roots are real and calculate 𝑥1 and 𝑥2 .
V. Display the values of 𝑥1 and 𝑥2 .
VI. End the program.

Python Code:

A = input('Enter a: ')
B = input('Enter b: ')
C = input('Enter c: ')
a = int(A)
b = int(B)
c = int(C)
D = b**2 - 4*a*c #calculate the discriminant
if (D > 0): #check for real or complex roots.
print('The roots are real.')
else:
print('The roots are complex.')
x1 = (-b + D**0.5) / 2*a #calculate x1
x2 = (-b - D**0.5) / 2*a # and x2
print('x1 = ', x1, ',','x2 = ',x2)

Example 3:
Write a program to check if a number entered by the user is a prime number. The
program should display the number entered and state whether it is prime or not.

30
Solution

The program will use an algorithm based on the method of trial division to verify if a
given number N is prime or not. It consists of testing whether N is a multiple of any
integer between 2 and √𝑁.

Pseudocode

i. Get the integer number N, from the user.

ii. Assume N is prime in the beginning until proven otherwise.
iii. Count from 2 to √𝑁.
iv. Check if the current count value is a factor of N.
v. If (iv) above is TRUE, then N is not a prime number.
vi. Increment the count by one and repeat step (iv) until √𝑁 is reached.
vii. Exclude 0 and 1 as prime numbers in the case the user enters 0 or 1.
viii. Display the result.

Python Code:

import math as m
N = input('Enter an integer number: ')
n = int(N)
prime = True #assume number is prime
root_n = int(m.sqrt(n)) #calculate integer root of n
for p in range(2, root_n): #check for a factor
print(p, n/p, int(n/p)) # between n and root n.
if (n/p == int(n/p)): #n is not prime if a
prime = False # factor exists.
break #exit the loop if a factor is
found.
if (n < 2): prime = False #exclude 0 and 1
print() #print empty line
if (prime == True): #check and
print(n, 'is a prime number!') # display the
else: # appropriate
print(n, 'is NOT a prime number.') # result.

Notes:

 The program first assumes all numbers are prime except proven otherwise by
assigning a Boolean variable prime to True.
 The int() function returns (extracts) the integer part of a number.
 The current count of the for loop is stored in the variable p.

31
  The if block within the for loop compares the result of n/p (a float) with its
integer part i.e. int(n/p). These will be equal if and only if p is a factor of n,
meaning that n is NOT prime.
 The break statement exits the loop once a factor of n is found.
 The second if statement (written in a single line) excludes the numbers 0 and
1 which by definition are not prime numbers.

Example 4
Write a Python program with user defined functions to compute the mean, variance
and standard deviation of the scores of ten (10) students in an examination.

Solution
The program will use a list array variable Score having an index of 0 to 9 to store the
students’ scores. The mean U will be calculated by dividing the sum of the scores by
the number of elements while the variance and S.D. will be computed respectfully as;

∑(𝑆 − 𝑈)2
𝑉𝑎𝑟 = and 𝑆𝐷 = √𝑉𝑎𝑟
𝑛
Pseudocode

i. Create a list with 10 elements representing the scores

ii. Create a function to calculate the mean.
iii. Create a function to calculate the variance by calculating the deviation,
deviation squared.
iv. Call the function to calculate the mean.
v. Call the function to calculate the variance.
vi. Compute the standard deviation as the square root of the variance.
vii. Display the results.

Python script
import math as m
def calc_mean(scores):
n = len(scores)
s = sum(scores)
mean = s/n
return mean
def calc_var(scores, mean):
n = len(scores)
deviations = [(x - mean) ** 2 for x in scores] # Square deviations
variance = sum(deviations) / n # Variance
return variance

32
 scores = [90, 35, 55, 50, 60, 48, 65, 70, 38, 63]
mean = calc_mean(scores)
print('Mean:', mean)
variance = calc_var(scores, mean)
print('Variance:', variance)
sd = round(m.sqrt(variance),2)
print('Standard deviation:', sd)

Notes:

 The calc_mean function calculates the mean of the scores passed to it by the
scores list parameter.
 The calc_var function uses two parameters i.e. the scores parameter and the
mean returned from the calc_mean function
 The standard deviation is calculated outside the function simply as the square
root of the variance.

33