Práce se soubory

Zpracování souborů začátečníky často přivádí do úzkých, ačkoliv důvody jsou pro mne tak trochu záhadou. Z pohledu programátora se soubory opravdu nijak neliší od souborů, které používáme při práci s textovým editorem nebo s jinou aplikací: musíme je otevřít, provedeme n�>jaké operace s obsahem a zase je zavřeme.

Nejv�>tší rozdíl spočívá v tom, že v programu se k souboru přistupuje sekvenčn�>. To znamená, že čteme od jeho začátku, postupn�> po jednom řádku. Textový editor často d�>lá totéž, jenže si obsah celého souboru nejdříve načte do pam�>ti, kde jej upravujete, a v okamžiku ukončení práce se souborem obsah pam�>ti zapíše zp�>t do souboru a uzavře jej. (Proto se vám může zdát, že textový editor nepoužívá postupné čtení obsahu souboru.) Další rozdíl spočívá v tom, že z programu obvykle soubor otvíráme jen pro čtení nebo jen pro zápis. Při zápisu můžeme vytvořit zcela nový soubor (nebo můžeme přepisovat obsah již existujícího souboru) nebo obsah připojujeme na konec (append) existujícího souboru.

Další operace, kterou můžeme při zpracování souboru použít, je skok zp�>t na začátek.

Soubory — vstup a výstup

Podívejme se na to v praxi. Budeme předpokládat, že existuje soubor zvaný menu.txt a že obsahuje seznam jídel:

spam & vajíčka
spam & opékané brambory
spam & spam

Poznámka překladatele: Pojem spam jsme si již vysv�>tlovali. Pokud nečtete texty učebnice postupn�>, naleznete vysv�>tlení zde. V jedné z epizod série Monty Python's Flying Circus se slovo spam objevovalo velmi hojn�>. S překvapiv�> podobnou frekvencí se v českých titulcích objevovalo slovo prejt. Není to totéž. Je to jen podobn�> stručné, což je pro titulky (a pro dabing) asi důležité.

Nyní napíšeme program, který obsah souboru přečte a zobrazí jej na výstupu — podobn�> jako to v Unixu d�>lá příkaz cat nebo v DOSu příkaz type.

# Nejdříve soubor otevřeme ke čtení (r jako read).
vstup = file("menu.txt", "r")

# Soubor načteme do seznamu řádků a pak
# každou položku seznamu (řádek) vytiskneme.
for radek in vstup.readlines():
    print radek
# A nyní soubor zase zavřeme.
vstup.close()

Poznámka 1: Operace file() vyžaduje dva argumenty. Prvním z nich je jméno souboru. Můžeme je předat prostřednictvím prom�>nné nebo je můžeme zapsat přímo jako řet�>zec, jako jsme to učinili zde. (Takovému zápisu řet�>zce se říká literál. Jde vlastn�> o přímo zapsanou řet�>zcovou konstantu.) Druhý argument určuje režim. Ten říká, zda soubor otvíráme pro čtení (r jako read) nebo pro zápis (w jako write). Můžeme též určit, zda se jedná o ASCII text nebo o binární data — přidáním 'b' za 'r' nebo za 'w' takto: open(jm_soub, "rb").

Poznámka 2: K otevření souboru jsme použili funkci file(). Starší verze jazyka Python místo ní používaly funkci open(). Parametry obou funkcí jsou naprosto shodné. Používání open() se stále dává přednost, takže v dalších ukázkách budeme obvykle používat open(). Ale pokud se vám zdá používání file() logičt�>jší, používejte file().

Poznámka 3: Ze souboru jsme četli a uzavírali jsme jej voláním funkcí, před které jsme připsali souborovou prom�>nnou. Tomuto zápisu se říká volání metody a je to naše další setkání s objektovou orientací. Teď si s tím nelamte hlavu. Jenom si všimn�>te, že to má svým způsobem vztah k modulům. O použité souborové prom�>nné můžete uvažovat, jako kdyby to byla reference na modul, který obsahuje funkce pro práci se soubory a který se jakoby automaticky importuje pokaždé, když vytvoříme souborovou prom�>nnou.

Poznámka 4: Na konci soubor uzavíráme voláním metody close(). Python (a nejen Python) sice všechny otevřené soubory na konci programu uzavírá, ale mezi dobré zvyky patří předepisování uzavírání souborů přímo. Proč? No, operační systém může odkládat zápis dat do souboru až do doby, kdy je soubor uzavírán (kvůli zvýšení výkonu systému). Pokud náhodou váš program skončí neočekávaným způsobem, riskujete, že vaše drahocenná data nebudou do souboru zapsána vůbec. Takže poučení zní: Jakmile ukončíte zápis do souboru, zavřete jej.

A teď uvažme, jak bychom se mohli vypořádat s dlouhými soubory. V prvé řad�> bychom museli soubor číst řádek po řádku. (V jazyce Python bychom místo použití readlines() a cyklu for museli použít readline() a cyklus while.) V takové situaci bychom mohli bychom použít prom�>nnou poc_radku, kterou bychom zvyšovali při načtení každého řádku a testovali bychom, zda dosáhla hodnoty 25 (počet řádku na obrazovce). Pokud by tato situace nastala, požádáme uživatele, aby stiskl n�>jaké tlačítko (dejme tomu Enter). Potom bychom poc_radku nastavili na nulu a pokračovali bychom dál. Můžete si to vyzkoušet jako cvičení….

Od verze 2.2 se Python k souborovému objektu umí chovat, jako kdyby to byl seznam řádků. To znamená, že v cyklu for nemusíme používat readlines(), ale jednoduše procházíme všemi řádky souboru. S využitím této vlastnosti můžeme předchozí příklad přepsat takto:

# Nejdříve soubor otevřeme ke čtení (r jako read).
vstup = file("menu.txt", "r")

# Procházíme souborem a tiskneme každou položku (řádek).
for radek in vstup:
    print radek
# A nyní soubor zase zavřeme.
vstup.close()

Výhoda tohoto stylu spočívá v tom, že nenarazíme na žádná omezení daná velikostí pam�>ti, jako v případ�> použití readlines(). Takže se vlastn�> kombinují výhody cyklu for a výše zmín�>ného řešení využívajícího while/readline().

Ukázali jsme si skutečn�> všechno, co pro zpracování souboru potřebujeme. Otevřeme soubor, čteme z n�>j a manipulujeme s načtenými daty jak potřebujeme. Jakmile skončíme, soubor uzavřeme. V předchozím příkladu jste si mohli všimnout jednoho malého zádrhele. Načtené řádky již na konci obsahují znak konce řádku, takže když je vytisknete příkazem print, který přidá navíc své konce řádků, bude výstup proložen prázdnými řádky. Abychom se tomu vyhnuli, můžeme použít metodu zabudovaného řet�>zcového typu rstrip(), která z konce řet�>zce odstraní všechny bílé znaky — říká se jim také netisknutelné znaky. (Existují i příbuzné metody lstrip() a strip(), které odstraňují bílé znaky zleva, respektive z obou konců řet�>zce.) Pokud tedy část výše uvedeného příkladu upravíme do podoby...

for radek in vstup:
    print radek.rstrip()

... m�>lo by to dopadnout podle očekávání.

Když budeme v jazyce Python chtít zapsat program pro příkaz copy, jednoduše otevřeme nový soubor pro zápis a místo tisku načtených řádků na displej je budeme zapisovat do tohoto souboru:

# Vytvoříme obdobu příkazu: COPY MENU.TXT MENU.BAK

# Nejdříve otevřeme soubory pro čtení (r) a pro zápis (w).
vstup = open("menu.txt", "r")
vystup = open("menu.bak", "w")

# Řádky vstupního souboru kopírujeme do nového souboru.
for radek in vstup:
    vystup.write(radek)

print "1 soubor okopírován..."

# Nyní soubory zavřeme.
vstup.close()
vystup.close()

Všimli jste si, že jsem na konci použil příkaz print k tomu, aby uživatel poznal, že se n�>co stalo? Podobná zp�>tná vazba pro uživatele je obvykle vhodná.

Protože jsme v tomto případ�> zapisovali stejný řádek, který jsme před tím načetli, nenastanou žádné problémy z konci řádků. (Metoda write() nepřidává další konec řádku.) Pokud bychom ale cht�>li zapisovat řet�>zce, které jsme si sami vygenerovali nebo které jsme před tím zbavili pravostranných bílých znaků metodou rstrip(), pak bychom museli na konec výstupního řet�>zce znak nového řádku přidat. Ud�>lali bychom to takto:

vystup.write(radek + '\n')  # \n reprezentuje přechod na nový řádek

Podívejme se, jak metodu write() využijeme v našem kopírovacím programu. Abychom soubor jen nekopírovali, přidáme na začátek souboru dnešní datum. Tím z jednoduše upravovatelného textového souboru s nabídkou jídel vygenerujeme denní menu. Stačí, když před vlastním kopírováním obsahu souboru menu.txt připíšeme na začátek nového souboru pár řádků:

# -*- coding: cp1250 -*-
# Vytvoříme denní menu podle obsahu souboru menu.txt.

import time

# Nejdříve otevřeme soubory pro čtení (r) a pro zápis (w).
vstup = open("menu.txt", "r")
vystup = open("menu.prn", "w")

# Připravíme si řet�>zec s dnešním datem.
dnes = time.localtime(time.time())
datum = time.strftime(u"%A %d. %B", dnes)

# Přidáme řádek s nadpisem a prázdný řádek.
vystup.write(u"Denní nabídka pro %s\n\n" % datum) 

# Řádky vstupního souboru kopírujeme do nového souboru.
for radek in vstup:
    vystup.write(radek)

print u"Menu pro %s bylo vytvořeno..." % datum

# Nyní soubory zavřeme.
vstup.close()
vystup.close()

Povšimn�>te si, že jsme použili modul time k získání aktuálního data a času (time.time()) a k převodu na n-tici souvisejících hodnot (time.localtime()), které jsou zase použity funkcí time.strftime() pro zformátování řet�>zcové podoby data. Ten je přes další formátovací řet�>zec vložen do nadpisu. Výsledný soubor pak vypadá n�>jak takto:

Denní nabídka pro Sunday 07. August

spam & vajíčka
spam & opékané brambory
spam & spam

Ačkoliv jsme na konec formátovacího řet�>zce nadpisu vložili dva znaky '\n', objevil se jen jeden prázdný řádek. Je to tím, že první znak způsobil ukončení řádku s nadpisem a teprve ten druhý způsobil vygenerování prázdného řádku. Správné vytváření a odstraňování znaků pro nový řádek patří při zpracování textových souborů k jedné z t�>ch otravn�>jších v�>cí.

import locale
locale.setlocale(locale.LC_ALL, 'cz')

Denní nabídka pro ned�>le 07. srpen

spam & vajíčka
spam & opékané brambory
spam & spam

Při zpracování souboru byste mohli ješt�> chtít, aby se načtená data přidávala na konec existujícího souboru. Jednou z možností by bylo otevřít výstupní soubor pro čtení, načíst jeho obsah do seznamu, připojit k seznamu data ze vstupního souboru a nakonec celý seznam zapsat jako novou verzi původního výstupního souboru. Pokud by byly soubory krátké, pak to nezpůsobí žádné problémy. Ale pokud je výstupní soubor velmi velký, třeba v�>tší než 100MB, pak vám prost�> při vytváření seznamu řádků dojde pam�>ť. (I kdybyste m�>li dostatečn�> velkou pam�>ť, takový postup by byl časov�> náročný.) Našt�>stí můžeme operaci open() určit další režim "a" (jako append), který zajistí připojení dat na konec souboru — do souboru prost�> zapisujeme. Je to dokonce ješt�> vylepšené tím, že pokud soubor neexistuje, bude vytvořen nový soubor — jako kdybyste použili režim "w".

Uveďme si příklad, kdy používáme takzvaný log^[2] soubor, do kterého zapisujeme chybová hlášení. Přitom ale nechceme smazat předchozí záznamy, takže nové záznamy připisujeme na konec souboru (error = chyba; msg = message [mesidž] = zpráva):

def logError(msg):
   err = open("Errors.log", "a")
   err.write(msg)
   err.close()

V reálném sv�>t�> bychom ovšem rádi n�>jakým způsobem omezili velikost souboru. B�>žn�> se používá technika, kdy se jméno souboru odvodí z aktuálního data. Takže když se datum zm�>ní, vytvoří se automaticky nový soubor. Správce systému pak může snadno najít chyby, které se staly v určitý den. Může snadno rozhodnout, které soubory jsou staré, archivovat je a odstranit v případ�>, kdy už nebudou potřebné. (Připomeňme si, že aktuální datum můžeme zjistit pomocí funkcí modulu time — stejn�> jako ve výše uvedeném příkladu generování denní nabídky.)

Oprášený příklad záznamníku s adresami

Pamatujete si na příklad záznamníku s adresami, který jsme poprvé nakousli v tématu Data, datové typy a prom�>nné a poté vylepšili v kapitole Konverzace s uživatelem? Teď z n�>j ud�>lám n�>co opravdu užitečného tím, že obsah záznamníku budeme ukládat do souboru. Při startu programu jej samozřejm�> budeme také načítat. Pro tyto účely si napíšeme pár funkcí. V tomto příkladu tedy spojíme n�>kolik prvků a dovedností, kterými jsme se zabývali v předešlých tématech.

Náš základní návrh bude vyžadovat funkci, která při startu přečte obsah souboru, a další funkci, která jej při ukončování programu op�>t do souboru zapíše. Prostřednictvím další funkce uživateli nabídneme možnost volby ze zobrazeného menu. A každou volbu položky z menu budou obsluhovat další funkce. Menu bude uživateli umožňovat:

• Přidání položky do záznamníku s adresami.
• Odstran�>ní položky ze záznamníku.
• Nalezení a zobrazení existující položky.
• Ukončení programu.

Načtení obsahu záznamníku

jmeno_souboru = 'adresy.dat'

def nactiObsah(zaznamnik):
    import os
    if os.path.exists(jmeno_souboru):
        soubor = open(jmeno_souboru, 'r')
        for radek in soubor:
            jmeno = radek.rstrip()
	    polozka = soubor.next().rstrip()
            zaznamnik[jmeno] = polozka
    else:
        soubor = open(jmeno_souboru, 'w') # vytvoř nový prázdný soubor
    soubor.close()

Povšimn�>te si, že znaky konců řádků odstraňujeme voláním rstrip(). Povšimn�>te si také, že k získání dalšího řádku souboru uvnitř t�>la cyklu využíváme operace next(). A všimn�>te si také toho, že jsme jméno souboru uložili do prom�>nné, která je definována na úrovni modulu. To znamená, že prom�>nnou jmeno_souboru můžeme využít jak při načítání, tak při ukládání dat.

Uložení obsahu záznamníku

def ulozObsah(zaznamnik):
    soubor = open(jmeno_souboru, 'w')
    for jmeno, polozka in zaznamnik.items():
        soubor.write(jmeno + '\n')
        soubor.write(polozka + '\n')
    soubor.close()

Povšimn�>te si, že při zápisu dat musíme přidávat znak konce řádku ('\n').

Načtení uživatelského vstupu

def nactiVolbu(menu):
    print menu
    volba = int(raw_input(u'Zvolte možnost (1-4): '))
    return volba

import sys
vyzva.encode(sys.stdout.encoding)

def raw_input(vyzva):
    import sys
    return __builtins__.raw_input(vyzva.encode(sys.stdout.encoding))

Přidání položky

def pridejPolozku(zaznamnik):
    jmeno = raw_input(u'Vložte jméno: ')
    polozka = raw_input(u'Vložte ulici, m�>sto a telefonní číslo: ')
    zaznamnik[jmeno] = polozka

Odstran�>ní položky

def odstranPolozku(zaznamnik):
    jmeno = raw_input(u'Vložte jméno: ')
    del(zaznamnik[jmeno])

Nalezení položky

def najdiPolozku(zaznamnik):
    jmeno = raw_input(u'Vložte jméno: ')
    if jmeno in zaznamnik: # v originále je zaznamnik.keys(), ale je to zbytečné
       print jmeno, zaznamnik[jmeno]
    else: 
       print u"Lituji. Pro '%s' nebyla nalezena žádná položka." % jmeno

Ukončení programu

Pro ukončení programu nebudeme psát n�>jakou zvláštní funkci. Místo toho budeme volbu na ukončení testovat v podmínce cyklu while. Takže hlavní program bude vypadat takto:

def main():
    menu = u'''
    1) Přidej položku
    2) Odstraň položku
    3) Najdi položku
    4) Uložit a konec
    '''
    zaznamnik = {}
    nactiObsah(zaznamnik)
    volba = nactiVolbu(menu)
    while volba != 4:
        if volba == 1:
            pridejPolozku(zaznamnik)
        elif volba == 2:
            odstranPolozku(zaznamnik)
        elif volba == 3:
            najdiPolozku(zaznamnik)
        else: 
            print u'Neočekávaná volba. Zkuste to znovu.'
        volba = nactiVolbu(menu)
    ulozObsah(zaznamnik)

Teď už zbývá jen zavolat při spušt�>ní programu funkci main(). Zajistíme to při použití trošky pythonovské magie:

if __name__ == '__main__':
    main()

Tento záhadný úsek kódu nám umožní spoušt�>t pythonovský soubor buď jako modul tím, že ho importujeme, nebo jako program tim, že ho spustíme. Rozdíl při uvedených dvou použitích pythonovského souboru spočívá v tom, že při importování modulu je vnitřní prom�>nné __name__ (dva znaky podtržení na začátku jména a dva na konci) přiřazeno jméno modulu. Pokud je soubor spušt�>n přímo (tj. použit jako samostatný program), je prom�>nná __name__ nastavena na hodnotu '__main__'. Tajemné, že?

Pokud nyní vložíte všechny kousky kódu do nového textového souboru a uložíte jej jako adresy.py, m�>lo by to jít spustit z příkazového řádku operačního systému tím, že napíšete:

C:\PROJEKTY> python adresy.py

Nebo prost�> v Průzkumníku (Explorer, MS Windows) poklepete na ikonu. M�>lo by se spustit nové DOSové okno a po ukončení programu by m�>lo zas zmizet.

V Linuxu by to vypadalo podobn�>:

$ python adresy.py

Prostudujte si uvedený kód, zkuste v n�>m najít chyby (nechal jsem tam přinejmenším dv�>, ale může jich tam být i více) a zkuste je opravit. Výsledný cca 70 řádkový program je typickým představitelem programů, které byste mohli začít psát pro svou vlastní potřebu. Pár v�>cí se v n�>m dá vylepšit — dostaneme se k tomu v další části —, ale i v této podob�> jde o rozumn�> užitečný, malý nástroj.

VBScript a JavaScript

Ani jeden z jazyků VBScript a JavaScript nepodporuje práci se soubory. Jde o rys související s bezpečností. Zajišťuje, že nikdo nebude schopen číst vaše soubory v situaci, kdy jste si nevinn�> stáhli n�>jakou webovou stránku. Na druhou stranu se tím však omezuje obecná použitelnost obou jazyků. V části zabývající se znovupoužitelností modulů jsme se ale dozv�>d�>li, že si v tomto sm�>ru můžeme pomoci, když použijeme Windows Script Host. WSH nám dává k dispozici objekt FileSystem, který jakémukoliv WSH jazyku umožní čtení souborů. Nejdříve se podíváme na příklad v JavaScript a potom si jej srovnáme s řešením v jazyce VBScript. Ale znovu uvidíme, jako v předchozím případ�>, že klíčovými prvky řešení budou volání WScript objektů.

Než se dostaneme k podrobnostem, m�>li bychom se zmínit o objektovém modelu FileSystem. Objektovým modelem rozumíme sadu vzájemn�> souvisejících objektů (tříd), které může programátor přímo využívat. V rámci WSH se objektový model FileSystem skládá z objektů FSO a z řady objektů typu File, včetn�> objektu TextFile, který budeme používat. Najdeme zde také pomocné objekty. Pro naše účely z nich budeme využívat objekt TextStream. V podstat�> budeme postupovat tak, že vytvoříme instanci objektu třídy FSO, tu použijeme pro vytvoření objektů třídy TextFile a z nich vytvoříme objekty TextStream. Do nich budeme zapisovat nebo z nich budeme číst. The TextStream objects themselves are what we actually read/write from the files.

Následující kód uložte do souboru nazvaného zkusSoubory.js a spusťe jej pomocí cscript způsobem, který jsme použili v úvodu k WSH (tedy cscript zkusSoubory.js).

Otevření souboru

Abychom ve WSH mohli otevřít soubor, musíme si vytvořit objekt typu FSO a poté jeho prostřednictvím vytvořit objekt TextFile.

var jmenoSouboru, fso, inSoubor, outSoubor, radek;

// Získáme jméno souboru.
fso = new ActiveXObject("Scripting.FileSystemObject");
WScript.Echo("Jak se bude soubor jmenovat? ");
jmenoSouboru = WScript.StdIn.Readline();

// Otevřeme inSoubor pro čtení a outSoubor pro zápis.
inSoubor = fso.OpenTextFile(jmenoSouboru, 1); // režim 1 = čtení
jmenoSouboru = jmenoSouboru + ".BAK"
outSoubor = fso.CreateTextFile(jmenoSouboru);

Čtení a zápis

// Cyklus přes vstupní soubor, dokud nenarazíme na konec.
while ( ! inSoubor.AtEndOfStream){
    radek = inSoubor.ReadLine();
    WScript.Echo(radek);
    outSoubor.WriteLine(radek);
    }

Uzavření souborů

inSoubor.close();
outSoubor.close();

Teď v jazyce VBScript

<?xml version="1.0" encoding="UTF-8" ?>

<job>
  <script language="VBScript">
      Dim fso, inSoubor, outSoubor, inJmenoSouboru, outJmenoSouboru
      Set fso = CreateObject("Scripting.FileSystemObject")
      
      WScript.Echo "Zadejte jméno souboru pro zálohu."
      inJmenoSouboru = WScript.StdIn.ReadLine
      outJmenoSouboru = inJmenoSouboru &amp; ".BAK"
      
      ' Otevřeme soubory.
      Set inSoubor = fso.OpenTextFile(inJmenoSouboru, 1)
      Set outSoubor = fso.CreateTextFile(outJmenoSouboru)

      ' Čteme soubor a vytváříme záložní kopii.
      While not inSoubor.AtEndOfStream
         line = inSoubor.ReadLine
	 outSoubor.WriteLine(line)
      Wend
      
      ' Uzavřeme oba soubory.
      inSoubor.Close
      outSoubor.Close
      
      WScript.Echo inJmenoSouboru &amp; " zálohován do " &amp; outJmenoSouboru
  </script>
</job>

C:\PROJEKTY> cscript zkusSoubory.wsf 

Práce s netextovými soubory

Zpracování textu patří k jednomu z nejb�>žn�>jších programátorských úkolů. Občas ale potřebujeme zpracovávat i binární data. V jazycích VBScript nebo JavaScript se s tímto problémem setkáme velmi zřídka — už jen proto, že nemají přímou podporu práce se soubory —, takže se budeme zabývat jen tím, jak se s tím vypořádáme v jazyce Python.

Otvírání a uzavírání binárních souborů

Klíčový rozdíl mezi textovými a binárními soubory spočívá v tom, že textové soubory jsou složené z oktetů (nebo bajtů) s binárními daty, kde každý bajt reprezentuje znak. Konec souboru je označen speciálním bajtem, kterému se anglicky obecn�> říká end of file [end of fajl] nebo eof (čili konec souboru). Binární soubor obsahuje libovolná binární data, takže pro identifikaci konce souboru nemůže být použita žádná speciální hodnota. Pro čtení takových souborů se proto musí použít jiný režim. Pokud tedy v Pythonu (nebo v jiném programovacím jazyce) otvíráme binární soubor, musíme jej otevřít v binárním režimu. V opačném případ�> riskujeme, že soubor bude ukončen v míst�> prvního výskytu znaku eof, který Python nalezne mezi binárními daty. Binárního otevření souboru v jazyce Python dosáhneme tak, že k parameru režimu přidáme 'b':

binarniSoubor = file('binSoubor.bin', 'rb')

Jedinou odlišnost od otvírání textového souboru představuje hodnota režimu 'rb'. Písmeno 'b' můžeme přidat i k ostatním režimům: 'wb' pro zápis, 'ab' pro připojování za konec souboru.

Uzavírání binárního souboru se provádí stejn�>, jako u textového souboru. Jednoduše zavoláme metodu otevřeného souborového objektu close():

binarniSoubor.close()

Protože soubor byl otevřen v binárním režimu, nemusíme Pythonu poskytovat n�>jakou další zvláštní informaci — Python ví, jak má soubor korektn�> uzavřít.

Modul struct

Pro kódování a dekódování binárních dat můžeme v Pythonu využít modulu struct (zkratka pro structure, tedy struktura). Tento modul pracuje podobn�>, jako když jsme používali formátovací řet�>zec pro tisk dat různého typu. Zadáváme řet�>zec, který reprezentuje typ načítaných dat, a ten je použit pro proud bajtů, který se pokoušíme interpretovat. Modul struct můžeme použít také pro převod dat na proud bajtů určených k zápisu do binárního souboru (nebo dokonce do komunikační linky).

Modul definuje řadu kódů pro převod formátů, ale my zde použijeme jen kódy pro celá čísla a pro řet�>zce. (Ostatní kódy si můžete vyhledat v dokumentaci k modulu struct, který je součástí distribuce Pythonu. Kódy pro celé číslo a řet�>zec jsou i respektive s. Formátovací řet�>zec modulu struct se skládá z posloupnosti kódů, kterým jsou předřazena čísla, určující kolik prvků příslušného typu chceme získat. Tak například zápis 4s znamená, že chceme řet�>zec o délce 4 znaky.

Poznámka překladatele: Číslo před řet�>zcovou značkou se chápe jinak, než čísla před značkami pro jiné typy. U řet�>zce udává délku získávaného řet�>zce, u značek ostatních typů jde skutečn�> o počet hodnot daného typu. Tak například značka 10s vyjadřuje jeden řet�>zec o délce 10 znaků, zatímco značka 10c vyjadřuje deset jednoznakových řet�>zců (Python nezná typ znak).

Dejme tomu, že bychom cht�>li detaily adresy ve výše zmín�>ném záznamníku adres zapisovat jako binární data, kde by číslo domu bylo uloženo jako celé číslo a zbytek by byl uložen jako řet�>zec. (Z praktického hlediska to zase není tak dobrý nápad, protože čísla domů n�>kdy obsahují i písmena.) Formátovací řet�>zec by pak vypadal n�>jak takto:

'i34s'  # Předpokládáme, že na adresu je vyhrazeno 34 znaků.

Pokud bychom potřebovali pracovat s různou délkou adresy, mohli bychom si napsat funkci, která vytvoří její binární podobu takto:

def formatujAdresu(adresa): 
    # split rozd�>lí řet�>zec na seznam 'slov'.
    slova = adresa.split()
    cislo = int(slova[0])
    zbytek = ' '.join(slova[1:])
    format = "i%ds" % len(zbytek)  # vytvoř formátovací řet�>zec
    return struct.pack(format, cislo, zbytek)

Takže adresu jsme rozsekali na kousky metodou split() zabudovaného typu řet�>zec. První slovo jsme převedli na číslo a ostatní slova jsme op�>t spojili mezerami do jednoho řet�>zce. Jeho délku potřebujeme pro vygenerování formátovacího řet�>zce pro metodu modulu struct.

Funkce formatujAdresu() vrací posloupnost bajtů, které zachycují binární vyjádření zadané adresy. Když už tedy máme potřebná binární data, podívejme se, jak je můžeme do binárního souboru zapsat a zase je zp�>t přečíst.

Čtení a zápis s využitím modulu struct

Vytvoříme si binární soubor, který bude obsahovat jediný řádek adresy převedený do binární podoby výše nadefinovanou funkcí formatujAdresu(). Soubor musíme otevřít pro zápis v binárním režimu ('wb'), zakódujeme data, zapíšeme je do souboru a ten následn�> uzavřeme. Vyzkoušejme si to:

import struct

f = file('adresa.bin','wb')
data = "10 Ulice, M�>sto, 0171 234 8765"
bindata = formatujAdresu(data)
f.write(bindata)
f.close()

Otevřením souboru adresa.bin v Poznámkovém bloku (notepad, případn�> v jiném editoru) si můžete ov�>řit, že data byla skutečn�> zapsána v binárním tvaru. Znaky adresy sice budou čitelné, ale neuvidíme zde žádné číslo 10.

Abychom adresu ze souboru op�>t přečetli, musíme jej otevřít v režimu 'rb', načíst data jako posloupnost bajtů, uzavřít soubor a nakonec data rozbalit metodou unpack() modulu struct. K tomu op�>t potřebujeme formátovací řet�>zec. Otázka zní, jak by m�>l vypadat? V našem případ�> víme, že musí být stejný jako ten, který jsme si připravili uvnitř funkce formatujAdresu() — konkrétn�> iNs, kde N musíme nahradit konkrétním číslem. Ale jak hodnotu N zjistíme?

V modulu struct najdeme také pomocné funkce, které vracejí velikost každého datového typu. Když si spustíme Python v interaktivním režimu, pak po pár pokusech zjistíme, kolik bajtů zabírají hodnoty různého datového typu:

>>> import struct
>>> print struct.calcsize('i')
4
>>> print struct.calcsize('s')
1

Takže teď už víme, že číslo zabere 4 bajty a každý znak řet�>zce zabere jeden bajt. To znamená, že N spočítáme jako délku dat mínus 4. Vyzkoušejme si načíst obsah našeho souboru:

import struct

f = file('adresa.bin','rb')
data = f.read()
f.close()

format = "i%ds" % (len(data) - 4)
cislo, zbytek = struct.unpack(format, data)
adresa = str(cislo) + ' ' + zbytek
print adresa

Co se týká binárních souborů je to vše, k čemu jsem se cht�>l vyjádřit. Jist�> jste si všimli, že používání binárních dat vede ke komplikacím. Pokud k tomu nemáte velmi dobrý důvod, pak uvedený přístup rozhodn�> nedoporučuji. Pokud ovšem skutečn�> potřebujete číst binární soubor, je to možné. V takovém případ�> ovšem musíte v�>d�>t, co data reprezentují.

Poznámka překladatele: V uvedeném příkladu předpokládáme, že pracujeme s řet�>zci, kde je každý znak uložen na jednom bajtu. Pokud bychom navíc potřebovali pracovat s Unicode řet�>zci, pak se při použitém kódování UTF-8 může počet bajtů pro uložení znaku m�>nit. Nov�>jší verze jazyka Python navíc podporují i celočíselný typ, kde hodnota tohoto typu může být v�>tší, než jakou můžeme zachytit na 4 bajtech. Pořadí ukládaných bajtů čísla se navíc řídí pravidly konkrétního výpočetního prostředí (little/big endian). Pokud tedy chceme zařídit přenositelnost takto vygenerovaných binárních souborů do na jiné systémy, musíme si pomoci explicitním uvedením dalších formátovacích značek, které předepíší konkrétní pořadí ukládání bajtů. V�>ci mohou být mnohem komplikovan�>jší, než se na první pohled zdá.