How to properly implement/overload “__repr__ ”?

问题

New to python and this might be a silly question, but how does one properly implement the repr method?

I wrote a quick little program to simulate a game of cards but I don't know what to write for the repr method. The repr method for the Card class was pretty straight forward, but I don't know what to do for the DeckOfCards class Here's my code:

import random
class Card:
'''Create a single card, by id number'''

# Class variables, created once for the class
    suits = [ '\u2660', '\u2661', '\u2662', '\u2663' ]
    ranks = [ 'A','2','3','4','5','6','7','8','9','10','J','Q','K' ]

    def __init__(self, n=0):
    # instance variables for _num, _rank, _suit, _value
    if 0 <= n < 52:
        self._num = n
        self._rank = Card.ranks[n%13]       # note referencing class vars
        self._suit = Card.suits[n//13]
        self._value = n%13 + 1
        if self._rank == 'A':
            self._value = 14
    else: # invalid card indicators
        self._rank = 'x'
        self._suit = 'x'
        self._value = -1

    def __repr__(self):
        return  self._rank + self._suit

    def __lt__(self,other):
        return self._value < other._value

    def __le__(self,other):
        return self._value <= other._value

    def __eq__(self,other):
        return self._value == other._value

class DeckOfCards:
'''A Deck is a collection of cards'''

    def __init__(self):
        self._deck = [ Card(i) for i in range(52) ]

    def __repr__(self):
        return 'Deck : ', self._deck

    def shuffle(self):
        return random.shuffle(self._deck)

    def deal_a_card(self, i=-1):
    #that way player can choose where to draw from 
        return self._deck.pop(i)

    def cards_left(self,count):
        return len(self._deck)

new_deck = DeckOfCards()

Also, feel free to comment on anything you'd like, whether it be a design flaw or redundancy in code, literally anything. Thanks in advance!

回答1:

You should return a string type, for example in Deck:

def __repr__(self):
    ...
    return 'Deck : '+str(self._deck)

回答2:

__repr__ ideally could return the representation of the object that you would use to create this instance.

From repr():

For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to eval(), otherwise the representation is a string enclosed in angle brackets that contains the name of the type of the object together with additional information often including the name and address of the object.

回答3:

First, It should be noted that you don't have to implement the __repr__ method. Python provides a somewhat reasonable default (it'll at least tell you the type).

If you want to implement __repr__, the "rule of thumb" is that where it makes sense, you should provide enough information about the object that a user could reconstruct it. In your case, there doesn't seem to be any real difference from one deck to another, so

def __repr__(self):
    return 'Deck()'

might be a reasonable return value. This doesn't get the state right (after shuffling), but you don't provide an interface for constructing a deck in a particular state. If you did, it might look like:

def __repr__(self):
    return 'Deck(%s)' % self._deck

来源：https://stackoverflow.com/questions/36323808/how-to-properly-implement-overload-repr

标签

python

overloading