1. Data Types

Built-in Data Types

Text Type

Numeric Types

Sequence Types

Mapping Type

Set Types

Boolean Type

Binary Types

None Type

Setting the Specific Data Type

2. Built in Functions

3. Strings

Definition

A sequence of characters and can contain letters, numbers, symbols and even spaces.

String Length

    phrase = "Hello, World"
    print(len((phrase))
    returns 13
        

String Concatenation

    a = 'Hello'
    b = 'World'
    phrase = a + " " + b
    print(phrase)
    returns "Hello World"
        

Format Strings or f-String

F-string allows you to format selected parts of a string.
To specify a string as an f-string, simply put an f in front of the string literal, like this:

    txt = f"The price is 49 dollars"
    print(txt)
        

Placeholders and Modifiers

• To format values in an f-string, add placeholders {} , a placeholder can contain variables, operations, functions, and modifiers to format the value.

    price = 59
    txt = f"The price is {price} dollars"
    print(txt)
    returns "The price is 59 dollars"
        

• A placeholder can also include a modifier to format the value. A modifier is included by adding a colon : followed by a legal formatting type, like .2f which means fixed point number with 2 decimals:

    price = 59
    txt = f"The price is {price:.2f} dollars"
    print(txt)
    returns "The price is 59.00 dollars"
        

• You can also format a value directly without keeping it in a variable:

    txt = f"The price is {95:.2f} dollars"
    print(txt)
    returns "The price is 59.00 dollars"
        

Perform Operations in F-Strings

You can perform Python operations inside the placeholders.
• Perform a math operation in the placeholder, and return the result:

    txt = f"The price is {20 * 59} dollars"
    print(txt)
    returns "The price is 1180 dollars"
        

• Add taxes before displaying the price:

    price = 59
    tax = 0.25
    txt = f"The price is {price + (price * tax)} dollars"
    print(txt)
    returns "The price is 73.75 dollars"
        

• You can perform if...else statements inside the placeholders:

    price = 49
    txt = f"It is very {'Expensive' if price>50 else 'Cheap'}"
    print(txt)
    returns "It is very Cheap"
        

Execute Functions in F-Strings

You can execute functions inside the placeholder.
• Use the string method upper()to convert a value into upper case letters:

    fruit = "apples"
    txt = f"I love {fruit.upper()}"
    print(txt)
    returns "I love APPLES"
        

• The function does not have to be a built-in Python method, you can create your own functions and use them:

    def myconverter(x):
        return x * 0.3048

    txt = f"The plane is flying at a {myconverter(30000)} meter altitude"
    print(txt)
    returns "The plane is flying at a 9144.0 meter altitude"
        

Formatting Types

There are several modifiers that can be used to format values.

Modify Strings

String Methods

Escape Characters

4. Variables

Definition

Variables are containers for storing data values.

Creating Variables

A variable is created the moment you first assign a value to it. (Note: Python has no command for declaring a variable.)
eg. x = 5

Variable Names

• A variable name must start with a letter or the underscore character.
• A variable name 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 (age, Age and AGE are three different variables)
• A variable name cannot be any of the Python keywords.

examples

myvar = "John"
my_var = "John"
_my_var = "John"
myVar = "John"
MYVAR = "John"
myvar2 = "John"

Python Keywords

Variable techniques

class="python_heading3">Camel Case

• Each word, except the first, starts with a capital letter. eg. myVariableName = "John"

class="python_heading3">Pascal Case

• Each word starts with a capital letter. eg. MyVariableName = "John"

class="python_heading3">Snake Case

• Each word is separated by an underscore character. e.g. my_variable_name = "John"

Assign Multiple Values

• Python allows you to assign values to multiple variables in one line. eg. x, y, z = "Orange", "Banana", "Cherry"
• Assign the same value to multiple variables in one line. eg. x = y = z = "Orange"
• If you have a collection of values in a list, tuple etc. Python allows you to extract the values into variables.

    fruits = ["apple", "banana", "cherry"]
    x, y, z = fruits
        

Output Variables

• The Python print() function is often used to output variables.

    x = "Python is awesome"
    print(x)
        

• In the print() function, you output multiple variables, separated by a comma.

    x = "Python"
    y= "is"
    z = "awesome"
    print(x, y, z)
        

• You can also use the + operator to output multiple variables.

    x = "Python"
    y= "is"
    z = "awesome"
    print(x + y + z)
        

(Note: Notice the space character after "Python " and "is ", without them the result would be "Pythonisawesome".)
• For numbers, the + character works as a mathematical operator.

    x = 5
    y = 10
    print(x + y)
        

Note: In the print() function, when you try to combine a string and a number with the + operator, Python will give you an error

Note: The best way to output multiple variables in the print() function is to separate them with commas, which even support different data types.

    x = 5
    y = "John"
    print(x, y)
        

Global and Local Variables

class="python_heading3">Global

Variables that are created outside of a function are known as global variables. Global variables can be used by everyone, both inside of functions and outside.

    x = "awesome"

    def myfunc():
        print("Python is " + x)

    myfunc()
        

class="python_heading3">Local

If you create a variable with the same name inside a function, this variable will be local, and can only be used inside the function. The global variable with the same name will remain as it was, global and with the original value.

    x = "awesome"

    def myfunc():
        x = "fantastic"
        print("Python is " + x)  # returns "Python is fantastic"

    myfunc()

    print("Python is " + x)  

    => returns "Python is awesome"
        

class="python_heading3">Global Keyword

Normally, when you create a variable inside a function, that variable is local, and can only be used inside that function. To create a global variable inside a function, you can use the global keyword.
• If you use the global keyword, the variable belongs to the global scope.

    def myfunc():
        global x
        x = "fantastic"

    myfunc()

    print("Python is " + x) 
        

Note: Also, use the global keyword if you want to change a global variable inside a function.

• To change the value of a global variable inside a function, refer to the variable by using the global keyword.

    x = "awesome"

    def myfunc():
        global x
    x = "fantastic"

    myfunc()

    print("Python is " + x)
        

5. Operators

Arithmetic Operators

Arithmetic operators are used with numeric values to perform common mathematical operations.

Assignment Operators

Assignment operators are used to assign values to variables.

Comparison Operators

Comparison operators are used to compare two values.

Logical Operators

Logical operators are used to combine conditional statements.

Identity Operators

Identity operators are used to compare the objects, not if they are equal, but if they are actually the same object, with the same memory location.

Membership Operators

Membership operators are used to test if a sequence is presented in an object.

Bitwise Operators

Bitwise operators are used to compare (binary) numbers.

Operator Precedence

Operator precedence describes the order in which operations are performed.

The precedence order is described in the table below, starting with the highest precedence at the top:

Note: If two operators have the same precedence, the expression is evaluated from left to right.

    print(5 + 4 - 7 + 3)
    returns 5
    (5 + 4 = 9, 9 - 7 = 2, 2 + 3 = 5)
        

6. Collection Types (Arrays)

Python does not have built-in support for Arrays, but Collections can be used instead.

There are four collection data types in the Python programming language:
• List is a collection which is indexed, ordered and changeable. Allows duplicate members.
• Tuple is a collection which is ordered and unchangeable. Allows duplicate members.
• Dictionary is a collection which is ordered and changeable. No duplicate members.
• Set is a collection which is unordered, unchangeable*, and unindexed. No duplicate members.

7. Lists

Definition

Lists are used to store multiple items in a single variable. Lists are created using square brackets.

List Items (Indexed)

List items are indexed, the first item has index [0], the second item has index [1] etc.

Ordered

When we say that lists are ordered, it means that the items have a defined order, and that order will not change. If you add new items to a list, the new items will be placed at the end of the list.

Changeable

The list is changeable, meaning that we can change, add, and remove items in a list after it has been created.

Allow Duplicates

Since lists are indexed, lists can have items with the same value. e.g. this_list = ["apple", "banana", "cherry", "apple", "cherry"]

List Methods

List length

To determine how many items a list has, use the len() function.

    this_list = ["apple", "banana", "cherry"]
    print(len((thislist))
    returns 3
        

List Data Type

• String e.g. list1 = ["apple", "banana", "cherry"]
• Integer eg. list2 = [1, 5, 7, 9, 3]
• Boolean eg. list3 = [True, False, False]

Note: A list can contain different data types. e.g. this_list = ["abc", 34, True, 40, "male"]

type()

From Python's perspective, lists are defined as objects with the data type 'list'.

    mytuple = ("apple", "banana", "cherry")
    print(type(mytuple))
    returns class 'list'
        

The list() Constructor

It is also possible to use the list() constructor when creating a new list.
e.g. this_list = list(("apple", "banana", "cherry")) ** note the double round-brackets.

Access List

1. Accessing

List items are indexed and you can access them by referring to the index number.

    this_list = ["apple", "banana", "cherry"]
    print(this_list[1])
    returns "banana"
        

2. Negative Indexing

Negative indexing means start from the end. -1 refers to the last item, -2 refers to the second last item etc.

    thislist = ["apple", "banana", "cherry"]
    print(thislist[-1])
    returns "cherry"
        

3. Range of Indexes

You can specify a range of indexes by specifying where to start and where to end the range. When specifying a range, the return value will be a new list with the specified items.

    thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
    print(thislist[2:5])
    returns ['cherry', 'orange', 'kiwi']
        

    thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
    print(thislist[:4])
    returns ['apple', 'banana', 'cherry', 'orange'] 
        

    thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
    print(thislist[2:])
    returns ['cherry', 'orange', 'kiwi', 'melon', 'mango'] 
        

    thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
    print(thislist[-4:-1])
    returns ['orange', 'kiwi', 'melon'] 
        

    thislist = ["apple", "banana", "cherry"]
    if "apple" in thislist:
        print("Yes, 'apple' is in the fruits list")
        

    thislist = ["apple", "banana", "cherry"]
    thislist[1] = "blackcurrant"
    print(thislist)
    returns ['apple', 'blackcurrant', 'cherry'] 
        

    thislist = ["apple", "banana", "cherry", "orange", "kiwi", "mango"]
    thislist[1:3] = ["blackcurrant", "watermelon"]
    print(thislist)
    returns ['apple', 'blackcurrant', 'watermelon', 'orange', 'kiwi', 'mango'] 
        

    thislist = ["apple", "banana", "cherry"]
    thislist[1:2] = ["blackcurrant", "watermelon"]
    print(thislist)
    returns ['apple', 'blackcurrant', 'watermelon', 'cherry'] 
        

    thislist = ["apple", "banana", "cherry"]
    thislist.insert(2, "watermelon")
    print(thislist)
    returns ['apple', 'banana', 'watermelon', 'cherry'] 
        

    thislist = ["apple", "banana", "cherry"]
    thislist.append("orange")
    print(thislist)
    returns ['apple', 'banana', 'cherry', 'orange'] 
        

    thislist = ["apple", "banana", "cherry"]
    tropical = ["mango", "pineapple", "papaya"]
    thislist.extend(tropical)
    print(thislist)
    returns ['apple', 'banana', 'cherry', 'mango', 'pineapple', 'papaya'] 
    

    thislist = ["apple", "banana", "cherry"]
    thistuple = ("kiwi", "orange")
    thislist.extend(thistuple)
    print(thislist)
    returns ['apple', 'banana', 'cherry', 'kiwi', 'orange'] 
        

    thislist = ["apple", "banana", "cherry"]
    thislist.remove("banana")
    print(thislist)
    returns ['apple', 'cherry'] 
        

    thislist = ["apple", "banana", "cherry"]
    thislist.pop(1)
    print(thislist)
    returns ['apple', 'cherry'] 
        

    thislist = ["apple", "banana", "cherry"]
    del thislist[0]
    print(thislist)
    returns ['banana', 'cherry'] 
    

    thislist = ["apple", "banana", "cherry"]
    del thislist
        

    thislist = ["apple", "banana", "cherry"]
    thislist.clear()
    print(thislist)
    returns [] 
        

    fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
    newlist = []

    for x in fruits:
    if "a" in x:
        newlist.append(x)

    print(newlist)
        

    fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
    newlist = [x for x in fruits if "a" in x]
    print(newlist)
        

    thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]
    thislist.sort()
    print(thislist)
    returns ['banana', 'kiwi', 'mango', 'orange', 'pineapple'] 
        

    thislist = [100, 50, 65, 82, 23]
    thislist.sort()
    print(thislist)
    returns [23, 50, 65, 82, 100] 
        

    thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]
    thislist.sort(reverse = True)
    print(thislist)
    returns ['pineapple', 'orange', 'mango', 'kiwi', 'banana'] 
        

    thislist = [100, 50, 65, 82, 23]
    thislist.(reverse = True)
    print(thislist)
    returns [100, 82, 65, 50, 23] 
        

    thislist = ["banana", "Orange", "Kiwi", "cherry"]
    thislist.()
    print(thislist)
    returns ['Kiwi', 'Orange', 'banana', 'cherry'] 
        

    thislist = ["banana", "Orange", "Kiwi", "cherry"]
    thislist.(key = str.lower)
    print(thislist)
    returns ['banana', 'cherry', 'Kiwi', 'Orange'] 
        

    thislist = ["banana", "Orange", "Kiwi", "cherry"]
    thislist.reverse()
    print(thislist)
    returns ['cherry', 'Kiwi', 'Orange', 'banana'] 
        

    thislist = ["apple", "banana", "cherry"]
    mylist = thislist.copy()
    print(mylist)
    returns ['apple', 'banana', 'cherry'] 
        

    thislist = ["apple", "banana", "cherry"]
    mylist = list(thislist)
    print(mylist)
    returns ['apple', 'banana', 'cherry'] 
        

    thislist = ["apple", "banana", "cherry"]
    mylist = thislist[:]
    print(mylist)
    returns ['apple', 'banana', 'cherry'] 
        

    list1 = ["a", "b", "c"]
    list2 = [1, 2, 3]
    list3 = list1 + list2
    print(list3)
    returns ['a', 'b', 'c', 1, 2, 3] 
        

    list1 = ["a", "b" , "c"]
    list2 = [1, 2, 3]

    for x in list2:
    list1.append(x)

    print(list1)
    returns  ['a', 'b', 'c', 1, 2, 3]
        

    list1 = ["a", "b" , "c"]
    list2 = [1, 2, 3]
    list1.extend(list2)
    print(list1)
    returns ['a', 'b', 'c', 1, 2, 3] 
        

8. Tuples

Definition

Tuples are used to store multiple items in a single variable. Tuples are written with round brackets.

Tuple Items (Indexed)

Tuple items are indexed, the first item has index [0], the second item has index [1] etc.

Ordered

When we say that tuples are ordered, it means that the items have a defined order, and that order will not change.

Unchangeable

Tuples are unchangeable, meaning that we cannot change, add or remove items after the tuple has been created.

Allow Duplicates

Since tuples are indexed, they can have items with the same value. e.g. thistuple = ("apple", "banana", "cherry", "apple", "cherry")

Tuple Methods

Tuple length

To determine how many items a tuple has, use the len() function.

    this_tuple = ["apple", "banana", "cherry"]
    print(len(this_tuple))
    returns 3 
        

Tuple Data Type

• String e.g. tuple1 = ["apple", "banana", "cherry"]
• Integer eg. tuple2 = [1, 5, 7, 9, 3]
• Boolean eg. tuple3 = [True, False, False]

Note: A tuple can contain different data types. eg. this_tuple = ["abc", 34, True, 40, "male"]

type()

From Python's perspective, tuples are defined as objects with the data type 'tuple'.

    mytuple = ("apple", "banana", "cherry")
    print(type(mytuple))
    returns class 'tuple' 
        

The tuple() Constructor

It is also possible to use the tuple() constructor when creating a new tuple.
e.g. this_tuple = tuple(("apple", "banana", "cherry")) ** note the double round-brackets.

Create Tuple With One Item

To create a tuple with only one item, you have to add a comma after the item, otherwise Python will not recognize it as a tuple.

    thistuple = ("apple",)
    print(type(thistuple))
    returns class 'tuple' 
        

    thistuple = ("apple")
    print(type(thistuple))
    return class 'str'
        

Access Tuple

1. Accessing

Tuple items are indexed and you can access them by referring to the index number.

    this_tuple = ("apple", "banana", "cherry")
    print(thistuple[1])
    returns "banana"
        

2. Negative Indexing

Negative indexing means start from the end. -1 refers to the last item, -2 refers to the second last item etc.

    thistuple = ("apple", "banana", "cherry")
    print(thistuple[-1])
    returns "cherry" 
        

3. Range of Indexes

You can specify a range of indexes by specifying where to start and where to end the range. When specifying a range, the return value will be a new tuple with the specified items.

    thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
    print(thistuple[2:5])
    returns ('cherry', 'orange', 'kiwi') 
        

Note The search will start at index 2 (included) and end at index 5 (not included).

• By leaving out the start value, the range will start at the first item.

    thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
    print(thistuple[:4])
    returns ('apple', 'banana', 'cherry', 'orange') 
        

• By leaving out the end value, the range will go on to the end of the tuple.

    thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
    print(thistuple[2:])
    returns ('cherry', 'orange', 'kiwi', 'melon', 'mango') 
        

• Specify negative indexes if you want to start the search from the end of the tuple.

    thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
    print(thistuple[-4:-1])
    returns ('orange', 'kiwi', 'melon') 
        

4. Check if Item Exists

To determine if a specified item is present in a tuple use the in keyword:

    thistuple = ("apple", "banana", "cherry")
    if "apple" in thistuple:
    print("Yes, 'apple' is in the fruits tuple")
        

Update Tuples

Tuples are unchangeable, meaning that you cannot change, add, or remove items once the tuple is created.
But there are some workarounds.

Change Tuple Values

Once a tuple is created, you cannot change its values. Tuples are unchangeable, or immutable as it also is called.
But there is a workaround. You can convert the tuple into a list, change the list, and convert the list back into a tuple.

    x = ("apple", "banana", "cherry")
    y = list(x)
    y[1] = "kiwi"
    x = tuple(y)

    print(x)
    returns ("apple", "kiwi", "cherry") 
        

Add Items

Since tuples are immutable, they do not have a built-in append() method, but there are other ways to add items to a tuple.
• Convert into a list.Just like the workaround for changing a tuple, you can convert it into a list, add your item(s), and convert it back into a tuple.

    thistuple = ("apple", "banana", "cherry")
    y = list(thistuple)
    y.append("orange")
    thistuple = tuple(y)
    returns ('apple', 'banana', 'cherry', 'orange') 
        

• Add tuple to a tuple.ou are allowed to add tuples to tuples, so if you want to add one item, (or many), create a new tuple with the item(s), and add it to the existing tuple.

    thistuple = ("apple", "banana", "cherry")
    y = ("orange",)
    thistuple += y

    print(thistuple)
    returns ('apple', 'banana', 'cherry', 'orange') 
        

Note: When creating a tuple with only one item, remember to include a comma after the item, otherwise it will not be identified as a tuple.

Remove Items

Note: You cannot remove items in a tuple.
Tuples are unchangeable, so you cannot remove items from it, but you can use the same workaround as we used for changing and adding tuple items

    thistuple = ("apple", "banana", "cherry")
    y = list(thistuple)
    y.remove("apple")
    thistuple = tuple(y)
    returns ('banana', 'cherry')    
        

Or you can delete the tuple completely using the del key.

    thistuple = ("apple", "banana", "cherry")
    del thistuple
    print(thistuple) #this will raise an error because the tuple no longer exists
        

Unpack Tuples

Unpacking a Tuple

When we create a tuple, we normally assign values to it. This is called "packing" a tuple.

    fruits = ("apple", "banana", "cherry")
        

But, in Python, we are also allowed to extract the values back into variables. This is called "unpacking".

    fruits = ("apple", "banana", "cherry")
    (green, yellow, red) = fruits

    print(green)
    print(yellow)
    print(red)
    returns:
    apple
    banana
    cherry
        

Note: The number of variables must match the number of values in the tuple, if not, you must use an asterisk to collect the remaining values as a list.

Using Asterisk *

• If the number of variables is less than the number of values, you can add an * to the variable name and the values will be assigned to the variable as a list.

    fruits = ("apple", "banana", "cherry", "strawberry", "raspberry")
    (green, yellow, *red) = fruits

    print(green)
    print(yellow)
    print(red)
    returns:
    apple
    banana
    ['cherry', 'strawberry', 'raspberry']
        

• If the asterisk is added to another variable name than the last, Python will assign values to the variable until the number of values left matches the number of variables left.

    fruits = ("apple", "mango", "papaya", "pineapple", "cherry")

    (green, *tropic, red) = fruits

    print(green)
    print(tropic)
    print(red)
    returns:
    apple
    ['mango', 'papaya', 'pineapple']
        cherry
        

Join Tuples

To join two or more tuples you can use the + operator.

+ (plus) Operator

• Join two tuples:

    tuple1 = ["a", "b", "c"]
    tuple2 = [1, 2, 3]
    tuple3 = tuple1 + tuple2
    print(tuple3)
    returns ['a', 'b', 'c', 1, 2, 3] 
        

Multiply Tuples

If you want to multiply the content of a tuple a given number of times, you can use the * operator

* (multiply) Operator

• Multiply the fruits tuple by 2:

    fruits = ("apple", "banana", "cherry")
    mytuple = fruits * 2
    print(mytuple)
    returns ('apple', 'banana', 'cherry', 'apple', 'banana', 'cherry') 
        

9. Dictionaries

Definition

Dictionaries are used to store data values in key:value pairs. Dictionaries are written with curly brackets.

Dictionary Items

Dictionary items are presented in key:value pairs, and can be referred to by using the key name.

    thisdict = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    print(thisdict["brand"])
    returns "Ford"
        

Ordered

When we say that dictionaries are ordered, it means that the items have a defined order, and that order will not change.

Changeable

Dictionaries are changeable, meaning that we can change, add or remove items after the dictionary has been created.

Duplicates Not Allowed

Dictionaries cannot have two items with the same key.

    thisdict = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964,
        "year": 2020
    }
    print(thisdict)
    returns {'brand': 'Ford', 'model': 'Mustang', 'year': 2020} 
        

Note: Duplicate values will overwrite existing values

Dictionary Methods

Dictionary length

To determine how many items a dictionary has, use the len() function.

    thisdict = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964,
        "year": 2020
    }
    print(len(thisdict))
    returns 3
        

Dictionary Data Type

A dictionary can contain different data types: e.g. String, int, boolean, and list.

    thisdict = {
        "brand": "Ford",
        "electric": False,
        "year": 1964,
    "colors": ["red", "white", "blue"]
        }
        

type()

From Python's perspective, dictionaries are defined as objects with the data type 'dict'.

    mydict = {"brand": "Ford", "year": "1964"}
    print(type(mydict))
    returns class 'dict' 
        

The dict() Constructor

It is also possible to use the dict() constructor when creating a new dictionary.
e.g. this_dictionary = dict(name = "John", age = 36, country = "Norway")

Acces Dictionary Items

1. Accessing

• You can access the items of a dictionary by referring to its key name, inside square brackets.

    thisdict = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    x = thisdict["model"]
    returns "Mustang" 
        

• There is also a method called get() that will give you the same result. e.g. x = thisdict.get("model")

2. Get Keys

The keys() method will return a list of all the keys in the dictionary.

    x = thisdict.keys()
    returns dict_keys(['brand', 'model', 'year']) 
        

• The list of the keys is a view of the dictionary, meaning that any changes done to the dictionary will be reflected in the keys list.

    car = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    x = car.keys()
    print(x) #before the change
    returns dict_keys(['brand', 'model', 'year']) 

    car["color"] = "white"
    print(x) #after the change
    returns dict_keys(['brand', 'model', 'year', 'color']) 
        

3. Get Values

The values() method will return a list of all the values in the dictionary.

    x = thisdict.values()
    returns dict_values(['Ford', 'Mustang', 1964]) 
        

• The list of the values is a view of the dictionary, meaning that any changes done to the dictionary will be reflected in the values list.

    car = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    x = car.values()

    print(x) #before the change
    returns dict_values(['Ford', 'Mustang', 1964]) 

    car["year"] = 2020
    print(x) #after the change
    returns dict_values(['Ford', 'Mustang', 2020]) 
        

•Add a new item to the original dictionary, and see that the values list gets updated as well.

    car = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    x = car.values()

    print(x) #before the change
    returns dict_values(['Ford', 'Mustang', 1964]) 

    car["color"] = "red"
    print(x) #after the change
    returns dict_values(['Ford', 'Mustang', 1964, 'red']) 
        

4. Get Items

The items() method will return each item in a dictionary, as tuples in a list.

    x = thisdict.items()
    returns dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)]) 
        

• The returned list is a view of the items of the dictionary, meaning that any changes done to the dictionary will be reflected in the items list.

    car = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }

    x = car.items()

    print(x) #before the change
    returns dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)]) 

    car["year"] = 2020

    print(x) #after the change
    returns dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 2020)]) 
        

•Add a new item to the original dictionary, and see that the values list gets updated as well.

    car = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }

    x = car.items()
    print(x) #before the change
    returns dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)]) 

    car["color"] = "red"
    print(x) #after the change
    returns dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964), ('color', 'red')]) 
        

5. Check if Key Exists

To determine if a specified key is present in a dictionary use the in keyword.

    thisdict = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    if "model" in thisdict:
    print("Yes, 'model' is one of the keys in the thisdict dictionary")
        

Change Dictionary Items

1. Change Values

You can change the value of a specific item by referring to its key name.

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    thisdict["year"] = 2018
    print(thisdict)
    returns {'brand': 'Ford', 'model': 'Mustang', 'year': 2018} 
        

2. Update Dictionary

The update() method will update the dictionary with the items from the given argument. The argument must be a dictionary, or an iterable object with key:value pairs.

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    thisdict.update({"year": 2020})
    print(thisdict) 
    returns {'brand': 'Ford', 'model': 'Mustang', 'year': 2020} 
        

Add Dictionary Items

1. Add Items

Adding an item to the dictionary is done by using a new index key and assigning a value to it.

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    thisdict["color"] = "red"
    print(thisdict)
    returns {'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'color': 'red'} 
        

2. Update Dictionary

The update() method will update the dictionary with the items from a given argument. If the item does not exist, the item will be added. The argument must be a dictionary, or an iterable object with key:value pairs.

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    thisdict.update({"color": "red"})
    returns {'brand': 'Ford', 'model': 'Mustang', 'year': 2020} 
    returns {'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'color': 'red'} 
        

Remove Dictionary Items

There are several methods to remove items from a dictionary.
• The pop() method removes the item with the specified key name.

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    thisdict.pop("model")
    print(thisdict) 
    returns {'brand': 'Ford', 'year': 1964} 
        

• The popitem() method removes the last inserted item.

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    thisdict.popitem()
    print(thisdict)
    returns {'brand': 'Ford', 'model': 'Mustang'} 
        

• The del keyword removes the item with the specified key name.

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    del thisdict["model"]
    print(thisdict)
    returns {'brand': 'Ford', 'year': '1964'} 
        

• The del keyword can also delete the dictionary completely.

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    del thisdict
    print(thisdict) #this will cause an error because "thisdict" no longer exists.
        

• The clear() method empties the dictionary.

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    thisdict.clear()
    print(thisdict)
    returns {}
        

Copy Dictionaries

You cannot copy a dictionary simply by typing dict2 = dict1, because: dict2 will only be a reference to dict1, and changes made in dict1 will automatically also be made in dict2. • here are ways to make a copy, one way is to use the built-in Dictionary method copy().

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    mydict = thisdict.copy()
    print(mydict)
    returns {'brand': 'Ford', 'model': 'Mustang', 'year': 1964} 
        

• Another way to make a copy is to use the built-in function dict().

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    mydict = dict(thisdict)
    print(mydict)
    returns {'brand': 'Ford', 'model': 'Mustang', 'year': 1964} 
        

Nested Dictionaries

• A dictionary can contain dictionaries, this is called nested dictionaries.

    myfamily = {
        "child1" : {
            "name" : "Emil",
            "year" : 2004
    },
        "child2" : {
            "name" : "Tobias",
            "year" : 2007
    },
        "child3" : {
            "name" : "Linus",
            "year" : 2011
    }
    }
        

• Or, if you want to add three dictionaries into a new dictionary.

    child1 = {
        "name" : "Emil",
        "year" : 2004
    }
    child2 = {
        "name" : "Tobias",
        "year" : 2007
    }
    child3 = {
        "name" : "Linus",
        "year" : 2011
    }

    myfamily = {
        "child1" : child1,
        "child2" : child2,
        "child3" : child3
    } 
        

Access Items in Nested Dictionaries.

To access items from a nested dictionary, you use the name of the dictionaries, starting with the outer dictionary.

    print(myfamily["child2"]["name"])
    returns  "Tobias"
        

10. Sets

Definition

Sets are used to store multiple items in a single variable. Sets are created using curly brackets.

List Items (Indexed)

List items are indexed, the first item has index [0], the second item has index [1] etc.

Unordered

Unordered means that the items in a set do not have a defined order. Set items can appear in a different order every time you use them, and cannot be referred to by index or key.

Unchangeable

Set items are unchangeable, meaning that we cannot change the items after the set has been created. Once a set is created, you cannot change its items, but you can remove items and add new items.

Duplicates Not Allowed

Sets cannot have two items with the same value. Duplicate values will be ignored.

    thisset = {"apple", "banana", "cherry", "apple"}
    print(thisset)
    returns {'banana', 'cherry', 'apple'} 
        

Note: The values True and 1 are considered the same value in sets, and are treated as duplicates.

    thisset = {"apple", "banana", "cherry", True, 1, 2}
    print(thisset)
    returns {True, 2, 'banana', 'cherry', 'apple'} 
        

Note: The values False and 0 are considered the same value in sets, and are treated as duplicates.

    thisset = {"apple", "banana", "cherry", False, True, 0}
    print(thisset)
    returns {False, True, 'cherry', 'apple', 'banana'} 
    

Set Methods

Set length

To determine how many items a set has, use the len() function.

    this_set = {"apple", "banana", "cherry"}
    print(len(this_set))
    returns 3
        

Set Data Type

• String e.g. set1 = {"apple", "banana", "cherry"}
• Integer eg. set2 = {1, 5, 7, 9, 3}
• Boolean eg. set3 = {True, False, False}

Note: A set can contain different data types. e.g. this_set = {"abc", 34, True, 40, "male"}

type()

From Python's perspective, sets are defined as objects with the data type 'set'.

    myset = {"apple", "banana", "cherry"}
    print(type(myset))
    returns class 'list' 
        

The set() Constructor

It is also possible to use the set() constructor when creating a new set.
e.g. this_set = set(("apple", "banana", "cherry")) ** note the double round-brackets.

Access Set

1. Accessing

You cannot access items in a set by referring to an index or a key. But you can loop through the set items using a for loop, or ask if a specified value is present in a set, by using the in keyword. • Loop through the set, and print the values:

    thisset = {"apple", "banana", "cherry"}
    for x in thisset:
    print(x) 
    returns "apple" 
            "banana"
            "cherry"
        

• Check if "banana" is present in the set::

    thisset = {"apple", "banana", "cherry"}
    print("banana" in thisset)
    returns True 
        

• Check if "banana" is not present in the set::

    thisset = {"apple", "banana", "cherry"}
    print("banana" not in thisset)
    returns True 
        

Change List Items

Note: Once a set is created, you cannot change its items, but you can add new items.

Add Set Items

1. Add Items

To add one item to a set use the add() method.

    thisset = {"apple", "banana", "cherry"}
    thisset.add("orange")
    print(thisset)
    returns {'apple', 'cherry', 'orange', 'banana'} 
        

2. Add Sets

To add items from another set into the current set, use the update() method.

    thisset = {"apple", "banana", "cherry"}
    tropical = {"pineapple", "mango", "papaya"}
    thisset.update(tropical)
    print(thisset)
    returns {'apple', 'mango', 'cherry', 'pineapple', 'banana', 'papaya'} 
        

3. Add Any Iterable

The object in the update() method does not have to be a set, it can be any iterable object (tuples, lists, dictionaries etc.).

    thisset = {"apple", "banana", "cherry"}
    mylist = ["kiwi", "orange"]
    thisset.update(mylist)
    print(thisset)
    returns {'banana', 'cherry', 'apple', 'orange', 'kiwi'}  
        

Remove Set Items

To remove an item in a set, use the remove(), or the discard() method. • Remove "banana" by using the remove() method:

    thisset = {"apple", "banana", "cherry"}
    thisset.remove("banana")
    print(thisset)
    returns {'apple', 'cherry'} 
        

Note If the item to remove does not exist, remove() will raise an error. • Remove "banana" by using the remove() method:

    thisset = {"apple", "banana", "cherry"}
    thisset.discard("banana")
    print(thisset)
    returns {'apple', 'cherry'} 
        

Note If the item to remove does not exist, discard() will not raise an error. • You can also use the pop() method to remove an item, but this method will remove a random item, so you cannot be sure what item that gets removed.

    thisset = {"apple", "banana", "cherry"}
    x = thisset.pop(1)
    print(x)  #removed item
    print(thisset)  #the set after removal
    returns "banana" 
            ['apple', 'cherry']
        

Note Sets are unordered, so when using the pop() method, you do not know which item that gets removed. • The clear() method empties the set:

    thisset = {"apple", "banana", "cherry"}
    thisset.clear()
    print(thisset)
    returns set() 
        

• The del keyword will delete the set completely.

    thisset = {"apple", "banana", "cherry"}
    del thisset
        

Join Sets

There are several ways to join two or more sets in Python.

1. Union

The union() method returns a new set with all items from both sets.

    set1 = {"a", "b", "c"}
    set2 = {1, 2, 3}
    set3 = set1.union(set2)
    print(set3)
    returns {'b', 2, 'c', 'a', 1, 3}  
        

• You can use the | operator instead of the union() method, and you will get the same result.

    set1 = {"a", "b", "c"}
    set2 = {1, 2, 3}
    set3 = set1 | set2
    print(set3)
    returns {'a', 1, 'b', 'c', 2, 3} 
        

• All the joining methods and operators can be used to join multiple sets. When using a method, just add more sets in the parentheses, separated by commas. Join multiple sets with the union() method:

    set1 = {"a", "b", "c"}
    set2 = {1, 2, 3}
    set3 = {"John", "Elena"}
    set4 = {"apple", "bananas", "cherry"}
    myset = set1.union(set2, set3, set4)
    print(myset)
    returns {Elena, 'a', John, 3, apple, 1, 'c', 2, banana, 'b', cherry} 
        

Join multiple sets with the union() method:

    set1 = {"a", "b", "c"}
    set2 = {1, 2, 3}
    set3 = {"John", "Elena"}
    set4 = {"apple", "bananas", "cherry"}
    myset = set1 | set2 | set3 |set4
    print(myset)
    returns {John, 'b', 3, Elena, 1, cherry, 'c', apple, 2, 'a', banana}  
        

• The union() method allows you to join a set with other data types, like lists or tuples. The result will be a set.

    x = {"a", "b", "c"}
    y = (1, 2, 3)
    z = x.union(y)
    print(z) 
    returns {3, 1, 'b', 'a', 'c', 2} 
        

Note: The | operator only allows you to join sets with sets, and not with other data types like you can with the union() method.

2. Update

The update() method inserts all items from one set into another. The update() changes the original set, and does not return a new set.

    set1 = {"a", "b" , "c"}
    set2 = {1, 2, 3}
    set1.update(set2)
    print(set1)
    returns {2, 'b', 'a', 1, 3, 'c'} 
        

Note: Both union() and update() will exclude any duplicate items.

3. Intersection

The intersection() method will return a new set, that only contains the items that are present in both sets.(Keep ONLY the duplicates)

    set1 = {"apple", "banana", "cherry"}
    set2 = {"google", "microsoft", "apple"}
    set3 = set1.intersection(set2)
    print(set3)
    returns {'apple'} 
        

• You can use the & operator instead of the intersection() method, and you will get the same result.

    set1 = {"apple", "banana", "cherry"}
    set2 = {"google", "microsoft", "apple"}
    set3 = set1 & set2
    print(set3)
    returns {'apple'} 
        

Note: The & operator only allows you to join sets with sets, and not with other data types like you can with the intersection() method.

• The intersection_update() method will also keep ONLY the duplicates, but it will change the original set instead of returning a new set.

    set1 = {"apple", "banana", "cherry"}
    set2 = {"google", "microsoft", "apple"}
    set1.intersection_update(set2)
    print(set1)
    returns {'apple'} 
        

• The values True and 1 are considered the same value. The same goes for False and 0.

    set1 = {"apple", 1,  "banana", 0, "cherry"}
    set2 = {False, "google", 1, "apple", 2, True}
    set3 = set1.intersection(set2)
    print(set3)
    returns {False, True, 'apple'} 
        

4. Difference

The difference() method will return a new set that will contain only the items from the first set that are not present in the other set.

    set1 = {"apple", "banana", "cherry"}
    set2 = {"google", "microsoft", "apple"}
    set3 = set1.difference(set2)
    print(set3)
    returns {'banana', 'cherry'} 
        

• You can use the - operator instead of the difference() method, and you will get the same result.

    set1 = {"apple", "banana", "cherry"}
    set2 = {"google", "microsoft", "apple"}
    set3 = set1 - set2
    print(set3) 
    returns {'banana', 'cherry'} 
        

Note: The - operator only allows you to join sets with sets, and not with other data types like you can with the difference() method.

The difference_update() method will also keep the items from the first set that are not in the other set, but it will change the original set instead of returning a new set.

    set1 = {"apple", "banana", "cherry"}
    set2 = {"google", "microsoft", "apple"}
    set1.difference_update(set2)
    print(set1) 
    returns {'banana', 'cherry'} 
        

5. Symmetric Differences

The symmetric_difference() method will keep only the elements that are NOT present in both sets.

    set1 = {"apple", "banana", "cherry"}
    set2 = {"google", "microsoft", "apple"}
    set3 = set1.symmetric_difference(set2)
    print(set3)
    returns {'google', 'banana', 'microsoft', 'cherry'} 
        

• You can use the ^ operator instead of the symmetric_difference() method, and you will get the same result.

    set1 = {"apple", "banana", "cherry"}
    set2 = {"google", "microsoft", "apple"}
    set3 = set1 ^ set2
    print(set3)
    returns {'google', 'banana', 'microsoft', 'cherry'} 
        

Note: The ^ operator only allows you to join sets with sets, and not with other data types like you can with the symmetric_difference() method.

The symmetric_difference_update() method will also keep all but the duplicates, but it will change the original set instead of returning a new set.

    set1 = {"apple", "banana", "cherry"}
    set2 = {"google", "microsoft", "apple"}
    set1.symmetric_difference_update(set2)
    print(set1)
    returns {'google', 'banana', 'microsoft', 'cherry'}  
        

11. Statements

Python Conditions and If statements

Python supports the usual logical conditions from mathematics:
• Equals: "a == b"
• Not Equals: "a != b"
• Less than: "a < b"
• Less than or equal to: "a <=b"
• Greater than: "a> b"
• Greater than or equal to: "a >= b"
These conditions can be used in several ways, most commonly in "if statements" and loops.

If statement

An "if statement" is written by using the if keyword.

      a = 33
      b = 200
      if b > a:
          print("b is greater than a")
      

In this example we use two variables, a and b, which are used as part of the if statement to test whether b is greater than a. As a is 33, and b is 200, we know that 200 is greater than 33, and so we print to screen that "b is greater than a".

Indentation

Python relies on indentation (whitespace at the beginning of a line) to define scope in the code. Other programming languages often use curly-brackets for this purpose.

      a = 33
      b = 200
      if b > a:
          print("b is greater than a")
      returns "b is greater than a" 
      

Note:If statement, without indentation will raise an error

Elif

The elif keyword is Python's way of saying "if the previous conditions were not true, then try this condition".

      a = 33
      b = 33
      if b > a:
          print("b is greater than a")
      elif a == b:
          print("a and b are equal")
      returns"a and b are equal"  
      

In this example a is equal to b, so the first condition is not true, but the elif condition is true, so we print to screen that "a and b are equal".

Else

The else keyword catches anything which isn't caught by the preceding conditions.

      a = 200
      b = 33
      if b > a:
          print("b is greater than a")
      elif a == b:
          print("a and b are equal")
      else:
          print("a is greater than b")
          returns"a is greater than b"  
      

In this example a is greater than b, so the first condition is not true, also the elif condition is not true, so we go to the else condition and print to screen that "a is greater than b".

• You can also have an else without the elif:

      a = 200
      b = 33
      if b > a:
          print("b is greater than a")
      else:
          print("a is greater than b")
          returns "a is greater than b" 
      

Shorthand If

If you have only one statement to execute, you can put it on the same line as the if statement.

      if a > b: print("a is greater than b")
      

Shorthand If..Else

If you have only one statement to execute, one for if, and one for else, you can put it all on the same line.

      a = 2
      b = 330
      print("A") if a > b else print("B")
      

Note:This technique is known as Ternary Operators, or Conditional Expressions.

• You can also have multiple else statements on the same line:

      a = 2
      b = 330
      print("A") if a > b else print("=") if a == b else print("B")
      

And

The and keyword is a logical operator, and is used to combine conditional statements.

      a = 200
      b = 33
      c = 500
      if a > b and c > a:
          print("Both conditions are True")
      

Or

The or keyword is a logical operator, and is used to combine conditional statements.

      a = 200
      b = 33
      c = 500
      if a > b or a > c:
          print("At least one of the conditions is True")
      

Not

The not keyword is a logical operator, and is used to reverse the result of the conditional statement.

      a = 33
      b = 200
      if not a > b:
          print("a is NOT greater than b")
      

Nested If

You can have if statements inside if statements, this is called nested if statements.

      x = 41

      if x > 10:
          print("Above ten,")
          if x > 20:
          print("and also above 20!")
          else:
          print("but not above 20.")
      returns "Above ten,"
              "and also above 20!" 
      

The Pass Statement

If statements cannot be empty, but if you for some reason have an if statement with no content, put in the pass statement to avoid getting an error.

      a = 33
      b = 200

      if b > a:
          pass
      

Note:Having an empty if statement like this, would raise an error without the pass statement.

12. Loops (Iteration)

Python has two primitive loop commands:
• While loops
• For loops

While Loop

The While Loop

With the while loop we can execute a set of statements as long as a condition is true.

    i = 1
    while i < 6:
        print(i)
        i += 1
        returns 1
                2
                3
                4
                5
		

Note: Remember to increment i, or else the loop will continue forever.

The while loop requires relevant variables to be ready, in this example we need to define an indexing variable, i, which we set to 1.

The break Statement

With the break statement we can stop the loop even if the while condition is true.

    i = 1
    while i < 6:
        print(i)
        if i == 3:
        break
        i += 1
    returns 1
            2
            3
		

The continue Statement

With the continue statement we can stop the current iteration, and continue with the next.

    i = 0
    while i < 6:
        i += 1
        if i == 3:
        continue
        print(i)
    returns 1
            2
            3
            4
            5
            6
		

The else Statement

With the else statement we can run a block of code once when the condition no longer is true.

    i = 1
    while i < 6:
        print(i)
        i += 1
    else:
        print("i is no longer less than 6")
    returns 1
            2
            3
            4
            5
            "i is no longer less than 6"
		

For Loop

The For Loop

A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string).
This is less like the for keyword in other programming languages, and works more like an iterator method as found in other object-orientated programming languages.
With the for loop we can execute a set of statements, once for each item in a list, tuple, set etc.

    fruits = ["apple", "banana", "cherry"]
    for x in fruits:
        print(x)
    returns  apple
            banana
            cherry
		

Note: The for loop does not require an indexing variable to set beforehand.

Even strings are iterable objects, they contain a sequence of characters.

    for x in "banana":
    print(x)
    returns  b
            a
            n
            a
            n
            a
		

The break Statement

With the break statement we can stop the loop before it has looped through all the items.

    fruits = ["apple", "banana", "cherry"]
     for x in fruits:
        if x == "banana":
        break
        print(x)
    returns apple
            banana
		

• Exit the loop when x is "banana", but this time the break comes before the print:

    fruits = ["apple", "banana", "cherry"]
    for x in fruits:
        print(x)
        if x == "banana":
        break
    returns apple
		

The continue Statement

With the continue statement we can stop the current iteration of the loop, and continue with the next.

    fruits = ["apple", "banana", "cherry"]
    for x in fruits:
        if x == "banana":
        continue
        print(x)
    returns apple 
            
		

The range() Function

To loop through a set of code a specified number of times, we can use the range() function.
The range() function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and ends at a specified number.

    for x in range(6):
        print(x)
    returns 0
            1
            2
            3
            4
            5 
		

Note that range(6) is not the values of 0 to 6, but the values 0 to 5.

• The range() function defaults to 0 as a starting value, however it is possible to specify the starting value by adding a parameter: range(2, 6), which means values from 2 to 6 (but not including 6:

    for x in range(2, 6):
        print(x)
    returns 2
            3
            4
            5
		

• The range() function defaults to increment the sequence by 1, however it is possible to specify the increment value by adding a third parameter: range(2, 30, 3):

    for x in range(2, 30, 3):
        print(x)
    returns 2
             5
             8
            11
            14
            17
            20
            23
            26
            29
		

Else in For loop

The else keyword in a for loop specifies a block of code to be executed when the loop is finished.

    for x in range(6):
        print(x)
    else:
        print("Finally finished!")
    returns 0
            1
            2
            3
            4
            5
        "Finally finished!"
		

Note: The else block will NOT be executed if the loop is stopped by a break statement.

    for x in range(6):
        if x == 3: break
        print(x)
    else:
        print("Finally finished!")
    returns 0
            1
            2
            3
		

Nested Loops

A nested loop is a loop inside a loop. The "inner loop" will be executed one time for each iteration of the "outer loop".

    adj = ["red", "big", "tasty"]
    fruits = ["apple", "banana", "cherry"]

    for x in adj:
        for y in fruits:
        print(x, y)
    returns red apple
            red banana
            red cherry
            big apple
            big banana
            big cherry
            tasty apple
            tasty banana
            tasty cherry
		

The Pass Statement

for loops cannot be empty, but if you for some reason have a for loop with no content, put in the pass statement to avoid getting an error.

    for x in [0, 1, 2]:
        pass   # having an empty for loop like this, would raise an error without the pass statement
		

Loop Lists

Loop Through a List

You can loop through the list items by using a class="python_highlight">for loop.

    thislist = ["apple", "banana", "cherry"]
     for x in thislist:
        print(x)
    returns apple
            banana
            cherry
		

Loop Through the Index Numbers

You can also loop through the list items by referring to their index number.
Use the range() and len() functions to create a suitable iterable.

    thislist = ["apple", "banana", "cherry"]
    for i in range(len(thislist)):
        print(thislist[i])
    returns apple
            banana
            cherry
		

Using a While Loop

You can loop through the list items by using a while loop. Use the len() function to determine the length of the list, then start at 0 and loop your way through the list items by referring to their indexes.
Remember to increase the index by 1 after each iteration.

    thislist = ["apple", "banana", "cherry"]
    i = 0
    while i < len(thislist):
        print(thislist[i])
        i = i + 1
    returns apple
            banana
            cherry
		

Looping Using List Comprehension

List Comprehension offers the shortest syntax for looping through lists.

    thislist = ["apple", "banana", "cherry"]
    [print(x)  for x in thislist]
    returns apple
            banana
            cherry
		

Loop Tuples

Loop Through a Tuple

You can loop through the tuple items by using a class="python_highlight">for loop.

    thistuple = ("apple", "banana", "cherry")
    for x in thistuple:
        print(x)
    returns apple
            banana
            cherry
		

Loop Through the Index Numbers

You can also loop through the tuple items by referring to their index number.
Use the range() and len() functions to create a suitable iterable.

    thistuple = ("apple", "banana", "cherry")
    for i in range(len(thistuple)):
        print(thistuple[i])
    returns apple
            banana
            cherry
		

Using a While Loop

You can loop through the tuple items by using a while loop. Use the len() function to determine the length of the tuple, then start at 0 and loop your way through the tuple items by referring to their indexes.
Remember to increase the index by 1 after each iteration.

    thistuple = ("apple", "banana", "cherry")
    i = 0
    while i < len(thistuple):
        print(thistuple[i])
        i = i + 1
    returns apple
            banana
            cherry
		

Loop Dictionaries

Loop Through a Dictionary

You can loop through a dictionary by using a class="python_highlight">for loop.
When looping through a dictionary, the return value are the keys of the dictionary, but there are methods to return the values as well.
• Print all key names in the dictionary, one by one:

    thisdict = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    for x in thisdict:
        print(x)
    returns brand
            model
            year
		

• Print all values in the dictionary, one by one:

    thisdict = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    for x in thisdict:
        print(thisdict[x])
    returns Ford
            Mustang
            1964
		

• You can also use the keys() method to return values of a dictionary:

    thisdict = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    for x in thisdict.keys():
        print(x)
    returns brand
            model
            year
		

• You can also use the values() method to return values of a dictionary:

    thisdict = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    for x in thisdict.values():
        print(x)
    returns Ford
            Mustang
            1964
		

• Loop through both keys and values, by using the items() method:

    thisdict = {
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    for x,y in thisdict.items():
        print(x, y)
    returns brand Ford
            model Mustang
            year 1964
		

Loop Through Nested Dictionaries

You can loop through a dictionary by using the items() method.
Loop through the keys and values of all nested dictionaries:

    myfamily = {
        "child1" : {
            "name" : "Emil",
            "year" : 2004
        },
        "child2" : {
            "name" : "Tobias",
            "year" : 2007
        },
        "child3" : {
            "name" : "Linus",
            "year" : 2011
        }
    }

    for x, obj in myfamily.items():
        print(x)
        
        for y in obj:
            print(y + ':', obj[y])
    returns child1
            name: Emil
            year: 2004
            child2
            name: Tobias
            year: 2007
            child3
            name: Linus
            year: 2011
		

Loop Sets

Loop Through a Set

You can loop through the set items by using a for loop.

    thisset = {"apple", "banana", "cherry"}
    for x in thisset:
        print(x)
    returns apple
            banana
            cherry
        

13. Functions

Definition

A function is a block of code which only runs when it is called. You can pass data, known as parameters, into a function. A function can return data as a result.

Creating a Function

In Python a function is defined using the def keyword:

	def my_function():
	print("Hello from a function") 
        

Calling a Function

To call a function, use the function name followed by parenthesis.

    def my_function():
        print("Hello from a function") 
    my_function()
    returns "Hello from a function" 
        

Arguments

Information can be passed into functions as arguments. Arguments are specified after the function name, inside the parentheses. You can add as many arguments as you want, just separate them with a comma.
The following example has a function with one argument (fname). When the function is called, we pass along a first name, which is used inside the function to print the full name:

    def my_function(fname):
        print(fname + " Refsnes")

    my_function("Emil")
    my_function("Tobias")
    my_function("Linus")
    returns Emil Refsnes
            Tobias Refsnes
            Linus Refsnes
        

Note: Arguments are often shortened to args

Parameters or Arguments

The terms parameter and argument can be used for the same thing: information that are passed into a function.
• A parameter is the variable listed inside the parentheses in the function definition. e.g. def my_function(fname, lname):
• An argument is the value that is sent to the function when it is called.

Number of Arguments

By default, a function must be called with the correct number of arguments. Meaning that if your function expects 2 arguments, you have to call the function with 2 arguments, not more, and not less. • This function expects 2 arguments, and gets 2 arguments:

    def my_function(fname, lname):
        print(fname + " " + lname)

    my_function("Emil", "Refsnes")
    returns Emil Refsnes  
        

If you try to call the function with 1 or 3 arguments, you will get an error.
• This function expects 2 arguments, but gets only 1:

    def my_function(fname, lname):
        print(fname + " " + lname)
    my_function("Emil")
    returns TypeError: my_function() missing 1 required positional argument: 'lname' 
        

Arbitrary Arguments, *args

If you do not know how many arguments that will be passed into your function, add a * before the parameter name in the function definition. This way the function will receive a tuple of arguments, and can access the items accordingly:

    def my_function(fname):
        print("The youngest child is " + kids[2])
    my_function("Emil", "Tobias", "Linus")
    returns "The youngest child is Linus" 
        

Note: Arguments are often shortened to args

Keyword Arguments

You can also send arguments with the key = value syntax. This way the order of the arguments does not matter.

    def my_function(child3, child2, child1):
        print("The youngest child is " + child3)
    my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")
    returns "The youngest child is Linus" 
        

Note: Keyword arguments are often shortened to kwargs

Arbitrary Keyword Arguments, *kwargs

If you do not know how many arguments that will be passed into your function, add a ** before the parameter name in the function definition. This way the function will receive a dictionary of arguments, and can access the items accordingly:

    def my_function(**kid):
        print("His last name is " + kid["lname"])
    my_function(fname = "Tobias", lname = "Refsnes")
    returns "His last name is Refsnes" 
        

Note: Keyword arguments are often shortened to kwargs

Default Parameter Value

The following example shows how to use a default parameter value.
If we call the function without argument, it uses the default value:

    def my_function(country = "Norway"):
        print("I am from " + country)
    my_function("Sweden")
    my_function("India")
    my_function()
    my_function("Brazil")
    returns "I am from Sweden"
            "I am from India"
            "I am from Norway"
            "I am from Brazil"
        

Passing a List as an Argument

You can send any data types of argument to a function (string, number, list, dictionary etc.), and it will be treated as the same data type inside the function.
E.g. if you send a List as an argument, it will still be a List when it reaches the function

    def my_function(food):
    for x in food:
        print(x)
    fruits = ["apple", "banana", "cherry"]
    my_function(fruits)
    returns apple
            banana
            cherry
        

Return Values

To let a function return a value, use the return statement

    def my_function(x):
        return 5 * x
    print(my_function(3))
    print(my_function(5))
    print(my_function(9))
    returns 15
            25
            45
        

The pass Statement

function definitions cannot be empty, but if you for some reason have a function definition with no content, put in the pass statement to avoid getting an error.

    def my_function():
        pass 
        

Positional-Only Arguments vs Keyword-Only Arguments

• Positional arguments are arguments that need to be included in the proper position or order. The first positional argument always needs to be listed first when the function is called. The second positional argument needs to be listed second and the third positional argument listed third, etc.

    def nameAge(name, age):
        print("Hi, I am", name)
        print("My age is ", age)
        
    nameAge("Prince", 20)
    returns Hi, I am Prince 
            My age is 20
        

• Keyword arguments are arguments passed to a function or method which is preceded by a keyword and an equals sign.

    def nameAge(name, age):
        print("Hi, I am", name)
        print("My age is ", age)

    nameAge(name="Prince", age=20)
    returns Hi, I am Prince
            My age is 20 
        

Difference between the Keyword and Positional Argument

Positional-Only Arguments

You can specify that a function can have ONLY positional arguments, or ONLY keyword arguments.
To specify that a function can have only positional arguments, add , / after the arguments:

    def my_function(x, /):
        print(x)
    my_function(3)
        

• Without the , / you are actually allowed to use keyword arguments even if the function expects positional arguments:

    def my_function(x):
        print(x)
    my_function(x = 3)
        

• But when adding the , / you will get an error if you try to send a keyword argument:

    def my_function(x, /):
        print(x)
    my_function(x = 3)
    returns TypeError: my_function() got some positional-only arguments passed as keyword arguments: 'x' 
        

Keyword-Only Arguments

To specify that a function can have only keyword arguments, add *, before the arguments:

• Without the * you are actually allowed to use keyword arguments even if the function expects positional arguments:

    def my_function(x):
        print(x)
    my_function(3)
        

• But when adding the * you will get an error if you try to send a keyword argument:

    def my_function(*, x):
        print(x)
    my_function(3)
    returns TypeError: my_function() takes 0 positional arguments but 1 was given 
        

Combine Positional-Only and Keyword-Only

You can combine the two argument types in the same function.
Any argument before the / , , are positional-only, and any argument after the *, are keyword-only.

    def my_function(a, b, /, *, c, d):
        print(a + b + c + d)
    my_function(5, 6, c = 7, d = 8)
    returns 26
        

Recursion

Python also accepts function recursion, which means a defined function can call itself.
Recursion is a common mathematical and programming concept. It means that a function calls itself. This has the benefit of meaning that you can loop through data to reach a result.

    def tri_recursion(k):
        if(k > 0):
            result = k + tri_recursion(k - 1)
            print(result)
        else:
            result = 0
            return result

    print("Recursion Example Results:")
    tri_recursion(6)

    returns Recursion Example Results:  1
                                        3
                                        6
                                       10
                                       15
                                       21
        

In this example, tri_recursion() is a function that we have defined to call itself ("recurse"). We use the k variable as the data, which decrements (-1) every time we recurse. The recursion ends when the condition is not greater than 0 (i.e. when it is 0).

The developer should be very careful with recursion as it can be quite easy to slip into writing a function which never terminates, or one that uses excess amounts of memory or processor power. However, when written correctly recursion can be a very efficient and mathematically-elegant approach to programming.

Lambda Function

Definition

A lambda function is a small anonymous function. A lambda function can take any number of arguments, but can only have one expression.

Syntax

lambda arguments : expression

The expression is executed and the result is returned:

    x = lambda a : a + 10
    print(x(5))
    returns 15
        

Lambda functions can take any number of arguments.

• Multiply argument a with argument b and return the result:

    x = lambda a, b : a * b
    print(x(5, 6))
    returns 30
        

• Summarize argument a, b, and c and return the result:

    x = lambda a, b, c : a + b + c
    print(x(5, 6, 2))
    returns 13
        

Why Use Lambda Functions?

The power of lambda is better shown when you use them as an anonymous function inside another function.

• Say you have a function definition that takes one argument, and that argument will be multiplied with an unknown number:

    def myfunc(n):
        return lambda a : a * n 
        

a) Use that function definition to make a function that always doubles the number you send in:

    def myfunc(n):
        return lambda a : a * n
    mydoubler = myfunc(2)

    print(mydoubler(11))
    returns 22
        

b) Or, use the same function definition to make a function that always triples the number you send in:

    def myfunc(n):
        return lambda a : a * n
    mydoubler = myfunc(3)

    print(mydoubler(11))
    returns 33
        

c) Or, use the same function definition to make both functions, in the same program:

    def myfunc(n):
        return lambda a : a * n
    mydoubler = myfunc(2)
    mytripler = myfunc(3)

    print(mydoubler(11))
    print(mytripler(11))
    returns 22
            33
        

Use lambda functions when an anonymous function is required for a short period of time.

Python Scope

A variable is only available from inside the region it is created. This is called scope.

Local Scope

A variable created inside a function belongs to the local scope of that function, and can only be used inside that function.

    def myfunc():
        x = 300
        print(x)
    myfunc()
    returns 300
        

Function Inside Function

As explained in the example above, the variable x is not available outside the function, but it is available for any function inside the function:

    def myfunc():
        x = 300
        def myinnerfunc():
            print(x)
        myinnerfunc()
    
    myfunc()
    returns 300
        

Global Scope

A variable created in the main body of the Python code is a global variable and belongs to the global scope.
Global variables are available from within any scope, global and local.

    x = 300
    def myfunc():
        print(x)

    myfunc()
    print(x)
    returns 300
            300
        

Naming Variables

If you operate with the same variable name inside and outside of a function, Python will treat them as two separate variables, one available in the global scope (outside the function) and one available in the local scope (inside the function):

    x = 300
    def myfunc():
            x = 200
        print(x)

    myfunc()
    print(x)
    returns 200
            300
        

Global Keyword

If you need to create a global variable, but are stuck in the local scope, you can use the global keyword. The global keyword makes the variable global.

    def myfunc():
        global x
        x = 300

    myfunc()
    print(x)
    returns 300
        

• Also, use the global keyword if you want to make a change to a global variable inside a function.

    x = 300
    def myfunc():
        global x
        x = 200

    myfunc()
    print(x)
    returns 200
        

Nonlocal Keyword

The nonlocal keyword is used to work with variables inside nested functions.
The nonlocal keyword makes the variable belong to the outer function.

    def myfunc1():
        x = "Jane"
        def myfunc2():
            nonlocal x
            x = "hello"
        myfunc2()
        return x
    
    print(myfunc1())
    returns "hello"
        

14. Error Handling (Try..Except)

Definition

Error handling is a critical aspect of programming, and it involves detecting and resolving errors that occur during program execution. Errors detected during execution are called exceptions.

Keywords

In Python to handle errors there are keywords that can be used to indentify and "catch" these errors:
• The try block lets you test a block of code for errors.
• The except block lets you handle the error.
• The else block lets you execute code when there is no error.
• The finally block lets you execute code, regardless of the result of the try- and except blocks.

Exception Handling

Try...Except

When an error occurs, or exception as we call it, Python will normally stop and generate an error message.
These exceptions can be handled using the try statement.
• The try block will generate an exception, because x is not defined:

    try:
        print(x)
    except:
        print("An exception occurred")
    returns "An exception occurred"
        

Since the try block raises an error, the except block will be executed. Without the try..except block, the program will crash and raise an error:

    print(x)
    returns NameError: name 'x' is not defined
        

Many Exceptions

You can define as many exception blocks as you want, e.g. if you want to execute a special block of code for a special kind of error.

    try:
        print(x)
    except NameError:
        print("Variable x is not defined")
    except:
        print("Something else went wrong")
    returns "Variable x is not defined"
        

else

You can use the else keyword to define a block of code to be executed if no errors were raised.

    try:
        print("Hello")
    except:
        print("Something went wrong")
    else:
        print("Nothing went wrong")
    returns "Hello"
            "Nothing went wrong"
        

finally

The finally block, if specified, will be executed regardless if the try block raises an error or not.

    try:
        print(x)
    except:
        print("Something went wrong")
    finally:
        print("The 'try except' is finished")
    returns "Something went wrong"
            "The 'try except' is finished"
        

This can be useful to close objects and clean up resources.

    try:
        f = open("demofile.txt")
        try:
            f.write("Lorum Ipsum")
        except:
            print("Something went wrong when writing to the file")
        finally:
            f.close()
    except:
        print("Something went wrong when opening the file")
    returns "Something went wrong when opening the file"
        

The program can continue, without leaving the file object open.

Raise an exception

As a Python developer you can choose to throw an exception if a condition occurs.
To throw (or raise) an exception, use the raise keyword.

• Raise an error and stop the program if x is lower than 0:

    x = -1
    if x < 0:
        raise Exception("Sorry, no numbers below zero")
    returns "Sorry, no numbers below zero"
        

The raise keyword is used to raise an exception.
You can define what kind of error to raise, and the text to print to the user.

• Raise a TypeError if x is not an integer:

    x = "hello"
        if not type(x) is int:
            raise TypeError("Only integers are allowed")
    returns "Only integers are allowed"
        

Built-in Exceptions

15. User Input

Definition

In Python we can ask the user for input. The input() function allows user input.

    username = input("Enter username:")
    print("Username is: " + username)
        

Or we can use string format:

    username = input("Enter username:")
    print(f"Username is: {username}")
        

Python stops executing when it comes to the input() function, and continues when the user has given some input.

16. Classes and Objects

Definition

Python is an object-oriented programming language. Almost everything in Python is an object, with its properties and methods.
A Class is like an object constructor, or a "blueprint" for creating objects.

Create a Class

To create a class, use the keyword class.

    class MyClass:
        x = 5
        

Create Object

Now we can use the class named MyClass to create objects.

    p1 = MyClass()
    print(p1.x)
    returns 5
        

The __init__() Function

The examples above are classes and objects in their simplest form, and are not really useful in real life applications.
To understand the meaning of classes we have to understand the built-in _init__() function.
All classes have a function called _init__(), which is always executed when the class is being initiated.

Use the _init__() function to assign values to object properties, or other operations that are necessary to do when the object is being created:

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

    p1 = Person("John", 36)

    print(p1.name)
    print(p1.age)
    returns "John"
            "36" 
        

Note: The _init__() function is called automatically every time the class is being used to create a new object.

The __str__() Function

The __str__() function controls what should be returned when the class object is represented as a string.
If the __str__() function is not set, the string representation of the object is returned. • The string representation of an object WITHOUT the __str__() function:

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

    p1 = Person("John", 36)

    print(p1)
    returns "__main__.Person object at 0x15039e602100" 
        

• The string representation of an object WITH the __str__() function:

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

        def __str__(self):
            return f"{self.name}({self.age})"
    
    p1 = Person("John", 36)
    print(p1)
    returns "John(36)" 
        

Object Methods

Objects can also contain methods. Methods in objects are functions that belong to the object.

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

        def myfunc(self):
            print ("Hello my name is " + self.name)"
    
    p1 = Person("John", 36)
    p1.myfunc()

    returns "Hello my name is John" 
        

Note: The self parameter is a reference to the current instance of the class, and is used to access variables that belong to the class.

The self Parameter

The self parameter is a reference to the current instance of the class, and is used to access variables that belong to the class.
It does not have to be named self, you can call it whatever you like, but it has to be the first parameter of any function in the class

    class Person:
	    def __init__(mysillyobject, name, age):
            mysillyobject.name = name
		    mysillyobject.age = age

	    def myfunc(abc):
		    print ("Hello my name is " + abc.name)"
    
    p1 = Person("John", 36)
    p1.myfunc()

    returns "Hello my name is John" 
	    

Modify Object Properties

You can modify properties on objects like this:

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

        def myfunc(self):
            print ("Hello my name is " + self.name)"
        
    p1 = Person("John", 36)
    p1.age = 40
    print(p1.age)

    returns 40
        

Delete Object Properties

You can delete properties on objects by using the del keyword:

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

        def myfunc(self):
            print("Hello my name is " + self.name)"
        
    p1 = Person("John", 36)
    del p1.age
    print(p1.age)

    returns AttributeError: 'Person' object has no attribute 'age'
        

The pass Statement

class definitions cannot be empty, but if you for some reason have a class definition with no content, put in the pass statement to avoid getting an error.

    class Person:
        pass
        

Python Inheritance

Inheritance allows us to define a class that inherits all the methods and properties from another class.
• Parent class is the class being inherited from, also called base class.
• Child class is the class that inherits from another class, also called derived class.

Create a Parent Class

Any class can be a parent class, so the syntax is the same as creating any other class.

    class Person:
    def __init__(self, fname, lname):
        self.firstname = fname
        self.lastname = lname

    def printname(self):
        print(self.firstname, self.lastname)

    #Use the Person class to create an object, and then execute the printname method:
    x = Person("John", "Doe")
    x.printname()
    returns John Doe
        

Create a Child Class

To create a class that inherits the functionality from another class, send the parent class as a parameter when creating the child class.
Create a class named Student, which will inherit the properties and methods from the Person class:

    class Student(Person):
        pass 
        

Note: Use the pass keyword when you do not want to add any other properties or methods to the class.

Now the Student class has the same properties and methods as the Person class.

    class Person:
    def __init__(self, fname, lname):
        self.firstname = fname
        self.lastname = lname

    def printname(self):
        print(self.firstname, self.lastname) 

    class Student(Person):
        pass

    x = Student("Mike", "Olsen")
    x.printname()
    returns John Doe
        

Add the __init__() Function

So far we have created a child class that inherits the properties and methods from its parent.
We want to add the __init__() function to the child class (instead of the pass keyword).

Note: The __init__() function is called automatically every time the class is being used to create a new object.

    class Student(Person):
        def __init__(self, fname, lname):
            self.firstname = fname
            self.lastname = lname
        

When you add the __init__() function, the child class will no longer inherit the parent's __init__() function.

Note: The __init__() function overrides the inheritance of the parent's __init__() function.

• To keep the inheritance of the parent's __init__() function, add a call to the parent's __init__() function:

    class Student(Person):
        def __init__(self, fname, lname):
            Person.__init__(self, fname, lname)
        

The complete code would look lik this:

    class Person:
        def __init__(self, fname, lname):
            self.firstname = fname
            self.lastname = lname

        def printname(self):
            print(self.firstname, self.lastname) 

    class Student(Person):
        def __init__(self, fname, lname):
            Person.__init__(self, fname, lname)

    x = Student("Mike", "Olsen")
    x.printname()
    returns Mike Olsen
        

• Now we have successfully added the __init__() function, and kept the inheritance of the parent class, and we are ready to add functionality in __init__() function.

Use the super() Function

Python also has a super() function that will make the child class inherit all the methods and properties from its parent:

    class Person:
        def __init__(self, fname, lname):
            self.firstname = fname
            self.lastname = lname

        def printname(self):
            print(self.firstname, self.lastname) 

    class Student(Person):
        def __init__(self, fname, lname):
            super().__init__(fname, lname)

    x = Student("Mike", "Olsen")
    x.printname()
    returns Mike Olsen
        

By using the super() function, you do not have to use the name of the parent element, it will automatically inherit the methods and properties from its parent.

Add Properties

Add a property called graduationyear to the Student class:

    class Person:
        def __init__(self, fname, lname):
            self.firstname = fname
            self.lastname = lname

        def printname(self):
            print(self.firstname, self.lastname) 

    class Student(Person):
        def __init__(self, fname, lname):
            super().__init__(fname, lname)
            graduationyear = 2019

        x = Student("Mike", "Olsen")
        print(x.graduationyear)
        returns 2019
        

• In the example below, the year 2019 should be a variable, and passed into the Student class when creating student objects. To do so, add another parameter in the __init__ function.

    class Person:
        def __init__(self, fname, lname):
            self.firstname = fname
            self.lastname = lname

        def printname(self):
            print(self.firstname, self.lastname) 

    class Student(Person):
        def __init__(self, fname, lname, year):
            super().__init__(fname, lname)
            self.graduationyear = year

        x = Student("Mike", "Olsen", 2019)
        print(x.graduationyear)
        returns 2019
        

Add Methods

Add a method called welcome to the Student class:

    class Person:
        def __init__(self, fname, lname):
            self.firstname = fname
            self.lastname = lname

        def printname(self):
            print(self.firstname, self.lastname) 

    class Student(Person):
        def __init__(self, fname, lname, year):
            super().__init__(fname, lname)
            self.graduationyear = year
        
        def welcome(self):
            print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear)
        
    x = Student("Mike", "Olsen", 2024)
    x.welcome
    returns "Welcome Mike Olsen to the class of 2024"
        

Note: If you add a method in the child class with the same name as a function in the parent class, the inheritance of the parent method will be overridden.

Iterators

Definition

An iterator is an object that contains a countable number of values.
An iterator is an object that can be iterated upon, meaning that you can traverse through all the values.
Technically, in Python, an iterator is an object which implements the iterator protocol, which consist of the methods __iter__() and __next__().

Iterator vs Iterable

Lists, tuples, dictionaries, and sets are all iterable objects. They are iterable containers which you can get an iterator from.
All these objects have a iter() method which is used to get an iterator:

    mytuple = ("apple", "banana", "cherry")
    myit = iter(mytuple)

    print(next(myit))
    print(next(myit))
    print(next(myit))
    returns apple
            banana
            cherry
        

• Even strings are iterable objects, and can return an iterator:

    mystr = "banana"
    myit = iter(mystr)

    print(next(myit))
    print(next(myit))
    print(next(myit))
    print(next(myit))
    print(next(myit))
    print(next(myit))

    returns b
            a
            n
            a
            n
            a
        

Looping Through an Iterator

• We can also use a for loop to iterate through an iterable object:

    mytuple = ("apple", "banana", "cherry")
    for x in mytuple:
        print(x)
    returns apple
            banana
            cherry
        

• Iterate the characters of a string:

    mystr = "banana"
    for x in mystr:
        print(x)
    returns b
            a
            n
            a
            n
            a
        

The for loop actually creates an iterator object and executes the next() method for each loop.

Create an Iterator

To create an object/class as an iterator you have to implement the methods __iter__() and __next__() to your object.
As you have learned in the Python Classes/Objects chapter, all classes have a function called __init__(), which allows you to do some initializing when the object is being created.
The __iter__() method acts similar, you can do operations (initializing etc.), but must always return the iterator object itself.
The __next__() method also allows you to do operations, and must return the next item in the sequence.

    class MyNumbers:
        def __iter__(self):
            self.a = 1
            return self

            def __next__(self):
                x = self.a
                self.a += 1
                return x

        myclass = MyNumbers()
        myiter = iter myclass

        print(next(myiter))
        print(next(myiter))
        print(next(myiter))
        print(next(myiter))
        print(next(myiter))
        returns 1
                2
                3
                4
                5
        

Stop Iteration

The example above would continue forever if you had enough next() statements, or if it was used in a for loop.

    class MyNumbers:
        def __iter__(self):
            self.a = 1
            return self

            def __next__(self):
                x = self.a
                self.a += 1
                return x

        myclass = MyNumbers()
        myiter = iter myclass

        for x in myiter:
            print(x)
        

To prevent the iteration from going on forever, we can use the StopIteration statement.

    class MyNumbers:
        def __iter__(self):
            self.a = 1
            return self

        def __next__(self):
            if self.a <= 20:
                x = self.a
                self.a += 1
                return x
            else:
                raise StopIteration

    myclass = MyNumbers()
    myiter = iter myclass

    for x in myiter:
        print(x)
        returns  1
                 2
                 3
                 4
                 5
                 6
                 7
                 8
                 9
                10
                11
                12
                13
                14
                15
                16
                17
                18
                19
                20
        

Polymorphism

Definition

The word "polymorphism" means "many forms", and in programming it refers to methods/functions/operators with the same name that can be executed on many objects or classes.

Function Polymorphism

An example of a Python function that can be used on different objects is the len() function.

String

For strings len() returns the number of characters:

    x = "Hello World!"
    print(len(x))
    returns 12
        

Tuple

For tuples len() returns he number of items in the tuple:

    mytuple = ("apple", "banana", "cherry")
    print(len(mytuple))
    returns 3
        

Dictionary

For dictionaries len() returns the number of key/value pairs in the dictionary:

    thisdict =	{
        "brand": "Ford",
        "model": "Mustang",
        "year": 1964
    }
    print(len(thisdict))
    returns 3
        

Class Polymorphism

Polymorphism is often used in Class methods, where we can have multiple classes with the same method name.
For example, say we have three classes: Car, Boat and Plane, and they all have a method called move():

    class Car:
        def __init__(self, brand, model):
            self.brand = brand
            self.model = model
        
        def move(self):
            print("Drive")

    class Boat:
        def __init__(self, brand, model):
            self.brand = brand
            self.model = model
        
        def move(self):
            print("Sail!")

    class Plane:
        def __init__(self, brand, model):
            self.brand = brand
            self.model = model
        
        def move(self):
            print("Fly!")

    car1 = Car("Ford", "Mustang")       #Create a Car class
    boat1 = Boat("Ibiza", "Touring 20") #Create a Boat class
    plane1 = Plane("Boeing", "747")     #Create a Plane class

    for x in (car1, boat1, plane1):
        x.move
    
    returns Drive!
            Sail!
            Fly!
        

• Look at the for loop at the end. Because of polymorphism we can execute the same method for all three classes.

Inheritance Class Polymorphism

What about classes with child classes with the same name? Can we use polymorphism there?
Yes. If we use the example above and make a parent class called Vehicle, and make Car, Boat, Plane child classes of Vehicle, the child classes inherits the Vehicle methods, but can override them:

    class Vehicle:
        def __init__(self, brand, model):
            self.brand = brand
            self.model = model
    
        def move(self):
            print("Move")

    class Car(Vehicle):
        pass

    class Boat(Vehicle):
        def move(self):
            print("Sail!")

    class Plane(Vehicle):
        def move(self):
            print("Fly!")

    car1 = Car("Ford", "Mustang")       #Create a Car class
    boat1 = Boat("Ibiza", "Touring 20") #Create a Boat class
    plane1 = Plane("Boeing", "747")     #Create a Plane class

    for x in (car1, boat1, plane1):
        print(x.brand)
        print(x.model)
        x.move()
    
    returns Ford
            Mustang
            Move!
            Ibiza
            Touring 20
            Sail!
            Boeing
            747
            Fly!
        

Child classes inherits the properties and methods from the parent class.

In the example above you can see that the Car class is empty, but it inherits brand, model, and move() from Vehicle.
The Boat and Plane classes also inherit brand, model, and move() from Vehicle, but they both override the move() method.
Because of polymorphism we can execute the same method for all classes.

17. Python Modules

Definition

A file containing a set of functions you want to include in your application.
Consider a module to be the same as a code library.

Create a Module

To create a module just save the code you want in a file with the file extension .py

Save this code in a file named mymodule.py

        def greeting(name):
            print("Hello, " + name)
        

Use a Module

Now we can use the module we just created, by using the import statement.

    import mymodule
    mymodule.greeting("Jonathan")
    returns Hello, Jonathan
        

Note: When using a function from a module, use the syntax: module_name.function_name.

Variables in Module

The module can contain functions, as already described, but also variables of all types (arrays, dictionaries, objects etc.).

Save this code in the file mymodule.py

    person1 = {
        "name": "John",
        "age": 36,
        "country": "Norway"
    }
        

Import the module named mymodule, and access the person1 dictionary:

    import mymodule

    a = mymodule.person1["age"]
    print(a)
    returns 36
        

Naming a Module

You can name the module file whatever you like, but it must have the file extension .py

Re-naming a Module

You can create an alias when you import a module, by using the as keyword.

Create an alias for mymodule.py called mx:

    import mymodule as mx

    a = mx.person1["age"]
    print(a)
    returns 36
        

Import From Module

You can choose to import only parts from a module, by using the from keyword.

• The module named mymodule has one function and one dictionary:

    def greeting(name):
        print("Hello, " + name)
        
    person1 = {
        "name": "John",
        "age": 36,
        "country": "Norway"
    }
        

Import only the person1 dictionary from the module:

    from mymodule import person1

    print(person1["age"])
    returns 36
        

Note: When importing using the from keyword, do not use the module name when referring to elements in the module. eg. person1["age"], not mymodule.person1["age"]

Python Package Manager

In Python to install software we use a manager called PIP (an acronym of “pip Install Packages”)

What is PIP?

PIP is a package manager for Python packages, or modules. (built-in with Python 3.4 or later)

What is a Package?

A package contains all the files you need for a module.

Install PIP

Navigate your command line to the location of Python's script directory, and type the following:
pip --version

If you do not have PIP installed, you can download and install it from this page: https://pypi.org/project/pip/

Download a Package

Downloading a package is very easy.
Navigate your command line to the location of Python's script directory, and type the following: pip install camelcase

Using a Package

Once the package is installed, it is ready to use. Import the "camelcase" package into your project.

    import camelcase

    c = camelcase.CamelCase()
    txt = "lorem ipsum dolor sit amet"
    print(c.hump(txt))
    returns Lorem Ipsum Dolor Sit Amet
        

Remove a Package

Use the uninstall command to remove a package:
pip uninstall camelcase

The PIP Package Manager will ask you to confirm that you want to remove the camelcase package, press y (yes) and the package will be removed.

List Packages

Use the list command to list all the packages installed on your system:
pip list

Built-in Modules

There are several built-in modules in Python, which you can import whenever you like. The Python standard library contains well over 200 modules.
Here are the most commonly used modules:

Numeric and Mathematical Module>

Data Types>

Text Processing>

Operating Systems>

MS Windows Specific Services>

Python Runtime Services>

Importing Modules>

Concurrent Execution>

Database>

Cryptographic Services>

Networking and Interprocess Communication>

Internet Related Services>

Graphical User Interfaces>

Numeric and Mathematical Modules

Math Module

Python has also a built-in module called math , which extends the list of mathematical functions.
To use it, you must import the math module:

    import math
        

When you have imported the math module, you can start using methods and constants of the module.
• The math.sqrt() method for example, returns the square root of a number:

    import math

    x = math.sqrt(64)
    print(x)
    returns 8
        

• The math.ceil() method rounds a number upwards to its nearest integer, and the math.floor() method rounds a number downwards to its nearest integer, and returns the result:

    import math

    x = math.ceil (1.4)
    y = math.floor (1.4)

    print(x)
    print(y)
    returns 2
            1
        

• The math.pi constant, returns the value of PI (3.14...):

    import math
    x = math.pi
    print(x)
    returns 3.141592653589793
        

Random Module

This module can be used to perform random actions such as generating random numbers, printing a random value for a list or string, etc.

    import random

    number = random.randint(1, 10)
    print(number)
    # returns a random number between 1 and 10, including 1 & 10
        

The random module has a set of methods:

Random Methods

Data Types

DateTime Module

A date in Python is not a data type of its own, but we can import a module named datetime to work with dates as date objects.

    import datetime

    x = datetime.datetime.now()
    print(x)
    returns 2024-11-28 13:48:08.616653 
        

Date Output

In the example above the date contains year, month, day, hour, minute, second, and microsecond.
The datetime module has many methods to return information about the date object.
Here are a few examples:

        import datetime

        x = datetime.datetime.now()
        print(x.year)
        print(x.strftime("%A"))
        returns 2024
                Thursday
            

Creating Date Objects

To create a date, we can use the datetime() class (constructor) of the datetime module.
The datetime() class requires three parameters to create a date: year, month, day.

    import datetime

    x = datetime.datetime(2020, 5, 17)
    print(x)
    returns 2020-05-17 00:00:00
        

The datetime() class also takes parameters for time and timezone (hour, minute, second, microsecond, tzone), but they are optional, and has a default value of 0, (None for timezone).

The strftime() Method

The datetime() object has a method for formatting date objects into readable strings.
The method is called strftime(), and takes one parameter, format, to specify the format of the returned string.

    import datetime

    x = datetime.datetime(2018, 6, 1)
    print(x.strftime("%B"))
    returns june
        

strftime Formats

Calendar Module

The calendar module is used to display calendars and provides useful Built-in functions for displaying week, week day, month, month of the year, and other operations.
By default, these calendars have Monday as the first day of the week, and Sunday as the last.

Calendar Methods

• Display the Year of a Calendar:

    import calendar

    year = 2024
    print(calendar.calendar(year))
        

• Display the Month of a Calendar:

    import calendar

    print(calendar.month(2024,11))
        

• Get the Weekday number:

    import calendar

    print(f'Monday Weekday Number: {calendar.MONDAY}')
    print(f'Tuesday Weekday Number: {calendar.TUESDAY}')
    print(f'Wednesday Weekday Number: {calendar.WEDNESDAY}')
    print(f'Thursday Weekday Number: {calendar.THURSDAY}')
    print(f'Friday Weekday Number: {calendar.FRIDAY}')
    print(f'Saturday Weekday Number: {calendar.SATURDAY}')
    print(f'Sunday Weekday Number: {calendar.SUNDAY}')

    returns Monday Weekday Number: 0
            Tuesday Weekday Number: 1
            Wednesday Weekday Number: 2
            Thursday Weekday Number: 3
            Friday Weekday Number: 4
            Saturday Weekday Number: 5
            Sunday Weekday Number: 6
        

• Check if an Year is a Leap Year:

    import calendar

    print(calendar.isleap(2020))
    print(calendar.isleap(2021))
    print(calendar.isleap(2022))
    print(calendar.isleap(2023))
    print(calendar.isleap(2024))
    print(calendar.isleap(2025))

    returns True
            False
            False
            False
            True
            False
        

Calendar Formats

The calendar() module also have a few formats.

Calendar Methods

• Text-Based Calendars:
To generate plain text calendars, the calendar module provides calendar.TextCalendar with methods to format and print monthly and yearly calendars.
TextCalendar.formatyear() accepts a single parameter for the year:

    import calendar

    text_calendar = calendar.TextCalendar()
    print(text_calendar.formatyear(2024))
    returns 
                            2024

        January                   February                   March
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
1  2  3  4  5  6  7                1  2  3  4                   1  2  3
8  9 10 11 12 13 14       5  6  7  8  9 10 11       4  5  6  7  8  9 10
15 16 17 18 19 20 21      12 13 14 15 16 17 18      11 12 13 14 15 16 17
22 23 24 25 26 27 28      19 20 21 22 23 24 25      18 19 20 21 22 23 24
29 30 31                  26 27 28 29               25 26 27 28 29 30 31

        April                      May                       June
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
1  2  3  4  5  6  7             1  2  3  4  5                      1  2
8  9 10 11 12 13 14       6  7  8  9 10 11 12       3  4  5  6  7  8  9
15 16 17 18 19 20 21      13 14 15 16 17 18 19      10 11 12 13 14 15 16
22 23 24 25 26 27 28      20 21 22 23 24 25 26      17 18 19 20 21 22 23
29 30                     27 28 29 30 31            24 25 26 27 28 29 30

        July                     August                  September
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
1  2  3  4  5  6  7                1  2  3  4                         1
8  9 10 11 12 13 14       5  6  7  8  9 10 11       2  3  4  5  6  7  8
15 16 17 18 19 20 21      12 13 14 15 16 17 18       9 10 11 12 13 14 15
22 23 24 25 26 27 28      19 20 21 22 23 24 25      16 17 18 19 20 21 22
29 30 31                  26 27 28 29 30 31         23 24 25 26 27 28 29
                                                    30

        October                   November                  December
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
1  2  3  4  5  6                   1  2  3                         1
7  8  9 10 11 12 13       4  5  6  7  8  9 10       2  3  4  5  6  7  8
14 15 16 17 18 19 20      11 12 13 14 15 16 17       9 10 11 12 13 14 15
21 22 23 24 25 26 27      18 19 20 21 22 23 24      16 17 18 19 20 21 22
28 29 30 31               25 26 27 28 29 30         23 24 25 26 27 28 29
                                                    30 31
        

Text-Based Calendar Methods

• HTMLCalendar:
to create a calendar for a website, the calendar module can also output calendars in HTML with calendar.HTMLCalendar with methods to format and print monthly and yearly calendars.

    import calendar

    html_calendar = calendar.HTMLCalendar()
    print(html_calendar.formatyear(2024))
    returns the code to build an HTML Table which would look like this:

    

    
2024

    
January
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
1
2
3
4
5
6
7
    
8
9
10
11
12
13
14
    
15
16
17
18
19
20
21
    
22
23
24
25
26
27
28
    
29
30
31
 
 
 
 
    
    

    
February
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
 
 
 
1
2
3
4
    
5
6
7
8
9
10
11
    
12
13
14
15
16
17
18
    
19
20
21
22
23
24
25
    
26
27
28
29
 
 
 
    
    

    
March
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
 
 
 
 
1
2
3
    
4
5
6
7
8
9
10
    
11
12
13
14
15
16
17
    
18
19
20
21
22
23
24
    
25
26
27
28
29
30
31
    
    

    
April
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
1
2
3
4
5
6
7
    
8
9
10
11
12
13
14
    
15
16
17
18
19
20
21
    
22
23
24
25
26
27
28
    
29
30
 
 
 
 
 
    
    

    
May
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
 
 
1
2
3
4
5
    
6
7
8
9
10
11
12
    
13
14
15
16
17
18
19
    
20
21
22
23
24
25
26
    
27
28
29
30
31
 
 
    
    

    
June
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
 
 
 
 
 
1
2
    
3
4
5
6
7
8
9
    
10
11
12
13
14
15
16
    
17
18
19
20
21
22
23
    
24
25
26
27
28
29
30
    
    

    
July
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
1
2
3
4
5
6
7
    
8
9
10
11
12
13
14
    
15
16
17
18
19
20
21
    
22
23
24
25
26
27
28
    
29
30
31
 
 
 
 
    
    

    
August
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
 
 
 
1
2
3
4
    
5
6
7
8
9
10
11
    
12
13
14
15
16
17
18
    
19
20
21
22
23
24
25
    
26
27
28
29
30
31
 
    
    

    
September
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
 
 
 
 
 
 
1
    
2
3
4
5
6
7
8
    
9
10
11
12
13
14
15
    
16
17
18
19
20
21
22
    
23
24
25
26
27
28
29
    
30
 
 
 
 
 
 
    
    

    
October
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
 
1
2
3
4
5
6
    
7
8
9
10
11
12
13
    
14
15
16
17
18
19
20
    
21
22
23
24
25
26
27
    
28
29
30
31
 
 
 
    
    

    
November
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
 
 
 
 
1
2
3
    
4
5
6
7
8
9
10
    
11
12
13
14
15
16
17
    
18
19
20
21
22
23
24
    
25
26
27
28
29
30
 
    
    

    
December
    
Mon
Tue
Wed
Thu
Fri
Sat
Sun
    
 
 
 
 
 
 
1
    
2
3
4
5
6
7
8
    
9
10
11
12
13
14
15
    
16
17
18
19
20
21
22
    
23
24
25
26
27
28
29
    
30
31
 
 
 
 
 
    
    
        

HTML Calendar Methods

Text Processing

Strings Module

Strings module is specifically designed for common string operations. It provides constants representing commonly used sets of characters (like lowercase and uppercase letters, digits, and punctuation) as well as utility functions like capwords() for manipulating strings.

Strings Constants

Whitespace Validation

We can use whitespace to check if a string contains only whitespace characters:

    import string

    def is_only_whitespace(s):
        return all(char in string.whitespace for char in s)

    print(is_only_whitespace("   \t\n"))
    returns TRUE
        

String Module Functions

Apart from constants, the string module provides several useful functions for string manipulation.

→ The capwords() The capwords() function capitalizes the first letter of every word in a string and lowers the rest of the letters. It also replaces multiple spaces between words with a single space.

    import string

    text = "hello, coder! this is your codeforcoders!"
    print(string.capwords(text))
    returns Hello, Coder! This Is Your Codeforcoders!
        

We can use capwords() to format user input or generate titles for articles, books, etc.

→ The formatter() provides an extensible way to create custom string formatting. It works behind the scenes in Python’s str.format() method but can be customized to fit our needs.

    from string import formatter

    print(formatter.format("Hello, {}!", "coder"))
    returns Hello, coder!
        

If we need special formatting rules beyond what str.format() provides, we can use Formatter() to define our own logic. → The Template() class allows us to create string templates where placeholders can be replaced by values. It's useful for situations where we need simple string substitution.

    from string import Template
    
    text = Template("Hello, $name!")
    print(text.substitute(name="coder"))
    returns Hello, coder!
        

⇉ The Template() class also offers safe substitution (safe_substitute) which will not raise an exception if a placeholder is missing:

    from string import Template
    
    text = Template("Hello, $name!")
    print(text.safe_substitute(name="Python"))
    print(text.safe_substitute())

    returns Hello, Python
            Hello, $name
        

We can use Template() for creating email templates where placeholders like $name or $date are replaced with actual values.

RegEx Module

A RegEx, or Regular Expression, is a sequence of characters that forms a search pattern. RegEx can be used to check if a string contains the specified search pattern.

    import re

    txt = "The rain in Spain"
    x = re.search("^The.*Spain$", txt)

    if x:
        print("YES! We have a match!")
    else:
        print("No match")
    
    returns YES! We have a match!
        

The re module offers a set of functions that allows us to search a string for a match.

RegEx Functions

Metacharacters

Metacharacters are characters with a special meaning:

Special Sequences

A special sequence is a \ followed by one of the characters in the list below, and has a special meaning:

Sets

A set is a set of characters inside a pair of square brackets [] with a special meaning:

The findall() Function

The findall() function returns a list containing all matches.

    import re

    txt = "The rain in Spain"
    x = re.findall("ai", txt)


    print(x)
    returns ['ai', 'ai']
        

The list contains the matches in the order they are found.
If no matches are found, an empty list is returned:

    import re

    txt = "The rain in Spain"
    x = re.findall("Portugal", txt)

    print(x)
    returns []
        

The search() Function

The search() searches the string for a match, and returns a Match object if there is a match.
If there is more than one match, only the first occurrence of the match will be returned:

    import re

    txt = "The rain in Spain"
    x = re.search("\s", txt)

    print("The first white-space character is located in position:", x.start())
    returns The first white-space character is located in position: 3
        

If no matches are found, the value None is returned:

    import re

    txt = "The rain in Spain"
    x = re.search("Portugal", txt)

    print(x)
    returns None
        

The split() Function

The split() function returns a list where the string has been split at each match:

    import re

    txt = "The rain in Spain"
    x = re.split("\s", txt)

    print(x)
    returns ['The', 'rain', 'in', 'Spain']
        

You can control the number of occurrences by specifying the maxsplit parameter:

    import re

    txt = "The rain in Spain"
    x = re.split("\s", txt, 1) #Split the string at the first white-space character

    print(x)
    returns ['The', 'rain in Spain']
        

The sub() Function

The sub() function replaces the matches with the text of your choice:

    import re

    txt = "The rain in Spain"
    x = re.sub("\s", "9", txt)

    print(x)
    returns The9rain9in9Spain
        

You can control the number of replacements by specifying the count parameter:

    import re

    txt = "The rain in Spain"
    x = re.sub("\s", "9", txt, 2)

    print(x)
    returns The9rain9in Spain
        

Match Object

A Match Object is an object containing information about the search and the result.
Note:If there is no match, the value None will be returned, instead of the Match Object.

You can control the number of replacements by specifying the count parameter:

    import re

    txt = "The rain in Spain"
    x = re.search("ai", txt)

    print(x) #this will print an object
    returns sre.SRE_Match object; span=(5, 7), match='ai'
        

The Match object has properties and methods used to retrieve information about the search, and the result:
• .span() returns a tuple containing the start-, and end positions of the match.

    import re

    txt = "The rain in Spain"
    x = re.search(r"\bS\w+", txt)

    print(x.span())
    returns (12, 17)
        

• .string returns the string passed into the function.

    import re

    txt = "The rain in Spain"
    x = re.search(r"\bS\w+", txt)

    print(x.string)
    returns The rain in Spain
        

• .group() returns the part of the string where there was a match.

    import re

    txt = "The rain in Spain"
    x = re.search(r"\bS\w+", txt)

    print(x.group())
    returns Spain
        

Note: If there is no match, the value None will be returned, instead of the Match Object.

Operating Systems

OS Module

Python has a built-in os module with methods for interacting with the operating system, like creating files and directories, management of files and directories, input, output, environment variables, process management, etc.
The os module has the following set of methods and constants.

OS Methods

OS Objects

OS Constants

OS Classes

Platform Module

The Platform Module is used to retrieve as much possible information about the platform on which the program is being currently executed.
It can be imported using the following syntax:

    import platform
    
    print('Platform processor:', platform.processor())
    returns 'Platform processor:' 'Intel64 family 69 Stepping 1', 'GenuineIntel'
        

Platform Functions

Python Runtime Services

SYS Module

The SYS Module provides various functions and variables that are used to manipulate different parts of the Python runtime environment.

• sys.version returns a string containing the version of Python Interpreter with some additional information.

    import sys
    
    print(sys.version)
    returns 3.6.9 (default, Oct  8 2020, 12:12:24) [GCC 8.4.0]
        

• sys.path returns the list of directories that the interpreter will search for the required module.

    import sys
    
    print(sys.path)
    returns ['/usr/lib/python312.zip', '/usr/lib/python3.12', '/usr/lib/python3.12/lib-dynload', '/home/user/PycharmProjects/MyProject/.venv/lib/python3.12/site-packages']
        

• sys.module return the name of the Python modules that the current shell has imported.

    import sys
    
    print(sys.module)
    returns {'sys': module 'sys' (built-in)>, 'builtins': module 'builtins' (built-in)>, '_frozen_importlib': module '_frozen_importlib' (frozen)>, '_imp': module '_imp' (built-in)>, 
            '_thread': module '_thread' (built-in)>, '_warnings': module '_warnings' (built-in)>, '_weakref': module '_weakref' (built-in)>, '_io': module '_io' (built-in)>, 'marshal': module 'marshal' (built-in)>, 'posix': module 'posix' (built-in)>, 
            '_frozen_importlib_external': module '_frozen_importlib_external' (frozen)>, 'time': module 'time' (built-in)>, 'zipimport': module 'zipimport' (frozen)>, '_codecs': module '_codecs' (built-in)>, 
            'codecs': module 'codecs' (frozen)>, 'encodings.aliases': module 'encodings.aliases' from '/usr/lib/python3.12/encodings/aliases.py'>, 'encodings': module 'encodings' from '/usr/lib/python3.12/encodings/__init__.py'>, 
            'encodings.utf_8': module 'encodings.utf_8' from '/usr/lib/python3.12/encodings/utf_8.py'>, '_signal': module '_signal' (built-in)>, '_abc': module '_abc' (built-in)>, 'abc': module 'abc' (frozen)>, 
            'io': module 'io' (frozen)>, '__main__': module '__main__' from '/home/reaper/PycharmProjects/Password Manager/test.py'>, '_stat': module '_stat' (built-in)>, 'stat': module 'stat' (frozen)>, 
            '_collections_abc': module '_collections_abc' (frozen)>, 'genericpath': module 'genericpath' (frozen)>, 'posixpath': module 'posixpath' (frozen)>, 'os.path': module 'posixpath' (frozen)>, 
            'os': module 'os' (frozen)>, '_sitebuiltins': module '_sitebuiltins' (frozen)>, '__future__': module '__future__' from '/usr/lib/python3.12/__future__.py'>, 'itertools': module 'itertools' (built-in)>, 
            'keyword': module 'keyword' from '/usr/lib/python3.12/keyword.py'>, '_operator': module '_operator' (built-in)>, 'operator': module 'operator' from '/usr/lib/python3.12/operator.py'>, 
            'reprlib': module 'reprlib' from '/usr/lib/python3.12/reprlib.py'>, '_collections': module '_collections' (built-in)>, 'collections': module 'collections' from '/usr/lib/python3.12/collections/__init__.py'>, 
            'types': module 'types' from '/usr/lib/python3.12/types.py'>, '_functools': module '_functools' (built-in)>, 'functools': module 'functools' from '/usr/lib/python3.12/functools.py'>, 
            'contextlib': module 'contextlib' from '/usr/lib/python3.12/contextlib.py'>, '_virtualenv': module '_virtualenv' from '/home/reaper/PycharmProjects/Password Manager/.venv/lib/python3.12/site-packages/_virtualenv.py'>, 
            'sitecustomize': module 'sitecustomize' from '/usr/lib/python3.12/sitecustomize.py'>, 'site': module 'site' (frozen)>, 'enum': module 'enum' from '/usr/lib/python3.12/enum.py'>, '_sre': module '_sre' (built-in)>, 
            're._constants': module 're._constants' from '/usr/lib/python3.12/re/_constants.py'>, 're._parser': module 're._parser' from '/usr/lib/python3.12/re/_parser.py'>, 're._casefix': module 're._casefix' from '/usr/lib/python3.12/re/_casefix.py'>, 
            're._compiler': module 're._compiler' from '/usr/lib/python3.12/re/_compiler.py'>, 'copyreg': module 'copyreg' from '/usr/lib/python3.12/copyreg.py'>, 're': module 're' from '/usr/lib/python3.12/re/__init__.py'>, 
            'platform': module 'platform' from '/usr/lib/python3.12/platform.py'>, 'errno': module 'errno' (built-in)>, '_locale': module '_locale' (built-in)>, 'locale': module 'locale' from '/usr/lib/python3.12/locale.py'>, 
            'signal': module 'signal' from '/usr/lib/python3.12/signal.py'>, '_weakrefset': module '_weakrefset' from '/usr/lib/python3.12/_weakrefset.py'>, 'threading': module 'threading' from '/usr/lib/python3.12/threading.py'>, 
            'warnings': module 'warnings' from '/usr/lib/python3.12/warnings.py'>, 'fcntl': module 'fcntl' (built-in)>, '_posixsubprocess': module '_posixsubprocess' (built-in)>, 'select': module 'select' (built-in)>, 
            'collections.abc': module 'collections.abc' from '/usr/lib/python3.12/collections/abc.py'>, 'math': module 'math' (built-in)>, 'selectors': module 'selectors' from '/usr/lib/python3.12/selectors.py'>, 
            'subprocess': module 'subprocess' from '/usr/lib/python3.12/subprocess.py'>, '_struct': module '_struct' (built-in)>, 'struct': module 'struct' from '/usr/lib/python3.12/struct.py'>}
        

• getrefcount() is used to get the reference count for any given object. This value is used by Python as when this value becomes 0, the memory for that particular value is deleted

    import sys
    
    a = 'Geeks'
    print(sys.getrefcount(a))
    returns 4
        

• stdin is used to get input from the command line directly. It is used for standard input. It internally calls the input() method. It, also, automatically adds ‘\n’ after each sentence.

    import sys
    
    for line in sys.stdin:
        if x == line.rstrip():
            break
        print(f'Input : {line}')

    print("Exit")
        

• stdout is used to display output directly to the screen console.

    import sys
    
    sys.stdout.write('Coding is awesome')

    returns 'Coding is awesome'
        

• Whenever an exception occurs in Python it is written to stderr.

    import sys
    
    def print_to_stderr(*a):
        print(*a, file = sys.stderr)

    print_to_stderr("Hello World")
        

• sys.argv is a Command-line argument which are passed during the calling of the program along with the calling statement.

    import sys
    
    n = len(sys.argv)
    print("Total arguments passed:", n)
    print("\nName of Python script:", sys.argv[0])
    print("\nArguments passed:", end = " ")

    for i in range(1, n):
        print(sys.argv[i], end = " ")
    
    Sum = 0
    for i in range(1, n):
        Sum += int(sys.argv[i])

    print("\n\nResult:", Sum)
        

• sys.exit can be used to exit the program.

    import sys

    age = 17
    if age < 18:
        sys.exit("Age less than 18") 
    else:
        print("Age is not less than 18")
        

• sys.setrecursionlimit() is used to set the maximum depth of the Python interpreter stack to the required limit, while sys.getrecursionlimit() is used to find the current recursion limit of the interpreter or to find the maximum depth of the Python interpreter stack.

    import sys

    limit = sys.getrecursionlimit()
    print('Before changing, limit of stack =', limit)

    Newlimit = 500
    sys.setrecursionlimit(Newlimit)

    limit = sys.getrecursionlimit() 
    print('After changing, limit of stack =', limit)
    
    returns Before changing, limit of stack = 1000
            After changing, limit of stack = 500
        

• sys.settrace() is used for implementing debuggers, profilers and coverage tools.

    from sys import settrace

    def my_tracer(frame, event, arg = None):
        code = frame.f_code
        func_name = code.co_name
        line_no = frame.f_lineno

        print(f"A {event} encountered in \
        {func_name}() at line number {line_no} ")

        return my_tracer

    def fun():
        return "GFG"
    
    def check():
        return fun()

    settrace(my_tracer) 
  
    check() 
    
    returns A call encountered in check() at line number 30 
            A line encountered in check() at line number 31 
            A call encountered in fun() at line number 24 
            A line encountered in fun() at line number 25 
            A return encountered in fun() at line number 25 
            A return encountered in check() at line number 31
        

• sys.setswitchinterval() is used to set the interpreter’s thread switch interval (in seconds).

    import sys

    interval = sys.getswitchinterval()
    print('Before changing, switchinterval =', interval)

    interval = 1
    sys.setswitchinterval(interval)

    interval = sys.getswitchinterval() 
    print('After changing, switchinterval =', interval)
    
    returns Before changing, switchinterval = 0.005
            After changing, switchinterval = 1.0
        

• sys.maxsize() fetches the largest value a variable of data type Py_ssize_t can store.

    import sys

    max_val = sys.maxsize
    print(max_val)
    
    returns 9223372036854775807
        

• sys.getdefaultencoding() is used to get the current default string encoding used by the Unicode implementation.

    import sys

    encoding = sys.getdefaultencoding()
    print(encoding)
    
    returns utf-8
        

Concurrent Execution

SubProcess Module

The subprocess modul is a built-in module that allows us to create new child processes. We can get exit codes, output, and error messages from these child processes. It is a valuable tool for executing external functions or commands in your Python code. Think of it as a way to programmatically interact with your computer using Python instead of manually entering commands in the terminal. This module simplifies the implementation process and seamlessly integrates external programming into your Python workflow.

Uses of Subprocess Module

• Run system commands or external programs from your Python script.
• Handle input, output, and errors caused by child programs in your Python code.
• Capture the output (stdout) and error messages (stderr) generated by these commands.
• Communicate with the running process by sending input (stdin).
• Wait for the command to complete and obtain its return code to check for success or failure.

Subprocess functions

• subprocess.Popen is a low-level interface for running subprocesses. Allows you to start a new process and interact with its standard input, output, and error streams. It returns a handle to the running procedure that can be used to wait for the procedure to complete, check its return code, or abort it.
• subprocess.run s a high-level wrapper around Popen intended for ease of use. is a more flexible function that allows you to run a command and capture its results in a single call, allowing you to specify options for a command without having to create a Popen object and manage the streams yourself, such as whether to raise or exception if the command fails.

* run() in Windows:

    import subprocess

    result = subprocess.run(["dir"], shell=True, capture_output=True, text=True)
    print(result.stdout)
        

* run() in Linux:

    import subprocess

    result = subprocess.run(["ls"], capture_output=True, text=True)
    print(result.stdout)
        

Note: You should use subprocess.run if you just want to run the command and capture its output and subprocess.Popen if you need more control over the process, such as interacting with its input and output streams. The Popen class takes the same arguments as run(), including args specifying which commands to run and other optional arguments such as stdin, stdout, stderr, shell, cwd, and env

    import subprocess

    try:
        ans = subprocess.check_output(["python", "--version"], text=True)
        print(ans)
    except subprocess.CalledProcessError as e:
        print(f"Command failed with return code {e.returncode}")
    
    returns Python 3.7.17
        

• subprocess.PIPE can connect the output of one command to the input of another, allowing the output of the first command to be used as input to the second command.

    import subprocess

    lsProcess = subprocess.Popen(["ls"], stdout=subprocess.PIPE, text=True)
    grepProcess = subprocess.Popen(
        ["grep", "sample"], stdin=ls_process.stdout,
        stdout=subprocess.PIPE, text=True)
    output, error = grepProcess.communicate()

    print(output)
    print(error)
        

• subprocess.call() is employed to execute a command in a separate process and wait for its completion. The function returns a return code, which is typically zero for success and non-zero for failure.

    import subprocess

    ans = subprocess.call(["python", "--version"])
    if ans == 0:
        print("Command executed.")
    else:
        print("Command failed.", return_code)
        returns Python 3.7.17
                Command executed.
        

Concurrent Module

The concurrent.futures module provides a high-level interface for asynchronously executing callables. The asynchronous execution can be performed with threads, using ThreadPoolExecutor, or separate processes, using ProcessPoolExecutor.

ThreadPoolExecutor Methods

• submit(fn, *args, **kwargs): It runs a callable or a method and returns a Future object representing the execution state of the method.

    from concurrent.futures import ThreadPoolExecutor

    with ThreadPoolExecutor(max_workers=1) as executor:
        future = executor.submit(pow, 323, 1235)
        print(future.result())
        

• map(fn, *iterables, timeout=None, chunksize=1): It maps the method and iterables together immediately and will raise an exception concurrent. futures.TimeoutError if it fails to do so within the timeout limit.

    from concurrent.futures import ThreadPoolExecutor
    from time import sleep

    values = [3,4,5,6]

    def cube(x):
        print(f'Cube of {x}:{x*x*x}')

    if __name__ == '__main__':
        result =[]
        with ThreadPoolExecutor(max_workers=5) as executor:
        executor.submit(cube, 2)
        executor.map(cube,values)

        returns Cube of 2:8
                Cube of 3:27
                Cube of 4:64
                Cube of 5:125
                Cube of 6:216
        

• shutdown(wait=True, *, cancel_futures=False):
* It signals the executor to free up all resources when the futures are done executing.
* It must be called after executor.submit() and executor.map() method else it would throw RuntimeError.
* wait=True makes the method not to return until execution of all threads is done and resources are freed up.
* cancel_futures=True then the executor will cancel all the future threads that are yet to start.

    from concurrent.futures import ThreadPoolExecutor
    from time import sleep

    values = [3,4,5,6]

    def cube(x):
        print(f'Cube of {x}:{x*x*x}')
        sleep(1)

    if __name__ == '__main__':
        executor = ThreadPoolExecutor(max_workers=3)
        executor.submit(cube, 2)
        executor.map(cube,values)

        executor.shutdown(wait=True)
        print("Executor has been shut down.")

        returns Cube of 2:8
                Cube of 3:27
                Cube of 4:64
                Cube of 5:125
                Cube of 6:216
                Executor has been shut down.
        

ProcessPoolExecutor Methods

The ProcessPoolExecutor, like ThreadPoolExecutor, uses submit, map and shutdown fuctions. It also has additional methods:
• cancel(): It Attempts to cancel the call, if the call cannot be canceled then it returns False, else True.
• cancelled(): Returns True if the call is canceled.
• running(): Rreturn True if the process is running and cannot be canceled.
• done(): Returns True if the process has finished executing.
• result(timeout=None): Returns the value which is returned by the process, if the process is still in execution then it waits for the timeout specified else raises a TimeoutError, if None is specified it will wait forever for the process to finish.
• add_done_callback(fn): Attaches a callback function which is called when the process finishes its execution.

Databases

SqLite Module

See the Database section for more details

Graphical User Interface

TKinter Module

See the Graphical User Interface section for more details

Cryptographic Services

Definition

A Cryptographic hash function is a function that takes in input data and produces a statistically unique output, which is unique to that particular set of data. The hash is a fixed-length byte stream used to ensure the integrity of the data

Hashlib Module

The hashlib module implements a common interface for many secure cryptographic hash and message digest algorithms. There is one constructor method named for each type of hash. All return a hash object with the same simple interface. Constructors for hash algorithms are always present in this module.

• hashlib.algorithms_guaranteed is a set containing the names of the hash algorithms is guaranteed to be supported by this module on all platforms.

    print(hashlib.algorithms_guaranteed)
    returns {‘sha3_512’, ‘sha1’, ‘sha224’, ‘shake_256’, ‘sha3_384’, ‘sha512’, ‘sha384’, ‘blake2s’, ‘md5’, ‘sha3_224’, ‘sha256’, ‘blake2b’, ‘sha3_256’, ‘shake_128’}       
        

• hashlib.algorithms_available is a set containing the names of the hash algorithms available in the running Python interpreter. The same algorithm may appear multiple times in this set under different names (due to OpenSSL).

    print(hashlib.algorithms_available)
    returns {‘sha384’, ‘sha3_224’, ‘whirlpool’, ‘ripemd160’, ‘blake2s’, ‘md5-sha1’, ‘sm3’, ‘sha256’, ‘shake_256’, ‘sha1’, ‘sha3_384’, ‘sha512’, ‘blake2b’, ‘sha512_256’, ‘sha3_256’, ‘shake_128’, ‘sha3_512’, ‘sha224’, ‘md5’, ‘mdc2’, ‘sha512_224’, ‘md4’}       
        

We will use the FIPS secure hash algorithm SHA-256 to obtain the file hash.
Other secure hash algorithms include:
• MD5 (Message Digest 5)
• SHA-512 (Secure Hashing Algorithm 512 bits)
• RC4 (Rivest Cipher 4)

The reason for the usage of SHA-256 is it is one of the most renowned and secure hashing algorithms currently used while offering less time required to compute a hash. The algorithm belongs to the SHA-2 Family, which is succeeded by the SHA-3 family based on sponge construction structure.

Cryptographic Hash

• Obtaining a Cryptographic Hash of a File

    import sys
    import hashlib

    def hashfile(file):
        # A arbitrary (but fixed) buffer size
        # 65536 = 65536 bytes = 64 kilobytes
        BUF_SIZE = 65536

        sha256 = hashlib.sha256()

        with open("test.txt", 'rb') as f:
            while True:
                data = f.read(BUF_SIZE)

                if not:
                    break
                
                sha256.update(data)

        return sha256.hexdigest()

    file_hash = hashfile(sys.argv[1])
    print(f"Hash:{file_hash}")
    returns Hash:7f83b1657fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069
        

• Obtaining a Cryptographic Hash of a String

    import hashlib

    string = b"My name is apple and I am a vegetable?"
    sha256 = hashlib.sha256()
    sha256.update(string)
    string_hash = sha256.hexdigest()

    print(f"Hash:{string_hash}")
    returns Hash:252f8ca07a6fcaae293e5097151c803a7f16504e48c4eb60f651c11341e83217
        

Secrets Module

The secrets module is used for generating random numbers for managing important data such as passwords, account authentication, security tokens, and related secrets, that are cryptographically strong.

Random Numbers

• secrets.choice() returns a randomly-chosen element from a non-empty sequence to manage a basic level of security.

    import secrets
    import strings

    alphabet = string.ascii_letters + string.digits 
    password = ''.join(secrets.choice(alphabet) for i in range(10))

    print(password)
    returns 'tmX47l1uo4'
        

Generate a ten-character alphanumeric password with at least one lowercase character, at least one uppercase character, and at least three digits.

    import secrets
    import strings

    alphabet = string.ascii_letters + string.digits

    while True:
        password = ''.join(secrets.choice(alphabet) for i in range(10))
        if (any(c.islower() for c in password) and any(c.isupper()
        for c in password) and sum(c.isdigit() for c in password) >= 3):
            print(password)
            break
        
    returns Tx8LppU05Q
        

• secrets.randbelow(n) returns a random integer in the range (0, n).

    import secrets
    
    passwd = secrets.randbelow(20)

    print(passwd)
    returns 2
        

• secrets.randbits(k) returns an int with k random bits.

    import secrets
    
    passwd = secrets.randbits(7)

    print(passwd)
    returns 61
        

Generating tokens

his module provides several functions for generating secure tokens for applications such as password resets, hard-to-guess URLs etc. • secrets.token_bytes([nbytes=None]) is responsible for generating a random byte string containing nbytes number of bytes. If no value is provided, a reasonable default is used.

    import secrets
    
    token1 = secrets.token_bytes() 
    token2 = secrets.token_bytes(10) 

    print(token1)
    print(token2)
    returns b"\x86?\x85\xcf\x8ek8ud\x8a\x92\x8b>R\xc7\x89_\xc4x\xce'u]\x95\x0c\x05*?HG8\xfb"
            b'Dx\xe8\x7f\xc05\xdf\xe0\xf6\xe1'
    
        

• secrets.token_hex([nbytes=None]) is responsible for generating a random text string in hexadecimal containing nbytes random bytes. If no value is provided, a reasonable default is used.

    import secrets
    
    token1 = secrets.token_hex(16) 
    token2 = secrets.token_hex(9) 

    print(token1)
    print(token2)
    returns 5d894a501c88fbe735c6ff496a6d3e51
            78baed9057e597dce4
    
        

• secrets.token_urlsafe([nbytes=None]) is responsible for generating a random URL-safe text string containing nbytes random bytes. This is suitable for password recovery applications.

    import secrets
    
    url = 'https://mydomain.com/reset=' + secrets.token_urlsafe()

    print(url)
    returns https://mydomain.com/reset=GbOiFIvhMoqWsfaTQKbj8ydbo8G1lsMx1ECa6SXjb1s
        

Note: At least 32 bytes for tokens should be used to be secure against a brute-force attack.

Networking and Interprocess Communication

Socket Module

Socket programming is a way of connecting two nodes on a network to communicate with each other. One socket(node) listens on a particular port at an IP, while the other socket reaches out to the other to form a connection. The server forms the listener socket while the client reaches out to the server.
They are the real backbones behind web browsing.

• Connecting to a server:

    import socket
    import sys

    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)    
        print("Socket successfully created")
    except socket.error as err:
        print("socket creation failed with error %s" %(err))
        
    port = 80

    try:
        host_ip = socket.gethostbyname('www.google.com') 
    except socket.gaierror:
        print("there was an error resolving the host")
        sys.exit()

    s.connect((host_ip, port))
    print("the socket has successfully connected to google")
        

A simple server-client program:

• Server:

A server has a bind() method which binds it to a specific IP and port so that it can listen to incoming requests on that IP and port. A server has a listen() method which puts the server into listening mode. This allows the server to listen to incoming connections. And last a server has an accept() and close() method. The accept method initiates a connection with the client and the close method closes the connection with the client.

    import socket

    s = socket.socket()   
    print("Socket successfully created")
        
    port = 12345

    s.bind(('', port))
    print("socket binded to %s" %(port))

    s.listen(5)
    print("socket is listening")

    while True:
        c, addr = s.accept()
        print('Got connection from', addr )

        c.send('Thank you for connecting'.encode())
        c.close()

        break
        

• Client:

Now we need something with which a server can interact.

    import socket

    s = socket.socket()
    port = 12345
    s.connect(('127.0.0.1', port))

    print(s.recv(1024).decode())

    s.close()
        

Check internet conectivity

A simple script to check if an active internet connection is available.

    import socket

    def check_internet_connection(host="8.8.8.8", port=53, timeout=5):
        try:
            socket.setdefaulttimeout(timeout)
            socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((host, port))
            return True
        except socket.error as ex:
            print(f"No internet connection: {ex}")
            return False
        

SSL Module

The ssl module is essential for creating secure connections in network applications. It provides tools to wrap sockets with SSL/TLS support, ensuring that data transmitted over the network is encrypted and secure.

Classes and Functions

• Creating a Secure Server

    import socket
    import ssl

    def secure_server():
        context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
        context.load_cert_chain(certfile='cert.pem', keyfile='key.pem')

        with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
            sock.bind(('localhost', 8443))
            sock.listen(5)
            with context.wrap_socket(sock, server_side=True) as ssock:
                conn, addr = ssock.accept()
                print(f'Connection from {addr}')
                data = conn.recv(1024)
                conn.sendall(b'HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nHello, World!')
                conn.close()
    
    secure_server()
        

• Creating a Secure Client

    import socket
    import ssl

    def secure_client():
        context = ssl.create_default_context()

        with socket.create_connection(('www.example.com', 443)) as sock:
            with context.wrap_socket(sock, server_hostname='www.example.com') as ssock:
                ssock.sendall(b'GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n')
                print(ssock.recv(4096).decode())
    
    secure_client()
        

• Secure File Transfer

    import socket
    import ssl

    def secure_file_transfer_client(file_path):
        context = ssl.create_default_context()

        with socket.create_connection(('localhost', 8443)) as sock:
            with context.wrap_socket(sock, server_hostname='localhost') as ssock:
                with open(file_path, 'rb') as f:
                    data = f.read()
                    ssock.sendall(data)

    def secure_file_transfer_server(save_path):
        context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
        context.load_cert_chain(certfile='cert.pem', keyfile='key.pem')

        with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
            sock.bind(('localhost', 8443))
            sock.listen(5)
            with context.wrap_socket(sock, server_side=True) as ssock:
                conn, addr = ssock.accept()
                print(f'Connection from {addr}')
                data = conn.recv(4096)
                with open(save_path, 'wb') as f:
                    f.write(data)
                conn.close()
        

Internet Related Services

Web Browser Module

In Python, webbrowser module is a convenient web browser controller. It provides a high-level interface that allows displaying Web-based documents to users.
webbrowser can also be used as a CLI tool. It accepts a URL as the argument with the following optional parameters: -n opens the URL in a new browser window, if possible, and -t opens the URL in a new browser tab.

    python -m webbrowser -t "https://www.google.com"
        

• The webbrowser module can be used to launch a browser in a platform-independent manner.

    import webbrowser
    webbrowser.open('http://www.python.org')
        

• Open the page in a new browser window.

    import webbrowser
    webbrowser.open_new('http://www.python.org')
        

• Open the page in a new browser tab.

    import webbrowser
    webbrowser.open_new_tab('http://www.python.org')
        

• To open a page in a specific browser, use the webbrowser.get() function to specify a particular browser.

    import webbrowser
    c = webbrowser.get('firefox')
    c.open('http://www.python.org')
    c.open_new_tab('http://docs.python.org')
        

18. File Handling

Python has several functions for creating, reading, updating, and deleting files.

File Handling

The key function for working with files in Python is the open() function. The open() function takes two parameters; filename, and mode.
There are four different methods (modes) for opening a file:

To open a file for reading it is enough to specify the name of the file:

    f = open("demofile.txt")
        

The code above is the same as:

    f = open("demofile.txt", "rt")
        

Note: Make sure the file exists, or else you will get an error.

Read Files

The open() function returns a file object, which has a read() method for reading the content of the file:

    f = open("demofile.txt", "r")
    print(f.read())
        

If the file is located in a different location, you will have to specify the file path, like this:

    f = open("D:\\myfiles\welcome.txt", "r")
    print(f.read())
        

By default the read() method returns the whole text, but you can also specify how many characters you want to return:

    f = open("demofile.txt", "r")
    print(f.read(5))
        

You can return one line by using the readline() method:

    f = open("demofile.txt", "r")
    print(f.readline())
        

By calling readline() two times, you can read the two first lines:

    f = open("demofile.txt", "r")
    print(f.readline())
    print(f.readline())
        

By looping through the lines of the file, you can read the whole file, line by line:

    f = open("demofile.txt", "r")
    for x in f:
        print(x)
        

It is a good practice to always close the file when you are done with it.

    f = open("demofile.txt", "r")
    print(f.readline())
    f.close()
        

Note: You should always close your files. In some cases, due to buffering, changes made to a file may not show until you close the file.

Write Files

To write to an existing file, you must add a parameter to the open() function:
• "a" - Append = will append to the end of the file.

    f = open("demofile2.txt", "a")
    f.write("Now the file has more content!")
    f.close()

    f = open("demofile2.txt", "r")
    print(f.read())
        

• "w" - Write = will overwrite any existing content.

    f = open("demofile3.txt", "w")
    f.write("Woops! I have deleted the content!")
    f.close()

    f = open("demofile2.txt", "r")
    print(f.read())
        

Note: the "w" method will overwrite the entire file.

To create a new file in Python, use the open() method, with one of the following parameters:
• "x" - Create = will create a file, returns an error if the file exists

    f = open("myfile.txt", "x")
        

Result: a new empty file is created!

• "a" - Append = will create a file if the specified file does not exists.

• "w" - Write = will create a file if the specified file does not exists.

    f = open("myfile.txt", "w")
        

Delete Files

To delete a file, you must import the OS module, and run its os.remove() function:

    import os
    os.remove("demofile.txt")
        

To avoid getting an error, you might want to check if the file exists before you try to delete it:

    import os

    if os.path.exists("demofile.txt"):
        os.remove("demofile.txt")
    else:
        print("The file does not exist")
        

To delete an entire folder, use the os.rmdir() method:

    import os

    os.rmdir("myfolder")
        

Note: You can only remove empty folders.

19. Python System Functions

20. Databases

SqLite

Introduction to SQLite in Python

Databases offer numerous functionalities by which one can manage large amounts of information easily over the web and high-volume data input and output over a typical file such as a text file. SQL is a query language and is very popular in databases.
Python has a library to access SQLite databases, called sqlite3, intended for working with this database which has been included with Python package since version 2.5. SQLite has the following features:

• Serverless
SQLite does not require a server to run. SQLite database is joined with the application that accesses the database. SQLite database read and write directly from the database files stored on disk and applications interact with that SQLite database.

• Self-Contained
SQLite is self-contained means it does not need any external dependencies like an operating system or external library. This feature of SQLite help especially in embedded devices like iPhones, Android phones, game consoles, handheld media players, etc.

• Zero-Configuration
SQLite is zero-configuration means no setup or administration needed. Because of the serverless architecture, you don’t need to “install” SQLite before using it. There is no server process that needs to be configured, started, and stopped.

• Transactional
SQLite is Transactional means they are atomic, consistent, isolated, and durable(ACID). All transactions in SQLite are fully ACID-compliant. In other words, all changes within a transaction take place completely or not at all even when an unexpected situation like application crash, power failure, or operating system crash occurs.

• Single-Database
SQLite is a single database that means it allows a single database connection to access multiple database files simultaneously. These features bring many nice features like joining tables in different databases or copying data between databases in a single command. SQLite also uses dynamic types for tables. It means you can store any value in any column, regardless of the data type.

Connecting to Database

Connecting to the SQLite Database can be established using the connect() method, passing the name of the database to be accessed as a parameter. If that database does not exist, then it’ll be created.

    sqliteConnection = sqlite3.connect('sql.db')
        

A cursor is created using the cursor() method on the connection instance, which will execute our SQL queries.

    cursor = sqliteConnection.cursor()
        

The SQL query to be executed can be written in form of a string, and then executed by calling the execute() method on the cursor object. Then, the result can be fetched from the server by using the fetchall() method.

    query = 'select sqlite_version();'
    cursor.execute(query)
    result = cursor.fetchall()
    print('SQLite Version is {}'.format(result))
    returns SQLite Version is [('3.45.1',)]
        

Let's now put it all together in a script to find the sqlite version:

    import sqlite3

    try:
        sqliteConnection = sqlite3.connect('sql.db')
        cursor = sqliteConnection.cursor()
        print('DB Init')

        query = 'select sqlite_version();'
        cursor.execute(query)
        result = cursor.fetchall()
        print('SQLite Version is {}'.format(result))

        cursor.close()

    except sqlite3.Error as error:
        print('Error occurred - ', error)

    finally:
        if sqliteConnection:
            sqliteConnection.close()
            print('SQLite Connection closed')

    returns DB Init
            SQLite Version is [('3.45.1',)]
            SQLite Connection closed
        

SQLite Datatypes and its Corresponding Python Types

A storage class can be called a collection of similar DataTypes. SQLite provides the following storage classes:

The SQLite DataTypes and their corresponding Python types are as follows

The type() function can be used in python to get the class of an argument. In the program below, the type() function is used to print the classes of every value we store in a database.

    import sqlite3

    cnt = sqlite3.connect('cfg.db')
    sql_table = ('''CREATE TABLE exam_hall( 
                    NAME TEXT, 
                    PIN INTEGER, 
                    OCCUPANCY REAL, 
                    LOGO BLOB);''')
    cnt.execute (sql_table)
    
    fileh = open('/content/JSBinCollaborativeJavaScriptDebugging6-300x160.png', 'rb') 
    img = fileh.read()
    
    sql = '''INSERT INTO exam_hall VALUES('centre-a',1125,98.6,?)''', (img,)
    sql2 = '''INSERT INTO exam_hall VALUES(NULL,1158,80.5,?)''', (img,)
    cnt.execute (sql, sql2)

    cursor = cnt.execute('''SELECT * FROM exam_hall;''')
    for i in cursor:
        print(str(i[0])+" "+str(i[1])+" "+str(i[2])+" "+str(len(i[3])))
        print(str(type(i[0]))+" "+str(type(i[1]))+" " + str(type(i[2]))+" "+str(type(i[3]))+"\n") 
    
    returns centre-a 1125 98.6 17030 
            class 'str' class 'int' class 'float' class 'bytes'
            
            None 1158 80.5 17030
            class 'NoneType' class 'int' class 'float' class 'bytes'
        

From the output of this program, the following observations can be made:
• ‘centre-a’ that was inserted as TEXT has been interpreted by python as str.
• 1125, 1158 that were inserted as INTEGER have been interpreted by python as int.
• 98.6, 80.5 that were inserted as REAL have been interpreted by python as float.
• NULL was interpreted by python as NoneType.
• The logo image which was inserted in binary format as BLOB has been interpreted by python as bytes.

Cursor Object

It is an object that is used to make the connection for executing SQL queries. It acts as middleware between SQLite database connection and SQL query. It is created after giving connection to SQLite database.

Syntax: cursor_object=connection_object.execute(“sql query”);

Python code to create a hotel_data database and insert records into the hotel table:

    import sqlite3

    connection = sqlite3.connect('hotel_data.db')
    sql_table = (''' CREATE TABLE hotel
                (FIND  INT PRIMARY KEY  NOT NULL,
                FNAME  TEXT  NOT NULL,
                COST   INT   NOT NULL,
                WEIGHT INT);
                ''')
    connection.execute(sql_table)

    sql = "INSERT INTO hotel (FIND, FNAME, COST, WEIGHT) VALUES (?, ?, ?, ?)"
    sql_data = [
    (1, 'cakes', 800, 10),
    (2, 'biscuits', 100, 20),
    (3, 'chocos', 1000, 30)
    ]
    connection.executemany(sql, sql_data)

    print("All data in food table\n")

    cursor = connection.execute("SELECT * from hotel")
    for row in cursor:
        print(row)

    returns All data in food table
            (1, 'cakes', 800, 10),
            (2, 'biscuits', 100, 20),
            (3, 'chocos', 1000, 30)
        

Create Table

In SQLite database we use the following syntax to create a table:

    CREATE TABLE database_name.table_name(

    column1 datatype PRIMARY KEY(one or more columns),

    column2 datatype,

    column3 datatype,

    …..

    columnN datatype

    );
        

Now let's create a table in the following example:

    import sqlite3

    connection_obj = sqlite3.connect('coding.db')
    cursor_obj = connection_obj.cursor()
    cursor_obj.execute("DROP TABLE IF EXISTS CODING")

    table = """ CREATE TABLE GEEK (
            Email VARCHAR(255) NOT NULL,
            First_Name CHAR(25) NOT NULL,
            Last_Name CHAR(25),
            Score INT
        ); """
 
    cursor_obj.execute(table)
    print("Table is Ready")

    connection_obj.close()

    returns "Table is Ready"
        

Insert Data

The SQL INSERT INTO statement of SQL is used to insert a new row in a table. There are two ways of using the INSERT INTO statement for inserting rows:
• Only values: The first method is to specify only the value of data to be inserted without the column names.

    INSERT INTO table_name VALUES (value1, value2, value3,…);
        

• Column names and values both: In the second method we will specify both the columns which we want to fill and their corresponding values.

    INSERT INTO table_name (column1, column2, column3,..) VALUES ( value1, value2, value3,..);
        

Let's put above into practice:

    import sqlite3

    conn = sqlite3.connect('coding2.db')
    cursor = conn.cursor()

    table ="""CREATE TABLE STUDENT(NAME VARCHAR(255), CLASS VARCHAR(255), SECTION VARCHAR(255));"""
    cursor.execute(table)

    sql = "INSERT INTO STUDENT VALUES (?, ?, ?)"
    sql_data = [
        ('Raju', '7th', 'A'),
        ('Shyam', '8th', 'B'),
        ('Baburao', '9th', 'C')
    ]
    connection.executemany(sql, sql_data)
    print("Data Inserted in the table: ")

    data=cursor.execute('''SELECT * FROM STUDENT''')
    for row in data:
        print(row)

    conn.commit()
    conn.close()

    returns "Data Inserted in the table: 
            ('Raju', '7th', 'A'),
            ('Shyam', '8th', 'B'),
            ('Baburao', '9th', 'C')"
        

We can also specify the columns for the values to be inserted:

    sql = "INSERT INTO STUDENT (NAME, CLASS, SECTION) VALUES (?, ?, ?)"
    sql_data = [
        ('Raju', '7th', 'A'),
        ('Shyam', '8th', 'B'),
        ('Baburao', '9th', 'C')
    ]
    connection.executemany(sql, sql_data)
        

Select Data from Table

The SELECT statement is used to retrieve data from an SQLite table and this returns the data contained in the table.
In SQLite the syntax of Select Statement is:

    SELECT * FROM table_name;
        

Note: * means all the column from the table. To select specific column replace * with the column name or column names.

Now we will use the Select statement in the Python program and see the results.
Creating the table:

    import sqlite3

    conn = sqlite3.connect('coding3.db')
    cursor = conn.cursor()

    table ="""CREATE TABLE CODING(Email varchar(255), Name varchar(50), Score int);"""
    cursor.execute(table)

    sql = "INSERT INTO CODING (Email,Name,Score) VALUES (?, ?, ?)"
    sql_data = [
        ("coding1@gmail.com","Coding1",25),
        ("coding2@gmail.com","Coding2",15),
        ("coding3@gmail.com","Coding3",36),
        ("coding4@gmail.com","Coding4",27),
        ("coding5@gmail.com","Coding5",40),
        ("coding6@gmail.com","Coding6",36),
        ("coding7@gmail.com","Coding7",27)
    ]
    connection.executemany(sql, sql_data)
    conn.commit()
    conn.close()
        

• Read All Rows:
Now we will use the Select statement to retrieve data from the table and fetch all records. To fetch all records we will use fetchall() method.

    Syntax: cursor.fetchall()
        

Example:

    import sqlite3
    
    conn = sqlite3.connect('coding3.db')
    cursor = conn.cursor()

    statement = '''SELECT * FROM CODING'''
    cursor.execute(statement)

    print("All the data")
    output = cursor.fetchall()
    for row in output:
        print(row)
    
    conn.commit()
    conn.close()

    returns All the data
            ("coding1@gmail.com","Coding1",25),
            ("coding2@gmail.com","Coding2",15),
            ("coding3@gmail.com","Coding3",36),
            ("coding4@gmail.com","Coding4",27),
            ("coding5@gmail.com","Coding5",40),
            ("coding6@gmail.com","Coding6",36),
            ("coding7@gmail.com","Coding7",27)
        

• Read Some Rows:
Now we will use the Select statement to retrieve data from the table and fetch many records not all. To fetch many records we will use fetchmany() method.

    Syntax: cursor.fetchmany(size)

    Parameters: size – a limit to fetch records
        

Example:

    import sqlite3
    
    conn = sqlite3.connect('coding3.db')
    cursor = conn.cursor()

    statement = '''SELECT * FROM CODING'''
    cursor.execute(statement)

    print("Limited data")
    output = cursor.fetchmany(5)
    for row in output:
        print(row)
    
    conn.commit()
    conn.close()

    returns Limited data
            ("coding1@gmail.com","Coding1",25),
            ("coding2@gmail.com","Coding2",15),
            ("coding3@gmail.com","Coding3",36),
            ("coding4@gmail.com","Coding4",27),
            ("coding5@gmail.com","Coding5",40),
        

• Read Only one Row:
Now we will use the Select statement to retrieve data from the table and fetch only one record. To fetch only one record, we will use fetchone() method.

    Syntax: cursor.fetchone()
        

Example:

    import sqlite3
    
    conn = sqlite3.connect('coding3.db')
    cursor = conn.cursor()

    statement = '''SELECT * FROM CODING'''
    cursor.execute(statement)

    print("Only one data")
    output = cursor.fetchone()
    print(output)
    
    conn.commit()
    conn.close()

    returns All the data
            ("coding1@gmail.com","Coding1",25)
        

WHERE Clause

The WHERE clause is used in order to make our search results more specific, using the where clause in SQL/SQLite we can go ahead and specify specific conditions that have to be met when retrieving data from the database.

    Syntax:  
    SELECT column_1, column_2,…,column_N FROM table_name WHERE [search_condition]

    Here, in this [search_condition] you can use comparison or logical operators to specify conditions.
    For example:  = , > , < , != , LIKE, NOT, etc. 
        

Let’s Create a Database (codingforgeeks_student.db) and a Table (STUDENT) and insert data into STUDENT table.

    import sqlite3
    
    conn = sqlite3.connect('codingforgeeks_student.db')
    cursor = conn.cursor()

    cursor.execute("DROP TABLE IF EXISTS STUDENT")
    createTable = '''CREATE TABLE STUDENT(
                    Student_ID int, First_Name VARCHAR(100),
                    Last_Name VARCHAR(100), Age int,
                    Department VARCHAR(100)
    )'''
    cursor.execute(createTable)

    if cursor:
        print("Database Created Successfully !")
    else:
        print("Database Creation Failed !")

    connection.commit()

    sql = "INSERT INTO STUDENT VALUES (?, ?, ?, ?, ?)"
    sql_data = [
        (1,'Rohit', 'Pathak', 21, 'IT'),
        (2,'Nitin', 'Biradar', 21, 'IT'),
        (3,'Virat', 'Kohli', 30, 'CIVIL'),
        (,'Rohit', 'Sharma', 32, 'COMP')
    ]
    connection.executemany(sql, sql_data)

    n class="python_highlight">if cursor:
        print("Data Inserted !")
    else:
        print("Data Insertion Failed !")

    connection.commit()
    connection.close()
        

Example 1: To retrieve the data of the students whose Department is IT

    import sqlite3
    
    conn = sqlite3.connect('codingforgeeks_student.db')
    cursor = conn.cursor()

    cursor.execute("SELECT * FROM STUDENT WHERE Department = 'IT'")
    print(cursor.fetchall())

    connection.commit()
    connection.close()

    returns (1, ‘Rohit’, ‘Pathak’, 21, ‘IT’), (2, ‘Nitin’, ‘Biradar’, 21, ‘IT’)]
        

Example 2: To retrieve the data of the students whose First Name starts with ‘R’. We can also use Wildcard characters with WHERE clause.

    import sqlite3
    
    conn = sqlite3.connect('codingforgeeks_student.db')
    cursor = conn.cursor()

    cursor.execute("SELECT * from STUDENT WHERE First_name Like'R%'")
    print(cursor.fetchall())

    connection.commit()
    connection.close()

    returns [(1, ‘Rohit’, ‘Pathak’, 21, ‘IT’), (4, ‘Rohit’, ‘Sharma’, 32, ‘COMP’)]
        

ORDER BY Clause

The ORDER BY statement is a SQL statement that is used to sort the data in either ascending or descending according to one or more columns. By default, ORDER BY sorts the data in ascending order.
• DESC is used to sort the data in descending order.
• ASC to sort in ascending order.

    Syntax: SELECT column1,column2,., column n  FROM table_name ORDER BY column_name ASC|DESC;
        

First, let’s create a database and Insert 5 records into the customer_address table.

    import sqlite3

    connection = sqlite3.connect('code_database.db')
    sql_table = CREATE TABLE customer_address 
         (ID INT PRIMARY KEY     NOT NULL, 
         NAME           TEXT    NOT NULL, 
         AGE            INT     NOT NULL, 
         ADDRESS        CHAR(50)); '''

    connection.execute(sql_table)

    sql = "INSERT INTO customer_address VALUES (?, ?, ?, ?)"
    sql_data = [
        (1, 'nikhil teja', 22, 'hyderabad'),
        (2, 'karthik', 25, 'khammam'),
        (3, 'sravan', 22, 'ponnur'),
        (4, 'deepika', 25, 'chebrolu'),
        (5, 'jyothika', 22, 'noida')
    ]
    connection.executemany(sql, sql_data)
    conn.commit()
    conn.close()
        

Example 1: Display all details from the table in ascending order(default) based on address.

    import sqlite3

    connection = sqlite3.connect('code_database.db')
    cursor = connection.execute("SELECT ADDRESS,ID from customer_address ORDER BY address DESC")

    for i in cursor:
        print(i)
    conn.close()

    returns (4, 'deepika', 25, 'chebrolu')
            (1, 'nikhil teja', 22, 'hyderabad'),
            (2, 'karthik', 25, 'khammam')
            (5, 'jyothika', 22, 'noida')
            (3, 'sravan', 22, 'ponnur')
        

LIMIT Clause

If there are many tuples satisfying the query conditions, it might be resourceful to view only a handful of them at a time. LIMIT keyword is used to limit the data given by the SELECT statement.

        Syntax:
        SELECT column1, column2, column n FROM table_name LIMIT [no of rows];

        where no of rows is an integer value specified as the no of rows to get as output from table.
        

Using our code_database.db, we are going to display the top 4 data from the table.

    import sqlite3

    connection = sqlite3.connect('code_database.db')
    cursor = connection.execute("SELECT * FROM customer_address LIMIT 4")

    for i in cursor:
        print(i)
    conn.close()

    returns (1, 'nikhil teja', 22, 'hyderabad'),
            (2, 'karthik', 25, 'khammam')
            (3, 'sravan', 22, 'ponnur')
            (4, 'deepika', 25, 'chebrolu')
        

JOIN Clause

A JOIN clause combines the records from two tables on the basis of common attributes. The different types of joins are as follows:
• INNER JOIN (OR JOIN) – Gives the records that have common attributes in both tables.
• LEFT JOIN – Gives all records from the left table and only the common records from the right table.
• RIGHT JOIN – Gives all records from the right table and only the common records from the left table.
• FULL OUTER JOIN – Gives all records when there is a common attribute in either the left or the right table.
• CROSS JOIN – Gives records of one table with all other records of another table.

Note: SQLite does not directly support the RIGHT JOIN and FULL OUTER JOIN.

Here, we will create a simple database having two tables Advisor(AdvisorID, AdvisorName) and Student(StudentID, StudentName, AdvisorID) where AdvisorID of the Student table is the foreign key referencing AdvisorID of the Advisor table.

    import sqlite3

    conn = sqlite3.connect(r'C:\Users\SQLite\Geeks.db')
    cursor = conn.cursor()

    cursor.executescript(''' 
    CREATE TABLE Advisor( 
        AdvisorID INTEGER NOT NULL, 
        AdvisorName TEXT NOT NULL, 
        PRIMARY KEY(AdvisorID) 
    ); 
    
    CREATE TABLE Student( 
        StudentID NUMERIC NOT NULL, 
        StudentName NUMERIC NOT NULL, 
        AdvisorID INTEGER, 
        FOREIGN KEY(AdvisorID) REFERENCES Advisor(AdvisorID), 
        PRIMARY KEY(StudentID) 
    ); 
  
    INSERT INTO Advisor(AdvisorID, AdvisorName) VALUES 
        (1,"John Paul"),  
        (2,"Anthony Roy"),  
        (3,"Raj Shetty"), 
        (4,"Sam Reeds"), 
        (5,"Arthur Clintwood"); 
    
    INSERT INTO Student(StudentID, StudentName, AdvisorID) VALUES 
        (501,"Geek1",1), 
        (502,"Geek2",1), 
        (503,"Geek3",3), 
        (504,"Geek4",2), 
        (505,"Geek5",4), 
        (506,"Geek6",2), 
        (507,"Geek7",2), 
        (508,"Geek8",3), 
        (509,"Geek9",NULL), 
        (510,"Geek10",1); 
    ''') 
    conn.commit()
    conn.close()
        

• INNER JOIN:
Inner join also represented as join which gives the records that have common attributes in both tables.

    Syntax:
    SELECT columns FROM table1 [INNER] JOIN table2 ON table1.column = table2.column;

    ** INNER keyword is optional **
        

Example:

    import sqlite3

    conn = sqlite3.connect(r'C:\Users\SQLite\Geeks.db')
    cursor = conn.cursor()

    sql = '''SELECT StudentID, StudentName, AdvisorName FROM Student INNER JOIN Advisor ON Student.AdvisorID = Advisor.AdvisorID;'''
    cursor.execute(sql)

    result = cursor.fetchall()
    for row in result:
        print(row)
    conn.close() 

    returns (501,"Geek1","John Paul"), 
        (502,"Geek2","John Paul"), 
        (503,"Geek3","Raj Shetty"), 
        (504,"Geek4","Anthony Roy"), 
        (505,"Geek5","Sam Reeds"), 
        (506,"Geek6","Anthony Roy"), 
        (507,"Geek7","Anthony Roy"), 
        (508,"Geek8","Raj Shetty"), 
        (510,"Geek10","John Paul")
        

• LEFT JOIN:
Gives all records from the left table, and only the common records from the right table.

    Syntax:
    SELECT columns FROM table1 LEFT [OUTER] JOIN table2 ON table1.column = table2.column;

    ** OUTER keyword is optional **
        

Example:

    import sqlite3

    conn = sqlite3.connect(r'C:\Users\SQLite\Geeks.db')
    cursor = conn.cursor()

    sql = '''SELECT StudentID, StudentName, AdvisorName FROM Student LEFT JOIN Advisor USING(AdvisorID);'''
    cursor.execute(sql)

    result = cursor.fetchall()
    for row in result:
        print(row)
    conn.close() 

    returns (501,"Geek1","John Paul"), 
        (502,"Geek2","John Paul"), 
        (503,"Geek3","Raj Shetty"), 
        (504,"Geek4","Anthony Roy"), 
        (505,"Geek5","Sam Reeds"), 
        (506,"Geek6","Anthony Roy"), 
        (507,"Geek7","Anthony Roy"), 
        (508,"Geek8","Raj Shetty"), 
        (509,"Geek9","None"),
        (510,"Geek10","John Paul")
        

• RIGHT JOIN:
Gives all records from the right table, and only the common records from the left table. As mentioned before, SQLite does not directly support RIGHT JOIN. However, it can be emulated using LEFT JOIN by switching the positions of the student and advisor table.

    Syntax:
    SELECT columns FROM table1 RIGHT [OUTER] JOIN table2 ON table1.column = table2.column;

    ** OUTER keyword is optional **
        

Example:

    import sqlite3

    conn = sqlite3.connect(r'C:\Users\SQLite\Geeks.db')
    cursor = conn.cursor()

    sql = '''SELECT StudentID, StudentName, AdvisorName FROM Advisor LEFT JOIN Student USING(AdvisorID);'''
    cursor.execute(sql)

    result = cursor.fetchall()
    for row in result:
        print(row)
    conn.close()
    
    returns (501,"Geek1","John Paul"), 
        (502,"Geek2","John Paul"),
        (510,"Geek10","John Paul"),
        (504,"Geek4","Anthony Roy"), 
        (506,"Geek6","Anthony Roy"), 
        (507,"Geek7","Anthony Roy"), 
        (503,"Geek3","Raj Shetty"), 
        (508,"Geek8","Raj Shetty"), 
        (505,"Geek5","Sam Reeds"),
        (None,"None","Arthur Clintwood")
        

• FULL OUTER JOIN:
Gives all records when there is a common attribute in either left or the right table. As mentioned before, SQLite does not directly support FULL OUTER JOIN. However, it can be emulated using LEFT JOIN. In this query, the second SELECT statement has the positions of the student and advisor table switched. The UNION ALL clause retains the duplicate rows from the result of both SELECT queries. And the WHERE clause in the second SELECT statement removes rows that already included in the result set of the first SELECT statement.

    Syntax:
    SELECT columns FROM table1 FULL [OUTER] JOIN table2 ON table1.column = table2.column;

    ** OUTER keyword is optional **
        

Example:

    import sqlite3

    conn = sqlite3.connect(r'C:\Users\SQLite\Geeks.db')
    cursor = conn.cursor()

    sql = '''SELECT StudentID, StudentName, AdvisorName FROM Student LEFT JOIN Advisor USING(AdvisorID) UNION ALL 
             SELECT StudentID, StudentName, AdvisorName FROM Advisor LEFT JOIN Student USING(AdvisorID) WHERE Student.AdvisorID IS NULL;'''
    cursor.execute(sql)

    result = cursor.fetchall()
    for row in result:
        print(row)
    conn.close()
    
    returns (501,"Geek1","John Paul"), 
        (502,"Geek2","John Paul"), 
        (503,"Geek3","Raj Shetty"), 
        (504,"Geek4","Anthony Roy"), 
        (505,"Geek5","Sam Reeds"), 
        (506,"Geek6","Anthony Roy"), 
        (507,"Geek7","Anthony Roy"), 
        (508,"Geek8","Raj Shetty"), 
        (509,"Geek9","None"),
        (510,"Geek10","John Paul")
        (None,"None","Arthur Clintwood")
        

• CROSS JOIN:
It combines all records of one table with all other records of another table, that is, it creates a Cartesian product of records from the join tables.

    Syntax:
    SELECT columns FROM table1 CROSS JOIN table2;
        

Example:

    import sqlite3

    conn = sqlite3.connect(r'C:\Users\SQLite\Geeks.db')
    cursor = conn.cursor()

    sql = '''SELECT StudentID, StudentName, AdvisorName FROM Student CROSS JOIN Advisor;'''
    cursor.execute(sql)

    result = cursor.fetchall()
    for row in result:
        print(row)
    conn.close()
    
    returns (501, 'Geek1', 'John Paul')
            (501, 'Geek1', 'Anthony Roy')
            (501, 'Geek1', 'Raj Shetty')
            (501, 'Geek1', 'Sam Reeds')
            (501, 'Geek1', 'Arthur Clintwood')
            (502, 'Geek2', 'John Paul')
            (502, 'Geek2', 'Anthony Roy')
            (502, 'Geek2', 'Raj Shetty')
            (502, 'Geek2', 'Sam Reeds')
            (502, 'Geek2', 'Arthur Clintwood')
            (503, 'Geek3', 'John Paul')
            (503, 'Geek3', 'Anthony Roy')
            (503, 'Geek3', 'Raj Shetty')
            (503, 'Geek3', 'Sam Reeds')
            (503, 'Geek3', 'Arthur Clintwood')
            (504, 'Geek4', 'John Paul')
            (504, 'Geek4', 'Anthony Roy')
            (504, 'Geek4', 'Raj Shetty')
            (504, 'Geek4', 'Sam Reeds')
            (504, 'Geek4', 'Arthur Clintwood')
            (505, 'Geek5', 'John Paul')
            (505, 'Geek5', 'Anthony Roy')
            (505, 'Geek5', 'Raj Shetty')
            (505, 'Geek5', 'Sam Reeds')
            (505, 'Geek5', 'Arthur Clintwood')
            (506, 'Geek6', 'John Paul')
            (506, 'Geek6', 'Anthony Roy')
            (506, 'Geek6', 'Raj Shetty')
            (506, 'Geek6', 'Sam Reeds')
            (506, 'Geek6', 'Arthur Clintwood')
            (507, 'Geek7', 'John Paul')
            (507, 'Geek7', 'Anthony Roy')
            (507, 'Geek7', 'Raj Shetty')
            (507, 'Geek7', 'Sam Reeds')
            (507, 'Geek7', 'Arthur Clintwood')
            (508, 'Geek8', 'John Paul')
            (508, 'Geek8', 'Anthony Roy')
            (508, 'Geek8', 'Raj Shetty')
            (508, 'Geek8', 'Sam Reeds')
            (508, 'Geek8', 'Arthur Clintwood')
            (509, 'Geek9', 'John Paul')
            (509, 'Geek9', 'Anthony Roy')
            (509, 'Geek9', 'Raj Shetty')
            (509, 'Geek9', 'Sam Reeds')
            (509, 'Geek9', 'Arthur Clintwood')
            (510, 'Geek10', 'John Paul')
            (510, 'Geek10', 'Anthony Roy')
            (510, 'Geek10', 'Raj Shetty')
            (510, 'Geek10', 'Sam Reeds')
            (510, 'Geek10', 'Arthur Clintwood')
        

Deleting Data in Table

n SQLite database we use the following syntax to delete data from a table:

    DELETE FROM table_name [WHERE Clause]
        

Example: