Functions

Functions are defined as

def function_name(parameters):



In [2]:

    
def hello(a,b):
    return a+b



In [3]:

    
hello(1,1)









    Out[3]:





2



In [4]:

    
hello('a','b')









    Out[4]:





'ab'

Recursive function

recursive function is an easy way to solve some mathemtical problems but performance varies. The following is an example of a recursive function calculating the nth number in the Fibonacci Sequence.



In [8]:

    
def Fibonacci(n):
    if n < 2: 
        return n
    else: 
        return Fibonacci(n-1)+Fibonacci(n-2)
print Fibonacci(10)



In [9]:

    
def Fibonacci(n):
    return n if n < 2 else Fibonacci(n-1)+Fibonacci(n-2)
print Fibonacci(10)

Class

Class is a blueprint defining the charactaristics and behaviors of an object.

class MyClass:
    ...
    ...

For a simple class, one shall define an instance

__init__()

to handle variable when it created. Let's try the following example:



In [30]:

    
class Person:
    def __init__(self,age,salary):
        self.age = age
        self.salary = salary
    def out(self):
        print self.age
        print self.salary

This is a basic class definition, the age and salary are needed when creating this object. The new class can be invoked like this:



In [33]:

    
a = Person(30,10000)
a.out()

The __init__ initilaze the variables stored in the class. When they are called inside the class, we should add a self. in front of the variable. The out(Self) method are arbitary functions that can be used by calling Yourclass.yourfunction(). The input to the functions can be added after the self input.

Scope of variables

Very important: "call-by-value" or "call-by-reference"?

It is not a simple question, it often confused many people..We now try to do some testing..



In [10]:

    
a = 'Alice'
print a
def change_my_name(my_name):
    my_name = 'Bob'
change_my_name(a)
print a









    



Alice
Alice



In [11]:

    
a = 'Alice'
print a
def change_my_name(my_name):
    my_name = 'Bob'
    return my_name
b = change_my_name(a)
print b









    



Alice
Bob

So is it "call-by-value"? The value does not changed?

But Try this:



In [13]:

    
a_list_of_names = ['Alice','Bob','Christ','Dora']
print a_list_of_names

def change_a_value(something):
    something[0] = 'Not Alice'
    
change_a_value(a_list_of_names)
print a_list_of_names









    



['Alice', 'Bob', 'Christ', 'Dora']
['Not Alice', 'Bob', 'Christ', 'Dora']

Confused? Why the list is changeable but the string is not?



In [14]:

    
a_list_of_names = ['Alice','Bob','Christ','Dora']
print a_list_of_names
a_new_list_of_names = a_list_of_names
print a_new_list_of_names

def change_a_value(something):
    something[0] = 'Not Alice'
change_a_value(a_list_of_names)

print "After change_a_value:"
print a_list_of_names
print a_new_list_of_names

print "Is 'a_new_list_of_names' same as 'a_list_of_names' ?"
print a_new_list_of_names is a_list_of_names









    



['Alice', 'Bob', 'Christ', 'Dora']
['Alice', 'Bob', 'Christ', 'Dora']
After change_a_value:
['Not Alice', 'Bob', 'Christ', 'Dora']
['Not Alice', 'Bob', 'Christ', 'Dora']
Is 'a_new_list_of_names' same as 'a_list_of_names' ?
True

More Confused? Why the function return the same object, is it say that it is call-by-reference?



In [15]:

    
some_guy = 'Alice'
a_list_of_names = []
a_list_of_names.append(some_guy)
print "Is 'some_guy' same as the first element in a_list_of_names ?"
print (some_guy is a_list_of_names[0])









    



Is 'some_guy' same as the first element in a_list_of_names ?
True



In [16]:

    
another_list_of_names = a_list_of_names
print "Is 'a_list_of_names' same as the 'another_list_of_names' ?"
print (a_list_of_names is another_list_of_names)









    



Is 'a_list_of_names' same as the 'another_list_of_names' ?
True



In [17]:

    
some_guy = 'Bob'
another_list_of_names.append(some_guy)
print "We have added Bob to the list, now is 'a_list_of_names' same as the 'another_list_of_names' ? "
print (a_list_of_names is another_list_of_names)









    



We have added Bob to the list, now is 'a_list_of_names' same as the 'another_list_of_names' ? 
True



In [18]:

    
print (some_guy,a_list_of_names,another_list_of_names)
some_guy = 'Christ'
print (some_guy,a_list_of_names,another_list_of_names)









    



('Bob', ['Alice', 'Bob'], ['Alice', 'Bob'])
('Christ', ['Alice', 'Bob'], ['Alice', 'Bob'])

The problem relates to the properties of the object: mutability. Wheather it is mutable and immutable counts.



In [ ]: