一. 组合 :
1. 什么是组合 ?
一个对象的属性是来自于另外一个类的对象, 称之为组合. (跟继承其实很相似.都是共用一个类里面的属性)
2. 为何用组合 ?
组合也是用来解决类与类代码冗余的问题.
3. 如何用组合 ?
class Foo: aaa=1111 def __init__(self,x,y): self.x=x self.y=y def func1(self): print(‘Foo内的功能‘) class Bar: bbb=2222 def __init__(self, m, n): self.m = m self.n = n def func2(self): print(‘Bar内的功能‘) obj1=Foo(10,20)obj2=Bar(30,40) obj1.xxx=obj2 (把两个类组合到了一起.) print(obj1.x,obj1.y,obj1.aaa,obj1.func1)print(obj1.xxx.m,obj1.xxx.n,obj1.xxx.bbb,obj1.xxx.func2) 小练习 :
class OldboyPeople: school = ‘Oldboy‘ def __init__(self, name, age, gender): self.name = name self.age = age self.gender = gender class OldboyStudent(OldboyPeople): def choose_course(self): print(‘%s is choosing course‘ %self.name) class OldboyTeacher(OldboyPeople): def __init__(self, name, age, gender,level,salary): OldboyPeople.__init__(self, name, age, gender) self.level=level self.salary=salary def score(self,stu,num): stu.num=num print(‘老师%s给学生%s打分%s‘ %(self.name,stu.name,num)) class Course: def __init__(self,course_name,course_price,course_period): self.course_name=course_name self.course_price=course_price self.course_period=course_period def tell_course(self): print(‘课程名:<%s> 价钱:[%s] 周期:[%s]‘ % (self.course_name, self.course_price, self.course_period)) python_obj=Course(‘python开发‘,3000,‘5mons‘)linux_obj=Course(‘linux运维‘,5000,‘3mons‘) stu1=OldboyStudent(‘egon‘,18,‘male‘)stu1.courses=[]stu1.courses.append(linux_obj)stu1.courses.append(python_obj)stu1.courses[0].tell_course() stu2=OldboyStudent(‘kevin‘,38,‘male‘) 二. 封装 : 1. 什么是封装 ? 装,指的是把属性装进一个容器, 封,指的是隐藏的意思,但是这种隐藏是对外不对内的. 2. 为何要封装 ? 封装不是单纯意义的隐藏, 封装数据属性的目的 : 将数据属性封装起来, 类外部的使用就无法直接操作该数据属性了. 需要类内部开一个接口给使用者,类的设计者可以在接口之上附加任意逻辑,从而严格控制使用者对属性的操作. 封装函数属性的目的 :隔离复杂度. 3. 如何封装 ? 只需要在属性前加上__开头,该属性就会被隐藏起来,该隐藏具备的特点 : 1. 只是一种语法意义上的变形, 即__开头的属性会在检测语法时发生变形为 _类名__属性名的形式 2. 这种隐藏式对外不对内的, 因为在类内部检测语法时, 所有的代码统一都发生了变形. 3. 这种变形只在检测语法时发生一次, 在类定义之后新增的__开头的属性并不会发生变形. 4. 如果父类不想让子类覆盖自己的属性, 可以在属性前加__开头 注意: 这种机制也并没有真正意义上的限制我们从外部直接访问属性, 知道了类名和属性名就可以拼出名字 : _类名__属性名, 然后就可以访问了, 如a._A__N, 即这种操作并不是严格意义上的限制外部访问, 仅仅是 一种语法意义上的变形, 主要用来限制外部的直接访问. 示例: 1. 封装数据 : 将数据隐藏起来并不是目的. 隐藏起来然后对外提供该数据的接口, 然后我们可以在接口附加上对该数据操作的 限制, 以此完成对数据属性操作的严格控制.
class Teacher:
def __init__(self,name,age):
# self.__name=name
# self.__age=age
self.set_info(name,age)
def tell_info(self):
print(‘姓名:%s,年龄:%s‘ %(self.__name,self.__age))
def set_info(self,name,age):
if not isinstance(name,str):
raise TypeError(‘姓名必须是字符串类型‘)
if not isinstance(age,int):
raise TypeError(‘年龄必须是整型‘)
self.__name=name
self.__age=age
t=Teacher(‘egon‘,18)
t.tell_info()
t.set_info(‘egon‘,19)
t.tell_info()
2. 封装函数 : 目的是隔离复杂度. 提示 :在编程语言里, 对外提供的接口 (接口可理为一个入口), 可以是函数, 称为接口函数, 这与接口的概念还不一样, 接口代表一组接口函数的集合体.
#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
#隔离了复杂度,同时也提升了安全性
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()
封装与扩展性: 封装在于明确区分内外, 使得类实现者可以修改封装内的东西,而不是影响外部调用者的代码. 而外部使用者只知道一个接口 (函数), 只要接口(函数)名,参数不变,使用者的代码永远无需改变, 这就提供一个良好的合作基础, 或者说,只要这个基础约定 不变,则代码改变不足为虑 三. 特性(property)装饰器: 什么是特性property property是一种特殊的属性,访问它时会执行一段功能(函数) 然后返回值 为什么要用property : 将一个类的函数定义后,对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的, 这种特性的使用方式遵循了统一访问的原则 property 下面还有装饰器. @setter.(可以修改属性) @deleter.(可以删除属性) 示例 :
BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性,更
便于理解)
成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
体质指数（BMI）=体重（kg）÷身高^2（m）
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)
p1=People(‘egon‘,75,1.85)
print(p1.bmi)
property 的两种使用方法.
class People: def __init__(self,name): self.__name=name @property def name(self): return ‘<name:%s>‘ %self.__name @name.setter def name(self,new_name): if type(new_name) is not str: print(‘名字必须是str类型‘) return self.__name=new_name @name.deleter def name(self): del self.__name obj=People(‘egon‘) print(obj.name) del obj.name print(obj.__dict__)
class People: def __init__(self,name): self.__name=name def xxx_name(self): return ‘<name:%s>‘ %self.__name def yyy_name(self,new_name): if type(new_name) is not str: print(‘名字必须是str类型‘) return self.__name=new_name def zzz_name(self): del self.__name name=property(xxx_name,yyy_name,zzz_name) obj=People(‘egon‘) print(obj.name) del obj.name print(obj.__dict_
四. 多态性. 多态性分为静态多态性与动态多态性. 静态多态性 :如任何类型都可以用运算符进行运算. 动态多态性 : 如下
peo=People()
dog=Dog()
pig=Pig()
#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()
#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
obj.talk()
多态性的好处 : 1, 增加了程序的灵活性 : 以不变应万变,不论对象千变万化,使用者都是同一种形式去调用, 如func(animal) 2, 增加了程序的可扩展性 通过集成animal类创建了一个新的类, 使用者无需更改自己的代码. 还是用func(animal)去调用 示例:
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)
鸭子类型 : Python崇尚鸭子类型,即如果看起来像,叫声像而且走起路来像鸭子, name它就是鸭子, python程序员通常根据这种行为来编写程序, 例如,如果想编写现有对象的自定义版本,可以继承该对象也可以 创建一个外观和行为像,但与它无任何关系的全新对象,后者通常用于保存程序组件的松耦合度. 示例一 : 利用标准库中定义的各种‘与文件类似‘的对象, 尽管这些对象的工作方式像文件,但他们没有继承内置文件对象的方法.
#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
def read(self):
pass
def write(self):
pass
class DiskFile:
def read(self):
pass
def write(self):
pass
示例二. : 其实大家一直在享受着多态性带来的好处,比如Python的序列类型有多种形态:字符串,列表,元组. 多态性体现如下
#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
原文地址：https://www.cnblogs.com/lvyipin1/p/9844802.html
时间： 2024-10-11 06:27:09