Have added actual Worse and worse strategy now.

Author: AdamPohl

axelrod/strategies/_strategies.py

@@ -59,7 +59,7 @@
     TitForTat, TitFor2Tats, TwoTitsForTat, Bully, SneakyTitForTat,
     SuspiciousTitForTat, AntiTitForTat, HardTitForTat, HardTitFor2Tats,
     OmegaTFT, Gradual, ContriteTitForTat, SlowTitForTwoTats, AdaptiveTitForTat)
-from .worse_and_worse import WorseAndWorse
+from .worse_and_worse import (WorseAndWorse, WorseAndWorseRandom)
 
 # Note: Meta* strategies are handled in .__init__.py
 
@@ -196,6 +196,7 @@
     WinShiftLoseStay,
     WinStayLoseShift,
     WorseAndWorse,
+    WorseAndWorseRandom,
     ZDExtort2,
     ZDExtort2v2,
     ZDExtort4,

axelrod/strategies/worse_and_worse.py

@@ -1,10 +1,12 @@
+import random
+
 from axelrod import Actions, Player, random_choice
 
 C, D = Actions.C, Actions.D
 
 class WorseAndWorse (Player):
     """
-    Defects with probability of 'current turn / total no. of turns'. Therefore
+    Defects with probability of 'current turn / 1000'. Therefore
     it is more and more likely to defect as the round goes on.
 
     Names:
@@ -13,6 +15,31 @@ class WorseAndWorse (Player):
     """
 
     name = 'Worse and worse'
+    classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': True,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def strategy(self, opponent):
+        current_round = len(self.history) + 1
+        if random.randint(0, 1000) < current_round:
+            return D
+        return C
+
+
+class WorseAndWorseRandom (Player):
+    """
+    This strategy is based of 'Worse And Worse' but will defect with probability
+    of 'current turn / total no. of turns'.
+
+    """
+
+    name = 'Worse and worse random'
     classifier = {
         'memory_depth': float('inf'),
         'stochastic': True,

axelrod/tests/unit/test_worse_and_worse.py

@@ -1,21 +1,19 @@
-"""Test for the Worse and Worse strategy."""
+"""Test for the Worse and Worse strategies."""
 
-import sys
 import axelrod
 
 from .test_player import TestPlayer
 
 C, D = axelrod.Actions.C, axelrod.Actions.D
 
-
 class TestWorseAndWorse(TestPlayer):
 
     name = "Worse and worse"
     player = axelrod.WorseAndWorse
     expected_classifier = {
         'memory_depth': float('inf'),
         'stochastic': True,
-        'makes_use_of': set(['length']),
+        'makes_use_of': set(),
         'long_run_time': False,
         'inspects_source': False,
         'manipulates_source': False,
@@ -26,10 +24,51 @@ def test_strategy(self):
         """
         Test that the strategy gives expected behaviour
         """
+
         axelrod.seed(1)
         opponent = axelrod.Cooperator()
         player = axelrod.WorseAndWorse()
         match = axelrod.Match((opponent, player), turns=5)
+        self.assertEqual(match.play(), [('C', 'C'),
+                                        ('C', 'C'),
+                                        ('C', 'C'),
+                                        ('C', 'C'),
+                                        ('C', 'C')])
+
+        # Test that behaviour does not depend on opponent
+        opponent = axelrod.Defector()
+        player = axelrod.WorseAndWorse()
+        axelrod.seed(1)
+        match = axelrod.Match((opponent, player), turns=5)
+        self.assertEqual(match.play(), [('D', 'C'),
+                                        ('D', 'C'),
+                                        ('D', 'C'),
+                                        ('D', 'C'),
+                                        ('D', 'C')])
+
+
+class TestWorseAndWorseRandom(TestPlayer):
+
+    name = "Worse and worse random"
+    player = axelrod.WorseAndWorseRandom
+    expected_classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': True,
+        'makes_use_of': set(['length']),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        """
+        Test that the strategy gives expected behaviour
+        """
+        axelrod.seed(1)
+        opponent = axelrod.Cooperator()
+        player = axelrod.WorseAndWorseRandom()
+        match = axelrod.Match((opponent, player), turns=5)
         self.assertEqual(match.play(), [('C', 'C'),
                                         ('C', 'D'),
                                         ('C', 'D'),
@@ -38,7 +77,7 @@ def test_strategy(self):
 
         # Test that behaviour does not depend on opponent
         opponent = axelrod.Defector()
-        player = axelrod.WorseAndWorse()
+        player = axelrod.WorseAndWorseRandom()
         axelrod.seed(1)
         match = axelrod.Match((opponent, player), turns=5)
         self.assertEqual(match.play(), [('D', 'C'),