Python学习笔记27：类序列对象

最新推荐文章于 2021-12-23 17:06:45 发布
最新推荐文章于 2021-12-23 17:06:45 发布
阅读量459 收藏 3
点赞数 5
分类专栏： Python 文章标签： Python 序列化 切片
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hy6533/article/details/116240247
版权

Python学习笔记27：类序列对象

在Python中，通常会把符合一定“行为”的对象称呼为“类某某对象”。比如类文件对象，就是说实现了上下文协议，可以在with/as中使用的对象，其行为与文件操作类似。

对应的，我们也可以创建一个类序列对象，指的是某一类可以像序列容器那样进行操作的对象。

这里使用和《Fluent Python》中所举的多维向量一致的例子，可能在具体命名和实现上有出入，但整体思路一致，都是为了说明如何把一个Python学习笔记26：符合Python风格的对象所举例的二维向量扩展到多维，并且符合序列的特性。

VectorN

我们的首要工作是创建一个多维向量，并且实现之前二维向量的大多数基本功能。

import array


class VectorN():
    typeCode = 'd'

    def __init__(self, iterable):
        self.__contents = array.array(self.typeCode, iterable)

    def __iter__(self):
        return iter(self.contents)

    def __repr__(self):
        cls = type(self)
        clsName = cls.__name__
        if len(self.contents) == 0:
            return "{}()".format(clsName)
        string = str(self.contents)
        numbersStr = string[string.find('[')+1:-2]
        return "{}({})".format(clsName, numbersStr)

    def __str__(self):
        if len(self.contents) == 0:
            return "()"
        string = str(self.contents)
        numbersStr = string[string.find('[')+1:-2]
        return "({})".format(numbersStr)

    def __eq__(self, other):
        return tuple(self) == tuple(other)

    def __abs__(self):
        pass

    def __bool__(self):
        pass

    def __bytes__(self):
        return self.typeCode.encode('UTF-8')+bytes(self.contents)

    def angle(self):
        pass

    def __format__(self, format_spec):
        pass

    @classmethod
    def fromBytes(cls, bytesVectorN):
        typeCode = chr(bytesVectorN[0])
        arrayVectorN = array.array(typeCode)
        arrayVectorN.frombytes(bytesVectorN[1:])
        return cls(arrayVectorN)

    @property
    def contents(self):
        return self.__contents

    def __hash__(self):
        pass

这里基本是对照着之前我们创建的Vector类进行创建的，部分比较棘手的方法先使用pass进行占位，稍后我们重点讨论如何实现。

这里有这么几点需要着重说明：

建议对照Python学习笔记26：符合Python风格的对象中文末的Vector类完整代码进行理解。

  1. 因为是多维向量，所以初始化方法中使用array来实现底层存储，相应的，接收参数也改为一个可迭代对象。
  2. __iter__方法我们可以直接利用array的迭代器直接返回，关于迭代器的详细内容我们将在以后进行讨论。
  3. __repr__和__str__我们都利用array的字符串形式进行裁切后组合成我们需要的形式，这里其实可以更简单地将其转化为元组后直接使用元组地字符串形式，但多一步转化也意味着多一步性能浪费，对于多维数组来说，其多余的空间开销也的确值得注意，所以这里使用了字符串裁切的方式。
  4. 如同我们在第三点中说的，__eq__这里沿用Vector中的做法也存在额外的性能浪费，这个我们在稍后将详细说明，并且会给出优化方案。
  5. 关于字节序列化和反字节序列化的方法__bytes__和fromBytes几乎和Vector中的没有区别，只不过在反字节序列化的时候，return cls(arrayVectorN)没有使用*，这是因为我们在第一点中所说的，现在初始化方法只接收一个可迭代对象。
  6. 使用property装饰器的目的和之前一样，是为了后续实现散列。

现在我们简单测试一下：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
print(vectorN)
print(repr((vectorN)))
vectorN2 = VectorN(l)
print(vectorN == vectorN2)
vectorN3 = VectorN([1, 2, 3])
print(vectorN == vectorN3)
print(bytes(vectorN))
vectorNBytes = bytes(vectorN)
vectorN4 = VectorN.fromBytes(vectorNBytes)
print(vectorN == vectorN4)
# (1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
# VectorN(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
# True
# False
# b'd\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@\x00\x00\x00\x00\x00\x00\x1c@\x00\x00\x00\x00\x00\x00 @\x00\x00\x00\x00\x00\x00"@\x00\x00\x00\x00\x00\x00$@'
# True

这里还有一个细节需要优化，因为我们这里是多维向量，所以如果包含的维度很大，通过__str__和__repr__返回的字符串对控制台显示就很不友好，事实上就像我们之前所说的，__repr__只是用于开发者调试的，完全没有必要显示所有信息，我们这里可以学习Python官方组件在类似情况下的输出，对于多余信息用...来简化显示。

    def __repr__(self):
        cls = type(self)
        clsName = cls.__name__
        if len(self.contents) == 0:
            return "{}()".format(clsName)
        string = reprlib.repr(self.contents)
        numbersStr = string[string.find('[')+1:-2]
        return "{}({})".format(clsName, numbersStr)

这里只要使用reprlib模块就可以简单实现。

我们看效果：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
print(repr(vectorN))
# VectorN(1.0, 2.0, 3.0, 4.0, 5.0, ...)

序列化

正如我们之前说的，类文件对象是要实现上下文协议，而类序列对象自然也要实现对应的协议。

这里的协议很像是传统编程语言中的接口，在Java中，实现了相应接口自然也可以将对象应用到所有使用该接口的用途中，而Python中的协议并不完全是类似接口的存在，其关键因素是Python中的协议仅代表一种约定，并不具有强制性。

我们用序列的实现协议进行类比，我们先来看如何将VectorN“变成”一个序列：

    def __getitem__(self, index):
        return self.contents[index]

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

很简单对不对，只要实现__getitem__和__len__就可以了，而且我们还可以通过委托给内含的array来完成具体工作。

进行一下简单测试：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
print(vectorN[0])
print(vectorN[2])
print(len(vectorN))
# 1.0
# 3.0
# 10

事实上，并不是每一个需要“变现地像个序列”的类序列对象都要实现__getitem__和__len__，如果你只会用到len(obj)，则只实现__len__是可行的。相似的，如果你只用切片，那不实现__len__也可以。

所以说Python中的协议并不具有强制性，它只是指出完整协议需要实现哪些方法，而具体使用中你完全可以按照实际需求仅实现其中的一部分，这是符合Python风格的，Python的设计本身就处处体现着实用性的思想。

我们再说回VectorN，看似其表现的像个序列，但是如果我们使用更多的切片功能：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
print(vectorN[:])
print(vectorN[2:-1])
# array('d', [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0])
# array('d', [3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0])

看出问题了么？

切片得到的子序列并不是VectorN类型，而是array，这显然不是我们想要的。如果子序列和原始序列不是同一类型，那我们就不能针对子序列进行原始序列的操作，这很不Python。

所以我们接下来讨论如何进一步改造以实现完整的切片支持。

切片

切片原理

我们先来探索一下Python是如何实现切片的。

为了观察程序运行时Python解释器给__getitem__传入的实际参数，我们对VectorN做如下修改：

    def __getitem__(self, index):
        return index

运行测试程序：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
print(vectorN[1])
print(vectorN[:])
print(vectorN[1:5])
print(vectorN[1:10:2])
print(vectorN[1:5, 2])
# 1
# slice(None, None, None)
# slice(1, 5, None)
# slice(1, 10, 2)
# (slice(1, 5, None), 2)

不难观察到以下规律：

  • 当切片方式是单个数字的时候，传入的参数index就是单数字索引值。
  • 当切片方式是[:]的时候，index参数是一个slice对象，具体是slice(None,None,None)。
  • 当切片方式是[1:5]的时候，参数是slice(1,5,None)。
  • 特别的是，当切片是类似NumPy中的那种多维切片[1:5],2的时候，index参数是一个包含slice对象的元组。

现在我们还需要知道如何从slice对象中提取start\stop\step。

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
sli = slice(1,10,2)
print(dir(sli))
print(sli)
print(sli.start, sli.stop, sli.step)
sli2 = slice(1, None, None)
print(sli2.start, sli2.stop, sli2.step)
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', 
# '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'indices', 'start', 'step', 'stop']
# slice(1, 10, 2)
# 1 10 2
# 1 None None

通过一些简单试探，我们可以知道如何提取start\stop\step，理论上我们现在就可以改造__getitem__方法了，只不过麻烦一些，需要考虑这些值为None的情况要如何处理。

事实上情况远比这要复杂，因为Python的切片操作是支持反向的，也就是说你还要考虑step为负数，或者start和stop为负数的情况。

这无疑是让人抓狂的，为了处理这些Python已经干的很好的问题自己去再实现一套逻辑？

那显然是个糟糕的提议。

indices

事实上，slice实例有一个方法indices，正可以解决这个问题：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
sli = slice(1,10,2)
print(help(sli.indices))
# Help on built-in function indices:

# indices(...) method of builtins.slice instance
#     S.indices(len) -> (start, stop, stride)

#     Assuming a sequence of length len, calculate the start and stop
#     indices, and the stride length of the extended slice described by
#     S. Out of bounds indices are clipped in a manner consistent with the
#     handling of normal slices.

# None

只要传入序列长度，indeces方法就会自动计算出实际的相应起始、终止索引和步进，完全不需要我们自行计算。

实现

索引的问题解决了，我们还需要考虑非法输入的问题，比如像上面那样多维切片，我们要如何处理，该不该报异常，该使用何种异常，提示信息又要写什么。

这个问题我们完全可以参考Python官方：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
l[:,2]
# Traceback (most recent call last):
#   File "D:\workspace\python\test\test.py", line 4, in <module>
#     l[:,2]
# TypeError: list indices must be integers or slices, not tuple

到了愉快的抄答案时间了。

好了，现在完事具备，我们来改写__getitem__：

    def __getitem__(self, index):
        cls = type(self)
        if isinstance(index, numbers.Integral):
            return self.contents[index]
        elif isinstance(index, slice):
            start,stop,step = index.indices(len(self))
            subArray = self.contents[start:stop:step]
            return cls(subArray)
        elif isinstance(index, tuple):
            raise TypeError("list indices must be integers or slices, not tuple")
        else:
            raise TypeError("list indices must be integers or slices")

测试一下：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
print(vectorN[1])
print(vectorN[:])
print(vectorN[1:5])
print(vectorN[1:10:2])
print(vectorN[1:5, 2])
# 2.0
# (1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
# (2.0, 3.0, 4.0, 5.0)
# (2.0, 4.0, 6.0, 8.0, 10.0)
# Traceback (most recent call last):
#   File "D:\workspace\python\test\test.py", line 8, in <module>
#     print(vectorN[1:5, 2])
#   File "D:\workspace\python\test\vectorN.py", line 71, in __getitem__
#     raise TypeError("list indices must be integers or slices, not tuple")
# TypeError: list indices must be integers or slices, not tuple

事实上，在调用array切片的时候，我们可以不使用start:stop:step的方式，可以直接使用slice实例，array可以正确进行处理：

        elif isinstance(index, slice):
            # start,stop,step = index.indices(len(self))
            # subArray = self.contents[start:stop:step]
            subArray = self.contents[index]
            return cls(subArray)

但之前我们做的探索并非无用功，比如我们底层如果是自己实现，而非是利用已有容器，那就很有必要获取正确的索引和步进，此外我们也对slice实例有了更多的了解不是吗。

动态存取属性

在之前的Vector类中，我们通过使用装饰器property实现了对私有属性的读取和保护，那在VectorN中，如果我们需要以vectorN.x\vectorN.y等方式读取前几个元素是不是也可以用类似方法？

答案当然是可以的，但是对两三个元素我们可以如此处理，如果是多个元素也要一一创建方法并用property装饰？

当然不用，Python提供一个魔术方法__getattr__正是用于处理此类问题。

注意，Python中还有一个__getattribute__方法，这两个方法效果完全不同，不要搞混。

__getattr__

在实现__getattr__之前，我们还要搞清楚如果访问的属性超过合理范围，需要怎么显示错误。

当然是继续抄官方了：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
l[13]
# Traceback (most recent call last):
#   File "D:\workspace\python\test\test.py", line 4, in <module>
#     l[13]
# IndexError: list index out of range

现在来实现__getattr__：

    def __getattr__(self, name):
        attrStr = "xyzt"
        if len(name) == 1:
            index = attrStr.find(name)
            if 0 <= index < len(self):
                return self.contents[index]
        raise IndexError("list index out of range")

测试一下：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
print(vectorN.x)
print(vectorN.y)
print(vectorN.z)
# 1.0
# 2.0
# 3.0

__getattr__的运行机制是：当Python解释器试图获取一个实例属性，但是实例字典中没有的时候，会在其类中查找类属性，如果类属性也没有，就会在父类中查找，如果父类中也没有，就会通过__getattr__函数获取。

真实情况比这更复杂，会在以后进行讨论。

这种属性访问方式目前看来似乎没有问题，但是我们一旦进行赋值操作：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
print(vectorN.x)
vectorN.x = 2
print(vectorN.x)
print(vectorN[0])
# 1.0
# 2
# 1.0

当我们试图进行赋值操作的时候，奇怪的事情发生了。

事实上只要我们对实际上并不存在的属性进行赋值，就会给实例添加一个新的属性，这就会导致我们原来设置的__getattr__机制完全失效，后续的读取和赋值操作都只会针对新产生的实例属性。

要解决这个问题我们就要实现__setattr__。

__setattr__

事实上__setattr__和__getattr__经常成对出现，如果只设置了其中之一，很可能会出现一些意料之外的bug。

    def __setattr__(self, name, value):
        cls = type(self)
        if len(name) == 1:
            msg = ""
            if name in cls.attrStr:
                msg = "readonly attribute {}".format(name)
            else:
                pass
            raise AttributeError(msg)
        super().__setattr__(name, value)

因为__setattr__也要使用attrStr，所以改为类属性，这里不多做演示。

用同样的测试程序进行测试：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
print(vectorN.x)
vectorN.x = 2
print(vectorN.x)
print(vectorN[0])
# 1.0
# Traceback (most recent call last):
#   File "D:\workspace\python\test\test.py", line 5, in <module>
#     vectorN.x = 2
#   File "D:\workspace\python\test\vectorN.py", line 97, in __setattr__
#     raise AttributeError(msg)
# AttributeError: readonly attribute x

散列和快速等值测试

我们在Vector中使用位运算^来实现哈希算法，相应的，这里我们同样可以通过累积异或来实现多维向量的哈希算法。

这里的哈希算法就是散列算法，一个意思，因为"hash"更贴近音译，所以我更习惯用哈希称呼。

reduce

提到累积运算，高阶函数reduce当然会是首先想到的。

    def __hash__(self):        hashes = [hash(num) for num in self.contents]        return functools.reduce(operator.xor, hashes, 0)

这里需要注意的是，reduce的第三个参数是0，这是为了避免第二个参数为空或者仅有一个元素时候可能出现的bug。但这个参数需要注意的是并不能无脑设置为0，这个参数是和第一个参数的具体运算方式密切相关的。简单来说它要符合相应运算的幂等性。如果运算是+，则是0，因为0无论加多少次还是0。如果运算是*，则是1，因为1无论被乘以多少次还是1。对于异或，则是0，因为异或操作的准则为“相同为0，相异为1”，所以0被异或多少次依然为0。

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
print(hash(vectorN))
vectorN2 = VectorN([1,2,3])
print(hash(vectorN2))
vectorSet = set()
vectorSet.add(vectorN)
vectorSet.add(vectorN2)
# 11
# 0

通过上面的测试我们可以知道，VectorN已经被我们成功散列化，它是可散列的了。

eq优化

我们在之前提到过，在实现==运算符重载的时候存在性能浪费，我们这里进行优化。

如果是用其它传统变成语言的方式，我会这么优化：

    def __eq__(self, other):
        if len(self) != len(other):
            return False
        else:
            for i in range(len(self)):
                if self[i] != other[i]:
                    return False
            return True

测试一下：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
vectorN2 = VectorN([1,2,3])
print(vectorN == vectorN2)
vectorN3 = VectorN(l)
print(vectorN == vectorN3)

OK，没有任何问题。但是吹毛求疵的人会说这很不Python。

我们看一下用Python的方式要怎么实现。

zip

这里我们需要用到一个Python内建函数zip。

zip是为了解决如何同时遍历多个可迭代对象的问题：

a = [i for i in range(10)]
b = [i for i in range(1, 9)]
for num1, num2 in zip(a, b):
    print(num1, num2)
# 0 1
# 1 2
# 2 3
# 3 4
# 4 5
# 5 6
# 6 7
# 7 8

我们需要注意到的是，zip在处理多个可迭代对象的时候，如果这些可迭代对象包含的元素个数并不相同，则会在遍历完最少元素的可迭代对象后立即结束遍历，不会有任何异常或者报错，就像示例中一样，即使a还有两个元素没有输出，遍历也结束了。

相应的，还有一个zip_longest：

from itertools import zip_longest
a = [i for i in range(10)]
b = [i for i in range(1, 9)]
for num1, num2 in zip_longest(a, b, fillvalue=-1):
    print(num1, num2)
# 0 1
# 1 2
# 2 3
# 3 4
# 4 5
# 5 6
# 6 7
# 7 8
# 8 -1
# 9 -1

zip_longest需要导入itertools模块，且使用的时候需要指定一个填充值fillvalue。

当有可迭代对象遍历完，但其他对象还没有的时候，缺少的相应元素就会使用填充值进行填充，就像示例中的-1那样。

我们现在用zip来改写：

    def __eq__(self, other):
        if len(self) != len(other):
            return False
        else:
            for num1, num2 in zip(self, other):
                if num1 != num2:
                    return False
            return True

看似没有改变多少，但其实我们已经摒弃了实际下标，而是使用遍历器同时遍历两个容器，这已经是相当大的进步。即使两个容器下标不同，但只要有相同的元素个数，以及元素能一一对应相等，就可以认为是相等的两个容器。这无疑比使用下标更为灵活。

我们可以进一步Python化：

    def __eq__(self, other):
        if len(self) != len(other):
            return False
        else:
            return all(num1 == num2 for num1,num2 in zip(self, other))

all函数的参考可以看这里。

甚至是这样：

    def __eq__(self, other):
        return len(self) != len(other) and all(num1 == num2 for num1,num2 in zip(self, other))

这无疑比我们一开始的写法更Python，更“政治正确”。

但在我看来，如果你时间充裕，而且对编写更Python化的代码更痴迷，你完全可以追求此类的写法，但如果你时间紧迫，且对离散数学很头大，那完全可以跳过此类的写法，毕竟，Python的真正奥义是实用。

终于到我们最后一个议题了。

格式化

在Vector中我们使用格式化进行极坐标输出，对应到多维向量，则是“球面坐标”或“超球面坐标”。

球面坐标的解释可以看这里。

要实现到球面坐标系的转化，我们要实现对n维向量的极坐标系计算。具体数学公式我就不细究了，老实说，我现在还能看懂极坐标就已经很难为自己了orz，所以我这里照抄《Fluent Python》中的代码。

这里先需要实现多维向量的求模：

    def __abs__(self):
        return math.sqrt(sum(x*x for x in self))

再实现求坐标转换算法：

    def angle(self, n):
        r = math.sqrt(sum(x*x for x in self[n:]))
        a = math.atan2(r, self[n-1])
        if (n == len(self)-1) and (self[-1]<0):
            return math.pi * 2 -a
        else:
            return a

    def angles(self):
        return (self.angle(n) for n in range(1, len(self)))

最后实现格式化：

    def __format__(self, format_spec):
        if format_spec.endswith('h'):
            format_spec = format_spec[:-1]
            coords = itertools.chain([abs(self)],self.angles())
            outer_fmt = "<{}>"
        else:
            coords = self
            outer_fmt = "({})"
        components = (format(c, format_spec) for c in coords)
        return outer_fmt.format(','.join(components))

测试一下：

from vectorN import VectorN
l = [i for i in range(1, 11)]
vectorN = VectorN(l)
print(format(vectorN,'.2fh'))
# <19.62,1.52,1.47,1.42,1.36,1.30,1.23,1.15,1.03,0.84>

老实说我也不知道结果是否正确=。=，就当是正确的好了。

好了，以上就是这次的全部内容，能看到这里的童鞋值得鼓励。

最后附上目前为止VectorN的完整定义，便于查看：

import array
import numbers
import functools
import operator
import math
import itertools
import reprlib


class VectorN():
    typeCode = 'd'
    attrStr = "xyzt"

    def __init__(self, iterable):
        self.__contents = array.array(self.typeCode, iterable)

    def __iter__(self):
        return iter(self.contents)

    def __repr__(self):
        cls = type(self)
        clsName = cls.__name__
        if len(self.contents) == 0:
            return "{}()".format(clsName)
        string = reprlib.repr(self.contents)
        numbersStr = string[string.find('[')+1:-2]
        return "{}({})".format(clsName, numbersStr)

    def __str__(self):
        if len(self.contents) == 0:
            return "()"
        string = str(self.contents)
        numbersStr = string[string.find('[')+1:-2]
        return "({})".format(numbersStr)

    def __eq__(self, other):
        return len(self) != len(other) and all(num1 == num2 for num1,num2 in zip(self, other))

    def __abs__(self):
        return math.sqrt(sum(x*x for x in self))

    def __bool__(self):
        return abs(self) != 0

    def __bytes__(self):
        return self.typeCode.encode('UTF-8')+bytes(self.contents)

    @classmethod
    def fromBytes(cls, bytesVectorN):
        typeCode = chr(bytesVectorN[0])
        arrayVectorN = array.array(typeCode)
        arrayVectorN.frombytes(bytesVectorN[1:])
        return cls(arrayVectorN)

    @property
    def contents(self):
        return self.__contents

    def __getitem__(self, index):
        cls = type(self)
        if isinstance(index, numbers.Integral):
            return self.contents[index]
        elif isinstance(index, slice):
            # start,stop,step = index.indices(len(self))
            # subArray = self.contents[start:stop:step]
            subArray = self.contents[index]
            return cls(subArray)
        elif isinstance(index, tuple):
            raise TypeError(
                "list indices must be integers or slices, not tuple")
        else:
            raise TypeError("list indices must be integers or slices")

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

    def __getattr__(self, name):
        cls = type(self)
        if len(name) == 1:
            index = cls.attrStr.find(name)
            if 0 <= index < len(self):
                return self.contents[index]
        raise IndexError("list index out of range")

    def __setattr__(self, name, value):
        cls = type(self)
        if len(name) == 1:
            msg = ""
            if name in cls.attrStr:
                msg = "readonly attribute {}".format(name)
            else:
                pass
            raise AttributeError(msg)
        super().__setattr__(name, value)

    def __hash__(self):
        hashes = [hash(num) for num in self.contents]
        return functools.reduce(operator.xor, hashes, 0)

    def angle(self, n):
        r = math.sqrt(sum(x*x for x in self[n:]))
        a = math.atan2(r, self[n-1])
        if (n == len(self)-1) and (self[-1]<0):
            return math.pi * 2 -a
        else:
            return a

    def angles(self):
        return (self.angle(n) for n in range(1, len(self)))

    def __format__(self, format_spec):
        if format_spec.endswith('h'):
            format_spec = format_spec[:-1]
            coords = itertools.chain([abs(self)],self.angles())
            outer_fmt = "<{}>"
        else:
            coords = self
            outer_fmt = "({})"
        components = (format(c, format_spec) for c in coords)
        return outer_fmt.format(','.join(components))

又是在一个没有暖气的阴冷北方下午完成了这篇博客，你们对我的CSDN博客的关注评论和点赞是我继续更新的最大动力，在这里再次感谢。

对我的博客有任何看法和内容纠错，都可以在下面留言。

谢谢阅读。

image-20210428182241629

魔芋红茶
关注
专栏目录
Python学习笔记-序列（1）
qq_51924093的博客
01-24 863
文章目录列表常用方法列表的创建列表元素的增加和删除增加删除列表元素访问和计数访问计数成员资格判断列表排序列表相关的其他内置函数汇总元祖元祖创建元组的元素访问和计数 python中常用的序列结构有：字符串、列表、元组、字典、集合 列表 语法公式：a = [10,20,30,40] 常用方法 方法 描述 list.append(x) 将元素 x 增加到列表 list 尾部 list.extend(aList) 将列表 alist 所有元素加到列表 list 尾部 list.insert(
python中的序列对象
yihuliunian的博客
06-13 421
转载自品略图书馆http://www.pinlue.com/article/2020/05/0113/4810273347219.html 在很多的入门书籍中，会针对列表，元组，字符串单独进行介绍，看完之后，你会发现有部分操作是相通的，比如根据下标进行访问的操作 >>> a = [1, 2, 3, 4, 5] >>> b = (1, 2, 3, 4, 5) >>> c = "abcdef" >>> a[0] 1 &..
浅谈python序列对象
asd3331380的博客
12-23 483
转自：微点阅读（www.weidianyuedu.com）微点阅读 - 范文大全 - 免费学习知识的网站 在很多的入门书籍中，会针对列表，元组，字符串单独进行介绍，看完之后，你会发现有部分操作是相通的，比如根据下标进行访问的操作 >>> a = [1, 2, 3, 4, 5] >>> b = (1, 2, 3, 4, 5) >>> c = "abcdef" >>> a[0] 1 >>> b[0] 1
Python基础---序列对象
weixin_30456039的博客
09-17 302
一.序列简介 数据结构是通过某种方式组织在一起的元素的集合。 容器（Container）是一种Python的数据结构，基本上是包含其他对象的任意对象。序列和映射（如字典）是两类主要的容器。集合（Set）也是容器类型。 序列是最基本的数据结构，是通过对数据元素进行编号将它们组织在一起的数据元素的集合。 成员是有序排列的，可以通过小标偏移量访问到它的一个或者几个成员，这类pyth...
Python学习笔记(干货) 中文PDF完整版.pdf
最新发布
05-23
这份"Python学习笔记"涵盖了从环境搭建到基础语法，再到数据类型和控制结构等关键知识点，旨在为初学者提供全面的学习指导。 首先，1.1章节介绍了Python的基础，包括Python的起源和历史。Python是由Guido van ...
python学习笔记
12-17
在Python学习笔记中，我们主要探讨以下几个核心知识点： 1. **数据类型与数据结构** Python支持多种数据类型，包括基本的整型、浮点型、字符串等。其中，数据结构是Python的一大特色，特别是容器类型。容器可以...
python学习笔记–2，序列方法
12-23
序列方法 dir(…)#查看所有方法 help(…)#查看帮助文档 ①列表方法 li=[1,2,[3,4]] 增 li.append(4)#在列表最后添加4，将append括号内的内容视为一个元素 li.insert(2,…)#在元素2前添加…，将…视为一个元素 li....
python学习笔记：字典的使用示例详解
01-21
经典字典使用函数dict：通过其他映射（比如其他字典）或者（键，值）这样的序列对建立字典。当然dict成为函数不是十分确切，它本质是一种类型。如同list。 复制代码 代码如下:items=[(‘name’,’zhang’),(‘age’,...
Python学习笔记：序列操作详解
"这是一份关于Python学习的个人笔记，主要涵盖了Python中的序列类型，包括字符串、列表和元组。笔记作者参考了《Python核心编程》一书，并编写了自己的程序来辅助理解。文档以.doc格式保存，适合正在学习Python的...
Python:slice与indices的用法
09-18
今天小编就为大家分享一篇Python:slice与indices的用法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Python序列对象特点
Neptuneyut的博客
04-27 1695
文章目录序列对象切片内置函数算数运算 序列对象 字符串(str) 列表（list） 元组(tuple) 字典(dict) 序列对象都是一系列的数据组成的集合，它们有很多共同的特点和操作方法 切片 字符串、列表、元组都是有序序列类型，因此都可切片取出任意子串;而字典无序无法按照固定索引切片。 类型 示例 结果 字符串 ‘abc’.[1:3] ‘bc’ 列表 [‘a’,‘b’,...
python：序列切片
OceanStar的博客
02-05 1319
!#!/usr/bin/python3 list = [ 'Google' , 'Runoob' , "Zhihu" , "Taobao" , "Wiki" ] # 读取第二位 print("list[1]: " , list [ 1 ]) # 从第二位开始（包含）截取到倒数第二位（不包含） print("list[1:-2]: " , list [ 1 : - 2 ])
python indices_Python numpy.indices() 使用实例
weixin_39901213的博客
12-19 2322
The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can al...
【Python】由slice和indices引发的对Python中切片操作的思考
小哲的博客
07-14 1629
由slice和indices引发的对Python中切片操作的思考Python中slice和indices的使用案例Python中的切片魔术方法_\_getitem()__和__setitem()_\_切片在__getitem__和__setitem__中的行为slice类和indices方法自定义支持索引的类总结参考资料 Python中slice和indices的使用案例 一般来说，内置的slice()函数会创建一个切片对象，可以用在任何允许进行切片操作的地方。 首先，看一下slice的用法： # slic
python cookbook笔记（1.11~1.20）
qq_43753525的博客
06-03 199
1.11:命名切片（使代码更清晰） 内置的 slice() 函数创建了一个切片对象。所有使用切片的地方都可以使用切片对象。 ###### 0123456789012345678901234567890123456789012345678901234567890' record = '....................100 .......513.25 ..........' #直接...
python编程之slice与indices函数用法
Free雅轩的博客
10-09 984
这篇文章主要介绍了详解python编程中slice与indices使用示例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪 一般来说，内置的slice()函数会创建一个切片对象，可以用在任何允许进行切片操作的地方。 下面是slice的简介： # slice 两种用法 class slice(stop) class slice(start, stop[, step]) 返回一个表示由 range(start, stop, step) 所指定索引集的 slice 对
python indices_python numpy triu_indices函数
weixin_39673051的博客
03-01 496
numpy.triu_indices返回函数的上三角矩阵numpy.triu_indices(n,k=0,m=None)[source]Return the indices for the upper-triangle of an (n, m) array.Parameters: n : intThe size of the arrays for which the returned indic...
python解析json时出现“string indices must be integers”
热门推荐
我的博客
02-20 5万+
import json，但是出现了一个奇怪的问题：string indices must be integers这个错误告诉我，[ ]里面应该是数字而不是字符串，但是dict使用key访问也可以，这种错误感觉解析出来的结果像是一个list。所以考虑是字符串解析的问题。打印解析的结果，是一长串的字符串，一堆的key挤在一起，value都缺失了。再打印原始的字符串，发现了一些细节，key并没有被双引号...
Python学习笔记：探索序列与惯性导航算法
"这篇文档是关于Python编程的学习笔记，涵盖了序列、列表、元组等基础知识，以及编程概念和语言特性。作者强调Python的易读性和跨平台性，并适合初学者学习。" 在Python编程中，序列是一种重要的数据类型，包括字符...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值