# coding: utf8
# Seminár 03 -- n-tice, množiny, slovníky, výnimky

"""
0. LIST COMPREHENSION (generátorová notácia zoznamu)
"""

a_list = [1, 8, 7, 4, 5, 7]
b_list = [elem * 2 for elem in a_list]
c_list = [elem for elem in a_list if elem > 6]

"""
1: TUPLES (n-tice)

Tuple je kolekcia hodnôt, na rozdiel od zoznamu (list) nie je po vytvorení meniteľný (immutable). Hodí sa v situáciách keď záleží na poradí hodnôt. Práca s tuple je tiež menej výpočtovo náročná a rýchlejšia.
"""

# tuple definujeme obyčajnými zátvorkami, tie sú ale nepovinné
new_tuple = 12, 15, 'hello', True
print(new_tuple)

# prázdny tuple
empty_tuple = tuple()

# tuple s jedinou hodnotou
singleton_tuple = 5,
print(singleton_tuple)

# tuple s vnoreným zoznamom
new_tuple = 12, 15, 'hello', True, [12, 15, False]
print(new_tuple)

# vnorený tuple
nested_tuple = (12,14), 16
print(nested_tuple)

# prístup k hodnotám
nested_tuple = (12,14), 16
print(nested_tuple[1])
print(nested_tuple[0][0])

# hodnoty v tuple nemôžeme meniť
nested_tuple = 12,15, 'hello', True
nested_tuple[0] = 13

# ak je v tuple meniteľný element, ten sa meniť dá
nested_tuple = (12,14), 16, []
nested_tuple[2].append(3)
print(nested_tuple )

nested_tuple = [12,15], 'hello', True
nested_tuple[0][1] = 13
print (nested_tuple)

# to znamená že:
list = [4, (5, 7), (2, 3)]
list[0] = 5
list[1] = 5
list[2][1] = 4

# operácie ktoré tuple nemenia sú povolené:
test_tuple = 'hello', 15, [14, 15, 'egg'], True

print(len(test_tuple))
print(15 in test_tuple)
print(test_tuple + (4,2))
print(test_tuple[2:4])
print(test_tuple.index(15))
print(test_tuple.count('hello'))

# konverzia na list
new_tuple = (16, 12, 15, True, 'hello')
new_list = list(new_tuple)
print(new_list)

# a naopak
a_list = [15, 14, [2, 3]]
a_string = 'I want to be a tuple'
print(tuple(a_list))
print(tuple(a_string))

# iterujeme cez tuple, nič prekvapivé
test_tuple = 'hello', 15, [14, 15, 'egg'], True
for i in test_tuple:
    print (i)

# hromadné priraďovanie hodnôt z tuple
normal_tuple = (12 ,16, 7)
x, y, z = normal_tuple
print (x)
print (y)
print (z)

"""
2: SETS (množiny)

Meniteľné neusporiadané (= nepamätajú si poradie prvkov pri vytvorení) kolekcie unikátnych hodnôt. Set zjednodušuje operácie ako zoraďovanie, odstraňovanie duplicít, testovanie príslušnosti a množinové operácie.
"""

# vytvárame pomocou {}
new_set1 = {15, 17, False, 'tea'}

# prázdna množina
new_empty_set = set()

# konverzia z iných typov
new_set_string = set('creating a set')
new_set_list = set([12, 15])
new_set_tuple = set((15, True))

# list nie je povolený člen
set_with_list = {15, 0, [2, 3]}

# tuple áno
set_with_tuple = {15, 0, (2, 3)}

# povolené operátory
test_set = {'element3', 15, True}

print(len(test_set))
print(15 in test_set)

# pridanie hodnôt, funguje ako append() pri zozname
set_example = {15, 2, 0, 14}
set_example.add(7)
print(set_example)

# remove má problém ak element neexistuje
set_example = {15, 2, 0, 14}
set_example.remove(2)
print(set_example)
set_example.remove(158)

# zatiaľ čo discard
set_example = {15, 2, 0, 14}
set_example.discard(484564768)
print(set_example)

# množinové operácie
# union
a_set = {5,1,6,7,3,2}
print(a_set.union({4,5}))

# intersection
a_set = {5,1,6,7,3,2}
print(a_set.intersection({1,4,5}))

# difference
a_set = {5,1,6,7,3,2}
print(a_set.difference({1,4,5}))

# set nepripúšťa duplicitu hodôt
print(set('abrakadabra'))
print(set(((2,3), (2, 3))))

# iterácia
set_example = {15, 2, 0, 14}

for i in set_example:
    print (i)

# set comprehension (generátorová notácia množiny)
a_set = set(range(10))
b_set = {x ** 2 for x in a_set}
c_set = {x for x in a_set if x % 2 == 0}


"""
3: DICTIONARIES (slovník)

Meniteľná kolekecia dvojíc kľúč-hodnota (key-value pairs). Slovníky sú neusporiadané.
"""

a = dict(one=1, two=2, three=3)
b = {'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({'three': 3, 'one': 1, 'two': 2})


# kľúč slúži ako index pre nájdenie hodnoty (podobne ako heslo v knižnom slovníku).
# číselné indexy teda nefungujú
a_dict = {'a': 15, 'b': 17, 'c': 250}
a_dict[0]

# ale
print(a_dict['a'])

# slovníky sú meniteľné
a_dict = {'Bob': 45, 'Alice': 89, 'Cecilia': 250}
a_dict['Bob'] += 20
print(a_dict)

# kľúče a hodnoty môžu byť rôznych typov
a_dict = {1: 'text_value', 'text_key': 89, 3: [80, False]}

# operácie so slovníkom
a_dict = {'a': 156, 'b': 89, 'c': 41, 'd': 547}
print(a_dict.items())
print(a_dict.keys())
print(a_dict.values())
print(len(a_dict))

# get() vracia None pre nedefinovaný kľúč
print(a_dict.get(4))
print(a_dict.get('a'))

# iterujeme
dict_example = {'a': 156, 'b': 89, 'c': 41, 'd': 547}

for i in dict_example:
    print (i)

for i in dict_example.values():
    print (i)

for i in dict_example.keys():
    print (i)

# dictionary comprehension (generátorová notácia množiny)
a_list = list(range(10))
a_dict = {f:f**2 for f in a_list}
b_dict = {value:key for key, value in a_dict.items()}

# použite slovníka ako náhrady za switch-case štruktúru (ktorá v Pythone nie je)
time = int(input('what hour is it?')) # 10

what_to_do = {
    5: 'you should be sleeping',
    8: 'make a breakfast',
    10: 'have a coffee',
    15: 'go to shop',
    20: 'have a shower'
}

print(what_to_do[time])

# pomocou slovníkov môžeme vytvárať zložité objekty, pre menšie projekty to môže byť alternatíva k databáze
countries_stats = {
    'Nigeria' : {
'GDP': 1109000,
'rank': 20,
'languages': ['English']
    },
    'South Africa' : {
'GDP': 725004,
'rank': 30,
'languages': ['Zulu', 'Xhosa', 'Afrikaans', 'English']
    },
    'Ethiopia' : {
'GDP': 132000,
'rank': 65,
'languages': ['Amharic']
    }
}

print(countries_stats['Nigeria']['languages']) # ['English']


"""
4. EXCEPTIONS (výnimky)

Indikujú že niečo nie je v poriadku. Umožňujú odchytiť nesprávne vstupy, vytvoriť zrozumiteľné správy pre očakávané chyby, a zabrániť pádu programu pri očakávaných chybách

4A: TRY EXCEPT

try - blok kódu ktorý kontrolujeme
except - kód ktorý sa vykoná pri chybe v bloku try
"""

# bez try-except
print(4/0) # ZeroDivisionError: division by zero
print('next lines') # crash

# try-except blok
try:
    print(4/0)
except:
    print('math error')

print('next lines') # beh programu dôjde až sem napriek výnimke

# ošetrenie používateľského vstupu
number = input('select a number: ')

try:
    number + 5
    print(number + 5)
except:
    print('input is not a number')


# index() vracia chybu (ValueError) ak element v zozname chýba:
a_list = [5, 1, 6, 7, 3, 2]

for i in range(1,7):
    print('index of ',i, 'is', a_list.index(i))

# s try-except:
a_list = [5, 1, 6, 7, 3, 2]

for i in range(1,7):
    try:
        print('index of ',i, 'is', a_list.index(i))
    except:
        print(i, 'is not in list')

"""
4B: ELSE

else v bloku try-except označuje kód ktorý sa vykoná ak k výnimke nedôjde.
"""

try:
    number = int(input('enter a number:' ))
except:
    print('this is not a number')
else:
    print('this is a number')


"""
4C: FINALLY

finally v bloku try-except označuje kód ktorý sa vykoná na koniec nezávisle od toho či výnimka nastala alebo nie.
"""

try:
    number = int(input('enter a number:' ))
except:
    print('this is not a number')
else:
    print('this is a number')
finally:
    print('thank you for using our program')


"""
4D: RAISE

raise - ukončí beh programu s definovanou výnimkou (zoznam možných výnimiek na https://docs.python.org/3.3/library/exceptions.html#concrete-exceptions)
"""

# raise - predvolená výnimka
a_list = [5, 1, 6, 7, 3, 2]

for i in range(1,7):
    try:
        print('index of ',i, 'is', a_list.index(i))
    except:
        print(i, 'is not in list')
        raise # ValueError: to sa ale stane aj bez raise

# raise - definovaná výnimka
a_list = [5, 1, 6, 7, 3, 2]

for i in range(1,7):
    try:
        print('index of ',i, 'is', a_list.index(i))
    except:
        print(i, 'is not in list')
        raise AssertionError('hi there, this is a custom error message')

# raise môžeme použiť aj mimo try-except bloku

lucky_number = input('whats your lucky number?:' )
if lucky_number.find('7') == -1:
    raise Exception ('this is not a lucky number')
else:
    print('this is a lucky number')


"""
5. BREAK

break - brzda ktorá ukončí beh iterácie
"""

rainfall_months = [10, 120, 150, 200, 210, 268, 272, 281, 295, 330, 354, 389]
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']

rainfall_required = 270
month_required = str()

for mi in range(len(rainfall_months)):
    if rainfall_months[mi] > rainfall_required:
        month_required = months[mi]
        break # ďalej už hľadať nemusíme

print(month_required) # Jul