Functions in Python

To define functions in Python we have the instruction def

After this reserved word goes the function name along with a list of arguments delimited by parentheses and separated by commas, ending with the symbol :

def name (param1, param2, ..., paramn):
     ["" "DOCSTRING_OF_FUNCTION" ""]
     instructions in python
     [return expression]

Defining a function does not execute the body of the function

It will only be executed when the function is called

Its execution binds the function name with the current local namespace to an objecto function (a wrapper around the executable code for the function)

This object function contains a reference to the global local namespace as the global namespace to be used when the function is called

Optionally you can add an expression that will be returned by the function

The expression can be a valid Python type preceded by the statement return

The DOCSTRING is a descriptive text of the function enclosed in three double quotes of opening and closing, before the first statement

It's optional, so if we don't want to add a description, we can omit it

But it is recommended to use it so that when we review after a while our code, we remember what our function did

Arguments

The argument step is optional and in some cases there may be functions that lack them

Type of arguments

Supports types str, int, float, complex,bool, list, tuple, dic and class

Arguments with value by position

When we send arguments to a function, they are received in order in the defined parameters

def rest(a, b):
     return a - b

rest(30, 10) #will show 20, no need to use print function

Value arguments by name

It is possible to evade the order of the parameters if we indicate during the call the value that each parameter has from its name

def rest(a, b):
     return a - b

rest(b=30, a=10) #will show -20, no need to use print function

No arguments

When calling a function which has a few parameters defined, if you do not pass the arguments correctly it will cause an exception TypeError

def rest(a, b):
     return a - b

rest() #throw an exception TypeError

Default value arguments

Sometimes we need an argument to have a value, to avoid an error (which would cause the exception to be thrown TypeError), even if the user of the function does not enter it

Note that default arguments become optional and that all arguments to the left of the first default value are required

def rest(a=None, b=None):
     if a == None or b == None:
         print("Error, you must send two numbers to the function")
         return
     return a - b

rest(30) #We have only passed one argument, shows: 'Error, you must send two numbers to the function'
rest() #Have not passed arguments, shows: 'Error, you must send two numbers to the function'

The example used the null value (None) to express that no arguments had been passed

But we could use any type we need as the default

Indeterminate arguments

Sometimes we won't know in advance how many elements we need to send to a function

For these cases we can use the indeterminate parameters by position or by name

Arguments by position

As an argument we will use a tuple type preceding it with the symbol *

In this way all the arguments will be received by position, being able to navigate them comfortably with a for

def ind_pos(*args):
     for arg in args:
         print( type(arg) )
         print(arg)

ind_pos(5, "Hello", [1,2,3,4,5] )

#return
#<class 'int'>
#5
#<class 'str'>
#Hello
#<class 'list'>
#[1, 2, 3, 4, 5]

Arguments by name

As an argument we will use a type to dictate it before the symbols **

In this way all the arguments will be received by the name of the dictionary key, being able to navigate them comfortably with a for

def ind_nom(**kwargs):
    print(kwargs)
    for kwarg in kwargs:
        print(kwarg, "=>", kwargs[kwarg])

ind_nom(n=5, c="Hello", l=[1,2,3,4,5])

#return
#{'n': 5, 'c': 'Hello', 'l': [1, 2, 3, 4, 5]}
#n => 5
#c => Hello
#l => [1, 2, 3, 4, 5]

Arguments by position and name

Sometimes you may need to use both types of parameters simultaneously in a function, so you must create both dynamic collections

First the indeterminate arguments by value and then by name

def pos_nom(*args,**kwargs):
     total = 0
     for arg in args:
         total += arg
     print("summation => ", total)
     for kwarg in kwargs:
         print(kwarg, "=>", kwargs[kwarg])

pos_nom(50, -1, 1.56, 10, 20, 300, name="Raúl", age=38)

#return
#summation =>  380.56
#name => Raúl
#age => 38

All examples have used the names args and kwargs but they're not mandatory

Many frameworks and libraries use them so it's a good practice to call them that, by convention

The pass statement

It's a null operation, when we execute it, nothing seems to happen

It is useful as a container when a statement is required syntactically, but you don't need to execute code

#a function that does nothing
def query(letter): 
    pass

type(query)

The return statement

The statement return it is the one that allows you to return the result of a function

Supports types str, int, float, complex,bool, list, tuple, dic and class

def sum(number1, number2):
    '''Sum two numbers'''
    print(number1 + number2)
    print("\n")

The statement return optional, but if omitted, by default it will return the null value (None)

Multiple return

An interesting feature of the functions in Python, is the possibility to return multiple values separated by commas

def test():
     return "Raúl", 20, [1,2,3]
cad, number, lists = test()
print (cad, type(cad) ) #return Raúl <class 'str'>
print (number, type(number) ) #return 20 <class 'int'>
print (lists, type(lists) ) #return [1, 2, 3] <class 'list'>

Functions are predefined by the language

Language defined functions are sorted by modules

A module is a set of classes and functions stored in a file that can be used later

We can create our own modules and import them into the new programs we make

However, it is advisable to reuse existing modules

To import a module we will use the statement import

In this way we will be driving a namespace, similar to how C++ does (using namespaces) or Java

It has the following syntax

import module_name [as alias]

To call a specific function of the module we will use number.funcion() or alias.funcion in case we've given the module an alias

If you don't want to use all the functions of the module but if you do, we'll use the statement from

It has the following syntax

from module_name import function_name

Sys module

This module is responsible for providing variables and functionalities related to the interpreter

The variables of the sys module are:

• sys.executable

  Returns the absolute directory of the Python interpreter executable binary file

• sys.platform

  Returns the platform on which the interpreter is running

• sys.version

  Return the Python version number with additional information

The most prominent methods of the sys module are as follows:

• sys.exit()

  Force the interpreter out

• sys.getdefaultencoding()

  Returns the default character encoding

• sys.getfilesystemencoding()

  Returns the character encoding used to convert unicode file names to system file names

• sys.getsizeof()

  Returns the size of the passed object as a parameter

import sys

cad = 'San Roque's dog has no tail'

print( sys.executable ) #return c:\python.exe, since i am using windows file system
print( sys.platform ) #return win32, since I am using a 32 bit Windows system
print( sys.version ) #return 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 21:26:53) [MSC v.1916 32 bit (Intel)]
print( sys.getdefaultencoding() ) #return utf-8
print( sys.getfilesystemencoding() ) #return utf-8
print( sys.getsizeof(cad) ) #return 60

os module

This module allows us to access OS dependent features

Above all, those that give us information about the environment of the same and allow us to manipulate the directory structure

Some of the most commonly used methods are:

• os.getcwd()

  It tells us what the current directory is

• os.chdir(route)

  Change working directory to last path as an argument

• os.chroot()

  Switch to the root directory

• os.mkdir(directory)

  Creates the passed directory as an argument

• os.rmdir(directory)

  Deletes the passed directory as an argument

• os.remove(file)

  Delete the file passed as an argument

• os.rename(current, new)

  Renames the current file by the name of the new file, passed as arguments

math module

This module provides us with mathematical functions and constants

We can find all the functions and attributes in your documentation

Some of the most commonly used variables are:

• math.pi

  Represents the value of the variable \pi (Pi number)

• math.e

  Represents the value of variable e (Euler number or Napier constant)

• math.tau

  Represents the value of the variable \tau = 2\cdot\pi (constant Tau, proposed by Bob Palais, Peter Harremoes, Hermann Laurent, Fred Hoyle, Michael Hartl, Nicolas Atanes, among others)

Some of the most commonly used methods are:

• math.ceil(x)

  Returns the integer less than or equal to x

• math.floor(x)

  Returns the largest integer less than or equal to x

• math.exp(x)

  Returns the number e raised to the power x

• math.log2(x)

  Returns the base 2 logarithm of x

• math.sin(x)

  Returns the sine of x radians

• math.cos(x)

  Returns the cosine of x radians

• math.tan(x)

  Returns the tangent of x radians

• math.degrees(x)

  Converts the x-angle of radians to degrees

import math

a = 4.5786
b = 2.873

print( math.ceil(a) ) #return 5
print( math.floor(a) ) #return 4
print( math.exp(a) ) #return 97.37796957468944
print( math.log2(a) ) #return 2.194906532422851
print( math.sin(a) ) #return -0.9910635960591139
print( math.cos(a) ) #return -0.133390211658793
print( math.tan(a) ) #return7.429807507871837
print( math.degrees(a) ) #return 262.3344560785987
print( math.pi ) #return 3.141592653589793
print( math.e ) #return 2.718281828459045
print( math.tau ) #return 6.283185307179586

Random module

The random module is used for everything related to random numbers

Some of the most commonly used methods are:

• shuffle(col)

  Randomly reorders items in a collection

• sample(col, k)

  Take n items without a collection replacement

• random()

  Generates a random number in the range [0, 1)

• uniform(a, b)

  Generates a random number in the range [a, b]

• randint(a, b)

  Generates an integer random number in the range [a, b]

• gauss(mean, sigma)

  Generates a random number following a gaussian distribution with given mean and sigma

import random

lists = [1, 2, 3]

print( random.shuffle(lists) ) #return None
print( random.sample(lists, 2) ) #return [1, 2]
print( random.random() ) #return 0.06298135634914415
print( random.uniform(0, 10) ) #return 3.304708273440835
print( random.randint(0, 10) ) #return 6
print( random.gauss(50, 1.28) ) #return 50.28864476388755

NumPy module

Numpy provides us with a lot of mathematical functions and the type of variable NumPy array

Usually the NumPy package is usually imported with the alias np

This module allows us to work with mathematical structures in a very comfortable way (product of matrices, random numbers, operations on matrices...)

It is a module that is not installed by default

To do this open a terminal and run:

python -m pip install numpy

We can find all the functions and attributes in your documentation

Some of the most commonly used methods are:

• random.rand()

  It returns random values to us with the desired shape

• empty()

  Creates an empty array with the right shape

• zeros()

  Creates an array of zeros with the right shape

• dot()

  Calculates the matrix product between two arrays

• sum()

  Calculates the sum of the elements of an array

import numpy as np

np.random.seed(3)
A = np.random.rand(3,3) * 2
B = np.random.rand(3,3) * 2
A = np.round(A, 2)
B = np.round(B, 2)

print("A = ", A)
#return
#A =  [[1.1  1.42 0.58]
# [1.02 1.79 1.79]
# [0.25 0.41 0.1 ]]

print("B = ", B)
#return
#B =  [[0.88 0.06 0.91]
# [1.3  0.56 1.35]
# [1.18 0.05 1.12]]

print("A * B = ", np.round(np.dot(A, B), 2) )
#return
#A * B =  [[3.5  0.89 3.57]
# [5.34 1.15 5.35]
# [0.87 0.25 0.89]]

print(Sum of A: ", np.sum(A) )
#return
#Suma de A:  8.459999999999999

print("Sum of A: ", np.sum(A, axis = 0) )
#return
#Suma de A:  [2.37 3.62 2.47]

C = A[A>1]
print(C) #return [1.1  1.42 1.02 1.79 1.79]

Pandas module

The package pandas is widely used in the Data Scientists

It's one of the packages we should focus on to learn about data analysis

Through pandas we can get acquainted with our data set by cleaning it, transforming and analyzing it

For example, with pandas we can read a CSV file from our computer, pass it to a DataFrame (a table, in essence) and do things like:

• Calculate statistics and answer questions about the data such as getting the maximum, minimum and average of each column, knowing how correlated columns A and B are, or knowing the statistical distribution of column C
• Clean up data doing things like removing missing values or filtering rows and columns according to some criteria
• Visualize the data with the help of matplotlib
• Save the data already cleaned back in a CSV or database

Pandas is based on NumPy, so we should have that module pre-installed

Jupyter Notebooks it's an app that complements very well with Pandas, since we can run the code by cells instead of completely, which is useful if we work with large datasets

The primary components of Pandas are series and DataFrame, the first type being a column and the second being a table

Usually the pandas package is usually imported with the alias np

It is a module that is not installed by default

To do this open a terminal and run:

python -m pip install pandas

We can find all the functions and attributes in your documentation

Now let's create a simple example to show the use of pandas using a series that will contain the members of the Spanish football team that won the 2010 World Cup

To create the series we use the method pd.Series you will receive a list of player names and a list with the number of players

Then we'll show it by screen

import pandas as pd

spanishPlayers = pd.Series(
    ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez', 'Pedrito',
     'Iniesta', 'Villa'], index=[1, 15, 3, 5, 11, 14, 16, 8, 18, 6, 7] )
print("Spanish Football Players: \n%s" %(spanishPlayers) )

#return
#Spanish Football Players: 
#1           Casillas
#15             Ramos
#3              Pique
#5              Puyol
#11         Capdevila
#14       Xabi Alonso
#16          Busquets
#8     Xavi Hernandez
#18           Pedrito
#6            Iniesta
#7              Villa
#dtype: object

Now we're not going to explicitly point indexes on it, then it will generate the indexes automatically starting from the zero value

import pandas as pd

spanishPlayers = pd.Series(
    ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez', 'Pedrito',
     'Iniesta', 'Villa'] )
print("Spanish Football Players: \n%s" %(spanishPlayers) )

#return
#Spanish Football Players: 
#0           Casillas
#1             Ramos
#2              Pique
#3              Puyol
#4         Capdevila
#5       Xabi Alonso
#6          Busquets
#7     Xavi Hernandez
#8           Pedrito
#9            Iniesta
#10              Villa
#dtype: object

Now let's introduce a dictionary into the series instead of a list and add one more player

import pandas as pd

spanishPlayers = pd.Series( {1: 'Casillas', 15: 'Ramos', 3: 'Pique', 5: 'Puyol', 11: 'Capdevila', 14: 'Xabi Alonso', 16: 'Busquets', 8: 'Xavi Hernandez', 18: 'Pedrito', 6: 'Iniesta', 7: 'Villa'} )
spanishPlayers[10] = 'Cesc' #add a player
print("Spanish Football Players: \n%s" %(spanishPlayers) )

#return
#Spanish Football Players: 
#1           Casillas
#15             Ramos
#3              Pique
#5              Puyol
#11         Capdevila
#14       Xabi Alonso
#16          Busquets
#8     Xavi Hernandez
#18           Pedrito
#6            Iniesta
#7              Villa
#10              Cesc
#dtype: object

Now let's create a simple example to show the use of pandas using a DataFrame that will contain the members of the Spanish football team that won the 2010 World Cup

To create the DataFrame we use the method pd.DataFrame you will receive a dictionary with player data, a list with the column name and a list with the number of players

We'll add one more player using the method loc dataFrame object

Then we'll show it by screen

import pandas as pd

spanishPlayers = pd.DataFrame(
    {
        'name': ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez',
                 'Pedrito', 'Iniesta', 'Villa'],
        'demarcation': ['Goalkeeper', 'Right back', 'Centre-back', 'Centre-back', 'Left back', 'Defensive midfield', 'Defensive midfield', 'Midfielder', 'Left winger', 'Right winger', 'Centre forward'],
        'team': ['Real Madrid', 'Real Madrid', 'FC Barcelona', 'FC Barcelona', 'Villareal', 'Real Madrid',
                 'FC Barcelona', 'FC Barcelona', 'FC Barcelona', 'FC Barcelona', 'FC Barcelona']
    }, columns=['name', 'demarcation', 'team'], index=[1, 15, 3, 5, 11, 14, 16, 8, 18, 6, 7]
)
spanishPlayers.loc[10] = ['Cesc', 'Forward', 'Arsenal'] #add a player
print("Spanish Football Players: \n%s" %(spanishPlayers) )

#return
#Spanish Football Players: 
#              name         demarcation          team
#1         Casillas          Goalkeeper   Real Madrid
#15           Ramos          Right back   Real Madrid
#3            Pique         Centre-back  FC Barcelona
#5            Puyol         Centre-back  FC Barcelona
#11       Capdevila           Left back     Villareal
#14     Xabi Alonso  Defensive midfield   Real Madrid
#16        Busquets  Defensive midfield  FC Barcelona
#8   Xavi Hernandez          Midfielder  FC Barcelona
#18         Pedrito         Left winger  FC Barcelona
#6          Iniesta        Right winger  FC Barcelona
#7            Villa      Centre forward  FC Barcelona
#10            Cesc             Forward       Arsenal

Display functions

print

The function print serves to send the output of your arguments to the browser in a format

Operador %

The operator % can also be used for string format

Interprets the left argument much like a style format string of the function printf C++, which applies to the right argument

In Python, there is no function printf but it has been endowed with its functionality print

For this purpose, the operator % is overloaded for strings to show the format of the string

It is often called string module operator (or, sometimes, even, module)

It has the format:

print( formatted_text %(variable1 [, variable2, ..., variableN] )

To format a text you have to enter the following formatting characters preceded by the symbol %:

Format characters for text
Character	Description
c	The argument is treated as a string value and collects a single character
d	The argument is treated as a value of type int and presented as an integer
e	The argument is treated with scientific notation (for example 1.2e+2)
E	As %e but uses the uppercase letter (for example 1.2E+2)
f	The argument is treated as a float value and presented as a floating point number (considering the locale)
F	The argument is treated as a float value and presented as a floating point number (without considering the locale)
g	Like %e and %f
G	Like %E and %f
o	The argument is treated as an integer value and presented as an octal number
s	The argument is treated as a string value and collects a string
u	The argument is treated as a value of type int and presented as an unsigned decimal number
x	The argument is treated as an integer value and presented as a hexadecimal number
X	The argument is treated as an integer value and presented as a hexadecimal number in uppercase

n =  int (43951789) #cast so that the value of n is integer
u = int(-43951789) #cast so that the value of u is integer
c = str("A") #cast so that the value of c is a string

print("%c" %(c) ) # c for ASCII value of number, shows 'A'
print("%d" %(n) ) # d for integer, displays '43951789'
print("%+d" %(n) ) # +d for signed positive integer, shows '+43951789'
print("%+d" %(u) ) # +d for negative signed integer, shows '-43951789'
print("%e" %(n) ) # e for scientific notation of the integer, shows '4.39518e + 7'
print("%E" %(n) ) # E for scientific notation of the integer, shows '4.39518E + 7'
print("%f" %(n) ) # f for decimal number (considering locale), displays '43951789.000000'
print("%F" %(n) ) # F for decimal number (regardless of locale), displays '43951789.000000'
print("%g" %(n) ) # g same as e and f
print("%G" %(n) ) # G same as E and f
print("%o" %(n) ) # o for octal number, shows '247523255'
print("%s" %(n) ) # s as a string, displays '43951789'
print("%u" %(n) ) # u for positive integer, shows '43951789'
print("%u" %(u) ) # u for negative integer, shows '-43951789'
print("%x" %(u) ) # x for hexadecimal number, displays '-29ea6ad'
print("%X" %(n) ) # X for uppercase hexadecimal number, displays '29EA6AD'

Format method

The method format added to string types in Python 2.6

Allows the use of characters {} to mark where a variable will be replaced and uses detailed formatting policies used to format

This method allows us to concatenate elements within an output through the positional format

Brackets and characters within them (called format fields) are replaced with objects passed to the format method

text = "the square root of two"
value = 2 ** 0.5

print("the result of {} is {}".format(text, value) ) #returns 'the result of the square root of two is 1.4142135623730951'

A number can be used in parentheses to refer to the position of the argument passed to the format method

Keep in mind that the first argument starts at zero

text = "the square root of two"
value = 2 ** 0.5

print("the result of {0} es {1}".format(text, value) ) #returns 'the result of the square root of two is 1.4142135623730951'

A key identifier can also be used when the argument is passed by name

This option will be useful when working with dictionaries or when we want to reduce the code something

dic = dict(text="the square root of two",  value=2**0.5)

print("the result of {text} is {value}".format(**dic) ) #returns 'the result of the square root of two is 1.4142135623730951'
print("the result of {text} is {value}.format(text="the square root of two", value=2**0.5) ) #returns 'the result of the square root of two is 1.4142135623730951'

Optionally you can put the symbol : after the number or name, and specify the type of the object:

Format characters for text
Character	Description
s	The argument is treated as a string value and collects a string
d	The argument is treated as a value of type int and presented as a decimal number (signed)
f	The argument is treated as a float value and presented as a floating point number (considering the locale)

import math

text = "the square root of two"
value = 2 ** 0.5

print("the result of {} es {:4d}".format(text, math.ceil(value) ) ) #with 4 padding spaces returns 'the result of the square root of two is    2'
print("the result of {} es {:04d}".format(text, math.ceil(value) ) ) #with 4 padding spaces returns y putting 0 to its left returns 'the result of the square root of two is 0002'
print("the result of {} es {:.4f}".format(text, value) ) #with 4 decimal values it returns 'the result of the square root of two is 1.4142'
print("the result of de {} es {:7.3f}".format(text, value) ) #cwith 7 spaces and 3 decimal values it returns 'the result of the square root of two is   1.414'
print("the result of {} es {:07.3f}".format(text, value) ) #with 7 spaces, 3 decimal values and putting 0 to its left returns returns 'the result of the square root of two is 001.414'

Higher order functions

In mathematics and computer science, higher order functions are functions that meet at least one of the following conditions:

• Take one or more functions as input
• Return a function as output

def double_function(f): #the function will perform what in mathematics is called composition
    def outcome(x):
        return f( f(x) ) #the function calls itself, it's a recursive function
    return result #returns the final result of the composition

def square(x):
    return x * x #calculate the square of x

g = double_function(square) #The composition runs from the innermost function (square) to the outermost (double_function)
g(3) #return 81

Lambda functions

Lambda functions are anonymous functions, that is, unnamed functions

They are only used where they were created (although they can be named and used later)

They are usually used in conjunction with map, filter and reduced functions

They are usually used to create functions that are passed as arguments to other functions

In Python the syntax of a lamdba function is:

lambda variable1<, variable2, ..., variableN>: expression

Where the expression can be any operation we would do when making an assignment

multiply = lambda x, y: x * y

print( multiply(2, 3) ) #return 6

map function

It allows us to apply a function on each of the elements of an iterable

It returns a map object, which we can easily transform into a list

lists = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
outcome = map(lambda x: x * x, lists)

print( outcome ) #return <map object at 0x04E889B0>
print( list(outcome) ) #return [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

filter function

Allows us to filter items in a collection (for example, a list)

It is a widely used function in the treatment of collections

lists = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
outcome = map(lambda x:x*x, lists)
filtered = filter(lambda x:x>30, outcome)

print( list(filtered) ) #return [36, 49, 64, 81, 100]

reduce function

Take a function and a collection by reducing it to a single value

It would be equivalent to an aggregation function

It belongs to the module functools, so it must be imported before it can use reduce

from functools import reduce

The function we pass must take at least two parameters and an optional one

The first is the aggregate parameter that accumulates in each iteration over the items in the collection

The second element corresponds to the step of the iteration

The third is in case an initial value is needed

from functools import reduce

lists = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print( reduce(lambda accumulator, number: acumulador + number, lista) ) #return 55