静态方法，类方法，实例方法区别
class A:
flage = 1
@staticmethod
def printHellow():
print 'hellow word'
@classmethod
def printflag(cls):
cls.flage = 2
print cls.flage
def printPython(self):
print 'python'
a = A()
print a.flage
a.printPython()
A.printHellow()
A.printflag()
result:
1
python
hellow word
2
1.调用方式不同
2.类方法默认有cls属性，可以修改本类的属性值，实例方法有self对象，可以使用，修改本地成员变量，而静态方法则没有
动态的创建类包含实例方法，类方法，静态方法
@staticmethod
def printHellow():
print 'hellow word'
@classmethod
def printflag(cls):
cls.flage = 2
print cls.flage
def printSelfFlage(self):
print self.flage
Foo = type('Foo', (),
{'flage': 5, 'printHellow': printHellow, 'printSelfFlage': printSelfFlage, 'printflag': printflag})
Foo.printHellow()
Foo.printflag()
foo = Foo()
foo.printSelfFlage()
元类中的属性
__class__属性
age = 35
print age.__class__
reult：
<type 'int'> #判断对象是什么类型的
__metaclass__属性
class Foo(Bar):
pass
如果写了上述代码则做得以下操作
1.Foo中有__metaclass__这个属性吗？如果是，python会通过__metaclass__创建一个名字为Foo对象
2.如果Python没有找到__metaclass__，它会继续在Bar(父类)中寻找__metaclass__属性，并尝试做上面的操作
3.如果Python在任何父类中都找不到__metaclass__，它就会在模块层次中去寻找__metaclass__，并尝试做同样的操作。
4.如果还是找不到__metaclass__,Python就会用内置的type来创建这个类对象。
自定义元类
def upper_attr(future_class_name, future_class_parents, future_class_attr):
newAttr = {}
for name, value in future_class_attr.items():
if not name.startswith('__'):
newAttr[name.upper()] = value
return type(future_class_name, future_class_parents, newAttr)
class Foo(object):
bar = 'bip'
__metaclass__ = upper_attr
foo = Foo()
print foo.BAR
result:
bip
__slots__属性
限制class实例能添加的属性
生成器
1.创建方式一
l=(x*2 for x in range(5))
2.创建方式二
def gen():
i = 0
while True:
temp = yield i
print temp
i = i + 1
取值:
l = gen()
print l.next()
print l.next()
print l.next()
0
None
1
None
2
*******************************
l = gen()
print l.next()
print l.send('dsada')
print l.next()
0
dsada
1
None
2
闭包
def line_conf(a, b):
def line(x):
return a * x + b
return line
line1 = line_conf(1, 1)
line2 = line_conf(2, 3)
print line1(5)
print line2(6)
result:
6
15
装饰器
# coding=utf8
from functools import *
def trace1(func):
@wraps(func)
def wrapper(*args, **kwargs):
print '装饰代码args=%s,kwargs=%s' % (args, kwargs)
return func(*args, **kwargs)
return wrapper
@trace1
def add(x, y):
return x + y
def trace2(*args1, **kwargs1):
def funargs(func):
@wraps(func)
def wrapper(*agrs2, **kwargs2):
print 'Hellow args1=%s,kwargs1=%s' % (args1, kwargs1)
return func(*agrs2, **kwargs2)
return wrapper
return funargs
@trace2('ss')
def multi(x, y):
return x * y
print add(3, 3)
print multi(3, 2)
result:
装饰代码args=(3, 3),kwargs={}
6
Hellow args1=('ss',),kwargs1={}
6
==,is的区别
1.is 是比较两个引用是否指向了同一个对象（引用比较）。
2.== 是比较两个对象是否相等
浅拷贝与深拷贝
import copy
orign = [1, 2, [3, 4]]
copy1 = copy.copy(orign)
copy2 = copy.deepcopy(orign)
print copy1
print copy2
orign[0] = 'ss'
print copy1
print copy2
orign[2][1] = 9
print copy1
print copy2
result:
[1, 2, [3, 4]]
[1, 2, [3, 4]]
[1, 2, [3, 4]]
[1, 2, [3, 4]]
[1, 2, [3, 9]]
[1, 2, [3, 4]]
copy.copy() 浅拷贝，只拷贝第一层
copy.deepcopy() 深拷贝，
