Základní syntaxe

# - Takto vypadá komentář.
# - Začíná vždy znakem "#" (hash)
# - Je víceméně ekvivalentní // v C++

a = 1 + 2  # Komentář na řádku s kódem

"""V Pythonu nejsou žádné víceřádkové komentáře, které by
odpovídaly /* */ z C++ či Javy, nicméně často se místo nich
používají víceřádkové řetězce, které se jen nepřiřadí do
žádné proměnné a dále nepoužijí. Obvyklé je to zejména u
tzv. docstringů (viz dále)."""

a = 1 + 1.1 / 2    # jednoduchý výpočet, vytvoření a přiřazení do proměnné a
print(type(a))     # výpis do terminálu (stdout)
a                  # IPython ukáže výstup, pokud ho neuložíme do proměnné

a = "Hello" + " world!"                                 # jednoduchá práce s řetězci
print(a)
print("type(a) = %s, len(a) = %i" % (type(a), len(a)))  # formátovaný výstup

import math                 # chceme načíst vestavěný modul math
a = math.cos(math.pi / 4)   # použijeme funkci cos a konstantu pi
print('a = %.3g' % a)

from math import sin, pi    # import pouze některých položek
a = sin(pi / 4)
print('a = %.3g' % a)

a = cos(pi / 2)             # tohle asi nebude fungovat --> výjimka

print(str(dir()) + "\n")
print(repr(dir("a")))

a = 2
e = input("Zadejte výraz s proměnnou a: ")
print("%s = %s, a = %s" % (e, str(eval(e)), str(a)))   # použití funkce eval na předem neznámý výraz

if 2 > 1:
    print("Platí 2 > 1")
    if 1 > 2:
        print("Platí 2 > 1 a 1 > 2")
    else:
        print("Platí 2 > 1 a neplatí 1 > 2")
else:
    print("Neplatí 2 > 1")

a = 5
if a > 10:
    print("Tolik prstů na rukou nemáme")
elif a > 5:
    print("Na to potřebujeme prsty na obou rukách")
elif a >= 0:
    print("To dokážu spočítat na jedné ruce")
else:
    print("Záporná čísla neumím")

a = 0
while a < 5:
    print(a)
    a += 1

a = 0
while a < 5:
    print("a = %i" % a)
    a += 1
else:
    a = 1
print("Konec, a = %i" % a)

a = 0
while a < 5:
    a += 1
    # sudá čísla nebudeme vypisovat
    if a % 2 == 0:
        continue
    print("a = %i" % a)
else:
    a = 1
print("Konec, a = %i" % a)

# pomocí break najdeme největší trojciferené číslo dělitelné 19ti
a = 999
while a > 0:
    if a % 19 == 0:
        print("Výsledek je: %i" % a)
        break
    a -= 1
else:
    # break nespustí else část
    print("Nic jsme nenašli")

dlouhy_nazev_promenne = "pomoci plus vytvorime pro ukazku nejaky dlouhy retezec znaku, " + \
                        "ktery nedava zadny velky smysl ..."
dlouhy_nazev_promenne

dlouhy_nazev_promenne = (10000000000000 + 2222222222222222 + 9999999999999999 + 3987493874 +
                         444444444444444 + 23987342978 + 9874 + 555555555555555555 +
                         987349987 - 9999999999999999999)
dlouhy_nazev_promenne

# definice jednoduché funkce bez parametrů a návratové hodnoty
def hello():
    print("Hello Python!")
# tady funkci zavoláme
hello()

# what je argument funkce hello
def hello(subj):
    phrase = "Hello %s!" % subj
    # return ukončí funkci a případně vrátí hodnotu
    return phrase
print(hello("Prague"))

# greet je argument s implicitní hodnotou
def hello(subj, greet="Hello"):
    phrase = "%s %s!" % (greet, subj)
    # return ukončí funkci a případně vrátí hodnotu
    return phrase
# ponecháme implicitní hodnotu greet
print(hello("Prague"))
# použijeme greet jako keyword argument
# poziční argumenty musí být vždy jako první
print(hello("Praho", greet="Nazdar"))
# subj můžeme také použít jako keyword argument
print(hello(greet="Nazdar", subj="Praho"))

a = 3.5
b = 2.1
v = 77e-1
S = (a + b) * v / 2
print("Obsah lichoběžníku a=%g, b=%g, v=%g je: %g" % (a, b, v, S))

def trapezoid_area(...): 
    ...
    
S = trapezoid_area(a, b, v)

def do_not_do_this(l):
    # předpokládáme, že l je list
    l.append("I'm here")
    print("l inside the function")
    print(l)
print("original list")
x = ["in my list"]
print(x)
do_not_do_this(x)
print("x after calling the function")
print(x)

# Toto už je lepší, neboť je zřejmé, že funkce vedlejší efekty má (a jaké asi jsou).
# Ale i tak by se to dalo vyřešit lépe.
def insert_item_into_list(l, item):
    l.append(item)

def foo(l=[]):
    # tady se mění l
    l.append("appended")
    print(l)
# zavoláme s explicitním argumentem
foo([])
# pak zavoláme s implicitní hodnotou - výsledek by měl být stejný
foo()
# zkusíme stejná dvě volání, očekáváme, že výsledky budou stále stejné, ale ...
foo([])
foo()

def foo(l=[]):
    p = l + ["appended"]
    print(p)
# zavoláme s explicitním argumentem
foo([])
# pak zavoláme s implicitní hodnotou - výsledek by měl být stejný
foo()
# zkusíme stejná dvě volání, výsledky už snad budou stejné
foo([])
foo()

# Načte modul "math" a zpřístupní objekty v něm obsažené
import math
# cos je funkce definovaná v modulu "math"
print(math.cos(0))

# Budeme s funkcí "cos" z modulu "math" zacházet, jako kdyby byla definována v aktuálním souboru
from math import cos
print(cos(0))

# Importuje všechny objekty, které v modulu najde. Obvykle se nedoporučuje používat, protože
# nevíme, co všechno modul obsahuje, a spousta pojmenovaných funkcí, tříd a proměnných by
# mohla kolidovat s něčím v aktuálním skriptu.
from math import *