day17-Python运维开发基础(类的封装 / 对象和类的相关操作、构造方法)

1. 类的封装及相关操作

# ### oop 面向对象程序开发

"""

#用几大特征表达一类事物称为一个类,类更像是一张图纸,表达的是一个抽象概念

"""

# (1) 类的定义

#

class Car:

    pass

# 2 推荐

class Car():

    pass

# 3

class Car(object):

    pass

# (2)类的实例化

class Car():

    pass

# 实例化对象 产生obj对象

obj = Car()

# (3)类的基本结构

class Car():

    # 成员属性

    color = "绿色"

    # 成员方法

    def didi():

        print("小车会滴滴的叫")

# 语法上允许,但是严禁使用

class Car():

    if 5==5:

        print(1234)

# 改成

class Car():

    def func():

        if 5==5:

            print(1234)

# (4)类的命名

"""

驼峰命名法: 推荐使用大驼峰命名法 -> mycar => MyCar

"""

class MyHouse():

    pass

class ChangyuanZhenHaoKan():

    pass

OOP面向对象程序开发示例代码

# ### oop 封装

"""

对象的相关操作

语法:

    对象.属性

    对象.方法

类中的绑定方法:

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

    (2) 绑定到类   : 在调用当前方法时,系统自动把该类当成参数进行传递

"""

# 定义一个车类

class Car():

    # 公有属性

    color = "屎黄色的"

    # 私有属性

    __logo = "奥利a6"

    # 公有方法

    def drive(self):

        print("小车可以驾驶,载人拉客")

    # 私有方法

    def __price(self):

        print("车的成本价格保密")

# 实例化对象

obj = Car()

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

# 调用属性

print(obj.color)

# 调用方法

"""obj.drive 系统自动把obj这个对象传递给drive方法中,self这个形参进行接收"""

obj.drive()

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

# 添加属性

obj.color = "天蓝色"

print(obj.color)

# 添加方法

# (1) 添加无参方法

def engine():

    print("我是2.0发动机")

obj.engine = engine

obj.engine()

# __dict__ 查看对象或者类中的内部成员

print(obj.__dict__)

# (2) 添加有参方法

"""

def carname(name):

    print("小车的名字是",name)

obj.carname = carname

obj.carname("林肯加长版,前后加辅轮")

"""

# 升级1

"""

def carname(obj,name):

    print(obj.color) # 天蓝色

    print(name)      # 林肯加长版

obj.carname = carname

obj.carname(obj,"林肯加长版")

"""

# 升级2 形成绑定方法(绑定到对象)

def carname(obj,name):

    print(obj.color) # 天蓝色

    print(name)      # 林肯加长版

import types

# MethodType(绑定的函数,绑定的对象) 把那个方法绑定到那个对象上

obj.carname = types.MethodType(carname,obj)

obj.carname("林肯加长80米版") # 只需要自己手动传递一个参数即可,系统自己传递obj

# (3) 添加lambda表达式

obj.carlight = lambda : print("把车灯换成手电筒")

obj.carlight()

类的封装-对象的相关操作示例代码

# ### oop 封装

"""

类的相关操作

# 语法:

    类.属性

    类.方法

"""

class MyCar():

    # 公有属性

    oil = 2.0

    # 私有属性

    __price = "80万"

    # 公有方法

    def oil_info():

        print("我的百公里油耗2.0")

    # 私有方法

    def __price_info():

        print("我的价格保密")

"""查看类中的成员"""

dic = MyCar.__dict__

print(dic)

# 实例化对象

obj = MyCar()

# 对象无法调用无参方法

# obj.oil_info() error

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

# 调用属性

print(MyCar.oil)

# 调用方法

MyCar.oil_info()

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

# 添加属性

MyCar.logo = "丰田_荣放"

print(MyCar.logo , MyCar.__dict__  )

# 添加方法

# (1) 添加无参方法

def dahuangfeng():

    print("我的车能变形,大黄蜂再此")

MyCar.dahuangfeng = dahuangfeng

MyCar.dahuangfeng()

# (2) 添加有参方法

def qingtianzhu(name):

    print("我的车能变形,我叫{},一柱擎天".format(name))

MyCar.qingtianzhu = qingtianzhu

MyCar.qingtianzhu("擎天柱")

# (3) 添加lambda表达式

MyCar.mieba = lambda : print("我是灭霸,人家都叫我爸爸,一个响指,十万八千里")

MyCar.mieba()

# (4) 无法在类外调用私有成员

# MyCar.__price_info() error

# (5) 对象无法调用无参方法

# obj.mieba()

print(obj.logo)

# obj.abc = 10

# 类不能调用对象中的成员

# print(MyCar.abc)

"""

总结:

    对象调用成员时,先找该对象中是否含有,

    如果有,调用自己的,如果没有,调类的(公有的)

    对象调用类中成员是单向的,类不能反过来调用对象中的成员;

    无论是类还是对象,其中的成员都归属与自己本身,

    对象如果没有会调用类中成员,但是类没有的话不会调用对象中成员

    是单向的,对象和类都不能互相修改或者删除对方的成员

"""

封装_类的相关操作示例代码

# ### 1.如果使用类中的私有成员

class Plane():

    # 公共属性

    captain = "宗永玲"

    # 私有属性

    __air_sistem = 18

    # 公有绑定对象方法

    def fly1(self):

        print("飞机会飞,百公里油耗100L")

    # 公有无参普通方法

    def fly2():

        print("飞机会飞,百公里油耗200L")

    # 私有绑定对象方法

    def __fly3(self):

        print("飞机会飞,百公里油耗300L")

    # 私有无参普通方法

    def __fly4():

        print("飞机会飞,百公里油耗300L")

    # 定义一个公有绑定方法,调取类中的成员

    def pub_info(self): # self 是对象

        # self = obj  => obj.captain

        print(self.captain)

        # 利用类内的公有方法,间接获取类中的私有成员(属性)

        print(self.__air_sistem)

        # 调用公有方法

        self.fly1()

        # 利用类内的公有方法,间接获取类中的私有成员(方法)

        self.__fly3()

    # 定义一个公有普通方法,调取类中的成员

    def pub_info2():

        print(Plane.captain) # Plane 是类

        print(Plane.__air_sistem)

        Plane.fly2()

        Plane.__fly4()

# 实例化对象

obj = Plane()

# 1.私有成员的改名策略  : _类名__私有名字 (不推荐)

print(Plane.__dict__)

# 调用私有属性

print(Plane._Plane__air_sistem)

# 调用私有方法

obj._Plane__fly3()

# 2.利用类中的公有方法,间接调用私有成员 (推荐)

# self 形参接收到obj这个对象

# print(obj.captain)

# obj.pub_info()

Plane.pub_info2()

# ### 2.删除类对象中的成员

"""删除的时候,看清该成员的归属"""

# 删除对象中的成员

# 删除属性

obj.captain = "朱京城"

print(obj.captain)

del obj.captain

print(obj.captain)

# 删除方法

print(obj.__dict__)

obj.func1 = lambda : print("我是func1")

obj.func1()

del obj.func1

# obj.func1()

# 删除类中的成员

# 删除属性

# del Plane.captain

# print(Plane.captain) error

# 删除方法

del Plane.pub_info

# Plane.pub_info(obj) error

# obj.pub_info() error

# 删除私有成员(不推荐,破坏类中结构)

# del Plane._Plane__air_sistem

# print(Plane._Plane__air_sistem)

删除成员_调用私有成员示例代码

2. 构造方法

# ### 魔术方法 :特定时机自动触发

"""__init__ 构造方法"""

'''

    触发时机：实例化对象,初始化的时候触发

    功能：为对象添加成员

    参数：参数不固定,至少一个self参数

    返回值：无

'''

# (1) 基本语法

class MyClass():

    def __init__(self):

        self.name = "黄乐锡"

# 实例化对象

obj = MyClass()

print(obj.__dict__)

print(obj.name)

# (2) 传递2个参数

class MyClass():

    def __init__(self,name):

        # self.成员属性 = 参数值

        #       name    = name

        self.name = name

# 实例化对象

"""李诗韵默认传递到name形参进行接收"""

obj = MyClass("李诗韵")

print(obj.name)

# (3) 多个参数

"""同一个类,可以实例化出多个对象,而对象和对象之间,彼此独立"""

class Children():

    def __init__(self,name,skin):

        self.name = name

        self.skin = skin

    def eat(self):

        print("小孩一下生手里拿了2串大腰子")

    def drink(self):

        print("小孩一下生手里拿了两瓶啤酒")

    def __sleep(self):

        print("小孩一天睡觉时间是23个小时")

    def pub_info(self):

        # 在类中,只能使用对象.属性/方法 或 类.属性/方法进行调用

        print("该对象name是{},该对象skin是{}".format(self.name,self.skin))

# 实例化一个对象

datuichui = Children("大铁锤","粉色")

datuichui.pub_info()

# 实例化第二个对象

wanggangdan = Children("王钢蛋","黑色")

wanggangdan.pub_info()

# 实例化第三个对象

wangbaoqiang = Children("王宝强","绿色")

wangbaoqiang.pub_info()

构造方法示例代码

day17

巴特西

day17-Python运维开发基础(类的封装 / 对象和类的相关操作、构造方法)

最新文章

热门文章