python中如何对一个属性或方法进行封装_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("尉翼麟","白色")