# __getitem__ __setitem__ __delitem__    obj['属性']操作触发

class Foo:

    def __getitem__(self, item):

        return self.__dict__[item]

    def __setitem__(self, key, value):

        self.__dict__[key] = value

    def __delitem__(self, key):

        self.__dict__.pop(key)

f = Foo()

f.name = 'zq'

f.age =

print(f.__dict__)

del f.name

print(f.__dict__)

print(f.age)

class Foo:

    def __init__(self,name,age):

        self.name = name

        self.age = age

    def __str__(self):

        return "定制__str__ %s %s" %(self.name,self.age)

    def __repr__(self):

        return "定制的__repr__ 替换__str__"

f = Foo("zhangsan","")

# 改变对象的字符串显示

# __str__

# __repr__ 在解释器中触发 当和str同时存在执行str，当str不存在，执行repr，是str的替代者

# str(f) > f.__str__()> "定制__str__"

print(f)  # 定制__str__ zhangsan 12

# 自定制 format

class Date:

    def __init__(self, year, month, day):

        self.year = year

        self.month = month

        self.day = day

    def __format__(self, format_spec=""):

        return "{0.year}{format_spec}{0.month}{format_spec}{0.day}".format(self, format_spec=format_spec)

d1 = Date('', '', '')

print(format(d1))  #

print(format(d1, ':'))  # 2018:12:12

# __slots__ 是一个类变量 可以是list tunple iter...

# 减少内存使用 取代__dict__的属性 不再有__dict__

# 1.限制创建属性

class Foo:

    __slots__ = ['name', 'age']  # 类似属性字典 定义字典中key {'name':None,'age':None}

f1 = Foo()

f1.name = 'zhangsan'

f1.age = 100

# print(f1.__dict__)  # AttributeError: 'Foo' object has no attribute '__dict__'

print(f1.__slots__)  # ['name', 'age']

print(f1.name, f1.age)

# f1.gender = 'man' # AttributeError: 'Foo' object has no attribute 'gender'

# __doc__ 文档注释 改属性不可被继承

class Foo:

    '''

    我是Foo文档信息

    '''

    pass

class A(Foo):

    '''

    我是A文档信息

    '''

    pass

print(Foo.__doc__)  # 我是Foo文档信息

print(A.__doc__)  # 我是A文档信息

# __module__ 查看由那个module产生
# __class__ 查看由那个类产生

import c

c = c.c()

print(c.name)

print(c.__module__)

print(c.__class__)

# __del__ 析构函数 删除实例才触发该函数

class Foo:

    def __init__(self, name):

        self.name = name

    def __del__(self):

        print("__del__ 实例")

f1 = Foo('zhangsan')

del f1.name  # 先删除实例的属性 再执行下面语句 然后删除实例 执行析构函数

print("--------->")

# call 对象后面加(),触发执行

# call 类()执行 会触发__call__ 函数 Foo()

class Foo:

    def __call__(self, *args, **kwargs):

        print("触发实例 obj()")

f1 = Foo()

f1()

Foo()

# 迭代器协议：对象必须有一个next方法，执行一次返回迭代下一项，直到Stopiteration，

# __iter___ 把一个对象变成可迭代对象

class Foo:

    def __init__(self, age):

        self.age = age

    def __iter__(self):

        return self

    def __next__(self):

        if self.age == 197:

            raise StopIteration("end")

        self.age += 1

        return self.age

f1 = Foo(195)

print(f1.__next__())

print(f1.__next__())

# print(f1.__next__())

for i in f1:  # for循环调用f1中的iter方法变成可迭代对象 再执行next方法 iter(f1)==f1.__iter__()

    print(i)

# 斐波那契数列

class Fib:

    def __init__(self, num):

        self._x = 1

        self._y = 1

        self.num = num

    def __iter__(self):

        return self

    def __next__(self):

        self._x, self._y = self._y, self._x + self._y

        if self._x > self.num:

            raise StopIteration("结束")

        return self._x

    def show_fib(self):

        l = []

        for i in self:

            l.append(i)

        return l

#求1000内的数

f1 = Fib(100000)

print(f1.show_fib())

#描述符Str

class Str:

    def __get__(self, instance, owner):

        print('Str调用')

    def __set__(self, instance, value):

        print('Str设置...')

    def __delete__(self, instance):

        print('Str删除...')

#描述符Int

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): #name被Str类代理,age被Int类代理,

        self.name=name

        self.age=age

#何地？：定义成另外一个类的类属性

#何时？：且看下列演示

p1=People('alex',18)

#描述符Str的使用

p1.name

p1.name='egon'

del p1.name

#描述符Int的使用

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__)

描述符应用之何时?何地?

# 软件开发规范 范例

'''

bin             脚本文件

    start.py    启动文件

conf

    settings.py 配置文件

db              用户数据

    admin

    classes

    teacher

    course

    cource_to_school

    student

lib            公共类库

    commons.py 

log            日志信息

src或core            核心文件         

#导入模块

# BASER_DIR

import sys, os

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(BASE_DIR)