九、Python-面向对象程序设计

九、Python-面向对象程序设计

面向对象（Object Oriented）缩写为OO，是一种设计思想。面向对象编程（Object Oriented Programming，即OOP）主要针对大型软件设计而提出，可以使软件设计更加灵活，并能更好的进行代码复用

面向对象中的对象是指客观世界中存在的对象，该对象具有唯一性，对象之间各不相同，各有各的特点，每个对象都有自己的运动规律和内部状态，对象之间又是可以相互联系、相互作用的，另外对象也可以是一个抽象的事物。

面向对象技术是一种从组织结构上模拟客观世界的方法

一、对象（Object）

对象是一个抽象概念，表示任何事物，对象划分为两部分：静态部分和动态部分

1. 静态部分：被称为属性，任何事物都有自己的属性（该属性不仅客观存在，且不容忽视，如人的性别）
2. 动态部分：指对象的行为，即对象执行的动作（如人可以行走）

类：是封装对象属性和行为的载体（具相同属性和行为的一类实体被称为类，对象是类的实体）

面向程序设计具有三大基本特征：封装、继承和多态

1. 封装：是面向对象编程的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体是类，类通常对客户隐藏其实现细节，这就是封装思想（只能执行类允许公开的数据，就避免了外部对内部数据影响，提高程序的可维护性）
2. 继承：是实现重复利用的重要手段，子类通过继承复用了父类的属性和行为的同时，又添加子类特有的属性和行为
3. 多态：将父类对象应用于子类的特征就是多态

二、类的定义和使用：类表示具有相同属性和方法的对象的集合

使用类时，需要先定义类，然后创建类的实例，通过类的实例就可以访问类中的属性的方法

定义类：使用class实现

格式：class ClassName:

'''注释'''

starement

1. ClassName：用于指定类名，首字母大写，连续的第二个单词首字母也要大写（驼峰式命名）
2. 注释：用于指定类的文档字符串，定义该字符串后，创建类对象时，输入类名和左侧“(”将显示该信息
3. statement：类体，主要由类变量（或类成员）、方法和属性等定义语句组成（没想好类的具体功能，可以用pass代替）

创建类的实例：class语句本身不创建该类的任何实例：创建实例ClassName(parameterlist)

ClassName：必选参数，用于指定具体的类

parameterlist：可选参数，没有创建__init__()方法或者__init()只有一个self参数时，可省略

创建__init__()方法：该方法是一个特殊方法，该方法必须含一个self参数(且必须在第一个位置)

self参数是一个指向实例本身的引用，用于访问类中的属性和方法（在方法调用时会自动传递实际参数self，Python中只能有一个__init__方法）

class Geese:

'''大雁类'''

def __init__(self): #构造方法

print('我是大雁类')

wildGoose = Geese() #创建大雁类的实例

除了self参数外还有其他参数时，用“,”隔开，创建类实例只有一个参数时，就不需要指定实际参数了（self可以以其他单词代替，一般直接用self）

创建类的成员并访问：类的成员主要由实例方法和数据成员组成

a.创建实例方法并访问：实例方法指在类中定义的函数，该函数是在类的实例上操作的函数

def functionName(self,parameterlist):

block

注释：functionName：指定方法名词，一般用小写字母开头

self：必须参数，表示类的实例，其名可以为self以外的单词

parameterlist：指定除self以外的参数（用“,”隔开）

block：方法体，实现具体的功能

实例方法创建完成后，可通过类的实例名称和点(.)操作符进行访问

instanceName.functionName(parametervalue)

instanceName：类的名称

functionName：要调用的方法名称

parametervalue：表示为方法指定对应的实际参数(其值得个数与创建实例方法中的parameterlist相同)

eg：class Dog():

　　　　"""一次模拟小狗的简单尝试"""

　　　　def __init__(self, name, age): #构造方法

　　　　　　"""初始化属性name和age"""

　　　　　　self.name = name

　　　　　　self.age = age

　　　　　　print("狗狗的名字为：",self.name,"年龄为：",self.age)

　　　　def sit(self): #定义行为方法

　　　　　　"""模拟小狗被命令时蹲下"""

　　　　　　print(self.name + " is now sitting.")

　　　　def roll_over(self): #定义行为方法

　　　　　　"""模拟小狗被命令时打滚"""

　　　　　　print(self.name,rolled)

name_1 = "小黄" #狗的名字

age_1 = 2 #狗的年龄

a = Dog(name_1,age_1) #创建狗的实例

c = " rolled over!" #定义行为方法参数

a.sit() #调用狗类的实例

a.roll_over(c) #调用狗类的实例

也可以直接把行为直接定义到参数中：def run(self,run='我会跑)

b.创建数据成员并访问：数据成员是指在类中定义的变量（即属性），根据定义位置，可分为类属性和实例属性

类属性：指定义在类中，并且函数体外的属性（类属性可以在类的所有实例之间共享值，即在所有实例化的对象中公用）

eg：class Geese():

　　　　'''大雁类'''

　　　　neck = '脖子长'

　　　　wing = '振翅频率高'

　　　　leg = '腿位于身体的中心支点，行走自如'

　　　　def __init__(self):

　　　　　　print('我属于大雁类，我的特点有：')

　　　　　　print(Geese.neck)

　　　　　　print(Geese.wing)

　　　　　　print(Geese.leg)

geese=Geese() #实例化一个大雁类的对象

Geese.beak = '啄的基部较高，长度和头部的长度几乎相等' #动态添加属性:beak

print(Geese.beak)

Python中除可以用类名称访问类属性，还能动态的为类和对象添加属性，也可以修改类属性，修改结果将作用于该类的所有实例

实例属性：定义在类的方法中的属性，只作用于当前实例中(实例属性只能通过实例名访问)

实例属性也可以通过实例名称修改，但是实例名称修改实例属性后，并不影响该类的另一个实例中相应的实例属性的值

eg：class Geese():

　　　　'''大雁类'''

　　　　def __init__(self):

　　　　　　self.neck = '脖子较长'

　　　　　　print(self.neck)

a = Geese() #创建Geese的实例a

b = Geese() #创建Geese的实例b

a.neck = '脖子没有天鹅长' #修改实例属性

print("a的neck属性为：",a.neck)

print("b的neck属性为：",b.neck)

访问限制：Python中没有对属性和方法的访问权限进行限制(可以使用_foo和__foo限制访问权)

1. _foo：表示protected（保护）类型的成员，只允许类本身和子类进行访问，但不能使用“from module import *”语句导入

eg：class Swan:

　　　　'''天鹅类'''

　　　　_neck_swan = '天鹅的脖子很长' #定义保护属性

　　　　def __init__(self):

　　　　　　print('__init__():',Swan._neck_swan) #在实例方法中访问保护属性

swan = Swan() #创建Swan类的实例

print('直接访问：',swan._neck_swan) #保护属性可以通过实例名访问

2. __foo：表示private（私有）类型的成员，只允许定义该方法的类本身进行访问，且不能通过类的实例进行访问（但可以通过”类的实例名._类名__xxx“方式访问）

eg：class Swan:

　　'''天鹅类'''

　　__neck_swan = '天鹅的脖子很长' #定义私有属性

　　def __init__(self):

　　　　print('__init__():',Swan.__neck_swan) #在实例方法中访问私有属性

swan = Swan() #创建Swan类的实例

print('直接访问：',swan._Swan__neck_swan) #私有属性访问

3. __foo__：首尾都是双下划线表示定义特殊方法（一般为系统定义名字，如（__init__））

三、属性（property）：

前面的属性将返回所存储的值，这里的属性是特殊属性，访问时将计算他的值，该属性还可以为属性添加安全保护机制

1. 创建用于计算的属性：

通过@property（装饰器）将一个方法转换为属性，而实现用于计算的属性（转换为属性后，可直接通过方法名来访问，不需要再添加“()”）。格式：

@property

def methodname(self):

block

注释：methodname：用于指定方法名（一般用小写字母开头），该名称最后将作为创建的属性名

self：必要参数，表示类的实例

block：方法体，实现具体的功能，方法体中，常用return语句结束，用于返回计算结果

eg：class Rect:

　　　　'''计算矩形面积'''

　　　　def __init__(self,width,height):

　　　　　　self.width = width

　　　　　　self.height = height

　　@property #将方法转化为属性

　　def area(self): #计算面积的方法

　　　　return self.width*self.height #返回计算面积的值

rect = Rect(800,600) #创建类的实例

print('面积为：',rect.area) #输出属性的值

转换后的属性不能重新赋值，对其重新赋值要报错

2. 为属性添加安全保护机制：

默认情况下，创建的类属性或者实例时可以在类体外进行修改的(私有可以限制体外修改，但体外同样不能获取其值)；要创建一个可以读取，但不能修改的属性，可以使用@property实现

eg：class TVshow:

　　　　'''正在播放的节目'''

　　　　def __init__(self,show):

　　　　　　self.__show = show

　　　　@property

　　　　def show(self):

　　　　　　return self.__show #返回私有属性的值

tv = TVshow('战狼2')

print('正在播放的节目:',tv.show)

tv.show = '战狼'

print('修改后',tv.show) #返回修改后的值（结果会报错）

3.可以为属性设置拦截器，即允许修改，但是需要遵循一定的约束

eg：class TVshow: #定义类

　　　　'''正在播放的节目'''

　　　　list1 = ['钢铁侠','绿巨人','黑衣人','战狼2'] #定义节目单列表

　　　　def __init__(self,show):

　　　　　　self.__show = show

　　　　@property #将方法转换为属性

　　　　def show(self): #定义show方法

　　　　　　return self.__show #返回私有属性的值

　　@show.setter #设置setter方法，让属性可修改

　　　　def show(self,a):

　　　　　　if a in TVshow.list1:

　　　　　　　　self.__show ='您选择了《' + a + '》' #返回修改的值

　　　　　　else:

　　　　　　　　self.__show = '您选择的节目不在节目单'

tv = TVshow('战狼2')

print('正在播放的节目:',tv.show)

tv.show = '绿巨人'

print('修改后',tv.show) #返回修改后的值（结果会报错）

tv.show = '战狼'

print('修改后',tv.show)

四、继承

当要编写的类和另一个已经存在的类之间存在一定的继承关系时，则可通过继承来达到代码重用的目的，提高开发效率

继承的基本语法：

程序设计中实现集成，表示这个类拥有它继承的类的所有共有成员或者受保护成员；面向对象象编辑中，被继承的类称为父类或基类，新的类称为子类或派生类

class ClassName(baseclasslist):

'''类的帮助信息''' #类文档字符串

Statement #类体

ClassName：用于指定类名

baseclasslist：用于指定要继承的基类（可以有多个，如不指定，将使用所有Python对象的类object）

Statement：类体，主要由类变量（或类成员）、方法和属性等定义语句组成（可用pass代替空类体）

eg：class Fruit: #定义水果类（基类）

　　color = '绿色' #定义类的属性

　　def harvest(self,color):

　　　　print('水果是：'+color+'的！') #输出形参color

　　　　print('水果已经收获……')

　　　　print('水果原来的颜色：',Fruit.color,'的\n') #输出类的属性

class Apply(Fruit): #定义苹果类（派生类）

　　color = '红色'

　　def __init__(self):

　　　　print('我是苹果！')

class Orange(Fruit): #定义苹果类（派生类）

　　color = '橙色'

　　def __init__(self):

　　　　print('我是橙子')

apply = Apply() #创建类的实例（苹果）

apply.harvest(apply.color) #调用harvest()方法

orange = Orange()

orange.harvest(orange.color)

方法重写：

基类的成员都会被派生类继承，当基类中的某个方法不完全适用于派生类时，就需要在派生类中重写父类这个方法（和Java方法重写一样）

eg：class Fruit: #定义水果类（基类）

　　color = '绿色' #定义类的属性

　　def harvest(self,color):

　　print('水果是：'+color+'的！') #输出形参color

　　print('水果已经收获……')

　　print('水果原来的颜色：',Fruit.color,'的\n') #输出类的属性

class Apply(Fruit): #定义苹果类（派生类）

　　color = '红色'

　　def __init__(self):

　　　　print('我是苹果！')

　　def harvest(self,color):

　　　　print('苹果是：'+color+'的！') #输出形参color

　　　　print('苹果已经收获……')

　　　　print('苹果原来的颜色：',Fruit.color,'的\n') #输出类的属性

apply = Apply() #创建类的实例（苹果）

apply.harvest(apply.color) #调用harvest()方法

派生类中调用基类的__init__()方法：

在派生类中定义__init__()方法时，不会自动调用基类的__init__()方法；要调用它，要让派生类调用__init__()方法进行初始化，需要在派生类适用super()函数调用基类的__init__()方法

eg：class Fruit: # 定义水果类（基类）

　　def __init__(self,color = "绿色"):

　　　　Fruit.color = color # 定义类属性

　　def harvest(self, color):

　　　　print("水果是：" + self.color + "的！") # 输出的是形式参数color

　　　　print("水果已经收获……")

　　　　print("水果原来是：" + Fruit.color + "的！"); # 输出的是类属性color

class Apple(Fruit): # 定义苹果类（派生类)

　　color = "红色"

　　def __init__(self):

　　　　print("我是苹果")

　　　　super().__init__()

class Aapodilla(Fruit): # 定义人参果类（派生类)

　　def __init__(self,color):

　　　　print("\n我是人参果")

　　　　super().__init__(color)

# 重写harvest()方法的代码

　　def harvest(self,color):

　　　　print("人参果是："+color+"的！") # 输出的是形式参数color

　　　　print("人参果已经收获……")

　　　　print("人参果原来是："+Fruit.color+"的！"); # 输出的是类属性color

apple = Apple() # 创建类的实例（苹果）

apple.harvest(apple.color) # 调用基类的harvest()方法

sapodilla = Aapodilla("白色") # 创建类的实例（人参果）

sapodilla.harvest("金黄色带紫色条纹") # 调用基类的harvest()方法

 

posted on 2019-05-06 16:57 dameon 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/dameon/p/10820659.html