python面向对象实例教程（Python面向对象程序设计类的多态用法详解）

python面向对象实例教程

Python面向对象程序设计类的多态用法详解

本文实例讲述了python面向对象程序设计类的多态用法。分享给大家供大家参考，具体如下：

多态

1、多态使用

一种事物的多种体现形式,举例:动物有很多种

注意: 继承是多态的前提

函数重写就是多态的体现形式

演示:重写animal类

第一步:先定义猫类和老鼠类,继承自object,在其中书写构造方法和eat方法
第二步: 抽取animal父类,定义属性和eat方法,猫类与老鼠类继承即可
第三步: 定义人类,在其中分别定义喂猫和喂老鼠的方法
第四步:使用多态,将多个喂的方法提取一个。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# 测试类 from cat import cat from mouse import mouse from person import person ''' 多态: 一种事物的多种状态 需求:人可以喂任何一种动物 ''' #创建猫和老鼠的对象 tom = cat("tom") jerry = mouse("jerry") #调用各自的方法 tom.eat() jerry.eat() #定义了一个有name属性和eat方法的animal类,让所有的动物类都继承自animal. #定义一个人类,可以喂猫和老鼠吃东西 per = person() #per.feedcat(tom) #per.feedmouse(jerry) #思考:人要喂100种动物,难道要写100个feed方法吗? #前提:tom和jerry都继承自动物 per.feedanimal(tom) per.feedanimal(jerry)

输出：

tom吃
jerry吃
给你食物
tom吃
给你食物
jerry吃

?

1 2 3 4 5 6

#animal.py文件中的动物类 class animal(object):   def __init__(self, name):     self.name = name   def eat(self):     print(self.name + "吃")

?

1 2 3 4 5

#cat.py文件中的猫类 class cat(animal):   def __init__(self, name):     #self.name = name     super(cat,self).__init__(name)

?

1 2 3 4 5

#mouse.py中的老鼠类 class mouse(animal):   def __init__(self, name):     #self.name = name     super(mouse,self).__init__(name)

?

1 2 3 4 5

#person.py中的人类 class person(object):   def feedanimal(self, ani):     print("给你食物")     ani.eat()

2、对象属性与类属性

对象属性和类属性的区别:

a.定义的位置不同,类属性是直接在类中的属性,对象属性是在定义在构造方法中的属性；

b.对象属性使用对象访问,类属性使用类名访问；

c.在内存中出现的时机不同[类属性随着类的加载而出现,对象属性随着对象的创建而出现]；

d.优先级不同,对象属性的优先级高于类属性。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

class person(object):   #1.定义位置   #类属性:直接定义在类中的属性   name = "person"   def __init__(self, name):     #对象属性:定义在构造方法中的属性     self.name = name #2.访问方式 print(person.name) per = person("tom") #对象属性的优先级高于类属性 print(per.name) #动态的给对象添加对象属性 per.age = 18 #只针对当前对象生效,对于类创建的其他对象没有作用 print(person.name) per2 = person("lilei") #print(per2.age) #没有age属性 #删除对象中的name属性,再调用会使用到同名的类属性 del per.name print(per.name) #注意事项:不要将对象属性与类属性重名,因为对象属性会屏蔽掉类属性,但是当删除对象属性之后,再使用就能使用到类属性了.

输出：

person
tom
person
person

3、动态添加属性和方法

正常情况下，我们定义了一个class，创建一个class的实例后，我们可以给该实例绑定任何的的属性和方法，这就是动态语言的灵活性。

python语言的特点:灵活。

这里说的动态添加属性和方法主要指的是关于slots函数的使用

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

from types import methodtype #定义一个空类 ''' class person():   pass ''' class person(object):   __slots__ = ("name","age","speak","hobby")   pass # 动态添加属性[体现了动态语言的特点:灵活性] per = person() per.name = "tom" print(per.name) #动态添加方法 def say(self):   print("my name is "+ self.name) per.speak = say per.speak(per) #这样实现不好,所以引入methodtype def hobby(self):   print("my hobby is running") per.hobby = methodtype(hobby,per) per.hobby()

输出：

tom
my name is tom
my hobby is running

但是，给一个实例绑定的方法对另外一个实例是不起作用的。

为了给所有的实例都绑定方法，可以通过给class绑定方法

?

1 2 3 4 5 6 7

#动态添加方法 def say(self,name):   self.name = name   print("my name is "+ self.name) person.speak = say per2 = person() per2.speak('hh')

输出：

my name is hh

给class绑定方法后，所有的实例均可调用。

4、slots

通常情况下，上面的say方法可以直接定义在class中，但动态绑定允许我们在程序在运行的过程中动态的给class添加功能，这在静态语言中很难实现。

如果我们想限制实例的属性怎么办?

比如，只允许给person实例添加name，age属性，为了达到限制的目的，python中允许在定义class的时候，定义一个特殊的变量【slots】变量，来限制该class添加的属性

?

1 2 3 4 5 6 7 8

class person(object):   __slots__=("name","age") #[不想无限制的任意添加属性] #比如,只允许给对象添加name, age属性 #解决:定义类的时候,定义一个特殊的属性(__slots__),可以限制动态添加的属性范围 per = person() per.height = 170 print(per.height)

这样做会报错

attributeerror: 'person' object has no attribute 'height'

使用slots的时候需要注意，slots定义的属性仅仅对当前类的实例起作用，对继承的子类是不起作用的。

除非在子类中也定义slots，这样子类实例允许定义的属性就是自身的slots加上父类的slots。

总结：

__slots__:

语法：

?

1	__slots__ = (属性名1,属性名2,...)

作用：

限制类的属性名

注意：当子类没有添加slots时，子类继承父类的时候，它的属性名不受父类的影响

若子类中也添加slots，子类的限制应该是父类的slots与子类slots的并集

5、@property

绑定属性时，如果我们直接把属性暴露出去，虽然写起来简单，但是没有办法检查参数，导致可以随意的更改。

比如：

?

1 2	p = person() p.age = -1

这显然不合常理，为了限制age的范围，我们可以通过setage()的方法来设置age，再通过getage()的方法获取age，这样在setage()中就可以检查输入的参数的合理性了。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

class person(object):   def __init__(self, name, age):     # 属性直接对外暴露     # self.age = age     # 限制访问     self.__age = age     self.__name = name     # self.__name = name   def getage(self):     return self.__age   def setage(self, age):     if age < 0:       age = 0     self.__age = age   # 通过@property和@age.setter改变原来的get/set方法   # 方法名为受限制的变量去掉双下划线   # 相当于get方法   @property   def age(self):     return self.__age   # 相当于set的方法   @age.setter # 去掉下划线.setter   def age(self, age):     if age < 0:       age = 0     self.__age = age   @property   def name(self):     return self.__name   @name.setter   def name(self, name):     self.__name = name per = person("lili", 18) # 属性直接对外暴露 # 不安全,没有数据的过滤 # per.age = -10 # print(per.age) # 使用限制访问,需要自己写set和get的方法才能访问 # 劣势:麻烦,代码不直观 # 思考问题:如果我就想使用对象"."的方式访问对象的私有属性,怎么办? # per.setage(15) # print(per.getage()) # property:可以让你对受限制访问的属性使用"."语法 per.age = 80 # 相当于调用setage print(per.age) # 相当于调用getage print(per.name)

输出：

80
lili

property

总结语法：

针对私有化的属性添加的。

?

1 2 3

@property   def 属性名(self):     return self.__属性名

?

1 2 3 4

@属性名.setter   def 属性名(self, 值):     #业务逻辑处理     self.属性名 = 值

总结:

a.装饰器(decorator)可以给函数动态加上功能,对于类的方法,装饰器一样起作用,python内置的@property装饰器就是负责把一个方法变成属性调用的。
b.@property的实现比较复杂,我们先考虑如何使用,把一个getter方法变成属性,只需要加上@property就可以了,此时@property本身又创建了另一个装饰器@属性setter,负责把一个setter方法变成属性赋值.
c.@property广泛应用在类的定义中,可以让调用者写出简短的代码,同时保证对参数进行必要的检查,这样,程序运行时就减少了出错的可能性。

6、运算符重载

类可以重载加减运算，打印，函数调用，索引等内置运算，运算符重载使我们的对象的行为与内置函数一样，在python调用时操作符会自动的作用于类的对象，python会自动的搜索并调用对象中指定的方法完成操作。

1、常见运算符重载方法

常见运算符重载方法

方法名	重载说明	运算符调用方式
init	构造函数	对象创建: x = class(args)
del	析构函数	x对象收回
add sub	加减运算	x+y， x+=y/x-y， x-=y
or	运算符|	x|y, x|=y
str_ repr	打印／转换	print(x)、repr(x)／str(x)
call	函数调用	x(*args, **kwargs)
getattr	属性引用	x.undefined
setattr	属性赋值	x.any=value
delattr	属性删除	del x.any
getattribute	属性获取	x.any
getitem	索引运算	x[key]，x[i:j]
setitem	索引赋值	x[key]，x[i:j]=sequence
delitem	索引和分片删除	del x[key]，del x[i:j]
len	长度	len(x)
bool	布尔测试	bool(x)
lt gt le ge eq ne	特定的比较	依次为xy，x<=y，x>=y， x==y，x!=y 注释：（lt: less than, gt: greater than, le: less equal, ge: greater equal, eq: equal, ne: not equal ）
radd	右侧加法	other+x
iadd	实地（增强的）加法	x+=y(or else add)
iter next	迭代	i=iter(x), next()
contains	成员关系测试	item in x(x为任何可迭代对象)
index	整数值	hex(x), bin(x), oct(x)
enter exit	环境管理器	with obj as var:
get set delete	描述符属性	x.attr, x.attr=value, del x.attr
new	创建	在init之前创建对象

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# 举例 # 数字和字符串都能相加 #print(1 + 2) #print("1" + "2") # 不同的类型用加法会有不同的解释 class person(object):   def __init__(self, num):     self.num = num   # 运算符重载   def __add__(self, other):     return person(self.num + other.num)   # 方法重写   def __str__(self):     return "num = " + str(self.num) # 如果两个对象相加会怎样? # 对象相加,编译器解释不了,所以就要用到运算符重载 per1 = person(1) per2 = person(2) print(per1 + per2) # 结果为地址:per1+per2 === per1.__add__(per2),如果想得到num的和则重写str方法 # 上述打印就等价于:print(per1.__add__(per2)),只不过add方法会自动调用 print(per1) print(per2)

输出：

num = 3
num = 1
num = 2

希望本文所述对大家python程序设计有所帮助。

原文链接：https://blog.csdn.net/lm_is_dc/article/details/80171357