0803Python总结-面向对象

一.oop 面向对象的程序开发

(1)类的定义

class MyClass:
    pass

class MyClass():  # (推荐)
    pass

class MyClass(object):
    pass

(2)类的实例化

class MyCar():
    color = "黄色的"

# 实例化对象(类的实例化)
obj = MyCar()  # object -> obj

(3)类的基本结构

1.成员属性
2.成员方法

class MyCar():
    # 成员属性
    color = "天蓝色的"
    # 成员方法
    def didi():
        print("小车会滴滴叫")

反例:这种写法可以直接在Python当中执行,但是严禁使用
如果想要表达逻辑或者循环,需要写在成员方法当中,不能直接裸露的写在类当中,会破坏类中结构

"""
class MyCar():
    if 5 == 5:
        print("打印成功")
"""

(4)类的命名

驼峰命名法:推荐起类名的时候,使用大驼峰命名法
mycar -> MyCar mymouse => MyMouse

二.oop 面向对象 – 封装

封装等级:
(1)私有:在类的内部可以访问,在类外不可以
(2)公有:在类的内部可以访问,在类外也可以访问

封装成员:
(1)成员属性
(2)成员方法

调用成员:
(1)对象.成员属性
(2)对象.成员方法

绑定方法:
(1)绑定到对象:对象调用方法时,系统自己默认传递该对象,作为一个参数传递到当前方法中
(2)绑定到类:对象或者类调用方法时,系统自己默认传递该类,作为一个参数传递到当前方法中

class MyCar():
    # 公有成员属性
    color = "屎黄色"
    logo = "中国吉利汽车"
    # 私有成员属性
    __price = "2000万"

    # 公有成员方法
    def run(self):
        print("小车会跑,百里0.01秒,颜色{}".format(self.color))  # self <=> obj
    # 私有成员方法
    def __info(self):
        print("车主信息是保密的,传说是京城有名的富二代")

# 实例化对象(类的实例化)
obj = MyCar()

(1)实例化的对象访问公有成员属性和方法

访问属性

print(obj.color)  # 屎黄色
# obj.__price  私有成员属性不能够在类外调用

访问方法

obj.run()  # 小车会跑,百里0.01秒,颜色屎黄色
# obj.__info()  error 私有成员方法不能够在类外调用

# obj.run()  # 小车会跑,百里0.01秒,颜色屎黄色
# # obj.__info()  error 私有成员方法不能够在类外调用
# 在类外动态添加成员属性 -> obj 对象
# obj.logo = "五菱宏光"
# print(obj.logo)
# __dict__ 是获取类对象中的成员
print(obj.__dict__)  # {}

在类外动态添加成员方法 -> obj对象

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(obj, name):
    print("请叫我一柱擎天,简称{},颜色是{}".format(name, obj.color))
# MethodType(方法,对象) 把哪个方法和哪个对象绑定到一起,形成绑定方法
obj.qingtianzhu = types.MethodType(qingtianzhu, obj)
obj.qingtianzhu("擎天柱")  # 请叫我一柱擎天,简称擎天柱,颜色是屎黄色

3.lambda表达式

obj.weizhentian = lambda : print("我是威震天")
obj.weizhentian()  # 我是威震天

三.oop 面向对象封装 – 类的相关操作

类调用的方式:
类.成员属性
类.成员方法
类中的无参方法只能是类来调用

class MyCar():
    # 公有属性
    oil = "2.0T"
    # 私有属性
    __price = "5000万"
    # 公有方法
    def oil_info():
        print("百里耗油是500升")
    # 私有方法
    def __price_info():
        print("我的耗油信息是保密的")

# 实例化对象
"""
对象不能调用类中无参的方法
obj = MyCar()
obj.oil_info
"""

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

访问公有成员属性

print(MyCar.oil)  # 2.0T
# MyCar.__price  error 无法在类外访问私有成员属性

访问公有成员方法

MyCar.oil_info()  # 百里耗油是500升
# MyCar.__price_info()  error 无法在类外访问私有成员方法

二.定义的类动态添加公有属性和方法

1.添加成员属性

MyCar.color = "屎绿色"
print(MyCar.color)  # 屎绿色
# 查看类对象内部成员使用__dict__,返回的是字典
print(MyCar.__dict__)
# MyCar.oil_info()  # 百里耗油是500升

2.添加成员方法

(1)无参方法

def fangxiangpan():
    print("改造方向盘的方法")
MyCar.fangxiangpan = fangxiangpan
MyCar.fangxiangpan()  # 改造方向盘的方法

print(MyCar.__dict__)  # {'__module__': '__main__', 'oil': '2.0T', '_MyCar__price': '5000万', 'oil_info': <function MyCar.oil_info at 0x7fdf598191e0>, '_MyCar__price_info': <function MyCar.__price_info at 0x7fdf59819268>, '__dict__': <attribute '__dict__' of 'MyCar' objects>, '__weakref__': <attribute '__weakref__' of 'MyCar' objects>, '__doc__': None, 'color': '屎绿色', 'fangxiangpan': <function fangxiangpan at 0x7fdf59819158>}

(2)有参方法

def fadongji(engin):
    print("动力引擎改成{}".format(engin))
MyCar.fadongji = fadongji
MyCar.fadongji("三缸发动机")

# lambda表达式
MyCar.luntai = lambda name : print("使用{}的轮胎".format(name))
MyCar.luntai("米其林")  # 使用米其林的轮胎

print(MyCar.__dict__)  # {'__module__': '__main__', 'oil': '2.0T', '_MyCar__price': '5000万', 'oil_info': <function MyCar.oil_info at 0x7fcb12620158>, '_MyCar__price_info': <function MyCar.__price_info at 0x7fcb126201e0>, '__dict__': <attribute '__dict__' of 'MyCar' objects>, '__weakref__': <attribute '__weakref__' of 'MyCar' objects>, '__doc__': None, 'color': '屎绿色', 'fangxiangpan': <function fangxiangpan at 0x7fcb126ffea0>, 'fadongji': <function fadongji at 0x7fcb12620268>, 'luntai': <function <lambda> at 0x7fcb126202f0>}

obj = MyCar()
# obj.logo = "柯尼塞格"
# print(MyCar.logo)  error 类不能返回调用对象中的成员

类和对象之间的区别
对象可以调用类中的成员属性和方法,反过来,类不能调用对象中的成员
类中的成员属性和方法归属于类本身,对象可以使用,但是没有修改和删除的权利
对象在调用相应成员时,先看看自己有没有
    如果有,调用自己的
    如果没有,调用类中的成员
    如果类中成员也没有,直接报错

MyCar.logo = "别摸我,我是宝马bmw"
obj.logo = "柯尼塞格"
print(obj.__dict__)  # {'logo': '柯尼塞格'}
print(obj.logo)  # 柯尼塞格

三.如何访问类中的私有成员

class Plane():
	# 公有属性
	caption = "宋云杰"
	# 私有属性
	__sister = 10

	# 公有绑定方法
	def fly1(self):
		print("我的飞机可以倒着飞1")

	# 公有普通方法
	def fly2():
		print("我的飞机可以倒着飞2")

	# 私有绑定方法
	def __fly_info1(self):
		print("我的飞机,百公里油耗5万升1")

	# 私有普通方法
	def __fly_info2():
		print("我的飞机,百公里油耗5万升2")

	# 公有绑定方法-> 间接调用私有成员
	def pub_info1(self):
		print(self.__sister)
		self.__fly_info1()

	# 公有普通方法->间接调用私有成员
	def pub_info2():
		print(Plane.__sister)
		Plane.__fly_info2()

关于python私有化的实现方法:改名策略
_类名 + 私有成员 => 改名策略

方法一.调用私有成员(不推荐使用改名策略找到私有成员,破坏封装性)

# 对象调用类中的私有成员
obj = Plane()
print(obj._Plane__sister)  # 10
obj._Plane__fly_info1()  # 我的飞机,百公里油耗5万升1

# 类调用类中的私有成员
print(Plane._Plane__sister)  # 10
Plane._Plane__fly_info2()  # 我的飞机,百公里油耗5万升2
print(Plane.__dict__)  # {'__module__': '__main__', 'caption': '宋云杰', '_Plane__sister': 10, 'fly1': <function Plane.fly1 at 0x000001CDF696F1E0>, 'fly2': <function Plane.fly2 at 0x000001CDF6B356A8>, '_Plane__fly_info1': <function Plane.__fly_info1 at 0x000001CDF6B35C80>, '_Plane__fly_info2': <function Plane.__fly_info2 at 0x000001CDF6B35D08>, 'pub_info1': <function Plane.pub_info1 at 0x000001CDF6B35D90>, 'pub_info2': <function Plane.pub_info2 at 0x000001CDF6B35E18>, '__dict__': <attribute '__dict__' of 'Plane' objects>, '__weakref__': <attribute '__weakref__' of 'Plane' objects>, '__doc__': None}

方法二.类或对象利用公有方法,间接找到私有成员(推荐)

obj.pub_info1()  # 10  我的飞机,百公里油耗5万升1
Plane.pub_info2()  # 10  我的飞机,百公里油耗5万升2

四.实例化的对象/定义的类 删除公有成员属性 和 公有成员方法

print(obj.__dict__)  # {}

1.公有成员属性

# 对当前对象添加成员属性叫captain
obj.caption = "王浩"
# 删除当前对象中的成员属性captain
del obj.caption
# 删除类当中的成员属性captain
del Plane.caption
# 无论是类还是对象都没有改属性,所以报错
# print(obj.caption)  error

2.公有成员方法

Plane.add_sister = lambda self: print("因为业务需要,需要增加空姐", "=======")

# del Plane.add_sister
Plane.add_sister(1)  # 因为业务需要,需要增加空姐 =======
obj.add_sister()  # 因为业务需要,需要增加空姐 =======
# 删除类中的成员方法
del Plane.add_sister
# obj.add_sister()  error 发现被删到不到

obj.paoniu = lambda : print("我的飞机可以用来泡妞")
obj.paoniu()  # 我的飞机可以用来泡妞
# 删除对象中的成员方法
del obj.paoniu
# obj.paoniu()  error

print(obj.__dict__)  # {}
print(Plane.__dict__)  # {'__module__': '__main__', '_Plane__sister': 10, 'fly1': <function Plane.fly1 at 0x000001CDF696F1E0>, 'fly2': <function Plane.fly2 at 0x000001CDF6B356A8>, '_Plane__fly_info1': <function Plane.__fly_info1 at 0x000001CDF6B35C80>, '_Plane__fly_info2': <function Plane.__fly_info2 at 0x000001CDF6B35D08>, 'pub_info1': <function Plane.pub_info1 at 0x000001CDF6B35D90>, 'pub_info2': <function Plane.pub_info2 at 0x000001CDF6B35E18>, '__dict__': <attribute '__dict__' of 'Plane' objects>, '__weakref__': <attribute '__weakref__' of 'Plane' objects>, '__doc__': None}