Python面向对象、编程模式的分类
Python面向对象、编程模式的分类。
编程模式的分类
面向过程：根据业务逻辑从上到下写垒代码
将之前实现的代码块复制到现需功能处。
whileTrue：
ifcpu利用率>90%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
if硬盘使用空间>90%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
if内存占用>80%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
增强代码的重用性和可读性，就变成了这样
def发送邮件(内容)
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
whileTrue：
ifcpu利用率>90%:
发送邮件('CPU报警')
if硬盘使用空间>90%:
发送邮件('硬盘报警')
if内存占用>80%:
发送邮件('内存报警')
面向对象：对函数进行分类和封装，让开发“更快更好更强…”
类就是一个模板，模板里可以包含多个函数，函数里实现一些功能，对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
#创建类
classFoo:
defBar(self):
print'Bar'
defHello(self,name):
print'iam%s'%name
#根据类Foo创建对象obj
obj=Foo()
obj.Bar()#执行Bar方法
obj.Hello('wupeiqi')#执行Hello方法
面向对象的三大过程
1.封装
通过对象直接调用被封装的内容通过self间接调用被封装的内容
init为系统自带的构造方法
classFoo:
def__init__(self,name,age):
self.name=name
self.age=age
defdetail(self):
printself.name
printself.age
obj1=Foo('wupeiqi',18)
obj1.detail()#Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的self＝obj1，即：self.name是wupeiqi；self.age是18
obj2=Foo('alex',73)
obj2.detail()#Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的self＝obj2，即：self.name是alex；self.age是78
2.继承
继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。
classAnimal:
defeat(self):
print"%s吃"%self.name
defdrink(self):
print"%s喝"%self.name
defshit(self):
print"%s拉"%self.name
defpee(self):
print"%s撒"%self.name
classCat(Animal):
def__init__(self,name):
self.name=name
self.breed＝'猫'
defcry(self):
print'喵喵叫'
classDog(Animal):
def__init__(self,name):
self.name=name
self.breed＝'狗'
defcry(self):
print'汪汪叫'
##########执行#########
c1=Cat('小白家的小黑猫')
c1.eat()
c2=Cat('小黑的小白猫')
c2.drink()
d1=Dog('胖子家的小瘦狗')
d1.eat()
对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
1、Python的类可以继承多个类，Java和C#中则只能继承一个类
2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先（经典类）和广度优先（新式类）
经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
经典类例子：
classD:
defbar(self):
print'D.bar'
classC(D):
defbar(self):
print'C.bar'
classB(D):
defbar(self):
print'B.bar'
classA(B,C):
defbar(self):
print'A.bar'
a=A()
#执行bar方法时
#首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
#所以，查找顺序：A-->B-->D-->C
#在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()
新式类例子：
classD(object):
defbar(self):
print'D.bar'
classC(D):
defbar(self):
print'C.bar'
classB(D):
defbar(self):
print'B.bar'
classA(B,C):
defbar(self):
print'A.bar'
a=A()
#执行bar方法时
#首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
#所以，查找顺序：A-->B-->C-->D
#在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()
经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
3.多态
classPerson(object):
def__init__(self,name,sex):
self.name=name
self.sex=sex
defprint_title(self):
ifself.sex=="male":
print("man")
elifself.sex=="female":
print("woman")
classChild(Person):#Child继承Person
defprint_title(self):
ifself.sex=="male":
print("boy")
elifself.sex=="female":
print("girl")
May=Child("May","female")
Peter=Person("Peter","male")
print(May.name,May.sex,Peter.name,Peter.sex)
May.print_title()
Peter.print_title()
当子类和父类都存在相同的print_title()方法时，子类的print_title()覆盖了父类的print_title()，在代码运行时，会调用子类的print_title()
这样，我们就获得了继承的另一个好处：多态。
多态的好处就是，当我们需要传入更多的子类，例如新增Teenagers、Grownups等时，我们只需要继承Person类型就可以了，而print_title()方法既可以直不重写（即使用Person的），也可以重写一个特有的。这就是多态的意思。调用方只管调用，不管细节，而当我们新增一种Person的子类时，只要确保新方法编写正确，而不用管原来的代码。这就是著名的“开闭”原则：
对扩展开放（Openforextension）：允许子类重写方法函数对修改封闭（Closedformodification）：不重写，直接继承父类方法函数
类的属性与方法
这里写图片描述
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时self.__private_attrs。
类的方法
在类的内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用self.__private_methods
classJustCounter:
__secretCount=0#私有变量
publicCount=0#公开变量
defcount(self):
self.__secretCount+=1
self.publicCount+=1
printself.__secretCount
counter=JustCounter()
counter.count()
counter.count()
printcounter.publicCount
printcounter.__secretCount#报错，实例不能访问私有变量
单下划线、双下划线、头尾双下划线说明：
__foo__:定义的是特殊方法，一般是系统定义名字，类似init()之类的。_foo:以单下划线开头的表示的是protected类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于frommoduleimport*__foo:双下划线的表示的是私有类型(private)的变量,只能是允许这个类本身进行访问了。
Python培训、Python培训班、Python培训机构，就选光环大数据！
大数据培训、人工智能培训、Python培训、大数据培训机构、大数据培训班、数据分析培训、大数据可视化培训，就选光环大数据！光环大数据，聘请专业的大数据领域知名讲师，确保教学的整体质量与教学水准。讲师团及时掌握时代潮流技术，将前沿技能融入教学中，确保学生所学知识顺应时代所需。通过深入浅出、通俗易懂的教学方式，指导学生更快的掌握技能知识，成就上万个高薪就业学子。 更多问题咨询，欢迎点击------>>>>在线客服！
