python复习48~49魔方方法（定制序列与迭代器）

定制序列

基于序列的三大容器：列表(List)、元祖( Tuple)、字符串(String)

定制容器类的魔法方法：

方法	作用
__ len __(self)	定义当被len()函数调用时的行为（返回容器中元素的个数）
__ getitem __(self,key)	定义获取容器中指定元素的行为（相当于self[key]）
__ setitem __(self,key,value)	定义设置容器中指定元素的行为，相当于self[key]=value)
__ delitem __(self,key)	定义删除容器中指定元素的行为，相当于del self[key]
__ iter __(self)	定义迭代容器中元素的行为
__ reversed __(self)	定义当被前后翻转reverse()函数调用的行为
__ contains __(self,item)	定义当使用成员测试运算符（in或not in）时的行为

编写一个不可改变的自定义列表，要求记录列表中每个元素被访问的次数。

class DIYlist:
    def __init__(self,*args):
        self.values=[x for x in args]#把每一个元素存放进value列表里
        self.count = {}.fromkeys(range(len(self.values)),0)#键为从0开始依此递增，长度为列表长度，对应初始值为0

    def __len__(self):#定义len()获取长度
        return len(self,value)

    def __getitem__(self,key):#访问列表中的元素时执行
        self.count[key]+=1
        return self.values[key]
        
>>> d1=DIYlist(1,6,3,5,9)
>>> d2=DIYlist(0,8,9,6,2)
>>> d1[2]
3
>>> d2[0]
0
>>> d1.count
{0: 0, 1: 0, 2: 1, 3: 0, 4: 0}

改进：在上一题的基础上支持append()、pop()、remove()、clear()、reverse()、insert()等方法。

class CountList(list):
    def __init__(self, *args):
        super().__init__(args)
        self.count = []
        for i in args:
            self.count.append(0)

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

    def __getitem__(self, key):
        self.count[key] += 1
        return super().__getitem__(key)

    def __setitem__(self, key, value):
        self.count[key] += 1
        super().__setitem__(key, value)

    def __delitem__(self, key):
        del self.count[key]
        super().__delitem__(key)

    def counter(self, key):  # 根据下标返回访问的次数
        return self.count[key]

    def append(self, value):
        self.count.append(0)
        super().append(value)

    def pop(self, key=-1):
        del self.count[key]
        return super().pop(key)

    def remove(self, value):
        key = super().index(value)
        del self.count[key]
        super().remove(value)

    def insert(self, key, value):
        self.count.insert(key, 0)
        super().insert(key, value)

    def clear(self):
        self.count.clear()
        super().clear()

    def reverse(self):
        self.count.reverse()
        super().reverse()


>>> c=CountList(9,0,8,7,6)
>>> c[1]
0
>>> print(c.count)
[0, 1, 0, 0, 0]
>>> print('*'*25)
*************************
>>> print(c.counter(1))
1
>>> c.append(9)
>>> print(c)
[9, 0, 8, 7, 6, 9]
>>> c.insert(3,69)
>>> print(c)
[9, 0, 8, 69, 7, 6, 9]
>>> c.clear()
>>> print(c)
[]
>>> print(c.count)
[]

迭代

迭代是重复反馈的过程，每一次迭代得到的结果会被原来作为下一次迭代的初始值。

迭代不是容器，它用于遍历容器里的数据。

>>> dict1={'carrot':'just do it',\
       'jack':'go away',\
       'nick':'hhh'}
>>> for each in dict1:
	print('%s-< %s'%(each,dict1[each]))

	
carrot-< just do it
jack-< go away
nick-< hhh

这就是一个迭代

关于iter()的用法：返回迭代器本身

>>> string = 'carrot'
>>> it = iter(string)
>>> while True:
	try:
		each=next(it)
	except StopIteration:
		break
	print(each)

	
c
a
r
r
o
t

关于__ next __(self)的用法：写迭代的规律，需与 __ iter __(self)连用

>>> class A:
	def __init__(self,n=15):
		self.a=0
		self.b=2
		self.n=n
	def __iter__(self):
		return self
	def __next__(self):
		self.a,self.b=self.b,self.a+self.b
		if self.a>self.n:
			raise StopIteration
		return self.a

>>> a=A(20)
>>> for each in a:
	print(each)
	
2
2
4
6
10
16

编写一个迭代器，要求输出迄今为止到2000年所有的闰年

import datetime as t

class LeapYear:
    def __init__(self):
        self.now = t.date.today().year

    def Leap(self, year):
        if (year%4 == 0 and year%100 != 0) or (year%400 == 0):
            return True
        else:
            return False

    def __iter__(self):
        return self

    def __next__(self):
        while not self.Leap(self.now):
            self.now -= 1

        temp = self.now
        self.now -= 1

        return temp

y = LeapYear()
for i in y:
    if i >= 2000:
        print(i)
    else:
        break

2020
2016
2012
2008
2004
2000