Blog

## 1) Zkontroluje jakou verzi PYTHONU mas na pc
python3 --version <===> ověří verzi pythonu 3 a vyssi

# Objeví-li se „Python“ a číslo verze (např. Python 3.6.6) a verze je 3.6 nebo vyšší, máš nainstalováno. Přejdi na další sekci 2) Kontrola Tkinter.
# Objeví-li se „Python“ a verze 3.5 nebo nižší, aktualizuj systém
# Objeví-li se bash: python3: command not found nebo podobná chyba, doinstaluj Python. Konkrétní příkaz záleží na distribuci:
sudo apt-get install python
# nebo
sudo apt-get install python3.6

## 2) Kontrola Tkinter
# Některé linuxové distribuce obsahují standardně jen část celkové funkčnosti Pythonu. Konkrétně knihovnu tkinter.
# Abys zjistil/a, jestli je už je nainstalovaná, zadej příkaz:
python3 -m tkinter

# Objeví-li se okýnko, je všechno v pořádku. Zavři ho a přejdi na dalsi sekci 3) Doinstalování virtualenv.
# Jestli ne, modul tkinter ještě nainstaluj
sudo apt-get install python3-tk

## 3) Doinstalování virtualenv
# Novější verze Pythonu mají zabudovaný nástroj venv, který použijeme níže.
# Starší verze ho ale nemají (a některé distribuce Linuxu ho dokonce z Pythonu vyřadily).
# Potřebuješ proto zjistit, jestli venv máš, a případně nainstalovat alternativu.

python3 -m ensurepip --version

#Objeví-li se výpis začínající „pip“, máš funkční venv nainstalovaný. Zbytek této sekce můžeš přeskočit!
#Objeví-li se ale nápis No module named ensurepip, je potřeba doinstalovat alternativu, Virtualenv:

sudo apt-get install python-virtualenv
# nebo
sudo apt-get install python3-venv

# After installing the python3-venv package, recreate your virtual environment.
# Virtuální prostředí je něco, co nám zajistí, že se všechny počítače budou chovat zhruba stejně.
# Až ho zprovozníme, nebudeme potřebovat instrukce zvlášť pro Linux, zvlášť pro Windows a zvlášť pro macOS.

## 4) Virtuální prostředí
# Virtuální prostředí je něco, co nám zajistí, že se všechny počítače budou chovat zhruba stejně.
# Až ho zprovozníme, nebudeme potřebovat instrukce zvlášť pro Linux, zvlášť pro Windows a zvlášť pro macOS.

python3 -m venv venv <===> normální Linux (pokud jsi přeskočil/a instalaci Virtualenv)
virtualenv -p python3 venv <===> starší Linux (pokud jsi musel/a instalovat Virtualenv)
# Tím se ti vytvořil adresář venv, který virtuální prostředí obsahuje. Můžeš se podívat dovnitř, ale neukládej tam své soubory a nikdy tam nic neměň!

## 5) Aktivace virtuálního prostředí
# Nakonec virtuální prostředí aktivuj
source venv/bin/activate
# Po spuštění tohoto příkazu by se mělo na začátku příkazové řádky (před $ objevit slovo (venv)). Tak poznáš, že je virtuální prostředí aktivní.
# Aktivační příkaz si zapiš. Bude potřeba ho zadat vždycky, když pustíš příkazovou řádku, ve které budeš zkoušet své programy.

#<------------------------------------ ------------------------------------>#

python --version <===> ověří verzi pythonu 2
python3 --version <===> ověří verzi pythonu 3 a vyssi
python <===> It opens Python 2 version interpreter prompt.
python3 <===> It opens Python 3 version interpreter prompt.

PIP is a package manager for Python
sudo apt-get install python3-pip
python3 -m pip install --upgrade pip

CTRL+D <===> ukončuje python spuštěný v konsoli

The virtual environment was not created successfully because ensurepip is not
available. On Debian/Ubuntu systems, you need to install the python3-venv
package using the following command.

apt-get install python3-venv

You may need to use sudo with that command. After installing the python3-venv
package, recreate your virtual environment.

#<------------------------------- Zapamatujte si ------------------------------->#
Cyklus FOR opakuje sadu příkazů při pevně daném počtu iterací (obrátek cyklu).
Cyklus WHILE opakuje sadu příkazů dokud je splněna podmínka. Může se stát, že se tělo cyklu neprovede nikdy. Stane se tak v případě, kdy se pokračovací podmínka hned na začátku vyhodnotí jako false (nepravda).
Existují i jiné typy cyklů, ale FOR a WHILE jsou k dispozici téměř ve všech jazycích.
Cyklus for v jazyce Python je skutečnosti cyklem typu foreach — pracuje nad položkami seznamu.
Cykly lze do sebe vnořovat.

#<------------------------------- escape sekvence ------------------------------->#

Občas potřebujeme trochu "speciální" text. Například v konzoli poskočit na další řádku, vytisknout uvozovky apod.
Tyto speciální znaky zapisujeme pomocí tzv. escape sekvencí, které začínají zpětným lomítkem.

Nový řádek se zapíše jako \n . Příklad:
print("První řádek\nDruhý řádek")

Tabulátor se zapíše jako \t . Příklad:
print("Před\tZa")

Zvonek se zapíše jako \a. Užitečné, pokud chcete v nějaké konzolové aplikaci zapípat.

Zpětné lomítko se zapíše jako \\ , protože \ začínají speciální znaky.
Pokud nepotřebujeme žádné speciální znaky začínající \, můžeme použít tzv. holé řetězce.
Ty se vytvářejí stejně jako řetězce, ale před první uvozovku se napíše navíc r.
Holý řetězec bere každý znak v řetězci zvlášť, takže např. r"\n",
bere holý řetězec jako zpětné lomítko a n, ne jako znak pro nový řádek.

Jednoduché uvozovky se zapíší jako \' , dvojité jako \" .
Pokud používáme řetězec vytvořený z jednoduchých uvozovek ('),
tak lze psát dvojité uvozovky (") bez problémů, bez nutnosti potlačení.
A naopak. Lze také použít i trojité uvozovky ('''Text''' anebo """Text"""),
pak nemusíte používat před uvozovkami v textu zpětné lomítko.

Jedno rovnítko = používáme pro přiřazení hodnoty do proměnné
Dve rovnítka == porovnáváme hodnoty

Escape Character Result
\’ Single Quote
\\ Backslash
\b Backspace
\f Line Feed
\n New Line
\r Line Feed
\t Tab
\v Vertical Tab

#<------------------------------- Parsovani ------------------------------->#

## int() <===> prevede hodnotu na CELE CISLO

## str() <===> prevede cislo (nebo něco jiné - např. desetinné číslo) na RETEZEC

#<------------------------------- input ------------------------------->#

Funkce input() vrací řetězec. Pokud chceme interakci s uzivatelem

#<------------------------------- pojmenovani promennych ------------------------------->#

je bezne pojmenovavat PROMENNE bez mezer tj.
dnes_je_den = "pondeli"
nebo
dnesJeDen = "pondeli"

#<------------------------------- Python Comparison Operators ------------------------------->#

Řetězce se dají porovnávat pomocí standardních porovnávacích operátorů:

Rovnost ==
Je ostře větší >
Je ostře menší <
Je větší nebo rovno >=
Je menší nebo rovno <=
Nerovnost !=
Obecná negace !
>
#<------------------------------- Python Arithmetic Operators ------------------------------->#

+ Addition x + y
- Subtraction x - y
* Multiplication x * y
/ Division x / y
% Modulus x % y
** Exponentiation x ** y
// Floor division x // y

14//3 <===> Vrátí celou část po dělení (tudiz nikoli 4.666666666666667 ale 4)
2**3 <===> Umocnění - v tomto případě 2na3 (8)
10%3 <===> Vrátí zbytek po dělení (1) tzv. modulo

#<------------------------------- Logické operátory ------------------------------->#

Operátor Zápis
A zároveň and
Nebo or
Negace not

#<------------------------------- Boolovské (nebo také logické) operátory ------------------------------->#

A and B A současně True, když A i B jsou True. V jiném případě je výsledkem False.
A or B NEBO True když oba nebo jeden z A, B jsou True. False, když oba A i B jsou False.
A == B ROVNOST True když A je rovno B.
A != B NEROVNOST True když A není rovno B.
A <> B NEROVNOST True když A není rovno B.
not B NEGACE True když B není True.

#<------------------------------- len() ------------------------------->#

print(len("letadlo letelo vysoko")) <===> zjisti delku daneho retezce (21)

s = 'supercalifragilisticexpialidocious'
len(s)
34 <===> vypise delku retezce

#<------------------------------- scitani retezcu / string ------------------------------->#

retezec_1 = "Abeceda"
retezec_2 = " je zabava!"
print(retezec_1 + retezec_2) <===> vypise obe promene spolecne (Abeceda je zabava)

print("Ja jsem prvni cast " + "textu" + " a ja druha!") <===> ukazka scitani retezcu

print("20 dni je dohromady " + str(28800) + " dni celkem") <===> secte string a cislo dohromady
print(f"20 dni je dohromady {28800} dni celkem") <===> secte string a cislo dohromady ELEGANTNEJI (funguje ale ve verzich 3.6 a novejsich.. ve verzi python2.* nefunguje)

calculation_to_units = 24 * 60 * 60
name_of_unit = "seconds"

print(f"20 days are {20 * 24 * 60 * 60} seconds")
print(f"20 days are {20 * 24 * 60 * 60}{name_of_unit}")
print(f"20 days are {35 * calculation_to_units}{name_of_unit}")

#<------------------------------- type() ------------------------------->#

# desetinka = 1.5
# cele_cislo = 15
# veta = "sel jsem na nakup"

type(desetinka) <===> Zjistit typ proměnné (class float)
type(cele_cislo) <===> Zjistit typ proměnné (class integer)
type(veta) <===> Zjistit typ proměnné (class string)

#<------------------------------- for ------------------------------->#

for znak in "python":
print(znak)

můžeme testovat, jestli nějaký řetězec neobsahuje jiný řetězec <===>
p
y
t
h
o
n

#<------------------------------- FUNKCE ------------------------------->#

##
## text = "Muzeme zkusit zjistit delku cisla stejnym zpusobem"
## upaleni_husa = 14150706
## veta = "sel jsem na nakup"
## triada = "abc,xyz,ghi"

print()
name = "Maria"
name <===> 'Maria'
print(name) <===> Maria
print() <===> vypise pouze PRAZDNY radek - hodi se k oddelovani casti vystupu na obrazovce

upper() <===> vsechen text prevede na velka pismena
text.upper() <===> MUZEME ZKUSIT ZJISTIT DELKU CISLA STEJNYM ZPUSOBEM

lower() <===> vsechen text prevede na mala pismena
text.lower() <===> muzeme zkusit zjistit delku cisla stejnym zpusobem

title() <===> vsechen text prevede na mala pismena+pocatecni pismena budou velka
text.title() <===> Muzeme Zkusit Zjistit Delku Cisla Stejnym Zpusobem

len() <===> zjisti delku retezce ve znacich (pocitaji se i mezery)
len(text) <===> 93
len(upaleni_husa) <===> POZOR toto nefunguje je potreba prevedst cisla na string tj. len(str(upaleni_husa))

replace()
retezec = "C-sharp je nejlepší!" <===> C-sharp je nejlepší!
retezec = retezec.replace("C-sharp", "Python") <===> Python je nejlepší!

list()
vysek = list(veta) <===> promenou veta rozdeli do listu(pole) po jednotlivych pismenech ['s', 'e', 'l', ' ', 'j', 's', 'e', 'm', ' ', 'n', 'a', ' ', 'n', 'a', 'k', 'u', 'p']
print(vysek[7]) <===> vypise z daneho pole jen pismeno na 7 pozici tj. pismeno "m"

round()
price = 100.50
round(price)
100 <===> funkce round() zaokrouhluje desetinna cisla na cela

split()
veta.split() <===> rozdeli retezec na jednotliva slova ['sel', 'jsem', 'na', 'nakup']
triada.split(',') <===> rozdeli do listu ['abc','xyz','ghi']

isalpha()
Vrátí booleovskou hodnotu True, pokud jsou všechny znaky v řetězci písmenné znaky a řetězec obsahuje minimálně jeden znak. Jinak vrací False
prvni_retezec = "Airbus"
print(prvni_retezec.isalpha()) <===> True
druhy_retezec = "Boeing 737"
print(druhy_retezec.isalpha()) <===> False

#<------------------------------------ ------------------------------------>#

retezec = "Bum! "
print(retezec * 7) <===> Zadaný řetězec se n-krát zopakuje, stačí ho "vynásobit" nějakým číslem. (Bum! Bum! Bum! Bum! Bum! Bum! Bum!)

#<------------------------------------ ------------------------------------>#

Ze řetězců lze "extrahovat" jednotlivé prvky stejně jako ze seznamů. K tomuto účelu se používají hranaté závorky.

retezec = "Honolulu"
print(retezec[0]) <===> H
print(retezec[1:4]) <===> ono
print(retezec[::2]) <===> Hnll

název_seznamu[m] - vybere jediný znak
název_seznamu[m:n] - vybere znaky v rozsahu m až n-1
název_seznamu[m:n:i] - vybere m a každý i-tý znak do n-1

Samozřejmě lze využít i speciality jako [:] - vybere celý řetězec, nebo [::-1] - převrátí řetězec.

slovo='superdlouhatananske'
slovo[5]
'd' <===> vypise pouze pismeno na pozici 5 (pocita se i nula)

slovo[5:]
'dlouhatananske' <===> vypise pouze zbytek slova od pozice 5 (pocita se i nula)

#<------------------------------- List ------------------------------->#

loterie = [3, 42, 12, 19, 30, 59]
len(loterie) <===> vysledek 6 tj. pocet cisel v loterii
loterie.sort() <===> setridi cisla vzestupne
loterie.reverse() <===> setridi cisla sestupne
loterie.append(199) <===> prida cislo 199 do loterie
print(lottery) <===> zobrazi co je v loterii
print(lottery[1]) <===> zobrazi pouze DRUHE cislo (tj 42) z loterie pomoci tzv. indexu - pozor indexuje se od nuly
lottery.pop(0) <===> odstrani polozku (PRVNI cislo) z listu loterie tj. 59

jinySeznam = [1, 2, 3]
print jinySeznam
[1, 2, 3]

jinySeznam[2] = 7
print jinySeznam
[1, 2, 7] <===> Hodnoty položek seznamu můžeme podobným způsobem i měnit:

print jinySeznam[-1]
7 <===> Záporné hodnoty indexového čísla používáme pro zpřístupnění položek indexovaných vůči konci seznamu. Nejčastěji se používá index -1 (mínus jedna), který zajistí zpřístupnění poslední položky seznamu:

seznam.append(42)
print seznam
[42] <===> Operátorem append() můžeme přidávat nové položky na konec seznamu:

#<------------------------------------ ------------------------------------>#

radek1 = [1, 2, 3]
radek2 = ['a', 'b', 'c']
tabulka = [radek1, radek2]
print (tabulka)
#[[1, 2, 3], ['a', 'b', 'c']]

prvek2 = tabulka[1][2]
print (prvek2)
#c
#<------------------------------------ ------------------------------------>#

adresy = ['Mirek', 'Kolbenova 15', 'Olomouc', '585 456 231'],
['Hanka', 'Ypsilantiho 42', 'Brno', '525 698 444']

print(adresy[1][1]) <===> Ypsilantiho 42

#<------------------------------------ ------------------------------------>#

>>> print seznam
[42]
>>> print jinySeznam
[1, 2, 7]
>>> novySeznam = seznam + jinySeznam
>>> print novySeznam
[42, 1, 2, 7]
#<------------------------------------ ------------------------------------>#

#<------------------------------------ ------------------------------------>#

prvni_retezec = "ARIZONA"
print(prvni_retezec.lower())
druhy_retezec = "PythoN"
print(druhy_retezec.lower())

#<------------------------------------ ------------------------------------>#

Vrátí booleovskou hodnotu (True/False) jestli řetězec končí zadaným řetězcem, který předáváme jako parametr. Lze zadat i výřez.
retezec = "alabama"
print(retezec.endswith("a")) <===> False
print(retezec.endswith("m")) <===> True

#<------------------------------------ ------------------------------------>#

 

#<------------------------------- okomentovani radku ------------------------------->#

print "Hello, Python!"; # second comment
#this is a comment in Python

"""
This is an example of a multiline
comment that
spans multiple
lines
"""

 

#<------------------------------- definice funkce ------------------------------->#

funkci definujeme slovem DEF nazev_funkce(): a vyvolame ji vypsanim nazvu funkce(): tj.

def nakup():
print("mliko")
print("maso")
print("ovoce")

print("DNES pujdu na nakup a koupim :")
nakup()
print("ZITRA pujdu na nakup a koupim :")
nakup()

#<------------------------------------ ------------------------------------>#