A Pythonic Card Deck: __len__ & __getitem__ & for 循环的嵌套

1.  Example of two-dimensional vector: Vector(2,4) + Vector(2,1) results in Vector(4,5)

import math

# special methods used: __repr__ , __abs__ , __add__ , __mul__

class Vector:

    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def __repr__(self):
        return "Vector(%r, %r)" % (self.x, self.y)
        # we use %r to obtain the standard representation of the attributes to be displayed.
        # !r should be used in the str.format method.

    def __abs__(self):
        return math.hypot(self.x, self.y)
        # math.hypot(x, y) 即相当于 math.sqrt(x*x + y*y)

    def __bool__(self):
        """
        By default, instances of user-defined classes are considered truthy, unless either __bool__ or __len__ is
        implemented. Basically, bool(x) calls x.__bool__() and uses the result. If __bool__ is not implemented, Python
        tries to invoke x.__len__(), and if that returns zero, bool returns False. Otherwise bool returns True.
        :return:
        """
        return bool(self.x or self.y)

    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Vector(x, y)  # create and return a new instance of Vector

    def __mul__(self, other):
        return Vector(self.x * other, self.y * other)

    """
    in both __add__ and __mul__ , the methods should create and return a new instance of Vector, and DO NOT modify
    either operand -- 'self' or 'other'  （应该生成新的对象）
    """

v1 = Vector(2, 4)
v2 = Vector(2, 1)

print(v2)
print("add: v1 + v2", v1 + v2)

v = Vector(3, 4)
print("abs(3,4)", abs(v))

print("v * 3", v * 3)

print("abs(v*3)", abs(v * 3))

2.1.  列表生成式的嵌套 for 循环：

示例如下：

li1 = range(1,6)
li2 = list("ABC")    # list("ABC") 的结果为 ["A", "B", "C"]    

for m in li1:
    for n in li2:
        print((m,n))

li = [(m,n) for m in li1 for n in li2]
print(li)

# 输出结果：
(1, 'A')
(1, 'B')
(1, 'C')
(2, 'A')
(2, 'B')
(2, 'C')
(3, 'A')
(3, 'B')
(3, 'C')
(4, 'A')
(4, 'B')
(4, 'C')
(5, 'A')
(5, 'B')
(5, 'C')
[(1, 'A'), (1, 'B'), (1, 'C'), (2, 'A'), (2, 'B'), (2, 'C'), (3, 'A'), (3, 'B'), (3, 'C'), (4, 'A'), (4, 'B'), (4, 'C'), (5, 'A'), (5, 'B'), (5, 'C')]

# 列表生成式中的 两个 for 循环 作用就相当于 for 循环的嵌套

参考链接： https://www.jb51.net/article/150400.htm

2.2   A Pythonic Card Deck: __len__ & __getitem__

示例如下：

import collections

Card = collections.namedtuple("Card", ["rank", "suit"])

class FrenchDeck(object):
    ranks = [str(n) for n in range(2, 11)] + list("JQKA")
    suits = "spades diamonds clubs hearts".split()

    def __init__(self):
        self._cards = [Card(rank, suit) for suit in self.suits
                       for rank in self.ranks]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, position):
        return self._cards[position]

deck = FrenchDeck()

print(len(deck))  # len() 实际只适合 dict, list 等；想要 适用于 deck ，就需要重写 __len__ 方法

# output:
#

print(deck[0], deck[1])  # __getitem__ delegates to the [] operator
"""
Special methods是理解Python语言的关键之一。例如，__getitem__特殊方法用来支持obj[key]。因此，当实现my_collection[key]，解释器实际上调用的是my_collection.__getitem__(key)
"""

# output:
# Card(rank='2', suit='spades') Card(rank='3', suit='spades')

import random

print(random.choice(deck))
print(random.choice(deck))
print(random.choice(deck))

# output:
# Card(rank='8', suit='clubs')
# Card(rank='J', suit='clubs')
# Card(rank='2', suit='diamonds')

"""
random.choice(seq) 的原理：
random.choice内部实现是先用len方法获取总长度然后从0到总长度时间取一个随机数作为索引获取

源码如下：
    def choice(self, seq):
        # Choose a random element from a non-empty sequence.
        try:
            i = self._randbelow(len(seq))
        except ValueError:
            raise IndexError('Cannot choose from an empty sequence') from None
        return seq[i]
"""

# 切片： class slice(start, stop[, step])

print(deck[12::13])

# output:
# [Card(rank='A', suit='spades'), Card(rank='A', suit='diamonds'),
# Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]

for card in deck:
    print(card)
# by implementing the __getitem__ special method, deck is also iterable
# the statement -- for i in x: actually causes the invocation of iter(x), which in turn may call x.__iter__() if that is possible.

# the deck can also be iterated in reverse :
for card in reversed(deck):
    print(card)

"""
reversed(seq)
    Return a reverse iterator. seq must be an object which has a __reversed__() method or supports the sequence protocol (the __len__() method and the __getitem__() method with integer arguments starting at 0).
"""

print(Card("Q", "hearts") in deck)
print(Card("", "beasts") in deck)

# output:
# True
# False

# 特殊方法 __contains__ 是用来进行in检验的。

# Sorting:
"""
要求：
A common system of ranking cards is by rank(with aces being highest),then by suit the order of spades(highest), then hearts,
diamonds, and clubs(lowest).
"""
suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)

def spades_high(card):
    card_rank = FrenchDeck.ranks.index(card.rank)
    return card_rank * len(suit_values) + suit_values[card.suit]

for card in sorted(deck, key=spades_high):
　　# deck 中的每个 item 会传为 spades_high 的参数 传入 spades_high 中
    print(card)

"""
By implementing the special methods __len__ and __getitem__ , our FrenchDeck behaves like a standard Python sequence.

The `list.sort` method sorts a list in place -- that is, without making a copy. (list.sort 方法是对一个列表进行【就地】排序；返回 None)；
In contrast , the built-in function `sorted` creates a new list and returns it. (返回排序后的 list)
"""