pythoncookbook3 第8章 类与对象

创建缓存实例--单例模式

# import logging
# a = logging.getLogger('foo')
# c = logging.getLogger('foo')
# b = logging.getLogger('bar')
# print(a is c)

# class Spam:
#     def __init__(self,name):
#         self.name = name

import weakref

# _cache = weakref.WeakValueDictionary()
#
# def get_spam(name):
#     if name not in _cache:
#         s = Spam(name)
#         _cache[name] = s
#     else:
#         s = _cache[name]
#     return s
#
#
# a = get_spam('foo')
# b = get_spam('bar')
# c = get_spam('foo')
# print(a is c)


# class Spam:
#     def __init__(self):
#         print('__init__')
#         raise TypeError('不能实例化对象')
#
#     @classmethod
#     def _new(cls,name):
#         print('__new__')
#         self = cls.__new__(cls)
#         self.name = name
#         return self
#
#
# class CacheSpamManage:
#     def __init__(self):
#         self._cache = weakref.WeakValueDictionary()
#
#     def get_spam(self, name):
#         if name not in self._cache:
#             s = Spam._new(name)
#             self._cache[name] = s
#         else:
#             s = self._cache[name]
#         return s
#
#     def clear(self):
#         self._cache.clear()
#
#
# s = CacheSpamManage()
# a = s.get_spam('foo')
# b = s.get_spam('bar')
# c = s.get_spam('foo')
# print(a is c)

创建可管理的属性

class Person:
    def __init__(self,first_name):
        self.first_name = first_name

    @property
    def first_name(self):
        return self._first_name

    @first_name.setter
    def first_name(self,value):
        if not isinstance(value,str):
            raise TypeError('参数必须是字符串')
        else:
            self._first_name = value

p = Person('42')
# p = Person(42)
print(p.__dict__)

#对象实例化的时候会触发 @first_name.setter包装的函数进行自动的类型检测
#如果类中有多个属性需要进行类型检测使用描述符进行检测
#如果类中需要进行类型检测的属性很少可以使用property进行类型检测

# class Person:
#     def __init__(self,first_name):
#         self.set_first_name(first_name)
#
#     def get_first_name(self):
#         return self._first_name
#
#     def set_first_name(self,value):
#         if not isinstance(value,str):
#             raise TypeError('参数必须是字符串')
#         else:
#             self._first_name = value
#
#     def del_first_name(self):
#         raise AttributeError('不能删除属性')
#
#     name = property(get_first_name,set_first_name,del_first_name)
#
# s = Person('42')


创建新的类或实例属性

# class Typed:
#
#     def __init__(self, name, expected_type):
#         self.name = name
#         self.expected_type = expected_type
#
#     def __get__(self, instance, owner):
#         if instance is None:
#             return self
#         return instance.__dict__[self.name]
#
#     def __set__(self, instance, value):
#         if not isinstance(value, self.expected_type):
#             raise TypeError('{}参数必须是{}类型'.format(value, self.expected_type.__name__))
#         instance.__dict__[self.name] = value
#
#     def __delete__(self, instance):
#         del instance.__dict__[self.name]
#
#
# def decorate_person(**kwargs):
#     def wapper(cls):
#         for name, expected_type in kwargs.items():
#             setattr(cls, name, Typed(name, expected_type))
#         return cls
#
#     return wapper
#
#
# @decorate_person(name=str, age=int, gender=str)
# class Person:
#
#     def __init__(self, name, age, gender):
#         self.name = name
#         self.age = age
#         self.gender = gender
#
#
# p = Person(123, 18, '男')
# print(p.name)
# print(p.age)
# print(p.gender)

"""
如果你只是想简单的自定义某个类的单个属性访问的话就
不用去写描述器了。这种情况下使用 property 技术会更加容易。
"""


class Person:
    def __init__(self,name):
        self.name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            raise TypeError('{}参数必须是{}类型'.format(value,str.__name__))
        self._name = value

# p = Person(123)
#TypeError: 123参数必须是str类型
p = Person('123')


使用延迟计算属性

import math

class lazyproperty:

    def __init__(self,func):
        self.func = func

    def __get__(self, instance, owner):
        if instance is None:
            return self
        else:
            value = self.func(instance)
            setattr(instance,self.func.__name__,value)
            return value

#另一个实现方式没有上一种方法高效但是可以阻止给属性赋值


def lazyproperty(func):
    name = '_lazy_' + func.__name__
    @property
    def lazy(args):

        if hasattr(args, name):
            return getattr(args, name)
        else:
            value = func(args)
            setattr(args, name, value)
            return value
    return lazy

class Circle:
    def __init__(self,radius):
        self.radius = radius

    @lazyproperty
    def area(self):
        print('Computing area')
        return math.pi * self.radius ** 2

    @lazyproperty
    def perimeter(self):
        print('Computing perimeter')
        return math.pi * 2 * self.radius

c = Circle(4.0)
"""
c.radius
4.0

c.area
Computing area
50.26548245743669

c.area
50.26548245743669

vars(c)
{'radius': 4.0, 'area': 50.26548245743669}

c.perimeter
Computing perimeter
25.132741228718345

vars(c)
{'radius': 4.0, 'area': 50.26548245743669, 'perimeter': 25.132741228718345}

c.perimeter
25.132741228718345
"""


简化数据结构的初始化

import math


class Structure:
    _fields = []

    def __init__(self, *args, **kwargs):
        if len(args) != len(self._fields):
            raise TypeError(('Expected {} arguments'.format(len(self._fields))))

        for name, value in zip(self._fields, args):
            setattr(self, name, value)

        expected_field = kwargs.keys() - self._fields

        for name in expected_field:
            setattr(self, name, kwargs.pop(name))

        if kwargs:
            raise TypeError('Duplicate values for {}'.format(','.join(kwargs)))


class Stock(Structure):
    _fields = ['name','age','gender']

s = Stock('小于',18,'男',date='2017-1-21')

print(vars(s))
#{'name': '小于', 'age': 18, 'gender': '男', 'date': '2017-1-21'}

#如果有很多需要初始化的数据量比较小的类使用这个方法会很方便

定义接口或者抽象基类

from abc import ABCMeta, abstractmethod

class IStream(metaclass=ABCMeta):

    @abstractmethod
    def read(self, maxbytes = -1):
        pass

    @abstractmethod
    def write(self, data):
        pass


class S(IStream):
    def __init__(self,a):
        self.a = a

    def read(self, maxbytes = -1):
        pass
    def write(self, data):
        pass

s = S('a')
#TypeError: Can't instantiate abstract class S with abstract methods read, write
#继承抽象基类定义的类必须实现抽象类中的abstractmethod装饰的方法

@abstractmethod 还能注解静态方法、类方法和 properties 。你只需保证这个注
解紧靠在函数定义前即可：

class A(metaclass=ABCMeta):
　　@property
　　@abstractmethod
　　def name(self):
　　　　pass

　　@name.setter
　　@abstractmethod
　　def name(self, value):
　　　　pass

实现数据模型的类型约束

class Descriptor:

    def __init__(self, name=None, **opts):
        self.name = name
        for key, value in opts.items():
            setattr(self, key, value)

    def __set__(self, instance, value):
        instance.__dict__[self.name] = value


# class Type(Descriptor):
#     expected_type = type(None)
#
#     def __set__(self, instance, value):
#         if not isinstance(value, self.expected_type):
#             raise TypeError('expected' + str(self.expected_type))
#         super().__set__(instance, value)


# 实现Type装饰器
def Type(expected_type, cls=None):

    if cls is None:
        return lambda cls: Type(expected_type, cls)

    super_set = cls.__set__

    def __set__(self, instance, value):
        if not isinstance(value, expected_type):
            raise TypeError('expected' + str(expected_type))
        super_set(self, instance, value)

    cls.__set__ = __set__
    return cls


# class Unsigned(Descriptor):
#
#     def __set__(self, instance, value):
#         if value < 0:
#             raise ValueError('expected >= 0')
#         super().__set__(instance, value)

# Unsigned装饰器

def Unsigned(cls):
    super_set = cls.__set__

    def __set__(self, instance, value):
        if value < 0:
            raise ValueError('expected >= 0')
        super_set(self, instance, value)

    cls.__set__ = __set__
    return cls


#
# class MaxSizes(Descriptor):
#
#     def __init__(self, name=None, **opts):
#         if 'size' not in opts:
#             raise TypeError('missing in opt')
#         super().__init__(name, **opts)
#
#     def __set__(self, instance, value):
#         if len(value) >= self.size:
#             raise ValueError('size must be <' + str(self.size))
#         super().__set__(instance, value)

# MaxSizes装饰器
def MaxSizes(cls):

    super_init = cls.__init__

    def __init__(self, name=None, **kwargs):
        if 'size' not in kwargs:
            raise TypeError('missing in opt')
        super_init(self, name, **kwargs)

    cls.__init__ = __init__

    super_set = cls.__set__

    def __set__(self, instance, value):
        if len(value) >= self.size:
            raise ValueError('size must be <' + str(self.size))
        super_set(self, instance, value)

    cls.__set__ = __set__
    return cls


@Type(int)
class Integer(Descriptor):
    pass


@Unsigned
class UnsignedInteger(Integer):
    pass


@Type(float)
class Float(Descriptor):
    pass


@Unsigned
class UnsignedFloat(Float):
    pass


@Type(str)
class Str(Descriptor):
    pass


@MaxSizes
class MaxSizesStr(Str):
    pass


# 使用装饰器进行类型检测
# def check_attr(**kwargs):
#     def decorate(cls):
#         for key, value in kwargs.items():
#             if isinstance(value, Descriptor):
#                 value.name = key
#                 setattr(cls, key, value)
#             else:
#                 setattr(cls, key, value(key))
#         return cls
#
#     return decorate


# 使用元类进行类型检测
# class MetaType(type):
#
#     def __new__(cls, cls_name, base, method):
#         for key, value in method.items():
#             if isinstance(value, Descriptor):
#                 value.name = key
#
#         return type.__new__(cls, cls_name, base, method)


# @check_attr(name=MaxSizesStr(size=8),shares=UnsignedInteger,price=UnsignedFloat)
class Share():
    name = MaxSizesStr('name',size=8)
    shares = UnsignedInteger('shares')
    price = UnsignedFloat('price')

    def __init__(self, name, shares, price):
        self.name = name
        self.shares = shares
        self.price = price


s = Share('阿里', 70, 70.0)
print(vars(s))
"""
这种方式定义的类跟之前的效果一样，而且执行速度会更快。设置一个简单的类型
属性的值，装饰器方式要比之前的混入类的方式几乎快 100%。
"""