Ťahák základných príkazov + tkinter

Veľmi dôležité! Python je CASE-SENSITIVE! Je rozdiel medzi veľkými a malými písmenami (napr. b a B).

Texty vždy píšeme v úvodzovkách. Buď „text“ alebo ‘text’ → nikdy nie kombinácia dvojitá text jednoitá úvodzovka, musia byť rovnaké.

Rada: Nikdy nenazvite súbor tkinter.py alebo názvom inej internej knižnice napr. random.py lebo nič vám nebude fungovať. Sú to chránené názvy knižníc, ktoré majú vlastné súbory s týmto názvom.

Tento ťahák je spísaný z mojich skúseností s programovaním v Pythone a z rôznych iných ťahákov na internete.

Obsah:

A) Základné príkazy všeobecné pre Python:

  1. Komentovanie
  2. Premenné (lokálne, globálne)
  3. Pretypovanie premennej
  4. Matematické operácie
  5. Získavanie vstupu od používateľa v Shelli
  6. Vypísanie textu do Shellu
  7. Náhoda (využitie modulu random)
  8. For cyklus
  9. Podprogramy/Funkcie/Procedúry
  10. Podmienky (if)
  11. Cyklus s podmienkou – While
  12. Práca s textovými reťazcami
  13. Jednorozmerné polia
  14. Dvojrozmerné polia
  15. Tuple (ntice)
  16. Asociatívne polia
  17. Textové súbory – zapisovanie a dopisovanie
  18. Textové súbory – čítanie
  19. Try-except
  20. Triedy (OOP)

B) Grafika – Modul Tkinter:

  1. Načítanie grafiky
  2. Základné grafické príkazy na kreslenie
  3. Ako môžeme zadávať súradnice
  4. Jednoduchý časovač do for cykla
  5. Pravý časovač používaný vo funkciách
  6. Udalosti myši
  7. Udalosti klávesnice
  8. Posúvanie objektov canvasu (aj klávesom, časovačom)
  9. Kolízia (objektov, myš a objekt)
  10. Entry vstupný box a tlačidlo button
  11. Práca s obrázkami – png a gif
  12. Problémy s obrázkami (využitie modulu os)
  13. Vylepšenia do tkinter okna

C) Iné moduly:

  1. Modul winsound (hudba s príponou .wav)
  2. Modul time
  3. Modul math (matematika)
  4. Modul os (cesta k súboru)
  5. Modul random (náhoda)

Základné zásady programovania v Pythone


A) Základné príkazy všeobecné pre Python + modul Random

1. Komentovanie:

# - znak na zakomentovanie
## - alebo dva heštegy

SK klávesnica:
ALT - SHIFT (oba ľavé) - 3 (hore, tam kde sú písmená s diakritikou)

Anglická klávesnica:
SHIFT (ľavý) - 3 (hore, tam kde sú písmená s diakritikou)

Pre obe klávesnice:
- ak označím celý blok textu a potom stlačím zakomentovávanie, tak mi zakomentuje celú časť naraz dvoma ##
- ak označíte zakomentovaný text a stlačíte namiesto 3 číslo 4 (hore), tak vám odkomentuje celý blok kódu

Komentovanie v editore mu:
- treba označiť kód a stlačiť CTRL+K

Komentovanie v prostredí IDLE:
- označím príkazy a hore na lište Format -> Comment Out Region
- odkomentovanie rovnako ale je tam Uncomment Region

2. Premenné:

Typy premenných:

  • int alebo integer – celé čísla kladné aj záporné (napr. 1, 2, 15, 90…)
  • float – reálne čísla, desatinnú čiarku píšeme bodkou!!! (napr. 0.6 , 9.7 alebo aj zapísané v tvare zlomku 1/3)
  • str alebo string – reťazce, znaky, texty, píšeme vždy v úvodzovkách buď v jednoitých alebo dvojitých (napr. „pes“ , ‘auto’ )
  • bool – logický typ, ktorý nadobúda hodnoty True alebo False – pozor, píšeme s veľkým T a veľkým F !!! (True , False)
  • list – pole, zoznam, píše sa v hranatých zátvorkách [ ]
  • tuple – ntica, píšeme v normálnych zátvorkách ( )
  • dict alebo dictionary – slovník, asociatívne pole, píšeme v kučeravých zátvorkách { }

Práca s premennými:

nazovpremennej = hodnota      #priradenie

Zvyšovanie hodnoty premennej o hodnotu napr. 10; číselné premenné integer: 
a = 32
a = a + 10         #aká bude teraz hodnota premennej? a=32+10 → a bude mať hodnotu 42

Znižovanie hodnoty premennej o hodnotu napr. 10:
a = 32
a = a - 10         #aká bude teraz hodnota premennej? a=32-10 → a bude mať hodnotu 22

Textové premenné - string:
a = "slovo"

Premenná s farbou:
farba = "blue"

Premenná s logickou hodnotou True/False:
logika = True

Lokálne premenné:

  • používané ak mám program, ktorý neobsahuje funkcie, alebo sa používajú tieto premenné buď iba vo funkcii alebo iba mimo funkcie

Globálne premenné:

  • používajú sa vtedy, ak chcem rovnaké premenné používať v rámci celého programu, v rôznych funkciách, aj mimo funkcií
  • vždy vo funkcii musím povedať pomocou príkazu global, aby program skontroloval všetky premenné a ak sú v ňom premenné s daným názvom, tak budem používať práve tie
a = 10
b = "Ahoj"

def nazovfunkcie():
    global a
    global b
    # alebo spolu zapísať:  global a, b
    # dalsie prikazy....

# premenné a b môžu byť definované aj tu
nazovfunkcie()

3. Pretypovanie premennej:

int(textovapremenna)     #pretypovanie textovej premennej na číslo, iba ak tam máme uložené texty, ktoré sú vlastne čísla v úvodzovkách "1" → 1
str(ciselnapremenna)     #pretypovanie celočíslenej premennej na text 1 → "1"

4. Matematické operácie:

Základné aritmetické operácie: 
// celočíselné delenie         22 // 7 má hodnotu 3  
%  zvyšok po delení            22 % 7 má hodnotu 1  
** umocňovanie                  2 ** 8 má hodnotu 256 
*  viacnásobné zreťazenie      3 * 'la' má hodnotu 'lalala'

premenná = premenná + hodnota   #pripočítaj hodnotu k hodnote v premennej
premenná += hodnota    #zjednodušene zapísané

premenná = premenná - hodnota  #odrátaj hodnotu od hodnoty v premennej
premenná -= hodnota   #zjednodušene zapísané

premenná = premenná * hodnota  #vynásob hodnotu v premennej zadanou hodnotou
premenná *= hodnota    #zjednodušene zapísané

premenná = premenná / hodnota  #vydeľ hodnotu v premennej zadanou hodnotou -> výsledok je reálne číslo
premenná /= hodnota     #zjednodušene zapísané

premenná = premenná // hodnota #celočíselne vydeľ hodnotu v premennej zadanou hodnotou
premenná //= hodnota    #zjednodušene zapísané

5. Získavanie vstupu od používateľa v Shelli:

vstup = input("Zadaj text: ")      #ak pýtame texty - stringy
vstup = int(input("Zadaj číslo: "))  #ak vieme, že chceme od používateľ celé číslo
#vstup si treba uložiť do nejakej premennej

6. Vypísanie textu do Shellu:

print("Ahoj")      #vypísanie textu do Shellu - stringov
print(str(135))    #vypísanie čísla do Shellu (musíme pretypovať z čísla na string)
print(textovapremenna)   #môžeme vypísať aj text, ktorý máme v premennej
print(str(ciselnapremenna))   #ak chceme vypísať číslo, ktoré je v premennej

7. Náhoda:

Načítanie náhodných čísiel – 2 spôsoby (väčšinou využívam prvým spôsob):

  • vždy musíme najprv importovať používaný modul/knižnicu, inak zvyšné príkazy fungovať nebudú
1.spôsob:

from random import * #tento príkaz dať úplne hore, niekde tam, kde načítavam aj grafiku

a = randrange(10, 20) #nepíšeme random.randrange, ale iba príkaz bez toho, aj pri ostatných typoch
b = randint(10,20)
farba = choice(('red', 'green', 'blue', 'black'))
cislo = choice([1, 2, 5, 10, 20, 50]) #alebo: cislo = choice((1, 2, 5, 10, 20, 50))
pismeno = choice(["K", "I", "s", "u", "I", "á"]) #alebo: pismeno = choice(("K", "I", "s", "u", "I", "á"))

# príkazy fungujú rovnako v oboch prípadoch ale vždy si musíme vybrať, ktorý spôsob použijeme

2.spôsob: 

import random  - vždy pred použitím musíme importovať knižnicu na náhodu 
a = random.randrange(10)  - môže mať 1 alebo 2 vstupy - toto vypľuje náhodné číslo v rozmedzí 0-9 - random.randrange(10,20) - toto vypľuje náhodné číslo v rozmedzí 10-19 
b = ramdom.randint(10,20) - musí mať 2 vstupy - toto vypľuje náhodné číslo v rozmedzí 10-20 
farba = random.choice(('red', 'green', 'blue', 'black')) - náhodná farba - vyberie si zo 4 možností - dá sa aplikovať aj na niečo iné, náhoda si vyberie jedno z uvedených možností oddelených čiarkou
cislo = random.choice([1, 2, 5, 10, 20, 50])   - vyberie si rôzne náhodné čísla
pismeno = random.choice(["K", "I", "s", "u", "I", "á"]) - vyberie si rôzne náhodné písmená/znaky
Náhodné farby z celej palety:
def rgb(r, g, b):
  return '#{:02x}{:02x}{:02x}'.format(r, g, b)
farba = rgb(randrange(256),randrange(256),randrange(256))
#pozor, toto je len keď máme from random import *, ak máme import random, potom dávame random.randrange()

8. For cyklus:

Princíp for cyklu – zdroj Kövesiová
  • ukážka cyklus – youtube video
  • vysvetlenie cyklus na rozprávke (zdroj: Žofia Kružliaková)
  • i je riadiacia premenná cyklu – počítadlo – postupne sa počas cyklu mení, zmení sa toľkokrát, koľkokrát má ísť cyklus, podľa toho, akú máme postupnosť; označenie i sa používa všeobecne, ale môže mať aj iné označenie
  • pozor! range ide vždy o jedno menej. príklad: range(0,9) , prípadne toto isté viem zapísať aj takto: range(9)
    • cyklus zbehne 9-krát, ide od 0 do 8
    • teda i bude mať hodnoty 0, 1, 2, 3, 4, 5, 6, 7, 8
zdroj obrázka (source)

Ako zapisujeme FOR cyklus v pythone? Je na to viac rôznych spôsobov:

Cyklus s použitím range, ktorý beží určitý počet krát:
range(po)  #napr. range(5) -> zbehne 5x, i bude mať hodnoty 0,1,2,3,4 (teda zbehne od 0 do po-1, teda do 4)
range(od, po) #napr. range(1,5) -> zbehne 4x, i bude mať hodnoty 1, 2, 3, 4
range(od, po, krok) #napr. range(1,8,2) -> zbehne 4x, i bude mať hodnoty 1, 3, 5, 7 -> preskakuje, krok hovorí ktoré číslo má preskočiť, tu každé druhé, vypíše len nepárne čísla
#pozor! po v range, ide vždy o jedno menej!!!!

Zápis:

for i in range(10): #čísla od 0 do 9
    print(i)

for i in range(5,10): #čísla od 5 do 9 
    print(i, end=' ')

for i in range(2,100,2): #čísla od 2 do 99 ale iba párne - tretie číslo hovorí o preskovaní v cykle
    print(i, end=' ')

-------------------------------------------------------

for i in premenna: #v premennaej musí myť string, pole alebo ntica napr. premenna = "Ahoj"
    print(i)

for i in 1,2,3:
    print(i)

for i in 2,3,5,11: 
    print(i**2)  #počítanie druhej mocniny číslu

for i in "AHOJ":
    print(i, end=' ') 

for i in "a","b","c","d":
    print(i)


break  #príkaz na vyskočenie z cykla, ukončenie cykla
pass  #prázdniny príkaz, nerobí nič
continue #na tomto mieste sa ukončí vykonávanie danej iterácie cyklu a pokračuje sa ďalšou hodnotou riadiacej premennej

- veľmi dôležité: príkazy, ktoré sa majú vykonať v rámci for cyklu, musia byť ďalej od okraja
- oddelenie od okraja sa urobí automaticky, ak je správne zapísaná hlavička for cyklu
- prípadne vieme urobiť oddelenie - na stlačenie TAB (tabulátora)
- alebo na 4 údery medzerníkom

9. Podprogramy/Funkcie/Procedúry:

  • vysvetlenie čo je to funkcia s ukážkou na pythone po slovensky – youtube video
#bez parametrov
def nazov():
    # prikazy

nazov()

#s parametrami, môže tam byť jeden aj viac)
def nazov(parameter1, parameter2, parameter3):
    # prikazy

nazov(hodnota1, hodnota2, hodnota3)

#funkcie s návratovou hodnotou
def navratovaNazov(): #v závorke môžu byť tiež parametre
     #prikazy
     return vysledok

ulozeniedopremennej = navratovaNazov()

10. Podmienky:

 if podmienka:
    prikazy
 else:
    prikazy

#zložitejšia podmienka

if podmienka:
    prikazy
elif inapodmienka:  #elifov môžeme mať aj viac
    prikazy
else:
    prikazy

#podmienka v matematickom zápise: <, >, <=, >=, == (rovná sa), != (nerovná sa), not (zápor)
#dve podmienky spojené: and (a zároveň), or (alebo)

Príklad jednoduchej podmienky:
if pocet == 12:
    #prikazy

Alebo zložená podmienka, ktorá obsahuje aj and alebo or:
if pocet == 12 and den = "pondelok":
    #prikazy

Napr.:
if 100 > body >= 90:
    print('za', body, 'bodov získavaš jednotku')
elif body >= 80:
    print('za', body, 'bodov získavaš dvojku')
else:
    print('rachol si')

11. Cyklus s podmienkou – While

Princíp while cyklu – zdroj Kövesiová
while podmienka:              # opakuj príkazy, kým platí podmienka
    prikaz
    prikaz
    ...

while podmienka:
    prikaz
    prikaz
    ...
else:
    prikaz # vetva else je nepovinná!


#nekonečný cyklus, ktorý ale môže spadnúť:
while True:  #alebo while 1:
    prikazy


#break ->> príkaz na vyskočenie z cykla, ukončenie cykla

12. Práca s textovými reťazcami

Zdroj obrázka: A.Blaho Programovanie
Čo vieme o znakových reťazcoch (stringoch):
• reťazec je postupnosť znakov uzavretá v úvodzovkách alebo apostrofoch, vieme ho aj vypísať
     "Ahoj" , 'Ahoj'
     print("Ahoj")
• priradiť reťazec do premennej
     text = "Ahoj"
• zreťaziť (zlepiť) dva reťazce
     text = "Ahoj" + " a ako sa máš?"
     text = text + "Dobrý deň."
• násobiť (zlepiť viac kópií) reťazca
      slovo = "ahoj"*3
      #print(slovo) by vypísalo "ahojahojahoj"
• načítať zo vstupu (pomocou input()) a vypisovať (pomocou print())
     slovo = input("Zadaj nejaké slovo")
     print(slovo)
• vyrobiť z čísla reťazec (str()), z reťazca číslo ( int(), float())
     cislo = int("12") #v premennej cislo bude 12
     text = str(12) #v premennej text bude "12"
• rozobrať reťazec vo for-cykle ->>> for znak in retazec:
     for i in "Ahoj":  #alebo for i in slovo: #ak mám definové: slovo = "ahoj"
         print(i) #do premennej i sa mi postupne priraďujú písmená a, h, o, j

meno = "Karol"
meno2 = "Boris"
vek = 15
#3 spôsoby toho istého výpisu:
print("Ahoj",meno,"dnes je krásny deň, preto máš",vek,"rokov. Vieš, kedy má",meno2,"narodeniny?")
print("Ahoj "+meno+" dnes je krásny deň, preto máš "+str(vek)+" rokov. Vieš, kedy má "+meno2+" narodeniny?")
print('Ahoj {}, dnes je krásny deň, pretože máš {} rokov. Vieš, kedy má {} narodeniny?'.format(meno, vek, meno2))
len(meno) #vráti počet znakov v reťazci - v tomto prípade 4

retazec = "nejaky text"
retazec.find(podreťazec) # vráti index prvého výskytu podreťazca v reťazci
retazec.lower() # vráti reťazec, v ktorom všetky veľké písmená zamení za malé
retazec.upper() # vráti reťazec, v ktorom všetky malé písmená zamení za veľké
retazec.replace(podreťazec1, podreťazec2) # vráti reťazec, v ktorom nahradí všetky výskyty podreťazec1 za reťazec podreťazec2.

pole = ["Adam","Peter","mačka"]
text = ', '.join(pole) #všetky prvky spojí do reťazca a ako oddeľovač medzi nimi dá to, čo dáme medzi úvodzovky, takže vyjde z toho jeden string z pôvodných prvkov pola
# print(text) -> Adam, Peter, mačka
#rezy:
>>> s = "Ahojky caute vsetci"
>>> s[4:10]
'ky cau'

#ASCII kód znakov:
#Pomocou funkcie ord(‘a’) zistíme ASCII kód znaku ‘a’. Naopak funkciou chr(97) zistíme, ktorý znak má číslo 97 v tabuľke kódovania znakov.

 >>> ord("a")
97
>>> chr(97)
'a'

Ďalšie funkcie, využívané na reťazcoch:

float() – prevod reťazca na desatinné číslo
bin() – prevod celého čísla do reťazca, ktorý reprezentuje toto číslo v dvojkovej sústave
hex() prevod celého čísla do reťazca, ktorý reprezentuje toto číslo v šestnástkovej sústave
oct() – prevod celého čísla do reťazca, ktorý reprezentuje toto číslo v osmičkovej sústave

13. Jednorozmerné polia (zoznamy, list):

ukážka číselného poľa
ukážka zmiešaného poľa
#1. vytvorenie prázdneho pola
prazdnepole = []
print(prazdnepole)

#inak vytvorenie prazdneho pola:
p = list()
print(p)

#2. vytvorenie hneď naplneného pola
polecisel = [5, 6, 7, 8] #pole čísel
print(polecisel)

poletextov = ["ahoj", "čau", "p"] #pole textov
print(poletextov)

zmiesanepole = ["ahoj", 5, "p", True, 36] #zmiešané pole
print(zmiesanepole)

#3. napĺňanie pola - koľko prvkové pole budeme mať? aké budú mať hodnoty?
pole = []
for i in range(5):
    pole.append(randint(1,10)) #náhodné číslo do pola, alebo rovno môžete pridať hodnotu
print(pole)

# 4.Prechádzanie poľom:
pole = [1, 5, 9]
for i in range(len(pole)):
     print(pole[i])

#iný spôsob:
pole = [1, 5, 9]
for prvok in pole:
     print(prvok)

------------------------------
print(pole[3]) #viete i vypísať hodnotu na danom mieste 
pole[3] = -19 #viete zmeniť hodnotu na danom mieste
len(pole) #zistenie dĺžky poľa, často sa to používa pri prechádzaní poľom

Postupnosť čísel, ktoré sú oddelené medzerami môžete načítať aj týmto príkazom od používateľa cez shell, potvrdíme enterom. Často sa to používa pri súťažiach KSP, Zenit alebo Informatická olympiáda:

pole = list(map(int, input("Pridaj prvky pola oddelene medzerou: ").split()))

#do shellu zadáme:
231 12 14 16
>> print(pole)
[231, 12, 14, 16]

#To isté, ale rozložené na dva príkazové riadky:
zoz=input("Zadaj čísla oddelené medzerou: ").split() #vráti pole stringov
zoznamcisel=list(map(int,zoz)) #vysledkom bude pole hodnôt typu int (integer - celé číslo)

#do shellu zadáme:
231 12 14 16
>>> print(zoz)
['231', '12', '14', '16']
>>> print(zoznamcisel)
[231, 12, 14, 16]

14. Dvojrozmerné polia (listy, zoznamy, matice):

ukážky dvojrozmerných polí – rovnaká veľkosť, rôzna veľkosť

Vytvorenie dvojrozmerného poľa:

#1.spôsob
dvojpole = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(dvojpole)

#2.spôsob
riadok1 = [1, 2, 3]
riadok2 = [4, 5, 6]
riadok3 = [7, 8, 9]
polko = [riadok1, riadok2, riadok3]
print(polko)

#3.spôsob
pole = []
for i in range(3):
    pole.append([0, 0, 0])
print(pole)

#4.spôsob
dvojrozmerne = []
for riadok in range(3):   #namiesto 3ky môže byť radšej premenná pocetriadkov
    pom = []
    for stlpec in range(3): #namiesto 3ky môže byť radšej premenná pocetstlpcov
        pom.append(0)
    dvojrozmerne.append(pom)
print(dvojrozmerne)

#5.spôsob
p = []
riadkov = 3
stlpcov = 3
for i in range(riadkov):
    p.append([0] * stlpcov)
print(p)

Ako čítať konkrétne miesto v poli – prechádzanie poľom:

->>> prepokladám, že mám vytvorené dvojrozmené pole p
for i in range(riadok):
   for j in range(stlpce):
       print(p[i][j])

->> ak neviem počet stĺpcov a riadkov v poli p, musím to robiť takto:
 for i in range(len(p)):
     for j in range(len(p[i])):
         print(p[i][j])

#Dôležité! Ak chceme pristupovať ku konkrétnej hodnote v poli, robíme to: 
p[riadok][stlpec] #Pri jednorozmernom poli nám stačilo urobiť p[index]
->> prípadne to môžem urobiť aj takto:
 for prvokriadku in p:
     for prvokstlpca in prvokriadku:
         print(prvokstlpca) #tu už hneď získame prvok

15. Tuple / n-tice:

Sú niečo ako jednoduchšie pole…

body = () #prázdna ntica
body = body + (x,y) #pridanie súradníc do ntice

ntica = tuple(range(1000000))
farby = ('red', 'green', 'blue', 'yellow', 'orange', 'grey')
# prechádzanie po nticiach vo for cykle:
#for farba in farby:
#funkcie s nticami:
len(ntica)
sum(ntica)
min(ntica)
max(ntica)
ntica.count(hodnota) 3 vráti počet výskytov nejakej hodnoty
ntica.index(hodnota) # vráti poradie prvého výskytu hodnoty, ak sa nenachádza, vznikne chyba

16. Asociatívne polia (slovníky):

asoc = {"Rudo":19, "Šani":28, "Judita":32}
#asoc = {kľúč : hodnota}
slovnik = {"pes":"dog", "mačka":"cat", "zajac":"rabbit"}

#funkcie na asociatívnych poliach:
type(asoc)
len(asoc)
asoc["Rudo"]
asoc["Feri"] = 10  # pridanie nového kľúča
if "Jan" in asoc: #vráti true/false podľa toho, či sa to nachádza v asoc.poli alebo nie
asoc.keys() # postupnosť kľúčov
asoc.values() # postupnosť hodnôt
asoc.items() # postupnosť prvkov ako dvojice kľúč a hodnota
for kluc, hodnota in asoc.items():
    print(kluc, hodnota)
asoc.get(kľúč) #vráti príslušnú hodnotu alebo None, ak kľúč neexistuje
apole.get(kľúč,náhradná) #vráti príslušnú hodnotu alebo vráti hodnotu parametra náhradná, ak kľúč neexistuje
del apole[kľúč] #zruší dvojicu kľúč:hodnota alebo príkaz spadne na chybe KeyError, ak neexistuje

17. Textové súbory – zápis a dopisovanie:

  • Prázdny súbor môžete alebo nemusíte mať vytvorený.
  • Súbor musíme vždy otvoriť a zavrieť! Vždy keď urobíte open, musíte si zapísať aj close.
  • Súbor sa vždy prepisuje „w“.
  • Zapisovanie pomocou príkazu write vždy píše do jedného riadku, ak chcete, aby ďalšie slovo/vetu písalo na nový riadok, treba pridať \n
  • Zapisovanie pomocou príkazu print, môžete pridať aj end, sem viete pridať oddeľovač, napr medzeru, alebo nový riadok, čiarku, hviezdičku, …. a treba napísať že do ktorého filu (súboru) zapisujete.
  • Ak chcete pokračovať v zápisoch, nahraďte „w“ pímenom „a“ – znamená append, pridáva na koniec súboru.
  • Pri práca si súbormi, majte vždy zavretý .txt súbor!!!!!!!!!!!!!!!!!! Nenechajte si ho otvorený!!!!!!!!!!!!
subor = open('zapis.txt', 'w') #w - prepisovanie súboru, vieme nahradiť aj inými písmenami "a", zapisovanie na koniec, "r" len čítanie
subor.write("Čauko kakuko")
subor.close()

subor = open('zapis.txt', 'w')
subor.write("Čauko kakuko\n")
subor.write("Halo hahaha")
subor.close()

subor = open('zapis.txt', 'w') #keby máme namiesto "w" písmeno "a", tak by nám dopisovalo do súboru, nechalo by tam aj to pôvodné, čo tam bolo
for i in range(10):
   print(randint(1, 100), end=' ', file=subor)
subor.close()

18. Textové súbory – čítanie zo súboru:

  • Pri čítaní zo súboru, musí už súbor existovať!!!!!
  • Súbor musíme vždy na začiatku otvoriť a zavrieť!
  • Ak chceme čítať súbor, musíme napísať, že ideme čítať zo súboru „r“.
  • Celý súbor vieme prečítať naraz pomocou príkazu read.
  • Obsah si môžeme uložiť do premennej alebo ho rovno vypísať napr. do shellu, zapísať do iného súboru, napísať na canvas…
  • Ak chceme prečítať súbor po riadkoch, tak čítame pomocou readline() ->>.> pozor na čítanie iba pomocou readline, pozrite sa ako to vypísalo a ako to vyzerá v skutočnosti v súbore!
  • Pomocou príkazu repr(riadok) viete zistiť, aké skryté znaky sa nachádzajú v texte.
  • Všimli ste si, že sa nám vypisujú aj tie skryté znaky, vieme ich odstrániť pomocou príkazu riadok. strip(). Odporúčam mať to ale aj v tom repr. Tak si zabezpečíte, že vám krásne prečíta celý riadok.
  • Funkcia strip() nám vie odstrániť medzery aj skryté znaky (koniec riadka) z textu. Ale čo ak to tak nechcem? Čo ak chcem vymazať len znak konca riadka? Vieme použiť rstrip() – odstráni medzery a znak konca riadka sprava, lstrip() odtráni medzery a iné skryté znaky zo začiatku riadka.
  • Ak náhodou máme diakritiku a škaredo to zobrazuje, treba čítať takýmto spôsobom: subor = open(meno_suboru, encoding=’utf-8′)
subor = open('citaj.txt', 'r')
print(subor.read())
subor.close()

subor = open('citaj.txt', 'r')
for i in range(0,5):
    riadok = subor.readline()
    print(riadok)
subor.close()

subor = open('citaj.txt', 'r')
for i in range(0,5):
    riadok = subor.readline()
    print(repr(riadok))
subor.close()

subor = open('citaj.txt', 'r')
for i in range(0,5):
    riadok = subor.readline()
    print(repr(riadok.strip()))
subor.close()

#Ak neviem počet riadkov súboru, tak takto:
subor = open('citaj.txt', 'r')
riadok = subor.readline()
while riadok != '':
   print(repr(riadok.strip()))
   riadok = subor.readline()
subor.close()

#alebo toto - ja preferujem tento spôsob:
subor = open("data.txt", "r")
for riadok in subor:
    print(riadok.strip())
subor.close()

19. Try-except

Je to formulka, pomocou ktorej viete odchytávať errory a upozorňovať na ne používateľa.

try:
  print(x)
except NameError:  #dá sa zapísať aj viac výnimiek naraz except (ValueError, IndexError):
  print("Premenná x nie je definovaná")
except:
  print("Iná chyba, niečo je zle")

Bežné typy errorov: ValueError, NameError, IndexError, TypeError, ZeroDivisionError

20. Triedy (OOP)

 class Nazovtriedy:

    def __init__(self, atr1, atr2, atr3=''):
        self.meno = atr1
        self.priezvisko = atr2
        self.adresa = atr3

    def vypis(self):
        print('volam sa', self.meno, self. priezvisko)

fero = Nazovtriedy('Frantisek', 'Mokry')
fero.vypis()
>> "volam sa Frantisek Mokry"

B) Grafika – Modul Tkinter:

1. Načítanie grafiky:

  • prvé tri príkazy musíme vždy načítať, ak budeme pracovať s grafikou tkinter
import tkinter 
c = tkinter.Canvas() 
# alebo c = tkinter.Canvas(bg='white', width=1000, height=600) #bg je farba pozadia, šírka, výška
c.pack()


#c.mainloop() #tento príkaz treba zadať úplne na konci súboru v iných editoroch než IDLE
ako je to s grafickým plátnom (plochou)

2. Základné grafické príkazy na kreslenie:

 c.create_line(x1,y1,x2,y2,x3,y3,...)
 nakreslí čiaru idúcu z bodu so súradnicami [x1,y1], do bodu [x2,y2], ďalej do bodu [x3,y3], prípadne ďalej do ďalších bodov
 c.create_line(x1,y1,x2,y2,width=5,fill='red')
 toto nastaví hrúbku čiary na 5 a jej farbu na červenú. Okrem základných môžete použiť aj nasledujúce farby: ‘orange’, ‘fuchsia’, ‘olive’, ‘skyblue’, a pod.
 c.create_rectangle(x1,y1,x2,y2)
# fill='red', outline='red', tag="auto"
 nakreslí obdĺžnik/štvorec, ktorý bude mať ľavý horný roh v bode so súradnicami [x1,y1] a pravý dolný roh v bode so súradnicami [x2,y2]
outline – zafarbí orámovanie útvaru; tag – označenie na budúcu manipuláciu
 c.create_rectangle(x1,y1,x2,y2,outline='blue')
# fill='red', outline='red'
 outline nastaví farbu čiary na modrú
 c.create_oval(x1,y1,x2,y2)
# fill='red', outline='red'
 nakreslí elipsu/kružnicu, ktorá bude vpísaná do obdĺžnika (preto vieme určiť x1,y1,x2,y2) s ľavým horným rohom v bode so súradnicami [x1,y1] a pravým dolným rohom v bode so súradnicami [x2,y2]
 c.create_polygon(x1,y1,x2,y2,x3,y3)
# fill='red', outline='red'
 nakreslí polygón, ktorý môže byť aj vyfarbený (napríklad na kreslenie trojuholníka, 5,6,7,8,9-uholníka… vždy treba zadať pre každý bod aj x aj y)
 c.create_text(x,y,text='toto sa vypíše',
font='Arial 70 bold',angle=90)
# fill='red'
 vypíše text „toto sa vypíše“ na súradnici x,y (x,y sú presné súradnice stredu textu), parameter „font“ môže, no nemusí byť zadaný, parametrom „angle“ otočíme napísaný text o príslušný uhol (tiež to nie je povinný parameter)
 c.delete("all")
 
 c.delete("nazov_tagu")
zmazanie grafickej plochy (používa sa často práve vtedy, ak robíme s c.after(100) – c.update() ); vnútri môže vyť aj tagmôžeme zmazať aj otagovaný objekt

3. Ako môžeme zadávať súradnice:

Ako pracovať so súradnicami
Kružnica alebo Elipsa má tiež rohy, pretože s ňou pracujeme tak, akoby bola vpísaná do štvorca / obdĺžnika.
Vyber si spôsob, ktorý ti najviac vyhovuje, alebo ktorý pri danom príklade najlepšie využiješ.

1. Ako súradnice si určíme ľavý horný (x1,y1) a pravý dolný roh (x2, y2)
    c.create_rectangle(x1,y1,x2,y2) #pri kreslení štvorca, kružnice, elipsy, obdĺžnika

2. Ako súradnice si určíme ľavý dolný roh (x1, y1) a pravý horný roh (x2, y2) 
    c.create_rectangle(x1,y1,x2,y2) #pri kreslení štvorca, kružnice, elipsy, obdĺžnika

3. Ako súradnice si určíme ľavý horný roh x,y a dĺžku strany a:
    c.create_rectangle(x,y,x+a,y+a) #pri kreslení štvorca a kružnice

4. Ako súradnice si určíme ľavý dolný roh x,y a dĺžku strany a:
    c.create_rectangle(x,y,x+a,y-a)  #pri kreslení štvorca a kružnice

5. Ako súradnice si ľavý horný roh x,y a dĺžky strán a, b:
    c.create_rectangle(x,y,x+a,y+b) #pri kreslení obdĺžnik a elipsy

6. Ako súradnice x,y si zvolíme stred objektu a určíme si polomer strany v.
   Potom vykresľujeme tak, že zadáme ľavý horný roh, ktorý bude mať súradnice (x-v, y-v)
   a pravý dolný roh, ktorý bude mať súradnice (x+v, y+v)
     c.create_rectangle(x-v,y-v,x+v,y+v) #kreslenie štvorca a kruhu

7. Rovnako ako 6. body, ale mám polomer kratšej a dlhšej strany v, k.
     c.create_rectangle(x-v,y-k,x+v,y+k) #kreslenie štvorca a kruhu

Pri ďalších grafických útvaroch:

ukážka
1. čiara:
    c.create_line(x1,y1,x2,y2) #môžem mať aj len x,y ľavý bod a veľkosť v, potom pravý bod bude x+v, y
2. čiara s viacerými bodmi:
    c.create_line(x1,y1,x2,y2,x3,y3)
3. čiara s viacerými bodmi, pozor! nevieme urobiť fill! sú to len čiary, preto nevieme vyfarbiť vnútro:
    c.create_line(x1,y1,x2,y2,x3,y3,x1,y1)
4. polygón - mnohouholník, v tomto prípade trojuholník, vieme urobiť aj fill - vieme vyfarbiť vnútro:
    c.create_polygon(x1,y1,x2,y2,x3,y3,x1,y1)
    c.create_line(x1,y1,x2,y2,x3,y3) #ak nezadám bod, s ktorým mám uzavrieť útvar, tak automaticky posledný bod spojí s prvým
5. polygón - mnohouholník, v tomto prípade päťuholník, vieme urobiť aj fill - vieme vyfarbiť vnútro:
    c.create_polygon(x1,y1,x2,y2,x3,y3,x4,y4,x5,y5)
    c.create_polygon(x1,y1,x2,y2,x3,y3,x4,y4,x5,y5,x1,y1) #alebo takto
6. vypisovanie textu - x,y je vždy v strede textu:
    c.create_text(x,y,text="niečo")

4. Jednoduchý časovač do for cykla:

Postupné vykresľovanie objektov – jednoduchý časovač – používaný vo for cykle (dáva sa do for cyklu!):

c.after(1000)           #v zátvorke je počet milisekúnd
c.update()

5. Pravý časovač používaný vo funkciách:

Nekonečný časovač, ale len do chvíle, kým ho nestopneme podmienkou – zložitejší časovač – používaný vo funkciách:

def nazovfunkcie(): #tieto zatvorky musia byt prazdne
    #prikazy
    #pripadne aj podmienka, kedy má iba fungovať časovač
    c.after(100, nazovfunkcie)           #v zátvorke je počet milisekúnd a funkcia, v ktorej sa nachádza, update tam môže a nemusí byť

nazovfunkcie()

6. Udalosti myši:

základné udalosti myši
def nazovfunkcie(event):  #okrem eventu si nevieme posielat ziadne ine parametre!
    x = event.x #uloženie miesta kliknutia, to kde máme kurzor, x-ová súradnica kliku
    y = event.y #uloženie miesta kliknutia, to kde máme kurzor, y-ová súradnica kliku
    prikazy

c.bind("<Button-1>", nazovfunkcie)

# 1 - ľavé, 2 - stredné, 3 - pravé tlačidlo
# "<Button-1>" - klikanie (ľavým tlačidlom)
# "<B1-Motion>" - ťahanie (zakliknutého ľavého tlačidla)
# "<ButtonRelease-1>" - pustenie ľavého tlačidla
# "<Double-Button-1>" - dvojklik ľavým tlačidlom myši
# "<Triple-Button-1>" - trojklik ľavým tlačidlom myši
# "<ButtonPress>" - kliknutie (zatlačenie tlačidla myši)
# "<Motion>" - ťahanie (posúvanie myšou so zatlačeným tlačidlom alebo bez zatlačeného tlačidla)
# "<ButtonRelease>" - pustenie myši
# ďalšie nájdeš tu


c.unbind("<Button-1>") # Metóda zruší zviazanie príslušnej udalosti, táto zruší klikaciu udalosť

7. Udalosti klávesnice:

def nazovfunkcie(event):  #okrem eventu si nevieme posielat ziadne ine parametre
    prikazy

c.bind_all("<a>", nazovfunkcie)     # "A" kláves na klávesnici

def vypis(event):
    x = randrange(300)
    y = randrange(300)
    c.create_text(x,y,text=event.keysym)  #vypíše to, na ktorý kláves sme klikli

c.bind_all('<Key>', vypis)   # hociktorý kláves na klávesnici

#ďalšie informácie, ktoré vieme zistiť zo sltačeného klávesu:
event.keysym   #názov klávesu
event.keychar   #znak na klávese
event.keycode   #ascii kód znaku na klávese

Príklady tlačidiel:
'<a>' '<Left>' '<Right>' '<Up>' '<Down>'
'<Return>' '<space>'

8. Posúvanie objektov canvasu:

#Posúvanie pomocou move -> zmena o určitý počet pixelov v určitom smere
x = x + posunx
y = y + posuny
c.move('nazov_tagu', posunx, posuny)

#Posúvanie pomocou coords -> posúvanie na konkrétne súradnice v canvase
c.coords("nazov_tagu",x1,y1,x2,y2)

a) klávesom:

x = 0
y = 0
c.create_oval(x, y, x+10, y+10, fill='red',tags='nazov')

def vlavo(event):
     global x, y
     c.move('nazov',10,0) #tag, posun o počet krokov doprava/doľava, posun o počet krokov hore/hole
     x = x + 10

c.bind_all("<Left>", vlavo)

b) v časovači:

x = 0
y = 0
c.create_oval(x, y, x+10, y+10, fill='red',tags='nazov')

def padadole():
     global x, y
     c.move('nazov',0,10) #tag, posun o počet krokov doprava/doľava, posun o počet krokov hore/hole
     y = y + 10
     c.after(100, padadole)

padadole()

9. Kolízia:

Kolízia myš a objekt (zisťovanie, či som na niečo klikol):

 Kolízia kurzoru myši a objektu v udalosti na klikanie myšou:
     if sx-v <= event.x <= sx+v and sy-v <= event.y <= sy+v:

Iný spôsob pomocou funkcie c.find_overlapping():
     if c.find_overlapping(sx,sy,sx,sy)==c.find_overlapping(event.x,event.y,event.x,event.y):

Kolízia objektov:

Kolízia - prekrývanie sa: 
   if sx-a <= kx <= sx+a and sy-a <= ky <= sy+a:
#presné prekrytie súradníc sx,sy == kx,ky nastane len výnimočne, väčšinou to treba urobiť takto

Kolízia - náraz:
   if sx+a >= kx+r or kx-r <= sx-a: 
#prípadne treba dorobiť ešte podmienku pre y-lonovú súradnicu, závisí to od toho, čo potrebujeme

Iný spôsob – pomocou príkazu c.find_overlapping(x1, y1, x2, y2):

Kolízia - prekrytie sa, náraz:
if c.find_overlapping(sx,sy,sx,sy)==c.find_overlapping(kx,ky,kx,ky):

Kolízia - náraz:
if c.find_overlapping(sx-a,sy-a,sx+a,sy+a) == c.find_overlapping(kx-r,ky-r,kx+r,ky+r):

10. Entry a tlačidlo:

def button1_klik(): #funkcia, ktorá sa viaže ku tlačidlu
    prikazy
    hodnota = entry1.get() #získanie hodnoty z entryboxu

#vstupné pole/entry box na ploche, povinné sú iba prvé dva riadky: 
entry1 = tkinter.Entry() #vytvorenie entryboxu 
entry1.pack() #zmena umiestnenia: entry1.pack(side = 'left') 
entry1.insert(0,'text') #toto je poznámka, ktorá sa bude zobrazovať v entryboxe, nepovinný príkaz, vôbec tam nemusí byť

#button, tlačidlo na ploche - musíte udať oba riadky!:
button1 = tkinter.Button(text='text na buttone', command=button1_klik) #čo bude na tlačidle napísané a s ktorou funkciou je prepojené
button1.pack() #zmena umiestnenia button1.pack(side = "bottom") -> strany: left, right, bottom, top

11. Práca s obrázkami – png a gif:

  • veľmi dôležité! obrázky musia byť uložené v tom isto súbore ako python súbor s príponou .py, inak nám obrázok nenačíta, alebo musíme zadať cestu k obrázku, nie len názov obrázku s príponou

Anchor je bod, ku ktorému priradíme x,y obrázka. Zo základu je anchor nastavený na center. Môže byť takýto:

obrazok1 = tkinter.PhotoImage(file = 'nazov.png') #obrázok musí byť uložený v tomto istom priečinku ako python súbor!!!!
#vykreslenie obrázka - x,y je v strede obrázka:
c.create_image(x, y, image = obrazok1, tag="nazov") #tag nemusí byť

#zistenie rozmerov obrázka
sirka = obrazok1.width()
vyska = obrazok1.height()

#Pole obrázkov:
obrazky = [] 

def nacitaj(nazov, typ, pocet, obrazky): 
    for i in range(1, pocet+1): 
         obrazok = tkinter.PhotoImage(file = nazov + str(i) + '.'+typ) 
         obrazky.append(obrazok) 

def nakresli(x,y,obrazky): 
    for obrazok in obrazky: 
         c.create_image(x, y, image = obrazok, anchor = 'nw') 
         x += 100

nacitaj('obr_', 'png', 4, obrazky) 
nakresli(10, 30, obrazky)

Obrázkové pozadie:

import tkinter
c = tkinter.Canvas()
c.pack()

pozadie = tkinter.PhotoImage(file = 'dlazba1.png')
sirka = pozadie.width()
vyska = pozadie.height()
c.create_image(0, 0, image = pozadie, anchor = "nw") #zmena vykreslovania obrázka, teraz ho kreslíme z ľavého horného rohu, tam sa nachádza jeho x,y
c['width'] = sirka
c['height'] = vyska

Jednoduchá animácia s viacerými obrázkami .png alebo .gif, ktoré máme uložené v poli:

def nacitaj(nazov, typ, pocet, obrazky): 
    for i in range(0, pocet+1): 
         obrazok = tkinter.PhotoImage(file = nazov + str(i) + '.'+typ) 
         obrazky.append(obrazok) 

def animacia():
    global poradie,x,y,obrazky
    c.delete("nazov")
    c.create_image(x, y, image = obrazky[poradie], anchor = 'nw',tag="nazov")
    poradie += 1
    if poradie == 8:
        poradie = 0
    c.after(200,animacia)

obrazky = [] 
nacitaj('nazov', 'png', 7, obrazky)

poradie=0
x,y=10,30
animacia()

12. Problémy s obrázkami:

Čo ak mi píše, že nevie nájsť obrázky? Prípadne sú obrázky v inom priečinku? – často v editore MU

import os
cestaKPriecinku = os.path.dirname(__file__)
cestaKSuboru = os.path.join(cestaKPriecinku, "images/trava.png")
pozadie = tkinter.PhotoImage(file= cestaKSuboru)
c.create_image(0,0, image = pozadie, anchor="nw")

13. Vylepšenia do tkinter okna:

#Viac canvasov v jednom okne: (ak budú v packu zátvorky prázdne, tak budú pod sebou)
import tkinter
c = tkinter.Canvas(width=500,height=500,bg="white")
c.pack(side = "left")
c2 = tkinter.Canvas(width=500,height=500,bg="white")
c2.pack(side = "right")

#Label - text, napr. vedľa entry boxu:
label1 = tkinter.Label(text = 'Napíš meno:')
label1.pack(side = 'left')

Iné:
– ListBox – napr. na výber farby, položky
– Frame – na orámovanie tlačidiel
– Menu – horná lišta ako v aplikáciach
– Posúvač – Scale
– Textová plochy – Text insert
– Možnosti – Radiobutton
– Zaškrtávacie okienka – Checkbox
– Dialógové okná – vyskakovacie okienka
– Vloženie súboru – tkinter.filedialog.askopenfile()
– Color boxy – tkinter.colorchooser.askcolor()

 


C) Iné moduly:

1. Hudba:

Hudbu treba mať uloženú vedľa .py súboru a spustí sa len hudba s príponou .wav.

import winsound
winsound.PlaySound('nazov.wav', winsound.SND_ALIAS | winsound.SND_ASYNC) #spustenie hudby
winsound.PlaySound(None, winsound.SND_PURGE) #zastavenie hudby

2. Modul time:

#Meranie času - trvania behu nejakého kódu:
import time
start = time.time() #začiatok merania času; funkcia vracia momentálny čas v sekundách
#tu sú príkazy
print(round(time.time()-start, 3)) # koniec merania času

#Zistenie momentálneho času a dátumu v našom počítači:
time.localtime() #môžeme si to vypísať ako pole: print(time.localtime() )

#Uloženie do premenných:
hodiny, minuty, ssekundy = time.localtime()[3:6]
mesiac, den = time.localtime()[1:3]

3. Matematika – modul math:

import math
math.sqrt(cislo) #druhá odmocnina
abs(cislo) #absolútna hodnota čísla, z každého čísla urobí kladné
round(cislo, pocet_miest) #zaokrúhlenie nahor
floor(cislo) #zaokrúhlenie nadol
ceil(cislo) #zaokrúhlenie nahor
math.radians(uhol_v_stupnoch) #stupne na radiany
math.degrees(uhol_v_radianoch) #radiany na stupne
math.cos(uhol)
math.sin(uhol)
math.tan(uhol)
math.pi

Výpočet do kruhu – Nuholník:

from math import sin, cos, radians

def nuholnik(x0,y0,r,n):
    stupne = 360//n
    for uhol in range(0,360,stupne):
        x = x0 + r * cos(radians(uhol))
        y = y0 + r * sin(radians(uhol))
        # c.create_oval(x-1,y-1,x+1,y+1,fill="black") #nakreslí bod na danom mieste n-uholníka v tkinter grafike
        # setpos(x,y)   #v turtle grafike by korytnačku posunulo na danú pozíciu

#x,y súradnice stredu
#r polomer kruznice
#n počet vrcholov nuholníka
nuholnik(x,y,r,n)

 


Ďalšie:


Základné zásady programovania v jazyku Python:

zdroj (Blaho).

  • načítanie modulov/knižníc by sa malo vykonávať na začiatku programu, úplne hore
  • názov funkcie píšeme malým písmenom
  • názov triedy píšeme veľkým písmenom
  • ak sa názov funkcie (premennej, triedy) skladá z viacerých slov, mali by sme používať tento spôsob: def nakresli_riadky():, a nepoužívať def nakresliRiadky()
  • riadok by nemal obsahovať viac ako 79 znakov – vtedy je lepšie rozdeliť do viacerých riadkov pomocou zátvoriek ( ) – zátvorky uzatvoria príkazy tak, aby bolo jasné, čo k sebe patrí
  • pre prehľadnosť kódu treba pridávať aj prázdne riadky – napr. medzi jednotlivými funkciami, oddelenie logických častí vo vnútri funkcie/programu, oddelenie tried…
  • nemali by sme používať diakritiku – dĺžne, mäkčene! (kódovanie je v anglickom UTF-8)
  • pozor na globálne a lokálne premenné – ako si nazývame jednotlivé premenné a ako a kde ich potom používame
  • medzery nevkladať pred ľavú a pravú zátvorku, nevkladať ani medzi názvom funkcie a ľavou okrúhlou zátvorkou, nevkladať ani medzi hranatou zátvorkou a prvým/posledným prvkom v poli, nevkladať ani pred čiarku a dvojbodku
  • naopak, medzeru by sme mali vložiť pred/za: = ,+=, -=, *=, …, ==, !=, <, <=, >, >=, in, not in, is, is not, and, or, not
Facebook komentáre