Python
| Site: | Virtuálna Univerzita Mateja Bela |
| Cours: | BBC micro:bit (bloky) |
| Livre: | Python |
| Imprimé par: | Hosťovský používateľ |
| Date: | lundi 20 mai 2024, 06:31 |
1. Vývojárske prostredie (IDE)
Využiteľné IDE pre programovanie v jazyku Python.
Visual Studio Code
Vývojárske prostredie od spoločnosti Microsoft. S oficiálnym rozšírením s názvom Python (viac ako 22 miliónov stiahnutí) je programovanie v tomto jazyku veľmi jednoduché. Obsahuje množstvo vyladených nástrojov - debugger, refactoring, formátovanie kódu, testy atď.
Inštalácia rozšírenia pre Python
V ľavej časti obrazovky sa nachádza ikona štvorcov (alebo ctrl+shift+x), kliknutím sa zobrazí možnosť pridať rozšírenie. Vyhľadáme si Python a zvolíme našu voľbu. Následne necháme rozšírenie inštalovať.
Vytvorenie nového programu
Nový program si vytvoríme cez File-New File alebo ikony pridania nového súboru, ktorý si pomenujeme aj s príponou .py.
Po vytvorení súboru, si vyberieme interpreter (vľavo dole) - v našom prípade to je Python verzia 3.8.0. Po napísaní programu si ho spustíme zelenou ikonou "play" vpravo hore. Ak máme výsledok vo forme výpisov, uvidíme ich v dolnej časti obrazovky v termináli.
JetBrains PyCharm (Community Edition/Professional)
Vytvorenie nového súboru v rámci projektu
File-New-PythonFile, ktorý si následne pomenujeme.
Spustenie programu
Program spustíme cez horný panel Run-Run'program' alebo v pravej časti stlačením zeleného tlačidla "play".
IDLE
Veľmi jednoduchým editorom jazyku Python je IDLE (Python’s Integrated Development and Learning Environment). Inštaluje sa spolu s jazykom Python do počítača.
Horný panel obsahuje iba základné funkcionality. Nový súbor vytvoríme cez File-New File. Nie je tu mnoho užitočných funkcií ako v predošlých prostrediach. Program si spustíme cez Run-Run Module.
2. Dátové typy
Každá premenná je určitým dátovým typom. V jazyku Python nie je nutné pri vytváraní premennej deklarovať aj jej typ ale možné to samozrejme je. Dátové typy je vhodné určiť kvôli tomu, aby sme kompileru dali vedieť, s akými dátami má pracovať aby nedošlo k chybám. Samozrejme aj nám, programátorom, uľahčuje prácu presná informácia, s čím pracujeme.
Boleánsky typ (boolean)
- tento dátový typ môže mať len dve možnosti – True alebo False
- používame ich napríklad pri logických operátoroch
nepravda = False # Bez určenia typu - fungovať bude ako False
print(type(pravda)) # Vypísanie dátového typu: <class 'bool'>
Čísla
- Celé čísla (integers, skratka int) – dátový typ celých čísel, ktorý teoreticky nemá limit na dĺžku hodnoty (limitom bude vždy systém, v ktorom sa pracuje). Celé čísla môžeme zapisovať v rôznych číselných sústavách:
bin2 = 0b10110110
bin3 = 14
print('bin1 =', bin1, 'bin2 =', bin2, 'bin3 =', bin(bin3)[2:]) # bin1 = 0b101011 bin2 = 182 bin3 = 1110
decimálna sústava (desiatková) – print(15)
dec2 = int(67)
print('dec1 =', dec1, 'dec2 =', dec2) # dec1 = 18 dec2 = 67
print(type(dec1)) # <class 'int'>
oktálna sústava (osmičková) – pred čísla dávame predponu 0o (0O) – print(0o15)
okt2 = 24
okt3 = oct(10)
print('okt1 =', okt1, 'okt2 =', oct(okt2), 'okt3 =', okt3) # okt1 = 20 okt2 = 0o30 okt3 = 0o12
hexadecimálna sústava (šestnástková) – pred čísla dávame predponu 0x (0X) – print(0x15)
hex2 = 16
hex3 = hex(32)
print('hex1 =', hex1, 'hex2 =', hex2, 'hex3 =', hex3) # hex1 = 322 hex2 = 16 hex3 = 0x20
- Desatinné čísla (floatI) – desatinné čísla sa píšu s bodkou
flt2 = float(18 / 4)
flt3 = 5.476e9
print('flt1 =', flt1, 'flt2 =', flt2, 'flt3 =', flt3) # flt1 = 24.8 flt2 = 4.5 flt3 = 5476000000.0
- Komplexné čísla (complex) – komplexné čísla sa skladajú s reálnej časti a imaginárnej (15j)
cmp2 = 7 + 4j
cmp3 = cmp1 + cmp2
print('cmp1 =', cmp1, 'cmp2 =', cmp2, 'cmp3 =', cmp3) # cmp1 = 4j cmp2 = (7+4j) cmp3 = (7+8j)
Reťazce (string) – určitý rad znakov, príkladom použitia je print("Miesto dvojitých úvodzoviek môžeme použiť jednoduché úvodzovky")
uvodnyText = str("Vitajte na našom webe")
print(type(uvodnyText)) # <class 'str'>
Zoznam (list) – určitý zoznam, napríklad mien - list(("Matej", "Gabriel", "Zuzana"))
print(type(zoznam)) # <class 'list'>
N-tice (tuple)
- podobne ako pri reťazcoch, obsahuje znaky, v tomto prípade sa tu môžu nachádzať aj hodnoty
- uchovávajú napríklad informácie o charaktere v počítačovej hre –meno hráča, úroveň, množstvo peňazí, počet ocenení a trieda - hrac = tuple(("Apolonius", "44", "14.547", "12", "Farmári"))
- k uloženým informáciám pristupujeme napríklad print(tuple[0]) kde sa v tomto prípade vypíše len meno hráča
print(hrac[0]) # Vypíšeme meno hráča, ktoré sa nachádza na pozícií 0
print(type(hrac)) # <class 'tuple'>
Slovník (dictionary)
- slovník je podobný n-ticiam, len v tomto prípade sa označuje, ktorá hodnota čo znamená
- použiť ho môžeme napríklad pri zozname žiakov a ich veku: ziaci= {"Adam": "12", "Adela": "11", "Martin": "12"}
- k dátam pristupujeme napríklad print(ziaci.get("Adela")), v tomto prípade sa vypíše vek Martina
print(ziaci.get("Adela")) # Zobrazí vek Adely
print(type(ziaci)) # <class 'dict'>
Sety (set)
- zbierka podobná ako zoznam, len bez poradia alebo indexovania
- set = {"Nemocnica", "Škola", "Polícia", "74.14"}
- výpis funguje ako print(set) kde v každom novom behu programu bude zoznam v inom poradí
print(set) # Zobrazenie stále v inom poradí
print(type(set)) # <class 'set'>
3. Premenné
O premenným môžeme hovoriť ako o rezervovaní miesta v pamäti na ukladanie hodnôt. Do premennej sa dajú ukladať rôzne dátové typy. V jazyku Python ich nie je potrebné pred používaním deklarovať, deje sa to automaticky pri priradení hodnoty k premennej. Každá premenná je v jazyku Python totiž objektom. Môžeme ich definovať ako miesto v pamäti k uloženiu určitej hodnoty.
Deklarovaním premennej určíme jej názov a dátový typ (platí pre iné jazyky). Takejto premennej sa vyhradí miesto v pamäti spolu s hodnotou, ak ju určíme.
Hodnoty sa pripisujú pomocou „=“, kde na ľavej strane sa nachádza názov premennej, napravo hodnota. Názov premennej má určité pravidlá:
Nesmie začínať číslom, jedine písmenom alebo „_“
osX, _osY - správne
24osX, 0vysledok0 - nesprávne
V názve sa môžu nachádzať len čísla, písmená a „_“
dotyk_pin0 - správne
dotyk.pin0 - nesprávne
Premenné sú citlivé na veľké/malé písmená
V skratke to znamená, že ak je premenná napísaná správne, každým rozdielom v premenných vzniká ďalšia - Strana_A, strana_A, strana_a - tri rôzne premenné.
Príkazom print(x) jednoducho vypíšeme hodnotu uloženú v premennej x. Pri zlučovaní dvoch premenných platí pravidlo, že nie je možné zlúčiť dve premenné rôznych typov bez deklarovania ich typu. Príklad:
# Správne použitie
var = "string "
num = 14
print(var + str(num))
4. Operácie
Operácie využívajú operandy a operátory. Operandami sú premenné/čísla a operátormi znamienka, napríklad + alebo -. Na vykonávanie operácií používame operátory. Poznáme napríklad:
Aritmetické
+ - * /, ale aj modul %, exponent ** a delenie bez zvyšku //
c = a + b
print("a + b =", c) # 9
c = a - b
print('a - b =', c) # 3
c = a * b
print('a * b =', c) # 18
c = a / b
print('a / b =', c) # 2.0
c = a % b
print('a % b =', c) # 8
c = a**2 + b**2
print('a**2 + b**2 =', c) # 370
c = a // b
print('a // b =', c) # 1
Logické
AND a OR
print('b je väčšie ako a, zároveň je b väčšie ako 3')
elif a > b or a == 6:
print('a je väčšie ako b, zároveň a sa a rovná 6')
Bitové
používajú sa na bitové operácie – and(&), or(|), xor(^), komplement(~), binárny posun vľavo(<<) a vpravo(>>)
y = 14 # 1110
# and(&) - 1 ak bude na bitovom mieste oboch premenných 1
z = x & y
print('x & y =', bin(z)[2:])
# or(|) - 1 ak na bitovom mieste je aspoň jedna hodnota 1
z = x | y
print('x | y =', bin(z)[2:])
# xor(^) - 1 ak bude na bitovom mieste presne jedenkrát 1
z = x ^ y
print('x ^ y =', bin(z)[2:])
# komplement(~) - prevod každej 1 na 0 a opačne
z = ~x
print('~x =', bin(z))
# binárny posun vľavo(<<) - posun bitov o určitý počet miest vľavo (číslo sa zväčší)
z = x << 2
print('x << 2 =', bin(z)[2:])
# vpravo(>>) - posun bitov o určitý počet miest vpravo (číslo sa zmenší)
z = x >> 2
print('x >> 2 = ', bin(z)[2:])
Porovnávacie
rovná sa(==), nerovná sa(!= a <>), väčší(>), menší(<), väčší rovný(>=), menší rovný(<=)
if x == y:
print('x je rovné y')
if x != z:
print('x je rozdielne od z')
if x > z:
print('x je väčšie ako z')
if x < y:
print('x je menšie ako y')
if z >= y:
print('z je väčšie alebo rovné y')
elif z <= y:
print('z je menšie alebo rovné y')
Identifikačné
porovnáva objekty, či sú rovnaké – is a is not
b = a
if a is b:
print('a = b')
if a is not b:
print('a sa nerovná b')
Členské
testujú, či sa premenná nachádza v inej – in a not in
hladanyA = 'Martin'
hladanyB = 'Arnold'
if hladanyA in zoznam:
print('Našla sa zhoda')
else:
print('Nenašla sa zhoda')
if hladanyB not in zoznam:
print('Hľadaný sa v zozname nenachádza')
else:
print('Hľadaný sa v zozname nachádza')
Priraďovacie
priraďujú hodnotu do premennej (=) alebo sčítajú(+=), odčítajú(-=), vynásobia(*=), vydelia(/=), použijú modulus(%=), exponent(**=) alebo sa vydelí bez zvyšku(//=) a hodnota sa súčasne pridelí do premennej
premenna += 1
print('premenna += 1 =', premenna) # 1
premenna -= 2
print('premenna -= 2 =', premenna) # -1
premenna *= 3
print('premenna *= 3 =', premenna) # -3
premenna /= 2
print('premenna /= 2 =', premenna) # -1.5
premenna **= 2
print('premenna **= 2 =', premenna) # 2.25
premenna //= 4
print('premenna //= 4 =', premenna) # 0.0
5. Podmienky
Rozhodovacím procesom môžeme rozumieť zhodnotenie podmienok a následne vykonanie opatrení, ktoré sa vykonajú pri určitej podmienke. Rozhodovacie štruktúry hodnotia viacnásobné výrazy, ktorých výsledkom je TRUE alebo FALSE. Určujú sa kroky, ktoré budú podniknuté v prípade TRUE alebo FALSE. Python vo všeobecnosti predpokladá, že každá hodnota, ktorá nie je 0 a NULL, je TRUE.
Typy rozhodovacích procesov:
- If
- Else
- Vnorené výrazy – v rámci jedného určenia podmienky, môžeme použiť viackrát if/else alebo elif
x = 10
y = 3
# Jednoduchý príklad na if
if x > y:
print("x je väčšie ako y")# Else používame ak chceme, aby sa vykonal určitý proces, ak naša podmienka nebola splnená
if x > y:
print("x je väčšie ako y")
else:
print("x je menšie ako y")# Príklad na vnorenú funkciu
if x > y:
print("x je väčšie ako y")
elif x == y:
print("x sa rovná y")
else:
print("x nie je väčšie ani rovné y")
6. Cykly
Cykly sa opakujú do momentu, kedy bude splnená určitá podmienka, prípadne nejaká už nebude platná. Obyčajne for cyklus má určený presný počet iterácií, while funguje kým je splnená podmienka. Break môže prerušiť cyklus okamžite a continue sa presunie k nasledujúcej iterácii. Používajú sa hlavne na vykonávanie určitej činnosti viac ako jedenkrát - opakovane.
Pre cykly/iterácie, prechádzanie cez rôzne dátové štruktúry (zoznam, string, čísla) využívame for. Napríklad pre výpis mien zo zoznamu
for a in zoznam:
print(a) # Vypíšu sa všetky položky zo zoznamu
Vytvorila sa premenná a, ktorá sa použije na uloženie hodnoty zo zoznamu a následne na výpis až kým zoznam nebude prázdny. Pri každom výpise sa premenná prepíše na nasledujúcu hodnotu. Break môžeme použiť ak nájdeme hodnotu, ktorú sme hľadali alebo pre ukončenie cyklu. Continue je používané ak chceme určitú hodnotu vynechať napríklad z radu čísel.
print(a)
if a == "Matej Bel":
break # V tomto prípade sa vypíše prvé a druhé meno, potom sa cyklus zruší
Pre prechádzanie hodnôt v presnom počte, používame funkciu range(). Ak nešpecifikujeme inak, začína od 0 a rastie o 1. Pre určenie spodnej hranice sa vloží argument:
print(a) # Výpis čísiel od 2 do 9
if a == 9:
print("Všetky čísla boli vypísané úspešne.")
Tretím paramentrom sa určuje aká hodnota sa bude pripočítavať.
Miesto for sa môže použiť while. Iteruje pokiaľ je podmienka splnená:
while i < 12:
print(i)
i += 1 # i bude rásť o 1 pri každom prechode cyklu, vypíšu sa čísla od 0 do 11
Enumerate používame v prípade, ak chceme vypísať zoznam spolu s pozíciou.
print (x, y) # 0 Andrej Záborský 1 Matej Bel 2 Matúš Príkladný
7. Funkcie
Funkciami si môžeme rozdeliť svoj kód na menšie bloky, ktoré sa budú vykonávať keď ich zavoláme. Taktiež funkcie uľahčujú prácu tým, že ich môžeme použiť ľubovoľný počet krát. Program tvorený funkciami je oveľa prehľadnejší ako bez nich, taktiež je takmer nemožné vytvárať väčšie projekty bez nich. Pri vytváraní funkcie musí byť vždy prvým slovom def nasledované názvom funkcie a zátvorkami, po ktorých nasleduje dvojbodka. Názov funkcie sa riadi pravidlami ako premenné, nemôžeme ich pomenovať rôznymi znakmi, nemôžu začínať číslami. Použiteľnými sú samozrejme písmená a-z, A-Z, čísla 0-9 a _. Pri definovaní funkcie môžeme použiť argumenty, ktoré budú ďalej predané funkcii počas jej behu, čo ale povinné nie je. Funkcie sú spustené len v momente, kedy budú zavolané.
Funkcie vytvárame nasledovne:
print("Trieda 3. B: " + meno)
# Následne funkciu zavoláme
funkcia("Matej Bel")
funkcia("Andrej Záborský")
Do argumentov funkcie môžeme vložiť čokoľvek, čo budeme používať.
8. Objekty a triedy
Python je objektovo-orientovaný programovací jazyk. To zjednodušene znamená, že takmer všetko je objekt. Trieda je návrh pre vytvorenie objektu, logické usporiadanie dát a funkcií. Umožňuje nám vytvárať dátové štruktúry, ktoré obsahujú ľubovoľný obsah a sú ľahko dostupné. Triedy nám poskytujú potrebné zoskupenie dát a funkcionalít do jedného objektu. Každá trieda môže obsahovať atribúty a metódy. Atribútmi sú napríklad premenné, s ktorými sa v rámci tried pracuje. Metódami sú funkcie. V jazyku Python triedy obsahujú všetky štandardné súčasti objektovo-orientovaného programovania - napríklad dedičnosť.
Triedu vytvárame pomocou class:
class novaTrieda:
x = 15
def funkcia(self):
print("Výpis funkcie")
novyobjekt.funkcia() # Na obrazovku sa vypíše „Výpis funkcie“
print(novyobjekt.x) # Zobrazí hodnotu x v triede novaTrieda
Dedičnosť
- Používa sa v objektovo-orientovanom programovaní
- Odkazuje na definovanie novej triedy s malými alebo žiadnymi zmenami k už existujúcej triede
- Derivovaná trieda „dedí“ atribúty a metódy, ktoré zvolíme
def metoda1(self):
print("Student")
def metoda2(self):
print("potomok triedy, metoda 2")
c2 = dieta()
c2.metoda1()
c2.metoda2()
main()