面向对象的封装
1.基本语法
2.面向对象的封装 - 对象的操作
3.面向对象的封装 - 类的操作
4.总结
1.基本语法
# 1.类的定义(三种)
# (1)
class Car:
pass
# (2)
class Car():
pass
# (3)
class Car(object): # object:父类
pass
# 2.类的实例化 obj = Car()
class Car():
pass
obj = Car()
# 3.类的基本结构(只有两种)
"""
类中有两样东西:
(1)成员属性
(2)成员方法
"""
class Car():
# 成员属性
color = "白色"
# 成员方法
def didi():
print("小车会滴滴的叫")
# (4)类的命名
"""
类的命名:推荐使用大驼峰命名法,每个但粗的首字母都要大写
mycar => MyCar
"""
# 注意点:
"""
语法不报错,但是严禁使用,破坏了类中的结构
不要裸露的把循环判断直接写在类中,而是用方法包起来
"""
class Car() :
if 5 == 5:
print(11223344)
2.面向对象的封装 - 对象的操作
"""
封装:
1.私有: 在类内可以互相访问,在类外不能访问
2.公有: 在类内或者类外都可以访问
类中成员:
1.成员属性
2.成员方法
绑定方法:
1.绑定到对象 : 当对象去调用类中成员方法时,系统会默认吧该对象当成参数传递给该方法
2.绑定到类 : 当对象或者类去调用类中成员方法时,系统会默认把该类当成参数传递给该方法
"""
class A():
# 公有属性
a1 = "我是公有属性"
# 私有属性
__a2 = "我是私有属性"
# 公有方法(有参数)
def b1(self):
print("公有方法(有参数)")
# 私有方法(有参数)
def __c1(self):
print("私有方法(有参数)")
# 公有方法(无参数)
def b2():
print("公有方法(无参数)")
# 私有方法(无参数)
def __c2():
print("私有方法(无参数)")
def pub_get1(self):
print(self.__a2)
self.__c1()
def pub_get2():
print(A.__a2)
A.__c2()
A.__c1(obj)
# 实例化对象
obj = A()
# 1.实例化的对象访问成员属性和方法
# (1)访问公有成员属性和方法
print(obj.a1)
obj.b1()
"""对象不能访问公有成员无参的方法"""
# obj.b2() error
# (2)访问私有成员属性和方法 (两种方式)
# 方法一(python私有化)不推荐
"""类(对象).__dict__ => 查看类(对象)中的成员"""
print(A.__dict__) # _A__a2 _类 + 私有成员
"""
{
'__module__': '__main__',
'a1': 'a1', '_A__a2': '__a2',
'b1': <function A.b1 at 0x0000025491FA3620>,
'_A__c1': <function A.__c1 at 0x0000025491FA36A8>,
'b2': <function A.b2 at 0x0000025491FA3730>,
'_A__c2': <function A.__c2 at 0x0000025491FA37B8>,
'pub_get1': <function A.pub_get1 at 0x0000025491FA3840>,
'pub_get2': <function A.pub_get2 at 0x0000025491FA38C8>,
'__dict__': <attribute '__dict__' of 'A' objects>,
'__weakref__': <attribute '__weakref__' of 'A' objects>,
'__doc__': None
}
"""
# 对象._类 + 私有成员
print(obj._A__a2)
obj._A__c1()
# obj._A__c2() error (对象不能获取类无参方法)
# 方法二 访问私有成员(使用类中的公有方法,间接访问私有成员)
obj = A()
print("<======>")
obj.pub_get1()
A.pub_get2()
# 2.实例化的对象动态添加公有成员属性和方法
# (1)动态添加公有成员属性
obj.color = "白色"
print(obj.color)
# (2)实例化的对象动态添加公有成员方法
# 1).无参方法
def dahuangfeng():
print("请叫我大黄蜂")
obj.dahuangfeng = dahuangfeng
obj.dahuangfeng()
# 2).有参方法
# 基本版
def qingtianzhu(name):
print("我是{}".format(name))
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu("擎天柱")
# 升级版
def qingtianzhu(obj,name):
print("我是{},颜色{}".format(name,obj.color))
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu(obj,"擎天柱")
# 究极版
def qingtianzhu(obj,name):
print("我是{},颜色{}".format(name,obj.color))
# 创建绑定方法,让系统自动把该对象当成参数传递给方法
# types.MethodType(方法,对象) => 绑定方法
import types
obj.qingtianzhu = types.MethodType(qingtianzhu,obj)
obj.qingtianzhu("擎天柱")
# 3).lambda 方法
obj.weizhengtian = lambda : print("我是威震天")
obj.weizhengtian()
# 3.使用对象删除相应的成员
# 删除对象成员属性
obj.a3 = "我是公有成员属性a3"
del obj.a3
# 删除对象成员方法
obj.c3 = lambda : print("我是私有方法(无参)c3")
obj.c3()
del obj.c3
3.面向对象的封装 - 类的操作
"""
使用方式:
类.成员属性
类.成员方法
"""
class A():
# 公有属性
a1 = "我是公有属性"
# 私有属性
__a2 = "我是私有属性"
# 公有方法(有参数)
def b1(self):
print("公有方法(有参数)")
# 私有方法(有参数)
def __c1(self):
print("私有方法(有参数)")
# 公有方法(无参数)
def b2():
print("公有方法(无参数)")
# 私有方法(无参数)
def __c2():
print("私有方法(无参数)")
def pub_get1(self):
print(self.__a2)
self.__c1()
def pub_get2():
print(A.__a2)
A.__c2()
A.__c1(obj)
# 实例化对象
obj = A()
# 1.定义的类访问成员属性和方法
# (1)访问公有成员属性和方法
print(A.a1)
A.b1(obj)
"""类可以访问类中无参方法 , 也可以访问对象中的绑定方法"""
# (2)访问私有成员属性和方法 (两种方式)
# 方法一(python私有化)不推荐
print(A.__dict__) # _A__a2 _类 + 私有成员(属性或者方法)
"""
{
'__module__': '__main__',
'a1': 'a1', '_A__a2': '__a2',
'b1': <function A.b1 at 0x0000025491FA3620>,
'_A__c1': <function A.__c1 at 0x0000025491FA36A8>,
'b2': <function A.b2 at 0x0000025491FA3730>,
'_A__c2': <function A.__c2 at 0x0000025491FA37B8>,
'pub_get1': <function A.pub_get1 at 0x0000025491FA3840>,
'pub_get2': <function A.pub_get2 at 0x0000025491FA38C8>,
'__dict__': <attribute '__dict__' of 'A' objects>,
'__weakref__': <attribute '__weakref__' of 'A' objects>,
'__doc__': None
}
"""
# 类._类 + 私有成员
print(A._A__a2)
A._A__c1(obj) # 类可以获取对象中的绑定方法(需要给参数)
A._A__c2()
# 方法二 访问私有成员(使用类中的公有方法,间接访问私有成员)
obj = A()
print("<======>")
obj.pub_get1()
A.pub_get2()
# 2.实例化的对象动态添加公有成员属性和方法
# (1)动态添加公有成员属性
A.color = "白色"
print(A.color)
# (2)实例化的对象动态添加公有成员方法
# 1).无参方法
def dahuangfeng():
print("请叫我大黄蜂")
A.dahuangfeng = dahuangfeng
A.dahuangfeng()
# 2).有参方法
def qingtianzhu(name):
print("我是{}".format(name))
A.qingtianzhu = qingtianzhu
A.qingtianzhu("擎天柱")
# 3).lambda 方法
A.weizhengtian = lambda : print("我是威震天")
A.weizhengtian()
# 3.使用对象删除相应的成员
# 删除对象成员属性
A.a3 = "我是公有成员属性a3"
del A.a3
# 删除对象成员方法
A.c3 = lambda : print("我是私有方法(无参)c3")
A.c3()
del A.c3
4.总结
"""
总结:
1.三种表达类的方法 及 实例化对象(对象的实例化)
2.类中只有成员属性和方法,不要将代码裸露在类中,用方法包装起来
3.绑定方法 :
(1)绑定到对象 (2)绑定到类
4.对象的操作 :
(1)实例化对象访问成员属性和方法(私有和公有)
(2)实例化对象动态添加公有成员属性和方法
(3)使用对象删除相应的成员
5.类的操作 :
(1)定义的类访问成员属性和方法(私有和公有)
(2)定义的类动态添加公有成员属性和方法
(3)使用类删除相应的成员
6.对比 对象和类之间的不同
(1)类中的无参的方法只能类来调用
(2)对象可以调用类中的成员,但是,类不能调用对象当中的成员
(3)每实例化一个对象,,,它们在内存当中是独立的
(4)对象可以访问类中公有成员,但是无权修改或者删除
(5)对象在访问成员时,优先访问该对象自己的成员,如果没有在访问类的
"""
浙公网安备 33010602011771号