A function is a block of organized code that performs a single task and only runs when called.
You can pass data, known as parameters, into a function. A function can return data as a
result. (They provide reusability of code)
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:
my_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:
Arguments are often shortened to args in Python documentations.
Example
def say _hello(fname):
print(“hello ", fname)
say _hello ("Emil")
say _hello("Tobias")
say _hello ("Linus")
LAMBDA
In Python, a lambda function is a single-line, anonymous function, that can have any number
of arguments, but it can only have one expression.
A lambda function is a small anonymous function.
A lambda function can take any number of arguments but only have one expression.
Syntax
lambda arguments: expression
The expression is executed and the result is returned:
Example
This function:
>>> def add(x, y):
... return x + y
...
>>> add(5, 3)
#8
Is equivalent to the lambda function:
>>> add = lambda x, y: x + y
>>> add(5, 3) # 8
Add 10 to argument a, and return the result:
x = lambda a : a + 10
print(x(5))
Lambda functions can take any number of arguments:
Return Values
When creating a function using the def statement, you can specify what the return value
should be with a return statement. A return statement consists of the following:
The return keyword.
The value or expression that the function should return.
def sum_two_numbers(number_1, number_2):
return number_1 + number_2
result = sum_two_numbers(7, 8)
print(result)
# 15
Local and Global Scope
Code in the global scope cannot use any local variables.
However, a local scope can access global variables.
Code in a function’s local scope cannot use variables in any other local scope.
You can use the same name for different variables if they are in different scopes. That
is, there can be a local variable named spam and a global variable also named spam.
global_variable = 'I am available everywhere'
>>> def some_function():
... print(global_variable) # because is global
... local_variable = "only available within this function"
... print(local_variable)
...
>>> # The following code will throw error because
>>> # 'local_variable' only exists inside 'some_function'
>>> print(local_variable)
Traceback (most recent call last):
File "<stdin>", line 10, in <module>
NameError: name 'local_variable' is not defined
The Tuple data type
Tuples vs Lists
The key difference between tuples and lists is that,
while tuples are immutable objects, lists are mutable. This means that
tuples cannot be changed while the lists can be modified. Tuples are
more memory efficient than the lists.
>>> furniture = ('table', 'chair', 'rack', 'shelf')
>>> furniture[0]
# 'table'
>>> furniture[1:3]
# ('chair', 'rack')
>>> len(furniture)
#4
The main way that tuples are different from lists is that tuples, like
strings, are immutable.
Converting between list() and tuple()
>>> tuple(['cat', 'dog', 5])
# ('cat', 'dog', 5)
>>> list(('cat', 'dog', 5))
# ['cat', 'dog', 5]
>>> list('hello')
# ['h', 'e', 'l', 'l', 'o']
Python Dictionaries
In Python, a dictionary is an ordered collection of key: value pairs.
From the Python 3 documentation
The main operations on a dictionary are storing a value with some key and extracting the
value given the key. It is also possible to delete a key:value pair with del.
Example Dictionary:
my_cat = {
'size': 'fat',
'color': 'gray',
'disposition': 'loud'
Set key, value using subscript operator []
>>> my_cat = {
... 'size': 'fat',
... 'color': 'gray',
... 'disposition': 'loud',
... }
>>> my_cat['age_years'] = 2
>>> print(my_cat)
...
# {'size': 'fat', 'color': 'gray', 'disposition': 'loud', 'age_years': 2}
Get value using subscript operator []
In case the key is not present in dictionary KeyError is raised.
>>> my_cat = {
... 'size': 'fat',
... 'color': 'gray',
... 'disposition': 'loud',
... }
>>> print(my_cat['size'])
...
# fat
>>> print(my_cat['eye_color'])
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# KeyError: 'eye_color'
values()
The values() method gets the values of the dictionary:
>>> pet = {'color': 'red', 'age': 42}
>>> for value in pet.values():
... print(value)
...
# red
# 42
keys()
The keys() method gets the keys of the dictionary:
>>> pet = {'color': 'red', 'age': 42}
>>> for key in pet.keys():
... print(key)
...
# color
# age
There is no need to use .keys() since by default you will loop through keys:
>>> pet = {'color': 'red', 'age': 42}
>>> for key in pet:
... print(key)
...
# color
# age
items()
The items() method gets the items of a dictionary and returns them as a Tuple:
>>> pet = {'color': 'red', 'age': 42}
>>> for item in pet.items():
... print(item)
...
# ('color', 'red')
# ('age', 42)
Using the keys(), values(), and items() methods, a for loop can iterate over the keys, values,
or key-value pairs in a dictionary, respectively.
>>> pet = {'color': 'red', 'age': 42}
>>> for key, value in pet.items():
... print(f'Key: {key} Value: {value}')
...
# Key: color Value: red
# Key: age Value: 42
get()
The get() method returns the value of an item with the given key. If the key doesn’t exist, it
returns None:
>>> wife = {'name': 'Rose', 'age': 33}
>>> f'My wife name is {wife.get("name")}'
# 'My wife name is Rose'
>>> f'She is {wife.get("age")} years old.'
# 'She is 33 years old.'
>>> f'She is deeply in love with {wife.get("husband")}'
# 'She is deeply in love with None'
You can also change the default None value to one of your choice:
>>> wife = {'name': 'Rose', 'age': 33}
>>> f'She is deeply in love with {wife.get("husband", "lover")}'
# 'She is deeply in love with lover'
Adding items with setdefault()
It’s possible to add an item to a dictionary in this way:
>>> wife = {'name': 'Rose', 'age': 33}
>>> if 'has_hair' not in wife:
... wife['has_hair'] = True
Using the setdefault method, we can make the same code more short:
>>> wife = {'name': 'Rose', 'age': 33}
>>> wife.setdefault('has_hair', True)
>>> wife
# {'name': 'Rose', 'age': 33, 'has_hair': True}
Removing Items
pop()
The pop() method removes and returns an item based on a given key.
>>> wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
>>> wife.pop('age')
# 33
>>> wife
# {'name': 'Rose', 'hair': 'brown'}
popitem()
The popitem() method removes the last item in a dictionary and returns it.
>>> wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
>>> wife.popitem()
# ('hair', 'brown')
>>> wife
# {'name': 'Rose', 'age': 33}
del()
The del() method removes an item based on a given key.
>>> wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
>>> del wife['age']
>>> wife
# {'name': 'Rose', 'hair': 'brown'}
clear()
Theclear() method removes all the items in a dictionary.
>>> wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
>>> wife.clear()
>>> wife
# {}
Checking keys in a Dictionary
>>> person = {'name': 'Rose', 'age': 33}
>>> 'name' in person.keys()
# True
>>> 'height' in person.keys()
# False
>>> 'skin' in person # You can omit keys()
# False
Checking values in a Dictionary
>>> person = {'name': 'Rose', 'age': 33}
>>> 'Rose' in person.values()
# True
>>> 33 in person.values()
# True
Pretty Printing
>>> import pprint
>>> wife = {'name': 'Rose', 'age': 33, 'has_hair': True, 'hair_color': 'brown', 'height': 1.6,
'eye_color': 'brown'}
>>> pprint.pprint(wife)
# {'age': 33,
# 'eye_color': 'brown',
# 'hair_color': 'brown',
# 'has_hair': True,
# 'height': 1.6,
# 'name': 'Rose'}
Merge two dictionaries
>>> dict_a = {'a': 1, 'b': 2}
>>> dict_b = {'b': 3, 'c': 4}
>>> dict_c = {**dict_a, **dict_b}
>>> dict_c
# {'a': 1, 'b': 3, 'c': 4}
Python Sets
Share
Python comes equipped with several built-in data types to help us organize our data. These
structures include lists, dictionaries, tuples and sets.
A set is an unordered collection with no duplicate elements. Basic uses include membership
testing and eliminating duplicate entries.
Initializing a set
There are two ways to create sets: using curly braces {} and the built-in function set()
Empty Sets
When creating set, be sure to not use empty curly braces {} or you will get an empty
dictionary instead.
>>> s = {1, 2, 3}
>>> s = set([1, 2, 3])
>>> s = {} # this will create a dictionary instead of a set
>>> type(s)
# <class 'dict'>
Unordered collections of unique elements
A set automatically remove all the duplicate values.
>>> s = {1, 2, 3, 2, 3, 4}
>>> s
# {1, 2, 3, 4}
And as an unordered data type, they can’t be indexed.
>>> s = {1, 2, 3}
>>> s[0]
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# TypeError: 'set' object does not support indexing
set add and update
Using the add() method we can add a single element to the set.
>>> s = {1, 2, 3}
>>> s.add(4)
>>> s
# {1, 2, 3, 4}
And with update(), multiple ones:
>>> s = {1, 2, 3}
>>> s.update([2, 3, 4, 5, 6])
>>> s
# {1, 2, 3, 4, 5, 6}
set remove and discard
Both methods will remove an element from the set, but remove() will raise a key error if the
value doesn’t exist.
>>> s = {1, 2, 3}
>>> s.remove(3)
>>> s
# {1, 2}
>>> s.remove(3)
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# KeyError: 3
discard() won’t raise any errors.
>>> s = {1, 2, 3}
>>> s.discard(3)
>>> s
# {1, 2}
>>> s.discard(3)
set union
union() or | will create a new set with all the elements from the sets provided.
>>> s1 = {1, 2, 3}
>>> s2 = {3, 4, 5}
>>> s1.union(s2) # or 's1 | s2'
# {1, 2, 3, 4, 5}
set intersection
intersection() or & will return a set with only the elements that are common to all of them.
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s3 = {3, 4, 5}
>>> s1.intersection(s2, s3) # or 's1 & s2 & s3'
# {3}
set difference
difference() or - will return only the elements that are unique to the first set (invoked set).
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.difference(s2) # or 's1 - s2'
# {1}
>>> s2.difference(s1) # or 's2 - s1'
# {4}
set symmetric_difference
symmetric_difference() or ^ will return all the elements that are not common between them.
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.symmetric_difference(s2) # or 's1 ^ s2'
# {1, 4}
