实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。

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

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

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

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

请给 Person 类添加一个类属性 count，每创建一个实例，count 属性就加 1，这样就可以统计出一共创建了多少个 Person 的实例。

• ?不会了怎么办

• 由于创建实例必定会调用__init__()方法，所以在这里修改类属性 count 很合适。

  参考代码:

  class Person(object):
      count = 0
      def __init__(self, name):
          Person.count = Person.count + 1
          self.name = name
  p1 = Person('Bob')
  print Person.count# => 1p2 = Person('Alice')
  print Person.count# => 2p3 = Person('Tim')
  print Person.count# => 3

def __init__(self,name):        self.name=name        Person.count+=1        (self.count+=1)  区分这两个 一个是给类属性赋值 一个是给类下面的实例，跑了一下，结果不一样的。

初始化实例

请定义Person类的__init__方法，除了接受 name、gender 和 birth 外，还可接受任意关键字参数，并把他们都作为属性赋值给实例。

• ?不会了怎么办

• 要定义关键字参数，使用 **kw；

  除了可以直接使用self.name = 'xxx'设置一个属性外，还可以通过 setattr(self, 'name', 'xxx') 设置属性。

  参考代码:

  class Person(object):
      def __init__(self, name, gender, birth, **kw):
          self.name = name
          self.gender = gender
          self.birth = birth
          for k, v in kw.iteritems():
              setattr(self, k, v)
  xiaoming = Person('Xiao Ming', 'Male', '1990-1-1', job='Student')
  print xiaoming.name
  print xiaoming.job

创建实例属性

每个实例拥有各自不同的属性？由于Python是动态语言，对每一个实例，都可以直接给他们的属性赋值，例如，给xiaoming这个实例加上name、gender和birth属性：

xiaoming = Person()
xiaoming.name = 'Xiao Ming'
xiaoming.gender = 'Male'
xiaoming.birth = '1990-1-1'

给xiaohong加上的属性不一定要和xiaoming相同：

xiaohong = Person()
xiaohong.name = 'Xiao Hong'

实例的属性可以像普通变量一样进行操作：

xiaohong.grade = xiaohong.grade + 1

创建实例使用 类名+()，类似函数调用的形式创建：

xiaoming = Person()
xiaohong = Person()

Python中获取对象的信息

isinstance（）方法可以判断对象的类型，返回true或者false；

type（）方法可以获取变量的类型，返回Type对象；

dir（）函数可以获取变量的所有属性，获取到函数的属性后可以利用filter（）对属性进行过滤，返回我们定义的属性，dir()返回的属性是一个字符串列表，如果已知一个属性的名称，要获取或设置对象的属性，要用getattr()和setattr()函数；

python 中的多重继承

一个子类可以有多个父类，同时具有所继承的父类的功能

例如：A->B-D    A->C-D   类D同时继承了B 和C

D 同时继承自 B 和 C，也就是 D 拥有了 A、B、C 的全部功能。多重继承通过 super()调用__init__()方法时，A 虽然被继承了两次，但__init__()只调用一次：

多重继承的目的是从两种继承树种分别选择并继承出子类，以便功能的组合使用

平方根函数前边有math.  

f那个是参数。math.sqrt那里还可以换成别的

Python 中多态

1）类具有继承性，子类可以向上转型看成是父类的类型

2）一个函数，如果接受一个变量x,不管这个变量是父类类型还是子类类型，都可以正确地传入

3）多态的特点，方法调用作用在x的实际类型上；方法调用时，可能该方法是继承的父类的方法也可能是自身定义的方法，但总是先查找自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止；

4）由于Python是动态语言，所以传递给所调用函数的参数x不一定是父类person的子类，任何数据类型的实例搜可以只要他有一个whoarl（）方法即可

备注：这是动态语言和静态语言（如Java）最大的区别之一

动态语言调用实例方法，不检测类型，只要方法存在，参数正确，就可以调用；

print 'call %s() in %fs' % (f.__name__, (t2 - t1))

下划线是连按两次

def count():
   fs = []
   for i in range(1, 4):
       def f(m = i):
           return m * m
       fs.append(f)
   return fs

f1, f2, f3 = count()
print f1(), f2(), f3()
方法：问题的产生是因为函数只在执行时才去获取外层参数i，若函数定义时可以获取到i，问题便可解决。而默认参数正好可以完成定义时获取i值且运行函数时无需参数输入的功能，所以在函数f()定义中改为f(m = i),函数f返回值改为m*m即可.

python 使用之__future__

Python 3.x已经改进了整数的除法运算，“/”除将得到浮点数，“//”除才仍是整数：

在Python 3.x中，字符串统一为unicode，不需要加前缀 u，而以字节存储的str则必须加前缀 b。

python之导入模块

我们只希望导入用到的math模块的某几个函数，而不是所有函数，可以用下面的语句：

from math import pow, sin, log

这样，可以直接引用 pow, sin, log 这3个函数，但math的其他函数没有导入进来：

>>> pow(2, 10)
1024.0
>>> sin(3.14)
0.0015926529164868282

如果使用 from...import 导入 log 函数，势必引起冲突。这时，可以给函数起个“别名”来避免冲突：

from math import log
from logging import log as logger   # logging的log现在变成了loggerprint log(10)   # 调用的是math的loglogger(10, 'import from logging')   # 调用的是logging的log

def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
                return j*j
            return g
        r = f(i)
        fs.append(r)
    return fs
f1, f2, f3 = count()
print f1(), f2(), f3()

与

def count():
    fs = []
    for i in range(1, 4):
        def f():
            return i*i
        fs.append(f)
    return fs
f1, f2, f3 = count()
print f1(), f2(), f3()

区别是：后者是9 ，9，9；前者是1，4，9