python M3 面向对象 - Day 6 Learning Note - 3. OPP 之进阶篇-CSDN博客

静态方法

截断了类和方法的内在联系。只是名义上归类管理，实际上在静态方法里访问不了类或者实例中的任何属性。

class Dog(object):

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

    @staticmethod    # 静态方法截断了类和方法的联系。 和在类外设置函数是一样的。
    def eat(self):
        print('%s is earting bum ' %(self.name))

d = Dog("Rory")
d.eat()

返回错误结果如下：

Traceback (most recent call last):
  File "/Users/PycharmProjects/learningnote/moduel3/OPP进阶 - 静态方法.py", line 18, in <module>
    d.eat()
TypeError: eat() missing 1 required positional argument: 'self'

类方法

只能访问类变量，不能访问实例变量。

class Dog(object):

    name = "marlynda"

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

    @classmethod  # 类方法
    def eat(self):
        print('%s is earting bum' % self.name)

d = Dog("Rory")
d.eat()  # 在类方法下， 调用的self.name是类变量

返回结果：

marlynda is earting bum

属性方法

@property 将一个方法变成一个静态属性，即调用是不用加()。

class Dog(object):

    name = "marlynda"

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

    @property
    def eat(self):
        print('%s is earting bum' % self.name)

d = Dog("Rory")
d.eat

当该方法原来有参数时，改写方式应该如下：

class Dog(object):

    name = "marlynda"

    def __init__(self, name):
        self.name = name
        self.__food = None   # 3. 添加私有属性__food

    @property          # 1. 设置属性方法，将方法转变为静态属性
    def eat(self):
        print('%s is eating %s' % (self.name, self.__food))

    @eat.setter        # 2. 另增加一个同为eat的方法，并增加参数food
    def eat(self, food):
        print("set the food:", food)
        self.__food = food    # 4. 传入参数，更新私有属性__food

    @eat.deleter       # 5. 作为属性, 单纯调用 del d.eat，是删不掉。需要再写个@eat.deleter
    def eat(self):
        del self.__food
        print("删完了")

d = Dog("Rory")

d.eat
d.eat = "bum"
d.eat
d.eat = "beef"
d.eat

del d.eat

返回结果

Rory is eating None
set the food: bum
Rory is eating bum
set the food: beef
Rory is eating beef
删完了

属性方法在实际情况中，比较有用。很多场景中是不能简单通过定义静态属性来实现的。

比如，类似像飞常准这样的平台，获取一个航班的当前状态（到达，延迟，取消，还是飞走等），需要经历以下几步：

链接航空公司提供的API接口：可能是json, xml等
对查询结果进行解析
返回结果给你的用户

获取这些status其实是一系列动作的结果，但是客户不关心，他们只需要这系列动作后的结果即可。

class Fight(object):
    def __init__(self, name):
        self.flight_name = name


    def checking_status(self):
        print('checking flight %s status' % self.flight_name)
        return 1

    @property
    def flight_status(self):
        status = self.checking_status()
        if status == 0:
            print('flight got cancelled...')
        elif status == 1:
            print("flight has arrived...")
        elif status == 2:
            print("flight has departured already...")
        else:
            print("cannot confirm the flight status... please check later")

    @flight_status.setter
    def flight_status(self, status):
        print("flight %s has change status to %s" %(self.flight_name, status))

f = Fight("CA980")
f.flight_status
f.flight_status = "2"
f.flight_status

返回信息

checking flight CA980 status
flight has arrived...
flight CA980 has change status to 2
checking flight CA980 status
flight has arrived...

特殊成员方法

特殊方法一般主要实现模拟标准类型和重载操作符。

1. `doc`

现实类的描述信息, 调用如下 print(Foo.__doc__)

2. `module` 和 `class`

__module__ 表示当前操作的对象在哪个模块 __class__ 表示当前操作的对象的类是啥么

3. `init`

4. `del`

5. `bases`

显示其父类的集合的元祖

5. `call`

对象后面加括号，促发执行，即对象（）或者类()()。比较重要

class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print
        '__call__'


obj = Foo()  # 执行 __init__
obj()  # 执行 __call__

6. `dict`

查看类或者对象中的所有成员

class Dog(object):

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

    def eat(self):
        print('%s is earting bum ' %(self.name))

d = Dog("Rory")

print(Dog.__dict__)  # 打印类里的所有属性，不包括实例属性
# 返回：{'__module__': '__main__', '__init__': <function Dog.__init__ at 0x103121840>, 'eat': <function Dog.eat at 0x1031218c8>, '__dict__': <attribute '__dict__' of 'Dog' objects>, '__weakref__': <attribute '__weakref__' of 'Dog' objects>, '__doc__': None}
print(d.__dict__)    # 打印所有实例属性，不包括类属性
# 返回：{'name': 'Rory'}

7. `str`

如果一个类中定义了__str__方法, 那么打印对象时，默认输出该方法的返回值。不打__str__的话，会返回内存地址。 django中用的比较多。

class Dog(object):

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

    def eat(self):
        print('%s is earting bum ' %(self.name))

    def __str__(self):
        return "<obj: %s>" % self.name

8. `getitem`, `setitem`, `delitem`

用于索引操作，如字典，以上分别表示获取、设置、删除数据。多数情况用不到。在封装一个底层的时候，经常会用到，让客户以为在调用一个字典。

class Foo(object):

    def __init__(self, ):
        self.data = {}

    def __getitem__(self, key):
        print('__getitem__', key)
        return self.data.get(key)

    def __setitem__(self, key, value):
        print("__setitem__", key, value)
        self.data[key] = value


    def __delitem__(self, key):
        print("__delitem__", key)


obj = Foo()
obj['name'] = 'alex'
print(obj.data)
del obj["name"]

9. `new` 和 `metaclass`

先来看段代码, 一般我们普通方式创建类如下：

class Foo(object):

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

f = Foo("moo")

print(type(f))    # 表示：obj对象由Foo类创建得来， f是Foo的一个实例
# 返回：<class '__main__.Foo'>
print(type(Foo))   # 表示：Foo类由type类创建得来，Foo是type的一个实例
# 返回：<class 'type'>

这里就引出了第2种创建类的方法，乃装逼利器，即特殊方式。其基本原理（以以上例子为列）， f是Foo类创建的，是Foo的一个实例。在python中，一切皆对象。其实Foo类本身也是一个实例，是type类所创建的一个实例。特殊方式创建类的方式如下：

def func(self):
    print('hello, 特殊方法')

def __init__(self, name, age):
    self.name = name
    self.age = age

Moo = type("Moo", (object,), {'talk': func,
                              '__init__': __init__})
# type第一参数：类名
# type第二参数：当前类的基类
# type第三参数：类的成员

m = Moo("alex", "22")
m.talk()

多数情况不大用到，重点是内部逻辑，以及“一切皆对象”的概念。