python类的行为类似于字典或列表数据，如

在python3控制台中，输入以下内容：

>>> import sys
>>> sys.version_info
sys.version_info(major=3, minor=4, micro=3, releaselevel='final', serial=0)
>>> type(sys.version_info)  # this is class type
<class 'sys.version_info'>
>>> sys.version_info[0:2]  # ?? But it acts like a list-data-like
(3, 4)

导入系统 >>>sys.version\u信息 系统版本信息（主版本=3，次版本=4，微版本=3，版本级别=final，序列号=0） >>>类型（系统版本信息）#这是类类型 >>>系统版本信息[0:2]？？但它的行为就像一个数据列表 (3, 4) 我的问题是：

一个类如何像字典或列表数据一样工作

可以举个例子来构造这样的类吗

是否有关于 这个

---

这很容易。。。您只需定义一个

\uuu getitem\uu

方法来处理切片或整数/字符串查找。你可以做任何你想做的事

class Foo(object):
    def __init__(self, bar, baz):
        self.bar = bar
        self.baz = baz
    def __getitem__(self, ix):
        return (self.bar, self.baz).__getitem__(ix)

以下是在以下情况下将作为

ix

传递给

\uuu getitem\uuu

的备忘单：

f[1]  # f.__getitem__(1)
f[1:]  # f.__getitem__(slice(1, None, None))
f[1:, 2]  # f.__getitem__( (slice(1, None, None), 2) )
f[1, 2]  # f.__getitem__( (1, 2) )
f[(1, 2)]  # f.__getitem__( (1, 2) )

诀窍（可能有点不寻常）就是简单地编写

\uuuu getitem\uuuu

，以便它查看传递的对象的类型，然后做正确的事情。对于我的答案，我作弊了，在我的

\uuuuu getitem\uuuuuuu

中创建了一个

元组，然后我在元组上调用了
\uuuuuuu getitem\uuuuuuu
（因为它在我想要支持的所有情况下都做了正确的事情）

下面是一些示例用法：

>>> f = Foo(1, 2)
>>> f[1]
2
>>> f[0]
1
>>> f[:]
(1, 2)

请注意，您通常甚至不需要自己做这件事。您可以创建一个用于为您执行作业的：

from collections import namedtuple
Foo = namedtuple('Foo', 'bar, baz')

而且用法基本相同：

>>> f = Foo(1, 2)
>>> f[1]
2
>>> f[0]
1
>>> f[:]
(1, 2)

这里的主要区别是我们的namedtuple是不可变的。一旦创建，我们就无法更改其成员。
这很容易。。。您只需定义一个
\uuu getitem\uu
方法来处理切片或整数/字符串查找。你可以做任何你想做的事

class Foo(object):
    def __init__(self, bar, baz):
        self.bar = bar
        self.baz = baz
    def __getitem__(self, ix):
        return (self.bar, self.baz).__getitem__(ix)

以下是在以下情况下将作为
ix
传递给
\uuu getitem\uuu
的备忘单：

f[1]  # f.__getitem__(1)
f[1:]  # f.__getitem__(slice(1, None, None))
f[1:, 2]  # f.__getitem__( (slice(1, None, None), 2) )
f[1, 2]  # f.__getitem__( (1, 2) )
f[(1, 2)]  # f.__getitem__( (1, 2) )

诀窍（可能有点不寻常）就是简单地编写
\uuuu getitem\uuuu
，以便它查看传递的对象的类型，然后做正确的事情。对于我的答案，我作弊了，在我的
\uuuuu getitem\uuuuuuu
中创建了一个
元组，然后我在元组上调用了
\uuuuuuu getitem\uuuuuuu
（因为它在我想要支持的所有情况下都做了正确的事情）

下面是一些示例用法：

>>> f = Foo(1, 2)
>>> f[1]
2
>>> f[0]
1
>>> f[:]
(1, 2)

请注意，您通常甚至不需要自己做这件事。您可以创建一个用于为您执行作业的：

from collections import namedtuple
Foo = namedtuple('Foo', 'bar, baz')

而且用法基本相同：

>>> f = Foo(1, 2)
>>> f[1]
2
>>> f[0]
1
>>> f[:]
(1, 2)

这里的主要区别是我们的namedtuple是不可变的。一旦创建，我们就不能更改它的成员。
Python包含多种方法，例如字典和列表

特别是，考虑下面的类：
 class MyDict(object):
     def __getitem__(self, key):
          # Called for getting obj[key]

     def __setitem__(self, key, value):
          # Called for setting obj[key] = value

如果你写信

obj = MyDict()

然后

将调用第一个方法，并且

obj[3] = 'foo'

将调用第二个方法

如果你还想支持

len(obj)

然后您只需要添加方法

def __len__(self):
    # Return here the logical length


下面是一个由列表实现的（非常低效）字典的示例

class MyDict(object):
    def __init__(self, seq=None):
        self._vals = list(seq) if seq is not None else []

    def __getitem__(self, key):
        return [v[1] for v in self._vals if v[0] == key][0]

    def __setitem__(self, key, val):
        self._vals = [v for v in self._vals if v[0] != key]
        self._vals.append((key, val))

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

您可以像普通的
dict
一样使用它：

obj = MyDict()
obj[2] = 'b'
>>> obj[2]
'b'

Python包含多种方法，例如字典和列表

特别是，考虑下面的类：
 class MyDict(object):
     def __getitem__(self, key):
          # Called for getting obj[key]

     def __setitem__(self, key, value):
          # Called for setting obj[key] = value

如果你写信

obj = MyDict()

然后

将调用第一个方法，并且

obj[3] = 'foo'

将调用第二个方法

如果你还想支持

len(obj)

然后您只需要添加方法

def __len__(self):
    # Return here the logical length


下面是一个由列表实现的（非常低效）字典的示例

class MyDict(object):
    def __init__(self, seq=None):
        self._vals = list(seq) if seq is not None else []

    def __getitem__(self, key):
        return [v[1] for v in self._vals if v[0] == key][0]

    def __setitem__(self, key, val):
        self._vals = [v for v in self._vals if v[0] != key]
        self._vals.append((key, val))

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

您可以像普通的
dict
一样使用它：

obj = MyDict()
obj[2] = 'b'
>>> obj[2]
'b'

我认为在类似python的ECMAScript（又名javascript）中，类是字典或关联数组。因为您可以在运行时向类添加属性或方法。（）

如果您想编写这样的类，可以使用
\uuu getitem\uuuuuuuuuuuuu
和
\uuuuuuuuuu setitem\uuuuuuuuuuu
方法：

class A(object):
    class B(object):
        def __init__(self, x, y):
            self.vals = (x, y)
        def __getitem__(self, key):
            return self.vals[key]
        def __setitem__(self, key, val):
            self.vals[key] = val
        def __len__(self):
            return len(self.__vals)
    def __init__(self, x, y):
        self.b = self.B(x,y)



a = A('foo','baz')

print type(a.b) # __main__.b     __main__ because we run script straightly
print a.b[:]    # ('foo', 'baz')

我认为在类似python的ECMAScript（又名javascript）中，类是字典或关联数组。因为您可以在运行时向类添加属性或方法。（）

如果您想编写这样的类，可以使用
\uuu getitem\uuuuuuuuuuuuu
和
\uuuuuuuuuu setitem\uuuuuuuuuuu
方法：

class A(object):
    class B(object):
        def __init__(self, x, y):
            self.vals = (x, y)
        def __getitem__(self, key):
            return self.vals[key]
        def __setitem__(self, key, val):
            self.vals[key] = val
        def __len__(self):
            return len(self.__vals)
    def __init__(self, x, y):
        self.b = self.B(x,y)



a = A('foo','baz')

print type(a.b) # __main__.b     __main__ because we run script straightly
print a.b[:]    # ('foo', 'baz')

您可以通过在类中重写getitem（）和setitem（）来实现相同的行为

    class Example:
        def __getitem__(self, index):
            return index ** 2

    >>> X = Example()
    >>> X[2]                                
    >>> 4

您也可以在类中重写setitem，以实现setter之类的功能
 您可以通过重写类中的getitem（）和setitem（）来实现相同的行为

    class Example:
        def __getitem__(self, index):
            return index ** 2

    >>> X = Example()
    >>> X[2]                                
    >>> 4

您也可以在类中重写setitem，以实现setter之类的功能
 注意，这不像是一本字典。。。它的行为更像是一个有命名成员的序列。是的，我同意你的观点。这是我的错。@mgilsonNote，这不像是一本字典。。。它的行为更像是一个有命名成员的序列。是的，我同意你的观点。这是我的错。@mgilson