7. Soubory a moduly

1. Datový typ bytes, bytearray, memoryview
   1. Převod objektu na bytes
   2. Převod bytes na původní objekt
   3. Bytearray
   4. Memoryview
2. Souborové objekty
3. Práce s textovými soubory
4. Práce s binárními soubory
5. Vytváření a import modulů
   1. Import modulu
   2. Cesta k modulu
   3. Import modulu z paketu
6. Modul sys
7. Modul Numpy, Array, Matplotlib
   1. Modul Numpy
   2. Modul Array
   3. Modul Matplotlib
8. Cvičení

7.1 Bytes, bytearray, memoryview

Objekt typu bytes je neměnitelná sekvence bitů. Tato binární serializace je nutná pro uložení dat do paměti počítače nebo pro jejich transport po síti.
Mnohá data (obrázky, zvuk, text) lze serializovat (kódovat - encode) na objekt typu bytes či deserializovat (dekódovat - decode) z typu bytes s použitím vhodného protokolu, jako je PNG, WAW, JSON nebo UTF-8, ASCII, cp1250 aj.

7.1.1   Převod objektu na bytes

Prezentaci objektu ve formátu bytes lze provést dvojím způsobem a to úpravou literálu nebo s použitím příslušných funkcí či metod.

Literálový přepis objektu na typ bytes vytvoříme předznamenáním literálu písmenem b. Vhodným typem literálu je řetězec (string), obsahující pouze znaky ze sady ASCII.
Řetězec se znaky UTF-8 lze převést funkcí bytes().

>>> asc = "Za horami, za lesy"    # konformní s ASCii 
>>> utf = "Bílá růže"             # konformní s UTF-8

# Literálová forma pro bytes:
>>> lba = b'Za horami, za lesy'; lba  
 b'Za horami, za lesy'                  
>>> lbu = b'Bílá růže'; lbu      # bude to chtít funkci  
 SyntaxError: bytes can only contain ASCII characters.  # vida

Převod funkcí bytes a encode

Převod na formát bytes lze provést pro všeliké kódování funkcí bytes, přijímající tři nepovinné parametry:

bytes([source[, encoding[, errors]]])

• source - zdrojem může být list, tuple, range, string, set, frozenset, dictionary, bytes, bytearray, memoryview (a dokonce i celé číslo); není-li uveden zdroj, vytvoří se prázdný objekt
• encoding - povinné při kódování řetězce, např 'utf-8'
• errors - uvedení akce, která se provede, když selže konverze řetězce, např . errors='strict'.

>>> asc = "Za horami, za lesy"
>>> utf = "Bílá růže"

>>> bytes(asc, "utf-8")         
b'Za horami, za lesy'          
>>> bytes(utf, "utf-8")
b'B \xc3\xad l \xc3\xa1 r \xc5\xaf \xc5\xbe e'
       í          á	      ů       ž

Znaky, které nejsou součástí ASCII, jsou vyjádřeny hexadecimálními čísly za zpětnými lomítky (escape sekvence). Na příkladě vidíme, že znaky ze sady UTF-8 (í, á, ů, ž ) jsou vyjádřeny dvěma kódovými čísly.

Převod na formát bytes metodou .encode() - pouze pro typ 'string':

string.encode([encoding[, errors]])

Údaj o kódování (encoding) lze vypustit, pokud souhlasíme s implicitně nastaveným utf-8. Pokud chceme použít jiné kódování, musíme jej uvést:

>>> "píšeš".encode()             # pro utf-8 je 'encoding' nepovinné
b'p\xc3\xad\xc5\xa1e\xc5\xa1'

>>> "píšeš".encode('utf-16')     # pro jiné kódování je povinné
b'\xff\xfep\x00\xed\x00a\x01e\x00a\x01'

7.1.2   Převod bytes na původní objekt

Při deserializaci (decoding) objektu typu bytes na původní objekt musíme vědět, jaké kódování bylo při serializaci použito. To není vždy spolehlivě zjistitelné.

Pro převod použijeme metodu zdroj.decode('coding')

>>> by = bytes("píšež", "utf-8"); by   # kódování je povinné   
 b'p\xc3\xad\xc5\xa1e\xc5\xa1'         # objekt typu bytes
>>> by.decode("utf-8")                 # kódování je nepovinné
 'píšeš' 

Lze také použít funkci str(bytes_obj, 'coding'):

>>> str(by, "utf-8")                   # kódování je povinné
 'píšež' 

7.1.3   Bytearray

Typ bytearray je měnitelná verze typu bytes.

# Pro bytearray použijeme funkci bytearray(bytes):
>>> ba = bytearray(b'Za horami, za lesy'); ba
 bytearray(b'Za horami, za lesy')

>>> by = bytes('Souznění', 'utf-8'); by   # objekt typu bytes
 b'Souzn\xc4\x9bn\xc3\xad'                # nejde změnit
>>> ba = bytearray(by); ba
 bytearray(b'Souzn\xc4\x9bn\xc3\xad')
# případně:  
>>> ba = bytearray('Souznění', 'utf-8'); ba
 bytearray(b'Souzn\xc4\x9bn\xc3\xad')
# Úprava iteráblu s konkatenací:
>>> ba[0] = 108             # změna znaku "S": (ord("l")=108)
>>> aba = bytearray("B", "utf-8") + ba; aba 
 bytearray(b'Blouzn\xc4\x9bn\xc3\xad')
>>> str(aba, "utf-8")                     # převod na řetězec
 'Blouznění'

7.1.4   Memoryview

Interní data objektu, uložená ve vyrovnávací paměti (buffer) jsou přístupná prostřednictvím procedury, zvané buffer protocol.

Tento protokol používá sekvenční objekt memoryview, vytvořený funkcí memoryview(obj). Objekt memoryview umožňuje přímý přístup (bez kopírování) k interním datům objektů typu bytes a bytearray.

Význam objektu memoryview spočívá v tom, že šetří paměť a urychluje výpočet zejména mnohokrát opakovaných operací.

# Vytvoření objektu
>>> ba = bytearray('Python','utf-8')   # objekt bytearray
>>> mvba = memoryview(ba); mvba        # objekt memoryview
 <memory at 0x0000020ED8FD53C0>        # místo v paměti
>>> tmvba = tuple(mvba); tmvba         # mvba jako tuple 
 (80, 121, 116, 104, 111, 110)         
cm_mvba = [chr(i) for i in tmvba]; cm_mvba  
['P', 'y', 't', 'h', 'o', 'n']     # převod komprehencí viz kap. 3.5 

# Změna objektu 'ba' prostřednictvím 'mvba'
>>> mvba[0] = 74; ba                   # chr(74) = J   
 bytearray(b'Jython')

# Výsek z objektu 'ba' prostřednictvím 'mvba'
>>> slba = tuple(mvba[0:4]); slba
 (74, 121, 116, 104)
>>> cm_slba = [chr(i) for i in slba]; cm_slba
 ['J', 'y', 't', 'h']

# Výsek pro bytes/memoryview/bytearray    
>>> bymv = bytes(mvba[0:4]); bymv       
 b'Jyth'
>>> bymv.decode('utf-8')                   
 'Jyth'

# Výsek pro bytearray/memoryview/bytearray
>>> bamv = bytearray(mvba[0:4]); bamv
 bytearray(b'Jyth')
>>> bamv.decode('utf-8')
 'Jyth'

Sekvence memoryview vytvořená z objektu bytes je neměnitelná, sekvence vytvořená z bytearray je měnitelná. Ovšem (jak vidno), sekvence bytes/memoryview/bytearray je rovněž měnitelná - zřejmě proto, že argumentem 'bymv' je objekt 'mvba', vytvořený z objektu 'ba' (bytearray).

7.2 Souborové objekty

Všechny soubory jsou v paměti počítače uloženy v binárním formátu. Při otevírání souboru v nějaké aplikaci (například v textovém editoru) je binární formát automaticky převeden do formátu, který lze číst nebo prohlížet. V prostředí Pythonu nám práci s binárním formátem umožňuje existence datového typu bytes.
Názvy souborů by neměly být stejné jako jména vestavěných objektů (built-ins) .

S textovými, ani s binárními soubory nepracujeme v Pythonu přímo, nýbrž prostřednictvím takzvaných souborových objektů.

Před vlastní manipulací s obsahem souboru musíme soubor otevřít funkcí open(~), po ukončení úprav musíme soubor zavřít funkcí close(). Případně můžeme použít idiom with open.

Při práci s textovým i binárním souborem musíme znát dvě věci - kde je soubor uložen a v jakém kódování (UTF-8, ASCII, ...) byl textový soubor uložen, neboli převeden do binárního formátu.

7.3 Práce s textovými soubory

Otevřený souborový objekt (označovaný také jako stream) vzniká použitím funkce open(~) dle následujícího schematu:

file_obj = open('file.ext', mode='r', buffering=-1, encoding=None,
   errors=None, newline=None, closed=True, opener=None)

file: název textového či bajtového souboru včetně přípony a 
   případné cesty, pokud nejsme s interpretem Pythonu (shell) 
   přímo 'nacédováni' do nadřazené složky souboru.
mode: přístupový režim pro manipulaci se souborem; implicitní 
   hodnota je 'r', 'read'.
encoding: žádané kódování např. encoding="utf-8" (kódování 
   "ASCII" netřeba explicitně uvádět)

Kromě pozičního parametru 'file.ext' ve schematu funkce open() jsou všechny ostatní parametry párové s přiřazenými implicitními hodnotami - což znamená, že není nutné je při invokaci funkce uvádět, pokud nechceme jejich hodnoty měnit. Při běžném použití funkce open() použijeme kromě vždy povinného parametru 'file.ext' nepovinné parametry 'mode' a 'encoding'.

Funkce open() je také iterátor, jenž vlastní funkci next(), která posouvá interní index objektu neboli ukazovátko (viz. kap. 3.1).

Přístupové režimy

Přístupový režim (mód) určuje, jakou manipulaci lze s otevřeným souborem provádět. Není-li režim zadán, je implicitně nastaven režim 'r' (read). Zároveň určuje polohu interního ukazovátka (funkce open() vytváří iterátorový objekt), označujícího počáteční místo pro případnou manipulaci.

'r', 'rt', 'rb' (read, read text, read binary) pouze pro 
     čtení; ukazovátko na začátku souboru
'w', 'wt', 'wb' (write, write text, write binary) pouze pro
     psaní; ukazovátko na začátku souboru; přepisuje  existující  soubor, neexistující vytvoří
'a', 'ab' (append, app. binary) pro připojení textu;
     ukazovátko na konci existujícího souboru; neexistující soubor vytvoří
'x'  vytvoří nový soubor a otevře jej pro psaní ('w')	  

'r+', 'rb+' pro čtení i psaní - pozor, přepisuje existující 
      soubor

# Těmto režimům je lépe se vyhnout:
'w+', 'wb+' pro psaní i čtení; přepisuje existující soubor,
      neexistující vytvoří
'a+', 'ab+' pro připojení textu i čtení; neexistující soubor 
      vytvoří  

Kombinaci různých možností lépe vyjádří následující tabulka.

Kromě přístupových režimů je při práci se souborovými objekty důležité znát typ kódování, v jakém byl ošetřovaný soubor vytvořen. Dobrým způsobem jak to zjistit, je otevření souboru v textovém editoru EditPad Lite 8, kde je kódování otevřeného souboru uvedeno ve spodní liště a nechá se případně nastavit.

Otevření a zavření souborového objektu

Jednoduchá invokace souborového objektu pro kódování v ANSII má tuto formu:

>>> myfile = open('week_en.txt')  # implicitní režim "r" a kódování "ANSII"

Pro UTF-8 i ASCII použijeme deklaraci:

>>> myfile = open('week_cz.txt', encoding="utf-8")  # implicitní režim "r"

Otevřený souborový objekt musíme po ukončení práce zavřít, neboť tato procedura je poměrně náročná na paměť a práci operačního systému.
Použijeme k tomu metodu myfile.close ():

>>> myfile.close()       # myfile je název objekt. souboru

Alternativně lze k deklaraci objektového souboru použít idiom with open, který otevřený soubor po provedení zadaného kódu automaticky zavře. Mějme dva soubory week_cz.txt a week_en.txt, obsahující výčet dnů v tydnu.

# proměnné 'cez' a 'eng' obsahují cesty k ošetřovaným souborům:
>>> cez = "F:/cesta/files/week_cz.txt"       # český text:
>>> eng = "F:/cesta/files/week_en.txt"       # anglický text 

# idiom 'with open':
>>> with open(cez, encoding="utf-8") as dny:
                 print(dny.read())
pondělí
úterý
středa
čtvrtek
pátek
sobota
neděle
>>>          # otevřený soubor je automaticky zavřen  

Při práci s existujícími soubory je alternativně možné být "nacédován" v jim nadřazené složce (zde files), kde jsou soubory uloženy:

Windows Command Precessor
F:\cesta\files> py       # zde přejdeme do prostředí Pythonu 
Python 3.13.5 (tags/v3.13.5:6cb20a2, Jun 11 2025, 16:15:46) [MSC v.1943 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Ve složce files máme již uloženy neprázdné soubory week_cz.txt a week_en.txt.

Nyní si v této složce vytvoříme prázdný soubor fruits_cz.txt, a to tak, že se jej pokusíme v Pythonu otevřít přesto, že dosud neexistuje:

>>> ovoce = open('fruits_cz.txt', 'w', encoding='utf-8')  
# hop a je tu lidoop - podívejte se do složky 'files'
>>> ovoce.close()     # otevřený objekt zase zavřeme

Poznámka: Pořadí argumenů v závorce je nutné dodržet. Kdybychom neuvedli parametr encoding vůbec, měli bychom problém pracovat se souborem, ve kterém se vyskytují háčky a čárky. Kdybychom jej neuvedli až na konci, potýkali bychom se s námitkou, že poziční argument 'w' následuje za klíčovým argumentem encoding.
Tímto kódem si ověříme, že nám interpret Pythonu rozuměl a že nám vyhověl:

>>> print(ovoce)
<_io.TextIOWrapper name='fruits_cz.txt' mode='w' encoding='utf-8'>

Příkaz print() nám vrátil typ objektu, jméno souboru, použitý mód a kódování souboru.
Pokud by soubor fruits_cz.txt v režimu write ('w') již existoval, byl by jeho případný text nahrazen textem, který bychom následně zapsali.

Pro vkládání dat do souborového objektu použijeme metodu .write. Pokud tuto proceduru provádíme v jedné seanci opakovaně, k přepisu stávajícího textu nedojde. K přepisu by došlo u nově otevřeného souborového objektu:

>>> ovoce.write("hrušky\ntřešně\nšvestky\nmeruňky\n")) # uloženo
31
>>> ovoce.write(" Nezapomeňte zavřít soubor.")  # rovněž uloženo
27 
>>> ovoce.close()                        # máme zavříno

Znak newline (\n) ukončuje jednotlivé řádky.

Nyní můžeme soubor opět otevřít, tentokrát pro čtení a načíst jeho obsah do výstupu v našem programu. Pokud není mód uveden, je implicitně zaveden mód 'r':

>>> ovoce = open('fruits_cz.txt', encoding="utf-8")
>>> print(ovoce.read())
hrušky
třešně
švestky
meruňky
Nezapomeňte zavřít soubor.
>>> next(ovoce)                # zkusíme ještě iteraci
StopIteration                  # iterátor je prázdný
>>> ovoce.close()

Metoda read() může také přijmout argument, který říká kolik znaků má být čteno; mezery se počítají.

Potřebujeme-li z objektu znovu číst, můžeme přesunout jeho ukazovátko (pointer) na začátek metodou seek(offset[, from]) předtím, než manipulovaný soubor posléze uzavřeme:

K idiomu 'with open' existuje alternativa 'try: ... finally:'. Ukážeme si to na tomto příkladě v aplikaci Thonny:

# try_finally.py

ovo = "F:/cesta/files/fruits_cz.txt"   # cesta k souboru
ovoce = open(ovo, encoding="utf-8")    # souborový objekt

try:
    print('1.', ovoce.read(23))
    print('2.', ovoce.readline())
    print('3.', ovoce.readlines())   # jsme na konci souboru
    print('4.', ovoce.tell())        # kde je ukazovátko?
    print'5.', (ovoce.seek(0,0))     # jsme na začátku
finally:
    ovoce.close()                    # zavíráme

>>> %Run try_finally.py
 1.
 hrušky                               # výstup z "read(23)"
 třešně                               # dtto
 švestky                              # dtto
 2. meruňky                           # výstup z "readline()"                         
 3. [' Nezapomeňte zavřít soubor.']   # výstup z "readlines()"
 4. 72                                # výstup z "tell()"
 5. 0                                 # výstup ze "seek(0,0)"

Metoda read() vrací zadaný počet znaků ze souboru. Implicitně (bez zadaného počtu) vrací celý soubor.
Metoda readline() vrací znaky z jednoho řádku včetně znaku newline (\n)
Metoda readlines() vrátí všechny zbyvající řádky jako seznam řetězců.

Následující funkce kopíruje textový soubor tak, že přečte a zapíše zadaný počet znaků najednou. První argument je jméno původního souboru, druhý argument je jméno nového souboru:

copy_file.py

def copy_file(staré_fru, nové_fru):   
    infile = open ("unsorted_fruits.txt", "r") # soubor existuje
    outfile = open("copied_fruits.txt", "w")   # je vytvořen
    while True:
        text = infile.read(150)    # zadaný max. počet znaků
        if text == "":
            break
        outfile.write(text)
    infile.close()
    outfile.close()
    return
	
... Invokace funce:	
copy_file('unsorted_fruits.txt', 'copied_fruits.txt')
...

Tato funkce cyklicky čte znaky z infile a zapisuje je do outfile až je dosaženo konce a proměnná text je prázdný řetězec, čímž se vyvolá provedení příkazu break.
Soubor copy_file.py uložte do složky, kde máte soubor unsorted_fruits.txt; najdete tam také v Pythonu vytvořený soubor copied_fruits. Operaci jsme provedli v aplikaci Thonny.
Na objekt typu file (soubor) lze rovněž aplikovat metodu .split() (viz 6.2.4).

7.4 Práce s binárními soubory

Soubory, které obsahují fotografie, obrázky, videa, zvukový záznam, zipové a spustitelné soubory - se nazývají binární soubory. Tyto soubory nejsou organizovány do řádků a nelze je (užitečně) otevřít normálním textovým editorem .

V Pythonu tyto soubory regulerně otevřeme již popsanou funkcí open() v režimu rb (read binary) a wb (write binary). V následující ukázce vytvoříme binární kopii obrázku motýla:

copy_motýl.py

f = open("motýl.jpg", "rb")        # exist. kopír. soubor
g = open("motýl_copy.jpg", "wb")   # tento se zároveń vytvoří

while True:
    buff = f.read(3300)            # pomocný objekt 3300 bitů
    if len(buff) == 0:
        break
    g.write(buff)
f.close()
g.close()	

Soubor motyl.jpg si prohlédnete zde , otevřený obrázek si v otevřeném kontextovém menu uložíte volbou "Save image as..." do téže složky jako soubor "copy_motýl.py", odkud dvojklikem invokujeme textový editor aplikace Thonny, kam zkopírujeme výše zobrazený text.

V následující ukázce si vytvoříme nový soubor a vložíme do něho text v kódování utf-8. Následně si tento soubor otevřeme jako objekt typu bytes:

with-open.py

with open("cat.txt", "w", encoding="utf-8") as cat:
    cat.write("Kočička")

with open("cat.txt", "rb") as cat:
    data = cat.read()

>>> data
b'Ko\xc4\x8di\xc4\x8dka'

Ve výstupu vidíme, že písmeno č se v utf-8 vyjádří pomocí dvou bajtů, což se v zápisu binárního řetězce (který je implicitně kódován v ASCII) projeví aplikací escape sekvence, neboli použitím zpětného lomítka \ .

7.5 Vytváření a import modulů

Soubor s příponou ~.py může být spuštěn jako skript přímou invokací (python file_name.py) z příkazového řádku systémové konzoly (CMD či Terminál) nebo být načten jako modul do jiného souboru příkazem import v jeho záhlaví.

Vestavěné (built-in) moduly jsou psány v jazyce C a jsou součástí standardní knihovny Pythonu - viz Python Module Index. Příkladem vestavěných modulů jsou moduly math, string, random, sys,   se kterými se postupně seznámíme.

Jako vlastní modul můžeme použít vhodný textový soubor s příponou .py. Název souboru nesmí být rozdělen pomlčkou, přípustné je podtržítko.

Importovaný modul je nejprve hledán v témže adresáři, v němž je přítomen importující soubor. Poté je hledán mezi vestavěnými (built-in) moduly. Následně je hledán v seznamu adresářů s názvem sys.path.

V následující ukázce vidíme jednoduchý příklad modulu (importovatelného souboru), jenž obsahuje deklaraci funkce a v modulu obecně nedoporučovaný přímo proveditelný příkaz (bez tečkové notace):

# file_a.py                           # zamýšlený modul    

def mocnina(m, n=3):                      
    print(" {}**{} = {} " .format(m, n, m**n))
	
print("Quo vadis?")	       # přímo proveditelný příkaz 

V další ukázce si předvedeme vliv příkazu import a použití idiomu if __name__ == '__main__' :

# file_b.py                      

import file_a                     # bez přípony '.py'

print("Nazdárek Kašpárek")
print("Hodnota proměnné __name__ je ", __name__)

if __name__ == "__main__":
    print("Soubor file_b.py byl invokován přímo.")
    file_a.mocnina(5)
else:
    print("Soubor file_b.py byl invokován nepřímo.")

Realizace tohoto souboru v Thonny či IDLE umožní přístup k definici funkce mocnina(m,n) ze souboru file_a.py.

>>> %Run file_b.py                      # jsme v konzole

Quo vadis?                              # výstup z file_a
Nazdárek Kašpárek                       # výstup z file_b
Hodnota proměnné __name__ je  __main__  # výstup z file_b
Soubor file_b.py byl invokován přímo.   # výstup z file_b
 6**3 = 216                             # mocnina z file_b,a
>>>                                     
>>> file_a.mocnina(5,4)  # invokace s použitím tečkové notace
 5**4 = 625

7.5.1   Import modulu

Import modulu lze provést různým způsobem.

a) Importujeme celý modul a jeho objekty evokujeme tečkovou notací:

>>> import file_a            # import modulu
>>> file_a.mocnina(4)        # aktivace objektu z modulu
 4**3 = 64

Případně importujeme celý modul pod jiným jménem
>>> import file_a as f_a
>>> f_a.mocnina(4)           # aktivace objektu (zde funkce) z modulu
 4**3 = 64

b) Importujeme všechny objekty z modulu:

>>> from file_a import *
>>> file_a.mocnina(4)        # aktivace objektu z modulu
64
# Tento způsob se nedoporučuje, neboť může dojít ke
  kolizi importovaných jmen se jmény lokálními.

c) Importujeme jen určité objekty modulu

>>> from math import pi, factorial as fact
>>> pi, fact(8)
(3.141592653589793, 40320)

7.5.2   Cesta k modulu

Importujeme-li vestavěný modul, můžeme jej importovat odkudkoli. Vlastní modul můžeme importovat :

1. přímo, pokud se nachází ve stejné složce jako importující soubor.
2. prostřednictvím seznamu složek (sys.path), v němž interpret Pythonu požadovaný modul povinně hledá.

Řekněmež, že si pro ukládání vlastních modulů vytvoříme složku F:/Howtopy/Cesty. Do seznamu sys.path ji vložíme tímto způsobem:

C:/> py                            # Terminál
Python 3.13.5 (tags/v3.13.5:6cb20a2, Jun 11 2025, 16:15:46)

>>> import sys
>>> sys.path.insert(0, 'F:\\Howtopy\\Cesty')     

# seznam 'sys.path' si nyní vytiskneme: 
>>> print(sys.path)                                
['', 'F:\\Howtopy\\Cesty', 'C:\\Users\\Bertík\\AppData\\Local\
\Programs\\Python\\Python313\\python313.zip', 'C:\\ ... ]  

7.5.3   Import modulu z paketu

Paket (package) je adresář, který spolu s potřebnými soubory (moduly) ~ .py obsahuje také soubor (třeba prázdný) __init__.py. Tento konstrukt využívá inherentní souborovou strukturu operačního systému.
V našem paketu se také sama vytvoří složka __pycache__, která bude akumulovat kompilované soubory ~.py.
Doplníme tedy paket /cesty o prázdný soubor __init__.py a přidáme pro ukázku soubory plus_ab.py a class_foo.py:

# plus_ab.py

def plus(a,b):
    print(a+b)

# class_foo.py

class Foo:                  # deklarace třídy (viz kap. 10)
    def ukul(self):         # metoda (funkce) třídy           
        print("Ukulele")

Oba soubory můžeme evokovat v konzole Terminálu:

C:/> py                          # Terminál
Python 3.13.5 (tags/v3.13.5:6cb20a2, Jun 11 2025, 16:15:46)

>>> import plus_ab               # cestu si najde Python sám
>>> plus_ab.plus(5,8)
13                               

C:/> python
Python 3.13.5 (tags/v3.13.5:6cb20a2, Jun 11 2025, 16:15:46)

>>> import class_foo          # import modulu
>>> inst = class_foo.Foo()    # vytvoření instance třídy
>>> inst.ukul()               # volání metody třídy
Ukulele

7.6 Modul sys

Modul sys poskytuje přístup k proměnným a funkcím, které spolupracují s interpretem, správou paměti a s knihovnami Pythonu. Stručný přehled proměnných a funkcí modulu sys - viz sys Module in Python. Následující příklad ukazuje výstupní hodnoty několika zadaných příkazů:

>>> import sys
>>> sys.path                       #  použité a použitelné cesty
 ['D:\\IDE\\Thonny\\lib\\ ... \\lib\\site-packages']    

>>> sys.version                    #  verze použitého Pythonu
 3.13.5 (tags/v3.13.5:6cb20a2, Jun 11 2025, 16:15:46)

>>> for name in sys.builtin_module_names:
        print(name, end=", ")      # výpis vestavěných modulů
 _abc, _ast, _bisect, _blake2, _codecs, ...
 ... itertools, marshal, math, mmap, msvcrt, nt, sys, time, reg, xxsubtype, zlib, 

Úplný obsah modulu sys nám vrátí funkce:

>>> dir(sys)                         

7.7 Modul Numpy, Array a Matplotlib

7.7.1   Modul Numpy

Aplikaci Numpy je nutné nejprve instalovat. Ve Windows s instalovaným programem Python s aplikací pip to je jednoduché:

C:\> pip install numpy            # velikost cca 15 MB

Knihovnu Numpy je nutné importovat do aktuálního pracovního prostředí Pythonu:

>>> import numpy as np               

Numpy používá vlastní formát kolektoru, zvaný array neboli pole. Prvky tohoto kolektoru musí být homogenní - to jest, musí být stejného typu .
Datový typ pole může být jedno- (1D, vektor), dvou- (2D, matice), tři- (3D, tenzor) i více (nD) dimenzionální.
Dimenzím se v Numpy říká osy (axes). Velikost pole je vyjádřena atributem shape (tvar), což je entice celých čísel, která vyjadřují délky jednotivých os (dimenzí).

Array v Numpy vytvoříme ze seznamu příkazem np.array() :

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> a[1][2]
7
>>> a.shape
(2,4)                   # počet os = počtu prvků v entici

Uvedené pole má dvě osy (je to tedy matice) o délkách 2 a 4 položky. Pro přístup k vybranému prvku matice lze použít indexy (počínající nulou).

>>> a = np.array([[1,2,3], [4,5,6]])
>>> b = np.array([[7,8], [9,1], [2,3]])
>>> c = np.matmul(a, b)
>>> c.shape
(2, 2)
>>> print(c)
[[31, 19],
 [85, 55]]

Protože solidnější popis práce s modulem Numpy přesahuje rámec tohoto tutoriálu, odkazuji případné zájemce na tuto webovou stránku.

7.7.2   Modul Array

Array je kolektor, podobně jako seznam. Na rozdíl od seznamu, který je vestavěným objektem Pythonu, je nutné objekt array vytvořit importovanou funkcí array() z modulu array nebo z instalovaného modulu (pip install numpy) numpy:

# Import funkce z modulu array: 
>>> from array import array as arr   
>>> arrpy = arr("i", [3, 6, 9, 12]); arpy    
 array('i', [3, 6, 9, 12])
 
# Import celého modulu
>>> import array as arr             
>>> arrpy = arr.array("i", [3, 6, 9, 12])
>>> print(arrpy)                  
 array('i', [3, 6, 9, 12])
>>> type(arrpy)
 <class 'array.array'>

# Import z modulu numpy:
>>> import numpy as np            
>>> arrnp = np.array(["numbers", 3.6, 6.9, 12])
>>> print(arrnp)
['numbers' '3.6' '6.9' '12']
>>> type(arrnp)
 <class 'numpy.ndarray'>

Deklarace kolektoru array má skladbu:

array_name = invokace_fce_array('type_code', [seznam_hodnot])

Údajem 'type_code' zadáváme typ a velikost jednotlivých elementů v bajtech :

signed integer: 'b'(1), 'i'(2)
float :         'f'(4), 'd'(8)
unicode char:   'u'(2)               # aktuálně 'deprecated'

Modul array obsahuje také řadu metod

>>> import array as arr              # import celého modulu
>>> ar_ray = arr.array('i', [1, 2, 3, 4]); ar_ray
 array('i', [1, 2, 3, 4])

# insert
>>> ar_ray.insert(3,9); ar_ray
 array('i', [1, 2, 3, 9, 4])
# remove
>>> ar_ray.remove(1); ar_ray
 array('i', [2, 3, 9, 4])
# pop
>>> ar_ray.pop(2); ar_ray
 9
 array('i', [2, 3, 4]) 

Kolektory array s výhodou použijeme při rozsáhlejších matematických výpočtech, neboť jsou rychlejší než standardní seznamy (lists).

7.7.3   Modul Matplotlib

V Kap. 8.11.2 je popisováno, jak lze rozdělit pole náhodných čísel [0,1) na intervaly (bucketWidth) a určit počet výskytů náhodných čísel v daném intervalu(výskyty).

Tento soubor čísel (frekvenční tabulku) je možné graficky znázornit histogramem, vytvořeným pomocí knihovny Matplotlib.

python -m pip install -U matplotlib       # velikost cca 12 MB

Podrobný popis práce s tímto nástrojem lze nalézt například zde.

7.8 Cvičení