def итератор_демо():
    """Коришћење итератора.

    >>> с = [[1, 2], 3, 4, 5]
    >>> next(с)
    Traceback (most recent call last):
        ...
    TypeError: 'list' object is not an iterator
    >>> т = iter(с)
    >>> next(т)
    [1, 2]
    >>> next(т)
    3
    >>> у = iter(с)
    >>> next(у)
    [1, 2]
    >>> list(т)
    [4, 5]
    >>> next(т)
    Traceback (most recent call last):
        ...
    StopIteration
    >>> р = {'један': 1, 'два': 2, 'три': 3} # Кључеви и вредности
    >>> к = iter(р) # next(к)
    >>> в = iter(р.values()) # next(в)
    >>> к = iter(р)
    >>> р.pop('два')
    2
    >>> next(к)
    Traceback (most recent call last):
        ...
    RuntimeError: dictionary changed size during iteration
    >>> о = range(3, 6)
    >>> с = iter(о)
    >>> next(с)
    3
    >>> for x in с:
    ...     print(x)
    4
    5
    >>> for x in с:
    ...     print(x)
    >>> for x in о:
    ...    print(x)
    3
    4
    5
    >>> for x in о:
    ...    print(x)
    3
    4
    5
    """

def дупло(x):
    print('***', x, '=>', 2*x, '***')
    return 2*x

def уграђене_функције_демо():
    """Коришћење уграђених фукнција секвенце.

    >>> бвг = ['б', 'в', 'г']
    >>> [x.upper() for x in бвг]
    ['Б', 'В', 'Г']
    >>> велика = map(lambda x: x.upper(), бвг)
    >>> next(велика)
    'Б'
    >>> next(велика)
    'В'
    >>> next(велика)
    'Г'
    >>> о = range(3, 7)
    >>> дуплирани = map(дупло, о)
    >>> next(дуплирани)
    *** 3 => 6 ***
    6
    >>> next(дуплирани)
    *** 4 => 8 ***
    8
    >>> list(дуплирани)
    *** 5 => 10 ***
    *** 6 => 12 ***
    [10, 12]
    >>> ф = lambda x: x < 10
    >>> т = filter(ф, map(дупло, reversed(о)))
    >>> list(т)
    *** 6 => 12 ***
    *** 5 => 10 ***
    *** 4 => 8 ***
    *** 3 => 6 ***
    [8, 6]
    >>> н = [1, 2, 3, 2, 1]
    >>> reversed(н) == н
    False
    >>> list(reversed(н)) == н
    True
    >>> р = {'а': 1, 'б': 2, 'в': 3, 'г': 4, 'д': 5}
    >>> парови = zip(р.keys(), р.values()) # Позив next(парови)
    """

# Zip

def палиндром(с):
    """Враћа да ли је с иста секвенца гледано унапред и уназад.

    >>> палиндром([3, 1, 4, 1, 5])
    False
    >>> палиндром([3, 1, 4, 1, 3])
    True
    >>> палиндром('ониволебеловино')
    True
    >>> палиндром('они воле бело вино')
    False
    """
    # return с == reversed(с)  # Ово решење не ради
    return all([x == y for x, y in zip(с, reversed(с))])
    return list(с) == list(reversed(с))

# Blackjack

import random

бодови = {'J': 10, 'Q': 10, 'K':10, 'A': 1}

def збир_руке(рука):
    """Укупан број бодова руке.

    >>> збир_руке(['A', 3, 6])
    20
    >>> збир_руке(['A', 'J', 'A'])
    12
    """
    укупно = sum([бодови.get(карта, карта) for карта in рука])
    if укупно <= 11 and 'A' in рука:
        return укупно + 10
    return укупно

def промешај_карте():
    шпил = (['J', 'Q', 'K', 'A'] + list(range(2, 11))) * 4
    random.shuffle(шпил)
    return iter(шпил)

def основна_стратегија(отворена_карта, карте):
    if збир_руке(карте) <= 11:
        return True
    if отворена_карта in [2, 3, 4, 5, 6]:
        return False
    return збир_руке(карте) < 17

def потез_играча(отворена_карта, карте, стратегија, шпил):
    while збир_руке(карте) <= 21 and стратегија(отворена_карта, карте):
        карте.append(next(шпил))

def потез_делитеља(карте, шпил):
    while збир_руке(карте) < 17:
        карте.append(next(шпил))

def блекџек(стратегија, објава=print):
    """Игра једног дељења у блекџеку."""
    шпил = промешај_карте()

    карте_играча = [next(шпил)]
    отворена_карта = next(шпил)
    карте_играча.append(next(шпил))
    затворена_карта = next(шпил)

    потез_играча(отворена_карта, карте_играча, стратегија, шпил)
    if збир_руке(карте_играча) > 21:
        објава('Играч губи са', карте_играча,
               'против', отворена_карта)
        return -1

    карте_делитеља = [отворена_карта, затворена_карта]
    потез_делитеља(карте_делитеља, шпил)
    if збир_руке(карте_делитеља) > 21:
        објава('Делитељ губи са', карте_делитеља)
        return 1
    else:
        објава('Играч има', збир_руке(карте_играча),
               'а делитељ има', збир_руке(карте_делитеља))
        разлика = збир_руке(карте_играча) - збир_руке(карте_делитеља)
        return max(-1, min(1, разлика))

def пссс(*args):
    "Не исписуј (и не ради ништа друго)."

def коцкање(стратегија, руке=1000):
    return sum([блекџек(стратегија, пссс) for _ in range(руке)])
