Python 对象列表的自定义列表表示法

我知道可以使用

\uu repr\uuu

魔术方法自定义对象的表示

class A:

    ...

    def __repr__(self):
        return 'A(id={})'.format(self.id)

当表示是这些对象的列表时，是否有一种自定义表示的方法，以便它不只是打印对象表示的列表

[a（id=1）、a（id=10）、a（id=11）]

例如：

class AGroup:
    def __init__(self, lst):
        self.lst = lst

>>> lst = [A(1), A(10), A(11)]
>>> grp = AGroup(lst)
>>> grp.lst
<Group of 3 A's>  # instead of [A(id=1), A(id=10), A(id=11)]

class-up：
定义初始（自我，lst）：
self.lst=lst
>>>lst=[A（1）、A（10）、A（11）]
>>>grp=AGroup（lst）
>>>grp.lst
您可以将传递给
AGroup
构造函数的列表存储在
list
子类的实例中，这样您就可以重写
list
子类的
\uuu repr\uuu
方法，以所需格式返回输出：

class A:
    def __init__(self, id):
        self.id = id
    def __repr__(self):
        return 'A(id={})'.format(self.id)

class AGroup:
    class AList(list):
        def __repr__(self):
            return "<Group of %d A's>" % len(self)

    def __init__(self, lst):
        self.lst = self.AList(lst)

lst = [A(1), A(10), A(11)]
grp = AGroup(lst)
print(grp.lst)

A类：
定义初始化（self，id）：
self.id=id
定义报告（自我）：
返回'A（id={}'）.format（self.id）
向上分类：
班级名单：
定义报告（自我）：
返回“
您可以将传递给
AGroup
构造函数的列表存储在
list
的子类的实例中，这样您就可以重写
list
子类的
\uurepr\uuu
方法，以所需格式返回输出：

class A:
    def __init__(self, id):
        self.id = id
    def __repr__(self):
        return 'A(id={})'.format(self.id)

class AGroup:
    class AList(list):
        def __repr__(self):
            return "<Group of %d A's>" % len(self)

    def __init__(self, lst):
        self.lst = self.AList(lst)

lst = [A(1), A(10), A(11)]
grp = AGroup(lst)
print(grp.lst)

A类：
定义初始化（self，id）：
self.id=id
定义报告（自我）：
返回'A（id={}'）.format（self.id）
向上分类：
班级名单：
定义报告（自我）：
返回“
要将类实例分组，我们需要覆盖eq、ne和哈希函数。通过给定静态哈希值，将把这个类的所有实例视为一个对象

from collections import Counter
class A:
    def __init__(self , id):
        self.id = id
    def __hash__(self): return hash('A')
    def __eq__(self, x): return type(x) is A
    def __ne__(self, x): return type(x) is not A

    def __repr__(self):
        return 'A'


class B:
    def __init__(self , id):
        self.id = id
    def __hash__(self): return hash('B')
    def __eq__(self, x): return type(x) is B
    def __ne__(self, x): return type(x) is not B

    def __repr__(self):
        return 'B'


class AGroup:
    def __init__(self, lst):
        count = Counter(lst)
        self.lst = []
        for cl in Counter(lst):
            self.lst.append('<Group of {} {}\'s>'.format(count[cl] , cl))



lst = [A(1), B(10), A(11)]
grp = AGroup(lst)
grp.lst


["<Group of 2 A's>", "<Group of 1 B's>"]

从集合导入计数器
A类：
定义初始化（self，id）：
self.id=id
定义散列（self）：返回散列（'A'））
def___eq__（self，x）：返回类型（x）是
定义（self，x）：返回类型（x）不是
定义报告（自我）：
返回“A”
B类：
定义初始化（self，id）：
self.id=id
定义散列（self）：返回散列（'B'））
def _; eq _;（self，x）：返回类型（x）为B
定义（self，x）：返回类型（x）不是B
定义报告（自我）：
返回“B”
向上分类：
定义初始（自我，lst）：
计数=计数器（lst）
self.lst=[]
对于计数器中的cl（lst）：
self.lst.append（“到组类实例中，我们需要覆盖eq、ne和hash函数。通过给出静态hash值，将该类的所有实例视为一个对象

from collections import Counter
class A:
    def __init__(self , id):
        self.id = id
    def __hash__(self): return hash('A')
    def __eq__(self, x): return type(x) is A
    def __ne__(self, x): return type(x) is not A

    def __repr__(self):
        return 'A'


class B:
    def __init__(self , id):
        self.id = id
    def __hash__(self): return hash('B')
    def __eq__(self, x): return type(x) is B
    def __ne__(self, x): return type(x) is not B

    def __repr__(self):
        return 'B'


class AGroup:
    def __init__(self, lst):
        count = Counter(lst)
        self.lst = []
        for cl in Counter(lst):
            self.lst.append('<Group of {} {}\'s>'.format(count[cl] , cl))



lst = [A(1), B(10), A(11)]
grp = AGroup(lst)
grp.lst


["<Group of 2 A's>", "<Group of 1 B's>"]

从集合导入计数器
A类：
定义初始化（self，id）：
self.id=id
定义散列（self）：返回散列（'A'））
def___eq__（self，x）：返回类型（x）是
定义（self，x）：返回类型（x）不是
定义报告（自我）：
返回“A”
B类：
定义初始化（self，id）：
self.id=id
定义散列（self）：返回散列（'B'））
def _; eq _;（self，x）：返回类型（x）为B
定义（self，x）：返回类型（x）不是B
定义报告（自我）：
返回“B”
向上分类：
定义初始（自我，lst）：
计数=计数器（lst）
self.lst=[]
对于计数器中的cl（lst）：
self.lst.append（'如果Python允许一个对象控制其他对象的
repr
，那将非常非常混乱。您可以尝试对内置
列表进行修补（非常不可取）。或者您可以创建自己的容器类（更干净），它可以简单地包装一个
列表
，然后为您实现任何行为want@juanpa.arrivillaga是的，容器类是我最初想做的，但我想知道是否还有其他的way@user2357112我在想一个界面，在这个界面上，一个对象列表会有不同的显示y行为与任何其他列表如果Python允许一个对象控制其他对象的
repr
，这将是非常非常混乱的。您可以尝试对内置的
list
（非常不可取）。或者您可以创建自己的容器类（更干净），它可以简单地包装一个
列表
，然后为您实现任何行为want@juanpa.arrivillaga是的，容器类是我最初想做的，但我想知道是否还有其他的way@user2357112我在想一个界面，在这个界面上，一个对象列表会有不同的显示y行为与任何其他列表问题显示具有不同ID值的元素的AGroup。此外，这是自定义AGroup对象的repr，而不是列表的repr。确实如此。修复了。谢谢。@juanpa.arrivillaga Oops太仓促了。谢谢。问题显示具有不同ID值的元素的AGroup。另外，这是cust删除AGroup对象的repr，而不是列表中的repr。确实。修复了。谢谢。@juanpa.arrivillaga-Oops太仓促了。谢谢。