Anketa:  Ktery jazyk pouzivate? 
	  Znate MP?
 
 -------------------------------------------------------------------------------
 #2.1) Typovani
 # dynamic (Python) vs static typing (Java, C)
 
 d=3
 s="Pepa z Depa"
 q=4.3 
 
 p+d
 
 
 # strong (Python, Java) vs weak typing (Perl) - casting
 s+d
 s+q 
 
 #weak lingo ok:
a="9"
b=9
c = concatenate(a, b)  // -> "99"
d = add(a, b)          // -> 18

 #strong lingo way
a  = 9
b = "9"

a+b

str(a) + b
a + int(b)


-------------------------------------------------------------------------

#2.2) Interpretovaný
#vztah s dynamicnostu

------------------------------------------------------------------------
    
#2.3)Compact
#tzn. Udrzitelny v kedlubne

#nacist soubor the java way:

import java.io.*;
...

BufferedReader myFile =
    new BufferedReader(
        new FileReader(argFilename));
        
#nacist soubor the Python way:

myFile = open("/home/honza/a.log")
myFile.read(200)

-------------------------------------------------------------------------

#2.4)odsazený

#-odsazeni namisto {} atp., (ukecanost)
#jave
if ( a > b )
{
    a = b;
    b = c;
}

#python
if  a > b :
    a = b
    b = c


*************************************************************************
*************************************************************************

#3)Hybrid paradigmat

#Imperative:
#  Objektove 	- krabicky s vnitrnim stavem menenym metodami, ktere ruzne interaguji
#		- program je prubeh zmen stavu objektu - knecht prichazi o haksny
#  Proceduralni	- seznam instrukci
#Funkcionalni 	- rozebere problem na funkce, majici vstup a vystup, 
#		- ktere nemeni zadny vnitrni stav a 
#		- nemaji zadne sideeffecty (sleep, print, atp.)
#		- Imutabilita
#		- program je tok dat mezi funkcemi


----------------------------------------------------------------------------

#3.1) Objektove vs Proceduralni paradigma

#Neobjektovy priklad (objektova orientace neni vynucena):

limbcount = 4

def chop(amount):
    global limbcount
    limbcount -= amount
    return limbcount

def stitch(amount):
    global limbcount
    limbcount += amount
    return limbcount  
     
#Ale co kdyz mame vice rytiru?
#-class		class
#-self		this
#-_		Special methods __gt__(self, other), __eq__(self, other)
#-def		defines function

class Knecht:
    def __init__(self):
	self.limbcount=4
    
    def chop(self, amount):
	self.limbcount -= amount
	return self.limbcount

    def stitch(self, amount):
	self.limbcount += amount
	return self.limbcount

    
 #-no primitive types, even ints and functions are objects (gegen java < 1.5, c++)


-------------------------------------------------------------------------

#3.2) Funkcionalni paradigma v pythonu (http://blog.dhananjaynene.com/2010/02/functional-programming-with-python-part-1/)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#3.2.1) Uniform Access principle  - Funkce take objekty 
#-treat functions the same as attributes - snadnejsi udrzba
def add(x,y): return x + y
def pow(x,y): return x ** y

add(2,3)

goodAdd = add
add = pow

add(2,3)
goodAdd(2,3)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#3.2) Funkce
# map
mrkev = [2,3,4,4,4,5,3]

def kousni(x):
    return x-1

okousana_mrkev = map(kousni, mrkev)

print okousana_mrkev, 

# reduce

def add(x,y):
    return x + y
    
stravene_mrkev = reduce(secti, okousana_mrkev)
print stravena_mrkev

#Bonus: map-reduce

import operator

add = operator.add
mul = operator.mul

A = [1,2,3,10,200,3000]
B = [20,30,40,10,3,2]
 
vysledek = reduce(add, map(mul, A, B))
print vysledek


#filter
vek = [1,3,5,18,20,30,2,4,11,6, 9]
 
def je_nizky(x):
    return x <= 10
 
haranti = filter(je_mala, vek)
print haranti

#lambda - anonymous function

pricti_jednicku = lambda x: x+1   #vsimnete si chybejiciho return

def pricti_dvojku(x):
    return x+2

print pricti_jednicku(10)
print pricti_dvojku(10)

    #Pouzitelne kdekoliv 
mrkev = [1,2,3,4,5]
print map(lambda x: x-1, mrkev)
 
    #Volatelne kdykoliv
print (lambda y: "Nazdar " + y)("dedo?")



    #Dalsi priklad:
def zvetsovac(n): return lambda x: x + n

f = zvetsovac(1)
g = zvetsovac(10)

print f(3), g(3)

print zvetsovac(12)(33)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#3.3) Currying

def pow(x,y): return x ** y

from functools import partial

kvadrat = partial(pow,y=2)
kubat = partial(pow, y=3)

print kvadrat(3), kubat(3)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#3.4) Immutability - in functional programming, not so much in python, 
#VELKE vyhody pro multithreading

#mutabilita - pokud objekt muze zmenit hodnotu bez zmeny identity
#cisla - imutabilni
x = puv_x = 1
x == 1

x += 1
x == 1        # Hodnota zmenena

x is puv_x   # identita take --> cisla jsou immutabilni

#Lists - mutabilni

x = puv_x = []
x == []

x += [1]
x == []      # Hodnota zmenena

x is puv_x  # Identita nikoliv --> muatable


#immutable priklad
from collections import namedtuple

UsporadanaNtice = namedtuple('FJFI','ucitele, katedry, pocet_studentu')