05-iterators-generators.slim

= slide 'Въпрос' do
  p Какво се случва, когато напишем <code>object.attr</code>?

  ol
    li.action Python връща <code>object.__dict__['attr']</code>
    li.action Ако няма такъв, Python търси в <code>object.__class__</code>, ако това е функция, се връща специален обект (bound method), на който може да извикате ().
    li.action Ако това в <code>object.__class__</code> не е функция, то просто се връща
    li.action Ако го няма там, се вика <code>object.__getattr__('attr')</code>

= slide 'Въпрос с код' do
  example:
    class A:
        pass

    def __str__(something):
        return "hax0r"

    a = A()
    a.__str__ = __str__

    print(a)

= slide 'Що е то итериране' do
    p Обикновено колекциите съдържат данни, които искаме да обхождаме.
    p Понякога тези данни не са подредени и няма начин да ги достъпваме директно.(<code>set</code>-ове, <code>dict</code>-ове)

= slide 'Как можем да итерираме' do
    p с <code>for</code>

    example:
        for cheese in cheeses:
            print('-{0}?'.format(cheese))
            print('-No...')

= slide 'Какво можем да итерираме' do
    p Итеруеми
    ul
        li <code>list</code>
        li <code>set</code>
        li <code>tuple</code>
        li <code>dict</code>
        li <code>range</code>
        li <code>map</code> и <code>filter</code> обекти
        li всичко в collections
        li
            strong всеки обект от клас имплементиращ <code>__getitem__</code>
        li ...

= slide 'многократно vs. еднократно' do
    p Някои обекти могат да се итерират многократно(списъци, множества...). Но не всички.

    annotate:
        squares = map(lambda x: x ** 2, range(5))
        for number in squares:
            print(number)
        # 0 1 4 9 16 

        for number in squares:
            print(number)
        #

    p Обикновено мързеливите се итерират по веднъж.

= slide '__iter__' do
    p Индексирането не винаги има смисъл, въпреки че обектът може да се итерира 
    p <code>__iter__</code> Връща обект-итератор, с който можем да обходим нашата "колекция"
    p Итераторът е обект, пазещ позицията на текущо обхождане на колекция
    p (обект, който има <code>__next__</code> метод)

= slide '__next__' do
    li Връща следващата стойност в обхождането
    li Предизвиква специална грешка(<code>StopIteration</code>), когато елементите свършат

= slide 'dunders' do
    li <code>iter(a)</code> <=> <code>a.__iter__()</code>
    li <code>next(a)</code> <=> <code>a.__next__()</code>
    li Има ред други подобни примери, за които споменахме предните път

    div.action
        p <strong>Забележка:</strong> трябва да имате МНОГО ДОБРА основателна причина, за да ползвате <code>a.__method__()</code> вместо <code>method(a)</code>
        p <strong>НЯМАТЕ</strong> такава причина

= slide 'What does the for do?' do
    p С разликата, че <code>for</code> ще обработи <code>StopIteration</code> грешката:
    annotate:
        interjections = [
            'Ring-ding-ding-ding-dingeringeding!',
            'Wa-pa-pa-pa-pa-pa-pow!',
            'Hatee-hatee-hatee-ho!',
            'Joff-tchoff-tchoffo-tchoffo-tchoff!'
        ]
        iterator = iter(interjections)
        while True:
            interjection = next(iterator)
            print(interjection)

= slide 'Кой итерира итератора?' do
    p Итераторите на стандартните обекти в python също имат <code>__iter__</code> метод, който не прави нищо особено зашеметяващо
    example:
        >>> iterable = iter([1, 2, 3])
        >>> iter(iterable) is iterable
        True

= slide 'Обобщено за iter' do
    p <code>iter</code> се опитва да извика <code>__iter__</code> метода на аргумента си, но ако се окаже, че такъв няма, конструира итератор, като просто извиква <code>__getitem__</code> с последователни естествени числа, започвайки от нула, докато не се хвърли <code>StopIteration</code>

    example:
        class IterableThingie:
            def __getitem__(self, index):
                if index < 10:
                    return index * 2
                else:
                    raise StopIteration()

        it = IterableThingie()
        for i in it:
            print(i)

    p.action Принтира 0, 2, 4, …, 18

= slide 'Обобщено за iter' do
    example:
        class IterableThingie:
            def __getitem__(self, index):
                if index < 10:
                    return index * 2
                else:
                    raise StopIteration()

            def __iter__(self):
                return iter('ⰰⰱⰲⰳⰴⰵⰶⰷⰸⰹⰺⰻ')

        it = IterableThingie()
        for i in it:
            print(i)

    p.action Принтира ⰰ, ⰱ, ⰲ, ⰳ, ⰴ, ⰵ, ⰶ, ⰷ, ⰸ, ⰹ, ⰺ, ⰻ

= slide 'Стражари и апаши' do
  p Има втора форма на <code>iter</code>, в която приема два аргумента, един callable обект и обект-страж.

  p В този случай върнатият итератор ще връща стойностите от последователните извиквания на callable обекта, докато той не върне обекта-страж. (по-скоро обект, който при сравнение със стража връща <code>True</code>)

  example:
      counter = 0
      def clbl():
          # WRITING CODE LIKE THIS WILL LIKELY RESULT
          # IN THE AGONIZING UNTIMELY DEATHS OF MANY
          # CUTE FURRY ANIMALS

          global counter
          counter += 1
          return counter

      iter(clbl, 23)
      list(_)

      # [1, 2, 3, …, 22]


= slide 'Итераторите са мързеливи' do
    p Казахме, че <code>map</code>, <code>filter</code> и <code>range</code> са мързеливи. Това означава, че всеки елемент се <strong>генерира</strong> чак когато е необходим.
    annotate:
        >>> odd = filter(lambda num: num % 2, range(10))
        >>> iter(odd) is odd
        True

= slide 'След като вече знаем това' do
    p Какво ще се случи тук?
    annotate:
        >>> loud_names = ['JEFF', 'STONE', 'MIKE', 'EDDIE', 'MATT']
        >>> quiet_names = map(lambda name: name.lower(), loud_names)
        >>> loud_names[3] = 'VEDDER'
        >>> print(list(quiet_names))

    div.action
        annotate:
            ['jeff', 'stone', 'mike', 'vedder', 'matt']

= slide 'sort' do
    p <code>list</code> обектите имат метод <code>sort</code>

    example:
        >>> numbers = [12, 15, 14, 10, 5, 7, 6]
        >>> print(numbers.sort())
        None
        >>> print(numbers)
        [5, 6, 7, 10, 12, 14, 15]

    p <strong>mutable нещата често пъти внасят усложнения</strong>

= slide 'sorted' do
    p Има вградена функция <code>sorted</code>

    example:
        >>> numbers = [12, 15, 14, 10, 5, 7, 6]
        >>> print(sorted(numbers))
        [5, 6, 7, 10, 12, 14, 15]
        >>> print(numbers)
        [12, 15, 14, 10, 5, 7, 6]

= slide 'Сортиране по ключ' do
    p <code>sorted</code> приема keyword аргумент <code>key</code>, който оказва как да се извлекат сравними стойности от елементите.

    example:
        >>> points = [(10, 3), (4, 8), (5, 9), (2, 3), (12, 6), (7, 4)]
        >>> sorted(points)
        [(2, 3), (4, 8), (5, 9), (7, 4), (10, 3), (12, 6)]
        >>> sorted(points, key=lambda point: point[1])
        [(10, 3), (2, 3), (7, 4), (12, 6), (4, 8), (5, 9)]

= slide 'reverse/reversed' do
    p Аналогично
    ul
        li <code>reverse</code> - метод на <code>list</code>, който обръща списъка на място
        li <code>reversed</code> - вградена функция, която връща ново итеруемо

    example:
        >>> numbers = [12, 15, 14, 10, 5, 7, 6]
        >>> reversed(numbers)
        <list_reverseiterator object at 0x7f14ff534490>
        >>> list(_)
        [6, 7, 5, 10, 14, 15, 12]

    p Ако добавяте/махате елементи, докато итерирате резултата от <code>reversed</code>, няма да останете доволни

= slide 'yield' do
    ul
        li.action албум на "Pearl Jam"
        li.action знак "Дай предимство" в Канада, Ирландия, ЮАР, Южна Корея и САЩ
        li.action ключова дума в python

= slide 'Генератори' do
    annotate:
        def actors_generator():
            yield 'Graham Chapman'
            yield 'John Cleese'
            yield 'Terry Gilliam'
            yield 'Eric Idle'
            yield 'Terry Jones'
            yield 'Michael Palin'

        actors = actors_generator()
        for actor in actors:
            print(actor + ' as seen on British TV')

= slide 'Защо?' do
    p Iterator pattern
    annotate:
        class SquaresUpTo:
            def __init__(self, up_to):
                self.up_to = up_to
                self.num = 0

            def __iter__(self):
                return self

            def __next__(self):
                if self.num > self.up_to:
                    raise StopIteration

                square = self.num ** 2
                self.num += 1
                return square

= slide 'Защо?' do
    p Можем да го използваме ето така
    annotate:
        squares = SquaresUpTo(100)

        for square in squares:
            print(square)

= slide 'С генератор' do
    annotate:
      def squares_up_to(number):
          value = 0
          while value <= number:
              yield value ** 2
              value += 1
          raise StopIteration

= slide 'Генератори' do
    img src='5/oreo.jpg' style='height: 80%;'

= slide 'Generator expression' do
    p Като list comprehension, но с обли скоби и "мързелив":
    example:
       squares_up_to_ten = (number ** 2 for number in range(10))


= slide 'Функции по темата' do
    ul
        li <code>any</code>, <code>all</code>
        li <code>map</code>, <code>filter</code>
        li <code>list</code>, <code>tuple</code>, <code>set</code>
        li <code>enumerate</code>
        li <code>zip</code>

= slide 'Проверки' do
    p Ако искаме да проверим дали елементите на итеруемо отговарят на условие
    annotate:
        >>> all([True, True])
        True
        >>> all([True, False])
        False
        >>> any([True, False])
        True

= slide 'Какво правят map и filter' do
    p Приемат итеруеми и връщат итератори.(<strong>2 vs. 3</strong>)

    p Ето добър пример защо това е хубава идея:

    annotate:
        def numbers():
            num = 0
            while True:
                yield num
                num += 1

        doulbes = map(lambda num: num*2, numbers())

= slide 'enumerate' do
    p Когато индексите ни интересуват

    annotate:
        >>> exclamations = ['кòли', 'бèси', 'сèчи']
        >>> for index, exclamation in enumerate(exclamations):
        ...     print('{0}. {1}!'.format(index, exclamation))
        ...

    div.action
        example:
            0. кòли!
            1. бèси!
            2. сèчи!


= slide 'zip' do
    p Итерира едновременно няколко итеруеми

    annotate:
        titles = ['Ænima', 'Lateralus', '10,000 Days']
        positions_US = [2, 1, 1]
        positions_UK = [108, 16, 4]
        template = 'Tool\'s {0} was at {1} in the US and at {2} in the UK'

        for title, us_pos, uk_pos in zip(titles, positions_US, positions_UK):
            print(template.format(title, us_pos, uk_pos))

= slide 'itertools' do
    p Удобства за работа с итеруеми обекти.
    p Всички функции в него са „мързеливи“.

= slide 'itertools.accumulate' do
    annotate:
        >>> from itertools import accumulate
        >>> sums = accumulate(range(1, 101), lambda a, b: a + b)
        >>> print(sums)
        <itertools.accumulate object at 0x7ff61d24b518>
        >>> next(sums)
        1
        >>> next(sums)
        3
        >>> next(sums)
        6
        >>> list(sums)[-1]
        5050

= slide 'itertools.chain' do
    p Конкатенира итеруеми
    annotate:
        >>> from itertools import chain
        >>> all_to_15 = chain(range(10), range(11, 15))
        >>> list(all_to_15)
        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14]

= slide 'itertools.compress' do
    p Връща част от итеруемо според маска
    annotate:
        >>> from itertools import compress
        >>> list(compress(range(10), [True, False]*5)
        [0, 2, 4, 6, 8]

= slide 'itertools.groupby' do
    p Групира сортирана последователност от елементи по ключ
    annotate:
        >>> from itertools import groupby
        >>> from collections import defaultdict
        >>> data = [ ('John', 'Tilsit'), ('Eric', 'Cheshire'), ('Michael', 'Camembert'),
        ...                  ('Terry', 'Gouda'), ('Terry', 'Port Salut'), ('Michael', 'Edam'),
        ...                  ('Eric', 'Ilchester'), ('John', 'Fynbo') ]
        >>> data = sorted(data, key=lambda record: record[0])
        >>> by_owner = defaultdict(list)
        >>> for key, group in groupby(data, lambda record: record[0]):
        ...     for record in group:
        ...         by_owner[key].append(record[1])
        ...
        >>> by_owner['Terry']
        ['Gouda', 'Port Salut']

= slide 'also starring' do
    ul
        li <code>itertools.repeat(objects[, times])</code> - връща итеруемо с опредлен брой(или безкрайно много) повторения на един обект
        li <code>itertools.cycle(iterable)</code> - безкрайна конкатенация на един итеруем обект
        li <code>itertools.filterfalse(function, iterable)</code> - filter, тълкуващ предиката на обратно(ако function е None, връща falsy елементите)
        li <code>itertools.permutations(iterable)</code> - генерира пермутациите на елементите в итеруемото
        li <code>itertools.product(*iterables [,repeat=1])</code> - връща декартово произведение на итеруеми
        li <code>itertools.takewhile(function, iterable)</code> - генерира елементите на итеруемото до първото, което не отговаря на предиката
        li <code>itertools.dropwhile(function, iterable)</code> - генерира елементите на итеруемото от първото, което не отговаря на предиката нататък
        li <code>itertools.tee(iterable, n)</code> - връща кортеж от n независими итеруеми

= slide 'itertools' do
    p EXPLORE!

    div.action
        annotate:
            import itertools
            dir(itertools)
            help(itertools)