python_面向对象

类成员

类成员分为三大类：字段、方法、属性

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

 字段

• 普通字段：属于对象
• 静态字段：属于类

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


class Provice:
    #静态字段
    country = "中国"

    def __init__(self,name):
        temp = "xxx"
        #普通字段，在对象中
        self.name = name

#访问普通字段
sz = Provice("深圳")
print(sz.sname)

#访问静态字段
print(Provice.country)

输出结果：
深圳
中国

 方法

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

• 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
• 静态方法：由类调用；无默认参数；

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


class Provice:
    #静态字段
    country = "中国"

    def __init__(self,name):
        temp = "xxx"
        #普通字段，在对象中
        self.name = name

    #类方法
    @classmethod
    def xing(cls):
        print("xxxxxoooo")

    #静态方法
    @staticmethod
    def test(arg1,arg2):
         print("abc")

    #普通方法，在类中
    def show(self):
        print('show')

#访问类方法
Provice.xing()

#访问静态方法
Provice.test(1,2)

#访问普通方法
obj = Provice("yin")
obj.show()

 属性

• 属性的基本使用
• 属性的定义方式

1､属性的基本使用 

定义时在普通方法的基础上添加 @property 装饰器；属性仅有一个self参数； 调用时无需括号访问。

2、属性的定义方式有两种

• 装饰器 即：在类的普通方法上应用@property装饰器
• 静态字段 即：在类中定义值为property对象的静态字段

Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富，如果类继object，那么该类是新式类 。

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


class Shoops:

    def __init__(self,price,discount):
        # 原价
        self.original_price = price
        # 折扣
        self.discount = discount

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


obj = Shoops(100,0.8)
print(obj.price)  # 获取商品价格

新式类，具有三种@property装饰器，分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法；可将三个方法定义为对同一个属性：获取、修改、删除。

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


class Shoops(object):

    def __init__(self,price,discount):
        # 原价
        self.original_price = price
        # 折扣
        self.discount = discount

    @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.deleter
    def price(self):
        del self.original_price

obj = Shoops(100,0.8)
print(obj.price)  # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价

 静态字段定义值为property对象,当使用静态字段的方式创建属性时，经典类和新式类无区别。

property的构造方法中有个四个参数，分别如下：

• 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
• 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
• 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
• 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


class Shoops(object):

    def __init__(self,price,discount):
        # 原价
        self.original_price = price
        # 折扣
        self.discount = discount

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

    def set_price(self, value):
        self.original_price = value

    def del_price(self):
        del self.original_price

    PRICE = property(get_price, set_price, del_price, '价格属性描述...')

obj = Shoops(100,0.8)
print(obj.PRICE)  # 自动调用第一个参数get_price方法获取商品价格
obj.PRICE = 200   # 自动调用第二参数set_price方法修改商品价格
print(obj.PRICE)
del obj.PRICE    # 自动调用第三个参数del_price删除商品价格
print(obj.PRICE.__doc__) #自动获取第四个参数设置的值

 类成员修饰符

类成员有两种形式：

• 私有成员 即：只有在类的内部才能访问
• 公有成员 即：在任何地方都能访问

静态字段

class Shop:

    name = "公有静态字段"

    def func(self):
        print Shop.name

class test(Shop):

    def show(self):
        print C.name


Shop.name         # 类访问

obj = Shop()
obj.func()     # 类内部可以访问

obj_son = test()
obj_son.show() # 派生类中可以访问

class Shop:

    __name = "私有静态字段"

    def func(self):
        print Shop.__name

class test(Shop):

    def show(self):
        print C.__name


Shop.__name         #错误！ 类不能访问

obj = Shop()
obj.func()     # 正确！类内部可以访问

obj_son = test()
obj_son.show() #错误！ 派生类中不能访问

普通字段

class C:
    
    def __init__(self):
        self.foo = "公有字段"

    def func(self):
        print self.foo 　#　类内部访问

class D(C):
    
    def show(self):
        print self.foo　＃　派生类中访问

obj = C()

obj.foo     # 通过对象访问
obj.func()  # 类内部访问

obj_son = D();
obj_son.show()  # 派生类中访问

class C:
    
    def __init__(self):
        self.__foo = "私有字段"

    def func(self):
        print self.foo 　#　类内部访问

class D(C):
    
    def show(self):
        print self.foo　＃　派生类中访问

obj = C()

obj.__foo     # 错误！通过对象访问 
obj.func()  # 正确！类内部访问 

obj_son = D();
obj_son.show()  # 错误！派生类中访问

带有下划线的方法

class Foo():

    #公有静态字段
    xo = "xo"
    #私有静态字段，带下划线表示私有成员，只能供内部访问
    __ox = "ooxxx"

    def __init__(self):
        #私有普通字段
        self.__name = "私有字段"
        #公有普通字段
        self.__psd = 123

    #带有下划线方法
    def __dele(self):
        print("abc")

    def te(self):
        self.__dele()    


obj1 = Foo()
obj1.te() #只能通过另一个关联方法去访问

 类的特殊成员

1. __module__ 和  __class__

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

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

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'yinjia'

class C:

    def __init__(self):
        self.name = 'yinjia'

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'

from lib.a import C

obj = C()
print obj.__module__  # 输出 lib.a，即：输出模块
print obj.__class__      # 输出 lib.a.C，即：输出类

 2、__call__

__call__ 方法的执行是由对象后加括号触发的

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


class Foo:
    """
    我是模块
    """
    abc = 123

    def __init__(self):
        self.name = 'yinjia'

    def __call__(self, *args, **kwargs):
        print("call")


r = Foo() #执行__init__方法

r() #执行__call__方法

3、__getitem__、__setitem__、__delitem__

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

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


class Foo:
    """
    我是模块
    """
    abc = 123

    def __init__(self):
        self.name = 'yinjia'

    def __getitem__(self, item):
        print(item)
    def __setitem__(self, key, value):
        print(key,value)
    def __delitem__(self, key):
        print(key)

r = Foo()

r['kafad'] #执行__getitem__方法
r['test'] = 123 #执行__setitem__方法
del r ['aabbccdd'] #执行__delitem__方法
r[1:3] #执行__getslice__/__getitem__
r[1:3] = [11,22,33] #执行__setslice__/__setitem__
del r[1:3]  #__delslice__/__delitem__

4. __iter__

 用于迭代器，之所以列表、字典、元组可以进行for循环

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


class Foo(object):

    def __init__(self, sq):
        self.sq = sq

    def __iter__(self):
        return iter(self.sq)

obj = Foo([11,22,33,44])

for i in obj:
    print(i)

 

5. __dict__

 输出类或对象的所有成员

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


class Foo:
    """
    我是模块
    """
    abc = 123

    def __init__(self):
        self.name = 'yinjia'

    def __call__(self, *args, **kwargs):
        print("call")
        return 1
    def __getitem__(self, item):
        print(item)
    def __setitem__(self, key, value):
        print(key,value)
    def __delitem__(self, key):
        print(key)

r = Foo()
print(r.__dict__) #输出对象所有的字段属性
print(Foo.__dict__) #输出类所有的方法

 执行基类构造方法

class Annimal:
    def __init__(self):
        print("父类构造方法")
        self.ty = "动物"
    def eat(self):
        print("%s%s在吃东西" % (self.name,self.n))

class Cat(Annimal):
    def __init__(self,name):
        print("子类构造方法")
        self.name = name
        self.n = "猫"
        super(Cat,self).__init__() #常用第一种方法,执行父类初始化数据
        #Annimal.__init__(self) #第二种方法

#数据初始化
c = Cat("张三的")
c.eat()
print(c.__dict__)

输出结果：
子类构造方法
父类构造方法
张三的猫在吃东西
{'name': '张三的', 'n': '猫', 'ty': '动物'}