python运维开发----面向对象（下）

Posted 2020-08-01 Jabe

内容目录：

• 面向对象三大特性之多态性
• 面向对象中的成员：字段、方法、属性
• 类的成员修饰符
• 类的特殊成员
• 特殊成员方法
• 面向对象其他
• 异常处理
• 设计模式之单例模式

 面向对象的多态性

多态性：即指多种形态多种类型

比如在函数中可以定义def func(arg),arg可以为为整型，可以为字符串可以为字典可以为列表等等多种类型，这就是面向对象的多态性。

 

#python中
def func(arg):
    print(arg)
func(1)
func(‘jabe‘)
func([11,22,33]) #python 中参数可以为整型，字符串，列表等即为面向对象的多态


#  c#/java中
def func1(int arg): #c#/java 中定义参数时需要指定该参数类型
    print(arg)
func1(123)
func1(‘123‘) #报错


class A:
    pass
class B(A):
    pass
class C(A):
    pass
    def func(A arg): #arg的参数必须是A类型或者A类的子类
        pass

面向对象的成员

• 字段：包括静态字段和普通字段
• 方法：包括静态方法和普通方法
• 属性：静态属性

一、字段

　　字段分为静态字段和普通字段，主要区别在于两者在内存中存在位置不同，静态字段存在类中，类创建完静态字段就已经生成，而普通字段存在于对象中，只有进行实例化之后才能生成普通的字段存入内存中，创建类时候普通字段是不占用内存的。

class Province:
    #静态字段
    country = ‘中国‘

    def __init__(self,name):
        #普通字段
        self.name = name

#普通字段直接访问方式，通过对象来访问普通字段
obj = Province(‘河北省‘)
print(obj.name)

#静态字段访问方式，直接通过类调用方式访问
print(Province.country)

ps：静态字段一般用类访问，对象方式也可以访问但是不推荐用对象方式访问。

静态字段在内存中只保存一份数据，普通字段在每个对象中都要保存一份；通过类创建对象时，如果每个对象都具有相同的字段那么就使用静态字段

二、方法

方法分为普通方法、静态方法和类方法，所有的方法均属于类，在内存中也是只保存一份，区别在于调用方式不同，各种方式调用传入的参数不同。

普通方法：至少有一个self，由对象调用执行；

静态方法：由类调用执行，可以添加任意参数；

类方法：至少一个cls参数，由类调用执行；

class Province:
    country = ‘中国‘  #静态字段
    def __init__(self,name):
        self.name = name #普通字段
        print(self.name)
    #普通方法
    def show(self,name):
        #print(self.name)
        print(123)

    #静态方法
    @staticmethod
    def f1(arg1,arg2):
        print(arg1,arg2)
    #类方法
    @classmethod
    def f2(cls):
        print(cls)


Province.f1(111,222) #静态方法调用
Province.f2() #类方法调用 返回当前的类名  <class ‘__main__.Province‘>
obj = Province(‘河北‘)
obj.show(‘河北‘) #普通方法调用

 三、属性

属性即为特殊的普通方法，方法和字段结合体，方法的定义方式，字段的调用方式。

定义方式：

1 在普通方法的基础上添加 @property 装饰器；

2 属性仅有一个self参数

3 调用时无需括号，方法:obj.func() 属性：obj.func

基本使用

class Pager:
    def __init__(self,all_count):
        self.all_count = all_count
    
    #属性的定义
    @property
    def all_pager(self):
        a1,a2 = divmod(self.all_count,10)
        if a2 == 0:
            return a1
        else:
            return a1+1
    #属性的设置
    @all_pager.setter
    def all_pager(self,value):
        print(value)

    #属性的删除
    @all_pager.deleter
    def all_pager(self):
        print(‘del all_pager‘)

p = Pager(101)
# p.all_count #字段
# ret = p.all_pager #属性的调用，比一般的方法调用少了括号
# print(ret)
p.all_pager = 11 #属性的setter，可以直接赋值方式，调用@all_pager.setter方法
del p.all_pager #属性的删除 调用@all_pager.deleter 方法

 属性的另一种定义方式

class Pager:
    def __init__(self,all_count):
        self.all_count = all_count

    def f1(self):
        return 123
    def f2(self,value):
        pass
    def f3(self):
        pass
    foo = property(fget=f1,fset=f2,fdel=f3) #直接将f1，f2,f3代入到属性指定关键字中

p = Pager(101)
resault = p.foo #自动调用fget的方法
print(resault)

p.foo = ‘jabe‘ #fset f2的方法

del p.foo #自动调用fdel的方法

类的成员修饰符

类的成员我们可以从上面知道包括字段、方法和属性，对于每一个类的成员来说都有两种形式：

公有成员：在任何地方都能访问，即类的内部和外部都能访问；

私有成员：只能在类的内部访问；