# random.shuffle 就地打乱
from random import shuffle

l = list(range(10))
shuffle(l)
print(l)
shuffle(l)
print(l)

[0, 6, 3, 2, 4, 8, 5, 7, 1, 9]
[0, 5, 9, 7, 6, 2, 4, 8, 1, 3]

import collections

Card = collections.namedtuple('Card', 'rank suit')

class FrenchDeck:

    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
    suits = 'spades diamondes 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]

# target: 洗牌
deck = FrenchDeck()
shuffle(deck)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In [4], line 3
      1 # target: 洗牌
      2 deck = FrenchDeck()
----> 3 shuffle(deck)


File c:\Users\qiany\AppData\Local\Programs\Python\Python39\lib\random.py:362, in Random.shuffle(self, x, random)
    359     for i in reversed(range(1, len(x))):
    360         # pick an element in x[:i+1] with which to exchange x[i]
    361         j = randbelow(i + 1)
--> 362         x[i], x[j] = x[j], x[i]
    363 else:
    364     _warn('The *random* parameter to shuffle() has been deprecated\n'
    365           'since Python 3.9 and will be removed in a subsequent '
    366           'version.',
    367           DeprecationWarning, 2)


TypeError: 'FrenchDeck' object does not support item assignment

# 打补丁
def set_card(deck, position, card):
    deck._cards[position] = card

FrenchDeck.__setitem__ = set_card
shuffle(deck)
print(deck[:5])

[Card(rank='9', suit='spades'), Card(rank='2', suit='spades'), Card(rank='5', suit='spades'), Card(rank='Q', suit='clubs'), Card(rank='10', suit='hearts')]

import collections

Card = collections.namedtuple('Card', 'rank suit')

class FrenchDeck2(collections.MutableSequence):

    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
    suits = 'spades diamondes 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]

    def __setitem__(self, position, value):  # 欲实现 shuffle 须实现 __setitem__
        self._cards[position] = value

    def __delitem__(self, position):
        del self._cards[position]

    def insert(self, position, value):
        self._cards.insert(position, value)

import numbers

print(1, isinstance(233, numbers.Integral))
print(2, isinstance(233.33, numbers.Integral))
print(3, isinstance(233.00, numbers.Integral))
print(4, isinstance(True, numbers.Integral))
print(5, isinstance(False, numbers.Integral))

True
False
False
True
True

import abc

class Tombola(abc.ABC):

    @abc.abstractclassmethod  # 一般 abstractclassmethod 只有 文档字符串
    def load(self, iterable):
        '''可从迭代对象中添加元素'''

    @abc.abstractclassmethod
    def pick(self):
        '''随机删除元素并返回
        若果实例为空, 抛出 LookupError'''
    
    def loaded(self):  # 抽象基类可以包含具体实现方法
        '''是否有元素'''
        return bool(self.inspect())  # 抽象基类中的具体方法 只能依赖基类定义的接口（即该抽象基类中其他具体方法、抽象方法、特征）

    def inspect(self):
        '''返回一个由当前元素构成的有序元组'''

        items = []
        while True:
            try:
                items.append(self.pick())
            except LookupError:
                break
        self.load(items)
        return tuple(sorted(items))

# 不符合 Tombola 的子类
class Fake(Tombola):
    def pick(self):
        return 13

f = Fake()

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In [13], line 6
      3     def pick(self):
      4         return 13
----> 6 f = Fake()


TypeError: Can't instantiate abstract class Fake with abstract method load

# Tombola 的子类 BingoCage

import random
class BingoCage(Tombola):

    def __init__(self, items):
        self._randomizer = random.SystemRandom()  # 调用 os.random() 函数, 生成"适合加密"的随机字节序列
        self._items = []
        self.load(items)  # 委托 load 初始化

    def load(self, items):
        self._items.extend(items)
        self._randomizer.shuffle(self._items)  # 打乱

    def pick(self):
        try:
            return self._items.pop()
        except IndexError:
            raise LookupError('pick from empty BingoCage')

    def __call__(self):
        self.pick()

class LotteryBlower(Tombola):

    def __init__(self, iterable):
        self._balls = list(iterable)

    def load(self, iterable):
        self._balls.extend(iterable)

    def pick(self):
        try:
            position = random.randrange(len(self._balls))
        except IndexError:
            raise LookupError('pick from empty LotteryBlower')
        return self._balls.pop(position)

    def loaded(self):  # 重写 loaded
        return bool(self._balls)
    
    def inspect(self):
        return tuple(sorted(self._balls))

@Tombola.register  # 注册为 Tombola 的 虚拟子类
class TomboList(list):  # 继承 list
    def pick(self):
        if self:  # 是否为空
            position = random.randrange(len(self))
            return self.pop(position)
        else:
            raise LookupError('pop from empty TomboList')

    load = list.extend

    def loaded(self):
        return bool(self)
    
    def inspect(self):
        return tuple(sorted(self))

print(1, issubclass(TomboList, Tombola))

t = TomboList(range(100))
print(2, isinstance(t, Tombola))

print(3, TomboList.__mro__)  # 按顺序列出类及其超类

1 True
2 True
3 (<class '__main__.TomboList'>, <class 'list'>, <class 'object'>)