Funkce a třídy

Funkce

Následuje příklad definice funkce, která sečte dva argumenty - a, b.



In [1]:

    
def my_function(a, b):
    """
    This function sum together two variables (if they are summable).
    """
    return a + b

Funkce může být opakovaně použita kde sčítání různých argumentů (čísel, textu i listů)



In [2]:

    
my_function(2, 5)









    Out[2]:





7



In [3]:

    
my_function("Spam ", "eggs")









    Out[3]:





'Spam eggs'



In [4]:

    
my_function([1, 2, "A"], [5, 5.3])









    Out[4]:





[1, 2, 'A', 5, 5.3]

Poznámka: Funkce nemusí mít žádné argumenty a nemusí ani mít příkaz return. Funce bez return vrací None.

Argumenty a klíčové argumenty

Argumenty (arguments, args) jsou povinné. Když voláte funkce, argumenty musí být zadané. Záleží na jejich pořadí.
Klíčové argumenty (keyword arguments, kwargs) jsou nepovinné, můžou mít zadanou defaultní hodnotu. Nezáleží na jejich pořadí.

Následuje příklad, kde jsou užity navíc i klíčové argumenty.



In [5]:

    
def my_function(arg1, arg2, kwarg1=0, kwarg2=0):
    """
    This function accepts two args and two kwargs.
    Product is sum of all args and kwargs
    """
    return arg1 + arg2 + kwarg1 + kwarg2



In [6]:

    
my_function(2, 3., kwarg1=1.5, kwarg2=2)









    Out[6]:





8.5



In [7]:

    
my_function(2, 3., 1.5, 2.)









    Out[7]:





8.5



In [8]:

    
my_function(2, 3.)









    Out[8]:





5.0



In [9]:

    
my_function(2, 3., kwarg2=3.)









    Out[9]:





8.0

Třídy

Třída je předpis, podle kterého je možné vytvářet instance - objekty. Příklad jednoduché třídy následuje.



In [10]:

    
class Example():
    
    def __init__(self):
        """
        This is constructor. This function runs during creation.
        """
        print("Instance created.")
        
    def __del__(self):
        """
        This is something like destructor.
        This function runs when the last pointer to the instance is lost.
        It is the last will of the instance.
        """
        print("Instance deleted")

Instance objektu může být vytvořena následovně. Všimněte si, že po přespání refence na instanci, je instance hned zničena.



In [11]:

    
f = Example()
f = None









    



Instance created.
Instance deleted

Funkce del (destruktor) se většinou nepoužívá. Ale funkce init (konstruktor) je nejčastější způsob jak inicializovat proměnné nebo činnost instance. V následujícím příkladě má konstruktor instance dva argumenty, které se uloží tak, aby byly přístupné i ostatním funkcím v dané instanci.



In [12]:

    
class Food():
    
    def __init__(self, portion_size, unit_mass):
        self.portion_size = portion_size # make it accessible from outside
        self.unit_mass = unit_mass
        self.UNIT = "g"

    def get_portion_mass(self):
        """
        This function returns mass of the portion with unit as string.
        """
        return str(self.portion_size * self.unit_mass) + " " + self.UNIT

Následuje příklad jak předat argumenty konstruktoru a jak zavolat vytvořenou funkci dané instance.



In [13]:

    
f = Food(10, 30) # create food with specific parameters
f.get_portion_mass() # get mass of a single portion









    Out[13]:





'300 g'

Dědičnost

Ukázka využíti dědičnosti následuje.



In [14]:

    
class Fruit(Food):
    
    def __init__(self, portion_size, unit_mass, sweetness=0):
        super(self.__class__, self).__init__(portion_size, unit_mass)
        self.sweetness = sweetness
        
class Vegetable(Food):
    
    def __init__(self, portion_size, unit_mass, is_green=False):
        super(self.__class__, self).__init__(portion_size, unit_mass)
        self.is_green = is_green

Takto zděděné třídy mají všechny proměnné a funkce původní třídy Food.



In [15]:

    
apple = Fruit(10, 30, 50)
apple.sweetness









    Out[15]:





50



In [16]:

    
apple.get_portion_mass()









    Out[16]:





'300 g'