Learn Python Programming – Everything You Need to Know (Free Book)

Fatos Morina

October 27, 2022

Python is one of the most popular programming languages in the world today. It was created in
1991 by Guido van Rossum.

According to van Rossum, Python is a:

“high-level programming language, and its core design philosophy is all about code readability
and a syntax which allows programmers to express concepts in a few lines of code.”
Benefits of Learning Python
Python is one of the easiest languages that you can learn and work with. You can use it for
software development, server side of web development, machine learning, mathematics, and
any type of scripting that you can think of.

The good thing about Python is that it is widely used and accepted by many companies and
academic institutions. This makes it a really good choice, especially if you are just starting your
coding journey.

Python also has a large community of developers that use it and are willing to help you if you
get stuck or have questions. This community has already published many open source libraries
that you can start using. They also actively keep improving them.

Python's syntax is quite similar to that of the English language, which makes it easier for you to
understand and use quite intuitively.

Python runs on an interpreter system, meaning that you don't have to wait for a compiler to
compile the code and then execute it. You can instead build prototypes quickly.

It also works on different platforms, such as Windows, Linux, Mac, Rapsberry Pi, and so on.

So you see – it's a great programming language, whether you're just starting out or you're
looking to add another useful tool to your kit.

Here's what we'll cover in this book:

Table of Contents
Python Basics
Operators in Python
Data types in Python
Tuples in Python
Dictionaries in Python
Sets in Python
Type Conversions in Python
Control Flow in Python
Functions in Python
Object Oriented Programming in Python
Importing in Python
How to Handle Exceptions in Python
User Input in Python
Get the PDF version of the book
Python Basics
Indentation in Python
Compared to other languages, Python places special importance on indentation.

In other programming languages, white spaces and indentations are only used to make the
code more readable and prettier. But in Python, they represent a sub-block of code.

The following code is not going to work, since the second line is not properly intended:

if 100 > 10:

print("100 is greater than 10")
For it to work properly, the indentation should look like the following:

if 100 > 10:

print("100 is greater than 10")
This may look hard to understand, but you can use a code editor that highlights such syntax
errors quite vividly. Moreover, the more Python code you write, the easier it gets for you to
consider such indentations as second nature.

Python uses four spaces for proper indentation by default.

Comments in Python
We use comments to specify parts of the program that should be simply ignored and not
executed by the Python interpreter. This means that everything written inside a comment is not
taken into consideration at all and you can write in any language that you want, including your
own native language.

In Python, you start a comment with the symbol # in front of the line:

# This is a comment in Python

You can also include more extended comments in multiple lines using triple quotes:

"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.
In the previous line we have a space, because it's allowed to have spaces inside comments.

Let's end this comment right here.

"""
print() method in Python
We are going to use the method print() since it helps us see results in the console.

You do not need to know how it works behind the scenes or even know what a method is right
now. Just think of it as a way for us to display results from our code in the console.

Operators in Python
Arithmetic operators in Python
Even though you can just pull out your phone from your pocket and do some calculations, you
should also get used to implementing some arithmetic operators in Python.

When we want to add two numbers, we use the plus sign, just like in math:

print(50 + 4) # 54
Similarly, for subtraction, we use the minus sign:

print(50 - 4) # 46
For multiplication, we use the star or asterisk:

print(50 * 4) # 200
When doing divisions, we use the forward slash:

print(50 / 4) # 12.5
print(8 / 4) # 2.0
This often results in float numbers (numbers with a decimal point, that is, not a round number). If
we want to only get integer numbers when doing division, that's called floor division. In that
case, we should use the double forward slashes like this:

print(50 // 4) # 12
print(8 / 4) # 2
We can also find the remainder of a number divided by another number using the percent sign
%:

print(50 % 4) # 2
This operation can be helpful especially in cases when we want to check whether a number is
odd or even. A number is odd if, when divided by 2, the remainder is 1. Otherwise, it is even.

Here is an illustration:
print(50 % 4) # 2
# Since the remainder is 2, this number is even

print(51 % 4) # 1
#Since the remainder is 1, this number is odd
When we want to raise a number to a specific power, we use the double asterisk:

print(2 ** 3) # 8
# This is a short way of writing 2 * 2 * 2

print(5 ** 4) # 625
# This is a short way of writing 5 * 5 * 5 * 5
Assignment operators in Python
You use these operators to assign values to variables.

When we declare a variable, we use the equal sign:

name = "Fatos"
age = 28
We can also declare multiple variables in the same line:

name, age, location = "Fatos", 28, "Europe"

We can use this as a way to also swap values between variables. For example, let's say that we
have two variables a and b and we want to switch their values.

One logical way to do that would be to introduce a third variable that serves as a temporary
variable:

a, b = 1, 2

print(a) # 1
print(b) # 2

c=a
a=b
b=c

print(a) # 2
print(b) # 1
We can do that in a single line in the following way:

a, b = 1, 2

print(a) # 1
print(b) # 2

b, a = a, b

print(a) # 2
print(b) # 1
We can also merge the assignment operators with arithmetic operators.

Let's see how we can do that for addition first.

Let's assume that we have the following variables:

total_sum = 20

current_sum = 10
Now we want to add the value of the current_sum to total_sum. To do that, we should write the
following:

total_sum = total_sum + current_sum

print(total_sum) # 30
This may not look accurate, since the right hand side is not equal to the left hand side. However,
in this case we are simply doing an assignment and not a comparison of both sides of the
equation.

To do this quickly, we can use the following form:

total_sum += current_sum

print(total_sum) # 30
This is equivalent to the previous statement.

Similarly, we can do the same with other arithmetic operators:

Subtraction:

result = 3
number = 4

result -= number # This is equal to result = result - number

print(result) # -1
Multiplication:
product = 3
number = 4

product *= number # This is equal to product = product * number

print(product) # 12
Division:

result = 8
number = 4

result *= number # This is equal to result = result / number

print(result) # 2.0
Modulo operator:

result = 8
number = 4

result %= number # This is equal to result = result % number

print(result) # 0
Power operator:

result = 2
number = 4

result **= number # This is equal to result = result ** number

print(result) # 16
Comparison operators in Python
You likely learned how to do basic comparisons of numbers in school, such as checking whether
a specific number is larger than another number, or whether they are equal.

We can use almost the same operators in Python to do such comparisons.

Let's see them in action.

Equality operators
You can check whether two numbers are equal using the == operator:

print(2 == 3) # False
The last expression evaluates to False since 2 is not equal to 3.
There is another operator that you can use to check whether 2 numbers are not equal. This is
an operator that you may have not have seen in your math classes written exactly in this way.
This is the operator !=.

Let's do a comparison of whether 2 is not equal to 3:

print(2 != 3) # True
This expression evaluates to True since 2 is indeed not equal to 3.

Inequality operators
Now here we are going to see how to check whether a number is larger than another number:

print(2 > 3) # False

This is something that you should already know from your math classes.

When trying to check whether a number is greater than or equal to another number, we need to
use this operator >=:

print(2 >= 3) # False

Similarly, to check whether a number is less than or equal to another, we have:

print(2 < 3) # True

print(2 <= 3) # True
Logical operators
In high school math, you may have learned about logical operators such as and and or.

Briefly speaking, for an expression to evaluate to True when using and, both statements should
be true. In Python, we implement it using and:

print(5 > 0 and 3 < 5) # True

This example is going to evaluate to True since 5 is greater than 0, which evaluates to True, and
3 is less than 5, which also evaluates to True. From this we get True and True, which evaluates
to True.

Let's take an example when an and expression is going to evaluate to False:

print(2 > 5 and 0 > -1) # False

2 is not greater than 5, so the statement in the left hand side is going to evaluate to False. No
matter what's on the right hand side, we are going to get the whole expression equal to False,
since False and any other value (like True) are going to result in False.

When you have statements where at least one of them should evaluate to True, then we should
use the or operator:
print(2 > 5 or 0 > -1) # True
This is going to evaluate to True since the statement in the right hand side evaluates to True –
so at least one of them is true.

If both statements are False, then or results in False in the end:

print(2 < 0 or 0 > 1) # False

This is False since 0 is not greater than 2 and also 0 is not greater than 1. So the whole
expression is False.

Data Types in Python

Variables in Python
You can think about variables as the building blocks of any computer program that you might
write.

You can use variables to store values and then reuse them as many times as you want. The
moment you want to change a value, you can just change it in one place and that new value
that you just changed is going to get reflected everywhere else where that variable is used.

Every variable in Python is an object.

A variable is created in the moment it is initialized with a value.

Here are the general rules for Python variables:

A variable name must start with a letter or the underscore character. It cannot start with a
number.
A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ ).
Variable names are case-sensitive, meaning that height, Height, and HEIGHT are all different
variables.
Let's define our first variable:

age = 28
In this example, we are initializing a variable with the name age and assigning the value 28 to it.

We can define other variables along with it, like:

age = 28
salary = 10000
We can use pretty much any name that we want, but it is a better practice to use names that
both you and other any colleagues who work with you can understand.

We have other variable types in Python, such as float numbers, strings, and boolean values. We
can even create our own custom types.
Let's see an example of a variable that holds a float number:

height = 3.5
As you can see, this initialization is quite similar to the ones when we had integer numbers.
Here we are only changing the value on the right. The Python interpreter is smart enough to
know that we are dealing with another type of variable, namely a float type of variable.

Let's see an example of a string:

reader = "Fatos"
We put string values either in double quotes or single quotes to specify the value that we want
to store in string variables.

When we want to store boolean values, we need to use reserved words, namely, True and
False.

text_visibile = False
We can also have a boolean value stored when we have expressions that result with a boolean
value, for example, when we compare a number with another number, such as:

is_greater = 5 > 6
This variable is going to get initialized with the value False since 5 is lower than 6.

Numbers in Python
We have three numeric types in Python: integers, floats, and complex numbers.

Integers
Integers represent whole numbers that can be both positive and negative and do not contain
any decimal part.

Here are a few examples of integers: 1, 3000, -31234, and so on.

When adding, subtracting, or multiplying two integers, we get an integer as a result in the end.

print(3 + 5) # 8
print(3 - 5) # -2
print(3 * 5) # 15
These are all integers.

This also includes cases when we raise a number to a power:

result = 3 ** 4 # This is similar to multiplying 3 * 3 * 3 * 3 in which case, we are multiplying

integers together
print(result) # 81
When we want to divide two integers, we are going to get a float number.

Booleans
The boolean type represents truth values, True and False. You learned the explanation of this
type in the Numbers section, since booleans are indeed subtypes of the integer type.

More specifically, almost always a False value can be considered as a 0, whereas a True value
can be considered as a 1.

As such, we can also do arithmetic operations with them:

print(True * 5) # 5
print(False * 500) # 0, since False is equal to 0
The exception for such integer representations of Boolean values is when these values are
strings such as "False" and "True".

Floats
Float numbers are numbers that contain the decimal part, such as -3.14, 12.031, 9.3124, and so
on.

We can also convert to float numbers using the float() function:

ten = float(10)

print(ten) # 10.0
When adding, subtracting, or dividing two float numbers, or a float number and an integer, we
get a float number as a result in the end:

print(3.4 * 2) # 6.8
print(3.4 + 2) # 5.4
print(3.4 - 2) # 1.4
print(2.1 * 3.4) # 7.14
Complex numbers
Complex numbers have both the real and the imaginary part that we write in the following way:

complex_number = 1 + 5j

print(complex_number) # (1+5j)
Strings in Python
Strings represent characters that are enclosed in either single quotes or double quotes. Both of
them are treated the same:

name = "Fatos" # Double quotes

name = 'Fatos' # Single quotes
If we want to include a quote inside a string, we need to let Python know that it should not close
the string but simply escape that quote:

greeting = 'Hello. I\'m fine.' # We escaped the apostrophe in I'm.

double_quote_greeting = "Hello. I'm fine." # When using double quotes, we do not need to
escape the apostrophe
When we want to include a new line in a string, we can include the special character \n:

my_string = "I want to continue \n in the next line"

print(my_string)
# I want to continue
# in the next line
Since strings are arrays of characters, we can index specific characters using indexes. Indexes
start from 0 and go all the way until the length of the string minus 1.

We exclude the index that is equal to the length of the string since we start indexing from 0 and
not from 1.

Here is an example:

string = "Word"
In this example, if we were to select individual characters of the string, they would unfold as
follows:

string = "Word"

print(string[0]) # W
print(string[1]) # o
print(string[2]) # r
print(string[3]) # d
We can use negative indexes as well, which means that we start from the end of the string with
-1. We cannot use 0 to index from the end of a string, since -0 = 0:

print(string[-1]) # d
print(string[-2]) # r
print(string[-3]) # o
print(string[-4]) # W
We can also do slicing and include only a portion of the string and not the entire string. For
example, if we want to get characters that start from a specific index until a specific index, we
should write it in the following way: string[start_index:end_index], excluding the character at
index end_index:

string = "Word"

print(string[0:3]) # Wor
If we want to start from a specific index and continue getting all the remaining characters of the
string until the end, we can omit specifying the end index, as follows:

string = "Word"

print(string[2:]) # rd
If we want to start from 0 and go until a specific index, we can simply specify the ending index:

string = "Word"

print(string[:2]) # Wo
This means that the value of string is equal to string[:2] (excluding the character at position 2) +
string[2:].

Note that strings in Python are immutable. This means that once a string object has been
created, it cannot be modified, such as trying to change a character in a string.

As an illustration, let's say that we want to change the first character in the string, namely
switching W with A in the following way:

string = "Word"
string[0] = "A"
Now, if we try to print string, we would get an error like the following:

# TypeError: 'str' object does not support item assignment

If we need a new string, we should simply create a new one.

String operators
We can concatenate strings using the + operator:

first = "First"
second = "Second"

concantenated_version = first + " " + second

print(concatenated_version) # First Second

We can use the multiplication operator * with strings and numbers.
You can use this to repeat the string that many times. For example, if we want to repeat a string
5 times, but we do not want to write it manually five times, we can simply multiply it with the
number 5:

string = "Abc"

repeated_version = string * 5

print(repeated_version) # AbcAbcAbcAbcAbc
String built-in methods
There are a few built-in methods of strings that we can use that can make it easier for us to
manipulate with them.

len() method
len() is a method that we can use to get the length of a string:

sentence = "I am fine."

print(len(sentence)) # 10
replace() method
We can use replace() to replace a character or a substring of a string with another character or
substring:

string = "Abc"

modified_version = string.replace("A", "Z")

print(modified_version) # Zbc
strip() method
strip() removes white spaces that can be in the beginning or at the end of a string:

string = " Hi there "

print(string.strip()) # Hi there
split() method
We can use split() to convert a string into an array of substrings based on a specific pattern that
is mentioned as the separator.

For example, let's assume that we want to save all words of a sentence in an array of words.
These words are separated by white spaces, so we will need to do the splitting based on that:

sentence = "This is a sentence that is being declared here"

print(string.split(" "))
# ['This', 'is', 'a', 'sentence', 'that', 'is', 'being', 'declared', 'here']
join() method
join() is the opposite of split(): from an array of strings, it returns a string. The process of
concatenation is supposed to happen with a specified separator in between each element of the
array that in the end results in a single concatenated string:

words = ["cat", "dog", "rabbit"]

print(" - ".join(words)) # cat - dog - rabbit

count() method
We can use count() to count the number of times a character or a substring appears in a string:

string = "Hi there"

print(string.count("h")) # 1, since, it is case sensitive and 'h' is not equal to 'H'

print(string.count("e")) # 2

print(string.count("Hi")) # 1

print(string.count("Hi there")) # 1
find() method
find() lets us find a character or a substring in a string and returns the index of it. In case it does
not find it, it will simply return -1:

string = "Hi there"

print(string.find("3")) # -1

print(string.find("e")) # 5

print(string.find("Hi")) # 0

print(string.find("Hi there")) # 0
lower()
lower() converts all characters of a string into lower case:

string = "Hi there"

print(string.lower()) # hi there
upper()
upper() converts all characters of a string into lower case:

string = "Hi there"

print(string.upper()) # HI THERE
capitalize() method
We can use capitalize() to covert the first character of a string into uppercase:

string = "hi there"

print(string.capitalize()) # Hi there
title() method
title() converts starting characters of each word (sequences that are separated by white spaces)
of a string into uppercase:

string = "hi there"

print(string.title()) # Hi There
isupper() method
isupper() is a method that we can use to check whether all characters in a string are upper
case:

string = "are you HERE"

another_string = "YES"

print(string.isupper()) # False
print(another_string.isupper()) # True
islower() method
islower() similarly checks whether all characters are lower case:

string = "are you HERE"

another_string = "no"

print(string.islower()) # False
print(another_string.islower()) # True
isalpha() method
isalpha() returns True if all characters in a string are letters of the alphabet:

string = "A1"
another_string = "aA"

print(string.isalpha()) # False, since it contains 1

print(another_string.isalpha()) # True since both `a` and `A` are letters of the alphabet
isdecimal() method
isdecimal() returns True if all characters in a string are numbers:

string = "A1"
another_string = "3.31"
yet_another_string = "3431"

print(string.isdecimal()) # False, since it contains 'A'

print(another_string.isdecimal()) # False, since it contains '.'
print(yet_another_string.isdecimal()) # True, since it contains only numbers
String Formatting
Formatting a string can be quite useful since you may be using it quite frequently no matter the
type of project or script that you are working on.

Let's first illustrate why we need formatting and include string interpolation.

Imagine that I want to develop a software that greets people the moment they come in, such as:

greeting = "Good morning Fatos."

This now looks great, but I am not the only person who uses it, right?

I am just one of the people who gets to use it.

Now if someone comes and signs in, I will have to use their own names, such as:

greeting = "Good morning Besart."

This is just my first real user who is registering. I am not counting myself.

Now let's think that I get lucky and the second user also pops in on a Friday morning and our
application should display:

greeting = "Good morning Betim."

As you can see, we are getting somewhere from a business perspective since two new users
just showed up, but this is not a scalable implementation. We are writing a very static greeting
expression.

You should already remember that we are about to mention something that I introduced back at
the beginning.

Yes, we will need to use variables and include a variable next to the string, as follows:

greeting = "Good morning " + first_name

This is much more flexible.

This is one way of doing that.

Another way you can do this is using a method called format().

We can use curly braces to specify places where we want to put dynamic values, such as the
following:

greeting = "Good morning {}. Today is {}.".format("Fatos", "Friday")

This is now going to put the first parameter of the method format() inside the first curly braces,
which in our case is Fatos. Then, in the second occurrence of the curly braces, it is going to put
the second parameter of the method format().

If we try to print the value of the string, we should get the following:

print(greeting)
# Good morning Fatos. Today is Friday.
We can specify parameters with indexes inside curly braces like the following that can then be
used:

greeting = "Today is {1}. Have a nice day {0}".format("Fatos", "Friday")

print(greeting)
# greeting = "Today is {1}. Have a nice day {0}.".format("Fatos", "Friday")
We can also specify parameters inside the format() method and use those specific words inside
curly braces as a reference:

greeting = "Today is {day_of_the_week}. Have a nice day

{first_name}.".format(first_name="Fatos",
day_of_the_week="Friday")
print(greeting) # Today is Friday. Have a nice day Fatos.
We can combine both types of arguments in a single example, such as the following:

short_bio = 'My name is {name}. My last name is {0}. I love {passion}. I like playing {1}.'.format(
'Morina',
'Basketball',
name='Fatos',
passion='Programming'
)

print(short_bio)
# My name is Fatos. My last name is Morina. I love Programming. I like playing Basketball.
As you can see, using named arguments as opposed to positional ones can be less error-prone,
since their ordering in the format() method does not matter.

We can also use another way of formatting strings which consists of beginning a string with f or
F before the opening quotation marks or triple quotation marks and including names of the
variables that we want to be included in the end:
first_name = "Fatos"
day_of_the_week = "Friday"
continent = "Europe"

greeting = f'Good morning {first_name}. Today is {day_of_the_week}'

print(greeting) # Good morning Fatos. Today is Friday.

Here is another example where we are using a triple quotient after the F:

continent = "Europe"

i_am_here = F'''I am in {continent}'''

print(i_am_here) # I am in Europe
Lists in Python
If you take a look at a bookshelf, you can see that the books are stacked and put closely
together. You can see that there are many examples of collecting, and structuring elements in
some way.

This is also quite important in computer programming. We cannot just continue declaring
countless variables and manage them that easily.

Let's say that we have a class of students and want to save their names. We can start saving
their names according to the way they are positioned in the classroom:

first = "Albert"
second = "Besart"
third = "Fisnik"
fourth = "Festim"
fifth = "Gazmend"
The list can keep on going which will make it quite hard for us to keep track of all of them.

There is fortunately an easier way for us to put these in a collection in Python called a list.

Let's create a list called students and store in that list all the names declared in the previous
code block:

students = ["Albert", "Besart", "Fisnik", "Festim", "Gazmend"]

This is prettier, right?

Moreover, this way, it is easier for us to manage and also manipulate the elements in the list.

You may think that, "Well it was easier for me to just call first and get the value stored in there.
Now it is impossible to get a value from this new list, called students".
If we couldn't read and use those elements that we just stored in a list, that would make it less
helpful.

Fortunately, lists have indexes, which start from 0. This means that if we want to get the first
element in a list, we need to use index 0 and not index 1 as you may think.

In the example above, the list items have these corresponding indexes:

students = ["Albert", "Besart", "Fisnik", "Festim", "Gazmend"]

# Indexes 0, 1, 2, 3, 4
Now, if we want to get the first element, we simply write:

students[0]
If we want to get the second element, we just write:

students[1]
As you can probably see, we simply need to write the name of the list and also the
corresponding index of the element that we want to get in the square brackets.

This list is, of course, not static. We can add elements to it, like when a new student joins the
class.

Let's add a new element in the list students with the value Besfort:

students.append("Besfort")
We can also change the value of an existing element. To do that, we need to simply reinitialize
that specific element of the list with a new value.

For example, let's change the name of the first student:

students[0] = "Besim"
Lists can contain contain different types of variables, for example, we can have a string that
contains integers, float numbers, and strings:

combined_list = [3.14, "An element", 1, "Another element here"]

Slicing
Similar to strings, lists can also be sliced, which as a result returns a new list. This means that
the original list remains unchanged.

Let's see how we can get the first three elements of a list using slicing:

my_list = [1, 2, 3, 4, 5]
print(my_list[0:3]) # [1, 2, 3]
As you can see, we have specified 0 as the starting index and 3 as the index where the slicing
should stop, excluding the element at the ending index.

If we want to simply start from an index and get all the remaining elements in the list, meaning
that the end_index should be the last index, then we can omit and not have to write the last
index at all:

my_list = [1, 2, 3, 4, 5]

print(my_list[3:]) # [4, 5]
Similarly, if we want to start from the beginning of the list and do the slicing until a specific index,
then we can omit writing the 0 index entirely, since Python is smart enough to infer that:

my_list = [1, 2, 3, 4, 5]

print(my_list[:3]) # [1, 2, 3]
Strings in Python are immutable, whereas lists are mutable, meaning that we can modify lists'
content after we declare them.

As an illustration, let's say that we want to change the first character in the string, namely
switching S with B in the following way:

string = "String"
string[0] = "B"
Now, if we try to print string, we would get an error like the following:

# TypeError: 'str' object does not support item assignment

Now if we have a list and want to modify its first element, then we can successfully do so:

my_list = ["a", "b", "c", "d", "e"]

my_list[0] = 50

print(my_list) # [50, 'b', 'c', 'd', 'e']

We can expand a list by concatenating it with another list using the + operator:

first_list = [1, 2, 3]

second_list = [4, 5]

first_list = first_list + second_list

print(first_list) # [1, 2, 3, 4, 5]
How to nest a list inside another list
We can nest a list inside another list like this:

math_points = [30, "Math"]

physics_points = [53, "Phyiscs"]

subjects = [math_points, physics_points]

print(subjects) # [[30, 'Math'], [53, 'Phyiscs']]

These lists do not need even have to have the same length.

To access elements of a list which is inside a list we need to use double indexes.

Let's see how we can access the element math_points inside the subjects list. Since
math_points is an element in the subjects list positioned at index 0, we simply need to do the
following:

print(subjects[0]) # [30, 'Math']

Now let's assume that we want to access Math inside the subjects list. Since Math is at index 1,
we are going to need to use the following double indexes:

print(subjects[0][1]) # 'Math'
List methods
len() is a method that you can use to find the length of a list:

my_list = ["a", "b", 1, 3]

print(len(my_list)) # 4
How to add elements to a list
We can also expand lists by adding new elements, or we can also delete elements.

We can add new elements at the end of a list using the append() method:

my_list = ["a", "b", "c"]

my_list.append("New element")

my_list.append("Yet another new element")

print(my_list)
# ['a', 'b', 'c', 'New element', 'Yet another new element']
If we want to add elements at specific indexes in a list, we can use the insert() method. We
specify the index in the first argument and the element that we want to add in the list as a
second argument:

my_list = ["a", "b"]

my_list.insert(1, "z")

print(my_list) # ['a', 'z', 'b']

How to delete elements from a list
We can delete elements from lists using the pop() method, which removes the last element in
the list:

my_list = [1, 2, 3, 4, 5]

my_list.pop() # removes 5 from the list

print(my_list) # [1, 2, 3, 4]

my_list.pop() # removes 4 from the list

print(my_list) # [1, 2, 3]
We can also specify the index of an element in the list that indicates which element in the list we
should delete:

my_list = [1, 2, 3, 4, 5]

my_list.pop(0) # Delete the element at index 0

print(my_list) # [2, 3, 4, 5]
We can also delete elements from lists using the del statement and then specifying the value of
the element that we want to delete:

my_list = [1, 2, 3, 4, 1]

del my_list[0] # Delete element my_list[0]

print(my_list) # [2, 3, 4, 5]
We can also delete slices of lists using del:

my_list = [1, 2, 3, 4, 1]

del my_list[0:3] # Delete elements: my_list[0], my_list[1], my_list[2]

print(my_list) # [4, 1]
We can do this using remove():

my_list = [1, 2, 3, 4]

my_list.remove(3)

print(my_list) # [1, 2, 4]
reverse() lets us reverse the elements in a list. This is quite easy and straightforward:

my_list = [1, 2, 3, 4]

my_list.reverse()

print(my_list) # [4, 3, 2, 1]
Index search
Getting elements of a list using indexes is simple. Finding indexes of elements of a list is also
easy. We simply need to use the method index() and mention the element that we want to find
inside a list:

my_list = ["Fatos", "Morina", "Python", "Software"]

print(my_list.index("Python")) # 2
Membership
This is quite intuitive and related to real life: We get to ask ourselves whether something is part
of something or not.

Is my phone in my pocket or bag?

Is my coworker's email included in the CC?

Is my friend in this coffee shop?

In Python, if we want to check whether a value is part of something, that we can use the
operator in:

my_list = [1, 2, 3] # This is a list

print(1 in my_list) # True

Since 1 is included in the array [1, 2, 3], the expression evaluates to True.

We can also use it not only with arrays of numbers, but with arrays of characters as well:

vowels = ['a', 'i', 'o', 'u']

print('y' in vowels) # False
Since y is not a vowel and not included in the declared array, the expression in the second line
of the previous code snippet is going to result in False.

Similarly, we can also check whether something is not included using not in:

odd_numbers = [1, 3, 5, 7]
print(2 not in odd_numbers) # True
Since 2 is not included in the array, the expression is going to evaluate to True.

How to sort elements in a list

Sorting elements in a list is something that you may need to do from time to time. sort() is a
built-in method that makes it possible for you to sort elements in a list in an ascending order
alphabetically or numerically:

my_list = [3, 1, 2, 4, 5, 0]

my_list.sort()

print(my_list) # [0, 1, 2, 3, 4, 5]

alphabetical_list = ['a', 'c', 'b', 'z', 'e', 'd']

alphabetical_list.sort()

print(alphabetical_list) # ['a', 'b', 'c', 'd', 'e', 'z']

There are other methods of lists that we have not included in here.

List comprehension
List comprehension represents a concise way in which we use a for loop to create a new list
from an existing one. The result is always a new list in the end.

Let's start with an example where we want to multiply each number of a list with 10 and save
that result in a new list. First, let's do this without using list comprehension:

numbers = [2, 4, 6, 8] # Complete list

numbers_tenfold = [] # Empty list

for number in numbers:

number = number * 10 # Multiply each number with 10
numbers_tenfold.append(number) # Add that new number in the new list

print(numbers_tenfold) # [20, 40, 60, 80]

We can implement that using list comprehension in the following way:

numbers = [2, 4, 6, 8] # Complete list

numbers_tenfold = [number * 10 for number in numbers] # List comprehension

print(numbers_tenfold) # [20, 40, 60, 80]

We can also include conditions when doing these list comprehensions.

Let's assume that we want to save a list of positive numbers.

Before we write the way we would implement this using list comprehension, let's write a way in
which we would create a list of only numbers that are greater than 0 in another list and increase
those positive numbers by 100:

positive_numbers = [] # Empty list

numbers = [-1, 0, 1, -2, -3, -4, 3, 2] # Complete list

for number in numbers:

if number > 0: # If the current number is greater than 0
positive_numbers.append(number + 100) # add that number inside the list
positive_numbers

print(positive_numbers) # [101, 103, 102]

We can do the same using list comprehension:

numbers = [-1, 0, 1, -2, -3, -4, 3, 2] # Compelete list

positive_numbers = [number + 100 for number in numbers if number > 0] # List comprehension

print(positive_numbers) # [101, 103, 102]

As you can see, this is much shorter and should take less time to write.

We can also use list comprehension with multiple lists as well.

Let's take an example where we want to add each element of a list with each element in another
list:

first_list = [1, 2, 3]
second_list = [50]

double_lists = [first_element +
 second_element for first_element in first_list for second_element in second_list]

print(double_lists) # [51, 52, 53]

In the end, we are going to get a resulting list that has the same number of elements as the list
with the longest length.

Tuples in Python
Tuples are collections that are ordered and immutable, meaning that their content cannot be
changed. They are ordered and we can access their elements using indexes.

Let's start with our first tuple:

vehicles = ("Computer", "Smartphone", "Smart watch", "Tablet")

print(vehicles)

# ('Computer', 'Smartphone', 'Smart watch', 'Tablet')

All the indexing and slicing operations that we have seen in the list section apply for tuples as
well:

print(len(vehicles)) # 4

print(vehicles[3]) # Tablet

print(vehicles[:3]) # ('Computer', 'Smartphone', 'Smart watch')

You can find the index of an element inside a tuple using the index() method:

print(vehicles.index('tablet')) # 3
We can also concatenate or merge two tuples using the + operator:

natural_sciences = ('Chemistry', 'Astronomy',

'Earth science', 'Physics', 'Biology')

social_sciences = ('Anthropology', 'Archaeology', 'Economics', 'Geography',

'History', 'Law', 'Linguistics', 'Politics', 'Psychology', 'Sociology')

sciences = natural_sciences + social_sciences

print(sciences)
# ('Chemistry', 'Astronomy', 'Earth science', 'Physics', 'Biology', 'Anthropology', 'Archaeology',
'Economics', 'Geography', 'History', 'Law', 'Linguistics', 'Politics', 'Psychology', 'Sociology')
Membership check
We can check whether an element is part of a tuple using the operators in and not in just like
with lists:
vehicles = ('Car', 'Bike', 'Airplane')

print('Motorcycle' in vehicles) # False, since Motorcycle is not included in vehicles

print('Train' not in vehicles) # True, since Train is not included in vehicles

How to nest two tuples
Instead of merging, we can also nest tuples into a single tuple by using tuples that we want to
nest inside the parenthesis:

natural_sciences = ('Chemistry', 'Astronomy',

'Earth science', 'Physics', 'Biology')

social_sciences = ('Anthropology', 'Archaeology', 'Economics', 'Geography',

'History', 'Law', 'Linguistics', 'Politics', 'Psychology', 'Sociology')

sciences = (natural_sciences, social_sciences)

print(sciences)
# (('Chemistry', 'Astronomy', 'Earth science', 'Physics', 'Biology'), ('Anthropology', 'Archaeology',
'Economics', 'Geography', 'History', 'Law', 'Linguistics', 'Politics', 'Psychology', 'Sociology'))
Immutability
Since tuples are immutable, we can't change them after we create them. This means that we
cannot add or delete elements in them, or append a tuple to another tuple.

We cannot even modify existing elements in a tuple. If we try to modify an element in a tuple, we
are going to face a problem like the following:

vehicles = ('Car', 'Bike', 'Airplane')

vehicles[0] = 'Truck'

print(vehicles)
# TypeError: 'tuple' object does not support item assignment
Dictionaries in Python – Key-Value Data Structures
As we saw previously, elements in lists are associated with indexes that we can use to
reference those elements.

There is another data structure in Python that allows us to specify our own custom indexes and
not just numbers. These are called dictionaries, and they are similar to dictionaries that we use
to find the meaning of words we do not understand.

Let's assume that you are trying to learn German and there is a new word that you have not had
the chance to learn before that you just saw at a market: Wasser.
Now, you can pick up your phone and check its corresponding meaning in English using Google
Translate or any other application of your choice. But if you were to use a physical dictionary,
you would need to find this word by going to that specific page and check its meaning sitting
right beside it. The reference or the key for the meaning of this word would be the term Wasser.

Now, if we want to implement this in Python, we should not use lists that have indexes only as
numbers. We should use dictionaries instead.

For dictionaries, we use curly braces and have each element that has two parts: the key and the
value.

In our previous example, the key was the German word, whereas the value was its translation in
English, as you can see in the following example:

german_to_english_dictionary = {
"Wasser": "Water",
"Brot": "Bread",
"Milch": "Milk"
}
Now, when we want to access specific elements in the dictionary, we simply use keys. For
example, let's assume that we want to get the meaning of the word Brot in English. To do that,
we can simply reference that element using that key:

brot_translation = german_to_english_dictionary["Brot"]
print(translation) # Bread
When we print the value that we get, we are going to get the translation in English.

Similarly, we can get the English translation of the word Milch by getting the value of the
element that has Milch as the key:

milch_translation = german_to_english_dictionary["Milch"]
print(milch_translation) # Milk
We can also get the value of an element in a dictionary using get() and specifying the key of the
item that we want to get:

german_to_english_dictionary.get("Wasser")
Both keys and values can be of any data type.

Dictionaries can have duplicate values, but the all the keys should be unique. Take a look at this
example to see what I mean:

my_dictionary = dict([
('a', 1),
 ('b', 1),
('c', 2)
])
We can create dictionaries using dict():

words = dict([
('abandon', 'to give up to someone or something on the ground'),
('abase', 'to lower in rank, office, or esteem'),
('abash', 'to destroy the self-possession or self-confidence of')
])

print(words)
# {'abandon': 'to give up to someone or something on the ground', 'abase': 'to lower in rank,
office, or esteem', 'abash': 'to destroy the self-possession or self-confidence of'}
How to add new values to a dict
We can add new values inside dictionaries by specifying a new key and a corresponding value.
Then Python is going to create a new element inside that dictionary:

words = {
'a': 'alfa',
'b': 'beta',
'd': 'delta',
}

words['g'] = 'gama'

print(words)
# {'a': 'alfa', 'b': 'beta', 'd': 'delta', 'g': 'gama'}
If we specify the key of an element that is already part of the dictionary, that element is going to
be modified:

words = {
'a': 'alfa',
'b': 'beta',
'd': 'delta',
}

words['b'] = 'bravo'

print(words)
# {'a': 'alfa', 'b': 'bravo', 'd': 'delta'}
How to remove elements from a dict
If we want to remove elements from a dictionary, we can use the method pop() and also specify
the key of the element that we want to delete:

words = {
'a': 'alfa',
'b': 'beta',
'd': 'delta',
}

words.pop('a')

print(words) # {'b': 'beta', 'd': 'delta'}

We can also delete values using popitem() which removes the last inserted key-value pair
starting from Python 3.7. In earlier versions, it deletes a random pair:

words = {
'a': 'alfa',
'b': 'beta',
'd': 'delta',
}

words['g'] = 'gamma'

words.popitem()

print(words)
# {'a': 'alfa', 'b': 'beta', 'd': 'delta'}

There is another way that we can delete elements, namely by using del statement:

words = {
'a': 'alfa',
'b': 'beta',
'd': 'delta',
}

del words['b']

print(words) # {'a': 'alfa', 'd': 'delta'}

How to get the length of a dict
We can get the length of a dictionary using len() just like with lists and tuples:

words = {
'a': 'alfa',
 'b': 'beta',
'd': 'delta',
}

print(len(words)) # 3
Membership
If we want to check whether a key is already part of a dictionary so that we avoid overriding it,
we can use the operator in and not in just like with lists and tuples:

words = {
'a': 'alfa',
'b': 'beta',
'd': 'delta',
}

print('a' in words) # True

print('z' not in words) # True
Comprehension
We can use comprehension just like with lists to create dictionaries in a quick way.

To help us with that, we are going to need to use a method called items() that converts a
dictionary into a list of tuples. The element in index 0 is a key, whereas in position with index 1,
we have a value.

Let's first see the method items() in action:

points = {
'Festim': 50,
'Zgjim': 89,
'Durim': 73
}

elements = points.items()

print(elements) # dict_items([('Festim', 50), ('Zgjim', 89), ('Durim', 73)])

Now let's create a new dictionary from this existing dictionary points using comprehension.

We can assume that a professor is in a good mood and generous enough to reward each
student with a bonus of 10 points. We want to add these new points to each student by saving
these new points in a new dictionary:

points = {
'Festim': 50,
'Zgjim': 89,
 'Durim': 73
}

elements = points.items()

points_modified = {key: value + 10 for (key, value) in elements}

print(points_modified) # {'Festim': 60, 'Zgjim': 99, 'Durim': 83}

Sets in Python
Sets are unordered and unindexed collections of data. Since elements in sets are not ordered,
we cannot access elements using indexes or using the method get().

We can add tuples, but we cannot add dictionaries or lists in a set.

We cannot add duplicate elements in sets. This means that when we want to remove duplicate
elements from another type of collection, we can make use of this uniqueness in sets.

Let's start creating our first set using curly brackets as follows:

first_set = {1, 2, 3}
We can also create sets using the set() constructor:

empty_set = set() # Empty set

first_set = set((1, 2, 3)) # We are converting a tuple into a set

Like all data structures, we can find the length of a set using the method len():

print(len(first_set)) # 3
How to add elements to a set
We can add one element in a set using the method add():

my_set = {1, 2, 3}

my_set.add(4)

print(my_set) # {1, 2, 3, 4}
If we want to add more than one element, then we need to use method update(). We use as an
input for this method a list, tuple, string or another set:

my_set = {1, 2, 3}

my_set.update([4, 5, 6])

print(my_set) # {1, 2, 3, 4, 5, 6}
my_set.update("ABC")

print(my_set) # {1, 2, 3, 4, 5, 6, 'A', 'C', 'B'}

How to delete elements from a set
If we want to delete elements from sets, we can use methods discard() or remove():

my_set = {1, 2, 3}

my_set.remove(2)

print(my_set) # {1, 3}
If we try to delete an element that is not part of the set using remove(), then we are going to get
an error:

my_set = {1, 2, 3}

my_set.remove(4)

print(my_set) # KeyError: 4
To avoid such errors when removing elements from sets, we can use the method discard():

my_set = {1, 2, 3}

my_set.discard(4)

print(my_set) # {1, 2, 3}
Set Theory Operations
If you remember high school math lessons, you should already know about union, intersection,
and the difference between two sets of elements. These operations are supported for sets in
Python as well.

Union
Union represents the collection of all unique elements from both sets. We can find the union of
two sets using the pipe operator | or the union() method:

first_set = {1, 2}
second_set = {2, 3, 4}

union_set = first_set.union(second_set)

print(union_set) # {1, 2, 3, 4}
Intersection
Intersection represents the collection that contains elements that are in both sets. We can find it
using operator & or the intersection() method:

first_set = {1, 2}
second_set = {2, 3, 4}

intersection_set = first_set.intersection(second_set)

print(union_set) # {2}
Difference
The difference between two sets represents the collection that contains only the elements that
are in the first set, but not in the second. We can find the difference between two sets using the
- operator or the method difference()

first_set = {1, 2}
second_set = {2, 3, 4}

difference_set = first_set.difference(second_set)

print(difference_set) # {1}
As you can probably remember from high school, ordering of sets when we find the difference of
two sets matters, which is not the case with the union and intersection.

This is similar to arithmetic, where 3 - 4 is not equal to 4 - 3:

first_set = {1, 2}
second_set = {2, 3, 4}

first_difference_set = first_set.difference(second_set)

print(first_difference_set) # {1}

second_difference_set = second_set.difference(first_set)

print(second_difference_set) # {3, 4}
Type Conversions in Python
Conversions Between Primitive Types
Python is an object oriented programming language. That is why it uses constructor functions of
classes to do conversions from one type into another.

int() method
int() is a method that you use do a conversion of an integer literal, float literal (rounding it to its
previous integer number, that is 3.1 to 3), or a string literal (with the condition that the string
represents an int or float literal):
three = int(3) # converting an integer literal into an integer
print(three) # 3

four = int(4.8) # converting a float number into its previous closest integer
print(four) # 4

five = int('5') # converting a string into an integer

print(five) # 5
float() method
float() is similarly used to create float numbers from an integer, float, or string literal (with the
condition that the string represents an int or float literal):

int_literal = float(5)
print(int_literal) # 5.0

float_literal = float(1.618)
print(float_literal) # 1.618

string_int = float("40")
print(string_int) # 40.0

string_float = float("37.2")
print(string_float) # 37.2
str() method
We can use str() to create strings from strings, integer literals, float literals, and many other data
types:

int_to_string = str(3)
print(int_to_string) # '3'

float_to_string = str(3.14)
print(float_to_string) # '3.14'

string_to_string = str('hello')
print(string_to_string) # 'hello'
Other Conversions
To convert from one type of data structure into another type, we do the following:

destination_type(input_type)
Let us get started with specific types, so that it becomes much clearer.

Conversions to lists
We can convert a set, tuple, or dictionary into a list using the list() constructor.
books_tuple = ('Book 1', 'Book 2', 'Book 3')
tuple_to_list = list(books_tuple) # Converting tuple to list
print(tuple_to_list) # ['Book 1', 'Book 2', 'Book 3']

books_set = {'Book 1', 'Book 2', 'Book 3'}

set_to_list = list(books_set) # Converting set to list
print(set_to_list) # ['Book 1', 'Book 2', 'Book 3']
When converting a dictionary into a list, only its keys are going to make it into a list:

books_dict = {'1': 'Book 1', '2': 'Book 2', '3': 'Book 3'}
dict_to_list = list(books_dict) # Converting dict to list
print(dict_to_list) # ['1', '2', '3']
If we want to keep both keys and values of a dictionary, we need to use the method items() to
first convert it into a list of tuples where each tuple is a key and a value:

books_dict = {'1': 'Book 1', '2': 'Book 2', '3': 'Book 3'}

dict_to_list = list(books_dict.items()) # Converting dict to list

print(dict_to_list)
# [('1', 'Book 1'), ('2', 'Book 2'), ('3', 'Book 3')]
Conversions to tuples
All data structures can be converted to a tuple using the tuple() constructor method, including a
dictionary In that case we get a tuple with the keys of the dictionary:

books_list = ['Book 1', 'Book 2', 'Book 3']

list_to_tuple = tuple(books_list) # Converting tuple to tuple
print(list_to_tuple) # ('Book 1', 'Book 2', 'Book 3')

books_set = {'Book 1', 'Book 2', 'Book 3'}

set_to_tuple = tuple(books_set) # Converting set to tuple
print(set_to_tuple) # ('Book 1', 'Book 2', 'Book 3')

books_dict = {'1': 'Book 1', '2': 'Book 2', '3': 'Book 3'}
dict_to_tuple = tuple(books_dict) # Converting dict to tuple
print(dict_to_tuple) # ('1', '2', '3')
Conversions to sets
Similarly, all data structures can be converted to a set using the set() constructor method,
including a dictionary. In that case we get a set with the keys of the dictionary:
books_list = ['Book 1', 'Book 2', 'Book 3']
list_to_set = set(books_list) # Converting list to set
print(list_to_set) # {'Book 2', 'Book 3', 'Book 1'}

books_tuple = ('Book 1', 'Book 2', 'Book 3')

tuple_to_set = set(books_tuple) # Converting tuple to set
print(tuple_to_set) # {'Book 2', 'Book 3', 'Book 1'}

books_dict = {'1': 'Book 1', '2': 'Book 2', '3': 'Book 3'}
dict_to_set = set(books_dict) # Converting dict to set
print(dict_to_set) # {'1', '3', '2'}
Conversions to dictionaries
Conversions into dictionaries cannot be done with any type of sets, lists, or tuples, since
dictionaries represent data structures where each element contains both a key and a value.

Converting a list, or a tuple into a dictionary can be done if each element in a list is also a list
with two elements, or a tuple with two elements.

books_tuple_list = [(1, 'Book 1'), (2, 'Book 2'), (3, 'Book 3')]
tuple_list_to_dictionary = dict(books_tuple_list) # Converting list to set
print(tuple_list_to_dictionary) # {1: 'Book 1', 2: 'Book 2', 3: 'Book 3'}

books_list_list = [[1, 'Book 1'], [2, 'Book 2'], [3, 'Book 3']]
tuple_list_to_dictionary = dict(books_list_list) # Converting list to set
print(tuple_list_to_dictionary) # {1: 'Book 1', 2: 'Book 2', 3: 'Book 3'}

books_tuple_list = ([1, 'Book 1'], [2, 'Book 2'], [3, 'Book 3'])
tuple_list_to_set = dict(books_tuple_list) # Converting tuple to set
print(tuple_list_to_set) # {'Book 2', 'Book 3', 'Book 1'}

books_list_list = ([1, 'Book 1'], [2, 'Book 2'], [3, 'Book 3'])
list_list_to_set = dict(books_list_list) # Converting tuple to set
print(list_list_to_set) # {'Book 2', 'Book 3', 'Book 1'}

In case when we want to convert a set into a dictionary, we need to have each element as a
tuple of length 2.

books_tuple_set = {('1', 'Book 1'), ('2', 'Book 2'), ('3', 'Book 3')}
tuple_set_to_dict = dict(books_tuple_set) # Converting dict to set
print(tuple_set_to_dict) # {'1', '3', '2'}
If we try to do a conversion of a set that has each element as a list of length 2 into a dictionary,
we are going to get an error:

books_list_set = {['1', 'Book 1'], ['2', 'Book 2'], ['3', 'Book 3']}
list_set_to_dict = dict(books_list_set) # Converting dict to set
print(list_set_to_dict) # {'1', '3', '2'}
After we run the last code block, we are going to get an error:

TypeError: unhashable type: 'list'

Wrapping Up Data Types
In conclusion, Python has a variety of data types that you can use to store data. These data
types are important to know so that you can choose the right one for your needs.

Be sure to use the right data type for the task that is in front of you to avoid errors and optimize
performance.

Control Flow in Python

Conditional statements
When you think about ways we think and also communicate with each other, you may get the
impression that we are indeed always using conditions.

If it's 8 am, I take the bus and go to work.

If I am hungry, I eat.
If this item is cheap, I can afford it.
This is also something that you can do in programming. We can use conditions to control the
flow of the execution.

To do that, we use the reserved term if and an expression that evaluates to a True or False
value. We can then also use an else statement where we want the flow to continue in cases
when the if condition is not met.

To make it easier to understand, let's assume that we have an example where we want to check
whether a number is positive:

if number > 0:
print("The given number is positive")
else:
print("The given number is not positive")
If we were to have number = 2: we would enter into the if branch and execute the command that
is used to print the following text in the console:

The given number is positive

If we would have another number, such as -1, we would see in the console the following
message being printed:
The given number is not positive
We can also add additional conditions – and not just 2 like above – by using elif which is
evaluated when the if expression is not evaluated.

Let's see an example to make it easier for you to understand:

if number > 0:
print("The given number is positive")
elif number == 0:
print("The given number is 0")
else:
print("The given number is negative")
Now if we were to have number = 0, the first condition is not going to be met, since the value is
not greater than 0. As you can guess, since the given number is equal to 0, we are going to see
the following message being printed in the console:

The given number is 0

In cases when the value is negative, our program is going to pass the first two conditions since
they are not satisfied and then jump into the else branch and print the following message in the
console:

The given number is negative

Looping / Iterator
Looping represents the ability of the program to execute a set of instructions over and over
again until a certain condition is met. We can do it with both while and for.

Let's first see the iteration with for.

for loop in Python

This looping is simple and quite straightforward. All you have to do is specify a starting state and
mention the range in which it should iterate, as you can see in the following example:

for number in range(1, 7):

print(number)
In this example, we are iterating from 1 to 7 and printing each number (from 1 up to 7 excluding
7) in the console.

We can change both the starting and the ending numbers in the range as we want. This way, we
can be quite flexible depending on our specific scenarios.

while loop in Python

Let's now describe iterations with while. This is also another way of doing iterations that is also
quite straightforward and intuitive.
Here we need to specify a starting condition before the while block and also update the
condition accordingly.

The while loop needs a “loop condition.” If it stays True, it continues iterating. In this example,
when num is 11 the loop condition equals False.

number = 1

while number < 7:

print(number)
number += 1 # This part is necessary for us to add so that the iteration does not last forever
This while block is going to print the same statements as the code we used with the for block.

Iteration: Looping Through Data Structures

Now that we have covered both iteration and lists, we can jump into ways of iterating through
lists.

We do not just store things in data structures and leave them there for ages. We are supposed
to be able to use those elements in different scenarios.

Let's take our list of students from before:

students = ["Albert", "Besart", "Fisnik", "Festim", "Gazmend"]

Now, to iterate through the list, we can simply type:

for student in students:

print(student)
Yes, it's that simple. We are iterating through each element in the list and printing their values.

We can do this for dictionaries as well. But since elements in dictionaries have 2 parts (key and
the value), we need to specify both the key and the value as follows:

german_to_english_dictionary = {
"Wasser": "Water",
"Brot": "Bread",
"Milch": "Milk"
}

for key, value in german_to_english_dictionary:

print("The German word " + key + " means " + value + " in English")
We can also get only keys from the elements of the dictionary:

for key in german_to_english_dictionary:

 print(key)
Note that key and value are simply variable names that we have chosen to illustrate the
iteration. But we can use any name that we want for our variables, such as the following
example:

for german_word, english_translation in german_to_english_dictionary:

print("The German word " + german_word + " means " + english_translation + " in English")
This iteration is going to print the same thing in the console as the code block before the last
one.

We can also have nested for loops. For example, let's say that we want to iterate through a list
of numbers and find a sum of each element with each other element of a list. We can do that
using nested for loops:

numbers = [1, 2, 3]
sum_of_numbers = [] # Empty list

for first_number in numbers:

for second_number in numbers: # Loop through the list and add the numbers
current_sum = first_number + second_number
# add current first_number from the first_list to the second_number from the second_list
sum_of_numbers.append(current_sum)

print(sum_of_numbers)
# [2, 3, 4, 3, 4, 5, 4, 5, 6]
How to stop a for-loop
Sometimes we may need to exit a for loop before it reaches the end. This may be the case
when a condition has been met or we have found what we were looking for and there is no need
to continue any further.

In those situations, we can use break to stop any other iteration of the for loop.

Let's assume that we want to check whether there is a negative number in a list. In case we find
that number, we stop searching for it.

Let's implement this using break:

my_list = [1, 2, -3, 4, 0]

for element in my_list:

print("Current number: ", element)
if element < 0:
print("We just found a negative number")
 break

# Current number: 1
# Current number: 2
# Current number: -3
# We just found a negative number
As we can see, the moment we reach -3, we break from the for loop and stop.

How to skip an iteration

There can also be cases when we want to skip certain iterations since we are not interested in
them and they do not matter that much. We can do that using continue which prevents code
execution below it in that code block and moves the execution procedure towards the next
iteration:

my_sum = 0
my_list = [1, 2, -3, 4, 0]

for element in my_list:

if element < 0: # Do not include negative numbers in the sum
continue
my_sum += element

print(my_sum) # 7
pass is a statement we can use to help us when we are about to implement a method or
something but we haven't done it yet and do not want to get errors.

It helps us execute the program even if some parts of the code are missing:

my_list = [1, 2, 3]

for element in my_list:

pass # Do nothing
Conditional Statement Wrap Up
In conclusion, Python offers conditional statements to help you control the flow of your program.

The if statement lets you run a block of code only if a certain condition is met. The elif statement
lets you run a block of code only if another condition is met. And the else statement lets you run
a block of code only if no other condition is met.

These statements are very useful for controlling the flow of your program.

Functions in Python
There are plenty of cases when we need to use the same code block again and again. Our first
guess would be to write it as many times as we want.
Objectively, it does work, but the truth is, this is a really bad practice. We are doing repetitive
work that can be quite boring and it's also prone to more mistakes that we might overlook.

This is the reason why we need to start using code blocks that we can define once and then use
that same code anywhere else.

Just think about this in real life: You see a YouTube video that has been recorded and uploaded
to YouTube once. It is then going to be watched by many other people, but the video still
remains the same one that was uploaded initially.

In other words, we use methods as a representative of a set of coding instructions that are then
supposed to be called anywhere else in the code and that we do not have to write it repeatedly.

In cases when we want to modify this method, we simply change it at the place where it was first
declared and other places where it is called do not have to do anything.

To define a method in Python, we start by using the def keyword, then the name of the function
and then a list of arguments that we expect to be used. After that, we need to start writing the
body of the method in a new line after an indentation.

def add(first_number, second_number):

our_sum = first_number + second_number
return our_sum
As you can see from the syntax highlighting, both def and return are keywords in Python that
you cannot use to name your variables.

Now, everywhere we want this add() to be called, we can just call it there and not have to worry
about implementing it entirely.

Since we have defined this method, we can call it in the following way:

result = add(1, 5)

print(result) # 6
You might think that this is such a simple method and start asking, why are we even bothering to
write a method for it?

You are right. This was a very simple method just to introduce you to the way we can implement
functions.

Let's write a function that finds the sum of numbers that are between two specified numbers:

def sum_in_range(starting_number, ending_number):

 result = 0

while starting_number < ending_number:

result = result + starting_number
starting_number = starting_number + 1

return result
This is now a set of instructions that you can call in other places and do not have to write all of it
again.

result = sum_in_range(1, 5)

print(result) # 10
Note that functions define a scope, which means that variables which are defined in that scope
are not accessible outside it.

For example, we cannot access the variable named product outside the scope of the function:

def multiply_in_range(starting_number, ending_number):

product = 1
while starting_number < ending_number:
product = product * starting_number
starting_number = starting_number + 1
return product
product is accessible only inside the body of this method.

Default Arguments in Functions

When we call functions, we may make some of the arguments optional by writing an initial value
for them at the header of the function.

Let's take an example of getting a user's first name as a required argument and let the second
argument be an optional one.

def get_user(first_name, last_name=""):

return f"Hi {first_name} {last_name}"
We'll now call this function with both arguments:

user = get_user("Durim", "Gashi")

print(user) # Hi Durim Gashi

We can now call that same function even though the the second argument is not specified:

user = get_user("Durim")
print(user) # Hi Durim
Keyword Argument List
We can define arguments of functions as keywords:

# The first argument is required. The other two are optional

def get_user(number, first_name='', last_name=''):
return f"Hi {first_name} {last_name}"
Now, we can call this function by writing arguments as keywords:

user = get_user(1, last_name="Gashi")

print(user) # Hi Gashi
As you can see, we can omit first_name since it is not required. We can also change the
ordering of the arguments when calling the function and it will still work the same:

user = get_user(1, last_name="Gashi", first_name='Durim')

print(user) # Hi Durim Gashi

Data Lifecycle
Variables that are declared inside a function cannot be accessed outside it. They are isolated.

Let's see an example to illustrate this:

def counting():
count = 0 # This is not accessible outside of the function.

counting()

print(count) # This is going to throw an error when executing, since count is only declared
inside the function and is not acessible outside that
Similarly, we cannot change variables inside functions that have been declared outside
functions and that are not passed as arguments:

count = 3331

def counting():
count = 0 # This is a new variable

counting()

print(count) # 3331
# This is declared outside the function and has not been changed
How to Change Data Inside Functions
We can change mutable data that is passed through a function as arguments. Mutable data
represents data that we can modify even after it has been declared, Lists, for example, are
mutable data.

names = ["betim", "durim", "gezim"]

def capitalize_names(current_list):

for i in range(len(current_list)):
current_list[i] = current_list[i].capitalize()

print("Inside the function:", current_list)

return current_list

capitalize_names(names) # Inside the function: ['Betim', 'Durim', 'Gezim']

print("Outside the function:", names) # Outside the function: ['Betim', 'Durim', 'Gezim']
In case of immutable data, we can only modify the variable inside a function, but the actual
value outside that function is going to remain unchanged. Immutable data are strings and
numbers:

name = "Betim"

def say_hello(current_param):
current_param = current_param + " Gashi"
name = current_param # name is a local variable
print("Value inside the function:", name)
return current_param

say_hello(name) # Value inside the function: Betim Gashi

print("Value outside the function:", name) # Value outside the function: Betim
If we really want to update immutable variables through a function, we can assign a return value
of a function to the immutable variable:

name = "Betim"
def say_hello(current_param):
current_param = current_param + " Gashi"
name = current_param # name is a local variable
print("Value inside the function", name)
return current_param

# Here we are assigning the value of name to the current_param that is returned from the
function
name = say_hello(name) # Value inside the function Betim Gashi

# Value outside the function: Betim Gashi

print("Value outside the function:", name)
Lambda Functions
Lambda functions are anonymous functions that we can use to return an output. We can write
lambda functions using the following syntax pattern:

lambda parameters: expression

The expression can only be written in a single line.

Let's start illustrating these anonymous functions using a few examples.

We'll start with a function that multiples each input with 10:

tenfold = lambda number : number * 10

print(tenfold(10)) # 100
Let's write another example in which we check whether the given argument is positive or not:

is_positive = lambda a : f'{a} is positive' if a > 0 else f'{a} is not positive'

print(is_positive(3)) # 3 is positive

print(is_positive(-1)) # -1 is not positive

Note that we cannot use the if clause without the else clause inside a lambda function.

At this point, you may wonder, why do we need to use lambda functions, since they seem to be
almost the same as other functions?

We can see that illustrated in the following section.

Functions as arguments of functions

So far, we have seen ways of calling functions using numbers and strings. We can actually call
functions with any type of Python object.

We can even provide an entire function as the argument of a function, which can provide a level
of abstraction that can be quite useful.

Let's see an example where we want to do a few conversions from one unit into another:

def convert_to_meters(feet):
return feet * 0.3048

def convert_to_feet(meters):
return meters / 0.3048

def convert_to_miles(kilometers):
return kilometers / 1.609344

def convert_to_kilometers(miles):
return miles * 1.609344
Now, we can make a general function and pass another function as an argument:

def conversion(operation, argument):

return operation(argument)
We can now call conversion() like this:

result = conversion(convert_to_miles, 10)

print(result) # 6.2137119223733395
As you can see, we have written convert_to_miles as a parameter of the function conversion().
We can use other already defined functions like that:

result = conversion(convert_to_feet, 310)

print(result) # 1017.0603674540682
We can now make use of lambdas and make this type of abstraction much simpler.

Instead of writing all those four functions, we can simply write a concise lambda function and
use it as a parameter when calling the conversion() function:

def conversion(operation, argument):

return operation(argument)
result = conversion(lambda kilometers: kilometers / 1.609344, 10)

print(result) # 6.2137119223733395
This is of course simpler.

Let's use a few other examples with built-in functions.

map() function
map() is a built-in function that creates a new object by getting results by calling a function on
each element of an existing list:

map(function_name, my_list)
Let's see an example of writing a lambda function as the function of a map.

Let's triple each number in a list using list comprehension:

my_list = [1, 2, 3, 4]

triple_list = [x * 3 for x in my_list]

print(triple_list) # [3, 6, 9, 12]

We can implement that using a map() function and a lambda function:

my_list = [1, 2, 3, 4]

triple_list = map(lambda x: x * 3, my_list)

print(triple_list) # [3, 6, 9, 12]

This creates a new list. The old list is not changed.

filter() function
This is another built-in function that we can use to filter elements of a list that satisfy a condition.

Let's first filter out negative elements from a list using list comprehension:

my_list = [3, -1, 2, 0, 14]

non_negative_list = [x for x in my_list if x >= 0]

print(non_negative_list) # [3, 2, 0, 14]

Now, we'll filter elements using filter() and a lambda function. This function returns an object
which we can convert into a list using list():
my_list = [3, -1, 2, 0, 14]

non_negative_filter_object = filter(lambda x: x >= 0, my_list)

non_negative_list = list(non_negative_filter_object)

print(non_negative_list) # [3, 2, 0, 14]

You should now understand how you can call functions with other functions as arguments and
why lambdas are useful and important.

Decorators in Python
A decorator represents a function that accepts another function as an argument.

We can think of it as a dynamic way of changing the way a function, method, or class behaves
without having to use subclasses.

Once a function is being passed as an argument to a decorator, it will be modified and then
returned as a new function.

Let's start with a basic function that we want to decorate:

def reverse_list(input_list):
return input_list[::-1]
In this example, we are simply returning a reversed list.

We can also write a function that accepts another function as an argument:

def reverse_list(input_list):
return input_list[::-1]

def reverse_input_list(another_function, input_list):

# we are delegating the execution to another_function()
return another_function(input_list)

result = reverse_input_list(reverse_list, [1, 2, 3])

print(result) # [3, 2, 1]
We can also nest a function inside another function:

def reverse_input_list(input_list):
# reverse_list() is now a local function that is not accessible from the outside
 def reverse_list(another_list):
return another_list[::-1]

result = reverse_list(input_list)
return result # Return the result of the local function

result = reverse_input_list([1, 2, 3])

print(result) # [3, 2, 1]
In this example, reverse_list() now is a local function and cannot be called outside the scope of
the reverse_input_list() function.

Now we can write our first decorator:

def reverse_list_decorator(input_function):
def function_wrapper():
returned_result = input_function()
reversed_list = returned_result[::-1]
return reversed_list

return function_wrapper
reverse_list_decorator() is a decorator function that takes as input another function. To call it, we
need to write another function:

# Function that we want to decorate

def get_list():
return [1, 2, 3, 4, 5]
Now we can call the decorator with our new function as an argument:

decorator = reverse_list_decorator(get_list) # This returns a reference to the function

result_from_decorator = decorator() # Here we call the actual function using parenthesis

# We can now print the result in the console

print(result_from_decorator) # [5, 4, 3, 2, 1]
Here is the complete example:

def reverse_list_decorator(input_function):
def function_wrapper():
returned_result = input_function()
reversed_list = returned_result[::-1]
return reversed_list

return function_wrapper
# Function that we want to decorate
def get_list():
return [1, 2, 3, 4, 5]

# This returns a reference to the function

decorator = reverse_list_decorator(get_list)

# Here we call the actual function using the parenthesis

result_from_decorator = decorator()

# We can now print the result in the console

print(result_from_decorator) # [5, 4, 3, 2, 1]
We can also call a decorator using annotations. To do that, we use the @ sign before the name
of the decorator that we want to call and put it right above the name of the function:

# Function that we want to decorate

@reverse_list_decorator # The annotation of the decorator function
def get_list():
return [1, 2, 3, 4, 5]
Now, we can simply call the functionget_list() and the decorator is going to be applied in it:

result_from_decorator = get_list()

print(result_from_decorator) # [5, 4, 3, 2, 1]
How to stack decorators
We can also use more than one decorator for a single function. Their order of execution starts
from top to bottom, meaning that the decorator that has been defined first is applied first, then
the second one, and so on.

Let's do a simple experiment and apply the same decorator that we defined in the previous
section twice.

First let's understand what that means.

So we first call the decorator to reverse a list:

[1, 2, 3, 4, 5] to [5, 4, 3, 2, 1]

Then we apply it again, but now with the returned result from the previous calling of the
decorator:

[5, 4, 3, 2, 1] => [1, 2, 3, 4, 5]

In other words, reversing a list and then reversing that reversed list again is going to return the
original ordering of the list.

Let's see this with decorators:

@reverse_list_decorator
@reverse_list_decorator
def get_list():
return [1, 2, 3, 4, 5]

result = get_list()

print(result) # [1, 2, 3, 4, 5]
I'll explain this with another example.

Let's implement another decorator that only returns numbers that are larger than 1. We then
want to reverse that returned list with our existing decorator.

def positive_numbers_decorator(input_list):
def function_wrapper():
# Get only numbers larger than 0
numbers = [number for number in input_list() if number > 0]
return numbers

return function_wrapper
Now we can call this decorator and the other decorator that we have implemented:

@positive_numbers_decorator
@reverse_list_decorator
def get_list():
return [1, -2, 3, -4, 5, -6, 7, -8, 9]

result = get_list()
print(result) # [9, 7, 5, 3, 1]
Here is the complete example:

def reverse_list_decorator(input_function):
def function_wrapper():
returned_result = input_function()
reversed_list = returned_result[::-1] # Reverse the list
return reversed_list
 return function_wrapper

# First decoorator
def positive_numbers_decorator(input_list):
def function_wrapper():
# Get only numbers larger than 0
numbers = [number for number in input_list() if number > 0]
return numbers

return function_wrapper

# Function that we want to decorate

@positive_numbers_decorator
@reverse_list_decorator
def get_list():
return [1, -2, 3, -4, 5, -6, 7, -8, 9]

result = get_list()
print(result) # [9, 7, 5, 3, 1]
How to pass arguments to decorator functions
We can also pass arguments to decorator functions:

def add_numbers_decorator(input_function):
def function_wrapper(a, b):
result = 'The sum of {} and {} is {}'.format(
a, b, input_function(a, b)) # calling the input function with arguments
return result
return function_wrapper

@add_numbers_decorator
def add_numbers(a, b):
return a + b

print(add_numbers(1, 2)) # The sum of 1 and 2 is 3

Built-in decorators
Python comes with multiple built-in decorators, such as @classmethod, @staticmethod,
@property, and so on. We'll cover these in the next chapter.
Function Wrap Up
Python is an excellent language for writing functions because they are easy to write.

Lambda functions are a great way to make small, concise functions in Python. They're perfect
for when you don't need a full-blown function, or when you just want to test out a snippet of
code.

Python decorators are a great way to improve code readability and maintainability. They allow
you to modularize your code and make it more organized. You can also use them to perform
various tasks such as logging, exception handling, and testing. So if you're looking for a way to
clean up your Python code, consider using decorators.

Object Oriented Programming in Python

If you go to buy a cookie at a local store, you are going to get a version of the cookie that has
been produced in many other copies.

There's a cookie cutter at a factory that has been used to produce a large number of cookies
that are then distributed all throughout different stores where those cookies are then served to
the end customers.

We can think of that cookie cutter as a blueprint that has been designed once and is used many
times afterwards. We also use this sort of blueprint in computer programming.

A blueprint that is used to create countless other copies is called a class. We can think of a
class like a class called Cookie, Factory, Building, Book, Pencil, and so on. We can use the
class of cookie as a blueprint to create as many instances as we want of it that we call objects.

In other words, blueprints are classes that are used as cookie cutters, whereas the cookies that
are served at different stores are objects.

Object Oriented Programming represents a way of organizing a program using classes and
objects. We use classes to create objects. Objects interact with each other.

We do not use the exact same blueprint for every object that is out there. There is a blueprint for
producing books, another one for producing pencils, and so on. We need to categorize them
based on attributes and their functionalities.

An object that is created from the Pencil class can have a color type, a manufacturer, a specific
thickness, and so on. These are the attributes. A pencil object can also write which represents
its functionality, or its method.

We use classes and objects in different programming languages, including Python.

Let's see how a very basic Bicycle class looks in Python:

class Bicycle:
pass
We have used the keyword class to indicate that we are about to start writing a class and then
we type the name of the class.

We have added the pass because we don't want the Python interpreter to yell at us by throwing
errors for not continuing to write the remaining part of the code that belongs to this class.

Now, if we want to create new objects from this class Bicycle, we can simply write the name of
the object (which can be any variable name that you want) and initiailize it with the constructor
method Bicycle() that is used to create new objects:

favorite_bike = Bicycle()
In this case, favorite_bike is an object that is created from the class Bicycle. It gets all the
functionalities and attributes of the class Bicycle.

We can enrich our Bicycle class and include additional attributes so that we can have custom
bikes, tailored to our needs.

To do that, we can define a constructor method called init as follows:

class Bicycle:
def __init__(self, manufacturer, color, is_mountain_bike):
self.manufacturer = manufacturer
self.color = color
self.is_mountain_bike = is_mountain_bike
Note the usage of underscores before and after the name init of the method. They represent
indicators to the Python interpreter to treat that method as a special method.

This is a method that does not return anything. It is a good practice to define it as the first
method of the class, so that other developers can also see it being at a specific line.

Now, if we want to create new objects using this blueprint of bicycles, we can simply write:

bike = Bicycle("Connondale", "grey", True)

We have provided our custom parameters for this bike and are passing them to the constructor
method. Then we get a new bike with those specific attributes in return. As you can probably
tell, we are creating a grey mountain bike of the brand Connondale.

We can also create objects from classes by using optional arguments as follows:

class Bicycle:
 # All the following attributes are optional
def __init__(self, manufacturer=None, color='grey', is_mountain_bike=False):
self.manufacturer = manufacturer
self.color = color
self.is_mountain_bike = is_mountain_bike
Now we have just created this object with these attributes, which are not currently accessible
outside the scope of the class.

This means that we have created this new object from the Bicycle class, but its corresponding
attributes are not accessible. To access them, we can implement methods that help us access
them.

To do that, we are going to define getters and setters, which represent methods that we use to
get and set values of attributes of objects. We are going to use an annotation called @property
to hep us with that.

Let’s see it with code:

class Bicycle:
def __init__(self, manufacturer, color, is_mountain_bike):
self._manufacturer = manufacturer
self._color = color
self._is_mountain_bike = is_mountain_bike

@property
def manufacturer(self):
return self._manufacturer

@manufacturer.setter
def manufacturer(self, manufacturer):
self._manufacturer = manufacturer

bike = Bicycle("Connondale", "Grey", True)

print(bike.manufacturer) # Connondale
We can write getters and setters for all the attributes of the class:

class Bicycle:
def __init__(self, manufacturer, color, is_mountain_bike):
self._manufacturer = manufacturer
self._color = color
self._is_mountain_bike = is_mountain_bike
 @property
def manufacturer(self):
return self._manufacturer

@manufacturer.setter
def manufacturer(self, manufacturer):
self._manufacturer = manufacturer

@property
def color(self):
return self._color

@color.setter
def color(self, color):
self._color = color

@property
def is_mountain_bike(self):
return self._is_mountain_bike

@is_mountain_bike.setter
def is_mountain_bike(self, is_mountain_bike):
self.is_mountain_bike = is_mountain_bike

bike = Bicycle("Connondale", "Grey", True)

Now that we have defined them, we can call these getter methods as attributes:

print(bike.manufacturer) # Connondale
print(bike.color) # Grey
print(bike.is_mountain_bike) # True
We can also modify the value that we initially used for any attribute by simply typing the name of
object and the attribute where we want to change the content:

bike.is_mountain_bike = False
bike.color = "Blue"
bike.manufacturer = "Trek"
Our classes can also have other methods as well and not just getters and setters.

Let's define a method inside the class Bicycle that we can then call from any object that we have
created from that class:

class Bicycle:
def __init__(self, manufacturer, color, is_mountain_bike):
self._manufacturer = manufacturer
 self._color = color
self._is_mountain_bike = is_mountain_bike

def get_description(self):
desc = "This is a " + self._color + " bike of the brand " + self._manufacturer
return desc
We have created a very simple method in which we are preparing a string as a result from the
attributes of the object that we are creating. We can then call this method like any other method.

Let's see this in action:

bike = Bicycle("Connondale", "Grey", True)

print(bike.get_description()) # This is a Grey bike of the brand Connondale

Methods in Python
Methods are similar to functions, which we covered above.

In a nutshell, we group a few statements in a code block called method. There we perform some
operations that we expect to be done more than once and do not want to write them again and
again. In the end, we may not return any result at all.

There are three types of methods in Python:

instance methods
class methods
static methods
Let's briefly talk about the overall structure of methods and then dive a little more into detail for
each method type.

Parameters
Parameters of a method make it possible for us to pass on dynamic values that can then be
taken into consideration when executing the statements that are inside the method.

The return statement represents the statement that is going to be the last one to be executed in
that method. It is an indicator for the Python interpreter to stop the execution of any other line
and return a value.

The self argument

The first argument of a method in Python is self which is also one of the differences between a
method and a function. It represents a reference to the object to which it belongs to. If we don't
specify as the first argument of the method when being declared, the first argument is then
treated as a reference to the object.
We only write it when we declare the method, but we do not need to include it when we invoke
that particular method using an object as a caller.

It is not required that we name it self, but it is a convention that is widely practiced by
developers writing Python code all around the world.

Let's define an instance method inside the class Bicycle that we can then call from any object
that we have created from that class:

class Bicycle:
def __init__(self, manufacturer, color, is_mountain_bike):
self._manufacturer = manufacturer
self._color = color
self._is_mountain_bike = is_mountain_bike

def get_description(self):
desc = "This is a " + self._color + " bike of the brand " + self._manufacturer
return desc
We have created a very simple method in which we are preparing a string as a result from the
attributes of the object that we are creating. We can then call this method like any other method:

bike = Bicycle("Connondale", "Grey", True)

print(bike.get_description()) # This is a Grey bike of the brand Connondale

# We are not passing any argument when calling the method get_description() since we do not
need to include self at all
Class methods
We have covered instance methods so far. These are methods that we can call with objects.

Class methods are methods that we can call using class names and that we can access without
needing to create any new object at all.

Since it is a specific type of method, we need to tell the Python interpreter that it is actually
different. We do that by making a change in the syntax.

We use the annotation @classmethod above a class method and cls similar to the usage of self
for instance methods. cls is just a conventional way of referring to the class that is calling the
method – you don't have to use this name.

Let's declare our first class method:

class Article:
blog = 'https://www.python.org/'
 # the init method is called when an instance of the class is created
def __init__(self, title, content):
self.title = title
self.content = content

@classmethod
def get_blog(cls):
return cls.blog
Now let's call this class method that we have just declared:

print(Article.get_blog()) # https://www.python.org/
Note that we did not have to write any argument when calling the get_blog() method. On the
other hand, when we declare methods and instance methods, we should always include at least
one argument.

Static methods
These are methods that do not have direct relations to class variables or instance variables. You
can think of them as utility functions that are supposed to help us do something with arguments
that are passed when calling them.

We can call them by using both the class name and an object that is created by that class where
this method is declared. This means that they do not need to have their first argument related to
the object or class calling them (as was the case with using parameters self for instance
methods and cls for class methods).

There is no limit to the number of arguments that we can use to call them.

To create it, we need to use the @staticmethod annotation.

Let's create a static method:

class Article:
blog = 'https://www.python.org/'

# the init method is called when an instance of the class is created

def __init__(self, title, content):
self.title = title
self.content = content

@classmethod
def get_blog(cls):
return cls.blog

@staticmethod
 def print_creation_date(date):
print(f'The blog was created on {date}')

article = Article('First Article', 'This is the first article')

# Calling the static method using the object

article.print_creation_date('2022-07-18') # The blog was created on 2022-07-18

# Calling the static method using the class name

Article.print_creation_date('2022-07-21') # The blog was created on 2022-07-21
Static methods cannot modify class or instance attributes. They are meant to be like utility
functions.

If we try to change a class, we are going to get errors:

class Article:
blog = 'https://www.python.org/'

# the init method is called when an instance of the class is created

def __init__(self, title, content):
self.title = title
self.content = content

@classmethod
def get_blog(cls):
return cls.blog

@staticmethod
def set_title(self, date):
self.title = 'A random title'

If we try to call this static method now, we are going to get an error:

# Calling the static method using the class name

Article.set_title('2022-07-21')
TypeError: set_title() missing 1 required positional argument: 'date'
This is because static methods do not have any reference to self as they are not directly related
to objects or classes and so they cannot modify attributes.

Access modifier
When creating classes, we can restrict access to certain attributes and methods so that they are
not accessible that easily.
We have publicand private access modifiers.

Let's see how both of them work.

Public attributes
Public attributes are the ones that are accessible from both inside and outside the class.

By default, all attributes and methods are public in Python. If we want them to be private, we
need to specify that.

Let's see an example of public attributes:

class Bicycle:
def __init__(self, manufacturer, color, is_mountain_bike):
self.manufacturer = manufacturer
self.color = color
self.is_mountain_bike = is_mountain_bike

def get_manufacturer(self):
return self.manufacturer
In the previous code block, both color and get_manufacturer() are accessible outside the class
since they are public and can be accessed both inside and outside the class:

bike = Bicycle("Connondale", "Grey", True)

print(bike.color) # Grey
print(bike.get_manufacturer()) # Connondale
Private attributes
Private attributes can be accessed directly only from inside the class.

We can make properties attributes by using the double underscore, as you can see in the
following example:

class Bicycle:
def __init__(self, manufacturer, color, is_mountain_bike, old):
self.manufacturer = manufacturer
self.color = color
self.is_mountain_bike = is_mountain_bike
self.__old = old # This is a private property
Now if we try to access __old, we are going to get an error:

bike = Bicycle("Connondale", "Grey", True, False)

print(bike.__old) # AttributeError: 'Bicycle' object has no attribute '__old'

Let's now see an example where we are declaring private methods using the double underscore
in front of the name of the method that we want to make private:

class Bicycle:
def __init__(self, manufacturer, color, is_mountain_bike, old):
self.manufacturer = manufacturer
self.color = color
self.is_mountain_bike = is_mountain_bike
self.__old = old # This is a private property

def __get_old(self): # This is a private method

return self.__old
Now, if we want to call this private method from outside the class, an error is going to be thrown:

bike = Bicycle("Connondale", "Grey", True, False)

print(bike.__get_old()) # AttributeError: 'Bicycle' object has no attribute '__get_old'

It is not a common practice to have private variables in Python. However, developers may find it
necessary to restrict access so that specific variables are not carelessly accessed and modified.

How to Hide Information in Python

When you go out there and use a coffee machine, you aren't expected to know all the
engineering details that are behind that machine.

This is the same with your car. When you sit in your driver's seat, you do not analyze and
understand all the details of every part of the car. You have some basic idea about them, but
other than that, you just focus on driving.

This is a sort of restriction of access from people outside, so that they do not have to worry
about exact details that are going on inside.

We can do that in Python as well.

We have seen so far the foundational blocks of object oriented programming, such as classes
and objects.

Classes are blueprints that are used to create instances called objects. We can use objects of
different classes to interact with each other and build a robust program.

When we work on our own programs, we may need to not let everyone know about all the
details that our classes have. So we can limit access to them, so that certain attributes are less
likely to be accessed unintentionally and be modified wrongfully.
To help us with that, we hide parts of a class and simply provide an interface that has fewer
details about the inner workings of our class.

We can hide data in two ways:

Encapsulation
Abstraction
Let's begin with Encapsulation.

What is Encapsulation?
Encapsulation is not something special and unique just for Python. Other programming
languages use it as well.

In a nutshell, we can define it as binding data and methods in a class. We then use this class to
create objects.

We encapsulate classes by using private access modifiers that can then restrict direct access to
such attributes. This can restrict control.

We are then supposed to write public methods that can provide access to the outside world.

These methods are called getters and setters.

A getter method is a method that we use to get the value of an attribute.

A setter is a method that we use to set the value of an attribute.

Let's define first define a getter and a setter method that we can use to get values:

class Smartphone:
def __init__(self, type=None): # defining initializer for case of no argument
self.__type = type # setting the type here in the beginning when the object is created

def set_type(self, value):

self.__type = value

def get_type(self):
return (self.__type)
Now, let's use this class to set the type and also get the type:

smartphone = Smartphone('iPhone') # we are setting the type using the constructor method

# getting the value of the type

print(smartphone.get_type()) # iPhone
# Changing the value of the type
smartphone.set_type('Samsung')

# getting the new value of the type

print(smartphone.get_type()) # Samsung
What we have done so far is set and also read the value of a private attribute of an object
created from the Smartphone class.

We can also define getters and setters using the @property annotation.

Let’s see it with code:

class Bicycle:
def __init__(self, manufacturer, color):
self._manufacturer = manufacturer
self._color = color

@property
def manufacturer(self):
return self._manufacturer

@manufacturer.setter
def manufacturer(self, manufacturer):
self._manufacturer = manufacturer

@property
def color(self):
return self._color

@color.setter
def color(self, color):
self._color = color

bike = Bicycle("Connondale", "Grey")

Now that we have defined them, we can call these getter methods as attributes:

print(bike.manufacturer) # Connondale
print(bike.color) # Grey
We can also modify the value that we initially used for any attribute by simply typing the name of
the object and the attribute that we want to modify:

bike.is_mountain_bike = False
bike.color = "Blue"
Our classes can also have other methods as well, and not just getters and setters.

Let's define a method inside the class Bicycle that we can then call from any object that we have
created from that class:

class Bicycle:
def __init__(self, manufacturer, color, is_mountain_bike):
self._manufacturer = manufacturer
self._color = color
self._is_mountain_bike = is_mountain_bike

def get_description(self):
desc = "This is a " + self._color + " bike of the brand " + self._manufacturer
return desc
We have created a very simple method in which we are preparing a string as a result from the
attributes of the object that we are creating. We can then call this method like any other method.

Let's see this in action:

bike = Bicycle("Connondale", "Grey", True)

print(bike.get_description()) # This is a Grey bike of the brand Connondale

But why do we need encapsulation?
This looks quite promising and fancy, but you may not get it quite yet. You might need some
additional reasons why you need this type of hiding.

To drive this home, let's take another class, where we have a private attribute called salary. Let's
say that we don't care about encapsulation and we are only trying to build a class fast and use it
in our project for our accountant client.

Let's say that we have the following class:

class Employee:
def __init__(self, name=None, email=None, salary=None):
self.name = name
self.email = email
self.salary = salary
Now, let's create a new employee object and initialize its attributes accordingly:

# We are creating an object

betim = Employee('Betim', '[email protected]', 5000)

print(betim.salary) # 5000
Since salary is not being protected in any way, we can set a new salary for this new object
without any problem:

betim.salary = 25000

print(betim.salary) # 25000
As we can see, this person got five times the salary of what he was getting previously without
going through any type of evaluation or interviewing at all. In fact, it happened in a matter of
seconds. That's probably going to hit the budget of the company heavily.

We do not want to do that. We want to restrict access to the salary attribute so that it is not
called from other places. We can do that by using the double underscore before the attribute
name as you can see below:

class Employee:
def __init__(self, name=None, email=None, salary=None):
self.__name = name
self.__email = email
self.__salary = salary
Let's create a new object:

# We are creating an object

betim = Employee('Betim', '[email protected]', 1000)
Now, if we try to access its attributes, we cannot do so, since they are private attributes:

print(betim.salary) # 1000
Trying to access any of the attributes is going to be followed with an error:

AttributeError: 'Employee' object has no attribute 'salary'

We can simply implement a method that returns the attributes but we are not providing any way
for someone to increase their salary sneakily:

class Employee:
def __init__(self, name=None, email=None, salary=None):
self.__name = name
self.__email = email
self.__salary = salary

def get_info(self):
return self.__name, self.__email, self.__salary
Now, we can access the information of objects created by this class:

# We are creating an object

betim = Employee('Betim', '[email protected]', '5000')
print(betim.get_info()) # ('Betim', '[email protected]', '5000')
In summary, encapsulation helps us protect properties of objects and provides access them in a
controlled fashion.

Inheritance in Python
In real life, we can share many characteristics with other human beings.

We all need to eat food, drink water, work, sleep, move, and so on. These and many other
behaviors and characteristics are shared among billions of people all around the world.

They are not something unique that only our generation has. These traits have been around as
long as humans have.

This is also something that is going to last for future generations to come.

We can also have certain shared characteristics between objects and classes that we
implement ourselves in computer programming using inheritance. This includes both attributes
and methods.

Let's imagine that we have a class called Book. It should contain a title, an author, a number of
pages, a category, an ISBN, and so on. We are going to keep our class simple and use only two
attributes:

class Book:
def __init__(self, title, author):
self.title = title
self.author = author

def get_short_book_paragraph(self):
short_paragraph = "This is a short paragraph of the book."
return short_paragraph
Now, we can create an object from this class and access it:

first_book = Book("Atomic Habits", "James Clear")

print(first_book.title) # Atomic Habits

print(first_book.author) # James Clear
print(first_book.get_short_book_paragraph()) # This is a short paragraph of the book.
Let's now create a subclass of the class Book that inherits attributes and methods from the class
Book, but also has an additional method called get_book_description():

class Book:
def __init__(self, title, author):
 self.title = title
self.author = author

def get_short_book_paragraph(self):
short_paragraph = "This is a short paragraph of the book."
return short_paragraph

class BookDetails(Book):
def __init__(self, title, author):
Book.__init__(self, title, author)
# Here we are call the constructor of the parent class Book

def get_book_details(self):
description = "Title: " + self.title + ". "
description += "Author: " + self.author
return description
Note the syntax in which we tell Python that BookDetails is a subclass of the class Book:

class BookDetails(Book):
If we try to access this new method from objects of the class Book, we are going to get an error:

first_book = Book("Atomic Habits", "James Clear")

print(first_book.get_book_details())
# AttributeError: 'Book' object has no attribute 'get_book_details'
This happens because this method get_book_details() can be accessed only from objects of
BookDetails:

first_book_details = BookDetails("Atomic Habits", "James Clear")

print(first_book_details.get_book_details())
# Title: Atomic Habits. Author: James Clear
We can, however, access any method that is defined in the parent class, which in our case is
the Book class:

first_book_details = BookDetails("Atomic Habits", "James Clear")

print(first_book_details.get_short_book_paragraph())
# This is a short paragraph of the book.
In the previous classes, Book is considered a parent class or a superclass, whereas
BookDetails is considered a child class, or a subclass.

super() function
There is a special function called super() that we can use from a child class to refer to its parent
class without writing the exact name of the parent class.

We use it with initializers, or when calling properties or methods of parent classes.

Let's see all three of them illustrated with examples.

How to use super() with initializers

We can use super() inside the constructor method of the subclass and even call the constructor
of the super class:

class Animal():
def __init__(self, name, age):
self.name = name
self.age = age

class Cat(Animal):
def __init__(self, name, age):
super().__init__(name, age) # calling the parent class constructor
self.health = 100 # initializing a new attribute that is not in the parent class
We can also replace super() with the name of the parent class, which is going to work in the
same way again:

class Animal():
def __init__(self, name, age):
self.name = name
self.age = age

class Cat(Animal):
def __init__(self, name, age):
Animal.__init__(name, age) # calling the parent class constructor
self.health = 100 # initializing a new attribute that is not in the parent class
Even changing the order of the lines inside the child's constructor will not cause any error at all.

How to use super() with class properties of the parent class

We can use super() to access class properties of the parent class, which can be useful
especially when both the parent and the child class use the same name for an attribute.

To see that in action, let's assume that we have a class attribute called name which is present
both in the parent and the child class. We want to access this variable from both the parent
class and the child class.
To do that, we simply need to write super() and then the name of the variable:

class Producer: # parent class

name = 'Samsung'

class Seller(Producer): # child class

name = 'Amazon'

def get_product_details(self):
# Calling the variable from the parent class
print("Producer:", super().name)

# Calling the variable from the child class

print("Seller:", self.name)
Now, if we call method get_product_details(), we are going to get the following printed in the
console:

seller = Seller()

seller.get_product_details()

# Producer: Samsung
# Seller: Amazon
How to use super() with methods of the parent class
We can similarly call methods in the parent class using super().

class Producer: # parent class

name = 'Samsung'

def get_details(self):
return f'Producer name: {self.name}'

class Seller(Producer): # child class

name = 'Amazon'

def get_details(self):
# Calling the method from the parent class
print(super().get_details())

# Calling the variable from the child class

print(f'Seller name: {self.name}')
seller = Seller()
seller.get_details()

# Producer name: Amazon

# Seller name: Amazon
This is all you need to know about super().

Types of inheritance
We can have different types of inheritance based on the relationship of parent classes and child
classes:

Single
Multi-level
Hierarchical
Multiple
Hybrid
1. Single inheritance
We can have a class that inherits only from another class:

class Animal:
def __init__(self):
self.health = 100

def get_health(self):
return self.health

class Cat(Animal):
def __init__(self, name):
super().__init__()
self.health = 150
self.name = name

def move(self):
print("Cat is moving")

cat = Cat("Cat")

# Calling the method from the parent class

print(cat.get_health()) # 150

# Calling the method from the child class

cat.move() # Cat is moving
2. Multi-level inheritance
This is another type of inheritance where a class inherits from another class which inherits from
another class: Class A inherits from Class B which inherits from Class C.

Let's implement this in Python:

class Creature:
def __init__(self, alive):
self.alive = alive

def is_it_alive(self):
return self.alive

class Animal(Creature):
def __init__(self):
super().__init__(True)
self.health = 100

def get_health(self):
return self.health

class Cat(Animal):
def __init__(self, name):
super().__init__()
self.name = name

def move(self):
print("Cat is moving")

cat = Cat("Cat")

# Calling the method from the parent of the parent class

print(cat.is_it_alive())

# Calling the method from the parent class

print(cat.get_health()) # 150

# Calling the method from the child class

cat.move() # Cat is moving
3. Hierarchical inheritance
When we derive multiple child classes from the same parent class, then we have hierarchical
inheritance. These child classes inherit from the parent class:

class Location:
def __init__(self, x, y):
self.x = x
self.y = y

def get_location(self):
return self.x, self.y

class Continent(Location):
pass

class Country(Location):
pass

continent = Continent(0, 0)
print(continent.get_location()) # (0, 0)

country = Country(10, 30)

print(country.get_location()) # (10, 30)
4. Multiple inheritance
We can have another type of inheritance, namely multiple inheritance which can help us inherit
from more than one class at the same time.

Let's assume that we have a class called Date and another one called Time.

We can then implement another class then inherits from both classes:

class Date:
date = '2022-07-23' # Hardcoded date

def get_date(self):
return self.date

class Time:
time = '20:20:20' # Hardcoded time

def get_time(self):
 return self.time

class DateTime(Date, Time): # Inheriting from both

def get_date_time(self):
return self.get_date() + ' ' + self.get_time() # getting methods from its parent classes

date_time = DateTime()
print(date_time.get_date_time()) # 2022-07-23 20:20:20
5. Hybrid inheritance
Hybrid inheritance is a combination of multiple and multi-level inheritance:

class Vehicle:
def print_vehicle(self):
print('Vehicle')

class Car(Vehicle):
def print_car(self):
print('Car')

class Ferrari(Car):
def print_ferrari(self):
print('Ferrari')

class Driver(Ferrari, Car):

def print_driver(self):
print('Driver')
Now, if we create an object from the class Driver, we can call all methods in all classes:

driver = Driver()

# Calling all methods from the subclass

driver.print_vehicle() # Vehicle
driver.print_car() # Car
driver.print_ferrari() # Ferrari
driver.print_driver() # Driver
Polymorphism in Python
This is another important concept from Object Oriented Programming that refers to the
possibility of an object behaving like different forms and calling different behaviors.
An example of a built-in function that uses polymorphism is the method len() which can be used
for both strings and lists:

print(len('Python')) # 6

print(len([2, 3, -43])) # 3
We can take another example with a class called House. We can have different subclasses that
inherit methods and attributes from that superclass, namely classes such as Condo, Apartment,
SingleFamilyHouse, MultiFamilyHouse, and so on.

Let's assume that we want to implement a method in the House class that is supposed to get
the area.

Each type of living residence has a different size, so each one of the subclasses should have
different implementations.

Now we can define methods into subclasses such as:

getAreaOfCondo()
getAreaOfApartment()
getAreaOfSingleFamilyHouse()
getAreaOfMultiFamilyHouse()
This would force us to remember the names of each subclass, which can be tedious and also
prone to errors when we call them.

Luckily, there is a simpler method that we can use that comes from polymorphism.

We can have polymorphism using both methods and inheritance.

Let's first see how we can implement polymorphism using methods.

Polymorphism using methods

Let's say that we have two classes, namely Condo and Apartment. Both of them have the
method get_area() that returns a value.

Each of them is going to have a custom implementation.

Now the method that we are going to call depends on the class type of the object:

class Condo:
def __init__(self, area):
self.area = area

def get_area(self):
 return self.area

class Apartment:
def __init__(self, area):
self.area = area

def get_area(self):
return self.area
Let's create two objects from these classes:

condo = Condo(100)

apartment = Apartment(200)
Now, we can put both of them in a list and call the same method for both objects:

places_to_live = [condo, apartment]

for place in places_to_live:

print(place.get_area()) # same method for both objects
After we execute that, we are going to see the following in the console:

# 100
# 200
This is how you implement polymorphism with methods.

Polymorphism with inheritance

We can not only call a method from a superclass. We can also use the same name but have a
different implementation for it for each subclass.

Let's first define a superclass:

class House:
def __init__(self, area):
self.area = area

def get_price(self):
pass
Then we'll implement subclasses Condo and Apartment of the superclass House:

class House:
def __init__(self, area):
self.area = area
 def get_price(self):
pass

class Condo(House):
def __init__(self, area):
self.area = area

def get_price(self):
return self.area * 100

class Apartment(House):
def __init__(self, area):
self.area = area

def get_price(self):
return self.area * 300
As we can see, both subclasses have the method get_price() but different implementations.

We can now create new objects from subclasses and call this method which is going to
polymorph based on the object that calls it:

condo = Condo(100)

apartment = Apartment(200)

places_to_live = [condo, apartment]

for place in places_to_live:

print(place.get_price())
After we execute that, we are going to see the following in the console:

# 10000
# 60000
This is another example of polymorphism where we have specific implementation of a method
that has the same name.

Importing in Python
One of the main benefits of using a popular language such as Python is its large number of
libraries that you can use and benefit from.
Many developers around the world are generous with their time and knowledge and publish a lot
of really useful libraries. These libraries can save us plenty of time both in our professional work,
but also on our side projects that we may do for fun.

Here are some of the modules with very useful methods that you can immediately start using in
your projects:

time: Time access and conversions

csv: CSV File Reading and Writing
math: Math functions
email: Create, send, and process email
urllib: Work with URLs
To import one or more modules, we only need to write import and then the name of the modules
that we want to import.

Let's import our first module:

import os
Now, let's import multiple modules at once:

import os, numbers, math

Once we have imported a module, we can start using methods that are inside it.

import math

print(math.sqrt(81)) # 9.0
We can also use new names for our imported modules by specifying an alias for them as alias
where alias is any variable name that you want:

import math as math_module_that_i_just_imported

result = math_module_that_i_just_imported.sqrt(4)

print(result) # 2.0
How to Limit What We Want to Import
There are times when we do not want to import a whole package with all its methods. This is
because we want to avoid overriding methods or variables that are in the module with the ones
that we want to implement ourselves.

We can specify parts that we want to import by using the following form:

from module import function

Let's take an example of importing only the square root function from math module:
from math import sqrt

print(sqrt(100)) # 10.0
Issues with Importing Everything from a Module
We can also import everything from a module, which can turn out to be a problem. Let's
illustrate this with an example.

Let's assume that we want to import everything that is included in the math module. We can do
that by using the asterisk like this:

from math import * # The asterisk is an indicator to include everything when importing
Now, let's assume that we want to declare a variable called sqrt:

sqrt = 25
When we try to call the function sqrt() from the math module, we are going to get an error, since
the interpreter is going to call the latest sqrt variable that we have just declared in the previous
code block:

print(sqrt(100))
TypeError: 'float' object is not callable
How to Handle Exceptions in Python
When we are implementing Python scripts or doing any type of implementation, we are going to
get many errors that are thrown even when the syntax is correct.

These types of errors that happen during execution are called exceptions.

We indeed do not have to surrender and not do anything regarding them. We can write handlers
that are there to do something so that the execution of the program does not stop.

Common Exceptions in Python

Here are some of the most common exceptions that happen in Python with definitions taken
from the Python documentation:

Exception – This is a class that is as a superclass of most other exception types that happen.
NameError – Raised when a local or global name is not found.
AttributeError – Raised when an attribute reference or assignment fails.
SyntaxError – Raised when the parser encounters a syntax error.
TypeError – Raised when an operation or function is applied to an object of inappropriate type.
The associated value is a string giving details about the type mismatch.
ZeroDivisionError – Raised when the second argument of a division or modulo operation is
zero.
IOError – Raised when an I/O operation (such as a print statement, the built-in open() function
or a method of a file object) fails for an I/O-related reason, e.g., “file not found” or “disk full”.
ImportError – Raised when an import statement fails to find the module definition or when a
from … import fails to find a name that is to be imported.
IndexError – Raised when a sequence subscript is out of range.
KeyError – Raised when a mapping (dictionary) key is not found in the set of existing keys.
ValueError – Raised when a built-in operation or function receives an argument that has the
right type but an inappropriate value, and the situation is not described by a more precise
exception such as IndexError.
There are many other error types, but you don't really need to see about them now. It is also
very unlikely that you are going to see all types of errors all the time.

You can see more types of exception in the Python documentation.

How to Handle Exceptions in Python

Let's start with a very simple example and write a program that throws an error on purpose so
that we can then fix it.

We are going to do a division by zero, which is something that you have probably seen at
school:

print(5 / 0)
If we try to execute that, we are going to be greeted with the following error in the console:

ZeroDivisionError: division by zero

If we were to have such occurrences inside a Python program of any kind, we should catch and
wrap this error inside a try/except block.

We need to write inside the try block the part of the code that we expect is going to throw errors.
We then catch those types of errors inside the except block by also specifying the type of error
that we except to happen.

Let's see the first example.

Let's see how we can deal with that error so that we also get informed that such error
happened:

try:
5/0
except ZeroDivisionError:
print('You cannot divide by 0 mate!')
As you can see, we are printing a message in the console once we have reached the part
where a division by 0 is happening.

We can also omit the part ZeroDivisionError completely:

try:
5/0
except:
print('You cannot divide by 0 mate!')
However, this is not recommended, since we are catching all types of errors in a single except
block and we are not sure what type of errors are being caught (which would be quite useful for
us).

Let's continue with another type of error.

Now we'll try to use a variable that is not defined at all:

name = 'User'

try:
person = name + surname # surname is not declared
except NameError:
print('A variable is not defined')
In the previous example, we have used variable surname before declaring it, therefore a
NameErroris going to be thrown.

Let's continue with another example that can be quite common.

When we use lists, it can be a common mistake to use an index that is out of range. This means
that the index we've used is larger or smaller than the range of indexes of the elements in that
list.

Let's illustrate this with an example, where an IndexError is going to be thrown:

my_list = [1, 2, 3, 4]

try:
​ print(my_list[5])
# This list only has 4 elements, so its indexes range from 0 to 3
except IndexError:
print('You have used an index that is out of range')
We can also use a single try block with multiple except errors:

my_list = [1, 2, 3, 4]

try:
print(my_list[5])
# This list only has 4 elements, so its indexes range from 0 to 3
except NameError:
 print('You have used an invalid value')
except ZeroDivisionError:
print('You cannot divide by zero')
except IndexError:
print('You have used an index that is out of range')
In the previous example, we try to initially catch whether there is any variable that is used but
not declared. If this error happens, then this except block is going to be taking over the
execution flow. This execution flow is going to stop there.

Then, we try to check whether we are dividing by zero. If this error is thrown, then this except
block is going to take over the execution and everything that is inside it is going to be executed.
Similarly, we continue with the rest of the errors declared.

We can also put more than one error inside parenthesis to catch multiple exceptions. But this is
not going to be helpful for us, since we do not know what specific error has been thrown. In
other words, the following method does work, but it is not recommended:

my_list = [1, 2, 3, 4]

try:
print(my_list[5])
# This list only has 4 elements, so its indexes range from 0 to 3
except (NameError, ZeroDivisionError, IndexError):
print('A NameError, ZeroDivisionError, or IndexError occurred')
The finally keyword
After the try and except are passed, there is another block that we can declare and execute.
This block starts with the finally keyword and it is executed no matter whether we have an error
is being thrown or not:

my_list = ['a', 'b']

try:
print(my_list[0])
except IndexError:
print('An IndexError occurred')
finally:
print('The program is ending. This is going to be executed.')
If we execute the previous block of code, we are going to see the following in the console:

The program is ending. This is going to be executed.

We usually write code that we want to be as a cleanup inside the finally block. This includes
things like closing a file, stopping a connection with a database, exiting the program entirely, and
so on.
try, else, except
We can write statements inside try and except, but we can also use an else block where we can
write code that we want to be executed if there are no errors being thrown:

my_list = ['a', 'b']

try:
print(my_list[0])
except IndexError:
print('An IndexError occurred')
else:
print('No error occurred. Congratulations!')
If we execute the code above, we are going to get the following printed in the console:

No error occurred. Congratulations!

Exception wrap up
Hopefully you now understand exceptions and the various ways that you can use to handle
them. If you handle them correctly, there shouldn't be any sudden interruptions that cause your
program to fail unexpectedly.

User Input in Python

When you want to develop an interactive program and get user input in the command line, you
can call a function called input().

It is very simple and all you have to do is declare a variable where you want to save the value
that the user types:

user_input = input("Please type in your name.")

We can than use that value and print it:

print(f'Hello {user_input}. Nice to have you here')

Wrapping Up
This book represents my attempt to make it quick and easy for you to learn the essentials of
Python. There are many other things to know about Python that I didn't cover in this book, but
we will leave it here.

I hope this is a useful reference for you.

Now that you have had the chance to learn how to write Python, go out there and make a
positive impact with your lines of code.

Get the book as a PDF

You can read this book as a PDF by downloading it here.
ADVERTISEMENT

freeCodeCamp.org © 2022