面向对象之封装，类的相关操作，私有成员删除，构造方法__init__---day20

1.面向对象之封装

# ### 面向对象oop -封装
"""
类中封装:
    成员属性
    成员方法
    
封装等级：
    1.公有:公有成员既能够在类外调用，也可在类内调用
    2.私有:私有成员不能够在类外调用，可以在类内调用

调用语法：
    对象.属性
    对象.方法
    

类中的绑定方法(方法在类的内部)
    (1)绑定到对象(对象调用方法时,系统自动把该对象当成参数进行传递)
    (2)绑定到类(对象或者类调用方法时,系统自动把该类当成参数进行传递)
"""
class MyCar():
    #公有成员属性
    color = "屎黄色的"
    #私有成员属性
    __logo = "五菱宏光"
    
    #公有成员方法
    def drive(self):
        print("我的小车可以跑高速,可以泡妹纸",self.color)
        
    #私有成员方法
    def __info():
        print("我的价格是保密的,我的油耗也是保密的")
        

#类的实例化
obj = MyCar()

#对象的相关操作
#(1)实例化的对象访问公有成员属性和方法
#调用属性
print(obj.color)
#调用方法
'''对象调用方法时，系统会自动把该对象当成参数传递到该方法中
为了保证形参实参一一对应,在定义方法时候,要加形参self，这个方法也叫作绑定方法(绑定到对象0

'''
obj.drive()
#调用私有成员
#obj.__logo  #error


#(2)实例化的对象动态添加公有成员属性和方法
#添加成员属性
obj.color ="武士黑"
#__dict__查看对象或者类当中的成员,返回一个字典
print(obj.__dict)
print(obj.color)
obj.drive()


#添加成员方法
#(1)动态添加无参方法
def dahuangfeng():
    print("变形!请叫我大黄蜂")
    
#对象.属性(自定义的) = 方法
obj.dahuangfeng = dahuangfeng 
obj.dahuangfeng()

#(2) 动态添加有参方法
#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对象)在类外,让系统自动帮助传递obj这个对象参数
import types

def qingtianzhu(self,name):
    print("变形!请叫我一柱擎天,简称{},我的颜色是{}".format(name , self.color))
    
#通过MethodType 来创建一个绑定方法，自动传递obj对象
#types.MethodType(函数,对象)当调用方法时,自动把对象当成参数传递给该方法
obj.qingtianzhu = types.MethodType(qingtianzhu,obj)
obj.qingtianzhu("擎天柱")

#(3) 动态添加lambda 匿名函数
obj.weizhentian = lambda : print("变形! 请叫我威震天")
obj.weizhentian()

print(obj.__dict__)

2.类的相关操作

#  ### 类的相关操作

class MyCar():
    #公有成员属性
    oil ="2.0T"
    #私有成员属性
    __price = "5000万"
    
    #公有无参方法
    def oil_info():
        print("我的油耗是百公里1000升,发动机是2.0T")
        
    #私有无参方法
    def __price_info():
        print("我的价格信息")
        
#实例化对象
'''
obj = MyCar()
obj.oil_info()
'''
#类的相关操作
#(一)定义的类访问公有成员属性和方法
print(MyCar.oil)
#MyCar.__price  #error
MyCar.oi;_info()


#(二)定义的类动态添加公有成员属性和方法
#添加公有成员属性
MyCar.logo = "法拉利"
print(MyCar.__dict__)

#添加公有成员方法
#(1) 动态添加公有无参方法
def fangxiangpan():
    print("制造方向盘的方法")
#类.成员(自定义名字) = 方法
MyCar.fangxiangpan = fangxiangpan
MyCar.fangxiangpan()


#(2)动态添加公有有参方法
def engine(dongli):
    print("我的发动机是%s"%(dongli))
    
MyCar.engine = engine
MyCar.engine("四缸发动机")


#(3) 动态添加lambda表达式
MyCar.luntai = lambda pinpai:print("我的轮胎使用的品牌是%s" % pinpai)
MyCar.luntai("米其林")
print(MyCar.__dict__)


# ### 类和对象之间的注意点
'''
类中的成员只归属当前这个类本身
对象可以调用其中的公有成员，但是没有修改和删除的权利，因为都是归属于类，不是对象中的成员
类无法调用对象中的成员，但是对象可以调用类中的相关成员
'''

#对象调用类中成员
'''
调用对象中的成员时，先看看自己有没有该成员
如果有，那就先调用自己的
如果没有，那么就调用类的
'''
obj = MyCar()
print(obj.logo)
obj2.logo = '玛莎拉蒂'
print(obj2.logo)
print(obj.__dict__)

#类调用对象中的成员
print(MyCar.logo)  #error 报错

3.私有成员之删除成员

# ### 1.类中的私有成员
class Plane():
    #公有成员属性
    captain = "刘伟"
    #私有成员属性
    __airsistem = 3
    
    #公有绑定方法
    def fly(self):
        print("飞机会飞,百公里油耗2万升1")
    
    #公有无参方法
    def fly2():
        print("飞机会飞,百公里油耗2万升2")
        
    #私有绑定方法
    def __plane_info(self): 
        print("飞机上的空姐数量是保密的,个数%d" % (self.__airsistem))
        
    #私有无参方法
    def __plane_info2():
        print("飞机上的空姐数量是保密的,个数%d" % (Plane.__airsistem))
        
    #用pub_info调用私有成员属性和方法
    def pub_info(self):
        print(self.__airsistem) #3
        self.__plane_info()
        
    def pub_info2():
        print(Plane.__airsistem)
        Plane.__plane_info2()
        
obj = Plane()
obj.fly()
Plane.fly2()
print(Plane.__dict__)


#(1) 私有成员的改名策略[_类名__成员名](不推荐)
print(obj._Plane__airsistem)
print(Plane._Plane__airsistem)

obj._Plane__plane_info()
Plane._Plane__plane_info2()


#(2)利用类内的公有方法间接调用私有成员(推荐)
obj.pub_info()
Plane.pub_info2()




# ### 2.删除相关成员

#(1)实例化的对象删除公有成员属性和方法
obj.captain = "王思聪"
print(obj.__dict__)
#删除属性
del obj.captain
print(obj.__dict__)
#如果对象有该成员，先调用自己的，没有的话，调用类的，如果都没有，就报错
print(obj.captain)

#删除方法
obj.func = lambda : print("开飞机是为了泡妞")
obj.func()
#Plane.func()  #error
del obj.func()
#obj.func()  #error


#(2) 定义的类删除公有成员属性和方法    
#删除属性
del Plane.captain
#print(Plane.captain)
#obj.captain  #error #对象和类当中没有captain成员

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

#注意点
obj.fly = lambda:print('1234')#这个是我自己又定义了一个方法
del Plane.fly #这个删除的是类里面的方法
del obj.fly #这个删除是我刚才定义的
obj.fly() #报错，都被删除了。这个是不同的成员方法

#注意点
obj = Plane() #创建实例对象
obj.fly()   #调用类里面的方法
del Plane.fly  #删除类调用方法
obj.fly()  #再用对象调用方法，报错

4.构造方法之__init__

# ### 魔术方法

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

#(1) 基本语法
class MyClass():
    def __init__(self):
        print(11)
        self.name = '刘伟'
        print(22)

#实例化对象
print(33)
obj = MyClass()
print(44)
print(obj.name)
print(55)

#(2)带有多个参数的构造方法
class MyClass():
    def __init__(self,name):
        #对象.成员属性(自定义) = 参数值
        self.name = name
#实例化(如果构造方法里面含有额外参数，在实例化时，需要传参)
obj = MyClass("刘伟")
print(obj.name)

#(3)类可以是1个，对象可以是多个，可以通过一个类实例化多个不同的对象
'''没创建一个对象，都会单独占用一个空间，创建的越多，占用的空间越大'''
class Children():
    def __init__(self,name,skin):
        self.name = name
        self.skin = skin
        
    def cry(self):
        print("小孩生下直接哭")
        
    def drink(self):
        print("小孩生下直接吃奶奶")
    
    def __eat(self):
        print("小孩自己吃自己的手指")
        
    def pub_func(self):
        print("该对象的名字是{},该对象的肤色是{}".format(self.name,self.skin))
        
    #注意点
    def pub_func2(self,name,skin):
        print("该对象的名字是{},该对象的肤色是{}".format(name,skin))
        
#创建第一个对象
afanda = Children("王铁柱","蓝色")
afanda.cry()
afanda.pub_func()


#创建第二个对象
dan = Children("王大锤","黑色")
dan.drink()
dan.pub_func()

#创建第三个对象
bao = Children("王宝强","绿色")
bao.pub_func()

#注意点：
bao.pub_func("刘伟","白色") #报错