FilesExpand file tree

 monkeyPatching

/

about_generators.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

149 lines (109 loc) · 4.58 KB

 monkeyPatching

/

about_generators.py

Copy path

Top

File metadata and controls

• Code
• Blame

149 lines (109 loc) · 4.58 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

#!/usr/bin/env python

# -*- coding: utf-8 -*-

#

# Written in place of AboutBlocks in the Ruby Koans

#

# Note: Both blocks and generators use a yield keyword, but they behave

# a lot differently

#

from runner.koan import *

class AboutGenerators(Koan):

def test_generating_values_on_the_fly(self):

result = list()

bacon_generator = (n + ' bacon' for n in ['crunchy','veggie','danish'])

for bacon in bacon_generator:

result.append(bacon)

self.assertEqual(['crunchy bacon', 'veggie bacon', 'danish bacon'], result)

def test_generators_are_different_to_list_comprehensions(self):

num_list = [x*2 for x in range(1,3)]

num_generator = (x*2 for x in range(1,3))

self.assertEqual(2, num_list[0])

# A generator has to be iterated through.

with self.assertRaises(TypeError): num = num_generator[0]

self.assertEqual(2, list(num_generator)[0])

# Both list comprehensions and generators can be iterated though. However, a generator

# function is only called on the first iteration. The values are generated on the fly

# instead of stored.

#

# Generators are more memory friendly, but less versatile

def test_generator_expressions_are_a_one_shot_deal(self):

dynamite = ('Boom!' for n in range(3))

attempt1 = list(dynamite)

attempt2 = list(dynamite)

self.assertEqual(['Boom!', 'Boom!', 'Boom!'], list(attempt1))

self.assertEqual([], list(attempt2))

# ------------------------------------------------------------------

def simple_generator_method(self):

yield 'peanut'

yield 'butter'

yield 'and'

yield 'jelly'

def test_generator_method_will_yield_values_during_iteration(self):

result = list()

for item in self.simple_generator_method():

result.append(item)

self.assertEqual(['peanut', 'butter', 'and', 'jelly'], result)

def test_coroutines_can_take_arguments(self):

result = self.simple_generator_method()

self.assertEqual('peanut', next(result))

self.assertEqual('butter', next(result))

result.close()

# ------------------------------------------------------------------

def square_me(self, seq):

for x in seq:

yield x * x

def test_generator_method_with_parameter(self):

result = self.square_me(range(2,5))

self.assertEqual([4, 9, 16], list(result))

# ------------------------------------------------------------------

def sum_it(self, seq):

value = 0

for num in seq:

# The local state of 'value' will be retained between iterations

value += num

yield value

def test_generator_keeps_track_of_local_variables(self):

result = self.sum_it(range(2,5))

self.assertEqual([2, 5, 9], list(result))

# ------------------------------------------------------------------

def generator_with_coroutine(self):

result = yield

yield result

def test_generators_can_take_coroutines(self):

generator = self.generator_with_coroutine()

# THINK ABOUT IT:

# Why is this line necessary?

#

# Hint: Read the "Specification: Sending Values into Generators"

# section of http://www.python.org/dev/peps/pep-0342/

next(generator)

self.assertEqual(3, generator.send(1 + 2))

def test_before_sending_a_value_to_a_generator_next_must_be_called(self):

generator = self.generator_with_coroutine()

try:

generator.send(1+2)

except TypeError as ex:

ex2 = ex

self.assertRegex(ex2.args[0], r'non-None value to a just-started')

# Curisity testing

generator.send(None)

self.assertEqual(3, generator.send(1 + 2))

# ------------------------------------------------------------------

def yield_tester(self):

value = yield

if value:

yield value

else:

yield 'no value'

def test_generators_can_see_if_they_have_been_called_with_a_value(self):

generator = self.yield_tester()

next(generator)

self.assertEqual('with value', generator.send('with value'))

generator2 = self.yield_tester()

next(generator2)

self.assertEqual('no value', next(generator2))

def test_send_none_is_equivalent_to_next(self):

generator = self.yield_tester()

next(generator)

# 'next(generator)' is exactly equivalent to 'generator.send(None)'

self.assertEqual('no value', generator.send(None))