【Python】【数据类型】

【序列更新&散列&切片】
"""
from array import array
import reprlib
array1 = array('d',(1,2,3))
print(array1)   #array('d', [1.0, 2.0, 3.0])
com = reprlib.repr(array1)
components = com[com.find('['):-1] 
print('Vector({})'.format(components))   #Vector([1.0, 2.0, 3.0])
"""
#10.2 Vector类第一版，与Vector2d类兼容
#例子10-2
from array import array
import reprlib
import math
import numbers
import functools
import operator
import itertools

class Vector:
    typecode = 'd'

    def __init__(self,components):
        self._components = array(self.typecode,components)  # 把Vector分量保存在一个数组里

    def __iter__(self):
        return iter(self._components)  #构造一个迭代器

    def __repr__(self):
        components = reprlib.repr(self._components)    #使用reprlib.repr()获取self._components的有限长度表示形式（如array('d',[0.0,1.0,2.0,3.0,4.0,...])）
        components = components[components.find('['):-1] #把字符串插入Vector的构造方法调用之前，去掉前面的array('d' 和后面的)
        return 'Vector({})'.format(components)
    '''
    def __str__(self):
        return str(tuple(self))
    '''
    __str__ = __repr__

    def __bytes__(self):
        return (bytes([ord(self.typecode)]) + bytes(self._components))  #直接用self._components构建bytes对象
    def __eq__(self, other):
        return tuple(self) == tuple(other)
    def __abs__(self):
        return math.sqrt(sum(x*x for x in self))  #不能直接用hypot方法了，因此我们先计算各分量的平方之和，然后再使用sqrt方法开平方
    def __bool__(self):
        return bool(abs(self))
    @classmethod
    def frombytes(cls,octets):
        typecode = chr(octets[0])
        memv = memoryview(octets[1:]).cast(typecode)
        return cls(memv)      #构造方法变了，所以不用像前面那样使用*拆包
    def __len__(self):       #以下两个方法实现切片的序列
        return len(self._components)
    def __getitem__(self, item):
        cls = type(self)   #获取实例的类，供后面使用
        if isinstance(item,slice):
            return cls(self._components[item])
        elif isinstance(item,numbers.Integral):
            return self._components[item]
        else:
            msg = '{cls.__name__} indices must be integers'
            raise TypeError(msg.format(cls=cls))
    def __eq__(self, other):
        return len(self) == len(other) and all(a==b for a,b in zip(self,other)) #all函数，只要一次比较结果为False，则结果为False.所有结果为True,结果为True
                                                                                #考虑到，按照老规则的话，Vector([1,2]) 和(1,2)的比较结果是一样的，所以出来了这个新规则
    def __hash__(self):
        hashes = map(hash,self._components)
        return functools.reduce(operator.xor,hashes)
    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, fmt_spec):
        if fmt_spec.endswith('h'):
            fmt_spec = fmt_spec[:-1]
            coords = itertools.chain([abs(self)],self.angles())
            a = list(self.angles())
            outer_fmt = '<{}>'
        else:
            coords = self
            outer_fmt = '({})'
        components = (format(c,fmt_spec) for c in coords)
        return outer_fmt.format(','.join(components))

    #通过@property来动态获取属性，想要获取向量的四个分量时，要写四个这样的特性，太麻烦，所以选择__getattr__这个特殊方法。
    #属性查找失败后，解释器会调用__getattr__方法。简单来说，对my_obj.x表达式，python会检查my_obj实例有没有名为x的属性；如果没有，到类（my_obj.__class__）中查找；如果还没有，顺着继承树继续查找。如果依旧找不到，调用my_objh所属类中
    #...定义的__getattr__方法，传入self和属性名称的字符串形式。
    #例子10-8
    shortcut_names = 'xyzt'
    def __getattr__(self, item):
        cls = type(self)
        if len(item) == 1:
            pos = cls.shortcut_names.find(item)
            if 0<= pos < len(self._components):
                return self._components[pos]
            msg = '{.__name__!r} object has no attribute {!r}'
            raise AttributeError(msg.format(cls,item))

#【备注】1⃣️使用reprlib.repr的方式需要做些说明。这个函数用于生成大型数据结构或递归结构的安全表现形式，它会限制输出字符串的长度，用'...'表示截断的部分。我希望Vector实例的表现形式是Vector([3.0,4.0])这样，而不是
#Vector(array('d',[3.0,4.0]))，因为我们不需要实例中的实现细节。
#【备注】2⃣️编写__repr__方法时，本可以使用这个表达式生成简化的componets显示形式：reprlib.repr(list(self._components))。然而，这么做优点浪费，因为要把self._components中每个元素复制带一个列表中，
#然后使用列表的表示形式。
#【备注】3⃣️调用repr()目的是调试
#【备注】4⃣️我们本可以让Vector继承Vector2d，没这么做的原因幼儿。其一，两个构造方法不兼容，因此不建议继承。这一点可以通过适当处理__init__方法的参数解决，不过第二个原因更重要：我想把Vector类当作单独的事例，以此实现序列协议

#10.3 协议和鸭子类型

'''
#例子10-3 可切片的序列
v7 = Vector(range(7))
print(v7[-1])   #6.0
print(v7[1:4])  #Vector([1.0, 2.0, 3.0])
print(v7[-1:])  #Vector([6.0])
print(v7[1,2])  #TypeError: Vector indices must be integers   Vector不支持多维索引

#例子10-4 了解__getitem__和切片的行为
class MySeq:
    def __getitem__(self, item):
        return item
s = MySeq()
print(s[1])         #1
print(s[1:4])       #slice(1, 4, None)
print(s[1:4:2])     #slice(1, 4, 2)
print(s[1:4:2,9])   #(slice(1, 4, 2), 9)
print(s[1:4:2,7:9]) #(slice(1, 4, 2), slice(7, 9, None))
#例子10-5 查看slice属性
print(slice)        #<class 'slice'>
print(dir(slice))
print(slice(None,10,2).indices(5))  #(0, 5, 2)
print('ABCDE'[:10:2])               #ACE  根据上方的原理，等同于 'ABCDE'[0:5:2]
print(slice(-3,None,None).indices(5))  #(2, 5, 1)
print('ABCDE'[-3:])                #CDE 等同于'ABCDE'[2:5:1]

#例子10-15 zip内置函数的使用
print(zip(range(3),'ABC'))    #<zip object at 0x102832788>
print(list(zip(range(3),'ABC')))  #[(0, 'A'), (1, 'B'), (2, 'C')]
print(list(zip(range(3),'ABC',[0.0,1.1,2.2,3.3])))  #[(0, 'A', 0.0), (1, 'B', 1.1), (2, 'C', 2.2)]  zip有个奇怪的特性，当一个可迭代对象耗尽后，它不发出警告就停止
from itertools import zip_longest
print(list(zip_longest(range(3),'ABC',[0.0,1.1,2.2,3.3],fillvalue=-1)))  #[(0, 'A', 0.0), (1, 'B', 1.1), (2, 'C', 2.2), (-1, -1, 3.3)]

print(','.join(format(c,'.3e') for c in (3.45678,0.555555))) #3.457e+00,5.556e-01
print('{:.3e},{:.3e}'.format(3.4567855,0.555555))            #3.457e+00,5.556e-01
import itertools
print(itertools.chain('123','456'))                 #<itertools.chain object at 0x10c554c18>
print(list(itertools.chain('123', '456')))          # ['1', '2', '3', '4', '5', '6']
print(list(itertools.chain([3.4444],(3.4444444,)))) #[3.4444, 3.4444444]
#tests of 'format()' with spherical coordinates in 2d,3d and 4d:
v3 = Vector([1,1])
print(format(v3,'h'))        #<1.4142135623730951,0.7853981633974483>
print(format(v3,'.3eh'))     #<1.414e+00,7.854e-01>
print(format(v3,'0.5fh'))    #<1.41421,0.78540>
v4 = Vector([1,1,1])
print(format(v4,'h'))        #<1.7320508075688772,0.9553166181245093,0.7853981633974483>
v5 = Vector([-1,-1,-1,-1])
print(format(v5,'.3eh'))     #<2.000e+00,2.094e+00,2.186e+00,3.927e+00>
#tests of 'format()' with cartesian coordinates in 2d:
v5 = Vector([3,4])
print(format(v5))        #(3.0,4.0)
print(format(v5,'.2f'))  #(3.00,4.00)
print(format(v5,'.3e'))  #(3.000e+00,4.000e+00)
#tests of 'format()' with cartesian coordinates in 3d and 7d:
v6 = Vector([3,4,5])
print(format(v6))
v7 = Vector(range(7))  #(3.0,4.0,5.0)
print(format(v7))      #(0.0,1.0,2.0,3.0,4.0,5.0,6.0)
#tests of hashing
v9 =  Vector([3,4])
v10 = Vector(range(6))      #7 1
print(hash(v9),hash(v10))
#Most hash values on ono-integers vary from a 32-bit to 64-bit CPython build::
import sys
v8 = Vector([3.1,4.2])
print(hash(v8))    #384307168202284039
print(hash(v8) == (384307168202284039 if sys.maxsize > 2**32 else 357915986))  #True
#tests of '.__bytes__ '  and   'frombytes()' methods:
v11 = Vector([3,4,5])
v11_clone = Vector.frombytes(bytes(v11))
print(v11_clone)   #Vector([3.0, 4.0, 5.0])
print(v11 == v11_clone)  #True

# 例子10-9 针对例子10-8的验证，不恰当的行为：为v.x赋值没有报错，但是前后矛盾
v12 = Vector(range(5))
print(v12)   #Vector([0.0, 1.0, 2.0, 3.0, 4.0])
print(v12.x)  #0.0
v12.x = 10
print(v12.x)  #10
print(v12)   #为向量赋新值后，向量依然没变。Vector([0.0, 1.0, 2.0, 3.0, 4.0])
#【分析】如果向量的分量数组中没有新值，为什么v12.x返回10？例子10-9之所以前后矛盾，是__getattr__的运作方式导致的：仅当对象没有指定名称的属性时，python才会调用那个方法，这是一种后备机制。可是，像v12.x=10这样赋值
#...赋值后，v12对象就有x属性了，因此使用v12.xhuoqu x属性的值时不会调用__getattr__方法了，解释器直接返回绑定到v12.x上的值，即10。为避免这种前后矛盾的现象，我们要改写Vector中设置属性的逻辑。
#例子10-10 实现__setter__方法：虽然这个例子不支持为Vector分量赋值，但是有一个问题要特别注意：多数时候，如果实现了—__getattr__方法，那么也要实现__setattr__    方法，以防对象的行为不一致。
#如果像允许修改分量，针对Vector可以使用__setitem__，支持v[0]=1.1,或者实现__setattr__，支持v.x=1.1。不过，我们要保持Vector是不可变的，因为接下去的实验我们要把它变成可散列的。
#这里格外讲一下__setattr__
class Test:
    shortcut_names = 'xyzt'
    def __setattr__(self, key, value):
        cls = type(self)
        if len(key) == 1:
            if key in cls.shortcut_names:
                error = 'readonly attribute {attr_name!r}'
            elif key.islower():
                error = "cannot set attribute 'a' to 'z' in {cls_name!r}"
            else:
                error = ''
            if error:
                msg = error.format(cls_name=cls,attr_name=key)
                raise AttributeError(msg)
        super().__setattr__(key,value)
v11 = Test()
#v11.x = 2   #AttributeError: readonly attribute 'x'
#v11.a = 3    #AttributeError: cannot set attribute 'a' to 'z' in <class '__main__.Test'>
v11.B = 3
print(v11.B)  #3
#【分析】
#1⃣️ 为了给AttributeError选择错误信息，我查看了内置的complex类型的行为，因为complex对象是不可变的，而且有一堆数据属性：real  imag。如果试图修改任何一个属性，complex实例会抛出AttributeError，而且把错误
#消息设置为"cannot set attribute'。而如果尝试为受保护的只读属性赋值，得到的错误消息是'readonly attribute'。在__setattr__方法中为error字符串选词时，我参考了这两个错误消息
#注意，我们没有禁止为全部属性赋值，只是禁止为单个小写字母属性赋值，以防与只读属性x y z t 混淆
#2⃣️ 我们知道，在类型声明__slots__属性可以防止设置新实例属性；因此，你可能想使用这个功能，而不像这里所做的，实现__setattr__方法。可是，不将以只为了避免创建实例属性而使用它。__slots__属性只应该用于节省内存，而且仅当内存严重不足时才使用
'''

【list&tuple&dict】

# 栗子 list排序

ls = ['d.txt','a.xlxs','a.xlas','b.txt']
print(ls) #['d.txt', 'a.xlxs', 'a.xlas', 'b.txt']

ls.sort(key=lambda x:x[0])
print(ls) #['a.xlxs', 'a.xlas', 'b.txt', 'd.txt']

ls.sort(key=lambda x:x[4])
print(ls) #['a.xlas', 'b.txt', 'd.txt', 'a.xlxs']

students = [('john','A',15),('jane','B',12),('dave','B',10)]
print(sorted(students,key=lambda s:s[2])) #[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]