Základní informace o jazyku Python

Co o Python říká oficiální web:

Python is a programming language that lets you work quickly and integrate systems more effectively.

Užitečné odkazy

Python 2.7 vs 3.x

Většina produkce stále používá Python 2.7, Python 3 je však zcela připraven pro ostré nasazení do produkce. Python 2.7 bude dostávat bezpečnostní update pouze do roku 2020. Více info na odkazu.

Instalace jazyka Python 3

Osobní zkušenost instalace mám pouze na Mac OS a Linux. V instalaci by vám měl pomoct následující odkaz.

Úkol

Instalace jazyka Python na vámi zvolenou platformu.

Pip vs (Ana)Conda

Oba dva balíčkovače pro instalování programů/knihoven v rámci Python ekosystému. Anaconda zaměřená více na vědecký Python (dataminig, machine learning). Conda nejenom pro Python, na PC na univerzitě najdete Condu.

IDE

Python je možné psát v jakémkoli textovém editoru případně používat Python interpretr.

Doporučené Python IDE

Jupyter notebook

Jupyter Notebook doporučuji na experimentování nejenom v jazyce Python. Jupyter umožňuje psát a vyhodnocovat kód rovnou v prohlížeči v takzvaném jupyter notebook. Více informací naleznete na oficiálním webu projektu.

The Jupyter Notebook is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations and narrative text. Uses include: data cleaning and transformation, numerical simulation, statistical modeling, data visualization, machine learning, and much more.

Úkol

Zprovoznit libobolné IDE (ideálně Jupyter) a otestovat jednoduchý hello_world.py.

hello_world.py

1
print("Hello world!")

Základy jazyka Python

Více informací dostupné na odkazu https://realpython.com/python-first-steps/. Následující příklady je možné stáhnout ve formě Jupyter Notebooku.

Promněnné

1
2
3
4
5
# název proměnné by měl vždy obsahovat podtržítka
nazev_promenne = 'hodnota'
cislo = 1
desetine_cslo = 1.56
boolean = True

Seznamy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
seznam = []
seznam_s_hodnotami = [1, 2, 3]

# assert testuje zda je podminka splnena, pouzivano casto u testovani
# testuje zda je hodnota vracena seznam_s_hodnotami[0] rovna 1,
# jelikoz na indexu 0 ocekavame jednicku je podminka splnena a assert uspesne probehne
assert seznam_s_hodnotami[0] == 1

# test zda je prvek v seznamu
assert 1 in seznam_s_hodnotami

# delka seznamu
assert len(seznam_s_hodnotami) == 3

# pridani prvku do seznamu, seznam muze obsahovat rozdilene datove typy
seznam_s_hodnotami.append('ahoj')

assert seznam_s_hodnotami == [1, 2, 3, 'ahoj']

# seznamy lze "rezat"

# veskere prvky do indexu 2
assert seznam_s_hodnotami[:2] == [1, 2]

# veskere prvky od indexu 2
assert seznam_s_hodnotami[2:] == [3, 'ahoj']

# Seznamy lze libovolne zanorovat, nebo je pouzivat jako frontu, zasobnik, viz dokumentace

Řetězce

1
2
3
4
5
6
7
8
9
10
11
retezec = 'abba'

# retezec se chova jako seznam
assert len(retezec) == 4
assert retezec[0] == 'a'

# prirazeni vsak nefunguje
# retezec[0] = 'c'

# podretezec ziskame jednoduse
assert retezec[:2] == 'ab'

Tuple

1
2
3
4
5
6
7
8
# Tuple narozdíl od seznamu obsahuje neměnné prvky

toto_je_tuple = (1, 3, 2)

print(toto_je_tuple)

# nefunguje
toto_je_tuple[0] = 'ahoj'
    (1, 3, 2)



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

    TypeError                                 Traceback (most recent call last)

    <ipython-input-51-4dd037267949> in <module>()
          6
          7 # nefunguje
    ----> 8 toto_je_tuple[0] = 'ahoj'


    TypeError: 'tuple' object does not support item assignment

Slovníky

1
2
3
slovnik = {'a': 1, 'b': 2}

assert slovnik.get('a') == slovnik['a']

Print

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var = 'světe'

# Jde to i takto, ale známe lepší
print("Ahoj " + var)

# Takto se formátovalo v Python 3
print("Ahoj {}".format(var))

# Takto by se mělo formátovat teď (Python 3.6+)
print(f"Ahoj {var}")

cislo = 1

# Dokonce není ani nutné převádět číselnou hodnotu na string
print(f"Krasne cislo {cislo}")
    Ahoj světe
    Ahoj světe
    Ahoj světe
    Krasne cislo 1

Podmínky

1
2
3
4
5
6
7
8
9
10
11
12
13
14
cislo = 1

if cislo < 0:
    print("zaporne")
elif cislo > 0:
    print("kladne")
else:
    print("nula")


# v podminkach je mozne pouzivat klasicke logicke operatory
assert (True and False) == False
assert (True or False) == True
assert (not True) == False
    kladne

Cykly

1
2
3
4
5
6
7
8
# Ostatní programovací jazyky

my_items = [1, 2, 3, 4, 5]

i = 0
while i < len(my_items):
    print(my_items[i])
    i += 1
    1
    2
    3
    4
    5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Python

my_items = [1, 2, 3, 4, 5]

# nejcasteji pouzivana iterace, for each
for item in my_items:
    print(item)

# pokud precejenom potrebujeme iterovat v nejakem rozmezi pouzivame range()
for i in range(6):
    print(f"Index: {i}")

# range muzeme pouzit i na sestupnou iteraci
for i in range(5, -1, -1):
    print(f"Sestupny index: {i}")


slovnik = {'a': 1, 'b': 2}

# pomoci for each muzeme krasne iterovat pres slovniky,
# ze slovniku je nutne ziskat seznam dvojic 'klic, hodnota' pomoci .items()
for key, value in slovnik.items():
    print(f"klic {key} hodnota {value}")
    1
    2
    3
    4
    5
    Index: 0
    Index: 1
    Index: 2
    Index: 3
    Index: 4
    Index: 5
    Sestupny index: 5
    Sestupny index: 4
    Sestupny index: 3
    Sestupny index: 2
    Sestupny index: 1
    Sestupny index: 0
    klic a hodnota 1
    klic b hodnota 2

Funkce

1
2
3
4
5
# nazev funkce rovnez obsahuje podtrzitko
def moje_funkce(argument):
    return argument + 1

assert moje_funkce(1) == 2

Python vs. parallel programming

Je Python vhodný pro paralelní/distribuované programování?

Global Interpreter Lock

GIL je mutex, který pomáhá udržovat informaci o tom co v rámci Pythonu právě běží. Zároveň poskytuje aktuálnímu vlánknu přístup k interním funkcím Python interpretru. V čem je to problém? Pouze jedno vláknu může v jeden okamžik vyhodnocovat kód v interpretru. Multi-thread scripty jsou ve výsledku pomalejší než single-thread.

The GIL is controversial because it prevents multithreaded CPython programs from taking full advantage of multiprocessor systems in certain situations. Note that potentially blocking or long-running operations, such as I/O, image processing, and NumPy number crunching, happen outside the GIL. Therefore it is only in multithreaded programs that spend a lot of time inside the GIL, interpreting CPython bytecode, that the GIL becomes a bottleneck.

Jak vyřešit GIL problém?

Oficiální knihovna multiprocessing pro jazyk Python je alternativa řešící problém s GIL. Místo vytváření vláken dochází k vytváření procesů. Každý proces má vlastní GIL a proto ve výsledku nedochází k problému zmíněném výše. Více informací a příklady jsou dostupné zde.

Jak by to tedy správně mělo být?

Scala https://www.scala-lang.org + Apache Spark http://spark.apache.org, Clojure https://clojure.org, výpočty na GPU CUDA https://developer.nvidia.com/cuda-zone (existuje i API do Python).

Proč je dobré (i tak) umět Python?

Python je jazyk, který získává stále více a více příznivců. Použivají jej firmy jako Google, Apple, Facebook, nebo Seznam.cz. Je to vynikající skriptovací jazyk na psaní prototypů, datamining případně machine learning. Obsahuje nespočet knihoven, které umožňují řešit většinu problému rychle a jednoduše. Více informací o jazyku Python na odkazu.