~Nožka

cteni_wav.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  cteni_wav.py
   4 # Datum:   05.02.2015 11:03
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   čtení hlavičky souboru WAV
   8 ############################################################################
   9 from __future__ import division, print_function, unicode_literals
  10 
  11 import struct
  12 ############################################################################
  13 # WAV formát
  14 # http://www.fi.muni.cz/~qruzicka/Duffek/wav.html
  15 
  16 f = open('left.wav', 'r')
  17 
  18 f.read(8)
  19 wID = f.read(4)
  20 fID = f.read(4)
  21 
  22 fLen = f.read(4)
  23 wFormatTag = f.read(2)
  24 nChannels = f.read(2)
  25 nSamplesPerSec = f.read(4)
  26 nAvgBytesPerSec = f.read(4)
  27 nBitsPerSample = f.read(2)
  28 # dohromady by to šlo udělat i jedním read()
  29 dohromady = b''.join((fLen, wFormatTag, nChannels, nSamplesPerSec,
  30                      nAvgBytesPerSec, nBitsPerSample))
  31 abych_to_videl = struct.unpack('IHHIIH', dohromady)
  32 
  33 print(wID)
  34 print(fID)
  35 print(repr(fLen))
  36 print(repr(wFormatTag))
  37 print(repr(nChannels))
  38 print(repr(nSamplesPerSec))
  39 print(repr(nAvgBytesPerSec))
  40 print(repr(nBitsPerSample))
  41 f.read(2)
  42 print(f.read(4))
  43 
  44 print(abych_to_videl)
  45 

`--> stáhnout

fibonacci.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  fibonacci.py
   4 # Datum:   07.05.2015 10:33
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   Fibonacciho posloupnost
   8 ############################################################################
   9 from __future__ import division, print_function, unicode_literals
  10 
  11 
  12 def fib(n):
  13     if n == 0:
  14         return 0
  15     elif n == 1:
  16         return 1
  17     elif n > 1:
  18         i = 2
  19         x, y = 0, 1
  20         while i <= n:
  21             i += 1
  22             vysledek = x + y
  23             x, y = y, vysledek
  24         return vysledek
  25     else:
  26         return None
  27 
  28 
  29 def fibR(n):
  30     if n == 0:
  31         return 0
  32     elif n == 1:
  33         return 1
  34     elif n > 1:
  35         return fibR(n-2) + fibR(n-1)
  36     else:
  37         return None
  38 
  39 
  40 def fibG(n):
  41     yield 0
  42     yield 1
  43     x, y = 0, 1
  44     i = 2
  45     while i <= n:
  46         yield x + y
  47         x, y = y, x+y
  48         i += 1
  49     return
  50 
  51 # n = 10
  52 # print(fib(n))
  53 # print(fibR(n))
  54 
  55 g = fibG(10)
  56 print(g.next())
  57 print(g.next())
  58 print(g.next())
  59 print(g.next())
  60 print(g.next())
  61 print(g.next())
  62 print(g.next())
  63 print(g.next())
  64 print(g.next())
  65 
  66 print('-----------------')
  67 for i in fibG(10):
  68     print(i)
  69 
  70 gen = [x*x for x in range(10)]
  71 print (gen)

`--> stáhnout

for.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 ############################################################################
   4 from __future__ import division
   5 from __future__ import print_function
   6 from __future__ import unicode_literals
   7 from __future__ import generators
   8 
   9 seznam = list( range(10, 20) )
  10 
  11 for cislo in seznam:
  12     if cislo % 3 == 0:
  13         print(cislo, "je dělitelne 3")
  14     print(cislo)
  15 
  16 
  17 for cislo in range(100):
  18     if cislo % 3 == 0:
  19         print(cislo, "je dělitelne 3")
  20         print(100 * cislo)
  21         print(100 * cislo)
  22     if cislo % 5 == 0:
  23         print(cislo, "je dělitelne 5")
  24 
  25 seznam = [ 2 ** i for i in range(100) if i < 20 ]
  26 print(seznam)
  27 
  28 import random
  29 nahoda = [ random.randint(0, 10) for _ in range(10) ]
  30 print(nahoda)
  31 
  32 nahoda = []
  33 for i in range(10):
  34     nahoda.append( random.randint(0, 10) )

`--> stáhnout

kalendar.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  kalendar.py
   4 # Datum:   30.10.2014 10:53
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Autor:   Marek Nožka, marek <@t> tlapicka <d.t> net
   7 # Licence: GNU/GPL
   8 # Úloha:   Ascii kalendář
   9 ############################################################################
  10 from __future__ import division
  11 from __future__ import print_function
  12 from __future__ import unicode_literals
  13 from __future__ import generators
  14 
  15 import sys
  16 echo = sys.stdout.write
  17 
  18 den = tuple(range(1, 32))
  19 
  20 '''tato proměnná obsahuje den v týdnu, kterým začíná měsíc'''
  21 prvni = 3  # středa
  22 
  23 echo(' ' * 3 * (prvni - 1) )
  24 for i in den:
  25     echo('{0:2d}'.format(i) )
  26     if i % (7-prvni+1) == 0:
  27         echo('\n')
  28     else:
  29         echo(' ')

`--> stáhnout

kladna_a_zaporna.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  kladna_a_zaporna.py
   4 # Datum:   23.10.2014 11:01
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   Je dána posloupnost celých čísel. Přerovnejte čísla tak, aby na
   8 #          začátku posloupnosti byla všechna záporná čísla v původním pořadí
   9 #          a za nimi všechna nezáporná čísla v opačném pořadí. Upravenou
  10 #          posloupnost vypište.
  11 ############################################################################
  12 from __future__ import division
  13 from __future__ import print_function
  14 from __future__ import unicode_literals
  15 from __future__ import generators
  16 
  17 radek = raw_input("zadej cisla > ")
  18 radek = radek.split()
  19 
  20 nezaporna = []
  21 zaporna = []
  22 for i in radek:
  23     i = int(i)
  24     if i >= 0:
  25         nezaporna.append(i)
  26     else:
  27         zaporna.append(i)
  28 
  29 zaporna.reverse()
  30 hotovo = nezaporna + zaporna
  31 print(hotovo)

`--> stáhnout

matice.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  myLMS.py
   4 # Datum:   22.07.2014 15:41
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   adaptivní filter (LMS)
   8 ##############################################################################
   9 from __future__ import division, print_function, unicode_literals
  10 import random
  11 
  12 
  13 def zobraz(data):
  14     for radek in data:
  15         for x in radek:
  16             print(x, end='')
  17         print()
  18 
  19 
  20 def generuj(pradku=12, psloupcu=12):
  21     data = []
  22     for _ in range(pradku):
  23         radek = []
  24         for _ in range(psloupcu):
  25             radek.append(random.randint(0, 1))
  26         data.append(radek)
  27     return data
  28 
  29 d = generuj(10, 20)
  30 
  31 for r in range(len(d)):
  32     for s in range(len(d[0])):
  33         if r == 0 or s == 0 or r == len(d)-1 or s == len(d[0])-1:
  34             d[r][s] = 2
  35 
  36 
  37 zobraz(d)
  38 
  39 # import pylab as lab
  40 # lab.imshow(d, interpolation='none', cmap='binary')
  41 # lab.show()

`--> stáhnout

mpl.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  mpl.py
   4 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   5 # Licence: GNU/GPL
   6 # Úloha:   výkon střídavého proudu
   7 ##############################################################################
   8 from __future__ import division, print_function, unicode_literals
   9 
  10 import pylab as lab
  11 from pylab import pi
  12 
  13 f = 50
  14 T = 1/f
  15 fi = lab.deg2rad(int(raw_input("zadej fázový posuv > ")))
  16 
  17 t = lab.linspace(0, 1.8 * T, 300)
  18 u = 1.5 * lab.sin(2*pi*f*t)
  19 i = 1.2 * lab.sin(2*pi*f*t + fi)
  20 
  21 lab.figure(1)
  22 lab.plot(t, u, label='napětí')
  23 lab.plot(t, i, label='proud')
  24 lab.plot(t, u*i, label='výkon')
  25 lab.grid(True)
  26 lab.xlim(min(t), max(t))
  27 lab.legend()
  28 
  29 lab.show()

`--> stáhnout

obdelnik.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf8 -*-
   3 # Licence: GNU/GPL
   4 # Úloha:   harmonické složky obdelníkového časového průběhu
   5 ##############################################################################
   6 from __future__ import division, print_function, unicode_literals
   7 
   8 import pylab as lab
   9 from pylab import pi
  10 
  11 
  12 Um = 1
  13 f = 1
  14 DCL = 0.5
  15 N = lab.arange(0, 10)
  16 U = 2.*Um*DCL*lab.sinc(N*DCL)
  17 U[0] = U[0]/2
  18 
  19 t = lab.linspace(0, 2, 300)
  20 
  21 lab.figure(1)
  22 u = lab.zeros(len(t))
  23 for n in N:
  24     un = U[n] * lab.cos(2*pi*n*f*t)
  25     u += un
  26     lab.plot(t, un, '--')
  27 lab.plot(t, u, 'r-', lw=3)
  28 lab.grid(True)
  29 lab.show()

`--> stáhnout

obrazky.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  myLMS.py
   4 # Datum:   22.07.2014 15:41
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   adaptivní filter (LMS)
   8 ##############################################################################
   9 from __future__ import division, print_function, unicode_literals
  10 
  11 import pylab as lab
  12 from random import random
  13 obrazek = lab.imread('samec.png')
  14 obrazek = lab.imread('sachy.png')
  15 
  16 print(obrazek[0][0][0])
  17 print(obrazek[0][0][1])
  18 print(type(obrazek[0][0][2]))
  19 
  20 novy = []
  21 for radek in obrazek:
  22     novy_r = []
  23     for bod in radek:
  24         # seda = 0.3*bod[0] + 0.59*bod[1] + 0.11*bod[2]
  25         seda = 0.33*bod[0] + 0.33*bod[1] + 0.33*bod[2]
  26         if seda > random():
  27             novy_r.append(0)
  28         else:
  29             novy_r.append(1)
  30     novy.append(novy_r)
  31 
  32 
  33 lab.imshow(obrazek)
  34 lab.imshow(novy, cmap='binary')
  35 lab.show()

`--> stáhnout

opp.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  opp.py
   4 # Datum:   29.01.2015 10:35
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   Ukázka OOP
   8 ############################################################################
   9 from __future__ import division, print_function, unicode_literals
  10 import math
  11 
  12 
  13 class Ccislo():
  14     """můj Datový typ pro komplaxní čísla"""
  15     def __init__(self, re, im):
  16         self.re = re
  17         self.im = im
  18 
  19     def __del__(self):
  20         print('umírám')
  21 
  22     @property
  23     def arg(self):
  24         return math.atan(self.im/self.re)
  25 
  26     def __add__(a, b):
  27         return Ccislo(a.re + b.re, a.im + b.im)
  28 
  29     def __str__(self):
  30         return "{} + {}j".format(self.re, self.im)
  31 
  32 
  33 class Ccislo2(Ccislo):
  34     @property
  35     def arg(self):
  36         return math.degrees(math.atan(self.im/self.re))
  37 
  38 
  39 x = Ccislo2(3, 4)
  40 y = Ccislo(4, 3)
  41 Q = Ccislo(4, 3)
  42 del(Q)
  43 print(x.arg)
  44 print(y.arg)
  45 
  46 z = x + y
  47 print(z.re)
  48 print(z.im)
  49 print(z.arg)
  50 
  51 print(x)
  52 print(y)
  53 print(z)

`--> stáhnout

platidla.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  platidla.py
   4 # Datum:   06.11.2014 11:03
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:
   8 ############################################################################
   9 from __future__ import division
  10 from __future__ import print_function
  11 from __future__ import unicode_literals
  12 from __future__ import generators
  13 
  14 platidla = [1, 2, 5]
  15 
  16 while platidla[-1] < 5000:
  17     platidla.append( platidla[-3] * 10 )
  18 platidla.reverse()
  19 
  20 castka = raw_input('zadej částku > ')
  21 castka = int(castka)
  22 
  23 for bankovka in platidla:
  24     if castka // bankovka == 0:
  25         continue
  26     else:
  27         print(castka // bankovka, 'x', bankovka)
  28         castka = castka % bankovka

`--> stáhnout

podminky.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 ############################################################################
   4 
   5 from __future__ import division
   6 from __future__ import print_function
   7 
   8 vek = input("Kolik ti je? > ")
   9 
  10 if vek < 6:
  11     print('Ti jsi ještě předškolák.')
  12     a = 10 * 59
  13     print('Ti jsi ještě předškolák.')
  14 elif vek == 6:
  15     print('Hurá jdeš do školy.')
  16 elif vek <= 17:
  17     print('Ještě prisim tě poslouchej maminku.')
  18 elif vek > 18 and vek < 65:
  19     print('Makej, makej, makej.')
  20 else:
  21     print('Jsi fakt starej.')
  22 print("konec")

`--> stáhnout

prumer.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  prumer.py
   4 # Datum:   30.10.2014 10:01
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   Vypočítá aritmetický průměr
   8 ############################################################################
   9 from __future__ import division
  10 from __future__ import print_function
  11 from __future__ import unicode_literals
  12 from __future__ import generators
  13 
  14 import random
  15 
  16 '''Pokud zádám jen Enter, čísla se vygenerují náhodně,
  17 jinak se čtou ze vstupu.'''
  18 radek = raw_input('zadej čísla oddělená mezerou > ')
  19 
  20 if radek == '':
  21     cisla = []
  22     for _ in range(20):
  23         cisla.append( random.randint(-20, 20) )
  24     cisla = [ random.randint(-20, 20) for _ in range(20) ]
  25 else:
  26     cisla = radek.split()   # rozdělím řetězec
  27     for i, cislo in enumerate(cisla):
  28         cisla[i] = int(cislo)
  29     cisla = [ int(i) for i in cisla ]  # převedu řetězce na čísla
  30 
  31 print(cisla)
  32 
  33 suma = 0
  34 for hodnota in cisla:
  35     suma = suma + hodnota
  36 print("Průměr:", suma / len(cisla) )
  37 
  38 pocet_kladnych = 0
  39 for hodnota in cisla:
  40     if hodnota > 0:
  41         pocet_kladnych = pocet_kladnych + 1
  42 print("Počet kladných:", pocet_kladnych)

`--> stáhnout

prvocisla.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  prvocisla.py
   4 # Datum:   16.10.2014 09:59
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   Provočísla
   8 ############################################################################
   9 from __future__ import division
  10 from __future__ import print_function
  11 from __future__ import unicode_literals
  12 from __future__ import generators
  13 
  14 
  15 def jeToProvocislo(cislo):
  16     for i in range(2, int(cislo ** 0.5) + 1):
  17         if cislo % i == 0:
  18             return False  # ukončí funkci s danou návratovou hodnotou
  19     return True
  20 
  21 # vypíšu všechna prvočísla menší než 1000
  22 for i in range(2, 1000):
  23     if jeToProvocislo(i):
  24         print(i, end=' ')
  25 print()
  26 
  27 # vypíšu prvních 1000 prvočísel
  28 i = 2
  29 pocet = 0
  30 while pocet < 1000:
  31     if jeToProvocislo(i):
  32         print(i, end=' ')
  33         pocet = pocet + 1
  34     i = i + 1
  35 print()
  36 
  37 
  38 ############################################################################
  39 # načtu vstup, cislo je řetězec
  40 cislo = raw_input("Zadej celé číslo > ")
  41 # převedu řetězec na číslo
  42 cislo = int(cislo)
  43 
  44 AnoNe = True
  45 # zjišťuji jestli je cislo prvočíslo
  46 for i in range(2, cislo // 2):
  47     if cislo % i == 0:
  48         AnoNe = False
  49         break   # když najdu prvního dělitele vyskočím z cyklu ven
  50 if AnoNe:
  51     print("Hurá, hurá", cislo, "je prvočíslo")
  52 else:
  53     print(cislo, "není prvočíslo")
  54 
  55 # ještě jedno trochu jinak
  56 for i in range(2, cislo // 2):
  57     if cislo % i == 0:
  58         print(cislo, "není prvočíslo")
  59         exit()  # ukončení programu
  60 print("Hurá, hurá", cislo, "je prvočíslo")

`--> stáhnout

reverzni_kalkulator.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  reverzni_kalkulator.py
   4 # Datum:   22.01.2015 10:29
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Autor:   Marek Nožka, marek <@t> tlapicka <d.t> net
   7 # Licence: GNU/GPL
   8 # Úloha:
   9 ############################################################################
  10 from __future__ import division, print_function, unicode_literals
  11 
  12 ############################################################################
  13 zasobnik = []
  14 
  15 
  16 def fce2argumenty(funkce):
  17     if len(zasobnik) >= 2:
  18         b = zasobnik.pop()
  19         a = zasobnik.pop()
  20         try:
  21             zasobnik.append(funkce(a, b))
  22         except Exception as e:
  23             print('Chyba:', e.__class__)
  24             print('Chyba:', e.message)
  25             zasobnik.extend([a, b])
  26     else:
  27         print('"' + token + '":',
  28               'nelze provést, v zásobníku musí být alespoň dvě čísla')
  29 
  30 
  31 def plus(a, b):
  32     return a+b
  33 
  34 
  35 def minus(a, b):
  36     return a-b
  37 
  38 while True:
  39     try:
  40         radek = raw_input(str(zasobnik) + ' >> ')
  41         for token in radek.split():
  42             try:
  43                 zasobnik.append(float(token))
  44             except ValueError:
  45                 if token == '+':
  46                     fce2argumenty(plus)
  47                 elif token == '-':
  48                     fce2argumenty(minus)
  49                 elif token == '*':
  50                     fce2argumenty(lambda x, y: x * y)
  51                 elif token == '/':
  52                     fce2argumenty(lambda x, y: x / y)
  53     except EOFError:
  54         exit(0)
  55     except KeyboardInterrupt:
  56         exit(1)

`--> stáhnout

soubory.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  soubory.py
   4 # Datum:   05.02.2015 10:03
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   Práce se soubory
   8 ############################################################################
   9 from __future__ import division, print_function, unicode_literals
  10 import os
  11 
  12 
  13 f = open('soubor.txt', 'w')
  14 
  15 f.write('ahoj')
  16 f.write(' nazdar\n')
  17 f.write('cau\n')
  18 
  19 raw_input('1. stiskni enter')
  20 f.flush()
  21 
  22 raw_input('2. stiskni enter')
  23 f.write('haloooo\n')
  24 f.writelines(['Karel\n', "Bob\n", 'Bobek\n', 'Nijak\n'])
  25 
  26 f.close()
  27 ############################################################
  28 print('######################################')
  29 f = open('soubor.txt', 'r')
  30 byte = f.read(1)
  31 print(byte)
  32 byte = f.read(1)
  33 print(byte)
  34 
  35 radek = f.readline()
  36 print(radek)
  37 
  38 # čtu zanak po znaku
  39 while True:
  40     znak = f.read(1)
  41     if znak == '':
  42         break
  43     print(znak.upper(), end=':')
  44 
  45 cely = f.read()
  46 print(cely)
  47 f.close()
  48 
  49 ############################################################
  50 print('######################################')
  51 f = open('soubor.txt', 'r+')
  52 
  53 neco = f.read(3)
  54 print(neco)
  55 print(f.tell())
  56 f.write('TADY')
  57 print(f.tell())
  58 f.seek(14)
  59 f.write('14')
  60 
  61 # o 4 znky dál
  62 f.seek(4, os.SEEK_CUR)
  63 f.write('RELATIVNE')
  64 
  65 #  jdu na konec souboru
  66 f.seek(0, os.SEEK_END)
  67 f.write('\nKonec')
  68 
  69 f.write('\x0d')
  70 f.write('\x0d')
  71 f.write('\x0d')
  72 f.write('neco')
  73 
  74 
  75 f.close()

`--> stáhnout

statistika_poctu_znaku.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  statistika_poctu_znaku.py
   4 # Datum:   15.01.2015 10:28
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   Vypíše na výstup počet použití jednotlivých znaků
   8 #          načtených ze vstupu
   9 ############################################################################
  10 from __future__ import division, print_function, unicode_literals
  11 
  12 ############################################################################
  13 pocet = {}
  14 while True:
  15     try:
  16         radek = raw_input()
  17         for znak in radek.upper():
  18             if znak.isalpha():
  19                 if znak in pocet:
  20                     pocet[znak] += 1
  21                 else:
  22                     pocet[znak] = 1
  23     except EOFError:
  24         m = max(pocet.values())
  25         for znak, pocet in pocet.items():
  26             print("{:>2s}: {:6d} |{:s}".format(znak, pocet,
  27                                                '#' * int(60*pocet/m)))
  28         exit(0)
  29     except KeyboardInterrupt:
  30         exit(1)

`--> stáhnout

suma.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  vyjiky.py
   4 # Datum:   08.01.2015 10:18
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   sečte všechny čísla zadaná na řádek
   8 ############################################################################
   9 from __future__ import division, print_function, unicode_literals
  10 
  11 ############################################################################
  12 while True:
  13     try:
  14         line = raw_input('suma: zadej čísla oddělená mezerou\n >> ')
  15         if 'konec' in line.lower():
  16             exit(0)
  17         suma = 0
  18         for i in line.split():
  19             try:
  20                 suma += float(i)
  21             except ValueError:
  22                 print("Vynechávám", i, "-- není to číslo")
  23         print('-->', suma, '\n')
  24     except EOFError:
  25         print("\nKonec")
  26         exit(0)
  27     except KeyboardInterrupt:
  28         print("\nPřerušeno uživatelem")
  29         exit(1)

`--> stáhnout

trojuhelnik.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  trojuhelnik.py
   4 # Datum:   09.10.2014 10:23
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Popis:   Trojúhelníkový fraktál
   8 ############################################################################
   9 from __future__ import division
  10 from __future__ import print_function
  11 from __future__ import unicode_literals
  12 from __future__ import generators
  13 
  14 import turtle as t
  15 
  16 
  17 def troj(delka=100, n=2):
  18     if n >= 3:
  19         troj(delka / 3, n - 1)
  20     else:
  21         t.forward(delka)
  22     t.left(60)
  23     if n >= 2:
  24         troj(delka / 3, n - 1)
  25     else:
  26         t.forward(delka)
  27     t.right(120)
  28     if n >= 2:
  29         troj(delka / 3, n - 1)
  30     else:
  31         t.forward(delka)
  32     t.left(60)
  33     if n >= 3:
  34         troj(delka / 3, n - 1)
  35     else:
  36         t.forward(delka)
  37 
  38 
  39 def vlocka(velikost=100, pstran=6, rev=False):
  40     for _ in range(pstran):
  41         troj(velikost / 3, 3)
  42         if rev:
  43             t.left( 360 / pstran )
  44         else:
  45             t.right( 360 / pstran )
  46 
  47 t.up()
  48 t.goto(-200, 0)
  49 t.down()
  50 """troj(200, 4)"""
  51 vlocka(rev=0)
  52 vlocka(rev=1)
  53 t.exitonclick()

`--> stáhnout

vyjiky.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  vyjiky.py
   4 # Datum:   08.01.2015 10:18
   5 # Autor:   Marek Nožka, nozka <@t> spseol <d.t> cz
   6 # Licence: GNU/GPL
   7 # Úloha:   podělí čísla na řádku
   8 ############################################################################
   9 from __future__ import division, print_function, unicode_literals
  10 
  11 ############################################################################
  12 while True:
  13     try:
  14         line = raw_input('deleni >> ')
  15         if 'konec' in line.lower():
  16             exit(0)
  17         a, b = line.split()
  18         print(float(a) / float(b))
  19     except EOFError:
  20         print("\nKonec")
  21         exit(0)
  22     except KeyboardInterrupt:
  23         print("\nPřerušeno uživatelem")
  24         exit(1)
  25     except ValueError:
  26         print("\nMusíš zadat celé číslo..")
  27     except ZeroDivisionError:
  28         print("\nNelze dělit nulou!")

`--> stáhnout

zelva.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # Soubor:  zelva.py
   4 # Datum:   02.10.2014 10:02
   5 ############################################################################
   6 from __future__ import division
   7 from __future__ import print_function
   8 from __future__ import unicode_literals
   9 from __future__ import generators
  10 
  11 import turtle as t
  12 import math
  13 
  14 #   t.speed(0)
  15 t.up()
  16 t.goto(-300, 0)
  17 t.down()
  18 
  19 
  20 def n_uhelnik(n=5, krok=100):
  21     if n < 1:
  22         return
  23     for _ in range(n):
  24         t.forward(krok)
  25         t.left(360 / n)
  26     return
  27 
  28 
  29 def sinus(amplituda, perioda):
  30     deleni = 256   # počet díléčků pro periodu
  31     pocatekX = t.xcor()
  32     pocatekY = t.ycor()
  33     krok = perioda / deleni
  34     krokUhel = 2 * math.pi / deleni
  35     for i in range(deleni):
  36         t.goto(pocatekX + i * krok,
  37                pocatekY + amplituda * math.sin( i * krokUhel  ) )
  38 ############################################################################
  39 
  40 n_uhelnik(7)
  41 n_uhelnik(7, 50)
  42 n_uhelnik()
  43 n_uhelnik(krok=200, n=8)
  44 t.exitonclick()
  45 exit(0)
  46 
  47 
  48 
  49 
  50 t.goto(50, 50)
  51 sinus(100, 200)
  52 
  53 
  54 for i in range(4):
  55     t.forward(100)
  56     t.left(90)
  57 
  58 t.left(45)
  59 
  60 i = 0
  61 while i < 4:
  62     t.forward(100)
  63     t.left(90)
  64     i = i + 1
  65 
  66 
  67 ############################################################################
  68 t.exitonclick()

`--> stáhnout