类的继承
什么是继承
继承是一种新建类的方式,新建的类称为子类,被继承的类称为父亲
继承的特性是:子类会遗传父亲的属性
继承是类与类之间的关系
为什么用继承
- 使用继承可以减少代码的冗余
对象的继承
- Python中支持一个类同时继承多个父类
class Parent1:
pass
class Parent2:
pass
class Sub1(Parent1, Parent2):
pass
- 使用
__bases__
方法可以获取对象继承的类
print(Sub1.__bases__)
(<class '__main__.Parent1'>, <class '__main__.Parent2'>)
在Python3中如果一个类没有继承任何类,则默认继承object类
在Python2中如果一个类没有继承任何类,不会继承object类
print(Parent1.__bases__)
(<class 'object'>,)
类的分类
新式类
继承了object的类以及该类的子类,都是新式类
Python3中所有的类都是新式类
经典类
没有继承object的类以及该类的子类,都是经典类
只有Python2中才有经典类
继承与抽象
继承描述的是子类与父类之间的关系,是一种什么是什么的关系。要找出这种关系,必须先抽象再继承,抽象即抽取类似或者说比较像的部分。
继承:基于抽象的结果,通过编程语言去实现它,肯定是先经历抽象这个过程,才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中,一个动作或者说一种技巧,通过抽象可以得到类。
继承的应用
- 牢记对象是特征与功能的集合体
class PekingPeople:
'''由于学生和老师都是人,因此人都有姓名、年龄、性别'''
school = 'peking'
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
class PekingStudent(PekingPeople):
def choose_course(self):
print(f'{self.name} is choosing course')
class PekingTeacher(PekingPeople):
def score(self, stu_obj, num):
print(f'{self.name} is scoring')
stu_obj.score = num
stu1 = PekingStudent('tom', 18, 'male')
tea1 = PekingTeacher('jerry', 18, 'male')
- 对象查找属性的顺序:对象自己 --> 对象的类 --> 父类 --> 父类。。。
print(stu1.school)
peking
print(tea1.school)
peking
print(stu1.__dict__)
{'name': 'tom', 'age': 18, 'gender': 'male'}
tea1.score(stu1, 99)
jerry is scoring
print(stu1.__dict__)
{'name': 'tom', 'age': 18, 'gender': 'male', 'score': 99}
属性查找练习
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.f1()
class Bar(Foo):
def f1(self):
print('Bar.f1')
# 对象查找属性的顺序:对象自己 --> 对象的类 --> 父类 --> 父类。。。
obj = Bar() # self是obj本身,即找到Bar的f1()
obj.f2()
Foo.f2
Bar.f1
类的派生
派生
- 派生:子类中新定义的属性的这个过程叫做派生,并且需要记住子类在使用派生的属性时始终以自己的为准
派生方法一
- 指名道姓访问某一个类的函数:该方式与继承无关
class PekingPeople:
'''由于学生和老师都是人,因此人都有姓名、年龄、性别'''
school = 'peking'
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
class PekingStudent(PekingPeople):
'''由于学生类没有独自的__init__()方法,因此不需要声明继承父类的__init__()方法,会自动继承'''
def choose_course(self):
print(f'{self.name} is choosing course')
class PekingTeacher(PekingPeople):
'''由于老师类有独自的__init__()方法,因此需要声明继承父类的__init__()'''
def __init__(self, name, age, gender, level):
PekingPeople.__init__(self, name, age, gender)
self.level = level # 派生
def score(self, stu_obj, num):
print(f'{self.name} is scoring')
stu_obj.score = num
stu1 = PekingStudent('tom', 18, 'male')
tea1 = PekingTeacher('jerry', 18, 'male', 10)
print(stu1.__dict__)
{'name': 'tom', 'age': 18, 'gender': 'male'}
print(tea1.__dict__)
{'name': 'jerry', 'age': 18, 'gender': 'male', 'level': 10}
派生方法二
严格以继承属性查找关系
super()会得到一个特殊的对象,该对象就是专门用来访问父类中的属性的(按照继承的关系)
super().__init__(不用为self传值)
super的完整用法是super(自己的类名,self),在Python2中需要写完整,而Python3中可以简写为super()
class PekingPeople:
school = 'peking'
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
class PekingStudent(PekingPeople):
def __init__(self, name, age, gender, stu_id):
super().__init__(name, age, gender)
self.stu_id = stu_id
def choose_course(self):
print(f'{self.name} is choosing course')
stu1 = PekingStudent('tom', 19, 'male', 1)
print(stu1.__dict__)
{'name': 'tom', 'age': 19, 'gender': 'male', 'stu_id': 1}
类的组合
什么是组合
- 组合就是一个类的对象具备某一个属性,该属性的值是指向另外一个类的对象
为什么用组合
- 组合是用来解决类与类之间代码冗余的问题
class PekingPeople:
school = 'peking'
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
class PekingStudent(PekingPeople):
def __init__(self, name, age, gender, stu_id):
PekingPeople.__init__(self, name, age, gender)
self.stu_id = stu_id
def choose_course(self):
print(f'{self.name} is choosing course')
class PekingTeacher(PekingPeople):
def __init__(self, name, age, gender, level):
PekingPeople.__init__(self, name, age, gender)
self.level = level
def score(self, stu, num):
stu.score = num
print(f'老师{self.name}为学生{stu.name}打分{num}')
stu1 = PekingStudent('tom', 19, 'male', 1)
tea1 = PekingTeacher('jerry', 18, 'male', 10)
stu1.choose_course()
tom is choosing course
tea1.score(stu1, 100)
老师jerry为学生tom打分100
print(stu1.__dict__)
{'name': 'tom', 'age': 19, 'gender': 'male', 'stu_id': 1, 'score': 100}
- 上面这个选课系统需要修改、扩展,我们需要修改上述的代码
如何用组合
需求:假如我们需要给学生增添课程属性,但是又不是所有学生一进学校就有课程属性,课程属性时学生来学校后选出来的,也就是说课程需要后期学生们添加进去的
实现思路:如果直接在学生中添加课程属性,那么学生刚被定义就需要添加课程属性,这就不符合我们的要求,因此我们可以使用组合能让学生未来添加课程属性
class Course:
def __init__(self, name, period, price):
self.name = name
self.period = period
self.price = price
def tell_info(self):
msg = f'''
课程名:{self.name}
课程周期:{self.period}
课程价钱:{self.price}
'''
print(msg)
class PekingPeople:
school = 'peking'
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
class PekingStudent(PekingPeople):
def __init__(self, name, age, gender, stu_id):
PekingPeople.__init__(self, name, age, gender)
self.stu_id = stu_id
def choose_course(self):
print(f'{self.name} is choosing course')
class PekingTeacher(PekingPeople):
def __init__(self, name, age, gender, level):
PekingPeople.__init__(self, name, age, gender)
self.level = level
def score(self, stu, num):
stu.score = num
print(f'老师{self.name}为学生{stu.name}打分{num}')
# 创造课程
python = Course('python全栈开发', '5mons', 3000)
python.tell_info()
课程名:python全栈开发
课程周期:5mons
课程价钱:3000
linux = Course('linux运维', '5mons', 800)
linux.tell_info()
课程名:linux运维
课程周期:5mons
课程价钱:800
# 创造学生与老师
stu1 = PekingStudent('tom', 19, 'male', 1)
tea1 = PekingTeacher('jerry', 18, 'male', 10)
- 组合
# 将学生、老师与课程对象关联/组合
stu1.course = python
tea1.course = linux
stu1.course.tell_info()
课程名:python全栈开发
课程周期:5mons
课程价钱:3000
tea1.course.tell_info()
课程名:linux运维
课程周期:5mons
课程价钱:800
- 组合可以理解成多个人去造一个机器人,有的人造头、有的人造脚、有的人造手、有的人造驱赶,大家都完工后,造躯干的人把头、脚、手拼接到自己的躯干上,因此一个机器人便造出来了
菱形继承问题
类的分类
新式类
继承了object的类以及该类的子类,都是新式类
Python3中所有的类都是新式类
经典类
没有继承object的类以及该类的子类,都是经典类
只有Python2中才有经典类
菱形继承问题
在Java和C#中子类只能继承一个父类,而Python中子类可以同时继承多个父类,如A(B,C,D)
如果继承关系为非菱形结构,则会按照先找B这一条分支,然后再找C这一条分支,最后找D这一条分支的顺序直到找到我们想要的属性
如果继承关系为菱形结构,即子类的父类最后继承了同一个类,那么属性的查找方式有两种:
经典类下:深度优先
广度优先:广度优先
经典类:一条路走到黑,深度优先
新式类:不找多个类最后继承的同一个类,直接去找下一个父类,广度优先
class G(object):
# def test(self):
# print('from G')
pass
print(G.__bases__)
class E(G):
# def test(self):
# print('from E')
pass
class B(E):
# def test(self):
# print('from B')
pass
class F(G):
# def test(self):
# print('from F')
pass
class C(F):
# def test(self):
# print('from C')
pass
class D(G):
# def test(self):
# print('from D')
pass
class A(B, C, D):
def test(self):
print('from A')
obj = A()
(<class 'object'>,)
obj.test() # A->B->E-C-F-D->G-object
from A
C3算法与mro()方法介绍
python到底是如何实现继承的,对于你定义的每一个类,python会计算出一个方法解析顺序(MRO)列表,这个MRO列表就是一个简单的所有基类的线性顺序列表,如:
print(A.mro()) # A.__mro__
[<class '__main__.A'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.F'>, <class '__main__.D'>, <class '__main__.G'>, <class 'object'>]
for i in A.mro():
print(i)
<class '__main__.A'>
<class '__main__.B'>
<class '__main__.E'>
<class '__main__.C'>
<class '__main__.F'>
<class '__main__.D'>
<class '__main__.G'>
<class 'object'>
为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
- 子类会先于父类被检查
- 多个父类会根据它们在列表中的顺序被检查
- 如果对下一个类存在两个合法的选择,选择第一个父类
类的多态与多态性
多态
- 多态是指同一种事物的多种形态(一个抽象类有多个子类,因而多态的概念依赖于继承)
* 水 --> 冰、水蒸气、液态水
* 序列数据类型有多种形态:字符串,列表,元组
* 动物 --> 人、狗、猪
动物的多种形态
# 动物有多种形态:人类、猪、狗(在定义角度)
class Animal:
def run(self): # 子类约定俗成的必须实现这个方法
raise AttributeError('子类必须实现这个方法')
class People(Animal):
def run(self):
print('人在走')
class Pig(Animal):
def run(self):
print('pig is walking')
class Dog(Animal):
def run(self):
print('dog is running')
peo1 = People()
pig1 = Pig()
dog1 = Dog()
peo1.run()
pig1.run()
dog1.run()
人在走
pig is walking
dog is running
import abc
class Animal(metaclass=abc.ABCMeta): # 同一类事物:动物
@abc.abstractmethod # 上述代码子类是约定俗成的实现这个方法, 加上@abc.abstractmethod装饰器后严格控制子类必须实现这个方法
def speak(self):
raise AttributeError('子类必须实现这个方法')
class People(Animal): # 动物的形态之一:人
def speak(self):
print('say hello')
class Dog(Animal):
def speak(self):
print('say wangwangwang')
class Pig(Animal):
def speak(self):
print('say aoao')
peo2 = People()
pig2 = Pig()
dog2 = Dog()
peo2.speak()
pig2.speak()
dog2.speak()
say hello
say aoao
say wangwangwang
文件的多种形态
# 文件有多种形态:文件、文本文件、可执行文件(在定义角度)
import abc
# 同一类事物:文件
class File(metaclass=abc.ABCMeta):
@abc.abstractmethod
def click(self):
pass
class Text(File): # 文件的形态之一:文本文件
def click(self):
print('open file')
class ExeFile(File): # 文件的形态之二:可执行文件
def click(self):
print('execute file')
text = Text()
exe_file = ExeFile()
text.click()
exe_file.click()
open file
execute file
多态性
注意:多态与多态性是两种概念
多态性是指具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表达多态性:向不同的对象发送同一条消息,不同的对象在就收时会产生不同的行为(即方法)。也就是说,每个对象可以用自己的方式去响应共同的消息。所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。
动物形态多态性的使用
# 多态性:一种调用方式,不同的执行效果(多态性)
def func(obj):
obj.run()
func(peo1)
func(pig1)
func(dog1)
人在走
pig is walking
dog is running
# 多态性依赖于:继承
# 多态性:定义统一的接口
def func(obj): # obj这个参数没有类型限制,可以传入不同类型的值
obj.speak() # 调用的逻辑都一样,执行的结果却不一样
func(peo2)
func(pig2)
func(dog2)
say hello
say aoao
say wangwangwang
文件形态多态性的使用
def func(obj):
obj.click()
func(text)
func(exe_file)
open file
execute file
序列数据类型多态性的使用
def func(obj):
print(len(obj))
func('hello')
func([1, 2, 3])
func((1, 2, 3))
5
3
3
综上可以说,多态性是一个接口(函数func)的多种实现,如obj.run(),obj.speak(),obj.click(),len(obj)
多态性的好处
Python本身就是支持多态性的,这么做的好处是什么:
增加了程序的灵活性:以不变应万变,不论对象千变万化,使用者都是同一种形式去调用,如func(animal)
增加了程序的可扩展性:通过继承Animal类创建了一个新的类,使用者无需更改自己的代码,还是用func(animal)去调用
class Cat(Animal): # 属于动物的另一种形态:猫
def speak(self):
print('say miao')
def func(animal): # 对于使用者来说,自己的代码根本无需改动
animal.speak()
cat1 = Cat() # 实例出一只猫
func(cat1) # 甚至连调用方式也无需改变,就能调用猫的speak功能
say miao
- 上述代码新增了一个形态Cat,由Cat类产生的实例cat1,使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的speak方法,即func(cat1)
小结
多态:同一种事物的多种形态,动物分为人类,猪类(在定义角度)
多态性:一种调用方式,不同的执行效果(多态性)
为什么用多态
- 多态性:
* 继承同一个类的多个子类中有相同的方法名
* 那么子类产生的对象就可以不用考虑具体的类型而直接调用功能
多态的应用
Animal() --> 强调是用来指定标准的,不能被实例化,也就是说父类中被
@abc.abcstractmethod
装饰的方法,子类也必须要有,如果没有的话则会报错,这个拥有被装饰的方法的类称为抽象类由于动物都叫,如果人的叫使用speak();狗的叫使用bark();也就是说对于不同的动物有不同的叫方法,那么对于使用者来说,使用起来非常麻烦。因此我们可以规定人、狗的叫都为speak(),那么后面使用某个动物叫的方法,只需要调用speak即可
import abc
class Animal(metaclass=abc.ABCMeta): # 同一类事物:动物
@abc.abstractmethod
def speak(self):
print('1111')
@abc.abstractmethod
def eat(self):
pass
class People(Animal):
def speak(self):
print('say hello')
def eat(self):
pass
class Dog(Animal):
def speak(self):
print('汪汪汪')
def eat(self):
pass
class Pig(Animal):
def speak(self):
print('哼哼哼')
def eat(self):
pass
peo = People()
dog = Dog()
pig = Pig()
peo.speak()
say hello
dog.speak()
汪汪汪
pig.speak()
哼哼哼
def my_speak(animal):
animal.speak()
my_speak(peo)
my_speak(dog)
my_speak(pig)
say hello
汪汪汪
哼哼哼
数据类型中多态的应用
- 我们一一直在使用多态,列表、元组、字符串的len()方法其实就是一种多态的应用,我们不需要关心len()的数据类型,我们只要记住如果需要求一个容器类型的长度,使用len()方法就行了
l = [1, 2, 3]
s = 'hello'
t = (1, 2, 3)
print(l.__len__())
print(s.__len__())
print(t.__len__())
# 列表、字符串、元组规定了计算这些数据类型的长度就必须使用len()方法
# def len(obj):
# return obj.__len__()
3
5
3
print(len(l))
print(len(s))
print(len(t))
3
5
3
鸭子类型
Python推崇的是鸭子类型,只要你叫声像鸭子,并且你走路的样子像鸭子,那么你就是鸭子
Linux中一切皆文件,只要我们规定硬盘、进程、文件都是文件,都拥有读read()写write()方法,那我们就没必要定义一个抽象文件类,更没必要使用
@abc.abstractmethod
装饰器规定文件需要拥有这些方法,因为这不符合Python的风格
class Disk:
'''硬盘'''
def read(self):
print('disk read')
def write(self):
print('disk write')
class Process:
'''进程'''
def read(self):
print('process read')
def write(self):
print('process write')
class File:
'''文件'''
def read(self):
print('file read')
def write(self):
print('file write')
obj1 = Disk()
obj2 = Process()
obj = File()
obj1.read()
obj1.write()
disk read
disk write
类的封装
什么是封装
封:类的属性对外是隐藏的,但是对内是开放的,类似于一个封闭的容器
装:定义类时会申请一个名称空间,往里装入一系列名字/属性
封装什么
你钱包的有什么钱(数据的封装)
你吃饭具体怎么实现的(方法的封装)
为什么要封装
封装数据的主要原因是:保护隐私
封装方法的主要原因是:隔离复杂度
提示:在编程语言里,对外提供的接口(接口可理解为了一个入口),就是函数,称为接口函数,这与接口的概念还不一样,接口代表一组接口函数的集合体。
两个层面的封装
封装其实分为两个层面,但无论哪种层面的封装,都要对外界提供访问你内部隐藏内容的接口(接口可以理解为入口,有了这个入口,使用者无需且不能够直接访问到内部隐藏的细节,只能走接口,并且我们可以在接口的实现上附加更多的处理逻辑,从而严格控制使用者的访问)
第一个层面
第一个层面的封装(什么都不用做):创建类和对象会分别创建二者的名称空间,我们只能用类名,或者obj.的方法去访问里面的名字,这本身就是一种封装
注意:对于这一层面的封装(隐藏),类名和实例名就是访问隐藏属性的接口
第二个层面
第二个层面的封装:类中把某些属性和方法隐藏起来(或者说定义成私有的),只在类的内部使用、外部无法访问,或者留下少量接口(函数)供外部访问。
在python中用双下划线的方式实现隐藏属性(设置成私有的)
类中所有双下划线开头的名称如__x
都会自动变形成:_类名__x
的形式:
class A:
__N = 0 # 类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形成_A__N
def __init__(self):
self.__X = 10 # 变形为self._A__X
def __foo(self): # 变形为_A__foo
print('form A')
def bar(self):
self.__foo() # 只有在类内部才可以通过__foo的形式访问到
这种自动变形的特点:
- 类中定义的
__x
只能在内部使用,如self.__x
,引用的就是变形的结果。 - 这种变形其实正是针对内部的变形,在外部是无法通过
__x
这个名字访问到。 - 在子类定义的
__x
不会覆盖在父类定义的__x
,因为子类中变形成了:_子类名__x
,而父类中形成了:_父类名__x
,即双下划线开头的属性在继承给子类时,子类是无法覆盖的。
注意:对于这一层面的封装(隐藏),我们需要在类中定义一个函数(接口函数)在它内部访问被隐藏的属性,然后外部就可以使用了
这种变形需要注意的问题是:
- 这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类属性名就可以拼出名字:
_类名__属性
,然后就可以访问了,如a._A__N
a = A()
print(a._A__N)
0
print(a._A__X)
10
print(A._A__N)
0
- 变形的过程只在类的定义时发生一次,在定义后的赋值操作,不会变形
a = A()
print(a.__dict__)
{'_A__X': 10}
a.__Y = 1
print(a.__dict__)
{'_A__X': 10, '__Y': 1}
- 在继承中,父类如果不想让子类覆盖自己的方法,可以将方法定义为私有的
# 正常情况
class A:
def fa(self):
print('from A')
def test(self):
self.fa()
class B(A):
def fa(self):
print('from B')
b = B()
b.test()
from B
# 把fa定义成私有的,即__fa
class A:
def __fa(self): # 在定义时就变形为_A__fa
print('from A')
def test(self):
self.__fa() # 只会与自己所在的类为准,即调用_A__fa
class B(A):
def __fa(self):
print('from B')
b = B()
b.test()
from A
私有模块
python并不会真的阻止你访问私有的属性,模块也遵循这种约定,如果模块中的变量名_private_module
以单下划线开头,那么from module import *
时不能被导入该变量,但是你from module import _private_module
依然是可以导入该变量的
其实很多时候你去调用一个模块的功能时会遇到单下划线开头的socket._socket,sys._home,sys._clear_type_cache
,这些都是私有的,原则上是供内部调用的,作为外部的你,一意孤行也是可以用的
python要想与其他编程语言一样,严格控制属性的访问权限,只能借助内置方法如__getattr__
注:__名字
,这种语法只在定义的时候才有变形的效果,如果类或对象已经产生了,就不会有变形得效果了。
类的property特性
什么是property特性
- property装饰器用于将被装饰的方法伪装成一个数据属性,在使用时可以不用加括号而直接使用
####### 定义 #######
class Foo:
def func(self):
pass
# 定义property属性
@property
def prop(self):
pass
####### 调用 #######
foo_obj = Foo()
foo_obj.func() # 调用实例方法
foo_obj.prop # 调用property属性
如下的例子用于说明如何定一个简单的property属性:
class Goods(object):
@property
def size(self):
return 100
g = Goods()
print(g.size)
100
property属性的定义和调用要注意一下几点:
- 定义时,在实例方法的基础上添加@property装饰器,并且仅有一个self参数
- 调用时,无需括号
简单示例
对于京东商城中显示电脑主机的列表页面,每次请求不可能把数据库中的所有内容都显示到页面上,而是通过分页的功能局部显示,所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据 这个分页的功能包括:
- 根据用户请求的当前页和总数据条数计算出 m 和 n
- 根据m 和 n 去数据库中请求数据
############ 定义 ##########
class Pager:
def __init__(self, current_page):
# 用户当前请求的页码(第一页、第二页...)
self.current_page = current_page
# 每页默认显示10条数据
self.per_items = 10
@property
def start(self):
val = (self.current_page - 1)*self.per_items
return val
@property
def end(self):
val = self.current_page * self.per_items
return val
########### 调用 #############
p = Pager(1)
p.start # 就是起始值,即:m
p.end # 就是结束值,即:n
10
从上述可见Python的property属性的功能是:property属性内部进行一系列的逻辑计算,最终将计算结果返回。
property属性的两种方式
- 装饰器 即:在方法上应用装饰器(推荐使用)
- 类属性 即:在类中定义值为property对象的类属性(Python2历史遗留)
装饰器
在类的实例化方法上应用@property装饰器
Python中的类有经典类和新式类,新式类的属性比经典类的属性丰富。(如果类继承object,那么该类是新式类)
经典类,具有一种@property装饰器:
########## 定义 ##########
class Goods:
@property
def price(self):
return 'laowang'
########## 调用 ########
obj = Goods()
result = obj.price # 自动执行 @property 修饰的price方法,并获取方法的返回值
print(result)
laowang
新式类,具有三种@property装饰器:
# coding = utf-8
############ 定义 ##########
class Goods:
'''
python3中默认继承object类
以Python2,3执行此程序的结果不同,因为只有在Python3中才有
@xxx.setter @ xxx.deleter
'''
@property
def price(self):
print('@property')
@price.setter
def price(self, value):
print('@price.setter')
@price.deleter
def price(self):
print('@price.deleter')
########## 调用 ############
obj = Goods()
obj.price # 自动执行@property修饰price方法,并获取方法的返回值
obj.price = 123 # 自动执行@price.setter修饰的price方法,并将123赋值给方法的参数
del obj.price # 自动执行@price.deleter修饰的price方法
@property
@price.setter
@price.deleter
注意:
经典类中的属性只有一种访问方式,其对应被@property修饰的方法
新式类中的属性有三种访问方式,并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法
由于新式类中具有三种访问方式,我们可以根据它们几个属性访问特点,分别将三个方法定义为对同一个属性:获取、修改、删除
class Goods(object):
def __init__(self):
self.original_price = 100
self.discount = 0.8
@property
def price(self):
new_price = self.original_price * self.discount
return new_price
@price.setter
def price(self, value):
self.original_price = value
@price.deleter
def price(self):
del self.original_price
obj = Goods()
obj.price
obj.price = 200
del obj.price
类属性方式
创建值为property对象的类属性
注意:当使用类属性的方式创建property属性时,经典类和新式类无区别
class Foo:
def get_bar(self):
return 'laowang'
BAR = property(get_bar)
obj = Foo()
result = obj.BAR # 自动调用get_bar方法,并获取方法的返回值
print(result)
laowang
property方法中有四个参数
第一个参数是方法名,调用
对象.属性
时自动触发执行方法第二个参数是方法名,调用
对象.属性 = xxx
时自动触发执行方法第三个参数是方法名,调用
del 对象.属性
时自动触发执行方法第四个参数是字符串,调用
对象.属性.__doc__
,此参数是属性的描述信息
# coding = utf-8
class Foo(object):
def get_bar(self):
print('getter...')
return 'laowang'
def set_bar(self, value):
'''必须两个参数'''
print('setter...')
return 'set value' + value
def del_bar(self):
print('deleter...')
return 'laowang'
BAR = property(get_bar, set_bar, del_bar, 'description...')
obj = Foo()
obj.BAR
obj.BAR = 'alex'
desc = Foo.BAR.__doc__
print(desc)
del obj.BAR
getter...
setter...
description...
deleter...
定义property属性共有两种方式,分别是【装饰器】和【类属性】,而【装饰器】方法针对经典类和新式类又有所不同。
通过使用property属性,能够简化调用者在获取数据的流程
property + 类的属性
class People:
def __init__(self, name):
self.__name = name
@property # 查看obj.name
def name(self):
return F'<名字是{self.__name}>'
peo1 = People('tom')
print(peo1.name)
<名字是tom>
try:
peo1.name = 'jerry'
except Exception as e:
print(e)
can't set attribute
应用
私有属性添加getter和setter方法
class Money(object):
def __init__(self):
self.__money = 0
def getMoney(self):
return self.__money
def setMoney(self, value):
if isinstance(value, int):
self.__money = value
else:
print('error:不是整型数据')
使用property升级getter和setter方法
class Money(object):
def __init__(self):
self.__money = 0
def getMoney(self):
return self.__money
def setMoney(self, value):
if isinstance(value, int):
self.__money = value
else:
print('error:不是整型数据')
# 定义一个数据,当对这个money设置值时调用setMoney,当获取值时调用getMoney
money = property(getMoney, setMoney)
a = Money()
a.money = 100 # 调用setMoney方法
print(a.money) # 调用getMoney方法
100
使用property取代getter和setter方法
重新实现一个属性的设置和读取方法,可做边界判定
class Money(object):
def __init__(self):
self.__money = 0
# 使用装饰器对money进行装饰,那么会自动添加一个叫money的属性,当调用获取money的值时,调用装饰的方法
@property
def money(self):
return self.__money
# 使用装饰器对money进行装饰,当对money设置值时,调用装饰的方法
@money.setter
def money(self, value):
if isinstance(value, int):
self.__money = value
else:
print("error:不是整型数字")
a = Money()
a.money = 100
print(a.money)
100
练习
计算圆的周长和面积
import math
class Circle:
def __init__(self, radius): # 圆的半径radius
self.radius = radius
@property
def area(self):
return math.pi * self.radius**2
@property
def perimeter(self):
return 2 * math.pi * self.radius
c = Circle(10)
print(c.radius)
10
print(c.area) # 可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
314.1592653589793
print(c.perimeter)
62.83185307179586
类与对象的绑定方法和非绑定方法
类中定义的方法大致可以分为两类:绑定方法和非绑定方法。其中绑定方法又可以分为绑定到对象的方法和绑定到类的方法。
绑定方法
对象的绑定方法
在类中没有被任何装饰器修饰的方法就是 绑定到对象的方法,这类方法专门为对象定制。
class People:
country = 'China'
def __init__(self, name, age):
self.name = name
self.age = age
def speak(self):
print(self.name + ',' + str(self.age))
p = People('Kitty', 18)
print(p.__dict__)
{'name': 'Kitty', 'age': 18}
print(People.__dict__['speak'])
<function People.speak at 0x000001C6F66D7B70>
speak即为绑定到对象的方法,这个方法不在对象的名称空间中,而是在类的名称空间中。
通过对象调用绑定到对象的方法,会有一个自动传值的过程,即自动将当前对象传递给方法的第一个参数(self,一般都叫self,也可以写成别的名称);若是使用类的调用,则第一个参数需要手动传值。
peo = People('tom', 18)
peo.speak() # 通过对象调用
tom,18
People.speak(p) # 通过类调用
Kitty,18
类的绑定方法
类中使用@classmethod修饰的方法就是绑定到类的方法。这类方法专门为类定制。通过类名调用绑定到类的方法时,会将类本身当作参数传给类方法的第一个参数。
class Operate_database():
host = '192.168.0.5'
port = '3306'
user = 'abc'
password = '123456'
@classmethod
def connect(cls):
print(cls)
print(cls.host + ':' + cls.port + ' ' + cls.user + '/' + cls.password)
Operate_database.connect()
<class '__main__.Operate_database'>
192.168.0.5:3306 abc/123456
通过对象也可以调用,只是默认传递的第一个参数还是这个对象对应的类。
Operate_database().connect() # 输出结果一致
<class '__main__.Operate_database'>
192.168.0.5:3306 abc/123456
非绑定方法
在类内部使用@staticmethod修饰的方法即为非绑定方法,这类方法和普通定义的函数没有区别,不与类或对象绑定,谁都可以调用,且没有自动传值的效果。
import hashlib
class Operate_database():
def __init__(self, host, port, user, password):
self.host = host
self.port = port
self.user = user
self.password = password
@staticmethod
def get_password(salt, password):
m = hashlib.md5(salt.encode('utf8')) # 加盐处理
m.update(password.encode('utf8'))
return m.hexdigest()
hash_password = Operate_database.get_password('lala', '123456') # 通过类调用
print(hash_password)
f7a1cc409ed6f51058c2b4a94a7e1956
p = Operate_database('192.168.0.5', '3306', 'abc', '123456')
hash_password = p.get_password(p.user, p.password) # 也可以通过对象调用
print(hash_password)
0659c7992e268962384eb17fafe88364
非绑定方法就是将普通方法放到了类的内部。
练习
假设我们现在有一个需求,需要让Mysql实例化的对象可以从文件setting.py中读取数据。
# settings.py
IP = '1.1.1.10'
PORT = 3306
NET = 27
# test.py
import uuid
class Mysql:
def __init__(self, ip, port, net):
self.uid = self.create_uid()
self.ip = ip
self.port = port
self.net = net
def tell_info(self):
"""查看ip地址和端口号"""
print('%s:%s' % (self.ip, self.port))
@classmethod
def from_conf(cls):
return cls(IP, NET, PORT)
@staticmethod
def func(x, y):
print('不与任何人绑定')
@staticmethod
def create_uid():
"""随机生成一个字符串"""
return uuid.uuid1()
# 默认的实例化方式:类名()
obj = Mysql('10.10.0.9', 3307, 27)
obj.tell_info()
10.10.0.9:3307
绑定方法小结
如果函数体代码需要用外部传入的类,则应该将该函数定义成绑定给类的方法
如果函数体代码需要用外部传入的对象,则应该将函数定义成绑定给对象的方法
# 一种新的实例化方式:从配置文件中读取配置完成实例化
obj1 = Mysql.from_conf()
obj1.tell_info()
1.1.1.10:27
print(obj.tell_info)
<bound method Mysql.tell_info of <__main__.Mysql object at 0x000001C6F686E080>>
print(obj.from_conf)
<bound method Mysql.from_conf of <class '__main__.Mysql'>>
非绑定方法小结
如果函数体代码既不需要外部传入的类也不需要外部传入的对象,则应该将函数定义成非绑定方法/普通函数
obj.func(1, 2)
不与任何人绑定
Mysql.func(3, 4)
不与任何人绑定
print(obj.func)
<function Mysql.func at 0x000001C6F672D598>
print(Mysql.func)
<function Mysql.func at 0x000001C6F672D598>
print(obj.uid)
05a7846c-94bc-11e9-8895-20898491368f