J'ai écrit un doctest dans "J'ai essayé de simuler la probabilité d'un jeu de bingo avec Python"

Histoire originale Histoire originale: [J'ai essayé de simuler la probabilité d'un jeu de bingo avec Python] (http://qiita.com/elzup/items/d532ffa1d326fbf75d01) Histoire originale: [J'ai essayé de corriger "J'ai essayé de simuler la probabilité d'un jeu de bingo avec Python"] (http://qiita.com/t2y/items/8584b77b3fe02dd2ce63)

Je ne sais toujours pas comment écrire un bloc doc, alors je vais étudier

L'une des fonctionnalités de Python est doctest. Si vous combinez le document sur l'utilisation de la fonction avec un test simple, il peut s'agir de deux oiseaux avec une pierre.

Si vous modifiez la logique du code original pour ne pas le gâcher, le doctest du code modifié n'est pas bon, mais si vous essayez de développer en écrivant le doctest, la perspective de la position à utiliser va s'étendre et il sera facile à utiliser naturellement Vous pouvez implémenter des fonctions et des modules.

Lors de l'écriture de doctest, si vous le développez de manière interactive, il sera facile à déboguer, ce sera une API facile à utiliser, et je voulais dire qu'il peut être utilisé comme un document tel quel, mais je ne pourrais pas écrire un exemple de code approprié, alors vengeance.

J'ai essayé de faciliter la compréhension du but de doctest.

• Gardez l'objet Carte perforé
• Vous pouvez écrire un test sans utiliser de simulation en passant les données de test au constructeur de la carte.
• • Si vous implémentez __repr__ , vous n'avez pas besoin de la fonction de sortie de débogage ( __repr__ * semble être utilisé dans la fonction d'impression, etc. lorsque * __str__ * n'est pas défini)

En passant, je me demandais si je pouvais écrire le processus de génération de numéro de carte plus proprement d'hier, et j'étais un peu heureux lorsque j'ai utilisé * réduire *.

    def _generate(self):
        def sampling(k=5):
            for i in range(k):
                yield sample(range(15 * i + 1, 15 * (i + 1) + 1), k)

        return reduce(add, sampling())

Je serais heureux si je pouvais transmettre ce genre d'atmosphère.

# -*- coding: utf-8 -*-
from functools import reduce
from operator import add
from random import sample


class Card:
    """ 75-ball Bingo Card

    The middle square is designated a "FREE" space.
    The columns are labeled as follows.
    "B": (numbers 1–15)
    "I": (numbers 16–30)
    "N": (numbers 31–45)
    "G": (numbers 46–60)
    "O": (numbers 61–75)

    http://en.wikipedia.org/wiki/Bingo_card

    >>> data = [  # for testing use
    ... 1, 2, 3, 4, 5,
    ... 6, 7, 8, 9, 10,
    ... 11, 12, 13, 14, 15,
    ... 16, 17, 18, 19, 20,
    ... 21, 22, 23, 24, 25,
    ... ]
    >>> card = Card(data)
    >>> len(card.numbers)
    25
    >>> card.numbers[12]
    True
    >>> card.is_bingo
    False
    >>> print(card)
      1  2  3  4  5
      6  7  8  9 10
     11 12  o 14 15
     16 17 18 19 20
     21 22 23 24 25

    Show 'o' when giving number is found

    >>> card.set_number(14)
    >>> print(card)
      1  2  3  4  5
      6  7  8  9 10
     11 12  o  o 15
     16 17 18 19 20
     21 22 23 24 25

    Check bingo giving number to the card.

    >>> card.set_number(35)  # have no effect if number not in card.numbers
    >>> card.set_number(1)
    >>> card.set_number(7)
    >>> card.set_number(19)
    >>> card.is_bingo
    False
    >>> card.set_number(25)
    >>> card.is_bingo
    True
    >>> print(card)
      o  2  3  4  5
      6  o  8  9 10
     11 12  o  o 15
     16 17 18  o 20
     21 22 23 24  o
    """

    def __init__(self, numbers=None):
        self.numbers = self._generate() if numbers is None else numbers
        self.numbers[12] = True
        self.is_bingo = False

    def __repr__(self):
        ascii_card = ''
        for i in range(int(len(self.numbers) / 5)):
            for num in self.numbers[5 * i:5 * (i + 1)]:
                if num is True:
                    num = 'o'
                elif num is False:
                    num = 'x'
                ascii_card += '{0:>3s}'.format(str(num))
            ascii_card += '\n'
        return ascii_card[:-1]

    def _generate(self):
        def sampling(k=5):
            for i in range(k):
                yield sample(range(15 * i + 1, 15 * (i + 1) + 1), k)

        return reduce(add, sampling())

    def set_number(self, number):
        if number not in self.numbers:
            return
        self.numbers[self.numbers.index(number)] = True
        if not self.is_bingo:
            self.check_bingo()

    def check_bingo(self):
        def check(start, stop, step=1):
            return all(map(lambda x: x is True, self.numbers[start:stop:step]))

        if self.numbers.count(True) < 5:
            return

        for i in range(5):
            if check(i * 5, (i + 1) * 5):  # horizontal
                self.is_bingo = True
                return

        for i in range(5):
            if check(i, i + 21, 5):  # vertical
                self.is_bingo = True
                return

        if check(0, 25, 6) or check(4, 21, 4):  # skew
            self.is_bingo = True
            return

Exécutez doctest comme ça.

$ python -m doctest Bingo_kai2.py  #Si aucune erreur n'est affichée, le test est correct
$ python -m doctest Bingo_kai2.py -v  #Mode redondant