1. 面向对象oop了解
|
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
|
# ### oop 面向对象的程序开发# (1) 类的定义# 1class Car: pass# 2 推荐class Car(): pass# 3.class Car(object): pass # (2)类的实例化class Car(): passobj = Car()print(obj)# (3)类的基本结构"""类中两样东西: (1)成员属性 (2)成员方法"""class Car(): # 成员属性 color = "白色" # 成员方法 def didi(): print("小车会嚓嚓的叫")# 语法上不报错,但是严禁使用,破坏了类中的结构,不要裸露的把判断和循环直接写在类中,而是用方法包起来class Car(): if 5 ==5 : print(11223344)# (4)类的命名"""类的命名 : 推荐使用大驼峰命名法,每个单词的首字母都要大写""""""mycar => MyCarzhangbaozhang => ZhangBaoZhang""" |
2. 对象的相关操作
|
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
|
# ### 面向对象的封装 - 对象的操作"""封装: 1.私有 : 在类内可以互相访问,在类外不能访问 2.公有 : 在类内或者类外都可以访问类中成员: 1.成员属性 2.成员方法绑定方法: 1.绑定到对象 : 当对象去调用类中成员方法时,系统会默认把该对象当成参数传递给该方法 2.绑定到类 : 当对象或者类去调用类中成员方法时,系统会默认把该类当成参数传递给该方法使用方式: 对象.成员属性 对象.成员方法"""class MyCar(): # 公有属性 logo = "布加迪威龙" # 私有属性 __price = "2000万" # 公有方法 def run(self): print("百公里油耗300L,logo={} , price={}".format(self.logo, self.__price)) # 私有方法 def __info(self): print("车主信息保密,据说是某个房地产大佬的儿子")# 实例化对象(类的实例化)obj = MyCar()# (1)实例化的对象访问成员属性和方法# 公有print(obj.logo)obj.run()# 私有 (私有成员无法在类外访问,类内可以)# obj.__price error# obj.run()# obj.__info() error#(2)实例化的对象动态添加公有成员属性obj.color = "尿黄色"obj.logo = "五菱宏光"print(obj.color)print(obj.logo)# __dict__ 获取类对象的内部成员print(obj.__dict__)print(MyCar.__dict__)#(3)实例化的对象动态添加公有成员方法# 1.无参方法def dahuangfeng(): print("请加我大黄蜂")obj.dahuangfeng = dahuangfengobj.dahuangfeng()# 2.有参方法# 基本版def qingtianzhu(name): print("请叫我一柱擎天么,{}".format(name))obj.qingtianzhu = qingtianzhuobj.qingtianzhu("擎天柱")# 升级版def qingtianzhu(obj,name): print("请叫我一柱擎天么,{},我的颜色是{}".format(name,obj.color))obj.qingtianzhu = qingtianzhuobj.qingtianzhu(obj,"擎天柱")# 究极版"""如果要创建绑定方法,参数的顺序,self对象本身要放到第一位."""def qingtianzhu(obj,name): print("请叫我一柱擎天么,{},我的颜色是{}".format(name,obj.color))import types# 创建绑定方法,系统自动把该对象当成参数传递给方法;# types.MethodType(方法,对象) => 绑定方法 res = types.MethodType(qingtianzhu,obj)print(res)obj.qingtianzhu = types.MethodType(qingtianzhu,obj)obj.qingtianzhu("擎天柱")# 3.lambda表达式obj.weizhentian = lambda : print("我是威震天")obj.weizhentian() |
小提示：
|
1
2
|
类对象在调用方法，如果方法是类外的（自定义的方法），那么不会自动传参的（不会把类对象传到方法里面）self是用来接收对象这参数（self只是一个名字而已，无所谓，习惯用self） |
3. 类的相关操作
|
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
|
# ### 面向对象的封装 - 类的操作"""使用方式: 类.成员属性 类.成员方法"""class MyCar(): # 公有成员属性 platenum = "京A7758BB" # 私有成员属性 __earning = "月收入6000" # 公有成员方法 def car_info(): print("牌照信息可以公开") print("<======>") MyCar.__money_info() # 私有成员方法 def __money_info(): print( "收入信息保密" , MyCar.__earning )# (1)定义的类访问公有成员属性和方法print(MyCar.platenum)MyCar.car_info()# MyCar.__money_info() error# (2)定义的类动态添加公有成员属性MyCar.oil = "1000L"print(MyCar.oil)print(MyCar.__dict__)# (3)定义的类动态添加公有成员方法# 1.无参方法def car_light(): print("我是造车灯的方法")MyCar.car_light = car_lightMyCar.car_light()# 2.有参方法def car_engine(name): print("我是造{}发动机的方法".format(name))MyCar.car_engine = car_engineMyCar.car_engine("三缸发动机")# 3.lambda表达式MyCar.luntai = lambda : print("我是造轮胎的方法")MyCar.luntai()# 对比 对象和类之间的不同"""1.类中的无参方法默认只能类来调用,对象无法调取2.对象可以调用类中的成员,反过来,类不能调用对象中的成员3.每创建一个对象都会在内存中占用一份空间,对象之间是彼此独立的;"""obj = MyCar()# obj.car_info() errorMyCar.car_info()obj.price = "10万"print(MyCar.price) |
4. 类对象的删除操作
|
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
58
59
60
61
62
63
64
65
66
|
# ### 1.如何在类外访问私有成员class Plane(): # 公有成员 captian = "赵沈阳" # 私有成员 __air_sister = "3名空姐" # 公有绑定方法 def fly(self): print("飞机要非要平流层,才能减少震动",self.__air_sister) # 私有绑定方法 def __age(self): print("空姐年龄保密") # 公有无参方法 def fly2(): print("航天飞机飞到天空层,翱翔太空") # 私有无参方法 def __earn(): print("机长的收入保密") def pub_get1(self): print(self.__air_sister) self.__age() def pub_get2(): print(Plane.__air_sister) Plane.__earn()# 实例化对象obj = Plane()# 方法一.访问私有成员 (不推荐)# python私有化: 采取了改名策略 => _类名 + __air_sister# print(obj.__air_sister)print(obj._Plane__air_sister)print(Plane.__dict__)"""{'__module__': '__main__', 'captian': '赵沈阳', '_Plane__air_sister': '3名空姐', 'fly': <function Plane.fly at 0x7f2774616158>, '_Plane__age': <function Plane.__age at 0x7f27746161e0>, 'fly2': <function Plane.fly2 at 0x7f2774616268>, '_Plane__earn': <function Plane.__earn at 0x7f27746162f0>, '__dict__': <attribute '__dict__' of 'Plane' objects>, '__weakref__': <attribute '__weakref__' of 'Plane' objects>, '__doc__': None}"""# 方法二.访问私有成员 (使用类中的公有方法,间接访问私有成员) (推荐)obj = Plane()obj.pub_get1()Plane.pub_get2()# ### 2.使用类对象删除相应的成员"""1.对象可以访问类中的公有成员,但是无权修改或者删除该类中的成员2.对象在访问成员时,优先访问该对象自己的成员,如果没有在访问类的,类如果也没有直接报错;"""# 删除对象成员属性obj.captian = "赵世超"del obj.captianprint(obj.captian)# 删除对象成员方法obj.basketball = lambda : print("我的私人飞机可以在天上打篮球")print(obj.__dict__)obj.basketball()del obj.basketballprint(obj.__dict__)# obj.basketball() error# 删除类中成员属性del Plane.captianprint(Plane.__dict__)# Plane.captian# print(obj.captian) error# 删除类中成员方法del Plane.fly2# Plane.fly2() error# 注意: 对象无法调无参方法!! 返回来,类可以调用对象的绑定方法么? 可以!!Plane.fly(obj) |
小提示：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
如果在类外添加公有方法def __abc(): print(1) 在类外定义的方法__abc()只是简单的函数名字而已，之后在类里面定义的时候，__abc()才是私有方法。删除或创建私有的方法，要在类外去操作 对象在调用属性的时候，先看自己有没有，然后在看类中的属性class Plane(): def fly1(self): print("飞机要起飞") def fly2(self): print("飞机真的要起飞了"，self.captian) def fly3(): print("飞机不起飞")Plane.fly1(1) 类可以调用有参的方法，随便穿个值进去即可Plane.fly2(1) 这样的话就报错，Plane.fly2(obj) 把对象传进去就可以出结果如果说对象调用类中无参的方法是不会成功的 |
5. 小练习
|
1
2
3
4
5
6
7
8
9
10
11
12
|
1.请定义一个交通工具(Vehicle)的类，其中有:属性：速度(公有speed)， 车的类型(私有type)方法：速度(公有setSpeed)，加速(私有speedUp),减速(私有speedDown)让公有setSpeed调用私有speedUp和私有speedDown2.用类改写:猜数字游戏：一个类有两个成员num和guess，num有一个初值100。定义一个方法guess，调用guess,如果大了则提示大了，小了则提示小了。等于则提示猜测成功。3.创建一个圆Circle类。为该类提供一个变量r表示半径方法一返回圆的面积,方法二返回圆的周长； |
小提示：
|
1
2
3
|
如果在类内的话，都是用对象调用方法或变量（self.speed、self.eat()）,如果不是类的话，可以直接调变量和方法r = 3 归属于circle这个类self.r = r 归属于self这个对象 |
答案：
|
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
"""1.请定义一个交通工具(Vehicle)的类，其中有:属性：速度(公有speed)， 车的类型(私有type)方法：速度(公有setSpeed)，加速(私有speedUp),减速(私有speedDown)让公有setSpeed调用私有speedUp和私有speedDown"""class Vehicle(): speed = "百公里1小时" __type = "拖拉机小蹦蹦" def setSpeed(self): self.__speedUp() self.__speedDown() def __speedUp(self): print("我是加速方法,速度{}".format(self.speed)) def __speedDown(self): print("我是减速方法,小车的类型是{}".format(Vehicle.__type))obj = Vehicle()obj.setSpeed()"""2.用类改写:猜数字游戏：一个类有两个成员num和guess，num有一个初值100。定义一个方法guess，调用guess,如果大了则提示大了，小了则提示小了。等于则提示猜测成功。"""import reclass GuessGame(): num = 100 def guess(self): while True: n = input("请输入要猜测的数字") obj = re.search(r"^\d+$",n) # print(obj) if obj: n = int(obj.group()) if n > self.num: print("大了..") elif n < self.num: print("小了..") elif n == self.num: print("ok~ bingo") break else: print("输入的内容不正确")# obj = GuessGame()# obj.guess()"""3.创建一个圆Circle类。为该类提供一个变量r表示半径方法一返回圆的面积,方法二返回圆的周长；"""import mathclass Circle(): r = 3 def area(self): return math.pi * self.r ** 2 def perimeter(self): return 2 * math.pi * self.robj = Circle()res1 = obj.area()res2 = obj.perimeter()print(res1,res2)# 方法二 (推荐)import mathclass Circle(): def __init__(self,r): self.r = r def area(self): return math.pi * self.r ** 2 def perimeter(self): return 2 * math.pi * self.robj = Circle(4)res1 = obj.area()res2 = obj.perimeter()print(res1,res2) |
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注服务器之家的更多内容!
原文链接：https://blog.csdn.net/weixin_46818279/article/details/121368048
