Have made the changes that @drvinceknight suggested.

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, WorseAndWorseRandom)
+from .worse_and_worse import (WorseAndWorse, KnowledgeableWorseAndWorse)
 
 # Note: Meta* strategies are handled in .__init__.py
 
@@ -196,7 +196,7 @@
     WinShiftLoseStay,
     WinStayLoseShift,
     WorseAndWorse,
-    WorseAndWorseRandom,
+    KnowledgeableWorseAndWorse,
     ZDExtort2,
     ZDExtort2v2,
     ZDExtort4,

axelrod/strategies/worse_and_worse.py

@@ -1,5 +1,3 @@
-import random
-
 from axelrod import Actions, Player, random_choice
 
 C, D = Actions.C, Actions.D
@@ -10,11 +8,12 @@ class WorseAndWorse (Player):
     it is more and more likely to defect as the round goes on.
 
     Names:
-        - worse_and_worse: [PRISON1998]
+        - worse_and_worse: Source code available at the download tab of
+                            [PRISON1998].
 
     """
 
-    name = 'Worse and worse'
+    name = 'Worse and Worse'
     classifier = {
         'memory_depth': float('inf'),
         'stochastic': True,
@@ -27,19 +26,20 @@ class WorseAndWorse (Player):
 
     def strategy(self, opponent):
         current_round = len(self.history) + 1
-        if random.randint(0, 1000) < current_round:
-            return D
-        return C
+        probability = 1 - float(current_round) / 1000
+        return random_choice(probability)
 
 
-class WorseAndWorseRandom (Player):
+class KnowledgeableWorseAndWorse (Player):
     """
     This strategy is based of 'Worse And Worse' but will defect with probability
     of 'current turn / total no. of turns'.
 
+    Names:
+        - Knowledgeable Worse and Worse: Original name by Adam Pohl
     """
 
-    name = 'Worse and worse random'
+    name = 'Knowledgeable Worse and Worse'
     classifier = {
         'memory_depth': float('inf'),
         'stochastic': True,

axelrod/tests/unit/test_worse_and_worse.py

@@ -8,7 +8,7 @@
 
 class TestWorseAndWorse(TestPlayer):
 
-    name = "Worse and worse"
+    name = "Worse and Worse"
     player = axelrod.WorseAndWorse
     expected_classifier = {
         'memory_depth': float('inf'),
@@ -25,32 +25,42 @@ def test_strategy(self):
         Test that the strategy gives expected behaviour
         """
 
-        axelrod.seed(1)
+        axelrod.seed(8)
         opponent = axelrod.Cooperator()
         player = axelrod.WorseAndWorse()
-        match = axelrod.Match((opponent, player), turns=5)
+        match = axelrod.Match((opponent, player), turns=10)
         self.assertEqual(match.play(), [('C', 'C'),
                                         ('C', 'C'),
                                         ('C', 'C'),
                                         ('C', 'C'),
+                                        ('C', 'C'),
+                                        ('C', 'C'),
+                                        ('C', 'D'),
+                                        ('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)
+        axelrod.seed(8)
+        match = axelrod.Match((opponent, player), turns=10)
         self.assertEqual(match.play(), [('D', 'C'),
                                         ('D', 'C'),
                                         ('D', 'C'),
                                         ('D', 'C'),
+                                        ('D', 'C'),
+                                        ('D', 'C'),
+                                        ('D', 'D'),
+                                        ('D', 'C'),
+                                        ('D', 'C'),
                                         ('D', 'C')])
 
 
 class TestWorseAndWorseRandom(TestPlayer):
 
-    name = "Worse and worse random"
-    player = axelrod.WorseAndWorseRandom
+    name = "Knowledgeable Worse and Worse"
+    player = axelrod.KnowledgeableWorseAndWorse
     expected_classifier = {
         'memory_depth': float('inf'),
         'stochastic': True,
@@ -67,7 +77,7 @@ def test_strategy(self):
         """
         axelrod.seed(1)
         opponent = axelrod.Cooperator()
-        player = axelrod.WorseAndWorseRandom()
+        player = axelrod.KnowledgeableWorseAndWorse()
         match = axelrod.Match((opponent, player), turns=5)
         self.assertEqual(match.play(), [('C', 'C'),
                                         ('C', 'D'),
@@ -77,7 +87,7 @@ def test_strategy(self):
 
         # Test that behaviour does not depend on opponent
         opponent = axelrod.Defector()
-        player = axelrod.WorseAndWorseRandom()
+        player = axelrod.KnowledgeableWorseAndWorse()
         axelrod.seed(1)
         match = axelrod.Match((opponent, player), turns=5)
         self.assertEqual(match.play(), [('D', 'C'),