python27期day19：面向对象

一、class GirlFriend(object):    #定义女友类：    eyes = 2    #类属性(静态属性),是属于当前类的    #当前类的全部对象,所共有的特征    sex = "女"    """    说明    """    #初始化方法    def __init__(self,name,age,height,weight):        #实例属性        self.name = "qwe"        self.age = age        self.height = height        self.weight = weight        #函数属性    def xiyifu(self):        #定义洗衣服功能：        print(self.name,"洗衣服")    def chuitu(self):        #定义捶腿功能：        print("捶腿")    def tiwolianji(self):        #定义替我联机功能：        print("打怪升级")二、#调用类属性,须要使用类名去调用(对象名也能够调用,可是不建议)# print(GirlFriend.name)三、#类名不能调用实例属性,也不要去调用实例方法print(GirlFriend.eyes)四、#能够在对象建立时,就让他拥有不一样的属性值girl_1 = GirlFriend("迪丽热巴",18,170,170)#经过对象调用类属性,没问题#可是不能修改print(girl_1.eyes)五、#若是经过对象去修改类属性,会建立一个新的实例属性,这个实例属性在对象中会覆盖掉类属性girl_1.eyes = 3GirlFriend.eyes = 3print("girl1的",girl_1.eyes)六、#实例属性的增长girl_1.money = 100七、#实例属性的删除del girl_1.name八、#实例属性的修改girl_1.age = 19九、#实例属性的查看print(girl_1.age)十、#修改某个对象的实例属性,对当前类的其余对象,没有任何影响#若是,在类中作了修改,全部对象都会发生改变girl_1.chuitu()girl_1.tiwolianji()# girl_1.name = "迪丽热巴"#在类的外部,给对象添加属性# girl_1.money = 100# print(girl_1.money)girl_2 = GirlFriend("baby",35,120,250)print(girl_2.name)print("girl2的",girl_2.eyes)十一、#定义天使：#光圈,翅膀,有眼睛,有腿等等,漂亮,善良,会飞,有法力,能打坏人,能救人,治疗#类是一个模板(里面放了一些属性和方法)#对象(也叫当前类的一个实例),是经过类建立出来的,用来完成具体工做十二、#设计程序的思路:#首先,根据需求,来设计类,这个过程被称为"抽象",从真实存在的事务当中,抽象出共同的属性和方法1三、# #类名,你们约定俗成,首字母大写# class Person:#     def __init__(self):#         #放属性#         self.name = "小明"#         self.age = 18#     #方法和属性,只关心完成当前工做所须要的#     def eat(self):#         #具体的工做(算法)#         print("人能够吃东西")# #self:哪一个对象调用了当前方法,self就表明谁#     def run(self):#         print(self.name)#         print("人会跑")## #建立对象(实例化)# 小明 = Person()# 小明.run()# print(小明.name,小明.age)1四、# class Hero:#     def __init__(self,name,HP,MP,ATK):#         self.name = name#         self.hp = HP#         self.mp = MP#         self.atk = ATK#     def jineng1(self):#         print("电光毒龙钻")#         self.hp -= 20##     def jineng2(self):#         print("摸鸡头下蛋")## alex = Hero("alex",100,200,250)# bigB = Hero("元宝",200,50,300)# alex.at = 123123123# del alex.jineng1# alex.jineng1()# if alex.hp <= 0:#     del alex# alex.atk = 20# print(alex.name)1五、# 建立一个英雄类：# • 包含英雄的各项属性：例如血量魔法值等等（注意哪些应该是类属性，哪些应该做# 为实例属性）# • 英雄有自残的能力，自残后会掉血# class Hero:#     def __init__(self,hp):#         self.hp = hp  #血量#         self.mp = 200 #魔法值#     def zican(self):#         print("我钻我本身")          #自身数量值减1#         self.hp -= 11六、# • 建立一个狗类：# • 包含名字，颜色，品种，年龄，性别等属性# • 有一个自我介绍的方法，打印自身的属性信息（我叫XXX。。。）# • 狗有看家的能力，狗有叫的能力，在看家方法中调用叫的方法# class Dog:    #定义狗类：    # def __init__(self,name,color,type,age,sex):    #实例化姓名、颜色、品种、年龄、性别    #     pass    # def ziwojieshao(self):    #     print("我叫",self.name,)#     def kanjia(self):        #类里面的方法相互调用：#         self.jiao()#     def jiao(self):#         print("汪~汪~")# douding = Dog()# douding.kanjia()1七、num = 0class Hero:    num = 0    def __init__(self):        self.name = "abc"        Hero.num += 1   #数量自加1    def run(self):        print("会跑")for i in range(10):    "循环调用10圈"    alex = Hero()bigB = Hero()a = Hero()print(Hero.num)1八、## 面向过程(函数式编程)经过数学逻辑去解决问题(设计算法,获得想要的结果)函数式编程:提升了代码的复用性,提升了维护性## 面向对象python中 万物皆对象面向过程,的程序,执行效率高面向对象,的开发效率高类:一类具备相同特征的事物的总称对象:经过类,建立的一个具体事务,用来完成工做基础数据结构(列表,元组...)是数据的封装,函数是算法的封装类:是抽象出来的,数据和算法都能封装,可维护性更高,能处理更复杂的问题,代码逻辑更清晰建立类和对象的格式过程描述:1,抽象2,经过抽象出的内容来设计类3,class 类名:​        属性​        def __init__(self):​              self.XXX = XXX​        方法​        函数定义同样4,建立对象:对象名 = 类名()5,调用对象的属性和方法使用万能的点.建立对象时:1,在内存中开辟一块空间2,自动调用init方法python27day18面向对象--------------------------------------------------------------------------------------------一、#方法和函数究竟有什么区别class Person:    def abc(self):        passa = Person()print(type(a.abc))print(type(Person.abc))#经过对象去调用时,是方法#其余状况,比方说经过类名调用,或者放在类外的时候叫函数二、#例一：class Baooy:    def __init__(self,name,girlFriend = None):        self.name = name        self.girlFriend = girlFriend    def eat(self):        if self.girlFriend:            print(f"{self.name}带着他的女友{self.girlFriend}去吃饭")        else:            print("单身狗，吃狗粮")    def movie(self):        if self.girlFriend:                                                     #加self确认的            print(f"{self.name}带着他的女友{self.girlFriend}去看电影")        #打印时必定加上self        else:            print("单身狗，回家看")a = Baooy("zs","zs1")a.eat()                     #对象调用函数属性：a.movie()三、# class Person:#     def __init__(self,name,age):#         self.name = name#         self.hp = 100#     def play(self,tool):#         print(self.name,"钻",tool.name)#         tool.hp -= 20#         print(tool.name,"还有",tool.hp,"点血")#     def kanjia(self,tool):#         tool.kanjia()# class Dog:#     def __init__(self,name,hp):#         self.name = name#         self.hp = hp#     def kanjia(self):#         print("汪~汪~~")## alex = Person("Alex",83)# bigB = Person("宝元",76)# alex.play(bigB)# xiaohei = Dog("小黑",20)# bigB.kanjia(xiaohei)四、#关联关系就是在一个类的方法当中,引入了另外一个对象(另外一个类的对象)# 定义一个英雄类和一个反派类# • 两个类都包含名字、血量，攻击力（ATK），和一个技能（skill）# • 两派对象互殴# • 血量为0死亡，删除对象（del 对象名）import randomclass Hero:    def __init__(self,name,hp,atk):        self.name = name        self.hp = hp        self.atk = atk    def skill(self,tool):           #tool = alex        print(self.name,"对",tool.name,"使出了波动拳") #name = 宝元，tool = alex        tool.hp -= self.atk * random.randint(1,5)/2class Boss:    def __init__(self,name,hp,atk):     #name = alex        self.name = name        self.hp = hp        self.atk = atk    def skill(self,tool):        print(self.name,"对",tool.name,"使出了独孤九剑")    #name = alex、tool = bigB、tool.name = bigB.name = 宝元        tool.hp -= self.atk * random.randint(1,5)/2bigB = Hero("宝元",200,15)alex = Boss("alex",150,20)while True:    bigB.skill(alex)    alex.skill(bigB)    if bigB.hp <= 0:        print("游戏结束")        del bigB                #删除Hero的实例        break    if alex.hp <= 0:        print("游戏结束")        del alex                #删除Boss的实例        break结果：  宝元 对 alex 使出了波动拳        alex 对 宝元 使出了独孤九剑        宝元 对 alex 使出了波动拳        alex 对 宝元 使出了独孤九剑        宝元 对 alex 使出了波动拳        alex 对 宝元 使出了独孤九剑        宝元 对 alex 使出了波动拳        alex 对 宝元 使出了独孤九剑        宝元 对 alex 使出了波动拳        alex 对 宝元 使出了独孤九剑        游戏结束五、# class Father(object):#     #在py3中,若是一个类,没有显式的继承任何一个类,那么他默认继承object#     # def __init__(self,name,age):#     #     self.name = name#     #     self.age = age#     def livelikeyemen(self):#         print("打妈妈")# class Son:#     def __init__(self,f):#         self.f = f#     def abc(self):#         self.f.livelikeyemen()#     #父类方法重写#     def livelikeyemen(self):#         print("打妹妹")# daming = Father()# xiaoming = Son(daming)# xiaoming.abc()六、# class Anm(object):#       """定义动物类"""#     def __init__(self,name,age):#       """实例化姓名和年龄"""#         self.name = name#         self.age = age#     def run(self):#       """定义跑的方法"""#         print("123")# class Dog(Anm):#       """定义狗类继承动物类"""#     #若是子类也有本身的初始化方法,可能会出错#     #解决方式,在子类的init方法里面,调用父类的init方法用super（）#     def __init__(self,name,age):#         self.xihuanshi = True#         super().__init__(name,age)#     def jump(self):#         print("跳")#     def run(self):#         print("abc")#         """调用动物类的跑方法"""#         Anm.run(self)#         """运行动物类的跑方法"""#         super().run()# class Cat(Dog):#       """定义猫类继承狗类"""#     def __init__(self):#       """调用狗类里面的init方法用super()"""#         super().__init__()#     def jiao(self):#         print("喵喵~~~")# a = Dog("动物",20)# a.run()七、class 蛇:    def __init__(self):        self.ya = 2    def panta(self):        print("pan")    def run(self):        print("123")class 蜘蛛:    def __init__(self):        eyes = 8        jiao = 8    def 吐丝(self):        print("cici")    def run(self):        print("456")class 人(蜘蛛,蛇):    pass    # def __init__(self, name,age):    #     self.name = name    #     self.age = age    #     super().__init__()xiaoming = 人()xiaoming.run()八、# 类之间的关系## 依赖关系：执行某个动做的时候，须要其余类的对象来帮助你完成这个动做            就是将一个类的对象或者类名放到另外一个类的方法当中就叫依赖            此时,类之间的关系是最轻的,由于随时能够更换其余对象九、class Person:    def play(self,tools):        tools.run()        print("我要打游戏了")class Compture:    def run(self):        print("电脑已经打开，DNF已登陆")class Phone:    def run(self):        print("王者荣耀已经登录")xiaoMing = Person()xmPhone = Phone()hwCom = Compture()xiaoMing.play(xmPhone)  #一个类的对象或者类名放到另外一个类的方法当中xiaoMing.play(hwCom)    #一个类的对象或者类名放到另外一个类的方法当中结果：  王者荣耀已经登录        我要打游戏了        电脑已经打开，DNF已登陆        我要打游戏了十、## 组合关系：将一个类的对象,放到另外一个类的属性中(做为一个组成部分)             一对一关系             一对多关系一对一关系：class Baooy:    def __init__(self,name,girlFriend = None):        self.name = name        self.girlFriend = girlFriend    def eat(self):        if self.girlFriend:            print(f"{self.name}带着他的女友{self.girlFriend.name}去吃饭")        else:            print("单身狗，吃狗粮")    def movie(self):        if self.girlFriend:            print(f"{self.name}带着他的女友{self.girlFriend.name}去看电影")        else:            print("单身狗不配看电影")class Girl:    def __init__(self,name):        self.name = namebao = Baooy("宝哥")friend = Girl("唐艺昕")bao.eat()bao.movie()bao.girlFriend = friendbao.eat()bao.movie()结果：  单身狗，吃狗粮        单身狗不配看电影        宝哥带着他的女友唐艺昕去吃饭        宝哥带着他的女友唐艺昕去看电影十一、## 继承关系：在不改变现有类的状况下,扩展这个类,子类能够得到父类的全部属性和方法            经过继承建立的新类称为"子类"或"派生类",被继承的类称为"基类"、"父类"或"超类"            在python中，同时支持单继承与多继承            增长了类的耦合性(耦合性不宜多，宜精)            减小了重复代码            使得代码更加规范化，合理化单继承：子类能够继承父类的属性和方法，修改父类，全部的子类都会受影响。python有两个判断继承的函数    isinstance（）用于检查实例类型：isinstance（对象，类型）    issubclass（）用于检查类继承：issubclass（子类，父类）继承的格式:class 子类名(父类名):子类能够定义本身的方法,也能够定义和父类同名的方法(方法重写),这时,子类方法会覆盖掉父类的同名方法、super（）关键字在当前类中调用父类方法super（）关键字：·子类若是编写了本身的构造方法，但没有显式调用父类的构造方法，而父类构造函数初始化了一些属性，就会出现问题·若是子类和父类都有构造函数，子类实际上是重写了父类的构造函数，若是不显式调用父类构造函数，父类的构造函数就不会被执行·解决方式：调用超类构造方法，或者使用super函数super（当前类名，self）.__init__(）所以,若是子类和父类都拥有本身的初始化方法,须要在子类的初始化方法中调用父类的init方法多重继承：包含多个间接父类多继承·有多个直接父类·大部分面向对象的编程语言（除了C++）都只支持单继承，而不支持多继承·多继承不只增长了编程的复杂度，并且很容易致使一些莫名的错误·Python虽然在语法上明确支持多继承，但一般推荐若是不是颇有必要，则尽可能不要使用多继承，而是使用单继承·这样能够保证编程思路更清晰，并且能够避免不少麻烦·若是多个直接父类中包含了同名的方法·此时排在前面的父类中的方法会“遮蔽”排在后面的父类中的同名方法class YeYe:    def __init__(self):        print("初始化爷爷")class Qinba(YeYe):    def __init__(self):        print("进入亲爸类")        YeYe.__init__(self)        print("初始化亲爸")class GanDie(YeYe):    def __init__(self):        print("进入干爹类")        YeYe.__init__(self)        print("初始化干爹")class ErZi(Qinba,GanDie):    def __init__(self):        Qinba.__init__(self)        GanDie.__init__(self)        print("初始化儿子")bigB = ErZi()结果：  进入亲爸类        初始化爷爷        初始化亲爸        进入干爹类        初始化爷爷        初始化干爹        初始化儿子十二、调用方式为```父类名.__init__(self)```若是只是想操做另外一个类的对象,用依赖若是两个类当中存在has a 的关系,用组合若是是is a 的关系,用继承(尽可能少用继承,多用组合)1三、新式类:继承了object的类,就叫新式类经典类:没有继承object的类py3中,全部的类都是新式类py2中,若是没有显式继承,那么这个类就没有集成任何类,因此有经典类,也有新式类# class Boy:#     def __init__(self,name,tools = None):#         self.name = name#         self.girl = tools#     def play(self):#         if self.girl:#             print(self.name,"玩",self.girl.name)#         else:#             print("单身狗玩本身吧")## class Girl:#     def __init__(self,name):#         self.name = name# class Hero:#     def __init__(self,wuqi,hujia):#         self.wuqi = wuqi#         self.hujia = hujia#     def skill(self,tool):#         print(f"用{self.wuqi.name}打{tool.name}")#组合关系:将一个类的对象,做为另外一类的属性#一对多关系class Person:    def __init__(self):        self.girl = []    def bamei(self,g1):        self.girl.append(g1)    def play(self):        for i in self.girl:            print(i.name,end=" ")            i.play()class Girl:    def __init__(self,name,age):        self.name = name        self.age = age    def play(self):        print("陪玩")girl1 = Girl("小丽",18)girl2 = Girl("贾玲",30)girl3 = Girl("韩红",50)bigB = Person()bigB.bamei(girl3)bigB.bamei(girl1)bigB.play()结果：  韩红 陪玩        小丽 陪玩class Boy:    def __init__(self):        self.girl_list = []    def baMei(self,girl):        self.girl_list.append(girl)    def happy(self):        for i in self.girl_list:            i.play()class Girl:    def __init__(self,name):        self.name = name    def play(self):        print(f"{self.name}和你一块儿玩")bao = Boy()friend1 = Girl("唐艺昕")friend2 = Girl("迪丽热巴")friend3 = Girl("杨颖")bao.baMei(friend1)bao.baMei(friend2)bao.baMei(friend3)bao.happy()结果：  唐艺昕和你一块儿玩        迪丽热巴和你一块儿玩        杨颖和你一块儿玩1四、# 定义一个用户类,用户名和密码是这个类的属性,实例化两个用户,分别有不一样的用户名和密码        # 登录成功以后才建立用户对象        # 设计一个方法 修改密码# class User:#     def __init__(self,name,pw):#         self.name = name#         self.pw = pw#     def rPassW(self):#         newPW = input("请输入新密码")#         self.pw = newPW# num = 0# while True:#     userName = input("请输入用户名")#     userPW = input("请输入密码")#     if userName == "alex" and userPW == "123123":#         xiaoming = User("xiaoming","123abc")#         xiaoli = User("xiaoli","123456")#         break#     else:#         print("输入有误!,请从新输入!")#         num += 11五、# 定义一个列表的操做类：Listinfo# 包括的方法:# 1 列表元素添加: add_key(keyname) [keyname:字符串或者整数类型]# 2 列表元素取值：get_key(num) [num:整数类型]# 3 列表合并：update_list(list) [list:列表类型]# 4 删除而且返回最后一个元素：del_key()# list_info = Listinfo([44,222,111,333,454,'sss','333'])# class ListInfo:#     def __init__(self, lis):#         self.lis = lis#     def add_Key(self, keyname):#         self.lis.append(keyname)#     def get_key(self,num):#         return self.lis[num]#     def update_list(self, new_list):#         self.lis + new_list#     def del_key(self):#         return self.lis.pop()1五、# class A:#     Country = ['中国']                          # 静态变量/静态属性 存储在类的命名空间里的#     def __init__(self,name,age,country):        # 绑定方法 存储在类的命名空间里的#         self.name = name#         self.age = age#     def func1(self):#         print(self)# a = A('alex',83,'印度')# b = A('wusir',74,'泰国')# a.Country[0] = '日本'# print(a.Country)# print(b.Country)# print(A.Country)结果：  ['日本']        ['日本']        ['日本']python27day20面向对象--------------------------------------------------------------------------------------------封装”就是将抽象获得的数据和行为相结合，造成一个有机的总体·元组，列表，字典等等：数据的封装，经过引用去使用数据·函数：算法的封装·没有函数，功能靠每一行代码去直接执行·耦合度过高，复用性太差，开发效率过低封装的目的是简化编程和加强安全性·使用者没必要关心该类具体的实现细节·经过接口（万能的点）·还能够给予的特定的访问权限来使用类的成员·明确区份内外：·类的实现者能够修改内部封装的东西而不影响外部调用者·外部调用者只须要知道本身可使用该类对象的哪些功能私有属性，私有方法·“双下划线”开始的是私有成员，在类外部不能够直接用属性或方法名调用，子类中也不能访问到这个数据·能够提供外界访问的接口·将不须要对外提供的内容都隐藏起来·把属性都隐藏，提供公共方法对其访问·双下滑线开头的属性在继承给子类时，子类是没法覆盖的class Abc:    def __init__(self):        self.__name = "abc"    def __set(self,x):        self.__name = x    def get_name(self):        print(self.__name)a = Abc()print(a.__name) #直接访问找不到结果：AttributeError: 'Abc' object has no attribute '__name' (AttributeError:“Abc”对象没有属性“\u name”)a.get_name()    #经过类里面的函数属性能够找到结果：abc破解私有属性和私有方法：·在名称前加上_类名，即_类名__名称·其实加双下划线仅仅是一种变形操做·类中全部双下划线开头的名称如__x都会自动变造成：_类名__x的形式class Abc:    def __init__(self):        self.__name = "abc"    def __set(self):        print("111")    def get_name(self):        print(self.__name)a = Abc()a._Abc__set()结果：111多态体现1：python是一种多态语言，不关心对象的类型·对于弱类型的语言来讲，变量并无声明类型，所以同一个变量彻底可    以在不一样的时间引用不一样的对象·毫无疑问，在python中对象是一块内存，内存中除了包含属性、方法之    外，还包含了对象类型，咱们经过引用来访问对象，好比a=A（），首先    python建立一个对象A，而后声明一个变量a，再将变量a与对象A联系起    来。变量a是没有类型的，它的类型取决于其关联的对象class Bird:    def move(self,field):        print("鸟在%s上自由地飞翔" %field)class Dog:    def move(self,field):        print("狗在%s里飞快的奔跑" %field)x = Bird()x.move("天空")x = Dog()x.move("草地")结果：  鸟在天空上自由地飞翔        狗在草地里飞快的奔跑同一个变量x：在执行同一个move（）方法时，因为x指向的对象不一样，所以呈现出不一样的行为特征，这就是多态。多态体现2：一类事物有多种形态（polymorphic）·一个抽象类有多个子类，但方法实现不一样·例如：动物类有多个子类，每一个子类都从新实现了父类的某个方法，但    方法的实现不一样（休息的方法）·此时须要有继承，须要有方法重写栈Stack和队列Queue实现put和get方法：class Stack:    def __init__(self):        self.lis = []    def put(self,num):        self.lis.append(num)    def get(self):        if self.lis != []:            return self.lis.pop()class Queue:    def __init__(self):        self.lis = []    def put(self,num):        self.lis.append(num)    def get(self):        if self.lis != []:            return self.lis.pop(0)# 数据结构：数据在内存中的存放顺序栈/队列栈：FILO--3,2,1队列：FIFO--1,2,3l = []l.put(1)l.put(2)l.put(3)l.get()l.get()l.get()多态：体现一：python中一个引用，能够指向不一样类型的对象体现二：一类事物，有多种形态多态性：在继承和方法重写的基础上，定义一个统一的接口，不关心传入对象的类型，只关心实现了哪些方法python崇尚鸭子类型·不关心类型，不须要继承，只关注方法实现，这种状况被称为鸭子类型·“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就能够被称为鸭子·在鸭子类型中，关注的不是对象的类型自己，而是它是如何使用的总结：Python自己就是支持多态性的·增长了程序的灵活性（通用性），以不变应万变，不论对象变幻无穷，使用者都是同一种形式去调用·增长了程序的可扩展性，经过继承某个类建立了一个新的类，接口使用者无需更改本身的代码，仍是用原方法调用对比：·多态强调的是：一类事物不一样的形态·多态性强调的是：同一操做，做用对象不一样，表现出不一样实现方式（只关心行为结果）class Car:    def __init__(self,color):        self.color = color    def run(self):        print(self.color,"小汽车在跑")class Cat:    def __init__(self,name):        self.name = name    def run(self):        print("猫咪",self.name,"在跑")a = Car("红色")a.run()结果：红色 小汽车在跑b = Cat("白色")b.run()结果：猫咪 白色 在跑有时经过单一对象方便集中管理资源·单例模式是保证一个类仅有一个实例的设计模式·保证了在程序的不一样位置均可以且仅能够取到同一个对象实例：若是实例不存在，会建立一个实例；若是已存在就会返回这个实例。设计模式：处理特定问题，可重用解决方案建立单例模式：class Danli:    ins = None    def __new__(cls, *args, **kwargs):        if cls.ins == None:            cls.ins = object.__new__(cls)        return cls.ins    def __init__(self):        passclass Boy(Danli):    passclass Girl(Danli):    passxiaoming = Danli()print(id(xiaoming))结果：35486800xiaoHong = Danli()print(id(xiaoHong))结果：35486800工厂模式是不直接暴露对象建立细节，而是经过一个共用类建立对象的设计模式，须要4步：建立基类-建立子类-建立工厂类-使用工厂模式class Girl:    passclass Boy:    passclass Dog:    passclass Cat:    passclass Alex:    passclass Gongchang:    def re_Per(self,arg):        if arg == "G":            return Girl()        elif arg == "B":            return Boy()        print("没有")