Python基础17-面向对象

# 面向过程的编程思想
面向过程的程序设计：核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么......面向过程的设计就好比精心设计好一条流水线，是一种机械式的思维方式。

优点是：复杂度的问题流程化，进而简单化（一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单）

缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

# 面向对象的编程思想

面向对象的程序设计：核心是对象二字，（要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的数据属性和方法属性），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取),对象是特征与技能的结合体，基于面向对象设计程序就好比在创造一个世界，你就是这个世界的上帝，存在的皆为对象，不存在的也可以创造出来，与面向过程机械式的思维方式形成鲜明对比，面向对象更加注重对现实世界的模拟，是一种“上帝式”的思维方式。

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：

1. 编程的复杂度远高于面向过程，不了解面向对象而立即上手基于它设计程序，极容易出现过度设计的问题。一些扩展性要求低的场景使用面向对象会徒增编程难度，比如管理linux系统的shell脚本就不适合用面向对象去设计，面向过程反而更加适合。

2. 无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法准确地预测最终结果。于是我们经常看到对战类游戏，新增一个游戏人物，在对战的过程中极容易出现阴霸的技能，一刀砍死3个人，这种情况是无法准确预知的，只有对象之间交互才能准确地知道最终的结果。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方

#在现实世界中，站在xx大学学校的角度：先有对象，再有类
对象1：李坦克
    特征:
        学校=xx大学
        姓名=李坦克
        性别=男
        年龄=18
    技能：
        学习
        吃饭
        睡觉

对象2：王大炮
    特征:
        学校=xx大学
        姓名=王大炮
        性别=女
        年龄=38
    技能：
        学习
        吃饭
        睡觉

对象3：牛榴弹
    特征:
        学校=xx大学
        姓名=牛榴弹
        性别=男
        年龄=78
    技能：
        学习
        吃饭
        睡觉


现实中的老男孩学生类
    相似的特征:
        学校=xx大学
    相似的技能：
        学习
        吃饭
        睡觉

#在程序中，务必保证：先定义（类），后使用（产生对象）
PS:
  1. 在程序中特征用变量标识，技能用函数标识
  2. 因而类中最常见的无非是：变量和函数的定义

#程序中的类
class xxSchoolStudent:
    school='xxSchool'
    def learn(self):
        print('is learning')
        
    def eat(self):
        print('is eating')
    
    def sleep(self):
        print('is sleeping')
  


#注意：
  1.类中可以有任意python代码，这些代码在类定义阶段便会执行
  2.因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过xxSchoolStudent.__dict__查看
  3.对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但python为我们提供专门的.语法
  4.点是访问属性的语法，类中定义的名字，都是类的属性

#程序中类的用法
.:专门用来访问属性，本质操作的就是__dict__
xxSchoolStudent.school #等于经典类的操作xxSchoolStudent.__dict__['school']
xxSchoolStudent.school='xxSchool' #等于经典类的操作xxSchoolStudent.__dict__['school']='xxSchool'
xxSchoolStudent.x=1 #等于经典类的操作xxSchoolStudent.__dict__['x']=1
del xxSchoolStudent.x #等于经典类的操作xxSchoolStudent.__dict__.pop('x')


#程序中的对象
#调用类，或称为实例化，得到对象
s1=xxSchoolStudent()
s2=xxSchoolStudent()
s3=xxSchoolStudent()

#如此，s1、s2、s3都一样了，而这三者除了相似的属性之外还各种不同的属性，这就用到了__init__
#注意：该方法是在对象产生之后才会执行，只用来为对象进行初始化操作，可以有任意代码，但一定不能有返回值
class xxSchoolStudent:
    ......
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    ......


s1=xxSchoolStudent('李坦克','男',18) #先调用类产生空对象s1，然后调用xxSchoolStudent.__init__(s1,'李坦克','男',18)
s2=xxSchoolStudent('王大炮','女',38)
s3=xxSchoolStudent('牛榴弹','男',78)


#程序中对象的用法
#执行__init__,s1.name='牛榴弹'，很明显也会产生对象的名称空间
s2.__dict__
{'name': '王大炮', 'age': '女', 'sex': 38}

s2.name #s2.__dict__['name']
s2.name='王三炮' #s2.__dict__['name']='王三炮'
s2.course='python' #s2.__dict__['course']='python'
del s2.course #s2.__dict__.pop('course')

print(OldboyStudent.__dict__) # 查看类的名称空间
print(OldboyStudent.school) #print(OldboyStudent.__dict__['school'])
print(OldboyStudent.choose_course)
OldboyStudent.school='OLDBOY' #OldboyStudent.__dict__['school']='OLDBOY'
OldboyStudent.country='China' #OldboyStudent.__dict__['country']='China'
del OldboyStudent.country # del OldboyStudent.__dict__['country']
print(OldboyStudent.__dict__)

OldboyStudent.choose_course(123123)
# 总结:
#1. 类本质就是一个名称空间,或者说是一个用来存放变量与函数的容器
#2. 类的用途之一就是当做名称空间从其内部取出名字来使用
#3. 类的用途之二是调用类来产生对象

class OldboyStudent:
    #相同的特征
    school = 'oldboy'

    #相同的技能
    def choose_course(self):
        print('choosing course')

#2. 后调用类来产生对象:
# 调用类的过程称之为类的实例化,调用类的返回值称之为类的一个对象/实例


# 调用类发生了?
# 1. 会产生一个对象,然后返回

stu1=OldboyStudent()
stu2=OldboyStudent()
stu3=OldboyStudent()

print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)

# 为对象定制自己独有的特征

# name='李铁蛋'
# age=18
# sex='male'
stu1.name='李铁蛋'
stu1.age=18
stu1.sex='male'

print(stu1.__dict__)

# name='赵钢弹'
# age=38
# sex='female'
stu2.name='赵钢弹'
stu2.age=38
stu2.sex='female'

print(stu2.__dict__)

# name='刘银弹'
# age=28
# sex='male'
stu3.name='刘银弹'
stu3.age=28
stu3.sex='male'

print(stu3.__dict__)


## 上面全是重复代码啊...怎么办？定义函数解决
# 为对象定制自己独有的特征,简化方案一:

def init(obj,name,age,sex):
    obj.name = name
    obj.age = age
    obj.sex = sex

# stu1.name='李铁蛋'
# stu1.age=18
# stu1.sex='male'
init(stu1,'李铁蛋',18,'male')

# stu2.name='赵钢弹'
# stu2.age=38
# stu2.sex='female'
init(stu2,'赵钢弹',38,'female')

# stu3.name='刘银弹'
# stu3.age=28
# stu3.sex='male'
init(stu3,'刘银弹',28,'male')

print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)


# 为对象定制自己独有的特征,简化方案二:
class OldboyStudent:
    #相同的特征
    school = 'oldboy'

    #           stu1,'李铁蛋',18,'male'
    def __init__(obj, name, age, sex):
        obj.name = name #stu1.name='李铁蛋'
        obj.age = age   #stu1.age=18
        obj.sex = sex   #stu1.sex='male'

    #相同的技能
    def choose_course(self):
        print('choosing course')
        
# 调用类发生了
# 1. 先产生一个空对象stu1,然后返回
# 2. 触发类中函数__init__的执行,将对象连同调用类括号内指定的参数一同传入__init__(stu1,'李铁蛋',18,'male')

stu1=OldboyStudent('李铁蛋',18,'male') #__init__(stu1,'李铁蛋',18,'male')
stu2=OldboyStudent('赵钢弹',38,'female') #__init__(stu2,'赵钢弹',38,'female')
stu3=OldboyStudent('刘银弹',28,'male') #__init__(stu3,'刘银弹',28,'male')

print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
# 总结__init__的功能: 是在实例化时就为对象初始自己独有的特征
# 注意:不能有返回值

#方式一、为对象初始化自己独有的特征
class People:
    country='China'
    x=1
    def run(self):
        print('----->', self)

# 实例化出三个空对象
obj1=People()
obj2=People()
obj3=People()

# 为对象定制自己独有的特征
obj1.name='zls'
obj1.age=18
obj1.sex='male'

obj2.name='lxx'
obj2.age=38
obj2.sex='female'

obj3.name='alex'
obj3.age=38
obj3.sex='female'

# print(obj1.__dict__)
# print(obj2.__dict__)
# print(obj3.__dict__)
# print(People.__dict__)





#方式二、为对象初始化自己独有的特征
class People:
    country='China'
    x=1
    def run(self):
        print('----->', self)

# 实例化出三个空对象
obj1=People()
obj2=People()
obj3=People()

# 为对象定制自己独有的特征
def chu_shi_hua(obj, x, y, z): #obj=obj1,x='zls',y=18,z='male'
    obj.name = x
    obj.age = y
    obj.sex = z

chu_shi_hua(obj1,'zls',18,'male')
chu_shi_hua(obj2,'lxx',38,'female')
chu_shi_hua(obj3,'alex',38,'female')





#方式三、为对象初始化自己独有的特征
class People:
    country='China'
    x=1

    def chu_shi_hua(obj, x, y, z): #obj=obj1,x='zls',y=18,z='male'
        obj.name = x
        obj.age = y
        obj.sex = z

    def run(self):
        print('----->', self)


obj1=People()
# print(People.chu_shi_hua)
People.chu_shi_hua(obj1,'zls',18,'male')

obj2=People()
People.chu_shi_hua(obj2,'lxx',38,'female')

obj3=People()
People.chu_shi_hua(obj3,'alex',38,'female')




# 方式四、为对象初始化自己独有的特征
class People:
    country='China'
    x=1

    def __init__(obj, x, y, z): #obj=obj1,x='zls',y=18,z='male'
        obj.name = x
        obj.age = y
        obj.sex = z

    def run(self):
        print('----->', self)

obj1=People('zls',18,'male') #People.__init__(obj1,'zls',18,'male')
obj2=People('lxx',38,'female') #People.__init__(obj2,'lxx',38,'female')
obj3=People('alex',38,'female') #People.__init__(obj3,'alex',38,'female')


# __init__方法
# 强调：
#   1、该方法内可以有任意的python代码
#   2、一定不能有返回值
class People:
    country='China'
    x=1

    def __init__(obj, name, age, sex): #obj=obj1,x='zls',y=18,z='male'
        # if type(name) is not str:
        #     raise TypeError('名字必须是字符串类型')
        obj.name = name
        obj.age = age
        obj.sex = sex


    def run(self):
        print('----->', self)


# obj1=People('zls',18,'male')
obj1=People(3537,18,'male')

# print(obj1.run)
# obj1.run() #People.run(obj1)
# print(People.run)

#类的数据属性是所有对象共享的,id都一样
print(id(OldboyStudent.school))

print(id(s1.school))
print(id(s2.school))
print(id(s3.school))

'''
4377347328
4377347328
4377347328
4377347328
'''



#类的函数属性是绑定给对象使用的,obj.method称为绑定方法,内存地址都不一样
#ps:id是python的实现机制,并不能真实反映内存地址,如果有内存地址,还是以内存地址为准
print(OldboyStudent.learn)
print(s1.learn)
print(s2.learn)
print(s3.learn)
'''
<function OldboyStudent.learn at 0x1021329d8>
<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x1021466d8>>
<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146710>>
<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146748>>
'''

xxx=33333
class OldboyStudent:
    school = 'oldboy'
    # xxx=2222
    yyy=333
    count=0

    def __init__(obj, name, age, sex):
        # print(OldboyStudent.yyy)
        # print(obj.yyy)

        OldboyStudent.count+=1
        obj.name = name #stu1.name='李铁蛋'
        obj.age = age   #stu1.age=18
        obj.sex = sex   #stu1.sex='male'

    def choose_course(self):
        print('choosing course')

# 1. 属性查找顺序
# stu1=OldboyStudent('李铁蛋',18,'male')
# print(stu1.__dict__)
# print(OldboyStudent.__dict__)
# stu1.xxx=111
# print(stu1.__dict__)
# 先从对象自己的名称空间找,没有则去所属的类中找
# print(stu1.xxx)

# 2.类中的变量共享
stu1=OldboyStudent('李铁蛋',18,'male')
stu2=OldboyStudent('赵钢弹',38,'female')
stu3=OldboyStudent('刘银弹',28,'male')
print(stu1.count)
print(stu2.count)
print(stu3.count)
print(OldboyStudent.count)

# 类中定义的变量是所有对象共享的,对象可以来用,类也可以来使用,类一旦改变自己的数据属性的值,所有的对象都能感知到
print(id(stu1.school))
print(id(stu2.school))
print(id(stu3.school))
print(id(OldboyStudent.school))

stu1.school=123
# OldboyStudent.school='OLDBOY'
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
print(OldboyStudent.__dict__)

print(OldboyStudent.school)
print(stu1.school)
print(stu2.school)
print(stu3.school)




print(id(stu1.choose_course))
print(id(stu2.choose_course))
print(id(stu3.choose_course))

#类中定义的变量是类的数据属性,类可以用,对象也可以用,大家都指向同一个内存地址,类变量值一旦改变所有对象都跟着变

#类中定义的函数是类的函数属性,类可以用,类来调用就是一个普通的函数,但其实类中定义的函数是给对象用的,而且是绑定给对象用的
# 绑定???
class OldboyStudent:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name #stu1.name='李铁蛋'
        self.age = age   #stu1.age=18
        self.sex = sex   #stu1.sex='male'

    def choose_course(self,x): #self=stu1
        print('%s choosing course' %self.name)



stu1=OldboyStudent('李铁蛋',18,'male')
stu2=OldboyStudent('赵钢弹',38,'female')
stu3=OldboyStudent('刘银弹',28,'male')

# 1. 类的函数: 该传几个参数就传几个
# print(OldboyStudent.__init__)
# print(OldboyStudent.choose_course)
# OldboyStudent.choose_course(stu1)

# 2. 绑定方法,指向类的函数: 特殊之处是绑定给谁就应该由谁来调用,谁来调用就会将谁当做第一个参数自动传入
# print(stu1.choose_course)
# print(stu2.choose_course)
# print(stu3.choose_course)

# stu1.choose_course(123) #OldboyStudent.choose_course(stu1,123)
# stu2.choose_course(123)
# stu3.choose_course(123)


stu1.choose_course()

#类型dict就是类dict
>>> list
<class 'list'>

#实例化的到3个对象l1,l2,l3
>>> l1=list()
>>> l2=list()
>>> l3=list()

#三个对象都有绑定方法append,是相同的功能,但内存地址不同
>>> l1.append
<built-in method append of list object at 0x10b482b48>
>>> l2.append
<built-in method append of list object at 0x10b482b88>
>>> l3.append
<built-in method append of list object at 0x10b482bc8>

#操作绑定方法l1.append(3),就是在往l1添加3,绝对不会将3添加到l2或l3
>>> l1.append(3)
>>> l1
[3]
>>> l2
[]
>>> l3
[]
#调用类list.append(l3,111)等同于l3.append(111)
>>> list.append(l3,111) #l3.append(111)
>>> l3
[111]

----------------

class Foo:
    pass

# print(Foo)
# obj=Foo()
# print(type(obj))

# print(int)
# age=10 #age=int(10)
# print(type(age))

# print(dict)


l1=[1,2,3] #l1=list([1,2,3])
# print(type(l1))
# l1.append(4)
# print(l1)

l1.append(4) # list.append(l1,4)
print(l1)

l2=['a','b','c'] #l2=list(['a','b','c'])
l2.append('d')

class Garen:        #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄;
    camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;
    def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
        self.nickname=nickname  #为自己的盖伦起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
    def attack(self,enemy):   #普通攻击技能，enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。

class Riven:
    camp='Noxus'  #所有玩家的英雄(锐雯)的阵营都是Noxus;
    def __init__(self,nickname,aggressivity=54,life_value=414): #英雄的初始攻击力54;
        self.nickname=nickname  #为自己的锐雯起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
    def attack(self,enemy):   #普通攻击技能，enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。 

>>> g1=Garen('草丛伦')
>>> r1=Riven('锐雯雯')

>>> g1.life_value
455
>>> r1.attack(g1)
>>> g1.life_value
401

1.子类可以遗传/重用父类的属性
2.python中一个子类可以同时继承多个父类
3.在继承背景下去说,python中的类分为两种:新式类,经典类
    1)新式类: 但凡继承了object的类Foo,以及该类的子类...都是新式类
        在python3中一个类即便是没有显式地继承任何类,默认就会继承object
        即python3中所有的类都是新式类
    2)经典类:没有继承object的类,以及该类的子类...都是经典类
        在python2中才区分新式类与经典类,
        在python2中一个类如果没有显式地继承任何类,也不会继承object

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

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

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

class Parent2(object):
    pass


#单继承
class Sub1(Parent1):
    pass

#多继承
class Sub2(Parent1,Parent2):
    pass
    
## 查看基类
print(Parent1.__bases__)
print(Parent2.__bases__)
print(Sub1.__bases__)
print(Sub2.__bases__)

# 问题:
# 1 子类如何重用父类的属性
# 2 在继承背景下,属性查找的优先级
# 3 新式类与经典类在属性查找上的区别

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

　　猫可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：
 

#猫和狗有大量相同的内容
class 猫：

    def 喵喵叫(self):
        print '喵喵叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

class 狗：

    def 汪汪叫(self):
        print '喵喵叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something



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

　　动物：吃、喝、拉、撒

　　   猫：喵喵叫（猫继承动物的功能）

　　   狗：汪汪叫（狗继承动物的功能）

伪代码如下：
class 动物:

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
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 cry(self):
        print('喵喵叫')

class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed='狗'

    def cry(self):
        print('汪汪叫')


# ######### 执行 #########

c1 = Cat('小白家的小黑猫')
c1.eat()

c2 = Cat('小黑的小白猫')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

class Hero:
    def __init__(self,nickname,aggressivity,life_value):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value

    def move_forward(self):
        print('%s move forward' %self.nickname)

    def move_backward(self):
        print('%s move backward' %self.nickname)

    def move_left(self):
        print('%s move forward' %self.nickname)

    def move_right(self):
        print('%s move forward' %self.nickname)

    def attack(self,enemy):
        enemy.life_value-=self.aggressivity
class Garen(Hero):
    pass

class Riven(Hero):
    pass

g1=Garen('草丛伦',100,300)
r1=Riven('锐雯雯',57,200)

print(g1.life_value)
r1.attack(g1)
print(g1.life_value)

'''
运行结果
243
'''

class OldboyPeople:
    school = 'Oldboy'

    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyStudent(OldboyPeople):
    # def __init__(self, name, age, sex, score=0):
    #     self.name = name
    #     self.age = age
    #     self.sex = sex
    #     self.score = score

    def choose_course(self):
        print('%s choosing course' % self.name)

class OldboyTeacher(OldboyPeople):
    # def __init__(self,name,age,sex,level):
    #     self.name=name
    #     self.age=age
    #     self.sex=sex
    #     self.level=level

    def score(self,stu,num):
        stu.score=num


stu1=OldboyStudent('刘二蛋',38,'male')
print(stu1.__dict__)

tea1=OldboyTeacher('zls',18,'male')
print(tea1.__dict__)

## 上面虽然解决了代码冗余，但是学生类只有父类的特征，没有学生自己独有的特征，如何解决呢？

# 方式一：
# 指名道姓地引用某一个类中的函数
# 总结:
# 1. 与继承无关
# 2. 访问是类的函数,没有自动传值的效果
class OldboyPeople:
    school = 'Oldboy'

    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyStudent(OldboyPeople):
    def __init__(self, name, age, sex, score=0):
        OldboyPeople.__init__(self,name,age,sex)
        self.score = score

    def choose_course(self):
        print('%s choosing course' % self.name)

class OldboyTeacher(OldboyPeople):
    def __init__(self,name,age,sex,level):
        OldboyPeople.__init__(self,name,age,sex)
        self.level=level

    def score(self,stu,num):
        stu.score=num


stu1=OldboyStudent('刘二蛋',38,'male')
print(stu1.__dict__)

tea1=OldboyTeacher('egon',18,'male',10)
print(tea1.__dict__)

# 在单继承背景下属性的查找优先级:对象->对象的类->父类->父类.....
class Foo:
    # xxx=444
    pass
class Bar1(Foo):
    # xxx=333
    pass

class Bar2(Bar1):
    # xxx=222
    pass
obj=Bar2()
# obj.xxx=111

print(obj.xxx)

## 挖坑

class Foo:
    def f1(self):
        print('Foo.f1')

    def f2(self):
        print('Foo.f2')
        self.f1() #obj.f1()

class Bar(Foo):
    def f1(self):
        print('Bar.f1')

obj=Bar()
obj.f2()

## 结果是下面两个哪一个？

'''
Foo.f2
Foo.f1
'''

'''
Foo.f2
Bar.f1
'''

# 在多继承背景下属性的查找优先级:
# 如果一个子类继承多个分支(多个分支没有共同继承一个非object的类)
# 此时属性的查找优先级是:对象->对象的类->按照从左往右的顺序一个分支一个分支的找下去

# # 第四层:
class G:
    # x = 'G'
    pass

# 第三层
class E(G):
    # x = 'E'
    pass

class F:
    # x = 'F'
    pass

# 第二层
class B(E):
    # x = 'B'
    pass

class C(F):
    # x = 'C'
    pass

class D:
    # x = 'D'
    pass

# 第一层
class A(B, C, D):
    # x = 'A'
    pass

obj = A()
# obj.x = 111
print(obj.x)

#菱形继承问题:
# 新式类 : 广度优先查找,从左往右一个分支一个分支的查找,在最后一个分支才去查找顶级类
# 经典类 : 深度优先查找,从左往右一个分支一个分支的查找,在第一个分支就查找顶级类
# 第四层:
class G(object):
    # x = 'G'
    pass

# 第三层
class E(G):
    # x = 'E'
    pass

class F(G):
    # x = 'F'
    pass

# 第二层
class B(E):
    # x = 'B'
    pass

class C(F):
    # x = 'C'
    pass

class D(G):
    # x = 'D'
    pass

# 第一层
class A(B, C, D):
    # x = 'A'
    pass


obj=A()
# obj.x=111
print(obj.x)
#新式类(广度优先): obj->A->B->E->C-F->D->G->object
#经典类(深度优先): obj->A->B->E->G->C-F->D

# python专门为新式类内置了一个mro的方法,用来查看c3算法的计算结果,结果是??
print(A.mro())

>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

# 方式二:super()必须在类中用
# 在python2中:super(自己的类名,自己的对象)
# 在python3中:super()
# 调用该函数会得到一个特殊的对象,该对象专门用来访问父类中的属性,!!!完全参照mro列表!!!!
# 总结:
# 1. 严格依赖继承的mro列表
# 2. 访问是绑定方法,有自动传值的效果

class OldboyPeople:
    school = 'Oldboy'

    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyStudent(OldboyPeople):
    def __init__(self, name, age, sex, score=0):
        super(OldboyStudent,self).__init__(name,age,sex)
        self.score = score

    def choose_course(self):
        print('%s choosing course' % self.name)

class OldboyTeacher(OldboyPeople):
    def __init__(self,name,age,sex,level):
        super().__init__(name,age,sex)
        self.level=level

    def score(self,stu,num):
        stu.score=num


stu1=OldboyStudent('刘二蛋',38,'male')
print(stu1.__dict__)

tea1=OldboyTeacher('zls',18,'male',10)
print(tea1.__dict__)

## 举例

class A:
    def f1(self):
        print('A.f1')
        super().f2()

class B:
    def f2(self):
        print('B.f2')

class C(A,B):
    def f2(self):
        print('C.f2')

obj=C()
print(C.mro())
obj.f1()

'''
A.f1
'''

class Foo:
    pass

class Bar:
    pass

obj=Foo()
obj.attr=Bar()

# 用Foo的属性
obj.xxx
# 用Bar的属性
obj.attr.yyy

class Foo1:
    pass
class Foo2:
    pass
class Foo3:
    pass
class Bar:
    pass

obj_from_bar=Bar()

obj1=Foo1()
obj2=Foo2()
obj3=Foo3()

obj1.attr1=obj_from_bar
obj2.attr2=obj_from_bar
obj3.attr3=obj_from_bar

class OldboyPeople:
    school = 'Oldboy'

    def __init__(self,name,age,sex,):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyStudent(OldboyPeople):
    def __init__(self, name, age, sex,score=0):
        OldboyPeople.__init__(self,name,age,sex)
        self.score = score

    def choose_course(self):
        print('%s choosing course' % self.name)

class OldboyTeacher(OldboyPeople):
    def __init__(self,name,age,sex,level):
        OldboyPeople.__init__(self,name,age,sex)
        self.level=level

    def score(self,stu,num):
        stu.score=num

class Course:
    def __init__(self,c_name,c_price,c_period):
        self.c_name = c_name
        self.c_price = c_price
        self.c_period = c_period

    def tell_info(self):
        print('<课程名:%s 价钱:%s 周期:%s>' %(self.c_name,self.c_price,self.c_period))

# 创建课程对象
python=Course('python全栈开发',100,'5mons')
linux=Course('linux架构师',20000,'3mons')


stu1=OldboyStudent('刘二蛋',38,'male')
stu1.course=python
# print(stu1.__dict__)

stu1.course.tell_info()


tea1=OldboyTeacher('zls',18,'male',10)
tea1.course=python
# print(tea1.__dict__)
tea1.course.tell_info()

class OldboyPeople:
    school = 'Oldboy'

    def __init__(self,name,age,sex,):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyStudent(OldboyPeople):
    def __init__(self, name, age, sex,score=0):
        OldboyPeople.__init__(self,name,age,sex)
        self.score = score
        self.courses=[]

    def choose_course(self):
        print('%s choosing course' % self.name)

    def tell_all_course(self):
        print(('学生[%s]选修的课程如下' %self.name).center(50,'='))
        for obj in self.courses:
            obj.tell_info()
        print('='*60)

class OldboyTeacher(OldboyPeople):
    def __init__(self,name,age,sex,level):
        OldboyPeople.__init__(self,name,age,sex)
        self.level=level
        self.courses=[]

    def score(self,stu,num):
        stu.score=num

    def tell_all_course(self):
        print(('老师[%s]教授的课程如下' %self.name).center(50,'*'))
        for obj in self.courses:
            obj.tell_info()
        print('*'*70)

class Course:
    def __init__(self,c_name,c_price,c_period):
        self.c_name = c_name
        self.c_price = c_price
        self.c_period = c_period

    def tell_info(self):
        print('<课程名:%s 价钱:%s 周期:%s>' %(self.c_name,self.c_price,self.c_period))

# 创建课程对象
python=Course('python全栈开发',1900,'5mons')
linux=Course('linux架构师',900,'3mons')


stu1=OldboyStudent('刘二蛋',38,'male')
stu1.courses.append(python)
stu1.courses.append(linux)
# print(stu1.courses)
stu1.tell_all_course()


tea1=OldboyTeacher('zls',18,'male',10)
tea1.courses.append(zls)
# print(tea1.courses)
tea1.tell_all_course()

class Animal:
    def speak(self):
        pass

class People(Animal):
    def shuo(self):
        print('say hello')

class Dog(Animal):
    def jiao(self):
        print('汪汪汪')

class Pig(Animal):
    def chang(self):
        print('哼哼哼')
        
        
        
obj1=People()
obj2=Dog()
obj3=Pig()


# obj1.speak()
# obj2.speak()
# obj3.speak()

def speak(animal):
    animal.speak()


speak(obj1)
speak(obj2)
speak(obj3)

s1='hello'
l1=[1,2,3]
t1=(1,2)

# changdu(s1)
# size(l1)
# kuandu(t1)


print(len(s1)) #s1.__len__()
print(len(l1)) #l1.__len__()
print(len(t1)) #t1.__len__()

import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def speak(self):
        pass

    @abc.abstractmethod
    def run(self):
        pass

# Animal() # 父类只是用来建立规范的,不能用来实例化的,更无需实现内部的方法

class People(Animal):
    def speak(self):
        print('say hello')

    def run(self):
        pass

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

    def run(self):
        pass

class Pig(Animal):
    def speak(self):
        print('哼哼哼')

    def run(self):
        pass

obj1=People()
obj2=Dog()
obj3=Pig()


# python崇尚鸭子类型
class Disk:
    def read(self):
        print('Disk read')

    def write(self):
        print('Disk write')


class Memory:
    def read(self):
        print('Mem read')

    def write(self):
        print('Mem write')


class Cpu:
    def read(self):
        print('Cpu read')

    def write(self):
        print('Cpu write')


obj1=Disk()
obj2=Memory()
obj3=Cpu()

obj1.read()
obj2.read()
obj3.read()

peo=People()
dog=Dog()
pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

>>> class Cat(Animal): #属于动物的另外一种形态：猫
...     def talk(self):
...         print('say miao')
... 
>>> def func(animal): #对于使用者来说，自己的代码根本无需改动
...     animal.talk()
... 
>>> cat1=Cat() #实例出一只猫
>>> func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
say miao

'''
这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)
'''

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))

#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()

len(s)
len(l)
len(t)

class Foo:
    __x=111 # _Foo__x
    __y=222 # _Foo__y

    def __init__(self,name,age):
        self.__name=name
        self.__age=age

    def __func(self): #_Foo__func
        print('func')

    def get_info(self):
        print(self.__name,self.__age,self.__x)#print(self._Foo__name,self._Foo__age,self._Foo__x)



----- 封装

print(Foo.__x)
print(Foo.__func)
print(Foo.__dict__)
print(Foo._Foo__x)
print(Foo._Foo__y)
Foo.__z=333
print(Foo.__dict__)
print(Foo.__z)


obj=Foo('zls',18)
print(obj.__dict__)
print(obj.__name)
print(obj.__age)
obj.get_info()

obj.__sex='male'
print(obj.__dict__)
print(obj.__sex)


obj.get_info()
# 1. __开头的属性到底如何实现的隐藏?
# 2. 如何实现的对外隐藏,对内不隐藏

在类内定义的属性前加__开头(没有__结尾)
总结:
1.__开头的属性实现的隐藏仅仅只是一种语法意义上的变形,并不会真的限制类外部的访问
2. 该变形操作只在类定义阶段检测语法时发生一次,类定义阶段之后新增的__开头的属性并不会变形
3. 如果父类不想让子类覆盖自己的属性,可以在属性前加__开头

class Foo:
    def __f1(self): #_Foo__f1
        print('Foo.f1')

    def f2(self):
        print('Foo.f2')
        self.__f1() #obj._Foo__f1()

class Bar(Foo):
    def __f1(self): # _Bar__f1
        print('Bar.f1')


obj=Bar()

# obj.f2()
'''
Foo.f2
Bar.f1
'''

class People:
    def __init__(self,name,age):
        self.__name=name
        self.__age=age

    def tell_info(self):
        print('<name:%s age:%s>'  %(self.__name,self.__age))

    def set_info(self,name,age):
        if type(name) is not str:
            print('名字必须是str类型傻叉')
            return
        if type(age) is not int:
            print('年龄必须是int类型傻叉')
            return
        self.__name=name
        self.__age=age


obj=People('zls',18)
# obj.tell_info()

# obj.set_info('zls',19)
# obj.set_info(123,19)
obj.set_info('zls','18')
obj.tell_info()

# 封装函数属性:隔离复杂度
class ATM:
    def __card(self):
        print('插卡')
    def __auth(self):
        print('用户认证')
    def __input(self):
        print('输入取款金额')
    def __print_bill(self):
        print('打印账单')
    def __take_money(self):
        print('取款')

    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()

a=ATM()
a.withdraw()

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    def bmi(self):
        return self.weight / (self.height**2)

obj=People('zls',60,1.85)
obj.height=1.88
obj.weight=55

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height

    @property
    def bmi(self):
        return self.weight / (self.height**2)

obj=People('zls',60,1.85)
obj.height=1.88
obj.weight=55

class People:
    def __init__(self,name):
        self.__name=name

    @property
    def name(self):
        return '<名字:%s>' %self.__name

    @name.setter
    def name(self,obj):
        if type(obj) is not str:
            print('name必须为str类型')
            return
        self.__name=obj

    @name.deleter
    def name(self):
        # print('不让删')
        del self.__name

obj=People('zls')

print(obj.name)
obj.name='ZLS'
obj.name=123
print(obj.name)

del obj.name
print(obj.__dict__)

## 古老写法
class People:
    def __init__(self,name):
        self.__name=name

    def get_name(self):
        return '<名字:%s>' %self.__name

    def set_name(self,obj):
        if type(obj) is not str:
            print('name必须为str类型')
            return
        self.__name=obj

    def del_name(self):
        # print('不让删')
        del self.__name

    name=property(get_name,set_name,del_name)

obj=People('zls')

print(obj.name)
obj.name='ZLS'
obj.name=123
print(obj.name)

del obj.name
print(obj.__dict__)

class Foo:
    def f1(self):
        print(self)

    @classmethod
    def f2(cls):
        print(cls)


obj=Foo()
print(obj.f1)
obj.f1()

print(Foo.f2)
Foo.f2()
print(obj.f2)
obj.f2()

class Foo:
    def f1(self):
        print(self)

    @classmethod
    def f2(cls):
        print(cls)

    @staticmethod
    def f3(x,y):
        print('f3',x+y)


obj=Foo()

print(Foo.f3)
print(obj.f3)

Foo.f3(1,2)
obj.f3(3,4)

class MySql:
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    def tell_info(self):
        print('<id:%s ip:%s port:%s>' % (self.id, self.ip, self.port))


obj1=MySql('1.1.1.1',3306)
obj1.tell_info()

## 上面的方法做起来 很麻烦，我们还得往里面传递一个IP和端口

# 我们通过配置文件的方法，来设置MySQL的端口和IP

# settings.py 内容
IP='192.168.101.100'
PORT=3306

## 从settings中取出变量
import settings

class MySql:
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    def tell_info(self):
        print('<id:%s ip:%s port:%s>' % (self.id, self.ip, self.port))

    @classmethod
    def from_conf(cls):
        return cls(settings.IP, settings.PORT)

obj2=MySql(settings.IP,settings.PORT)

## 但是 这个方法还是不简单，我每次都要记住settings.IP,settings.PORT
# 更简单的方法

obj2 = MySql.from_conf()
obj2.tell_info()

## 现在给每一个对象加一个独一无二的id
import settings

class MySql:
    def __init__(self, ip, port):
        self.id = self.create_id()
        self.ip = ip
        self.port = port

    def tell_info(self):
        print('<id:%s ip:%s port:%s>' % (self.id, self.ip, self.port))

    @classmethod
    def from_conf(cls):
        return cls(settings.IP, settings.PORT)

    @staticmethod
    def create_id():
        import uuid
        return uuid.uuid4()

obj2 = MySql.from_conf()
obj2.tell_info()