python 面向对象 进阶篇

在上篇《python面向对象》中，简单介绍了python中面向对象的基本知识

在这篇博客中，详细介绍python类的成员，成员修饰符，类的特殊成员。

类的成员

类的成员分为三种：字段，方法和属性

所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。

字段

字段包括普通字段和静态字段。静态字段，保存在类中。普通字段，保存在对象中。

class FOO：
    country = “中国”  #静态字段
    def __init__(self):
            self.name.= 'alex' #普通字段

>>>
obj = FOO()
print(obj.name)
FOO.cointry

规则：普通字段只能是对象去访问，静态字段用类访问，不要用对象访问。但是静态字段可以用对象访问，但不建议这么做。以免Python语言版本更迭的时候发生变化。

注意：静态字段在代码加载时已经创建，普通字段需创建对象后才执行。这跟类的加载很相似，当我们允许代码时，会把类先加载到内存中，类中的方法整个加载到内存中，当我们为其创建对象的时候才会调用。

应用场景： 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段

方法

普通方法：由对象去调用执行，方法属于类。至少需要一个self

静态方法：静态方法属于类，由类调用执行，不依赖任何对象。可以有任意参数

@staticmethod

def func():  #可以有零个或者多个参数

    pass

class Proviced:
    @staticmethod
    def f1():
        print('这是一个静态方法')
    def __init__(self,name):
        self.name = name
    def f2(self):
         print(self.name)
         print('这是一个普通方法')
Proviced.f1()
obj = Proviced('zhang')
obj.f2()

类方法：@classmethod 至少有一个cls，由类执行

由类调用，必须有一个参数cls，自动将类名传递到方法中。

class Proviced:
    @staticmethod
    def f1():
        print('这是一个静态方法')
    def __init__(self,name):
        self.name = name
    def f2(self):
         print(self.name)
         print('这是一个普通方法')
@classmethod
    def f3(cls):
        obj2 = cls('wang') #cls即当前的类名，cls() 即为创建对象
        obj2.f2()
        print(cls)
Proviced.f1()
obj = Proviced('zhang')
obj.f2()
Proviced.f3()
>>>
这是一个静态方法
zhang
这是一个普通方法
wang
这是一个普通方法
<class '__main__.Proviced'>

属性

具有方法的表现形式，也有字段的访问形式。也就是说我们访问的时候可以采用不伦不类的方式。。。。

class pager:
    def __init__(self,page):
        self.all_count = page
    @property
    def all_page(self):
        a1,a2 = divmod(self.all_count,10)
        if a2 == 0:
            return a1
        else:
            return a1+1
p = pager(101)
ret = p.all_page
print(ret)

属性可以看做一个特殊的方法，通过字段修饰的方法。。。

class Pager:
    def f1(self):
        return 'get'
    def f2(self,value):
        print(value)
        return 'set'
    def f3(self):
        print('del')
        return 'del'
    foo = property(fget=f1,fset=f2,fdel=f3)
p = Pager()
result = p.foo
print(result)
p.foo = 'zhang'
del p.foo

注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象

        属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。

实例：对于主机列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据（即：limit m,n），这个分页的功能包括：

• 根据用户请求的当前页和总数据条数计算出 m 和 n
• 根据m 和 n 去数据库中请求数据
  

class Pager:
    
    def __init__(self, current_page):
        # 用户当前请求的页码（第一页、第二页...）
        self.current_page = current_page
        # 每页默认显示10条数据
        self.per_items = 10 


    @property
    def start(self):
        val = (self.current_page - 1) * self.per_items
        return val

    @property
    def end(self):
        val = self.current_page * self.per_items
        return val

# ############### 调用 ###############

p = Pager(1)
p.start 就是起始值，即：m
p.end   就是结束值，即：n

在继承了object的新式类中，属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法，分别是获取，修改和删除。当然这些操作都是基于对象的，不是直接在类上做修改。

class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deltter
    def price(self, value):
        del self.original_price

obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
del obj.price     # 删除商品原价

我们也可以使用静态字段的方式创建属性：

class Foo：

    def get_bar(self):
        return 'wupeiqi'

    # *必须两个参数
    def set_bar(self, value): 
        return return 'set value' + value

    def del_bar(self):
        return 'wupeiqi'

    BAR ＝ property(get_bar, set_bar, del_bar, 'description...')

obj = Foo()

obj.BAR              # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "alex"     # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
del Foo.BAR          # 自动调用第三个参数中定义的方法：del_bar方法
obj.BAE.__doc__      # 自动获取第四个参数中设置的值：description...

类成员修饰符

类具有三个成员，而每个成员都可以具有两种身份：公有成员和私有成员。公有成员在任何地方都可以访问，而私有成员只能在类的内部才能访问。

公有字段和私有字段

当在字段前面加两个“__”下划线的时候，字段变成私有字段，只能在类本身内部执行，而且不能继承。

class Foo:
    __cc = 123
    def __init__(self,name,value):
        self.__name = name   #将字段变为私有字段
        self.value = value
    def f1(self):
        print(self.__name)
        print(self.value)
    def f2(self):
        print(Foo.__cc)
class Ge(Foo):
    def f3(self):
        print(self.__name)
obj = Foo('zhang','20')
obj.f1()
print(obj.value)
# obj.f2()
#print(Foo.__cc)  #外部调用私有的静态字段会报错
#print(obj.__name) #外部调用私有的普通字段时会出现报错
obj1 = Ge('wang','30')
obj1.f3()

zhang
20
20
Traceback (most recent call last):
  File "C:/Users/Administrator/PycharmProjects/s13/day8/成员修饰符.py", line 16, in <module>
    print(obj.__name)
AttributeError: 'Foo' object has no attribute '__name'

实际上，Python也可以在外部访问私有对象，方法是_类名__私有对象名。但强烈不建议这么做。

特殊成员

除了上面介绍的外，类还有一些特殊成员，提供特殊的功能。

1.__doc__

表示类的描述信息

2. __module__ 和  __class__ 

　　__module__ 表示当前操作的对象在那个模块

　　__class__     表示当前操作的对象的类是什么

3.__init__

　　构造方法，通过类创建对象时，自动触发执行。

4. __del__

　　析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

5. __call__

　　对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

6、__getitem__、__setitem__、__delitem__

用于索引操作，如字典。以上分别表示获取、设置、删除数据

class Foo:   
 def __getitem__(self, item):
        print('getitem')
        print(item)
    def __setitem__(self, key, value):
        print('set item')
        print(key,value)
    def __delitem__(self, key):
        print('del item')
        print(key)
obj = Foo('zhang',20)
obj['zhang'] = 10   #__setitem__
ret = obj['zhang']  #__getitem__
del obj['zhang']    #__delitem__

set item
zhang 10
getitem
zhang
del item
zhang

    def __getitem__(self, item):
        print('getitem')
        #print(item)
        print(item.start)  #输出切片的起始位置
        print(item.stop)   #输出切片的结束位置
        print(item.step)   #输出切片步长
    def __setitem__(self, key, value):
        print('set item')
        print(key,value)
        print(key.start)  #输出赋值的起始位置
        print(key.stop)   #输出赋值的结束位置
        print(key.step)   #输出赋值的步长
    def __delitem__(self, key):
        print('del item')
        #print(key)
        print(key.start)    #删除的起始位置
        print(key.stop)     #删除的结束位置
        print(key.step)     #删除的步长
ret = obj[1:3]
obj[1:3:2] = [2,5,5]
del obj[2:5]

同样的，可以使用__getslice__、__setslice__、__delslice__进行分片操作

class Foo(object):
 
    def __getslice__(self, i, j):
        print '__getslice__',i,j
 
    def __setslice__(self, i, j, sequence):
        print '__setslice__',i,j
 
    def __delslice__(self, i, j):
        print '__delslice__',i,j
 
obj = Foo()
 
obj[-1:1]                   # 自动触发执行 __getslice__
obj[0:1] = [11,22,33,44]    # 自动触发执行 __setslice__
del obj[0:2]                # 自动触发执行 __delslice__

7. __iter__ 

用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__

面向对象其他

    -isinstance   #查看对象是否由类创建（包括继承的对象） isinstance（obj,类名）   

    -issubclass  #判断A是否是B的子类

执行父类的方法

当我们需要对源码进行修改时，可以定义一个类，继承源码的类，需要使用super方法

class C1:
    def f1(self):
        print('c1.f1')
class C2(C1):
    def f1(self):
        #print('c2.f1')
        #主动执行父类的f1方法。
        super(C2,self).f1()
        print('c2.f1')
obj = C2()
obj.f1()

    应用

        自定义类型，有序字典

        源码的扩展