Varování: Tento dokument je zastaralý a nevztahuje se už k aktuální verzi Pythonu. Poohlédněte se po jiném návodu.

Tento dokument je určen pouze jako základní reference jazyka Python pro programátory, pokud s programováním hodláte teprve začít, tak tento dokument není tím pravým místem.

• multiplatformní
• interpretovaný
• procedurální i objektový
• dynamicky typovaný
• zjednodušená syntax
• řada rozšiřovacích modulů
• záleží na bílých znacích
• rozšířitelnost pomocí C++

• eclipse + PyDEV
• DrPython
• SPE
• jEdit
• eric3
• idle (dodávaný s Pythonem)

• další viz IDE na py.cz nebo IDE na wiki.python.org

print "Hello world"

Kód můžeme přímo spustit interpretem:

python zdrojovy_soubor.py

Nebo pomocí shellu tak, že na začátek souboru přidáme řádku:

#!/usr/bin/env python

S následnou změnou atributů a spuštěním:

chmod a+x zdrojovy_soubor.py
./zdrojovy_soubor.py

Deklarace proměnných se v Pythonu realizuje prostým přiřazením konkrétní hodnoty. Typ proměnné se určí automaticky, automaticky se provádí i přetypování. Pozn.: V závorkách je uveden název objektu v Pythonu, který daný typ zapouzdřuje.

Proměnné mohou být vestavěné (built-in), lokální nebo globální. Chceme-li deklarovat nebo zapisovat do globální proměnné, musíme ji v daném bloku označit jako globální, jinak se vytvoří lokální proměnná, která onu globální překryje:

a = 5              # deklarace promenne a
def fl():
  a = 10           # vytvoreni _lokalni_ promenne funkce
  print "a: ",a
 
fl()               # vypise a: 10
print "a: ",a      # vypise a: 5
 
def fg():
  global a         # zpristupni globalni promennou
  a = 10           # priradi globalni promenne hodnotu 10
  print "a: ",a
 
fg()               # vypise a: 10
print "a: ",a      # vypise a: 10

• zdroj

• zdroj

• zdroj

Řetězec lze rozdělit na více řádků pomocí zpětného lomítka, takto (a pozor, na bílých znacích záleží!):

"EU zavedla prostredky \
  pro smirovani obcanu."

Hodnota proměnné, které bude přiřazen tento zápis, bude (všimněte si těch dvou mezer navíc):

EU zavedla prostredky   pro smirovani obcanu.

Lze použít klasické zástupné konstrukce pro speciální znaky, jako \n pro konec řádky, \t pro tabulátor, \u0000 pro znaky Unikódu, atd.

Základní rozdíl mezi n-ticí a seznamem je skutečnost, že n-tice je statická proměnná, kterou nelze za běhu měnit (přidávat či odebírat prvky), zatímco seznam je dynamická proměnná, stejně jako slovník, do kterého lze přidávat či naopak odebírat prvky za chodu. U seznamů lze testovat, je-li určitá hodnota jeho součástí velmi jednoduše:

a = (1,2,3,4,5)
print 4 in a       # vrati True
print 9 in a       # vrati False

• zdroj

  a = 5
  b = long(a)
  print "a je typ ", type(a), " s hodnotou ", a
  print "b je typ ", type(b), " s hodnotou ", b

• zdroj

• zdroj

• zdroj

• zdroj

• zdroj

• zdroj

V Pythonu mají bílé znaky (mezery, apod.) klíčový význam, odsazení tu nahrazuje klasické céčkovské složené závorky, a proto existuje obrovský rozdíl mezi:

if a==5:
  print "Hello"
print "Hello"

a mezi

if a==5:
  print "Hello"
  print "Hello"

První zmíněná konstrukce vypíše jedno „Hello“ pouze pokud se proměnná a rovná číslu pět, a druhé „Hello“ v každém případě. Druhá konstrukce vypíše „Hello“ dvakrát, ale pouze v případě, že se proměnná a rovná číslu pět.

Python nesnese prázdnou větev v podmínce nebo cyklu. Vždy je nutné, aby daná větev obsahovala alespoň jeden příkaz. Potřebujete-li prázdnou větev, použijte příkaz pass, který je právě k tomu určen. Ukažme si to na příkladu:

if a == 0:
  # prazdna vetev neni pripustna
  # tady dojde k chybe
else:
  print 'a je nenulove'

Ale:

if a == 0:
  pass # vse OK
else:
  print 'a je nenulove'

Python nezná víceřádkové komentáře, pouze jednořádkové počínaje křížkem:

# komentar

Jednoduchá podmínka:

if podminka:
  prikazy        # vsimnete si odsazeni

Složitá podmínka:

if podminka:
  prikazy
elif podminka:   # zkracena verze else if
  prikazy
else:
  prikazy

Příklad:

if len(filename) > 0:
  print 'String filename is not empty.'
elif filename == 'hacker.txt':
  print 'Hi, Mr. Hacker'
elif filename == 'cracker.txt':
  print 'Hi, Mr. Cracker'
else:
  print 'Hi, someone else'

Cyklus v Pythonu iteruje trošku jinak než v jiných jazycích. Iteruje nad každou hodnotou v seznamu, nikoliv nad sekvencí čísel, a sice takto:

x = ['a', 'h', 'o', 'j']
 
for a in x:
  print a

Pokud potřebujeme iterovat klasickým způsobem, sekvencí čísel, použijeme objekt range(pocatecni_hodnota, koncova_hodnota, velikost_skoku), který nám vytvoří seznam hodnot pro iteraci:

for a in range(0,10):
  print a

Oba přístupy je možné kombinovat:

a = ['Kobyla', 'ma', 'maly', 'bok.']
for i in range(len(a)):
  print i, a[i]

while podminka:
  prikazy

Příklad:

a = 0
while a < 50:
  a += 5

V cyklech je možné používat klasické C-čkové konstrukce break, continue, dokonce i else:

for n in range(2, 10):
  for x in range(2, n):
    if n % x == 0:
      print n, ' se rovna ', x, '*', n/x
      break
  else:
    # nebyl nalezen nasobek cisla
    print n, 'je prvocislo'

• zdroj

Syntax:

def funkce(parametr):
  telo_funkce

Příklad:

def iteruj(od, do):
  for i in range(od, do+1):
    print i

Funkce s návratovou hodnotou:

def iteruj(od, do):
  result = []
  for i in range(od, do+1):
    result.append(i)
  return result

Funkce s implicitní hodnotou:

def iteruj(od=1, do=10):
  result = []
  for i in range(od, do+1):
    result.append(i)
  return result

Tady pozor, implicitní hodnota je dynamické proměnné přiřazena pouze při prvním volání funkce, při ostatních zůstává v proměnné původní hodnota a je třeba mírně obcházet. Buď použít statickou proměnnou:

def f(a, L=()): # L je staticky seznam
  T=list(L)
  T.append(a)
  return T

Nebo upravit funkci:

def f(a, L=None):
  if L is None:
    L = []
  L.append(a)
  return L

• zdroj

Parametry funkce lze zadávat buď pozičně nebo přiřazením hodnoty (keyword). U prvního způsobu záleží na pořadí, u druhého nikoliv:

def funkce(text, cislo):
  for i in range(cislo):
    print text
 
funkce("ahoj", 4)              # primo
funkce(cislo=4, text='ahoj')   # prirazenim hodnoty

Pokud voláme funkci s více parametry, než funkce umožňuje, vyvoláme výjimku. Můžeme však zbývající parametry zapsat do proměnné typu tuple nebo slovník, podle způsobu zadávání parametrů (viz předchozí bod). Nelze však míchat typy parametrů:

def funkce(text, cislo, *seznam, **slovnik):
  for i in range(cislo):
    print text
  print "Seznam promennych navic: ", seznam
  print "Seznam prirazeni navic: ", slovnik
 
funkce("ahoj", 4, 'a', a='a', 1, 2, b='c') 
# hodi vyjimku - pozicni parametr za prirazujicim
funkce("ahoj", 4, 'a', 1, 2, b='c', a='a') 

• zdroj

Proměnné i funkce jsou objekty, a funkce je možné používat na místo proměnných:

def f(promenna, funkce):
  for i in range(0, promenna+1):
    print funkce(i)                 # zavola funkci 'funkce' s parametrem 'i'

• zdroj

Lambda je anonymní funkce, konstrukce, která byla převzata z jazyků jako např. Lisp. Problémem je, že tyto funkce nesmí být složité:

f = lambda a, b: a + b
 
print f(3,6)              # vytiskne 9

Jelikož funkce jsou objekty, dají se předávat jako proměnné:

def expo(e):
  return lambda x: x ** e
 
fx = expo(6)
 
print type(fx)          # vrati: <type 'function'>                
print fx(2)             # vrati 2^6, tedy: 64

• zdroj

Funkce i třídy lze dokumentovat níže uvedeným způsobem. Doporučuje se na prvním řádku napsat krátký popis, oddělit prázdnou řádkou a doplnit delším popisem:

def nic_nedelej():
  """Funkce, ktera nic nedela
 
Ne, takhle funkce opravdu nic nedela.
"""
  pass
 
print nic_nedelej.__doc__  # vypise dokumentaci funkce

• zdroj

Konstrukce pro výjimky je try … except … finally:

while True:
  try:
    x = int(raw_input("Zadejte cislo: "))
    break
  except ValueError:
    print "To nebylo platne cislo."

Výjimku je možné vyvolat:

raise ValueError, 'Nazdar!'

Lze i vytvořit nový typ výjimky:

class MojeVyjimka(Exception):
  def __init__(self, value):
    self.value = value
  def __str__(self):
    return repr(self.value)

Klauzule finally (provede se, ať už vznikla nebo nevznikla chyba):

try:
  raise KeyboardInterrupt
finally:
  print 'Sbohem, svete!'

• zdroj

Výjimky se (třeba na rozdíl od Javy) propagují směrem vzhůru automaticky:

a = 'a'
print type(a)
 
def fx(x):
  if type(x) != int:
    raise ValueError
  else:
    print x
 
def fy(y):
  fx(y)
 
def fz(z=5):
  fy(z)
 
fz(a)

• zdroj

Moduly představují dodatečnou funkcionalitu, jejíž využití je třeba deklarovat příkazem import. Používá se standardní tečka k oddělení jmenných prostorů:

import math
print math.cos(30)
 
dir(math)           # vypise vsechny funkce modulu math

Nutnost zadávat jmenný prostor odpadne použitím konstrukce:

from math import *
 
print cos(30)

• zdroj

Úvod do funkcí standardních knihoven naleznete zde a zde. Seznam modulů a jejich popis pak zde.

Vytvořit vlastní modul není nic těžkého, jelikož v Pythonu může být kterýkoliv program, který vytvoříte, importován jako modul. Nicméně zkusme si to ukázat na příkladu:

Soubor mujModul.py:

""" Muj modul
 
Nic jineho nez demonstrace, jak vytvaret a pouzivat vlastni moduly."""
import sys
 
def myPrint(* toPrint):
  """ Upravena funkce print
 
Tato funkce je nahradou za tradicni print, na rozdil od ktereho
neoddeluje promenne mezerou."""
  for i in toPrint:
    sys.stdout.write(str(i))
 
def selfDestruct():
  """ Funkce ukonci program
 
I kdyz, kdo by takovou funkci pouzil, kdyz je jeji zapis delsi nez
sys.exit()... ale budiz."""
  sys.exit()

Jiný soubor:

import mujModul
 
mujModul.myPrint("Hello", "World")
mujModul.selfDestruct()
mujModul.myPrint("Hello", "World")

Soubor se otevírá příkazem open, který má dva parametry, a sice název souboru a mód přístupu k souboru, který může být w pro zápis, r pro čtení a a pro append, tedy zápis automaticky na konec souboru. Na MS Windows a Macintoshi se rozlišuje textový a binární soubor, binární soubor musí mít ještě přídomek b, tedy rb, wb, ab, jinak se zpracuje jako textový. Na unixových systémech existuje pouze binární režim, ale pro zachování portability programu je dobré binární přídomky používat.

soubor=open('/tmp/soubor', 'w')

• zdroj

• zdroj

Objekty je možné ukládat a číst ze souboru pomocí modulu pickle:

soubor=open('/tmp/soubor', 'w')
pickle.dump(objekt, soubor)       # ulozeni objektu do souboru
 
...
 
x = pickle.load(f)                # nacteni objektu ze souboru

• zdroj

Všechny třídy v Pythonu jsou veřejné (public) a všechny metody jsou virtuální - zapouzdření tedy záleží na programátorovi. Dědičnost a polymorfismus jsou samozřejmostí. Třídy se vytváří konstrukcí class:

class distribuce:
  "Linuxova distribuce"
  def __init__(self, nazev = 'unknown'):
    self.nazev = nazev
  def popis(self):
    print 'Objekt: ', self
    print 'Nazev: ', self.nazev
 
a = distribuce("Debian GNU/Linux")
a.popis()
b = distribuce("Mandriva")
b.popis()

Dědičnost (i vícenásobná) se realizuje snadno:

class Potomek(Rodic1, Rodic2, Rodic3):
  def metoda_1
  .
  .
  def metoda_n

• jeden a druhý zdroj

Teď už víte, že kterýkoliv objekt lze v Pythonu iterovat v cyklu takto:

s = 'ahoj'
for i in s:
  print s

Tuto funkcionalitu mají na starosti iterátory:

s = 'ahoj'
s_iterator = iter(s)
print it                # iterator je objekt
 
print it.next()         # vypise "a"
print it.next()         # vypise "h"
print it.next()         # vypise "o"
print it.next()         # vypise "j"
print it.next()         # vyhodi vyjimku StopIteration

Pythonský iterační protokol vypadá takto:

iter = x.__iter__()       # ziskej iterator
try:
  while True:
    y = iter.next()       # ziskej kazdy prvek
    ...                   # zpracuj y
except StopIteration:
  pass                    # iterator dorazil na konec

• zdroj

Postup pro integrování iterátoru do vlastní třídy je:

class Obraceni:
    def __init__(self, kObraceni):
        self.kObraceni = kObraceni
        self.index = len(kObraceni)
    def __iter__(self):              # vraci iterator tridy
        return self                  # v tomto pripade je to trida sama
    def next(self):                  # treba definovat funkci next()
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

Python však nabízí jednodušší cestu - generátory. Ty slouží ke zjednodušenému vytváření iterátorů. Jsou zapsány jako normální funkce, ale pro návrat hodnot používají yield. Po každém zavolání metody next() bude generátor pokračovat tam, kde přestal (pamatuje si všechna data a hodnoty). Metody __iter__() a next() se vytvoří automaticky.

def obratit(s)
  for index in range(len(s)-1, -1, -1):
    yield s[index]
 
for znak in obratit('ahoj'):
  print znak

• zdroj

• True, False - boolovské hodnoty, novinka ve verzi 2.4
• None - obdoba null, prázdný ukazatel, žádná přiřazená hodnota

• český fanouškovský web
• další fanouškovský web
• oficiální web
• seriál na Rootu
• seriál na LinuxSoftu
• záznam v české Wikipédii
• pasti jazyka Python

• Learning with Python
• Dive into Python
• Thinking in Python