8.03_python_lx_day22

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

(1)类的定义

<1>

1 class MyClass:    
2     pass

<2>

1 class MyClass(): #(推荐)
2     pass

<3>

1 class MyClass(object):
2     pass

(2)类的实例化(实例化对象)

1 class MyCar():
2     color = "黄色的"
3 obj = MyCar() # object -> obj

(3)类的基本结构

<1>成员属性
<2>成员方法

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

<3>错误示例:这种写法可以直接在python当中执行,但是严禁使用

　如果想要表达逻辑或者循环,需要写在成员方法当中,不能直接裸露的写在类当中,会破坏类中结构.

1 class MyCar():
2     if 5 == 5:
3         print("打印成功123456")

<4>类的命名

驼峰命名法 : 推荐起类名的时候,使用大驼峰命名法.

mycar -> MyCar   mymouse => MyMouse

二.oop 面向对象封装 -- 对象的相关操作

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

封装成员:
　　<1> 成员属性
　　<2> 成员方法

调用成员:
　　<1> 对象.成员属性
　　<2> 对象.成员方法

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

 1 class MyCar():
 2     # 公有成员属性
 3     color = "屎黄色"
 4     logo =  "中国吉利汽车"
 5     # 私有成员属性
 6     __price = "2000万"
 7     
 8     # 公有成员方法
 9     def run(self):
10         print("小车会跑,百公里0.01秒,颜色{}".format(self.color)) # self <=> obj 
11     # 私有成员方法
12     def __info(self):
13         print("车主信息是保密的,传说是京城有名的富二代")
14 # 实例化对象(类的实例化)
15 obj = MyCar()

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

<1>访问属性

1 print( obj.color    )
2 # obj.__price error  # 私有成员属性不能够在类外调用

<2>访问方法

1 obj.run()
2 # obj.__info() error  # 私有成员方法不能够在类外调用

(2)实例化的对象动态添加公有成员属性和方法

<1>在类外动态添加成员属性 -> obj对象

1 obj.logo = "五菱宏光"
2 print(obj.logo)
3 #__dict__ 是获取类对象中的成员
4 print(obj.__dict__)

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

①无参方法

 

②有参方法

  1. 基础版 
    1 def dahuangfeng():
2     print("变形! 我是大黄蜂~")
3 obj.dahuangfeng = dahuangfeng
4 obj.dahuangfeng()
  2. 升级版 
    1 def qingtianzhu(obj,name):
2     print("请我叫我一柱擎天,简称{},颜色是{}".format(name,obj.color))
3 obj.qingtianzhu = qingtianzhu
4 obj.qingtianzhu(obj,"擎天柱")
  3. 究极版 (即使调用类外动态创建的方法,也让系统自己传递obj对象本身) 
    1 #在类外调用自定义方法时,系统不会自动传递obj对象参数
2 import types
3 def qingtianzhu(obj,name):
4     print("请我叫我一柱擎天,简称{},颜色是{}".format(name,obj.color))
5 # MethodType(方法,对象) 把哪个方法和哪个对象绑定到一起,形成绑定方法
6 obj.qingtianzhu = types.MethodType(qingtianzhu,obj)
7 obj.qingtianzhu("擎天柱")

③lambda 表达式

1 obj.weizhentian = lambda : print("我是威震天~ ")
2 obj.weizhentian()

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

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

 1 class MyCar():
 2     # 公有属性
 3     oil = "2.0T"
 4     # 私有属性
 5     __price = "5000千万"
 6     # 公有方法
 7     def oil_info():
 8         print("百公里油耗是500升",MyCar.color)
 9     # 私有方法
10     def __price_info():
11         print("我的油耗信息是保密的")
12 #实例化对象
13 # 注意!!!对象不能调用类中无参的方法
14 obj = MyCar()
15 obj.oil_info()

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

<1>访问公有成员属性

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

<2>访问公有成员方法

1 MyCar.oil_info()
2 MyCar.__price_info() error # 无法在类外访问私有成员方法

(2)定义的类动态添加公有成员属性和方法

<1>添加成员属性

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

<2>添加成员方法

  1. 无参方法 
    1 def fangxiangpan():
2     print("改造方向盘的方法")
3 MyCar.fangxiangpan = fangxiangpan
4 MyCar.fangxiangpan()
5 print(MyCar.__dict__)
  2. 有参方法 
    1 def fadongji(engin):
2     print("动力引擎改成{}".format(engin))
3 MyCar.fadongji = fadongji
4 MyCar.fadongji("三缸发动机")
  3. lambda 表达式 
    1 MyCar.luntai = lambda name : print("使用{}的轮胎".format(name))
2 MyCar.luntai("米其林")
3 print(MyCar.__dict__)

(3)类不能返回来调用对象中的成员

1 obj = MyCar()
2 obj.logo = "柯尼塞格"
3 #print(MyCar.logo) error

(4)类和对象之间的区别

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

四.oop面向对象删除操作

(1)如何访问类中的私有成员

class Plane():
    # 公有属性
    captain = "123"
    # 私有属性
    __sistem = 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.__sistem)
        self.__fly_info1()
        
    def pub_info2():
        print(Plane.__sistem)
        Plane.__fly_info2()

<1>关于python私有化的实现方法: 改名策略　　　

_类名 + 私有成员 => 改名策略

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

①对象调用类中的私有成员

1 obj = Plane()
2 print(obj._Plane__sistem)
3 obj._Plane__fly_info1()

②类调用类中的私有成员

1 obj = Plane()
2 print(Plane._Plane__sistem)
3 Plane._Plane__fly_info2()
4 print(Plane.__dict__)

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

1 obj.pub_info1()
2 Plane.pub_info2()

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

<1>公有成员属性

①对当前对象添加成员属性交captain

obj.captain = "abc"

②删除当前对象中的成员属性captain

del obj.captain

③删除类当中的成员属性captain

del Plane.captain

④无论是类还是对象都没有改属性,报错;

# print(obj.captain) error

<2>公有成员方法

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

<1>删除类中的成员方法

del Plane.add_sistem

<2>发现被删找不到报错

# obj.add_sistem() error

<3>创建对象方法

obj.paoniu = lambda : print("我的飞机可以用来泡妞")

<4>删除对象中的成员方法

del obj.paoniu
发现被删找不到报错
# obj.paoniu() error
posted @ 2020-08-03 23:33  Magicianlx  阅读(91)  评论(0)  编辑  收藏  举报