Python基础篇——Day8
Python基础篇——Day8
- 方法重载
- 方法的动态性
- 私有属性和私有方法（实现封装）
- @property 装饰器
- 面向对象三大特征
-
- 继承
-
- 类成员的继承和重写
- 重写__str__()方法
- super()方法
- 多重继承
- 多态
- 组合
- 特殊属性
方法重载
不像其它语言（如JAVA），在Python中没有方法的重载，定义多个同名的方法，只有最后一个生效
方法的动态性
Python是动态语言，我们可以动态地为类添加新的方法，或者动态地修改类已有的方法
操作示例：
'''
测试方法的动态性
'''
class Person:
def work(self):
print("work hard!")
def play(s):
print("play hard!")
def work2(s):
print("work harder!")
>>>p=Person()
>>>p.play() # 此时p对象中没有play方法
AttributeError: 'Person' object has no attribute 'play'
>>>Person.play=play # 为类添加新方法
>>>p.play()
play hard!
>>>Person.work=work2 # 修改类原有的方法
p.work()
work harder!
'''
注意，play(s)和work(s)函数中带有参数s，这是必须得有的，因为当把它们
添加到类中时，该参数相当于self
'''
私有属性和私有方法（实现封装）
！方法的本质也是属性，只不过可以通过()调用而已
Python对于类的成员没有严格的访问控制限制，这与其它面向对象的语言有区别（如JAVA），关于私有属性和私有方法，其要点如下：
- 约定两个下划线开头的属性是私有属性（private），其它是公共属性（public）
- 类内部可以直接访问私有属性（方法）
- 类外部不能直接访问，若想访问，可通过如下形式访问：
_类名__私有属性（方法）名
操作示例：
'''
测试私有属性
'''
class Person:
def __init__(self,name,age):
self.name=name
self.__age=age
>>>e=Person("Tom",18)
>>>print(e.name)
Tom
>>>print(e.age) # 因为age已经私有化，所以无法直接访问
AttributeError: 'Person' object has no attribute 'age'
>>>e._Person__age
18
@property 装饰器
@property可以将一个方法的调用方式变成“属性调用”
操作示例：
'''
测试@property装饰器
'''
class Person:
@property
def work(self):
print("work hard!")
>>>a=Person()
>>>a.work
work hard! # 看起来就像是属性一样，但是这里不能赋值哦！
'''
稍微复杂一些
'''
class Person:
def __init__(self,name,age):
self.__name=name
self.__age=age
@property
def age(self):
return self.__age
@age.setter
def age(self,age):
if age>=0:
self.__age=age
else:
print("wrong age!")
#@age.setter用于表示这里要给age赋值了
'''
def getAge(self):
return self.__age
def setAge(self,age):
if age>=0:
self.__age=age
else:
print("wrong age!")
'''
>>>p=Person("Tom",18)
>>>p.age
18
>>>p.age=20
>>>p.age
20
面向对象三大特征
- 封装（隐藏）
隐藏对象的属性和实现细节，只对外提供必要的方法，Python追求简洁的语法，通过私有属性和方法实现封装，但是没有严格的“访问控制符” - 继承
使子类具有父类的特性，提高了代码的重用性，在原有父类功能设计不变的情况下，可以增加新功能 - 多态
同一方法调用由于对象不同会产生不同的行为，比如说，同样是休息方法，由于人的不同而产生不同的行为
继承
语法格式：
class 子类名(父类1[,父类2，...]):
类体
一个子类可以有多个直接的父类
要点：
- 如果在类的定义中没有出现父类，则默认父类是object类，即，object类是所有类的父类
- 定义子类时，逻辑上必须在其构造函数中调用父类的构造函数，格式：
父类名.__init__(self,参数列表)
操作示例：
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
def getAge(self):
print("age is: ",self.age)
class Student(Person): # 继承父类
def __init__(self,name,age,score):
# 必须显式地调用父类构造函数，不然解释器不会自动调用
Person.__init__(self,name,age)
self.score=score
'''
注意：对于父类中私有的属性和方法，子类可以继承，但无法直接使用，但可以
通过_类名__属性名方式访问
'''
类成员的继承和重写
- 成员继承：子类继承了父类除构造方法之外的所有成员
- 方法重写：子类可以重新定义父类的方法，这样就会覆盖父类的方法，称为“重写”
操作示例：
'''
重写父类中的方法
'''
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
def getAge(self):
print("age is: ",self.age)
class Student(Person): # 继承父类
def __init__(self,name,age,score):
# 必须显式地调用父类构造函数，不然解释器不会自动调用
Person.__init__(self,name,age)
self.score=score
def getAge(self):
print("cannot get age!")
>>>p=Student("Tom",18,20)
>>>p.getAge()
cannot get age!
>>>dir(p) # dir()方法获取子类中所有的成员信息
['_Person__age', '__class__', '__delattr__', '__dict__', \
'__dir__', '__doc__', '__eq__', '__format__', '__ge__', \
'__getattribute__', '__gt__', '__hash__', '__init__', \
'__init_subclass__', '__le__', '__lt__', '__module__',\
'__ne__', '__new__', '__reduce__', '__reduce_ex__',\
'__repr__', '__setattr__', '__sizeof__', '__str__', \
'__subclasshook__', '__weakref__', 'getAge', 'name', 'score']
重写__str__()方法
object类中有一个__str__() 方法，可以返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮助我们查看对象的信息，__ str __() 可以被重写
操作示例：
class Person:
def __init__(self,name):
self.name=name
def __str__(self):
return "the name is: {0}".format(self.name)
>>>p=Person("Tom")
>>>print(p)
the name is: Tom
super()方法
在子类中，如果想要获得父类的方法时，我们可以通过super()来做
super()代表父类的定义，而不是父类对象
操作示例：
'''
测试super()方法
'''
class A:
def say(self):
print("A:")
class B(A):
def say(self):
# A().say()
super().say()
print("B:")
>>>B().say()
A
B
多重继承
Python支持多重继承，一个子类可以有多个“直接父类”，这样，就具备了多个父类的特点，但是，这样会被“类的整体层次”搞的非常复杂，所以应该谨慎使用
操作示例：
'''
多重继承
'''
class A:
def aa(self):
print("aa")
class B:
def bb(self):
print("bb")
class C(B,A):
def cc(self):
print("cc")
>>>k=C()
>>>k.aa()
aa
>>>k.bb()
bb
>>>k.cc()
cc
Python中支持多重继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将按“从左向右”的顺序搜索
多态
多态时指同一种方法调用由于对象不同可能产生不同的行为。需要注意的是：
- 多态是方法的多态而不是属性的多态
- 多态的存在有两个必要条件，即继承和方法重写
操作示例：
class Man:
def eat(self):
print("eat")
class Chinese(Man):
def eat(self):
print("chopsticks")
class English(Man):
def eat(self):
print("forks")
class Indian(Man):
def eat(self):
print("hand")
def manEat(m):
if isinstance(m,Man): # 判断对象是不是指定类型
m.eat()
else:
print("no")
>>>manEat(Chinese())
chopsticks
>>>manEat(English())
forks
>>>manEat(Indian())
hand
组合
组合和继承：
- 继承是“is-a”关系，继承使得子类拥有父类的方法和属性
- 组合式“has-a”关系，实现的是一个类拥有另一个类的方法和属性
'''
测试组合
'''
class A1:
def say(self):
print("say")
class B1:
def __init__(self,a):
self.a=a
>>>a1=A1()
>>>b1=B1(a1)
>>>b1.a.say()
say
特殊属性
Python对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。常见的特殊属性有：
# 查看对象的属性与方法
obj.__dict__
# 查看对象所属的类
obj.__class__
# 查看类的基类元组
class.__bases__
# 查看类的基类,哪个父类写在前就返回哪个
class.__base__
# 查看类的层次结构
class.__mro__
# 查看子类列表
class.__subclasses__()