'''
def functionName(args):
    "函数文档字符串"
    函数体
'''
'''
class 类名:
    "类的文档字符串"
    类体
'''


# 我们创建一个类
class Data:  # 类名首字母大写
    pass

class Person:  # 定义一个人类
    role = "person"  # 人的角色属性都是人

    def walk(self):  # 人都可以走路,也就是说有一个走路方法
        print("person is walking.....")


print(Person.role)  # 查看人的role属性
print(Person.walk)  # 引用人的走路方法,注意,这里不是在调用

class Person:  # 定义一个人类
    role = "person"  # 人的角色属性是人

    def __init__(self, name):
        self.name = name  # 每一个角色都有自己的昵称

    def walk(self):  # 人都可以走路,也就是有一个走路方法
        print("person is walking")


print(Person.role)  # 查看人的role 属性
print(Person.walk)  # 引用人的走路方法,注意,这里不是在调用

一 :我们定义的类的属性到底存到哪里了?有两种方式查看
dir(类名):查出的是一个名字列表
类名.__dict__:查出的是一个字典,key为属性名,value为属性值


二 :特殊的类属性
类名.__name__     #类的名字(字符串)
类名.__doc__         #类的文档字符串
类名.__base__        #类的第一个父类(在讲继承时会讲)
类名.__bases__       #类所有父类构成的元祖(在讲继承时会讲)
类名.__dict__       #类的字典属性
类名.__module__     #类定义所在的模块
类名.__class__       #实例对应的类(仅新式类中)

class 类名:
    def __init__(self, 参数1, 参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名1(self):
        pass

    def 方法名2(self):
        pass
对象名 = 类名(1,2) # 对象就是实例,代表一个具体的东西
                   # 类名() : 类名+括号就是实例化一个类,相当于调用了__init__方法
                   # 括号里传参数,参数不需要传self,其他与init中的形参一一对象
                   # 结果返回一个对象
对象名.对象的属性1  #查看对象的属性,直接用 对象名.属性名 即可
对象名.方法名1()     # 调用类中的方法,直接用 对象名.属性名 即可

'''
练习一：在终端输出如下信息

小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健
老张…

练习题
'''
class A:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex =sex
    def chop_wood(self):   # chop_wood   砍柴
        print("%s,%s,%s,上山去砍柴" %(self.name,self.age,self.sex))
    def drive(self):      # drive  驾驶
        print("%s,%s,%s,开车去东北" % (self.name, self.age, self.sex))
    def great_health_care(self):  # great_health_care  卫生保健系统
        print("%s,%s,%s,最爱大保健" % (self.name, self.age, self.sex))
p1 =A("小名",10,"男")
p1.chop_wood()
p1.drive()
p1.great_health_care()
p2 = A("老李",90,"男")
p2.chop_wood()
p2.drive()
p2.great_health_care()

>>>id(egg.role)
4341594072
>>>id(Person.role)
4341594072

>>>egg.attack
<bound method Person.attack of <__main__.Person object at 0x101285860>>
>>>Person.attack
<function Person.attack at 0x10127abf8>

class ParentClass1:  # 定义父类
    pass


class ParentClass2:  # 定义父类
    pass


class SubClass1(ParentClass1):  # 单继承,基类是ParentClass1 ,派生类是SubClass
    pass


class SubClass2(ParentClass1, ParentClass2):  # python 支持多继承,
用逗号分隔开多个继承的类
    pass

 SubClass1.__bases__ 
　　　　　　　#__base__只查看从左到右继承的第一个子类
　　　　　　　#__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

==========================第一部分
例如

　　猫可以：爬树、吃、喝、拉、撒

　　狗可以：看门、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：
#猫和狗有大量相同的内容
class 猫:
    def 爬树(self):
        print("爬树")

    def 吃(self):
        print("吃")

    def 喝(self):
        print("喝")

    def 拉(self):
        print("拉")

    def 撒(self):
        print("撒")


class 狗:
    def 看门(self):
        print("看门")

    def 吃(self):
        print("吃")

    def 喝(self):
        print("喝")

    def 拉(self):
        print("拉")

    def sa(self):
        print("撒")


==========================第二部分
上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，
而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：

　　动物：吃、喝、拉、撒

　　   猫：爬树（猫继承动物的功能）

　　   狗：看门（狗继承动物的功能）

伪代码如下：
class 动物:
    def 吃(self):
        print("吃")

    def 喝(self):
        print("喝")

    def 拉(self):
        print("拉")

    def 撒(self):
        print("撒")


# 在类后面括号中写入另一个类名,表示当前类继承另一个类
class 猫(动物):
    def 爬树(self):
        print("爬树")


# 在类后面括号中写入另一个类名,表示当前类继承另一个类
class 狗(动物):
    def 看门(self):
        print("看门")

==========================第三部分

# 继承的代码实现
class Animal:  # 定义一个动物类
    def eat(self):
        print("%s吃" % self.name)

    def drink(self):
        print("%s喝" % self.name)

    def shit(self):
        print("%s拉" % self.name)

    def pee(self):
        print("%s撒" % self.name)


class Cat(Animal):  # 猫
    def __init__(self, name):
        self.name = name
        self.breed = "猫"

    def climb_tree(self):  # 爬树
        print("%s爬树" % self.name)


class Dog(Animal):
    def __init__(self, name):
        self.name = name
        self.breed = "狗"

    def door(self):  # 门
        print("%s看门" % self.name)


# ######### 执行 #########
c1 = Cat("小白家的小黑猫")
c1.eat()
c2 = Cat("小黑的小白猫")
c2.drink()
d1 = Dog("胖子家的小瘦狗")
d1.eat()
# 使用继承来重用代码比较好的例子

class D:
    def bar(self):
        print("D.bar")


class C(D):
    def bar(self):
        print("C.bar")


class B(D):
    def bar(self):
        print("B.bar")


class A(B, C):
    def bar(self):
        print("A.bar")


a = A()
#执行bar方法
#首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中没有,则继续去D类去找,如果D类中没有,则继续去C类中找,如果还是未找到,则报错
#所以,查询顺序:A-->B-->D-->C
#在上述查找bar的过程中,一旦找到,则寻找过程立即中断,便不会再继续找了
a.bar()


经典类多继承

class D(object):
    def bar(self):
        print("D.bar")


class C(D):
    def bar(self):
        print("C.bar")


class B(D):
    def bar(self):
        print("B.bar")


class A(B, C):
    def bar(self):
        print("A.bar")


a = A()
# 执行bar方法时
# 首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中没有,则继续去C类中找,如果C类中么有,则继续去D类中找,如果还是未找到,则报错
# 所以,查找顺序:A-->B-->C-->D
a.bar()


新式类多继承

# 一:这样不好,我们要统一一下支付的规则.
class QQpay:
    def pay(self, money):
        print("使用qq支付%s远" % money)


class Alipay:
    def pay(self, money):
        print("使用阿里支付%s元" % money)


a = Alipay()
a.pay(100)

b = QQpay()
b.pay(200)


# 二:统一支付的规则,归一化设计,统一  pay接口
class QQpay:
    def pay(self, money):
        print("使用qq支付%s元" % money)


class Alipay:
    def pay(self, money):
        print("使用阿里支付%s元" % money)


def pay(obj, moeny):
    obj.pay("money")


a = Alipay()
b = QQpay()

pay(a, 100)
pay(b, 200)


# 三,但是,来了一个野生程序员,他不知道你的约定俗称的规则,就会出问题
class QQpay:
    def pay(self, money):
        print("使用qq支付%s元" % money)


class Alipay:
    def pay(self, money):
        print("使用阿里云支付%s元" % money)


class Wechatpay:
    def fuqian(self, money):
        print("使用微信支付%s元" % money)


def pay(obj, money):
    obj.pay(money)


a = Alipay()
b = QQpay()

pay(a, 100)
pay(b, 200)

c = Wechatpay()
c.fuqian(300)


# 四 :解决方式
# 定义一个父类,什么都不写,只是要求继承我的所有类的一个pay方法,这样就制定了一个规范,这就叫做接口,后者抽象类.

class Payment:
    def pay(self): pass


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

pay(a, 100)
pay(b, 200)

c = Wechatpay()
c.fuqian(300)

# 五,他还是不知道看你的这些都继承了一个类,所以你要定制一个规范,强制他执行
# 创建一个规范
from abc import ABCMeta, abstractmethod


class Payment(metaclass=ABCMeta):  # 抽象类  接口类 规范和约束 metaclass 指定的是一个元类
    @abstractmethod
    def pay(self):
        pass  # 抽象方法


class Alipay(Payment):
    def pay(self, money):
        print('使用支付宝支付了%s元' % money)


class QQpay(Payment):
    def pay(self, money):
        print('使用qq支付了%s元' % money)


class Wechatpay(Payment):
    # def pay(self,money):
    #     print('使用微信支付了%s元'%money)
    def recharge(self): pass


def pay(a, money):
    a.pay(money)


a = Alipay()
a.pay(100)
pay(a, 100)  # 归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能
q = QQpay()
q.pay(100)
pay(q, 100)
w = Wechatpay()
pay(w, 100)  # 到用的时候才会报错

#抽象类和接口类做的事情:建立规范
#指定一个类的 metaclass是 ABCMeta
#那么这个类就变成了一个抽象类(接口类)
#这个类的主要功能就是建立一个规范

依赖倒置原则:
高层模块不应该依赖底层模块,二者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象,换言之,
要针对接口编程,而不是针对实现编程

接口提取了一群类共同的函数,可以把接口当做一个函数的集合.

然后让子类去实现接口中的函数

这么做的意义在于归一化,什么叫归一化,就是只要是基于同一个接口实现的类,
那么所有的这些类产生的对象在使用时,从用法上来说都一样

归一化,让使用者无需关心对象的类是什么,只需要的知道这些对象都具备某些功能就可以了,
这极大地降低了使用者的使用难度.

比如:我们定义一个动物接口,接口里定义了有跑,吃,呼吸等接口函数,这样老鼠的类去实现了该接口,
松鼠的类也去实现了该接口,由二者恩别产生一只老鼠和一只松鼠送到你面前,
即便是你分别不到底那只是什么鼠你肯定知道他俩都会跑,都会吃,都能呼吸.

再比如:我们有一个汽车接口,里面定义了汽车所有的功能,然后由本田汽车的类,
奥迪汽车的类,大众汽车的类,我们都实现了汽车接口,这样就好办了,
大家只需要学会了这么开汽车,那么无论是本田,还是奥迪,
还是大众我们都会开了,开的时候根本无需关心我开的是哪一类车,操作手法(函数调用)都一样