s1 = "Potřebuji 'apostrofy'"
s2 = 'Potřebuji "uvozovky"'
s3 = '''Jsem víceřádkový string,
vytvořený pomocí
trojic jednoduchých uvozovek.'''
print(s1)
print(s2)
print(s3)

Potřebuji 'apostrofy'
Potřebuji "uvozovky"
Jsem víceřádkový string,
vytvořený pomocí
trojic jednoduchých uvozovek.

print(int("1234"))
print(float(-3.5))
print(complex("1+2j"))
print(bool("0"))
print(str("Python"))
print(repr("Python"))

1234
-3.5
(1+2j)
True
Python
'Python'

# opakovani:
s = "abcdef ahoj!"

# podmínka
c = "a"
if c in s:
    print("ano, je tam")  

# for-cyklus:
for x in s:
    print(x, end = " ")
print("")

for i in range(len(s)):
    print(s[i], end = " ")
print("")

# indexace:
print(s[0])
#s[0] = "2" # chyba!

# slicing
print(s[2:4])

# zřetězení
s = "ahoj" + " " + "lidi"
print(s)
s = "20" * 3 + " " + s[1:-3]
s += " A"
print(s)

ano, je tam
a b c d e f   a h o j ! 
a b c d e f   a h o j ! 
a
cd
ahoj lidi
202020 hoj l A

print(chr(0x20ac))    # Znak euro
print(chr(87))
print(ord("€"))

# porovnání:

print("a" < "A")   # False
print(ord("a"), ord("A"), ord("Á"))

print(sorted("abhjsHWUVPgcvsdgcdsjkzdg"))

€
W
8364
False
97 65 193
['H', 'P', 'U', 'V', 'W', 'a', 'b', 'c', 'c', 'd', 'd', 'd', 'g', 'g', 'g', 'h', 'j', 'j', 'k', 's', 's', 's', 'v', 'z']

s = [1, 2, 3, 4, 5]
v = s.remove(3)
print(s)
print(v)

[1, 2, 4, 5]
None

s = "abcdefabc"
v = s.replace("a", "")
print(s)
print(v)

abcdefabc
bcdefbc

ovoce = ["Jablko", "Hruška", "Meruňka"]
s1 = ", ".join(ovoce)       # Jako oddělovač použijeme čárku s mezerou
s2 = "".join(ovoce)         # Jako oddělovač použijeme prázdný řetězec
s3 = "; ".join("Jablko")    # Pokud jako argument použijeme string, oddělovač se vloží mezi všechny jeho znaky
s3 = " ".join("Jablko")
print(s1)
print(s2)
print(s3)

Jablko, Hruška, Meruňka
JablkoHruškaMeruňka
J a b l k o

list1 = "Jablko a hruška a meruňka".split(" a ")
list2 = "Jablko,,hruška,,meruňka".split(",")           # Separátory se neslučují
list3 = "Jablko a  hruška\na   meruňka".split()        # Používají se výchozí hodnoty parametrů
list4 = "Jablko,,hruška,,meruňka".split(";")           # Separátor není nalezen
list5 = "Jablko a hruška a meruňka".split(" a ", 1)    # Určujeme maximální počet použití separátoru
list6 = "Jablko a hruška a meruňka".rsplit(" a ", 1)   # Začínáme zprava
print(list1, list2, list3, list4, list5, list6, sep="\n")

['Jablko', 'hruška', 'meruňka']
['Jablko', '', 'hruška', '', 'meruňka']
['Jablko', 'a', 'hruška', 'a', 'meruňka']
['Jablko,,hruška,,meruňka']
['Jablko', 'hruška a meruňka']
['Jablko a hruška', 'meruňka']

"ahoj    lidi\t jablko\n\n\nhruska".split()

['ahoj', 'lidi', 'jablko', 'hruska']

"ahoj    lidi\t jablko\n\n\nhruska".splitlines(keepends=True)

['ahoj    lidi\t jablko\n', '\n', '\n', 'hruska']

ntice1 = "Jablko a hruška a meruňka".partition(" a ")
ntice2 = "Jablko a hruška a meruňka".partition(" x ")    # Oddělovač není nalezen
ntice3 = "Jablko a hruška a meruňka".rpartition(" a ")   # Hledáme oddělovač zprava
ntice4 = "Jablko a hruška a meruňka".rpartition(" x ")   # Hledáme zprava, oddělovač není nalezen
print(ntice1, ntice2, ntice3, ntice4, sep="\n")

('Jablko', ' a ', 'hruška a meruňka')
('Jablko a hruška a meruňka', '', '')
('Jablko a hruška', ' a ', 'meruňka')
('', '', 'Jablko a hruška a meruňka')

help(str.split)

Help on method_descriptor:

split(self, /, sep=None, maxsplit=-1) unbound builtins.str method
    Return a list of the substrings in the string, using sep as the separator string.

      sep
        The separator used to split the string.

        When set to None (the default value), will split on any whitespace
        character (including \n \r \t \f and spaces) and will discard
        empty strings from the result.
      maxsplit
        Maximum number of splits.
        -1 (the default value) means no limit.

    Splitting starts at the front of the string and works to the end.

    Note, str.split() is mainly useful for data that has been intentionally
    delimited.  With natural text that includes punctuation, consider using
    the regular expression module.

# Write your exercise code here
print("abc def".islower())
print("A Q".isupper(),"\n")

print("abc def".isalpha(),"\n")

print("162".isdecimal())
print("16.2".isdecimal())
print("16.2".isnumeric(),"\n")

print("abc def".isprintable())
print("abc\tdef".isprintable())

True
True 

False 

True
False
False 

True
False

# Write your exercise code here
print("babab bab bababa".count("bab"))
print("babab bab bababa".count("bab", 0, 4))
print("babab bab bababa".startswith("bab"))

3
1
True

s1 = "Ve slově standart se na konci nepíše t, ale d!"
print(s1.replace("t", "d"))
print(s1.replace("t", "d", 2))
print(s1)

Ve slově sdandard se na konci nepíše d, ale d!
Ve slově sdandard se na konci nepíše t, ale d!
Ve slově standart se na konci nepíše t, ale d!

print("01\t012\t0123\t01234".expandtabs())
print("01\t012\t0123\t01234".expandtabs(4))

01      012     0123    01234
01  012 0123    01234

s1 = "       Nechci bílé znaky před ani za textem!  \n  ".strip()
s2 = "       Nechci bílé znaky před textem!  \n  ".lstrip()
s3 = "       Nechci bílé znaky za textem!  \n  ".rstrip()
s4 = "*   Nechci * před ani za textem!****".strip("*")
s5 = "*--Nechci * ani - za textem!**---".rstrip("*-")
print(s1, s2, s3, s4, s5, sep="\n")

Nechci bílé znaky před ani za textem!
Nechci bílé znaky před textem!  
  
       Nechci bílé znaky za textem!
   Nechci * před ani za textem!
*--Nechci * ani - za textem!

s5 = "*--Nechci * ani - za textem!**---".removesuffix("*---")
print(s5)

*--Nechci * ani - za textem!*

s1 = "Text z malých písmen, VELKÝCH PÍSMEN a čísla 42."
print(s1.lower(), s1.upper(), s1.capitalize(), s1.title(), sep="\n")
s2 = "they're bill's friends from the UK"
print(s2.title())

text z malých písmen, velkých písmen a čísla 42.
TEXT Z MALÝCH PÍSMEN, VELKÝCH PÍSMEN A ČÍSLA 42.
Text z malých písmen, velkých písmen a čísla 42.
Text Z Malých Písmen, Velkých Písmen A Čísla 42.
They'Re Bill'S Friends From The Uk

print("|", "vlevo".ljust(20), "|", "uprostřed".center(20), "|", "vpravo".rjust(20), "|")
print("|", "jiny text".ljust(20), "|", "gjf".center(20), "|", "jjf ggyug".rjust(20), "|")
print ("Ahoj!".center(40, '-'))

| vlevo                |      uprostřed       |               vpravo |
| jiny text            |         gjf          |            jjf ggyug |
-----------------Ahoj!------------------

hodiny = 2
minuty = hodiny * 60
print("vysledek:", hodiny, "hod je", minuty, "min")

vysledek: 2 hod je 120 min

Mil[ý/á] _______,
Váš výsledek 1. testu ZPRO je __________ bodů.

S pozdravem
_________

Mil{y_a} {osloveni},
Váš výsledek 1. testu ZPRO je {soucet} bodů.

S pozdravem,
{podpis}.

x = 6 + 5
string = f"Vysledek prikladu je {x + 34}." 
print(string)
string = f"Hodnota výrazu je {x / 3 + 34}." 
print(string)
string = f"Hodnota výrazu je {x / 3 + 34:.2f}." 
print(string)

Vysledek prikladu je 45.
Hodnota výrazu je 37.666666666666664.
Hodnota výrazu je 37.67.

y_a = "á"
osloveni = "Žofie"
ukol1 = 25
ukol2 = 40
ukol3 = 20
soucet = ukol1 + ukol2 + ukol3
podpis = "Váš cvičící"

vystup = f"""
Mil{y_a} {osloveni},
Váš výsledek 1. testu ZPRO je {soucet} bodů.

S pozdravem,
{podpis}
"""
print(vystup)

Milá Žofie,
Váš výsledek 1. testu ZPRO je 85 bodů.

S pozdravem,
Váš cvičící

from math import pi
r = 4
print(f"Obvod kruhu o poloměru {r =} je {2 * pi * r }")

Obvod kruhu o poloměru r =4 je 25.132741228718345

string = r"ahoj\"t\\ahoj"
print(string)

ahoj\"t\\ahoj

s1 = "{} krát {} je {}.".format(2, 3, 2 * 3)
print(s1)
s2 = "Ahoj, jsem {jmeno}. A moje oblibené číslo je {cislo}."
print(s2.format(cislo=7, jmeno="Matěj"))
print(s2.format(cislo=42, jmeno="divný člověk"))
#print(s2.format("Žofie", 3))    # KeyError: není možné dosadit nepojmenovaný argument do pojmenovaného místa

2 krát 3 je 6.
Ahoj, jsem Matěj. A moje oblibené číslo je 7.
Ahoj, jsem divný člověk. A moje oblibené číslo je 42.

def strong_password(passwd):
    a = b = c = d = e = False
    for znak in passwd:
        if znak.islower():
            a = True
        elif znak.isupper():
            b = True
        elif znak.isdecimal():
            c = True
        elif znak in "!\"#$%&'()*+":
            d = True
    if len(passwd) >= 8:
        e = True
    
    return (a, b, c, d, e, a & b & c & d & e)

print(strong_password("Moje8Heslo "))  # splňuje všechna kriteria

(True, True, True, False, True, False)

def strong_password(passwd):
    vysledek = {"a": False, "b": False, "c": False, "d": False, "e": False  }
    for znak in passwd:
        if znak.islower():
            vysledek["a"] = True
        elif znak.isupper():
            vysledek["b"] = True
        elif znak.isdecimal():
            vysledek["c"] = True
        elif znak in "!\"#$%&'()*+":
            vysledek["d"] = True
    if len(passwd) >= 8:
        vysledek["e"] = True
    return vysledek

print(strong_password("Moje8Heslo'"))  # splňuje všechna kriteria

{'a': True, 'b': True, 'c': True, 'd': True, 'e': True}

string = "abcdabcdda"
print(string.count("a"))
l = sorted(string)
print(l)

3
['a', 'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd', 'd']

def anagrams(str1, str2):
    return sorted(str1) == sorted(str2)

def anagrams(str1, str2):
    for x in set(str1+str2):
        if str1.count(x) != str2.count(x):
            return False
    return True
    

assert anagrams("reklama", "makrela")
assert anagrams("reklama", "marekll") == False

def get_initials(name, surname):
    name = name.lstrip()
    surname = surname.lstrip()
    
    initials = name[0] + surname[0]
    
    return initials.upper()

get_initials("  jan ", "  novák")

'JN'

def freq_analysis(text):
    dictionary = {}
    text = text.lower()
    for c in set(text):
        if c.isalnum():
            dictionary[c]=text.count(c)
    return dictionary

d = freq_analysis("All the world is a stage and all the men and women merely players.")
...

Ellipsis

def freq_analysis(text):
    dictionary = {}
    text = text.lower()
    for c in text:
        if c.isalnum():
            if c in dict:
                dictionary[c] += 1
            else:
                dictionary[c] = 1
    return dict

d = freq_analysis("All the world is a stage and all the men and women merely players.")
...

def word_lengths(text):
    words = text.split()
    word_lengths = []
    for word in words:
        word_lengths.append(len(word))

    return word_lengths

assert word_lengths("   Toto   je    příklad textu s různě dlouhými slovy.  ") == [4, 2, 7, 5, 1, 5, 8, 6]

def freq_analysis(text):
    ...

d = freq_analysis("This is a test. This is only a test, not a real situation.")
...

def caesar(text, shift):
   ...

a = "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ"
assert caesar(a,12) == "mnopqrstuvwxyzabcdefghijkl MNOPQRSTUVWXYZABCDEFGHIJKL"

b = "All the world is a stage; And all the men and women merely players."
assert caesar(b, -2) == "Yjj rfc umpjb gq y qryec; Ylb yjj rfc kcl ylb umkcl kcpcjw njywcpq."
assert caesar(b, 26) == b
assert caesar(caesar(b,15), -15) == b

print(caesar("Ask me, how to "))

def try_caesar(text):
    ...

try_caesar("Clguba vf n irel hfrshy cebtenzzvat ynathntr. Naq ubj fvzcyr vg vf... V ybir vg!")

def caesar_frequency_analysis(text):
    ...

caesar_frequency_analysis("Clguba vf n irel hfrshy cebtenzzvat ynathntr. Naq ubj fvzcyr vg vf... V ybir vg!")

Metoda	Krátký popis
`islower`	Vrací `True`, je-li ve stringu alespoň jedno písmeno a všechna písmena jsou malá. Znaky, které nejsou písmeny, výsledek neovlivní.
`isupper`	Vrací `True`, je-li ve stringu alespoň jedno písmeno a všechna písmena jsou velká. Znaky, které nejsou písmeny, výsledek neovlivní.
`istitle`	Vrací `True`, je-li ve stringu alespoň jedno písmeno a mají-li ve stringu všechna slova první písmeno velké a ostatní malá. Znaky, které nejsou písmeny, výsledek neovlivní.
`isalpha`	Vrací `True`, je-li string neprázdný a všechny jeho znaky jsou v sadě Unicode považovány za písmena.
`isdecimal`	Vrací `True`, je-li string neprázdný a všechny jeho znaky mohou být použity pro zápis čísel o základu 10.
`isdigit`	Vrací `True`, je-li string neprázdný a všechny jeho znaky jsou v sadě Unicode považovány za číslice. Vedle běžných číslic a číslic zapsaných jako indexy či exponenty sem patří i číslice dalších jazyků – např. arabsko-indické.
`isnumeric`	Vrací `True`, je-li string neprázdný a všechny jeho znaky jsou v sadě Unicode považovány za reprezentanty čísel. Sem patří vedle číslic i řada dalších znaků reprezentujících některé zlomky, římské číslice a jiné symboly. Platí `isdecimal()` ⊆ `isdigit()` ⊆ `isnumeric()`.
`isalnum`	Vrací `True`, je-li string neprázdný a všechny znaky představují písmena, číslice či čísla. Za alfanumerický je znak `c` považován v případě, vrací-li `True` alespoň jedna z metod `c.isalpha()`, `c.isdecimal()`, `c.isdigit()`, `c.isnumeric()`.
`isspace`	Vrací `True`, je-li string neprázdný a všechny jeho znaky jsou v sadě Unicode klasifikovány jako bílé znaky.
`isprintable`	Vrací `True`, je-li string prázdný, nebo obsahuje pouze tisknutelné znaky. Za netisknutelné znaky jsou mimo jiné považovány všechny bílé znaky s výjimkou obyčejné mezery (tedy naříklad pevná mezera `'\xA0'` je netisknutelný znak).
`isascii`	Vrací `True`, je-li string prázdný, nebo mají všechny jeho znaky kód menší nebo roven `255` (`0x7F`).
`isidentifier`	Vrací `True`, je-li string platným identifikátorem podle pravidel Pythonu.

Metody	Krátký popis
`count`	Vrací počet nepřekrývajících se výskytů zadaného podstringu.
`find`, `rfind`	Vracejí pozici počátku prvního výskytu zadaného podstringu. Není-li podstring nalezen, vrátí `-1`. Metoda `rfind` prohledává zprava.
`index`, `rindex`	Pracují stejně jako metody `find`, resp. `rfind`. Liší se pouze tím, že nenajdou-li hledaný řetězec, vyvolají `ValueError`.
`startswith`, `endswith`	Vracejí `True` v případě, začíná-li (resp. končí-li) prohledávaný řetězec zadaným podstringem. Prvním argumentem může být i n-tice stringů.

Metoda	Krátký popis
`lower`	Vrátí nový string, ve kterém jsou všechna písmena převedena na malá písmena.
`upper`	Vrátí nový string, ve kterém jsou všechna písmena převedena na velká písmena.
`capitalize`	Vrátí nový string s prvním písmenem velkým a ostatními písmeny malými.
`title`	Vrátí nový string, kde je první písmeno každého slova velké a ostatní písmena malá. Slova jsou definována jako skupiny po sobě jdoucích písmen. Tato definice funguje ve většině případů, ale má své limity (např. apostrofy jsou považovány za oddělovače slov).

Cvičení č. 14 rozšířené o poznámky ze cvičení a řešení některých příkladů (ZS 2024/25)¶

V minulém díle jste viděli…¶

Textové řetězce (2. část)¶

Metody pro práci se stringy¶

Spojování a rozdělování stringů¶

Zjišťovací metody¶

Vyhledávání podstringů¶

Metody nahrazování¶

Ořezávání stringů¶

Metody pro jednoduché formátování¶

Formátování řetězců¶

Příklady¶