day17-Python运维开发基础(类的封装 / 对象和类的相关操作、构造方法)

1. 类的封装及相关操作

# ### oop 面向对象程序开发
"""
#用几大特征表达一类事物称为一个类,类更像是一张图纸,表达的是一个抽象概念
"""

# (1) 类的定义
# 1
class Car:
    pass
    
# 2 推荐
class Car():
    pass
    
# 3 
class Car(object):
    pass
    
# (2)类的实例化
class Car():
    pass
# 实例化对象 产生obj对象
obj = Car()

# (3)类的基本结构
class Car():
    # 成员属性
    color = "绿色"
    # 成员方法
    def didi():
        print("小车会滴滴的叫")

# 语法上允许,但是严禁使用
class Car():
    if 5==5:
        print(1234)
# 改成
class Car():
    def func():
        if 5==5:
            print(1234)

# (4)类的命名
"""
驼峰命名法: 推荐使用大驼峰命名法 -> mycar => MyCar
"""
class MyHouse():
    pass
    
class ChangyuanZhenHaoKan():
    pass

# ### oop 封装 
"""
对象的相关操作
语法:
    对象.属性
    对象.方法
    
类中的绑定方法:
    (1) 绑定到对象 : 在调用当前方法时,系统自动把该对象当成参数进行传递
    (2) 绑定到类   : 在调用当前方法时,系统自动把该类当成参数进行传递
"""

# 定义一个车类
class Car():
    # 公有属性
    color = "屎黄色的"
    
    # 私有属性
    __logo = "奥利a6"
    
    # 公有方法
    def drive(self):
        print("小车可以驾驶,载人拉客")
        
    # 私有方法
    def __price(self):
        print("车的成本价格保密")

# 实例化对象
obj = Car()

# (1)实例化的对象访问公有成员属性和方法
# 调用属性
print(obj.color)
# 调用方法
"""obj.drive 系统自动把obj这个对象传递给drive方法中,self这个形参进行接收"""
obj.drive()


# (2)实例化的对象动态添加公有成员属性和方法
# 添加属性
obj.color = "天蓝色"
print(obj.color)

# 添加方法
# (1) 添加无参方法
def engine():
    print("我是2.0发动机")
obj.engine = engine
obj.engine()
# __dict__ 查看对象或者类中的内部成员
print(obj.__dict__)

# (2) 添加有参方法
"""
def carname(name):
    print("小车的名字是",name)
obj.carname = carname
obj.carname("林肯加长版,前后加辅轮")
"""
# 升级1
"""
def carname(obj,name):
    print(obj.color) # 天蓝色
    print(name)      # 林肯加长版
obj.carname = carname
obj.carname(obj,"林肯加长版")
"""
# 升级2 形成绑定方法(绑定到对象)
def carname(obj,name):
    print(obj.color) # 天蓝色
    print(name)      # 林肯加长版
    
import types
# MethodType(绑定的函数,绑定的对象) 把那个方法绑定到那个对象上
obj.carname = types.MethodType(carname,obj)
obj.carname("林肯加长80米版") # 只需要自己手动传递一个参数即可,系统自己传递obj

# (3) 添加lambda表达式
obj.carlight = lambda : print("把车灯换成手电筒")
obj.carlight()

 

# ### oop 封装 
"""
类的相关操作
# 语法:
    类.属性
    类.方法
"""
class MyCar():
    # 公有属性
    oil = 2.0
    # 私有属性
    __price = "80万"
    
    # 公有方法
    def oil_info():
        print("我的百公里油耗2.0")
    # 私有方法
    def __price_info():
        print("我的价格保密")    
"""查看类中的成员"""
dic = MyCar.__dict__
print(dic)

# 实例化对象
obj = MyCar()
# 对象无法调用无参方法
# obj.oil_info() error


# (1)定义的类访问公有成员属性和方法
# 调用属性
print(MyCar.oil)
# 调用方法
MyCar.oil_info()


# (2)定义的类动态添加公有成员属性和方法
# 添加属性
MyCar.logo = "丰田_荣放"
print(MyCar.logo , MyCar.__dict__  )

# 添加方法
# (1) 添加无参方法
def dahuangfeng():
    print("我的车能变形,大黄蜂再此")
MyCar.dahuangfeng = dahuangfeng
MyCar.dahuangfeng()

# (2) 添加有参方法
def qingtianzhu(name):
    print("我的车能变形,我叫{},一柱擎天".format(name))
MyCar.qingtianzhu = qingtianzhu
MyCar.qingtianzhu("擎天柱")

# (3) 添加lambda表达式
MyCar.mieba = lambda : print("我是灭霸,人家都叫我爸爸,一个响指,十万八千里")
MyCar.mieba()

# (4) 无法在类外调用私有成员
# MyCar.__price_info() error

# (5) 对象无法调用无参方法
# obj.mieba()
print(obj.logo)
# obj.abc = 10
# 类不能调用对象中的成员
# print(MyCar.abc)

"""
总结:
    对象调用成员时,先找该对象中是否含有,
    如果有,调用自己的,如果没有,调类的(公有的)

    对象调用类中成员是单向的,类不能反过来调用对象中的成员;
    
    无论是类还是对象,其中的成员都归属与自己本身,
    对象如果没有会调用类中成员,但是类没有的话不会调用对象中成员
    是单向的,对象和类都不能互相修改或者删除对方的成员    
"""

# ### 1.如果使用类中的私有成员
class Plane():
    # 公共属性
    captain = "宗永玲"
    
    # 私有属性
    __air_sistem = 18
    
    # 公有绑定对象方法
    def fly1(self):
        print("飞机会飞,百公里油耗100L")

    # 公有无参普通方法
    def fly2():
        print("飞机会飞,百公里油耗200L")
        
    # 私有绑定对象方法
    def __fly3(self):
        print("飞机会飞,百公里油耗300L")
    
    # 私有无参普通方法
    def __fly4():
        print("飞机会飞,百公里油耗300L")
        
    # 定义一个公有绑定方法,调取类中的成员
    def pub_info(self): # self 是对象
        # self = obj  => obj.captain  
        print(self.captain)
        # 利用类内的公有方法,间接获取类中的私有成员(属性)
        print(self.__air_sistem)
        # 调用公有方法
        self.fly1()
        # 利用类内的公有方法,间接获取类中的私有成员(方法)
        self.__fly3()
        
    # 定义一个公有普通方法,调取类中的成员
    def pub_info2():
        print(Plane.captain) # Plane 是类
        print(Plane.__air_sistem)
        Plane.fly2()
        Plane.__fly4()
        
        
# 实例化对象
obj = Plane()
# 1.私有成员的改名策略  : _类名__私有名字 (不推荐)
print(Plane.__dict__)
# 调用私有属性
print(Plane._Plane__air_sistem)
# 调用私有方法
obj._Plane__fly3()

# 2.利用类中的公有方法,间接调用私有成员 (推荐)
# self 形参接收到obj这个对象
# print(obj.captain)
# obj.pub_info()
Plane.pub_info2()


# ### 2.删除类对象中的成员
"""删除的时候,看清该成员的归属"""
# 删除对象中的成员
# 删除属性
obj.captain = "朱京城"
print(obj.captain)
del obj.captain
print(obj.captain)

# 删除方法
print(obj.__dict__)
obj.func1 = lambda : print("我是func1")
obj.func1()
del obj.func1
# obj.func1()

# 删除类中的成员
# 删除属性
# del Plane.captain
# print(Plane.captain) error

# 删除方法
del Plane.pub_info
# Plane.pub_info(obj) error
# obj.pub_info() error

# 删除私有成员(不推荐,破坏类中结构)
# del Plane._Plane__air_sistem
# print(Plane._Plane__air_sistem)

 2. 构造方法

# ### 魔术方法 :特定时机自动触发
"""__init__ 构造方法"""
'''
    触发时机：实例化对象,初始化的时候触发
    功能：为对象添加成员
    参数：参数不固定,至少一个self参数
    返回值：无
'''

# (1) 基本语法
class MyClass():
    def __init__(self):
        self.name = "黄乐锡"
        
# 实例化对象
obj = MyClass()
print(obj.__dict__)
print(obj.name)

# (2) 传递2个参数
class MyClass():
    def __init__(self,name):
        # self.成员属性 = 参数值
        #       name    = name
        self.name = name
        
# 实例化对象
"""李诗韵默认传递到name形参进行接收"""
obj = MyClass("李诗韵")
print(obj.name)


# (3) 多个参数
"""同一个类,可以实例化出多个对象,而对象和对象之间,彼此独立"""
class Children():
    def __init__(self,name,skin):
        self.name = name
        self.skin = skin
        
    def eat(self):
        print("小孩一下生手里拿了2串大腰子")
        
    def drink(self):
        print("小孩一下生手里拿了两瓶啤酒")
        
    def __sleep(self):
        print("小孩一天睡觉时间是23个小时")
        
    def pub_info(self):
        # 在类中,只能使用对象.属性/方法 或 类.属性/方法进行调用
        print("该对象name是{},该对象skin是{}".format(self.name,self.skin))

# 实例化一个对象
datuichui = Children("大铁锤","粉色")
datuichui.pub_info()

# 实例化第二个对象
wanggangdan = Children("王钢蛋","黑色")
wanggangdan.pub_info()

# 实例化第三个对象
wangbaoqiang = Children("王宝强","绿色")
wangbaoqiang.pub_info()

day17