From 8d0c9232f0bd422be5896bf9ec80a7a10ae5c0b0 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Wed, 9 Oct 2024 18:20:08 +0800
Subject: [PATCH 01/51] update

---
 koans/about_asserts.py | 14 +++++++-------
 koans/about_strings.py | 26 ++++++++++++++------------
 2 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/koans/about_asserts.py b/koans/about_asserts.py
index d17ed0cdf..a85869529 100644
--- a/koans/about_asserts.py
+++ b/koans/about_asserts.py
@@ -14,25 +14,25 @@ def test_assert_truth(self):
         #
         #   http://bit.ly/about_asserts
 
-        self.assertTrue(False) # This should be True
+        self.assertTrue(True) # This should be True
 
     def test_assert_with_message(self):
         """
         Enlightenment may be more easily achieved with appropriate messages.
         """
-        self.assertTrue(False, "This should be True -- Please fix this")
+        self.assertTrue(True, "This should be True -- Please fix this")
 
     def test_fill_in_values(self):
         """
         Sometimes we will ask you to fill in the values
         """
-        self.assertEqual(__, 1 + 1)
+        self.assertEqual(2, 1 + 1)
 
     def test_assert_equality(self):
         """
         To understand reality, we must compare our expectations against reality.
         """
-        expected_value = __
+        expected_value = 2
         actual_value = 1 + 1
         self.assertTrue(expected_value == actual_value)
 
@@ -40,7 +40,7 @@ def test_a_better_way_of_asserting_equality(self):
         """
         Some ways of asserting equality are better than others.
         """
-        expected_value = __
+        expected_value = 2
         actual_value = 1 + 1
 
         self.assertEqual(expected_value, actual_value)
@@ -51,7 +51,7 @@ def test_that_unittest_asserts_work_the_same_way_as_python_asserts(self):
         """
 
         # This throws an AssertionError exception
-        assert False
+        assert True
 
     def test_that_sometimes_we_need_to_know_the_class_type(self):
         """
@@ -70,7 +70,7 @@ def test_that_sometimes_we_need_to_know_the_class_type(self):
         #
         # See for yourself:
 
-        self.assertEqual(__, "navel".__class__) # It's str, not <type 'str'>
+        self.assertEqual(str, "navel".__class__) # It's str, not <type 'str'>
 
         # Need an illustration? More reading can be found here:
         #
diff --git a/koans/about_strings.py b/koans/about_strings.py
index 25f5f59df..fd93762e3 100644
--- a/koans/about_strings.py
+++ b/koans/about_strings.py
@@ -7,57 +7,59 @@ class AboutStrings(Koan):
 
     def test_double_quoted_strings_are_strings(self):
         string = "Hello, world."
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_single_quoted_strings_are_also_strings(self):
         string = 'Goodbye, world.'
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_triple_quote_strings_are_also_strings(self):
         string = """Howdy, world!"""
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_triple_single_quotes_work_too(self):
         string = '''Bonjour tout le monde!'''
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_raw_strings_are_also_strings(self):
         string = r"Konnichi wa, world!"
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_use_single_quotes_to_create_string_with_double_quotes(self):
         string = 'He said, "Go Away."'
-        self.assertEqual(__, string)
+        self.assertEqual('He said, "Go Away."', string)
 
     def test_use_double_quotes_to_create_strings_with_single_quotes(self):
         string = "Don't"
-        self.assertEqual(__, string)
+        self.assertEqual("Don't", string)
 
     def test_use_backslash_for_escaping_quotes_in_strings(self):
         a = "He said, \"Don't\""
         b = 'He said, "Don\'t"'
-        self.assertEqual(__, (a == b))
+
+        self.assertEqual(True, (a == b))
 
     def test_use_backslash_at_the_end_of_a_line_to_continue_onto_the_next_line(self):
         string = "It was the best of times,\n\
 It was the worst of times."
-        self.assertEqual(__, len(string))
+
+        self.assertEqual(52, len(string))
 
     def test_triple_quoted_strings_can_span_lines(self):
         string = """
 Howdy,
 world!
 """
-        self.assertEqual(__, len(string))
+        self.assertEqual(15, len(string))
 
     def test_triple_quoted_strings_need_less_escaping(self):
         a = "Hello \"world\"."
         b = """Hello "world"."""
-        self.assertEqual(__, (a == b))
+        self.assertEqual(True, (a == b))
 
     def test_escaping_quotes_at_the_end_of_triple_quoted_string(self):
         string = """Hello "world\""""
-        self.assertEqual(__, string)
+        self.assertEqual('Hello "world"', string)
 
     def test_plus_concatenates_strings(self):
         string = "Hello, " + "world"

From 48cc840ea8c771306d06770a6f63989a645a4271 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Wed, 9 Oct 2024 18:32:28 +0800
Subject: [PATCH 02/51] finish about strings

---
 koans/about_strings.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/koans/about_strings.py b/koans/about_strings.py
index fd93762e3..2d6194555 100644
--- a/koans/about_strings.py
+++ b/koans/about_strings.py
@@ -63,34 +63,34 @@ def test_escaping_quotes_at_the_end_of_triple_quoted_string(self):
 
     def test_plus_concatenates_strings(self):
         string = "Hello, " + "world"
-        self.assertEqual(__, string)
+        self.assertEqual("Hello, world", string)
 
     def test_adjacent_strings_are_concatenated_automatically(self):
         string = "Hello" ", " "world"
-        self.assertEqual(__, string)
+        self.assertEqual("Hello, world", string)
 
     def test_plus_will_not_modify_original_strings(self):
         hi = "Hello, "
         there = "world"
         string = hi + there
-        self.assertEqual(__, hi)
-        self.assertEqual(__, there)
+        self.assertEqual("Hello, ", hi)
+        self.assertEqual("world", there)
 
     def test_plus_equals_will_append_to_end_of_string(self):
         hi = "Hello, "
         there = "world"
         hi += there
-        self.assertEqual(__, hi)
+        self.assertEqual("Hello, world", hi)
 
     def test_plus_equals_also_leaves_original_string_unmodified(self):
         original = "Hello, "
         hi = original
         there = "world"
         hi += there
-        self.assertEqual(__, original)
+        self.assertEqual("Hello, ", original)
 
     def test_most_strings_interpret_escape_characters(self):
         string = "\n"
         self.assertEqual('\n', string)
         self.assertEqual("""\n""", string)
-        self.assertEqual(__, len(string))
+        self.assertEqual(1, len(string))

From 5d370993f2de3562a9272995e305ac0842624174 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Fri, 11 Oct 2024 00:30:10 +0800
Subject: [PATCH 03/51] finish None, Daily Python exercise

---
 koans/about_none.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/koans/about_none.py b/koans/about_none.py
index 1731f0108..3d947883d 100644
--- a/koans/about_none.py
+++ b/koans/about_none.py
@@ -11,11 +11,11 @@ class AboutNone(Koan):
 
     def test_none_is_an_object(self):
         "Unlike NULL in a lot of languages"
-        self.assertEqual(__, isinstance(None, object))
+        self.assertEqual(True, isinstance(None, object))
 
     def test_none_is_universal(self):
         "There is only one None"
-        self.assertEqual(____, None is None)
+        self.assertEqual(True, None is None)
 
     def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         """
@@ -27,7 +27,7 @@ def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         Don't worry about what 'try' and 'except' do, we'll talk about this later
         """
         try:
-            None.some_method_none_does_not_know_about()
+            None.some_method_none_does_not_know_about() # type: ignore
         except Exception as ex:
             ex2 = ex
 
@@ -37,15 +37,15 @@ def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         #
         #     https://github.com/gregmalcolm/python_koans/wiki/Class-Attribute
 
-        self.assertEqual(__, ex2.__class__)
+        self.assertEqual(AttributeError, ex2.__class__) # type: ignore
 
         # What message was attached to the exception?
         # (HINT: replace __ with part of the error message.)
-        self.assertRegex(ex2.args[0], __)
+        self.assertRegex(ex2.args[0], "'NoneType' object has no attribute 'some_method_none_does_not_know_about'") # type: ignore
 
     def test_none_is_distinct(self):
         """
         None is distinct from other things which are False.
         """
-        self.assertEqual(__, None is not 0)
-        self.assertEqual(__, None is not False)
+        self.assertEqual(True, None is not 0)
+        self.assertEqual(True, None is not False)

From fbcd2d7c02cfb07d4b04d6daf43b68496dc41f87 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sat, 19 Oct 2024 16:31:13 +0800
Subject: [PATCH 04/51] python daily exercise - about lists

---
 koans/about_lists.py | 67 ++++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 33 deletions(-)

diff --git a/koans/about_lists.py b/koans/about_lists.py
index 61cc3bb29..de13bf123 100644
--- a/koans/about_lists.py
+++ b/koans/about_lists.py
@@ -11,7 +11,7 @@ class AboutLists(Koan):
     def test_creating_lists(self):
         empty_list = list()
         self.assertEqual(list, type(empty_list))
-        self.assertEqual(__, len(empty_list))
+        self.assertEqual(0, len(empty_list))
 
     def test_list_literals(self):
         nums = list()
@@ -21,70 +21,71 @@ def test_list_literals(self):
         self.assertEqual([1], nums)
 
         nums[1:] = [2]
-        self.assertListEqual([1, __], nums)
+        self.assertListEqual([1, 2], nums)
 
         nums.append(333)
-        self.assertListEqual([1, 2, __], nums)
+        self.assertListEqual([1, 2, 333], nums)
 
     def test_accessing_list_elements(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(__, noms[0])
-        self.assertEqual(__, noms[3])
-        self.assertEqual(__, noms[-1])
-        self.assertEqual(__, noms[-3])
+        self.assertEqual('peanut', noms[0])
+        self.assertEqual('jelly', noms[3])
+        self.assertEqual('jelly', noms[-1])
+        self.assertEqual('butter', noms[-3])
 
     def test_slicing_lists(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(__, noms[0:1])
-        self.assertEqual(__, noms[0:2])
-        self.assertEqual(__, noms[2:2])
-        self.assertEqual(__, noms[2:20])
-        self.assertEqual(__, noms[4:0])
-        self.assertEqual(__, noms[4:100])
-        self.assertEqual(__, noms[5:0])
+        self.assertEqual(['peanut'], noms[0:1])
+
+        self.assertEqual(['peanut', 'butter'], noms[0:2])
+        self.assertEqual([], noms[2:2])
+        self.assertEqual(['and', 'jelly'], noms[2:20])
+        self.assertEqual([], noms[4:0])
+        self.assertEqual([], noms[4:100])
+        self.assertEqual([], noms[5:0])
 
     def test_slicing_to_the_edge(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(__, noms[2:])
-        self.assertEqual(__, noms[:2])
+        self.assertEqual(['and', 'jelly'], noms[2:])
+        self.assertEqual(['peanut', 'butter'], noms[:2])
 
     def test_lists_and_ranges(self):
         self.assertEqual(range, type(range(5)))
         self.assertNotEqual([1, 2, 3, 4, 5], range(1,6))
-        self.assertEqual(__, list(range(5)))
-        self.assertEqual(__, list(range(5, 9)))
+        self.assertEqual([0,1,2,3,4], list(range(5)))
+        self.assertEqual([5,6,7,8], list(range(5, 9)))
 
     def test_ranges_with_steps(self):
-        self.assertEqual(__, list(range(5, 3, -1)))
-        self.assertEqual(__, list(range(0, 8, 2)))
-        self.assertEqual(__, list(range(1, 8, 3)))
-        self.assertEqual(__, list(range(5, -7, -4)))
-        self.assertEqual(__, list(range(5, -8, -4)))
+        self.assertEqual([5,4], list(range(5, 3, -1)))
+        self.assertEqual([0, 2, 4, 6], list(range(0, 8, 2)))
+        self.assertEqual([1, 4, 7], list(range(1, 8, 3)))
+        self.assertEqual([5,1, -3], list(range(5, -7, -4)))
+        self.assertEqual([5, 1, -3, -7], list(range(5, -8, -4)))
 
     def test_insertions(self):
         knight = ['you', 'shall', 'pass']
         knight.insert(2, 'not')
-        self.assertEqual(__, knight)
+        self.assertEqual(['you', 'shall', 'not', 'pass'], knight)
 
         knight.insert(0, 'Arthur')
-        self.assertEqual(__, knight)
+        self.assertEqual(['Arthur', 'you', 'shall', 'not', 'pass'], knight)
 
     def test_popping_lists(self):
         stack = [10, 20, 30, 40]
         stack.append('last')
 
-        self.assertEqual(__, stack)
+        self.assertEqual([10, 20, 30, 40, 'last'], stack)
 
         popped_value = stack.pop()
-        self.assertEqual(__, popped_value)
-        self.assertEqual(__, stack)
+        self.assertEqual('last', popped_value)
+        self.assertEqual([10, 20, 30, 40], stack)
 
         popped_value = stack.pop(1)
-        self.assertEqual(__, popped_value)
-        self.assertEqual(__, stack)
+        self.assertEqual(20, popped_value)
+        self.assertEqual([10, 30, 40], stack)
 
         # Notice that there is a "pop" but no "push" in python?
 
@@ -98,11 +99,11 @@ def test_making_queues(self):
         queue = [1, 2]
         queue.append('last')
 
-        self.assertEqual(__, queue)
+        self.assertEqual([1, 2, 'last'], queue)
 
         popped_value = queue.pop(0)
-        self.assertEqual(__, popped_value)
-        self.assertEqual(__, queue)
+        self.assertEqual(1, popped_value)
+        self.assertEqual([2, 'last'], queue)
 
         # Note, popping from the left hand side of a list is
         # inefficient. Use collections.deque instead.

From 083a4c11dda55e80735540f306f7deeb69bf8f28 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sun, 20 Oct 2024 22:24:05 +0800
Subject: [PATCH 05/51] python daily exercise

---
 koans/about_list_assignments.py | 30 +++++++++++++++++-------------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/koans/about_list_assignments.py b/koans/about_list_assignments.py
index 8a8d48090..2bc1337e9 100644
--- a/koans/about_list_assignments.py
+++ b/koans/about_list_assignments.py
@@ -10,34 +10,38 @@
 class AboutListAssignments(Koan):
     def test_non_parallel_assignment(self):
         names = ["John", "Smith"]
-        self.assertEqual(__, names)
+        self.assertEqual(["John", "Smith"], names)
 
     def test_parallel_assignments(self):
         first_name, last_name = ["John", "Smith"]
-        self.assertEqual(__, first_name)
-        self.assertEqual(__, last_name)
+        self.assertEqual("John", first_name)
+        self.assertEqual("Smith", last_name)
 
     def test_parallel_assignments_with_extra_values(self):
         title, *first_names, last_name = ["Sir", "Ricky", "Bobby", "Worthington"]
-        self.assertEqual(__, title)
-        self.assertEqual(__, first_names)
-        self.assertEqual(__, last_name)
+
+        self.assertEqual("Sir", title)
+        self.assertEqual(["Ricky", "Bobby"], first_names)
+        self.assertEqual("Worthington", last_name)
 
     def test_parallel_assignments_with_fewer_values(self):
         title, *first_names, last_name = ["Mr", "Bond"]
-        self.assertEqual(__, title)
-        self.assertEqual(__, first_names)
-        self.assertEqual(__, last_name)
+        print(title)
+        print(first_names)
+        print(last_name)
+        self.assertEqual("Mr", title)
+        self.assertEqual([], first_names)
+        self.assertEqual("Bond", last_name)
 
     def test_parallel_assignments_with_sublists(self):
         first_name, last_name = [["Willie", "Rae"], "Johnson"]
-        self.assertEqual(__, first_name)
-        self.assertEqual(__, last_name)
+        self.assertEqual(["Willie", "Rae"], first_name)
+        self.assertEqual("Johnson", last_name)
 
     def test_swapping_with_parallel_assignment(self):
         first_name = "Roy"
         last_name = "Rob"
         first_name, last_name = last_name, first_name
-        self.assertEqual(__, first_name)
-        self.assertEqual(__, last_name)
+        self.assertEqual("Rob", first_name)
+        self.assertEqual("Roy", last_name)
 

From 268a75a59ff70b158c5ed55310834557e1093dfe Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Mon, 21 Oct 2024 01:43:37 +0800
Subject: [PATCH 06/51] dict, string manipulation

---
 koans/about_dictionaries.py        | 30 +++++++++++++++---------------
 koans/about_string_manipulation.py |  2 +-
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/koans/about_dictionaries.py b/koans/about_dictionaries.py
index da1ed6bfe..0d81d1356 100644
--- a/koans/about_dictionaries.py
+++ b/koans/about_dictionaries.py
@@ -12,46 +12,46 @@ def test_creating_dictionaries(self):
         empty_dict = dict()
         self.assertEqual(dict, type(empty_dict))
         self.assertDictEqual({}, empty_dict)
-        self.assertEqual(__, len(empty_dict))
+        self.assertEqual(0, len(empty_dict))
 
     def test_dictionary_literals(self):
         empty_dict = {}
         self.assertEqual(dict, type(empty_dict))
         babel_fish = { 'one': 'uno', 'two': 'dos' }
-        self.assertEqual(__, len(babel_fish))
+        self.assertEqual(2, len(babel_fish))
 
     def test_accessing_dictionaries(self):
         babel_fish = { 'one': 'uno', 'two': 'dos' }
-        self.assertEqual(__, babel_fish['one'])
-        self.assertEqual(__, babel_fish['two'])
+        self.assertEqual('uno', babel_fish['one'])
+        self.assertEqual('dos', babel_fish['two'])
 
     def test_changing_dictionaries(self):
         babel_fish = { 'one': 'uno', 'two': 'dos' }
         babel_fish['one'] = 'eins'
 
-        expected = { 'two': 'dos', 'one': __ }
+        expected = { 'two': 'dos', 'one': 'eins' }
         self.assertDictEqual(expected, babel_fish)
 
     def test_dictionary_is_unordered(self):
         dict1 = { 'one': 'uno', 'two': 'dos' }
         dict2 = { 'two': 'dos', 'one': 'uno' }
 
-        self.assertEqual(__, dict1 == dict2)
+        self.assertEqual(True, dict1 == dict2)
 
 
     def test_dictionary_keys_and_values(self):
         babel_fish = {'one': 'uno', 'two': 'dos'}
-        self.assertEqual(__, len(babel_fish.keys()))
-        self.assertEqual(__, len(babel_fish.values()))
-        self.assertEqual(__, 'one' in babel_fish.keys())
-        self.assertEqual(__, 'two' in babel_fish.values())
-        self.assertEqual(__, 'uno' in babel_fish.keys())
-        self.assertEqual(__, 'dos' in babel_fish.values())
+        self.assertEqual(2, len(babel_fish.keys()))
+        self.assertEqual(2, len(babel_fish.values()))
+        self.assertEqual(True, 'one' in babel_fish.keys())
+        self.assertEqual(False, 'two' in babel_fish.values())
+        self.assertEqual(False, 'uno' in babel_fish.keys())
+        self.assertEqual(True, 'dos' in babel_fish.values())
 
     def test_making_a_dictionary_from_a_sequence_of_keys(self):
         cards = {}.fromkeys(('red warrior', 'green elf', 'blue valkyrie', 'yellow dwarf', 'confused looking zebra'), 42)
 
-        self.assertEqual(__, len(cards))
-        self.assertEqual(__, cards['green elf'])
-        self.assertEqual(__, cards['yellow dwarf'])
+        self.assertEqual(5, len(cards))
+        self.assertEqual(42, cards['green elf'])
+        self.assertEqual(42, cards['yellow dwarf'])
 
diff --git a/koans/about_string_manipulation.py b/koans/about_string_manipulation.py
index 5204f29ba..62a4c86bb 100644
--- a/koans/about_string_manipulation.py
+++ b/koans/about_string_manipulation.py
@@ -9,7 +9,7 @@ def test_use_format_to_interpolate_variables(self):
         value1 = 'one'
         value2 = 2
         string = "The values are {0} and {1}".format(value1, value2)
-        self.assertEqual(__, string)
+        self.assertEqual("The values are one and 2", string)
 
     def test_formatted_values_can_be_shown_in_any_order_or_be_repeated(self):
         value1 = 'doh'

From 052f833ad081c7109077575b6d6a6b9c0bf68509 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Tue, 22 Oct 2024 23:34:39 +0800
Subject: [PATCH 07/51] daily python exercise

---
 koans/about_string_manipulation.py | 33 +++++++++++++++---------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/koans/about_string_manipulation.py b/koans/about_string_manipulation.py
index 62a4c86bb..6c3733f39 100644
--- a/koans/about_string_manipulation.py
+++ b/koans/about_string_manipulation.py
@@ -15,7 +15,7 @@ def test_formatted_values_can_be_shown_in_any_order_or_be_repeated(self):
         value1 = 'doh'
         value2 = 'DOH'
         string = "The values are {1}, {0}, {0} and {1}!".format(value1, value2)
-        self.assertEqual(__, string)
+        self.assertEqual("The values are DOH, doh, doh and DOH!", string)
 
     def test_any_python_expression_may_be_interpolated(self):
         import math # import a standard python module with math functions
@@ -23,24 +23,24 @@ def test_any_python_expression_may_be_interpolated(self):
         decimal_places = 4
         string = "The square root of 5 is {0:.{1}f}".format(math.sqrt(5),
             decimal_places)
-        self.assertEqual(__, string)
+        self.assertEqual("The square root of 5 is 2.2361", string)
 
     def test_you_can_get_a_substring_from_a_string(self):
         string = "Bacon, lettuce and tomato"
-        self.assertEqual(__, string[7:10])
+        self.assertEqual("let", string[7:10])
 
     def test_you_can_get_a_single_character_from_a_string(self):
         string = "Bacon, lettuce and tomato"
-        self.assertEqual(__, string[1])
+        self.assertEqual("a", string[1])
 
     def test_single_characters_can_be_represented_by_integers(self):
-        self.assertEqual(__, ord('a'))
-        self.assertEqual(__, ord('b') == (ord('a') + 1))
+        self.assertEqual(97, ord('a'))
+        self.assertEqual(True, ord('b') == (ord('a') + 1))
 
     def test_strings_can_be_split(self):
         string = "Sausage Egg Cheese"
         words = string.split()
-        self.assertListEqual([__, __, __], words)
+        self.assertListEqual(['Sausage', 'Egg', 'Cheese'], words)
 
     def test_strings_can_be_split_with_different_patterns(self):
         import re #import python regular expression library
@@ -50,25 +50,26 @@ def test_strings_can_be_split_with_different_patterns(self):
 
         words = pattern.split(string)
 
-        self.assertListEqual([__, __, __, __], words)
+        self.assertListEqual(['the', 'rain', 'in', 'spain'], words)
 
         # Pattern is a Python regular expression pattern which matches ',' or ';'
 
     def test_raw_strings_do_not_interpret_escape_characters(self):
         string = r'\n'
         self.assertNotEqual('\n', string)
-        self.assertEqual(__, string)
-        self.assertEqual(__, len(string))
+
+        self.assertEqual(r'\n', string)
+        self.assertEqual(2, len(string))
 
         # Useful in regular expressions, file paths, URLs, etc.
 
     def test_strings_can_be_joined(self):
         words = ["Now", "is", "the", "time"]
-        self.assertEqual(__, ' '.join(words))
+        self.assertEqual("Now is the time", ' '.join(words))
 
     def test_strings_can_change_case(self):
-        self.assertEqual(__, 'guido'.capitalize())
-        self.assertEqual(__, 'guido'.upper())
-        self.assertEqual(__, 'TimBot'.lower())
-        self.assertEqual(__, 'guido van rossum'.title())
-        self.assertEqual(__, 'ToTaLlY aWeSoMe'.swapcase())
+        self.assertEqual("Guido", 'guido'.capitalize())
+        self.assertEqual("GUIDO", 'guido'.upper())
+        self.assertEqual("timbot", 'TimBot'.lower())
+        self.assertEqual("Guido Van Rossum", 'guido van rossum'.title())
+        self.assertEqual("tOtAlLy AwEsOmE", 'ToTaLlY aWeSoMe'.swapcase())

From 2f73a2a8c5ffb07a9bfb68edeb707936d479f7fb Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Wed, 23 Oct 2024 02:05:19 +0800
Subject: [PATCH 08/51] python daily exercise

---
 koans/about_tuples.py | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/koans/about_tuples.py b/koans/about_tuples.py
index 1b38c8f7f..292f1bdaf 100644
--- a/koans/about_tuples.py
+++ b/koans/about_tuples.py
@@ -6,7 +6,7 @@
 class AboutTuples(Koan):
     def test_creating_a_tuple(self):
         count_of_three =  (1, 2, 5)
-        self.assertEqual(__, count_of_three[2])
+        self.assertEqual(5, count_of_three[2])
 
     def test_tuples_are_immutable_so_item_assignment_is_not_possible(self):
 
@@ -18,12 +18,11 @@ def test_tuples_are_immutable_so_item_assignment_is_not_possible(self):
 
         # Note, assertRegex() uses regular expression pattern matching,
         # so you don't have to copy the whole message.
-
-        self.assertRegex(msg, __)
+        self.assertRegex(msg, "'tuple' object does not support item assignment")
 
     def test_tuples_are_immutable_so_appending_is_not_possible(self):
         count_of_three =  (1, 2, 5)
-        with self.assertRaises(___): count_of_three.append("boom")
+        with self.assertRaises(AttributeError): count_of_three.append("boom")
 
         # Tuples are less flexible than lists, but faster.
 
@@ -34,26 +33,26 @@ def test_tuples_can_only_be_changed_through_replacement(self):
         list_count.append("boom")
         count_of_three = tuple(list_count)
 
-        self.assertEqual(__, count_of_three)
+        self.assertEqual((1,2,5, "boom"), count_of_three)
 
     def test_tuples_of_one_look_peculiar(self):
-        self.assertEqual(__, (1).__class__)
-        self.assertEqual(__, (1,).__class__)
-        self.assertEqual(__, ("I'm a tuple",).__class__)
-        self.assertEqual(__, ("Not a tuple").__class__)
+        self.assertEqual(int, (1).__class__)
+        self.assertEqual(tuple, (1,).__class__)
+        self.assertEqual(tuple, ("I'm a tuple",).__class__)
+        self.assertEqual(str, ("Not a tuple").__class__)
 
     def test_tuple_constructor_can_be_surprising(self):
-        self.assertEqual(__, tuple("Surprise!"))
+        self.assertEqual(('S', 'u', 'r', 'p', 'r', 'i', 's', 'e', '!'), tuple("Surprise!"))
 
     def test_creating_empty_tuples(self):
-        self.assertEqual(__ , ())
-        self.assertEqual(__ , tuple())  # Sometimes less confusing
+        self.assertEqual(() , ())
+        self.assertEqual(() , tuple())  # Sometimes less confusing
 
     def test_tuples_can_be_embedded(self):
         lat = (37, 14, 6, 'N')
         lon = (115, 48, 40, 'W')
         place = ('Area 51', lat, lon)
-        self.assertEqual(__, place)
+        self.assertEqual(('Area 51', (37, 14, 6, 'N'), (115, 48, 40, 'W')), place)
 
     def test_tuples_are_good_for_representing_records(self):
         locations = [
@@ -63,5 +62,5 @@ def test_tuples_are_good_for_representing_records(self):
 
         locations.append( ("Cthulu", (26, 40, 1, 'N'), (70, 45, 7, 'W')) )
 
-        self.assertEqual(__, locations[2][0])
-        self.assertEqual(__, locations[0][1][2])
+        self.assertEqual('Cthulu', locations[2][0])
+        self.assertEqual(15.56, locations[0][1][2])

From 0a9fafdc456b633260422f6807f827b368b0dec0 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Thu, 24 Oct 2024 17:47:15 +0800
Subject: [PATCH 09/51] update

---
 koans/about_methods.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/koans/about_methods.py b/koans/about_methods.py
index 796a07ea5..ee12f16f5 100644
--- a/koans/about_methods.py
+++ b/koans/about_methods.py
@@ -12,7 +12,7 @@ def my_global_function(a,b):
 
 class AboutMethods(Koan):
     def test_calling_a_global_function(self):
-        self.assertEqual(__, my_global_function(2,3))
+        self.assertEqual(5, my_global_function(2,3))
 
     # NOTE: Wrong number of arguments is not a SYNTAX error, but a
     # runtime error.

From e5acd6c1abfa0c34a16ebeb503bb8bab551ad6e6 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Fri, 25 Oct 2024 21:41:24 +0800
Subject: [PATCH 10/51] python daily exercise

---
 koans/about_methods.py | 38 ++++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/koans/about_methods.py b/koans/about_methods.py
index ee12f16f5..0b9ba3115 100644
--- a/koans/about_methods.py
+++ b/koans/about_methods.py
@@ -17,6 +17,7 @@ def test_calling_a_global_function(self):
     # NOTE: Wrong number of arguments is not a SYNTAX error, but a
     # runtime error.
     def test_calling_functions_with_wrong_number_of_arguments(self):
+        msg = None
         try:
             my_global_function()
         except TypeError as exception:
@@ -32,8 +33,9 @@ def test_calling_functions_with_wrong_number_of_arguments(self):
         except Exception as e:
             msg = e.args[0]
 
+
         # Note, watch out for parenthesis. They need slashes in front!
-        self.assertRegex(msg, __)
+        self.assertRegex(msg, r"my_global_function\(\) takes 2 positional arguments but 3 were given")
 
     # ------------------------------------------------------------------
 
@@ -41,7 +43,7 @@ def pointless_method(self, a, b):
         sum = a + b
 
     def test_which_does_not_return_anything(self):
-        self.assertEqual(__, self.pointless_method(1, 2))
+        self.assertEqual(None, self.pointless_method(1, 2))
         # Notice that methods accessed from class scope do not require
         # you to pass the first "self" argument?
 
@@ -51,8 +53,8 @@ def method_with_defaults(self, a, b='default_value'):
         return [a, b]
 
     def test_calling_with_default_values(self):
-        self.assertEqual(__, self.method_with_defaults(1))
-        self.assertEqual(__, self.method_with_defaults(1, 2))
+        self.assertEqual([1, 'default_value'], self.method_with_defaults(1))
+        self.assertEqual([1, 2], self.method_with_defaults(1, 2))
 
     # ------------------------------------------------------------------
 
@@ -60,9 +62,9 @@ def method_with_var_args(self, *args):
         return args
 
     def test_calling_with_variable_arguments(self):
-        self.assertEqual(__, self.method_with_var_args())
+        self.assertEqual((), self.method_with_var_args())
         self.assertEqual(('one',), self.method_with_var_args('one'))
-        self.assertEqual(__, self.method_with_var_args('one', 'two'))
+        self.assertEqual(('one', 'two'), self.method_with_var_args('one', 'two'))
 
     # ------------------------------------------------------------------
 
@@ -73,13 +75,13 @@ def test_functions_without_self_arg_are_global_functions(self):
         def function_with_the_same_name(a, b):
             return a * b
 
-        self.assertEqual(__, function_with_the_same_name(3,4))
+        self.assertEqual(12, function_with_the_same_name(3,4))
 
     def test_calling_methods_in_same_class_with_explicit_receiver(self):
         def function_with_the_same_name(a, b):
             return a * b
 
-        self.assertEqual(__, self.function_with_the_same_name(3,4))
+        self.assertEqual(7, self.function_with_the_same_name(3,4))
 
     # ------------------------------------------------------------------
 
@@ -92,10 +94,10 @@ def another_method_with_the_same_name(self):
         return 42
 
     def test_that_old_methods_are_hidden_by_redefinitions(self):
-        self.assertEqual(__, self.another_method_with_the_same_name())
+        self.assertEqual(42, self.another_method_with_the_same_name())
 
     def test_that_overlapped_method_is_still_there(self):
-        self.assertEqual(__, self.link_to_overlapped_method())
+        self.assertEqual(10, self.link_to_overlapped_method())
 
     # ------------------------------------------------------------------
 
@@ -103,21 +105,21 @@ def empty_method(self):
         pass
 
     def test_methods_that_do_nothing_need_to_use_pass_as_a_filler(self):
-        self.assertEqual(__, self.empty_method())
+        self.assertEqual(None, self.empty_method())
 
     def test_pass_does_nothing_at_all(self):
         "You"
         "shall"
         "not"
         pass
-        self.assertEqual(____, "Still got to this line" != None)
+        self.assertEqual(True, "Still got to this line" != None)
 
     # ------------------------------------------------------------------
 
     def one_line_method(self): return 'Madagascar'
 
     def test_no_indentation_required_for_one_line_statement_bodies(self):
-        self.assertEqual(__, self.one_line_method())
+        self.assertEqual('Madagascar', self.one_line_method())
 
     # ------------------------------------------------------------------
 
@@ -126,7 +128,7 @@ def method_with_documentation(self):
         return "ok"
 
     def test_the_documentation_can_be_viewed_with_the_doc_method(self):
-        self.assertRegex(self.method_with_documentation.__doc__, __)
+        self.assertRegex(self.method_with_documentation.__doc__, "A string placed at the beginning of a function is used for documentation")
 
     # ------------------------------------------------------------------
 
@@ -143,20 +145,20 @@ def __password(self):
 
     def test_calling_methods_in_other_objects(self):
         rover = self.Dog()
-        self.assertEqual(__, rover.name())
+        self.assertEqual("Fido", rover.name())
 
     def test_private_access_is_implied_but_not_enforced(self):
         rover = self.Dog()
 
         # This is a little rude, but legal
-        self.assertEqual(__, rover._tail())
+        self.assertEqual("wagging", rover._tail())
 
     def test_attributes_with_double_underscore_prefixes_are_subject_to_name_mangling(self):
         rover = self.Dog()
-        with self.assertRaises(___): password = rover.__password()
+        with self.assertRaises(AttributeError): password = rover.__password()
 
         # But this still is!
-        self.assertEqual(__, rover._Dog__password())
+        self.assertEqual("password", rover._Dog__password())
 
         # Name mangling exists to avoid name clash issues when subclassing.
         # It is not for providing effective access protection

From a3ce0df40dffc940303237d73e1a6d3fc39032bc Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Wed, 30 Oct 2024 18:01:21 +0800
Subject: [PATCH 11/51] python daily exdercise

---
 koans/about_control_statements.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/koans/about_control_statements.py b/koans/about_control_statements.py
index 842c8d91f..0fbce89ee 100644
--- a/koans/about_control_statements.py
+++ b/koans/about_control_statements.py
@@ -10,13 +10,13 @@ def test_if_then_else_statements(self):
             result = 'true value'
         else:
             result = 'false value'
-        self.assertEqual(__, result)
+        self.assertEqual('true value', result)
 
     def test_if_then_statements(self):
         result = 'default value'
         if True:
             result = 'true value'
-        self.assertEqual(__, result)
+        self.assertEqual('true value', result)
 
     def test_if_then_elif_else_statements(self):
         if False:
@@ -25,7 +25,7 @@ def test_if_then_elif_else_statements(self):
             result = 'true value'
         else:
             result = 'default value'
-        self.assertEqual(__, result)
+        self.assertEqual('true value', result)
 
     def test_while_statement(self):
         i = 1
@@ -33,7 +33,7 @@ def test_while_statement(self):
         while i <= 10:
             result = result * i
             i += 1
-        self.assertEqual(__, result)
+        self.assertEqual(3628800, result)
 
     def test_break_statement(self):
         i = 1
@@ -42,7 +42,7 @@ def test_break_statement(self):
             if i > 10: break
             result = result * i
             i += 1
-        self.assertEqual(__, result)
+        self.assertEqual(3628800, result)
 
     def test_continue_statement(self):
         i = 0
@@ -51,14 +51,14 @@ def test_continue_statement(self):
             i += 1
             if (i % 2) == 0: continue
             result.append(i)
-        self.assertEqual(__, result)
+        self.assertEqual([1, 3, 5, 7, 9], result)
 
     def test_for_statement(self):
         phrase = ["fish", "and", "chips"]
         result = []
         for item in phrase:
             result.append(item.upper())
-        self.assertEqual([__, __, __], result)
+        self.assertEqual(['FISH', 'AND', 'CHIPS'], result)
 
     def test_for_statement_with_tuples(self):
         round_table = [
@@ -71,7 +71,7 @@ def test_for_statement_with_tuples(self):
         for knight, answer in round_table:
             result.append("Contestant: '" + knight + "'   Answer: '" + answer + "'")
 
-        text = __
+        text = 'Blue! I mean Green!'
 
         self.assertRegex(result[2], text)
 

From 1851f6665c69070954604e329a4a1678824593d1 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Thu, 31 Oct 2024 20:30:10 +0800
Subject: [PATCH 12/51] pthon daily exercise

---
 koans/about_true_and_false.py | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/koans/about_true_and_false.py b/koans/about_true_and_false.py
index 5f06a63db..9467caf51 100644
--- a/koans/about_true_and_false.py
+++ b/koans/about_true_and_false.py
@@ -12,32 +12,32 @@ def truth_value(self, condition):
             return 'false stuff'
 
     def test_true_is_treated_as_true(self):
-        self.assertEqual(__, self.truth_value(True))
+        self.assertEqual('true stuff', self.truth_value(True))
 
     def test_false_is_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(False))
+        self.assertEqual('false stuff', self.truth_value(False))
 
     def test_none_is_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(None))
+        self.assertEqual('false stuff', self.truth_value(None))
 
     def test_zero_is_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(0))
+        self.assertEqual('false stuff', self.truth_value(0))
 
     def test_empty_collections_are_treated_as_false(self):
-        self.assertEqual(__, self.truth_value([]))
-        self.assertEqual(__, self.truth_value(()))
-        self.assertEqual(__, self.truth_value({}))
-        self.assertEqual(__, self.truth_value(set()))
+        self.assertEqual('false stuff', self.truth_value([]))
+        self.assertEqual('false stuff', self.truth_value(()))
+        self.assertEqual('false stuff', self.truth_value({}))
+        self.assertEqual('false stuff', self.truth_value(set()))
 
     def test_blank_strings_are_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(""))
+        self.assertEqual('false stuff', self.truth_value(""))
 
     def test_everything_else_is_treated_as_true(self):
-        self.assertEqual(__, self.truth_value(1))
-        self.assertEqual(__, self.truth_value([0]))
-        self.assertEqual(__, self.truth_value((0,)))
+        self.assertEqual('true stuff', self.truth_value(1))
+        self.assertEqual('true stuff', self.truth_value([0]))
+        self.assertEqual('true stuff', self.truth_value((0,)))
         self.assertEqual(
-            __,
+            'true stuff',
             self.truth_value("Python is named after Monty Python"))
-        self.assertEqual(__, self.truth_value(' '))
-        self.assertEqual(__, self.truth_value('0'))
+        self.assertEqual('true stuff', self.truth_value(' '))
+        self.assertEqual('true stuff', self.truth_value('0'))

From 817ab64e9914888d6855293e9f3425e705f372eb Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Fri, 1 Nov 2024 17:53:52 +0800
Subject: [PATCH 13/51] Python daily exercise

---
 koans/about_sets.py | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/koans/about_sets.py b/koans/about_sets.py
index 87cf10959..9156605ca 100644
--- a/koans/about_sets.py
+++ b/koans/about_sets.py
@@ -9,27 +9,27 @@ def test_sets_make_keep_lists_unique(self):
 
         there_can_only_be_only_one = set(highlanders)
 
-        self.assertEqual(__, there_can_only_be_only_one)
+        self.assertEqual({'Matunas', 'MacLeod', 'Ramirez', 'Malcolm'}, there_can_only_be_only_one)
 
     def test_empty_sets_have_different_syntax_to_populated_sets(self):
-        self.assertEqual(__, {1, 2, 3})
-        self.assertEqual(__, set())
+        self.assertEqual({1, 2, 3}, {1, 2, 3})
+        self.assertEqual(set(), set())
 
     def test_dictionaries_and_sets_use_same_curly_braces(self):
         # Note: Literal sets using braces were introduced in python 3.
         #       They were also backported to python 2.7.
 
-        self.assertEqual(__, {1, 2, 3}.__class__)
-        self.assertEqual(__, {'one': 1, 'two': 2}.__class__)
+        self.assertEqual(set, {1, 2, 3}.__class__)
+        self.assertEqual(dict, {'one': 1, 'two': 2}.__class__)
 
-        self.assertEqual(__, {}.__class__)
+        self.assertEqual(dict, {}.__class__)
 
     def test_creating_sets_using_strings(self):
-        self.assertEqual(__, {'12345'})
-        self.assertEqual(__, set('12345'))
+        self.assertEqual({'12345'}, {'12345'})
+        self.assertEqual({'4', '3', '5', '2', '1'}, set('12345'))
 
     def test_convert_the_set_into_a_list_to_sort_it(self):
-        self.assertEqual(__, sorted(set('12345')))
+        self.assertEqual(['1', '2', '3', '4', '5'], sorted(set('12345')))
 
     # ------------------------------------------------------------------
 
@@ -37,19 +37,19 @@ def test_set_have_arithmetic_operators(self):
         scotsmen = {'MacLeod', 'Wallace', 'Willie'}
         warriors = {'MacLeod', 'Wallace', 'Leonidas'}
 
-        self.assertEqual(__, scotsmen - warriors)
-        self.assertEqual(__, scotsmen | warriors)
-        self.assertEqual(__, scotsmen & warriors)
-        self.assertEqual(__, scotsmen ^ warriors)
+        self.assertEqual({'Willie'}, scotsmen - warriors)
+        self.assertEqual({'Leonidas', 'Willie', 'Wallace', 'MacLeod'}, scotsmen | warriors)
+        self.assertEqual({'MacLeod', 'Wallace'}, scotsmen & warriors)
+        self.assertEqual({'Willie', 'Leonidas'}, scotsmen ^ warriors)
 
     # ------------------------------------------------------------------
 
     def test_we_can_query_set_membership(self):
-        self.assertEqual(__, 127 in {127, 0, 0, 1} )
-        self.assertEqual(__, 'cow' not in set('apocalypse now') )
+        self.assertEqual(True, 127 in {127, 0, 0, 1} )
+        self.assertEqual(True, 'cow' not in set('apocalypse now') )
 
     def test_we_can_compare_subsets(self):
-        self.assertEqual(__, set('cake') <= set('cherry cake'))
-        self.assertEqual(__, set('cake').issubset(set('cherry cake')) )
+        self.assertEqual(True, set('cake') <= set('cherry cake'))
+        self.assertEqual(True, set('cake').issubset(set('cherry cake')) )
 
-        self.assertEqual(__, set('cake') > set('pie'))
+        self.assertEqual(False, set('cake') > set('pie'))

From 93e8890286bf7f938e064a45b2669f1eb15e9df1 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sat, 2 Nov 2024 13:40:56 +0800
Subject: [PATCH 14/51] daily python exercise

---
 koans/about_triangle_project.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/koans/about_triangle_project.py b/koans/about_triangle_project.py
index ad2485909..5d8054939 100644
--- a/koans/about_triangle_project.py
+++ b/koans/about_triangle_project.py
@@ -8,16 +8,16 @@
 
 class AboutTriangleProject(Koan):
     def test_equilateral_triangles_have_equal_sides(self):
-        self.assertEqual('equilateral', triangle(2, 2, 2))
-        self.assertEqual('equilateral', triangle(10, 10, 10))
+        self.assertEqual(None, triangle(2, 2, 2))
+        self.assertEqual(None, triangle(10, 10, 10))
 
     def test_isosceles_triangles_have_exactly_two_sides_equal(self):
-        self.assertEqual('isosceles', triangle(3, 4, 4))
-        self.assertEqual('isosceles', triangle(4, 3, 4))
-        self.assertEqual('isosceles', triangle(4, 4, 3))
-        self.assertEqual('isosceles', triangle(10, 10, 2))
+        self.assertEqual(None, triangle(3, 4, 4))
+        self.assertEqual(None, triangle(4, 3, 4))
+        self.assertEqual(None, triangle(4, 4, 3))
+        self.assertEqual(None, triangle(10, 10, 2))
 
     def test_scalene_triangles_have_no_equal_sides(self):
-        self.assertEqual('scalene', triangle(3, 4, 5))
-        self.assertEqual('scalene', triangle(10, 11, 12))
-        self.assertEqual('scalene', triangle(5, 4, 2))
+        self.assertEqual(None, triangle(3, 4, 5))
+        self.assertEqual(None, triangle(10, 11, 12))
+        self.assertEqual(None, triangle(5, 4, 2))

From 0d527959bad2a22f1e0b133f9985c3ed565b2409 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sun, 3 Nov 2024 20:45:01 +0800
Subject: [PATCH 15/51] python daily exercise

---
 koans/about_exceptions.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/koans/about_exceptions.py b/koans/about_exceptions.py
index d321bbc50..2f755ea65 100644
--- a/koans/about_exceptions.py
+++ b/koans/about_exceptions.py
@@ -10,10 +10,10 @@ class MySpecialError(RuntimeError):
 
     def test_exceptions_inherit_from_exception(self):
         mro = self.MySpecialError.mro()
-        self.assertEqual(__, mro[1].__name__)
-        self.assertEqual(__, mro[2].__name__)
-        self.assertEqual(__, mro[3].__name__)
-        self.assertEqual(__, mro[4].__name__)
+        self.assertEqual('RuntimeError', mro[1].__name__)
+        self.assertEqual('Exception', mro[2].__name__)
+        self.assertEqual('BaseException', mro[3].__name__)
+        self.assertEqual('object', mro[4].__name__)
 
     def test_try_clause(self):
         result = None
@@ -24,15 +24,15 @@ def test_try_clause(self):
 
             ex2 = ex
 
-        self.assertEqual(__, result)
+        self.assertEqual('exception handled', result)
 
-        self.assertEqual(__, isinstance(ex2, Exception))
-        self.assertEqual(__, isinstance(ex2, RuntimeError))
+        self.assertEqual(True, isinstance(ex2, Exception))
+        self.assertEqual(False, isinstance(ex2, RuntimeError))
 
         self.assertTrue(issubclass(RuntimeError, Exception), \
             "RuntimeError is a subclass of Exception")
 
-        self.assertEqual(__, ex2.args[0])
+        self.assertEqual('Oops', ex2.args[0])
 
     def test_raising_a_specific_error(self):
         result = None
@@ -42,8 +42,8 @@ def test_raising_a_specific_error(self):
             result = 'exception handled'
             msg = ex.args[0]
 
-        self.assertEqual(__, result)
-        self.assertEqual(__, msg)
+        self.assertEqual('exception handled', result)
+        self.assertEqual('My Message', msg)
 
     def test_else_clause(self):
         result = None
@@ -55,7 +55,7 @@ def test_else_clause(self):
         else:
             result = 'no damage done'
 
-        self.assertEqual(__, result)
+        self.assertEqual('no damage done', result)
 
 
     def test_finally_clause(self):
@@ -68,4 +68,4 @@ def test_finally_clause(self):
         finally:
             result = 'always run'
 
-        self.assertEqual(__, result)
+        self.assertEqual('always run', result)

From f8b2d1ad331a85c174579158b55b4fa5f7b14e7e Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Mon, 4 Nov 2024 22:39:12 +0800
Subject: [PATCH 16/51] Daily python

---
 koans/about_exceptions.py       |  1 -
 koans/about_triangle_project.py | 18 +++++++++---------
 koans/triangle.py               | 18 ++++++++++++++++--
 3 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/koans/about_exceptions.py b/koans/about_exceptions.py
index 2f755ea65..30ce6f92a 100644
--- a/koans/about_exceptions.py
+++ b/koans/about_exceptions.py
@@ -57,7 +57,6 @@ def test_else_clause(self):
 
         self.assertEqual('no damage done', result)
 
-
     def test_finally_clause(self):
         result = None
         try:
diff --git a/koans/about_triangle_project.py b/koans/about_triangle_project.py
index 5d8054939..ad2485909 100644
--- a/koans/about_triangle_project.py
+++ b/koans/about_triangle_project.py
@@ -8,16 +8,16 @@
 
 class AboutTriangleProject(Koan):
     def test_equilateral_triangles_have_equal_sides(self):
-        self.assertEqual(None, triangle(2, 2, 2))
-        self.assertEqual(None, triangle(10, 10, 10))
+        self.assertEqual('equilateral', triangle(2, 2, 2))
+        self.assertEqual('equilateral', triangle(10, 10, 10))
 
     def test_isosceles_triangles_have_exactly_two_sides_equal(self):
-        self.assertEqual(None, triangle(3, 4, 4))
-        self.assertEqual(None, triangle(4, 3, 4))
-        self.assertEqual(None, triangle(4, 4, 3))
-        self.assertEqual(None, triangle(10, 10, 2))
+        self.assertEqual('isosceles', triangle(3, 4, 4))
+        self.assertEqual('isosceles', triangle(4, 3, 4))
+        self.assertEqual('isosceles', triangle(4, 4, 3))
+        self.assertEqual('isosceles', triangle(10, 10, 2))
 
     def test_scalene_triangles_have_no_equal_sides(self):
-        self.assertEqual(None, triangle(3, 4, 5))
-        self.assertEqual(None, triangle(10, 11, 12))
-        self.assertEqual(None, triangle(5, 4, 2))
+        self.assertEqual('scalene', triangle(3, 4, 5))
+        self.assertEqual('scalene', triangle(10, 11, 12))
+        self.assertEqual('scalene', triangle(5, 4, 2))
diff --git a/koans/triangle.py b/koans/triangle.py
index 4d8d66f42..2ce7e04bd 100644
--- a/koans/triangle.py
+++ b/koans/triangle.py
@@ -17,8 +17,22 @@
 #   about_triangle_project_2.py
 #
 def triangle(a, b, c):
-    # DELETE 'PASS' AND WRITE THIS CODE
-    pass
+    # Check if all sides are greater than 0
+    if a <= 0 or b <= 0 or c <= 0:
+        raise TriangleError()
+
+    # Check if the sum of any two sides is greater than the third
+    if (a + b <= c) or (b + c <= a) or (a + c <= b):
+        raise TriangleError()
+
+    # If we get here, figure out what type of triangle it is
+    sides = sorted([a, b, c])
+    if sides[0] == sides[2]:
+        return 'equilateral'
+    elif sides[0] == sides[1] or sides[1] == sides[2]:
+        return 'isosceles'
+    else:
+        return 'scalene'
 
 # Error class used in part 2.  No need to change this code.
 class TriangleError(Exception):

From 42250dcd7c7d0155968c4410a17072aebc0820c6 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Tue, 5 Nov 2024 23:13:17 +0800
Subject: [PATCH 17/51] python daily exercise

---
 koans/about_iteration.py | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/koans/about_iteration.py b/koans/about_iteration.py
index 1faca8e33..763c43ffd 100644
--- a/koans/about_iteration.py
+++ b/koans/about_iteration.py
@@ -13,20 +13,20 @@ def test_iterators_are_a_type(self):
         for num in it:
             total += num
 
-        self.assertEqual(__ , total)
+        self.assertEqual(15 , total)
 
     def test_iterating_with_next(self):
         stages = iter(['alpha','beta','gamma'])
 
         try:
-            self.assertEqual(__, next(stages))
+            self.assertEqual('alpha', next(stages))
             next(stages)
-            self.assertEqual(__, next(stages))
+            self.assertEqual('gamma', next(stages))
             next(stages)
         except StopIteration as ex:
             err_msg = 'Ran out of iterations'
 
-        self.assertRegex(err_msg, __)
+        self.assertRegex(err_msg, 'Ran out of iterations')
 
     # ------------------------------------------------------------------
 
@@ -40,14 +40,14 @@ def test_map_transforms_elements_of_a_list(self):
         mapping = map(self.add_ten, seq)
 
         self.assertNotEqual(list, mapping.__class__)
-        self.assertEqual(__, mapping.__class__)
+        self.assertEqual(map, mapping.__class__)
         # In Python 3 built in iterator funcs return iterable view objects
         # instead of lists
 
         for item in mapping:
             mapped_seq.append(item)
 
-        self.assertEqual(__, mapped_seq)
+        self.assertEqual([11, 12, 13], mapped_seq)
 
         # Note, iterator methods actually return objects of iter type in
         # python 3. In python 2 map() would give you a list.
@@ -62,7 +62,7 @@ def is_even(item):
         for item in filter(is_even, seq):
             even_numbers.append(item)
 
-        self.assertEqual(__, even_numbers)
+        self.assertEqual([2, 4, 6], even_numbers)
 
     def test_filter_returns_all_items_matching_criterion(self):
         def is_big_name(item):
@@ -71,8 +71,8 @@ def is_big_name(item):
         names = ["Jim", "Bill", "Clarence", "Doug", "Eli", "Elizabeth"]
         iterator = filter(is_big_name, names)
 
-        self.assertEqual(__, next(iterator))
-        self.assertEqual(__, next(iterator))
+        self.assertEqual("Clarence", next(iterator))
+        self.assertEqual("Elizabeth", next(iterator))
 
         try:
             next(iterator)
@@ -80,7 +80,7 @@ def is_big_name(item):
         except StopIteration:
             msg = 'Ran out of big names'
 
-        self.assertEquals(__, msg)
+        self.assertEqual('Ran out of big names', msg)
 
     # ------------------------------------------------------------------
 
@@ -96,13 +96,13 @@ def test_reduce_will_blow_your_mind(self):
         # to the functools module.
 
         result = functools.reduce(self.add, [2, 3, 4])
-        self.assertEqual(__, result.__class__)
+        self.assertEqual(int, result.__class__)
         # Reduce() syntax is same as Python 2
 
-        self.assertEqual(__, result)
+        self.assertEqual(9, result)
 
         result2 = functools.reduce(self.multiply, [2, 3, 4], 1)
-        self.assertEqual(__, result2)
+        self.assertEqual(24, result2)
 
         # Extra Credit:
         # Describe in your own words what reduce does.
@@ -113,14 +113,14 @@ def test_use_pass_for_iterations_with_no_body(self):
         for num in range(1,5):
             pass
 
-        self.assertEqual(__, num)
+        self.assertEqual(4, num)
 
     # ------------------------------------------------------------------
 
     def test_all_iteration_methods_work_on_any_sequence_not_just_lists(self):
         # Ranges are an iterable sequence
         result = map(self.add_ten, range(1,4))
-        self.assertEqual(__, list(result))
+        self.assertEqual([11, 12, 13], list(result))
 
     def test_lines_in_a_file_are_iterable_sequences_too(self):
         def make_upcase(line):
@@ -128,5 +128,5 @@ def make_upcase(line):
 
         file = open("example_file.txt")
         upcase_lines = map(make_upcase, file.readlines())
-        self.assertEqual(__, list(upcase_lines))
+        self.assertEqual(['This', 'Is', 'A', 'Test'], list(upcase_lines))
         file.close()

From 55572187677276a018acb0038ce6837b97663522 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Wed, 6 Nov 2024 23:48:38 +0800
Subject: [PATCH 18/51] python daily exercise

---
 koans/about_comprehension.py | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/koans/about_comprehension.py b/koans/about_comprehension.py
index e5add6d9e..3c193f743 100644
--- a/koans/about_comprehension.py
+++ b/koans/about_comprehension.py
@@ -13,8 +13,8 @@ def test_creating_lists_with_list_comprehensions(self):
 
         comprehension = [delicacy.capitalize() for delicacy in feast]
 
-        self.assertEqual(__, comprehension[0])
-        self.assertEqual(__, comprehension[2])
+        self.assertEqual('Lambs', comprehension[0])
+        self.assertEqual('Orangutans', comprehension[2])
 
     def test_filtering_lists_with_list_comprehensions(self):
         feast = ['spam', 'sloths', 'orangutans', 'breakfast cereals',
@@ -22,15 +22,15 @@ def test_filtering_lists_with_list_comprehensions(self):
 
         comprehension = [delicacy for delicacy in feast if len(delicacy) > 6]
 
-        self.assertEqual(__, len(feast))
-        self.assertEqual(__, len(comprehension))
+        self.assertEqual(5, len(feast))
+        self.assertEqual(3, len(comprehension))
 
     def test_unpacking_tuples_in_list_comprehensions(self):
         list_of_tuples = [(1, 'lumberjack'), (2, 'inquisition'), (4, 'spam')]
         comprehension = [ skit * number for number, skit in list_of_tuples ]
 
-        self.assertEqual(__, comprehension[0])
-        self.assertEqual(__, comprehension[2])
+        self.assertEqual('lumberjack', comprehension[0])
+        self.assertEqual('spamspamspamspam', comprehension[2])
 
     def test_double_list_comprehension(self):
         list_of_eggs = ['poached egg', 'fried egg']
@@ -40,13 +40,13 @@ def test_double_list_comprehension(self):
         comprehension = [ '{0} and {1}'.format(egg, meat) for egg in list_of_eggs for meat in list_of_meats]
 
 
-        self.assertEqual(__, comprehension[0])
-        self.assertEqual(__, len(comprehension))
+        self.assertEqual('poached egg and lite spam', comprehension[0])
+        self.assertEqual(6, len(comprehension))
 
     def test_creating_a_set_with_set_comprehension(self):
         comprehension = { x for x in 'aabbbcccc'}
 
-        self.assertEqual(__, comprehension)  # remember that set members are unique
+        self.assertEqual({'a', 'b', 'c'}, comprehension)  # remember that set members are unique
 
     def test_creating_a_dictionary_with_dictionary_comprehension(self):
         dict_of_weapons = {'first': 'fear', 'second': 'surprise',
@@ -55,7 +55,7 @@ def test_creating_a_dictionary_with_dictionary_comprehension(self):
 
         dict_comprehension = { k.upper(): weapon for k, weapon in dict_of_weapons.items() if weapon}
 
-        self.assertEqual(__, 'first' in dict_comprehension)
-        self.assertEqual(__, 'FIRST' in dict_comprehension)
-        self.assertEqual(__, len(dict_of_weapons))
-        self.assertEqual(__, len(dict_comprehension))
+        self.assertEqual(False, 'first' in dict_comprehension)
+        self.assertEqual(True, 'FIRST' in dict_comprehension)
+        self.assertEqual(5, len(dict_of_weapons))
+        self.assertEqual(4, len(dict_comprehension))

From 20ab3fa18bb5ea24c8c65e9f3f53b200d08dcc9b Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Thu, 7 Nov 2024 23:33:17 +0800
Subject: [PATCH 19/51] python daily exercise

---
 koans/about_generators.py | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/koans/about_generators.py b/koans/about_generators.py
index a81a43ba6..03ffde85c 100644
--- a/koans/about_generators.py
+++ b/koans/about_generators.py
@@ -19,7 +19,7 @@ def test_generating_values_on_the_fly(self):
         for bacon in bacon_generator:
             result.append(bacon)
 
-        self.assertEqual(__, result)
+        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)]
@@ -28,9 +28,9 @@ def test_generators_are_different_to_list_comprehensions(self):
         self.assertEqual(2, num_list[0])
 
         # A generator has to be iterated through.
-        with self.assertRaises(___): num = num_generator[0]
+        with self.assertRaises(TypeError): num = num_generator[0]
 
-        self.assertEqual(__, list(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
@@ -44,8 +44,8 @@ def test_generator_expressions_are_a_one_shot_deal(self):
         attempt1 = list(dynamite)
         attempt2 = list(dynamite)
 
-        self.assertEqual(__, attempt1)
-        self.assertEqual(__, attempt2)
+        self.assertEqual(['Boom!', 'Boom!', 'Boom!'], attempt1)
+        self.assertEqual([], attempt2)
 
     # ------------------------------------------------------------------
 
@@ -59,12 +59,12 @@ def test_generator_method_will_yield_values_during_iteration(self):
         result = list()
         for item in self.simple_generator_method():
             result.append(item)
-        self.assertEqual(__, result)
+        self.assertEqual(['peanut', 'butter', 'and', 'jelly'], result)
 
     def test_generators_can_be_manually_iterated_and_closed(self):
         result = self.simple_generator_method()
-        self.assertEqual(__, next(result))
-        self.assertEqual(__, next(result))
+        self.assertEqual('peanut', next(result))
+        self.assertEqual('butter', next(result))
         result.close()
 
     # ------------------------------------------------------------------
@@ -75,7 +75,7 @@ def square_me(self, seq):
 
     def test_generator_method_with_parameter(self):
         result = self.square_me(range(2,5))
-        self.assertEqual(__, list(result))
+        self.assertEqual([4, 9, 16], list(result))
 
     # ------------------------------------------------------------------
 
@@ -88,7 +88,7 @@ def sum_it(self, seq):
 
     def test_generator_keeps_track_of_local_variables(self):
         result = self.sum_it(range(2,5))
-        self.assertEqual(__, list(result))
+        self.assertEqual([2, 5, 9], list(result))
 
     # ------------------------------------------------------------------
 
@@ -106,7 +106,7 @@ def test_generators_can_act_as_coroutines(self):
         #       section of http://www.python.org/dev/peps/pep-0342/
         next(generator)
 
-        self.assertEqual(__, generator.send(1 + 2))
+        self.assertEqual(3, generator.send(1 + 2))
 
     def test_before_sending_a_value_to_a_generator_next_must_be_called(self):
         generator = self.coroutine()
@@ -114,7 +114,8 @@ def test_before_sending_a_value_to_a_generator_next_must_be_called(self):
         try:
             generator.send(1 + 2)
         except TypeError as ex:
-            self.assertRegex(ex.args[0], __)
+            print(ex.args[0])
+            self.assertRegex(ex.args[0], 'can\'t send non-None value to a just-started generator')
 
     # ------------------------------------------------------------------
 
@@ -132,11 +133,11 @@ def test_generators_can_see_if_they_have_been_called_with_a_value(self):
 
         generator2 = self.yield_tester()
         next(generator2)
-        self.assertEqual(__, 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(__, generator.send(None))
+        self.assertEqual('no value', generator.send(None))

From 8ee421218ddc13fafdb522d401411697095aa2b5 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Fri, 8 Nov 2024 17:55:32 +0800
Subject: [PATCH 20/51] reset to original to lookback repeat the exercises

---
 koans/about_asserts.py             | 14 +++----
 koans/about_comprehension.py       | 26 ++++++------
 koans/about_control_statements.py  | 16 +++----
 koans/about_dictionaries.py        | 30 ++++++-------
 koans/about_exceptions.py          | 25 +++++------
 koans/about_generators.py          | 29 +++++++------
 koans/about_iteration.py           | 32 +++++++-------
 koans/about_list_assignments.py    | 30 ++++++-------
 koans/about_lists.py               | 67 +++++++++++++++---------------
 koans/about_methods.py             | 40 +++++++++---------
 koans/about_none.py                | 14 +++----
 koans/about_sets.py                | 36 ++++++++--------
 koans/about_string_manipulation.py | 35 ++++++++--------
 koans/about_strings.py             | 40 +++++++++---------
 koans/about_true_and_false.py      | 30 ++++++-------
 koans/about_tuples.py              | 29 ++++++-------
 koans/triangle.py                  | 18 +-------
 17 files changed, 244 insertions(+), 267 deletions(-)

diff --git a/koans/about_asserts.py b/koans/about_asserts.py
index a85869529..d17ed0cdf 100644
--- a/koans/about_asserts.py
+++ b/koans/about_asserts.py
@@ -14,25 +14,25 @@ def test_assert_truth(self):
         #
         #   http://bit.ly/about_asserts
 
-        self.assertTrue(True) # This should be True
+        self.assertTrue(False) # This should be True
 
     def test_assert_with_message(self):
         """
         Enlightenment may be more easily achieved with appropriate messages.
         """
-        self.assertTrue(True, "This should be True -- Please fix this")
+        self.assertTrue(False, "This should be True -- Please fix this")
 
     def test_fill_in_values(self):
         """
         Sometimes we will ask you to fill in the values
         """
-        self.assertEqual(2, 1 + 1)
+        self.assertEqual(__, 1 + 1)
 
     def test_assert_equality(self):
         """
         To understand reality, we must compare our expectations against reality.
         """
-        expected_value = 2
+        expected_value = __
         actual_value = 1 + 1
         self.assertTrue(expected_value == actual_value)
 
@@ -40,7 +40,7 @@ def test_a_better_way_of_asserting_equality(self):
         """
         Some ways of asserting equality are better than others.
         """
-        expected_value = 2
+        expected_value = __
         actual_value = 1 + 1
 
         self.assertEqual(expected_value, actual_value)
@@ -51,7 +51,7 @@ def test_that_unittest_asserts_work_the_same_way_as_python_asserts(self):
         """
 
         # This throws an AssertionError exception
-        assert True
+        assert False
 
     def test_that_sometimes_we_need_to_know_the_class_type(self):
         """
@@ -70,7 +70,7 @@ def test_that_sometimes_we_need_to_know_the_class_type(self):
         #
         # See for yourself:
 
-        self.assertEqual(str, "navel".__class__) # It's str, not <type 'str'>
+        self.assertEqual(__, "navel".__class__) # It's str, not <type 'str'>
 
         # Need an illustration? More reading can be found here:
         #
diff --git a/koans/about_comprehension.py b/koans/about_comprehension.py
index 3c193f743..e5add6d9e 100644
--- a/koans/about_comprehension.py
+++ b/koans/about_comprehension.py
@@ -13,8 +13,8 @@ def test_creating_lists_with_list_comprehensions(self):
 
         comprehension = [delicacy.capitalize() for delicacy in feast]
 
-        self.assertEqual('Lambs', comprehension[0])
-        self.assertEqual('Orangutans', comprehension[2])
+        self.assertEqual(__, comprehension[0])
+        self.assertEqual(__, comprehension[2])
 
     def test_filtering_lists_with_list_comprehensions(self):
         feast = ['spam', 'sloths', 'orangutans', 'breakfast cereals',
@@ -22,15 +22,15 @@ def test_filtering_lists_with_list_comprehensions(self):
 
         comprehension = [delicacy for delicacy in feast if len(delicacy) > 6]
 
-        self.assertEqual(5, len(feast))
-        self.assertEqual(3, len(comprehension))
+        self.assertEqual(__, len(feast))
+        self.assertEqual(__, len(comprehension))
 
     def test_unpacking_tuples_in_list_comprehensions(self):
         list_of_tuples = [(1, 'lumberjack'), (2, 'inquisition'), (4, 'spam')]
         comprehension = [ skit * number for number, skit in list_of_tuples ]
 
-        self.assertEqual('lumberjack', comprehension[0])
-        self.assertEqual('spamspamspamspam', comprehension[2])
+        self.assertEqual(__, comprehension[0])
+        self.assertEqual(__, comprehension[2])
 
     def test_double_list_comprehension(self):
         list_of_eggs = ['poached egg', 'fried egg']
@@ -40,13 +40,13 @@ def test_double_list_comprehension(self):
         comprehension = [ '{0} and {1}'.format(egg, meat) for egg in list_of_eggs for meat in list_of_meats]
 
 
-        self.assertEqual('poached egg and lite spam', comprehension[0])
-        self.assertEqual(6, len(comprehension))
+        self.assertEqual(__, comprehension[0])
+        self.assertEqual(__, len(comprehension))
 
     def test_creating_a_set_with_set_comprehension(self):
         comprehension = { x for x in 'aabbbcccc'}
 
-        self.assertEqual({'a', 'b', 'c'}, comprehension)  # remember that set members are unique
+        self.assertEqual(__, comprehension)  # remember that set members are unique
 
     def test_creating_a_dictionary_with_dictionary_comprehension(self):
         dict_of_weapons = {'first': 'fear', 'second': 'surprise',
@@ -55,7 +55,7 @@ def test_creating_a_dictionary_with_dictionary_comprehension(self):
 
         dict_comprehension = { k.upper(): weapon for k, weapon in dict_of_weapons.items() if weapon}
 
-        self.assertEqual(False, 'first' in dict_comprehension)
-        self.assertEqual(True, 'FIRST' in dict_comprehension)
-        self.assertEqual(5, len(dict_of_weapons))
-        self.assertEqual(4, len(dict_comprehension))
+        self.assertEqual(__, 'first' in dict_comprehension)
+        self.assertEqual(__, 'FIRST' in dict_comprehension)
+        self.assertEqual(__, len(dict_of_weapons))
+        self.assertEqual(__, len(dict_comprehension))
diff --git a/koans/about_control_statements.py b/koans/about_control_statements.py
index 0fbce89ee..842c8d91f 100644
--- a/koans/about_control_statements.py
+++ b/koans/about_control_statements.py
@@ -10,13 +10,13 @@ def test_if_then_else_statements(self):
             result = 'true value'
         else:
             result = 'false value'
-        self.assertEqual('true value', result)
+        self.assertEqual(__, result)
 
     def test_if_then_statements(self):
         result = 'default value'
         if True:
             result = 'true value'
-        self.assertEqual('true value', result)
+        self.assertEqual(__, result)
 
     def test_if_then_elif_else_statements(self):
         if False:
@@ -25,7 +25,7 @@ def test_if_then_elif_else_statements(self):
             result = 'true value'
         else:
             result = 'default value'
-        self.assertEqual('true value', result)
+        self.assertEqual(__, result)
 
     def test_while_statement(self):
         i = 1
@@ -33,7 +33,7 @@ def test_while_statement(self):
         while i <= 10:
             result = result * i
             i += 1
-        self.assertEqual(3628800, result)
+        self.assertEqual(__, result)
 
     def test_break_statement(self):
         i = 1
@@ -42,7 +42,7 @@ def test_break_statement(self):
             if i > 10: break
             result = result * i
             i += 1
-        self.assertEqual(3628800, result)
+        self.assertEqual(__, result)
 
     def test_continue_statement(self):
         i = 0
@@ -51,14 +51,14 @@ def test_continue_statement(self):
             i += 1
             if (i % 2) == 0: continue
             result.append(i)
-        self.assertEqual([1, 3, 5, 7, 9], result)
+        self.assertEqual(__, result)
 
     def test_for_statement(self):
         phrase = ["fish", "and", "chips"]
         result = []
         for item in phrase:
             result.append(item.upper())
-        self.assertEqual(['FISH', 'AND', 'CHIPS'], result)
+        self.assertEqual([__, __, __], result)
 
     def test_for_statement_with_tuples(self):
         round_table = [
@@ -71,7 +71,7 @@ def test_for_statement_with_tuples(self):
         for knight, answer in round_table:
             result.append("Contestant: '" + knight + "'   Answer: '" + answer + "'")
 
-        text = 'Blue! I mean Green!'
+        text = __
 
         self.assertRegex(result[2], text)
 
diff --git a/koans/about_dictionaries.py b/koans/about_dictionaries.py
index 0d81d1356..da1ed6bfe 100644
--- a/koans/about_dictionaries.py
+++ b/koans/about_dictionaries.py
@@ -12,46 +12,46 @@ def test_creating_dictionaries(self):
         empty_dict = dict()
         self.assertEqual(dict, type(empty_dict))
         self.assertDictEqual({}, empty_dict)
-        self.assertEqual(0, len(empty_dict))
+        self.assertEqual(__, len(empty_dict))
 
     def test_dictionary_literals(self):
         empty_dict = {}
         self.assertEqual(dict, type(empty_dict))
         babel_fish = { 'one': 'uno', 'two': 'dos' }
-        self.assertEqual(2, len(babel_fish))
+        self.assertEqual(__, len(babel_fish))
 
     def test_accessing_dictionaries(self):
         babel_fish = { 'one': 'uno', 'two': 'dos' }
-        self.assertEqual('uno', babel_fish['one'])
-        self.assertEqual('dos', babel_fish['two'])
+        self.assertEqual(__, babel_fish['one'])
+        self.assertEqual(__, babel_fish['two'])
 
     def test_changing_dictionaries(self):
         babel_fish = { 'one': 'uno', 'two': 'dos' }
         babel_fish['one'] = 'eins'
 
-        expected = { 'two': 'dos', 'one': 'eins' }
+        expected = { 'two': 'dos', 'one': __ }
         self.assertDictEqual(expected, babel_fish)
 
     def test_dictionary_is_unordered(self):
         dict1 = { 'one': 'uno', 'two': 'dos' }
         dict2 = { 'two': 'dos', 'one': 'uno' }
 
-        self.assertEqual(True, dict1 == dict2)
+        self.assertEqual(__, dict1 == dict2)
 
 
     def test_dictionary_keys_and_values(self):
         babel_fish = {'one': 'uno', 'two': 'dos'}
-        self.assertEqual(2, len(babel_fish.keys()))
-        self.assertEqual(2, len(babel_fish.values()))
-        self.assertEqual(True, 'one' in babel_fish.keys())
-        self.assertEqual(False, 'two' in babel_fish.values())
-        self.assertEqual(False, 'uno' in babel_fish.keys())
-        self.assertEqual(True, 'dos' in babel_fish.values())
+        self.assertEqual(__, len(babel_fish.keys()))
+        self.assertEqual(__, len(babel_fish.values()))
+        self.assertEqual(__, 'one' in babel_fish.keys())
+        self.assertEqual(__, 'two' in babel_fish.values())
+        self.assertEqual(__, 'uno' in babel_fish.keys())
+        self.assertEqual(__, 'dos' in babel_fish.values())
 
     def test_making_a_dictionary_from_a_sequence_of_keys(self):
         cards = {}.fromkeys(('red warrior', 'green elf', 'blue valkyrie', 'yellow dwarf', 'confused looking zebra'), 42)
 
-        self.assertEqual(5, len(cards))
-        self.assertEqual(42, cards['green elf'])
-        self.assertEqual(42, cards['yellow dwarf'])
+        self.assertEqual(__, len(cards))
+        self.assertEqual(__, cards['green elf'])
+        self.assertEqual(__, cards['yellow dwarf'])
 
diff --git a/koans/about_exceptions.py b/koans/about_exceptions.py
index 30ce6f92a..d321bbc50 100644
--- a/koans/about_exceptions.py
+++ b/koans/about_exceptions.py
@@ -10,10 +10,10 @@ class MySpecialError(RuntimeError):
 
     def test_exceptions_inherit_from_exception(self):
         mro = self.MySpecialError.mro()
-        self.assertEqual('RuntimeError', mro[1].__name__)
-        self.assertEqual('Exception', mro[2].__name__)
-        self.assertEqual('BaseException', mro[3].__name__)
-        self.assertEqual('object', mro[4].__name__)
+        self.assertEqual(__, mro[1].__name__)
+        self.assertEqual(__, mro[2].__name__)
+        self.assertEqual(__, mro[3].__name__)
+        self.assertEqual(__, mro[4].__name__)
 
     def test_try_clause(self):
         result = None
@@ -24,15 +24,15 @@ def test_try_clause(self):
 
             ex2 = ex
 
-        self.assertEqual('exception handled', result)
+        self.assertEqual(__, result)
 
-        self.assertEqual(True, isinstance(ex2, Exception))
-        self.assertEqual(False, isinstance(ex2, RuntimeError))
+        self.assertEqual(__, isinstance(ex2, Exception))
+        self.assertEqual(__, isinstance(ex2, RuntimeError))
 
         self.assertTrue(issubclass(RuntimeError, Exception), \
             "RuntimeError is a subclass of Exception")
 
-        self.assertEqual('Oops', ex2.args[0])
+        self.assertEqual(__, ex2.args[0])
 
     def test_raising_a_specific_error(self):
         result = None
@@ -42,8 +42,8 @@ def test_raising_a_specific_error(self):
             result = 'exception handled'
             msg = ex.args[0]
 
-        self.assertEqual('exception handled', result)
-        self.assertEqual('My Message', msg)
+        self.assertEqual(__, result)
+        self.assertEqual(__, msg)
 
     def test_else_clause(self):
         result = None
@@ -55,7 +55,8 @@ def test_else_clause(self):
         else:
             result = 'no damage done'
 
-        self.assertEqual('no damage done', result)
+        self.assertEqual(__, result)
+
 
     def test_finally_clause(self):
         result = None
@@ -67,4 +68,4 @@ def test_finally_clause(self):
         finally:
             result = 'always run'
 
-        self.assertEqual('always run', result)
+        self.assertEqual(__, result)
diff --git a/koans/about_generators.py b/koans/about_generators.py
index 03ffde85c..a81a43ba6 100644
--- a/koans/about_generators.py
+++ b/koans/about_generators.py
@@ -19,7 +19,7 @@ def test_generating_values_on_the_fly(self):
         for bacon in bacon_generator:
             result.append(bacon)
 
-        self.assertEqual(['crunchy bacon', 'veggie bacon', 'danish bacon'], result)
+        self.assertEqual(__, result)
 
     def test_generators_are_different_to_list_comprehensions(self):
         num_list = [x*2 for x in range(1,3)]
@@ -28,9 +28,9 @@ def test_generators_are_different_to_list_comprehensions(self):
         self.assertEqual(2, num_list[0])
 
         # A generator has to be iterated through.
-        with self.assertRaises(TypeError): num = num_generator[0]
+        with self.assertRaises(___): num = num_generator[0]
 
-        self.assertEqual(2, list(num_generator)[0])
+        self.assertEqual(__, 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
@@ -44,8 +44,8 @@ def test_generator_expressions_are_a_one_shot_deal(self):
         attempt1 = list(dynamite)
         attempt2 = list(dynamite)
 
-        self.assertEqual(['Boom!', 'Boom!', 'Boom!'], attempt1)
-        self.assertEqual([], attempt2)
+        self.assertEqual(__, attempt1)
+        self.assertEqual(__, attempt2)
 
     # ------------------------------------------------------------------
 
@@ -59,12 +59,12 @@ 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)
+        self.assertEqual(__, result)
 
     def test_generators_can_be_manually_iterated_and_closed(self):
         result = self.simple_generator_method()
-        self.assertEqual('peanut', next(result))
-        self.assertEqual('butter', next(result))
+        self.assertEqual(__, next(result))
+        self.assertEqual(__, next(result))
         result.close()
 
     # ------------------------------------------------------------------
@@ -75,7 +75,7 @@ def square_me(self, seq):
 
     def test_generator_method_with_parameter(self):
         result = self.square_me(range(2,5))
-        self.assertEqual([4, 9, 16], list(result))
+        self.assertEqual(__, list(result))
 
     # ------------------------------------------------------------------
 
@@ -88,7 +88,7 @@ def sum_it(self, seq):
 
     def test_generator_keeps_track_of_local_variables(self):
         result = self.sum_it(range(2,5))
-        self.assertEqual([2, 5, 9], list(result))
+        self.assertEqual(__, list(result))
 
     # ------------------------------------------------------------------
 
@@ -106,7 +106,7 @@ def test_generators_can_act_as_coroutines(self):
         #       section of http://www.python.org/dev/peps/pep-0342/
         next(generator)
 
-        self.assertEqual(3, generator.send(1 + 2))
+        self.assertEqual(__, generator.send(1 + 2))
 
     def test_before_sending_a_value_to_a_generator_next_must_be_called(self):
         generator = self.coroutine()
@@ -114,8 +114,7 @@ def test_before_sending_a_value_to_a_generator_next_must_be_called(self):
         try:
             generator.send(1 + 2)
         except TypeError as ex:
-            print(ex.args[0])
-            self.assertRegex(ex.args[0], 'can\'t send non-None value to a just-started generator')
+            self.assertRegex(ex.args[0], __)
 
     # ------------------------------------------------------------------
 
@@ -133,11 +132,11 @@ def test_generators_can_see_if_they_have_been_called_with_a_value(self):
 
         generator2 = self.yield_tester()
         next(generator2)
-        self.assertEqual('no value', next(generator2))
+        self.assertEqual(__, 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))
+        self.assertEqual(__, generator.send(None))
diff --git a/koans/about_iteration.py b/koans/about_iteration.py
index 763c43ffd..1faca8e33 100644
--- a/koans/about_iteration.py
+++ b/koans/about_iteration.py
@@ -13,20 +13,20 @@ def test_iterators_are_a_type(self):
         for num in it:
             total += num
 
-        self.assertEqual(15 , total)
+        self.assertEqual(__ , total)
 
     def test_iterating_with_next(self):
         stages = iter(['alpha','beta','gamma'])
 
         try:
-            self.assertEqual('alpha', next(stages))
+            self.assertEqual(__, next(stages))
             next(stages)
-            self.assertEqual('gamma', next(stages))
+            self.assertEqual(__, next(stages))
             next(stages)
         except StopIteration as ex:
             err_msg = 'Ran out of iterations'
 
-        self.assertRegex(err_msg, 'Ran out of iterations')
+        self.assertRegex(err_msg, __)
 
     # ------------------------------------------------------------------
 
@@ -40,14 +40,14 @@ def test_map_transforms_elements_of_a_list(self):
         mapping = map(self.add_ten, seq)
 
         self.assertNotEqual(list, mapping.__class__)
-        self.assertEqual(map, mapping.__class__)
+        self.assertEqual(__, mapping.__class__)
         # In Python 3 built in iterator funcs return iterable view objects
         # instead of lists
 
         for item in mapping:
             mapped_seq.append(item)
 
-        self.assertEqual([11, 12, 13], mapped_seq)
+        self.assertEqual(__, mapped_seq)
 
         # Note, iterator methods actually return objects of iter type in
         # python 3. In python 2 map() would give you a list.
@@ -62,7 +62,7 @@ def is_even(item):
         for item in filter(is_even, seq):
             even_numbers.append(item)
 
-        self.assertEqual([2, 4, 6], even_numbers)
+        self.assertEqual(__, even_numbers)
 
     def test_filter_returns_all_items_matching_criterion(self):
         def is_big_name(item):
@@ -71,8 +71,8 @@ def is_big_name(item):
         names = ["Jim", "Bill", "Clarence", "Doug", "Eli", "Elizabeth"]
         iterator = filter(is_big_name, names)
 
-        self.assertEqual("Clarence", next(iterator))
-        self.assertEqual("Elizabeth", next(iterator))
+        self.assertEqual(__, next(iterator))
+        self.assertEqual(__, next(iterator))
 
         try:
             next(iterator)
@@ -80,7 +80,7 @@ def is_big_name(item):
         except StopIteration:
             msg = 'Ran out of big names'
 
-        self.assertEqual('Ran out of big names', msg)
+        self.assertEquals(__, msg)
 
     # ------------------------------------------------------------------
 
@@ -96,13 +96,13 @@ def test_reduce_will_blow_your_mind(self):
         # to the functools module.
 
         result = functools.reduce(self.add, [2, 3, 4])
-        self.assertEqual(int, result.__class__)
+        self.assertEqual(__, result.__class__)
         # Reduce() syntax is same as Python 2
 
-        self.assertEqual(9, result)
+        self.assertEqual(__, result)
 
         result2 = functools.reduce(self.multiply, [2, 3, 4], 1)
-        self.assertEqual(24, result2)
+        self.assertEqual(__, result2)
 
         # Extra Credit:
         # Describe in your own words what reduce does.
@@ -113,14 +113,14 @@ def test_use_pass_for_iterations_with_no_body(self):
         for num in range(1,5):
             pass
 
-        self.assertEqual(4, num)
+        self.assertEqual(__, num)
 
     # ------------------------------------------------------------------
 
     def test_all_iteration_methods_work_on_any_sequence_not_just_lists(self):
         # Ranges are an iterable sequence
         result = map(self.add_ten, range(1,4))
-        self.assertEqual([11, 12, 13], list(result))
+        self.assertEqual(__, list(result))
 
     def test_lines_in_a_file_are_iterable_sequences_too(self):
         def make_upcase(line):
@@ -128,5 +128,5 @@ def make_upcase(line):
 
         file = open("example_file.txt")
         upcase_lines = map(make_upcase, file.readlines())
-        self.assertEqual(['This', 'Is', 'A', 'Test'], list(upcase_lines))
+        self.assertEqual(__, list(upcase_lines))
         file.close()
diff --git a/koans/about_list_assignments.py b/koans/about_list_assignments.py
index 2bc1337e9..8a8d48090 100644
--- a/koans/about_list_assignments.py
+++ b/koans/about_list_assignments.py
@@ -10,38 +10,34 @@
 class AboutListAssignments(Koan):
     def test_non_parallel_assignment(self):
         names = ["John", "Smith"]
-        self.assertEqual(["John", "Smith"], names)
+        self.assertEqual(__, names)
 
     def test_parallel_assignments(self):
         first_name, last_name = ["John", "Smith"]
-        self.assertEqual("John", first_name)
-        self.assertEqual("Smith", last_name)
+        self.assertEqual(__, first_name)
+        self.assertEqual(__, last_name)
 
     def test_parallel_assignments_with_extra_values(self):
         title, *first_names, last_name = ["Sir", "Ricky", "Bobby", "Worthington"]
-
-        self.assertEqual("Sir", title)
-        self.assertEqual(["Ricky", "Bobby"], first_names)
-        self.assertEqual("Worthington", last_name)
+        self.assertEqual(__, title)
+        self.assertEqual(__, first_names)
+        self.assertEqual(__, last_name)
 
     def test_parallel_assignments_with_fewer_values(self):
         title, *first_names, last_name = ["Mr", "Bond"]
-        print(title)
-        print(first_names)
-        print(last_name)
-        self.assertEqual("Mr", title)
-        self.assertEqual([], first_names)
-        self.assertEqual("Bond", last_name)
+        self.assertEqual(__, title)
+        self.assertEqual(__, first_names)
+        self.assertEqual(__, last_name)
 
     def test_parallel_assignments_with_sublists(self):
         first_name, last_name = [["Willie", "Rae"], "Johnson"]
-        self.assertEqual(["Willie", "Rae"], first_name)
-        self.assertEqual("Johnson", last_name)
+        self.assertEqual(__, first_name)
+        self.assertEqual(__, last_name)
 
     def test_swapping_with_parallel_assignment(self):
         first_name = "Roy"
         last_name = "Rob"
         first_name, last_name = last_name, first_name
-        self.assertEqual("Rob", first_name)
-        self.assertEqual("Roy", last_name)
+        self.assertEqual(__, first_name)
+        self.assertEqual(__, last_name)
 
diff --git a/koans/about_lists.py b/koans/about_lists.py
index de13bf123..61cc3bb29 100644
--- a/koans/about_lists.py
+++ b/koans/about_lists.py
@@ -11,7 +11,7 @@ class AboutLists(Koan):
     def test_creating_lists(self):
         empty_list = list()
         self.assertEqual(list, type(empty_list))
-        self.assertEqual(0, len(empty_list))
+        self.assertEqual(__, len(empty_list))
 
     def test_list_literals(self):
         nums = list()
@@ -21,71 +21,70 @@ def test_list_literals(self):
         self.assertEqual([1], nums)
 
         nums[1:] = [2]
-        self.assertListEqual([1, 2], nums)
+        self.assertListEqual([1, __], nums)
 
         nums.append(333)
-        self.assertListEqual([1, 2, 333], nums)
+        self.assertListEqual([1, 2, __], nums)
 
     def test_accessing_list_elements(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual('peanut', noms[0])
-        self.assertEqual('jelly', noms[3])
-        self.assertEqual('jelly', noms[-1])
-        self.assertEqual('butter', noms[-3])
+        self.assertEqual(__, noms[0])
+        self.assertEqual(__, noms[3])
+        self.assertEqual(__, noms[-1])
+        self.assertEqual(__, noms[-3])
 
     def test_slicing_lists(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(['peanut'], noms[0:1])
-
-        self.assertEqual(['peanut', 'butter'], noms[0:2])
-        self.assertEqual([], noms[2:2])
-        self.assertEqual(['and', 'jelly'], noms[2:20])
-        self.assertEqual([], noms[4:0])
-        self.assertEqual([], noms[4:100])
-        self.assertEqual([], noms[5:0])
+        self.assertEqual(__, noms[0:1])
+        self.assertEqual(__, noms[0:2])
+        self.assertEqual(__, noms[2:2])
+        self.assertEqual(__, noms[2:20])
+        self.assertEqual(__, noms[4:0])
+        self.assertEqual(__, noms[4:100])
+        self.assertEqual(__, noms[5:0])
 
     def test_slicing_to_the_edge(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(['and', 'jelly'], noms[2:])
-        self.assertEqual(['peanut', 'butter'], noms[:2])
+        self.assertEqual(__, noms[2:])
+        self.assertEqual(__, noms[:2])
 
     def test_lists_and_ranges(self):
         self.assertEqual(range, type(range(5)))
         self.assertNotEqual([1, 2, 3, 4, 5], range(1,6))
-        self.assertEqual([0,1,2,3,4], list(range(5)))
-        self.assertEqual([5,6,7,8], list(range(5, 9)))
+        self.assertEqual(__, list(range(5)))
+        self.assertEqual(__, list(range(5, 9)))
 
     def test_ranges_with_steps(self):
-        self.assertEqual([5,4], list(range(5, 3, -1)))
-        self.assertEqual([0, 2, 4, 6], list(range(0, 8, 2)))
-        self.assertEqual([1, 4, 7], list(range(1, 8, 3)))
-        self.assertEqual([5,1, -3], list(range(5, -7, -4)))
-        self.assertEqual([5, 1, -3, -7], list(range(5, -8, -4)))
+        self.assertEqual(__, list(range(5, 3, -1)))
+        self.assertEqual(__, list(range(0, 8, 2)))
+        self.assertEqual(__, list(range(1, 8, 3)))
+        self.assertEqual(__, list(range(5, -7, -4)))
+        self.assertEqual(__, list(range(5, -8, -4)))
 
     def test_insertions(self):
         knight = ['you', 'shall', 'pass']
         knight.insert(2, 'not')
-        self.assertEqual(['you', 'shall', 'not', 'pass'], knight)
+        self.assertEqual(__, knight)
 
         knight.insert(0, 'Arthur')
-        self.assertEqual(['Arthur', 'you', 'shall', 'not', 'pass'], knight)
+        self.assertEqual(__, knight)
 
     def test_popping_lists(self):
         stack = [10, 20, 30, 40]
         stack.append('last')
 
-        self.assertEqual([10, 20, 30, 40, 'last'], stack)
+        self.assertEqual(__, stack)
 
         popped_value = stack.pop()
-        self.assertEqual('last', popped_value)
-        self.assertEqual([10, 20, 30, 40], stack)
+        self.assertEqual(__, popped_value)
+        self.assertEqual(__, stack)
 
         popped_value = stack.pop(1)
-        self.assertEqual(20, popped_value)
-        self.assertEqual([10, 30, 40], stack)
+        self.assertEqual(__, popped_value)
+        self.assertEqual(__, stack)
 
         # Notice that there is a "pop" but no "push" in python?
 
@@ -99,11 +98,11 @@ def test_making_queues(self):
         queue = [1, 2]
         queue.append('last')
 
-        self.assertEqual([1, 2, 'last'], queue)
+        self.assertEqual(__, queue)
 
         popped_value = queue.pop(0)
-        self.assertEqual(1, popped_value)
-        self.assertEqual([2, 'last'], queue)
+        self.assertEqual(__, popped_value)
+        self.assertEqual(__, queue)
 
         # Note, popping from the left hand side of a list is
         # inefficient. Use collections.deque instead.
diff --git a/koans/about_methods.py b/koans/about_methods.py
index 0b9ba3115..796a07ea5 100644
--- a/koans/about_methods.py
+++ b/koans/about_methods.py
@@ -12,12 +12,11 @@ def my_global_function(a,b):
 
 class AboutMethods(Koan):
     def test_calling_a_global_function(self):
-        self.assertEqual(5, my_global_function(2,3))
+        self.assertEqual(__, my_global_function(2,3))
 
     # NOTE: Wrong number of arguments is not a SYNTAX error, but a
     # runtime error.
     def test_calling_functions_with_wrong_number_of_arguments(self):
-        msg = None
         try:
             my_global_function()
         except TypeError as exception:
@@ -33,9 +32,8 @@ def test_calling_functions_with_wrong_number_of_arguments(self):
         except Exception as e:
             msg = e.args[0]
 
-
         # Note, watch out for parenthesis. They need slashes in front!
-        self.assertRegex(msg, r"my_global_function\(\) takes 2 positional arguments but 3 were given")
+        self.assertRegex(msg, __)
 
     # ------------------------------------------------------------------
 
@@ -43,7 +41,7 @@ def pointless_method(self, a, b):
         sum = a + b
 
     def test_which_does_not_return_anything(self):
-        self.assertEqual(None, self.pointless_method(1, 2))
+        self.assertEqual(__, self.pointless_method(1, 2))
         # Notice that methods accessed from class scope do not require
         # you to pass the first "self" argument?
 
@@ -53,8 +51,8 @@ def method_with_defaults(self, a, b='default_value'):
         return [a, b]
 
     def test_calling_with_default_values(self):
-        self.assertEqual([1, 'default_value'], self.method_with_defaults(1))
-        self.assertEqual([1, 2], self.method_with_defaults(1, 2))
+        self.assertEqual(__, self.method_with_defaults(1))
+        self.assertEqual(__, self.method_with_defaults(1, 2))
 
     # ------------------------------------------------------------------
 
@@ -62,9 +60,9 @@ def method_with_var_args(self, *args):
         return args
 
     def test_calling_with_variable_arguments(self):
-        self.assertEqual((), self.method_with_var_args())
+        self.assertEqual(__, self.method_with_var_args())
         self.assertEqual(('one',), self.method_with_var_args('one'))
-        self.assertEqual(('one', 'two'), self.method_with_var_args('one', 'two'))
+        self.assertEqual(__, self.method_with_var_args('one', 'two'))
 
     # ------------------------------------------------------------------
 
@@ -75,13 +73,13 @@ def test_functions_without_self_arg_are_global_functions(self):
         def function_with_the_same_name(a, b):
             return a * b
 
-        self.assertEqual(12, function_with_the_same_name(3,4))
+        self.assertEqual(__, function_with_the_same_name(3,4))
 
     def test_calling_methods_in_same_class_with_explicit_receiver(self):
         def function_with_the_same_name(a, b):
             return a * b
 
-        self.assertEqual(7, self.function_with_the_same_name(3,4))
+        self.assertEqual(__, self.function_with_the_same_name(3,4))
 
     # ------------------------------------------------------------------
 
@@ -94,10 +92,10 @@ def another_method_with_the_same_name(self):
         return 42
 
     def test_that_old_methods_are_hidden_by_redefinitions(self):
-        self.assertEqual(42, self.another_method_with_the_same_name())
+        self.assertEqual(__, self.another_method_with_the_same_name())
 
     def test_that_overlapped_method_is_still_there(self):
-        self.assertEqual(10, self.link_to_overlapped_method())
+        self.assertEqual(__, self.link_to_overlapped_method())
 
     # ------------------------------------------------------------------
 
@@ -105,21 +103,21 @@ def empty_method(self):
         pass
 
     def test_methods_that_do_nothing_need_to_use_pass_as_a_filler(self):
-        self.assertEqual(None, self.empty_method())
+        self.assertEqual(__, self.empty_method())
 
     def test_pass_does_nothing_at_all(self):
         "You"
         "shall"
         "not"
         pass
-        self.assertEqual(True, "Still got to this line" != None)
+        self.assertEqual(____, "Still got to this line" != None)
 
     # ------------------------------------------------------------------
 
     def one_line_method(self): return 'Madagascar'
 
     def test_no_indentation_required_for_one_line_statement_bodies(self):
-        self.assertEqual('Madagascar', self.one_line_method())
+        self.assertEqual(__, self.one_line_method())
 
     # ------------------------------------------------------------------
 
@@ -128,7 +126,7 @@ def method_with_documentation(self):
         return "ok"
 
     def test_the_documentation_can_be_viewed_with_the_doc_method(self):
-        self.assertRegex(self.method_with_documentation.__doc__, "A string placed at the beginning of a function is used for documentation")
+        self.assertRegex(self.method_with_documentation.__doc__, __)
 
     # ------------------------------------------------------------------
 
@@ -145,20 +143,20 @@ def __password(self):
 
     def test_calling_methods_in_other_objects(self):
         rover = self.Dog()
-        self.assertEqual("Fido", rover.name())
+        self.assertEqual(__, rover.name())
 
     def test_private_access_is_implied_but_not_enforced(self):
         rover = self.Dog()
 
         # This is a little rude, but legal
-        self.assertEqual("wagging", rover._tail())
+        self.assertEqual(__, rover._tail())
 
     def test_attributes_with_double_underscore_prefixes_are_subject_to_name_mangling(self):
         rover = self.Dog()
-        with self.assertRaises(AttributeError): password = rover.__password()
+        with self.assertRaises(___): password = rover.__password()
 
         # But this still is!
-        self.assertEqual("password", rover._Dog__password())
+        self.assertEqual(__, rover._Dog__password())
 
         # Name mangling exists to avoid name clash issues when subclassing.
         # It is not for providing effective access protection
diff --git a/koans/about_none.py b/koans/about_none.py
index 3d947883d..1731f0108 100644
--- a/koans/about_none.py
+++ b/koans/about_none.py
@@ -11,11 +11,11 @@ class AboutNone(Koan):
 
     def test_none_is_an_object(self):
         "Unlike NULL in a lot of languages"
-        self.assertEqual(True, isinstance(None, object))
+        self.assertEqual(__, isinstance(None, object))
 
     def test_none_is_universal(self):
         "There is only one None"
-        self.assertEqual(True, None is None)
+        self.assertEqual(____, None is None)
 
     def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         """
@@ -27,7 +27,7 @@ def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         Don't worry about what 'try' and 'except' do, we'll talk about this later
         """
         try:
-            None.some_method_none_does_not_know_about() # type: ignore
+            None.some_method_none_does_not_know_about()
         except Exception as ex:
             ex2 = ex
 
@@ -37,15 +37,15 @@ def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         #
         #     https://github.com/gregmalcolm/python_koans/wiki/Class-Attribute
 
-        self.assertEqual(AttributeError, ex2.__class__) # type: ignore
+        self.assertEqual(__, ex2.__class__)
 
         # What message was attached to the exception?
         # (HINT: replace __ with part of the error message.)
-        self.assertRegex(ex2.args[0], "'NoneType' object has no attribute 'some_method_none_does_not_know_about'") # type: ignore
+        self.assertRegex(ex2.args[0], __)
 
     def test_none_is_distinct(self):
         """
         None is distinct from other things which are False.
         """
-        self.assertEqual(True, None is not 0)
-        self.assertEqual(True, None is not False)
+        self.assertEqual(__, None is not 0)
+        self.assertEqual(__, None is not False)
diff --git a/koans/about_sets.py b/koans/about_sets.py
index 9156605ca..87cf10959 100644
--- a/koans/about_sets.py
+++ b/koans/about_sets.py
@@ -9,27 +9,27 @@ def test_sets_make_keep_lists_unique(self):
 
         there_can_only_be_only_one = set(highlanders)
 
-        self.assertEqual({'Matunas', 'MacLeod', 'Ramirez', 'Malcolm'}, there_can_only_be_only_one)
+        self.assertEqual(__, there_can_only_be_only_one)
 
     def test_empty_sets_have_different_syntax_to_populated_sets(self):
-        self.assertEqual({1, 2, 3}, {1, 2, 3})
-        self.assertEqual(set(), set())
+        self.assertEqual(__, {1, 2, 3})
+        self.assertEqual(__, set())
 
     def test_dictionaries_and_sets_use_same_curly_braces(self):
         # Note: Literal sets using braces were introduced in python 3.
         #       They were also backported to python 2.7.
 
-        self.assertEqual(set, {1, 2, 3}.__class__)
-        self.assertEqual(dict, {'one': 1, 'two': 2}.__class__)
+        self.assertEqual(__, {1, 2, 3}.__class__)
+        self.assertEqual(__, {'one': 1, 'two': 2}.__class__)
 
-        self.assertEqual(dict, {}.__class__)
+        self.assertEqual(__, {}.__class__)
 
     def test_creating_sets_using_strings(self):
-        self.assertEqual({'12345'}, {'12345'})
-        self.assertEqual({'4', '3', '5', '2', '1'}, set('12345'))
+        self.assertEqual(__, {'12345'})
+        self.assertEqual(__, set('12345'))
 
     def test_convert_the_set_into_a_list_to_sort_it(self):
-        self.assertEqual(['1', '2', '3', '4', '5'], sorted(set('12345')))
+        self.assertEqual(__, sorted(set('12345')))
 
     # ------------------------------------------------------------------
 
@@ -37,19 +37,19 @@ def test_set_have_arithmetic_operators(self):
         scotsmen = {'MacLeod', 'Wallace', 'Willie'}
         warriors = {'MacLeod', 'Wallace', 'Leonidas'}
 
-        self.assertEqual({'Willie'}, scotsmen - warriors)
-        self.assertEqual({'Leonidas', 'Willie', 'Wallace', 'MacLeod'}, scotsmen | warriors)
-        self.assertEqual({'MacLeod', 'Wallace'}, scotsmen & warriors)
-        self.assertEqual({'Willie', 'Leonidas'}, scotsmen ^ warriors)
+        self.assertEqual(__, scotsmen - warriors)
+        self.assertEqual(__, scotsmen | warriors)
+        self.assertEqual(__, scotsmen & warriors)
+        self.assertEqual(__, scotsmen ^ warriors)
 
     # ------------------------------------------------------------------
 
     def test_we_can_query_set_membership(self):
-        self.assertEqual(True, 127 in {127, 0, 0, 1} )
-        self.assertEqual(True, 'cow' not in set('apocalypse now') )
+        self.assertEqual(__, 127 in {127, 0, 0, 1} )
+        self.assertEqual(__, 'cow' not in set('apocalypse now') )
 
     def test_we_can_compare_subsets(self):
-        self.assertEqual(True, set('cake') <= set('cherry cake'))
-        self.assertEqual(True, set('cake').issubset(set('cherry cake')) )
+        self.assertEqual(__, set('cake') <= set('cherry cake'))
+        self.assertEqual(__, set('cake').issubset(set('cherry cake')) )
 
-        self.assertEqual(False, set('cake') > set('pie'))
+        self.assertEqual(__, set('cake') > set('pie'))
diff --git a/koans/about_string_manipulation.py b/koans/about_string_manipulation.py
index 6c3733f39..5204f29ba 100644
--- a/koans/about_string_manipulation.py
+++ b/koans/about_string_manipulation.py
@@ -9,13 +9,13 @@ def test_use_format_to_interpolate_variables(self):
         value1 = 'one'
         value2 = 2
         string = "The values are {0} and {1}".format(value1, value2)
-        self.assertEqual("The values are one and 2", string)
+        self.assertEqual(__, string)
 
     def test_formatted_values_can_be_shown_in_any_order_or_be_repeated(self):
         value1 = 'doh'
         value2 = 'DOH'
         string = "The values are {1}, {0}, {0} and {1}!".format(value1, value2)
-        self.assertEqual("The values are DOH, doh, doh and DOH!", string)
+        self.assertEqual(__, string)
 
     def test_any_python_expression_may_be_interpolated(self):
         import math # import a standard python module with math functions
@@ -23,24 +23,24 @@ def test_any_python_expression_may_be_interpolated(self):
         decimal_places = 4
         string = "The square root of 5 is {0:.{1}f}".format(math.sqrt(5),
             decimal_places)
-        self.assertEqual("The square root of 5 is 2.2361", string)
+        self.assertEqual(__, string)
 
     def test_you_can_get_a_substring_from_a_string(self):
         string = "Bacon, lettuce and tomato"
-        self.assertEqual("let", string[7:10])
+        self.assertEqual(__, string[7:10])
 
     def test_you_can_get_a_single_character_from_a_string(self):
         string = "Bacon, lettuce and tomato"
-        self.assertEqual("a", string[1])
+        self.assertEqual(__, string[1])
 
     def test_single_characters_can_be_represented_by_integers(self):
-        self.assertEqual(97, ord('a'))
-        self.assertEqual(True, ord('b') == (ord('a') + 1))
+        self.assertEqual(__, ord('a'))
+        self.assertEqual(__, ord('b') == (ord('a') + 1))
 
     def test_strings_can_be_split(self):
         string = "Sausage Egg Cheese"
         words = string.split()
-        self.assertListEqual(['Sausage', 'Egg', 'Cheese'], words)
+        self.assertListEqual([__, __, __], words)
 
     def test_strings_can_be_split_with_different_patterns(self):
         import re #import python regular expression library
@@ -50,26 +50,25 @@ def test_strings_can_be_split_with_different_patterns(self):
 
         words = pattern.split(string)
 
-        self.assertListEqual(['the', 'rain', 'in', 'spain'], words)
+        self.assertListEqual([__, __, __, __], words)
 
         # Pattern is a Python regular expression pattern which matches ',' or ';'
 
     def test_raw_strings_do_not_interpret_escape_characters(self):
         string = r'\n'
         self.assertNotEqual('\n', string)
-
-        self.assertEqual(r'\n', string)
-        self.assertEqual(2, len(string))
+        self.assertEqual(__, string)
+        self.assertEqual(__, len(string))
 
         # Useful in regular expressions, file paths, URLs, etc.
 
     def test_strings_can_be_joined(self):
         words = ["Now", "is", "the", "time"]
-        self.assertEqual("Now is the time", ' '.join(words))
+        self.assertEqual(__, ' '.join(words))
 
     def test_strings_can_change_case(self):
-        self.assertEqual("Guido", 'guido'.capitalize())
-        self.assertEqual("GUIDO", 'guido'.upper())
-        self.assertEqual("timbot", 'TimBot'.lower())
-        self.assertEqual("Guido Van Rossum", 'guido van rossum'.title())
-        self.assertEqual("tOtAlLy AwEsOmE", 'ToTaLlY aWeSoMe'.swapcase())
+        self.assertEqual(__, 'guido'.capitalize())
+        self.assertEqual(__, 'guido'.upper())
+        self.assertEqual(__, 'TimBot'.lower())
+        self.assertEqual(__, 'guido van rossum'.title())
+        self.assertEqual(__, 'ToTaLlY aWeSoMe'.swapcase())
diff --git a/koans/about_strings.py b/koans/about_strings.py
index 2d6194555..25f5f59df 100644
--- a/koans/about_strings.py
+++ b/koans/about_strings.py
@@ -7,90 +7,88 @@ class AboutStrings(Koan):
 
     def test_double_quoted_strings_are_strings(self):
         string = "Hello, world."
-        self.assertEqual(True, isinstance(string, str))
+        self.assertEqual(__, isinstance(string, str))
 
     def test_single_quoted_strings_are_also_strings(self):
         string = 'Goodbye, world.'
-        self.assertEqual(True, isinstance(string, str))
+        self.assertEqual(__, isinstance(string, str))
 
     def test_triple_quote_strings_are_also_strings(self):
         string = """Howdy, world!"""
-        self.assertEqual(True, isinstance(string, str))
+        self.assertEqual(__, isinstance(string, str))
 
     def test_triple_single_quotes_work_too(self):
         string = '''Bonjour tout le monde!'''
-        self.assertEqual(True, isinstance(string, str))
+        self.assertEqual(__, isinstance(string, str))
 
     def test_raw_strings_are_also_strings(self):
         string = r"Konnichi wa, world!"
-        self.assertEqual(True, isinstance(string, str))
+        self.assertEqual(__, isinstance(string, str))
 
     def test_use_single_quotes_to_create_string_with_double_quotes(self):
         string = 'He said, "Go Away."'
-        self.assertEqual('He said, "Go Away."', string)
+        self.assertEqual(__, string)
 
     def test_use_double_quotes_to_create_strings_with_single_quotes(self):
         string = "Don't"
-        self.assertEqual("Don't", string)
+        self.assertEqual(__, string)
 
     def test_use_backslash_for_escaping_quotes_in_strings(self):
         a = "He said, \"Don't\""
         b = 'He said, "Don\'t"'
-
-        self.assertEqual(True, (a == b))
+        self.assertEqual(__, (a == b))
 
     def test_use_backslash_at_the_end_of_a_line_to_continue_onto_the_next_line(self):
         string = "It was the best of times,\n\
 It was the worst of times."
-
-        self.assertEqual(52, len(string))
+        self.assertEqual(__, len(string))
 
     def test_triple_quoted_strings_can_span_lines(self):
         string = """
 Howdy,
 world!
 """
-        self.assertEqual(15, len(string))
+        self.assertEqual(__, len(string))
 
     def test_triple_quoted_strings_need_less_escaping(self):
         a = "Hello \"world\"."
         b = """Hello "world"."""
-        self.assertEqual(True, (a == b))
+        self.assertEqual(__, (a == b))
 
     def test_escaping_quotes_at_the_end_of_triple_quoted_string(self):
         string = """Hello "world\""""
-        self.assertEqual('Hello "world"', string)
+        self.assertEqual(__, string)
 
     def test_plus_concatenates_strings(self):
         string = "Hello, " + "world"
-        self.assertEqual("Hello, world", string)
+        self.assertEqual(__, string)
 
     def test_adjacent_strings_are_concatenated_automatically(self):
         string = "Hello" ", " "world"
-        self.assertEqual("Hello, world", string)
+        self.assertEqual(__, string)
 
     def test_plus_will_not_modify_original_strings(self):
         hi = "Hello, "
         there = "world"
         string = hi + there
-        self.assertEqual("Hello, ", hi)
-        self.assertEqual("world", there)
+        self.assertEqual(__, hi)
+        self.assertEqual(__, there)
 
     def test_plus_equals_will_append_to_end_of_string(self):
         hi = "Hello, "
         there = "world"
         hi += there
-        self.assertEqual("Hello, world", hi)
+        self.assertEqual(__, hi)
 
     def test_plus_equals_also_leaves_original_string_unmodified(self):
         original = "Hello, "
         hi = original
         there = "world"
         hi += there
-        self.assertEqual("Hello, ", original)
+        self.assertEqual(__, original)
 
     def test_most_strings_interpret_escape_characters(self):
         string = "\n"
         self.assertEqual('\n', string)
         self.assertEqual("""\n""", string)
-        self.assertEqual(1, len(string))
+        self.assertEqual(__, len(string))
diff --git a/koans/about_true_and_false.py b/koans/about_true_and_false.py
index 9467caf51..5f06a63db 100644
--- a/koans/about_true_and_false.py
+++ b/koans/about_true_and_false.py
@@ -12,32 +12,32 @@ def truth_value(self, condition):
             return 'false stuff'
 
     def test_true_is_treated_as_true(self):
-        self.assertEqual('true stuff', self.truth_value(True))
+        self.assertEqual(__, self.truth_value(True))
 
     def test_false_is_treated_as_false(self):
-        self.assertEqual('false stuff', self.truth_value(False))
+        self.assertEqual(__, self.truth_value(False))
 
     def test_none_is_treated_as_false(self):
-        self.assertEqual('false stuff', self.truth_value(None))
+        self.assertEqual(__, self.truth_value(None))
 
     def test_zero_is_treated_as_false(self):
-        self.assertEqual('false stuff', self.truth_value(0))
+        self.assertEqual(__, self.truth_value(0))
 
     def test_empty_collections_are_treated_as_false(self):
-        self.assertEqual('false stuff', self.truth_value([]))
-        self.assertEqual('false stuff', self.truth_value(()))
-        self.assertEqual('false stuff', self.truth_value({}))
-        self.assertEqual('false stuff', self.truth_value(set()))
+        self.assertEqual(__, self.truth_value([]))
+        self.assertEqual(__, self.truth_value(()))
+        self.assertEqual(__, self.truth_value({}))
+        self.assertEqual(__, self.truth_value(set()))
 
     def test_blank_strings_are_treated_as_false(self):
-        self.assertEqual('false stuff', self.truth_value(""))
+        self.assertEqual(__, self.truth_value(""))
 
     def test_everything_else_is_treated_as_true(self):
-        self.assertEqual('true stuff', self.truth_value(1))
-        self.assertEqual('true stuff', self.truth_value([0]))
-        self.assertEqual('true stuff', self.truth_value((0,)))
+        self.assertEqual(__, self.truth_value(1))
+        self.assertEqual(__, self.truth_value([0]))
+        self.assertEqual(__, self.truth_value((0,)))
         self.assertEqual(
-            'true stuff',
+            __,
             self.truth_value("Python is named after Monty Python"))
-        self.assertEqual('true stuff', self.truth_value(' '))
-        self.assertEqual('true stuff', self.truth_value('0'))
+        self.assertEqual(__, self.truth_value(' '))
+        self.assertEqual(__, self.truth_value('0'))
diff --git a/koans/about_tuples.py b/koans/about_tuples.py
index 292f1bdaf..1b38c8f7f 100644
--- a/koans/about_tuples.py
+++ b/koans/about_tuples.py
@@ -6,7 +6,7 @@
 class AboutTuples(Koan):
     def test_creating_a_tuple(self):
         count_of_three =  (1, 2, 5)
-        self.assertEqual(5, count_of_three[2])
+        self.assertEqual(__, count_of_three[2])
 
     def test_tuples_are_immutable_so_item_assignment_is_not_possible(self):
 
@@ -18,11 +18,12 @@ def test_tuples_are_immutable_so_item_assignment_is_not_possible(self):
 
         # Note, assertRegex() uses regular expression pattern matching,
         # so you don't have to copy the whole message.
-        self.assertRegex(msg, "'tuple' object does not support item assignment")
+
+        self.assertRegex(msg, __)
 
     def test_tuples_are_immutable_so_appending_is_not_possible(self):
         count_of_three =  (1, 2, 5)
-        with self.assertRaises(AttributeError): count_of_three.append("boom")
+        with self.assertRaises(___): count_of_three.append("boom")
 
         # Tuples are less flexible than lists, but faster.
 
@@ -33,26 +34,26 @@ def test_tuples_can_only_be_changed_through_replacement(self):
         list_count.append("boom")
         count_of_three = tuple(list_count)
 
-        self.assertEqual((1,2,5, "boom"), count_of_three)
+        self.assertEqual(__, count_of_three)
 
     def test_tuples_of_one_look_peculiar(self):
-        self.assertEqual(int, (1).__class__)
-        self.assertEqual(tuple, (1,).__class__)
-        self.assertEqual(tuple, ("I'm a tuple",).__class__)
-        self.assertEqual(str, ("Not a tuple").__class__)
+        self.assertEqual(__, (1).__class__)
+        self.assertEqual(__, (1,).__class__)
+        self.assertEqual(__, ("I'm a tuple",).__class__)
+        self.assertEqual(__, ("Not a tuple").__class__)
 
     def test_tuple_constructor_can_be_surprising(self):
-        self.assertEqual(('S', 'u', 'r', 'p', 'r', 'i', 's', 'e', '!'), tuple("Surprise!"))
+        self.assertEqual(__, tuple("Surprise!"))
 
     def test_creating_empty_tuples(self):
-        self.assertEqual(() , ())
-        self.assertEqual(() , tuple())  # Sometimes less confusing
+        self.assertEqual(__ , ())
+        self.assertEqual(__ , tuple())  # Sometimes less confusing
 
     def test_tuples_can_be_embedded(self):
         lat = (37, 14, 6, 'N')
         lon = (115, 48, 40, 'W')
         place = ('Area 51', lat, lon)
-        self.assertEqual(('Area 51', (37, 14, 6, 'N'), (115, 48, 40, 'W')), place)
+        self.assertEqual(__, place)
 
     def test_tuples_are_good_for_representing_records(self):
         locations = [
@@ -62,5 +63,5 @@ def test_tuples_are_good_for_representing_records(self):
 
         locations.append( ("Cthulu", (26, 40, 1, 'N'), (70, 45, 7, 'W')) )
 
-        self.assertEqual('Cthulu', locations[2][0])
-        self.assertEqual(15.56, locations[0][1][2])
+        self.assertEqual(__, locations[2][0])
+        self.assertEqual(__, locations[0][1][2])
diff --git a/koans/triangle.py b/koans/triangle.py
index 2ce7e04bd..4d8d66f42 100644
--- a/koans/triangle.py
+++ b/koans/triangle.py
@@ -17,22 +17,8 @@
 #   about_triangle_project_2.py
 #
 def triangle(a, b, c):
-    # Check if all sides are greater than 0
-    if a <= 0 or b <= 0 or c <= 0:
-        raise TriangleError()
-
-    # Check if the sum of any two sides is greater than the third
-    if (a + b <= c) or (b + c <= a) or (a + c <= b):
-        raise TriangleError()
-
-    # If we get here, figure out what type of triangle it is
-    sides = sorted([a, b, c])
-    if sides[0] == sides[2]:
-        return 'equilateral'
-    elif sides[0] == sides[1] or sides[1] == sides[2]:
-        return 'isosceles'
-    else:
-        return 'scalene'
+    # DELETE 'PASS' AND WRITE THIS CODE
+    pass
 
 # Error class used in part 2.  No need to change this code.
 class TriangleError(Exception):

From 42e83f714c737613a576ccbed97c5d3ef63e485d Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sat, 9 Nov 2024 00:11:45 +0800
Subject: [PATCH 21/51] python daily exercise

---
 koans/about_asserts.py | 14 +++++++-------
 koans/about_strings.py | 38 +++++++++++++++++++-------------------
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/koans/about_asserts.py b/koans/about_asserts.py
index d17ed0cdf..a85869529 100644
--- a/koans/about_asserts.py
+++ b/koans/about_asserts.py
@@ -14,25 +14,25 @@ def test_assert_truth(self):
         #
         #   http://bit.ly/about_asserts
 
-        self.assertTrue(False) # This should be True
+        self.assertTrue(True) # This should be True
 
     def test_assert_with_message(self):
         """
         Enlightenment may be more easily achieved with appropriate messages.
         """
-        self.assertTrue(False, "This should be True -- Please fix this")
+        self.assertTrue(True, "This should be True -- Please fix this")
 
     def test_fill_in_values(self):
         """
         Sometimes we will ask you to fill in the values
         """
-        self.assertEqual(__, 1 + 1)
+        self.assertEqual(2, 1 + 1)
 
     def test_assert_equality(self):
         """
         To understand reality, we must compare our expectations against reality.
         """
-        expected_value = __
+        expected_value = 2
         actual_value = 1 + 1
         self.assertTrue(expected_value == actual_value)
 
@@ -40,7 +40,7 @@ def test_a_better_way_of_asserting_equality(self):
         """
         Some ways of asserting equality are better than others.
         """
-        expected_value = __
+        expected_value = 2
         actual_value = 1 + 1
 
         self.assertEqual(expected_value, actual_value)
@@ -51,7 +51,7 @@ def test_that_unittest_asserts_work_the_same_way_as_python_asserts(self):
         """
 
         # This throws an AssertionError exception
-        assert False
+        assert True
 
     def test_that_sometimes_we_need_to_know_the_class_type(self):
         """
@@ -70,7 +70,7 @@ def test_that_sometimes_we_need_to_know_the_class_type(self):
         #
         # See for yourself:
 
-        self.assertEqual(__, "navel".__class__) # It's str, not <type 'str'>
+        self.assertEqual(str, "navel".__class__) # It's str, not <type 'str'>
 
         # Need an illustration? More reading can be found here:
         #
diff --git a/koans/about_strings.py b/koans/about_strings.py
index 25f5f59df..77393eca2 100644
--- a/koans/about_strings.py
+++ b/koans/about_strings.py
@@ -7,88 +7,88 @@ class AboutStrings(Koan):
 
     def test_double_quoted_strings_are_strings(self):
         string = "Hello, world."
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_single_quoted_strings_are_also_strings(self):
         string = 'Goodbye, world.'
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_triple_quote_strings_are_also_strings(self):
         string = """Howdy, world!"""
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_triple_single_quotes_work_too(self):
         string = '''Bonjour tout le monde!'''
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_raw_strings_are_also_strings(self):
         string = r"Konnichi wa, world!"
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_use_single_quotes_to_create_string_with_double_quotes(self):
         string = 'He said, "Go Away."'
-        self.assertEqual(__, string)
+        self.assertEqual('He said, "Go Away."', string)
 
     def test_use_double_quotes_to_create_strings_with_single_quotes(self):
         string = "Don't"
-        self.assertEqual(__, string)
+        self.assertEqual('Don\'t', string)
 
     def test_use_backslash_for_escaping_quotes_in_strings(self):
         a = "He said, \"Don't\""
         b = 'He said, "Don\'t"'
-        self.assertEqual(__, (a == b))
+        self.assertEqual(True, (a == b))
 
     def test_use_backslash_at_the_end_of_a_line_to_continue_onto_the_next_line(self):
         string = "It was the best of times,\n\
 It was the worst of times."
-        self.assertEqual(__, len(string))
+        self.assertEqual(52, len(string))
 
     def test_triple_quoted_strings_can_span_lines(self):
         string = """
 Howdy,
 world!
 """
-        self.assertEqual(__, len(string))
+        self.assertEqual(15, len(string))
 
     def test_triple_quoted_strings_need_less_escaping(self):
         a = "Hello \"world\"."
         b = """Hello "world"."""
-        self.assertEqual(__, (a == b))
+        self.assertEqual(True, (a == b))
 
     def test_escaping_quotes_at_the_end_of_triple_quoted_string(self):
         string = """Hello "world\""""
-        self.assertEqual(__, string)
+        self.assertEqual('Hello "world"', string)
 
     def test_plus_concatenates_strings(self):
         string = "Hello, " + "world"
-        self.assertEqual(__, string)
+        self.assertEqual('Hello, world', string)
 
     def test_adjacent_strings_are_concatenated_automatically(self):
         string = "Hello" ", " "world"
-        self.assertEqual(__, string)
+        self.assertEqual('Hello, world', string)
 
     def test_plus_will_not_modify_original_strings(self):
         hi = "Hello, "
         there = "world"
         string = hi + there
-        self.assertEqual(__, hi)
-        self.assertEqual(__, there)
+        self.assertEqual('Hello, ', hi)
+        self.assertEqual('world', there)
 
     def test_plus_equals_will_append_to_end_of_string(self):
         hi = "Hello, "
         there = "world"
         hi += there
-        self.assertEqual(__, hi)
+        self.assertEqual('Hello, world', hi)
 
     def test_plus_equals_also_leaves_original_string_unmodified(self):
         original = "Hello, "
         hi = original
         there = "world"
         hi += there
-        self.assertEqual(__, original)
+        self.assertEqual('Hello, ', original)
 
     def test_most_strings_interpret_escape_characters(self):
         string = "\n"
         self.assertEqual('\n', string)
         self.assertEqual("""\n""", string)
-        self.assertEqual(__, len(string))
+        self.assertEqual(1, len(string))

From 7953a5464ae9a8b6326adc1231e34e55a59beeba Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sun, 10 Nov 2024 15:33:37 +0800
Subject: [PATCH 22/51] python daily exercise

---
 koans/about_none.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/koans/about_none.py b/koans/about_none.py
index 1731f0108..740ef00c1 100644
--- a/koans/about_none.py
+++ b/koans/about_none.py
@@ -11,11 +11,11 @@ class AboutNone(Koan):
 
     def test_none_is_an_object(self):
         "Unlike NULL in a lot of languages"
-        self.assertEqual(__, isinstance(None, object))
+        self.assertEqual(True, isinstance(None, object))
 
     def test_none_is_universal(self):
         "There is only one None"
-        self.assertEqual(____, None is None)
+        self.assertEqual(True, None is None)
 
     def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         """
@@ -37,15 +37,15 @@ def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         #
         #     https://github.com/gregmalcolm/python_koans/wiki/Class-Attribute
 
-        self.assertEqual(__, ex2.__class__)
+        self.assertEqual(AttributeError, ex2.__class__)
 
         # What message was attached to the exception?
         # (HINT: replace __ with part of the error message.)
-        self.assertRegex(ex2.args[0], __)
+        self.assertRegex(ex2.args[0], "'NoneType' object has no attribute 'some_method_none_does_not_know_about'")
 
     def test_none_is_distinct(self):
         """
         None is distinct from other things which are False.
         """
-        self.assertEqual(__, None is not 0)
-        self.assertEqual(__, None is not False)
+        self.assertEqual(True, None is not 0)
+        self.assertEqual(True, None is not False)

From 7129cc462bd2b7fd4be4f0f0fd3ee35172e48ff0 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Mon, 11 Nov 2024 22:16:51 +0800
Subject: [PATCH 23/51] python daily exercise

---
 koans/about_lists.py | 66 ++++++++++++++++++++++----------------------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/koans/about_lists.py b/koans/about_lists.py
index 61cc3bb29..aa5014cd6 100644
--- a/koans/about_lists.py
+++ b/koans/about_lists.py
@@ -11,7 +11,7 @@ class AboutLists(Koan):
     def test_creating_lists(self):
         empty_list = list()
         self.assertEqual(list, type(empty_list))
-        self.assertEqual(__, len(empty_list))
+        self.assertEqual(0, len(empty_list))
 
     def test_list_literals(self):
         nums = list()
@@ -21,70 +21,70 @@ def test_list_literals(self):
         self.assertEqual([1], nums)
 
         nums[1:] = [2]
-        self.assertListEqual([1, __], nums)
+        self.assertListEqual([1, 2], nums)
 
         nums.append(333)
-        self.assertListEqual([1, 2, __], nums)
+        self.assertListEqual([1, 2, 333], nums)
 
     def test_accessing_list_elements(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(__, noms[0])
-        self.assertEqual(__, noms[3])
-        self.assertEqual(__, noms[-1])
-        self.assertEqual(__, noms[-3])
+        self.assertEqual('peanut', noms[0])
+        self.assertEqual('jelly', noms[3])
+        self.assertEqual('jelly', noms[-1])
+        self.assertEqual('butter', noms[-3])
 
     def test_slicing_lists(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(__, noms[0:1])
-        self.assertEqual(__, noms[0:2])
-        self.assertEqual(__, noms[2:2])
-        self.assertEqual(__, noms[2:20])
-        self.assertEqual(__, noms[4:0])
-        self.assertEqual(__, noms[4:100])
-        self.assertEqual(__, noms[5:0])
+        self.assertEqual(['peanut'], noms[0:1])
+        self.assertEqual(['peanut', 'butter'], noms[0:2])
+        self.assertEqual([], noms[2:2])
+        self.assertEqual(['and', 'jelly'], noms[2:20])
+        self.assertEqual([], noms[4:0])
+        self.assertEqual([], noms[4:100])
+        self.assertEqual([], noms[5:0])
 
     def test_slicing_to_the_edge(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(__, noms[2:])
-        self.assertEqual(__, noms[:2])
+        self.assertEqual(['and', 'jelly'], noms[2:])
+        self.assertEqual(['peanut', 'butter'], noms[:2])
 
     def test_lists_and_ranges(self):
         self.assertEqual(range, type(range(5)))
         self.assertNotEqual([1, 2, 3, 4, 5], range(1,6))
-        self.assertEqual(__, list(range(5)))
-        self.assertEqual(__, list(range(5, 9)))
+        self.assertEqual([0, 1, 2, 3, 4], list(range(5)))
+        self.assertEqual([5, 6, 7, 8], list(range(5, 9)))
 
     def test_ranges_with_steps(self):
-        self.assertEqual(__, list(range(5, 3, -1)))
-        self.assertEqual(__, list(range(0, 8, 2)))
-        self.assertEqual(__, list(range(1, 8, 3)))
-        self.assertEqual(__, list(range(5, -7, -4)))
-        self.assertEqual(__, list(range(5, -8, -4)))
+        self.assertEqual([5, 4], list(range(5, 3, -1)))
+        self.assertEqual([0, 2, 4, 6], list(range(0, 8, 2)))
+        self.assertEqual([1, 4, 7], list(range(1, 8, 3)))
+        self.assertEqual([5, 1, -3], list(range(5, -7, -4)))
+        self.assertEqual([5, 1, -3, -7], list(range(5, -8, -4)))
 
     def test_insertions(self):
         knight = ['you', 'shall', 'pass']
         knight.insert(2, 'not')
-        self.assertEqual(__, knight)
+        self.assertEqual(['you', 'shall', 'not', 'pass'], knight)
 
         knight.insert(0, 'Arthur')
-        self.assertEqual(__, knight)
+        self.assertEqual(['Arthur', 'you', 'shall', 'not', 'pass'], knight)
 
     def test_popping_lists(self):
         stack = [10, 20, 30, 40]
         stack.append('last')
 
-        self.assertEqual(__, stack)
+        self.assertEqual([10, 20, 30, 40, 'last'], stack)
 
         popped_value = stack.pop()
-        self.assertEqual(__, popped_value)
-        self.assertEqual(__, stack)
+        self.assertEqual('last', popped_value)
+        self.assertEqual([10, 20, 30, 40], stack)
 
         popped_value = stack.pop(1)
-        self.assertEqual(__, popped_value)
-        self.assertEqual(__, stack)
+        self.assertEqual(20, popped_value)
+        self.assertEqual([10, 30, 40], stack)
 
         # Notice that there is a "pop" but no "push" in python?
 
@@ -98,11 +98,11 @@ def test_making_queues(self):
         queue = [1, 2]
         queue.append('last')
 
-        self.assertEqual(__, queue)
+        self.assertEqual([1, 2, 'last'], queue)
 
         popped_value = queue.pop(0)
-        self.assertEqual(__, popped_value)
-        self.assertEqual(__, queue)
+        self.assertEqual(1, popped_value)
+        self.assertEqual([2, 'last'], queue)
 
         # Note, popping from the left hand side of a list is
         # inefficient. Use collections.deque instead.

From 9d2544b3f920f2a247212c0851e348aee02e5ecd Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Tue, 12 Nov 2024 22:26:45 +0800
Subject: [PATCH 24/51] python daily exercisse

---
 koans/about_list_assignments.py | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/koans/about_list_assignments.py b/koans/about_list_assignments.py
index 8a8d48090..0b036f0b0 100644
--- a/koans/about_list_assignments.py
+++ b/koans/about_list_assignments.py
@@ -10,34 +10,34 @@
 class AboutListAssignments(Koan):
     def test_non_parallel_assignment(self):
         names = ["John", "Smith"]
-        self.assertEqual(__, names)
+        self.assertEqual(["John", "Smith"], names)
 
     def test_parallel_assignments(self):
         first_name, last_name = ["John", "Smith"]
-        self.assertEqual(__, first_name)
-        self.assertEqual(__, last_name)
+        self.assertEqual("John", first_name)
+        self.assertEqual("Smith", last_name)
 
     def test_parallel_assignments_with_extra_values(self):
         title, *first_names, last_name = ["Sir", "Ricky", "Bobby", "Worthington"]
-        self.assertEqual(__, title)
-        self.assertEqual(__, first_names)
-        self.assertEqual(__, last_name)
+        self.assertEqual("Sir", title)
+        self.assertEqual(["Ricky", "Bobby"], first_names)
+        self.assertEqual("Worthington", last_name)
 
     def test_parallel_assignments_with_fewer_values(self):
         title, *first_names, last_name = ["Mr", "Bond"]
-        self.assertEqual(__, title)
-        self.assertEqual(__, first_names)
-        self.assertEqual(__, last_name)
+        self.assertEqual("Mr", title)
+        self.assertEqual([], first_names)
+        self.assertEqual("Bond", last_name)
 
     def test_parallel_assignments_with_sublists(self):
         first_name, last_name = [["Willie", "Rae"], "Johnson"]
-        self.assertEqual(__, first_name)
-        self.assertEqual(__, last_name)
+        self.assertEqual(["Willie", "Rae"], first_name)
+        self.assertEqual("Johnson", last_name)
 
     def test_swapping_with_parallel_assignment(self):
         first_name = "Roy"
         last_name = "Rob"
         first_name, last_name = last_name, first_name
-        self.assertEqual(__, first_name)
-        self.assertEqual(__, last_name)
+        self.assertEqual("Rob", first_name)
+        self.assertEqual("Roy", last_name)
 

From f94fc2712f5ff91c01baafdef9767d0925fdc4ba Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Wed, 13 Nov 2024 23:19:53 +0800
Subject: [PATCH 25/51] python daily exercise

---
 koans/about_dictionaries.py | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/koans/about_dictionaries.py b/koans/about_dictionaries.py
index da1ed6bfe..0d81d1356 100644
--- a/koans/about_dictionaries.py
+++ b/koans/about_dictionaries.py
@@ -12,46 +12,46 @@ def test_creating_dictionaries(self):
         empty_dict = dict()
         self.assertEqual(dict, type(empty_dict))
         self.assertDictEqual({}, empty_dict)
-        self.assertEqual(__, len(empty_dict))
+        self.assertEqual(0, len(empty_dict))
 
     def test_dictionary_literals(self):
         empty_dict = {}
         self.assertEqual(dict, type(empty_dict))
         babel_fish = { 'one': 'uno', 'two': 'dos' }
-        self.assertEqual(__, len(babel_fish))
+        self.assertEqual(2, len(babel_fish))
 
     def test_accessing_dictionaries(self):
         babel_fish = { 'one': 'uno', 'two': 'dos' }
-        self.assertEqual(__, babel_fish['one'])
-        self.assertEqual(__, babel_fish['two'])
+        self.assertEqual('uno', babel_fish['one'])
+        self.assertEqual('dos', babel_fish['two'])
 
     def test_changing_dictionaries(self):
         babel_fish = { 'one': 'uno', 'two': 'dos' }
         babel_fish['one'] = 'eins'
 
-        expected = { 'two': 'dos', 'one': __ }
+        expected = { 'two': 'dos', 'one': 'eins' }
         self.assertDictEqual(expected, babel_fish)
 
     def test_dictionary_is_unordered(self):
         dict1 = { 'one': 'uno', 'two': 'dos' }
         dict2 = { 'two': 'dos', 'one': 'uno' }
 
-        self.assertEqual(__, dict1 == dict2)
+        self.assertEqual(True, dict1 == dict2)
 
 
     def test_dictionary_keys_and_values(self):
         babel_fish = {'one': 'uno', 'two': 'dos'}
-        self.assertEqual(__, len(babel_fish.keys()))
-        self.assertEqual(__, len(babel_fish.values()))
-        self.assertEqual(__, 'one' in babel_fish.keys())
-        self.assertEqual(__, 'two' in babel_fish.values())
-        self.assertEqual(__, 'uno' in babel_fish.keys())
-        self.assertEqual(__, 'dos' in babel_fish.values())
+        self.assertEqual(2, len(babel_fish.keys()))
+        self.assertEqual(2, len(babel_fish.values()))
+        self.assertEqual(True, 'one' in babel_fish.keys())
+        self.assertEqual(False, 'two' in babel_fish.values())
+        self.assertEqual(False, 'uno' in babel_fish.keys())
+        self.assertEqual(True, 'dos' in babel_fish.values())
 
     def test_making_a_dictionary_from_a_sequence_of_keys(self):
         cards = {}.fromkeys(('red warrior', 'green elf', 'blue valkyrie', 'yellow dwarf', 'confused looking zebra'), 42)
 
-        self.assertEqual(__, len(cards))
-        self.assertEqual(__, cards['green elf'])
-        self.assertEqual(__, cards['yellow dwarf'])
+        self.assertEqual(5, len(cards))
+        self.assertEqual(42, cards['green elf'])
+        self.assertEqual(42, cards['yellow dwarf'])
 

From 0d62189b9bcbcaad102288e19665b05700363392 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Thu, 14 Nov 2024 00:33:49 +0800
Subject: [PATCH 26/51] daily python exercise

---
 koans/about_string_manipulation.py | 34 +++++++++++++++---------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/koans/about_string_manipulation.py b/koans/about_string_manipulation.py
index 5204f29ba..7fca3ae90 100644
--- a/koans/about_string_manipulation.py
+++ b/koans/about_string_manipulation.py
@@ -9,13 +9,13 @@ def test_use_format_to_interpolate_variables(self):
         value1 = 'one'
         value2 = 2
         string = "The values are {0} and {1}".format(value1, value2)
-        self.assertEqual(__, string)
+        self.assertEqual("The values are one and 2", string)
 
     def test_formatted_values_can_be_shown_in_any_order_or_be_repeated(self):
         value1 = 'doh'
         value2 = 'DOH'
         string = "The values are {1}, {0}, {0} and {1}!".format(value1, value2)
-        self.assertEqual(__, string)
+        self.assertEqual("The values are DOH, doh, doh and DOH!", string)
 
     def test_any_python_expression_may_be_interpolated(self):
         import math # import a standard python module with math functions
@@ -23,24 +23,24 @@ def test_any_python_expression_may_be_interpolated(self):
         decimal_places = 4
         string = "The square root of 5 is {0:.{1}f}".format(math.sqrt(5),
             decimal_places)
-        self.assertEqual(__, string)
+        self.assertEqual("The square root of 5 is 2.2361", string)
 
     def test_you_can_get_a_substring_from_a_string(self):
         string = "Bacon, lettuce and tomato"
-        self.assertEqual(__, string[7:10])
+        self.assertEqual('let', string[7:10])
 
     def test_you_can_get_a_single_character_from_a_string(self):
         string = "Bacon, lettuce and tomato"
-        self.assertEqual(__, string[1])
+        self.assertEqual('a', string[1])
 
     def test_single_characters_can_be_represented_by_integers(self):
-        self.assertEqual(__, ord('a'))
-        self.assertEqual(__, ord('b') == (ord('a') + 1))
+        self.assertEqual(97, ord('a'))
+        self.assertEqual(True, ord('b') == (ord('a') + 1))
 
     def test_strings_can_be_split(self):
         string = "Sausage Egg Cheese"
         words = string.split()
-        self.assertListEqual([__, __, __], words)
+        self.assertListEqual(['Sausage', 'Egg', 'Cheese'], words)
 
     def test_strings_can_be_split_with_different_patterns(self):
         import re #import python regular expression library
@@ -50,25 +50,25 @@ def test_strings_can_be_split_with_different_patterns(self):
 
         words = pattern.split(string)
 
-        self.assertListEqual([__, __, __, __], words)
+        self.assertListEqual(["the", "rain", "in", "spain"], words)
 
         # Pattern is a Python regular expression pattern which matches ',' or ';'
 
     def test_raw_strings_do_not_interpret_escape_characters(self):
         string = r'\n'
         self.assertNotEqual('\n', string)
-        self.assertEqual(__, string)
-        self.assertEqual(__, len(string))
+        self.assertEqual('\\n', string)
+        self.assertEqual(2, len(string))
 
         # Useful in regular expressions, file paths, URLs, etc.
 
     def test_strings_can_be_joined(self):
         words = ["Now", "is", "the", "time"]
-        self.assertEqual(__, ' '.join(words))
+        self.assertEqual("Now is the time", ' '.join(words))
 
     def test_strings_can_change_case(self):
-        self.assertEqual(__, 'guido'.capitalize())
-        self.assertEqual(__, 'guido'.upper())
-        self.assertEqual(__, 'TimBot'.lower())
-        self.assertEqual(__, 'guido van rossum'.title())
-        self.assertEqual(__, 'ToTaLlY aWeSoMe'.swapcase())
+        self.assertEqual('Guido', 'guido'.capitalize())
+        self.assertEqual('GUIDO', 'guido'.upper())
+        self.assertEqual('timbot', 'TimBot'.lower())
+        self.assertEqual('Guido Van Rossum', 'guido van rossum'.title())
+        self.assertEqual('tOtAlLy AwEsOmE', 'ToTaLlY aWeSoMe'.swapcase())

From 569702617da3f1add434520bd836db428dd2ebd9 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Fri, 15 Nov 2024 00:57:15 +0800
Subject: [PATCH 27/51] python daily exercise

---
 koans/about_tuples.py | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/koans/about_tuples.py b/koans/about_tuples.py
index 1b38c8f7f..00711005d 100644
--- a/koans/about_tuples.py
+++ b/koans/about_tuples.py
@@ -6,7 +6,7 @@
 class AboutTuples(Koan):
     def test_creating_a_tuple(self):
         count_of_three =  (1, 2, 5)
-        self.assertEqual(__, count_of_three[2])
+        self.assertEqual(5, count_of_three[2])
 
     def test_tuples_are_immutable_so_item_assignment_is_not_possible(self):
 
@@ -19,11 +19,12 @@ def test_tuples_are_immutable_so_item_assignment_is_not_possible(self):
         # Note, assertRegex() uses regular expression pattern matching,
         # so you don't have to copy the whole message.
 
-        self.assertRegex(msg, __)
+        self.assertRegex(msg, "'tuple' object does not support item assignment")
 
     def test_tuples_are_immutable_so_appending_is_not_possible(self):
         count_of_three =  (1, 2, 5)
-        with self.assertRaises(___): count_of_three.append("boom")
+
+        with self.assertRaises(AttributeError): count_of_three.append("boom")
 
         # Tuples are less flexible than lists, but faster.
 
@@ -34,26 +35,26 @@ def test_tuples_can_only_be_changed_through_replacement(self):
         list_count.append("boom")
         count_of_three = tuple(list_count)
 
-        self.assertEqual(__, count_of_three)
+        self.assertEqual((1,2,5, "boom"), count_of_three)
 
     def test_tuples_of_one_look_peculiar(self):
-        self.assertEqual(__, (1).__class__)
-        self.assertEqual(__, (1,).__class__)
-        self.assertEqual(__, ("I'm a tuple",).__class__)
-        self.assertEqual(__, ("Not a tuple").__class__)
+        self.assertEqual(int, (1).__class__)
+        self.assertEqual(tuple, (1,).__class__)
+        self.assertEqual(tuple, ("I'm a tuple",).__class__)
+        self.assertEqual(str, ("Not a tuple").__class__)
 
     def test_tuple_constructor_can_be_surprising(self):
-        self.assertEqual(__, tuple("Surprise!"))
+        self.assertEqual(('S', 'u', 'r', 'p', 'r', 'i', 's', 'e', '!'), tuple("Surprise!"))
 
     def test_creating_empty_tuples(self):
-        self.assertEqual(__ , ())
-        self.assertEqual(__ , tuple())  # Sometimes less confusing
+        self.assertEqual(() , ())
+        self.assertEqual(() , tuple())  # Sometimes less confusing
 
     def test_tuples_can_be_embedded(self):
         lat = (37, 14, 6, 'N')
         lon = (115, 48, 40, 'W')
         place = ('Area 51', lat, lon)
-        self.assertEqual(__, place)
+        self.assertEqual(('Area 51', (37, 14, 6, 'N'), (115, 48, 40, 'W')), place)
 
     def test_tuples_are_good_for_representing_records(self):
         locations = [
@@ -63,5 +64,5 @@ def test_tuples_are_good_for_representing_records(self):
 
         locations.append( ("Cthulu", (26, 40, 1, 'N'), (70, 45, 7, 'W')) )
 
-        self.assertEqual(__, locations[2][0])
-        self.assertEqual(__, locations[0][1][2])
+        self.assertEqual("Cthulu", locations[2][0])
+        self.assertEqual(15.56, locations[0][1][2])

From 89dda3dd717bfa3ada14865b083b8d8284610a0e Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sat, 16 Nov 2024 01:18:06 +0800
Subject: [PATCH 28/51] Daily python exercise

---
 koans/about_methods.py | 38 +++++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/koans/about_methods.py b/koans/about_methods.py
index 796a07ea5..228de0e7f 100644
--- a/koans/about_methods.py
+++ b/koans/about_methods.py
@@ -12,7 +12,7 @@ def my_global_function(a,b):
 
 class AboutMethods(Koan):
     def test_calling_a_global_function(self):
-        self.assertEqual(__, my_global_function(2,3))
+        self.assertEqual(5, my_global_function(2,3))
 
     # NOTE: Wrong number of arguments is not a SYNTAX error, but a
     # runtime error.
@@ -33,7 +33,7 @@ def test_calling_functions_with_wrong_number_of_arguments(self):
             msg = e.args[0]
 
         # Note, watch out for parenthesis. They need slashes in front!
-        self.assertRegex(msg, __)
+        self.assertRegex(msg, 'my_global_function\(\) takes 2 positional arguments but 3 were given')
 
     # ------------------------------------------------------------------
 
@@ -41,7 +41,7 @@ def pointless_method(self, a, b):
         sum = a + b
 
     def test_which_does_not_return_anything(self):
-        self.assertEqual(__, self.pointless_method(1, 2))
+        self.assertEqual(None, self.pointless_method(1, 2))
         # Notice that methods accessed from class scope do not require
         # you to pass the first "self" argument?
 
@@ -51,8 +51,8 @@ def method_with_defaults(self, a, b='default_value'):
         return [a, b]
 
     def test_calling_with_default_values(self):
-        self.assertEqual(__, self.method_with_defaults(1))
-        self.assertEqual(__, self.method_with_defaults(1, 2))
+        self.assertEqual([1, 'default_value'], self.method_with_defaults(1))
+        self.assertEqual([1, 2], self.method_with_defaults(1, 2))
 
     # ------------------------------------------------------------------
 
@@ -60,9 +60,9 @@ def method_with_var_args(self, *args):
         return args
 
     def test_calling_with_variable_arguments(self):
-        self.assertEqual(__, self.method_with_var_args())
+        self.assertEqual((), self.method_with_var_args())
         self.assertEqual(('one',), self.method_with_var_args('one'))
-        self.assertEqual(__, self.method_with_var_args('one', 'two'))
+        self.assertEqual(('one', 'two'), self.method_with_var_args('one', 'two'))
 
     # ------------------------------------------------------------------
 
@@ -73,13 +73,13 @@ def test_functions_without_self_arg_are_global_functions(self):
         def function_with_the_same_name(a, b):
             return a * b
 
-        self.assertEqual(__, function_with_the_same_name(3,4))
+        self.assertEqual(12, function_with_the_same_name(3,4))
 
     def test_calling_methods_in_same_class_with_explicit_receiver(self):
         def function_with_the_same_name(a, b):
             return a * b
 
-        self.assertEqual(__, self.function_with_the_same_name(3,4))
+        self.assertEqual(7, self.function_with_the_same_name(3,4))
 
     # ------------------------------------------------------------------
 
@@ -92,10 +92,10 @@ def another_method_with_the_same_name(self):
         return 42
 
     def test_that_old_methods_are_hidden_by_redefinitions(self):
-        self.assertEqual(__, self.another_method_with_the_same_name())
+        self.assertEqual(42, self.another_method_with_the_same_name())
 
     def test_that_overlapped_method_is_still_there(self):
-        self.assertEqual(__, self.link_to_overlapped_method())
+        self.assertEqual(10, self.link_to_overlapped_method())
 
     # ------------------------------------------------------------------
 
@@ -103,21 +103,21 @@ def empty_method(self):
         pass
 
     def test_methods_that_do_nothing_need_to_use_pass_as_a_filler(self):
-        self.assertEqual(__, self.empty_method())
+        self.assertEqual(None, self.empty_method())
 
     def test_pass_does_nothing_at_all(self):
         "You"
         "shall"
         "not"
         pass
-        self.assertEqual(____, "Still got to this line" != None)
+        self.assertEqual(True, "Still got to this line" != None)
 
     # ------------------------------------------------------------------
 
     def one_line_method(self): return 'Madagascar'
 
     def test_no_indentation_required_for_one_line_statement_bodies(self):
-        self.assertEqual(__, self.one_line_method())
+        self.assertEqual('Madagascar', self.one_line_method())
 
     # ------------------------------------------------------------------
 
@@ -126,7 +126,7 @@ def method_with_documentation(self):
         return "ok"
 
     def test_the_documentation_can_be_viewed_with_the_doc_method(self):
-        self.assertRegex(self.method_with_documentation.__doc__, __)
+        self.assertRegex(self.method_with_documentation.__doc__, "A string placed at the beginning of a function is used for documentation")
 
     # ------------------------------------------------------------------
 
@@ -143,20 +143,20 @@ def __password(self):
 
     def test_calling_methods_in_other_objects(self):
         rover = self.Dog()
-        self.assertEqual(__, rover.name())
+        self.assertEqual("Fido", rover.name())
 
     def test_private_access_is_implied_but_not_enforced(self):
         rover = self.Dog()
 
         # This is a little rude, but legal
-        self.assertEqual(__, rover._tail())
+        self.assertEqual("wagging", rover._tail())
 
     def test_attributes_with_double_underscore_prefixes_are_subject_to_name_mangling(self):
         rover = self.Dog()
-        with self.assertRaises(___): password = rover.__password()
+        with self.assertRaises(AttributeError): password = rover.__password()
 
         # But this still is!
-        self.assertEqual(__, rover._Dog__password())
+        self.assertEqual("password", rover._Dog__password())
 
         # Name mangling exists to avoid name clash issues when subclassing.
         # It is not for providing effective access protection

From b891dc6411e7e0340c952aec5355f65ff43bda21 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Tue, 19 Nov 2024 05:11:28 +0800
Subject: [PATCH 29/51] daily python exercise

---
 koans/about_control_statements.py | 16 ++++++++--------
 koans/about_sets.py               |  2 +-
 koans/about_true_and_false.py     | 30 +++++++++++++++---------------
 3 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/koans/about_control_statements.py b/koans/about_control_statements.py
index 842c8d91f..7935fb00a 100644
--- a/koans/about_control_statements.py
+++ b/koans/about_control_statements.py
@@ -10,13 +10,13 @@ def test_if_then_else_statements(self):
             result = 'true value'
         else:
             result = 'false value'
-        self.assertEqual(__, result)
+        self.assertEqual('true value', result)
 
     def test_if_then_statements(self):
         result = 'default value'
         if True:
             result = 'true value'
-        self.assertEqual(__, result)
+        self.assertEqual('true value', result)
 
     def test_if_then_elif_else_statements(self):
         if False:
@@ -25,7 +25,7 @@ def test_if_then_elif_else_statements(self):
             result = 'true value'
         else:
             result = 'default value'
-        self.assertEqual(__, result)
+        self.assertEqual('true value', result)
 
     def test_while_statement(self):
         i = 1
@@ -33,7 +33,7 @@ def test_while_statement(self):
         while i <= 10:
             result = result * i
             i += 1
-        self.assertEqual(__, result)
+        self.assertEqual(3628800, result)
 
     def test_break_statement(self):
         i = 1
@@ -42,7 +42,7 @@ def test_break_statement(self):
             if i > 10: break
             result = result * i
             i += 1
-        self.assertEqual(__, result)
+        self.assertEqual(3628800, result)
 
     def test_continue_statement(self):
         i = 0
@@ -51,14 +51,14 @@ def test_continue_statement(self):
             i += 1
             if (i % 2) == 0: continue
             result.append(i)
-        self.assertEqual(__, result)
+        self.assertEqual([1, 3, 5, 7, 9], result)
 
     def test_for_statement(self):
         phrase = ["fish", "and", "chips"]
         result = []
         for item in phrase:
             result.append(item.upper())
-        self.assertEqual([__, __, __], result)
+        self.assertEqual(['FISH', 'AND', 'CHIPS'], result)
 
     def test_for_statement_with_tuples(self):
         round_table = [
@@ -71,7 +71,7 @@ def test_for_statement_with_tuples(self):
         for knight, answer in round_table:
             result.append("Contestant: '" + knight + "'   Answer: '" + answer + "'")
 
-        text = __
+        text = "Contestant: 'Robin'   Answer: 'Blue! I mean Green!'"
 
         self.assertRegex(result[2], text)
 
diff --git a/koans/about_sets.py b/koans/about_sets.py
index 87cf10959..e1f335ea8 100644
--- a/koans/about_sets.py
+++ b/koans/about_sets.py
@@ -9,7 +9,7 @@ def test_sets_make_keep_lists_unique(self):
 
         there_can_only_be_only_one = set(highlanders)
 
-        self.assertEqual(__, there_can_only_be_only_one)
+        self.assertEqual({"MacLeod", "Ramirez", "Matunas", "Malcolm"}, there_can_only_be_only_one)
 
     def test_empty_sets_have_different_syntax_to_populated_sets(self):
         self.assertEqual(__, {1, 2, 3})
diff --git a/koans/about_true_and_false.py b/koans/about_true_and_false.py
index 5f06a63db..9467caf51 100644
--- a/koans/about_true_and_false.py
+++ b/koans/about_true_and_false.py
@@ -12,32 +12,32 @@ def truth_value(self, condition):
             return 'false stuff'
 
     def test_true_is_treated_as_true(self):
-        self.assertEqual(__, self.truth_value(True))
+        self.assertEqual('true stuff', self.truth_value(True))
 
     def test_false_is_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(False))
+        self.assertEqual('false stuff', self.truth_value(False))
 
     def test_none_is_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(None))
+        self.assertEqual('false stuff', self.truth_value(None))
 
     def test_zero_is_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(0))
+        self.assertEqual('false stuff', self.truth_value(0))
 
     def test_empty_collections_are_treated_as_false(self):
-        self.assertEqual(__, self.truth_value([]))
-        self.assertEqual(__, self.truth_value(()))
-        self.assertEqual(__, self.truth_value({}))
-        self.assertEqual(__, self.truth_value(set()))
+        self.assertEqual('false stuff', self.truth_value([]))
+        self.assertEqual('false stuff', self.truth_value(()))
+        self.assertEqual('false stuff', self.truth_value({}))
+        self.assertEqual('false stuff', self.truth_value(set()))
 
     def test_blank_strings_are_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(""))
+        self.assertEqual('false stuff', self.truth_value(""))
 
     def test_everything_else_is_treated_as_true(self):
-        self.assertEqual(__, self.truth_value(1))
-        self.assertEqual(__, self.truth_value([0]))
-        self.assertEqual(__, self.truth_value((0,)))
+        self.assertEqual('true stuff', self.truth_value(1))
+        self.assertEqual('true stuff', self.truth_value([0]))
+        self.assertEqual('true stuff', self.truth_value((0,)))
         self.assertEqual(
-            __,
+            'true stuff',
             self.truth_value("Python is named after Monty Python"))
-        self.assertEqual(__, self.truth_value(' '))
-        self.assertEqual(__, self.truth_value('0'))
+        self.assertEqual('true stuff', self.truth_value(' '))
+        self.assertEqual('true stuff', self.truth_value('0'))

From 33dabf0b599a39cc460801266fac370c66dc10cf Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Wed, 20 Nov 2024 00:22:17 +0800
Subject: [PATCH 30/51] python daily exercise

---
 koans/about_sets.py | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/koans/about_sets.py b/koans/about_sets.py
index e1f335ea8..14fc0662c 100644
--- a/koans/about_sets.py
+++ b/koans/about_sets.py
@@ -12,24 +12,24 @@ def test_sets_make_keep_lists_unique(self):
         self.assertEqual({"MacLeod", "Ramirez", "Matunas", "Malcolm"}, there_can_only_be_only_one)
 
     def test_empty_sets_have_different_syntax_to_populated_sets(self):
-        self.assertEqual(__, {1, 2, 3})
-        self.assertEqual(__, set())
+        self.assertEqual(set([1,2,3]), {1, 2, 3})
+        self.assertEqual(set(), set())
 
     def test_dictionaries_and_sets_use_same_curly_braces(self):
         # Note: Literal sets using braces were introduced in python 3.
         #       They were also backported to python 2.7.
 
-        self.assertEqual(__, {1, 2, 3}.__class__)
-        self.assertEqual(__, {'one': 1, 'two': 2}.__class__)
+        self.assertEqual(set, {1, 2, 3}.__class__)
+        self.assertEqual(dict, {'one': 1, 'two': 2}.__class__)
 
-        self.assertEqual(__, {}.__class__)
+        self.assertEqual(dict, {}.__class__)
 
     def test_creating_sets_using_strings(self):
-        self.assertEqual(__, {'12345'})
-        self.assertEqual(__, set('12345'))
+        self.assertEqual(set(['12345']), {'12345'})
+        self.assertEqual({'1','2','3','4','5'}, set('12345'))
 
     def test_convert_the_set_into_a_list_to_sort_it(self):
-        self.assertEqual(__, sorted(set('12345')))
+        self.assertEqual(['1','2','3','4','5'], sorted(set('12345')))
 
     # ------------------------------------------------------------------
 
@@ -37,19 +37,19 @@ def test_set_have_arithmetic_operators(self):
         scotsmen = {'MacLeod', 'Wallace', 'Willie'}
         warriors = {'MacLeod', 'Wallace', 'Leonidas'}
 
-        self.assertEqual(__, scotsmen - warriors)
-        self.assertEqual(__, scotsmen | warriors)
-        self.assertEqual(__, scotsmen & warriors)
-        self.assertEqual(__, scotsmen ^ warriors)
+        self.assertEqual({'Willie'}, scotsmen - warriors)
+        self.assertEqual({'Wallace', 'MacLeod', 'Willie', 'Leonidas'}, scotsmen | warriors)
+        self.assertEqual({'Wallace', 'MacLeod'}, scotsmen & warriors)
+        self.assertEqual({'Willie', 'Leonidas'}, scotsmen ^ warriors)
 
     # ------------------------------------------------------------------
 
     def test_we_can_query_set_membership(self):
-        self.assertEqual(__, 127 in {127, 0, 0, 1} )
-        self.assertEqual(__, 'cow' not in set('apocalypse now') )
+        self.assertEqual(True, 127 in {127, 0, 0, 1} )
+        self.assertEqual(True, 'cow' not in set('apocalypse now') )
 
     def test_we_can_compare_subsets(self):
-        self.assertEqual(__, set('cake') <= set('cherry cake'))
-        self.assertEqual(__, set('cake').issubset(set('cherry cake')) )
+        self.assertEqual(True, set('cake') <= set('cherry cake'))
+        self.assertEqual(True, set('cake').issubset(set('cherry cake')) )
 
-        self.assertEqual(__, set('cake') > set('pie'))
+        self.assertEqual(False, set('cake') > set('pie'))

From c278a11f742deed9ecc0719cbfb4b42a936e6c6d Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Wed, 20 Nov 2024 03:16:43 +0800
Subject: [PATCH 31/51] daily python exercise

---
 koans/about_exceptions.py | 24 ++++++++++++------------
 koans/about_iteration.py  | 32 ++++++++++++++++----------------
 koans/triangle.py         | 14 ++++++++++++--
 3 files changed, 40 insertions(+), 30 deletions(-)

diff --git a/koans/about_exceptions.py b/koans/about_exceptions.py
index d321bbc50..7063786da 100644
--- a/koans/about_exceptions.py
+++ b/koans/about_exceptions.py
@@ -10,10 +10,10 @@ class MySpecialError(RuntimeError):
 
     def test_exceptions_inherit_from_exception(self):
         mro = self.MySpecialError.mro()
-        self.assertEqual(__, mro[1].__name__)
-        self.assertEqual(__, mro[2].__name__)
-        self.assertEqual(__, mro[3].__name__)
-        self.assertEqual(__, mro[4].__name__)
+        self.assertEqual('RuntimeError', mro[1].__name__)
+        self.assertEqual('Exception', mro[2].__name__)
+        self.assertEqual('BaseException', mro[3].__name__)
+        self.assertEqual('object', mro[4].__name__)
 
     def test_try_clause(self):
         result = None
@@ -24,15 +24,15 @@ def test_try_clause(self):
 
             ex2 = ex
 
-        self.assertEqual(__, result)
+        self.assertEqual('exception handled', result)
 
-        self.assertEqual(__, isinstance(ex2, Exception))
-        self.assertEqual(__, isinstance(ex2, RuntimeError))
+        self.assertEqual(True, isinstance(ex2, Exception))
+        self.assertEqual(False, isinstance(ex2, RuntimeError))
 
         self.assertTrue(issubclass(RuntimeError, Exception), \
             "RuntimeError is a subclass of Exception")
 
-        self.assertEqual(__, ex2.args[0])
+        self.assertEqual('Oops', ex2.args[0])
 
     def test_raising_a_specific_error(self):
         result = None
@@ -42,8 +42,8 @@ def test_raising_a_specific_error(self):
             result = 'exception handled'
             msg = ex.args[0]
 
-        self.assertEqual(__, result)
-        self.assertEqual(__, msg)
+        self.assertEqual('exception handled', result)
+        self.assertEqual("My Message", msg)
 
     def test_else_clause(self):
         result = None
@@ -55,7 +55,7 @@ def test_else_clause(self):
         else:
             result = 'no damage done'
 
-        self.assertEqual(__, result)
+        self.assertEqual('no damage done', result)
 
 
     def test_finally_clause(self):
@@ -68,4 +68,4 @@ def test_finally_clause(self):
         finally:
             result = 'always run'
 
-        self.assertEqual(__, result)
+        self.assertEqual('always run', result)
diff --git a/koans/about_iteration.py b/koans/about_iteration.py
index 1faca8e33..c1cbefbaf 100644
--- a/koans/about_iteration.py
+++ b/koans/about_iteration.py
@@ -13,20 +13,20 @@ def test_iterators_are_a_type(self):
         for num in it:
             total += num
 
-        self.assertEqual(__ , total)
+        self.assertEqual(15 , total)
 
     def test_iterating_with_next(self):
         stages = iter(['alpha','beta','gamma'])
 
         try:
-            self.assertEqual(__, next(stages))
+            self.assertEqual('alpha', next(stages))
             next(stages)
-            self.assertEqual(__, next(stages))
+            self.assertEqual('gamma', next(stages))
             next(stages)
         except StopIteration as ex:
             err_msg = 'Ran out of iterations'
 
-        self.assertRegex(err_msg, __)
+        self.assertRegex(err_msg, 'Ran out of iterations')
 
     # ------------------------------------------------------------------
 
@@ -40,14 +40,14 @@ def test_map_transforms_elements_of_a_list(self):
         mapping = map(self.add_ten, seq)
 
         self.assertNotEqual(list, mapping.__class__)
-        self.assertEqual(__, mapping.__class__)
+        self.assertEqual(map, mapping.__class__)
         # In Python 3 built in iterator funcs return iterable view objects
         # instead of lists
 
         for item in mapping:
             mapped_seq.append(item)
 
-        self.assertEqual(__, mapped_seq)
+        self.assertEqual([11, 12, 13], mapped_seq)
 
         # Note, iterator methods actually return objects of iter type in
         # python 3. In python 2 map() would give you a list.
@@ -62,7 +62,7 @@ def is_even(item):
         for item in filter(is_even, seq):
             even_numbers.append(item)
 
-        self.assertEqual(__, even_numbers)
+        self.assertEqual([2, 4, 6], even_numbers)
 
     def test_filter_returns_all_items_matching_criterion(self):
         def is_big_name(item):
@@ -71,8 +71,8 @@ def is_big_name(item):
         names = ["Jim", "Bill", "Clarence", "Doug", "Eli", "Elizabeth"]
         iterator = filter(is_big_name, names)
 
-        self.assertEqual(__, next(iterator))
-        self.assertEqual(__, next(iterator))
+        self.assertEqual('Clarence', next(iterator))
+        self.assertEqual('Elizabeth', next(iterator))
 
         try:
             next(iterator)
@@ -80,7 +80,7 @@ def is_big_name(item):
         except StopIteration:
             msg = 'Ran out of big names'
 
-        self.assertEquals(__, msg)
+        self.assertEqual('Ran out of big names', msg)
 
     # ------------------------------------------------------------------
 
@@ -96,13 +96,13 @@ def test_reduce_will_blow_your_mind(self):
         # to the functools module.
 
         result = functools.reduce(self.add, [2, 3, 4])
-        self.assertEqual(__, result.__class__)
+        self.assertEqual(int, result.__class__)
         # Reduce() syntax is same as Python 2
 
-        self.assertEqual(__, result)
+        self.assertEqual(9, result)
 
         result2 = functools.reduce(self.multiply, [2, 3, 4], 1)
-        self.assertEqual(__, result2)
+        self.assertEqual(24, result2)
 
         # Extra Credit:
         # Describe in your own words what reduce does.
@@ -113,14 +113,14 @@ def test_use_pass_for_iterations_with_no_body(self):
         for num in range(1,5):
             pass
 
-        self.assertEqual(__, num)
+        self.assertEqual(4, num)
 
     # ------------------------------------------------------------------
 
     def test_all_iteration_methods_work_on_any_sequence_not_just_lists(self):
         # Ranges are an iterable sequence
         result = map(self.add_ten, range(1,4))
-        self.assertEqual(__, list(result))
+        self.assertEqual([11, 12, 13], list(result))
 
     def test_lines_in_a_file_are_iterable_sequences_too(self):
         def make_upcase(line):
@@ -128,5 +128,5 @@ def make_upcase(line):
 
         file = open("example_file.txt")
         upcase_lines = map(make_upcase, file.readlines())
-        self.assertEqual(__, list(upcase_lines))
+        self.assertEqual(['This', 'Is', 'A', 'Test'], list(upcase_lines))
         file.close()
diff --git a/koans/triangle.py b/koans/triangle.py
index 4d8d66f42..3d21e6336 100644
--- a/koans/triangle.py
+++ b/koans/triangle.py
@@ -17,8 +17,18 @@
 #   about_triangle_project_2.py
 #
 def triangle(a, b, c):
-    # DELETE 'PASS' AND WRITE THIS CODE
-    pass
+    if a <= 0 or b <= 0 or c <= 0:
+        raise TriangleError("Sides must be greater than 0")
+
+    if (a + b <= c) or (b + c <= a) or (a + c <= b):
+        raise TriangleError("Triangle inequality not satisfied")
+
+    if a == b == c:
+        return 'equilateral'
+    elif a == b or b == c or a == c:
+        return 'isosceles'
+    else:
+        return 'scalene'
 
 # Error class used in part 2.  No need to change this code.
 class TriangleError(Exception):

From 8352e0b5e497f92ace18d509e44fd9265f2f999b Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Fri, 22 Nov 2024 21:42:48 +0800
Subject: [PATCH 32/51] python koans

---
 koans/about_comprehension.py | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/koans/about_comprehension.py b/koans/about_comprehension.py
index e5add6d9e..9577a0e4d 100644
--- a/koans/about_comprehension.py
+++ b/koans/about_comprehension.py
@@ -13,8 +13,8 @@ def test_creating_lists_with_list_comprehensions(self):
 
         comprehension = [delicacy.capitalize() for delicacy in feast]
 
-        self.assertEqual(__, comprehension[0])
-        self.assertEqual(__, comprehension[2])
+        self.assertEqual("Lambs", comprehension[0])
+        self.assertEqual("Orangutans", comprehension[2])
 
     def test_filtering_lists_with_list_comprehensions(self):
         feast = ['spam', 'sloths', 'orangutans', 'breakfast cereals',
@@ -22,15 +22,15 @@ def test_filtering_lists_with_list_comprehensions(self):
 
         comprehension = [delicacy for delicacy in feast if len(delicacy) > 6]
 
-        self.assertEqual(__, len(feast))
-        self.assertEqual(__, len(comprehension))
+        self.assertEqual(5, len(feast))
+        self.assertEqual(3, len(comprehension))
 
     def test_unpacking_tuples_in_list_comprehensions(self):
         list_of_tuples = [(1, 'lumberjack'), (2, 'inquisition'), (4, 'spam')]
         comprehension = [ skit * number for number, skit in list_of_tuples ]
 
-        self.assertEqual(__, comprehension[0])
-        self.assertEqual(__, comprehension[2])
+        self.assertEqual('lumberjack', comprehension[0])
+        self.assertEqual('spamspamspamspam', comprehension[2])
 
     def test_double_list_comprehension(self):
         list_of_eggs = ['poached egg', 'fried egg']
@@ -40,13 +40,13 @@ def test_double_list_comprehension(self):
         comprehension = [ '{0} and {1}'.format(egg, meat) for egg in list_of_eggs for meat in list_of_meats]
 
 
-        self.assertEqual(__, comprehension[0])
-        self.assertEqual(__, len(comprehension))
+        self.assertEqual('poached egg and lite spam', comprehension[0])
+        self.assertEqual(6, len(comprehension))
 
     def test_creating_a_set_with_set_comprehension(self):
         comprehension = { x for x in 'aabbbcccc'}
 
-        self.assertEqual(__, comprehension)  # remember that set members are unique
+        self.assertEqual({'b', 'a', 'c'}, comprehension)  # remember that set members are unique
 
     def test_creating_a_dictionary_with_dictionary_comprehension(self):
         dict_of_weapons = {'first': 'fear', 'second': 'surprise',
@@ -55,7 +55,7 @@ def test_creating_a_dictionary_with_dictionary_comprehension(self):
 
         dict_comprehension = { k.upper(): weapon for k, weapon in dict_of_weapons.items() if weapon}
 
-        self.assertEqual(__, 'first' in dict_comprehension)
-        self.assertEqual(__, 'FIRST' in dict_comprehension)
-        self.assertEqual(__, len(dict_of_weapons))
-        self.assertEqual(__, len(dict_comprehension))
+        self.assertEqual(False, 'first' in dict_comprehension)
+        self.assertEqual(True, 'FIRST' in dict_comprehension)
+        self.assertEqual(5, len(dict_of_weapons))
+        self.assertEqual(4, len(dict_comprehension))

From f86539156d56808749c8e726ab885afa57e8eec1 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sat, 30 Nov 2024 23:54:19 +0800
Subject: [PATCH 33/51] python daily exercise

---
 koans/about_generators.py | 29 +++++++++++++++--------------
 workspace.sublime-project |  5 +++++
 2 files changed, 20 insertions(+), 14 deletions(-)
 create mode 100644 workspace.sublime-project

diff --git a/koans/about_generators.py b/koans/about_generators.py
index a81a43ba6..c26b8fb85 100644
--- a/koans/about_generators.py
+++ b/koans/about_generators.py
@@ -19,7 +19,7 @@ def test_generating_values_on_the_fly(self):
         for bacon in bacon_generator:
             result.append(bacon)
 
-        self.assertEqual(__, result)
+        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)]
@@ -28,9 +28,9 @@ def test_generators_are_different_to_list_comprehensions(self):
         self.assertEqual(2, num_list[0])
 
         # A generator has to be iterated through.
-        with self.assertRaises(___): num = num_generator[0]
+        with self.assertRaises(TypeError): num = num_generator[0]
 
-        self.assertEqual(__, list(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
@@ -44,8 +44,8 @@ def test_generator_expressions_are_a_one_shot_deal(self):
         attempt1 = list(dynamite)
         attempt2 = list(dynamite)
 
-        self.assertEqual(__, attempt1)
-        self.assertEqual(__, attempt2)
+        self.assertEqual(['Boom!', 'Boom!','Boom!'], attempt1)
+        self.assertEqual([], attempt2)
 
     # ------------------------------------------------------------------
 
@@ -59,12 +59,12 @@ def test_generator_method_will_yield_values_during_iteration(self):
         result = list()
         for item in self.simple_generator_method():
             result.append(item)
-        self.assertEqual(__, result)
+        self.assertEqual(['peanut', 'butter', 'and', 'jelly'], result)
 
     def test_generators_can_be_manually_iterated_and_closed(self):
         result = self.simple_generator_method()
-        self.assertEqual(__, next(result))
-        self.assertEqual(__, next(result))
+        self.assertEqual('peanut', next(result))
+        self.assertEqual('butter', next(result))
         result.close()
 
     # ------------------------------------------------------------------
@@ -75,7 +75,7 @@ def square_me(self, seq):
 
     def test_generator_method_with_parameter(self):
         result = self.square_me(range(2,5))
-        self.assertEqual(__, list(result))
+        self.assertEqual([4, 9, 16], list(result))
 
     # ------------------------------------------------------------------
 
@@ -88,7 +88,7 @@ def sum_it(self, seq):
 
     def test_generator_keeps_track_of_local_variables(self):
         result = self.sum_it(range(2,5))
-        self.assertEqual(__, list(result))
+        self.assertEqual([2, 5, 9], list(result))
 
     # ------------------------------------------------------------------
 
@@ -106,7 +106,7 @@ def test_generators_can_act_as_coroutines(self):
         #       section of http://www.python.org/dev/peps/pep-0342/
         next(generator)
 
-        self.assertEqual(__, generator.send(1 + 2))
+        self.assertEqual(3, generator.send(1 + 2))
 
     def test_before_sending_a_value_to_a_generator_next_must_be_called(self):
         generator = self.coroutine()
@@ -114,7 +114,8 @@ def test_before_sending_a_value_to_a_generator_next_must_be_called(self):
         try:
             generator.send(1 + 2)
         except TypeError as ex:
-            self.assertRegex(ex.args[0], __)
+            print(ex.args[0])
+            self.assertRegex(ex.args[0], "can't send non-None value to a just-started generator")
 
     # ------------------------------------------------------------------
 
@@ -132,11 +133,11 @@ def test_generators_can_see_if_they_have_been_called_with_a_value(self):
 
         generator2 = self.yield_tester()
         next(generator2)
-        self.assertEqual(__, 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(__, generator.send(None))
+        self.assertEqual('no value', generator.send(None))
diff --git a/workspace.sublime-project b/workspace.sublime-project
new file mode 100644
index 000000000..38cf8b15d
--- /dev/null
+++ b/workspace.sublime-project
@@ -0,0 +1,5 @@
+{
+    "settings": {
+        "SublimeLinter.enabled": false
+    }
+}
\ No newline at end of file

From 6a0b58e8223b55dfb8c844f5dd32186d374e3c3f Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sun, 1 Dec 2024 20:02:40 +0800
Subject: [PATCH 34/51] Daily python exercise

---
 koans/about_classes.py         | 41 +++++++++++++++++-----------------
 koans/about_lambdas.py         |  8 +++----
 koans/about_scoring_project.py | 18 +++++++++++++--
 3 files changed, 40 insertions(+), 27 deletions(-)

diff --git a/koans/about_classes.py b/koans/about_classes.py
index 22dc4e7f0..592a53064 100644
--- a/koans/about_classes.py
+++ b/koans/about_classes.py
@@ -12,10 +12,10 @@ def test_instances_of_classes_can_be_created_adding_parentheses(self):
         # NOTE: The .__name__ attribute will convert the class
         # into a string value.
         fido = self.Dog()
-        self.assertEqual(__, fido.__class__.__name__)
+        self.assertEqual("Dog", fido.__class__.__name__)
 
     def test_classes_have_docstrings(self):
-        self.assertRegex(self.Dog.__doc__, __)
+        self.assertRegex(self.Dog.__doc__, "Dogs need regular walkies. Never, ever let them drive.")
 
     # ------------------------------------------------------------------
 
@@ -28,12 +28,12 @@ def set_name(self, a_name):
 
     def test_init_method_is_the_constructor(self):
         dog = self.Dog2()
-        self.assertEqual(__, dog._name)
+        self.assertEqual("Paul", dog._name)
 
     def test_private_attributes_are_not_really_private(self):
         dog = self.Dog2()
         dog.set_name("Fido")
-        self.assertEqual(__, dog._name)
+        self.assertEqual("Fido", dog._name)
         # The _ prefix in _name implies private ownership, but nothing is truly
         # private in Python.
 
@@ -41,11 +41,11 @@ def test_you_can_also_access_the_value_out_using_getattr_and_dict(self):
         fido = self.Dog2()
         fido.set_name("Fido")
 
-        self.assertEqual(__, getattr(fido, "_name"))
+        self.assertEqual("Fido", getattr(fido, "_name"))
         # getattr(), setattr() and delattr() are a way of accessing attributes
         # by method rather than through assignment operators
 
-        self.assertEqual(__, fido.__dict__["_name"])
+        self.assertEqual("Fido", fido.__dict__["_name"])
         # Yes, this works here, but don't rely on the __dict__ object! Some
         # class implementations use optimization which result in __dict__ not
         # showing everything.
@@ -69,10 +69,10 @@ def test_that_name_can_be_read_as_a_property(self):
         fido.set_name("Fido")
 
         # access as method
-        self.assertEqual(__, fido.get_name())
+        self.assertEqual("Fido", fido.get_name())
 
         # access as property
-        self.assertEqual(__, fido.name)
+        self.assertEqual("Fido", fido.name)
 
     # ------------------------------------------------------------------
 
@@ -92,7 +92,7 @@ def test_creating_properties_with_decorators_is_slightly_easier(self):
         fido = self.Dog4()
 
         fido.name = "Fido"
-        self.assertEqual(__, fido.name)
+        self.assertEqual("Fido", fido.name)
 
     # ------------------------------------------------------------------
 
@@ -106,10 +106,10 @@ def name(self):
 
     def test_init_provides_initial_values_for_instance_variables(self):
         fido = self.Dog5("Fido")
-        self.assertEqual(__, fido.name)
+        self.assertEqual("Fido", fido.name)
 
     def test_args_must_match_init(self):
-        with self.assertRaises(___):
+        with self.assertRaises(TypeError):
             self.Dog5()
 
         # THINK ABOUT IT:
@@ -119,7 +119,7 @@ def test_different_objects_have_different_instance_variables(self):
         fido = self.Dog5("Fido")
         rover = self.Dog5("Rover")
 
-        self.assertEqual(__, rover.name == fido.name)
+        self.assertEqual(False, rover.name == fido.name)
 
     # ------------------------------------------------------------------
 
@@ -134,15 +134,14 @@ def __str__(self):
             #
             # Implement this!
             #
-            return __
+            return self._name
 
         def __repr__(self):
             return "<Dog named '" + self._name + "'>"
 
     def test_inside_a_method_self_refers_to_the_containing_object(self):
         fido = self.Dog6("Fido")
-
-        self.assertEqual(__, fido.get_self())  # Not a string!
+        self.assertEqual(fido, fido.get_self())  # Not a string!
 
     def test_str_provides_a_string_version_of_the_object(self):
         fido = self.Dog6("Fido")
@@ -152,17 +151,17 @@ def test_str_provides_a_string_version_of_the_object(self):
     def test_str_is_used_explicitly_in_string_interpolation(self):
         fido = self.Dog6("Fido")
 
-        self.assertEqual(__, "My dog is " + str(fido))
+        self.assertEqual("My dog is Fido", "My dog is " + str(fido))
 
     def test_repr_provides_a_more_complete_string_version(self):
         fido = self.Dog6("Fido")
-        self.assertEqual(__, repr(fido))
+        self.assertEqual("<Dog named 'Fido'>", repr(fido))
 
     def test_all_objects_support_str_and_repr(self):
         seq = [1, 2, 3]
 
-        self.assertEqual(__, str(seq))
-        self.assertEqual(__, repr(seq))
+        self.assertEqual("[1, 2, 3]", str(seq))
+        self.assertEqual("[1, 2, 3]", repr(seq))
 
-        self.assertEqual(__, str("STRING"))
-        self.assertEqual(__, repr("STRING"))
+        self.assertEqual('STRING', str("STRING"))
+        self.assertEqual("'STRING'", repr("STRING"))
diff --git a/koans/about_lambdas.py b/koans/about_lambdas.py
index c1e688094..9362853bd 100644
--- a/koans/about_lambdas.py
+++ b/koans/about_lambdas.py
@@ -10,7 +10,7 @@
 class AboutLambdas(Koan):
     def test_lambdas_can_be_assigned_to_variables_and_called_explicitly(self):
         add_one = lambda n: n + 1
-        self.assertEqual(__, add_one(10))
+        self.assertEqual(11, add_one(10))
 
     # ------------------------------------------------------------------
 
@@ -21,8 +21,8 @@ def test_accessing_lambda_via_assignment(self):
         sausages = self.make_order('sausage')
         eggs = self.make_order('egg')
 
-        self.assertEqual(__, sausages(3))
-        self.assertEqual(__, eggs(2))
+        self.assertEqual("3 sausages", sausages(3))
+        self.assertEqual("2 eggs", eggs(2))
 
     def test_accessing_lambda_without_assignment(self):
-        self.assertEqual(__, self.make_order('spam')(39823))
+        self.assertEqual("39823 spams", self.make_order('spam')(39823))
diff --git a/koans/about_scoring_project.py b/koans/about_scoring_project.py
index 0fd055de2..16b4d43e6 100644
--- a/koans/about_scoring_project.py
+++ b/koans/about_scoring_project.py
@@ -33,8 +33,22 @@
 # Your goal is to write the score method.
 
 def score(dice):
-    # You need to write this method
-    pass
+    score = 0
+    counts = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0}
+    for die in dice:
+        counts[die] += 1
+    for die, count in counts.items():
+        if count >= 3:
+            if die == 1:
+                score += 1000
+            else:
+                score += die * 100
+            count -= 3
+        if die == 1:
+            score += count * 100
+        elif die == 5:
+            score += count * 50
+    return score
 
 class AboutScoringProject(Koan):
     def test_score_of_an_empty_list_is_zero(self):

From 1c967ee180c23842494fa3fa278b591f8bce0b22 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Tue, 3 Dec 2024 23:03:52 +0800
Subject: [PATCH 35/51] Python daily exercise

---
 koans/about_with_statements.py | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/koans/about_with_statements.py b/koans/about_with_statements.py
index 0ae9b5ff8..3eccfbf30 100644
--- a/koans/about_with_statements.py
+++ b/koans/about_with_statements.py
@@ -22,7 +22,7 @@ def count_lines(self, file_name):
             self.fail()
 
     def test_counting_lines(self):
-        self.assertEqual(__, self.count_lines("example_file.txt"))
+        self.assertEqual(4, self.count_lines("example_file.txt"))
 
     # ------------------------------------------------------------------
 
@@ -41,7 +41,7 @@ def find_line(self, file_name):
             self.fail()
 
     def test_finding_lines(self):
-        self.assertEqual(__, self.find_line("example_file.txt"))
+        self.assertEqual("test\n", self.find_line("example_file.txt"))
 
     ## ------------------------------------------------------------------
     ## THINK ABOUT IT:
@@ -85,13 +85,21 @@ def count_lines2(self, file_name):
             return len(file.readlines())
 
     def test_counting_lines2(self):
-        self.assertEqual(__, self.count_lines2("example_file.txt"))
+        self.assertEqual(4, self.count_lines2("example_file.txt"))
 
     # ------------------------------------------------------------------
 
     def find_line2(self, file_name):
         # Using the context manager self.FileContextManager, rewrite this
         # function to return the first line containing the letter 'e'.
+
+        with self.FileContextManager(file_name) as file:
+            for line in file.readlines():
+                match = re.search('e', line)
+                if match:
+                    return line
+
+
         return None
 
     def test_finding_lines2(self):
@@ -105,4 +113,4 @@ def count_lines3(self, file_name):
             return len(file.readlines())
 
     def test_open_already_has_its_own_built_in_context_manager(self):
-        self.assertEqual(__, self.count_lines3("example_file.txt"))
+        self.assertEqual(4, self.count_lines3("example_file.txt"))

From fdd2bae4c6b6a233fcf7915be1769f57d0646d07 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Wed, 4 Dec 2024 22:28:42 +0800
Subject: [PATCH 36/51] python daily exercise

---
 koans/about_monkey_patching.py | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/koans/about_monkey_patching.py b/koans/about_monkey_patching.py
index bdea2b8b9..c090fd1fd 100644
--- a/koans/about_monkey_patching.py
+++ b/koans/about_monkey_patching.py
@@ -14,7 +14,7 @@ def bark(self):
 
     def test_as_defined_dogs_do_bark(self):
         fido = self.Dog()
-        self.assertEqual(__, fido.bark())
+        self.assertEqual("WOOF", fido.bark())
 
     # ------------------------------------------------------------------
 
@@ -24,8 +24,8 @@ def wag(self): return "HAPPY"
         self.Dog.wag = wag
 
         fido = self.Dog()
-        self.assertEqual(__, fido.wag())
-        self.assertEqual(__, fido.bark())
+        self.assertEqual("HAPPY", fido.wag())
+        self.assertEqual("WOOF", fido.bark())
 
     # ------------------------------------------------------------------
 
@@ -34,8 +34,7 @@ def test_most_built_in_classes_cannot_be_monkey_patched(self):
             int.is_even = lambda self: (self % 2) == 0
         except Exception as ex:
             err_msg = ex.args[0]
-
-        self.assertRegex(err_msg, __)
+        self.assertRegex(err_msg, "cannot set 'is_even' attribute of immutable type 'int'")
 
     # ------------------------------------------------------------------
 
@@ -44,5 +43,5 @@ class MyInt(int): pass
     def test_subclasses_of_built_in_classes_can_be_be_monkey_patched(self):
         self.MyInt.is_even = lambda self: (self % 2) == 0
 
-        self.assertEqual(__, self.MyInt(1).is_even())
-        self.assertEqual(__, self.MyInt(2).is_even())
+        self.assertEqual(False, self.MyInt(1).is_even())
+        self.assertEqual(True, self.MyInt(2).is_even())

From 37730e99b047b27f8bf11e77e2fd7e7f5aa27549 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Thu, 5 Dec 2024 21:48:28 +0800
Subject: [PATCH 37/51] daily python exercise

---
 koans/about_dice_project.py    |  3 ++-
 koans/about_method_bindings.py | 28 ++++++++++++++--------------
 2 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/koans/about_dice_project.py b/koans/about_dice_project.py
index 27bc54a24..ddccf31b5 100644
--- a/koans/about_dice_project.py
+++ b/koans/about_dice_project.py
@@ -16,7 +16,8 @@ def values(self):
     def roll(self, n):
         # Needs implementing!
         # Tip: random.randint(min, max) can be used to generate random numbers
-        pass
+        self._values = [random.randint(1, 6) for _ in range(n)]
+
 
 class AboutDiceProject(Koan):
     def test_can_create_a_dice_set(self):
diff --git a/koans/about_method_bindings.py b/koans/about_method_bindings.py
index 020851bd5..47313bcda 100644
--- a/koans/about_method_bindings.py
+++ b/koans/about_method_bindings.py
@@ -16,42 +16,42 @@ def method(self):
 class AboutMethodBindings(Koan):
     def test_methods_are_bound_to_an_object(self):
         obj = Class()
-        self.assertEqual(__, obj.method.__self__ == obj)
+        self.assertEqual(True, obj.method.__self__ == obj)
 
     def test_methods_are_also_bound_to_a_function(self):
         obj = Class()
-        self.assertEqual(__, obj.method())
-        self.assertEqual(__, obj.method.__func__(obj))
+        self.assertEqual("parrot", obj.method())
+        self.assertEqual("parrot", obj.method.__func__(obj))
 
     def test_functions_have_attributes(self):
         obj = Class()
-        self.assertEqual(__, len(dir(function)))
-        self.assertEqual(__, dir(function) == dir(obj.method.__func__))
+        self.assertEqual(36, len(dir(function)))
+        self.assertEqual(True, dir(function) == dir(obj.method.__func__))
 
     def test_methods_have_different_attributes(self):
         obj = Class()
-        self.assertEqual(__, len(dir(obj.method)))
+        self.assertEqual(27, len(dir(obj.method)))
 
     def test_setting_attributes_on_an_unbound_function(self):
         function.cherries = 3
-        self.assertEqual(__, function.cherries)
+        self.assertEqual(3, function.cherries)
 
     def test_setting_attributes_on_a_bound_method_directly(self):
         obj = Class()
-        with self.assertRaises(___): obj.method.cherries = 3
+        with self.assertRaises(AttributeError): obj.method.cherries = 3
 
     def test_setting_attributes_on_methods_by_accessing_the_inner_function(self):
         obj = Class()
         obj.method.__func__.cherries = 3
-        self.assertEqual(__, obj.method.cherries)
+        self.assertEqual(3, obj.method.cherries)
 
     def test_functions_can_have_inner_functions(self):
         function2.get_fruit = function
-        self.assertEqual(__, function2.get_fruit())
+        self.assertEqual("pineapple", function2.get_fruit())
 
     def test_inner_functions_are_unbound(self):
         function2.get_fruit = function
-        with self.assertRaises(___): cls = function2.get_fruit.__self__
+        with self.assertRaises(AttributeError): cls = function2.get_fruit.__self__
 
     # ------------------------------------------------------------------
 
@@ -68,8 +68,8 @@ def test_get_descriptor_resolves_attribute_binding(self):
         #   binding_owner = obj
         #   owner_type = cls
 
-        self.assertEqual(__, bound_obj.__class__.__name__)
-        self.assertEqual(__, binding_owner.__class__.__name__)
+        self.assertEqual("BoundClass", bound_obj.__class__.__name__)
+        self.assertEqual("AboutMethodBindings", binding_owner.__class__.__name__)
         self.assertEqual(AboutMethodBindings, owner_type)
 
     # ------------------------------------------------------------------
@@ -86,5 +86,5 @@ def __set__(self, obj, val):
     def test_set_descriptor_changes_behavior_of_attribute_assignment(self):
         self.assertEqual(None, self.color.choice)
         self.color = 'purple'
-        self.assertEqual(__, self.color.choice)
+        self.assertEqual('purple', self.color.choice)
 

From 0ce471a4a4ce4bdfd3ac9ac741e3baeefaba8946 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Fri, 6 Dec 2024 09:01:06 +0800
Subject: [PATCH 38/51] daily python exercise

---
 koans/about_decorating_with_functions.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/koans/about_decorating_with_functions.py b/koans/about_decorating_with_functions.py
index a51260213..67c5beaaf 100644
--- a/koans/about_decorating_with_functions.py
+++ b/koans/about_decorating_with_functions.py
@@ -14,8 +14,8 @@ def mediocre_song(self):
         return "o/~ We all live in a broken submarine o/~"
 
     def test_decorators_can_modify_a_function(self):
-        self.assertRegex(self.mediocre_song(), __)
-        self.assertEqual(__, self.mediocre_song.wow_factor)
+        self.assertRegex(self.mediocre_song(), "o/~ We all live in a broken submarine o/~")
+        self.assertEqual('COWBELL BABY!', self.mediocre_song.wow_factor)
 
     # ------------------------------------------------------------------
 
@@ -29,4 +29,4 @@ def render_tag(self, name):
         return name
 
     def test_decorators_can_change_a_function_output(self):
-        self.assertEqual(__, self.render_tag('llama'))
+        self.assertEqual('<llama/>', self.render_tag('llama'))

From 995e3aa4f2e1112a3549e38c6b5858c1466a9ded Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Fri, 6 Dec 2024 18:00:17 +0800
Subject: [PATCH 39/51] python daily exercise

---
 koans/about_decorating_with_classes.py | 28 +++++++++++++-------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/koans/about_decorating_with_classes.py b/koans/about_decorating_with_classes.py
index 00bd5fe90..5ec6da294 100644
--- a/koans/about_decorating_with_classes.py
+++ b/koans/about_decorating_with_classes.py
@@ -19,21 +19,21 @@ def test_partial_that_wrappers_no_args(self):
         """
         max = functools.partial(self.maximum)
 
-        self.assertEqual(__, max(7,23))
-        self.assertEqual(__, max(10,-10))
+        self.assertEqual(23, max(7,23))
+        self.assertEqual(10, max(10,-10))
 
     def test_partial_that_wrappers_first_arg(self):
         max0 = functools.partial(self.maximum, 0)
 
-        self.assertEqual(__, max0(-4))
-        self.assertEqual(__, max0(5))
+        self.assertEqual(0, max0(-4))
+        self.assertEqual(5, max0(5))
 
     def test_partial_that_wrappers_all_args(self):
         always99 = functools.partial(self.maximum, 99, 20)
         always20 = functools.partial(self.maximum, 9, 20)
 
-        self.assertEqual(__, always99())
-        self.assertEqual(__, always20())
+        self.assertEqual(99, always99())
+        self.assertEqual(20, always20())
 
     # ------------------------------------------------------------------
 
@@ -64,8 +64,8 @@ def test_decorator_with_no_arguments(self):
         # To clarify: the decorator above the function has no arguments, even
         # if the decorated function does
 
-        self.assertEqual(__, self.foo())
-        self.assertEqual(__, self.parrot('pieces of eight'))
+        self.assertEqual("foo, foo", self.foo())
+        self.assertEqual('PIECES OF EIGHT, PIECES OF EIGHT', self.parrot('pieces of eight'))
 
     # ------------------------------------------------------------------
 
@@ -77,7 +77,7 @@ def test_what_a_decorator_is_doing_to_a_function(self):
         #wrap the function with the decorator
         self.sound_check = self.doubleit(self.sound_check)
 
-        self.assertEqual(__, self.sound_check())
+        self.assertEqual("Testing..., Testing...", self.sound_check())
 
     # ------------------------------------------------------------------
 
@@ -108,11 +108,11 @@ def idler(self, num):
         pass
 
     def test_decorator_with_an_argument(self):
-        self.assertEqual(__, self.count_badly(2))
-        self.assertEqual(__, self.count_badly.__doc__)
+        self.assertEqual(5, self.count_badly(2))
+        self.assertEqual("Increments a value by one. Kind of.", self.count_badly.__doc__)
 
     def test_documentor_which_already_has_a_docstring(self):
-        self.assertEqual(__, self.idler.__doc__)
+        self.assertEqual('Idler: Does nothing', self.idler.__doc__)
 
     # ------------------------------------------------------------------
 
@@ -123,6 +123,6 @@ def homer(self):
         return "D'oh"
 
     def test_we_can_chain_decorators(self):
-        self.assertEqual(__, self.homer())
-        self.assertEqual(__, self.homer.__doc__)
+        self.assertEqual("D'oh, D'oh, D'oh, D'oh", self.homer())
+        self.assertEqual('DOH!', self.homer.__doc__)
 

From a0bafd7384ad4e8aad21df254553eb647810018c Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Tue, 10 Dec 2024 21:23:28 +0800
Subject: [PATCH 40/51] python daily exercise

---
 koans/about_inheritance.py          | 22 +++++++++++-----------
 koans/about_multiple_inheritance.py | 22 +++++++++++-----------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/koans/about_inheritance.py b/koans/about_inheritance.py
index 5d2407dfa..9a378571c 100644
--- a/koans/about_inheritance.py
+++ b/koans/about_inheritance.py
@@ -23,31 +23,31 @@ def bark(self):
             return "yip"
 
     def test_subclasses_have_the_parent_as_an_ancestor(self):
-        self.assertEqual(__, issubclass(self.Chihuahua, self.Dog))
+        self.assertEqual(True, issubclass(self.Chihuahua, self.Dog))
 
     def test_all_classes_in_python_3_ultimately_inherit_from_object_class(self):
-        self.assertEqual(__, issubclass(self.Chihuahua, object))
+        self.assertEqual(True, issubclass(self.Chihuahua, object))
 
         # Note: This isn't the case in Python 2. In that version you have
         # to inherit from a built in class or object explicitly
 
     def test_instances_inherit_behavior_from_parent_class(self):
         chico = self.Chihuahua("Chico")
-        self.assertEqual(__, chico.name)
+        self.assertEqual("Chico", chico.name)
 
     def test_subclasses_add_new_behavior(self):
         chico = self.Chihuahua("Chico")
-        self.assertEqual(__, chico.wag())
+        self.assertEqual("happy", chico.wag())
 
         fido = self.Dog("Fido")
-        with self.assertRaises(___): fido.wag()
+        with self.assertRaises(AttributeError): fido.wag()
 
     def test_subclasses_can_modify_existing_behavior(self):
         chico = self.Chihuahua("Chico")
-        self.assertEqual(__, chico.bark())
+        self.assertEqual("yip", chico.bark())
 
         fido = self.Dog("Fido")
-        self.assertEqual(__, fido.bark())
+        self.assertEqual("WOOF", fido.bark())
 
     # ------------------------------------------------------------------
 
@@ -58,7 +58,7 @@ def bark(self):
 
     def test_subclasses_can_invoke_parent_behavior_via_super(self):
         ralph = self.BullDog("Ralph")
-        self.assertEqual(__, ralph.bark())
+        self.assertEqual("WOOF, GRR", ralph.bark())
 
     # ------------------------------------------------------------------
 
@@ -68,7 +68,7 @@ def growl(self):
 
     def test_super_works_across_methods(self):
         george = self.GreatDane("George")
-        self.assertEqual(__, george.growl())
+        self.assertEqual('WOOF, GROWL', george.growl())
 
     # ---------------------------------------------------------
 
@@ -82,8 +82,8 @@ def __init__(self, name):
 
     def test_base_init_does_not_get_called_automatically(self):
         snoopy = self.Pug("Snoopy")
-        with self.assertRaises(___): name = snoopy.name
+        with self.assertRaises(AttributeError): name = snoopy.name
 
     def test_base_init_has_to_be_called_explicitly(self):
         boxer = self.Greyhound("Boxer")
-        self.assertEqual(__, boxer.name)
+        self.assertEqual("Boxer", boxer.name)
diff --git a/koans/about_multiple_inheritance.py b/koans/about_multiple_inheritance.py
index 4227f7eb9..552b3d06d 100644
--- a/koans/about_multiple_inheritance.py
+++ b/koans/about_multiple_inheritance.py
@@ -87,7 +87,7 @@ def here(self):
 
     def test_normal_methods_are_available_in_the_object(self):
         jeff = self.Spiderpig()
-        self.assertRegex(jeff.speak(), __)
+        self.assertRegex(jeff.speak(), "This looks like a job for Spiderpig!")
 
     def test_base_class_methods_are_also_available_in_the_object(self):
         jeff = self.Spiderpig()
@@ -95,22 +95,22 @@ def test_base_class_methods_are_also_available_in_the_object(self):
             jeff.set_name("Rover")
         except:
             self.fail("This should not happen")
-        self.assertEqual(__, jeff.can_climb_walls())
+        self.assertEqual(True, jeff.can_climb_walls())
 
     def test_base_class_methods_can_affect_instance_variables_in_the_object(self):
         jeff = self.Spiderpig()
-        self.assertEqual(__, jeff.name)
+        self.assertEqual('Jeff', jeff.name)
 
         jeff.set_name("Rover")
-        self.assertEqual(__, jeff.name)
+        self.assertEqual('Rover', jeff.name)
 
     def test_left_hand_side_inheritance_tends_to_be_higher_priority(self):
         jeff = self.Spiderpig()
-        self.assertEqual(__, jeff.color())
+        self.assertEqual('pink', jeff.color())
 
     def test_super_class_methods_are_higher_priority_than_super_super_classes(self):
         jeff = self.Spiderpig()
-        self.assertEqual(__, jeff.legs())
+        self.assertEqual(8, jeff.legs())
 
     def test_we_can_inspect_the_method_resolution_order(self):
         #
@@ -119,10 +119,10 @@ def test_we_can_inspect_the_method_resolution_order(self):
         mro = type(self.Spiderpig()).mro()
         self.assertEqual('Spiderpig', mro[0].__name__)
         self.assertEqual('Pig', mro[1].__name__)
-        self.assertEqual(__, mro[2].__name__)
-        self.assertEqual(__, mro[3].__name__)
-        self.assertEqual(__, mro[4].__name__)
-        self.assertEqual(__, mro[5].__name__)
+        self.assertEqual('Spider', mro[2].__name__)
+        self.assertEqual('Animal', mro[3].__name__)
+        self.assertEqual('Nameable', mro[4].__name__)
+        self.assertEqual('object', mro[5].__name__)
 
     def test_confirm_the_mro_controls_the_calling_order(self):
         jeff = self.Spiderpig()
@@ -132,7 +132,7 @@ def test_confirm_the_mro_controls_the_calling_order(self):
         self.assertRegex(next.here(), 'Pig')
 
         next = super(AboutMultipleInheritance.Pig, jeff)
-        self.assertRegex(next.here(), __)
+        self.assertRegex(next.here(), 'Spider')
 
         # Hang on a minute?!? That last class name might be a super class of
         # the 'jeff' object, but its hardly a superclass of Pig, is it?

From 2fd09a7402615abfe61931b533a3243c8ea1e550 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Wed, 11 Dec 2024 23:31:23 +0800
Subject: [PATCH 41/51] python daily exercise

---
 koans/about_scope.py | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/koans/about_scope.py b/koans/about_scope.py
index a9cf2a168..5eae9e49f 100644
--- a/koans/about_scope.py
+++ b/koans/about_scope.py
@@ -16,18 +16,18 @@ class AboutScope(Koan):
     #
 
     def test_dog_is_not_available_in_the_current_scope(self):
-        with self.assertRaises(___): fido = Dog()
+        with self.assertRaises(NameError): fido = Dog()
 
     def test_you_can_reference_nested_classes_using_the_scope_operator(self):
         fido = jims.Dog()
         # name 'jims' module name is taken from jims.py filename
 
         rover = joes.Dog()
-        self.assertEqual(__, fido.identify())
-        self.assertEqual(__, rover.identify())
+        self.assertEqual("jims dog", fido.identify())
+        self.assertEqual('joes dog', rover.identify())
 
-        self.assertEqual(__, type(fido) == type(rover))
-        self.assertEqual(__, jims.Dog == joes.Dog)
+        self.assertEqual(False, type(fido) == type(rover))
+        self.assertEqual(False, jims.Dog == joes.Dog)
 
     # ------------------------------------------------------------------
 
@@ -35,26 +35,26 @@ class str:
         pass
 
     def test_bare_bones_class_names_do_not_assume_the_current_scope(self):
-        self.assertEqual(__, AboutScope.str == str)
+        self.assertEqual(False, AboutScope.str == str)
 
     def test_nested_string_is_not_the_same_as_the_system_string(self):
-        self.assertEqual(__, self.str == type("HI"))
+        self.assertEqual(False, self.str == type("HI"))
 
     def test_str_without_self_prefix_stays_in_the_global_scope(self):
-        self.assertEqual(__, str == type("HI"))
+        self.assertEqual(True, str == type("HI"))
 
     # ------------------------------------------------------------------
 
     PI = 3.1416
 
     def test_constants_are_defined_with_an_initial_uppercase_letter(self):
-        self.assertAlmostEqual(_____, self.PI)
+        self.assertAlmostEqual(3.1416, self.PI)
         # Note, floating point numbers in python are not precise.
         # assertAlmostEqual will check that it is 'close enough'
 
     def test_constants_are_assumed_by_convention_only(self):
         self.PI = "rhubarb"
-        self.assertEqual(_____, self.PI)
+        self.assertEqual('rhubarb', self.PI)
         # There aren't any real constants in python. Its up to the developer
         # to keep to the convention and not modify them.
 
@@ -71,13 +71,13 @@ def test_incrementing_with_local_counter(self):
         global counter
         start = counter
         self.increment_using_local_counter(start)
-        self.assertEqual(__, counter == start + 1)
+        self.assertEqual(False, counter == start + 1)
 
     def test_incrementing_with_global_counter(self):
         global counter
         start = counter
         self.increment_using_global_counter()
-        self.assertEqual(__, counter == start + 1)
+        self.assertEqual(True, counter == start + 1)
 
     # ------------------------------------------------------------------
 
@@ -96,10 +96,10 @@ def from_the_boosh():
         return from_the_boosh()
 
     def test_getting_something_locally(self):
-        self.assertEqual(__, self.local_access())
+        self.assertEqual('this is a local shop for local people', self.local_access())
 
     def test_getting_something_nonlocally(self):
-        self.assertEqual(__, self.nonlocal_access())
+        self.assertEqual('eels', self.nonlocal_access())
 
     # ------------------------------------------------------------------
 
@@ -107,4 +107,4 @@ def test_getting_something_nonlocally(self):
     deadly_bingo = [4, 8, 15, 16, 23, 42]
 
     def test_global_attributes_can_be_created_in_the_middle_of_a_class(self):
-        self.assertEqual(__, deadly_bingo[5])
+        self.assertEqual(42, deadly_bingo[5])

From e052380ab18b850b588f7bcb3b721caadb26dfa9 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sun, 15 Dec 2024 03:09:43 +0800
Subject: [PATCH 42/51] daily python exercise

---
 koans/about_modules.py        | 22 +++++++++++-----------
 koans/about_scope.py          |  5 +++--
 koans/another_local_module.py |  2 +-
 3 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/koans/about_modules.py b/koans/about_modules.py
index 7a266171d..0a66cc2c9 100644
--- a/koans/about_modules.py
+++ b/koans/about_modules.py
@@ -17,21 +17,21 @@ def test_importing_other_python_scripts_as_modules(self):
         from . import local_module  # local_module.py
 
         duck = local_module.Duck()
-        self.assertEqual(__, duck.name)
+        self.assertEqual("Daffy", duck.name)
 
     def test_importing_attributes_from_classes_using_from_keyword(self):
         from .local_module import Duck
 
         duck = Duck()  # no module qualifier needed this time
-        self.assertEqual(__, duck.name)
+        self.assertEqual("Daffy", duck.name)
 
     def test_we_can_import_multiple_items_at_once(self):
         from . import jims, joes
 
         jims_dog = jims.Dog()
         joes_dog = joes.Dog()
-        self.assertEqual(__, jims_dog.identify())
-        self.assertEqual(__, joes_dog.identify())
+        self.assertEqual("jims dog", jims_dog.identify())
+        self.assertEqual("joes dog", joes_dog.identify())
 
     def test_importing_all_module_attributes_at_once(self):
         """
@@ -43,18 +43,18 @@ def test_importing_all_module_attributes_at_once(self):
         goose = Goose()
         hamster = Hamster()
 
-        self.assertEqual(__, goose.name)
-        self.assertEqual(__, hamster.name)
+        self.assertEqual("Mr Stabby", goose.name)
+        self.assertEqual("Phil", hamster.name)
 
     def test_modules_hide_attributes_prefixed_by_underscores(self):
-        with self.assertRaises(___):
+        with self.assertRaises(NameError):
             private_squirrel = _SecretSquirrel()
 
     def test_private_attributes_are_still_accessible_in_modules(self):
         from .local_module import Duck  # local_module.py
 
         duck = Duck()
-        self.assertEqual(__, duck._password)
+        self.assertEqual('password', duck._password)
         # module level attribute hiding doesn't affect class attributes
         # (unless the class itself is hidden).
 
@@ -66,12 +66,12 @@ def test_a_module_can_limit_wildcard_imports(self):
 
         # 'Goat' is on the __all__ list
         goat = Goat()
-        self.assertEqual(__, goat.name)
+        self.assertEqual('George', goat.name)
 
         # How about velociraptors?
         lizard = _Velociraptor()
-        self.assertEqual(__, lizard.name)
+        self.assertEqual("Cuddles", lizard.name)
 
         # SecretDuck? Never heard of her!
-        with self.assertRaises(___):
+        with self.assertRaises(NameError):
             duck = SecretDuck()
diff --git a/koans/about_scope.py b/koans/about_scope.py
index 5eae9e49f..20667c82e 100644
--- a/koans/about_scope.py
+++ b/koans/about_scope.py
@@ -24,7 +24,7 @@ def test_you_can_reference_nested_classes_using_the_scope_operator(self):
 
         rover = joes.Dog()
         self.assertEqual("jims dog", fido.identify())
-        self.assertEqual('joes dog', rover.identify())
+        self.assertEqual("joes dog", rover.identify())
 
         self.assertEqual(False, type(fido) == type(rover))
         self.assertEqual(False, jims.Dog == joes.Dog)
@@ -54,7 +54,7 @@ def test_constants_are_defined_with_an_initial_uppercase_letter(self):
 
     def test_constants_are_assumed_by_convention_only(self):
         self.PI = "rhubarb"
-        self.assertEqual('rhubarb', self.PI)
+        self.assertEqual("rhubarb", self.PI)
         # There aren't any real constants in python. Its up to the developer
         # to keep to the convention and not modify them.
 
@@ -77,6 +77,7 @@ def test_incrementing_with_global_counter(self):
         global counter
         start = counter
         self.increment_using_global_counter()
+
         self.assertEqual(True, counter == start + 1)
 
     # ------------------------------------------------------------------
diff --git a/koans/another_local_module.py b/koans/another_local_module.py
index 242daaa79..44c235c8f 100644
--- a/koans/another_local_module.py
+++ b/koans/another_local_module.py
@@ -14,4 +14,4 @@ def name(self):
 class _SecretSquirrel:
     @property
     def name(self):
-        return "Mr Anonymous"
\ No newline at end of file
+        return "Mr Anonymous"

From 62b0e201e0c2c2129ec0e83286135cbc7cf48750 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Mon, 16 Dec 2024 06:30:06 +0800
Subject: [PATCH 43/51] python daily exercise

---
 koans/about_class_attributes.py | 44 ++++++++++++++++-----------------
 koans/about_packages.py         |  8 +++---
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/koans/about_class_attributes.py b/koans/about_class_attributes.py
index 7a5be1df4..cbd3db6d8 100644
--- a/koans/about_class_attributes.py
+++ b/koans/about_class_attributes.py
@@ -13,36 +13,36 @@ class Dog:
 
     def test_objects_are_objects(self):
         fido = self.Dog()
-        self.assertEqual(__, isinstance(fido, object))
+        self.assertEqual(True, isinstance(fido, object))
 
     def test_classes_are_types(self):
-        self.assertEqual(__, self.Dog.__class__ == type)
+        self.assertEqual(True, self.Dog.__class__ == type)
 
     def test_classes_are_objects_too(self):
-        self.assertEqual(__, issubclass(self.Dog, object))
+        self.assertEqual(True, issubclass(self.Dog, object))
 
     def test_objects_have_methods(self):
         fido = self.Dog()
-        self.assertEqual(__, len(dir(fido)))
+        self.assertEqual(26, len(dir(fido)))
 
     def test_classes_have_methods(self):
-        self.assertEqual(__, len(dir(self.Dog)))
+        self.assertEqual(26, len(dir(self.Dog)))
 
     def test_creating_objects_without_defining_a_class(self):
         singularity = object()
-        self.assertEqual(__, len(dir(singularity)))
+        self.assertEqual(23, len(dir(singularity)))
 
     def test_defining_attributes_on_individual_objects(self):
         fido = self.Dog()
         fido.legs = 4
 
-        self.assertEqual(__, fido.legs)
+        self.assertEqual(4, fido.legs)
 
     def test_defining_functions_on_individual_objects(self):
         fido = self.Dog()
         fido.wag = lambda : 'fidos wag'
 
-        self.assertEqual(__, fido.wag())
+        self.assertEqual('fidos wag', fido.wag())
 
     def test_other_objects_are_not_affected_by_these_singleton_functions(self):
         fido = self.Dog()
@@ -52,7 +52,7 @@ def wag():
             return 'fidos wag'
         fido.wag = wag
 
-        with self.assertRaises(___): rover.wag()
+        with self.assertRaises(AttributeError): rover.wag()
 
     # ------------------------------------------------------------------
 
@@ -75,19 +75,19 @@ def growl(cls):
             return "classmethod growl, arg: cls=" + cls.__name__
 
     def test_since_classes_are_objects_you_can_define_singleton_methods_on_them_too(self):
-        self.assertRegex(self.Dog2.growl(), __)
+        self.assertRegex(self.Dog2.growl(), 'classmethod growl, arg: cls=Dog2')
 
     def test_classmethods_are_not_independent_of_instance_methods(self):
         fido = self.Dog2()
-        self.assertRegex(fido.growl(), __)
-        self.assertRegex(self.Dog2.growl(), __)
+        self.assertRegex(fido.growl(), 'classmethod growl, arg: cls=Dog2')
+        self.assertRegex(self.Dog2.growl(), 'classmethod growl, arg: cls=Dog2')
 
     def test_staticmethods_are_unbound_functions_housed_in_a_class(self):
-        self.assertRegex(self.Dog2.bark(), __)
+        self.assertRegex(self.Dog2.bark(), "staticmethod bark, arg: None")
 
     def test_staticmethods_also_overshadow_instance_methods(self):
         fido = self.Dog2()
-        self.assertRegex(fido.bark(), __)
+        self.assertRegex(fido.bark(), 'staticmethod bark, arg: None')
 
     # ------------------------------------------------------------------
 
@@ -114,20 +114,20 @@ def set_name(cls, name):
 
     def test_classmethods_can_not_be_used_as_properties(self):
         fido = self.Dog3()
-        with self.assertRaises(___): fido.name = "Fido"
+        with self.assertRaises(TypeError): fido.name = "Fido"
 
     def test_classes_and_instances_do_not_share_instance_attributes(self):
         fido = self.Dog3()
         fido.set_name_from_instance("Fido")
         fido.set_name("Rover")
-        self.assertEqual(__, fido.get_name_from_instance())
-        self.assertEqual(__, self.Dog3.get_name())
+        self.assertEqual('Fido', fido.get_name_from_instance())
+        self.assertEqual('Rover', self.Dog3.get_name())
 
     def test_classes_and_instances_do_share_class_attributes(self):
         fido = self.Dog3()
         fido.set_name("Fido")
-        self.assertEqual(__, fido.get_name())
-        self.assertEqual(__, self.Dog3.get_name())
+        self.assertEqual('Fido', fido.get_name())
+        self.assertEqual('Fido', self.Dog3.get_name())
 
     # ------------------------------------------------------------------
 
@@ -142,13 +142,13 @@ def a_static_method():
         a_static_method = staticmethod(a_static_method)
 
     def test_you_can_define_class_methods_without_using_a_decorator(self):
-        self.assertEqual(__, self.Dog4.a_class_method())
+        self.assertEqual('dogs class method', self.Dog4.a_class_method())
 
     def test_you_can_define_static_methods_without_using_a_decorator(self):
-        self.assertEqual(__, self.Dog4.a_static_method())
+        self.assertEqual('dogs static method', self.Dog4.a_static_method())
 
     # ------------------------------------------------------------------
 
     def test_heres_an_easy_way_to_explicitly_call_class_methods_from_instance_methods(self):
         fido = self.Dog4()
-        self.assertEqual(__, fido.__class__.a_class_method())
+        self.assertEqual('dogs class method', fido.__class__.a_class_method())
diff --git a/koans/about_packages.py b/koans/about_packages.py
index 69288a1c8..999cb7fb8 100644
--- a/koans/about_packages.py
+++ b/koans/about_packages.py
@@ -29,13 +29,13 @@ def test_subfolders_can_form_part_of_a_module_package(self):
         from .a_package_folder.a_module import Duck
 
         duck = Duck()
-        self.assertEqual(__, duck.name)
+        self.assertEqual("Donald", duck.name)
 
     def test_subfolders_become_modules_if_they_have_an_init_module(self):
         # Import ./a_package_folder/__init__.py
         from .a_package_folder import an_attribute
 
-        self.assertEqual(__, an_attribute)
+        self.assertEqual(1984, an_attribute)
 
     # ------------------------------------------------------------------
 
@@ -43,7 +43,7 @@ def test_use_absolute_imports_to_import_upper_level_modules(self):
         # Import /contemplate_koans.py
         import contemplate_koans
 
-        self.assertEqual(__, contemplate_koans.__name__)
+        self.assertEqual('contemplate_koans', contemplate_koans.__name__)
 
         # contemplate_koans.py is the root module in this package because it's
         # the first python module called in koans.
@@ -57,4 +57,4 @@ def test_import_a_module_in_a_subfolder_folder_using_an_absolute_path(self):
         # Import contemplate_koans.py/koans/a_package_folder/a_module.py
         from koans.a_package_folder.a_module import Duck
 
-        self.assertEqual(__, Duck.__module__)
+        self.assertEqual('koans.a_package_folder.a_module', Duck.__module__)

From 7eb9522f2089d358447adce3ff751d0c8670a80f Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Fri, 20 Dec 2024 22:06:08 +0800
Subject: [PATCH 44/51] python daily exervise

---
 koans/about_attribute_access.py | 36 ++++++++++++++++-----------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/koans/about_attribute_access.py b/koans/about_attribute_access.py
index f12f61143..ea89fefa7 100644
--- a/koans/about_attribute_access.py
+++ b/koans/about_attribute_access.py
@@ -15,12 +15,12 @@ class TypicalObject:
     def test_calling_undefined_functions_normally_results_in_errors(self):
         typical = self.TypicalObject()
 
-        with self.assertRaises(___): typical.foobar()
+        with self.assertRaises(AttributeError): typical.foobar()
 
     def test_calling_getattribute_causes_an_attribute_error(self):
         typical = self.TypicalObject()
 
-        with self.assertRaises(___): typical.__getattribute__('foobar')
+        with self.assertRaises(AttributeError): typical.__getattribute__('foobar')
 
         # THINK ABOUT IT:
         #
@@ -36,19 +36,19 @@ def __getattribute__(self, attr_name):
     def test_all_attribute_reads_are_caught(self):
         catcher = self.CatchAllAttributeReads()
 
-        self.assertRegex(catcher.foobar, __)
+        self.assertRegex(catcher.foobar, "Someone called 'foobar' and it could not be found")
 
     def test_intercepting_return_values_can_disrupt_the_call_chain(self):
         catcher = self.CatchAllAttributeReads()
 
-        self.assertRegex(catcher.foobaz, __) # This is fine
+        self.assertRegex(catcher.foobaz,  "Someone called 'foobaz' and it could not be found") # This is fine
 
         try:
             catcher.foobaz(1)
         except TypeError as ex:
             err_msg = ex.args[0]
 
-        self.assertRegex(err_msg, __)
+        self.assertRegex(err_msg, "'str' object is not callable")
 
         # foobaz returns a string. What happens to the '(1)' part?
         # Try entering this into a python console to reproduce the issue:
@@ -59,7 +59,7 @@ def test_intercepting_return_values_can_disrupt_the_call_chain(self):
     def test_changes_to_the_getattribute_implementation_affects_getattr_function(self):
         catcher = self.CatchAllAttributeReads()
 
-        self.assertRegex(getattr(catcher, 'any_attribute'), __)
+        self.assertRegex(getattr(catcher, 'any_attribute'), "Someone called 'any_attribute' and it could not be found")
 
     # ------------------------------------------------------------------
 
@@ -73,13 +73,13 @@ def __getattribute__(self, attr_name):
     def test_foo_attributes_are_caught(self):
         catcher = self.WellBehavedFooCatcher()
 
-        self.assertEqual(__, catcher.foo_bar)
-        self.assertEqual(__, catcher.foo_baz)
+        self.assertEqual('Foo to you too', catcher.foo_bar)
+        self.assertEqual('Foo to you too', catcher.foo_baz)
 
     def test_non_foo_messages_are_treated_normally(self):
         catcher = self.WellBehavedFooCatcher()
 
-        with self.assertRaises(___): catcher.normal_undefined_attribute
+        with self.assertRaises(AttributeError): catcher.normal_undefined_attribute
 
     # ------------------------------------------------------------------
 
@@ -114,7 +114,7 @@ def test_getattribute_is_a_bit_overzealous_sometimes(self):
         catcher = self.RecursiveCatcher()
         catcher.my_method()
         global stack_depth
-        self.assertEqual(__, stack_depth)
+        self.assertEqual(11, stack_depth)
 
     # ------------------------------------------------------------------
 
@@ -135,17 +135,17 @@ def test_getattr_ignores_known_attributes(self):
         catcher = self.MinimalCatcher()
         catcher.my_method()
 
-        self.assertEqual(__, catcher.no_of_getattr_calls)
+        self.assertEqual(0, catcher.no_of_getattr_calls)
 
     def test_getattr_only_catches_unknown_attributes(self):
         catcher = self.MinimalCatcher()
         catcher.purple_flamingos()
         catcher.free_pie()
 
-        self.assertEqual(__,
+        self.assertEqual('DuffObject',
             type(catcher.give_me_duff_or_give_me_death()).__name__)
 
-        self.assertEqual(__, catcher.no_of_getattr_calls)
+        self.assertEqual(3, catcher.no_of_getattr_calls)
 
     # ------------------------------------------------------------------
 
@@ -166,13 +166,13 @@ def test_setattr_intercepts_attribute_assignments(self):
         fanboy.comic = 'The Laminator, issue #1'
         fanboy.pie = 'blueberry'
 
-        self.assertEqual(__, fanboy.a_pie)
+        self.assertEqual('blueberry', fanboy.a_pie)
 
         #
         # NOTE: Change the prefix to make this next assert pass
         #
 
-        prefix = '__'
+        prefix = 'my'
         self.assertEqual("The Laminator, issue #1", getattr(fanboy, prefix + '_comic'))
 
     # ------------------------------------------------------------------
@@ -194,7 +194,7 @@ def test_it_modifies_external_attribute_as_expected(self):
         setter = self.ScarySetter()
         setter.e = "mc hammer"
 
-        self.assertEqual(__, setter.altered_e)
+        self.assertEqual('mc hammer', setter.altered_e)
 
     def test_it_mangles_some_internal_attributes(self):
         setter = self.ScarySetter()
@@ -202,9 +202,9 @@ def test_it_mangles_some_internal_attributes(self):
         try:
             coconuts = setter.num_of_coconuts
         except AttributeError:
-            self.assertEqual(__, setter.altered_num_of_coconuts)
+            self.assertEqual(9, setter.altered_num_of_coconuts)
 
     def test_in_this_case_private_attributes_remain_unmangled(self):
         setter = self.ScarySetter()
 
-        self.assertEqual(__, setter._num_of_private_coconuts)
+        self.assertEqual(2, setter._num_of_private_coconuts)

From 239b5054d372a9023e82f16dc13cd06cc313be36 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Fri, 27 Dec 2024 21:30:06 +0800
Subject: [PATCH 45/51] daily python exercise

---
 koans/about_deleting_objects.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/koans/about_deleting_objects.py b/koans/about_deleting_objects.py
index 152265c98..6a7ad92d7 100644
--- a/koans/about_deleting_objects.py
+++ b/koans/about_deleting_objects.py
@@ -9,13 +9,13 @@ def test_del_can_remove_slices(self):
         del lottery_nums[1]
         del lottery_nums[2:4]
 
-        self.assertEqual(___, lottery_nums)
+        self.assertEqual([4, 15, 42], lottery_nums)
 
     def test_del_can_remove_entire_lists(self):
         lottery_nums = [4, 8, 15, 16, 23, 42]
         del lottery_nums
 
-        with self.assertRaises(___): win = lottery_nums
+        with self.assertRaises(UnboundLocalError): win = lottery_nums
 
     # ====================================================================
 
@@ -48,8 +48,8 @@ def test_del_can_remove_attributes(self):
         except AttributeError as e:
             err_msg2 = e.args[0]
 
-        self.assertRegex(err_msg1, __)
-        self.assertRegex(err_msg2, __)
+        self.assertRegex(err_msg1, "'ClosingSale' object has no attribute 'toilet_brushes'")
+        self.assertRegex(err_msg2, "'ClosingSale' object has no attribute 'hamsters'")
 
     # ====================================================================
 
@@ -78,7 +78,7 @@ def test_del_works_with_properties(self):
         self.assertEqual('Senor Ninguno', cowboy.name)
 
         del cowboy.name
-        self.assertEqual(__, cowboy.name)
+        self.assertEqual("The man with no name", cowboy.name)
 
 
     # ====================================================================
@@ -105,7 +105,7 @@ def test_another_way_to_make_a_deletable_property(self):
         self.assertEqual('Patrick', citizen.name)
 
         del citizen.name
-        self.assertEqual(__, citizen.name)
+        self.assertEqual('Number Six', citizen.name)
 
     # ====================================================================
 
@@ -119,6 +119,6 @@ def __delattr__(self, attr_name):
 
     def tests_del_can_be_overriden(self):
         sale = self.MoreOrganisedClosingSale()
-        self.assertEqual(__, sale.jellies())
+        self.assertEqual(5, sale.jellies())
         del sale.jellies
-        self.assertEqual(__, sale.last_deletion)
+        self.assertEqual('jellies', sale.last_deletion)

From b7df9cb1d7cfd3700058f5d8c57dcd36eaff0dc9 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sat, 28 Dec 2024 21:11:23 +0800
Subject: [PATCH 46/51] update

---
 koans/about_proxy_object_project.py | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/koans/about_proxy_object_project.py b/koans/about_proxy_object_project.py
index db70e0c70..596a67df8 100644
--- a/koans/about_proxy_object_project.py
+++ b/koans/about_proxy_object_project.py
@@ -20,12 +20,28 @@
 
 class Proxy:
     def __init__(self, target_object):
-        # WRITE CODE HERE
-
-        #initialize '_obj' attribute last. Trust me on this!
         self._obj = target_object
+        self._messages = []
+
+    def __getattr__(self, name):
+        self._messages.append(name)
+        return getattr(self._obj, name)
+
+    def __setattr__(self, name, value):
+        if name in ['_obj', '_messages']:
+            super().__setattr__(name, value)
+        else:
+            self._messages.append(name)
+            setattr(self._obj, name, value)
+
+    def messages(self):
+        return self._messages
+
+    def was_called(self, name):
+        return name in self._messages
 
-    # WRITE CODE HERE
+    def number_of_times_called(self, name):
+        return self._messages.count(name)
 
 # The proxy object should pass the following Koan:
 #

From 8b02530e9d7e03fd0d0bb3e5d5f3aedd6e8499a8 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Mon, 30 Dec 2024 18:16:13 +0800
Subject: [PATCH 47/51] completed all koans

---
 koans/about_regex.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/koans/about_regex.py b/koans/about_regex.py
index f562594e5..0d77ee28c 100644
--- a/koans/about_regex.py
+++ b/koans/about_regex.py
@@ -20,7 +20,7 @@ def test_matching_literal_text(self):
         """
         string = "Hello, my name is Felix and these koans are based " + \
         "on Ben's book: Regular Expressions in 10 minutes."
-        m = re.search(__, string)
+        m = re.search("Felix", string)
         self.assertTrue(
             m and m.group(0) and
                 m.group(0) == 'Felix',
@@ -49,7 +49,7 @@ def test_matching_literal_text_how_many(self):
         m = re.match('Felix', string)  # TIP: match may not be the best option
 
         # I want to know how many times my name appears
-        self.assertEqual(m, __)
+        self.assertEqual(m, None)
 
     def test_matching_literal_text_not_case_sensitivity(self):
         """
@@ -63,8 +63,8 @@ def test_matching_literal_text_not_case_sensitivity(self):
         string = "Hello, my name is Felix or felix and this koan " + \
             "is based on Ben's book: Regular Expressions in 10 minutes."
 
-        self.assertEqual(re.findall("felix", string), __)
-        self.assertEqual(re.findall("felix", string, re.IGNORECASE), __)
+        self.assertEqual(re.findall("felix", string), ['felix'])
+        self.assertEqual(re.findall("felix", string, re.IGNORECASE), ['Felix', 'felix'])
 
     def test_matching_any_character(self):
         """
@@ -84,7 +84,7 @@ def test_matching_any_character(self):
         change_this_search_string = 'a..xlx'
         self.assertEquals(
             len(re.findall(change_this_search_string, string)),
-            3)
+            0)
 
     def test_matching_set_character(self):
         """
@@ -110,7 +110,7 @@ def test_matching_set_character(self):
         change_this_search_string = '[nsc]a[2-9].xls'
         self.assertEquals(
             len(re.findall(change_this_search_string, string)),
-            3)
+            1)
 
     def test_anything_but_matching(self):
         """
@@ -137,4 +137,4 @@ def test_anything_but_matching(self):
         change_this_search_string = '[^nc]am'
         self.assertEquals(
             re.findall(change_this_search_string, string),
-            ['sam.xls'])
+            ['sam'])

From b6b5d2f3a99bbf7169a0dd35ecd967bb142a3d13 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Mon, 20 Jan 2025 23:16:53 +0800
Subject: [PATCH 48/51] another round of python koans

---
 koans/about_asserts.py                   | 14 ++---
 koans/about_attribute_access.py          | 36 ++++++-------
 koans/about_class_attributes.py          | 44 ++++++++--------
 koans/about_classes.py                   | 41 ++++++++-------
 koans/about_comprehension.py             | 26 +++++-----
 koans/about_control_statements.py        | 16 +++---
 koans/about_decorating_with_classes.py   | 28 +++++-----
 koans/about_decorating_with_functions.py |  6 +--
 koans/about_deleting_objects.py          | 16 +++---
 koans/about_dice_project.py              |  3 +-
 koans/about_dictionaries.py              | 30 +++++------
 koans/about_exceptions.py                | 24 ++++-----
 koans/about_generators.py                | 29 +++++------
 koans/about_inheritance.py               | 22 ++++----
 koans/about_iteration.py                 | 32 ++++++------
 koans/about_lambdas.py                   |  8 +--
 koans/about_list_assignments.py          | 26 +++++-----
 koans/about_lists.py                     | 66 ++++++++++++------------
 koans/about_method_bindings.py           | 28 +++++-----
 koans/about_methods.py                   | 38 +++++++-------
 koans/about_modules.py                   | 22 ++++----
 koans/about_monkey_patching.py           | 13 ++---
 koans/about_multiple_inheritance.py      | 22 ++++----
 koans/about_none.py                      | 12 ++---
 koans/about_packages.py                  |  8 +--
 koans/about_proxy_object_project.py      | 24 ++-------
 koans/about_regex.py                     | 14 ++---
 koans/about_scope.py                     | 31 ++++++-----
 koans/about_scoring_project.py           | 18 +------
 koans/about_sets.py                      | 36 ++++++-------
 koans/about_string_manipulation.py       | 34 ++++++------
 koans/about_strings.py                   | 38 +++++++-------
 koans/about_true_and_false.py            | 30 +++++------
 koans/about_tuples.py                    | 29 +++++------
 koans/about_with_statements.py           | 16 ++----
 koans/another_local_module.py            |  2 +-
 koans/triangle.py                        | 14 +----
 37 files changed, 423 insertions(+), 473 deletions(-)

diff --git a/koans/about_asserts.py b/koans/about_asserts.py
index a85869529..d17ed0cdf 100644
--- a/koans/about_asserts.py
+++ b/koans/about_asserts.py
@@ -14,25 +14,25 @@ def test_assert_truth(self):
         #
         #   http://bit.ly/about_asserts
 
-        self.assertTrue(True) # This should be True
+        self.assertTrue(False) # This should be True
 
     def test_assert_with_message(self):
         """
         Enlightenment may be more easily achieved with appropriate messages.
         """
-        self.assertTrue(True, "This should be True -- Please fix this")
+        self.assertTrue(False, "This should be True -- Please fix this")
 
     def test_fill_in_values(self):
         """
         Sometimes we will ask you to fill in the values
         """
-        self.assertEqual(2, 1 + 1)
+        self.assertEqual(__, 1 + 1)
 
     def test_assert_equality(self):
         """
         To understand reality, we must compare our expectations against reality.
         """
-        expected_value = 2
+        expected_value = __
         actual_value = 1 + 1
         self.assertTrue(expected_value == actual_value)
 
@@ -40,7 +40,7 @@ def test_a_better_way_of_asserting_equality(self):
         """
         Some ways of asserting equality are better than others.
         """
-        expected_value = 2
+        expected_value = __
         actual_value = 1 + 1
 
         self.assertEqual(expected_value, actual_value)
@@ -51,7 +51,7 @@ def test_that_unittest_asserts_work_the_same_way_as_python_asserts(self):
         """
 
         # This throws an AssertionError exception
-        assert True
+        assert False
 
     def test_that_sometimes_we_need_to_know_the_class_type(self):
         """
@@ -70,7 +70,7 @@ def test_that_sometimes_we_need_to_know_the_class_type(self):
         #
         # See for yourself:
 
-        self.assertEqual(str, "navel".__class__) # It's str, not <type 'str'>
+        self.assertEqual(__, "navel".__class__) # It's str, not <type 'str'>
 
         # Need an illustration? More reading can be found here:
         #
diff --git a/koans/about_attribute_access.py b/koans/about_attribute_access.py
index ea89fefa7..f12f61143 100644
--- a/koans/about_attribute_access.py
+++ b/koans/about_attribute_access.py
@@ -15,12 +15,12 @@ class TypicalObject:
     def test_calling_undefined_functions_normally_results_in_errors(self):
         typical = self.TypicalObject()
 
-        with self.assertRaises(AttributeError): typical.foobar()
+        with self.assertRaises(___): typical.foobar()
 
     def test_calling_getattribute_causes_an_attribute_error(self):
         typical = self.TypicalObject()
 
-        with self.assertRaises(AttributeError): typical.__getattribute__('foobar')
+        with self.assertRaises(___): typical.__getattribute__('foobar')
 
         # THINK ABOUT IT:
         #
@@ -36,19 +36,19 @@ def __getattribute__(self, attr_name):
     def test_all_attribute_reads_are_caught(self):
         catcher = self.CatchAllAttributeReads()
 
-        self.assertRegex(catcher.foobar, "Someone called 'foobar' and it could not be found")
+        self.assertRegex(catcher.foobar, __)
 
     def test_intercepting_return_values_can_disrupt_the_call_chain(self):
         catcher = self.CatchAllAttributeReads()
 
-        self.assertRegex(catcher.foobaz,  "Someone called 'foobaz' and it could not be found") # This is fine
+        self.assertRegex(catcher.foobaz, __) # This is fine
 
         try:
             catcher.foobaz(1)
         except TypeError as ex:
             err_msg = ex.args[0]
 
-        self.assertRegex(err_msg, "'str' object is not callable")
+        self.assertRegex(err_msg, __)
 
         # foobaz returns a string. What happens to the '(1)' part?
         # Try entering this into a python console to reproduce the issue:
@@ -59,7 +59,7 @@ def test_intercepting_return_values_can_disrupt_the_call_chain(self):
     def test_changes_to_the_getattribute_implementation_affects_getattr_function(self):
         catcher = self.CatchAllAttributeReads()
 
-        self.assertRegex(getattr(catcher, 'any_attribute'), "Someone called 'any_attribute' and it could not be found")
+        self.assertRegex(getattr(catcher, 'any_attribute'), __)
 
     # ------------------------------------------------------------------
 
@@ -73,13 +73,13 @@ def __getattribute__(self, attr_name):
     def test_foo_attributes_are_caught(self):
         catcher = self.WellBehavedFooCatcher()
 
-        self.assertEqual('Foo to you too', catcher.foo_bar)
-        self.assertEqual('Foo to you too', catcher.foo_baz)
+        self.assertEqual(__, catcher.foo_bar)
+        self.assertEqual(__, catcher.foo_baz)
 
     def test_non_foo_messages_are_treated_normally(self):
         catcher = self.WellBehavedFooCatcher()
 
-        with self.assertRaises(AttributeError): catcher.normal_undefined_attribute
+        with self.assertRaises(___): catcher.normal_undefined_attribute
 
     # ------------------------------------------------------------------
 
@@ -114,7 +114,7 @@ def test_getattribute_is_a_bit_overzealous_sometimes(self):
         catcher = self.RecursiveCatcher()
         catcher.my_method()
         global stack_depth
-        self.assertEqual(11, stack_depth)
+        self.assertEqual(__, stack_depth)
 
     # ------------------------------------------------------------------
 
@@ -135,17 +135,17 @@ def test_getattr_ignores_known_attributes(self):
         catcher = self.MinimalCatcher()
         catcher.my_method()
 
-        self.assertEqual(0, catcher.no_of_getattr_calls)
+        self.assertEqual(__, catcher.no_of_getattr_calls)
 
     def test_getattr_only_catches_unknown_attributes(self):
         catcher = self.MinimalCatcher()
         catcher.purple_flamingos()
         catcher.free_pie()
 
-        self.assertEqual('DuffObject',
+        self.assertEqual(__,
             type(catcher.give_me_duff_or_give_me_death()).__name__)
 
-        self.assertEqual(3, catcher.no_of_getattr_calls)
+        self.assertEqual(__, catcher.no_of_getattr_calls)
 
     # ------------------------------------------------------------------
 
@@ -166,13 +166,13 @@ def test_setattr_intercepts_attribute_assignments(self):
         fanboy.comic = 'The Laminator, issue #1'
         fanboy.pie = 'blueberry'
 
-        self.assertEqual('blueberry', fanboy.a_pie)
+        self.assertEqual(__, fanboy.a_pie)
 
         #
         # NOTE: Change the prefix to make this next assert pass
         #
 
-        prefix = 'my'
+        prefix = '__'
         self.assertEqual("The Laminator, issue #1", getattr(fanboy, prefix + '_comic'))
 
     # ------------------------------------------------------------------
@@ -194,7 +194,7 @@ def test_it_modifies_external_attribute_as_expected(self):
         setter = self.ScarySetter()
         setter.e = "mc hammer"
 
-        self.assertEqual('mc hammer', setter.altered_e)
+        self.assertEqual(__, setter.altered_e)
 
     def test_it_mangles_some_internal_attributes(self):
         setter = self.ScarySetter()
@@ -202,9 +202,9 @@ def test_it_mangles_some_internal_attributes(self):
         try:
             coconuts = setter.num_of_coconuts
         except AttributeError:
-            self.assertEqual(9, setter.altered_num_of_coconuts)
+            self.assertEqual(__, setter.altered_num_of_coconuts)
 
     def test_in_this_case_private_attributes_remain_unmangled(self):
         setter = self.ScarySetter()
 
-        self.assertEqual(2, setter._num_of_private_coconuts)
+        self.assertEqual(__, setter._num_of_private_coconuts)
diff --git a/koans/about_class_attributes.py b/koans/about_class_attributes.py
index cbd3db6d8..7a5be1df4 100644
--- a/koans/about_class_attributes.py
+++ b/koans/about_class_attributes.py
@@ -13,36 +13,36 @@ class Dog:
 
     def test_objects_are_objects(self):
         fido = self.Dog()
-        self.assertEqual(True, isinstance(fido, object))
+        self.assertEqual(__, isinstance(fido, object))
 
     def test_classes_are_types(self):
-        self.assertEqual(True, self.Dog.__class__ == type)
+        self.assertEqual(__, self.Dog.__class__ == type)
 
     def test_classes_are_objects_too(self):
-        self.assertEqual(True, issubclass(self.Dog, object))
+        self.assertEqual(__, issubclass(self.Dog, object))
 
     def test_objects_have_methods(self):
         fido = self.Dog()
-        self.assertEqual(26, len(dir(fido)))
+        self.assertEqual(__, len(dir(fido)))
 
     def test_classes_have_methods(self):
-        self.assertEqual(26, len(dir(self.Dog)))
+        self.assertEqual(__, len(dir(self.Dog)))
 
     def test_creating_objects_without_defining_a_class(self):
         singularity = object()
-        self.assertEqual(23, len(dir(singularity)))
+        self.assertEqual(__, len(dir(singularity)))
 
     def test_defining_attributes_on_individual_objects(self):
         fido = self.Dog()
         fido.legs = 4
 
-        self.assertEqual(4, fido.legs)
+        self.assertEqual(__, fido.legs)
 
     def test_defining_functions_on_individual_objects(self):
         fido = self.Dog()
         fido.wag = lambda : 'fidos wag'
 
-        self.assertEqual('fidos wag', fido.wag())
+        self.assertEqual(__, fido.wag())
 
     def test_other_objects_are_not_affected_by_these_singleton_functions(self):
         fido = self.Dog()
@@ -52,7 +52,7 @@ def wag():
             return 'fidos wag'
         fido.wag = wag
 
-        with self.assertRaises(AttributeError): rover.wag()
+        with self.assertRaises(___): rover.wag()
 
     # ------------------------------------------------------------------
 
@@ -75,19 +75,19 @@ def growl(cls):
             return "classmethod growl, arg: cls=" + cls.__name__
 
     def test_since_classes_are_objects_you_can_define_singleton_methods_on_them_too(self):
-        self.assertRegex(self.Dog2.growl(), 'classmethod growl, arg: cls=Dog2')
+        self.assertRegex(self.Dog2.growl(), __)
 
     def test_classmethods_are_not_independent_of_instance_methods(self):
         fido = self.Dog2()
-        self.assertRegex(fido.growl(), 'classmethod growl, arg: cls=Dog2')
-        self.assertRegex(self.Dog2.growl(), 'classmethod growl, arg: cls=Dog2')
+        self.assertRegex(fido.growl(), __)
+        self.assertRegex(self.Dog2.growl(), __)
 
     def test_staticmethods_are_unbound_functions_housed_in_a_class(self):
-        self.assertRegex(self.Dog2.bark(), "staticmethod bark, arg: None")
+        self.assertRegex(self.Dog2.bark(), __)
 
     def test_staticmethods_also_overshadow_instance_methods(self):
         fido = self.Dog2()
-        self.assertRegex(fido.bark(), 'staticmethod bark, arg: None')
+        self.assertRegex(fido.bark(), __)
 
     # ------------------------------------------------------------------
 
@@ -114,20 +114,20 @@ def set_name(cls, name):
 
     def test_classmethods_can_not_be_used_as_properties(self):
         fido = self.Dog3()
-        with self.assertRaises(TypeError): fido.name = "Fido"
+        with self.assertRaises(___): fido.name = "Fido"
 
     def test_classes_and_instances_do_not_share_instance_attributes(self):
         fido = self.Dog3()
         fido.set_name_from_instance("Fido")
         fido.set_name("Rover")
-        self.assertEqual('Fido', fido.get_name_from_instance())
-        self.assertEqual('Rover', self.Dog3.get_name())
+        self.assertEqual(__, fido.get_name_from_instance())
+        self.assertEqual(__, self.Dog3.get_name())
 
     def test_classes_and_instances_do_share_class_attributes(self):
         fido = self.Dog3()
         fido.set_name("Fido")
-        self.assertEqual('Fido', fido.get_name())
-        self.assertEqual('Fido', self.Dog3.get_name())
+        self.assertEqual(__, fido.get_name())
+        self.assertEqual(__, self.Dog3.get_name())
 
     # ------------------------------------------------------------------
 
@@ -142,13 +142,13 @@ def a_static_method():
         a_static_method = staticmethod(a_static_method)
 
     def test_you_can_define_class_methods_without_using_a_decorator(self):
-        self.assertEqual('dogs class method', self.Dog4.a_class_method())
+        self.assertEqual(__, self.Dog4.a_class_method())
 
     def test_you_can_define_static_methods_without_using_a_decorator(self):
-        self.assertEqual('dogs static method', self.Dog4.a_static_method())
+        self.assertEqual(__, self.Dog4.a_static_method())
 
     # ------------------------------------------------------------------
 
     def test_heres_an_easy_way_to_explicitly_call_class_methods_from_instance_methods(self):
         fido = self.Dog4()
-        self.assertEqual('dogs class method', fido.__class__.a_class_method())
+        self.assertEqual(__, fido.__class__.a_class_method())
diff --git a/koans/about_classes.py b/koans/about_classes.py
index 592a53064..22dc4e7f0 100644
--- a/koans/about_classes.py
+++ b/koans/about_classes.py
@@ -12,10 +12,10 @@ def test_instances_of_classes_can_be_created_adding_parentheses(self):
         # NOTE: The .__name__ attribute will convert the class
         # into a string value.
         fido = self.Dog()
-        self.assertEqual("Dog", fido.__class__.__name__)
+        self.assertEqual(__, fido.__class__.__name__)
 
     def test_classes_have_docstrings(self):
-        self.assertRegex(self.Dog.__doc__, "Dogs need regular walkies. Never, ever let them drive.")
+        self.assertRegex(self.Dog.__doc__, __)
 
     # ------------------------------------------------------------------
 
@@ -28,12 +28,12 @@ def set_name(self, a_name):
 
     def test_init_method_is_the_constructor(self):
         dog = self.Dog2()
-        self.assertEqual("Paul", dog._name)
+        self.assertEqual(__, dog._name)
 
     def test_private_attributes_are_not_really_private(self):
         dog = self.Dog2()
         dog.set_name("Fido")
-        self.assertEqual("Fido", dog._name)
+        self.assertEqual(__, dog._name)
         # The _ prefix in _name implies private ownership, but nothing is truly
         # private in Python.
 
@@ -41,11 +41,11 @@ def test_you_can_also_access_the_value_out_using_getattr_and_dict(self):
         fido = self.Dog2()
         fido.set_name("Fido")
 
-        self.assertEqual("Fido", getattr(fido, "_name"))
+        self.assertEqual(__, getattr(fido, "_name"))
         # getattr(), setattr() and delattr() are a way of accessing attributes
         # by method rather than through assignment operators
 
-        self.assertEqual("Fido", fido.__dict__["_name"])
+        self.assertEqual(__, fido.__dict__["_name"])
         # Yes, this works here, but don't rely on the __dict__ object! Some
         # class implementations use optimization which result in __dict__ not
         # showing everything.
@@ -69,10 +69,10 @@ def test_that_name_can_be_read_as_a_property(self):
         fido.set_name("Fido")
 
         # access as method
-        self.assertEqual("Fido", fido.get_name())
+        self.assertEqual(__, fido.get_name())
 
         # access as property
-        self.assertEqual("Fido", fido.name)
+        self.assertEqual(__, fido.name)
 
     # ------------------------------------------------------------------
 
@@ -92,7 +92,7 @@ def test_creating_properties_with_decorators_is_slightly_easier(self):
         fido = self.Dog4()
 
         fido.name = "Fido"
-        self.assertEqual("Fido", fido.name)
+        self.assertEqual(__, fido.name)
 
     # ------------------------------------------------------------------
 
@@ -106,10 +106,10 @@ def name(self):
 
     def test_init_provides_initial_values_for_instance_variables(self):
         fido = self.Dog5("Fido")
-        self.assertEqual("Fido", fido.name)
+        self.assertEqual(__, fido.name)
 
     def test_args_must_match_init(self):
-        with self.assertRaises(TypeError):
+        with self.assertRaises(___):
             self.Dog5()
 
         # THINK ABOUT IT:
@@ -119,7 +119,7 @@ def test_different_objects_have_different_instance_variables(self):
         fido = self.Dog5("Fido")
         rover = self.Dog5("Rover")
 
-        self.assertEqual(False, rover.name == fido.name)
+        self.assertEqual(__, rover.name == fido.name)
 
     # ------------------------------------------------------------------
 
@@ -134,14 +134,15 @@ def __str__(self):
             #
             # Implement this!
             #
-            return self._name
+            return __
 
         def __repr__(self):
             return "<Dog named '" + self._name + "'>"
 
     def test_inside_a_method_self_refers_to_the_containing_object(self):
         fido = self.Dog6("Fido")
-        self.assertEqual(fido, fido.get_self())  # Not a string!
+
+        self.assertEqual(__, fido.get_self())  # Not a string!
 
     def test_str_provides_a_string_version_of_the_object(self):
         fido = self.Dog6("Fido")
@@ -151,17 +152,17 @@ def test_str_provides_a_string_version_of_the_object(self):
     def test_str_is_used_explicitly_in_string_interpolation(self):
         fido = self.Dog6("Fido")
 
-        self.assertEqual("My dog is Fido", "My dog is " + str(fido))
+        self.assertEqual(__, "My dog is " + str(fido))
 
     def test_repr_provides_a_more_complete_string_version(self):
         fido = self.Dog6("Fido")
-        self.assertEqual("<Dog named 'Fido'>", repr(fido))
+        self.assertEqual(__, repr(fido))
 
     def test_all_objects_support_str_and_repr(self):
         seq = [1, 2, 3]
 
-        self.assertEqual("[1, 2, 3]", str(seq))
-        self.assertEqual("[1, 2, 3]", repr(seq))
+        self.assertEqual(__, str(seq))
+        self.assertEqual(__, repr(seq))
 
-        self.assertEqual('STRING', str("STRING"))
-        self.assertEqual("'STRING'", repr("STRING"))
+        self.assertEqual(__, str("STRING"))
+        self.assertEqual(__, repr("STRING"))
diff --git a/koans/about_comprehension.py b/koans/about_comprehension.py
index 9577a0e4d..e5add6d9e 100644
--- a/koans/about_comprehension.py
+++ b/koans/about_comprehension.py
@@ -13,8 +13,8 @@ def test_creating_lists_with_list_comprehensions(self):
 
         comprehension = [delicacy.capitalize() for delicacy in feast]
 
-        self.assertEqual("Lambs", comprehension[0])
-        self.assertEqual("Orangutans", comprehension[2])
+        self.assertEqual(__, comprehension[0])
+        self.assertEqual(__, comprehension[2])
 
     def test_filtering_lists_with_list_comprehensions(self):
         feast = ['spam', 'sloths', 'orangutans', 'breakfast cereals',
@@ -22,15 +22,15 @@ def test_filtering_lists_with_list_comprehensions(self):
 
         comprehension = [delicacy for delicacy in feast if len(delicacy) > 6]
 
-        self.assertEqual(5, len(feast))
-        self.assertEqual(3, len(comprehension))
+        self.assertEqual(__, len(feast))
+        self.assertEqual(__, len(comprehension))
 
     def test_unpacking_tuples_in_list_comprehensions(self):
         list_of_tuples = [(1, 'lumberjack'), (2, 'inquisition'), (4, 'spam')]
         comprehension = [ skit * number for number, skit in list_of_tuples ]
 
-        self.assertEqual('lumberjack', comprehension[0])
-        self.assertEqual('spamspamspamspam', comprehension[2])
+        self.assertEqual(__, comprehension[0])
+        self.assertEqual(__, comprehension[2])
 
     def test_double_list_comprehension(self):
         list_of_eggs = ['poached egg', 'fried egg']
@@ -40,13 +40,13 @@ def test_double_list_comprehension(self):
         comprehension = [ '{0} and {1}'.format(egg, meat) for egg in list_of_eggs for meat in list_of_meats]
 
 
-        self.assertEqual('poached egg and lite spam', comprehension[0])
-        self.assertEqual(6, len(comprehension))
+        self.assertEqual(__, comprehension[0])
+        self.assertEqual(__, len(comprehension))
 
     def test_creating_a_set_with_set_comprehension(self):
         comprehension = { x for x in 'aabbbcccc'}
 
-        self.assertEqual({'b', 'a', 'c'}, comprehension)  # remember that set members are unique
+        self.assertEqual(__, comprehension)  # remember that set members are unique
 
     def test_creating_a_dictionary_with_dictionary_comprehension(self):
         dict_of_weapons = {'first': 'fear', 'second': 'surprise',
@@ -55,7 +55,7 @@ def test_creating_a_dictionary_with_dictionary_comprehension(self):
 
         dict_comprehension = { k.upper(): weapon for k, weapon in dict_of_weapons.items() if weapon}
 
-        self.assertEqual(False, 'first' in dict_comprehension)
-        self.assertEqual(True, 'FIRST' in dict_comprehension)
-        self.assertEqual(5, len(dict_of_weapons))
-        self.assertEqual(4, len(dict_comprehension))
+        self.assertEqual(__, 'first' in dict_comprehension)
+        self.assertEqual(__, 'FIRST' in dict_comprehension)
+        self.assertEqual(__, len(dict_of_weapons))
+        self.assertEqual(__, len(dict_comprehension))
diff --git a/koans/about_control_statements.py b/koans/about_control_statements.py
index 7935fb00a..842c8d91f 100644
--- a/koans/about_control_statements.py
+++ b/koans/about_control_statements.py
@@ -10,13 +10,13 @@ def test_if_then_else_statements(self):
             result = 'true value'
         else:
             result = 'false value'
-        self.assertEqual('true value', result)
+        self.assertEqual(__, result)
 
     def test_if_then_statements(self):
         result = 'default value'
         if True:
             result = 'true value'
-        self.assertEqual('true value', result)
+        self.assertEqual(__, result)
 
     def test_if_then_elif_else_statements(self):
         if False:
@@ -25,7 +25,7 @@ def test_if_then_elif_else_statements(self):
             result = 'true value'
         else:
             result = 'default value'
-        self.assertEqual('true value', result)
+        self.assertEqual(__, result)
 
     def test_while_statement(self):
         i = 1
@@ -33,7 +33,7 @@ def test_while_statement(self):
         while i <= 10:
             result = result * i
             i += 1
-        self.assertEqual(3628800, result)
+        self.assertEqual(__, result)
 
     def test_break_statement(self):
         i = 1
@@ -42,7 +42,7 @@ def test_break_statement(self):
             if i > 10: break
             result = result * i
             i += 1
-        self.assertEqual(3628800, result)
+        self.assertEqual(__, result)
 
     def test_continue_statement(self):
         i = 0
@@ -51,14 +51,14 @@ def test_continue_statement(self):
             i += 1
             if (i % 2) == 0: continue
             result.append(i)
-        self.assertEqual([1, 3, 5, 7, 9], result)
+        self.assertEqual(__, result)
 
     def test_for_statement(self):
         phrase = ["fish", "and", "chips"]
         result = []
         for item in phrase:
             result.append(item.upper())
-        self.assertEqual(['FISH', 'AND', 'CHIPS'], result)
+        self.assertEqual([__, __, __], result)
 
     def test_for_statement_with_tuples(self):
         round_table = [
@@ -71,7 +71,7 @@ def test_for_statement_with_tuples(self):
         for knight, answer in round_table:
             result.append("Contestant: '" + knight + "'   Answer: '" + answer + "'")
 
-        text = "Contestant: 'Robin'   Answer: 'Blue! I mean Green!'"
+        text = __
 
         self.assertRegex(result[2], text)
 
diff --git a/koans/about_decorating_with_classes.py b/koans/about_decorating_with_classes.py
index 5ec6da294..00bd5fe90 100644
--- a/koans/about_decorating_with_classes.py
+++ b/koans/about_decorating_with_classes.py
@@ -19,21 +19,21 @@ def test_partial_that_wrappers_no_args(self):
         """
         max = functools.partial(self.maximum)
 
-        self.assertEqual(23, max(7,23))
-        self.assertEqual(10, max(10,-10))
+        self.assertEqual(__, max(7,23))
+        self.assertEqual(__, max(10,-10))
 
     def test_partial_that_wrappers_first_arg(self):
         max0 = functools.partial(self.maximum, 0)
 
-        self.assertEqual(0, max0(-4))
-        self.assertEqual(5, max0(5))
+        self.assertEqual(__, max0(-4))
+        self.assertEqual(__, max0(5))
 
     def test_partial_that_wrappers_all_args(self):
         always99 = functools.partial(self.maximum, 99, 20)
         always20 = functools.partial(self.maximum, 9, 20)
 
-        self.assertEqual(99, always99())
-        self.assertEqual(20, always20())
+        self.assertEqual(__, always99())
+        self.assertEqual(__, always20())
 
     # ------------------------------------------------------------------
 
@@ -64,8 +64,8 @@ def test_decorator_with_no_arguments(self):
         # To clarify: the decorator above the function has no arguments, even
         # if the decorated function does
 
-        self.assertEqual("foo, foo", self.foo())
-        self.assertEqual('PIECES OF EIGHT, PIECES OF EIGHT', self.parrot('pieces of eight'))
+        self.assertEqual(__, self.foo())
+        self.assertEqual(__, self.parrot('pieces of eight'))
 
     # ------------------------------------------------------------------
 
@@ -77,7 +77,7 @@ def test_what_a_decorator_is_doing_to_a_function(self):
         #wrap the function with the decorator
         self.sound_check = self.doubleit(self.sound_check)
 
-        self.assertEqual("Testing..., Testing...", self.sound_check())
+        self.assertEqual(__, self.sound_check())
 
     # ------------------------------------------------------------------
 
@@ -108,11 +108,11 @@ def idler(self, num):
         pass
 
     def test_decorator_with_an_argument(self):
-        self.assertEqual(5, self.count_badly(2))
-        self.assertEqual("Increments a value by one. Kind of.", self.count_badly.__doc__)
+        self.assertEqual(__, self.count_badly(2))
+        self.assertEqual(__, self.count_badly.__doc__)
 
     def test_documentor_which_already_has_a_docstring(self):
-        self.assertEqual('Idler: Does nothing', self.idler.__doc__)
+        self.assertEqual(__, self.idler.__doc__)
 
     # ------------------------------------------------------------------
 
@@ -123,6 +123,6 @@ def homer(self):
         return "D'oh"
 
     def test_we_can_chain_decorators(self):
-        self.assertEqual("D'oh, D'oh, D'oh, D'oh", self.homer())
-        self.assertEqual('DOH!', self.homer.__doc__)
+        self.assertEqual(__, self.homer())
+        self.assertEqual(__, self.homer.__doc__)
 
diff --git a/koans/about_decorating_with_functions.py b/koans/about_decorating_with_functions.py
index 67c5beaaf..a51260213 100644
--- a/koans/about_decorating_with_functions.py
+++ b/koans/about_decorating_with_functions.py
@@ -14,8 +14,8 @@ def mediocre_song(self):
         return "o/~ We all live in a broken submarine o/~"
 
     def test_decorators_can_modify_a_function(self):
-        self.assertRegex(self.mediocre_song(), "o/~ We all live in a broken submarine o/~")
-        self.assertEqual('COWBELL BABY!', self.mediocre_song.wow_factor)
+        self.assertRegex(self.mediocre_song(), __)
+        self.assertEqual(__, self.mediocre_song.wow_factor)
 
     # ------------------------------------------------------------------
 
@@ -29,4 +29,4 @@ def render_tag(self, name):
         return name
 
     def test_decorators_can_change_a_function_output(self):
-        self.assertEqual('<llama/>', self.render_tag('llama'))
+        self.assertEqual(__, self.render_tag('llama'))
diff --git a/koans/about_deleting_objects.py b/koans/about_deleting_objects.py
index 6a7ad92d7..152265c98 100644
--- a/koans/about_deleting_objects.py
+++ b/koans/about_deleting_objects.py
@@ -9,13 +9,13 @@ def test_del_can_remove_slices(self):
         del lottery_nums[1]
         del lottery_nums[2:4]
 
-        self.assertEqual([4, 15, 42], lottery_nums)
+        self.assertEqual(___, lottery_nums)
 
     def test_del_can_remove_entire_lists(self):
         lottery_nums = [4, 8, 15, 16, 23, 42]
         del lottery_nums
 
-        with self.assertRaises(UnboundLocalError): win = lottery_nums
+        with self.assertRaises(___): win = lottery_nums
 
     # ====================================================================
 
@@ -48,8 +48,8 @@ def test_del_can_remove_attributes(self):
         except AttributeError as e:
             err_msg2 = e.args[0]
 
-        self.assertRegex(err_msg1, "'ClosingSale' object has no attribute 'toilet_brushes'")
-        self.assertRegex(err_msg2, "'ClosingSale' object has no attribute 'hamsters'")
+        self.assertRegex(err_msg1, __)
+        self.assertRegex(err_msg2, __)
 
     # ====================================================================
 
@@ -78,7 +78,7 @@ def test_del_works_with_properties(self):
         self.assertEqual('Senor Ninguno', cowboy.name)
 
         del cowboy.name
-        self.assertEqual("The man with no name", cowboy.name)
+        self.assertEqual(__, cowboy.name)
 
 
     # ====================================================================
@@ -105,7 +105,7 @@ def test_another_way_to_make_a_deletable_property(self):
         self.assertEqual('Patrick', citizen.name)
 
         del citizen.name
-        self.assertEqual('Number Six', citizen.name)
+        self.assertEqual(__, citizen.name)
 
     # ====================================================================
 
@@ -119,6 +119,6 @@ def __delattr__(self, attr_name):
 
     def tests_del_can_be_overriden(self):
         sale = self.MoreOrganisedClosingSale()
-        self.assertEqual(5, sale.jellies())
+        self.assertEqual(__, sale.jellies())
         del sale.jellies
-        self.assertEqual('jellies', sale.last_deletion)
+        self.assertEqual(__, sale.last_deletion)
diff --git a/koans/about_dice_project.py b/koans/about_dice_project.py
index ddccf31b5..27bc54a24 100644
--- a/koans/about_dice_project.py
+++ b/koans/about_dice_project.py
@@ -16,8 +16,7 @@ def values(self):
     def roll(self, n):
         # Needs implementing!
         # Tip: random.randint(min, max) can be used to generate random numbers
-        self._values = [random.randint(1, 6) for _ in range(n)]
-
+        pass
 
 class AboutDiceProject(Koan):
     def test_can_create_a_dice_set(self):
diff --git a/koans/about_dictionaries.py b/koans/about_dictionaries.py
index 0d81d1356..da1ed6bfe 100644
--- a/koans/about_dictionaries.py
+++ b/koans/about_dictionaries.py
@@ -12,46 +12,46 @@ def test_creating_dictionaries(self):
         empty_dict = dict()
         self.assertEqual(dict, type(empty_dict))
         self.assertDictEqual({}, empty_dict)
-        self.assertEqual(0, len(empty_dict))
+        self.assertEqual(__, len(empty_dict))
 
     def test_dictionary_literals(self):
         empty_dict = {}
         self.assertEqual(dict, type(empty_dict))
         babel_fish = { 'one': 'uno', 'two': 'dos' }
-        self.assertEqual(2, len(babel_fish))
+        self.assertEqual(__, len(babel_fish))
 
     def test_accessing_dictionaries(self):
         babel_fish = { 'one': 'uno', 'two': 'dos' }
-        self.assertEqual('uno', babel_fish['one'])
-        self.assertEqual('dos', babel_fish['two'])
+        self.assertEqual(__, babel_fish['one'])
+        self.assertEqual(__, babel_fish['two'])
 
     def test_changing_dictionaries(self):
         babel_fish = { 'one': 'uno', 'two': 'dos' }
         babel_fish['one'] = 'eins'
 
-        expected = { 'two': 'dos', 'one': 'eins' }
+        expected = { 'two': 'dos', 'one': __ }
         self.assertDictEqual(expected, babel_fish)
 
     def test_dictionary_is_unordered(self):
         dict1 = { 'one': 'uno', 'two': 'dos' }
         dict2 = { 'two': 'dos', 'one': 'uno' }
 
-        self.assertEqual(True, dict1 == dict2)
+        self.assertEqual(__, dict1 == dict2)
 
 
     def test_dictionary_keys_and_values(self):
         babel_fish = {'one': 'uno', 'two': 'dos'}
-        self.assertEqual(2, len(babel_fish.keys()))
-        self.assertEqual(2, len(babel_fish.values()))
-        self.assertEqual(True, 'one' in babel_fish.keys())
-        self.assertEqual(False, 'two' in babel_fish.values())
-        self.assertEqual(False, 'uno' in babel_fish.keys())
-        self.assertEqual(True, 'dos' in babel_fish.values())
+        self.assertEqual(__, len(babel_fish.keys()))
+        self.assertEqual(__, len(babel_fish.values()))
+        self.assertEqual(__, 'one' in babel_fish.keys())
+        self.assertEqual(__, 'two' in babel_fish.values())
+        self.assertEqual(__, 'uno' in babel_fish.keys())
+        self.assertEqual(__, 'dos' in babel_fish.values())
 
     def test_making_a_dictionary_from_a_sequence_of_keys(self):
         cards = {}.fromkeys(('red warrior', 'green elf', 'blue valkyrie', 'yellow dwarf', 'confused looking zebra'), 42)
 
-        self.assertEqual(5, len(cards))
-        self.assertEqual(42, cards['green elf'])
-        self.assertEqual(42, cards['yellow dwarf'])
+        self.assertEqual(__, len(cards))
+        self.assertEqual(__, cards['green elf'])
+        self.assertEqual(__, cards['yellow dwarf'])
 
diff --git a/koans/about_exceptions.py b/koans/about_exceptions.py
index 7063786da..d321bbc50 100644
--- a/koans/about_exceptions.py
+++ b/koans/about_exceptions.py
@@ -10,10 +10,10 @@ class MySpecialError(RuntimeError):
 
     def test_exceptions_inherit_from_exception(self):
         mro = self.MySpecialError.mro()
-        self.assertEqual('RuntimeError', mro[1].__name__)
-        self.assertEqual('Exception', mro[2].__name__)
-        self.assertEqual('BaseException', mro[3].__name__)
-        self.assertEqual('object', mro[4].__name__)
+        self.assertEqual(__, mro[1].__name__)
+        self.assertEqual(__, mro[2].__name__)
+        self.assertEqual(__, mro[3].__name__)
+        self.assertEqual(__, mro[4].__name__)
 
     def test_try_clause(self):
         result = None
@@ -24,15 +24,15 @@ def test_try_clause(self):
 
             ex2 = ex
 
-        self.assertEqual('exception handled', result)
+        self.assertEqual(__, result)
 
-        self.assertEqual(True, isinstance(ex2, Exception))
-        self.assertEqual(False, isinstance(ex2, RuntimeError))
+        self.assertEqual(__, isinstance(ex2, Exception))
+        self.assertEqual(__, isinstance(ex2, RuntimeError))
 
         self.assertTrue(issubclass(RuntimeError, Exception), \
             "RuntimeError is a subclass of Exception")
 
-        self.assertEqual('Oops', ex2.args[0])
+        self.assertEqual(__, ex2.args[0])
 
     def test_raising_a_specific_error(self):
         result = None
@@ -42,8 +42,8 @@ def test_raising_a_specific_error(self):
             result = 'exception handled'
             msg = ex.args[0]
 
-        self.assertEqual('exception handled', result)
-        self.assertEqual("My Message", msg)
+        self.assertEqual(__, result)
+        self.assertEqual(__, msg)
 
     def test_else_clause(self):
         result = None
@@ -55,7 +55,7 @@ def test_else_clause(self):
         else:
             result = 'no damage done'
 
-        self.assertEqual('no damage done', result)
+        self.assertEqual(__, result)
 
 
     def test_finally_clause(self):
@@ -68,4 +68,4 @@ def test_finally_clause(self):
         finally:
             result = 'always run'
 
-        self.assertEqual('always run', result)
+        self.assertEqual(__, result)
diff --git a/koans/about_generators.py b/koans/about_generators.py
index c26b8fb85..a81a43ba6 100644
--- a/koans/about_generators.py
+++ b/koans/about_generators.py
@@ -19,7 +19,7 @@ def test_generating_values_on_the_fly(self):
         for bacon in bacon_generator:
             result.append(bacon)
 
-        self.assertEqual(['crunchy bacon', 'veggie bacon', 'danish bacon'], result)
+        self.assertEqual(__, result)
 
     def test_generators_are_different_to_list_comprehensions(self):
         num_list = [x*2 for x in range(1,3)]
@@ -28,9 +28,9 @@ def test_generators_are_different_to_list_comprehensions(self):
         self.assertEqual(2, num_list[0])
 
         # A generator has to be iterated through.
-        with self.assertRaises(TypeError): num = num_generator[0]
+        with self.assertRaises(___): num = num_generator[0]
 
-        self.assertEqual(2, list(num_generator)[0])
+        self.assertEqual(__, 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
@@ -44,8 +44,8 @@ def test_generator_expressions_are_a_one_shot_deal(self):
         attempt1 = list(dynamite)
         attempt2 = list(dynamite)
 
-        self.assertEqual(['Boom!', 'Boom!','Boom!'], attempt1)
-        self.assertEqual([], attempt2)
+        self.assertEqual(__, attempt1)
+        self.assertEqual(__, attempt2)
 
     # ------------------------------------------------------------------
 
@@ -59,12 +59,12 @@ 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)
+        self.assertEqual(__, result)
 
     def test_generators_can_be_manually_iterated_and_closed(self):
         result = self.simple_generator_method()
-        self.assertEqual('peanut', next(result))
-        self.assertEqual('butter', next(result))
+        self.assertEqual(__, next(result))
+        self.assertEqual(__, next(result))
         result.close()
 
     # ------------------------------------------------------------------
@@ -75,7 +75,7 @@ def square_me(self, seq):
 
     def test_generator_method_with_parameter(self):
         result = self.square_me(range(2,5))
-        self.assertEqual([4, 9, 16], list(result))
+        self.assertEqual(__, list(result))
 
     # ------------------------------------------------------------------
 
@@ -88,7 +88,7 @@ def sum_it(self, seq):
 
     def test_generator_keeps_track_of_local_variables(self):
         result = self.sum_it(range(2,5))
-        self.assertEqual([2, 5, 9], list(result))
+        self.assertEqual(__, list(result))
 
     # ------------------------------------------------------------------
 
@@ -106,7 +106,7 @@ def test_generators_can_act_as_coroutines(self):
         #       section of http://www.python.org/dev/peps/pep-0342/
         next(generator)
 
-        self.assertEqual(3, generator.send(1 + 2))
+        self.assertEqual(__, generator.send(1 + 2))
 
     def test_before_sending_a_value_to_a_generator_next_must_be_called(self):
         generator = self.coroutine()
@@ -114,8 +114,7 @@ def test_before_sending_a_value_to_a_generator_next_must_be_called(self):
         try:
             generator.send(1 + 2)
         except TypeError as ex:
-            print(ex.args[0])
-            self.assertRegex(ex.args[0], "can't send non-None value to a just-started generator")
+            self.assertRegex(ex.args[0], __)
 
     # ------------------------------------------------------------------
 
@@ -133,11 +132,11 @@ def test_generators_can_see_if_they_have_been_called_with_a_value(self):
 
         generator2 = self.yield_tester()
         next(generator2)
-        self.assertEqual('no value', next(generator2))
+        self.assertEqual(__, 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))
+        self.assertEqual(__, generator.send(None))
diff --git a/koans/about_inheritance.py b/koans/about_inheritance.py
index 9a378571c..5d2407dfa 100644
--- a/koans/about_inheritance.py
+++ b/koans/about_inheritance.py
@@ -23,31 +23,31 @@ def bark(self):
             return "yip"
 
     def test_subclasses_have_the_parent_as_an_ancestor(self):
-        self.assertEqual(True, issubclass(self.Chihuahua, self.Dog))
+        self.assertEqual(__, issubclass(self.Chihuahua, self.Dog))
 
     def test_all_classes_in_python_3_ultimately_inherit_from_object_class(self):
-        self.assertEqual(True, issubclass(self.Chihuahua, object))
+        self.assertEqual(__, issubclass(self.Chihuahua, object))
 
         # Note: This isn't the case in Python 2. In that version you have
         # to inherit from a built in class or object explicitly
 
     def test_instances_inherit_behavior_from_parent_class(self):
         chico = self.Chihuahua("Chico")
-        self.assertEqual("Chico", chico.name)
+        self.assertEqual(__, chico.name)
 
     def test_subclasses_add_new_behavior(self):
         chico = self.Chihuahua("Chico")
-        self.assertEqual("happy", chico.wag())
+        self.assertEqual(__, chico.wag())
 
         fido = self.Dog("Fido")
-        with self.assertRaises(AttributeError): fido.wag()
+        with self.assertRaises(___): fido.wag()
 
     def test_subclasses_can_modify_existing_behavior(self):
         chico = self.Chihuahua("Chico")
-        self.assertEqual("yip", chico.bark())
+        self.assertEqual(__, chico.bark())
 
         fido = self.Dog("Fido")
-        self.assertEqual("WOOF", fido.bark())
+        self.assertEqual(__, fido.bark())
 
     # ------------------------------------------------------------------
 
@@ -58,7 +58,7 @@ def bark(self):
 
     def test_subclasses_can_invoke_parent_behavior_via_super(self):
         ralph = self.BullDog("Ralph")
-        self.assertEqual("WOOF, GRR", ralph.bark())
+        self.assertEqual(__, ralph.bark())
 
     # ------------------------------------------------------------------
 
@@ -68,7 +68,7 @@ def growl(self):
 
     def test_super_works_across_methods(self):
         george = self.GreatDane("George")
-        self.assertEqual('WOOF, GROWL', george.growl())
+        self.assertEqual(__, george.growl())
 
     # ---------------------------------------------------------
 
@@ -82,8 +82,8 @@ def __init__(self, name):
 
     def test_base_init_does_not_get_called_automatically(self):
         snoopy = self.Pug("Snoopy")
-        with self.assertRaises(AttributeError): name = snoopy.name
+        with self.assertRaises(___): name = snoopy.name
 
     def test_base_init_has_to_be_called_explicitly(self):
         boxer = self.Greyhound("Boxer")
-        self.assertEqual("Boxer", boxer.name)
+        self.assertEqual(__, boxer.name)
diff --git a/koans/about_iteration.py b/koans/about_iteration.py
index c1cbefbaf..1faca8e33 100644
--- a/koans/about_iteration.py
+++ b/koans/about_iteration.py
@@ -13,20 +13,20 @@ def test_iterators_are_a_type(self):
         for num in it:
             total += num
 
-        self.assertEqual(15 , total)
+        self.assertEqual(__ , total)
 
     def test_iterating_with_next(self):
         stages = iter(['alpha','beta','gamma'])
 
         try:
-            self.assertEqual('alpha', next(stages))
+            self.assertEqual(__, next(stages))
             next(stages)
-            self.assertEqual('gamma', next(stages))
+            self.assertEqual(__, next(stages))
             next(stages)
         except StopIteration as ex:
             err_msg = 'Ran out of iterations'
 
-        self.assertRegex(err_msg, 'Ran out of iterations')
+        self.assertRegex(err_msg, __)
 
     # ------------------------------------------------------------------
 
@@ -40,14 +40,14 @@ def test_map_transforms_elements_of_a_list(self):
         mapping = map(self.add_ten, seq)
 
         self.assertNotEqual(list, mapping.__class__)
-        self.assertEqual(map, mapping.__class__)
+        self.assertEqual(__, mapping.__class__)
         # In Python 3 built in iterator funcs return iterable view objects
         # instead of lists
 
         for item in mapping:
             mapped_seq.append(item)
 
-        self.assertEqual([11, 12, 13], mapped_seq)
+        self.assertEqual(__, mapped_seq)
 
         # Note, iterator methods actually return objects of iter type in
         # python 3. In python 2 map() would give you a list.
@@ -62,7 +62,7 @@ def is_even(item):
         for item in filter(is_even, seq):
             even_numbers.append(item)
 
-        self.assertEqual([2, 4, 6], even_numbers)
+        self.assertEqual(__, even_numbers)
 
     def test_filter_returns_all_items_matching_criterion(self):
         def is_big_name(item):
@@ -71,8 +71,8 @@ def is_big_name(item):
         names = ["Jim", "Bill", "Clarence", "Doug", "Eli", "Elizabeth"]
         iterator = filter(is_big_name, names)
 
-        self.assertEqual('Clarence', next(iterator))
-        self.assertEqual('Elizabeth', next(iterator))
+        self.assertEqual(__, next(iterator))
+        self.assertEqual(__, next(iterator))
 
         try:
             next(iterator)
@@ -80,7 +80,7 @@ def is_big_name(item):
         except StopIteration:
             msg = 'Ran out of big names'
 
-        self.assertEqual('Ran out of big names', msg)
+        self.assertEquals(__, msg)
 
     # ------------------------------------------------------------------
 
@@ -96,13 +96,13 @@ def test_reduce_will_blow_your_mind(self):
         # to the functools module.
 
         result = functools.reduce(self.add, [2, 3, 4])
-        self.assertEqual(int, result.__class__)
+        self.assertEqual(__, result.__class__)
         # Reduce() syntax is same as Python 2
 
-        self.assertEqual(9, result)
+        self.assertEqual(__, result)
 
         result2 = functools.reduce(self.multiply, [2, 3, 4], 1)
-        self.assertEqual(24, result2)
+        self.assertEqual(__, result2)
 
         # Extra Credit:
         # Describe in your own words what reduce does.
@@ -113,14 +113,14 @@ def test_use_pass_for_iterations_with_no_body(self):
         for num in range(1,5):
             pass
 
-        self.assertEqual(4, num)
+        self.assertEqual(__, num)
 
     # ------------------------------------------------------------------
 
     def test_all_iteration_methods_work_on_any_sequence_not_just_lists(self):
         # Ranges are an iterable sequence
         result = map(self.add_ten, range(1,4))
-        self.assertEqual([11, 12, 13], list(result))
+        self.assertEqual(__, list(result))
 
     def test_lines_in_a_file_are_iterable_sequences_too(self):
         def make_upcase(line):
@@ -128,5 +128,5 @@ def make_upcase(line):
 
         file = open("example_file.txt")
         upcase_lines = map(make_upcase, file.readlines())
-        self.assertEqual(['This', 'Is', 'A', 'Test'], list(upcase_lines))
+        self.assertEqual(__, list(upcase_lines))
         file.close()
diff --git a/koans/about_lambdas.py b/koans/about_lambdas.py
index 9362853bd..c1e688094 100644
--- a/koans/about_lambdas.py
+++ b/koans/about_lambdas.py
@@ -10,7 +10,7 @@
 class AboutLambdas(Koan):
     def test_lambdas_can_be_assigned_to_variables_and_called_explicitly(self):
         add_one = lambda n: n + 1
-        self.assertEqual(11, add_one(10))
+        self.assertEqual(__, add_one(10))
 
     # ------------------------------------------------------------------
 
@@ -21,8 +21,8 @@ def test_accessing_lambda_via_assignment(self):
         sausages = self.make_order('sausage')
         eggs = self.make_order('egg')
 
-        self.assertEqual("3 sausages", sausages(3))
-        self.assertEqual("2 eggs", eggs(2))
+        self.assertEqual(__, sausages(3))
+        self.assertEqual(__, eggs(2))
 
     def test_accessing_lambda_without_assignment(self):
-        self.assertEqual("39823 spams", self.make_order('spam')(39823))
+        self.assertEqual(__, self.make_order('spam')(39823))
diff --git a/koans/about_list_assignments.py b/koans/about_list_assignments.py
index 0b036f0b0..8a8d48090 100644
--- a/koans/about_list_assignments.py
+++ b/koans/about_list_assignments.py
@@ -10,34 +10,34 @@
 class AboutListAssignments(Koan):
     def test_non_parallel_assignment(self):
         names = ["John", "Smith"]
-        self.assertEqual(["John", "Smith"], names)
+        self.assertEqual(__, names)
 
     def test_parallel_assignments(self):
         first_name, last_name = ["John", "Smith"]
-        self.assertEqual("John", first_name)
-        self.assertEqual("Smith", last_name)
+        self.assertEqual(__, first_name)
+        self.assertEqual(__, last_name)
 
     def test_parallel_assignments_with_extra_values(self):
         title, *first_names, last_name = ["Sir", "Ricky", "Bobby", "Worthington"]
-        self.assertEqual("Sir", title)
-        self.assertEqual(["Ricky", "Bobby"], first_names)
-        self.assertEqual("Worthington", last_name)
+        self.assertEqual(__, title)
+        self.assertEqual(__, first_names)
+        self.assertEqual(__, last_name)
 
     def test_parallel_assignments_with_fewer_values(self):
         title, *first_names, last_name = ["Mr", "Bond"]
-        self.assertEqual("Mr", title)
-        self.assertEqual([], first_names)
-        self.assertEqual("Bond", last_name)
+        self.assertEqual(__, title)
+        self.assertEqual(__, first_names)
+        self.assertEqual(__, last_name)
 
     def test_parallel_assignments_with_sublists(self):
         first_name, last_name = [["Willie", "Rae"], "Johnson"]
-        self.assertEqual(["Willie", "Rae"], first_name)
-        self.assertEqual("Johnson", last_name)
+        self.assertEqual(__, first_name)
+        self.assertEqual(__, last_name)
 
     def test_swapping_with_parallel_assignment(self):
         first_name = "Roy"
         last_name = "Rob"
         first_name, last_name = last_name, first_name
-        self.assertEqual("Rob", first_name)
-        self.assertEqual("Roy", last_name)
+        self.assertEqual(__, first_name)
+        self.assertEqual(__, last_name)
 
diff --git a/koans/about_lists.py b/koans/about_lists.py
index aa5014cd6..61cc3bb29 100644
--- a/koans/about_lists.py
+++ b/koans/about_lists.py
@@ -11,7 +11,7 @@ class AboutLists(Koan):
     def test_creating_lists(self):
         empty_list = list()
         self.assertEqual(list, type(empty_list))
-        self.assertEqual(0, len(empty_list))
+        self.assertEqual(__, len(empty_list))
 
     def test_list_literals(self):
         nums = list()
@@ -21,70 +21,70 @@ def test_list_literals(self):
         self.assertEqual([1], nums)
 
         nums[1:] = [2]
-        self.assertListEqual([1, 2], nums)
+        self.assertListEqual([1, __], nums)
 
         nums.append(333)
-        self.assertListEqual([1, 2, 333], nums)
+        self.assertListEqual([1, 2, __], nums)
 
     def test_accessing_list_elements(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual('peanut', noms[0])
-        self.assertEqual('jelly', noms[3])
-        self.assertEqual('jelly', noms[-1])
-        self.assertEqual('butter', noms[-3])
+        self.assertEqual(__, noms[0])
+        self.assertEqual(__, noms[3])
+        self.assertEqual(__, noms[-1])
+        self.assertEqual(__, noms[-3])
 
     def test_slicing_lists(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(['peanut'], noms[0:1])
-        self.assertEqual(['peanut', 'butter'], noms[0:2])
-        self.assertEqual([], noms[2:2])
-        self.assertEqual(['and', 'jelly'], noms[2:20])
-        self.assertEqual([], noms[4:0])
-        self.assertEqual([], noms[4:100])
-        self.assertEqual([], noms[5:0])
+        self.assertEqual(__, noms[0:1])
+        self.assertEqual(__, noms[0:2])
+        self.assertEqual(__, noms[2:2])
+        self.assertEqual(__, noms[2:20])
+        self.assertEqual(__, noms[4:0])
+        self.assertEqual(__, noms[4:100])
+        self.assertEqual(__, noms[5:0])
 
     def test_slicing_to_the_edge(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(['and', 'jelly'], noms[2:])
-        self.assertEqual(['peanut', 'butter'], noms[:2])
+        self.assertEqual(__, noms[2:])
+        self.assertEqual(__, noms[:2])
 
     def test_lists_and_ranges(self):
         self.assertEqual(range, type(range(5)))
         self.assertNotEqual([1, 2, 3, 4, 5], range(1,6))
-        self.assertEqual([0, 1, 2, 3, 4], list(range(5)))
-        self.assertEqual([5, 6, 7, 8], list(range(5, 9)))
+        self.assertEqual(__, list(range(5)))
+        self.assertEqual(__, list(range(5, 9)))
 
     def test_ranges_with_steps(self):
-        self.assertEqual([5, 4], list(range(5, 3, -1)))
-        self.assertEqual([0, 2, 4, 6], list(range(0, 8, 2)))
-        self.assertEqual([1, 4, 7], list(range(1, 8, 3)))
-        self.assertEqual([5, 1, -3], list(range(5, -7, -4)))
-        self.assertEqual([5, 1, -3, -7], list(range(5, -8, -4)))
+        self.assertEqual(__, list(range(5, 3, -1)))
+        self.assertEqual(__, list(range(0, 8, 2)))
+        self.assertEqual(__, list(range(1, 8, 3)))
+        self.assertEqual(__, list(range(5, -7, -4)))
+        self.assertEqual(__, list(range(5, -8, -4)))
 
     def test_insertions(self):
         knight = ['you', 'shall', 'pass']
         knight.insert(2, 'not')
-        self.assertEqual(['you', 'shall', 'not', 'pass'], knight)
+        self.assertEqual(__, knight)
 
         knight.insert(0, 'Arthur')
-        self.assertEqual(['Arthur', 'you', 'shall', 'not', 'pass'], knight)
+        self.assertEqual(__, knight)
 
     def test_popping_lists(self):
         stack = [10, 20, 30, 40]
         stack.append('last')
 
-        self.assertEqual([10, 20, 30, 40, 'last'], stack)
+        self.assertEqual(__, stack)
 
         popped_value = stack.pop()
-        self.assertEqual('last', popped_value)
-        self.assertEqual([10, 20, 30, 40], stack)
+        self.assertEqual(__, popped_value)
+        self.assertEqual(__, stack)
 
         popped_value = stack.pop(1)
-        self.assertEqual(20, popped_value)
-        self.assertEqual([10, 30, 40], stack)
+        self.assertEqual(__, popped_value)
+        self.assertEqual(__, stack)
 
         # Notice that there is a "pop" but no "push" in python?
 
@@ -98,11 +98,11 @@ def test_making_queues(self):
         queue = [1, 2]
         queue.append('last')
 
-        self.assertEqual([1, 2, 'last'], queue)
+        self.assertEqual(__, queue)
 
         popped_value = queue.pop(0)
-        self.assertEqual(1, popped_value)
-        self.assertEqual([2, 'last'], queue)
+        self.assertEqual(__, popped_value)
+        self.assertEqual(__, queue)
 
         # Note, popping from the left hand side of a list is
         # inefficient. Use collections.deque instead.
diff --git a/koans/about_method_bindings.py b/koans/about_method_bindings.py
index 47313bcda..020851bd5 100644
--- a/koans/about_method_bindings.py
+++ b/koans/about_method_bindings.py
@@ -16,42 +16,42 @@ def method(self):
 class AboutMethodBindings(Koan):
     def test_methods_are_bound_to_an_object(self):
         obj = Class()
-        self.assertEqual(True, obj.method.__self__ == obj)
+        self.assertEqual(__, obj.method.__self__ == obj)
 
     def test_methods_are_also_bound_to_a_function(self):
         obj = Class()
-        self.assertEqual("parrot", obj.method())
-        self.assertEqual("parrot", obj.method.__func__(obj))
+        self.assertEqual(__, obj.method())
+        self.assertEqual(__, obj.method.__func__(obj))
 
     def test_functions_have_attributes(self):
         obj = Class()
-        self.assertEqual(36, len(dir(function)))
-        self.assertEqual(True, dir(function) == dir(obj.method.__func__))
+        self.assertEqual(__, len(dir(function)))
+        self.assertEqual(__, dir(function) == dir(obj.method.__func__))
 
     def test_methods_have_different_attributes(self):
         obj = Class()
-        self.assertEqual(27, len(dir(obj.method)))
+        self.assertEqual(__, len(dir(obj.method)))
 
     def test_setting_attributes_on_an_unbound_function(self):
         function.cherries = 3
-        self.assertEqual(3, function.cherries)
+        self.assertEqual(__, function.cherries)
 
     def test_setting_attributes_on_a_bound_method_directly(self):
         obj = Class()
-        with self.assertRaises(AttributeError): obj.method.cherries = 3
+        with self.assertRaises(___): obj.method.cherries = 3
 
     def test_setting_attributes_on_methods_by_accessing_the_inner_function(self):
         obj = Class()
         obj.method.__func__.cherries = 3
-        self.assertEqual(3, obj.method.cherries)
+        self.assertEqual(__, obj.method.cherries)
 
     def test_functions_can_have_inner_functions(self):
         function2.get_fruit = function
-        self.assertEqual("pineapple", function2.get_fruit())
+        self.assertEqual(__, function2.get_fruit())
 
     def test_inner_functions_are_unbound(self):
         function2.get_fruit = function
-        with self.assertRaises(AttributeError): cls = function2.get_fruit.__self__
+        with self.assertRaises(___): cls = function2.get_fruit.__self__
 
     # ------------------------------------------------------------------
 
@@ -68,8 +68,8 @@ def test_get_descriptor_resolves_attribute_binding(self):
         #   binding_owner = obj
         #   owner_type = cls
 
-        self.assertEqual("BoundClass", bound_obj.__class__.__name__)
-        self.assertEqual("AboutMethodBindings", binding_owner.__class__.__name__)
+        self.assertEqual(__, bound_obj.__class__.__name__)
+        self.assertEqual(__, binding_owner.__class__.__name__)
         self.assertEqual(AboutMethodBindings, owner_type)
 
     # ------------------------------------------------------------------
@@ -86,5 +86,5 @@ def __set__(self, obj, val):
     def test_set_descriptor_changes_behavior_of_attribute_assignment(self):
         self.assertEqual(None, self.color.choice)
         self.color = 'purple'
-        self.assertEqual('purple', self.color.choice)
+        self.assertEqual(__, self.color.choice)
 
diff --git a/koans/about_methods.py b/koans/about_methods.py
index 228de0e7f..796a07ea5 100644
--- a/koans/about_methods.py
+++ b/koans/about_methods.py
@@ -12,7 +12,7 @@ def my_global_function(a,b):
 
 class AboutMethods(Koan):
     def test_calling_a_global_function(self):
-        self.assertEqual(5, my_global_function(2,3))
+        self.assertEqual(__, my_global_function(2,3))
 
     # NOTE: Wrong number of arguments is not a SYNTAX error, but a
     # runtime error.
@@ -33,7 +33,7 @@ def test_calling_functions_with_wrong_number_of_arguments(self):
             msg = e.args[0]
 
         # Note, watch out for parenthesis. They need slashes in front!
-        self.assertRegex(msg, 'my_global_function\(\) takes 2 positional arguments but 3 were given')
+        self.assertRegex(msg, __)
 
     # ------------------------------------------------------------------
 
@@ -41,7 +41,7 @@ def pointless_method(self, a, b):
         sum = a + b
 
     def test_which_does_not_return_anything(self):
-        self.assertEqual(None, self.pointless_method(1, 2))
+        self.assertEqual(__, self.pointless_method(1, 2))
         # Notice that methods accessed from class scope do not require
         # you to pass the first "self" argument?
 
@@ -51,8 +51,8 @@ def method_with_defaults(self, a, b='default_value'):
         return [a, b]
 
     def test_calling_with_default_values(self):
-        self.assertEqual([1, 'default_value'], self.method_with_defaults(1))
-        self.assertEqual([1, 2], self.method_with_defaults(1, 2))
+        self.assertEqual(__, self.method_with_defaults(1))
+        self.assertEqual(__, self.method_with_defaults(1, 2))
 
     # ------------------------------------------------------------------
 
@@ -60,9 +60,9 @@ def method_with_var_args(self, *args):
         return args
 
     def test_calling_with_variable_arguments(self):
-        self.assertEqual((), self.method_with_var_args())
+        self.assertEqual(__, self.method_with_var_args())
         self.assertEqual(('one',), self.method_with_var_args('one'))
-        self.assertEqual(('one', 'two'), self.method_with_var_args('one', 'two'))
+        self.assertEqual(__, self.method_with_var_args('one', 'two'))
 
     # ------------------------------------------------------------------
 
@@ -73,13 +73,13 @@ def test_functions_without_self_arg_are_global_functions(self):
         def function_with_the_same_name(a, b):
             return a * b
 
-        self.assertEqual(12, function_with_the_same_name(3,4))
+        self.assertEqual(__, function_with_the_same_name(3,4))
 
     def test_calling_methods_in_same_class_with_explicit_receiver(self):
         def function_with_the_same_name(a, b):
             return a * b
 
-        self.assertEqual(7, self.function_with_the_same_name(3,4))
+        self.assertEqual(__, self.function_with_the_same_name(3,4))
 
     # ------------------------------------------------------------------
 
@@ -92,10 +92,10 @@ def another_method_with_the_same_name(self):
         return 42
 
     def test_that_old_methods_are_hidden_by_redefinitions(self):
-        self.assertEqual(42, self.another_method_with_the_same_name())
+        self.assertEqual(__, self.another_method_with_the_same_name())
 
     def test_that_overlapped_method_is_still_there(self):
-        self.assertEqual(10, self.link_to_overlapped_method())
+        self.assertEqual(__, self.link_to_overlapped_method())
 
     # ------------------------------------------------------------------
 
@@ -103,21 +103,21 @@ def empty_method(self):
         pass
 
     def test_methods_that_do_nothing_need_to_use_pass_as_a_filler(self):
-        self.assertEqual(None, self.empty_method())
+        self.assertEqual(__, self.empty_method())
 
     def test_pass_does_nothing_at_all(self):
         "You"
         "shall"
         "not"
         pass
-        self.assertEqual(True, "Still got to this line" != None)
+        self.assertEqual(____, "Still got to this line" != None)
 
     # ------------------------------------------------------------------
 
     def one_line_method(self): return 'Madagascar'
 
     def test_no_indentation_required_for_one_line_statement_bodies(self):
-        self.assertEqual('Madagascar', self.one_line_method())
+        self.assertEqual(__, self.one_line_method())
 
     # ------------------------------------------------------------------
 
@@ -126,7 +126,7 @@ def method_with_documentation(self):
         return "ok"
 
     def test_the_documentation_can_be_viewed_with_the_doc_method(self):
-        self.assertRegex(self.method_with_documentation.__doc__, "A string placed at the beginning of a function is used for documentation")
+        self.assertRegex(self.method_with_documentation.__doc__, __)
 
     # ------------------------------------------------------------------
 
@@ -143,20 +143,20 @@ def __password(self):
 
     def test_calling_methods_in_other_objects(self):
         rover = self.Dog()
-        self.assertEqual("Fido", rover.name())
+        self.assertEqual(__, rover.name())
 
     def test_private_access_is_implied_but_not_enforced(self):
         rover = self.Dog()
 
         # This is a little rude, but legal
-        self.assertEqual("wagging", rover._tail())
+        self.assertEqual(__, rover._tail())
 
     def test_attributes_with_double_underscore_prefixes_are_subject_to_name_mangling(self):
         rover = self.Dog()
-        with self.assertRaises(AttributeError): password = rover.__password()
+        with self.assertRaises(___): password = rover.__password()
 
         # But this still is!
-        self.assertEqual("password", rover._Dog__password())
+        self.assertEqual(__, rover._Dog__password())
 
         # Name mangling exists to avoid name clash issues when subclassing.
         # It is not for providing effective access protection
diff --git a/koans/about_modules.py b/koans/about_modules.py
index 0a66cc2c9..7a266171d 100644
--- a/koans/about_modules.py
+++ b/koans/about_modules.py
@@ -17,21 +17,21 @@ def test_importing_other_python_scripts_as_modules(self):
         from . import local_module  # local_module.py
 
         duck = local_module.Duck()
-        self.assertEqual("Daffy", duck.name)
+        self.assertEqual(__, duck.name)
 
     def test_importing_attributes_from_classes_using_from_keyword(self):
         from .local_module import Duck
 
         duck = Duck()  # no module qualifier needed this time
-        self.assertEqual("Daffy", duck.name)
+        self.assertEqual(__, duck.name)
 
     def test_we_can_import_multiple_items_at_once(self):
         from . import jims, joes
 
         jims_dog = jims.Dog()
         joes_dog = joes.Dog()
-        self.assertEqual("jims dog", jims_dog.identify())
-        self.assertEqual("joes dog", joes_dog.identify())
+        self.assertEqual(__, jims_dog.identify())
+        self.assertEqual(__, joes_dog.identify())
 
     def test_importing_all_module_attributes_at_once(self):
         """
@@ -43,18 +43,18 @@ def test_importing_all_module_attributes_at_once(self):
         goose = Goose()
         hamster = Hamster()
 
-        self.assertEqual("Mr Stabby", goose.name)
-        self.assertEqual("Phil", hamster.name)
+        self.assertEqual(__, goose.name)
+        self.assertEqual(__, hamster.name)
 
     def test_modules_hide_attributes_prefixed_by_underscores(self):
-        with self.assertRaises(NameError):
+        with self.assertRaises(___):
             private_squirrel = _SecretSquirrel()
 
     def test_private_attributes_are_still_accessible_in_modules(self):
         from .local_module import Duck  # local_module.py
 
         duck = Duck()
-        self.assertEqual('password', duck._password)
+        self.assertEqual(__, duck._password)
         # module level attribute hiding doesn't affect class attributes
         # (unless the class itself is hidden).
 
@@ -66,12 +66,12 @@ def test_a_module_can_limit_wildcard_imports(self):
 
         # 'Goat' is on the __all__ list
         goat = Goat()
-        self.assertEqual('George', goat.name)
+        self.assertEqual(__, goat.name)
 
         # How about velociraptors?
         lizard = _Velociraptor()
-        self.assertEqual("Cuddles", lizard.name)
+        self.assertEqual(__, lizard.name)
 
         # SecretDuck? Never heard of her!
-        with self.assertRaises(NameError):
+        with self.assertRaises(___):
             duck = SecretDuck()
diff --git a/koans/about_monkey_patching.py b/koans/about_monkey_patching.py
index c090fd1fd..bdea2b8b9 100644
--- a/koans/about_monkey_patching.py
+++ b/koans/about_monkey_patching.py
@@ -14,7 +14,7 @@ def bark(self):
 
     def test_as_defined_dogs_do_bark(self):
         fido = self.Dog()
-        self.assertEqual("WOOF", fido.bark())
+        self.assertEqual(__, fido.bark())
 
     # ------------------------------------------------------------------
 
@@ -24,8 +24,8 @@ def wag(self): return "HAPPY"
         self.Dog.wag = wag
 
         fido = self.Dog()
-        self.assertEqual("HAPPY", fido.wag())
-        self.assertEqual("WOOF", fido.bark())
+        self.assertEqual(__, fido.wag())
+        self.assertEqual(__, fido.bark())
 
     # ------------------------------------------------------------------
 
@@ -34,7 +34,8 @@ def test_most_built_in_classes_cannot_be_monkey_patched(self):
             int.is_even = lambda self: (self % 2) == 0
         except Exception as ex:
             err_msg = ex.args[0]
-        self.assertRegex(err_msg, "cannot set 'is_even' attribute of immutable type 'int'")
+
+        self.assertRegex(err_msg, __)
 
     # ------------------------------------------------------------------
 
@@ -43,5 +44,5 @@ class MyInt(int): pass
     def test_subclasses_of_built_in_classes_can_be_be_monkey_patched(self):
         self.MyInt.is_even = lambda self: (self % 2) == 0
 
-        self.assertEqual(False, self.MyInt(1).is_even())
-        self.assertEqual(True, self.MyInt(2).is_even())
+        self.assertEqual(__, self.MyInt(1).is_even())
+        self.assertEqual(__, self.MyInt(2).is_even())
diff --git a/koans/about_multiple_inheritance.py b/koans/about_multiple_inheritance.py
index 552b3d06d..4227f7eb9 100644
--- a/koans/about_multiple_inheritance.py
+++ b/koans/about_multiple_inheritance.py
@@ -87,7 +87,7 @@ def here(self):
 
     def test_normal_methods_are_available_in_the_object(self):
         jeff = self.Spiderpig()
-        self.assertRegex(jeff.speak(), "This looks like a job for Spiderpig!")
+        self.assertRegex(jeff.speak(), __)
 
     def test_base_class_methods_are_also_available_in_the_object(self):
         jeff = self.Spiderpig()
@@ -95,22 +95,22 @@ def test_base_class_methods_are_also_available_in_the_object(self):
             jeff.set_name("Rover")
         except:
             self.fail("This should not happen")
-        self.assertEqual(True, jeff.can_climb_walls())
+        self.assertEqual(__, jeff.can_climb_walls())
 
     def test_base_class_methods_can_affect_instance_variables_in_the_object(self):
         jeff = self.Spiderpig()
-        self.assertEqual('Jeff', jeff.name)
+        self.assertEqual(__, jeff.name)
 
         jeff.set_name("Rover")
-        self.assertEqual('Rover', jeff.name)
+        self.assertEqual(__, jeff.name)
 
     def test_left_hand_side_inheritance_tends_to_be_higher_priority(self):
         jeff = self.Spiderpig()
-        self.assertEqual('pink', jeff.color())
+        self.assertEqual(__, jeff.color())
 
     def test_super_class_methods_are_higher_priority_than_super_super_classes(self):
         jeff = self.Spiderpig()
-        self.assertEqual(8, jeff.legs())
+        self.assertEqual(__, jeff.legs())
 
     def test_we_can_inspect_the_method_resolution_order(self):
         #
@@ -119,10 +119,10 @@ def test_we_can_inspect_the_method_resolution_order(self):
         mro = type(self.Spiderpig()).mro()
         self.assertEqual('Spiderpig', mro[0].__name__)
         self.assertEqual('Pig', mro[1].__name__)
-        self.assertEqual('Spider', mro[2].__name__)
-        self.assertEqual('Animal', mro[3].__name__)
-        self.assertEqual('Nameable', mro[4].__name__)
-        self.assertEqual('object', mro[5].__name__)
+        self.assertEqual(__, mro[2].__name__)
+        self.assertEqual(__, mro[3].__name__)
+        self.assertEqual(__, mro[4].__name__)
+        self.assertEqual(__, mro[5].__name__)
 
     def test_confirm_the_mro_controls_the_calling_order(self):
         jeff = self.Spiderpig()
@@ -132,7 +132,7 @@ def test_confirm_the_mro_controls_the_calling_order(self):
         self.assertRegex(next.here(), 'Pig')
 
         next = super(AboutMultipleInheritance.Pig, jeff)
-        self.assertRegex(next.here(), 'Spider')
+        self.assertRegex(next.here(), __)
 
         # Hang on a minute?!? That last class name might be a super class of
         # the 'jeff' object, but its hardly a superclass of Pig, is it?
diff --git a/koans/about_none.py b/koans/about_none.py
index 740ef00c1..1731f0108 100644
--- a/koans/about_none.py
+++ b/koans/about_none.py
@@ -11,11 +11,11 @@ class AboutNone(Koan):
 
     def test_none_is_an_object(self):
         "Unlike NULL in a lot of languages"
-        self.assertEqual(True, isinstance(None, object))
+        self.assertEqual(__, isinstance(None, object))
 
     def test_none_is_universal(self):
         "There is only one None"
-        self.assertEqual(True, None is None)
+        self.assertEqual(____, None is None)
 
     def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         """
@@ -37,15 +37,15 @@ def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         #
         #     https://github.com/gregmalcolm/python_koans/wiki/Class-Attribute
 
-        self.assertEqual(AttributeError, ex2.__class__)
+        self.assertEqual(__, ex2.__class__)
 
         # What message was attached to the exception?
         # (HINT: replace __ with part of the error message.)
-        self.assertRegex(ex2.args[0], "'NoneType' object has no attribute 'some_method_none_does_not_know_about'")
+        self.assertRegex(ex2.args[0], __)
 
     def test_none_is_distinct(self):
         """
         None is distinct from other things which are False.
         """
-        self.assertEqual(True, None is not 0)
-        self.assertEqual(True, None is not False)
+        self.assertEqual(__, None is not 0)
+        self.assertEqual(__, None is not False)
diff --git a/koans/about_packages.py b/koans/about_packages.py
index 999cb7fb8..69288a1c8 100644
--- a/koans/about_packages.py
+++ b/koans/about_packages.py
@@ -29,13 +29,13 @@ def test_subfolders_can_form_part_of_a_module_package(self):
         from .a_package_folder.a_module import Duck
 
         duck = Duck()
-        self.assertEqual("Donald", duck.name)
+        self.assertEqual(__, duck.name)
 
     def test_subfolders_become_modules_if_they_have_an_init_module(self):
         # Import ./a_package_folder/__init__.py
         from .a_package_folder import an_attribute
 
-        self.assertEqual(1984, an_attribute)
+        self.assertEqual(__, an_attribute)
 
     # ------------------------------------------------------------------
 
@@ -43,7 +43,7 @@ def test_use_absolute_imports_to_import_upper_level_modules(self):
         # Import /contemplate_koans.py
         import contemplate_koans
 
-        self.assertEqual('contemplate_koans', contemplate_koans.__name__)
+        self.assertEqual(__, contemplate_koans.__name__)
 
         # contemplate_koans.py is the root module in this package because it's
         # the first python module called in koans.
@@ -57,4 +57,4 @@ def test_import_a_module_in_a_subfolder_folder_using_an_absolute_path(self):
         # Import contemplate_koans.py/koans/a_package_folder/a_module.py
         from koans.a_package_folder.a_module import Duck
 
-        self.assertEqual('koans.a_package_folder.a_module', Duck.__module__)
+        self.assertEqual(__, Duck.__module__)
diff --git a/koans/about_proxy_object_project.py b/koans/about_proxy_object_project.py
index 596a67df8..db70e0c70 100644
--- a/koans/about_proxy_object_project.py
+++ b/koans/about_proxy_object_project.py
@@ -20,28 +20,12 @@
 
 class Proxy:
     def __init__(self, target_object):
-        self._obj = target_object
-        self._messages = []
-
-    def __getattr__(self, name):
-        self._messages.append(name)
-        return getattr(self._obj, name)
-
-    def __setattr__(self, name, value):
-        if name in ['_obj', '_messages']:
-            super().__setattr__(name, value)
-        else:
-            self._messages.append(name)
-            setattr(self._obj, name, value)
-
-    def messages(self):
-        return self._messages
+        # WRITE CODE HERE
 
-    def was_called(self, name):
-        return name in self._messages
+        #initialize '_obj' attribute last. Trust me on this!
+        self._obj = target_object
 
-    def number_of_times_called(self, name):
-        return self._messages.count(name)
+    # WRITE CODE HERE
 
 # The proxy object should pass the following Koan:
 #
diff --git a/koans/about_regex.py b/koans/about_regex.py
index 0d77ee28c..f562594e5 100644
--- a/koans/about_regex.py
+++ b/koans/about_regex.py
@@ -20,7 +20,7 @@ def test_matching_literal_text(self):
         """
         string = "Hello, my name is Felix and these koans are based " + \
         "on Ben's book: Regular Expressions in 10 minutes."
-        m = re.search("Felix", string)
+        m = re.search(__, string)
         self.assertTrue(
             m and m.group(0) and
                 m.group(0) == 'Felix',
@@ -49,7 +49,7 @@ def test_matching_literal_text_how_many(self):
         m = re.match('Felix', string)  # TIP: match may not be the best option
 
         # I want to know how many times my name appears
-        self.assertEqual(m, None)
+        self.assertEqual(m, __)
 
     def test_matching_literal_text_not_case_sensitivity(self):
         """
@@ -63,8 +63,8 @@ def test_matching_literal_text_not_case_sensitivity(self):
         string = "Hello, my name is Felix or felix and this koan " + \
             "is based on Ben's book: Regular Expressions in 10 minutes."
 
-        self.assertEqual(re.findall("felix", string), ['felix'])
-        self.assertEqual(re.findall("felix", string, re.IGNORECASE), ['Felix', 'felix'])
+        self.assertEqual(re.findall("felix", string), __)
+        self.assertEqual(re.findall("felix", string, re.IGNORECASE), __)
 
     def test_matching_any_character(self):
         """
@@ -84,7 +84,7 @@ def test_matching_any_character(self):
         change_this_search_string = 'a..xlx'
         self.assertEquals(
             len(re.findall(change_this_search_string, string)),
-            0)
+            3)
 
     def test_matching_set_character(self):
         """
@@ -110,7 +110,7 @@ def test_matching_set_character(self):
         change_this_search_string = '[nsc]a[2-9].xls'
         self.assertEquals(
             len(re.findall(change_this_search_string, string)),
-            1)
+            3)
 
     def test_anything_but_matching(self):
         """
@@ -137,4 +137,4 @@ def test_anything_but_matching(self):
         change_this_search_string = '[^nc]am'
         self.assertEquals(
             re.findall(change_this_search_string, string),
-            ['sam'])
+            ['sam.xls'])
diff --git a/koans/about_scope.py b/koans/about_scope.py
index 20667c82e..a9cf2a168 100644
--- a/koans/about_scope.py
+++ b/koans/about_scope.py
@@ -16,18 +16,18 @@ class AboutScope(Koan):
     #
 
     def test_dog_is_not_available_in_the_current_scope(self):
-        with self.assertRaises(NameError): fido = Dog()
+        with self.assertRaises(___): fido = Dog()
 
     def test_you_can_reference_nested_classes_using_the_scope_operator(self):
         fido = jims.Dog()
         # name 'jims' module name is taken from jims.py filename
 
         rover = joes.Dog()
-        self.assertEqual("jims dog", fido.identify())
-        self.assertEqual("joes dog", rover.identify())
+        self.assertEqual(__, fido.identify())
+        self.assertEqual(__, rover.identify())
 
-        self.assertEqual(False, type(fido) == type(rover))
-        self.assertEqual(False, jims.Dog == joes.Dog)
+        self.assertEqual(__, type(fido) == type(rover))
+        self.assertEqual(__, jims.Dog == joes.Dog)
 
     # ------------------------------------------------------------------
 
@@ -35,26 +35,26 @@ class str:
         pass
 
     def test_bare_bones_class_names_do_not_assume_the_current_scope(self):
-        self.assertEqual(False, AboutScope.str == str)
+        self.assertEqual(__, AboutScope.str == str)
 
     def test_nested_string_is_not_the_same_as_the_system_string(self):
-        self.assertEqual(False, self.str == type("HI"))
+        self.assertEqual(__, self.str == type("HI"))
 
     def test_str_without_self_prefix_stays_in_the_global_scope(self):
-        self.assertEqual(True, str == type("HI"))
+        self.assertEqual(__, str == type("HI"))
 
     # ------------------------------------------------------------------
 
     PI = 3.1416
 
     def test_constants_are_defined_with_an_initial_uppercase_letter(self):
-        self.assertAlmostEqual(3.1416, self.PI)
+        self.assertAlmostEqual(_____, self.PI)
         # Note, floating point numbers in python are not precise.
         # assertAlmostEqual will check that it is 'close enough'
 
     def test_constants_are_assumed_by_convention_only(self):
         self.PI = "rhubarb"
-        self.assertEqual("rhubarb", self.PI)
+        self.assertEqual(_____, self.PI)
         # There aren't any real constants in python. Its up to the developer
         # to keep to the convention and not modify them.
 
@@ -71,14 +71,13 @@ def test_incrementing_with_local_counter(self):
         global counter
         start = counter
         self.increment_using_local_counter(start)
-        self.assertEqual(False, counter == start + 1)
+        self.assertEqual(__, counter == start + 1)
 
     def test_incrementing_with_global_counter(self):
         global counter
         start = counter
         self.increment_using_global_counter()
-
-        self.assertEqual(True, counter == start + 1)
+        self.assertEqual(__, counter == start + 1)
 
     # ------------------------------------------------------------------
 
@@ -97,10 +96,10 @@ def from_the_boosh():
         return from_the_boosh()
 
     def test_getting_something_locally(self):
-        self.assertEqual('this is a local shop for local people', self.local_access())
+        self.assertEqual(__, self.local_access())
 
     def test_getting_something_nonlocally(self):
-        self.assertEqual('eels', self.nonlocal_access())
+        self.assertEqual(__, self.nonlocal_access())
 
     # ------------------------------------------------------------------
 
@@ -108,4 +107,4 @@ def test_getting_something_nonlocally(self):
     deadly_bingo = [4, 8, 15, 16, 23, 42]
 
     def test_global_attributes_can_be_created_in_the_middle_of_a_class(self):
-        self.assertEqual(42, deadly_bingo[5])
+        self.assertEqual(__, deadly_bingo[5])
diff --git a/koans/about_scoring_project.py b/koans/about_scoring_project.py
index 16b4d43e6..0fd055de2 100644
--- a/koans/about_scoring_project.py
+++ b/koans/about_scoring_project.py
@@ -33,22 +33,8 @@
 # Your goal is to write the score method.
 
 def score(dice):
-    score = 0
-    counts = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0}
-    for die in dice:
-        counts[die] += 1
-    for die, count in counts.items():
-        if count >= 3:
-            if die == 1:
-                score += 1000
-            else:
-                score += die * 100
-            count -= 3
-        if die == 1:
-            score += count * 100
-        elif die == 5:
-            score += count * 50
-    return score
+    # You need to write this method
+    pass
 
 class AboutScoringProject(Koan):
     def test_score_of_an_empty_list_is_zero(self):
diff --git a/koans/about_sets.py b/koans/about_sets.py
index 14fc0662c..87cf10959 100644
--- a/koans/about_sets.py
+++ b/koans/about_sets.py
@@ -9,27 +9,27 @@ def test_sets_make_keep_lists_unique(self):
 
         there_can_only_be_only_one = set(highlanders)
 
-        self.assertEqual({"MacLeod", "Ramirez", "Matunas", "Malcolm"}, there_can_only_be_only_one)
+        self.assertEqual(__, there_can_only_be_only_one)
 
     def test_empty_sets_have_different_syntax_to_populated_sets(self):
-        self.assertEqual(set([1,2,3]), {1, 2, 3})
-        self.assertEqual(set(), set())
+        self.assertEqual(__, {1, 2, 3})
+        self.assertEqual(__, set())
 
     def test_dictionaries_and_sets_use_same_curly_braces(self):
         # Note: Literal sets using braces were introduced in python 3.
         #       They were also backported to python 2.7.
 
-        self.assertEqual(set, {1, 2, 3}.__class__)
-        self.assertEqual(dict, {'one': 1, 'two': 2}.__class__)
+        self.assertEqual(__, {1, 2, 3}.__class__)
+        self.assertEqual(__, {'one': 1, 'two': 2}.__class__)
 
-        self.assertEqual(dict, {}.__class__)
+        self.assertEqual(__, {}.__class__)
 
     def test_creating_sets_using_strings(self):
-        self.assertEqual(set(['12345']), {'12345'})
-        self.assertEqual({'1','2','3','4','5'}, set('12345'))
+        self.assertEqual(__, {'12345'})
+        self.assertEqual(__, set('12345'))
 
     def test_convert_the_set_into_a_list_to_sort_it(self):
-        self.assertEqual(['1','2','3','4','5'], sorted(set('12345')))
+        self.assertEqual(__, sorted(set('12345')))
 
     # ------------------------------------------------------------------
 
@@ -37,19 +37,19 @@ def test_set_have_arithmetic_operators(self):
         scotsmen = {'MacLeod', 'Wallace', 'Willie'}
         warriors = {'MacLeod', 'Wallace', 'Leonidas'}
 
-        self.assertEqual({'Willie'}, scotsmen - warriors)
-        self.assertEqual({'Wallace', 'MacLeod', 'Willie', 'Leonidas'}, scotsmen | warriors)
-        self.assertEqual({'Wallace', 'MacLeod'}, scotsmen & warriors)
-        self.assertEqual({'Willie', 'Leonidas'}, scotsmen ^ warriors)
+        self.assertEqual(__, scotsmen - warriors)
+        self.assertEqual(__, scotsmen | warriors)
+        self.assertEqual(__, scotsmen & warriors)
+        self.assertEqual(__, scotsmen ^ warriors)
 
     # ------------------------------------------------------------------
 
     def test_we_can_query_set_membership(self):
-        self.assertEqual(True, 127 in {127, 0, 0, 1} )
-        self.assertEqual(True, 'cow' not in set('apocalypse now') )
+        self.assertEqual(__, 127 in {127, 0, 0, 1} )
+        self.assertEqual(__, 'cow' not in set('apocalypse now') )
 
     def test_we_can_compare_subsets(self):
-        self.assertEqual(True, set('cake') <= set('cherry cake'))
-        self.assertEqual(True, set('cake').issubset(set('cherry cake')) )
+        self.assertEqual(__, set('cake') <= set('cherry cake'))
+        self.assertEqual(__, set('cake').issubset(set('cherry cake')) )
 
-        self.assertEqual(False, set('cake') > set('pie'))
+        self.assertEqual(__, set('cake') > set('pie'))
diff --git a/koans/about_string_manipulation.py b/koans/about_string_manipulation.py
index 7fca3ae90..5204f29ba 100644
--- a/koans/about_string_manipulation.py
+++ b/koans/about_string_manipulation.py
@@ -9,13 +9,13 @@ def test_use_format_to_interpolate_variables(self):
         value1 = 'one'
         value2 = 2
         string = "The values are {0} and {1}".format(value1, value2)
-        self.assertEqual("The values are one and 2", string)
+        self.assertEqual(__, string)
 
     def test_formatted_values_can_be_shown_in_any_order_or_be_repeated(self):
         value1 = 'doh'
         value2 = 'DOH'
         string = "The values are {1}, {0}, {0} and {1}!".format(value1, value2)
-        self.assertEqual("The values are DOH, doh, doh and DOH!", string)
+        self.assertEqual(__, string)
 
     def test_any_python_expression_may_be_interpolated(self):
         import math # import a standard python module with math functions
@@ -23,24 +23,24 @@ def test_any_python_expression_may_be_interpolated(self):
         decimal_places = 4
         string = "The square root of 5 is {0:.{1}f}".format(math.sqrt(5),
             decimal_places)
-        self.assertEqual("The square root of 5 is 2.2361", string)
+        self.assertEqual(__, string)
 
     def test_you_can_get_a_substring_from_a_string(self):
         string = "Bacon, lettuce and tomato"
-        self.assertEqual('let', string[7:10])
+        self.assertEqual(__, string[7:10])
 
     def test_you_can_get_a_single_character_from_a_string(self):
         string = "Bacon, lettuce and tomato"
-        self.assertEqual('a', string[1])
+        self.assertEqual(__, string[1])
 
     def test_single_characters_can_be_represented_by_integers(self):
-        self.assertEqual(97, ord('a'))
-        self.assertEqual(True, ord('b') == (ord('a') + 1))
+        self.assertEqual(__, ord('a'))
+        self.assertEqual(__, ord('b') == (ord('a') + 1))
 
     def test_strings_can_be_split(self):
         string = "Sausage Egg Cheese"
         words = string.split()
-        self.assertListEqual(['Sausage', 'Egg', 'Cheese'], words)
+        self.assertListEqual([__, __, __], words)
 
     def test_strings_can_be_split_with_different_patterns(self):
         import re #import python regular expression library
@@ -50,25 +50,25 @@ def test_strings_can_be_split_with_different_patterns(self):
 
         words = pattern.split(string)
 
-        self.assertListEqual(["the", "rain", "in", "spain"], words)
+        self.assertListEqual([__, __, __, __], words)
 
         # Pattern is a Python regular expression pattern which matches ',' or ';'
 
     def test_raw_strings_do_not_interpret_escape_characters(self):
         string = r'\n'
         self.assertNotEqual('\n', string)
-        self.assertEqual('\\n', string)
-        self.assertEqual(2, len(string))
+        self.assertEqual(__, string)
+        self.assertEqual(__, len(string))
 
         # Useful in regular expressions, file paths, URLs, etc.
 
     def test_strings_can_be_joined(self):
         words = ["Now", "is", "the", "time"]
-        self.assertEqual("Now is the time", ' '.join(words))
+        self.assertEqual(__, ' '.join(words))
 
     def test_strings_can_change_case(self):
-        self.assertEqual('Guido', 'guido'.capitalize())
-        self.assertEqual('GUIDO', 'guido'.upper())
-        self.assertEqual('timbot', 'TimBot'.lower())
-        self.assertEqual('Guido Van Rossum', 'guido van rossum'.title())
-        self.assertEqual('tOtAlLy AwEsOmE', 'ToTaLlY aWeSoMe'.swapcase())
+        self.assertEqual(__, 'guido'.capitalize())
+        self.assertEqual(__, 'guido'.upper())
+        self.assertEqual(__, 'TimBot'.lower())
+        self.assertEqual(__, 'guido van rossum'.title())
+        self.assertEqual(__, 'ToTaLlY aWeSoMe'.swapcase())
diff --git a/koans/about_strings.py b/koans/about_strings.py
index 77393eca2..25f5f59df 100644
--- a/koans/about_strings.py
+++ b/koans/about_strings.py
@@ -7,88 +7,88 @@ class AboutStrings(Koan):
 
     def test_double_quoted_strings_are_strings(self):
         string = "Hello, world."
-        self.assertEqual(True, isinstance(string, str))
+        self.assertEqual(__, isinstance(string, str))
 
     def test_single_quoted_strings_are_also_strings(self):
         string = 'Goodbye, world.'
-        self.assertEqual(True, isinstance(string, str))
+        self.assertEqual(__, isinstance(string, str))
 
     def test_triple_quote_strings_are_also_strings(self):
         string = """Howdy, world!"""
-        self.assertEqual(True, isinstance(string, str))
+        self.assertEqual(__, isinstance(string, str))
 
     def test_triple_single_quotes_work_too(self):
         string = '''Bonjour tout le monde!'''
-        self.assertEqual(True, isinstance(string, str))
+        self.assertEqual(__, isinstance(string, str))
 
     def test_raw_strings_are_also_strings(self):
         string = r"Konnichi wa, world!"
-        self.assertEqual(True, isinstance(string, str))
+        self.assertEqual(__, isinstance(string, str))
 
     def test_use_single_quotes_to_create_string_with_double_quotes(self):
         string = 'He said, "Go Away."'
-        self.assertEqual('He said, "Go Away."', string)
+        self.assertEqual(__, string)
 
     def test_use_double_quotes_to_create_strings_with_single_quotes(self):
         string = "Don't"
-        self.assertEqual('Don\'t', string)
+        self.assertEqual(__, string)
 
     def test_use_backslash_for_escaping_quotes_in_strings(self):
         a = "He said, \"Don't\""
         b = 'He said, "Don\'t"'
-        self.assertEqual(True, (a == b))
+        self.assertEqual(__, (a == b))
 
     def test_use_backslash_at_the_end_of_a_line_to_continue_onto_the_next_line(self):
         string = "It was the best of times,\n\
 It was the worst of times."
-        self.assertEqual(52, len(string))
+        self.assertEqual(__, len(string))
 
     def test_triple_quoted_strings_can_span_lines(self):
         string = """
 Howdy,
 world!
 """
-        self.assertEqual(15, len(string))
+        self.assertEqual(__, len(string))
 
     def test_triple_quoted_strings_need_less_escaping(self):
         a = "Hello \"world\"."
         b = """Hello "world"."""
-        self.assertEqual(True, (a == b))
+        self.assertEqual(__, (a == b))
 
     def test_escaping_quotes_at_the_end_of_triple_quoted_string(self):
         string = """Hello "world\""""
-        self.assertEqual('Hello "world"', string)
+        self.assertEqual(__, string)
 
     def test_plus_concatenates_strings(self):
         string = "Hello, " + "world"
-        self.assertEqual('Hello, world', string)
+        self.assertEqual(__, string)
 
     def test_adjacent_strings_are_concatenated_automatically(self):
         string = "Hello" ", " "world"
-        self.assertEqual('Hello, world', string)
+        self.assertEqual(__, string)
 
     def test_plus_will_not_modify_original_strings(self):
         hi = "Hello, "
         there = "world"
         string = hi + there
-        self.assertEqual('Hello, ', hi)
-        self.assertEqual('world', there)
+        self.assertEqual(__, hi)
+        self.assertEqual(__, there)
 
     def test_plus_equals_will_append_to_end_of_string(self):
         hi = "Hello, "
         there = "world"
         hi += there
-        self.assertEqual('Hello, world', hi)
+        self.assertEqual(__, hi)
 
     def test_plus_equals_also_leaves_original_string_unmodified(self):
         original = "Hello, "
         hi = original
         there = "world"
         hi += there
-        self.assertEqual('Hello, ', original)
+        self.assertEqual(__, original)
 
     def test_most_strings_interpret_escape_characters(self):
         string = "\n"
         self.assertEqual('\n', string)
         self.assertEqual("""\n""", string)
-        self.assertEqual(1, len(string))
+        self.assertEqual(__, len(string))
diff --git a/koans/about_true_and_false.py b/koans/about_true_and_false.py
index 9467caf51..5f06a63db 100644
--- a/koans/about_true_and_false.py
+++ b/koans/about_true_and_false.py
@@ -12,32 +12,32 @@ def truth_value(self, condition):
             return 'false stuff'
 
     def test_true_is_treated_as_true(self):
-        self.assertEqual('true stuff', self.truth_value(True))
+        self.assertEqual(__, self.truth_value(True))
 
     def test_false_is_treated_as_false(self):
-        self.assertEqual('false stuff', self.truth_value(False))
+        self.assertEqual(__, self.truth_value(False))
 
     def test_none_is_treated_as_false(self):
-        self.assertEqual('false stuff', self.truth_value(None))
+        self.assertEqual(__, self.truth_value(None))
 
     def test_zero_is_treated_as_false(self):
-        self.assertEqual('false stuff', self.truth_value(0))
+        self.assertEqual(__, self.truth_value(0))
 
     def test_empty_collections_are_treated_as_false(self):
-        self.assertEqual('false stuff', self.truth_value([]))
-        self.assertEqual('false stuff', self.truth_value(()))
-        self.assertEqual('false stuff', self.truth_value({}))
-        self.assertEqual('false stuff', self.truth_value(set()))
+        self.assertEqual(__, self.truth_value([]))
+        self.assertEqual(__, self.truth_value(()))
+        self.assertEqual(__, self.truth_value({}))
+        self.assertEqual(__, self.truth_value(set()))
 
     def test_blank_strings_are_treated_as_false(self):
-        self.assertEqual('false stuff', self.truth_value(""))
+        self.assertEqual(__, self.truth_value(""))
 
     def test_everything_else_is_treated_as_true(self):
-        self.assertEqual('true stuff', self.truth_value(1))
-        self.assertEqual('true stuff', self.truth_value([0]))
-        self.assertEqual('true stuff', self.truth_value((0,)))
+        self.assertEqual(__, self.truth_value(1))
+        self.assertEqual(__, self.truth_value([0]))
+        self.assertEqual(__, self.truth_value((0,)))
         self.assertEqual(
-            'true stuff',
+            __,
             self.truth_value("Python is named after Monty Python"))
-        self.assertEqual('true stuff', self.truth_value(' '))
-        self.assertEqual('true stuff', self.truth_value('0'))
+        self.assertEqual(__, self.truth_value(' '))
+        self.assertEqual(__, self.truth_value('0'))
diff --git a/koans/about_tuples.py b/koans/about_tuples.py
index 00711005d..1b38c8f7f 100644
--- a/koans/about_tuples.py
+++ b/koans/about_tuples.py
@@ -6,7 +6,7 @@
 class AboutTuples(Koan):
     def test_creating_a_tuple(self):
         count_of_three =  (1, 2, 5)
-        self.assertEqual(5, count_of_three[2])
+        self.assertEqual(__, count_of_three[2])
 
     def test_tuples_are_immutable_so_item_assignment_is_not_possible(self):
 
@@ -19,12 +19,11 @@ def test_tuples_are_immutable_so_item_assignment_is_not_possible(self):
         # Note, assertRegex() uses regular expression pattern matching,
         # so you don't have to copy the whole message.
 
-        self.assertRegex(msg, "'tuple' object does not support item assignment")
+        self.assertRegex(msg, __)
 
     def test_tuples_are_immutable_so_appending_is_not_possible(self):
         count_of_three =  (1, 2, 5)
-
-        with self.assertRaises(AttributeError): count_of_three.append("boom")
+        with self.assertRaises(___): count_of_three.append("boom")
 
         # Tuples are less flexible than lists, but faster.
 
@@ -35,26 +34,26 @@ def test_tuples_can_only_be_changed_through_replacement(self):
         list_count.append("boom")
         count_of_three = tuple(list_count)
 
-        self.assertEqual((1,2,5, "boom"), count_of_three)
+        self.assertEqual(__, count_of_three)
 
     def test_tuples_of_one_look_peculiar(self):
-        self.assertEqual(int, (1).__class__)
-        self.assertEqual(tuple, (1,).__class__)
-        self.assertEqual(tuple, ("I'm a tuple",).__class__)
-        self.assertEqual(str, ("Not a tuple").__class__)
+        self.assertEqual(__, (1).__class__)
+        self.assertEqual(__, (1,).__class__)
+        self.assertEqual(__, ("I'm a tuple",).__class__)
+        self.assertEqual(__, ("Not a tuple").__class__)
 
     def test_tuple_constructor_can_be_surprising(self):
-        self.assertEqual(('S', 'u', 'r', 'p', 'r', 'i', 's', 'e', '!'), tuple("Surprise!"))
+        self.assertEqual(__, tuple("Surprise!"))
 
     def test_creating_empty_tuples(self):
-        self.assertEqual(() , ())
-        self.assertEqual(() , tuple())  # Sometimes less confusing
+        self.assertEqual(__ , ())
+        self.assertEqual(__ , tuple())  # Sometimes less confusing
 
     def test_tuples_can_be_embedded(self):
         lat = (37, 14, 6, 'N')
         lon = (115, 48, 40, 'W')
         place = ('Area 51', lat, lon)
-        self.assertEqual(('Area 51', (37, 14, 6, 'N'), (115, 48, 40, 'W')), place)
+        self.assertEqual(__, place)
 
     def test_tuples_are_good_for_representing_records(self):
         locations = [
@@ -64,5 +63,5 @@ def test_tuples_are_good_for_representing_records(self):
 
         locations.append( ("Cthulu", (26, 40, 1, 'N'), (70, 45, 7, 'W')) )
 
-        self.assertEqual("Cthulu", locations[2][0])
-        self.assertEqual(15.56, locations[0][1][2])
+        self.assertEqual(__, locations[2][0])
+        self.assertEqual(__, locations[0][1][2])
diff --git a/koans/about_with_statements.py b/koans/about_with_statements.py
index 3eccfbf30..0ae9b5ff8 100644
--- a/koans/about_with_statements.py
+++ b/koans/about_with_statements.py
@@ -22,7 +22,7 @@ def count_lines(self, file_name):
             self.fail()
 
     def test_counting_lines(self):
-        self.assertEqual(4, self.count_lines("example_file.txt"))
+        self.assertEqual(__, self.count_lines("example_file.txt"))
 
     # ------------------------------------------------------------------
 
@@ -41,7 +41,7 @@ def find_line(self, file_name):
             self.fail()
 
     def test_finding_lines(self):
-        self.assertEqual("test\n", self.find_line("example_file.txt"))
+        self.assertEqual(__, self.find_line("example_file.txt"))
 
     ## ------------------------------------------------------------------
     ## THINK ABOUT IT:
@@ -85,21 +85,13 @@ def count_lines2(self, file_name):
             return len(file.readlines())
 
     def test_counting_lines2(self):
-        self.assertEqual(4, self.count_lines2("example_file.txt"))
+        self.assertEqual(__, self.count_lines2("example_file.txt"))
 
     # ------------------------------------------------------------------
 
     def find_line2(self, file_name):
         # Using the context manager self.FileContextManager, rewrite this
         # function to return the first line containing the letter 'e'.
-
-        with self.FileContextManager(file_name) as file:
-            for line in file.readlines():
-                match = re.search('e', line)
-                if match:
-                    return line
-
-
         return None
 
     def test_finding_lines2(self):
@@ -113,4 +105,4 @@ def count_lines3(self, file_name):
             return len(file.readlines())
 
     def test_open_already_has_its_own_built_in_context_manager(self):
-        self.assertEqual(4, self.count_lines3("example_file.txt"))
+        self.assertEqual(__, self.count_lines3("example_file.txt"))
diff --git a/koans/another_local_module.py b/koans/another_local_module.py
index 44c235c8f..242daaa79 100644
--- a/koans/another_local_module.py
+++ b/koans/another_local_module.py
@@ -14,4 +14,4 @@ def name(self):
 class _SecretSquirrel:
     @property
     def name(self):
-        return "Mr Anonymous"
+        return "Mr Anonymous"
\ No newline at end of file
diff --git a/koans/triangle.py b/koans/triangle.py
index 3d21e6336..4d8d66f42 100644
--- a/koans/triangle.py
+++ b/koans/triangle.py
@@ -17,18 +17,8 @@
 #   about_triangle_project_2.py
 #
 def triangle(a, b, c):
-    if a <= 0 or b <= 0 or c <= 0:
-        raise TriangleError("Sides must be greater than 0")
-
-    if (a + b <= c) or (b + c <= a) or (a + c <= b):
-        raise TriangleError("Triangle inequality not satisfied")
-
-    if a == b == c:
-        return 'equilateral'
-    elif a == b or b == c or a == c:
-        return 'isosceles'
-    else:
-        return 'scalene'
+    # DELETE 'PASS' AND WRITE THIS CODE
+    pass
 
 # Error class used in part 2.  No need to change this code.
 class TriangleError(Exception):

From 644c5bbb63487a658e6689c2ae9f28416b37d118 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Tue, 21 Jan 2025 20:51:37 +0800
Subject: [PATCH 49/51] python daily exercise

---
 koans/about_asserts.py | 14 +++++++-------
 koans/about_none.py    | 12 ++++++------
 koans/about_strings.py | 38 +++++++++++++++++++-------------------
 3 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/koans/about_asserts.py b/koans/about_asserts.py
index d17ed0cdf..a85869529 100644
--- a/koans/about_asserts.py
+++ b/koans/about_asserts.py
@@ -14,25 +14,25 @@ def test_assert_truth(self):
         #
         #   http://bit.ly/about_asserts
 
-        self.assertTrue(False) # This should be True
+        self.assertTrue(True) # This should be True
 
     def test_assert_with_message(self):
         """
         Enlightenment may be more easily achieved with appropriate messages.
         """
-        self.assertTrue(False, "This should be True -- Please fix this")
+        self.assertTrue(True, "This should be True -- Please fix this")
 
     def test_fill_in_values(self):
         """
         Sometimes we will ask you to fill in the values
         """
-        self.assertEqual(__, 1 + 1)
+        self.assertEqual(2, 1 + 1)
 
     def test_assert_equality(self):
         """
         To understand reality, we must compare our expectations against reality.
         """
-        expected_value = __
+        expected_value = 2
         actual_value = 1 + 1
         self.assertTrue(expected_value == actual_value)
 
@@ -40,7 +40,7 @@ def test_a_better_way_of_asserting_equality(self):
         """
         Some ways of asserting equality are better than others.
         """
-        expected_value = __
+        expected_value = 2
         actual_value = 1 + 1
 
         self.assertEqual(expected_value, actual_value)
@@ -51,7 +51,7 @@ def test_that_unittest_asserts_work_the_same_way_as_python_asserts(self):
         """
 
         # This throws an AssertionError exception
-        assert False
+        assert True
 
     def test_that_sometimes_we_need_to_know_the_class_type(self):
         """
@@ -70,7 +70,7 @@ def test_that_sometimes_we_need_to_know_the_class_type(self):
         #
         # See for yourself:
 
-        self.assertEqual(__, "navel".__class__) # It's str, not <type 'str'>
+        self.assertEqual(str, "navel".__class__) # It's str, not <type 'str'>
 
         # Need an illustration? More reading can be found here:
         #
diff --git a/koans/about_none.py b/koans/about_none.py
index 1731f0108..740ef00c1 100644
--- a/koans/about_none.py
+++ b/koans/about_none.py
@@ -11,11 +11,11 @@ class AboutNone(Koan):
 
     def test_none_is_an_object(self):
         "Unlike NULL in a lot of languages"
-        self.assertEqual(__, isinstance(None, object))
+        self.assertEqual(True, isinstance(None, object))
 
     def test_none_is_universal(self):
         "There is only one None"
-        self.assertEqual(____, None is None)
+        self.assertEqual(True, None is None)
 
     def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         """
@@ -37,15 +37,15 @@ def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
         #
         #     https://github.com/gregmalcolm/python_koans/wiki/Class-Attribute
 
-        self.assertEqual(__, ex2.__class__)
+        self.assertEqual(AttributeError, ex2.__class__)
 
         # What message was attached to the exception?
         # (HINT: replace __ with part of the error message.)
-        self.assertRegex(ex2.args[0], __)
+        self.assertRegex(ex2.args[0], "'NoneType' object has no attribute 'some_method_none_does_not_know_about'")
 
     def test_none_is_distinct(self):
         """
         None is distinct from other things which are False.
         """
-        self.assertEqual(__, None is not 0)
-        self.assertEqual(__, None is not False)
+        self.assertEqual(True, None is not 0)
+        self.assertEqual(True, None is not False)
diff --git a/koans/about_strings.py b/koans/about_strings.py
index 25f5f59df..202506a6a 100644
--- a/koans/about_strings.py
+++ b/koans/about_strings.py
@@ -7,88 +7,88 @@ class AboutStrings(Koan):
 
     def test_double_quoted_strings_are_strings(self):
         string = "Hello, world."
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_single_quoted_strings_are_also_strings(self):
         string = 'Goodbye, world.'
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_triple_quote_strings_are_also_strings(self):
         string = """Howdy, world!"""
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_triple_single_quotes_work_too(self):
         string = '''Bonjour tout le monde!'''
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_raw_strings_are_also_strings(self):
         string = r"Konnichi wa, world!"
-        self.assertEqual(__, isinstance(string, str))
+        self.assertEqual(True, isinstance(string, str))
 
     def test_use_single_quotes_to_create_string_with_double_quotes(self):
         string = 'He said, "Go Away."'
-        self.assertEqual(__, string)
+        self.assertEqual('He said, "Go Away."', string)
 
     def test_use_double_quotes_to_create_strings_with_single_quotes(self):
         string = "Don't"
-        self.assertEqual(__, string)
+        self.assertEqual("Don't", string)
 
     def test_use_backslash_for_escaping_quotes_in_strings(self):
         a = "He said, \"Don't\""
         b = 'He said, "Don\'t"'
-        self.assertEqual(__, (a == b))
+        self.assertEqual(True, (a == b))
 
     def test_use_backslash_at_the_end_of_a_line_to_continue_onto_the_next_line(self):
         string = "It was the best of times,\n\
 It was the worst of times."
-        self.assertEqual(__, len(string))
+        self.assertEqual(52, len(string))
 
     def test_triple_quoted_strings_can_span_lines(self):
         string = """
 Howdy,
 world!
 """
-        self.assertEqual(__, len(string))
+        self.assertEqual(15, len(string))
 
     def test_triple_quoted_strings_need_less_escaping(self):
         a = "Hello \"world\"."
         b = """Hello "world"."""
-        self.assertEqual(__, (a == b))
+        self.assertEqual(True, (a == b))
 
     def test_escaping_quotes_at_the_end_of_triple_quoted_string(self):
         string = """Hello "world\""""
-        self.assertEqual(__, string)
+        self.assertEqual('Hello "world"', string)
 
     def test_plus_concatenates_strings(self):
         string = "Hello, " + "world"
-        self.assertEqual(__, string)
+        self.assertEqual("Hello, world", string)
 
     def test_adjacent_strings_are_concatenated_automatically(self):
         string = "Hello" ", " "world"
-        self.assertEqual(__, string)
+        self.assertEqual("Hello, world", string)
 
     def test_plus_will_not_modify_original_strings(self):
         hi = "Hello, "
         there = "world"
         string = hi + there
-        self.assertEqual(__, hi)
-        self.assertEqual(__, there)
+        self.assertEqual("Hello, ", hi)
+        self.assertEqual("world", there)
 
     def test_plus_equals_will_append_to_end_of_string(self):
         hi = "Hello, "
         there = "world"
         hi += there
-        self.assertEqual(__, hi)
+        self.assertEqual("Hello, world", hi)
 
     def test_plus_equals_also_leaves_original_string_unmodified(self):
         original = "Hello, "
         hi = original
         there = "world"
         hi += there
-        self.assertEqual(__, original)
+        self.assertEqual("Hello, ", original)
 
     def test_most_strings_interpret_escape_characters(self):
         string = "\n"
         self.assertEqual('\n', string)
         self.assertEqual("""\n""", string)
-        self.assertEqual(__, len(string))
+        self.assertEqual(1, len(string))

From 008acc89450dac1205fea81942cfd40e3eb9f0e7 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Wed, 22 Jan 2025 23:39:51 +0800
Subject: [PATCH 50/51] daily python exercise - quick review

---
 koans/about_lists.py | 66 ++++++++++++++++++++++----------------------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/koans/about_lists.py b/koans/about_lists.py
index 61cc3bb29..bcdb09004 100644
--- a/koans/about_lists.py
+++ b/koans/about_lists.py
@@ -11,7 +11,7 @@ class AboutLists(Koan):
     def test_creating_lists(self):
         empty_list = list()
         self.assertEqual(list, type(empty_list))
-        self.assertEqual(__, len(empty_list))
+        self.assertEqual(0, len(empty_list))
 
     def test_list_literals(self):
         nums = list()
@@ -21,70 +21,70 @@ def test_list_literals(self):
         self.assertEqual([1], nums)
 
         nums[1:] = [2]
-        self.assertListEqual([1, __], nums)
+        self.assertListEqual([1, 2], nums)
 
         nums.append(333)
-        self.assertListEqual([1, 2, __], nums)
+        self.assertListEqual([1, 2, 333], nums)
 
     def test_accessing_list_elements(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(__, noms[0])
-        self.assertEqual(__, noms[3])
-        self.assertEqual(__, noms[-1])
-        self.assertEqual(__, noms[-3])
+        self.assertEqual("peanut", noms[0])
+        self.assertEqual("jelly", noms[3])
+        self.assertEqual("jelly", noms[-1])
+        self.assertEqual("butter", noms[-3])
 
     def test_slicing_lists(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(__, noms[0:1])
-        self.assertEqual(__, noms[0:2])
-        self.assertEqual(__, noms[2:2])
-        self.assertEqual(__, noms[2:20])
-        self.assertEqual(__, noms[4:0])
-        self.assertEqual(__, noms[4:100])
-        self.assertEqual(__, noms[5:0])
+        self.assertEqual(["peanut"], noms[0:1])
+        self.assertEqual(["peanut", "butter"], noms[0:2])
+        self.assertEqual([], noms[2:2])
+        self.assertEqual(["and", "jelly"], noms[2:20])
+        self.assertEqual([], noms[4:0])
+        self.assertEqual([], noms[4:100])
+        self.assertEqual([], noms[5:0])
 
     def test_slicing_to_the_edge(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(__, noms[2:])
-        self.assertEqual(__, noms[:2])
+        self.assertEqual(['and', 'jelly'], noms[2:])
+        self.assertEqual(['peanut', 'butter'], noms[:2])
 
     def test_lists_and_ranges(self):
         self.assertEqual(range, type(range(5)))
         self.assertNotEqual([1, 2, 3, 4, 5], range(1,6))
-        self.assertEqual(__, list(range(5)))
-        self.assertEqual(__, list(range(5, 9)))
+        self.assertEqual([0, 1, 2, 3, 4], list(range(5)))
+        self.assertEqual([5, 6, 7, 8], list(range(5, 9)))
 
     def test_ranges_with_steps(self):
-        self.assertEqual(__, list(range(5, 3, -1)))
-        self.assertEqual(__, list(range(0, 8, 2)))
-        self.assertEqual(__, list(range(1, 8, 3)))
-        self.assertEqual(__, list(range(5, -7, -4)))
-        self.assertEqual(__, list(range(5, -8, -4)))
+        self.assertEqual([5,4], list(range(5, 3, -1)))
+        self.assertEqual([0, 2, 4, 6], list(range(0, 8, 2)))
+        self.assertEqual([1, 4, 7], list(range(1, 8, 3)))
+        self.assertEqual([5, 1, -3], list(range(5, -7, -4)))
+        self.assertEqual([5, 1, -3, -7], list(range(5, -8, -4)))
 
     def test_insertions(self):
         knight = ['you', 'shall', 'pass']
         knight.insert(2, 'not')
-        self.assertEqual(__, knight)
+        self.assertEqual(['you', 'shall',  'not', 'pass'], knight)
 
         knight.insert(0, 'Arthur')
-        self.assertEqual(__, knight)
+        self.assertEqual(['Arthur', 'you', 'shall', 'not', 'pass'], knight)
 
     def test_popping_lists(self):
         stack = [10, 20, 30, 40]
         stack.append('last')
 
-        self.assertEqual(__, stack)
+        self.assertEqual([10, 20, 30, 40, 'last'], stack)
 
         popped_value = stack.pop()
-        self.assertEqual(__, popped_value)
-        self.assertEqual(__, stack)
+        self.assertEqual('last', popped_value)
+        self.assertEqual([10, 20, 30, 40], stack)
 
         popped_value = stack.pop(1)
-        self.assertEqual(__, popped_value)
-        self.assertEqual(__, stack)
+        self.assertEqual(20, popped_value)
+        self.assertEqual([10, 30, 40], stack)
 
         # Notice that there is a "pop" but no "push" in python?
 
@@ -98,11 +98,11 @@ def test_making_queues(self):
         queue = [1, 2]
         queue.append('last')
 
-        self.assertEqual(__, queue)
+        self.assertEqual([1, 2, 'last'], queue)
 
         popped_value = queue.pop(0)
-        self.assertEqual(__, popped_value)
-        self.assertEqual(__, queue)
+        self.assertEqual(1, popped_value)
+        self.assertEqual([2,'last'], queue)
 
         # Note, popping from the left hand side of a list is
         # inefficient. Use collections.deque instead.

From 5c4a770134b8cf1a8f4b1ffdeb0feae98cafbb45 Mon Sep 17 00:00:00 2001
From: kulapoo <kulaskulapoo@gmail.com>
Date: Sun, 26 Jan 2025 03:28:47 +0800
Subject: [PATCH 51/51] python daily exercise

---
 koans/about_comprehension.py       | 12 ++++-----
 koans/about_control_statements.py  | 19 +++++++-------
 koans/about_dictionaries.py        | 30 +++++++++++-----------
 koans/about_exceptions.py          | 29 +++++++++-------------
 koans/about_iteration.py           | 32 ++++++++++++------------
 koans/about_list_assignments.py    | 27 ++++++++++----------
 koans/about_lists.py               | 21 ++++++++--------
 koans/about_methods.py             | 39 +++++++++++++++--------------
 koans/about_sets.py                | 40 ++++++++++++++++--------------
 koans/about_string_manipulation.py | 34 ++++++++++++-------------
 koans/about_true_and_false.py      | 30 +++++++++++-----------
 koans/about_tuples.py              | 28 ++++++++++-----------
 koans/triangle.py                  | 24 +++++++++++++++++-
 13 files changed, 193 insertions(+), 172 deletions(-)

diff --git a/koans/about_comprehension.py b/koans/about_comprehension.py
index e5add6d9e..adbbf5537 100644
--- a/koans/about_comprehension.py
+++ b/koans/about_comprehension.py
@@ -13,8 +13,8 @@ def test_creating_lists_with_list_comprehensions(self):
 
         comprehension = [delicacy.capitalize() for delicacy in feast]
 
-        self.assertEqual(__, comprehension[0])
-        self.assertEqual(__, comprehension[2])
+        self.assertEqual('Lambs', comprehension[0])
+        self.assertEqual('Orangutans', comprehension[2])
 
     def test_filtering_lists_with_list_comprehensions(self):
         feast = ['spam', 'sloths', 'orangutans', 'breakfast cereals',
@@ -22,15 +22,15 @@ def test_filtering_lists_with_list_comprehensions(self):
 
         comprehension = [delicacy for delicacy in feast if len(delicacy) > 6]
 
-        self.assertEqual(__, len(feast))
-        self.assertEqual(__, len(comprehension))
+        self.assertEqual(5, len(feast))
+        self.assertEqual(3, len(comprehension))
 
     def test_unpacking_tuples_in_list_comprehensions(self):
         list_of_tuples = [(1, 'lumberjack'), (2, 'inquisition'), (4, 'spam')]
         comprehension = [ skit * number for number, skit in list_of_tuples ]
 
-        self.assertEqual(__, comprehension[0])
-        self.assertEqual(__, comprehension[2])
+        self.assertEqual('lumberjack', comprehension[0])
+        self.assertEqual('spamspamspam', comprehension[2])
 
     def test_double_list_comprehension(self):
         list_of_eggs = ['poached egg', 'fried egg']
diff --git a/koans/about_control_statements.py b/koans/about_control_statements.py
index 842c8d91f..f0835f8ea 100644
--- a/koans/about_control_statements.py
+++ b/koans/about_control_statements.py
@@ -10,13 +10,13 @@ def test_if_then_else_statements(self):
             result = 'true value'
         else:
             result = 'false value'
-        self.assertEqual(__, result)
+        self.assertEqual('true value', result)
 
     def test_if_then_statements(self):
         result = 'default value'
         if True:
             result = 'true value'
-        self.assertEqual(__, result)
+        self.assertEqual('true value', result)
 
     def test_if_then_elif_else_statements(self):
         if False:
@@ -25,7 +25,7 @@ def test_if_then_elif_else_statements(self):
             result = 'true value'
         else:
             result = 'default value'
-        self.assertEqual(__, result)
+        self.assertEqual('true value', result)
 
     def test_while_statement(self):
         i = 1
@@ -33,16 +33,17 @@ def test_while_statement(self):
         while i <= 10:
             result = result * i
             i += 1
-        self.assertEqual(__, result)
+        self.assertEqual(3628800, result)
 
     def test_break_statement(self):
         i = 1
         result = 1
         while True:
-            if i > 10: break
+            if i > 10:
+                break
             result = result * i
             i += 1
-        self.assertEqual(__, result)
+        self.assertEqual(3628800, result)
 
     def test_continue_statement(self):
         i = 0
@@ -51,14 +52,14 @@ def test_continue_statement(self):
             i += 1
             if (i % 2) == 0: continue
             result.append(i)
-        self.assertEqual(__, result)
+        self.assertEqual([1, 3, 5, 7, 9], result)
 
     def test_for_statement(self):
         phrase = ["fish", "and", "chips"]
         result = []
         for item in phrase:
             result.append(item.upper())
-        self.assertEqual([__, __, __], result)
+        self.assertEqual(["FISH", "AND", "CHIPS"], result)
 
     def test_for_statement_with_tuples(self):
         round_table = [
@@ -71,7 +72,7 @@ def test_for_statement_with_tuples(self):
         for knight, answer in round_table:
             result.append("Contestant: '" + knight + "'   Answer: '" + answer + "'")
 
-        text = __
+        text = "Blue! I mean Green!"
 
         self.assertRegex(result[2], text)
 
diff --git a/koans/about_dictionaries.py b/koans/about_dictionaries.py
index da1ed6bfe..c87c739dc 100644
--- a/koans/about_dictionaries.py
+++ b/koans/about_dictionaries.py
@@ -12,46 +12,46 @@ def test_creating_dictionaries(self):
         empty_dict = dict()
         self.assertEqual(dict, type(empty_dict))
         self.assertDictEqual({}, empty_dict)
-        self.assertEqual(__, len(empty_dict))
+        self.assertEqual(0, len(empty_dict))
 
     def test_dictionary_literals(self):
         empty_dict = {}
         self.assertEqual(dict, type(empty_dict))
         babel_fish = { 'one': 'uno', 'two': 'dos' }
-        self.assertEqual(__, len(babel_fish))
+        self.assertEqual(2, len(babel_fish))
 
     def test_accessing_dictionaries(self):
         babel_fish = { 'one': 'uno', 'two': 'dos' }
-        self.assertEqual(__, babel_fish['one'])
-        self.assertEqual(__, babel_fish['two'])
+        self.assertEqual("uno", babel_fish['one'])
+        self.assertEqual("dos", babel_fish['two'])
 
     def test_changing_dictionaries(self):
         babel_fish = { 'one': 'uno', 'two': 'dos' }
         babel_fish['one'] = 'eins'
 
-        expected = { 'two': 'dos', 'one': __ }
+        expected = { 'two': 'dos', 'one': "eins" }
         self.assertDictEqual(expected, babel_fish)
 
     def test_dictionary_is_unordered(self):
         dict1 = { 'one': 'uno', 'two': 'dos' }
         dict2 = { 'two': 'dos', 'one': 'uno' }
 
-        self.assertEqual(__, dict1 == dict2)
+        self.assertEqual(True, dict1 == dict2)
 
 
     def test_dictionary_keys_and_values(self):
         babel_fish = {'one': 'uno', 'two': 'dos'}
-        self.assertEqual(__, len(babel_fish.keys()))
-        self.assertEqual(__, len(babel_fish.values()))
-        self.assertEqual(__, 'one' in babel_fish.keys())
-        self.assertEqual(__, 'two' in babel_fish.values())
-        self.assertEqual(__, 'uno' in babel_fish.keys())
-        self.assertEqual(__, 'dos' in babel_fish.values())
+        self.assertEqual(2, len(babel_fish.keys()))
+        self.assertEqual(2, len(babel_fish.values()))
+        self.assertEqual(True, 'one' in babel_fish.keys())
+        self.assertEqual(False, 'two' in babel_fish.values())
+        self.assertEqual(False, 'uno' in babel_fish.keys())
+        self.assertEqual(True, 'dos' in babel_fish.values())
 
     def test_making_a_dictionary_from_a_sequence_of_keys(self):
         cards = {}.fromkeys(('red warrior', 'green elf', 'blue valkyrie', 'yellow dwarf', 'confused looking zebra'), 42)
 
-        self.assertEqual(__, len(cards))
-        self.assertEqual(__, cards['green elf'])
-        self.assertEqual(__, cards['yellow dwarf'])
+        self.assertEqual(5, len(cards))
+        self.assertEqual(42, cards['green elf'])
+        self.assertEqual(42, cards['yellow dwarf'])
 
diff --git a/koans/about_exceptions.py b/koans/about_exceptions.py
index d321bbc50..ed8469d0f 100644
--- a/koans/about_exceptions.py
+++ b/koans/about_exceptions.py
@@ -10,10 +10,10 @@ class MySpecialError(RuntimeError):
 
     def test_exceptions_inherit_from_exception(self):
         mro = self.MySpecialError.mro()
-        self.assertEqual(__, mro[1].__name__)
-        self.assertEqual(__, mro[2].__name__)
-        self.assertEqual(__, mro[3].__name__)
-        self.assertEqual(__, mro[4].__name__)
+        self.assertEqual('RuntimeError', mro[1].__name__)
+        self.assertEqual('Exception', mro[2].__name__)
+        self.assertEqual('BaseException', mro[3].__name__)
+        self.assertEqual('object', mro[4].__name__)
 
     def test_try_clause(self):
         result = None
@@ -21,18 +21,14 @@ def test_try_clause(self):
             self.fail("Oops")
         except Exception as ex:
             result = 'exception handled'
-
             ex2 = ex
 
-        self.assertEqual(__, result)
-
-        self.assertEqual(__, isinstance(ex2, Exception))
-        self.assertEqual(__, isinstance(ex2, RuntimeError))
-
+        self.assertEqual('exception handled', result)
+        self.assertEqual(True, isinstance(ex2, Exception))
+        self.assertEqual(False, isinstance(ex2, RuntimeError))
         self.assertTrue(issubclass(RuntimeError, Exception), \
             "RuntimeError is a subclass of Exception")
-
-        self.assertEqual(__, ex2.args[0])
+        self.assertEqual('Oops', ex2.args[0])
 
     def test_raising_a_specific_error(self):
         result = None
@@ -42,8 +38,8 @@ def test_raising_a_specific_error(self):
             result = 'exception handled'
             msg = ex.args[0]
 
-        self.assertEqual(__, result)
-        self.assertEqual(__, msg)
+        self.assertEqual('exception handled', result)
+        self.assertEqual('My Message', msg)
 
     def test_else_clause(self):
         result = None
@@ -55,8 +51,7 @@ def test_else_clause(self):
         else:
             result = 'no damage done'
 
-        self.assertEqual(__, result)
-
+        self.assertEqual('no damage done', result)
 
     def test_finally_clause(self):
         result = None
@@ -68,4 +63,4 @@ def test_finally_clause(self):
         finally:
             result = 'always run'
 
-        self.assertEqual(__, result)
+        self.assertEqual('always run', result)
diff --git a/koans/about_iteration.py b/koans/about_iteration.py
index 1faca8e33..0347f4915 100644
--- a/koans/about_iteration.py
+++ b/koans/about_iteration.py
@@ -13,20 +13,20 @@ def test_iterators_are_a_type(self):
         for num in it:
             total += num
 
-        self.assertEqual(__ , total)
+        self.assertEqual(15 , total)
 
     def test_iterating_with_next(self):
         stages = iter(['alpha','beta','gamma'])
 
         try:
-            self.assertEqual(__, next(stages))
+            self.assertEqual('alpha', next(stages))
             next(stages)
-            self.assertEqual(__, next(stages))
+            self.assertEqual('gamma', next(stages))
             next(stages)
         except StopIteration as ex:
             err_msg = 'Ran out of iterations'
 
-        self.assertRegex(err_msg, __)
+        self.assertRegex(err_msg, "Ran out of iterations")
 
     # ------------------------------------------------------------------
 
@@ -40,14 +40,14 @@ def test_map_transforms_elements_of_a_list(self):
         mapping = map(self.add_ten, seq)
 
         self.assertNotEqual(list, mapping.__class__)
-        self.assertEqual(__, mapping.__class__)
+        self.assertEqual(map, mapping.__class__)
         # In Python 3 built in iterator funcs return iterable view objects
         # instead of lists
 
         for item in mapping:
             mapped_seq.append(item)
 
-        self.assertEqual(__, mapped_seq)
+        self.assertEqual([11,12,13], mapped_seq)
 
         # Note, iterator methods actually return objects of iter type in
         # python 3. In python 2 map() would give you a list.
@@ -62,7 +62,7 @@ def is_even(item):
         for item in filter(is_even, seq):
             even_numbers.append(item)
 
-        self.assertEqual(__, even_numbers)
+        self.assertEqual([2, 4, 6], even_numbers)
 
     def test_filter_returns_all_items_matching_criterion(self):
         def is_big_name(item):
@@ -71,8 +71,8 @@ def is_big_name(item):
         names = ["Jim", "Bill", "Clarence", "Doug", "Eli", "Elizabeth"]
         iterator = filter(is_big_name, names)
 
-        self.assertEqual(__, next(iterator))
-        self.assertEqual(__, next(iterator))
+        self.assertEqual("Clarence", next(iterator))
+        self.assertEqual("Elizabeth", next(iterator))
 
         try:
             next(iterator)
@@ -80,7 +80,7 @@ def is_big_name(item):
         except StopIteration:
             msg = 'Ran out of big names'
 
-        self.assertEquals(__, msg)
+        self.assertEqual('Ran out of big names', msg)
 
     # ------------------------------------------------------------------
 
@@ -96,13 +96,13 @@ def test_reduce_will_blow_your_mind(self):
         # to the functools module.
 
         result = functools.reduce(self.add, [2, 3, 4])
-        self.assertEqual(__, result.__class__)
+        self.assertEqual(int, result.__class__)
         # Reduce() syntax is same as Python 2
 
-        self.assertEqual(__, result)
+        self.assertEqual(9, result)
 
         result2 = functools.reduce(self.multiply, [2, 3, 4], 1)
-        self.assertEqual(__, result2)
+        self.assertEqual(24, result2)
 
         # Extra Credit:
         # Describe in your own words what reduce does.
@@ -113,14 +113,14 @@ def test_use_pass_for_iterations_with_no_body(self):
         for num in range(1,5):
             pass
 
-        self.assertEqual(__, num)
+        self.assertEqual(4, num)
 
     # ------------------------------------------------------------------
 
     def test_all_iteration_methods_work_on_any_sequence_not_just_lists(self):
         # Ranges are an iterable sequence
         result = map(self.add_ten, range(1,4))
-        self.assertEqual(__, list(result))
+        self.assertEqual([11, 12, 13], list(result))
 
     def test_lines_in_a_file_are_iterable_sequences_too(self):
         def make_upcase(line):
@@ -128,5 +128,5 @@ def make_upcase(line):
 
         file = open("example_file.txt")
         upcase_lines = map(make_upcase, file.readlines())
-        self.assertEqual(__, list(upcase_lines))
+        self.assertEqual(['This', 'Is', 'A', 'Test'], list(upcase_lines))
         file.close()
diff --git a/koans/about_list_assignments.py b/koans/about_list_assignments.py
index 8a8d48090..bdac9ddf7 100644
--- a/koans/about_list_assignments.py
+++ b/koans/about_list_assignments.py
@@ -10,34 +10,33 @@
 class AboutListAssignments(Koan):
     def test_non_parallel_assignment(self):
         names = ["John", "Smith"]
-        self.assertEqual(__, names)
+        self.assertEqual(["John", "Smith"], names)
 
     def test_parallel_assignments(self):
         first_name, last_name = ["John", "Smith"]
-        self.assertEqual(__, first_name)
-        self.assertEqual(__, last_name)
+        self.assertEqual("John", first_name)
+        self.assertEqual("Smith", last_name)
 
     def test_parallel_assignments_with_extra_values(self):
         title, *first_names, last_name = ["Sir", "Ricky", "Bobby", "Worthington"]
-        self.assertEqual(__, title)
-        self.assertEqual(__, first_names)
-        self.assertEqual(__, last_name)
+        self.assertEqual("Sir", title)
+        self.assertEqual(["Ricky", "Bobby"], first_names)
+        self.assertEqual("Worthington", last_name)
 
     def test_parallel_assignments_with_fewer_values(self):
         title, *first_names, last_name = ["Mr", "Bond"]
-        self.assertEqual(__, title)
-        self.assertEqual(__, first_names)
-        self.assertEqual(__, last_name)
+        self.assertEqual("Mr", title)
+        self.assertEqual([], first_names)
+        self.assertEqual("Bond", last_name)
 
     def test_parallel_assignments_with_sublists(self):
         first_name, last_name = [["Willie", "Rae"], "Johnson"]
-        self.assertEqual(__, first_name)
-        self.assertEqual(__, last_name)
+        self.assertEqual(["Willie", "Rae"], first_name)
+        self.assertEqual("Johnson", last_name)
 
     def test_swapping_with_parallel_assignment(self):
         first_name = "Roy"
         last_name = "Rob"
         first_name, last_name = last_name, first_name
-        self.assertEqual(__, first_name)
-        self.assertEqual(__, last_name)
-
+        self.assertEqual("Rob", first_name)
+        self.assertEqual("Roy", last_name)
diff --git a/koans/about_lists.py b/koans/about_lists.py
index bcdb09004..9e405a42d 100644
--- a/koans/about_lists.py
+++ b/koans/about_lists.py
@@ -29,18 +29,18 @@ def test_list_literals(self):
     def test_accessing_list_elements(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual("peanut", noms[0])
-        self.assertEqual("jelly", noms[3])
-        self.assertEqual("jelly", noms[-1])
-        self.assertEqual("butter", noms[-3])
+        self.assertEqual('peanut', noms[0])
+        self.assertEqual('jelly', noms[3])
+        self.assertEqual('jelly', noms[-1])
+        self.assertEqual('butter', noms[-3])
 
     def test_slicing_lists(self):
         noms = ['peanut', 'butter', 'and', 'jelly']
 
-        self.assertEqual(["peanut"], noms[0:1])
-        self.assertEqual(["peanut", "butter"], noms[0:2])
+        self.assertEqual(['peanut'], noms[0:1])
+        self.assertEqual(['peanut', 'butter'], noms[0:2])
         self.assertEqual([], noms[2:2])
-        self.assertEqual(["and", "jelly"], noms[2:20])
+        self.assertEqual(['and', 'jelly'], noms[2:20])
         self.assertEqual([], noms[4:0])
         self.assertEqual([], noms[4:100])
         self.assertEqual([], noms[5:0])
@@ -58,7 +58,7 @@ def test_lists_and_ranges(self):
         self.assertEqual([5, 6, 7, 8], list(range(5, 9)))
 
     def test_ranges_with_steps(self):
-        self.assertEqual([5,4], list(range(5, 3, -1)))
+        self.assertEqual([5, 4], list(range(5, 3, -1)))
         self.assertEqual([0, 2, 4, 6], list(range(0, 8, 2)))
         self.assertEqual([1, 4, 7], list(range(1, 8, 3)))
         self.assertEqual([5, 1, -3], list(range(5, -7, -4)))
@@ -67,7 +67,7 @@ def test_ranges_with_steps(self):
     def test_insertions(self):
         knight = ['you', 'shall', 'pass']
         knight.insert(2, 'not')
-        self.assertEqual(['you', 'shall',  'not', 'pass'], knight)
+        self.assertEqual(['you', 'shall', 'not', 'pass'], knight)
 
         knight.insert(0, 'Arthur')
         self.assertEqual(['Arthur', 'you', 'shall', 'not', 'pass'], knight)
@@ -102,8 +102,7 @@ def test_making_queues(self):
 
         popped_value = queue.pop(0)
         self.assertEqual(1, popped_value)
-        self.assertEqual([2,'last'], queue)
+        self.assertEqual([2, 'last'], queue)
 
         # Note, popping from the left hand side of a list is
         # inefficient. Use collections.deque instead.
-
diff --git a/koans/about_methods.py b/koans/about_methods.py
index 796a07ea5..1ea8c4916 100644
--- a/koans/about_methods.py
+++ b/koans/about_methods.py
@@ -12,7 +12,7 @@ def my_global_function(a,b):
 
 class AboutMethods(Koan):
     def test_calling_a_global_function(self):
-        self.assertEqual(__, my_global_function(2,3))
+        self.assertEqual(5, my_global_function(2,3))
 
     # NOTE: Wrong number of arguments is not a SYNTAX error, but a
     # runtime error.
@@ -33,7 +33,7 @@ def test_calling_functions_with_wrong_number_of_arguments(self):
             msg = e.args[0]
 
         # Note, watch out for parenthesis. They need slashes in front!
-        self.assertRegex(msg, __)
+        self.assertRegex(msg, r'my_global_function\(\) takes 2 positional arguments but 3 were given')
 
     # ------------------------------------------------------------------
 
@@ -41,7 +41,7 @@ def pointless_method(self, a, b):
         sum = a + b
 
     def test_which_does_not_return_anything(self):
-        self.assertEqual(__, self.pointless_method(1, 2))
+        self.assertEqual(None, self.pointless_method(1, 2))
         # Notice that methods accessed from class scope do not require
         # you to pass the first "self" argument?
 
@@ -51,8 +51,8 @@ def method_with_defaults(self, a, b='default_value'):
         return [a, b]
 
     def test_calling_with_default_values(self):
-        self.assertEqual(__, self.method_with_defaults(1))
-        self.assertEqual(__, self.method_with_defaults(1, 2))
+        self.assertEqual([1, 'default_value'], self.method_with_defaults(1))
+        self.assertEqual([1,2], self.method_with_defaults(1, 2))
 
     # ------------------------------------------------------------------
 
@@ -60,9 +60,9 @@ def method_with_var_args(self, *args):
         return args
 
     def test_calling_with_variable_arguments(self):
-        self.assertEqual(__, self.method_with_var_args())
+        self.assertEqual((), self.method_with_var_args())
         self.assertEqual(('one',), self.method_with_var_args('one'))
-        self.assertEqual(__, self.method_with_var_args('one', 'two'))
+        self.assertEqual(('one', 'two'), self.method_with_var_args('one', 'two'))
 
     # ------------------------------------------------------------------
 
@@ -73,13 +73,13 @@ def test_functions_without_self_arg_are_global_functions(self):
         def function_with_the_same_name(a, b):
             return a * b
 
-        self.assertEqual(__, function_with_the_same_name(3,4))
+        self.assertEqual(12, function_with_the_same_name(3,4))
 
     def test_calling_methods_in_same_class_with_explicit_receiver(self):
         def function_with_the_same_name(a, b):
             return a * b
 
-        self.assertEqual(__, self.function_with_the_same_name(3,4))
+        self.assertEqual(7, self.function_with_the_same_name(3,4))
 
     # ------------------------------------------------------------------
 
@@ -92,10 +92,10 @@ def another_method_with_the_same_name(self):
         return 42
 
     def test_that_old_methods_are_hidden_by_redefinitions(self):
-        self.assertEqual(__, self.another_method_with_the_same_name())
+        self.assertEqual(42, self.another_method_with_the_same_name())
 
     def test_that_overlapped_method_is_still_there(self):
-        self.assertEqual(__, self.link_to_overlapped_method())
+        self.assertEqual(10, self.link_to_overlapped_method())
 
     # ------------------------------------------------------------------
 
@@ -103,21 +103,21 @@ def empty_method(self):
         pass
 
     def test_methods_that_do_nothing_need_to_use_pass_as_a_filler(self):
-        self.assertEqual(__, self.empty_method())
+        self.assertEqual(None, self.empty_method())
 
     def test_pass_does_nothing_at_all(self):
         "You"
         "shall"
         "not"
         pass
-        self.assertEqual(____, "Still got to this line" != None)
+        self.assertEqual(True, "Still got to this line" != None)
 
     # ------------------------------------------------------------------
 
     def one_line_method(self): return 'Madagascar'
 
     def test_no_indentation_required_for_one_line_statement_bodies(self):
-        self.assertEqual(__, self.one_line_method())
+        self.assertEqual('Madagascar', self.one_line_method())
 
     # ------------------------------------------------------------------
 
@@ -126,7 +126,7 @@ def method_with_documentation(self):
         return "ok"
 
     def test_the_documentation_can_be_viewed_with_the_doc_method(self):
-        self.assertRegex(self.method_with_documentation.__doc__, __)
+        self.assertRegex(self.method_with_documentation.__doc__, "A string placed at the beginning of a function is used for documentation")
 
     # ------------------------------------------------------------------
 
@@ -143,20 +143,21 @@ def __password(self):
 
     def test_calling_methods_in_other_objects(self):
         rover = self.Dog()
-        self.assertEqual(__, rover.name())
+        self.assertEqual("Fido", rover.name())
 
     def test_private_access_is_implied_but_not_enforced(self):
         rover = self.Dog()
 
         # This is a little rude, but legal
-        self.assertEqual(__, rover._tail())
+        self.assertEqual("wagging", rover._tail())
 
     def test_attributes_with_double_underscore_prefixes_are_subject_to_name_mangling(self):
         rover = self.Dog()
-        with self.assertRaises(___): password = rover.__password()
+
+        with self.assertRaises(AttributeError): password = rover.__password()
 
         # But this still is!
-        self.assertEqual(__, rover._Dog__password())
+        self.assertEqual("password", rover._Dog__password())
 
         # Name mangling exists to avoid name clash issues when subclassing.
         # It is not for providing effective access protection
diff --git a/koans/about_sets.py b/koans/about_sets.py
index 87cf10959..99abe75e2 100644
--- a/koans/about_sets.py
+++ b/koans/about_sets.py
@@ -9,47 +9,51 @@ def test_sets_make_keep_lists_unique(self):
 
         there_can_only_be_only_one = set(highlanders)
 
-        self.assertEqual(__, there_can_only_be_only_one)
+        self.assertEqual({'MacLeod', 'Matunas', 'Malcolm', 'Ramirez'}, there_can_only_be_only_one)
 
     def test_empty_sets_have_different_syntax_to_populated_sets(self):
-        self.assertEqual(__, {1, 2, 3})
-        self.assertEqual(__, set())
+        self.assertEqual({1, 2, 3}, {1, 2, 3})
+        self.assertEqual(set(), set())
 
     def test_dictionaries_and_sets_use_same_curly_braces(self):
         # Note: Literal sets using braces were introduced in python 3.
         #       They were also backported to python 2.7.
 
-        self.assertEqual(__, {1, 2, 3}.__class__)
-        self.assertEqual(__, {'one': 1, 'two': 2}.__class__)
+        self.assertEqual(set, {1, 2, 3}.__class__)
+        self.assertEqual(dict, {'one': 1, 'two': 2}.__class__)
 
-        self.assertEqual(__, {}.__class__)
+        self.assertEqual(dict, {}.__class__)
 
     def test_creating_sets_using_strings(self):
-        self.assertEqual(__, {'12345'})
-        self.assertEqual(__, set('12345'))
+        self.assertEqual({'12345'}, {'12345'})
+        self.assertEqual({'1', '2', '3', '4', '5'}, set('12345'))
 
     def test_convert_the_set_into_a_list_to_sort_it(self):
-        self.assertEqual(__, sorted(set('12345')))
+        self.assertEqual(['1', '2', '3', '4', '5'], sorted(set('12354')))
 
     # ------------------------------------------------------------------
 
+    # - (difference): scotsmen - warriors ->> returns elements in scotsmen that aren't in warriors = {'Willie'}
+    # | (union): scotsmen | warriors ->> combines all unique elements from both sets = {'Willie', 'Wallace', 'Leonidas', 'MacLeod'}
+    # & (intersection): scotsmen & warriors ->> returns common elements = {'Wallace', 'MacLeod'}
+    # ^ (symmetric difference): scotsmen ^ warriors ->> returns elements in either set but not both = {'Willie', 'Leonidas'}
     def test_set_have_arithmetic_operators(self):
         scotsmen = {'MacLeod', 'Wallace', 'Willie'}
         warriors = {'MacLeod', 'Wallace', 'Leonidas'}
 
-        self.assertEqual(__, scotsmen - warriors)
-        self.assertEqual(__, scotsmen | warriors)
-        self.assertEqual(__, scotsmen & warriors)
-        self.assertEqual(__, scotsmen ^ warriors)
+        self.assertEqual({'Willie'}, scotsmen - warriors)
+        self.assertEqual({'Willie', 'Wallace', 'Leonidas', 'MacLeod'}, scotsmen | warriors)
+        self.assertEqual({'Wallace', 'MacLeod'}, scotsmen & warriors)
+        self.assertEqual({'Willie', 'Leonidas'}, scotsmen ^ warriors)
 
     # ------------------------------------------------------------------
 
     def test_we_can_query_set_membership(self):
-        self.assertEqual(__, 127 in {127, 0, 0, 1} )
-        self.assertEqual(__, 'cow' not in set('apocalypse now') )
+        self.assertEqual(True, 127 in {127, 0, 0, 1} )
+        self.assertEqual(True, 'cow' not in set('apocalypse now') )
 
     def test_we_can_compare_subsets(self):
-        self.assertEqual(__, set('cake') <= set('cherry cake'))
-        self.assertEqual(__, set('cake').issubset(set('cherry cake')) )
+        self.assertEqual(True, set('cake') <= set('cherry cake'))
+        self.assertEqual(True, set('cake').issubset(set('cherry cake')) )
 
-        self.assertEqual(__, set('cake') > set('pie'))
+        self.assertEqual(False, set('cake') > set('pie'))
diff --git a/koans/about_string_manipulation.py b/koans/about_string_manipulation.py
index 5204f29ba..f70783234 100644
--- a/koans/about_string_manipulation.py
+++ b/koans/about_string_manipulation.py
@@ -9,13 +9,13 @@ def test_use_format_to_interpolate_variables(self):
         value1 = 'one'
         value2 = 2
         string = "The values are {0} and {1}".format(value1, value2)
-        self.assertEqual(__, string)
+        self.assertEqual("The values are one and 2", string)
 
     def test_formatted_values_can_be_shown_in_any_order_or_be_repeated(self):
         value1 = 'doh'
         value2 = 'DOH'
         string = "The values are {1}, {0}, {0} and {1}!".format(value1, value2)
-        self.assertEqual(__, string)
+        self.assertEqual("The values are DOH, doh, doh and DOH!", string)
 
     def test_any_python_expression_may_be_interpolated(self):
         import math # import a standard python module with math functions
@@ -23,24 +23,24 @@ def test_any_python_expression_may_be_interpolated(self):
         decimal_places = 4
         string = "The square root of 5 is {0:.{1}f}".format(math.sqrt(5),
             decimal_places)
-        self.assertEqual(__, string)
+        self.assertEqual("The square root of 5 is 2.2361", string)
 
     def test_you_can_get_a_substring_from_a_string(self):
         string = "Bacon, lettuce and tomato"
-        self.assertEqual(__, string[7:10])
+        self.assertEqual("let", string[7:10])
 
     def test_you_can_get_a_single_character_from_a_string(self):
         string = "Bacon, lettuce and tomato"
-        self.assertEqual(__, string[1])
+        self.assertEqual('a', string[1])
 
     def test_single_characters_can_be_represented_by_integers(self):
-        self.assertEqual(__, ord('a'))
-        self.assertEqual(__, ord('b') == (ord('a') + 1))
+        self.assertEqual(97, ord('a'))
+        self.assertEqual(True, ord('b') == (ord('a') + 1))
 
     def test_strings_can_be_split(self):
         string = "Sausage Egg Cheese"
         words = string.split()
-        self.assertListEqual([__, __, __], words)
+        self.assertListEqual(["Sausage", "Egg", "Cheese"], words)
 
     def test_strings_can_be_split_with_different_patterns(self):
         import re #import python regular expression library
@@ -50,25 +50,25 @@ def test_strings_can_be_split_with_different_patterns(self):
 
         words = pattern.split(string)
 
-        self.assertListEqual([__, __, __, __], words)
+        self.assertListEqual(["the", "rain", "in", "spain"], words)
 
         # Pattern is a Python regular expression pattern which matches ',' or ';'
 
     def test_raw_strings_do_not_interpret_escape_characters(self):
         string = r'\n'
         self.assertNotEqual('\n', string)
-        self.assertEqual(__, string)
-        self.assertEqual(__, len(string))
+        self.assertEqual(r'\n', string)
+        self.assertEqual(2, len(string))
 
         # Useful in regular expressions, file paths, URLs, etc.
 
     def test_strings_can_be_joined(self):
         words = ["Now", "is", "the", "time"]
-        self.assertEqual(__, ' '.join(words))
+        self.assertEqual("Now is the time", ' '.join(words))
 
     def test_strings_can_change_case(self):
-        self.assertEqual(__, 'guido'.capitalize())
-        self.assertEqual(__, 'guido'.upper())
-        self.assertEqual(__, 'TimBot'.lower())
-        self.assertEqual(__, 'guido van rossum'.title())
-        self.assertEqual(__, 'ToTaLlY aWeSoMe'.swapcase())
+        self.assertEqual('Guido', 'guido'.capitalize())
+        self.assertEqual('GUIDO', 'guido'.upper())
+        self.assertEqual('timbot', 'TimBot'.lower())
+        self.assertEqual('Guido Van Rossum', 'guido van rossum'.title())
+        self.assertEqual('tOtAlLy AwEsOmE', 'ToTaLlY aWeSoMe'.swapcase())
diff --git a/koans/about_true_and_false.py b/koans/about_true_and_false.py
index 5f06a63db..9467caf51 100644
--- a/koans/about_true_and_false.py
+++ b/koans/about_true_and_false.py
@@ -12,32 +12,32 @@ def truth_value(self, condition):
             return 'false stuff'
 
     def test_true_is_treated_as_true(self):
-        self.assertEqual(__, self.truth_value(True))
+        self.assertEqual('true stuff', self.truth_value(True))
 
     def test_false_is_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(False))
+        self.assertEqual('false stuff', self.truth_value(False))
 
     def test_none_is_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(None))
+        self.assertEqual('false stuff', self.truth_value(None))
 
     def test_zero_is_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(0))
+        self.assertEqual('false stuff', self.truth_value(0))
 
     def test_empty_collections_are_treated_as_false(self):
-        self.assertEqual(__, self.truth_value([]))
-        self.assertEqual(__, self.truth_value(()))
-        self.assertEqual(__, self.truth_value({}))
-        self.assertEqual(__, self.truth_value(set()))
+        self.assertEqual('false stuff', self.truth_value([]))
+        self.assertEqual('false stuff', self.truth_value(()))
+        self.assertEqual('false stuff', self.truth_value({}))
+        self.assertEqual('false stuff', self.truth_value(set()))
 
     def test_blank_strings_are_treated_as_false(self):
-        self.assertEqual(__, self.truth_value(""))
+        self.assertEqual('false stuff', self.truth_value(""))
 
     def test_everything_else_is_treated_as_true(self):
-        self.assertEqual(__, self.truth_value(1))
-        self.assertEqual(__, self.truth_value([0]))
-        self.assertEqual(__, self.truth_value((0,)))
+        self.assertEqual('true stuff', self.truth_value(1))
+        self.assertEqual('true stuff', self.truth_value([0]))
+        self.assertEqual('true stuff', self.truth_value((0,)))
         self.assertEqual(
-            __,
+            'true stuff',
             self.truth_value("Python is named after Monty Python"))
-        self.assertEqual(__, self.truth_value(' '))
-        self.assertEqual(__, self.truth_value('0'))
+        self.assertEqual('true stuff', self.truth_value(' '))
+        self.assertEqual('true stuff', self.truth_value('0'))
diff --git a/koans/about_tuples.py b/koans/about_tuples.py
index 1b38c8f7f..09bcd4456 100644
--- a/koans/about_tuples.py
+++ b/koans/about_tuples.py
@@ -6,7 +6,7 @@
 class AboutTuples(Koan):
     def test_creating_a_tuple(self):
         count_of_three =  (1, 2, 5)
-        self.assertEqual(__, count_of_three[2])
+        self.assertEqual(5, count_of_three[2])
 
     def test_tuples_are_immutable_so_item_assignment_is_not_possible(self):
 
@@ -19,11 +19,11 @@ def test_tuples_are_immutable_so_item_assignment_is_not_possible(self):
         # Note, assertRegex() uses regular expression pattern matching,
         # so you don't have to copy the whole message.
 
-        self.assertRegex(msg, __)
+        self.assertRegex(msg, "object does not support item assignment")
 
     def test_tuples_are_immutable_so_appending_is_not_possible(self):
         count_of_three =  (1, 2, 5)
-        with self.assertRaises(___): count_of_three.append("boom")
+        with self.assertRaises(AttributeError): count_of_three.append("boom")
 
         # Tuples are less flexible than lists, but faster.
 
@@ -34,26 +34,26 @@ def test_tuples_can_only_be_changed_through_replacement(self):
         list_count.append("boom")
         count_of_three = tuple(list_count)
 
-        self.assertEqual(__, count_of_three)
+        self.assertEqual((1, 2, 5, "boom"), count_of_three)
 
     def test_tuples_of_one_look_peculiar(self):
-        self.assertEqual(__, (1).__class__)
-        self.assertEqual(__, (1,).__class__)
-        self.assertEqual(__, ("I'm a tuple",).__class__)
-        self.assertEqual(__, ("Not a tuple").__class__)
+        self.assertEqual(int, (1).__class__)
+        self.assertEqual(tuple, (1,).__class__)
+        self.assertEqual(tuple, ("I'm a tuple",).__class__)
+        self.assertEqual(str, ("Not a tuple").__class__)
 
     def test_tuple_constructor_can_be_surprising(self):
-        self.assertEqual(__, tuple("Surprise!"))
+        self.assertEqual(('S', 'u', 'r', 'p', 'r', 'i', 's', 'e', '!'), tuple("Surprise!"))
 
     def test_creating_empty_tuples(self):
-        self.assertEqual(__ , ())
-        self.assertEqual(__ , tuple())  # Sometimes less confusing
+        self.assertEqual((), ())
+        self.assertEqual((), tuple())  # Sometimes less confusing
 
     def test_tuples_can_be_embedded(self):
         lat = (37, 14, 6, 'N')
         lon = (115, 48, 40, 'W')
         place = ('Area 51', lat, lon)
-        self.assertEqual(__, place)
+        self.assertEqual(('Area 51', (37, 14, 6, 'N'), (115, 48, 40, 'W')), place)
 
     def test_tuples_are_good_for_representing_records(self):
         locations = [
@@ -63,5 +63,5 @@ def test_tuples_are_good_for_representing_records(self):
 
         locations.append( ("Cthulu", (26, 40, 1, 'N'), (70, 45, 7, 'W')) )
 
-        self.assertEqual(__, locations[2][0])
-        self.assertEqual(__, locations[0][1][2])
+        self.assertEqual("Cthulu", locations[2][0])
+        self.assertEqual(15.56, locations[0][1][2])
diff --git a/koans/triangle.py b/koans/triangle.py
index 4d8d66f42..ab75efbfe 100644
--- a/koans/triangle.py
+++ b/koans/triangle.py
@@ -18,7 +18,29 @@
 #
 def triangle(a, b, c):
     # DELETE 'PASS' AND WRITE THIS CODE
-    pass
+
+    if a <= 0 or b <= 0 or c <= 0:
+        raise TriangleError()
+
+    if a + b <= c or a + c <= b or b + c <= a:
+        raise TriangleError()
+
+
+
+    set1 = set([a, b, c])
+    set2 = set([a, c, b])
+
+    set3 = set1 & set2
+
+    set_len = len(set3)
+
+    if set_len == 1:
+        return "equilateral"
+    elif set_len == 2:
+        return "isosceles"
+    else:
+        return "scalene"
+
 
 # Error class used in part 2.  No need to change this code.
 class TriangleError(Exception):