(补 6-1)
方法没有重载
Python中没有方法的重载!!
定义一个方法即可有多种调用方式,
相当于其他语言中的方法的重载。
在类体中定义了多个重名的方法,只有最后一个方法有效。
建议:不要使用重名的方法!
方法的动态性
可以动态的为类添加新的方法,
或者动态的修改类的已有的方法。
class Person:
def work(self):
print("work hard!")
def play_game(self):
print("{0}paly game".format(self))
def work2(s):
print("work hard!play game!")
Person.play = play_game # 新增方法
Person.work = work2 # 修改已有方法
p = Person()
p.play()
p.work
# 结果:
# Person 动态的新增了 play_game 方法,work2 替换了 work方法。
私有属性和私有方法(实现封装)
Python对于类的成员 没有 严格的访问控制限制。
私有属性和私有方法:
1. 两个下划线开头的属性是私有的(private)。其他为公共的(public)
2. 类内部可以访问私有属性(方法),类外部不能直接访问私有属性(方法)
3. 类外部可以通过“_类名 私有属性(方法)名”访问私有属性(方法)
4. 方法本质上也是属性!只不过是可以通过()执行。所以,此处也是私有方法和公有方法的用法。
@property 装饰器
@property可以将一个方法的调用方式变成“属性调用”。
class Employee:
@property
def salary(self):
return 30000
emp1 = Employee()
print(emp1.salary) # 将方法像属性一样调用了
# print(type(emp1.salary))
几个实例比较 体会一下
# 一个普普通通的脑子 想到的普普通通的类的调用
# 犯了一堆普普通通的错误
class Employee:
def __init__(self,name,salary):
self.name = name
self.salary = salary
empl = Employee('hhh',1000)
print(empl.name)
print(empl.salary)
empl.salary = -2000 # 这样搞:属性都没有私有,那用户都随便改你的内容了
print (empl.salary)
# 高级了一点,知道封装起来了
class Employee:
def __init__(self,name,salary):
self.name = name
self.__salary = salary
def get_salary(self):
return self.__salary # 此时,__salary为私有属性
def set_salary(self,salary):
if 1000<salary<20000: # 写顺手了 别忘了python里 if等没有括号
self.__salary = salary
else:
print("工资范围输入错误!应该在1000~20000内")
empl = Employee('hhh',1000)
print(empl.get_salary())
empl.set_salary(5000)
print(empl.get_salary())
# 用@property 实现 对方法像属性一样调用
class Employee:
def __init__(self,name,salary):
self.name = name
self.__salary = salary
@property
def salary(self):
return self.__salary
@salary.setter
def salary(self,salary): # 这里参数还有一个输入变量salary呢 别忘了!!
if 1000 < salary < 20000:
self.__salary = salary
else:
print("工资范围输入错误!应该在1000~20000内")
empl = Employee('hhh', 1000)
print(empl.salary)
empl.salary = 5000
print(empl.salary)
6-2 面向对象(进阶)
6-2.1 面向对象三大特征介绍
继承、封装(隐藏)、多态。
- 封装(隐藏)
只对外暴露“相关调用方法”。
Python追求简洁的语法,没有严格的语法级别的“访问控制符”,更多的是依靠程序员自觉实现。
-
继承
继承可以让子类具有父类的特性,提高了代码的重用性。
-
多态
多态是指同一个方法调用由于对象不同会产生不同的行为。
6-2.1.1 继承
实现“代码复用”。
已有的类,我们称为“父类或者基类”,新的类,我们称为“子类或者派生类”(直接具备了已有类的特征)。
-
Python 支持多重继承,一个子类可以继承多个父类。
如果在类定义中没有指定父类,则默认父类是object类。 也就是说,object是所有类的父类。 object里面定义了一些所有类共有的默认实现,比如:_new_()。
# 继承的简单例子
class Person:
def __init__(self,name,age): # 别又忘了添加变量!!
self.name = name
# self.age = age
# 如果把 age 改成私有属性
self.__age = age
def say_age(self):
# print (self.name,"的年龄是:",self.age)
print ("{0}的年龄是:{1}".format(self.name,self.age))
class Student(Person):
def __init__(self,name,age,score):
self.score = score # 子类的私有属性
Person.__init__(self,name,age) # 调用父类的初始化构造器
# 想要继承 必须显式的调用父类的初始化方法,不然解释器不会去调用
s1 = Student("xxx",16,100)
# s1.say_age() # 注意这里也因为私有的原因不能用了!
# print (s1.age) # 会报错 因为age 为私有属性 不能这么调用了!
# 怎么用呢?用dir()看s1现在的属性 然后复制粘贴显示!
print (dir(s1)) # 显示s1有哪些属性
print (s1._Person__age)
类成员的继承和重写
-
成员继承:子类继承了父类除构造方法之外的所有成员。
-
方法重写:子类可以重新定义父类中的方法,这样就会覆盖父类的方法,也称为“重写”
查看类的继承层次结构
通过类的方法mro()或者类的属性 mro 可以输出这个类的继承层次结构。
object 根类
dir()查看对象属性
重写 str ()方法
object 有一个 str()方法,用于返回一个对于“对象的描述”
print()方法,帮助我们查看对象的信息。
str()可以重写。
多重继承
Python支持多重继承,一个子类可以有多个“直接父类”。
异常复杂,尽量避免使用。
MRO()
Python支持多继承,如果父类中有相同名字的方法,在子类没有指定父类名时
print(C.mro())
解释器将
==“从左向右”==按顺序搜索。
MRO(Method Resolution Order):方法解析顺序。
通过mro()方法获得“类的层次结构”
方法解析顺序也是按照这个“类的层次结构”寻找的。
super()获得父类定义
在子类中获得父类的方法
super()代表父类的定义,不是父类对象。
(即:子类和父类找到的是一个东西,没有新建对象)
# 子类中:
# 这两种都可
A.say(self)
super().say()
6-2.1.2 多态
不同实现。
注:
-
多态是方法的多态,属性没有多态。
-
多态的存在有 2 个必要条件:继承、方法重写。
6-2.1.3 特殊方法和运算符重载
- Python 的运算符实际上是通过调用对象的特殊方法实现的。
我们可以重写上面的特殊方法,即实现了“运算符的重载”。
class Person:
def init (self,name):
self.name = name
def add (self, other):
if isinstance(other,Person):
return "{0}--{1}".format(self.name,other.name)
else:
return "不是同类对象,不能相加"
def mul (self, other):
if isinstance(other,int):
return self.name*other
else:
return "不是同类对象,不能相乘"
p1 = Person("baba")
p2 = Person("son")
x = p1 + p2 print(x)
print(p1*3)
# 结果
# baba--son
# sonsonson
特殊属性
对象的浅拷贝和深拷贝
-
变量的赋值操作
只是形成两个变量,实际还是指向同一个对象。
-
浅拷贝
Python拷贝一般都是浅拷贝。
拷贝时,对象包含的子对象内容不拷贝。
因此,源对象和拷贝对象会引用同一个子对象。
-
深拷贝
使用 copy 模块的 deepcopy 函数,递归拷贝对象中包含的子对象。
源对象和拷贝对象所有的子对象也不同。
组合
-
“is-a”关系,使用“继承”。
dog is animal。 狗类就应该继承动物类。
-
“has-a”关系,使用“组合”。
MobilePhone has a CPU. 手机拥有 CPU。
6-2.1.4 设计模式_工厂模式实现
设计模式是面向对象语言特有的内容,是我们在面临某一类问题时候固定的做法。
设计模式有很多种,比较流行的是:GOF(Goup Of Four)23种设计模式
对于初学者,我们学习两个最常用的模式:工厂模式和单例模式。
-
工厂模式
实现了创建者和调用者的分离, 使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。
-
单例模式
核心作用是确保一个类只有一个实例, 并且提供一个访问该实例的全局访问点。
单例模式只生成一个实例对象.
单例模式有多种实现的方式,
推荐重写 new ()的方法。
设计模式称之为“模式”,就是一些固定的套路。