day22:面向对象封装对象操作&类操作&面向对象删除操作

目录

1.面向对象程序开发

2.面向对象封装:对象的相关操作

3.面向对象封装:类的相关操作

4.实例化的对象/定义的类删除公有成员属性和公有成员方法

面向对象程序开发 

1.类的三种定义方式

class MyClass:    
    pass
    
class MyClass(): #(推荐)
    pass
    
class MyClass(object): # object类是所有类的父类
    pass

2.类的实例化

class MyCar():
    color = "黄色的"
     
# 实例化对象 (类的实例化)
obj = MyCar() 

3.类的基本结构

类的基本结构包括成员属性和成员方法

"""
1.成员属性
2.成员方法
"""
class MyCar():
    # 成员属性
    color = "天蓝色的"
    # 成员方法
    def didi():
        print("小车会滴滴叫")

4.注意:在类中不能写逻辑语句或循环语句

这种写法可以直接在python当中执行,但是严禁使用.

如果想要表达逻辑或者循环,

需要写在成员方法当中,不能直接裸露的写在类当中,会破坏类中结构.

class MyCar():
    if 5 == 5:
        print("打印成功123456")

5.类的命名

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

面向对象封装:对象的相关操作

1.关于封装的相关概念

封装等级:
(1) 私有 : 在类的内部可以访问,在类外不可以访问
(2) 公有 : 在类的内部可以访问,在类外也可以访问

封装成员:
(1) 成员属性
(2) 成员方法

调用成员:
(1) 对象.成员属性
(2) 对象.成员方法

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

 

定义一个MyCar类，并定义公有/私有成员属性和公有/私有成员方法

class MyCar():
    # 公有成员属性
    color = "屎黄色"
    logo =  "中国吉利汽车"
    # 私有成员属性
    __price = "2000万"
    
    # 公有成员方法
    def run(self):
        print("小车会跑,百公里0.01秒,颜色{}".format(self.color)) # self <=> obj 
    # 私有成员方法
    def __info(self):
        print("车主信息是保密的,传说是京城有名的富二代")
        
# 实例化对象(类的实例化)
obj = MyCar()

2.实例化的对象访问公有成员属性和方法

# 访问属性
print(obj.color)
# obj.__price error  # 私有成员属性不能够在类外调用
        
# 访问方法
obj.run()
# obj.__info() error  # 私有成员方法不能够在类外调用

3.实例化的对象动态添加公有成员属性和方法

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

# 可以在类外通过对象.属性为对象添加属性
obj.logo = "五菱宏光"
print(obj.logo)

如果想确认obj对象中是否有你新添加的logo属性,可以使用对象.__dict__获取类对象中的成员

 

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

在类外动态添加成员方法，可分为无参方法和有参方法

# 1.无参方法
def dahuangfeng():
    print("变形! 我是大黄蜂~")

obj.dahuangfeng = dahuangfeng
obj.dahuangfeng()

# 2.有参方法
# 2.1 基础版
def qingtianzhu(name):
    print("请我叫我一柱擎天,简称{}".format(name))

obj.qingtianzhu = qingtianzhu
obj.qingtianzhu("擎天柱")
    
# 2.2 升级版
def qingtianzhu(obj,name):
    print("请我叫我一柱擎天,简称{},颜色是{}".format(name,obj.color))
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu(obj,"擎天柱")


# 2.3 究极版 (即使调用类外动态创建的方法,也让系统自己传递obj对象本身)
'''在类外调用自定义方法时,系统不会自动传递obj对象参数'''
import types
def qingtianzhu(obj,name):
    print("请我叫我一柱擎天,简称{},颜色是{}".format(name,obj.color))
# MethodType(方法,对象) 把哪个方法和哪个对象绑定到一起,形成绑定方法
obj.qingtianzhu = types.MethodType(qingtianzhu,obj)
obj.qingtianzhu("擎天柱")

3.也可以使用lambda表达式实现在类外添加方法

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

面向对象封装:类的相关操作

类调用的方式也是两种：类.成员属性和类.成员方法

但是需要注意的是:类中的无参方法只能由类来调用！！

定义一个MyCar类,并定义其公私有属性和方法

class MyCar():
    # 公有属性
    oil = "2.0T"
    # 私有属性
    __price = "5000千万"
    # 公有方法
    def oil_info():
        print("百公里油耗是500升",MyCar.color)
    # 私有方法
    def __price_info():
        print("我的油耗信息是保密的")

请注意:对象不能调用类中无参的方法!!!

# 对象不能调用类中无参的方法
obj = MyCar()
obj.oil_info() # 请注意!!!对象不能调用类中无参的方法
'''
注意：对象不能调用类中无参的方法!!
原因:对象在调用方法时，会默认将obj对象作为参数传到类中的无参的方法,进而导致参数数量不一致
'''

1.定义的类访问公有成员和属性

# 访问公有成员属性
print(MyCar.oil)
# MyCar.__price     error # 无法在类外访问私有成员属性

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

2.定义的类动态添加公有成员和属性

1.添加成员属性

MyCar.color = "红色"
print(MyCar.color)
# 查看类对象内部成员使用__dict__,返回的是字典
print(MyCar.__dict__)

2.添加成员方法

# 1.无参方法
def fangxiangpan():
    print("改造方向盘的方法")
MyCar.fangxiangpan = fangxiangpan
MyCar.fangxiangpan()

print(MyCar.__dict__)

# 2.有参方法
def fadongji(engin):
    print("动力引擎改成{}".format(engin))
MyCar.fadongji = fadongji
MyCar.fadongji("三缸发动机")

# 3.lambda 表达式
MyCar.luntai = lambda name : print("使用{}的轮胎".format(name))
MyCar.luntai("米其林")

print(MyCar.__dict__)

3.需要注意:类不能反过来调用对象中的成员!!!

3.类和对象之间的差别

类和对象之间的区别:
1.对象可以调用类中的成员属性和方法,返过来,类不能调用对象中的成员.
2.类中的成员属性和方法归属于类本身,对象可以使用,但是没有修改和删除的权利.
3.对象在调用相应成员时,先看看自己有没有
　　如果有,调用自己的
　　如果没有,调用类中的成员
　　如果类中成员也没有,直接报错

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

定义Plane类,并创建如下属性和方法

class Plane():
    # 公有属性
    captain = "Mike"
    # 私有属性
    __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私有化,有两种方法:

方法一：

'''
关于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()
"""
针对于这个方法,我们可以在类中定义公有绑定方法和公有普通方法间接调用私有成员
"""
# 公有绑定方法->间接调用私有成员
def pub_info1(self):
    print(self.__sistem)
    self.__fly_info1()
        
# 公有普通方法->间接调用私有成员
def pub_info2():
    print(Plane.__sistem)
    Plane.__fly_info2()

实例化的对象/定义的类删除公有成员属性和公有成员方法

# 1.公有成员属性
# 对当前对象添加成员属性交captain
obj.captain = "王浩"
# 删除当前对象中的成员属性captain
del obj.captain
# 删除类当中的成员属性captain
del Plane.captain
print(obj.captain) # error 无论是类还是对象都没有改属性,所以报错;

# 2.公有成员方法
Plane.add_sistem = lambda self: print("因为业务需要,需要增加乘务员")
Plane.add_sistem(1)
obj.add_sistem()
# 删除类中的成员方法
del Plane.add_sistem
obj.add_sistem() # error 发现被删找不到了

obj.chaixie = lambda : print("我的飞机可以用来拆卸")
obj.chaixie()
# 删除对象中的成员方法
del obj.chaixie
obj.chaixie()  # error

最后:对象和类都可以使用__dict__方法查看当前类/对象中的成员

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}