python实用代码片段收集贴

获取一个类的所有子类

代码如下:

def itersubclasses(cls, _seen=none):
“””generator over all subclasses of a given class in depth first order.”””
if not isinstance(cls, type):
raise typeerror(_(‘itersubclasses must be called with ‘
‘new-style classes, not %.100r’) % cls)
_seen = _seen or set()
try:
subs = cls.__subclasses__()
except typeerror: # fails only when cls is type
subs = cls.__subclasses__(cls)
for sub in subs:
if sub not in _seen:
_seen.add(sub)
yield sub
for sub in itersubclasses(sub, _seen):
yield sub

简单的线程配合

代码如下:

import threading
is_done = threading.event()
consumer = threading.thread(
target=self.consume_results,
args=(key, self.task, runner.result_queue, is_done))
consumer.start()
self.duration = runner.run(
name, kw.get(“context”, {}), kw.get(“args”, {}))
is_done.set()
consumer.join() #主线程堵塞,直到consumer运行结束

多说一点,threading.event()也可以被替换为threading.condition(),condition有notify(), wait(), notifyall()。解释如下:

代码如下:

the wait() method releases the lock, and then blocks until it is awakened by a notify() or notifyall() call for the same condition variable in another thread. once awakened, it re-acquires the lock and returns. it is also possible to specify a timeout.
the notify() method wakes up one of the threads waiting for the condition variable, if any are waiting. the notifyall() method wakes up all threads waiting for the condition variable.
note: the notify() and notifyall() methods don’t release the lock; this means that the thread or threads awakened will not return from their wait() call immediately, but only when the thread that called notify() or notifyall() finally relinquishes ownership of the lock.

代码如下:

# consume one item
cv.acquire()
while not an_item_is_available():
cv.wait()
get_an_available_item()
cv.release()
# produce one item
cv.acquire()
make_an_item_available()
cv.notify()
cv.release()

计算运行时间

代码如下:

class timer(object):
def __enter__(self):
self.error = none
self.start = time.time()
return self
def __exit__(self, type, value, tb):
self.finish = time.time()
if type:
self.error = (type, value, tb)
def duration(self):
return self.finish – self.start
with timer() as timer:
func()
return timer.duration()

元类

__new__()方法接收到的参数依次是:
当前准备创建的类的对象;
类的名字;
类继承的父类集合;
类的方法集合;

代码如下:

class modelmetaclass(type):
def __new__(cls, name, bases, attrs):
if name==’model’:
return type.__new__(cls, name, bases, attrs)
mappings = dict()
for k, v in attrs.iteritems():
if isinstance(v, field):
print(‘found mapping: %s==>%s’ % (k, v))
mappings[k] = v
for k in mappings.iterkeys():
attrs.pop(k)
attrs[‘__table__’] = name # 假设表名和类名一致
attrs[‘__mappings__’] = mappings # 保存属性和列的映射关系
return type.__new__(cls, name, bases, attrs)
class model(dict):
__metaclass__ = modelmetaclass
def __init__(self, **kw):
super(model, self).__init__(**kw)
def __getattr__(self, key):
try:
return self[key]
except keyerror:
raise attributeerror(r”‘model’ object has no attribute ‘%s'” % key)
def __setattr__(self, key, value):
self[key] = value
def save(self):
fields = []
params = []
args = []
for k, v in self.__mappings__.iteritems():
fields.append(v.name)
params.append(‘?’)
args.append(getattr(self, k, none))
sql = ‘insert into %s (%s) values (%s)’ % (self.__table__, ‘,’.join(fields), ‘,’.join(params))
print(‘sql: %s’ % sql)
print(‘args: %s’ % str(args))
class field(object):
def __init__(self, name, column_type):
self.name = name
self.column_type = column_type
def __str__(self):
return ” % (self.__class__.__name__, self.name)
class stringfield(field):
def __init__(self, name):
super(stringfield, self).__init__(name, ‘varchar(100)’)
class integerfield(field):
def __init__(self, name):
super(integerfield, self).__init__(name, ‘bigint’)
class user(model):
# 定义类的属性到列的映射:
id = integerfield(‘id’)
name = stringfield(‘username’)
email = stringfield(’email’)
password = stringfield(‘password’)
# 创建一个实例:
u = user(michael’, email=’test@orm.org’, password=’my-pwd’)
# 保存到数据库:
u.save()

输出如下:

代码如下:

found model: user
found mapping: email ==>
found mapping: password ==>
found mapping: id ==>
found mapping: name ==>
sql: insert into user (password,email,username,uid) values (?,?,?,?)
args: [‘my-pwd’, ‘test@orm.org’, ‘michael’, 12345]

sqlalchemy简单使用

代码如下:

# 导入:
from sqlalchemy import column, string, create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
# 创建对象的基类:
base = declarative_base()
# 定义user对象:
class user(base):
# 表的名字:
__tablename__ = ‘user’
# 表的结构:
id = column(string(20), primary_key=true)
name = column(string(20))
# 初始化数据库连接:
engine = create_engine(‘mysql+mysqlconnector://root:password@localhost:3306/test’) # ‘数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名’
# 创建dbsession类型:
dbsession = sessionmaker(bind=engine)
# 创建新user对象:
new_user = user(, name=’bob’)
# 添加到session:
session.add(new_user)
# 提交即保存到数据库:
session.commit()
# 创建query查询,filter是where条件,最后调用one()返回唯一行,如果调用all()则返回所有行:
user = session.query(user).filter(user.5′).one()
# 关闭session:
session.close()

wsgi简单使用和web框架flask的简单使用

代码如下:

from wsgiref.simple_server import make_server
def application(environ, start_response):
start_response(‘200 ok’, [(‘content-type’, ‘text/html’)])
return ‘hello, web!’
# 创建一个服务器,ip地址为空,端口是8000,处理函数是application:
httpd = make_server(”, 8000, application)
print “serving http on port 8000…”
# 开始监听http请求:
httpd.serve_forever()

了解了wsgi框架,我们发现:其实一个web app,就是写一个wsgi的处理函数,针对每个http请求进行响应。
但是如何处理http请求不是问题,问题是如何处理100个不同的url。
一个最简单和最土的想法是从environ变量里取出http请求的信息,然后逐个判断。

代码如下:

from flask import flask
from flask import request
app = flask(__name__)
@app.route(‘/’, methods=[‘get’, ‘post’])
def home():
return ‘home’
@app.route(‘/signin’, methods=[‘get’])
def signin_form():
return ”’

sign in

”’
@app.route(‘/signin’, methods=[‘post’])
def signin():
# 需要从request对象读取表单内容:
if request.form[‘username’]==’admin’ and request.form[‘password’]==’password’:
return ‘hello, admin!’
return ‘bad username or password.’
if __name__ == ‘__main__’:
app.run()

格式化显示json

代码如下:

print(json.dumps(data, indent=4))
# 或者
import pprint
pprint.pprint(data)

实现类似java或c中的枚举

代码如下:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import itertools
import sys
class immutablemixin(object):
_inited = false
def __init__(self):
self._inited = true
def __setattr__(self, key, value):
if self._inited:
raise exception(“unsupported action”)
super(immutablemixin, self).__setattr__(key, value)
class enummixin(object):
def __iter__(self):
for k, v in itertools.imap(lambda x: (x, getattr(self, x)), dir(self)):
if not k.startswith(‘_’):
yield v
class _runnertype(immutablemixin, enummixin):
serial = “serial”
constant = “constant”
constant_for_duration = “constant_for_duration”
rps = “rps”
if __name__==”__main__”:
print _runnertype.constant

创建文件时指定权限

代码如下:

import os
def write_to_file(path, contents, umask=none):
“””write the given contents to a file
:param path: destination file
:param contents: desired contents of the file
:param umask: umask to set when creating this file (will be reset)
“””
if umask:
saved_umask = os.umask(umask)
try:
with open(path, ‘w’) as f:
f.write(contents)
finally:
if umask:
os.umask(saved_umask)
if __name__ == ‘__main__’:
write_to_file(‘/home/kong/tmp’, ‘test’, 31)
# then you will see a file is created with permission 640.
# warning: if the file already exists, its permission will not be changed.
# note:for file, default all permission is 666, and 777 for directory.

多进程并发执行

代码如下:

import multiprocessing
import time
import os
def run(flag):
print “flag: %s, sleep 2s in run” % flag
time.sleep(2)
print “%s exist” % flag
return flag
if __name__ == ‘__main__’:
pool = multiprocessing.pool(3)
iter_result = pool.imap(run, xrange(6))
print “sleep 5s\n\n”
time.sleep(5)
for i in range(6):
try:
result = iter_result.next(600)
except multiprocessing.timeouterror as e:
raise
print result
pool.close()
pool.join()

运行时自动填充函数参数

代码如下:

import decorator
def default_from_global(arg_name, env_name):
def default_from_global(f, *args, **kwargs):
id_arg_index = f.func_code.co_varnames.index(arg_name)
args = list(args)
if args[id_arg_index] is none:
args[id_arg_index] = get_global(env_name)
if not args[id_arg_index]:
print(“missing argument: –%(arg_name)s” % {“arg_name”: arg_name})
return(1)
return f(*args, **kwargs)
return decorator.decorator(default_from_global)
# 如下是一个装饰器,可以用在需要自动填充参数的函数上。功能是:
# 如果没有传递函数的deploy_id参数,那么就从环境变量中获取(调用自定义的get_global函数)
with_default_deploy_id = default_from_global(‘deploy_id’, env_deployment)

嵌套装饰器

validator函数装饰func1,func1使用时接收参数(*arg, **kwargs),而func1又装饰func2(其实就是rally中的scenario函数),给func2增加validators属性,是一个函数的列表,函数的接收参数config, clients, task。这些函数最终调用func1,传入参数(config, clients, task, *args, **kwargs),所以func1定义时参数是(config, clients, task, *arg, **kwargs)
最终实现的效果是,func2有很多装饰器,每个都会接收自己的参数,做一些校验工作。

代码如下:

def validator(fn):
“””decorator that constructs a scenario validator from given function.
decorated function should return validationresult on error.
:param fn: function that performs validation
:returns: rally scenario validator
“””
def wrap_given(*args, **kwargs):
“””dynamic validation decorator for scenario.
:param args: the arguments of the decorator of the benchmark scenario
ex. @my_decorator(“arg1″), then args = (‘arg1’,)
:param kwargs: the keyword arguments of the decorator of the scenario
ex. @my_decorator(kwarg1=”kwarg1”), then kwargs = {“kwarg1”: “kwarg1”}
“””
def wrap_validator(config, clients, task):
return (fn(config, clients, task, *args, **kwargs) or
validationresult())
def wrap_scenario(scenario):
wrap_validator.permission = getattr(fn, “permission”,
consts.endpointpermission.user)
if not hasattr(scenario, “validators”):
scenario.validators = []
scenario.validators.append(wrap_validator)
return scenario
return wrap_scenario
return wrap_given

inspect库的一些常见用法

inspect.getargspec(func) 获取函数参数的名称和默认值,返回一个四元组(args, varargs, keywords, defaults),其中:
args是参数名称的列表;
varargs和keywords是*号和**号的变量名称;
defaults是参数默认值的列表;

inspect.getcallargs(func[, *args][, **kwds]) 绑定函数参数。返回绑定后函数的入参字典。

python中的私有属性和函数

python把以两个或以上下划线字符开头且没有以两个或以上下划线结尾的变量当作私有变量。私有变量会在代码生成之前被转换为长格式(变为公有),这个过程叫”private name mangling”,如类a里的__private标识符将被转换为_a__private,但当类名全部以下划线命名的时候,python就不再执行轧压。而且,虽然叫私有变量,仍然有可能被访问或修改(使用_classname__membername),所以, 总结如下:

无论是单下划线还是双下划线开头的成员,都是希望外部程序开发者不要直接使用这些成员变量和这些成员函数,只是双下划线从语法上能够更直接的避免错误的使用,但是如果按照_类名__成员名则依然可以访问到。单下划线的在动态调试时可能会方便一些,只要项目组的人都遵守下划线开头的成员不直接使用,那使用单下划线或许会更好。

Posted in 未分类