py3000愉快的开始

摆渡终极鉴黄师

getattr(object, name[, default])#用于返回对象的属性值，如果指定的对象不存在，如果有设置default，那么Ta会把default参数打印，否则会抛出异常，返回一个AttributeError

摆渡终极鉴黄师

严记只要是用户可以控制的变量都是有危害的

摆渡终极鉴黄师

1、如果第一个参数不是对象，则永远返回False
2、如果第二个参数不是类或者由类的对象组成的元祖，会抛出一个TypeError异常
isinstance(object, classinfo)

摆渡终极鉴黄师

魔法方法总是被双下划线包围，例如__init__
魔法方法是面向对象的python的一切
魔法方法的“魔力”体现在总是能够在适当的时候自动被调用

摆渡终极鉴黄师

___new___(cls[, ...])  例如
>>>class CapStr(str):
                def __new__(cls, string):
                        string = string.upper()
                        return str.__new__(cls, string)


>>>a = CapStr("I love FishC.com!")
>>>a
'I LOVE FISHC.COM!'
>>>

摆渡终极鉴黄师

>>> class C:
                def __init__(self):
                             print("我是__init__方法，我被调用了....")
                def __del__(self):
                            print("我是__del__方法，我被调用了....")


>>> c1 = C()
我是__init__方法，我被调用了....
>>> c2 = c1
>>> c3 = c2
>>> del c3
>>> del c2
>>> del c1
我是__del__方法，我被调用了....
>>>
魔法del方法Ta并不是说发生del操作后就被调用，当Ta的对象生成之后，所有对Ta的引用，都被del之后，才会启动垃圾回收机制，当这个垃圾回收机制去销毁这个对象的时候，Ta就会自动调用del方法

摆渡终极鉴黄师

__add__(self, other)                定义加法的行为：+
__sub__(self, other)                定义减法的行为：-
__mul__(self, other)                定义乘法的行为：*
__truediv__(self, other)        定义真除法的行为：/
__floordiv__(self, other)        定义整数除法的行为：//
__mod__(self, other)        定义取模算法的行为：%
__divmod__(self, other)        定义当被 divmod() 调用时的行为
__pow__(self, other[, modulo])        定义当被 power() 调用或 ** 运算时的行为
__lshift__(self, other)        定义按位左移位的行为：<<
__rshift__(self, other)        定义按位右移位的行为：>>
__and__(self, other)                定义按位与操作的行为：&
__xor__(self, other)                定义按位异或操作的行为：^
__or__(self, other)                定义按位或操作的行为：|

摆渡终极鉴黄师

>>> class New_int(int):
                def __add__(self, other):
                                return int.__sub__(self, other)
                def __sub__(self, other):
                                return int.__add__(self, other)

>>> a = New_int(3)
>>> b = New_int(5)
>>> a + b # 调用了add魔法方法
-2
>>> a - b # 调用了sub魔法方法
8

摆渡终极鉴黄师

>>> class Try_int(int):
                def __add__(self, other):
                                return self + other
                def __sub__(self, other)
                                 return self - other


>>> a = Try_int(3)
>>> b = Try_int(5)
>>> a + b        #        先调用add，返回self（self绑定了a进来），other事实上呢是加法右边的另外一个数，也就是b，return又是返回 a+b，又是发现加法，然后又是进行add，先调用add，返回self（self绑定了a进来），other事实上...所以就无限递归了
>>> *!^*(&$@*&!#(*        #        无限递归

摆渡终极鉴黄师

>>> class Try_int(int):
                def __add__(self, other):
                        return int(self) + int(other)        #        这样的话呢返回的就是一个整形相加的值了
                def __sub__(self, other):
                        return int(self) - int(other)        #        这样的话呢返回的就是一个整形相减的值了


>>> a = Try_int(3)
>>> b = Try_int(5)
>>> a + b
8
>>>
然后就不会无限递归了

摆渡终极鉴黄师

divmod(a, b)返回的值是一个元祖：(a//b, a%b)

摆渡终极鉴黄师

>>> class int(int):
                def __add__(self, other)
                                return int.__sub__(self, other)

>>> a = int('5')
>>> a
5
>>> b = int(3)
>>> a + b
2                #        这里是因为add方法被sub覆盖掉了（a的话呢，加法操作没有实现或者不支持的时候，Ta就会实现b的反运算，相应的加法反运算操作符）
>>>
当Ta变成类对象的时候Ta就把原来的给覆盖掉了

摆渡终极鉴黄师

>>> class Nint(int):
                def __radd__(self, other):
                                return int.__sub__(self, other)                #        这里的self指的是b，这里的other反而是指前面的那一个


>>> a = Nint(5)
>>> b = Nint(3)
>>> a + b
8
>>> 1 + b        #        因为这个1Ta找不到Ta的add方法然后Ta就找了b，b呢有这个radd方法，那么Ta就触发b的radd方法，结果上呢事实上就执行了一个sub方法，把两个相减，把3去减去1就得到这个2
2
>>>

摆渡终极鉴黄师

>>> class Nint(int):
                        def __rsub__(self, other):               
                                        return int.__sub__(self, other)        #←


>>> a = Nint(5)
>>> 3 - a
2
所以应该这样
>>> class Nint(int):
                        def __rsub__(self, other):               
                                        return int.__sub__(other, self)#←


>>> a = Nint(5)
>>> 3 - a
2

摆渡终极鉴黄师

一元操作符
__neg__(self)        定义正号的行为：+x                #强调说你这玩意儿是一个正数，表示正号的行为
__pos__(self)        定义负号的行为：-x                        #强调说你这玩意儿是一个负数，表示负号的行为
__abs__(self)        定义当被abs()调用时的行为        #取绝对值的意思
__invert__(self)定义按位取反的行为：~x                #0的变成1,1的变成0

摆渡终极鉴黄师

时间远足（time.struct_time）:
gmtime(), localtime()和strptime()以时间元祖（struct_time）的形势返回。
索引值（Index）        属性（Attribute）                        值（Values）
0                                tm_year(年)                                （例如：2015）
1                                tm_mon（月）                        1 ~ 12
2                                tm_mday（日）                        0 ~ 31
3                                tm_hour（时）                        0 ~ 23
4                                tm_min（分）                                0 ~ 59
5                                tm_sec（秒）                                0 ~ 61（下方见注1）
6                                tm_wday（星期几）                0 ~ 6（0 表示星期一）
7                                tm_yday（一年中的几天）        1 ~ 366
8                                tm_isdst（是否为夏令时）        0， 1， -1（-1代表夏令时）
注1：范围真的是 0 ~ 61；60代表闰秒， 61是基于历史原因保留。

摆渡终极鉴黄师

import time as t

class MyTimer:
    def __init__(self):
        self.unit = ['年', '月', '天', '小时', '分钟', '秒']
        self.prompt = "未开始计时！"
        self.lasted = []
        self.begin = 0                #        不要跟方法名重复
        self.end = 0
   
    def __str__(self):
        return self.prompt

    __repr__ = __str__

    def __add__(self, other):
        prompt = "总共运行了"
        result = []
        for index in range(6):
            result.append(self.lasted[index] + other.lasted[index])
            if result[index]:
                prompt += (str(result[index]) + self.unit[index])
        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()
            self._calc()
            print("计时结束！")

    # 内部方法，计算运行时间
    def _calc(self):
        self.lasted = []
        self.prompt = "总共运行了"
        for index in range(6):
            self.lasted.append(self.end[index] - self.begin[index])
            if self.lasted[index]:
                self.prompt += (str(self.lasted[index]) + self.unit[index])
        # 为下一轮计时初始化变量
        self.begin = 0
        self.end = 0

摆渡终极鉴黄师

属性函数property

将类方法转换为只读属性
重新实现一个属性的setter和getter方法

摆渡终极鉴黄师

魔法方法        什么时候被调用        解释
__new__(cls [,...])        instance = MyClass(arg1, arg2)        __new__在实例创建时调用
__init__(self [,...])        instance = MyClass(arg1,arg2)        __init__在实例创建时调用
__cmp__(self)        self == other, self > other 等        进行比较时调用
__pos__(self)        +self        一元加法符号
__neg__(self)        -self        一元减法符号
__invert__(self)        ~self        按位取反
__index__(self)        x[self]        当对象用于索引时
__nonzero__(self)        bool(self)        对象的布尔值
__getattr__(self, name)        self.name #name不存在        访问不存在的属性
__setattr__(self, name)        self.name = val        给属性赋值
__delattr_(self, name)        del self.name        删除属性
__getattribute__(self,name)        self.name        访问任意属性
__getitem__(self, key)        self[key]        使用索引访问某个元素
__setitem__(self, key)        self[key] = val        使用索引给某个元素赋值
__delitem__(self, key)        del self[key]        使用索引删除某个对象
__iter__(self)        for x in self        迭代
__contains__(self, value)        value in self, value not in self        使用in进行成员测试
__call__(self [,...])        self(args)        “调用”一个实例
__enter__(self)        with self as x:        with声明的上下文管理器
__exit__(self, exc, val, trace)        with self as x:        with声明的上下文管理器
__getstate__(self)        pickle.dump(pkl_file, self)        Pickling
__setstate__(self)        data = pickle.load(pkl_file)        Pickling#拷贝用来复习的

摆渡终极鉴黄师

class C:
    def __getattribute__(self, name):
        print('getattribute')
        # 使用 super() 调用 object 基类的 __getattribute__ 方法
        return super().__getattribute__(name)  

    def __setattr__(self, name, value):
        print('setattr')
        super().__setattr__(name, value)

    def __delattr__(self, name):
        print('delattr')
        super().__delattr__(name)

    def __getattr__(self, name):
        print('getattr')