Příkazy jazyka Python zapisujeme po řádcích, tj. na každý řádek pouze jeden. Prázdné řádky slouží jen ke zvýšení přehlednosti zdrojového kódu. Mezery a tabulátory se obecně ignorují, slouží k oddělení jednotlivých elementů (proměnných, klíčových slov, konstant, operátorů) tam, kde je to nezbytné. Mají však zásadní význam na začátku řádku (správné odsazení začátku textu je pro strukturu programu klíčové)!

# text uvozený znakem '#' až do konce řádky je komentář (poznámka), který
# je určen programátorům (pro program je bez významu)
 
'Toto není komentář'        # Toto je komentář
 
20+4.0*8-2.5                # je správný aritmetický výraz,
20    + 4.0*   0.8  - 2.5   # stejně jako tento
from math import sin, pi    # mezery jsou někdy nezbytné,
8+sin(pi/2)                 # jindy je zápis jednoznačný i bez nich,
8 + sin(pi / 2)             # přesto mohou být použity
 
12                          # OK - bez úvodních mezer
  12                        # => syntaktická chyba (nečekané odsazení)
 
# v případě nutnosti je možné (pro přehlednost) zapsat jeden 
# (logický) řádek na více skutečných řádků pomocí znaku '\'
dlouhy_vyraz = 1 + 1/2 + 1/3 + \
               1/4 + 1/5 + 1/6 + \
               1/7          # uf, ještě že to není do nekonečna
# všimněte si, že před 1/4 a 1/7 úvodní mezery ve dlouhém výrazu nevadí, 
# neboť z pohledu programu je to jeden řádek (s mezerami uvnitř)

Čísla patří mezi základní objekty, se kterými Python pracuje. Poskytuje řadu číselných datových typů, nyní se seznámíme s celými a desetinnými čísly.

# ========================================
# celá čísla - int
1                           # => 1
+15                         # volitelné + => 15
1_000_000                   # oddělovač pro vyšší přehlednost => 1000000
-6                          # => -6
# běžné aritmetické operace
2 + 9                       # sčítání=> 11
-6 - 3                      # odčítání => -9
-2 * 6                      # násobení => -12
14 // 4                     # CELOČÍSELNĚ dělení => 3
14 % 4                      # ZBYTEK po dělení => 2 (neboť 3 * 4 + 2 = 14)
-15 // 4                    # => -4
-15 % 4                     # => 1 (neboť -4 * 4 + 1 = -15)
6 ** 2                      # mocnění => 36
 
# ========================================
# "reálná" čísla (s plovoucí desetinnou čárkou) - float
0.158                       # desetinná TEČKA! (nikoliv čárka) => 0.158
-12.7                       # => -12.7
1.128e-3                    # exponenciální (vědecký) tvar => 0.001128
-0.0624E3                   # => -62.4
+18.5e+24                   # => 1.85e+25
.5                          # 0 lze vypustit => 0.5
128.256_154_12              # s oddělovačem => 128.25615412
# běžné aritmetické operace
3.5 + 12.3                  # sčítání => 15.8
2.0 - 6.0                   # odčítání => -4.0
2.5 * 8.4                   # násobení => 21.0
16.5 / 2.5                  # dělení => 6.6
2.0 ** 3.0                  # mocnění => 8.0
2.0 ** 0.5                  # i odmocňování => 1.4142135623730951
 
# ========================================
# složitější výrazy aj.
1 + 8 * 4                   # běžná priorita operátorů => 33
(1 + 8) * 4                 # dle potřeby závorkujeme => 36
(-1)**4 + (8 - (-4)) + 6 * (-1 + 4) // 2    # => 22
# při kombinaci 'int' a 'float' je výsledkem 'float'
1 + (-1.0)                  # => 0.0
6.0 ** 2                    # => 36.0
16 + 5.0 ** (1 / 3) - (0.25 + 9) / 9        # => 16.682198168898918
# též při ("reálném") dělení
6 / 3                       # => 2.0 (float)
# na rozdíl od celočíselného
6 // 3                      # => 2 (int)
# převod na celé číslo (odseknutí desetinné části)
int(5.85)                   # => 5
int(-5.85)                  # => -5
# převod na desetinné číslo
float(-240)                 # -240.0
 
# přesnost operací s 'int' je omezena pouze prostředky počítače
2268978 ** 49               # je vyčísleno přesně
# POZOR: přesnost operací s 'float' je OMEZENÁ!!! 
# (dle implementace, v našem případě na cca 15 platných cifer)
# na rozdíl od 'int' je pro uložení 'float' vyhražen prostor pevné délky
# v paměti (typicky 8 bytů)
1 - 1/3 - 1/3 - 1/3         # => 1.1102230246251565e-16 (mělo by být 0.0)
(2 ** 0.5) ** 2             # => 2.0000000000000004 (mělo by být 2.0)

Obvykle chceme výsledek nějaké operace uschovat a následně jej (třeba i opakovaně) znovu použít. Uložíme jej tedy do paměti a dáme mu nějaké jméno, tj. vytvoříme proměnnou a přiřadíme ji hodnotu. Přitom nemusíme dopředu deklarovat datový typ proměnné, ten se automaticky určí dle hodnoty.

Jména proměnných (identifikátory) budeme tvořit z malých i velkých písmen anglické abecedy (těmi budeme začínat), číslic a podtržítka¹⁾. Musíme se také vyhnout několika klíčovým slovům, která jsou vyhrazena pro účely jazyka (např. from, while, def apod.).²⁾

strana = 2.0                # vytvořili jsme proměnnou typu float
vyska = 1.5
obsah = strana * vyska / 2  # obsah trojúhelníka
obsah                       # vypíšeme hodnotu proměnné => 1.5
obsah = 3                   # původní hodnota i typ jsou přepsány 
 
# zvětšíme stranu o 1/2 délkové jednotky
# je to přiřazení, nikoliv matematická rovnost!
strana = strana + 0.5       # pomocí současné hodnoty vypočteme novou
strana                      # => 2.5
 
# na velikosti písmen záleží
cislo = 15
Cislo = 4                   # máme 2 proměnné typu int
cislo + Cislo               # => 19

Znakové řetězce jsou dalším základním datovým typem, slouží k uložení textových informaci. Zde si uvedeme pouze několik základních vlastností, podrobněji se problematikou budeme zabývat později.

'Řetězec je sled znaků uzavřených do apostrofů'
"Rovnocennou alternativou je použití uvozovek"
 
# samozřejmě lze vytvářet řetězcové proměnné - mají typ str
text1 = "Řetězec může obsahovat spoustu slov"
text2 = '+'                 # nebo jen jeden znak
text3 = ''                  # případně být prázdný
 
# je rozdíl mezi hodnotou proměnných
cislo = 15.0                # typu float
retezec = "15.0"            # a typu str
 
# číslo lze vždy převést na řetězec
str(-8.4)                   # => '-8.4'
str(7_000)                  # => '7000'
# naopak to lze pouze někdy
int("16")                   # => 16
int('-0.125')               # => chyba
float('-8')                 # => -8.0
float("6.55E-003")          # => 0.00655
float("deset")              # => chyba

Pro vstup z textové konzole (terminálu) slouží vestavěná funkce input, pro výstup funkce print.

# funkci input předáváme v závorce argument - řetězec, který chceme
# vytisknou na řádce jako výzvu uživateli
# návratovou hodnotou funkce je řetězec s obsahem zadaným uživatelem,
# který lze přiřadit do proměnné
vstup = input('Zadej své jméno: ')
#  nebo jinak zpracovat (např. rovnou převést na číslo)
cislo = float(input("Zadej délku v metrech: "))
# argument může být prázdný, závorky je přesto nutno použít
a = input()
 
# objekty určené k výstupu předáváme funkci print jako argumenty
# oddělené čárkami - mohou to být např. číselné nebo řetězcové
# konstanty, proměnné, výrazy apod.
print('---- Nadpis ----')   # příkaz vypíše text a odřádkuje
print('Číslo =', 15.0)      # mezi položkami se vloží mezera
print("Dvojnásobkem", cislo, "je", 2 * cislo, ".")
print()                     # pouze odřádkování

Připravili jsme si základní stavební kameny a nyní již můžeme vytvářet jednoduché programy, které skutečně něco dělají.

krychle.py

# na základě zadané délky hrany krychle vypočte
# její povrch a objem
 
hrana = float(input('Zadej délku hrany krychle v metrech: '))
# výpočty
povrch = 6 * hrana * hrana
objem = hrana ** 3
# tisk výsledků
print('Povrch krychle je', povrch, 'm^2')
print('Objem krychle je', objem, 'm^3')

zbozi.py

# pro zadané zboží určí procentuální změnu ceny
 
zbozi = input('Název zboží ') # typu str
cena1 = float(input('Původní cena [Kč] '))
cena2 = float(input('Nová cena [Kč] ')) # ceny jsou typu float
print(zbozi, '- cena se změnila o', (cena2 - cena1) / cena1 * 100.0, '%')