在python中，类可以提供模块级别之下的命名空间。

如果一个模块写很多函数，某些函数之间共同完成一组功能，用类会看起来更清晰，在调用时候也会更好，对于ide补全有更小范围的限定提示。

类提供 继承 组合 多重实例  通过继承进行定制 运算符重载（就是类的双下划线方法__del__ __call__ __str__ __iter__  ........）。

类和模块都可以建立命名空间树，模块中的功能叫函数，类中的一般称为方法。

python中模块的方法也可以像类一样被继承和定制。

下面是两个文件。

modulea.py

# coding=utf8

x = 1

def fun1():

    print 'modulea',x

def fun2():

    print 'modulea',x*2

moduleb.py

# coding=utf8

import modulea

print modulea.__dict__

modulea.fun1()

modulea.fun2()

def fun1():

    print 'moduleb',modulea.x*10

modulea.x = 11

modulea.fun1 = fun1

print '替换后'

modulea.fun1()

modulea.fun2()

运行noduleb.py

modulea.fun1()

modulea.fun2()
这种方法和类实例调用方法形式上一样

modulea的fun1函数被改变了，类似类继承。

如果使用类，里面是

class A(object):

    def __init__(self,x):

        self.x = x

    def fun1(self):

        print self.x * 1

    def fun2(self):

        print self.x * 2

这样在x在初始化赋值和继承修改fun1更方便，类是一个对象工厂，可以产生多重实例，使用上面模块的方式就不行。但最简单的单利模式就是使用模块，例如a模块有一个b对象，其余所有py文件中都import a，使用a.b来操作a，这就达到天然的单例模式了；但要注意的是一定要import a ，a.b这种用法，不可使用from a import b，然后操作b，这样会使b脱离了a的命名空间，每个py文件中的b对象将是不同的了，就不是单例模式了。

类还提供了运算符重载，这是模块方式不具备。

实例属性，在类中的所有普通方法（带self的方法）始终是操作同一个变量，

使用模块时候，在函数中操作同一个变量，变量必须是全局变量，函数里面的局部变量会比全局变量优先。

在一个大文件中，分成几个类是必须的，更清晰的结构，不至于全局变量到处是，和函数过多结构不清晰。

面向对象和面向过程的区别是   狗.吃屎 和 吃.*，使用面向对象在别处调用时候那就是个爽快，在调用时候比写的时候体现得明显。

使用类怎么模拟模块的行为。那就是模块里面的一个类全部使用staticmetod，由类来提供命名空间。

例如

class Bb:

    @staticmethod

    def fun1(a):

        print  a *1

    @staticmethod

    def fun2(a,b):

        return a+b

print Bb.fun2(1,2)

stackflow上说明，这种情况不要使用这种全部静态方法，使用模块加函数就可以了。

模块 + 全局变量 + 函数 类似于  类 + 属性 + 方法的单例模式类。