*T>R>P>S*

*5>3>1>0*

- Alternator: give gifts one year and not give gifts the next.
- TitForTat: do whatever the other does the previous year.

```
>>> import axelrod as axl
>>> alex, camille = axl.Alternator(), axl.TitForTat()
>>> match = axl.Match([alex, camille], 10)
>>> _ = match.play()
>>> print(match.sparklines(c_symbol='π', d_symbol='π'))
ππππππππππ
ππππππππππ
```

- Robert Axelrod
- 1980a: 14+1 strategies
- 1980b: 64+1 strategies

**Cooperator****Defector****Alternator****TitForTat****TwoTitForTat****Grudger**

```
>>> family = [axl.Cooperator(),
... axl.Defector(),
... axl.Alternator(),
... axl.TitForTat(),
... axl.TwoTitsForTat(),
... axl.Grudger()]
>>> christmas = axl.Tournament(family, turns=50, repetitions=1)
>>> results = christmas.play()
>>> results.scores
[[525], [562], [417], [622], [646], [646]]
```

```
>>> evo = axl.Ecosystem(results)
>>> evo.reproduce(100)
>>> plot = axl.Plot(results)
>>> plot.stackplot(evo)
```

*T=500*

```
>>> def check_if_end_pop_cooperates(r=3, p=1, s=0, t=5,
... digits=5, family=family,
... turns=10000):
... """Returns a boolean and the last population vector"""
... game = axl.Game(r=r, p=p, s=s, t=t)
... christmas = axl.Tournament(family, turns=50,
... repetitions=1, game=game)
... results = christmas.play()
... evo = axl.Ecosystem(results)
... evo.reproduce(turns)
... last_pop = [round(pop, digits) for pop in evo.population_sizes[-1]]
... return last_pop[1] == last_pop[2] == 0, last_pop
```

```
class TitForTat(Player):
"""A player starts by cooperating and then mimics previous move by opponent."""
name = 'Tit For Tat'
classifier = {
'memory_depth': 1, # Four-Vector = (1.,0.,1.,0.)
'stochastic': False,
'inspects_source': False,
'manipulates_source': False,
'manipulates_state': False
}
@staticmethod
def strategy(opponent):
return 'D' if opponent.history[-1:] == ['D'] else 'C'
```

```
class TestTitForTat(TestPlayer):
name = "Tit For Tat"
player = axelrod.TitForTat
expected_classifier = {
'memory_depth': 1,
'stochastic': False,
'inspects_source': False,
'manipulates_source': False,
'manipulates_state': False
}
def test_strategy(self):
"""Starts by cooperating."""
self.first_play_test(C)
def test_effect_of_strategy(self):
"""Repeats last action of opponent history."""
self.markov_test([C, D, C, D])
self.responses_test([C] * 4, [C, C, C, C], [C])
self.responses_test([C] * 5, [C, C, C, C, D], [D])
```