day22 面向对象的程序开发、面相对象-封装、面向对象0-类操作、面向对象删除操作

# ### opp 面向对象

类的定义

1
2
3
4
5
6
7
8
class MyClass: 
    pass
     
class MyClass(): #(推荐)
    pass
     
class MyClass(object):
    pass

类的实例化

1
2
3
4
5
class MyCar():
    color = "黄色的"
      
# 实例化对象 (类的实例化)
obj = MyCar() # object -> obj

 

类的基本结构
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
"""
1.成员属性
2.成员方法
"""
class MyCar():
    # 成员属性
    color = "天蓝色的"
    # 成员方法
    def didi():
        print("小车会滴滴叫")
     
# 反例: 这种写法可以直接在python当中执行,但是严禁使用
# 如果想要表达逻辑或者循环,需要写在成员方法当中,不能直接裸露的写在类当中,会破坏类中结构.
"""
class MyCar():
    if 5 == 5:
        print("打印成功123456")
"""

 

类的命名
驼峰命名法 : 推荐起类名的时候,使用大驼峰命名法.
# mycar -> MyCar mymouse => MyMouse

# ### oop 面向对象 -- 封装

"""

封装等级:

 (1)私有:在类的内部可以访问,在类外不可以

 (2)公有:在类的内部可以访问,在类外也可以访问

 

封装成员:

  (1)成员属性

  (2)成员方法

 

调用成员:

  (1)对象.成员属性

  (2)对象.成员方法

 

绑定方法:

  (1)绑定到对象:对象调用方法时,系统自己默认传递改对象,作为一个参数传递到当前方法中

  (2)绑定到类   :对象或者类调用方法时,系统自己默认传递该类,作为一个参数传递到当前方法中

"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class MyCar():
    # 公有成员属性
    color = "屎黄色"
    logo = "中国吉利汽车"
 
    # 私有成员属性
    __price = "2000万"
 
    # 公有成员方法
    def run(self):
        print("小车会跑,百公里0.01秒,颜色{}".format(self.color))    # self <==> obj
 
    # 私有成员方法   
    def __info(self):
        print("车主信息是保密的,传说是京城有名的富二代")

 

实例化对象(类的实例化)

1
obj= MyCar()

 

(1) 实例化的对象访问公有成员属性和方法

  访问属性

1
2
print(obj.color)
# obj.__price error  # 私有成员属性不能够在类外调用

  访问方法

1
2
obj.run()
# obj.__info() erroe # 私有成员方法不能够在类外调用

  

(2)实例化的对象动态添加公有成员属性和方法

  在类外动态添加成员属性 -> obj对象

1
2
3
4
obj.logo = "五菱宏光"
print(obj.logo)
__dict__是获取类对象中的成员
print(obj.__dict__)

  在类外动态添加成员方法 -> obj对象

  1.无参方法

1
2
3
4
5
def dahuangfeng()
    print("变形!我是大黄蜂~")
 
obj.dahuangfeng = dahuangfeng
obj.dahuangfeng()

  2.有参方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 1.基础版
def qingtianzhu(name):
    print("请我叫我一柱擎天,简称{}".format(name))
 
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu("擎天柱")
     
# 2.升级版
def qingtianzhu(obj,name):
    print("请我叫我一柱擎天,简称{},颜色是{}".format(name,obj.color))
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu(obj,"擎天柱")
 
# 3.究极版 (即使调用类外动态创建的方法,也让系统自己传递obj对象本身)
import types
def qingtianzhu(obj,name):
    print("请我叫我一柱擎天,简称{},颜色是{}".format(name,obj.color))
# MethodType(方法,对象) 把哪个方法和哪个对象绑定到一起,形成绑定方法
obj.qingtianzhu = types.MethodType(qingtianzhu,obj)
obj.qingtianzhu("擎天柱")


lambda表达式

1
2
obj.weizhentian = lambda:print("我是威震天~")
obj.weizhentian()

  

 

# ### oop 面向对象封装 -- 类的相关操作

"""
类调用的方式:
类.成员属性
类.成员方法
类中的无参方法只能是类来调用.
"""
1
2
3
4
5
6
7
8
9
10
11
class MyCar():
    # 公有属性
    oil = "2.0T"
    # 私有属性
    __price = "5000千万"
    # 公有方法
    def oil_info():
        print("百公里油耗是500升",MyCar.color)
    # 私有方法
    def __price_info():
        print("我的油耗信息是保密的")

  

实例化对象
"""
# 对象不能调用类中无参的方法
1
2
obj = MyCar()
obj.oil_info()
"""
定义的类访问公有成员属性和方法
访问公有成员属性
1
2
print(MyCar.oil)
MyCar.__price     error # 无法在类外访问私有成员属性 
访问公有成员方法

1
2
MyCar.oil_info()
MyCar.__price_info() error # 无法在类外访问私有成员方法

 

定义的类动态添加公有成员属性和方法 

添加成员属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
MyCar.color = "屎绿色"
print(MyCar.color)
# 查看类对象内部成员使用__dict__,返回的是字典
print(MyCar.__dict__)
# MyCar.oil_info()
"""
{'__module__': '__main__',
'oil': '2.0T',
'_MyCar__price': '5000千万',
'oil_info': <function MyCar.oil_info at 0x7f3f9668b0d0>,
'_MyCar__price_info': <function MyCar.__price_info at 0x7f3f9668b158>,
'__dict__': <attribute '__dict__' of 'MyCar' objects>,
'__weakref__': <attribute '__weakref__' of 'MyCar' objects>,
'__doc__': None,
'color': '屎绿色'
}
"""

 添加成员方法 

1.无参方法
1
2
3
4
5
6
def fangxiangpan():
    print("改造方向盘的方法")
MyCar.fangxiangpan = fangxiangpan
MyCar.fangxiangpan()
 
print(MyCar.__dict__)
2.有参方法
1
2
3
4
def fadongji(engin):
    print("动力引擎改成{}".format(engin))
MyCar.fadongji = fadongji
MyCar.fadongji("三缸发动机") 
3.lambda 表达式
1
2
3
4
5
6
7
8
9
MyCar.luntai = lambda name : print("使用{}的轮胎".format(name))
MyCar.luntai("米其林")
 
print(MyCar.__dict__)
 
 
obj = MyCar()
# obj.logo = "柯尼塞格"
# print(MyCar.logo) error 类不能返回来调用对象中的成员

 

"""
# 类和对象之间的区别
对象可以调用类中的成员属性和方法,返过来,类不能调用对象中的成员.
类中的成员属性和方法归属于类本身,对象可以使用,但是没有修改和删除的权利.
对象在调用相应成员时,先看看自己有没有
如果有,调用自己的
如果没有,调用类中的成员
如果类中成员也没有,直接报错.
"""
1
2
3
4
MyCar.logo = "别摸我,我是宝马bwm"
obj.logo = "柯尼塞格"
print(obj.__dict__)
print(obj.logo)

  


# ### 一.如何访问类中的私有成员

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
77
78
79
80
81
82
83
# ### 一.如何访问类中的私有成员
class Plane():
    # 公有属性
    captain = "宋云杰"
    # 私有属性
    __sistem = 10
     
    # 公有绑定方法
    def fly1(self):
        print("我的飞机可以倒着飞1")
         
    # 公有普通方法
    def fly2():
        print("我的飞机可以倒着飞2")
         
    # 私有绑定方法
    def __fly_info1(self):
        print("我的飞机,百公里油耗是5万升1")
         
    # 私有普通方法
    def __fly_info2():
        print("我的飞机,百公里油耗是5万升2")
         
    # 公有绑定方法->间接调用私有成员
    def pub_info1(self):
        print(self.__sistem)
        self.__fly_info1()
         
    # 公有普通方法->间接调用私有成员
    def pub_info2():
        print(Plane.__sistem)
        Plane.__fly_info2()
'''
关于python私有化的实现方法: 改名策略
_类名 + 私有成员 => 改名策略
'''
# 方法一.调用私有成员 (不推荐使用改名策略找到私有成员,破坏封装性)
# 对象调用类中的私有成员
obj = Plane()
print(obj._Plane__sistem)
obj._Plane__fly_info1()
 
# 类调用类中的私有成员
print(Plane._Plane__sistem)
Plane._Plane__fly_info2()
print(Plane.__dict__)
 
# 方法二.类或对象利用公有方法,间接找到私有成员(推荐)
obj.pub_info1()
Plane.pub_info2()
 
 
# ### 二.实例化的对象/定义的类 删除公有成员属性 和 公有成员方法
print(obj.__dict__)
 
# 1.公有成员属性
# 对当前对象添加成员属性交captain
obj.captain = "王浩"
# 删除当前对象中的成员属性captain
del obj.captain
# 删除类当中的成员属性captain
del Plane.captain
# 无论是类还是对象都没有改属性,所以报错;
# print(obj.captain) error
 
# 2.公有成员方法
Plane.add_sistem = lambda self: print("因为业务需要,需要增加空姐","<====>")
 
# del Plane.add_sistem
Plane.add_sistem(1)
obj.add_sistem()
# 删除类中的成员方法
del Plane.add_sistem
# obj.add_sistem() error 发现被删找不到了
 
obj.paoniu = lambda : print("我的飞机可以用来泡妞")
obj.paoniu()
# 删除对象中的成员方法
del obj.paoniu
# obj.paoniu() error
 
print(obj.__dict__) # {}
print(Plane.__dict__) # {'__module__': '__main__', '_Plane__sistem': 10, 'fly1': <function Plane.fly1 at 0x7f26187360d0>, 'fly2': <function Plane.fly2 at 0x7f2618736158>, '_Plane__fly_info1': <function Plane.__fly_info1 at 0x7f26187361e0>, '_Plane__fly_info2': <function Plane.__fly_info2 at 0x7f2618736268>, 'pub_info1': <function Plane.pub_info1 at 0x7f26187362f0>, 'pub_info2': <function Plane.pub_info2 at 0x7f2618736378>, '__dict__': <attribute '__dict__' of 'Plane' objects>, '__weakref__': <attribute '__weakref__' of 'Plane' objects>, '__doc__': None}

  

 
 

posted @   liyaaa  阅读(110)  评论(0编辑  收藏  举报
努力加载评论中...
点击右上角即可分享
微信分享提示