previous up next hi end end

7. Řetězce

  1. Složený datový typ
  2. Délka
  3. Úseky řetězce
  4. Řetězce jsou neměnitelné
  5. Operace s řetězci
  6. Modul 'string'
  7. Řetězce a smyčka 'for'
  8. Příkaz smyčky 'break'
  9. Příkaz smyčky 'continue'
  10. Operátor 'in'
  11. Počítání písmen
  12. Porovnávání řetězců
  13. Vyhodnocení znaků
  14. Funkce 'find'
  15. Formátování řetězce I
  16. Formátování řetězce II
  17. Glosář
  18. Cvičení

7.1 Složený datový typ

Až dosud jsme poznali pět typů dat: int, float, bool, NoneType a str . Řetězce (strings) jsou kvalitativně odlišné od ostatních čtyř typů, protože se skládají z menších částic - alfanumerických znaků.

Typy, které se skládají z menších částic, se nazývají složené datové typy, neboli kontejnery či také kolektory. Se složeným datovým typem můžeme chtít zacházet jako s jednou věcí, nebo můžeme chtít mít přístup k jeho částem.

Pořadí znaku v řetězci je indexováno, neboli označováno číselnou řadou, která začíná nulou. Hranaté závorky slouží jako operátor, který vybere určené znaky z řetězce:

>>> fruit = "banana"
>>> letter = fruit[1]
>>> print(letter)
a

Výraz fruit[1] vybere z řetězce fruit znak, odpovídající indexu 1. Proměnná letter se vztahuje k výsledku.

Chceme-li první písmeno řetězce, zadáme 0 nebo jakýkoliv výraz s hodnotou 0 do hranatých závorek:

>>> letter = fruit[False]
>>> print(letter)
b

Výrazu v hranatých závorkách se říká index. Může jím být jakýkoliv celočíselný výraz.


7.2 Délka

Funkce len vrací počet znaků v řetězci:

>>> fruit = "banana"
>>> len(fruit)
6

Ve snaze získat poslední písmeno řetězce bychom mohli být v pokušení zkusit něco jako:

length = len(fruit)
last = fruit[length]       # chyba!

Toto nepůjde. Způsobí to chybu při běhu programu IndexError: string index out or range (index řetězce mimo rozsah). Důvod je ten, že ve slově banana není "6-té" písmeno. Protože jsme začali počítat od nuly, je šest písmen očíslováno od 0 do 5. Abychom dostali poslední znak, musíme od length odečíst 1:

length = len(fruit)
last = fruit[length-1]

Alternativně můžeme použít záporné indexy, které počítají od konce řetězce. Výraz fruit[-1] poskytne poslední písmeno, fruit[-2] předposlední, a tak dále.

7.3 Úseky řetězce

Část řetězce se nazývá úsek (slice). Výběr úseku je podobný jako výběr znaku:

>>> s = "Peter, Paul, and Mary"
>>> print(s[0:5] )
Peter
>>> print(s[7:11])
Paul
>>> print(s[17:21])
Mary

Operátor [n:m] vrací část řetězce od n-tého znaku včetně po znak před m-tým. Toto chování se příčí intuitivnímu přístupu; bude mít větší smysl, když si představíme, že indicie ukazují před jednotlivé znaky, viz obrázek:

Vynecháme-li první index (před dvojtečkou), začíná úsek na počátku řetězce. Vynecháme-li druhý index, úsek jde až ke konci řetězce. Takže:

>>> fruit = "banana"
>>> fruit[:3]
'ban'
>>> fruit[3:]
'ana'

Co asi znamená s[:]?

7.4 Řetězce jsou neměnitelné

Může být lákavé použít operátor [] na levé straně přiřazení se záměrem změnit znak v řetězci. Na příklad:

greeting = "Hello, world!"
greeting[0] ='J'        # chyba!
print(greeting)

Místo výstupu Jello, world!, tento kód způsobí chybu při běhu programu: TypeError: 'str' object doesn´t support item assignment.

Řetězce jsou neměnitelné, což znamená, že existující řetězec nelze změnit. Nejlepší věc, kterou lze udělat, je vytvořit nový řetězec, který je variací původního:

greeting = "Hello, world!"
new_greeting = 'J' + greeting[1:]
print(new_greeting)

Řešením je zřetězení nového prvního písmena s úsekem řetězce greeting. Tato operace nemá žádný vliv na původní řetězec.

7.5 Operace s řetězci

Společné operace pro řetězce i seznamy

Pro manipulaci s řetězci (i seznamy) je k disposici řada vestavěných funkcí a metod:

Obecně vzato, na řetězcích nelze provádět matematické operace, i když vypadají jako čísla. Následující výrazy nejsou přípustné (za předpokladu, že message je typu řetězec):

message - 1   "Hello"/123   message* "Hello"   "15" + 2

Kupodivu, operátor + s řetězci umí pracovat, i když jinak, než bychom očekávali. Pro řetězce (i seznamy) představuje operátor + příkaz zřetězení (concatenation), což je spojení dvou operandů jejich připojením těsně k sobě. Například:

fruit = "banana" 
bakedGood = " nut bread"
print(fruit + bakedGood)

Výstupem tohoto programu je banana nut bread. Mezera před slovem nut je součástí řetězce nut bread.

Operátor * rovněž pracuje s řetězci i seznamy, provádí opakování. Například, 'Fun' *3 je 'FunFunFun'. Jeden z operandů musí být řetězec, druhým operandem musí být celé číslo.

Volně přístupné metody pro řetězce

Kromě společných procedur pro řetězce a seznamy existuje také velké množství vestavěných metod, specielně určených pro řetězce, které většinou evokujeme formátem  str.metoda()

 
 capitalize, casefold, center, count, encode, endswith, expandtabs,
 find, format, format_map, index, isalnum, isalpha, isdecimal,
 isdigit, isidentifier, islower, isnumeric, isprintable, isspace,
 istitle, isupper, join, ljust, lower, lstrip, maketrans, partition,
 replace, rfind, rindex, rjust, rpartition, rsplit, rstrip,
 split, splitlines, startswith, strip, swapcase, title, translate,
 upper, zfill

V prostředí PyScripter se tyto termíny zobrazují jako nápověda včetně požadované skladby a stručného popisu:

pic

Zde je překlad žluté cedulky:

S.find(sub [,start [,end]]) -> int

  "Vrátí nejnižší index místa výskytu sub s tím, 
  že sub je obsažen 
  uvnitř úseku S[start, end]."

  Return -1 on failure.

Parametry v hranatých závorkách jsou nepovinné.


7.6 Modul 'string'

Modul string obsahuje další užitečné objekty pro manipulaci s řetězci. Jako obvykle, modul musíme importovat dřív než jej použijeme:

>>> import  string

Obsah modulu zjistíme vestavěnou fcí dir se jménem modulu jako argument:

>>> dir(string)
čímž dostaneme seznam atributů a specielních metod:

['ChainMap','Formatter','Template','_TemplateMetaclass', '__builtins__','__cached__','__doc__','__file__','__initializing__', '__loader__','__name__','__package__','_re','_string','ascii_letters', 'ascii_lowercase','ascii_uppercase','capwords','digits','hexdigits', 'octdigits','printable','punctuation','whitespace']

Krátké vysvětlení uvedených položek získáme voláním specielní metody __doc__ :

>>> string.__doc__
'A collection of string constants.\n\nPublic module variables:
\n\nwhitespace -- a string containing all ASCII whitespace ...

Udělejte si průzkum a sami si zjistěte, co jednotlivé atributy vracejí. Metoda digits například vrací všechny numerické znaky:

>>> string.digits
0123456789

Další konstanta z modulu string nás možná překvapí, když ji vytiskneme:

>>> string.whitespace
' \t\n\r\x0b\x0c'

Znaky whitespace posouvají kurzor, aniž by se cokoli tisklo. Vytvářejí prázdné místo mezi viditelnými znaky.


7.7 Řetězce a smyčka 'for'

Mnohé výpočty zahrnují probírání znaků v řetězci postupně jeden za druhým. Počínaje prvním, s každým něco provedou, končí posledním. Tento způsob pojednání se jmenuje traverzování . Možný zápis tohoto postupu je pomocí příkazu while:

index = 0
while index < len(fruit):
    letter = fruit[index]
    print(letter)
    index = index + 1

Tato smyčka prochází řetězcem a zobrazí každé písmeno na samostatném řádku. Podmínka smyčky je index < len(fruit), takže když je index roven délce řetězce, je podmínka nepravdivá a tělo smyčky se neprovede. Poslední procházený znak je s indexem len(fruit)-1, což je poslední znak řetězce.

Použití indexu k traverzování sady hodnot je tak běžné, že Python poskytuje alternativu - jednodušší smyčku for:

for char in fruit:
    print(char)

V každém cyklu smyčky se přiřadí jeden znak našeho řetězce proměnné char. Smyčka projde postupně všemi znaky.

Zákulisí smyčky for si přiblížíme v kapitole 13.5

Následující příklad ukazuje použití zřetězení (concatenation) a smyčku for pro tvorbu abecedních řad. Abecedním je míněno uspořádání prvků řady či seznamu podle abecedy. Například, v knize Roberta McCloskeyho: Uvolněte cestu pro káčata se kachňata jmenují: Jack, Kack, Lack, Mack, Nack, Ouack, Pack a Quack. Tato smyčka vydá jejich jména v pořadí:

prefixes = "JKLMNOPQ"
suffix = "ack"

for letter in prefixes:     print(letter + suffix)

Výstup programu je tento:

Jack
Kack
Lack
Mack
Nack
Oack
Pack
Qack

V pořádku to úplně není, protože Ouack a Quack nejsou zapsáni správně. Tuto chybu napravíme v rámci cvičení.

7.8 Příkaz smyčky 'break'

Příkaz break ukončí provádění smyčky a výpočet pokračuje dalším příkazem za blokem smyčky. Tento příkaz lze použít u smyček while i for:

for letter in "Python":
    if letter == "h":
        break
    print("Current Letter: ", letter)

nebo:

var = 8
while var > 0:
    print("Current var. value: ", var)
    var = var - 1	
    if var == 5:
        break
print("Adieu!")

Výstup z obou kódů je tento:

>>> 
Current Letter : P
Current Letter : y
Current Letter : t

Current var. value:  8
Current var. value:  7
Current var. value:  6
Adieu!
>>> 

7.9 Příkaz smyčky 'continue'

Příkaz continue přeruší provádění smyčky a výpočet pokračuje dalším cyklem smyčky. Tento příkaz lze použít u smyček while i for:

for letter in "Python":
    if letter == "h":
        continue
    print("Current Letter: ", letter)	

nebo:

var = 6
while var > 0:
    var = var - 1	
    if var == 3:
        continue
    print("Current var. value: ", var)
print("Adieu!")

Výstup z obou kódů je tento:

>>> 
Current Letter:  P
Current Letter:  y
Current Letter:  t
Current Letter:  o
Current Letter:  n

Current var. value:  5
Current var. value:  4
Current var. value:  2
Current var. value:  1
Current var. value:  0
Adieu!
>>> 

7.10 Operátor 'in'

Operátor in přezkoumá, zda je zadaný řetězec součástí jiného:

>>> 'p' in 'apple'
True
>>> 'i' in 'apple'
False
>>> 'ap' in 'apple'
True
>>> 'pa' in 'apple'
False
Všimněmež si, že řetězec může byt součástí sebe sama:
>>> 'a' in 'a'
True
>>> 'apple' in 'apple'
True

Použitím operátoru in a zřetězení můžeme napsat funkci, která odstraní všechny samohlásky z řetězce:

def remove_vowels(s):
    samohl = "aeiouyAEIOUY" 
    s_bez_samohl = ""
    for letter in s:
        if letter not in samohl:
            s_bez_samohl += letter
    return s_bez_samohl           

Ověřme si, že funkce dělá to co jsme chtěli

7.11 Počítání písmen

Funkce ord vrací číselnou presentaci písmene:

>>> ord('a')
97
>>> ord('A')
65
>>>

Tento příklad vysvětluje, proč se 'Apple' < 'apple' vyhodnotí jako True.

Funkce chr je inverzní k fci ord. Přijme jako argument celé číslo a vrátí jeho písmennou presentaci:

>>> for i in range(65, 71):
...     print(chr(i))
...
A
B
C
D
E
F
>>>

Následující program počítá kolikrát se písmeno a vyskytne v řetězci a je dalším příkladem počítadla, uvedeného v kapitole 6:

fruit = "banana"
count = 0
for char in fruit:
    if char == 'a':
        count += 1
print(count)

Je hezké, že si všechno chceme dělat sami. Kdo si ale vzpomene, může použít vestavěnou metodu:

>>> fruit.count("a")
3

Následující program countletters.py počítá množství výskytů jednotlivých písmen v knize Alice in Wonderland (Alenka v říši divů):

#
# countletters.py
#

def display(i):
    if i == 10: return 'LF'
    if i == 13: return 'CR'
    if i == 32: return 'SPACE'
    return chr(i)

infile = open('alice_in_wonderland.txt', 'r')
text = infile.read()
infile.close()

counts = 128 * [0]

for letter in text:
    counts[ord(letter)] += 1

outfile = open('alice_counts.dat', 'w')
outfile.write("%-12s%s\n" % ("Character", "Count"))
outfile.write("=================\n")

for i in range(len(counts)):
    if counts[i]:
        outfile.write("%-12s%d\n" % (display(i), counts[i]))

outfile.close()

Spusťte si tento program a prohlédněte si generovaný výstupní soubor v textovém editoru.

7.12 Porovnávání řetězců

Porovnávací (relační) operátory pracují také s řetězci. Rovnost řetězců zjistíme:

if word == "banana":
    print ("Yes, we have bananas!"

Jiné relační operátory jsou užitečné při uspořádávání slov podle abecedy:

if word < "banana":
    print("Your word," + word + ", comes before banana.")
elif word > "banana":
    print("Your word," + word + ", comes after banana.")
else:
    print("Maybe, we have bananas!")

Musíme si však být vědomi toho, že Python zachází s malými a velkými písmeny jinak, než jsme zvyklí. Všechna velká písmena řadí před všechna malá. V důsledku toho:

Your word, Zebra, comes before banana.

Obvyklý způsob řešení tohoto problému je přeměna řetězce do standardního formátu (např. všechna písmena malá) před prováděním porovnávání. Svízelnější problém je přinutit program, aby si uvědomil, že zebry nejsou ovoce.

7.13 Vyhodnocení znaků

Často bývá potřebné otestovat jednotlivý znak a zjistit, zda je to velké či malé písmeno, nebo zda to je číslice. Modul string poskytuje několik konstant, které jsou pro tyto účely vhodné.

Atribut string.ascii_lowercase obsahuje všechna písmena, která systém řadí mezi malá. Podobně string.ascii_uppercase obsahuje všechna velká písmena. Vyzkoušejme si následující příkazy a uvidíme, co dostanete:

print(string.ascii_lowercase)
print(string.ascii_uppercase)

Tyto konstanty a metodu find můžeme použit k vyhodnocení znaků. Vrátí-li například find(string.lowercase,ch) hodnotu jinou než -1, pak ch musí být malé písmeno:

def is_lower(ch):
    return string.ascii_lowercase.find(ch) != -1

Případně můžeme využít operátoru in, který určí, zda se znak nachází v řetězci:

def is_lower(ch):
    return ch in string.ascii_lowercase

Nutno si uvědomit, že funkce neodpovídají na otázku, zda zkoumané písmeno je velké či malé ale zda patří do sady ascii_lowercase, kde se písmeno "ch" nevyskytuje. Obě varianty funkce správně odpoví:

>>> is_lower("ch")
False

7.14 Funkce 'find'

Uživatelská varianta

def find(strng, ch):
    index = 0
    while index < len(strng):
        if strng[index] == ch:
            return index
        index += 1
    return -1

V jistém smyslu je funkce find opakem operátoru [ ]. Místo přijmutí indexu a vyjmutí odpovídajícího znaku z řetězce, find přijme znak a nalezne index místa, kde se znak nachází. Není-li znak nalezen, funkce vrací -1.

V této funkci se opět setkáváme s příkazem return uvnitř smyčky. Je-li str[index] == ch, je funkce ukončena předčasným přerušením smyčky.

Není-li znak v řetězci obsažen, potom program opustí smyčku normálně a vrátí -1.

Tento způsob výpočtu je někdy nazýván traverzování Heuréka, protože jakmile nalezneme co hledáme, můžeme zvolat „Heuréka” a skončit hledání.

Pro stanovení počátku pro hledání můžeme do funkce přidat třetí parametr:

def find1(strng, ch, start):
    index = start
    while index < len(strng):
        if strng[index] == ch:
            return index
        index += 1
    return -1
Volání find1("banana","a",2) nyní vrátí pozici prvního a za indexem 2.

Funkci si vylepšíme úpravou parametru start. Připojením hodnoty z něj učiníme paramter s počáteční hodnotu, který je volitelný v tom smyslu, že jej můžeme při volání případně vynechat:

def find2(strng, ch, start=0):
    index = start
    while index < len(strng):
        if strng[index] == ch:
            return index
        index += 1
    return -1
Výsledek volání find2("banana", "a", 2) bude stejný jako find1("banana", "a", 2), zatímco při volání find2("banana", "a") bude parametr start nastaven na počáteční hodnotu 0.

Přidáním dalšího volitelného parametru do fce find zajistíme prohledávání jak dopředu, tak dozadu:

def find3(strng, ch, start=0, step=1):
    index = start
    while 0 <= index < len(strng):
        if strng[index] == ch:
            return index
        index += step
    return -1
Zadání hodnoty -1 pro step způsobí zmenšování stavu počítadla. Pro tuto změnu bylo nutné ošetřit jak horní tak i dolní mez proměnné index.

Předdefinovaná varianta

Pokud se spokojíme s jednodušším servisem, můžeme opět použít vestavěnou metodu:

tanec = "Dokolečka dokola"
>>> tanec.find("č", 2, 12)
6
    # budeme-li méně vybíraví
>>> tanec.find("č")
6

Metoda "str".find je ve skutečnosti všestrannější než naše funkce. Umí nalézt i části řetězců, nejenom pouhé znaky:

>>> tanec.find("leč")
4

Jako naše funkce i tato metoda přijímá dodatečný argument, který určuje index u kterého má začít:

>>> tanec.find("kol", 4)
12

Odlišně od naší funkce, druhý nepovinný parametr metody určuje index, kde má hledání skončit:

>>> tanec.find("la", 1, 8)
-1

V tomto případě skončí hledání nezdarem, protože se substring la nevyskytuje v intervalu od 1 do 2 (nikoliv včetně).


7.15 Formátování řetězců I

Starší a v Pythonu 3.x stále použitelný způsob formátování řetězce je s použitím interpolačního operátoru % spolu s konverzními specifikacemi.

Konverzními specifikacemi jsou znaky, která zastupují zamýšlený formát vkládané hodnoty, například:

Schema formátování řetězce vypadá takto:

<FORMAT >  %  < ( VALUES ) >
Část FORMAT obsahuje kombinaci řetězců a konverzních specifikací. Následuje samotný interpolační operátor % a za ním výčet hodnot, doplňovaných za konverzní specifikace. Závorky jsou nepovinné, je-li hodnota pouze jedna.

Nejlépe si to ukážeme na několika příkladech:

>>> "Jmenuje se %s." % "Arthur"
'Jmenuje se Arthur.'
>>> name = "Alice"
>>> age = 10
>>> "I am %s and I am %d years old." % (name, age)
'I am Alice and I am 10 years old'
>>> n1 = 4
>>> n2 = 5
>>> "2**10 = %d and %d*%d = %f"  %  (2**10, n1, n2, n1*n2)
'2**10 = 1024 and 4*5 = 20.000000'
>>> 

V prvním uvedeném příkladě je jediná konverzní specifikace %s, která označuje řetězec. K ní se přiřazuje jediná hodnota "Arthur" a není uzavřena v závorkách.

Ve druhém příkladě má name hodnotu řetězce "Alice" a age má hodnotu celého čísla 10. Tyto se přiřazují ke dvěma konverzním specifikacím %s a %d; druhá specifikace je označením celého dekadického čísla.

Ve třetím příkladě mají proměnné n1 a n2 celočíselné hodnoty 4 a 5. Ve formátovaném řetězci jsou čtyři konverzní specifikace: tři %d a jedna %f. Písmeno f naznačuje, že příslušná hodnota má být ve tvaru čísla s plovoucí desetinnou čárkou. Čtyři hodnoty, které se vztahují k uvedeným čtyřem konverzním specifikacím jsou: 2**10,n1,n2 a n1*n2.

V následující ukázce vidíme povel k tisku bez formátování řetězce:

i = 1
print("i\ti**2\ti**3\ti**5\ti**10\ti**20")
while i <= 10:
   print(i,'\t',i**2,'\t',i**3,'\t',i**5,'\t',i**10,'\t',i**20)
   i += 1    

Tento program vytiskne tabulku různých mocnin čísel od 1 do 10. V uvedeném tvaru je rovnání výsledků do sloupců způsobené znakem tabelátoru (\t) které selhává jakmile hodnoty výsledků zaberou 8 míst:

i       i**2    i**3    i**5    i**10   i**20
1       1       1       1       1       1
2       4       8       32      1024    1048576
3       9       27      243     59049   3486784401
4       16      64      1024    1048576         1099511627776
5       25      125     3125    9765625         95367431640625
6       36      216     7776    60466176        3656158440062976
7       49      343     16807   282475249       79792266297612001
8       64      512     32768   1073741824      1152921504606846976
9       81      729     59049   3486784401      12157665459056928801
10      100     1000    100000  10000000000     100000000000000000000

Mohli bychom změnit šířku sloupce ale vidíme, že první sloupce již teď mají více místa než potřebují. Nejlepší bude určit šířku pro každý sloupec jednotlivě. Jak lze tušit, řešení poskytuje formátovaný řetězec :

i = 1 
print("%-4s%-5s%-6s%-8s%-13s%-15s" %
   ('i', 'i**2', 'i**3', 'i**5', 'i**10', 'i**20'))
while i <= 10:
   print("%-4d%-5d%-6d%-8d%-13d%-15d" % (i, i**2, i**3, i**5, i**10, i**20))
   i += 1    

Běh této verze dává následující výstup:

i   i**2 i**3  i**5    i**10        i**20          
1   1    1     1       1            1              
2   4    8     32      1024         1048576        
3   9    27    243     59049        3486784401     
4   16   64    1024    1048576      1099511627776  
5   25   125   3125    9765625      95367431640625 
6   36   216   7776    60466176     3656158440062976
7   49   343   16807   282475249    79792266297612001
8   64   512   32768   1073741824   1152921504606846976
9   81   729   59049   3486784401   12157665459056928801
10  100  1000  100000  10000000000  100000000000000000000

Pomlčka - za každou konverzní specifikací určuje zarovnání zleva. Číselné hodnoty určují minimální délku, takže %-13d je minimálně třináctimístné číslo zarovnané zleva.


7.16 Formátování řetězců II

Nový způsob formátování výstupu je pomocí metody .format() v sestavě "formátovaný_řetězec_s_výměnnými_poli" . format().

Výměnná pole jsou instrukce, uzavřené ve složených závorkách { }. Vše, co je mimo těchto závorek, je považováno za text, který je v nezměněném stavu kopírován do výstupu.

Pro popis skladby výměnného pole se domluvme, že hranatými závorkami označíme údaj, který může chybět.

Skladbu výměnného pole tedy vyjádříme schematicky takto:

{ [field_name] [!conversion] [:format_spec] }

Pozorný čtenář si již stačil všimnout, že nejjednodušší možná forma výměnného pole jsou prázdné složené závorky { }.

Sektor  field_name
je buď číslo, nebo klíčové slovo. Číslo odkazuje na poziční argument, klíčové slovo na pojmenovaný argument metody .format(). Tvoří-li čísla řadu 0, 1, 2, ..., lze je vynechat.

Více než slova řekne ukázka:

>>> "Od {} do {}" .format("rána", 22.00)
'Od rána do 22.0'  # totéž jako "Od {0} do {1}"
>>> "Jmenuji se {name}" .format(name = "Pavel")
'Jmenuji se Pavel'

Sektor  !conversion
způsobí změnu typu před formátováním. Používá se značení
!s, které volá funkci str(), jež vrací objekt coby řetězec
!r, které volá funkci repr(), jež vrací řetězec obsahující tisknutelnou prezentaci objektu
!a, které volá funkci ascii(), jež vrací řetězec obsahující tisknutelnou prezentaci objektu, avšak...

Ukázka přiblíží způsob použití:

>>> "Harold je chytrý {0!s}" .format("chlapec")
'Harold je chytrý chlapec'
>>> "Harold je chytrý {0!r}" .format("chlapec")
"Harold je chytrý 'chlapec'"   
>>> "Harold je chytrý {0!a}" .format("chlapec")
"Harold je chytrý 'chlapec'"

Sektor  :format_spec
upřesňuje, jak má být hodnota prezentována, to jest určuje:
šířku - pole pro zadávanou hodnotu
výplň - libovolný znak kromě závorek { }; následuje pokyn pro zarovnání
zarovnání - vlevo (<), vpravo (>), na střed (^) a mezi(=) signum a číslici
signum - +, -, " ", (také # a 0)
přesnost - počet desetinných míst čísla: . údaj
typ - určuje způsob prezentace dat, například b je pro binární formát, d je pro decimální celé číslo, f pro formát float

Ukázka přiblíží způsob použití:

>>> "{:<25}" .format("zarovnáno vlevo")
'zarovnáno vlevo          '
>>> "{:>25}" .format("zarovnáno vpravo")
'         zarovnáno vpravo'   
>>> "{:ˇ^25}" .format("hulín")
'ˇˇˇˇˇˇˇˇˇˇhulínˇˇˇˇˇˇˇˇˇˇ'

Další zajímavé příklady namátkou:

>>> import math
>>> print("Hodnota Pí je asi {0:.3f}" .format(math.pi))
Hodnota Pí je asi 3.142
>>>  
>>> telef = {"Jan":4127, "Dana":4098, "Ota":863678}
>>> for name, phone in telef.items():
        print("{0:10} ==> {1:10d}" .format(name, phone))
...
Ota        ==>    863678
Dana       ==>      4098
Jan        ==>      4127

Další příklady lze nalézt v literatuře (pohříchu anglické), například The Python Tutorial - Input and Output

Najde se tam také tento užitečný:

>>> for x in range(7,11):
...     print("{0:2d} {1:3d} {2:4d}" .format(x, x*x, x*x*x))
...
 7  49  343
 8  64  512
 9  81  729
10 100 1000
>>>



7.17 Glosář

složený datový typ (compound data type)
Datový typ, v němž hodnoty jsou tvořeny z prvků, které jsou samy hodnotami. Mezi složené datové typy patří řetězce, seznamy, sety, entice, slovníky nebo také soubory.
sekvence (sequence)
Uspořádaná množina prvků. Podmnožina této množiny se nazývá subsekvence.
index
Proměnná či hodnota, použitá k označení prvku uspořádané řady, například znaku v řetězci.
traverzovat (traverse)
Probírat postupně jednotlivé prvky dané řady a s každým provést obdobnou operaci.
úsek (slice)
Část řetězce, vymezená rozsahem indexů.
neměnitelný datový typ (immutable data type)
Složený datový typ, jehož položky nemohou být měněny.
volitelný parametr (optional parameter)
Parametr uvedený v záhlaví funkce s přiřazenou počáteční hodnotou, která se použije, když při volání funkce není pro tento parametr zadán argument.
tečková notace (dot natation)
Použití tečky (dot operator) při volání funkce uvnitř modulu.
dokumentační řetězec (docstring)
Řetězcová konstanta, uvedená na prvním řádku funkce nebo modulu (a jak uvidíme později i třídy a metody). Dokumentační řetězce vhodně spojují programový kód s jeho komentářem. Používají se také pro automatické testování kódu s modulem doctest.
whitespace
Netištěné znaky pro ovládání kurzoru. Všechny tyto znaky obsahuje konstanta string.whitespace.

7.18 Cvičení

  1. Upravte sled příkazů tak, aby se Ouack a Quack vytiskly správně:
    prefixes = "JKLMNOPQ"
    suffix = "ack"
    
    for letter in prefixes:
        print(letter + suffix)
    
  2. Zapouzdřete následující sekvenci příkazů do funkce count_letters
    fruit = "banana"
    count = 0
    for char in fruit:
        if char == 'a':
            count = count + 1
    print(count)
    
    a zobecněte ji tak, aby přijímala řetězec a písmeno jako argument.
  3. Nyní tuto funkci přepište tak, aby místo traverzování řetězcem opakovaně volala funkci find (verzi z odst. 8.10). s nepovinným třetím parametrem pro určení místa výskytu posuzovaného písmena.
  4. Která verze fce is_lower (odst. 7.12) je nejrychlejší? Mohou být pro upřednostňování jedné verze před druhou jiné důvody než rychlost?
  5. Vytvořte soubor se jménem stringtools.py a vložte do ní následující řádky:
    def reverse (s):
        """
        >>> reverse('happy')
        'yppah'
        >>> reverse('Python') 
        'nohtyP'
        >>> reverse('')
        ''
        >>> reverse('P')
        'P'
        """
    
    if __name__ == '__main__':
        import doctest  
        doctest.testmod() 
    
    Přidejte tělo funkce tak, aby prošla zkouškou doctestů.
  6. Přidejte mirror do souboru stringtools.py.
    def mirror (s):
        """
        >>> mirror ('good')
        'gooddoog'
        >>> mirror ('yes') 
        'yessey'
        >>> mirror ('Python')
        'PythonnohtyP'
        >>> mirror ('')
        ''
        >>> mirror ('a')
        'aa'
        """
    
    Napište tělo funkce tak, aby pracovala tak, jak naznačují doctesty.
  7. Přidejte remove_letter do souboru stringtools.py.
    def remove_letter (letter, strng):
        """
        >>> remove_letter ('a', 'apple')
        'pple'
        >>> remove_letter ('a', 'banana') 
        'bnn'
        >>> remove_letter ('z', 'banana')
        'banana'
        >>> remove_letter ('i', 'Mississippi')
        'Msssspp'
        """
    
    Napište tělo funkce tak, aby pracovala tak, jak naznačují doctesty.
  8. Konečně, přidávejte postupně těla funkcím
    def is_palindrome (s):
        """
        >>> is_palindrome('abba')
        True
        >>> is_palindrome('abab') 
        False
        >>> is_palindrome('tenet')
        True
        >>> is_palindrome('banana')
        False
        >>> is_palindrome('straw warts')
        True
        """
    
    def count (sub, s):
        """
        >>> count('is', 'Mississippi')
        2
        >>> count('an', 'banana') 
        2
        >>> count('ana', 'banana')
        2
        >>> count('nana', 'banana')
        1
        >>> count('nanan', 'banana')
        0
        """
    
    def remove (sub, s):
        """
        >>> remove('an', 'banana') 
        'bana'
        >>> remove('cyc', 'bicycle')
        'bile'
        >>> remove('iss', 'Mississippi')
        'Missippi'
        >>> remove('egg', 'bicycle')
        'bicycle'
        """
    
    def remove_all (sub, s):
        """
        >>> remove_all('an', 'banana') 
        'ba'
        >>> remove_all('cyc', 'bicycle')
        'bile'
        >>> remove_all('iss', 'Mississippi')
        'Mippi'
        >>> remove('eggs', 'bicycle')
        'bicycle'
        """
    
    až všechny doctesty budou vyhovovat.
  9. Vyzkoušejte následující formátující řetězcové operace v IPP (Python shell) a zaznamenejte výsledky:
    1. "%s %d %f" % (5,5,5)
    2. "%-.2f" % 3
    3. "%-10.2f %-10.2f" % (7, 1.0/2)
    4. print(" $%5.2f\n $%5.2f\n $%5.2f" % (3, 4.5, 11.2))
  10. Totéž proveďte pomocí funkce . format().

previous up next hi end end