Solutions generators exercises

ex1: Python Students

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# python_students.py

class PythonStudents:
    
    def __init__(self):
        self.students = []

    def __add__(self, student):
        self.students.append(student)

    def __iter__(self):
        self.index = 0
        return self

    def __next__(self):
        ri = self.index
        self.index += 1
        if self.index > len(self.students):
            raise StopIteration()
        return self.students[ri]



class Student:

    def __init__(self, name, cpr):
        self.name = name
        self.cpr = cpr

    @property
    def name(self):
            return self.__name

    @name.setter
    def name(self, name):
            self.__name = name.capitalize()

    def __add__(self, student):
            return Student('Anna the daugther', 1234)

    def __str__(self):
            return f'{self.name}, {self.cpr}'

    def __repr__(self):
            return f'{self.__dict__}'

ex2: School of students

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# school_of_students.py

import random
import time

def timer(func):
    def wrapper(*args):
        start = time.time()
        val = func(*args)
        end = (time.time()) - start
        print(f'Time elepsed: {end}')
        return val
    return wrapper

names = ['John', 'Corey', 'Adam', 'Steve', 'Rick', 'Thomas']
majors = ['Math', 'Engineering', 'CompSci', 'Arts', 'Business']

@timer
def people_list(num_people):
    result = []
    for i in range(num_people):
        person = {
            'id': i,
            'name': random.choice(names),
            'major': random.choice(majors)
        }
        result.append(person)
    # return result

@timer
def people_generator(num_people):
    for i in range(num_people):
        person = {
            'id': i,
            'name': random.choice(names),
            'major': random.choice(majors)
        }
        yield person

ex3: Range Mimic

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# range_mimic.py

# 1. Create a "clone" of the build in range() function.

class MyRange:

    def __call__(self, *args):
        if len(args) == 1:
            self.start = 0
            self.end = args[0]
            self.step = 1
        elif len(args) == 2:
            self.start = args[0]
            self.end = args[1]
            self.step = 1
        elif len(args) == 3:
            self.start = args[0]
            self.end = args[1]
            self.step = args[2]
        return iter(self)

    def __iter__(self):
        self.i = self.start
        return self

    def __next__(self):
        try:
            if self.end > self.i:
                self.tmp = self.i
                self.i += self.step
                return self.tmp
            else:
                raise StopIteration
        except AttributeError:
            raise TypeError('range method is not itterable')


my_range = MyRange()
x = my_range(2, 12, 2)
for i in x:
    print(i)


# 2. Now do the same, but use a generator function instead.
def my_range_gen(start, stop, step):
    r = MyRange()
    for i in r(start, stop, step):
        yield i