面向对象进阶篇

• 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
• 类 是一个模板，模板中包装了多个“函数”供使用（可以讲多函数中公用的变量封装到对象中）
• 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
• 面向对象三大特性：封装、继承和多态

类的成员

类的成员可以分为三大类：字段、方法和属性

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

一、字段

字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，

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

 class Proice:
     #静态字段
     country = "中国"
     def __init__(self,name):
         #普通字段
         self.name = name
ret = Proice("山西")
print(ret.name)      #直接访问普通字段
print(ret.country)    #直接访问静态字段

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

二、方法

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

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

class Paric:
    def func(self):
        #普通方法
        print("name")
    @classmethod
    #类方法        最少有一个参数
    def xxoo(cls,arg1,arg2):
        print(arg1,arg2)
    #静态方法        可也加参数也可以不加参数
    @staticmethod
    def xo():
        print("xo")
ret = Paric()  #创建对象
ret.func()   #对象调用普通方法
Paric.xxoo(1,2)     #类调用类方法
Paric.xo()      #类调用静态方法

三、属性　　

如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。

对于属性，有以下三个知识点：

• 属性的基本使用
• 属性的两种定义方式
• 调用时，无需括号 

class Foo:
    def __init__(self,name):
        self.name = name
    #获取
    @property
    def func(self):
        temp = self.name
        return temp
    #设置
    @func.setter
    def func(self,value):
        self.name = value
    #调用
    @func.deleter
    def func(self):
        del self.name

ret = Foo("Wyc")
r = ret.func    #获取
print(r)
del ret.func      #删除
ret.func = "nihao"      #设置
 

静态字段方式，创建值为country对象的静态字段

class Foo:
    #静态字段
    country ="中国"
    def func(self):
        print("11")
#类调用静态方法
print(Foo.country) 

类成员的修饰符

类的所有成员在上一步骤中已经做了详细的介绍，对于每一个类的成员而言都有两种形式：

• 公有成员，在任何地方都能访问
• 私有成员，只有在类的内部才能使用方法

私有成员和公有成员的定义不同：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）

class Foo:
    #私有字段
    __yer = "Wyc"
    def func(self):
        #用类调用私有字段，只能在内部调用。
        print(Foo.__yer)
ret = Foo()
ret.func()

class Foo:
    #公有静态字段
    name = "中国"
    def func(self):
        pass
    #公有静态字段由类调用
print(Foo.name)

类的特殊成员

 __doc__

　　表示类的描述信息

class  Foo:
    """
    这是__doc__的方法
    """
    def func(self):
        pass
    #由类直接调用，类的注释
print(Foo.__doc__)

class Foo:
    #构造方法，简称封装
    def __init__(self):
        self.name = "wyc"
    def func(self):
        print(self.name)
ret = Foo()
ret.func()

__call__

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

class Foo:
    def func(self):
        pass
    def __call__(self, *args, **kwargs):
        print("123")
ret = Foo()
ret()   #对象后边加括号自动触发__call__方法

 __dict__

　　类或对象中的所有成员

class Foo:
    def func(self):
        pass
ret = Foo.__dict__    #查看类或对象中的所有成员
print(ret)

 __str__

　　如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

class Foo:
#默认输出该↓方法的默认值
    def __str__(self):
        return "Wyc"
ret = Foo()
print(ret)

 __getitem__、__setitem__、__delitem__

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

class Foo:
    def __setitem__(self,key,value):
        print(key,value)
r = Foo()
r["xxx"] = 123
#对象后边加中括号就会执行__setitem__方法，一个key，一个value

class Foo:
    def __delitem__(self,key):
         print(key)
r = Foo()
del r["xxx"]         #执行__delitem__方法，删除key

class Foo:
    def __getitem__(self, item):
        print(item)
r = Foo()
r["123456"]
#对象后边加个中括号就会自动执行

 __iter__ 

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

class Foo(object):
    def __init__(self,sq):
        self.sq = sq
    def __iter__(self):
        return iter(self.sq)
obj = Foo([11,22,33,44,55])
for i in obj:
    print(i)

总结：

成员：

     字段      静态字段（每个对象都有一份），普通字段（每个对象都有不同的数据）

     方法      静态方法（无需使用对象封装的内容），类方法，普通方法（使用对象中的数据）

     特性      普通特性（将方法伪造成字段）

如何快速判断，类执行，或者对象执行：

                 有self的对象调用

                 无self的，类调用