一. 组合 :
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