【轻松学】Python面向对象编程——类的设计、基础语法、继承、多态、类属性和类方法、单例设计
文章目录
- 1. 类的设计
- 大驼峰命名法
- 1.1 类名的确定
- 1.2 属性和方法的确定
- 练习 1.1
- 练习 1.2
- 2. 面相对象基础语法
- 2.1 定义简单的类(只包含方法)
- 2.1.1 定义只包含方法的类
- 2.1.2 创建对象
- 2.1.3 第一个面向对象程序
- 2.2 方法中的 `self` 参数
- 2.2.1 案例改造 —— 给对象增加属性
- 2.2.2 使用 `self` 在方法内部输出每一只猫的名字
- 2.3 初始化方法
- 2.3.1 在初始化方法内部定义属性
- 2.3.2 改造初始化方法 —— 初始化的同时设置初始值
- 2.4 内置方法和属性
- 2.4.1 `__del__` 方法(知道)
- 2.4.2 `__str__` 方法(☆☆☆重要)
- 2.5 身份运算符
- is 与 == 的区别:
- 2.6 私有属性和私有方法
- 2.6.1 应用场景及定义方式
- 2.6.2 伪私有属性和私有方法(科普)
- 3. 面向对象三大特性之——继承
- 3.1 单继承
- 3.1.1 继承的概念、语法和特点
- 1) 继承的语法
- 2) 专业术语
- 3) 继承的传递性
- 3.1.2 方法的重写
- 1) 覆盖父类的方法
- 2) 对父类方法进行 **扩展**
- 关于 `super`
- 3.2 多继承
- 3.2.1 多继承的使用注意事项
- Python 中的 MRO —— 方法搜索顺序(知道)
- 3.2.2 新式类与旧式(经典)类
- 4. 面向对象三大特性之——多态
- 多态案例演练
- 5. 类属性和类方法
- 5.1 类的结构
- 5.1.1 术语 —— 实例
- 5.1.2 类是一个特殊的对象
- 5.2 类属性和实例属性
- 5.2.1 概念和使用
- 5.2.2 属性的获取机制(科普)
- 5.3 类方法和静态方法
- 5.3.1 类方法
- 5.3.2 静态方法
- 5.3.3 方法综合案例
- 案例小结
- 6. 单例
- 6.1 单例设计模式
- 单例设计模式的应用场景
- 6.2 `__new__` 方法
- 6.3 Python 中的单例
- 6.4 如何只执行一次初始化工作
1. 类的设计
在使用面相对象开发前,应该首先分析需求,确定一下,程序中需要包含哪些类!
在程序开发中,要设计一个类,通常需要满足以下三个要素:
- 类名 这类事物的名字,满足大驼峰命名法
- 属性 这类事物具有什么样的特征
- 方法 这类事物具有什么样的行为
大驼峰命名法
CapWords
- 每一个单词的首字母大写
- 单词与单词之间没有下划线
1.1 类名的确定
名词提炼法 分析 整个业务流程,出现的 名词,通常就是找到的类
1.2 属性和方法的确定
- 对 对象的特征描述,通常可以定义成 属性
- 对象具有的行为(动词),通常可以定义成 方法
提示:需求中没有涉及的属性或者方法在设计类时,不需要考虑
练习 1.1
需求
- 小明 今年 18 岁,身高 1.75,每天早上 跑 完步,会去 吃 东西
- 小美 今年 17 岁,身高 1.65,小美不跑步,小美喜欢 吃 东西
练习 1.2
需求
- 一只 黄颜色 的 狗狗 叫 大黄
- 看见生人 汪汪叫
- 看见家人 摇尾巴
2. 面相对象基础语法
2.1 定义简单的类(只包含方法)
面向对象 是 更大 的 封装,在 一个类中 封装 多个方法,这样 通过这个类创建出来的对象,就可以直接调用这些方法了!
2.1.1 定义只包含方法的类
- 在
Python
中要定义一个只包含方法的类,语法格式如下:
class 类名:def 方法1(self, 参数列表):passdef 方法2(self, 参数列表):pass
- 方法 的定义格式和之前学习过的函数 几乎一样
- 区别在于第一个参数必须是
self
,大家暂时先记住,稍后介绍self
注意:类名 的 命名规则 要符合 大驼峰命名法
2.1.2 创建对象
- 当一个类定义完成之后,要使用这个类来创建对象,语法格式如下:
对象变量 = 类名()
2.1.3 第一个面向对象程序
需求
- 小猫 爱 吃 鱼,小猫 要 喝 水
分析
- 定义一个猫类
Cat
- 定义两个方法
eat
和drink
- 按照需求 —— 不需要定义属性
class Cat:"""这是一个猫类"""def eat(self):print("小猫爱吃鱼")def drink(self):print("小猫在喝水")tom = Cat()
tom.drink()
tom.eat()
输出:
2.2 方法中的 self
参数
2.2.1 案例改造 —— 给对象增加属性
- 在
Python
中,要 给对象设置属性,非常的容易,但是不推荐使用- 因为:对象属性的封装应该封装在类的内部
- 只需要在 类的外部的代码 中直接通过
.
设置一个属性即可
注意:这种方式虽然简单,但是不推荐使用!
tom.name = "Tom"
...lazy_cat.name = "大懒猫"
2.2.2 使用 self
在方法内部输出每一只猫的名字
由 哪一个对象 调用的方法,方法内的
self
就是 哪一个对象的引用
- 在类封装的方法内部,
self
就表示 当前调用方法的对象自己 - 调用方法时,程序员不需要传递
self
参数 - 在方法内部
- 可以通过
self.
访问对象的属性 - 也可以通过
self.
调用其他的对象方法
- 可以通过
- 改造代码如下:
class Cat:def eat(self):print("%s 爱吃鱼" % self.name)tom = Cat()
tom.name = "Tom"
tom.eat()lazy_cat = Cat()
lazy_cat.name = "大懒猫"
lazy_cat.eat()
输出:
Tom 爱吃鱼
大懒猫 爱吃鱼
- 在 类的外部,通过
变量名.
访问对象的 属性和方法 - 在 类封装的方法中,通过
self.
访问对象的 属性和方法
2.3 初始化方法
- 当使用
类名()
创建对象时,会 自动 执行以下操作:- 为对象在内存中 分配空间 —— 创建对象
- 为对象的属性 设置初始值 —— 初始化方法(
init
)
- 这个 初始化方法 就是
__init__
方法,__init__
是对象的内置方法
__init__
方法是 专门 用来定义一个类 具有哪些属性的方法!
在 Cat
中增加 __init__
方法,该方法在创建对象时会被自动调用
class Cat:"""这是一个猫类"""def __init__(self):print("初始化方法")
2.3.1 在初始化方法内部定义属性
- 在
__init__
方法内部使用self.属性名 = 属性的初始值
就可以 定义属性 - 定义属性之后,再使用
Cat
类创建的对象,都会拥有该属性
class Cat:def __init__(self):print("这是一个初始化方法")# 定义用 Cat 类创建的猫对象都有一个 name 的属性self.name = "Tom"def eat(self):print("%s 爱吃鱼" % self.name)# 使用类名()创建对象的时候,会自动调用初始化方法 __init__
tom = Cat()tom.eat()
输出:
2.3.2 改造初始化方法 —— 初始化的同时设置初始值
- 在开发中,如果希望在 创建对象的同时,就设置对象的属性,可以对
__init__
方法进行 改造- 把希望设置的属性值,定义成
__init__
方法的参数 - 在方法内部使用
self.属性 = 形参
接收外部传递的参数。【只有需要从外部传入的参数,才需要把这些参数定义成初始化方法的形参,如果某些参数不需要外部传递,就不需要额外增加那些参数,直接self.属性 = 设定的某初始值
】 - 在创建对象时,使用
类名(属性1, 属性2...)
调用
- 把希望设置的属性值,定义成
class Cat:def __init__(self, name):print("初始化方法 %s" % name)self.name = name...tom = Cat("Tom")
...lazy_cat = Cat("大懒猫")
...
定义没有初始值的属性
在定义属性时,如果 不知道设置什么初始值,可以设置为 None
None
关键字 表示 什么都没有- 表示一个 空对象,没有方法和属性,是一个特殊的常量
- 可以将
None
赋值给任何一个变量
一个对象的 属性 可以是 另外一个类创建的对象:
class Gun:def __init__(self, model):self.model = modelself.bullet_count = 0def add_bullet(self, count):self.bullet_count += countdef shoot(self):if self.bullet_count <= 0:print("[%s] 没有子弹了..." % self.model)returnself.bullet_count -= 1print("[%s] 突突突... [%d]" % (self.model, self.bullet_count))class Soldier:def __init__(self, name):self.name = nameself.gun = Nonedef fire(self):if self.gun == None:print("[%s] 还没有枪..." % self.name)returnprint("冲啊...[%s]" % self.name)self.gun.add_bullet(50)self.gun.shoot()
2.4 内置方法和属性
序号 | 方法名 | 类型 | 作用 |
---|---|---|---|
01 |
__del__
|
方法 | 对象被从内存中销毁前,会被 自动 调用 |
02 |
__str__
|
方法 |
返回对象的描述信息,print 函数输出使用
|
2.4.1 __del__
方法(知道)
在
Python
中- 当使用
类名()
创建对象时,为对象 分配完空间后,自动 调用__init__
方法 - 当一个 对象被从内存中销毁 前,会 自动 调用
__del__
方法
- 当使用
应用场景
__init__
改造初始化方法,可以让创建对象更加灵活__del__
如果希望在对象被销毁前,再做一些事情,可以考虑一下__del__
方法
生命周期
- 一个对象从调用
类名()
创建,生命周期开始 - 一个对象的
__del__
方法一旦被调用,生命周期结束 - 在对象的生命周期内,可以访问对象属性,或者让对象调用方法
- 一个对象从调用
class Cat:def __init__(self, new_name):self.name = new_nameprint("%s 来了" % self.name)def __del__(self):print("%s 去了" % self.name)# tom 是一个全局变量
tom = Cat("Tom")
print(tom.name)# del 关键字可以删除一个对象
del tomprint("-" * 50)
输出为:
2.4.2 __str__
方法(☆☆☆重要)
- 在
Python
中,使用print
输出 对象变量,默认情况下,会输出这个变量 引用的对象 是 由哪一个类创建的对象,以及 在内存中的地址(十六进制表示) - 如果在开发中,希望使用
print
输出 对象变量 时,能够打印 自定义的内容,就可以利用__str__
这个内置方法了
注意:
__str__
方法必须返回一个字符串
class Cat:def __init__(self, new_name):self.name = new_nameprint("%s 来了" % self.name)def __del__(self):print("%s 去了" % self.name)def __str__(self):return "我是小猫[%s]" % self.nametom = Cat("Tom")
print(tom)
输出为:
2.5 身份运算符
身份运算符用于 比较 两个对象的 内存地址 是否一致 —— 是否是对同一个对象的引用
- 在
Python
中针对None
比较时,建议使用is
判断
运算符 | 描述 | 实例 |
---|---|---|
is | is 是判断两个标识符是不是引用同一个对象 | x is y,类似 id(x) == id(y) |
is not | is not 是判断两个标识符是不是引用不同对象 | x is not y,类似 id(a) != id(b) |
is 与 == 的区别:
is
用于判断 两个变量 引用对象是否为同一个
==
用于判断 引用变量的值 是否相等
>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> b is a
False
>>> b == a
True
2.6 私有属性和私有方法
2.6.1 应用场景及定义方式
应用场景
- 在实际开发中,对象 的 某些属性或方法 可能只希望 在对象的内部被使用,而 不希望在外部被访问到
- 私有属性 就是 对象 不希望公开的 属性
- 私有方法 就是 对象 不希望公开的 方法
定义方式
- 在 定义属性或方法时,在 属性名或者方法名前 增加 两个下划线,定义的就是 私有 属性或方法
class Women:def __init__(self, name):self.name = name# 不要问女生的年龄self.__age = 18def __secret(self):print("我的年龄是 %d" % self.__age)xiaofang = Women("小芳")
# 私有属性,外部不能直接访问
# print(xiaofang.__age)# 私有方法,外部不能直接调用
# xiaofang.__secret()
在对象的内部,是可以访问对象的私有属性和方法的;在对象的外部,不能访问对象的私有属性和方法!!!
运行结果:
小芳 的年龄是 18
2.6.2 伪私有属性和私有方法(科普)
提示:在日常开发中,不要使用这种方式,访问对象的 私有属性 或 私有方法
Python
中,并没有 真正意义 的 私有
- 在给 属性、方法 命名时,实际是对 名称 做了一些特殊处理,使得外界无法访问到
- 处理方式:在 名称 前面加上
_类名
=>_类名__名称
# 私有属性,外部不能直接访问到,但可以通过"_类名__名称"来访问
print(xiaofang._Women__age)# 私有方法,外部不能直接调用,但可以通过"_类名__名称"来访问
xiaofang._Women__secret()
输出为:
18
小芳 的年龄是 18
3. 面向对象三大特性之——继承
- 单继承
- 多继承
面向对象三大特性
- 封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中
- 继承 实现代码的重用,相同的代码不需要重复的编写
- 多态 不同的对象调用相同的方法,产生不同的执行结果,增加代码的灵活度
3.1 单继承
3.1.1 继承的概念、语法和特点
继承的概念:子类 拥有 父类 的所有 方法 和 属性
1) 继承的语法
class 类名(父类名):pass
- 子类 继承自 父类,可以直接 享受 父类中已经封装好的方法,不需要再次开发
- 子类 中应该根据 职责,封装 子类特有的 属性和方法
2) 专业术语
Dog
类是Animal
类的子类,Animal
类是Dog
类的父类,Dog
类从Animal
类继承Dog
类是Animal
类的派生类,Animal
类是Dog
类的基类,Dog
类从Animal
类派生
3) 继承的传递性
C
类从B
类继承,B
类又从A
类继承- 那么
C
类就具有B
类和A
类的所有属性和方法
子类 拥有 父类 以及 父类的父类 中封装的所有 属性 和 方法
3.1.2 方法的重写
- 子类 拥有 父类 的所有 方法 和 属性
- 子类 继承自 父类,可以直接 享受 父类中已经封装好的方法,不需要再次开发
应用场景
- 当 父类 的方法实现不能满足子类需求时,可以对方法进行 重写(override)
重写 父类方法有两种情况:
- 覆盖 父类的方法
- 对父类方法进行 扩展
1) 覆盖父类的方法
- 如果在开发中,父类的方法实现 和 子类的方法实现,完全不同
- 就可以使用 覆盖 的方式,在子类中 重新编写 父类的方法实现
具体的实现方式,就相当于在 子类中 定义了一个 和父类同名的方法并且实现
重写之后,在运行时,只会调用 子类中重写的方法,而不再会调用 父类封装的方法
2) 对父类方法进行 扩展
- 如果在开发中,子类的方法实现 中 包含 父类的方法实现
- 父类原本封装的方法实现 是 子类方法的一部分
- 就可以使用 扩展 的方式
- 在子类中 重写 父类的方法
- 在需要的位置使用
super().父类方法
来调用父类方法的执行 - 代码其他的位置针对子类的需求,编写 子类特有的代码实现
关于 super
- 在
Python
中super
是一个 特殊的类 super()
就是使用super
类创建出来的对象- 最常 使用的场景就是在 重写父类方法时,调用 在父类中封装的方法实现
3.2 多继承
概念
- 子类 可以拥有 多个父类,并且具有 所有父类 的 属性 和 方法
- 例如:孩子 会继承自己 父亲 和 母亲 的 特性
语法
class 子类名(父类名1, 父类名2...)pass
3.2.1 多继承的使用注意事项
问题的提出
- 如果 不同的父类 中存在 同名的方法,子类对象 在调用方法时,会调用 哪一个父类中的方法呢?
提示:开发时,应该尽量避免这种容易产生混淆的情况! —— 如果 父类之间 存在 同名的属性或者方法,应该 尽量避免 使用多继承
Python 中的 MRO —— 方法搜索顺序(知道)
Python
中针对 类 提供了一个 内置属性__mro__
可以查看 方法 搜索顺序- MRO 是
method resolution order
,主要用于 在多继承时判断 方法、属性 的调用 路径
print(C.__mro__)
输出结果
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
- 在搜索方法时,是按照
__mro__
的输出结果 从左至右 的顺序查找的 - 如果在当前类中 找到方法,就直接执行,不再搜索
- 如果 没有找到,就查找下一个类 中是否有对应的方法,如果找到,就直接执行,不再搜索
- 如果找到最后一个类,还没有找到方法,程序报错
3.2.2 新式类与旧式(经典)类
object
是Python
为所有对象提供的 基类,提供有一些内置的属性和方法,可以使用dir
函数查看
新式类:以
object
为基类的类,推荐使用经典类:不以
object
为基类的类,不推荐使用在
Python 3.x
中定义类时,如果没有指定父类,会 默认使用object
作为该类的 基类 ——Python 3.x
中定义的类都是 新式类在
Python 2.x
中定义类时,如果没有指定父类,则不会以object
作为 基类
新式类 和 经典类 在多继承时 —— 会影响到方法的搜索顺序
为了保证编写的代码能够同时在 Python 2.x
和 Python 3.x
运行!
今后在定义类时,如果没有父类,建议统一继承自 object
class 类名(object):pass
4. 面向对象三大特性之——多态
- 多态
面向对象三大特性
- 封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中
- 定义类的准则
- 继承 实现代码的重用,相同的代码不需要重复的编写
- 设计类的技巧
- 子类针对自己特有的需求,编写特定的代码
- 多态 不同的 子类对象 调用相同的 父类方法,产生不同的执行结果
- 多态 可以 增加代码的灵活度
- 以 继承 和 重写父类方法 为前提
- 是调用方法的技巧,不会影响到类的内部设计
多态案例演练
需求
- 在
Dog
类中封装方法game
- 普通狗只是简单的玩耍
- 定义
XiaoTianDog
继承自Dog
,并且重写game
方法- 哮天犬需要在天上玩耍
- 定义
Person
类,并且封装一个 和狗玩 的方法- 在方法内部,直接让 狗对象 调用
game
方法
- 在方法内部,直接让 狗对象 调用
案例小结
Person
类中只需要让 狗对象 调用game
方法,而不关心具体是 什么狗game
方法是在Dog
父类中定义的
- 在程序执行时,传入不同的 狗对象 实参,就会产生不同的执行效果
多态 更容易编写出出通用的代码,做出通用的编程,以适应需求的不断变化!
class Dog(object):def __init__(self, name):self.name = namedef game(self):print("%s 蹦蹦跳跳的玩耍..." % self.name)class XiaoTianDog(Dog):def game(self):print("%s 飞到天上去玩耍..." % self.name)class Person(object):def __init__(self, name):self.name = namedef game_with_dog(self, dog):print("%s 和 %s 快乐的玩耍..." % (self.name, dog.name))# 让狗玩耍dog.game()# 1. 创建一个狗对象
# wangcai = Dog("旺财")
wangcai = XiaoTianDog("飞天旺财")# 2. 创建一个小明对象
xiaoming = Person("小明")# 3. 让小明调用和狗玩的方法
xiaoming.game_with_dog(wangcai)
输出结果为:
5. 类属性和类方法
5.1 类的结构
5.1.1 术语 —— 实例
- 使用面相对象开发,第 1 步 是设计 类
- 使用 类名() 创建对象,创建对象 的动作有两步:
- 在内存中为对象 分配空间
- 调用初始化方法
__init__
为 对象初始化
- 调用初始化方法
- 对象创建后,内存 中就有了一个对象的 实实在在 的存在 —— 实例
因此,通常也会把:
- 创建出来的 对象 叫做 类 的 实例
- 创建对象的 动作 叫做 实例化
- 对象的属性 叫做 实例属性
- 对象调用的方法 叫做 实例方法
在程序执行时:
- 对象各自拥有自己的 实例属性
- 调用对象方法,可以通过
self.
- 访问自己的属性
- 调用自己的方法
结论
- 每一个对象 都有自己 独立的内存空间,保存各自不同的属性
- 多个对象的方法,在内存中只有一份,在调用方法时,需要把对象的引用 传递到方法内部
5.1.2 类是一个特殊的对象
Python
中 一切皆对象:
class AAA:
定义的类属于 类对象obj1 = AAA()
属于 实例对象
- 在程序运行时,类 同样 会被加载到内存
- 在
Python
中,类 是一个特殊的对象 —— 类对象 - 在程序运行时,类对象 在内存中 只有一份,使用 一个类 可以创建出 很多个对象实例
- 除了封装 实例 的 属性 和 方法外,类对象 还可以拥有自己的 属性 和 方法
- 类属性
- 类方法
- 通过 类名. 的方式可以 访问类的属性 或者 调用类的方法
5.2 类属性和实例属性
5.2.1 概念和使用
- 类属性 就是给 类对象 中定义的 属性
- 通常用来记录 与这个类相关 的特征
- 类属性 不会用于记录 具体对象的特征
示例需求
- 定义一个 工具类
- 每件工具都有自己的
name
- 需求 —— 知道使用这个类,创建了多少个工具对象?
class Tool(object):# 使用赋值语句,定义类属性,记录创建工具对象的总数count = 0def __init__(self, name):self.name = name# 针对类属性做一个计数+1Tool.count += 1# 创建工具对象
tool1 = Tool("斧头")
tool2 = Tool("榔头")
tool3 = Tool("铁锹")# 知道使用 Tool 类到底创建了多少个对象?
print("现在创建了 %d 个工具" % Tool.count)
5.2.2 属性的获取机制(科普)
- 在
Python
中 属性的获取 存在一个 向上查找机制
- 因此,要访问类属性有两种方式:
- 类名.类属性
- 对象.类属性 (不推荐)
注意
- 如果使用
对象.类属性 = 值
赋值语句,只会 给对象添加一个属性,而不会影响到 类属性的值
5.3 类方法和静态方法
5.3.1 类方法
- 类属性 就是针对 类对象 定义的属性
- 使用 赋值语句 在
class
关键字下方可以定义 类属性 - 类属性 用于记录 与这个类相关 的特征
- 使用 赋值语句 在
- 类方法 就是针对 类对象 定义的方法
- 在 类方法 内部可以直接访问 类属性 或者调用其他的 类方法
语法如下
@classmethod
def 类方法名(cls):pass
- 类方法需要用 修饰器
@classmethod
来标识,告诉解释器这是一个类方法 - 类方法的 第一个参数 应该是
cls
- 由 哪一个类 调用的方法,方法内的
cls
就是 哪一个类的引用 - 这个参数和 实例方法 的第一个参数是
self
类似 - 提示 使用其他名称也可以,不过习惯使用
cls
- 由 哪一个类 调用的方法,方法内的
- 通过 类名. 调用 类方法,调用方法时,不需要传递
cls
参数 - 在方法内部
- 可以通过
cls.
访问当前类的类属性 - 也可以通过
cls.
调用当前类的其他的类方法
- 可以通过
示例需求
- 定义一个 工具类
- 每件工具都有自己的
name
- 需求 —— 在 类 封装一个
show_tool_count
的类方法,输出使用当前这个类,创建的对象个数
@classmethod
def show_tool_count(cls):"""显示工具对象的总数"""print("工具对象的总数 %d" % cls.count)
在类方法内部,可以直接使用
cls
访问 类属性 或者 调用类方法
5.3.2 静态方法
在开发时,如果需要在 类 中封装一个方法,这个方法:
- 既 不需要 访问 实例属性 或者调用 实例方法
- 也 不需要 访问 类属性 或者调用 类方法
这个时候,可以把这个方法封装成一个 静态方法
语法如下
@staticmethod
def 静态方法名():pass
- 静态方法 需要用 修饰器
@staticmethod
来标识,告诉解释器这是一个静态方法 - 通过 类名. 调用 静态方法
class Dog(object):# 狗对象计数dog_count = 0@staticmethoddef run():# 不需要访问实例属性也不需要访问类属性的方法print("狗在跑...")def __init__(self, name):self.name = name# 通过类名.调用静态方法
Dog.run()
5.3.3 方法综合案例
需求
- 设计一个
Game
类 - 属性:
- 定义一个 类属性
top_score
记录游戏的 历史最高分 - 定义一个 实例属性
player_name
记录 当前游戏的玩家姓名
- 定义一个 类属性
- 方法:
- 静态方法
show_help
显示游戏帮助信息 - 类方法
show_top_score
显示历史最高分 - 实例方法
start_game
开始当前玩家的游戏
- 静态方法
- 主程序步骤
- 查看帮助信息
- 查看历史最高分
- 创建游戏对象,开始游戏
案例小结
- 实例方法 —— 方法内部需要访问 实例属性
- 实例方法 内部可以使用 类名. 访问类属性
- 类方法 —— 方法内部 只 需要访问 类属性
- 静态方法 —— 方法内部,不需要访问 实例属性 和 类属性
提问
如果方法内部 即需要访问 实例属性,又需要访问 类属性,应该定义成什么方法?
答案
- 应该定义 实例方法
- 因为,类只有一个,在 实例方法 内部可以使用 类名. 访问类属性
class Game(object):# 类属性,游戏最高分top_score = 0# 实例属性,玩家姓名def __init__(self, player_name):self.player_name = player_name# 静态方法,显示帮助信息@staticmethoddef show_help():print("帮助信息:让僵尸走进房间")# 类方法,显示最高分@classmethoddef show_top_score(cls):print("游戏最高分是 %d" % cls.top_score)# 实例方法,开始游戏def start_game(self):print("[%s] 开始游戏..." % self.player_name)# 使用类名.修改历史最高分Game.top_score = 999# 1. 查看游戏帮助
Game.show_help()# 2. 查看游戏最高分
Game.show_top_score()# 3. 创建游戏对象,开始游戏
game = Game("小明")game.start_game()# 4. 游戏结束,查看游戏最高分
Game.show_top_score()
6. 单例
6.1 单例设计模式
设计模式
- 设计模式 是 前人工作的总结和提炼,通常,被人们广泛流传的设计模式都是针对 某一特定问题 的成熟的解决方案
- 使用 设计模式 是为了可重用代码、让代码更容易被他人理解、保证代码可靠性
单例设计模式
- 目的 —— 让 类 创建的对象,在系统中 只有 唯一的一个实例
- 每一次执行
类名()
返回的对象,内存地址是相同的 (即执行print(对象),返回同样的地址结果)
单例设计模式的应用场景
- 音乐播放 对象
- 回收站 对象
- 打印机 对象
- ……
6.2 __new__
方法
- 使用 类名() 创建对象时,
Python
的解释器 首先 会 调用__new__
方法为对象 分配空间 __new__
是一个 由object
基类提供的 内置的静态方法,主要作用有两个:- 在内存中为对象 分配空间
- 返回 对象的引用(地址)
Python
的解释器获得对象的 引用 后,将引用作为 第一个参数,传递给__init__
方法
重写
__new__
方法 的代码非常固定!
- 重写
__new__
方法 一定要return super().__new__(cls)
- 否则 Python 的解释器 得不到 分配了空间的 对象引用,就不会调用对象的初始化方法
- 注意:
__new__
是一个静态方法,在调用时需要 主动传递cls
参数
示例代码
class MusicPlayer(object):def __new__(cls, *args, **kwargs):# 如果不返回任何结果,return super().__new__(cls)def __init__(self):print("初始化音乐播放对象")player = MusicPlayer()print(player)
6.3 Python 中的单例
单例 —— 让 类 创建的对象,在系统中 只有 唯一的一个实例
- 定义一个 类属性,初始值是
None
,用于记录 单例对象的引用 - 重写
__new__
方法 - 如果 类属性
is None
,调用父类方法分配空间,并在类属性中记录结果 - 返回 类属性 中记录的 对象引用
class MusicPlayer(object):# 定义类属性记录单例对象引用instance = Nonedef __new__(cls, *args, **kwargs):# 1. 判断类属性是否已经被赋值#(如果未被赋值,调用父类的方法,为第一个对象分配空间,然后返回这个引用)#(如果已经赋值,直接返回它保存的单例引用)if cls.instance is None:cls.instance = super().__new__(cls)# 2. 返回类属性保存的单例引用return cls.instance# 创建多个对象
player1 = MusicPlayer()
print(player1)player2 = MusicPlayer()
print(player2)
结果为返回同样的引用:
6.4 如何只执行一次初始化工作
- 在每次使用
类名()
创建对象时,Python
的解释器都会自动调用两个方法:__new__
分配空间__init__
对象初始化
- 在上一小节对
__new__
方法改造之后,每次都会得到 第一次被创建对象的引用 - 但是:初始化方法还会被再次调用
需求
- 让 初始化动作 只被 执行一次
解决办法
- 定义一个类属性
init_flag
标记是否 执行过初始化动作,初始值为False
- 在
__init__
方法中,判断init_flag
,如果为False
就执行初始化动作 - 然后将
init_flag
设置为True
- 这样,再次 自动 调用
__init__
方法时,初始化动作就不会被再次执行 了
class MusicPlayer(object):# 记录第一个被创建对象的引用instance = None# 记录是否执行过初始化动作init_flag = Falsedef __new__(cls, *args, **kwargs):# 1. 判断类属性是否是空对象if cls.instance is None:# 2. 调用父类的方法,为第一个对象分配空间cls.instance = super().__new__(cls)# 3. 返回类属性保存的对象引用return cls.instancedef __init__(self):# 1. 判断是否执行过初始化动作if MusicPlayer.init_flag:return# 2. 如果没有执行过,再执行初始化动作print("初始化音乐播放器")# 3. 修改类属性的标记MusicPlayer.init_flag = True# 创建多个对象
player1 = MusicPlayer()
print(player1)player2 = MusicPlayer()
print(player2)
输出为:(一次初始化)
否则,输出为:(多次初始化)
new` 方法改造之后,每次都会得到 第一次被创建对象的引用
- 但是:初始化方法还会被再次调用
需求
- 让 初始化动作 只被 执行一次
解决办法
- 定义一个类属性
init_flag
标记是否 执行过初始化动作,初始值为False
- 在
__init__
方法中,判断init_flag
,如果为False
就执行初始化动作 - 然后将
init_flag
设置为True
- 这样,再次 自动 调用
__init__
方法时,初始化动作就不会被再次执行 了
class MusicPlayer(object):# 记录第一个被创建对象的引用instance = None# 记录是否执行过初始化动作init_flag = Falsedef __new__(cls, *args, **kwargs):# 1. 判断类属性是否是空对象if cls.instance is None:# 2. 调用父类的方法,为第一个对象分配空间cls.instance = super().__new__(cls)# 3. 返回类属性保存的对象引用return cls.instancedef __init__(self):# 1. 判断是否执行过初始化动作if MusicPlayer.init_flag:return# 2. 如果没有执行过,再执行初始化动作print("初始化音乐播放器")# 3. 修改类属性的标记MusicPlayer.init_flag = True# 创建多个对象
player1 = MusicPlayer()
print(player1)player2 = MusicPlayer()
print(player2)
输出为:(一次初始化)
否则,输出为:(多次初始化)
【轻松学】Python面向对象编程——类的设计、基础语法、继承、多态、类属性和类方法、单例设计相关推荐
- 使用java实现面向对象编程第二章_java面向对象编程——第二章 java基础语法
第二章 java基础语法 1.java关键字 abstract boolean break byte case catch char class const continue default do d ...
- Python面向对象编程:类继承和其衍生术语
Python面向对象编程03:类继承和其衍生术语 前面我们讲到过正则表达式字符等,上一篇分享了面向对象编程和类的结构,最后稍微提到了继承. Python面向对象编程:深度认识类class_ Pytho ...
- Python零基础速成班-第9讲-Python面向对象编程(上),对象和类、初始化、继承、重写、多态、类方法、组合
Python零基础速成班-第9讲-Python面向对象编程(上),对象和类.初始化.继承.重写.多态.类方法.组合 学习目标 修饰器 面向对象编程:对象和类.初始化.继承.重写.多态.类方法.组合 课 ...
- 《Python面向对象编程指南》——1.2 基类中的__init__()方法
本节书摘来自异步社区<Python面向对象编程指南>一书中的第1章,第1.2节,作者[美]Steven F. Lott, 张心韬 兰亮 译,更多章节内容可以访问云栖社区"异步社区 ...
- python面向对象编程的三大特性_Python面向对象总结及类与正则表达式详解
Python3 面向对象 -------------------------------------------------------------------------------- 一丶面向对象 ...
- python多个对象调用类方法、且之间有联系_趣味解读Python面向对象编程 (类和对象)...
一.面向对象简介 考虑现实生活中,我们的思维方式是放在学生这个个人上,是学生做了自我介绍.而不是像我们刚刚写出的代码,先有了介绍的行为,再去看介绍了谁. 用我们的现实思维方式该怎么用程序表达呢? 面向 ...
- python面向对象图片_趣味解读Python面向对象编程 (类和对象)
一.面向对象简介 考虑现实生活中,我们的思维方式是放在学生这个个人上,是学生做了自我介绍.而不是像我们刚刚写出的代码,先有了介绍的行为,再去看介绍了谁. 用我们的现实思维方式该怎么用程序表达呢?面向过 ...
- ES6学习笔记(一):轻松搞懂面向对象编程、类和对象
文章目录 面向过程编程P OP(Process oriented programming) 面向对象编程OOP(Object Oriented Programming) ES6中的类和对象 面向对象 ...
- python面向对象编程中方法和属性_Python面向对象编程中关于类和方法的学习笔记...
Python面向对象编程中关于类和方法的学习笔记 类与类方法是面向对象的编程语言中必不可少的特性,本文总结了Python面向对象编程中关于类和方法的学习笔记,需要的朋友可以参考下 类和实例 pytho ...
最新文章
- Asp.net(c#)实现多线程断点续传
- poj - 2243 Knight Moves
- 独家 | 用pandas-profiling做出更好的探索性数据分析(附代码)
- 关于EventSource的精华
- Unix Domain Socket 域套接字实现
- spring中的BeanFactoryPostProcessor
- c#Struts框架理念和自制Struts框架下 复杂版
- python中高阶函数和装饰器_三.Python高阶函数和装饰器
- 玩转ECS第7讲 | ECS数据保护-数据备份新特性与最佳实践
- 2014届华为校园招聘机试题
- 比较好的一些 ConcurrentHashMap讲解博客
- 2021 ISC会上山石网科重磅发布智能下一代防火墙A系列,重新定义边界安全防御
- python之join()用法
- for循环中取出最大最小 累加_使用 for 循环实现从 1 累加至 10。_学小易找答案...
- Android聊天软件开发(基于网易云IM即时通讯)——添加好友(三)
- PCB中常见的单位换算
- Tbase 源码 (六)
- html5设计页面背景颜色,网页背景设计全攻略
- python pandas处理excel 统计数据_python使用pandas处理excel数据
- AHRS 原理算法+代码实现(好文记录)
热门文章
- Qt基础-QString字母大小写转换
- Group coordinator ali-ddd-cdhdev-04:9092 (id: 2147483643 rack: null) is unavailable or invalid, wil
- 英灵神殿linux服务器安装mod,英灵神殿云服务器MOD安装教程
- chrome浏览器崩溃了,STATUS_INVALID_IMAGE_HASH
- SUSCTF2022 Misc
- contos 7新手上路之四:使用与美化
- 面向对象程序设计——Java语言 第3周编程题 查找里程(10分)
- 小米盒子开启ADB调试的方法
- 基于flash骨骼动画的游戏unity实现
- mysql创建唯一索引