#面向对象设计，例1：

def dog(name,gender,type):    # 狗的动作    def jiao(dog):        print('一条狗[%s]，汪汪汪' % dog['name'])    def chi_shi(dog):        print('一条[%s] 正在吃屎' % dog['type'])    dog1 = {        'name':name,        'gender': gender,        'type': type,        'jiao':jiao,        'chi_shi':chi_shi,    }    return dog1d1=dog('元昊','母','中华田园犬')d2=dog('alex','母','藏敖')print(d1)print(d2)d1['jiao'](d1)d2['chi_shi'](d2)jiao(dog1)        chi_shi(dog1)chi_shi(dog2)jiao(person1)    #人本来不应该能调用狗方法的#面向对象设计：类，对象#将所有整合封装起来，利用函数的局部作用域，使得人不能调用了def dog(name,gender,type):    # 狗的动作    def jiao(dog):        print('一条狗[%s]，汪汪汪' % dog['name'])    def chi_shi(dog):        print('一条[%s] 正在吃屎' % dog['type'])    def init(name,gender,type):    #初始化函数：再用一个函数将狗属性封装起来。使得整个程序清晰明了        dog1 = {            'name':name,            'gender': gender,            'type': type,            'jiao':jiao,            'chi_shi':chi_shi,        }        return dog1    #dog1当中不能写死，狗的信息应该要允许从外部能够传入    return init(name,gender,type)d1=dog('元昊','母','中华田园犬')d2=dog('alex','母','藏敖')print(d1)        #打印出调用dog函数之后的dog1字典中的值（包含d1的特征和d1的动作）#['type':'中华田园犬','name':'元昊','jiao':
      
       .jiao at 0x0000000000B101E0>,'gender':'母','chi_shi':
       
        .chi_shi at 0x0000000000B10378>]print(d2)# 在整个大的dog函数中利用一个dog字典，将内嵌的函数整合在一起d1['jiao'](d1)           #d1专门直接调用其动作d2['chi_shi'](d2)
       
      

#面向对象设计方法一：#利用一个大函数将对象及其方法特征封装起来实现##例2：学校类（与例1是一个原理）def school(name,addr,type):    def init(name, addr, type):         #只要不执行init，当中的kao_shi,zhao_sheng有没有在此函数之前定义都没有影响    #或者说，只要在调用init执行的时候，init内所有函数在执行语句之前都有定义过（已经加载完）就没问题        sch = {            'name': name,            'addr': addr,            'type': type,            'kao_shi': kao_shi,            'zhao_sheng': zhao_sheng,        }        return sch         def kao_shi(school):        print('%s 学校正在考试' %school['name'])    def zhao_sheng(school):        print('%s %s 正在招生' %(school['type'],school['name']))    return  init(name,addr,type)         #只需利用返回值来调用init函数，才能触发初始化函数的调用，否则school啥都没做#对象1： s1=school('oldboy','沙河','私立学校')print(s1)print(s1['name'])   #oldboys1['zhao_sheng'](s1)   #一定要传参数（字典s1）#对象2：s2=school('清华','北京','公立学校')print(s2)print(s2['name'],s2['addr'],s2['type'])s2['zhao_sheng'](s2)

#面向对象设计的第二种方法：#用面向对象编程独有的语法class去实现面向对象设计#利用class只不过更加方便地实现了面向对象设计，但其实单纯用一个大函数也实现了面向对象设计class Dog:      #类：不必在后面再return一个函数了    def __init__(self,name,gender,type):    #最终返回一个字典结构        self.name=name        self.gender=gender        self.type=type    def bark(self):        print('一条名字为[%s]的[%s],狂吠不止' %(self.name,self.type))    def yao_ren(self):        print('[%s]正在咬人' %(self.name))    def chi_shi(self):        print('[%s]正在吃屎' %(self.type))dog1=Dog('alex','female','京巴')   #执行函数print(dog1.__dict__)   #内置特征（看内置字典）# {'name':'alex','type':'京巴','gender':'female'}# dog2=Dog('wupeiqi','female','腊肠')# dog3=Dog('yuanhao','female','藏獒')## dog1.bark()# dog2.yao_ren()# dog3.chi_shi()

def functionName(args):    '函数文档字符串'    函数体

'''class 类名:                 #规范：类名首字母大写    '类的文档字符串'        类体'''#我们创建一个类class Chinese:     '这是一个中国人的类'     passprint(Chinese)      #
      
         #运行该文件，文件名默认为__main__，类名Chinese#这与函数一样#实例化出一个对象p1=Chinese()        #类的运行进行实例化，函数的运行执行一段逻辑print(p1)
      

#在Python2中：#经典类：class 类名：    pass#新式类：class 类名(父类):    pass#在python3中这两种都是新式类

class Chinese:    '这是一个中国人的类'    dang='党'    def sui_di_tu_tan():    #可以不传参数        print('朝着墙上就是一口痰')    def cha_dui(self):        print('插到了前面')print(Chinese.dang)  　　　#党  #本质上就是去自己的属性字典中寻找函数名Chinese.sui_di_tu_tan()   #类名Chinese直接调用函数Chinese.cha_dui('元昊')

# print(dir(Chinese))     #系统内置的（——形式——）加上自定义的函数名# print(Chinese.__dict__) #查看属性字典（内置的）函数和相应的属性及内存地址print(Chinese.__dict__['dang'])　　　　    #党   #等价于Chinese.dangprint(Chinese.__dict__['sui_di_tu_tan'])  #输出该函数内存地址,因此用这个函数地址直接加括号就能调用了Chinese.__dict__['sui_di_tu_tan']()      #调用函数  Chinese.__dict__['cha_dui'](1)           #朝着墙上就是一口痰

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

#实例化：实质触发初始化函数的运行#对比函数式的，只要一触发函数，就能触发初始化函数（return init()）#在类中，只要有定义init函数，就会直接将参数全部传入类的init中#init函数中不需要加任何的return#对象只包含数据属性结构，没有函数属性#实例属性能访问到类属性（如果在自己对象属性中没找到，就会去类属性中去找）##类：class Chinese:    '这是一个中国人的类'    dang='党'    #函数中：    # def __init__(name,age,gender):    #     dic={
         #         'name':name,    #         'age':age,    #         'gender':gender    #     }    #     return dic    #在class类中    def __init__(self,name,age,gender):    #self相当于实例本身，一个字典。        print('我是初始化函数，我开始运行了')        self.mingzi=name  #p1.mingzi=name        self.nianji=age   #p1.nianji=age        self.xingbie=gender        print('我结束啦')    #不用写return    def sui_di_tu_tan(self):        print('%s 朝着墙上就是一口痰' %self.mingzi)    def cha_dui(self):        print(self)        print('%s 插到了前面' %self.mingzi)    def eat_food(self,food):        print('%s 正在吃%s' %(self.mingzi,food))#实例的生成p1=Chinese('元昊',18,'female') #--->__init__(self,name,age,gender)#如果不用class用函数实现时，最外层的chinese函数还需要写需要传入的形参表#而class中，会把你传入的实参值直接交给内置的_init_函数# p1=Chinese.__init__(p1,name,age,gender)print(p1.__dict__)     #实例也有一个内置的_dict_函数，也能打印出一个函数# {'xingbie':'female','nianji':18,'mingzi':'元昊'}p1.sui_di_tu_tan()p1.eat_food('苹果')p2=Chinese('武sir',10000,'姑娘')p2.eat_food('韭菜馅饼')print(dir(p2))    #输出属性名# print(p1.__dict__['xingbie'])print(p1.mingzi)   #在dict中去找# print(p1.mingzi111111111111111)print(p1.dang)   #Chinese当中虽然没有，但是init中产生的函数# 类自己调用print(Chinese.__dict__)Chinese.sui_di_tu_tan()Chinese.cha_dui(p1)# p1.sui_di_tu_tan()   #能够成功找到这个函数，但是还报错。因为python会帮你直接把p1传给函数的第一个参数selfprint('[------------------->')p1.cha_dui()    #p1本身直接传给cha_dui()函数的第一个self参量

#类属性又称为静态变量，或者静态属性，#这些数据是与他们所属类对象绑定的，不依赖于任何实例。#在C++和Java当中，静态数据的变量声明前加static关键字class Chinese:               #首字母大写两个单词分别首字母大写，如：ChinesePeople    country='China'    def __init__(self,name):        self.name=name    def play_ball(self,ball):    #动词_名词        print('%s 正在打 %s' %(self.name))#查看print(Chinese.country)    #China#修改Chinese.country='Japan'print(Chinese.country)    #Japanp1=Chinese('alex')print(p1.__dict__)    #可以发现p1自己的字典中没有countryprint(p1.country)      #Japan    #自己没有，去类中找修改过的country值#增加Chinese.dang='党'    #本质就是操作字典# 类和实例都能找到print(Chinese.dang)   #党print(p1.dang)          #党#删除del Chinese.dangdel Chinese.countryprint(Chinese.__dict__)    #字典中没有dang和country了# print(Chinese.country)    #会报错，因为没有country了#新增一个函数# 定义一个新的函数，在跟类一个级别上，在最外面def eat_food(self,food):    print('%s 正在吃%s' %(self.name,food))# 将此顶级函数传给类当中Chinese.eat=eat_foodprint(Chinese.__dict__)   #查看到新增的成功了p1.eat('苹果')            #可以成功调用# 修改类中的函数def test(self):    print('test')Chinese.play_ball=testp1.play_ball()    #括号内可以不写，实例调用，默认直接把实例传入# Chinese.play_ball(p1)类调用不会自动传参数，需要在括号内手动将对象p1传入

class Chinese:    country='China'    def __init__(self,name):        self.name=name    def play_ball(self,ball):        print('%s 正在打 %s' %(self.name,ball))p1=Chinese('alex')print(p1.__dict__)   #{'name':'alex'}#查看print(p1.name)        #访问实例的数据属性print(p1.play_ball)    #访问类的函数属性# 不是自己的，而是一个bound method绑定在类Chinese上的方法# 此时不要给play_ball后面加括号传参数，否则就运行了#增加p1.age=18print(p1.__dict__)   #增加数据属性 # {'age':'18','name':'alex'}print(p1.age)''''''''''''# 一般都不会采用如下方法，一般往类当中添加函数方法#仅在实例中加入函数的话，违背了建立类的初衷，减少代码重用#实例没有函数属性，但是可以访问类的函数属性#所以，实例可以增加数据属性，但是不能直接增加类的函数属性#其实可以给实例用和（类增加函数属性一样方法）增加函数属性#但运行时，由于是调用实例自己的函数，此时不会自动传入#只有实例调用类的函数时，才会自动将实例传入函数当中def test(self):    print('我是来自实例的函数属性',self)p1.test=testprint(p1.__dict__)  #{'age':'18','name':'alex','test':
      
       }p1.test(p1)         #我是来自实例的函数属性    p1.test('hcjjd')    #可以随意传参数（就是一个普通函数）''''''''''''''''''''''''#不要用如下方式修改底层的属性字典# p1.__dict__['sex']='male'     # print(p1.__dict__)       #能够成功加入，也能成功调用# print(p1.sex)#修改p1.age=19print(p1.__dict__)print(p1.age)#删除del p1.ageprint(p1.__dict__)
      

# 定义一个类，只把它当做一个作用域去使用# 此时类似于C语言中的结构体class MyData:    passx=10y=20MyData.x=1   #专门给类加数据属性，相当于局部作用域中加一个，与全局作用域自然地隔开了MyData.y=2print(x,y)print(MyData.x,MyData.y)print(MyData.x+MyData.y)

#关于作用域的几个例子： # 例1：class Chinese:    country='China'    def __init__(self,name):        self.name=name    def play_ball(self,ball):        print('%s 正在打 %s' %(self.name,ball))p1=Chinese('alex')print(p1.country)    #此时p1还没有country，调用的是Chinese类当中的Chinap1.country='日本'print('类的--->',Chinese.country)     #China    #p1改的是自己的country，动不了类的print('实例的',p1.country)            #日本      #p1自己的country被改（创建）为日本# 例2：country='中国'class Chinese:    def __init__(self,name):        self.name=name    def play_ball(self,ball):        print('%s 正在打 %s' %(self.name,ball))p1=Chinese('alex')# print(p1.country)    #报错#点访问只在自己实例中和类中找，不会找到全局的country'''''''''''''''''''#例3：如下方法很初级，特定函数一定要写特定的功能#init函数本来的就是用于初始化字典结构的，在里面又加入input，这样缺点：#一是函数代码可读性差，二是输入输出和逻辑耦合到一起了country='中国'class Chinese:    def __init__(self):        print('---------->?')        name=input('请输入用户名>>:')    #在init中可以写input,init就不用传参数了        self.name=name    def play_ball(self,ball):        print('%s 正在打 %s' %(self.name,ball))p1=Chinese()print(p1.name)''''''''''''''''''''# 将例3修改为如下：将输入输出和初始化函数分离开country='中国'class Chinese:    def __init__(self,name):        self.name=name    def play_ball(self,ball):        print('%s 正在打 %s' %(self.name,ball))def shi_li_hua():    name=input('>>: ')    p1=Chinese(name)    # print(p1.country)    print(p1.name)shi_li_hua()       #函数当中利用input来实现动态传参数#例4：country='中国1'class Chinese:    country='中国2'    def __init__(self,name):        self.name=name        print('--->',country)     #中国1        #现在不是用点访问，找到的是全局的country    def play_ball(self,ball):        print('%s 正在打 %s' %(self.name,ball))print(Chinese.__dict__)   #查到的country对应的是’中国2‘print(Chinese.country)    #中国2只能通过点来访问，既可以实例调用，也可以类调用p1=Chinese('alex')        #自动触发init函数，输出的是中国1print('实例--------》',p1.country)   #实例来调用中国2# Chinese.# p.

class Chinese:    country='China'    l=['a','b']    def __init__(self,name):        self.name=name    def play_ball(self,ball):        print('%s 正在打 %s' %(self.name,ball))p1=Chinese('alex')print(p1.l)            #p1没有l，则调用类中的#改法1：p1.l.append('c')       # p1依旧没有l，这种方法会给类中的l增加一个print(p1.__dict__)     #['name':'alex']print(Chinese.l)       # ['a','b','c']# 改法2：要给实例增加数据属性，只能通过赋值表达式实现# p1.l=[1,2,3]         #改p1自己的，p1中有一个新的l# print(Chinese.l)     # ['a','b']# print(p1.__dict__)   #['l':[1,2,3],'name':'alex']

#很low的解决关联的方法：利用appendclass School:    def __init__(self,name,addr):        self.name=name        self.addr=addr        self.course_list=[]    def zhao_sheng(self):        print('%s 正在招生' %self.name)class Course:    def __init__(self,name,price,period):        self.name=name        self.price=price        self.period=periods1=School('oldboy','北京')s2=School('oldboy','南京')s3=School('oldboy','东京')c1=Course('linux',10,'1h')c2=Course('python',10,'1h')s1.course_list.append(c1)s1.course_list.append(c2)print(s1.__dict__)   #成功加入了两门课程到列表course_list中for course_obj in s1.course_list:    print(course_obj.name,course_obj.price)

# 例1：定义一个人的类，人包含头、躯干、手、脚等数据属性。class Hand:    passclass Foot:    passclass Trunk:    passclass Head:    passclass Person:    def __init__(self,id_num,name):        self.id_num=id_num        self.name=name        self.hand=Hand()     #就是创建对象，等价于类名加括号        self.foot=Foot()        self.trunk=Trunk()        self.head=Head()p1=Person('111111','alex')# print(p1.__dict__)# 例2：将一个类的实例传入另外一个实例class School:    def __init__(self,name,addr):        self.name=name        self.addr=addr    def zhao_sheng(self):        print('%s 正在招生' %self.name)class Course:    def __init__(self,name,price,period,school):        self.name=name        self.price=price        self.period=period        self.school=schools1=School('oldboy','北京')s2=School('oldboy','南京')s3=School('oldboy','东京')# c1=Course('linux',10,'1h','oldboy 北京') #这么写与s1没关系c1=Course('linux',10,'1h',s1)   #把school创建的实例传入，就是传对象进来print(c1.__dict__)   #c1的school参量指向s1内存地址#{'period':'1h','price':10,'school':<_main_.School object at ox0000000000B2C208>,'name':'linux'}print(c1.school.name)   #两个点来访问print(s1)   #等价于print(c1.school)# 例3：选课系统# 为了让用户有选择，手动输入参数值class School:    def __init__(self,name,addr):        self.name=name        self.addr=addr    def zhao_sheng(self):        print('%s 正在招生' %self.name)class Course:    def __init__(self,name,price,period,school):        self.name=name        self.price=price        self.period=period        self.school=schools1=School('oldboy','北京')s2=School('oldboy','南京')s3=School('oldboy','东京')# c1=Course('linux',10,'1h','oldboy 北京')# c1=Course('linux',10,'1h',s1)msg='''1 老男孩 北京校区2 老男孩 南京校区3 老男孩 东京校区'''while True:    print(msg)    menu={        '1':s1,        '2':s2,        '3':s3    }    choice=input('选择学校>>: ')    school_obj=menu[choice]    name=input('课程名>>： ')    price=input('课程费用>>： ')    period=input('课程周期>>： ')    new_course=Course(name,price,period,school_obj)    print('课程【%s】属于【%s】学校' %(new_course.name,new_course.school.name))

#在现实世界中，站在老男孩学校的角度：先有对象，再有类对象1：李坦克    特征:        学校=oldboy        姓名=李坦克        性别=男        年龄=18    技能：        学习        吃饭        睡觉对象2：王大炮    特征:        学校=oldboy        姓名=王大炮        性别=女        年龄=38    技能：        学习        吃饭        睡觉对象3：牛榴弹    特征:        学校=oldboy        姓名=牛榴弹        性别=男        年龄=78    技能：        学习        吃饭        睡觉现实中的老男孩学生类    相似的特征:        学校=oldboy    相似的技能：        学习        吃饭        睡觉在现实世界中：先有对象，再有类

#改写class OldboyStudent:    school='oldboy'    def __init__(self,name,age,sex):        self.name=name        self.age=age        self.sex=sex    def learn(self):        print('%s is learning' %self.name) #新增self.name    def eat(self):        print('%s is eating' %self.name)    def sleep(self):        print('%s is sleeping' %self.name)s1=OldboyStudent('李坦克','男',18)s2=OldboyStudent('王大炮','女',38)s3=OldboyStudent('牛榴弹','男',78)

OldboyStudent.learn(s1) #李坦克 is learningOldboyStudent.learn(s2) #王大炮 is learningOldboyStudent.learn(s3) #牛榴弹 is learning

s1.learn() #等同于OldboyStudent.learn(s1)s2.learn() #等同于OldboyStudent.learn(s2)s3.learn() #等同于OldboyStudent.learn(s3)

#类型dict就是类dict>>> list
      
       #实例化的到3个对象l1,l2,l3>>> l1=list()>>> l2=list()>>> l3=list()#三个对象都有绑定方法append,是相同的功能,但内存地址不同>>> l1.append
       
        >>> l2.append
        
         >>> l3.append
         
          #操作绑定方法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 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_value455>>> r1.attack(g1)>>> g1.life_value401