python定制

1、简单定制

　　　  a、使用time模块的localtime方法获取时间

　　b、time.localtime返回struct_time的时间格式

　　c、表现你的类：__str__和__repr__

　　注：当属性名与方法名同名时，默认属性名覆盖方法名

　　　　

import time as t

class MyTimer():
    def __init__(self):
        self.begin = 0
        self.end = 0
        self.lasted = []
        self.prompt = "未运行"
        self.unit = ["年","月", "天", "小时", "分钟", "秒"]

    # 重写__str__和__repr__方法
    def __str__(self):
        return self.prompt
    __repr__ = __str__

    #定义add函数，计算运行总时间
    def __add__(self, other):
        result = []
        prompt = "总共运行了"
        for i in range(6):
            result.append(self.lasted[i]+other.lasted[i])
            if result[i]:
                prompt += (str(result[i])+self.unit[i])
        return prompt
    #开始计时
    def start(self):
        self.begin = t.localtime()
        self.prompt = "提示：请先调用stop()停止计时！"
        print("计时开始...")
    # 停止计时
    def stop(self):
        if not self.begin:
            print("提示：请先调用start()开始计时！")
        else:
            self.end = t.localtime()
            print("计时结束...")
    #定义内部方法，用于计算时间差
    def __calc__(self):
        self.lasted = []
        self.prompt = "总共运行了"
        for i in range(6):
            self.lasted.append(self.start[i] - self.stop[i])
            if self.lasted[i]:
                self.prompt += (str(self.lasted[i])+self.unit[i])
        #为下一轮计时初始化变量
        self.begin = 0
        self.end = 0
t1 = MyTimer()
t1.start()
t1.stop()
print(t1)

 2、定制序列

　　协议（Protocols）：与其他编程语言中的接口很相似，规定哪些方法必须定义。

　　容器类型的协议：

　　　　a、如果希望定制的容器是不可变的话，只需要定义__len__()和__getitem__()方法。

　　　　b、如果希望定制的容器是可变的话，除了__len__()和__getitem__()方法，还要定义　　__setitem__()和__delitem__()方法。

　　

　　#把类定义成一个容器
　　class CountList:
　　　　def __init__(self, *args):
　　　　　　self.values = [x for x in args] #将用户传入的参数存放到列表中
　　　　　　self.count = {}.fromkeys(range(len(self.values)), 0) #记录用户传入参数被访问的次数
　　　　def __len__(self):
　　　　　　return len(self.values)
　　　　def __getitem__(self, key):
　　　　　　self.count[key] += 1 #计数器加1
　　　　　　return self.values[key]
　　c1 = CountList(1, 3, 5, 7, 9)
　　c2 = CountList(2, 4, 6, 8, 10)
　　print(c1[1])
　　print(c2[1])
　　print(c1[2] + c2[1])
　　print(c1.count)
　　print(c2.count)

3、迭代器

　　a、iter()

　　　　__iter__()

　　b、next()

　　　　__next__()

　　

　　string = "加油吧"
　　#方法一：迭代输出元素
　　it = iter(string)
　　while True:
　　　　try:
　　　　　　each = next(it)
　　　　except StopIteration:
　　　　　　break
　　　　print(each)
　　#方法二：for循环输出元素
　　for i in string:
　　　　print(i)

　　

上述迭代器如果不加限制的话，会无限迭代下去，改进代码如下：

　　

4、生成器(yield):生成器其实就是迭代器的一种实现

　　协同程序：就是可以运行的独立函数调用，函数可以暂停或者挂起，并在需要的时候从程序离开的地方继续或者重新开始。

　　yield和var不同，不是用来声明，但是和return一样，用来告知程序某种状态，return告诉程序要返回什么值（也意味着结束，结束的时候才会返回值嘛），而yield告诉程序当前的状态值，而且你运行到这里给我暂停一下。

　　一个带有 yield 的函数就是一个 generator，它和普通函数不同，生成一个 generator 看起来像函数调用，但不会执行任何函数代码，直到对其调用 next()（在 for 循环中会自动调用 next()）才开始执行。

　　

　　

　生成器实现斐波那契数列：

　　　　

5、列表推导式

　　#列表推导式
　　#求出100以内能被2整除，不能被3整除的数
　　a = [i for i in range(100) if not (i % 2) and (i % 3)]
　　print(a)

6、字典推导式

　　#字典推导式
　　#返回10以内的数字是否为偶数
　　b = {i : i % 2 == 0 for i in range(10)}
　　print(b)

7、集合推导式

　　

8、生成器推导式

　　

　　

9、生成器推导式元素求和

　　#使用生成器求10以内的奇数和
　　s = sum(i for i in range(100) if i % 2)
　　print(s)