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.

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()

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. 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

def nactiObsah(zaznamnik):
    import os
    jmeno_souboru = 'adresy.dat'
    if os.path.exists(jmeno_souboru):
        soubor = open(jmeno_souboru,'r')
        while soubor:
            jmeno = soubor.readline().strip()
	    polozka = soubor.readline().strip()
            zaznamnik[jmeno] = polozka
    else:
        soubor = open(jmeno_souboru, 'w') # vytvoř nový prázdný soubor zbytečné
    soubor.close()

Povšimněte si, že znaky konců řádků budou odstraněny voláním strip().

Poznámka překladatele: Ve výše uvedeném kódu jsou závažné chyby — viz poznámka autora na konci této části.

Uložení obsahu záznamníku

def ulozObsah(zaznamnik):
    soubor = open('adresy.dat', '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á.