内置方法

#!/usr/bin/env python
# -*- coding:utf-8 -*-

 四个方法的使用演示

class BlackMedium:
    feature = 'Ugly'
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr

    def sell_hours(self):
        print("%s 不傻" %self.name)

    def ren_hours(self):
        print("%s 不租" %self.addr)

b1 = BlackMedium('金三角','锦绣华城')
# 判断类b1 中是否有一个name字符串对应的方法或属性
print(hasattr(b1,'addr',))
# 判断类b1 中是否有一个ren_hours字符串对应的方法或属性
print(hasattr(b1,'ren_hours'))

# 获取属性
n = getattr(b1,'name')
print(n)
m = getattr(b1,'sell_hours')
m()

#设置属性
setattr(b1,'sb',True)
setattr(b1,'show_name',lambda self:self.name+'sb')
print(b1.__dict__)
print(b1.show_name(b1))

# 删除属性

delattr(b1,'addr')
delattr(b1,'show_name')
# delattr(b1,'show_name1111')#不存在，就报错
print(b1.__dict__)

******类也是对象*******

class Foo(object):
    staticField = 'oldboy'
    def __init__(self):
        self.name = 'wupeiqi'

    def func(self):
        return 'func'

    @staticmethod
    def bar():
        return 'bar'

print(getattr(Foo,'staticField'))
print(getattr(Foo,'func'))
print(getattr(Foo,'bar'))

反射当前模块成员

import sys
def s1():
    print('s1')

def f2():
    print('s2')

this_module = sys.modules[__name__]

a = hasattr(this_module,'s1')
b = hasattr(this_module,'s2')
print(a)
print(b)

三__setattr__,__delattr__,__getattr__

class Foo:
    x = 1
    def __init__(self,y):
        self.y = y

    def __getattr__(self, item):
        print('-->from getattr:你找的属性不存在：')

    def __setattr__(self, key, value):
        print('--> from setattr')
        # self.key = value
        # self.__dict__[key] = value

    def __delattr__(self, item):
        print('--> from delattr')
        # del self.item
        self.__dict__.pop(item)

property

四，二次加工标准类型（包装）

基于继承实现

class List(list):
    
    def append(self, p_object):
        if not isinstance(p_object,int):
            raise TypeError('must be int')

        super().append(p_object)

    @property
    def mid(self):
        index = len(self)//2
        return self[index]
l = List([1,2,3,4])
print(l)
l.append(5)
print(l)
print(l.mid)
l.insert(1,-123)
print(l)
print(len(l))
l.clear()
print(l)

# 练习，（clear 加权限限制）

class List(list):
    def __init__(self,item,tag = False):
        super().__init__(item)
        self.tag = tag

    def append(self, p_object):
        if not isinstance(p_object, int):
            raise TypeError

        super().append(p_object)

    def clear(self):
        if not self.tag:
            raise PermissionError
        super().clear()

l = List([1,2,3],False)
print(l)
print(l.tag)

l.append(123)
print(l)
l.tag = True
print(l.tag)
l.clear()
print(l)

# ***授权***

实现授权的关键点就是覆盖__getattr__方法

import time
class FileHandle:
    def __init__(self,filename,mode = 'r',encoding = 'utf-8'):
        self.file = open(filename,mode,encoding='utf-8')

    def write(self,line):
        t = time.strftime('%Y-%m-%d %T')
        self.file.write('%s %s '%(t,line))

    def __getattr__(self, item):
        return getattr(self.file,item)
f1 = FileHandle('b.txt','w+')
f1.write('你好啊')
f1.seek(10)
print(f1.read())
f1.close()

# 授权示范二

# __author__ = 'linhaifeng'
# 我们来加上b模式支持
"""
import time
class FileHandle:
    def __init__(self,filename,mode = 'r',encoding = 'utf-8'):
        if 'b' in mode:
            self.file = open(filename,mode)
        else:
            self.file == open(filename,mode,encoding= encoding)
        self.filename = filename
        self.mode = mode
        self.encoding = encoding

    def wriet(self,line):
        if 'b' in self.mode:
            if not isinstance(line,bytes):
                raise TypeError('must be bytes')
        self.file.write(line)

    def __getattr__(self, item):
        return getattr(self.file,item)

    def __str__(self):
        if 'b' in self.mode:
            res = "<_io.BufferedReadr name ='%s'>"%self.filename

        else:
            res = "<_io Text|OWrapper name = '%s' mode = '%s' encoding = '%s'>" %(self.filename,self.mode,self.encoding)
        return res

f1 = FileHandle('b.txt','wb')
f1.wriet("你好啊".encode('utf-8'))
print(f1)
f1.close()

# 练习题（授权）
# 练习一
"""
class List:
    def __int__(self,seq):

        self.seq = seq

    def append(self,p_object):
        if not isinstance(p_object,int):
            raise TypeError('must be int')

        self.seq.append(p_object)

    @property
    def mid(self):
        index = len(self.seq)//2
        return self.seq[index]

    def __getattr__(self, item):
        return getattr(self.seq,item)

    def __str__(self):
        return str(self.seq)
l = List([1,2,3,4])
print(l)
l.append(4)
print(l)
print(l.mid)


"""

# 五、、__getattribute__
"""
class Foo:
    def __init__(self,x):
        self.x = x

    def __getattr__(self, item):
        print('执行的是我')
        # return self.__dict__[item]

f1 = Foo(10)
print(f1.x)
f1.xxxxxxx#不存在的属性访问，触发__getattr__


# getattribute

class Foo:
    def __init__(self,x):
        self.x =x
        
    def __getattribute__(self, item):
        print("不管是否存在，我都会执行")
        
f1 = Foo(10)
f1.x
f1.xxxxx
"""


# 六 、描述符（__get__,__set__,__delete__）
# 1 描述符是什么:描述符本身就是一个新式类，在这个新式类中，至少实现了__get__(),__set__(),__delete__()中的一个，
# 这个也被称为描述符协议__get__():调用一个属性时，触发。__get__()：为一个属性赋值时，触发。
# __delete__():采用del删除属性时，触发

# 定义一个描述符
"""
class Foo:
    def __get__(self,instance,owner):
        pass
    
    def __set__(self,instance,value):
        pass
    
    def __delete__(self, instance):
        pass
"""

# 2.描述符是干什么的：描述符的作用是用来代理另外一个类属性的（必须把描述符定义成这个类的类属性，不能定义到构造函数中）
"""
class Str:
    def __get__(self, instance, owner):
        print('Str 调用')

    def __set__(self, instance, value):
        print('Str 设置。。。')

    def __delete__(self, instance):
        print('Str 删除。。。')

class Int:
    def __get__(self, instance, owner):
        print('Int 调用')

    def __set__(self, instance, value):
        print('Int 设置。。。')

    def __delete__(self, instance):
        print('Int 删除。。。')

class People:
    name = Str()
    age = Int()
    def __init__(self,name,age):
        self.name = name
        self.age = age

p1 = People('alex',18)

p1.name
p1.name = 'egon'
del p1.name

p1.age
p1.age = 18
del p1.age

print(p1.__dict__)
print(People.__dict__)

print(type(p1) == People)#type(obj)其实是查看obj是由哪个类实例化来的
print(type(p1).__dict__ == People.__dict__)

"""

# 修订__get__方法
"""
class Str:
    def __init__(self,name):
        self.name = name

    def __get__(self,instance,owner):
        print("get-->",instance,owner)
        if instance is None:
            return self
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        print("ste-->",instance,value)
        instance.__dict__[self.name] = value

    def __delete__(self, instance):
        print('__delete__-->',instance)
        instance.__dict__.pop(self.name)

class People:
    name = Str('name')
    def __init__(self,name,age,salary):
        self.name = name
        self.age = age
        self.salary = salary

print(People.name)
"""

# 类的装饰器 ：无
def decorate(cls):
    print('类的装饰器开始运行了')
    return cls
@decorate
class People:
    def __init__(self,name,age,salary):#salary 薪水
        self.name = name
        self.age = age
        self.salary = salary

p1 = People('alex',18,3000)


# 类的装饰器：无参
def Typeassert(**kwargs):
    def decorate(cls):
        print('类的装饰器开始运行了',kwargs)
        return cls
    return decorate

@Typeassert(name = atr,age = int,salary = float)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @property回顾
"""
class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length

    @property
    def area(self):
        return self.width * self.length

r1 = Room('alex',2,3)
print(r1.area)

"""
# 自己做一个@property
"""
class lazyproperty:
    def __init__(self,func):
        self.func = func

    def __get__(self, instance, owner):
        print('这是我自己制定的静态属性，r1.area 实际上是要执行 r1.area()')
        if instance is owner:
            return self
        return self.func(instance)

class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length

    @lazyproperty
    def area(self):
        return self.width * self.length

r1 = Room('alex',2,3)
print(r1.area)

"""
# 实现延迟计算功能
"""
class Lazyproperty:
    def __init__(self,func):
        self.func = func

    def __get__(self, instance, owner):
        print("这是自己定制的静态属性，r1.area 实际上是要执行r1.area()")
        if instance is None:
            return self
        else:
            print("-->")
            value = self.func(instance)
            setattr(instance,self.func.__name__,value)
            return value

class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length

    @Lazyproperty  #area = Lazyproperty(area) 相当于定义了一个类属性，即描述符
    def area(self):
        return self.width * self.length

r1 = Room('ouayng',2,3)
print(r1.area)
print(r1.area)
"""

# 六 再看property
# 一个静态属性property本质就是实现了get,set,delete 三种方法

 # 用法一：

"""
class Foo:
    @property
    def BBB(self):
        print("get 的时候运行")

    @BBB.setter
    def BBB(self,value):
        print("set 的时候运行")

    @BBB.deleter
    def BBB(self):
        print("delter 的时候运行")
        
# 只有在属性BBB定义property之后才能定义BBB.setter,BBB.deleter

f1 = Foo()
f1.BBB
f1.BBB = 'aaa'
del f1.BBB

"""


# 用法二
"""
class Foo:
    def get_BBB(self):
        print("get 的时候运行")

    def set_BBB(self, value):
        print("set 的时候运行")

    def deleter_BBB(self):
        print("delter 的时候运行")
    BBB = property(get_BBB,set_BBB,deleter_BBB)

f1 = Foo()
f1.BBB
f1.BBB = 'aaa'
del f1.BBB

"""

# 怎么用
# ******案例一*******
"""
class Goods:
    def __init__(self):
        self.original_price = 100
        self.discount = 0.8

    def get_price(self):
        new_price = self.original_price * self.discount
        return new_price

    def set_pricce(self,value):
        self.original_price = value

    def deleter_price(self):
        del self.original_price

    price = property(get_price,set_pricce,deleter_price)
obj = Goods()
obj.get_price
obj.price = 80
print(obj.price)
del obj.price
"""
# 从写案例一
"""
class Goods:
    def __init__(self):
        self.original_price = 100
        self.discount = 0.8

    @property
    def price(self):
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self,value):
        self.original_price = value

    @price.deleter
    def deleter(self):
        del self.original_price

obj = Goods()

yj = obj.original_price
print(yj)
obj.price
obj.price = 20
print(obj.price)
obj.deleter
print(obj.deleter)
"""

# *****案例二******
# 实现类型检测功能

# 第一关
# class People:
#     def __init__(self,name):
#         self.name = name
#
#     @property
#     def name(self):
#         return self.name

# 第二关：修订版
"""
class People:
    def __init__(self,name):
        self.name = name# 实例化就触发property


    @property
    def name(self):
        # return self.name 无限递归
        print('get--->')
        return self.DouNiWan

    @name.setter
    def name(self,value):
        print('set-->')
        self.DouNiWan = value

    @name.deleter
    def name(self):
        print('delete-->')
        del self.DouNiWan
p1 = People('alex')
print(p1.name)
# print(p1.name)
# print(p1.name)
print(p1.__dict__)

p1.name = 'egon'
print(p1.__dict__)

del p1.name
print(p1.__dict__)

"""

# 七、 __setitem__,__getitem__,__delitem__
"""
class Foo:
    def __init__(self,name):
        self.name = name

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key] = value

    def __delitem__(self, key):
        print('del obj[key]时，我执行')
        self.__dict__.pop(key)

    def __delattr__(self, item):
        print('del obj.key 时，我执行')
        self.__dict__.pop(item)

f1 = Foo('sb')
f1['age'] = 18
f1["age1"] = 19
del f1.age1
del f1['age']
f1['name'] = 'alex'
print(f1.__dict__)

"""

# 八、__str__,__repr__,__format__
# 改变对象的字符串显示 __str__,__repr__
# 自定制格式化字符串__format__
"""
__author__ = 'linhaifeng'
format_dic = [
    'nat':'{obj.name}-{obj.addr}-{obj.type}'
    'tna':''
]
"""


# 九、 slots
# 1，含义：__slots__是一个类变量，变量值可以是列表，元组，或者可迭代对象，也可以是一个字符串
# 2、引子、使用点来访问属性本质就是在访问类或者对象的__dict__属性字典（类的字典是共享的，每个实例是独立的）
# __slots__会为实例使用一种更加紧凑的内部表示，很多特性都依赖于字典，
# 常见误区：它可以作为一个封装工具来防止用户给实例增加新的属性
# 简而言之，__slots__就是一个字典，只能被付一次值
"""
class Foo:
    __slots__ = 'x'

f1 = Foo()
f1.x = 1
f1.x = 2#报错
f1.x = 3
print(f1.__slots__)

"""
"""
class Bar:
    __slots__ = ['x','y']

n = Bar()
n.x,n.y = 1,2
# n.z = 3
print(n.__slots__)

"""

# 刨根问底
"""
class Foo:
    __slots__ = ['name','age']

f1 = Foo()
f1,name = 'alex'
f1.age = 18
print(f1.__slots__)

f2 = Foo()
f2.name = 'egon'
f2.age = '19'
print(f2.__slots__)

print(Foo.__slots__)
f1,f2都会报错，f1,f2都没有属性字典__dict__了，统一归__slots__管，节省内存。

"""

# 十、__next__和__iter__ 实现迭代器协议

# 简单示范
"""
import time
class Foo:
    def __init__(self,x):
        self.x =x

    def __iter__(self):
        return self

    def __next__(self):
        n = self.x
        self.x += 1
        return self.x

f1 = Foo(3)
for i in f1:
    print(i)
    time.sleep(1)
"""


"""

class Foo:
    def __init__(self,start,stop):
        self.num = start
        self.stop = stop


    def __iter__(self):
        return self

    def __next__(self):
        if self.num >= self.stop:
            raise StopIteration

        n = self.num
        self.num += 1
        return n

f = Foo(1,5)
from collections import Iterable,Iterator
print(isinstance(f,Iterator))

for i in Foo(1,5):
    print(i)
"""

# 练习：简单模拟range,加上步长
"""
class Range:
    def __init__(self,n,stop,step):
        self.n = n
        self.stop = stop
        self.step = step

    def __next__(self):
        if self.n >= self.stop:
            raise StopIteration
        x = self.n
        self.n += self.step
        return x

    def __iter__(self):
        return self

for i in Range(1,7,3):
    print(i)

"""
# 斐波那契数列
"""
class Fib:
    def __iter__(self):
        self._a = 0
        self._b = 1

    def __iter__(self):
        return self

    def __next__(self):
        self._a,self._b = self._b,self._a + self._b
        return self._a

f1 = Fib()

print(f1.__next__())
print(next(f1))
print(next(f1))

for i in f1:
    if i > 100:
        break

    print('%s' %i,end='')

"""

# 十一、__doc__
"""
# 它类的描述信息

class Foo:
    print('我是描述信息')
    pass

print(Foo.__doc__)

# 该属性无法被继承
class Foo:
    print('我是描述信息')
    pass

class Bar(Foo):
    print('我是子类')
    pass
print(Bar.__doc__)#该属性无法继承子类
"""




# 十二、__module__ ,__class__
# __module__表示当前操作的对象在那个模块
# __class__ 表示当前操作的对象的类是什么


# 十三、__del__
# 清楚对象的同时回收系统资源，用到__del__
"""
class Foo:
    def __del__(self):
        print('执行我了')


f1 = Foo()

del f1#这时会执行def __del__(self) 内容
print("------->")

"""
# 十四，__enter__, __exit__

"""
class Open:
    def __init__(self,name):
        self.name = name

    def __enter__(self):
        print('出现with 语句 ，对象的__enter__被触发，有返回值则赋值给as 声明的变量')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with 中代码块执行完毕时执行我啊')


with Open('a.txt') as f:
    print('执行代码块')
    print(f,f.name)
"""
#__exit__() 中的 三个参数分别代表异常类型，异常值，和追溯信息，with 语句中的代码块出现异常
    # ，则with 后代码都无法执行
"""
class Open:
    def __init__(self,name):
        self.name = name

    def __enter__(self):
        print("出现with 语句，对象的__enter__被触发，有返回值则赋值给as 声明的变量")

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with 中的代码执行完毕')
        print(exc_type)
        print(exc_val)
        print(exc_tb)

with Open('a.txt') as f:
    print('=====>执行代码块')
    raise AttributeError('***着火了，救火了****')

print('0'*100)#不会执行

"""

# 十五、__call__
# 对象后加括号，触发执行
# 注：构造方法的执行是由创建对象触发的，即：对象 = 类名（）：
# 而对于__call__方法的执行是由对象后加括号触发的，即 对象（）或者 类（）（）

"""
class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print("类后面加上俩括号会执行__call__")

        print('__call__')

# obj = Foo()
# obj()
Foo()()

"""