python学习第20天

一.面向对象oop - 封装

1.类中封装:

成员属性和成员方法

2.封装等级

公有:公有成员既能够在类外调用,也可以在类调用

私有:私有成员不能够在类外调用,可以在类内调用 (前面加上双下划线表示)

3.调用语法:

对象.属性

对象.方法

4.类中的绑定方法(方法在类的内部)

1)绑定到对象(对象调用方法时,系统自动把该对象当成参数进行传递)

2)绑定到类(对象或者类调用方法时,系统自动把该类当成参数进行传递)

class MyCar():
   # 公有成员属性
   color = "屎黄色的"
   # 私有成员属性
   __logo = "五菱宏光"
   
   # 公有成员方法
   def drive(self):
      print("我的小车可以跑高速,可以泡妹子",self.color)

   # 私有成员方法
   def __info():
      print("我的价格是保密的,我的油耗也是保密的")

1.1对象的相关操作

类的实例化

obj = MyCar()

调用属性

print(obj.color)

调用方法

对象调用方法时,系统会自动把该对象当成参数传递到该方法中
为了保证形参实参一一对应,在定义方法时候,要加形参self,这个方法也叫绑定方法(绑定到对象)
obj.drive()

添加成员属性

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()

1.2类的相关操作

定义一个类

class MyCar():
   # 公有成员属性
   oil = "2.0T"
   # 私有成员属性
   __price = "5000万"
   
   # 公有无参方法
   def oil_info():
      print("我的油耗是百公里1000升,发动机是2.0T")
      
   # 私有无参方法
   def __price_info():
      print("我的价格信息")

定义的类访问公有成员属性和方法

print(MyCar.oil)
# MyCar.__price error
MyCar.oil_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__)

类和对象之间的注意点

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

对象调用类中的成员时

调用对象中的成员时,先看看自己有没有该成员,
如果有,那么就先调用自己的
如果没有,那么就调用类的.

1.3类中的私有成员

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.如何在类外调用私有成员

1)私有成员的改名策略 [_类名__成员名] (面向监狱编程,不推荐)

print(Plane.__dict__)
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("112233")
del Plane.fly
del obj.fly
obj.fly()

1.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.类可以是一个,对象可以使多个,可以通过一个类实例化多个不同的对象

每创建一个对象,都会单独占用一个空间,创建的越多,占用的空间就越大

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_func2("尉翼麟","白色")