卡瓦邦噶！ | 无法自制的人得不到自由。

《Effective Python》小记

Posted on 2017年9月11日 by laixintao Leave a comment

Effective Python 59 SPECIFIC WAYS TO WRITE BETTER PYTHON 这本书终于读完了。从这本书里学到不少经验，以及之前忽略的知识。书中部分内容也是库的内容（这么说有失公允，大部分属都会有抄库文档的嫌疑的，因为文档包含了最多的信息），也有很多内容基本上是常识，比如七八章合作和产品的东西。这些内容，看了书也不会，不看书实践一下不会也得会。是“纸上得来终觉浅”的东西。

下面按照目录记一下有用的东西。划掉的是垃圾，加粗或者颜色的是干货。

Chapter 1: Pythonic Thinking
Item 1: Know Which Version of Python You’re Using
Item 2: Follow the PEP 8 Style Guide
Item 3: Know the Differences Between bytes, str, and unicode
Item 4: Write Helper Functions Instead of Complex Expressions
Item 5: Know How to Slice Sequences
~~Item 6: Avoid Using start, end, and stride in a Single Slice~~
Item 7: Use List Comprehensions Instead of map and filter
Item 8: Avoid More Than Two Expressions in List Comprehensions
Item 9: Consider Generator Expressions for Large Comprehensions
Item 10: Prefer enumerate Over range
Item 11: Use zip to Process Iterators in Parallel
~~Item 12: Avoid else Blocks After for and while Loops~~
Item 13: Take Advantage of Each Block in try/except/else/finally

第一张虽然是Pythonic Thinking，却提出了很多不提倡使用的Python特性。但是我觉得书中这些条条框框没有必要必须遵守。比如6，为了可读性不要在一个切片操作上用3个数字，以及12，避免使用while-else，也是为了可读性。但是我认为，用了也不一定破坏了可读性。但是初衷是好的。我觉得只要不是写的太复杂，能保持一眼看明白或者多看一眼也能看明白，甚至看三眼也看不明白但是看看注释能看明白，也是可以的。本章中我觉得3和4非常有价值，4可以极大提高可读性。从这里我们知道不一定是非要为了重用才将代码封装成函数，为了可读性进行封装也可以。毕竟，函数的名字比注释要“优雅”的多。

Chapter 2: Functions
Item 14: Prefer Exceptions to Returning None
Item 15: Know How Closures Interact with Variable Scope
Item 16: Consider Generators Instead of Returning Lists
Item 17: Be Defensive When Iterating Over Arguments
Item 18: Reduce Visual Noise with Variable Positional Arguments
Item 19: Provide Optional Behavior with Keyword Arguments
Item 20: Use None and Docstrings to Specify Dynamic Default Arguments
Item 21: Enforce Clarity with Keyword-Only Arguments

14，15，16是干货，抛出一个有时候我们希望错误打断函数运行（如果出错之后后面的代码没有价值了的话），这样更好调试。对于调用出也可以使用try-except处理，而不是罗列一些if-else。有关闭包是一个重点知识。以及迭代器，不过这里感觉也并不是太深入。有关yield我还得多花点时间研究下。后面几条基本上是为了可维护性做的一些惯例。

Chapter 3: Classes and Inheritance
Item 22: Prefer Helper Classes Over Bookkeeping with Dictionaries and Tuples
Item 23: Accept Functions for Simple Interfaces Instead of Classes
Item 24: Use @classmethod Polymorphism to Construct Objects Generically
Item 25: Initialize Parent Classes with super
Item 26: Use Multiple Inheritance Only for Mix-in Utility Classes
Item 27: Prefer Public Attributes Over Private Ones
Item 28: Inherit from collections.abc for Custom Container Types

本章是面向对象的内容。Python很好入门，但是很多人将他当做一门面向过程的语言，项目都用函数组织。其实Python是纯正的面向对象的语言。就连函数也是一等的object。目前我们公司的项目都是以函数的形式组织的，我觉得很多地方都可以使用class，重用性会更好。

Chapter 4: Metaclasses and Attributes
Item 29: Use Plain Attributes Instead of Get and Set Methods
Item 30: Consider @property Instead of Refactoring Attributes Item 31: Use Descriptors for Reusable @property Methods
Item 32: Use __getattr__, __getattribute__, and __setattr__ for Lazy Attributes
Item 33: Validate Subclasses with Metaclasses
Item 34: Register Class Existence with Metaclasses
Item 35: Annotate Class Attributes with Metaclasses

这一章比较好，主要讲了Python获取属性的过程。这里的内容我觉得大多数和Python有关的书都讲不到。关于获取属性的部分我结合文档写了这篇博客。有关metaclass的部分我总结了这篇博客。都是干货。

Chapter 5: Concurrency and Parallelism
Item 36: Use subprocess to Manage Child Processes
Item 37: Use Threads for Blocking I/O, Avoid for Parallelism
Item 38: Use Lock to Prevent Data Races in Threads
Item 39: Use Queue to Coordinate Work Between Threads
Item 40: Consider Coroutines to Run Many Functions Concurrently
Item 41: Consider concurrent.futures for True Parallelism

这章涉及并行，进程、线程、协程等概念。目前用到的不太多，所以没有深入研究。这部分内容要结合操作系统的知识。以后再深入了解吧。

Chapter 6: Built-in Modules
Item 42: Define Function Decorators with functools.wraps
Item 43: Consider contextlib and with Statements for Reusable try/finally Behavior
Item 44: Make pickle Reliable with copyreg
Item 45: Use datetime Instead of time for Local Clocks
Item 46: Use Built-in Algorithms and Data Structures
Item 47: Use decimal When Precision Is Paramount
Item 48: Know Where to Find Community-Built Modules

Chapter 7: Collaboration
Item 49: Write Docstrings for Every Function, Class, and Module
Item 50: Use Packages to Organize Modules and Provide Stable APIs
Item 51: Define a Root Exception to Insulate Callers from APIs
Item 52: Know How to Break Circular Dependencies
Item 53: Use Virtual Environments for Isolated and Reproducible Dependencies

Chapter 8: Production
Item 54: Consider Module-Scoped Code to Configure Deployment Environments
Item 55: Use repr Strings for Debugging Output Item 56: Test Everything with unittest
Item 57: Consider Interactive Debugging with pdb Item 58: Profile Before Optimizing
Item 59: Use tracemalloc to Understand Memory Usage and Leaks

第六章将build-in函数，不如文档详细。甚至有点过时。

第七八章是开发经验，可以参考一下。不过没有应用的话都是纸上谈兵。

就写这些吧，下一步准备结合源代码和文档研究一下常用的函数、数据结构和库。

个人抗风险基金的想法

Posted on 2017年9月9日 by laixintao 2 Comments

人活着不容易，世间的任何东西都比不上健康、幸福和自由。本文基于这个观点。

最近由于快递造成了一笔小损失，很不爽。基本每过一段时间，就会遇到各种各样的烂事，比如丢了交通卡，丢了钥匙，错过了高铁等等。然后造成自己不开心。其实过了一段时间也就过去了，想想也没什么，但是就是得经历一段不开心的时间。

所以我想到一个办法，也许可以解决这个问题。每个月可以拿出一部分钱（暂定300），这笔钱作为“对抗各种意外事故”的基金。一切意外事故造成的金钱损失都从这部分钱里面出。如果这个钱用不完，就把他捐掉。这样感觉花的不是自己的钱，相对来说感情伤害会小得多。

这个办法如果起作用有以下几个要点。

这笔钱是必须支付的。如果这个月没有用到，就把它提现，可以说就没有任何用处了。因为“不发生意外”给自己带来了收益。我们的目的是“使意外没有造成损失”，所以如果损失是注定的，那么就无所谓“意外带来的损失”了。
这笔钱必须是不给自己带来收益的。很好理解，还是为了“发生意外”与“不发生意外”没有什么大区别。所以这笔钱不可以给自己带来收益，包括请朋友吃一顿大餐带来的人情、买自己不需要的东西等等。所以最合适的方式是“不记名的捐赠”。
可以1年来结算一次或者更长。因为主要目的是以减少自己的损失为主，所以可以这样，账户金额超过1000结算一次。或者半年结算一次。防止某个月出现比较大的损失。

我跟人感觉比较靠谱。刚毕业一个月我就把“报道证”给弄丢了，但是可以找淘宝代办，他们帮你跑腿，一个月搞出来。如果有这个基金的话我肯定心安理得找淘宝了。这个月开始打算试一下。

认识Python的MetaClass

Posted on 2017年9月6日 by laixintao Leave a comment

本文主要介绍Python的MetaClass的用法。

MetaClass也是一个class，这个class继承自type，它用于生产新的class对象。定义class的时候，就会执行到MetaClass的__new__()代码。

从这里出发，我们需要一个新的class的时候，就可以使用MetaClass定义它的行为。本文介绍MetaClass的三种用法：

定义新的class的时候，执行一些检查操作
定义新的class的时候，将新class进行注册动作
定义新的class的时候，自动修改class的属性

MetaClass可以读取和修改class的属性。

class Meta(type):
       def __new__(meta, name, bases, class_dict):
           print((meta, name, bases, class_dict))
           return type.__new__(meta, name, bases, class_dict)

class MyClass(object, metaclass=Meta):
   stuff = 123
   def foo(self):
           pass

# (<class '__main__.Meta'>, 'MyClass', (<class 'object'>,), {'__module__': '__main__', '__qualname__': 'MyClass', 'stuff': 123, 'foo': <function MyClass.foo at 0x10af271e0>})Python

class Meta(type):

def __new__(meta, name, bases, class_dict):

print((meta, name, bases, class_dict))

return type.__new__(meta, name, bases, class_dict)

class MyClass(object, metaclass=Meta):

stuff = 123

def foo(self):

pass

# (<class '__main__.Meta'>, 'MyClass', (<class 'object'>,), {'__module__': '__main__', '__qualname__': 'MyClass', 'stuff': 123, 'foo': <function MyClass.foo at 0x10af271e0>})Python

Python2和Python3的写法有所不同，上面是Python3的写法，Python2的写法如下。

class Meta(type):
     def __new__(meta, name, bases, class_dict):
         print((meta, name, bases, class_dict))
         return type.__new__(meta, name, bases, class_dict)

class MyClass(object):
     __metaclass__ = Meta
     stuff = 123
     def foo(self):
           pass

class Meta(type):

def __new__(meta, name, bases, class_dict):

print((meta, name, bases, class_dict))

return type.__new__(meta, name, bases, class_dict)

class MyClass(object):

__metaclass__ = Meta

stuff = 123

def foo(self):

pass

用MetaClass验证

定义一个新的class相当于调用type创建一个新的class对象，所以覆盖__new__()方法可以实现一些验证的动作。

下面的代码定义了一个多边形的MetaClass，在定义新的class的时候，验证边数是否小于3，如果小于3，这不科学。

# -*- coding: utf-8 -*-

class ValidatePolygon(type):
    def __new__(meta, name, bases, class_dict):
        # Don’t validate the abstract Polygon class
        if bases != (object,):
            if class_dict['sides'] < 3:
                raise ValueError(‘Polygons need 3+ sides’)
        return type.__new__(meta, name, bases, class_dict)

class Polygon(object, metaclass=ValidatePolygon):
    sides = None # Specified by subclasses
    @classmethod
    def interior_angles(cls):
        return (cls.sides - 2) * 180

class Triangle(Polygon):
    sides = 3

# -*- coding: utf-8 -*-

class ValidatePolygon(type):

def __new__(meta, name, bases, class_dict):

# Don’t validate the abstract Polygon class

if bases != (object,):

if class_dict['sides'] < 3:

raise ValueError(‘Polygons need 3+ sides’)

return type.__new__(meta, name, bases, class_dict)

class Polygon(object, metaclass=ValidatePolygon):

sides = None # Specified by subclasses

@classmethod

def interior_angles(cls):

return (cls.sides - 2) * 180

class Triangle(Polygon):

sides = 3

使用MetaClass对class进行注册

下面的代码，在每次定义一个新的class的时候，就将class注册到一个字典，维护对应的行为。而不必每次都手动进行维护。

class Vector3D(RegisteredSerializable):
       def __init__(self, x, y, z):
           super().__init__(x, y, z)
           self.x, self.y, self.z = x, y, z
   v3 = Vector3D(10, -7, 3)
   print(‘Before:    ’, v3)
   data = v3.serialize()
   print(‘Serialized:’, data)
   print(‘After:     ’, deserialize(data))

class Vector3D(RegisteredSerializable):

def __init__(self, x, y, z):

super().__init__(x, y, z)

self.x, self.y, self.z = x, y, z

v3 = Vector3D(10, -7, 3)

print(‘Before: ’, v3)

data = v3.serialize()

print(‘Serialized:’, data)

print(‘After: ’, deserialize(data))

修改class的属性

假设我们想要实现一个Python对象到数据库字段的对应（也就是ORM），我们可以使用前面博客提到的Descriptor，如下。

class Field(object):
       def __init__(self, name):
           self.name = name
           self.internal_name = ‘_’ + self.name
       def __get__(self, instance, instance_type):
           if instance is None: return self
           return getattr(instance, self.internal_name, ”)
       def __set__(self, instance, value):
           setattr(instance, self.internal_name, value)

class Customer(object):
       # Class attributes
       first_name = Field(‘first_name’)
       last_name = Field(‘last_name’)
       prefix = Field(‘prefix’)
       suffix = Field(‘suffix’)

class Field(object):

def __init__(self, name):

self.name = name

self.internal_name = ‘_’ + self.name

def __get__(self, instance, instance_type):

if instance is None: return self

return getattr(instance, self.internal_name, ”)

def __set__(self, instance, value):

setattr(instance, self.internal_name, value)

class Customer(object):

# Class attributes

first_name = Field(‘first_name’)

last_name = Field(‘last_name’)

prefix = Field(‘prefix’)

suffix = Field(‘suffix’)

但是这里存在的问题是，first_name已经写了一次了，还要在创建Field的时候再写一次，不是有些多余吗？Field应该自动根据引用它的变量名自动命名。这可以通过MetaClass来做到。

class Meta(type):
       def __new__(meta, name, bases, class_dict):
           for key, value in class_dict.items():
               if isinstance(value, Field):
                   value.name = key
                   value.internal_name = ‘_’ + key
           cls = type.__new__(meta, name, bases, class_dict)
           return cls

# Field不需要在接受参数创建实例了
class Field(object):
       def __init__(self):
           # These will be assigned by the metaclass.
           self.name = None
           self.internal_name = None


# 这里由MetaClass代劳
class BetterCustomer(meta=Meta):
       first_name = Field()
       last_name = Field()
       prefix = Field()
       suffix = Field()

class Meta(type):

def __new__(meta, name, bases, class_dict):

for key, value in class_dict.items():

if isinstance(value, Field):

value.name = key

value.internal_name = ‘_’ + key

cls = type.__new__(meta, name, bases, class_dict)

return cls

# Field不需要在接受参数创建实例了

class Field(object):

def __init__(self):

# These will be assigned by the metaclass.

self.name = None

self.internal_name = None

# 这里由MetaClass代劳

class BetterCustomer(meta=Meta):

first_name = Field()

last_name = Field()

prefix = Field()

suffix = Field()

综上，MetaClass是非常实用的，可以帮我们减少很多需要重复复制粘贴的代码。

参考：Effective Python 59 SPECIFIC WAYS TO WRITE BETTER PYTHON by Brett Slatkin， Item 33，34，35

理解Python对象的属性和描述器

Posted on 2017年9月5日 by laixintao 10 Comments

对于Python对象的属性是如何读取的，我一直存在一些疑问。对对象的属性赋值，什么时候直接指向一个新的对象，什么时候会直接抛出AttributeError错误，什么时候会通过Descriptor？Python的descriptor是怎么工作的？如果对a.x进行赋值，那么a.x不是应该直接指向一个新的对象吗？但是如果x是一个descriptor实例，为什么不会直接指向新对象而是执行__get__方法？经过一番研究和实验尝试，我大体明白了这个过程。

getattr getattribute和setattr

对于对象的属性，默认的行为是对对象的字典（即__dict__）进行get set delete操作。比如说，对a.x查找x属性，默认的搜索顺序是a.__dict__[‘x’]，然后是type(a).__dict__[‘x’]，然后怼type(a)的父类(metaclass除外）继续查找。如果查找不到，就会执行特殊的方法。

# -*- coding: utf-8 -*-

class Foo(object):
    class_foo = 'world'
    def __init__(self):
        self.foo = 'hello'
    def __getattr__(self, name):
        print("Foo get attr run..." + self + name)


class Bar(Foo):
    def __getattr__(self, name):
        print("Bar get attr run..." + name)


bar = Bar()
print bar.foo  # hello
print bar.class_foo  # world

# -*- coding: utf-8 -*-

class Foo(object):

class_foo = 'world'

def __init__(self):

self.foo = 'hello'

def __getattr__(self, name):

print("Foo get attr run..." + self + name)

class Bar(Foo):

def __getattr__(self, name):

print("Bar get attr run..." + name)

bar = Bar()

print bar.foo # hello

print bar.class_foo # world

__getattr__只有在当对象的属性找不到的时候被调用。

   class LazyDB(object):
       def __init__(self):
           self.exists = 5
       def __getattr__(self, name):
           value = ‘Value for %s’ % name
           setattr(self, name, value)
           return value

class LazyDB(object):

def __init__(self):

self.exists = 5

def __getattr__(self, name):

value = ‘Value for %s’ % name

setattr(self, name, value)

return value

   data = LazyDB()
   print(‘Before:’, data.__dict__)
   print(‘foo:   ’, data.foo)
   print(‘After: ‘, data.__dict__)
   >>>
   Before: {‘exists’: 5}
   foo:    Value for foo
   After:  {‘exists’: 5, ‘foo’: ‘Value for foo’}

data = LazyDB()

print(‘Before:’, data.__dict__)

print(‘foo: ’, data.foo)

print(‘After: ‘, data.__dict__)

>>>

Before: {‘exists’: 5}

foo: Value for foo

After: {‘exists’: 5, ‘foo’: ‘Value for foo’}

__getattribute__ 每次都会调用这个方法拿到对象的属性，即使对象存在。

class ValidatingDB(object):
    def __init__(self):
        self.exists = 5

    def __getattribute__(self, name):
        print("Called __getattribute__(%s)" % name)
        try:
            attr = super().__getattribute__(name)
            print("Call __getattribute__ done")
            return attr
        except AttributeError:
            value = "Value for %s" % name
            setattr(self, name, value)
            return value


data = ValidatingDB()

print("exists:", data.exists)
print("foo:   ", data.foo)
print("foo:   ", data.foo)

class ValidatingDB(object):

def __init__(self):

self.exists = 5

def __getattribute__(self, name):

print("Called __getattribute__(%s)" % name)

try:

attr = super().__getattribute__(name)

print("Call __getattribute__ done")

return attr

except AttributeError:

value = "Value for %s" % name

setattr(self, name, value)

return value

data = ValidatingDB()

print("exists:", data.exists)

print("foo: ", data.foo)

输出如下：

Called __getattribute__(exists)
exists: 5
Called __getattribute__(foo)
foo:    Value for foo
Called __getattribute__(foo)
foo:    Value for foo

Called __getattribute__(exists)

exists: 5

Called __getattribute__(foo)

foo: Value for foo

Called __getattribute__(foo)

foo: Value for foo

__setattr__每次在对象设置属性的时候都会调用。

判断对象的属性是否存在用的是内置函数hasattr。hasattr是C语言实现的，看了一下源代码，发现自己看不懂。不过搜索顺序和本节开头我说的一样。以后再去研究下源代码吧。

总结一下，取得一个对象的属性，默认的行为是：

如果定义了 __getattribute__ 会无条件执行 __getattribute__ 的逻辑
查找对象的__dict__
如果没有，就查找对象的class的__dict__,即type(a).__dict__['x']
如果没有，就查找父类class的__dict__
如果没有，就执行__getattr__（如果定义了的话）
否则就抛出AttributeError

对一个对象赋值，默认的行为是：

如果定义了__set__方法，会通过__setattr__赋值
否则会更新对象的__dict__

但是，如果对象的属性是一个Descriptor的话，会改变这种默认行为。

Python的Descriptor

对象的属性可以通过方法来定义特殊的行为。下面的代码，Homework.grade可以像普通属性一样使用。

 class Homework(object):
       def __init__(self):
           self._grade = 0
       @property
       def grade(self):
           return self._grade
       @grade.setter
       def grade(self, value):
           if not (0 <= value <= 100):
               raise ValueError(‘Grade must be between 0 and 100’)
               self._grade = value

class Homework(object):

def __init__(self):

self._grade = 0

@property

def grade(self):

return self._grade

@grade.setter

def grade(self, value):

if not (0 <= value <= 100):

raise ValueError(‘Grade must be between 0 and 100’)

self._grade = value

但是，如果有很多这样的属性，就要定义很多setter和getter方法。于是，就有了可以通用的Descriptor。

 class Grade(object):
       def __get__(*args, **kwargs):
           #...
       def __set__(*args, **kwargs): 
           #...


class Exam(object):
       # Class attributes
       math_grade = Grade()
       writing_grade = Grade()
       science_grade = Grade()

class Grade(object):

def __get__(*args, **kwargs):

#...

def __set__(*args, **kwargs):

#...

class Exam(object):

# Class attributes

math_grade = Grade()

writing_grade = Grade()

science_grade = Grade()

Descriptor是Python的内置实现，一旦对象的某个属性是一个Descriptor实例，那么这个对象的读取和赋值将会使用Descriptor定义的相关方法。如果对象的__dict__和Descriptor同时有相同名字的，那么Descriptor的行为会优先。

# -*- coding: utf-8 -*-

class Descriptor(object):
    def __init__(self, name='x'):
        self.value = 0
        self.name = name
    def __get__(self, obj, type=None):
        print "get call"
        return self.value
    def __set__(self, obj, value):
        print "set call"
        self.value = value


class Foo(object):
    x = Descriptor()

foo = Foo()
print foo.x
foo.x = 200
print foo.x
print foo.__dict__
foo.__dict__['x'] = 500
print foo.__dict__
print foo.x

# --------------
# output
# get call
# 0
# set call
# get call
# 200
# {}
# {'x': 500}
# get call
# 200

# -*- coding: utf-8 -*-

class Descriptor(object):

def __init__(self, name='x'):

self.value = 0

self.name = name

def __get__(self, obj, type=None):

print "get call"

return self.value

def __set__(self, obj, value):

print "set call"

self.value = value

class Foo(object):

x = Descriptor()

foo = Foo()

print foo.x

foo.x = 200

print foo.x

print foo.__dict__

foo.__dict__['x'] = 500

print foo.__dict__

print foo.x

# --------------

# output

# get call

# 0

# set call

# get call

# 200

# {}

# {'x': 500}

# get call

# 200

实现了__get__()和__set__()方法的叫做data descriptor,只定义了__get__()的叫做non-data descriptor(通常用于method，本文后面有相应的解释）。上文提到，data descriptor优先级高于对象的__dict__但是non-data descriptor的优先级低于data descriptor。上面的代码删掉__set__()将会是另一番表现。

# -*- coding: utf-8 -*-

class Descriptor(object):
    def __init__(self, name='x'):
        self.value = 0
        self.name = name
    def __get__(self, obj, type=None):
        print "get call"
        return self.value


class Foo(object):
    x = Descriptor()

foo = Foo()
print foo.x
foo.x = 200
print foo.x
print foo.__dict__
foo.__dict__['x'] = 500
print foo.__dict__
print foo.x

# --------------
# output
# get call
# 0
# 200
# {'x': 200}
# {'x': 500}
# 500

# -*- coding: utf-8 -*-

class Descriptor(object):

def __init__(self, name='x'):

self.value = 0

self.name = name

def __get__(self, obj, type=None):

print "get call"

return self.value

class Foo(object):

x = Descriptor()

foo = Foo()

print foo.x

foo.x = 200

print foo.x

print foo.__dict__

foo.__dict__['x'] = 500

print foo.__dict__

print foo.x

# --------------

# output

# get call

# 0

# 200

# {'x': 200}

# {'x': 500}

# 500

如果需要一个“只读”的属性，只需要将__set__()抛出一个AttributeError即可。只定义__set__()也可以称作一个data descriptor。

调用关系

对象和类的调用有所不同。

对象的调用在object.__getattribute__()，将b.x转换成type(b).__dict__['x'].__get__(b, type(b))，然后引用的顺序和上文提到的那样，首先是data descriptor，然后是对象的属性，然后是non-data descriptor。

对于类的调用，由type.__getattribute__()将B.x转换成B.__dict__['x'].__get__(None, B)。Python实现如下：

def __getattribute__(self, key):
    "Emulate type_getattro() in Objects/typeobject.c"
    v = object.__getattribute__(self, key)
    if hasattr(v, '__get__'):
        return v.__get__(None, self)
    return v

def __getattribute__(self, key):

"Emulate type_getattro() in Objects/typeobject.c"

v = object.__getattribute__(self, key)

if hasattr(v, '__get__'):

return v.__get__(None, self)

return v

需要注意的一点是，Descriptor默认是由__getattribute__()调用的，如果覆盖__getattribute__()将会使Descriptor失效。

Function，ClassMethod和StaticMethod

看起来这和本文内容没有什么关系，但其实Python中对象和函数的绑定，其原理就是Descriptor。

在Python中，方法（method）和函数（function）并没有实质的区别，只不过method的第一个参数是对象（或者类）。Class的__dict__中把method当做function一样存储，第一个参数预留出来作为self。为了支持方法调用，function默认有一个__get__()实现。也就是说，所有的function都是non-data descriptor，返回bound method(对象调用）或unbound method(类调用)。用纯Python实现，如下。

class Function(object):
    . . .
    def __get__(self, obj, objtype=None):
        "Simulate func_descr_get() in Objects/funcobject.c"
        return types.MethodType(self, obj, objtype)

class Function(object):

. . .

def __get__(self, obj, objtype=None):

"Simulate func_descr_get() in Objects/funcobject.c"

return types.MethodType(self, obj, objtype)

>>> class D(object):
...     def f(self, x):
...         return x
...
>>> d = D()
>>> D.__dict__['f']  # Stored internally as a function
<function f at 0x00C45070>
>>> D.f              # Get from a class becomes an unbound method
<unbound method D.f>
>>> d.f              # Get from an instance becomes a bound method
<bound method D.f of <__main__.D object at 0x00B18C90>>

>>> class D(object):

... def f(self, x):

... return x

...

>>> d = D()

>>> D.__dict__['f'] # Stored internally as a function

>>> D.f # Get from a class becomes an unbound method

>>> d.f # Get from an instance becomes a bound method

bound和unbound method虽然表现为两种不同的类型，但是在C源代码里，是同一种实现。如果第一个参数im_self是NULL，就是unbound method，如果im_self有值，那么就是bound method。

总结：Non-data descriptor提供了将函数绑定成方法的作用。Non-data descriptor将obj.f(*args)转化成f(obj, *args)，将klass.f(*args)转化成f(*args)。如下表。

Transformation	Called from an Object	Called from a Class
function	f(obj, *args)	f(*args)
staticmethod	f(*args)	f(*args)
classmethod	f(type(obj), *args)	f(klass, *args)

可以看到，staticmethod并没有什么转化，和function几乎没有什么差别。因为staticmethod的推荐用法就是将逻辑相关，但是数据不相关的functions打包组织起来。通过函数调用、对象调用、方法调用都没有什么区别。staticmethod的纯python实现如下。

class StaticMethod(object):
    "Emulate PyStaticMethod_Type() in Objects/funcobject.c"

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

    def __get__(self, obj, objtype=None):
        return self.f

class StaticMethod(object):

"Emulate PyStaticMethod_Type() in Objects/funcobject.c"

def __init__(self, f):

self.f = f

def __get__(self, obj, objtype=None):

return self.f

classmethod用于那些适合通过类调用的函数，例如工厂函数等。与类自身的数据有关系，但是和实际的对象没有关系。例如，Dict类将可迭代的对象生成字典，默认值为None。

class Dict(object):
    . . .
    def fromkeys(klass, iterable, value=None):
        "Emulate dict_fromkeys() in Objects/dictobject.c"
        d = klass()
        for key in iterable:
            d[key] = value
        return d
    fromkeys = classmethod(fromkeys)

>>> Dict.fromkeys('abracadabra')
{'a': None, 'r': None, 'b': None, 'c': None, 'd': None}

class Dict(object):

. . .

def fromkeys(klass, iterable, value=None):

"Emulate dict_fromkeys() in Objects/dictobject.c"

d = klass()

for key in iterable:

d[key] = value

return d

fromkeys = classmethod(fromkeys)

>>> Dict.fromkeys('abracadabra')

{'a': None, 'r': None, 'b': None, 'c': None, 'd': None}

classmethod的纯Python实现如下。

class ClassMethod(object):
    "Emulate PyClassMethod_Type() in Objects/funcobject.c"

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

    def __get__(self, obj, klass=None):
        if klass is None:
            klass = type(obj)
        def newfunc(*args):
            return self.f(klass, *args)
        return newfunc

class ClassMethod(object):

"Emulate PyClassMethod_Type() in Objects/funcobject.c"

def __init__(self, f):

self.f = f

def __get__(self, obj, klass=None):

if klass is None:

klass = type(obj)

def newfunc(*args):

return self.f(klass, *args)

return newfunc

最后的话

一开始只是对对象的属性有些疑问，查来查去发现还是官方文档最靠谱。然后认识了Descriptor，最后发现这并不是少见的trick，而是Python中的最常见对象——function时时刻刻都在用它。从官方文档中能学到不少东西呢。另外看似平常、普通的东西背后，可能蕴含了非常智慧和简洁的设计。

《Effective Python》小记

个人抗风险基金的想法

认识Python的MetaClass

用MetaClass验证

使用MetaClass对class进行注册

修改class的属性

理解Python对象的属性和描述器

getattr getattribute和setattr

Python的Descriptor

调用关系

Function，ClassMethod和StaticMethod

最后的话

相关阅读

推荐音乐专辑《Labor》

2025 年 4 月
一	二	三	四	五	六	日
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30

用MetaClass验证

使用MetaClass对class进行注册

修改class的属性

__getattr__ __getattribute__和__setattr__

Python的Descriptor

调用关系

Function，ClassMethod和StaticMethod

最后的话

相关阅读

getattr getattribute和setattr