类            对象      属性             方法

车            BYD       E6(京A.88888)    行驶

狗            小京巴     户籍号:00001     喝水

# Python2中不指定继承object会创建经典类

class A:

    pass

# Python2中定义新式类

class B(object):

    pass

# Python3中无论是否制定继承object,都会创建新式类

class C:

    pass

# 查看类的继承派生关系

help(__builtins__)

class Dog:  # 定义一个狗类

    pass

dog1 = Dog()  # 用类来创建一个对象用dog1绑定

print(id(dog1))  # 打印dog1所在的内存地址

dog2 = Dog()  # 创建第二个对象 用dog2绑定

print(id(dog2))

# 判断两只示例化出来的狗对象是不是同一条狗

print(dog1 is dog2)  # False

class ClassMember:

    """此示例阐述类的组成成员"""

    company_name = "x公司"  # 公有静态字段(公有静态变量,类变量),类和实例都可以访问,类内部和派生类中也可以访问

    __iphone = "135xxxxxxxx"  # 私有静态字段(私有静态变量,私有类变量),仅类内部可以访问

    def __init__(self, name, age):  # 初始化方法

        self.name = name  # 公有普通字段(实例属性),实例可以访问,类内部可以访问,派生类中可以访问

        self.__age = age  # 私有普通字段(私有实例属性),仅类内部可以访问

    def func1(self):  # 实例方法,至少有一个self参数,实例可以访问,类内部可以访问,派生类中可以访问

        pass

    def __func(self):  # 私有方法,仅类内部可以访问

        print(666)

    @classmethod  # 类方法

    def class_func(cls):

        """定义类方法,至少有一个cls参数"""

        print("类方法")

    @staticmethod  # 静态方法

    def static_func():

        """定义静态方法,无默认参数"""

        print("静态方法")

    @property  # 静态属性,将方法伪装成属性来使用

    def prop(self):

        pass

class Human:

    total_count = 0  # 类变量, 用于记录对象的个数

print(Human.total_count)

h1 = Human()

print(h1.total_count)  # 0  # 不会出错

Human.total_count = 1  # 修改类变量

h1.total_count = 2  # 添加了自己的实例属性total_count

h1.__class__.total_count = 3  # 间接修改类变量

class Human:

    total_count = 0  # 类变量,用于记录对象的个数

    def __init__(self, name):

        self.name = name

        self.__class__.total_count += 1  # 人数加1

        print(name, "对象创建")

    def __del__(self):

        self.__class__.total_count -= 1  # 总人数减1

print("当前对象的个数是:", Human.total_count)  #

h1 = Human("张飞")

h2 = Human("赵云")

print("当前对象的个数是:", Human.total_count)  #

del h2  # 或 h2 = None

print("当前对象的个数是:", Human.total_count)  #

class C:

    name = "公有静态字段"

    def func(self):

        print(C.name)

class D(C):

    def show(self):

        print(C.name)

C.name  # 类访问

obj = C()

obj.func()  # 类内部可以访问

obj_son = D()

obj_son.show()  # 派生类中可以访问

class C:

    __name = "私有静态字段"

    def func(self):

        print(C.__name)

class D(C):

    def show(self):

        print(C.__name)

# C.__name  # 不可在外部访问

obj = C()

# obj.__name  # 不可在外部访问

obj._C__name  # 可以通过_类名__属性名来间接访问

obj.func()  # 类内部可以访问

obj_son = D()

obj_son.show()  # 不可在派生类中访问

class C:

    def __init__(self):

        self.foo = "公有普通字段"

    def func(self):

        print(self.foo)  # 类内部访问

class D(C):

    def show(self):

        print(self.foo)  # 派生类中访问

obj = C()

obj.foo  # 通过对象访问

obj.func()  # 类内部访问

obj_son = D()

obj_son.show()  # 派生类中访问

class Dog:

    def __init__(self):

        self.name = None

        self.color = None

dog1 = Dog()

dog1.kinds = "京巴"  # 为dog1绑定的实例添加kinds属性

dog1.color = "白色"  # 添加属性

print(dog1.kinds, dog1.color)  # 访问属性

dog1.color = '黄色' # 修改dog1.color 的绑定关系

print(dog1.color)

class C:

    def __init__(self):

        self.__foo = "私有字段"

    def func(self):

        print(self.foo)  # 类内部访问

class D(C):

    def show(self):

        print(self.foo)  # 派生类中访问

obj = C()

obj.__foo  # 通过对象访问会报错

obj.func()  # 类内部可以访问

obj_son = D()

obj_son.show()  # 派生类中访问会报错

class Women:

    def __init__(self, name):

        self.name = name

        self.__age = 18

    def secret(self):

        print("%s的年龄是%d" % (self.name, self.__age))

xiaomei = Women("小美")

# print(xiaomei.__age)  # 私有属性不能被外界的实例对象直接访问

xiaomei.secret()  # 在对象内部的方法可以直接访问对象的私有属性

print(xiaomei._Women__age)  # 私有属性可以通过_类名__属性名来间接访问

xiaomei.__dict__  # {'name': '小美', '_Women__age': 18}

dir(xiaomei)[0:3]  # ['_Women__age', '__class__', '__delattr__']

class Student:

    pass

stu = Student()

stu.name = 'xiaozhang'  # 创建属性

print(stu.name)

del stu.name  # 删除此属性

print(stu.name)  # 属性错误,因为属性已经不存在了

class C:

    def __init__(self):

        pass

    def add(self):

        print("this is add")

class D(C):

    def show(self):

        print("this is show")

    def func(self):

        self.show()

obj = D()

obj.show()  # 通过对象访问

obj.func()  # 类内部访问

obj.add()  # 派生类中访问

D.func(obj)  # 类名调用

class Women:

    def __init__(self, name):

        self.name = name

        self.__age = 18

    def __secret(self):

        print("%s的年龄是%d" % (self.name, self.__age))

xiaomei = Women("小美")

# xiaomei.__secret()  # 私有方法不能被外界的实例对象直接访问

xiaomei._Women__secret()  # 私有方法可以通过_类名__方法名来间接访问

xiaomei.__dict__  # {'name': '小美', '_Women__age': 18}

dir(xiaomei)[0:3]  # ['_Women__age', '_Women__secret', '__class__']

class A:

    v = 0  # 类变量

    @classmethod

    def get_v(cls):  # 此方法是类方法

        return cls.v

a = A()

a.get_v()  #

A.get_v()  #

a.__dict__  # {}

class Goods:

    __discount = 0.8

    def __init__(self, price):

        self.__price = price

    @property

    def price(self):

        return self.__price * Goods.__discount

    @classmethod

    def change_discount(cls, num):

        cls.__discount = num

# 商场的程序

apple = Goods(10)

banana = Goods(15)

print(apple.price,banana.price)

Goods.change_discount(1)

print(apple.price,banana.price)

class A:

    @staticmethod

    def myadd(a, b):  # 此方法是静态方法

        return a + b

print(A.myadd(100, 200))  #

a = A()

print(a.myadd(300, 400))  #

# 装饰登录功能

class Person:

    @staticmethod

    def login():  # 动词 动作 属于某一个对象

        pass

class Student(Person):

    pass

class Manager(Person):

    pass

class Course:

    pass

class Classes:

    pass

# property属性定义方式: 类中定义值为property对象的类属性

class Foo:

    def get_bar(self):

        return 'Tom'

    # 必须两个参数

    def set_bar(self, value):

        return return 'set value' + value

    def del_bar(self):

        return 'Tom'

    BAR ＝ property(get_bar, set_bar, del_bar, 'description')

obj = Foo()

obj.BAR  # 自动调用第一个参数中定义的方法: get_bar

obj.BAR = "Cat"  # 自动调用第二个参数中定义的方法: set_bar方法,并将"Cat"当作参数传入

del Foo.BAR  # 自动调用第三个参数中定义的方法: del_bar方法

obj.BAE.__doc__  # 自动获取第四个参数中设置的值: description

# property属性定义方式: 在方法上应用装饰器

class Person:

    def __init__(self, name, age):

        self.name = name

        if type(age) is int:

            self.__age = age

        else:

            print('你输入的年龄的类型有误,请输入数字')

    @property

    def age(self):

        return self.__age

    @age.setter

    def age(self, a1):

        '''判断,你修改的年龄必须是数字'''

        if type(a1) is int:

            self.__age = a1

        else:

            print('你输入的年龄的类型有误,请输入数字')

    @age.deleter

    def age(self):

        del self.__age

p1 = Person('帅哥', 20)

print(p1.age)  #

print(p1.__dict__)  # {'name': '帅哥', '_Person__age': 20}

p1.age = 23

print(p1.age)  #

del p1.age

# property属性定义方式: 在方法上应用装饰器

class Money(object):

    def __init__(self):

        self.__money = 0

    # 使用装饰器对money进行装饰,那么会自动添加一个叫money的属性,当调用获取money的值时调用装饰的方法

    @property

    def money(self):

        return self.__money

    # 使用装饰器对money进行装饰,当对money设置值时,调用装饰的方法

    @money.setter

    def money(self, value):

        if isinstance(value, int):

            self.__money = value

        else:

            print("error:不是整型数字")

a = Money()

a.money = 100

print(a.money)

# property属性定义方式: 在方法上应用装饰器

    class Money(object):

        def __init__(self):

            self.__money = 0

        def getMoney(self):

            return self.__money

        def setMoney(self, value):

            if isinstance(value, int):

                self.__money = value

            else:

                print("error:不是整型数字")

        # 定义一个属性,当对这个money设置值时调用setMoney,当获取值时调用getMoney

        money = property(getMoney, setMoney)

    a = Money()

    a.money = 100  # 调用setMoney方法

    print(a.money)  # 调用getMoney方法

# property属性定义方式: 在方法上应用装饰器,实现类型检测功能

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

        if not isinstance(value, str):

            raise TypeError('必须是字符串类型')

        self.DouNiWan = value

    @name.deleter

    def name(self):

        print('delete------>')

        del self.DouNiWan

p1 = People('echo')  # self.name实际是存放到self.DouNiWan里

p1.name = 1

# property属性定义方式: 在方法上应用装饰器,验证@deleter不会删除被property装饰的方法

class A:

    def __init__(self, name):

        self.__name = name

    @property

    def name(self):

        return self.__name

    @name.setter

    def name(self, new_name):

        if type(new_name) is str:

            self.__name = new_name

    @name.deleter

    def name(self):

        def self.__name

a = A("Ccoc")

print(a.name)

a.name = "echo"

del a.name  # 看似是删除了name属性,实际是删除了__name私有属性

# print(a)

# property属性定义方式: 在方法上应用装饰器,让调用看起来更加合理

class Pager:

    def __init__(self, current_page):

        # 用户当前请求的页码(第一页,第二页...)

        self.current_page = current_page

        # 每页默认显示10条数据

        self.per_items = 10 

    @property

    def start(self):

        val = (self.current_page - 1) * self.per_items

        return val

    @property

    def end(self):

        val = self.current_page * self.per_items

        return val

p = Pager(1)

p.start  # 就是起始值,即: m

p.end  # 就是结束值,即: n

# property属性定义方式: 在方法上应用装饰器,取代getater和seatter以及delattr方法

class Goods(object):

    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 price(self):

        del self.original_price

obj = Goods()

obj.price  # 获取商品价格

obj.price = 200  # 修改商品原价

del obj.price  # 删除商品原价

# property属性定义方式: 使用类属性的方式创建property属性改写示例7

class Goods(object):

    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_price(self, value):

        self.original_price = value

    def del_price(self):

        del self.original_price

    PRICE = property(get_price, set_price, del_price, '价格属性描述...')

obj = Goods()

obj.PRICE  # 获取商品价格

obj.PRICE = 200  # 修改商品原价

del obj.PRICE  # 删除商品原价

class Room(object):

    tag = 1

    def __init__(self, wight, length):

        self.wight = wight

        self.length = length

    @property

    def car_area(self):

        return self.length * self.wight + self.tag

    @classmethod

    def tell_info(cls):

        print(cls)

        print("-->", cls.tag)

    @staticmethod

    def run(a, b):

        print("%s %s 正在跑步" % (a, b))

# 静态属性: 将类的函数属性@property装饰后,是对象以数据属性的方式调用

# 只和实例对象绑定-->即可以访问实例属性也可以访问类的属性

p1 = Room(10, 20)

print("类属性", p1.tag)

print("实例对象调用静态属性", p1.car_area)

# 类方法: 将类的函数属性@classmethod装饰后,不用创建实例对象,调用类的函数属性

# 只和类绑定-->可以访问类属性,不能访问实例属性

Room.tell_info()

# 静态方法: 将类的函数属性@staticmethod装饰后,不创建和创建实例对象,都可以调用类的函数属性

# 即不和类绑定也不和实例对象绑定-->不能访问类属性,也不能访问实例属性,是类的工具包

Room.run("co1", "co2")

p2 = Room(20, 20)

p2.run("co3", "co4")

class WSGIRequest(http.HttpRequest):

    def __init__(self, environ):

        script_name = get_script_name(environ)

        path_info = get_path_info(environ)

        if not path_info:

            # Sometimes PATH_INFO exists, but is empty (e.g. accessing

            # the SCRIPT_NAME URL without a trailing slash). We really need to

            # operate as if they'd requested '/'. Not amazingly nice to force

            # the path like this, but should be harmless.

            path_info = '/'

        self.environ = environ

        self.path_info = path_info

        self.path = '%s/%s' % (script_name.rstrip('/'), path_info.lstrip('/'))

        self.META = environ

        self.META['PATH_INFO'] = path_info

        self.META['SCRIPT_NAME'] = script_name

        self.method = environ['REQUEST_METHOD'].upper()

        _, content_params = cgi.parse_header(environ.get('CONTENT_TYPE', ''))

        if 'charset' in content_params:

            try:

                codecs.lookup(content_params['charset'])

            except LookupError:

                pass

            else:

                self.encoding = content_params['charset']

        self._post_parse_error = False

        try:

            content_length = int(environ.get('CONTENT_LENGTH'))

        except (ValueError, TypeError):

            content_length = 0

        self._stream = LimitedStream(self.environ['wsgi.input'], content_length)

        self._read_started = False

        self.resolver_match = None

    def _get_scheme(self):

        return self.environ.get('wsgi.url_scheme')

    def _get_request(self):

        warnings.warn('`request.REQUEST` is deprecated, use `request.GET` or '

                      '`request.POST` instead.', RemovedInDjango19Warning, 2)

        if not hasattr(self, '_request'):

            self._request = datastructures.MergeDict(self.POST, self.GET)

        return self._request

    @cached_property

    def GET(self):

        # The WSGI spec says 'QUERY_STRING' may be absent.

        raw_query_string = get_bytes_from_wsgi(self.environ, 'QUERY_STRING', '')

        return http.QueryDict(raw_query_string, encoding=self._encoding)

    # ############### 看这里看这里  ###############

    def _get_post(self):

        if not hasattr(self, '_post'):

            self._load_post_and_files()

        return self._post

    # ############### 看这里看这里  ###############

    def _set_post(self, post):

        self._post = post

    @cached_property

    def COOKIES(self):

        raw_cookie = get_str_from_wsgi(self.environ, 'HTTP_COOKIE', '')

        return http.parse_cookie(raw_cookie)

    def _get_files(self):

        if not hasattr(self, '_files'):

            self._load_post_and_files()

        return self._files

    # ############### 看这里看这里  ###############

    POST = property(_get_post, _set_post)

    FILES = property(_get_files)

    REQUEST = property(_get_request)

class Foo(object):

     pass

obj = Foo()

isinstance(obj, Foo)  # True

isinstance(1, int)  # True

isinstance("", (int, str, list))  # # True

class A:

    pass

class B(A):

    pass

class C(B):

    pass

class D(B):

    pass

issubclass(B, A)  # True

issubclass(C, B)  # True

issubclass(D, C)  # False

issubclass(C, (int, str))  # False

class A:

    pass

# 默认继承object类

print(issubclass(A,object))  # True

# object类定义了所有类的一些公共方法

print(dir(object)[0:5])

# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__']

# object函数返回一个新的无特征对象

obj = object()

type(obj)  # object

print(obj)  # <object object at 0x0000000003E89EF0>

# 定义一个类A

class A:

    pass

a = A()

a.name = 'li'  # 能设置属性

b = object()

b.name = 'wang'  # 不能设置属性

"""执行结果

    AttributeError                            Traceback (most recent call last)

    <ipython-input-23-fae4aa8bc37b> in <module>

          7

          8 b = object()

    ----> 9 b.name = 'wang' # 不能设置属性

    AttributeError: 'object' object has no attribute 'name'

"""

# 此示例示意用super函数访问父类的覆盖方法

class A:

    def work(self):

        print("A类的work方法被调用")

class B(A):

    def work(self):

        print("B类的work方法被调用")

    def doworks(self):

        # self.work()  # 调用B类的方法

        super(B, self).work()  # 调用超类的方法

        super().work()  # Python推荐的调用超类的调用方法

        # super(__class__, self).work()  # 一样会调用超类的方法

b = B()

b.work()  # B类的work方法被调用

print("-----以下用b调用覆盖版本的方法----")

# A.work(b)  # A类的work方法被调用

super(B, b).work()

b.doworks()

# 此示例示意显式调用基类的初始化方法

class Human:

    def __init__(self, n, a):

        self.name = n

        self.age = a

        print("Human类的 __init__被调用")

    def show_info(self):

        print("姓名:", self.name)

        print("年龄:", self.age)

class Student(Human):

    """学生类"""

    def __init__(self, n, a, s=0):

        super().__init__(n, a)  # 显式调用基类的初始化方法

        self.score = s

        print("Student类的 __init__被调用")

    def show_info(self):

        super().show_info()

        print("成绩:", self.score)

s1 = Student('coco', 20)

s1.show_info()

print(vars())

"""

    {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__',

    '__doc__': None, '__package__': None}

"""

class Runoob:

    a = 1

print(vars(Runoob))  # {'a': 1, '__module__': '__main__', '__doc__': None}

runoob = Runoob()

print(vars(runoob))  # {}

# type(obj)返回对象的类

class A:

    pass

a = A()

type(a)  # __main__.A

# 对类的反射-拿静态属性,类方法,静态方法

class Student:

    ROLE = 'STUDENT'

    @classmethod

    def check_course(cls):

        print('查看课程了')

    @staticmethod

    def login():

        print('登录')

# 反射查看属性

print(Student.ROLE)  # STUDENT

print(getattr(Student, 'ROLE'))  # STUDENT

# 反射调用方法

getattr(Student, 'check_course')()  # 查看课程了

getattr(Student, 'login')()  # 登录

num = input('>>>')  # login

if hasattr(Student, num):

    getattr(Student, num)()  # 登录

# 对实例化对象的反射-拿属性,方法

class Foo:

    f = '类的静态变量'

    def __init__(self, name, age):

        self.name = name

        self.age = age

    def say_hi(self):

        print('hi,%s' % self.name)

obj = Foo('egon', 73)

# 检测是否含有某属性

print(hasattr(obj, 'name'))

print(hasattr(obj, 'say_hi'))

# 获取属性

n = getattr(obj, 'name')

print(n)

func = getattr(obj, 'say_hi')

func()

print(getattr(obj, 'aaaaaaaa', '不存在'))  # 报错

# 设置属性

setattr(obj, 'sb', True)

setattr(obj, 'show_name', lambda self: self.name + 'sb')

print(obj.__dict__)

print(obj.show_name(obj))

# 删除属性

delattr(obj, 'age')

delattr(obj, 'show_name')

delattr(obj, 'show_name111')  # 不存在,则报错

print(obj.__dict__)

# 反射当前模块成员-拿自己的变量名

import sys

def s1():

    print('s1')

def s2():

    print('s2')

this_module = sys.modules[__name__]

hasattr(this_module, 's1')

getattr(this_module, 's2')

# 导入其他模块,利用反射-拿模块中的方法

"""程序目录

        module_test.py

        index.py

"""

# module_test.py中的代码

def test():

    print('from the test')

# index.py中的代码

import module_test as obj

# obj.test()

print(hasattr(obj, 'test'))

getattr(obj, 'test')()

# 反射的应用

class User:

    def login(self):

        print('欢迎来到登录页面')

    def register(self):

        print('欢迎来到注册页面')

    def save(self):

        print('欢迎来到存储页面')

user = User()

while 1:

    choose = input('>>>').strip()

    if hasattr(user, choose):

        func = getattr(user, choose)

        func()

    else:

        print('输入错误...')

# 四个反射函数综合运用

class BlackMedium:

    feature = 'Ugly'

    def __init__(self, name, addr):

        self.name = name

        self.addr = addr

    def sell_house(self):

        print('%s 卖房子' %self.name)

    def rent_house(self):

        print('%s 出租' %self.name)

b1 = BlackMedium('桃园', 'xx区xx路')

# 检测是否含有某属性

print(hasattr(b1, 'name'))

print(hasattr(b1, 'sell_house'))

# 获取属性

n = getattr(b1, 'name')

print(n)

func = getattr(b1, 'rent_house')

func()

# getattr(b1, 'a')  # 报错

print(getattr(b1, 'a', '不存在'))

# 设置属性

setattr(b1, 'sb', True)

setattr(b1, 'show_name', lambda self: '景秀' + self.name)

print(b1.__dict__)

print(b1.show_name(b1))

# 删除属性

delattr(b1, 'addr')

delattr(b1, 'show_name')

# delattr(b1, 'show_name111')  # 不存在则报错

print(b1.__dict__)

def func():

    pass

print(func)  # <function func at 0x10f65c170>

class A:

    def func(self):

        pass

print(A.func)  # <function A.func at 0x10f67c0e0>

obj = A()

print(obj.func)  # <bound method A.func of <__main__.A object at 0x10f692250>>

from types import FunctionType

from types import MethodType

def func():

    pass

class A:

    def func(self):

        pass

obj = A()

print(isinstance(func, FunctionType))  # True

print(isinstance(A.func, FunctionType))  # True

print(isinstance(obj.func, FunctionType))  # False

print(isinstance(obj.func, MethodType))  # True

from types import FunctionType

from types import MethodType

class A:

    def func(self):

        pass

    @classmethod

    def func1(cls):

        pass

    @staticmethod

    def func2():

        pass

obj = A()

# 静态方法其实是函数

print(isinstance(A.func2, FunctionType))  # True

print(isinstance(obj.func2, FunctionType))  # True

print(isinstance(obj.func1, FunctionType))  # False

class Demo:

    """测试类"""

    pass

Demo.__doc__  # '测试类'

class Foo:

    """描述信息"""

    pass

class Bar(Foo):

    pass

print(Bar.__doc__)  # 该属性无法继承给子类

class A:

    a = 1

    def add():

        pass

A.__dict__

"""执行结果

    mappingproxy({'__module__': '__main__',

                  'a': 1,

                  'add': <function __main__.A.add()>,

                  '__dict__': <attribute '__dict__' of 'A' objects>,

                  '__weakref__': <attribute '__weakref__' of 'A' objects>,

                  '__doc__': None})

"""

class Demo:

    """测试类"""

    pass

Demo.__name__  # 'Demo'

class A:

    pass

class B(A):

    pass

B.__base__  # __main__.A

B.__bases__  # (__main__.A,)

A.__base__  # object

A.__bases__  # (object,)

type.__base__  # object

str.__bases__  # (object,)

class Student:

    # 限定此的类创建的对象只能有name和age两个属性

    __slots__ = ['name', 'age']

    def __init__(self, n, a):

        self.name = n

        self.age = a

s1 = Student("小张", 20)

# s1.Age = 21  # 此时是错写了age为Age, 会报错

# print(s1.__dict__) # 出错,因为没有__dict__字典

class Foo2:

    """文档描述"""

    # __slost__取代了类的__dict__使实例化除的属性没有__dict__方法

    __slots__ = ["name", "age"]

class Foo3(Foo2):

    def __del__(self):

        print("回收实例时触发")

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

        print("__call__方法让实例对象可以加()执行")

f3 = Foo2

print("f3", f3.__slots__)

# __doc__记录类的文档描述信息

print(Foo2.__doc__)  # 文档描述

# __doc__无法被子类继承,因为子类一旦定义就有属于自己的__doc__

print(Foo3.__doc__)  # None

print(Foo3.__dict__)

# __module__查看f3来自于哪个模块

print(f3.__module__)  # __main__

# __class__查看f3来自于哪个类

print(f3.__class__)  # <class 'type'>

f3 = Foo3()  # <class 'type'>

f3()  # __call__方法让实例对象可以加()执行

# __del__析构函数,会在回收实例时触发

del f3  # 回收实例时触发

class Dog:

    pass

dog1 = Dog()

print(dog1.__dict__)  # {}

dog1.color = "白色"

print(dog1.__dict__)  # {'color': '白色'}

print(dog1.__class__)  # <class '__main__.Dog'>

# 模块 My_Module 中的代码

class C:

    def __init__(self):

        self.name = "Cat"

# 主模块中的代码

from My_Module import C

obj = C()

# 输出obj对象所在的模块

print(obj.__module__)  # My_Module

# 即输出obj对象所在的类

print(obj.__class__)  # My_Module.C

class Single:

    def __new__(cls, *args, **kwargs):

        # print('在new方法里')

        obj = object.__new__(cls)

        print('在new方法里', obj)

        return obj

    def __init__(self):

        print('在init方法里', self)

# 实例化时,__new__构造方法先调用,接着__init__初始化方法调用

obj = Single()

"""执行结果

    在new方法里 <__main__.Single object at 0x000000000525EDD8>

    在init方法里 <__main__.Single object at 0x000000000525EDD8>

"""

# 此示例示意初始化方法的定义方法和调用过程

class Car:

    """小汽车类"""

    def __init__(self, c, b, m):

        self.color = c  # 颜色

        self.brand = b  # 品牌

        self.model = m  # 型号

        self.wheel = 4

        print("__init__方法被调用")

    def run(self, speed):

        print(self.color, '的', self.brand, self.model, '正在以', speed, '公里/小时的速度行驶')

    def change_color(self, c):

        self.color = c

a4 = Car('红色', '奥迪', 'A4')

a4.run(199)

a4.change_color("白色")

a4.run(280)

x5 = Car('蓝色', '宝马', 'x5')

x5.run(188)

class FileManage:

    """定义一个文件管理员类"""

    def __init__(self, filename='a.txt'):

        self.file = open(filename, 'w')

    def writeline(self, string):

        self.file.write(string)

        self.file.write('\n')

    def __del__(self):

        """析构方法会在对象销毁前自动调用"""

        self.file.close()

        print("文件已关闭")

fm = FileManage()

fm.writeline("hello world")

fm.writeline("这是中文写的第二行")

del fm  # 文件已关闭

# 死循环永远不退出,del不调用一直不关闭文件

while True:

    pass

print("程序结束")

class A:

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

        print('执行call方法了')

    def call(self):

        print('执行call方法了')

class B:

    def __init__(self, cls):

        print('在实例化A之前做一些事情')

        self.a = cls()

        self.a()

        print('在实例化A之后做一些事情')

a = A()

# 对象() 相当于调用__call__方法

a()  # 执行call方法了

a.call()  # 执行call方法了

# 类名()()相当于先实例化得到一个对象,再对对象(),和上面的结果一样,相当于调用__call__方法

A()()  # 执行call方法了

B(A)

"""B(A)执行结果

    在实例化A之前做一些事情

    执行call方法了

    在实例化A之后做一些事情

    Out[11]: <__main__.B at 0x550a9b0>  # 这行是调用B类的基类object的__call__方法执行的结果

"""

obj = {'k':'v'}

# 字典的对象

print(obj)  #  {'k': 'v'}

print(obj['k'])  # v

class B:

    def __getitem__(self, item):

        return getattr(self, item)

    def __setitem__(self, key, value):

        setattr(self, key, value*2)

    def __delitem__(self, key):

        delattr(self, key)

b = B()

# b.k2 = 'v2'

# print(b.k2)

# __setitem__

b['k1'] = 'v1'

# __getitem__

print(b['k1'])  # v1v1

# __delitem__

del b['k1']

# print(b['k1'])  # 会报错

# 字典的对象

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 obj.key时执行

del f1['age']  # del obj[key]时执行

f1['name'] = 'coco'

print(f1.__dict__)  # {'name': 'coco'}

# 字典的对象

class Foo():

    def __getattr__(self, item):

        print("执行了getattr查找%s" % item)

    # 无论是否找到属性都会执行getattribute

    def __getattribute__(self, item):

        print("执行了getattribute查找%s" % item)

        raise AttributeError("抛出异常")

f1 = Foo()

# isinstance(obj, cls)判断对象obj是否是类cls实例化出来的对象

print(isinstance(f1, Foo))  # True

f1.x

"""f1.x执行结果

    执行了 __getattribute__ 查找x

    执行了 __getattr__ 查找x

"""

class Bar():

    # 只针对字典方式操作触发

    def __getitem__(self, item):

        print("%s getitem" % item)

        return self.__dict__[item]

    # 只针对字典方式操作触发

    def __setitem__(self, key, value):

        print("%s:%s setitem" % (key, value))

        self.__dict__[key] = value

    # 只针对字典方式操作触发

    def __delitem__(self, key):

        print("%s delitem" % key)

        self.__dict__.pop(key)

# issubclass(sub, super)判断子类sub是否是由父类super继承来的派生类

print(issubclass(Bar, Foo))  # False

f2 = Bar()

f2["name"] = "coco"  # name:coco setitem

print(f2["name"])

"""print(f2["name"])执行结果

    name getitem

    coco

"""

f2["age"] = ""  # age:18 setitem

print(f2.__dict__)  # {'name': 'coco', 'age': '18'}

del f2["age"]  # age delitem

print(f2.__dict__)  # {'name': 'coco'}

# 列表的对象

class Foo(object):

    def __getitem__(self, index):

        if isinstance(index, slice):

            print("Get slice---------> start: %s, stop: %s, step: %s." \

                    % (str(index.start), str(index.stop), str(index.step)))

    def __setitem__(self, index, value):

        if isinstance(index, slice):

            print("Set slice---------> start: %s, stop: %s, step: %s." \

                    % (str(index.start), str(index.stop), str(index.step)))

            print("\tThe value is:", value)

    def __delitem__(self, index):

        if isinstance(index, slice):

            print("Delete slice------> start: %s, stop: %s, step: %s." \

                    % (str(index.start), str(index.stop), str(index.step)))

if __name__ == "__main__":

    obj = Foo()

    obj[-1:10]  # Get slice---------> start: -1, stop: 10, step: None.

    obj[-1:10:1] = [2, 3, 4, 5]

    """obj[-1:10:1] = [2, 3, 4, 5]执行结果

        Set slice---------> start: -1, stop: 10, step: 1.

            The value is: [2, 3, 4, 5]

    """

    del obj[-1:10:2]  # Delete slice------> start: -1, stop: 10, step: 2.

# Python2中的分片(切片)操作 __getslice__ __setslice__ __delslice__

class Foo(object):

    def __getslice__(self, i, j):

        print('__getslice__', i, j)

    def __setslice__(self, i, j, sequence):

        print('__setslice__', i, j)

    def __delslice__(self, i, j):

        print('__delslice__', i, j)

obj = Foo()

obj[-1:1]  # 自动触发执行 __getslice__

obj[0:1] = [11, 22, 33, 44]  # 自动触发执行 __setslice__

del obj[0:2]  # 自动触发执行 __delslice__

class A:

    def __init__(self, name, age):

        self.name = name

        self.age = age

    def __eq__(self, other):

        if self.name == other.name and self.age == other.age:

            return True

a = A('gogo', 83)

aa = A('gogo', 83)

aa2 = A('gogo', 83)

aa3 = A('gogo', 83)

aa4 = A('gogo', 83)

print(a, aa)

# <__main__.A object at 0x0000000004F94FD0> <__main__.A object at 0x0000000004F94748>

# ==这个语法 是完全和__eq__ 相同

print(aa3 == aa == aa4)  # True

class Foo1():

    # 运用在print打印时触发

    def __str__(self):

        return "自定义打印信息"

    # 运用在解释器时触发

    def __repr__(self):

        return "自定义打印信息2"

obj = Foo1()

print(obj)  # 自定义打印信息

# __str__和 __repr__共存,print先找str没有再找repr

print(obj)  # 自定义打印信息

class B:

     def __str__(self):

         return 'str : class B'

     def __repr__(self):

         return 'repr : class B'

b=B()

print('%s' % b)

print('%r' % b)

# __format__ 格式化方法示例

format_dic = {

    "ymd": "{0.year}{0.mon}{0.day}",

    "m-d-y": "{0.mon}-{0.day}-{0.year}",

}

class Date:

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

        self.year = year

        self.mon = mon

        self.day = day

    def __format__(self, format_spec):

        print("-->", format_spec)

        if not format_spec or format_spec not in format_dic:

            format_spec = "ymd"

        fm = format_dic[format_spec]

        return fm.format(self)

d1 = Date(2019, 4, 13)

print("{0.year}{0.mon}{0.day}".format(d1))  #

print(format(d1, "ymd"))  #

print(format(d1, "m-d-y"))  # 4-13-2019

class Foo4():

    def __get__(self, instance, owner):

        print("get")

    def __set__(self, instance, value):

        print("set")

    def __delete__(self, instance):

        print("delete")

class Foo5(Foo4):

    name = Foo4()

f5 = Foo5()

f5.name  # get

f5.name = 1 # set

del f5.name  # delete

class Typed:

    def __init__(self, key, expected_type):

        self.key = key

        self.expected_type = expected_type

    def __get__(self, instance, owner):

        print('get方法')

        # print('instance参数【%s】' %instance)

        # print('owner参数【%s】' %owner)

        return instance.__dict__[self.key]

    def __set__(self, instance, value):

        print('set方法')

        # print('instance参数【%s】' % instance)

        # print('value参数【%s】' % value)

        # print('====>',self)

        if not isinstance(value,self.expected_type):

            # print('你传入的类型不是字符串,错误')

            # return

            raise TypeError('%s 传入的类型不是%s' %(self.key, self.expected_type))

        instance.__dict__[self.key] = value

    def __delete__(self, instance):

        print('delete方法')

        # print('instance参数【%s】' % instance)

        instance.__dict__.pop(self.key)

class People:

    name = Typed('name', str)  # t1.__set__()  self.__set__()

    age = Typed('age', int)  # t1.__set__()  self.__set__()

    def __init__(self, name, age, salary):

        self.name = name

        self.age = age

        self.salary = salary

p1 = People("coco", 13, 13.3)

print(p1.__dict__)  # {'name': 'coco', 'age': 13, 'salary': 13.3}

#描述符Str

class Str:

    def __get__(self, instance, owner):

        print('Str调用')

    def __set__(self, instance, value):

        print('Str设置...')

    def __delete__(self, instance):

        print('Str删除...')

class People:

    name = Str()

    def __init__(self, name, age):  # name被Str类代理,age被Int类代理

        self.name = name

        self.age = age

# 在一个类中定义描述符它就是一个类属性,存在于类的属性字典中,而不是实例的属性字典

# 描述符被定义成了一个类属性,直接通过类名也可以调用类属性name,本质就是在调用描述符Str,触发了__get__()

People.name  # Str调用

# 赋值并没有触发__set__()

People.name = 'coco'

# del也没有触发__delete__()

del People.name

'''原因: 描述符在使用时被定义成另外一个类的类属性,因而类属性比二次加工的描述符伪装而来的类属性有更高的优先级

    People.name  # 调用类属性name,找不到就去找描述符伪装的类属性name,触发了__get__()

    People.name = 'coco'  # 直接赋值了一个类属性,它拥有更高的优先级,相当于覆盖了描述符不会触发描述符的__set__()

    del People.name  # 直接删除一个类属性,它拥有更高的优先级,相当于覆盖了描述符不会触发描述符的__delete__()

'''

#描述符Str

class Str:

    def __get__(self, instance, owner):

        print('Str调用')

    def __set__(self, instance, value):

        print('Str设置...')

    def __delete__(self, instance):

        print('Str删除...')

class People:

    name=Str()

    def __init__(self, name, age):  # name被Str类代理,age被Int类代理

        self.name = name

        self.age = age

p1 = People('angels', 18)  # Str设置...

# 如果描述符是一个数据描述符(即有__get__又有__set__)

# 那么p1.name的调用与赋值都是触发描述符的操作,与p1本身无关了相当于覆盖了实例的属性

p1.name ='coco'  # # Str设置...

p1.name  # Str调用

# 实例的属性字典中没有name,因为name是一个数据描述符,优先级高于实例属性

# 查看/赋值/删除都是跟描述符有关,与实例无关

print(p1.__dict__)  # {'age': 18}

del p1.name  # Str删除...

class Foo:

    def __set__(self, instance, value):

        print('set')

    def __get__(self, instance, owner):

        print('get')

class Room:

    name = Foo()

    def __init__(self, name, width, length):

        self.name = name

        self.width = width

        self.length = length

# name是一个数据描述符,因为name = Foo()而Foo实现了get和set方法,因而比实例属性有更高的优先级

# 对实例的属性操作,触发的都是描述符的方法

r1 = Room('厕所', 1, 1)  # set

r1.name  # get

r1.name = '厨房'  # set

class Foo:

    def __get__(self, instance, owner):

        print('get')

class Room:

    name = Foo()

    def __init__(self, name, width, length):

        self.name = name

        self.width = width

        self.length = length

# name是一个非数据描述符,因为name=Foo()而Foo没有实现set方法,因而比实例属性有更低的优先级

# 对实例的属性操作,触发的都是实例自己的方法

r1 = Room('厕所', 1, 1)

r1.name

r1.name = '厨房'

class Foo:

    def func(self):

        print('func被调用')

    def __getattr__(self, item):

        print('找不到就调用getattr', item)

f1=Foo()

f1.xxx  # 找不到就调用getattr xxx

class Lazyproperty:

    def __init__(self, func):

        print('==========>', func)

        self.func = func

    def __get__(self, instance, owner):

        print('get')

        # print(instance)

        # print(owner)

        if instance is None:

            return self

        res = self.func(instance)

        setattr(instance, self.func.__name__, res)

        return res

class Room:

    def __init__(self, name, width, length):

        self.name = name

        self.width = width

        self.length = length

    # @property #area = property(area)

    @Lazyproperty  #area = Lazypropery(area)

    def area(self):

        return self.width * self.length

    @property  #test = property(test)

    def area1(self):

        return  self.width * self.length

r1 = Room("coco", 10, 10)  # ======> <function Room.area at 0x0000000006AC4C80>

print(r1.area1)  #

# 先从自己的属性字典找,没有再去类的中找,然后触发了area的__get__方法

print(r1.area)  # 先打印get, 再打印100

# 先从自己的属性字典找,找到了,是上次计算的结果,这样就不用每执行一次都去计算

print(r1.area)  # 先打印100, 再打印get

print(Room.area)  # <__main__.Lazyproperty object at 0x0000000005AE52B0>

print(Room.area1)  # <property object at 0x00000000052F1458>

class ClassMethod:

    def __init__(self, func):

        self.func = func

    # 类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身

    def __get__(self, instance, owner):

        def feedback():

            print('在这里可以加功能啊...')

            return self.func(owner)

        return feedback

class People:

    name = 'coco'

    @ClassMethod  # say_hi = ClassMethod(say_hi)

    def say_hi(cls):

        print('你好啊,world %s' % cls.name)

People.say_hi()

p1 = People()

p1.say_hi()

class ClassMethod:

    def __init__(self, func):

        self.func = func

    # 类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身

    def __get__(self, instance, owner):

        def feedback(*args, **kwargs):

            print('在这里可以加功能啊...')

            return self.func(owner, *args, **kwargs)

        return feedback

class People:

    name = 'linhaifeng'

    @ClassMethod # say_hi = ClassMethod(say_hi)

    def say_hi(cls, msg):

        print('你好啊,world %s %s' %(cls.name, msg))

People.say_hi('每天都是充满希望的一天')

p1 = People()

p1.say_hi('每天都是充满希望的一天')

class StaticMethod:

    def __init__(self, func):

        self.func = func

    # 类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身

    def __get__(self, instance, owner):

        def feedback(*args, **kwargs):

            print('在这里可以加功能啊...')

            return self.func(*args, **kwargs)

        return feedback

class People:

    @StaticMethod  # say_hi = StaticMethod(say_hi)

    def say_hi(x, y, z):

        print('------>', x, y, z)

People.say_hi(1, 2, 3)

p1 = People()

p1.say_hi(4, 5, 6)

class Open():

    def __init__(self, name):

        self.name = name

    def __enter__(self):

        print("执行了enter")

        return self

    def __exit__(self, exc_type, exc_val, exc_tb):

        print("执行了exit")

        print(exc_type)  # 异常类型

        print(exc_val)  # 异常值

        print(exc_tb)  # 异常追踪信息

with Open("a.txt") as f:

    print(f)  # <__main__.Foo6 object at 0x000000000358E0F0>

    print(f.name)  # a.txt

print("结束")  # 结束

class A:

    def __enter__(self):

        print('before')

    def __exit__(self, exc_type, exc_val, exc_tb):

        print('after')

with A() as a:

    print('')

class A:

    def __init__(self):

        print('init')

    def __enter__(self):

        print('before')

    def __exit__(self, exc_type, exc_val, exc_tb):

        print('after')

with A() as a:

    print('')

class Myfile:

    def __init__(self, path, mode='r', encoding='utf-8'):

        self.path = path

        self.mode = mode

        self.encoding = encoding

    def __enter__(self):

        self.f = open(self.path, mode=self.mode, encoding=self.encoding)

        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):

        self.f.close()

with Myfile('file',mode='w') as f:

    f.write('wahaha')

import  pickle

class MyPickledump:

    def __init__(self, path):

        self.path = path

    def __enter__(self):

        self.f = open(self.path, mode='ab')

        return self

    def dump(self, content):

        pickle.dump(content, self.f)

    def __exit__(self, exc_type, exc_val, exc_tb):

        self.f.close()

class Mypickleload:

    def __init__(self, path):

        self.path = path

    def __enter__(self):

        self.f = open(self.path, mode='rb')

        return self

    def __exit__(self, exc_type, exc_val, exc_tb):

        self.f.close()

    def load(self):

         return pickle.load(self.f)

    def loaditer(self):

        while True:

            try:

                yield self.load()

            except EOFError:

                break

# with MyPickledump('file') as f:

#      f.dump({1, 2, 3, 4})

with Mypickleload('file') as f:

    for item in f.loaditer():

        print(item)

import  pickle

class MyPickledump:

    def __init__(self, path):

        self.path = path

    def __enter__(self):

        self.f = open(self.path, mode='ab')

        return self

    def dump(self, content):

        pickle.dump(content, self.f)

    def __exit__(self, exc_type, exc_val, exc_tb):

        self.f.close()

class Mypickleload:

    def __init__(self, path):

        self.path = path

    def __enter__(self):

        self.f = open(self.path, mode='rb')

        return self

    def __exit__(self, exc_type, exc_val, exc_tb):

        self.f.close()

    def __iter__(self):

        while True:

            try:

                yield  pickle.load(self.f)

            except EOFError:

                break

# with MyPickledump('file') as f:

#      f.dump({1, 2, 3, 4})

with Mypickleload('file') as f:

    for item in f:

        print(item)

class A:

    def __init__(self):

        self.a = 1

        self.b = 2

    def __hash__(self):

        return hash(str(self.a) + str(self.b))

a = A()

print(hash(a))  # -7282248652925619321

hash("")  # -7282248652925619321

class B:

    def __len__(self):

        print("len函数触发__len__方法")

        return 0

b = B()

# len一个对象就会触发 __len__方法

len(b)

"""len(b)执行结果

    len函数触发__len__方法

    0

"""

class A:

    def __init__(self):

        self.a = 1

        self.b = 2

    def __len__(self):

        print(self.__dict__)  # {'a': 1, 'b': 2}

        return len(self.__dict__)  #

a = A()

print(len(a))  #

class Foo(object):

    def __init__(self, sq):

        self.sq = sq

    def __iter__(self):

        return iter(self.sq)

obj = Foo([11, 22, 33, 44])

for i in obj:

    print(i, end=" ")  # 11 22 33 44

# 模拟range函数加上步长

class Range:

    def __init__(self, start, stop, step):

        self.start = start

        self.stop = stop

        self.step = step

    def __next__(self):

        if self.start >= self.stop:

            raise StopIteration

        x = self.start

        self.start += self.step

        return x

    def __iter__(self):

        return self

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

    print(i)

# 斐波拉契数列

class Fib:

    def __init__(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=' ')

class Foo:

    def __init__(self, name):

        self.name = name

    def __getattr__(self, item):

        print('__getattr__执行')

        # return self.__dict__[item]

    def __getattribute__(self, item):

        print('无论如何都会执行')

        raise AttributeError('发生了异常')

f1 = Foo("Coco")

f1.x

f1.xx

class Single:

    __ISINCTANCE = None

    def __new__(cls, *args, **kwargs):

        if not cls.__ISINCTANCE:

            cls.__ISINCTANCE = object.__new__(cls)

        return cls.__ISINCTANCE

    def __init__(self, name, age):

        # self.name = name

        # self.age = age

        print(self)

s1 = Single('coco', 23)  # <__main__.Single object at 0x10f67fad0>

s2 = Single('gogo', 40)  # <__main__.Single object at 0x10f67fad0>

class MusicPlayer(object):

    # 记录第一个被创建对象的引用

    instance = None

    # 记录是否执行过初始化动作

    init_flag = False

    def __new__(cls, *args, **kwargs):

        # 1.判断类属性是否是空对象

        if cls.instance is None:

            # 2.调用父类方法,为第一个对象分配空间

            cls.instance = super().__new__(cls)

        # 3.返回类属性保存的对象引用

        return cls.instance

    def __init__(self):

        # 1.判断是否执行过初始化动作

        if MusicPlayer.init_flag:

            return

        # 2.没有执行过,再执行初始化动作

        print("初始化播放器")

        # 3.修改类属性标记

        MusicPlayer.init_flag = True  

player1 = MusicPlayer()  # 初始化播放器

print(player1)  # <__main__.MusicPlayer object at 0x0000000006AA28D0>

player2 = MusicPlayer()

print(player2)  # <__main__.MusicPlayer object at 0x0000000006AA28D0>

def dogs(name, gender, type):

    # 狗的属性

    def init(name, gender, type):

        dog = {

            "name": name,

            "gender": gender,

            "type": type,

            "run": run

        }

        return dog

    # 狗的方法

    def run(dog):

        print("一条狗%s正在跑" % dog["name"])

    return init(name, gender, type)

d1 = dogs("wangcai", "公", "中华田园犬")

d2 = dogs("xiaoqiang", "公", "哈士奇")

print("面向对象设计", d1)

d1["run"](d1)

print(d2["name"])

# 面向对象编程-->用面向对象独有的class语法实现面向对象设计

class Dog:

    """定义一个狗类"""

    def __init__(self,name, gender, type):

        self.name = name

        self.gender = gender

        self.type = type

    def run(self):

        print("一条狗%s正在跑" % self.name)

dog1 = Dog("wangcai", "公", "中华田园犬")

dog2 = Dog("xiaoqiang", "公", "哈士奇")

print("面向对象编程", dog1.__dict__)  # __dict__ 查看属性字典

print(dog1.__dict__["type"])  # 中华田园犬

# 创建出的实例只有数据属性,函数属性实际是调的类的函数属性

dog1.run()

print(dog2.name)

# 查看类的名字

print(Dog.__name__)  # Dog

# 查看文档说明

print(Dog.__doc__)  # 定义一个狗类

# 查看第一个父类

print(Dog.__base__)  # <class 'object'>

# 查看所有父类,构成元组

print(Dog.__bases__)  # (<class 'object'>,)

# 查看类的属性,返回一个字典

print(Dog.__dict__)

# 查看类定义所在的模块

print(Dog.__module__)  # __main__

# 查看实例对应的类

print(Dog.__class__)  # <class 'type'>

class GameRole:

    """英雄人物类"""

    def __init__(self, name, ad, hp):

        self.name = name

        self.ad = ad

        self.hp = hp

    def attack(self,p):

        p.hp = p.hp - self.ad

        print('%s 攻击 %s,%s 掉了%s血,还剩%s血' %(self.name, p.name, p.name, self.ad, p.hp))

    def armament_weapon(self, wea):

        self.wea = wea

class Weapon:

    """武器属性类"""

    def __init__(self, name, ad):

        self.name = name

        self.ad = ad

    def fight(self, p1, p2):

        p2.hp = p2.hp - self.ad

        print('%s 用%s打了%s\t%s 掉了%s血,还剩%s血'\

              % (p1.name, self.name, p2.name, p2.name, self.ad, p2.hp))

p1 = GameRole('coco', 20, 500)

p2 = GameRole('cat', 50, 200)

axe = Weapon('三板斧', 60)

broadsword = Weapon('屠龙宝刀', 100)

p1.armament_weapon(axe)  # 给coco装备了三板斧这个对象.

p1.wea.fight(p1, p2)  # coco 用三板斧打了cat    cat 掉了60血,还剩140血

# 组合实现与类的关联

class School:

    def __init__(self, name, addr):

        self.name = name

        self.addr = addr

class Course:

    def __init__(self, name, price, school):

        self.name = name

        self.price = price

        self.school = school

s1 = School("coco", "成都")

s2 = School("coco", "广州")

msg = """

1 coco 成都

2 coco 广州

"""

while True:

    print(msg)

    menu = {

        "": s1,

        "": s2

    }

    choice = input("请选择学校>>>:")

    school_obj = menu[choice]

    name = input("课程名: ")

    price = input("课程费用: ")

    new_course = Course(name, price, school_obj)

    print("课程 %s 属于 %s 学校" % (new_course.name, new_course.school.name))

class A:

    def __init__(self):

        self.__p1 = 100  # 创建私有属性

    def __m1(self):

        print("A类的私有方法被调用!")

    def test(self):

        print(self.__p1)  # 可以访问

        self.__m1()  # 可以访问

a = A()

# print(a.__p1)  # 出错,不可以访问

# a.__m1()  # 出错, 在类外部不能调用类的私有方法

a.test()  # 用方法来操作私有属性和私有方法

a.__dict__  # {'_A__p1': 100}

a._A__p1  #

a._A__m1()  # A类的私有方法被调用!

class Parent:

    def __func(self):

        print('in Parent func')

    def __init__(self):

        self.__func()

class Son(Parent):

    def __func(self):

        print('in Son func')

son1 = Son()  # in Parent func

class Human:  # 人

    def say(self, what):  # 说话的行为

        print("说: ", what)

    def walk(self, distance):  # 走路的行为

        print("走了", distance, "公里")

h1 = Human()

h1.say("今天天气不错!")

h1.walk(5)

class Student(Human):

    # def say(self, what):  # 说话的行为

    #     print("说: ", what)

    # def walk(self, distance):  # 走路的行为

    #     print("走了", distance, "公里")

    def study(self, subject):

        print("正在学习", subject)

s1 = Student()

s1.say("今天晚饭吃什么？")

s1.walk(3)

s1.study("python")

class Car:

    def run(self, speed):

        print("汽车以", speed, "km/h的速度行驶")

class Plane:

    def fly(self, height):

        print("飞机以海拔", height, "米的高度飞行")

class PlaneCar(Car, Plane):

    """飞行汽车类, 同时继承 自Car和 Plane"""

    pass

p1 = PlaneCar()

p1.fly(10000)  # 飞机以海拔 10000 米的高度飞行

p1.run(299)  # 汽车以 299 km/h的速度行驶

# 多继承缺陷示例

# 小张写了一个类A

class A:

    def m(self):

        print("A.m()被调用")

# 小李写了一个类B:

class B:

    def m(self):

        print("B.m() 被调用")

# 小王感觉小张和小李写的两个类自己可以用

class AB(A, B):

    pass

ab = AB()

ab.m()  # 调用A类中的m方法

class E:

    pass

class F:

    pass

class A(E):

    pass

class B(E):

    pass

class C(F):

    pass

class D(F):

    pass

class AB(A, B):

    pass

class CD(C, D):

    pass

class ABCD(AB, CD):

    pass

print(ABCD.__mro__)

"""Python3运行结果

    (__main__.ABCD,

     __main__.AB,

     __main__.A,

     __main__.B,

     __main__.E,

     __main__.CD,

     __main__.C,

     __main__.D,

     __main__.F,

     object)

"""

print("******多继承使用类名.__init__ 发生的状态******")

class Parent(object):

    def __init__(self, name):

        print('parent的init开始被调用')

        self.name = name

        print('parent的init结束被调用')

class Son1(Parent):

    def __init__(self, name, age):

        print('Son1的init开始被调用')

        self.age = age

        Parent.__init__(self, name)

        print('Son1的init结束被调用')

class Son2(Parent):

    def __init__(self, name, gender):

        print('Son2的init开始被调用')

        self.gender = gender

        Parent.__init__(self, name)

        print('Son2的init结束被调用')

class Grandson(Son1, Son2):

    def __init__(self, name, age, gender):

        print('Grandson的init开始被调用')

        Son1.__init__(self, name, age)  # 单独调用父类的初始化方法

        Son2.__init__(self, name, gender)

        print('Grandson的init结束被调用')

gs = Grandson('grandson', 12, '男')

print('姓名: ', gs.name)

print('年龄: ', gs.age)

print('性别: ', gs.gender)

print("******多继承使用类名.__init__ 发生的状态******\n\n")

print("******单继承使用super().__init__ 发生的状态******")

class Parent(object):

    def __init__(self, name):

        print('parent的init开始被调用')

        self.name = name

        print('parent的init结束被调用')

class Son1(Parent):

    def __init__(self, name, age):

        print('Son1的init开始被调用')

        self.age = age

        super().__init__(name)  # 单继承不能提供全部参数

        print('Son1的init结束被调用')

class Grandson(Son1):

    def __init__(self, name, age, gender):

        print('Grandson的init开始被调用')

        super().__init__(name, age)  # 单继承不能提供全部参数

        print('Grandson的init结束被调用')

gs = Grandson('grandson', 12, '男')

print('姓名: ', gs.name)

print('年龄: ', gs.age)

#print('性别: ', gs.gender)

print("******单继承使用super().__init__ 发生的状态******\n\n")

print("******多继承使用super().__init__ 发生的状态******")

class Parent(object):

    def __init__(self, name, *args, **kwargs):  # 为避免多继承报错,使用不定长参数,接受参数

        print('parent的init开始被调用')

        self.name = name

        print('parent的init结束被调用')

class Son1(Parent):

    # 为避免多继承报错,使用不定长参数,接受参数

    def __init__(self, name, age, *args, **kwargs):

        print('Son1的init开始被调用')

        self.age = age

        super().__init__(name, *args, **kwargs)  # 为避免多继承报错,使用不定长参数,接受参数

        print('Son1的init结束被调用')

class Son2(Parent):

    # 为避免多继承报错,使用不定长参数,接受参数

    def __init__(self, name, gender, *args, **kwargs):

        print('Son2的init开始被调用')

        self.gender = gender

        super().__init__(name, *args, **kwargs)  # 为避免多继承报错,使用不定长参数,接受参数

        print('Son2的init结束被调用')

class Grandson(Son1, Son2):

    def __init__(self, name, age, gender):

        print('Grandson的init开始被调用')

        # 多继承时,相对于使用类名.__init__方法,要把每个父类全部写一遍

        # 而super只用一句话,执行了全部父类的方法,这也是为何多继承需要全部传参的一个原因

        # super(Grandson, self).__init__(name, age, gender)

        super().__init__(name, age, gender)

        print('Grandson的init结束被调用')

print(Grandson.__mro__)

gs = Grandson('grandson', 12, '男')

print('姓名: ', gs.name)

print('年龄: ', gs.age)

print('性别: ', gs.gender)

print("******多继承使用super().__init__ 发生的状态******\n\n")

class Shape:

    def draw(self):

        pass

class Point(Shape):

    def draw(self):

        print("正在画一个点")

class Circle(Point):

    def draw(self):

        print("正在画一个圆")

def my_draw(s):

    s.draw()  # 根据实例的类型在运行时动态决定调用的方法,这样的行为为动态

s1 = Circle()

s2 = Point()

my_draw(s1)  # 正在画一个圆

my_draw(s2)  # 正在画一个点

class MiniOS(object):

    """MiniOS 操作系统类 """

    def __init__(self, name):

        self.name = name

        self.apps = []  # 安装的应用程序名称列表

    def __str__(self):

        return "%s 安装的软件列表为 %s" % (self.name, str(self.apps))

    def install_app(self, app):

        # 判断是否已经安装了软件

        if app.name in self.apps:

            print("已经安装了 %s,无需再次安装" % app.name)

        else:

            app.install()

            self.apps.append(app.name)

class App(object):

    def __init__(self, name, version, desc):

        self.name = name

        self.version = version

        self.desc = desc

    def __str__(self):

        return "%s 的当前版本是 %s - %s" % (self.name, self.version, self.desc)

    def install(self):

        print("将 %s [%s] 的执行程序复制到程序目录..." % (self.name, self.version))

class PyCharm(App):

    pass

class Chrome(App):

    def install(self):

        print("正在解压缩安装程序...")

        super().install()

linux = MiniOS("Linux")

print(linux)

pycharm = PyCharm("PyCharm", "1.0", "python 开发的 IDE 环境")

chrome = Chrome("Chrome", "2.0", "谷歌浏览器")

linux.install_app(pycharm)

linux.install_app(chrome)

linux.install_app(chrome)

print(linux)

"""执行结果

    Linux 安装的软件列表为 []

    将 PyCharm [1.0] 的执行程序复制到程序目录...

    正在解压缩安装程序...

    将 Chrome [2.0] 的执行程序复制到程序目录...

    已经安装了 Chrome,无需再次安装

    Linux 安装的软件列表为 ['PyCharm', 'Chrome']

"""

# Srt,List,Tuple这些类都有相同的方法,那么这些类互称鸭子

class Str:

    def index(self):

        pass

class List:

    def index(self):

        pass

class Tuple:

    def index(self):

        pass

s = Str()

s.index()

l = List()

l.index()

t = Tuple()

t.index()

# Str类,List类和Tuple类完全没有耦合性,但是在某种意义上他们却统一了一个标准

# 对相同的功能设定了相同的名字,这样方便开发,这个方法就可以互成为鸭子类型

# 用鸭子类型实现多态

class Duck:

    def quack(self):

        print "Duck imitate duck"

class Bird:

    def quack(self):

        print "bird imitate duck"

class Chicken:

    def quack(self):

        print "chicken imitate duck"

def in_the_forest(duck):

    duck.quack()

duck = Duck()

bird = Bird()

chicken = Chicken()

for x in [duck, bird, chicken]:

    in_the_forest(x)

# 包装 = 继承 + 派生

class List(list):

    # 定义一个方法取列表中间值

    def show_midlle(self):

        min_index = int(len(self) / 2)

        return self[min_index]

    # 重写列表的append方法,限制只允许添加字符串

    def append(self, p_object):

        if type(p_object) is str:

            super().append(p_object)

        else:

            print("类型错误,只允许添加字符串")

l1 = List("helloworld")

print(l1, type(l1))  # ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'] <class '__main__.List'>

print("列表%s的中间值是%s" %(l1, l1.show_midlle()))

# 列表['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']的中间值是w

l1.append("coco")

l1.append(123)  # 类型错误,只允许添加字符串

print(l1)  # ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd', 'coco']

# 给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, str):

            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('saf')

print(l)

# l.clear() #异常

l.tag = True

l.clear()

# 授权-->是组合的运用

import time

class Open:

    def __init__(self, filename, mode="r", encoding="utf-8"):

        self.filename = filename

        self.file = open(filename, mode, encoding=encoding)

        self.mode = mode

        self.encoding = encoding

    def write(self, line):

        t = time.strftime("%Y-%m-%d %X")

        self.file.write("%s %s" % (t, line))

    def __getattr__(self, item):

        return getattr(self.file, item, "没有找到%s" % item)

f1 = Open("a.txt", "r+")

print(f1.file)  # <_io.TextIOWrapper name='a.txt' mode='r+' encoding='utf-8'>

print(f1.reads)  # 没有找到reads

print(f1.read)  # <built-in method read of _io.TextIOWrapper object at 0x00000000056F51F8>

f1.write("hello world\n")

f1.seek(0)  # 移动文件指针到文件开头

print("读文件%s内容是%s" % (f1.filename, f1.read()))  # 读文件a.txt内容是2020-07-31 10:54:27 hello world

# 加上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 write(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.BufferedReader name='%s'>" %self.filename

        else:

            res = ("<_io.TextIOWrapper name='%s' mode='%s' encoding='%s'>" %

                (self.filename, self.mode, self.encoding))

        return res

f1 = FileHandle('b.txt','wb')

# f1.write('你好啊')  # 自定制的write,不用在进行encode转成二进制去写了

f1.write('你好啊'.encode('utf-8'))

print(f1)  # <_io.BufferedReader name='b.txt'>

f1.close()

class List:

    def __init__(self, seq):

        self.seq = seq

    def append(self, p_object):

        '派生自己的append加上类型检查,覆盖原有的append'

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

print(l)  # [1, 2, 3]

l.append(4)

print(l)  # [1, 2, 3, 4]

# l.append('33') # 会报错,必须为int类型

print(l.mid)  #

# 基于授权,获得insert方法

l.insert(0, -123)

print(l)  # [-123, 1, 2, 3, 4]

class List:

    def __init__(self, seq, permission=False):

        self.seq = seq

        self.permission = permission

    def clear(self):

        if not self.permission:

            raise PermissionError('not allow the operation')

        self.seq.clear()

    def __getattr__(self, item):

        return getattr(self.seq, item)

    def __str__(self):

        return str(self.seq)

l = List([1, 2, 3])

# l.clear() # 此时没有权限,抛出异常

l.permission = True

print(l)  # [1, 2, 3]

l.clear()  # l.clear()

print(l)  # []

#基于授权,获得insert方法

l.insert(0, -123)

print(l)  # [-123]

class A:

    def work(self):

        print("A类的work方法被调用")

class B(A):

    def work(self):

        print("B类的work方法被调用")

b = B()

b.work()  # 子类已经覆盖了父类的方法

class B:

    def __str__(self):

     return 'str : class B'

    def __repr__(self):

     return 'repr : class B'

b=B()

print('%s'%b)  # str : class B

print('%r'%b)  # repr : class B

# 此示例示意 abs(obj) 函数的重写方法 obj.__abs__() 方法的使用

class MyInteger:

    def __init__(self, value):

        self.data = value

    def __repr__(self):

        return 'MyInteger(%d)' % self.data

    def __abs__(self):

        if self.data < 0:

            return MyInteger(-self.data)  # 创建一个新的以对象并返回

        return MyInteger(self.data)

    def __len__(self):

        '''len(x)函数规定只能返回整数值,因此此方法不能返回字符串等其它类型的值'''

        return 100

I1 = MyInteger(-10)

print(I1)   # <-- 此处等同于print(str(I1))

I2 = abs(I1)  # I2 = MyInteger(10)

print(I2)  # MyInteger(10)

print(len(I1))  # I1.__len__()

# 此示例示意 bool 真值测试函数的重写

class MyList:

    '''定义一个容器类,用于存储任意类型的数据其内部的存储方式用list实现'''

    def __init__(self, iterable):

        self.data = [x for x in iterable]

    def __repr__(self):

        return 'MyList(%s)' % self.data

    def __len__(self):

        print("__len__ 方法被调用!")

        return len(self.data)  # 返回列表的长度

    def __bool__(self):

        print('__bool__方法被调用')

        '''此方法用于bool(obj) 函数取值,优先取此函数的返回值,此方法用于定义bool(obj)的取值规则'''

        # 规则,所有元素的和为0,则返回False否则返回True

        return sum(self.data) != 0

myl = MyList([1, -2, 5, -4])

print(myl)  # MyList([1, -2, 5, -4])

print('bool(myl) =', bool(myl))

if myl:

    print('myl 的布尔值为True')

else:

    print('myl 的布尔值为False')

format_dict = {

    'nat':'{obj.name}-{obj.addr}-{obj.type}',  # 学校名-学校地址-学校类型

    'tna':'{obj.type}:{obj.name}:{obj.addr}',  # 学校类型:学校名:学校地址

    'tan':'{obj.type}/{obj.addr}/{obj.name}',  # 学校类型/学校地址/学校名

}

class School:

    def __init__(self, name, addr, type):

        self.name = name

        self.addr = addr

        self.type = type

    def __repr__(self):

        return 'School(%s,%s)' %(self.name, self.addr)

    def __str__(self):

        return '(%s,%s)' %(self.name, self.addr)

    def __format__(self, format_spec):

        # if format_spec

        if not format_spec or format_spec not in format_dict:

            format_spec = 'nat'

        fmt = format_dict[format_spec]

        return fmt.format(obj=self)

s1 = School('oldboy1', '北京', '私立')

print('from repr: ',repr(s1))

print('from str: ',str(s1))

print(s1)

'''

    str函数或者print函数--->obj.__str__();repr或者交互式解释器--->obj.__repr__()

    如果__str__没有被定义,那么就会使用__repr__来代替输出,这俩方法的返回值必须是字符串,否则抛出异常

'''

print(format(s1, 'nat'))

print(format(s1, 'tna'))

print(format(s1, 'tan'))

print(format(s1, 'asfdasdffd'))

class Foo():

    x = 1

    def __init__(self):

        self.y = 1

    def __getattr__(self, item):

        print("你要找的%s属性不存在" % item)

    # 重写内置删除方法,限制删除条件

    def __delattr__(self, item):

        print("执行了删除%s属性的操作" % item)

        self.__dict__.pop(item)

    # 重写内置设置方法,限制设置条件

    def __setattr__(self, key, value):

        print("你执行了设置%s属性值为%s的操作" %(key, value))

        self.__dict__[key] = value

f1 = Foo()

f1.x = 10

f1.name = "coco"  # 设置属性时会触发__setattr__

print(f1.z)  # 属性不存在时,会自动触发__getattr__

del f1.y  # 删除属性时,会触发__delattr__

print(f1.__dict__)

# 此程序示意运算符重载

class MyNumber:

    def __init__(self, v):

        self.data = v

    def __repr__(self):

        return "MyNumber(%d)" % self.data

    def __add__(self, other):

        print("__add__方法被调用")

        obj = MyNumber(self.data + other.data)

        return obj

    def __sub__(self, other):

        return MyNumber(self.data - other.data)

n1 = MyNumber(100)

n2 = MyNumber(200)

# n3 = n1.__add__(n2)

n3 = n1 + n2  # 等同于 n1.__add__(n2)

print(n3)

n4 = n2 - n1

print('n4 =', n4)  # MyNumber(100)

# 自定义对象的加法运算符重载规则

class MyType:

    """实现对象中*号求和"""

    def __init__(self, s):

        self.s = s

    def __add__(self, other):

        return self.s.count('*') + other.s.count('*')

obj1 = MyType('ccasdd***2343*****')

obj2 = MyType('vvsvvndk***3423**6517***')

print(obj1 + obj2)

print(obj1.__add__(obj2))

# 此示例示意返向算术运算符的重载

class MyList:

    def __init__(self, iterable):

        self.data = [x for x in iterable]

    def __repr__(self):

        # %r 等同与用repr函数取值--> repr(self.data)

        return 'MyList(%r)' % self.data

    def __mul__(self, rhs):

        return MyList(self.data * rhs)

    def __rmul__(self, lhs):

        print("__rmul__被调用, lhs=", lhs)

        return MyList(self.data * lhs)  # lhs (left hand side)

L1 = MyList([1, 2, 3])

L2 = MyList(range(4, 7))

L4 = L1 * 2  # 实现乘法运算调用的是自定义的__mul__方法

print('L4 =', L4)  # MyList([1,2,3,1,2,3])

L5 = 2 * L1  # 此时调用的是自定义的反向乘法运算符重载__rmul__方法

print(L5)

# 此示例示意复合赋值算术运算符的重载

class MyList:

    def __init__(self, iterable):

        self.data = [x for x in iterable]

    def __repr__(self):

        return 'MyList(%r)' % self.data

    def __add__(self, rhs):

        print("__add__方法被调用")

        return MyList(self.data + rhs.data)

    def __iadd__(self, rhs):

        print("__iadd__方法被调用")

        self.data.extend(rhs.data)

        return self

L1 = MyList([1, 2, 3])

L2 = MyList(range(4, 7))

print("id(L1) =", id(L1))

# +=优先调用__iadd__方法,没有再调用__add__方法

L1 += L2  # 相当于 L1 = L1 + L2

print('L1 =', L1)

print("id(L1) =", id(L1))

# 此示例示意一元运算符的重载

class MyList:

    def __init__(self, iterable):

        self.data = [x for x in iterable]

    def __repr__(self):

        return 'MyList(%r)' % self.data

    def __neg__(self):

        print("__neg__方法被调用!")

        L = (-x for x in self.data)

        return MyList(L)

L1 = MyList([1, -2, 3, -4, 5])

print("L1 =", L1)

L2 = -L1

print("L2 =", L2)

# 此示例示意 in / not in 运算符的重载

class MyList:

    def __init__(self, iterable):

        self.data = [x for x in iterable]

    def __repr__(self):

        return 'MyList(%r)' % self.data

    def __contains__(self, e):  # e 代表测试元素

        print("__contains__被调用")

        for x in self.data:

            if e == x:  # 如果相同,则说明e在列表中

                return True

        return False

L1 = MyList([1, -2, 3, -4, 5])

if 2 in L1:  # 需要重载 __contains__ 方法

    print("2在L1中")

else:

    print("2不在L1中")

# 此示例示意索引 index 和切片 slice 运算符的重载

class MyList:

    def __init__(self, iterable):

        self.data = [x for x in iterable]

    def __repr__(self):

        return "MyList(%r)" % self.data

    def __getitem__(self, i):

        print("__getitem__被调用", i)

        if type(i) is slice:

            print("正在进行切片操作")

        elif type(i) is int:

            print("正在进行索引操作")

        return self.data[i]

    def __setitem__(self, i, v):

        print("__setitem__被调用", i, v)

        self.data[i] = v

    def __delitem__(self, i):

        print("__delitem__被调用", i)

        del self.data[i]

L1 = MyList([1, -2, 3, -4, 5])

# 切片操作调用的是__getitem__方法,L1[0:2]等同于L1[slice(0, 2, None)]

print(L1[0:2])  # [1, -2]

print(L1[2])  #

L1[1] = 2  # MyList([1, 2, 3, -4, 5])

del L1[:2]

print(L1)  # MyList([3, -4, 5])

def decorate(cls):

    print('类的装饰器开始运行啦------>')

    return cls

@decorate  # 无参:People=decorate(People)

class People:

    def __init__(self, name, age, salary):

        self.name = name

        self.age = age

        self.salary = salary

p1=People('egon', 18, 3.3)

def typeassert(**kwargs):

    def decorate(cls):

        print('类的装饰器运行:', kwargs)

        return cls

    return decorate

# 有参:1.运行typeassert(...)返回结果是decorate,此时参数都传给kwargs

# 有参:2.People=decorate(People)

@typeassert(name=str, age=int, salary=float)

class People:

    def __init__(self, name, age, salary):

        self.name = name

        self.age = age

        self.salary = salary

p1=People('egon', 18, 3.3)  # 类的装饰器运行:{'name': <class 'str'>, 'age': <class 'int'>, 'salar': <class 'float'>}

class Test(object):

    def __init__(self, func):

        print("---初始化---")

        print("func name is %s" % func.__name__)

        self.__func = func

    def __call__(self):

        print("---装饰器中的功能---")

        self.__func()

"""说明:

    1.用Test来装作装饰器对test函数进行装饰的时,先创建Test的实例对象,再把test这个函数名当做参数传递到__init__方法中

        即在__init__方法中的属性__func指向了test指向的函数,而test则指向了用Test创建出来的实例对象

    2.当在使用test()进行调用时,就相当于让这个对象(),因此会调用这个对象的__call__方法

    3.为了能够在__call__方法中调用原来test指向的函数体,在__init__方法中需要一个实例属性来保存这个函数体的引用

        所以才有了self.__func = func这句代码,从而在调用__call__方法中能够调用到test之前的函数体

 """

@Test

def test():

    print("----test---")

test()

"""执行结果

    ---初始化---

    func name is test

    ---装饰器中的功能---

    ----test---

"""

class Typed:

    def __init__(self, key, expected_type):

        self.key = key

        self.expected_type = expected_type

    def __get__(self, instance, owner):

        print('get方法')

        # print('instance参数【%s】' % instance)

        # print('owner参数【%s】' % owner)

        return instance.__dict__[self.key]

    def __set__(self, instance, value):

        print('set方法')

        # print('instance参数【%s】' % instance)

        # print('value参数【%s】' % value)

        # print('====>', self)

        if not isinstance(value, self.expected_type):

            # print('你传入的类型不是字符串,错误')

            # return

            raise TypeError('%s 传入的类型不是%s' % (self.key, self.expected_type))

        instance.__dict__[self.key] = value

    def __delete__(self, instance):

        print('delete方法')

        # print('instance参数【%s】' % instance)

        instance.__dict__.pop(self.key)

def deco(**kwargs):

    def wrapper(obj):

        for key,val in kwargs.items():

            print("-->", key, val)

            setattr(obj, key, Typed(key, val))

        return obj

    return wrapper

@deco(name=str, age=int)

class People:

    def __init__(self, name, age, salary):

        self.name = name

        self.age = age

        self.salary = salary

p1 = People('coco', 13, 13.3)

print(p1.__dict__)

"""执行结果

    --> name <class 'str'>

    --> age <class 'int'>

    set方法

    set方法

    {'name': 'coco', 'age': 13, 'salary': 13.3}

"""

class Test:

    def __init__(self, func):

        # 要使__call__方法中调用原来get_str指向的函数体,需要在__init__方法中就需要一个实例属性来保存这个函数体的引用

        self.__func = func

    def __call__(self):

        print("Test类装饰的内容")

        return self.__func()

# 用Test来装作装饰器对get_str函数进行装饰的时候,首先会创建Test的实例对象

# 然后把get_str这个函数名当做参数传递到__init__方法中的属性__func指向了get_str指向的函数

@Test  # 等同于get_str = Test(get_str)

def get_str():

    print("this is get_str function")

    return "ok"

# get_str指向了用Test创建出来的实例对象,当在使用get_str()进行调用时

# 就相当于让这个对象(),因此会调用这个对象的__call__方法

ret = get_str()

print(ret)

"""执行结果

    Test类装饰的内容

    this is get_str function

    ok

"""

from abc import ABCMeta

from abc import abstractmethod

class Payment(metaclass=ABCMeta):  # 抽象类规范和约束,metaclass指定的是一个元类

    @abstractmethod

    def pay(self):  # 抽象方法

        pass

class Alipay(Payment):

    def __init__(self,money):

        self.money = money

    def pay(self):

        print('使用支付宝支付了%s' %self.money)

class Jdpay(Payment):

    def __init__(self, money):

        self.money = money

    def pay(self):

        print('使用京东支付了%s' % self.money)

class Wechatpay(Payment):

    def __init__(self,money):

        self.money = money

    def pay(self):

        print('使用微信支付了%s' % self.money)

def pay(obj):

    obj.pay()

# 子类中没有实现pay方法时,子类实例化对象时会报错

w1 = Wechatpay(200)

a1 = Alipay(200)

j1 = Jdpay(100)

# 统一化接口设计,也叫归一化设计: 不管是哪一个类的对象,都调用同一个函数去完成相似的功能

pay(a1)  # 使用支付宝支付了200

pay(j1)  # 使用京东支付了100

# 用元类的思想来实现约束时子类必须实现pay方法

class Payment:

    """此类什么都不做,就是制定一个标准,谁继承我就必须定义我里面的方法"""

    def pay(self, money):

        raise Exception("你没有实现pay方法")

class QQpay(Payment):

    def pay(self, money):

        print('使用qq支付%s元' % money)

class Alipay(Payment):

    def pay(self, money):

        print('使用阿里支付%s元' % money)

class Wechatpay(Payment):

    def fuqian(self, money):

        print('使用微信支付%s元' % money)

def pay(obj,money):

    obj.pay(money)

a = Alipay()

b = QQpay()

c = Wechatpay()

pay(a, 100)  # 使用阿里支付100元

pay(b, 200)  # 使用qq支付200元

pay(c, 300)  # Exception: 你没有实现pay方法

class A:

    pass

a = A()

a.__class__  # __main__.A

a.__class__.__class__  # type

a.__class__.__class__.__class__  # type

Test = type("Test", (), {"num1": 100, "num2": 200})

Test.__dict__

obj = Test()

obj.num1

obj.num2

"""执行结果

    mappingproxy({'num1': 100,

                  'num2': 200,

                  '__module__': '__main__',

                  '__dict__': <attribute '__dict__' of 'Test' objects>,

                  '__weakref__': <attribute '__weakref__' of 'Test' objects>,

                  '__doc__': None})

    100

    200

"""

class A(object):

    num = 100

def print_b(self):

    print("实例方法调用", self.num)

@staticmethod

def print_static():

    print("----静态方法调用-----")

@classmethod

def print_class(cls):

    print("类方法调用", cls.num)

B = type("B", (A,), {"print_b": print_b, "print_static": print_static, "print_class": print_class})

b = B()

b.print_b()  # 实例方法调用 100

b.print_static()  # ----静态方法调用----

b.print_class()  # 类方法调用 100

class MyType(type):

    def __init__(self, a, b, c):

        print("a:", a)  # a: Foo

        print("b:", b)  # b: ()

        print("c:", c)

        # c: {'__module__': '__main__', '__qualname__': 'Foo', '__init__': <function Foo.__init__ at 0x102ead560>}

        print("元类初始化执行完成")  # 元类初始化执行完成

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

        print(args, kwargs)  # ('coco', 18) {}

        obj = object.__new__(self)  # object.__new__(Foo)-->f1

        self.__init__(obj, *args, **kwargs)  # Foo.__init__(f1, *args, **kwargs)

        return obj

class Foo(object, metaclass=MyType):  # Foo=MyType(Foo, "Foo", (), {})-->__init__

    def __init__(self, name, age):

        self.name = name

        self.age = age

f1 = Foo("coco", 18)

print(f1)  # <__main__.Foo object at 0x00000000055BF6A0>

print(f1.__dict__)  # {'name': 'coco', 'age': 18}

class UpperAttrMetaClass(type):

    # __new__ 是在__init__之前被调用的特殊方法,很少用到__new__,除非希望能够控制对象的创建

    # __new__是用来创建对象并返回的方法,而__init__只是用来将传入的参数初始化给对象

    def __new__(cls, class_name, class_parents, class_attr):

        # 遍历属性字典,把不是__开头的属性名字变为大写

        new_attr = {}

        for name, value in class_attr.items():

            if not name.startswith("__"):

                new_attr[name.upper()] = value

        # 方法1: 通过'type'来做类对象的创建

        return type(class_name, class_parents, new_attr)

        # 方法2: 复用type.__new__方法,这就是基本的OOP编程,没什么魔法

        # return type.__new__(cls, class_name, class_parents, new_attr)

# python3的用法

class Foo(object, metaclass=UpperAttrMetaClass):

    bar = 'bip'

# python2的用法

# class Foo(object):

#     __metaclass__ = UpperAttrMetaClass

#     bar = 'bip'

print(hasattr(Foo, 'bar'))  # False

print(hasattr(Foo, 'BAR'))  # True

f = Foo()

print(f.BAR)  # bip

class ModelMetaclass(type):

    def __new__(cls, name, bases, attrs):

        mappings = dict()

        # 判断是否需要保存

        for k, v in attrs.items():

            # 判断是否是指定的StringField或者IntegerField的实例对象

            if isinstance(v, tuple):

                print('Found mapping: %s ==> %s' % (k, v))

                mappings[k] = v

        # 删除这些已经在字典中存储的属性

        for k in mappings.keys():

            attrs.pop(k)

        # 将之前的uid/name/email/password以及对应的对象引用,类名字

        attrs['__mappings__'] = mappings  # 保存属性和列的映射关系

        attrs['__table__'] = name  # 假设表名和类名一致

        return type.__new__(cls, name, bases, attrs)

class Model(object, metaclass=ModelMetaclass):

    def __init__(self, **kwargs):

        for name, value in kwargs.items():

            setattr(self, name, value)

    def save(self):

        fields = []

        args = []

        for k, v in self.__mappings__.items():

            fields.append(v[0])

            args.append(getattr(self, k, None))

        args_temp = list()

        for temp in args:

            # 判断入如果是数字类型

            if isinstance(temp, int):

                args_temp.append(str(temp))

            elif isinstance(temp, str):

                args_temp.append("""'%s'""" % temp)

        sql = ('insert into %s (%s) values (%s)' %

            (self.__table__, ','.join(fields), ','.join(args_temp)))

        print('SQL: %s' % sql)

class User(Model):

    uid = ('uid', "int unsigned")

    name = ('username', "varchar(30)")

    email = ('email', "varchar(30)")

    password = ('password', "varchar(30)")

# 实例化对象首先会调用元类ModelMetaclass的__new__构造方法,再调用父类Model的__init__初始化方法

u = User(uid=12345, name='Michael', email='test@orm.org', password='my-pwd')

# print(u.__dict__)

u.save()

#! /usr/bin/env python

# coding: utf-8

import random

import time

class Message(object):

    def __init__(self, msgarr=[], toacc=''):

        self.msgbody = msgarr  # 此处为MsgDict对象实例的列表或者空列表

        self.toacc = toacc  # toacc为字符串(单发)或者列表(批量发)

        self.msgrandom = random.randint(1, 1000000000)

        self.msgrequest = {

            'To_Account': toacc,  # 消息接收方账号

            'MsgRandom': self.msgrandom,  # 消息随机数,由随机函数产生

            'MsgBody': [t.msg for t in msgarr]

        }

    def del_option(self, option):

        if option in (set(self.msgrequest) - set(['To_Account', 'MsgRandom', 'MsgBody'])):

            self.__dict__.pop(option)

            self.msgrequest.pop(option)

    def append_msg(self, msg):

        self.msgbody.append(msg)

        self.msgrequest['MsgBody'].append(msg.msg)

    def insert_msg(self, index, msg):

        self.msgbody.insert(index, msg)

        self.msgrequest['MsgBody'].insert(msg.msg)

    def del_msg(self, index):

        if index in range(len(self.msgbody)):

            del self.msgbody[index]

            del sel.msgrequest['MsgBody'][index]

    def set_from(self, fromacc):

        #  指定消息的发送方,默认为服务器发送

        self.fromacc = fromacc

        self.msgrequest['From_Account'] = fromacc

    def set_to(self, toacc):

        #  指定消息的接收方,可以为String(单发),可以为List(批量发送)

        self.toacc = toacc

        self.msgrequest['To_Account'] = toacc

    def refresh_random(self):

        self.msgrandom = random.randint(1, 1000000000)

        self.msgrequest['MsgRandom'] = self.msgrandom,  # 消息随机数,由随机函数产生

    def set_sync(self, sync):

        # 同步选项: 1, 把消息同步到From_Account在线终端和漫游上

        #           2, 消息不同步至From_Account

        #           若不填写,默认情况下会将消息同步

        #           仅在单发单聊消息中可调用

        self.sync = sync

        self.msgrequest['SyncOtherMachine'] = sync

    def set_timestamp(self):

        # 设置消息时间戳,unix时间, 仅在单发单聊消息中可以调用

        self.timestamp = int(time.time())

        self.msgrequest['MsgTimeStamp'] = self.timestamp

    def set_offlinepush(self, pushflag=0, desc='', ext='', sound=''):

        # 仅适用于APNa推送,不适用于安卓厂商推送

        self.msgrequest['OfflinePushInfo'] = {

            'PushFlag': pushflag,

            'Desc': desc,

            'Ext': ext,

            'Sound': sound

        }

class MsgDict(object):

    def __init__(self, msgtype='', msgcontent={}):

        self.msgtype = msgtype

        self.msgcontent = msgcontent

    @property

    def msg(self):

        return {

            'MsgType': self.msgtype,

            'MsgContent': self.msgcontent

        }

    def set_content(self, content):

        self.msgcontent = content

class TextMsg(MsgDict):

    def __init__(self, text='', msgtype='TIMTextElem'):

        self.text = text

        content = {'Text': text}

        super(TextMsg, self).__init__(msgtype=msgtype, msgcontent=content)

    def set_text(self, text):

        self.text = text

        self.msgcontent['Text'] = text

class LocationMsg(MsgDict):

    def __init__(self, desc='', latitude=0, longitude=0, msgtype='TIMLocationElem'):

        self.desc = desc

        self.latitude = latitude

        self.longitude = longitude

        content = {

            'Desc': desc,  # 地理位置描述信息, String

            'Latitude': latitude,  # 纬度, Number

            'Longitude': longitude  # 经度, Number

        }

        super(LocationMsg, self).__init__(msgtype=msgtype, msgcontent=content)

    def set_desc(self, desc):

        self.desc = desc

        self.msgcontent['Desc'] = desc

    def set_location(self, latitude, longitude):

        self.latitude = latitude

        self.longitude = longitude

        self.msgcontent['Latitude'] = latitude

        self.msgcontent['Longitude'] = longitude

    def set_latitude(self, latitude):

        self.latitude = latitude

        self.msgcontent['Latitude'] = latitude

    def set_longitude(self, longitude):

        self.longitude = longitude

        self.msgcontent['Longitude'] = longitude

class FaceMsg(MsgDict):

    def __init__(self, index=1, data='', msgtype='TIMFaceElem'):

        self.index = index

        self.data = data

        content = {

            'Index': index,  # 表情索引,用户自定义, Number

            'Data': data  # 额外数据, String

        }

        super(TextMsg, self).__init__(msgtype=msgtype, msgcontent=content)

    def set_index(self, index):

        self.index = index

        self.msgcontent['Index'] = index

    def set_data(self, data):

        self.data = data

        self.msgcontent['Data'] = data

class CustomMsg(MsgDict):

    def __init__(self, data='', desc='', ext='', sound='', msgtype='TIMCustomElem'):

        self.data = data

        self.desc = desc

        self.ext = ext

        self.sound = sound

        content = {

            'Data': data,  # 自定义消息数据,不作为APNS的payload中字段下发,故从payload中无法获取Data字段, String

            'Desc': desc,  # 自定义消息描述,当接收方为iphone后台在线时,做ios离线Push时文本展示

            'Ext': ext,  # 扩展字段,当接收方为ios系统且应用处在后台时,此字段作为APNS请求包Payloads中的ext键值下发,Ext的协议格式由业务方确定,APNS只做透传

            'Sound': sound  # 自定义APNS推送铃声

        }

        super(CustomMsg, self).__init__(msgtype=msgtype, msgcontent=content)

    def set_data(self, data):

        self.data = data

        self.msgcontent['Data'] = data

    def set_desc(self, desc):

        self.desc = desc

        self.msgcontent['Desc'] = desc

    def set_ext(self, ext):

        self.ext = ext

        self.msgcontent['Ext'] = ext

    def set_sound(self, sound):

        self.sound = sound

        self.msgcontent['Sound'] = sound

class SoundMsg(MsgDict):

    def __init__(self, uuid='', size=0, second=0, msgtype='TIMSoundElem'):

        self.uuid = uuid

        self.size = size

        self.second = second

        content = {

            'UUID': uuid,  # 语音序列号,后台用于索引语音的键值,String

            'Size': size,  # 语音数据大小, Number

            'Second': second  # 语音时长,单位秒 Number

        }

        super(SoundMsg, self).__init__(msgtype=msgtype, msgcontent=content)

    def set_uuid(self, uuid):

        self.uuid = uuid

        self.msgcontent['UUID'] = uuid

    def set_size(self, size):

        self.size = size

        self.msgcontent['Size'] = size

    def set_second(self, second):

        self.second = second

        self.msgcontent['Second'] = second

class ImageMsg(MsgDict):

    def __init__(self, uuid='', imgformat=0, imginfo=[], msgtype='TIMImageElem'):

        self.uuid = uuid

        self.imgformat = imgformat

        self.imginfo = imginfo

        content = {

            'UUID': uuid,  # 图片序列号,后台用于索引语音的键值,String

            'ImageFormat': imgformat,  # 图片格式, BMP=1, JPG=2, GIF=3, 其他=0, Number

            'ImageInfoArray': [t.info for t in imginfo]  # 原图,缩略图或者大图下载信息, Array

        }

        super(ImageMsg, self).__init__(msgtype=msgtype, msgcontent=content)

    def set_uuid(self, uuid):

        self.uuid = uuid

        self.msgcontent['UUID'] = uuid

    def set_format(self, imgformat):

        self.imgformat = imgformat

        self.msgcontent['ImageFormat'] = imgformat

    def append_info(self, info):

        # info 为ImageInfo对象实例

        self.imginfo.append(info)

        self.msgcontnet['ImageInfoArray'].append(info.info)

    def insert_info(self, index, info):

        self.imginfo.insert(index, info)

        self.msgcontent['ImageInfoArray'].insert(index, info.info)

    def del_info(self, index):

        del self.imginfo[index]

        del self.msgcontent['ImageInfoArray'][index]

class FileMsg(MsgDict):

    def __init__(self, uuid='', size=0, name='', msgtype='TIMFileElem'):

        self.uuid = uuid

        self.size = size

        self.name = name

        content = {

            'UUID': uuid,  # 文件序列号,后台用于索引语音的键值,String

            'FileSize': size,  # 文件数据大小, Number

            'FileName': name  # 文件名称/路径, String

        }

        super(FileMsg, self).__init__(msgtype=msgtype, msgcontent=content)

    def set_uuid(self, uuid):

        self.uuid = uuid

        self.msgcontent['UUID'] = UUID

    def set_size(self, size):

        self.size = size

        self.msgcontent['FileSize'] = size

    def set_name(self, name):

        self.name = name

        self.msgcontent['FileName'] = name

class ImageInfo(object):

    def __init__(self, itype=1, size=0, width=0, height=0, url=''):

        # 图片类型, 1-原图, 2-大图, 3-缩略图, 0-其他

        self.itype = itype

        # 图片数据大小,Number

        self.size = size

        # 图片宽度,Number

        self.width = width

        # 图片高度, Number

        self.height = height

        # 图片下载地址,String

        self.url = url

    @property

    def info(self):

        return {

            'Type': self.itype,

            'Size': self.size,

            'Width': self.width,

            'Height': self.height,

            'URL': self.url

        }

    def set_type(self, itype):

        self.itype = itype

    def set_size(self, size):

        self.size = size

    def set_width(self, width):

        self.width = width

    def set_height(self, height):

        self.height = height

    def set_url(self, url):

        self.url = url

from __future__ import unicode_literals

import time

from wechat_sdk.exceptions import NeedParamError

from wechat_sdk.lib.crypto import BasicCrypto

from wechat_sdk.lib.request import WechatRequest

from wechat_sdk.utils import disable_urllib3_warning

class WechatConf(object):

    """ WechatConf 配置类

    该类将会存储所有和微信开发相关的配置信息, 同时也会维护配置信息的有效性.

    """

    def __init__(self, **kwargs):

        """

        :param kwargs: 配置信息字典, 可用字典 key 值及对应解释如下:

                       'token': 微信 Token

                       'appid': App ID

                       'appsecret': App Secret

                       'encrypt_mode': 加解密模式 ('normal': 明文模式, 'compatible': 兼容模式, 'safe': 安全模式(默认))

                       'encoding_aes_key': EncodingAESKey 值 (传入此值必须保证同时传入 token, appid, 否则抛出异常)

                       'access_token_getfunc': access token 获取函数 (用于单机及分布式环境下, 具体格式参见文档)

                       'access_token_setfunc': access token 写入函数 (用于单机及分布式环境下, 具体格式参见文档)

                       'access_token_refreshfunc': access token 刷新函数 (用于单机及分布式环境下, 具体格式参见文档)

                       'access_token': 直接导入的 access token 值, 该值需要在上一次该类实例化之后手动进行缓存并在此处传入, 如果不

                                       传入, 将会在需要时自动重新获取 (传入 access_token_getfunc 和 access_token_setfunc 函数

                                       后将会自动忽略此处的传入值)

                       'access_token_expires_at': 直接导入的 access token 的过期日期, 该值需要在上一次该类实例化之后手动进行缓存

                                                  并在此处传入, 如果不传入, 将会在需要时自动重新获取 (传入 access_token_getfunc

                                                  和 access_token_setfunc 函数后将会自动忽略此处的传入值)

                       'jsapi_ticket_getfunc': jsapi ticket 获取函数 (用于单机及分布式环境下, 具体格式参见文档)

                       'jsapi_ticket_setfunc': jsapi ticket 写入函数 (用于单机及分布式环境下, 具体格式参见文档)

                       'jsapi_ticket_refreshfunc': jsapi ticket 刷新函数 (用于单机及分布式环境下, 具体格式参见文档)

                       'jsapi_ticket': 直接导入的 jsapi ticket 值, 该值需要在上一次该类实例化之后手动进行缓存并在此处传入, 如果不

                                       传入, 将会在需要时自动重新获取 (传入 jsapi_ticket_getfunc 和 jsapi_ticket_setfunc 函数

                                       后将会自动忽略此处的传入值)

                       'jsapi_ticket_expires_at': 直接导入的 jsapi ticket 的过期日期, 该值需要在上一次该类实例化之后手动进行缓存

                                                  并在此处传入, 如果不传入, 将会在需要时自动重新获取 (传入 jsapi_ticket_getfunc

                                                  和 jsapi_ticket_setfunc 函数后将会自动忽略此处的传入值)

                       'partnerid': 财付通商户身份标识, 支付权限专用

                       'partnerkey': 财付通商户权限密钥 Key, 支付权限专用

                       'paysignkey': 商户签名密钥 Key, 支付权限专用

                       'checkssl': 是否检查 SSL, 默认不检查 (False), 可避免 urllib3 的 InsecurePlatformWarning 警告

        :return:

        """

        self.__request = WechatRequest()

        if kwargs.get('checkssl') is not True:

            disable_urllib3_warning()  # 可解决 InsecurePlatformWarning 警告

        self.__token = kwargs.get('token')

        self.__appid = kwargs.get('appid')

        self.__appsecret = kwargs.get('appsecret')

        self.__encrypt_mode = kwargs.get('encrypt_mode', 'safe')

        self.__encoding_aes_key = kwargs.get('encoding_aes_key')

        self.__crypto = None

        self._update_crypto()

        self.__access_token_getfunc = kwargs.get('access_token_getfunc')

        self.__access_token_setfunc = kwargs.get('access_token_setfunc')

        self.__access_token_refreshfunc = kwargs.get('access_token_refreshfunc')

        self.__access_token = kwargs.get('access_token')

        self.__access_token_expires_at = kwargs.get('access_token_expires_at')

        self.__jsapi_ticket_getfunc = kwargs.get('jsapi_ticket_getfunc')

        self.__jsapi_ticket_setfunc = kwargs.get('jsapi_ticket_setfunc')

        self.__jsapi_ticket_refreshfunc = kwargs.get('jsapi_ticket_refreshfunc')

        self.__jsapi_ticket = kwargs.get('jsapi_ticket')

        self.__jsapi_ticket_expires_at = kwargs.get('jsapi_ticket_expires_at')

        self.__partnerid = kwargs.get('partnerid')

        self.__partnerkey = kwargs.get('partnerkey')

        self.__paysignkey = kwargs.get('paysignkey')

    @property

    def token(self):

        """ 获取当前 Token """

        self._check_token()

        return self.__token

    @token.setter

    def token(self, token):

        """ 设置当前 Token """

        self.__token = token

        self._update_crypto()  # 改动 Token 需要重新更新 Crypto

    @property

    def appid(self):

        """ 获取当前 App ID """

        return self.__appid

    @property

    def appsecret(self):

        """ 获取当前 App Secret """

        return self.__appsecret

    def set_appid_appsecret(self, appid, appsecret):

        """ 设置当前 App ID 及 App Secret"""

        self.__appid = appid

        self.__appsecret = appsecret

        self._update_crypto()  # 改动 App ID 后需要重新更新 Crypto

    @property

    def encoding_aes_key(self):

        """ 获取当前 EncodingAESKey """

        return self.__encoding_aes_key

    @encoding_aes_key.setter

    def encoding_aes_key(self, encoding_aes_key):

        """ 设置当前 EncodingAESKey """

        self.__encoding_aes_key = encoding_aes_key

        self._update_crypto()  # 改动 EncodingAESKey 需要重新更新 Crypto

    @property

    def encrypt_mode(self):

        return self.__encrypt_mode

    @encrypt_mode.setter

    def encrypt_mode(self, encrypt_mode):

        """ 设置当前加密模式 """

        self.__encrypt_mode = encrypt_mode

        self._update_crypto()

    @property

    def crypto(self):

        """ 获取当前 Crypto 实例 """

        return self.__crypto

    @property

    def access_token(self):

        """ 获取当前 access token 值, 本方法会自行维护 access token 有效性 """

        self._check_appid_appsecret()

        if callable(self.__access_token_getfunc):

            self.__access_token, self.__access_token_expires_at = self.__access_token_getfunc()

        if self.__access_token:

            now = time.time()

            if self.__access_token_expires_at - now > 60:

                return self.__access_token

        self.grant_access_token()  # 从腾讯服务器获取 access token 并更新

        return self.__access_token

    @property

    def jsapi_ticket(self):

        """ 获取当前 jsapi ticket 值, 本方法会自行维护 jsapi ticket 有效性 """

        self._check_appid_appsecret()

        if callable(self.__jsapi_ticket_getfunc):

            self.__jsapi_ticket, self.__jsapi_ticket_expires_at = self.__jsapi_ticket_getfunc()

        if self.__jsapi_ticket:

            now = time.time()

            if self.__jsapi_ticket_expires_at - now > 60:

                return self.__jsapi_ticket

        self.grant_jsapi_ticket()  # 从腾讯服务器获取 jsapi ticket 并更新

        return self.__jsapi_ticket

    @property

    def partnerid(self):

        """ 获取当前财付通商户身份标识 """

        return self.__partnerid

    @property

    def partnerkey(self):

        """ 获取当前财付通商户权限密钥 Key """

        return self.__partnerkey

    @property

    def paysignkey(self):

        """ 获取商户签名密钥 Key """

        return self.__paysignkey

    def grant_access_token(self):

        """

        获取 access token 并更新当前配置

        :return: 返回的 JSON 数据包 (传入 access_token_refreshfunc 参数后返回 None)

        """

        self._check_appid_appsecret()

        if callable(self.__access_token_refreshfunc):

            self.__access_token, self.__access_token_expires_at = self.__access_token_refreshfunc()

            return

        response_json = self.__request.get(

            url="https://api.weixin.qq.com/cgi-bin/token",

            params={

                "grant_type": "client_credential",

                "appid": self.__appid,

                "secret": self.__appsecret,

            },

            access_token=self.__access_token

        )

        self.__access_token = response_json['access_token']

        self.__access_token_expires_at = int(time.time()) + response_json['expires_in']

        if callable(self.__access_token_setfunc):

            self.__access_token_setfunc(self.__access_token, self.__access_token_expires_at)

        return response_json

    def grant_jsapi_ticket(self):

        """

        获取 jsapi ticket 并更新当前配置

        :return: 返回的 JSON 数据包 (传入 jsapi_ticket_refreshfunc 参数后返回 None)

        """

        self._check_appid_appsecret()

        if callable(self.__jsapi_ticket_refreshfunc):

            self.__jsapi_ticket, self.__jsapi_ticket_expires_at = self.__jsapi_ticket_refreshfunc()

            return

        response_json = self.__request.get(

            url="https://api.weixin.qq.com/cgi-bin/ticket/getticket",

            params={

                "type": "jsapi",

            },

            access_token=self.access_token,

        )

        self.__jsapi_ticket = response_json['ticket']

        self.__jsapi_ticket_expires_at = int(time.time()) + response_json['expires_in']

        if callable(self.__jsapi_ticket_setfunc):

            self.__jsapi_ticket_setfunc(self.__jsapi_ticket, self.__jsapi_ticket_expires_at)

        return response_json

    def get_access_token(self):

        """

        获取 Access Token 及 Access Token 过期日期, 仅供缓存使用, 如果希望得到原生的 Access Token 请求数据请使用 :func:`grant_token`

        **仅为兼容 v0.6.0 以前版本使用, 自行维护 access_token 请使用 access_token_setfunc 和 access_token_getfunc 进行操作**

        :return: dict 对象, key 包括 `access_token` 及 `access_token_expires_at`

        """

        self._check_appid_appsecret()

        return {

            'access_token': self.access_token,

            'access_token_expires_at': self.__access_token_expires_at,

        }

    def get_jsapi_ticket(self):

        """

        获取 Jsapi Ticket 及 Jsapi Ticket 过期日期, 仅供缓存使用, 如果希望得到原生的 Jsapi Ticket 请求数据请使用 :func:`grant_jsapi_ticket`

        **仅为兼容 v0.6.0 以前版本使用, 自行维护 jsapi_ticket 请使用 jsapi_ticket_setfunc 和 jsapi_ticket_getfunc 进行操作**

        :return: dict 对象, key 包括 `jsapi_ticket` 及 `jsapi_ticket_expires_at`

        """

        self._check_appid_appsecret()

        return {

            'jsapi_ticket': self.jsapi_ticket,

            'jsapi_ticket_expires_at': self.__jsapi_ticket_expires_at,

        }

    def _check_token(self):

        """

        检查 Token 是否存在

        :raises NeedParamError: Token 参数没有在初始化的时候提供

        """

        if not self.__token:

            raise NeedParamError('Please provide Token parameter in the construction of class.')

    def _check_appid_appsecret(self):

        """

        检查 AppID 和 AppSecret 是否存在

        :raises NeedParamError: AppID 或 AppSecret 参数没有在初始化的时候完整提供

        """

        if not self.__appid or not self.__appsecret:

            raise NeedParamError('Please provide app_id and app_secret parameters in the construction of class.')

    def _update_crypto(self):

        """

        根据当前配置内容更新 Crypto 类

        """

        if self.__encrypt_mode in ['compatible', 'safe'] and self.__encoding_aes_key is not None:

            if self.__token is None or self.__appid is None:

                raise NeedParamError('Please provide token and appid parameters in the construction of class.')

            self.__crypto = BasicCrypto(self.__token, self.__encoding_aes_key, self.__appid)

        else:

            self.__crypto = None

import pygame

from plane_sprites import *

class PlaneGame(object):

    """飞机大战主游戏"""

    def __init__(self):

        print("游戏初始化")

        # 1.创建游戏的窗口

        self.screen = pygame.display.set_mode(SCREEN_RECT.size)

        # 2.创建游戏的时钟

        self.clock = pygame.time.Clock()

        # 3.调用私有方法完成精灵和精灵组的创建

        self.__create_sprites()

        # 4.设置定时器时间-创建敌机 ENEMY_TIME时间出场一次

        pygame.time.set_timer(CREATE_ENEMY_EVENT, ENEMY_TIME)

        # 5.设定定时器时间-英雄子弹 FIRE_TIME时间发射一次

        pygame.time.set_timer(HERO_FIRE_EVENT, FIRE_TIME)

        # 6.设定定时器时间-敌机子弹 ENEMY_FIRE_EVENT时间发射一次

        pass

    def __create_sprites(self):

        # 创建背景精灵和精灵组

        bg1 = Background()

        bg2 = Background(True)

        self.back_group = pygame.sprite.Group(bg1, bg2)

        # 创建敌机的精灵组

        self.enemy_group = pygame.sprite.Group()

        # 创建英雄的精灵和精灵组

        self.hero = Hero()

        self.hero_group = pygame.sprite.Group(self.hero)

    def start_game(self):

        # print("游戏开始...")

        while True:

            # 1.设置刷新帧率

            self.clock.tick(FRAME_PER_SEC)

            # 2.事件监听

            self.__event_handler()

            # 3.碰撞检测

            self.__check_collide()

            # 4.更新/绘制精灵组

            self.__update_sprites()

            # 5.更新显示

            pygame.display.update()

    def __event_handler(self):

        """事件监听"""

        for event in pygame.event.get():

            # 判断是否退出游戏

            if event.type == pygame.QUIT:

                PlaneGame.__game_over()

            # 监听敌机出场事件

            elif event.type == CREATE_ENEMY_EVENT:

                # print(CREATE_ENEMY_EVENT, "敌机出场...")

                # 创建敌机精灵

                enemy = Enemy()

                # 将敌机精灵添加到敌机精灵组

                self.enemy_group.add(enemy)

            # 监听英雄发射子弹事件

            elif event.type == HERO_FIRE_EVENT:

                self.hero.fire()

            # 事件监听模式获取按键

            # elif event.type == pygame.KEYDOWN and \

            #         event.key == pygame.K_RIGHT:

            #     print("单次向右移动...")

        # 使用键盘提供的方法获取键盘按键-返回按键元组

        # 获取键盘按键键位

        keys_pressed = pygame.key.get_pressed()

        # 判断元组中对应的按键索引值

        if keys_pressed[pygame.K_RIGHT]:

            # print("持续向右移动...")

            self.hero.around = True

            self.hero.speed = HERO_RIGHT_LEFT

        elif keys_pressed[pygame.K_LEFT]:

            self.hero.around = True

            self.hero.speed = -HERO_RIGHT_LEFT

        elif keys_pressed[pygame.K_UP]:

            self.hero.around = False

            self.hero.speed = -HERO_UP_DOWN

        elif keys_pressed[pygame.K_DOWN]:

            self.hero.around = False

            self.hero.speed = HERO_UP_DOWN

        else:

            self.hero.speed = 0

    def __check_collide(self):

        """碰撞检测"""

        # 1.子弹摧毁敌机

        pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)

        # 2.敌机撞毁英雄

        enemies = pygame.sprite.spritecollide(self.hero, self.enemy_group, True)

        #  判断列表是否有类容

        if len(enemies) > 0:

            # 让英雄牺牲

            self.hero.kill()

            # 结束游戏

            PlaneGame.__game_over()

    def __update_sprites(self):

        """更新显示"""

        self.back_group.update()

        self.back_group.draw(self.screen)

        self.enemy_group.update()

        self.enemy_group.draw(self.screen)

        self.hero_group.update()

        self.hero_group.draw(self.screen)

        self.hero.bullets.update()

        self.hero.bullets.draw(self.screen)

    @staticmethod

    def __game_over():

        print("游戏结束")

        pygame.quit()

        exit()

if __name__ == '__main__':

    # 创建游戏对象

    game = PlaneGame()

    # 启动游戏

    game.start_game()

import random

import pygame

# 屏幕大小的常量

SCREEN_RECT = pygame.Rect(0, 0, 480, 700)

# 屏幕的刷新帧率

FRAME_PER_SEC = 60

# 屏幕的背景图像

BG1_PNG = "./images/background2.png"

# 创建敌机的定时器常量

CREATE_ENEMY_EVENT = pygame.USEREVENT

# 敌人出现时间的间隔,多少毫秒出现

ENEMY_TIME = 300

# 敌机的图片

ENEMY1_PNG = "./images/enemy4.png"

# 敌机的最大/最小速度

ENEMY_MAX_SD = 7

ENEMY_MIN_SD = 3

# 英雄的图片

HERO_PNG = "./images/me3.png"

# 英雄距离屏幕底端的距离

HERO_MAX_Y = 120

# 英雄左右移动速度

HERO_RIGHT_LEFT = 4

# 英雄上下移动速度

HERO_UP_DOWN = 2

# 英雄发射子弹的定时器常量

HERO_FIRE_EVENT = pygame.USEREVENT + 1

# 英雄子弹自动发射间隔 0.5秒发射一次

FIRE_TIME = 500

# 英雄子弹图片

BULLET_PNG = "./images/bomb.png"

# 英雄子弹飞行速度

BULLET_TIME = -3

class GameSprite(pygame.sprite.Sprite):

    """飞机大战游戏精灵"""

    def __init__(self, image_name, speed=1):

        # 调用父类的初始化方法

        super().__init__()

        # 定义对象的属性

        self.image = pygame.image.load(image_name)

        self.rect = self.image.get_rect()

        self.speed = speed

    def update(self):

        # 屏幕的垂直方向上移动

        self.rect.y += self.speed

class Background(GameSprite):

    """游戏背景精灵"""

    def __init__(self, is_alt=False):

        # 1.调用父类方法实现精灵的创建(images/rect/speed)

        super().__init__(BG1_PNG)

        # 2.判断是否是交替图像,如果是则设置初始位置

        if is_alt:

            self.rect.y = -self.rect.height

    def update(self):

        # 1.调用父类的方法实现

        super().update()

        # 2.判断是否移出屏幕,移出则将图像设置到屏幕的上方

        if self.rect.y >= SCREEN_RECT.height:

            self.rect.y = -self.rect.height

        pass

class Enemy(GameSprite):

    """敌机精灵"""

    def __init__(self):

        # 1.调用父类方法,创建敌机精灵,同时指定敌机图片

        super().__init__(ENEMY1_PNG)

        # 2.指定敌机的初始随机速度

        self.speed = random.randint(ENEMY_MIN_SD, ENEMY_MAX_SD)

        # 3.指定敌机的初始随机位置,bottom=y+height

        self.rect.bottom = 0

        max_x = SCREEN_RECT.width - self.rect.width

        self.rect.x = random.randint(0, max_x)

    def update(self):

        # 1.调用父类方法保持垂直方向的飞行

        super().update()

        # 2.判断是否飞出屏幕,是则从精灵组中删除敌机

        if self.rect.y >= SCREEN_RECT.height:

            # print("飞出屏幕,需要从精灵组删除...")

            # kill方法可以将精灵从所有精灵组中移出,自动销毁

            self.kill()

    def __del__(self):

        # print("敌机销毁 %s" % self.rect)

        pass

class Hero(GameSprite):

    """英雄精灵"""

    def __init__(self):

        # 1.调用父类方法,设置images/speed

        super().__init__(HERO_PNG, 0)

        # 2.设置英雄的初始位置

        self.rect.centerx = SCREEN_RECT.centerx

        self.rect.bottom = SCREEN_RECT.bottom - HERO_MAX_Y

        # 3.设置英雄的初始控制模式,True左右飞行,False上下飞行

        self.around = True

        # 4.创建子弹的精灵组

        self.bullets = pygame.sprite.Group()

    def update(self, ):

        # 英雄在水平/垂直方向移动

        if self.around:

            self.rect.x += self.speed

        else:

            self.rect.y += self.speed

        # 控制英雄不能离开屏幕,right=x+width

        if self.rect.x < 0:

            self.rect.x = 0

        elif self.rect.right > SCREEN_RECT.right:

            self.rect.right = SCREEN_RECT.right

        elif self.rect.y < 0:

            self.rect.y = 0

        elif self.rect.bottom > SCREEN_RECT.bottom:

            self.rect.bottom = SCREEN_RECT.bottom

    def fire(self):

        # print("发射子弹...")

        for i in (0, 1):

            # 1.创建子弹精灵

            bullet = Bullet()

            # 2.设置精灵的位置

            bullet.rect.bottom = self.rect.y - i * 50

            bullet.rect.centerx = self.rect.centerx

            # 3.将精灵添加到精灵组

            self.bullets.add(bullet)

class Bullet(GameSprite):

    """子弹精灵"""

    def __init__(self):

        # 调用父类方法,设置子弹图片和初始速度

        super().__init__(BULLET_PNG, BULLET_TIME)

    def update(self):

        # 调用父类方法,让子弹沿垂直方向飞行

        super().update()

        # 判断子弹是否飞出屏幕

        if self.rect.bottom < 0:

            self.kill()

    def __del__(self):

        # print("子弹被销毁...")

        pass