StringIO 是纯Python代码编写的，而 cStringIO 部分函数是 C 写的，因此 cStringIO 运行速度更快。

try:
    from cStringIO import StringIO
except ImportError:
    from StringIO import StringIO

try 的作用是捕获错误，并在捕获到指定错误时执行 except 语句。

包：文件夹，可以有多级，包的每一层下面必须有一个_init_.py文件

模块：xxx.py文件

函数

引用其他模块：

#test.py          自身模块名test

import math    引用math模块

print math.pow(2,10)      调用math模块函数

在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。

要在class中定义类方法，需要这么写：

class Person(object):
    count = 0    @classmethod
    def how_many(cls):
        return cls.count
    def __init__(self, name):
        self.name = name
        Person.count = Person.count + 1

print Person.how_many()
p1 = Person('Bob')
print Person.how_many()

通过标记一个 @classmethod，该方法将绑定到 Person 类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count。

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)#base=2为默认值
>>> int2('1000000')
64
>>> int2('1010101')
85

functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了。

函数调用不需要传入 self，但是方法调用需要传入 self。

>>> int('12345', base=8)
5349

#int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做 N 进制的转换：

参数的调用和返回的函数

1. 私有属性无法从外部访问，但是，从类的内部是可以访问的。除了可以定义实例的属性外，还可以定义实例的方法。

2. 实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的

3. class Person(object):
   
       def __init__(self, name):
           self.__name = name
   
       def get_name(self):
           return self.__name

4. get_name(self) 就是一个实例方法，它的第一个参数是self。

5. p1 = Person('Bob')
   print p1.get_name()

import functools
def log(f):
    @functools.wraps(f) #内置functools
    def wrapper(*args, **kw):
        print 'call...'
        return f(*args, **kw)
    return wrapper

def log(f):
    def wrapper(*args, **kw):
        print 'call...'
        return f(*args, **kw)
    wrapper.__name__ = f.__name__
    wrapper.__doc__ = f.__doc__
    return wrapper

这样写decorator很不方便，因为我们也很难把原函数的所有必要属性都一个一个复制到新函数上，所以Python内置的functools可以用来自动化完成这个“复制”的任务。

修改类属性会导致所有实例访问到的类属性全部都受影响，但是，如果在实例变量上修改类属性,它实际上并没有修改类属性，而是给实例绑定了一个实例属性。当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。

1. 绑定在一个实例上的属性不会影响其他实例，但是，类本身也是一个对象，如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个！也就是说，实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。

2. 定义类属性可以直接在 class 中定义：

3. class Person(object):    address = 'Earth'
       def __init__(self, name):
           self.name = name

4. 因为类属性是直接绑定在类上的，所以，访问类属性不需要创建实例，就可以直接访问：

5. print Person.address# => Earth

6. 对一个实例调用类的属性也是可以访问的，所有实例都可以访问到它所属的类的属性：

7. p1 = Person('Bob')
   p2 = Person('Alice')
   print p1.address# => Earthprint p2.address# => Earth

8. 由于Python是动态语言，类属性也是可以动态添加和修改的：

9. Person.address = 'China'
   print p1.address# => 'China'print p2.address# => 'China'

10. 因为类属性只有一份，所以，当Person类的address改变时，所有实例访问到的类属性都改变了。

1. Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问。

2. 如果一个属性以"__xxx__"的形式定义，那它又可以被外部访问了，以"__xxx__"定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，通常我们不要把普通属性用"__xxx__"定义。

3. 以单下划线开头的属性"_xxx"虽然也可以被外部访问，但是，按照习惯，他们不应该被外部访问。

在定义 Person 类时，可以为Person类添加一个特殊的__init__()方法，当创建实例时，__init__()方法被自动调用，我们就能在此为每个实例都统一加上以下属性：

class Person(object):    def __init__(self, name, gender, birth):
        self.name = name
        self.gender = gender
        self.birth = birth

__init__() 方法的第一个参数必须是 self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。

被赋予不同的属性值，访问属性使用.操作符：

print xiaoming.name# 输出 'Xiao Ming'print xiaohong.birth# 输出 '1992-2-2'