Python-技巧

class a:pass
class b(a):pass
class c(a):pass
class d(b, c):pass

class A(O):pass
class B(O):pass
class C(O):pass
class E(A,B):pass
class F(B,C):pass
class G(E,F):pass

#-*- encoding:GBK -*-#
def mro_C3(*cls):
if len(cls)==1:
if not cls[0].__bases__:
return  cls
else:
return cls+ mro_C3(*cls[0].__bases__)
else:
seqs = [list(mro_C3(C)) for C in cls ] +[list(cls)]
res = []
while True:
non_empty = list(filter(None, seqs))
if not non_empty:
return tuple(res)
for seq in non_empty:
candidate = seq[0]
not_head = [s for s in non_empty if candidate in s[1:]]
if not_head:
candidate = None
else:
break
if not candidate:
raise TypeError("inconsistent hierarchy, no C3 MRO is possible")
res.append(candidate)
for seq in non_empty:
if seq[0] == candidate:
del seq[0]

# -*- coding:utf-8 -*-
class D(object):
def foo(self):
print "class D"

class B(D):
pass

class C(D):
def foo(self):
print "class C"

class A(B, C):
pass

f = A()
f.foo()
#A的实例对象f在调用foo函数的时候, 根据广度优先搜索原则, 调用的是C类里面的foo函数, 上面的代码输出class C; 如果定义D类的时候直接class D, 而不是class D(object), 那么上述代码就该输出class D了

class Singleton(object):
def __new__(cls, *args, **kwargs):
# 关键在于这，每一次实例化的时候，我们都只会返回这同一个instance对象
if not hasattr(cls, "instance"):
cls.instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls.instance

class A(object):
def __new__(cls):
Object = super(A, cls).__new__(cls)
print "in New"
return Object #如果把此行注释掉, 则不会执行 __init__ 方法
def __init__(self):
print "in init"

class B(A):
def __init__(self):
print "in B's init"

B()

'var' in locals().keys()

try:
print var
except NameError:
print 'var not defined'

'var' in dir()

m = __import__(clsstr所在模块名)
cls = getattr(m, clsstr)
cls()

import sys   #引用sys模块进来，并不是进行sys的第一次加载
reload(sys)  #重新加载sys
sys.setdefaultencoding('utf8')  ##调用setdefaultencoding函数
#如果去掉reload(sys), 会执行失败, 因为这里的import语句其实并不是sys的第一次导入语句, 也就是说这里其实可能是第二、三次进行sys模块的import, 这里只是一个对sys的引用, 只能reload才能进行重新加载; 那么为什么要重新加载, 而直接引用过来则不能调用该函数呢？因为setdefaultencoding函数在被系统调用后被删除了, 所以通过import引用进来时其实已经没有了, 所以必须reload一次sys模块, 这样setdefaultencoding才会为可用, 才能在代码里修改解释器当前的字符编码

__import__(module_name[, globals[, locals[, fromlist]]]) #可选参数默认为globals(),locals(),[]
__import__('os')
__import__('os',globals(),locals(),['path','pip'])  #等价于from os import path, pip

for i in seq:
do_something_to(i)

fetch = iter(seq)
while True:
try:
i = fetch.next()
except StopIteration:
break
do_something_to(i)

>>> generator = get_0_1_2()
>>> generator
<generator object get_0_1_2 at 0x00B1C7D8>

>>> generator.next()
0

>>> generator.next()
1
>>> generator.next()
2

>>> generator.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

>>> def fibonacci():
...   a = b = 1
...   yield a
...   yield b
...   while True:
...     a, b = b, a+b
...     yield b
...
>>> for num in fibonacci():
...   if num > 100: break
...   print num,
...
1 1 2 3 5 8 13 21 34 55 89

{x: 1 for x in ["name", "sex"]} #返回 {"name": 1, "sex" 1}

(x+1 for x in lst) #生成器表达式，返回迭代器。外部的括号可在用于参数时省略。
[x+1 for x in lst] #列表解析，返回list

(for x in range(1000000))    #返回生成器
[for x in range(1000000)]    #返回整个列表

((x, y) for x in range(3) for y in range(x))

(x for x in (y.doSomething() for y in lst) if x>0)

def abc(numbers = []):
numbers.append(9)
print numbers

def print_now(now = time.time()):
print now    #如果不加参数, 则每次都会返回相同的时间

a, b, c = 1, 2, 3 #赋值
a, b = b, a #转换a, b的值
a = 1, #声明元组

def test(x, y = 5, *a, **b):
print x, y, a, b

　　test(1) ===> 1 5 () {}
　　test(1,2) ===> 1 2 () {}
　　test(1,2,3)  ===> 1 2 (3,) {}
　　test(1,2,3,4) ===> 1 2 (3,4)
　　test(x=1)   ===> 1 5 () {}
　　test(x=1,y=1)  ===> 1 1 () {}
　　test(x=1,y=1,a=1)   ===> 1 1 () {'a':1}
　　test(x=1,y=1,a=1,b=1)   ===> 1 1 () {'a':1,'b':1}
　　test(1,y=1) ===> 1 1 () {}
　　test(1,2,y=1) ===> 出错, 说y给赋了多个值
　　test(1, y = 2, 3, a = 4) ===> 出错, non-keyword arg after keyword arg
　　test(1,2,3,4,a=1) ===> 1 2 (3,4) {'a':1}

#只接收city和job作为关键字参数
def person(name, age, *, city, job):
print(name, age, city, job)

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

class Model():
model_path = "online_model"
model_dict = {}

def __init__(self, path = None):
self.reload(path)

def reload(self, path = None):
if not path:
return

self.model_dict.clear()
fp = file(path, "r")
for line in fp:
cols = line.split()
self.model_dict[cols[0]] = cols[1]

self.model_path = path

def main():
m1 = Model()
m2 = Model()

m1.reload("aa_model")
m2.reload("bb_model")

print m1.model_path
print m2.model_path

print m1.model_dict
print m2.model_dict

return 0

if __name__ == "__main__":
main()

1 a
2 b

x 1
y 2
z 3

class A(object):
def __getattr__(self, attr):
if attr == "age":
return lambda : 25

a = A()
a.age()

class A(object):
pass

a = A()
b = type(a)() #此时b为A的实例

print type(A) #<type 'type'>
print type(a) #<class '__main__.A'>
print isinstance(b, A) #True

def fn(self, name = "John"):
self.name = name

A = type('A', (object,), dict(hello=fn))
a = A()
print type(A) #<type 'type'>
print type(a) #<class '__main__.A'>