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
"""
学习目标: 掌握私有成员
1. 概念:
私有成员(属性,方法), 只能在 本类
内部使用
作用:
1. 起到对成员属性的保护作用,不能在类外修改
2. 提高类的封装性,将用户不需要用的功能都设置成私有的,简化用户的使用(关心公有的)
ATM 机
2. 语法:
只需要在成员(属性,方法)名前面加 两个下划线, 这样的成员就是私有成员
3. 了解 原理
在类外部使用的时候, 其实python解释器将私有成员名进行修改了: _类名__私有成员名
如何查看: dir(对象)
列出对象上的属性
"""
class Student:
def __init__(self, name, age):
self.name = name
self.__age = age
# 名前面加 两个下划线 就是私有成员
def show(self):
# 展示个人信息
print("我是{},今年{}岁".format(self.name, self.__age))
# 私有成员能在本类内部访问
# 创建学生 张飞
zhangfei = Student(name="张飞", age=28)
zhangfei.show()
print(zhangfei.name)
# print(zhangfei.__age) # 私有成员不能在本类外部访问
print(dir(zhangfei)) # 查看对象上的所有属性

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
"""
了解 __del__ 方法
1. 概念:
当我们的对象 在内存中被销毁(释放)的时候 自动调用对象上的 __del__ 方法
注意: __方法__ : 这类方法被称为魔术方法, 都是自动调用
作用:
1. 清理对象占用的第三方资源(打开的数据库连接,打开的文件)
2. 明确知道对象的销毁时机
2 明确知道对象的销毁时机
a. 脚本执行结束, 程序占用内存的所有数据都会释放,包括对象
原因: python高级语言,自带垃圾回收机制
b. 当对象空间没有被任何的变量所指向(引用), 这个时候对象被当作垃圾进行释放
两种方式:
del 对象变量
或者
对象变量 = None
"""
# 定义一个学生类
class Student:
def __init__(self):
print("创建对象成功!")
def __del__(self): # 对象被销毁自动调用
print("对象被消耗~~")
# 创建对象
stu1 = Student()
stu2 = stu1
del stu1
del stu2
# 如果对象的所有引用被删除,对象就会被当作垃圾销毁释放
print("end.....")
# 默认脚本执行结束对象被销毁
# print(id(None))

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
47
48
"""
学习目标: 掌握继承的使用
1. 概念:
什么是继承: 子类继承父类, 就可以直接使用父类上的成员(属性和方法)
补充俩概念: 子类
父类
继承的作用: 达到代码的重用(覆用)
2. 语法:
class 子类名(父类名):
# 定义子类自己的属性和方法
pass
说明:
1. 子类如果没有明确指明继承的类, 那么默认继承基础类 object, 或者明确指明继承object
2. 子类和父类 建议为有关系的类
注意:
1 私有属性不能被继承(私有属性只能在本类内部使用)
2.子类可以新增自己的属性和方法
"""
"""
定义俩类:
Father
Son
"""
class Father(object):
def __init__(self, name, age, money):
# 初始化方法
self.name = name
self.age = age
self.money = money
# 定义一个私有的属性
self.__height = 178
def show(self):
print(f"{self.name}今年{self.age},有财富:{self.money},身高:{self.__height}")
# 子类 继承 父类, 直接使用父类上的成员
class Son(Father):
# 展示身高
def showHeight(self):
print(self.__height)
# 子类不能使用父类上的私有成员
# 创建一个大头儿子对象
son = Son(name="大头儿子", age=8, money=20)
print(son.name)
# 继承的属性
son.show()
# 继承的方法
print(dir(son))
son.showHeight()

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
"""
单继承: 一个子类继承一个父类
class 类名(父类名):
pass
多层继承: 一个子类继承一个父类, 父类又继承其他父类,可以同时使用多个类上的成员
class C(object):
pass
class B(C):
pass
class A(B):
pass
多继承(了解): 一个子类可以继承多个父类, 可以同时使用多个类上的成员
class 子类(父类1,父类2):
pass
"""
class C(object):
def showC(self):
print("C")
class B(C):
def showB(self):
print("B")
class A(B):
def showA(self):
print("A")
a = A()
a.showA()
a.showB()
a.showC()
# 案例: 骡子同时继承驴和马
class Horse(object):
def run(self):
print("跑得快~")
class Lv(object):
def tuo(self):
print("拖得绑重~")
# 骡子
class Luozi(Horse, Lv):
pass
# 创建骡子对象
lz = Luozi()
lz.run()
lz.tuo()

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
"""
掌握 重写(重点中的重点)
1. 概念
什么是重写: 在子类中定义一个与父类相同名字的成员, 就叫作 重写
常见的重写:
1. 属性的重写(了解)
2. 方法的重写(重点关注)
2. 方法的重写
为什么要重写方法:
当父类上的方法不满足子类需求的时候, 但是子类又不得不使用该方法,
这个时候只能在子类上重写父类方法.
例如: 子类的初始属性多于父类
特点: 如果子类重写了父类方法, 再通过子类对象调用被重写的方法的时候, 只调用
子类上的方法.
3. 优化重写方法
我们可以在子类中通过以下语法 调用父类上的方法:
super().父类方法名([实参])
super(子类名,self).父类方法名([实参])
"""
# 定义俩类:
# 商品类: 属性: 名字,价格
# 手机类: 属性: 名字,价格,品牌,尺寸,颜色
class Goods(object):
def __init__(self, name, price):
self.name = name
self.price = price
print("对象被创建")
def ma(self):
print("安全码~~~~~")
# 父类上有很多方法
class Phone(Goods):
# 父类上有__init__, 子类又定义了 __init__ , 重写了初始化方法
def __init__(self, name, price, brand, size, color):
# self.name = name
# self.price = price
# 调用父类上的方法
super(Phone, self).__init__(name, price)
self.brand = brand
self.size = size
self.color = color
print("子类对象被创建")
# 创建子类对象
iphone11 = Phone("iphone11", 5000, "苹果", 5, "土豪金")
print(iphone11.name, iphone11.price, iphone11.brand, iphone11.size)
print(iphone11)

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
"""
目标: 了解类属性和实例属性
1. 实例属性
实例(对象) 属性: 对象上的属性
如何添加实例属性:
1. 动态添加: 对象变量.属性名 = 值
2. 属性绑定: self.属性名 = 值
2. 类属性
万物皆对象
类 也是一个对象: 通过 dir(类) 只要查看到属性说明 类也是一个对象
类属性: 可以在类上添加属性
添加类属性的语法:
(1) 动态添加: 类名.属性名 = 值
(2) 类中绑定
class 类名(object):
类属性名1 = 值
类属性名2 = 值
访问的语法:
类名.属性名
类属性的的作用:
将 所有对象共享的属性 设置为类属性, 目的为了节约内存空间
类属性的特殊(了解): 可以通过对象访问类属性
"""
class Student(object):
# 绑定类属性
class_name = "软件测试精英班"
# print(dir(Student)) # 说明类也是对象
# 例如: Student类添加一个属性 班级名
对象.属性名 = 值
# 动态添加
# Student.class_name = "软件测试精英班"
# 在类中绑定类属性
print(Student.class_name)
# 创建对象
stu = Student()
print(stu.class_name)
# 对象访问类属性

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
47
48
49
50
51
52
53
54
55
56
57
"""
学习目标: 了解类方法和静态方法
1. 类方法和静态方法
作用: 不用创建对象就能通过类名调用, 简单方便
2. 语法
类方法:
class 类名(object):
# 实例方法
def 方法名(self,[形参]):
pass
# 类方法
@classmethod
# 装饰器
def 方法名(cls,[形参]): # cls == class, python自动将调用的那个类传递给第一个参数 cls
pass
静态方法:
class 类名(object):
# 实例方法
def 方法名(self,[形参]):
pass
# 静态方法
@staticmethod
# 装饰器
def 方法名([形参]):
pass
"""
# 案例:
class Student(object):
# 类属性
class_name = "软件测试精英班"
# 初始化方法
def __init__(self, name, age):
self.name = name
self.age = age
# 展示个人信息: 实例方法
def show(self):
print(f"{self.name},今年{self.age}, 在{Student.class_name}班")
# 展示班级
@classmethod
def showClass(cls):
# cls 类自己: 类名.属性名
# print(id(cls))
print(cls.class_name)
# 展示时间
@staticmethod
def showTime():
import datetime
print(datetime.datetime.now())
# 创建对象
# stu = Student("张飞",28)
# stu.show()
# print(id(Student))
# 调用类方法
Student.showClass()
# 调用静态方法
Student.showTime()