From Ever changing code
Jump to navigation Jump to search

Function vs Method

method is the object-oriented word for function, no real difference. So, the split is:

  • method is on an object.
  • function is independent of an object.

A function
is a piece of code that is called by name. It can be passed data to operate on (i.e. the parameters) and can optionally return data (the return value). All data that is passed to a function is explicitly passed.
A method
is a piece of code that is called by a name that is associated with an object. A method is able to operate on data that is contained within the class (remembering that an object is an instance of a class - the class is the definition, the object is an instance of that data).

All because of a class

Look the code below. A class called Door which has a method(action) called open. There is another portion of code with def just below which defines a function, it is a function because it is not declared inside a class, this function calls the method we defined inside our class as you can see and finally the function is being called by itself.

class Door:
  def open(self):  # <- method
    print 'hello'

def knock_door:    # <- function
  a_door = Door()



Lambda function

Is most commonly used when passing a simple function as an argument to another function. The syntax consists of the lambda keyword followed by a list of arguments, a colon, and the expression to evaluate and return. Can only do things that require a single expression (a single line of code).

In comparison, creating a function normally (using def) assigns it to a variable automatically. In the function below value of the calculation will be assigned to my_func variable.

def my_func():
  return "Hello" # <- it's 'return' statement that assigns value to 'my_func' variable

print(my_func()) # <- this prints 'my_func' variable it has just function syntax()
>>> Hello

Lambda is a single line function (anonymous function/unnamed function)

square = (lambda x: x**2)
>>> 4
>>> 9

Comparison Lambda vs Named def full function
Lambda assigned to variable Lambda inline def named function
func_lambda = lambda x: x*10
>>> Hi1Hi1Hi1Hi1Hi1Hi1Hi1Hi1Hi1Hi1
#      ___function___   _arg_
print((lambda x: x*10) ("Hi2"))
>>> Hi2Hi2Hi2Hi2Hi2Hi2Hi2Hi2Hi2Hi2
def func_full(x):
    return x*10
>>> Hi3Hi3Hi3Hi3Hi3Hi3Hi3Hi3Hi3Hi3

Lambda passed as an argument to another function

def my_func(f, arg):
  return f(arg)

my_func(lambda x: 2*x*x, 5)
>>> 50
  1. lambda -> keyword
  2. x -> input argument to the anonymous function
  3. 2*x*x -> the expression to compute
  4. 5 -> the function argument. Passed as x