previous up next hi end end

6. Moduly a soubory

  1. Moduly
  2. Modul pydoc
  3. Jmenné prostory
  4. Atributy a tečkový operátor
  5. Čtení a zápis textových souborů
  6. Textové soubory
  7. Adresáře
  8. Modul sys a proměnná argv
  9. Glosář
  10. Cvičení

6.1 Moduly

Modul je soubor, obsahujicí definice a příkazy určené pro použití v jiných programech Pythonu. Mnohé moduly jsou standardní součástí Pythonu a jsou uloženy v jeho standardní knihovně. Dosud jsme poznali moduly math, doctest a string.

V následujícím odstavci se seznámíme s modulem pydoc.

6.2 Modul pydoc

Modul Pydoc použijeme k prohledávání knihoven Pythonu, instalovaných na počítači. Na příkazový řádek napíšeme:

$ pydoc -g

# případně ve Windows napíšeme:
> python -m pydoc -g
nebo z prostředí Pythonu:
>>> import pydoc
>>> pydoc.gui()
a mělo by se nám objevit ovládací okno "pydoc":

Stiskem tlačítka open browser otevřeme okno webového prohlížeče, které obsahuje dokumentaci, generovanou modulem pydoc:

Je to výčet všech knihoven Pythonu na vašem počítači. Klikem na jménu modulu otevřeme novou stránku s dokumentací o vybraném modulu. Například, klik na slovu keyword otevře následující stánku:

Dokumentace pro většinu modulů obsahuje tři barevně označené sektory:

Modul keyword obsahuje jedinou funkci iskeyword, která - jak její jméno naznačuje - je booleovskou funkcí, vracející True je-li zadaný řetězec klíčovým slovem:

>>> from keyword import *
>>> iskeyword('for')
True
>>> iskeyword('all')
False
>>>

Datový prvek kwlist obsahuje seznam všech současných klíčovych slov Pythonu:

>>> from keyword import *
>>> print(kwlist)
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 
'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 
'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 
'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield', 
'False', 'None', 'True']
>>>

Doporučujeme časté používání služby pydoc ke zkoumání rozsáhlých knihoven Pythonu. Mnoho pokladů čeká na své objevení!

6.3 Jmenné prostory

Jmenný prostor (namespace) je systémový kontejner, který umožňuje použití stejného jména v různých modulech nebo funkcích - a jak brzy uvidíme, také v třídách a metodách.

Každý modul vymezuje svůj vlastní jmenný prostor, takže stejné jméno můžeme použít v různých modulech aniž bychom vyvolali problém s jeho příslušností.

# module1.py
question = "What is the meaning of life and everything?"
answer = 42
# module2.py
question = "What is your quest?"
answer = "To seek the holy grail."

Můžeme nyní oba moduly (soubory ~.py) importovat a zajistit si v každém přístup k proměnným question a answer :

>>> import module1
>>> import module2
>>> print(module1.question)
What is the meaning of life and everything?
>>> print(module2.question)
What is your quest?
>>> print(module1.answer)
42
>>> print(module2.answer)
To seek the holy grail.
>>>

Kdybychom byli použili from module1 import* a from module2 import*, dospěli bychom k jmenné kolizi (naming collision) a neměli bychom přístup ke jménu question a answer z modulu module1.

Funkce mají také své jmenné prostory:

def f():
    n = 7     # lokální proměnná
    print("printing n inside of f: %d" % n)

def g():
    n = 42    # lokální proměnná
    print("printing n inside of g: %d"  % n)

n = 11        # globální proměnná
print("printing n before calling f: %d"  % n)
f()
print("printing n after calling f: %d"  % n)
g()
print("printing n after calling g: %d"  % n)

Běh tohoto programu vytvoří následující výstup:

printing n before calling f: 11
printing n inside of f: 7
printing n after calling f: 11
printing n inside of g: 42
printing n after calling g: 11

Ona tři n zde nezpůsobí kolizi, protože každé n je z jiného jmenného prostoru.

6.4 Atributy a tečkové operátory

Elementy, definované uvnitř modulu, se nazývají atributy modulu. Jsou dostupné s použitím tečkového operátoru. Atributy question modulu module1 a module2 jsou přístupné použitím skladby module1.question a module2.question.

Funkce uvnitř modulů jsou rovněž dostupné použitím tečkového operátoru. Zápis seqtools.remove_at() ukazuje na funkci remove_at v modulu seqtools.

V další kapitole o řetězcích se seznámíme s řadou vestavěných funkcí, které se evokují přes tečkový operátor, například:

>>> import string

>>> string.capwords("what's all this, then, amen?")
"What's All This, Then, Amen?"
>>>

6.5 Čtení a zápis textových souborů

Při běhu programu jsou data ukládána v prostoru RAM (náhodně přístupná paměť). Paměť RAM je rychlá a laciná, ale je také nestálá, čímž je míněno to, že když program skončí nebo se vypne počítač, obsah RAM se ztratí. Abychom měli data k disposici i při příštím spuštění počítače a programu, musíme je zapsat na stálejší záznamové medium, jako je pevný disk, USB nebo CD-RW.

Data na těchto trvalých nosičích jsou uložena v pojmenovaných souhrnech, zvaných soubory (files). Do těchto souborů mohou programy informace zapisovat a z nich je také načítat.

Práce se soubory je velmi podobná práci se sešitem. Před použitím sešitu jej musíme otevřít. Po ukončení práce jej musíme zavřít. Když je sešit otevřen, můžeme do něho psát, nebo z něho číst. V obou případech vždy víme na kterém místě sešitu se nalézáme. Sešit můžeme číst celý popořádku nebo napřeskáčku.

Totéž platí i pro soubory. Pro otevření souboru zadáme jeho jméno a udáme, zda chceme soubor číst nebo zapisovat.

Otevření souboru vytváří souborový objekt. V našem případě na tento objekt ukazuje proměnná myfile.

>>> myfile = open('test.dat', 'w')
>>> print(myfile)
<_io.TextIOWrapper name='test.dat' mode='w' encoding='cp1250'>

Funkce open přijímá dva argumenty. První je jméno souboru, druhý je mód zamýšlené činnosti. Mód 'w' říká, že otevíráme soubor pro zápis (write).

Neexistuje-li soubor se jménem test.dat, bude vytvořen. Jestliže takový soubor již existuje, bude nahrazen souborem, který píšeme.

Příkaz print vrátí jméno souboru, mód a jeho kódování.

Při vkládání dat do souboru vyvoláme metodu write souborového objektu:

>>> myfile.write("Now is the time")
>>> myfile.write("to close the file")

Zavření souboru říká systému, že jsme skončili zapisování a soubor je možné číst:

>>> myfile.close()

Nyní můžeme soubor opět otevřít, tentokrát pro čtení, a načíst obsah do řetězce v našem programu. Hodnotou parametru mód je 'r', od slova read (číst); tento argument je ale nepovinný:

>>> myfile = open('test.dat', 'r')

Pokusíme-li se otevřít soubor, který neexistuje, dostaneme chybové hlášení:

>>> myfile = open('test.cat', 'r')
FileNotFoundError: [Errno 2] No such file or directory: 'test.cat'

Nepřekvapí nás, že metoda read čte data ze souboru. Bez zadaných argumentů přečte celý obsah souboru do jediného řetězce:

>>> text = myfile.read()
>>> print(text)
Now is the timeto close the file

Mezi time a to není mezera, protože jsme ji mezi řetězce nenapsali.

Metoda read může také přijmout argument, který říká kolik znaků má být čteno:

>>> myfile = open('test.dat')
>>> print(myfile.read(5))
Now i

Zadáme-li číslo větší než je počet znaků v souboru, vrátí read jen zbývající znaky. Došlo-li se na konec souboru, vrátí read prázdný řetězec:

>>> print(myfile.read(1000006))
s the timeto close the file
>>> print(myfile.read())
   
>>>

Následující funkce kopíruje soubor tak, že přečte a zapíše nejvíce 50 znaků najednou. První argument je jméno originálního souboru, druhý argument je jméno nového souboru:

def copy_file(oldfile, newfile):
    infile = open(oldfile, 'r')
    outfile = open(newfile, 'w')
    while True:
        text = infile.read(50)
        if text == "":
            break
        outfile.write(text)
    infile.close()
    outfile.close()
    return

Tato funkce cyklicky čte 50 znaků z infile a zapisuje je do outfile až je dosaženo konce a text je prázdný řetězec, čímž se vyvolá provedení příkazu break.

6.6 Textové soubory

Textový soubor je soubor, který obsahuje tisknutelné znaky a mezery uspořádané do řádků, oddělených znaky pro nový řádek (newline characters). Protože Python je navržen zejména pro zpracování textových souborů, poskytuje metody, které tento úkol usnadňují.

Pro ukázku vytvoříme textový soubor se třemi řádky textu, oddělenými znaky newline:

>>> outfile = open("test.dat","w")
>>> outfile.write("line one\nline two\nline three\n")
>>> outfile.close()

Metoda readline přečte všechny znaky z prvního řádku včetně znaku newline:

>>> infile = open("test.dat","r")
>>> print(infile.readline())
line one
                  # znak \n vytvořil prázdný řádek   
>>>

Metoda readlines vrátí všechny zbyvající řádky jako seznam řetězců:

>>> print(infile.readlines())
['line two\012', 'line three\012']

Řetězce v seznamu jsou uvedeny v uvozovkách (či apostrofech) a znaky newline jsou tisknuty jako escape sequence: \\012.

Na konci souboru vrací readline prázdný řetězec a readlines prázdný seznam:

>>> print(infile.readline())
   
>>> print(infile.readlines())
[]

Následuje ukázka programu, který zpracovává řádky textu. Funkce filter vytvoří kopii oldfile, přičemž vypustí všechny řádky, které začínají znakem #:

def filter(oldfile, newfile):
    infile = open(oldfile, 'r')
    outfile = open(newfile, 'w')
    while True:
        text = infile.readline()
        if text == "":
            break
        if text[0] == '#':
            continue
        outfile.write(text)
    infile.close()
    outfile.close()
    return

Příkaz continue končí aktuální průchod smyčkou (iteraci), ale nekončí cyklování. Tok provádění se přesune na vrchol smyčky, přezkoumá podmínku a pokračuje příslušnou cestou.

Tedy, je-li text prázdný řetězec, smyčka končí. Je-li prvním znakem řetězce mřížka (#), tok provádění přechází na počátek smyčky. Pouze při nesplnění obou podmínek je text kopírován do nového souboru.

Jiný způsob iterace po řádcích otevřeného souboru poznáme v kapitole 14.

6.7 Adresáře

Soubory uložené na trvalých paměťových nosičích jsou uspořádány podle souboru pravidel, známého jako souborový systém (file system). Tento systém se skládá ze souborů a složek (folders) neboli adresářů (directories), což jsou kontejnery jak pro soubory, tak pro další složky.

Nově vytvořený soubor se po otevření a zápisu uloží do aktuálního adresáře (to jest do toho, ve kterém se nalézáme při provádění programu). Nebo naopak, otevíráme-li soubor pro čtení, hledá jej Python v aktuálním adresáři.

Chceme-li otevřít soubor někde jinde, musíme k němu určit cestu, například:

>>> wordsfile = open('/usr/share/dict/words.txt', 'r')
>>> wordlist = wordsfile.readlines()
>>> print(wordlist[:5])
['\n', 'A\n', "A's\n", 'AOL\n', "AOL's\n", 'Aachen\n']

Tento příklad otevírá soubor se jménem words.txt, který je uložený v adresáři se jménem dict jenž se nalézá v adresáři share, kterýžto je uložen v adresáři usr, jenžto sídlí v nejvyšším systémovém adresáři, označeném /. Program potom načítá jednotlivé řádky do seznamu se jménem wordlist s použitím metody readlines a posléze vytiskne prvních pět položek vytvořeného seznamu.

Znak / nelze použít jako součást jména souboru; je vyhrazen jako vymezovač mezi jmény adresářů a souborů.

Soubor /usr/share/dict/words.~ by měl existovat na unixových systémech a obsahovat abecedně uspořádaný seznam slov.

6.8 Modul sys a proměnná argv

Modul sys obsahuje funkce a proměnné, které poskytují přístup k prostředí operačního systému, ve kterém běží překladač Pythonu. Následující příklad ukazuje výstupní hodnoty několika příkazů, zadaných na některém z našich počítačů:

>>> import sys
>>> sys.platform
'linux2'
>>> sys.path
['', '/home/jelkner/lib/python', '/usr/lib/python25.zip', 
'/usr/lib/python2.5', '/usr/lib/python2.5/plat-linux2', 
'/usr/lib/python2.5/lib-tk', '/usr/lib/python2.5/lib-dynload',
'/usr/local/lib/python2.5/site-packages',
'/usr/lib/python2.5/site-packages',
'/usr/lib/python2.5/site-packages/Numeric',
'/usr/lib/python2.5/site-packages/gst-0.10',
'/var/lib/python-support/python2.5',
'/usr/lib/python2.5/site-packages/gtk-2.0',
'/var/lib/python-support/python2.5/gtk-2.0']
>>> sys.version
'2.5.1 (r251:54863, Mar  7 2008, 04:10:12)
\n[GCC 4.1.3 20070929 (prerelease)
(Ubuntu 4.1.2-16ubuntu2)]'
>>> 

Na jiném počítači může být výsledek odlišný:

>>> import sys
>>> sys.platform
'win32'
>>> sys.path
[''
'C:\\WINDOWS\\system32\\python33.zip',
 'C:\\Python33\\Lib',
 'C:\\Python33\\DLLs',
 'C:\\Python33',
 'C:\\Python33\\lib\\site-packages']
>>> 

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

>>> dir(sys)

Proměnná argv obsahuje seznam řetězců, načtených z příkazového řádku při spuštění skriptu. Tyto argumenty příkazového řádku mohou být použity k zadání informace pro program ve stejném okamžiku, kdy je tento program invokován.

Vytvoříme-li například skript demo_argv.py

#
# demo_argv.py
#
import sys

print(sys.argv)

Spustíme jej z příkazového řádku zároveň s argumenty (viz), obdržíme:

$ python demo_argv.py this and that 1 2 3
['demo_argv.py', 'this', 'and', 'that', '1', '2', '3']

Proměnná argv je seznam řetězců se jménem souboru na prvém místě. Argumenty jsou odděleny mezerou a uspořádány do seznamu stejným způsobem jako při operaci "str".split. Chceme-li zadat argumenty s uskupením, použijeme uvozovky:

$ python demo_argv.py "this and" that "1 2" 3
['demo_argv.py', 'this and', 'that', '1 2', '3']

Pomocí argv můžeme psát užitečné programy, které přijímají vstupy přímo z příkazového řádku. Zde je například program, který určí součet zadané řady čísel:

#
# sum.py
#
from sys import argv

nums = argv[1:]

for index, value in enumerate(nums):
    nums[index] = float(value)

print(sum(nums))

V tomto programu používáme způsob importu from <module> import <attribute>, při kterém je proměnná argv přenesena do hlavního jmenného prostoru modulu.

Nyní můžeme spouštět program z příkazové řádky takto:

$ python sum.py 3 4 5 11
23.0

# případně:
> python sum.py 3.5 5 11 100
119.5

6.9 Glosář

modul (module)
Soubor obsahující definice a příkazy Pythonu určené pro použití v jiných pythonovských programech. Obsah modulu je zpřístupněn použitím příkazu import .
standardní knihovna (standard library)
Knihovna je kolekce programů, používaných jako nástroje při vytváření jiných programů. Knihovny jsou nedílnou součástí programovacích jazyků. Python má bohatou standardní knihovnu.
pydoc
Generátor dokumentace, který je součástí standardní knihovny Pythonu.
výzva k zadání příkazu (command prompt)
Řetězec, zobrazený v konzole (command line interface, CLI), naznačující že má být zadán příkaz.
příkaz k importu (import statement)
Příkaz, který zpřístupní objekty ze zadaného modulu. Jsou tři formy tohoto příkazu (jméno mymod je fiktivní):
import mymod
importuje celý modul mymod,
from mymod import *
importuje vše z modulu mymod,
from mymod import f1, v1
importuje z modulu mymod jen objekt f1 a v1.
jmenný prostor (namespace)
Syntaktický kontejner, který umožňuje aby totéž jméno mohlo být součástí různých jmenných prostor bez víceznačností. Jmenné prostory v Pythonu se tvoří pro moduly, třídy, funkce a metody.
jmenná kolize (naming collision)
Situace, při které nelze od sebe rozlišit dvě nebo více jmen v daném jmenném prostoru. Použítím
import string
# a posléze s použitím tečkové notace
string.method_name() 
místo
from string import *
zabráníme jmenné kolizi.
atribut (attribute)
Proměnná či funkce, která je definovaná uvnitř modulu (nebo třídy či instance, jak uvidíme později). Atributy modulů jsou přistupné s použitím tečkového operátoru (.).
metoda (method)
Funkce, definovaná uvnitř třídy. Metody se pro objekt evokují s použitím tečkového operátoru, například:
>>> s = "this is a string"
>>> s.upper()
'THIS IS A STRING'
>>>

Říkáme, že metoda upper je volána pro řetězec s.

nestálá paměť (volatile memory)
Paměť, která k zachování stavu potřebuje stálý příkon elektrické energie. Hlavní paměť počítače, neboli RAM je nestálá. Informace, uložená v paměti RAM se ztratí při vypnutí počítače.
trvalá paměť (non-volatile memory)
Paměť, která svůj stav udržuje bez elektrické energie. Pevné disky, měnitelné disky a přepisovatelné kompaktní disky (CD-RW) jsou příklady nosičů s trvalou pamětí.
soubor (file)
Pojmenovaná entita, uložená na nosiči s trvalou pamětí, která obsahuje proud znaků.
mód (mode)
Určitý způsob operace v počítačovém programu. Soubory v Pythonu mohou být otevřeny v jednom ze tří módů: číst~read ('r'), psát~write ('w'), připojit~append ('a').
textový soubor (text file)
Soubor, který obsahuje tisknutelné znaky uspořádané do řádků oddělených znaky newline.
adresář či složka (directory or folder)
Pojmenovaná kolekce souborů či dalších adresářů. Adresáře uvnitř adresářů jsou označovány jako podadresáře (subdirectories).
argument příkazové řádky (command line argument)
Hodnota zadaná programu společně s jeho invokací z příkazové řádky (CLI).
argv
Zkratka pro argument vector a proměnná modulu sys, do které se uloží argumenty příkazového řádku, použité později při běhu programu.

6.10 Cvičení

  1. Proveďte následující:
    • Spusťte server pydoc příkazem & pydoc -g případně > python -m pydoc -g z příkazového řádku.
    • Stiskněte tlačítko open browser v okně pydoc tk.
    • Vyberte modul calendar.
    • Ze sektoru Funkctions vyberte a vyzkoušejte:
      >>> import calendar
      >>> year = calendar.calendar(2008)
      >>> print(year)  # What happens here?
      
    • Experimentujte s funkcí calendar.isleap(?). Co očekává jako argument? Co vrací jako výsledek? O jaký druh funkce se jedná?
    Zapište si poznatky, získané z tohoto cvičení.
  2. Alternativně se lze k webové stránce s nápovědou Pydoc dostat bez pomocného okna Tkinteru přímo:

    > python -m pydoc -p 7464
    

    To aktivuje webový server pydoc na portu 7464 (a příkazový řádek v konzole vám "zamrzne").
    Nyní nasměrujte svůj webový prohlížeč na:

    http://localhost:7464
    

    a budete si moci prohlížet knihovny Pythonu instalované na svém pořítači.
    Zamrzlý řádek v konzole "rozmrazíte" tím, že konzolu zavřete. Přístup přes pomocné okno Tkinteru (tkinteru) je lepší.

    Použijte tento postup ke spuštění pydoc a vyhledejte modul math.

    1. Kolik funkcí je v modulu math?
    2. Co dělá math.ceil? A co dělá math.floor? (nápověda: jak floor tak ceil očekávají argument v plovoucí čárce.)
    3. Popište, jak jsme počítali stejnou hodnotu jako math.sqrt bez použití modulu math.
    4. Jaké jsou dvě datové konstanty v modulu math?

    Dělejte si podrobné poznámky o svém zkoumání v tomto cvičení.

  3. Použijte pydoc k prozkoumání modulu copy. Co dělá deepcopy? Ve kterém cvičení z předchozí kapitoly by se nám deepcopy hodila?
  4. Vytvořte modul mymodule1.py. Přidejte atribut myage se zadaným vlastním věkem a year se zadaným současným letopočtem. Vytvořte další modul mymodule2.py. Přidejte atribut myage s nastavenou nulou a year s rokem svého narození.

    Nyní vytvořte soubor namespace_test.py. Importujte oba výše uvedené moduly a napište následující příkaz:
    print((mymodule2.myage - mymodule1.myage) 
                    == (mymodule2.year - mymodule1.year))
    

    Spustíte-li namespace_test.py, dostanete jako výstup buď True nebo False podle toho, zda jste letos již narozeniny měl nebo neměl.

  5. Do modulů mymodule1.pymymodule2.py a namespace_test.py přidejte následující příkaz:
    print("My name is %s" % __name__)
    
    Spusťte namespace_test.py. Co se stane? Proč? Nyní přidejte následující kód na konec mymodule1.py:
    if __name__ == '__main__':
        print("This won't run if I'm  imported.")
    
    Opět spusťte mymodule1.py a namespace_test.py. Ve kterém případě vidíte nový příkaz k tisku?
  6. V prostředí IPP si vykoušejte následující:
    >>> import this
    
    Co říká Tim Peter o jmenných prostorech?
  7. Použijte pydoc k vyhledání a vyzkoušení tří dalších funkcí z modulu string. Zapište si své poznatky.
  8. Přepište matrix_mult z předchozí kapitoly s využitím znalostí o metodách na seznamech.
  9. Funkce dir, kterou jsme poznali v kapitole 7, vytiskne seznam atributů objektu zadaného jako argument. Jinými slovy, dir vrátí obsah jmenného prostoru argumentu.

    Použijte dir(str) a dir(list) k nalezení nejméně tří metod na řetězci a seznamu, které nebyly dosud uvedeny. Prozatím ignorujte všechno, co začíná dvojitým podtržítkem (__). Pečlivě si zapisujte své poznatky včetně jmen nových metod a příkladů jejich použití.

    (nápověda: Vytiskněte si dokumentační řetězec funkce, kteru chcete zkoumat. Například, abychom zjistili, jak pracuje str.join, zadáme příkaz print(str.join.__doc__))

  10. V jedné seanci IPP vyvolejte odezvy k následujícím příkazům:
    1. >>> s = "If we took the bones out,
               it wouldn't be crunchy, would it?"
      >>> s.split()
      
    2. >>> type(s.split())
      
    3. >>> s.split('o')
      
    4. >>> s.split('i')
      
    5. >>> '0'.join(s.split('o'))
      
    Je důležité, abyte každému výsledku porozuměl. Získané poznatky použijte při doplnění následující funkce s použitím metod split a join na objektech str:
    def myreplace(old, new, s ):
        """
        Nahraď všechny argumenty 'old' argumenty 'new'
        v řetězci 's'.
    
        >>> myreplace(',', ';', 'this, that, and, some, other, thing')
        'this; that; and; some; other; thing'
    	
        >>> myreplace(' ', '**', 'Words will now be separated by stars.')
        'Words**will**now**be**seperated**by**stars.'
        """
    
    Vaše řešení má projít oběma doctesty.
  11. Vytvořte modul wordtools.py s následujcím ukončením:
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
    Vysvětlete jak tento příkaz usnadňuje užití a testování vytvořeného modulu. Jaká bude hodnota __name__ při importu wordtools.py z jiného modulu? A jaká bude při spuštění wordtools.py jako hlavního programu? Ve kterém případě budou aktivovány doctesty?

    Nyní přidejte těla ke každé z následujících funkcí tak, aby bylo vyhověno doctestům:
    def cleanword(word):
        """
        >>> cleanword('what?')
        'what'
        >>> cleanword('"now!"')
        'now'
        >>> cleanword('?+="word!,@$()"')
        'word'
        """
    
    def has_dashdash(s):
        """
        >>> has_dashdash('distance--but')
        True
        >>> has_dashdash('several')
        False
        >>> has_dashdash('critters')
        False
        >>> has_dashdash('spoke--fancy')
        True
        >>> has_dashdash('yo-yo')
        False
        """
    
    def extract_words(s): """ >>> extract_words('Now is the time!"Now", is the time? Yes, now.') ['now', 'is', 'the', 'time', 'now', 'is', 'the', 'time', 'yes', 'now'] >>> extract_words('she tried to curtsey as she spoke--fancy') ['she', 'tried', 'to', 'curtsey', 'as', 'she', 'spoke', 'fancy'] """
    def wordcount(word, wordlist): """ >>> wordcount('now', ['now', 'is', 'time', 'is', 'now', 'is', 'is']) ['now', 2] >>> wordcount('is', ['now', 'is', 'time', 'is', 'now', 'is', 'the', 'is']) ['is', 4] >>> wordcount('time', ['now', 'is', 'time', 'is', 'now', 'is', 'is']) ['time', 1] >>> wordcount('frog', ['now', 'is', 'time', 'is', 'now', 'is', 'is']) ['frog', 0] """
    def wordset(wordlist): """ >>> wordset(['now', 'is', 'time', 'is', 'now', 'is', 'is']) ['is', 'now', 'time'] >>> wordset(['I', 'a', 'a', 'is', 'a', 'is', 'I', 'am']) ['I', 'a', 'am', 'is'] >>> wordset(['or', 'a', 'am', 'is', 'are', 'be', 'but', 'am']) ['a', 'am', 'are', 'be', 'but', 'is', 'or'] """
    def longestword(wordset): """ >>> longestword(['a', 'apple', 'pear', 'grape']) 5 >>> longestword(['a', 'am', 'I', 'be']) 2 >>> longestword(['this', 'that', 'supercalifragilisticexpialidocious']) 34 """
    Modul si uložte pro použití jeho procedur v jiných programech.

  12. Soubor unsorted_fruits.txt obsahuje seznam 26 druhů ovoce, přičemž každé jméno začíná jiným písmenem abecedy.

    Napište program sort_fruits.py, který načte ovoce z unsorted_fruits.txt a zapíše je v abecedním pořádku do sorted_fruits.txt.

  13. Odpovězte na následující otázky, týkající se countletters.py:
    1. Podrobně vysvětlete činnost následujících tří řádků:
      infile = open('alice_in_wonderland.txt', 'r')
      text = infile.read()
      infile.close()
      
      Co vrátí příkaz type(text) po provedení oněch tří řádků?
    2. Jaký bude výsledek výrazu 128 * [0]? Najděte si ASCII ve Wikipedii a vysvětlete proč si myslíte, že proměnná counts je přiřazena k 128 * [0].
    3. Co učiní
      for letter in text:
          counts[ord(letter)] += 1
      
      s proměnnou   counts?
    4. Vysvětlete účel funkce display. Proč kontroluje hodnoty 10, 13, a 32? Co je na nich zvláštního?
    5. Popište podrobně, co dělají řádky:
      outfile = open('alice_counts.dat', 'w')
      outfile.write("%-12s%s\n" % ("Character", "Count"))
      outfile.write("=================\n")
      
      Co bude obsahovat alice_counts.dat po jejich provedení?
    6. Konečně, vysvětlete podrobně co dělá:
      for i in range(len(counts)):
          if counts[i]:
              outfile.write("%-12s%d\n" % (display(i), counts[i]))
      
      Jaký je účel if counts[i]?
  14. Napište program alice_words.py, který vytvoří textový soubor alice_words.txt obsahující abecedně uspořádaný výpis slov z alice_in_wonderland.txt spolu s počtem výskytů každého slova. Prvních 10 řádek tvého výstupu by mohlo vypadat nějak takto:
    Word              Count
    =======================
    a                 631
    a-piece           1
    abide             1
    able              1
    about             94
    above             3
    absence           1
    absurd            2
    
    Kolikrát se v knize objeví slovo alice?
  15. Které je nejdelší slovo v Alice in Wonderland? Kolik má písmen?
  16. Napište program mean.py, který na příkazovém řádku přijme číselné pořadí a vrátí jeho střední hodnotu.
    $ python mean.py 3 4
    3.5
    $ python mean.py 3 4 5
    4.0
    $ python mean.py 11 15 94.5 22
    35.625
    
    Vztah mezi vstupy a výstupy u vašeho programu by měl být stejný jako v uvedené ukázce.
  17. Napište program median.py který na příkazovém řádku přijme číselné pořadí a vrátí jeho prostřední hodnotu.
    $ python median.py 3 7 11
    7
    $ python median.py 19 85 121
    85
    $ python median.py 11 15 16 22
    15.5
    
  18. Upravte program countletters.py tak, že jméno otevíraného souboru bude přijato jako argument z příkazového řádku. Jak ošetříte pojmenování výstupního souboru?

previous up next hi end end