Python for loop

• Python frequently uses the Loop to iterate

over iterable objects like lists, tuples, and
strings.
• Crossing is the most common way of
emphasizing across a series, for loops are
used when a section of code needs to be
repeated a certain number of times.
Python for loop
• Syntax of for Loop
• for value in sequence:
• {loop body}
• The value is the parameter that determines the element's value
within the iterable sequence on each iteration.
• When a sequence contains expression statements, they are
processed first.
• The first element in the sequence is then assigned to the iterating
variable iterating_variable.
• From that point onward, the planned block is run. Each element
in the sequence is assigned to iterating_variable during the
statement block until the sequence as a whole is completed.
• Using indentation, the contents of the Loop are distinguished
from the remainder of the program.
Example of Python for Loop
• numbers = [3, 5, 23, 6, 5, 1, 2, 9, 8]
• sum_ = 0
• for num in numbers:
• sum_ = sum_ + num ** 2
• print("The sum of squares is: ", sum_)

Output:
• The sum of squares is: 774
The range() Function
• The range() function returns a sequence of numbers, starting
from 0 by default, and increments by 1 (by default), and stops
before a specified number.

Syntax
• range(start, stop, step)

Parameter Values
• start Optional. An integer number specifying at which
position to start. Default is 0
• stop Required. An integer number specifying at which
position to stop (not included).
• step Optional. An integer number specifying the
incrementation. Default is 1
List
• Lists are used to store multiple items in a single
variable.
• Lists are one of 4 built-in data types in Python
used to store collections of data, the other 3
are Tuple, Set, and Dictionary, all with different
qualities and usage.
• Lists are created using square brackets:

Example
• thislist = ["apple", "banana", "cherry"]
print(thislist)
List Items

• List items are ordered, changeable, and allow duplicate values.

• 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:
• thislist = ["apple", "banana", "cherry", "apple", "cherry"]
print(thislist)
List Length

• To determine how many items a list has, use the len() function:
• Example
• thislist = ["apple", "banana", "cherry"]
print(len(thislist))

List Items - Data Types

• List items can be of any data type:

• Example
• list1 = ["apple", "banana", "cherry"]
list2 = [1, 5, 7, 9, 3]
list3 = [True, False, False]
• A list can contain different data types:
• Example
• A list with strings, integers and boolean values:
• list1 = ["abc", 34, True, 40, "male"]
type()

• From Python's perspective, lists are defined as objects with the data type 'list':
• <class 'list'>
• Example
• What is the data type of a list?
• mylist = ["apple", "banana", "cherry"]
print(type(mylist))
The list() Constructor

• It is also possible to use the list() constructor when creating a new list.
• Example
• Using the list() constructor to make a List:
• thislist = list(("apple", "banana", "cherry")) # note the double round-brackets
print(thislist)
Python Collections (Arrays)

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

• List items are indexed and you can access them by referring to the index number:
• Example
• Print the second item of the list:
• thislist = ["apple", "banana", "cherry"]
print(thislist[1])
Negative Indexing

• Negative indexing means start from the end

• -1 refers to the last item, -2 refers to the second last item etc.
• Example
• Print the last item of the list:
• thislist = ["apple", "banana", "cherry"]
print(thislist[-1])
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.
• Example
• Return the third, fourth, and fifth item:
• thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:5])
Range of Negative Indexes

• Specify negative indexes if you want to start the search from the end of the list:
• Example
• This example returns the items from "orange" (-4) to, but NOT including "mango" (-
1):
• thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[-4:-1])
Check if Item Exists

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

• Example
• Check if "apple" is present in the list:
• thislist = ["apple", "banana", "cherry"]
if "apple" in thislist:
print("Yes, 'apple' is in the fruits list")
Change Item Value

• To change the value of a specific item, refer to the index number:

• Example
• Change the second item:
• thislist = ["apple", "banana", "cherry"]
thislist[1] = "blackcurrant"
print(thislist)
Change a Range of Item Values

• To change the value of items within a specific range, define a list with the new values, and
refer to the range of index numbers where you want to insert the new values:
• Example
• Change the values "banana" and "cherry" with the values "blackcurrant" and "watermelon":
• thislist = ["apple", "banana", "cherry", "orange", "kiwi", "mango"]
thislist[1:3] = ["blackcurrant", "watermelon"]
print(thislist)
Insert Items

• To insert a new list item, without replacing any of the existing values, we can use
the insert() method.
• The insert() method inserts an item at the specified index:
• Example
• Insert "watermelon" as the third item:
• thislist = ["apple", "banana", "cherry"]
thislist.insert(2, "watermelon")
print(thislist)
Append Items

• To add an item to the end of the list, use the append() method:
• Example
• Using the append() method to append an item:
• thislist = ["apple", "banana", "cherry"]
thislist.append("orange")
print(thislist)
Insert Items

• To insert a list item at a specified index, use the insert() method.

• The insert() method inserts an item at the specified index:
• Example
• Insert an item as the second position:
• thislist = ["apple", "banana", "cherry"]
thislist.insert(1, "orange")
print(thislist)
Extend List

• To append elements from another list to the current list, use the extend() method.
• Example
• Add the elements of tropical to thislist:
• thislist = ["apple", "banana", "cherry"]
tropical = ["mango", "pineapple", "papaya"]
thislist.extend(tropical)
print(thislist)
Remove Specified Item

• The remove() method removes the specified item.

• Example
• Remove "banana":
• thislist = ["apple", "banana", "cherry"]
thislist.remove("banana")
print(thislist)
Clear the List

• The clear() method empties the list.

• The list still remains, but it has no content.
• Example
• Clear the list content:
• thislist = ["apple", "banana", "cherry"]
thislist.clear()
print(thislist)
Loop Through a List

• You can loop through the list items by using a for loop:
• Example
• Print all items in the list, one by one:
• thislist = ["apple", "banana", "cherry"]
for x in thislist:
print(x)
Sort List Alphanumerically

• List objects have a sort() method that will sort the list alphanumerically, ascending, by default:
• Example
• Sort the list alphabetically:
• thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]
thislist.sort()
print(thislist)

Sort Descending

• To sort descending, use the keyword argument reverse = True:

• Example
• Sort the list descending:
• thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]
thislist.sort(reverse = True)
print(thislist)
Copy a List

• You cannot copy a list simply by typing list2 = list1, because: list2 will only be
a reference to list1, and changes made in list1 will automatically also be made in list2.
• There are ways to make a copy, one way is to use the built-in List method copy().
• Example
• Make a copy of a list with the copy() method:
• thislist = ["apple", "banana", "cherry"]
mylist = thislist.copy()
print(mylist)
Join Two Lists

• There are several ways to join, or concatenate, two or more lists in Python.
• One of the easiest ways are by using the + operator.
• Example
• Join two list:
• list1 = ["a", "b", "c"]
list2 = [1, 2, 3]

list3 = list1 + list2

print(list3)
List Methods

• append() Adds an element at the end of the list

• clear() Removes all the elements from the list
• copy() Returns a copy of the list
• count() Returns the number of elements with the specified value
• extend() Add the elements of a list (or any iterable), to the end of the current list
• index() Returns the index of the first element with the specified value
• insert() Adds an element at the specified position
• pop() Removes the element at the specified position
• remove() Removes the item with the specified value
• reverse() Reverses the order of the list
• sort() Sorts the list
Tuple

• Tuples are used to store multiple items in a single variable.

• Tuple is one of 4 built-in data types in Python used to store collections of data, the other 3 are List, Set,
and Dictionary, all with different qualities and usage.
• A tuple is a collection which is ordered and unchangeable.
• Tuples are written with round brackets.
• Example
• Create a Tuple:
• thistuple = ("apple", "banana", "cherry")
print(thistuple)
Tuple Items

• Tuple items are ordered, unchangeable, and allow duplicate values.

• 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:
• Example
• Tuples allow duplicate values:
• thistuple = ("apple", "banana", "cherry", "apple", "cherry")
print(thistuple)
Tuple Length

• To determine how many items a tuple has, use the len() function:
• Example
• Print the number of items in the tuple:
• thistuple = ("apple", "banana", "cherry")
print(len(thistuple))
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.
• Example
• One item tuple, remember the comma:
• thistuple = ("apple",)
print(type(thistuple))

#NOT a tuple
thistuple = ("apple")
print(type(thistuple))
Tuple Items - Data Types

• Tuple items can be of any data type:

• Example
• String, int and boolean data types:
• tuple1 = ("apple", "banana", "cherry")
tuple2 = (1, 5, 7, 9, 3)
tuple3 = (True, False, False)
type()

• From Python's perspective, tuples are defined as objects with the data type 'tuple':
• <class 'tuple'>
• Example
• What is the data type of a tuple?
• mytuple = ("apple", "banana", "cherry")
print(type(mytuple))
The tuple() Constructor

• It is also possible to use the tuple() constructor to make a tuple.

• Example
• Using the tuple() method to make a tuple:
• thistuple = tuple(("apple", "banana", "cherry")) # note the double round-brackets
print(thistuple)
Access Tuple Items

• You can access tuple items by referring to the index number, inside square
brackets:
• Example
• Print the second item in the tuple:
• thistuple = ("apple", "banana", "cherry")
print(thistuple[1])
Negative Indexing

• Negative indexing means start from the end.

• -1 refers to the last item, -2 refers to the second last item etc.
• Example
• Print the last item of the tuple:
• thistuple = ("apple", "banana", "cherry")
print(thistuple[-1])
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.
• Example
• Return the third, fourth, and fifth item:
• thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[2:5])
Range of Negative Indexes

• Specify negative indexes if you want to start the search from the end of the tuple:
• Example
• This example returns the items from index -4 (included) to index -1 (excluded)
• thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[-4:-1])
Check if Item Exists

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

• Example
• Check if "apple" is present in the tuple:
• thistuple = ("apple", "banana", "cherry")
if "apple" in thistuple:
print("Yes, 'apple' is in the fruits tuple")
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.
• Example
• Convert the tuple into a list to be able to change it:
• x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)

print(x)
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.
• 1. 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.
• Example
• Convert the tuple into a list, add "orange", and convert it back into a tuple:
• thistuple = ("apple", "banana", "cherry")
y = list(thistuple)
y.append("orange")
thistuple = tuple(y)
Add Items

• 2. Add tuple to a tuple. You 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:
• Example
• Create a new tuple with the value "orange", and add that tuple:
• thistuple = ("apple", "banana", "cherry")
y = ("orange",)
thistuple += y

print(thistuple)
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:
• Example
• Convert the tuple into a list, remove "apple", and convert it back into a tuple:
• thistuple = ("apple", "banana", "cherry")
y = list(thistuple)
y.remove("apple")
thistuple = tuple(y)
Unpacking a Tuple

• When we create a tuple, we normally assign values to it. This is called "packing" a
tuple:
• Example
• Packing a tuple:
• fruits = ("apple", "banana", "cherry")
Unpacking a Tuple

• 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:
• Example
• Assign the rest of the values as a list called "red":
• fruits = ("apple", "banana", "cherry", "strawberry", "raspberry")

(green, yellow, *red) = fruits

print(green)
print(yellow)
print(red)
Loop Through a Tuple

• You can loop through the tuple items by using a for loop.
• Example
• Iterate through the items and print the values:
• thistuple = ("apple", "banana", "cherry")
for x in thistuple:
print(x)
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.
• Example
• Print all items by referring to their index number:
• thistuple = ("apple", "banana", "cherry")
for i in range(len(thistuple)):
print(thistuple[i])
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.
• Example
• Print all items, using a while loop to go through all the index numbers:
• thistuple = ("apple", "banana", "cherry")
i=0
while i < len(thistuple):
print(thistuple[i])
i=i+1
Join Two Tuples

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

• Example
• Join two tuples:
• tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2

print(tuple3)
Tuple Methods

• Python has two built-in methods that you can use on tuples.
• count() Returns the number of times a specified value occurs in a tuple
• index() Searches the tuple for a specified value and returns the position of where
it was found
Set
 Dictionary

• Dictionaries are used to store data values in key:value pairs.

• A dictionary is a collection which is ordered*, changeable and do not allow duplicates.
• As of Python version 3.7, dictionaries are ordered.
• In Python 3.6 and earlier, dictionaries are unordered.
• Dictionaries are written with curly brackets, and have keys and values:
• Example
• Create and print a dictionary:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict)
Dictionary Items

• Dictionary items are ordered, changeable, and does not allow duplicates.
• Dictionary items are presented in key:value pairs, and can be referred to by using the key name.
• Example
• Print the "brand" value of the dictionary:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict["brand"])
Ordered or Unordered?

• As of Python version 3.7, dictionaries are ordered.

• In Python 3.6 and earlier, dictionaries are unordered.
• When we say that dictionaries are ordered, it means that the items have a defined
order, and that order will not change.
• Unordered means that the items does not have a defined order, you cannot refer
to an item by using an index.
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:

• Example
• Duplicate values will overwrite existing values:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964,
"year": 2020
}
print(thisdict)
Dictionary Length

• To determine how many items a dictionary has, use the len() function:
• Example
• Print the number of items in the dictionary:
• print(len(thisdict))

Dictionary Items - Data Types

• The values in dictionary items can be of any data type:

• Example
• String, int, boolean, and list data types:
• 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':
• <class 'dict'>
• Example
• Print the data type of a dictionary:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(type(thisdict))
The dict() Constructor

• It is also possible to use the dict() constructor to make a dictionary.

• Example
• Using the dict() method to make a dictionary:
• thisdict = dict(name = "John", age = 36, country = "Norway")
print(thisdict)
Accessing Items

• You can access the items of a dictionary by referring to its key name, inside square brackets:
• Example
• Get the value of the "model" key:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = thisdict["model"]

There is also a method called get() that will give you the same result:

• Example
• Get the value of the "model" key:
• x = thisdict.get("model")
Get Keys

• The keys() method will return a list of all the keys in the dictionary.
• Example
• Get a list of the keys:
• x = thisdict.keys()
• 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.

Example

• Add a new item to the original dictionary, and see that the keys list gets updated as well:
• car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = car.keys()
print(x) #before the change
car["color"] = "white"
print(x) #after the change
Get Values

• The values() method will return a list of all the values in the dictionary.
• Example
• Get a list of the values:
• x = thisdict.values()
• 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.

Example

• Make a change in 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
car["year"] = 2020
print(x) #after the change
Get Items

• The items() method will return each item in a dictionary, as tuples in a list.
• Example
• Get a list of the key:value pairs
• x = thisdict.items()
• 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.

Example

• Make a change in the original dictionary, and see that the items list gets updated as well:
• car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = car.items()
print(x) #before the change
car["year"] = 2020
print(x) #after the change
Check if Key Exists

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

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

• You can change the value of a specific item by referring to its key name:
• Example
• Change the "year" to 2018:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict["year"] = 2018
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.
• Example
• Update the "year" of the car by using the update() method:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.update({"year": 2020})
Adding Items

• Adding an item to the dictionary is done by using a new index key and assigning a value to it:
• Example
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict["color"] = "red"
print(thisdict)
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.
• Example
• Add a color item to the dictionary by using the update() method:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.update({"color": "red"})
Removing Items

• There are several methods to remove items from a dictionary:

• Example
• The pop() method removes the item with the specified key name:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.pop("model")
print(thisdict)
Removing Items

• The popitem() method removes the last inserted item (in versions before 3.7, a random item is removed
instead):
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.popitem()
print(thisdict)
Removing Items

• The del keyword removes the item with the specified key name:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
del thisdict["model"]
print(thisdict)
Removing Items

• The clear() method empties the dictionary:

• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.clear()
print(thisdict)
Loop Through a Dictionary

• You can loop through a dictionary by using a 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.

Example

• Print all key names in the dictionary, one by one:

• for x in thisdict:
print(x)

Example

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

• for x in thisdict:
print(thisdict[x])
Example

• You can also use the values() method to return values of a dictionary:
• for x in thisdict.values():
print(x)

Example

• You can use the keys() method to return the keys of a dictionary:
• for x in thisdict.keys():
print(x)

Example

• Loop through both keys and values, by using the items() method:
• for x, y in thisdict.items():
print(x, y)
Copy a Dictionary

• 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.
• There are ways to make a copy, one way is to use the built-in Dictionary method copy().
• Example
• Make a copy of a dictionary with the copy() method:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
mydict = thisdict.copy()
print(mydict)
Copy a Dictionary

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

• Example
• Make a copy of a dictionary with the dict() function:
• thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
mydict = dict(thisdict)
print(mydict)
 Nested Dictionaries

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

• Example
• Create a dictionary that contain three dictionaries:
• myfamily = {
"child1" : {
"name" : "Emil",
"year" : 2004
},
"child2" : {
"name" : "Tobias",
"year" : 2007
},
"child3" : {
"name" : "Linus",
"year" : 2011
}
}
Dictionary Methods

• clear() Removes all the elements from the dictionary

• copy() Returns a copy of the dictionary
• fromkeys() Returns a dictionary with the specified keys and value
• get() Returns the value of the specified key
• items() Returns a list containing a tuple for each key value pair
• keys() Returns a list containing the dictionary's keys
• pop() Removes the element with the specified key
• popitem() Removes the last inserted key-value pair
• update() Updates the dictionary with the specified key- value pairs
• values() Returns a list of all the values in the dictionary
If While For
Python Functions

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

• Example
• def my_function():
print("Hello from a function")
Python Functions

• Calling a Function
• To call a function, use the function name followed by parenthesis:
• Example
• def my_function():
print("Hello from a function")

my_function()
Arguments

• Information can be passed into functions as arguments.

• Arguments are often shortened to args in Python documentations.
• 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:
• Example
• def my_function(fname):
print(fname + " Refsnes")
my_function("Emil")
my_function("Tobias")
my_function("Linus")
Parameters or Arguments?

• The terms parameter and argument can be used for the same thing: information
that are passed into a function.
• From a function's perspective:
• A parameter is the variable listed inside the parentheses in the function definition.
• 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.
• Example
• This function expects 2 arguments, and gets 2 arguments:
• def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil", "Refsnes")
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:
• Example
• If the number of arguments is unknown, add a * before the parameter name:
• def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Emil", "Tobias", "Linus")
Keyword Arguments

• You can also send arguments with the key = value syntax.
• This way the order of the arguments does not matter.
• Example
• def my_function(child3, child2, child1):
print("The youngest child is " + child3)
my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")
Arbitrary Keyword Arguments, **kwargs

• If you do not know how many keyword arguments that will be passed into your function, add two
asterisk: ** before the parameter name in the function definition.
• This way the function will receive a dictionary of arguments, and can access the items accordingly:
• Example
• If the number of keyword arguments is unknown, add a double ** before the parameter name:
• def my_function(**kid):
print("His last name is " + kid["lname"])
my_function(fname = "Tobias", lname = "Refsnes")
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:
• Example
• def my_function(country = "Norway"):
print("I am from " + country)
my_function("Sweden")
my_function("India")
my_function()
my_function("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:
• Example
• def my_function(food):
for x in food:
print(x)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)
Return Values

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

• Example
• def my_function(x):
return 5 * x
print(my_function(3))
print(my_function(5))
print(my_function(9))
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.
• Example
• def myfunction():
pass
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.
• 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.
Recursion

• 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).
• To a new developer it can take some time to work out how exactly this works, best way to find out is by testing and modifying it.
• Example
• Recursion Example
• def tri_recursion(k):
if(k > 0):
result = k + tri_recursion(k - 1)
print(result)
else:
result = 0
return result
print("\n\nRecursion Example Results")
tri_recursion(6)