Začínám s Pythonem #2

Začnu vyhodnocováním logických výrazů. And a or se jednak nedají zapsat ve znacích (&& a ||), hlavně však fungují trochu jinak. Při použití and, např. 1 and 0 se postupuje tak, že se nejprve vyhodnotí první výraz, je-li false, vrátí se jeho hodnota, je-li true, vrátí se hodnota druhého výraz. Or funguje podobně, jen se hodnota prvního výrazu vrací, pokud je true. Kdy je výraz pravdivý a nepravdivý, o tom píše dokumentace.

0 and 1 #0
1 and 2 #2
0 or 1  #1
1 or 2  #1

Zajímavostí Pythonu jsou také operátory in a not in. Jejich funkci nejlépe ukáže příklad.

'k' in 'meloun'     #false
'k' in 'jablko'     #true
1 in [2, 3, 4,]     #false
1 not in [2, 3, 4,] #true

Jenom lehce se dotknu funkcí, které jsou poměrně logické a pochopitelné, kromě běžných povinných pozičních parametrů, tak jak je známe, existují také parametry nepovinné. Tyto parametry nemusí být při volání funkce zadány, pak se použije jejich výchozí hodnota z definice funkce.

def vypis_datum(den, mesic, rok = '2011'):
  print den, mesic, rok
vypis_datum('15','3','2015') #15 3 2015
vypis_datum('15','3')        #15 3 2011

Zajímavé je také předávání parametrů klíčovými slovy, musíme si však hlídat, abychom klíčovými slovy nepředávali parametry, které jsme již vyjádřili předtím pozičně.

def vypis_datum(den = '1', mesic = '1', rok = '2011'):
  print den, mesic, rok
vypis_datum('15',rok = '2015') #15 1 2015

Poslední novinkou jsou speciální parametry *param a **kwparam, které slouží k zápisu přebývajích pozičních a klíčových parametrů. Nebojte se, nejde o žádné pointery, více o nich zde.

Objektově orientované programování v jazyce Python

Nyní konečně přichází ta zajímavá část a tou je objektově orientované programování. Principy OOP vysvětlovat nebudu, mohu však vřele doporučit tuto knihu. Ukáži rovnou následující kód.

class zak:
  'Definuje tridu zak s atributem jmeno a znamka'
  def __init__(self, jmeno, znamka): #init funkce se provede pri vytvoreni instance
    self.jmeno = jmeno
    self.znamka = znamka
  def ukaz_znamku(self):
    print 'Zak', self.jmeno, 'dostal znamku', self.znamka
 
zak1 = zak('Karel', 5)
zak1.ukaz_znamku() #lze i takto zak.ukaz_znamku(zak1)
print zak1.__doc__

Na řádku 1 vytváříme novou třídu zak, na dalším řádku je krátký popis třídy (jak jej zobrazit vidíme na řádku 11), dále je nutno definovat inicializační funkci __init__. Všimněte si, že u každé funkce musí být první parametr self. V inicializační funkci přiřadíme hodnoty jednotlivým atributům třídy (objektu). Dále definujeme funkci ukaz_znamku, která nám zobrazí údaje o žákovi. Zbývá už jen vytvořit instanci třídy, tedy objekt. To se udělá obyčejným přiřazením, viz řádek 9 (nezapomeňte na parametry inicializační funkce!). Na předposledním řádku zavoláme funkci ukaz_znamku, všimněte si alternativního způsobu volání. Poslední řádek zobrazí komentář třídy.

Základní práce s třídami a objekty není těžká, jen je nutné si hlídat parametry a také zda objekt před použitím vytvoříme. Charakteristickou vlastností OOP je dědičnost. Její použití už je malinko složitější, nejprve opět příklad (třídu zak již máme definovanou).

class zak_1a (zak):
  'Definuje tridu zak_1a, coz je zak tridy 1.A'
  def __init__(self, jmeno, znamka, poradi):
    zak.__init__(self, jmeno, znamka)
    self.poradi = poradi
  def ukaz_znamku_poradi(self):
    zak.ukaz_znamku(self)
    print 'Poradi ve tride:', self.poradi
 
zak2 = zak_1a('Honza', 2, 3)
zak2.ukaz_znamku_poradi()
zak2.ukaz_znamku()

Vytvoříme si novou třídu pro žáky 1.A (určitě by to šlo vymyslet jinak, ale pro názorné účely jsem to udělal takto). Opět definujeme inicializační funkci, ve které inicializujeme instanci třídy zak (zde musí být self při volání!). Dále ještě přidělíme hodnotu atributu poradi (pořadí ve třídě podle prospěchu). Dále opět definujeme funkci ukaz_znamku (může mít i jiný název), nejprve v ní zobrazíme jméno a známku a „dotiskneme“ pořadí. Volání funkcí je stejné jako v předchozím příkladě, zde navíc můžeme zavolat i zděděnou metodu ukaz_znamku třídy zak. Můžeme udělat i toto

zak2.poradi = 5
zak2.ukaz_znamku_poradi()

Pokud se nepletu, něco takového by OOP nemělo umožňovat, zde to však umožňuje fakt, že všechny metody a atributy jsou veřejné. Pokud se pletu, opravte mne. :) Správně bychom měli ještě definovat funkci zmen_poradi.

  def zmen_poradi(self, poradi):
    self.poradi = poradi
...
zak2.zmen_poradi(4)
zak2.ukaz_znamku_poradi()

Více o tom zde.

Jak vidíte, zatím ta práce s objekty a třídami není zase tak těžká. Něco mi ale říká, že bude hůř. :)