Python裝飾器例項：呼叫引數合法性驗證

發表於2015-09-16

python是不帶靜態檢查的動態語言，有時候需要在呼叫函式時保證引數合法。檢查引數合法性是一個顯著的切面場景，各個函式都可能有這個需求。但另一方面，引數合法性是不是應該由呼叫方來保證比較好也是一個需要結合實際才能回答的問題，總之雙方約定好，不要都不檢查或者都檢查就可以了。下面這個模組用於在函式上使用裝飾器進行引數的合法性驗證。

你可以直接執行這個模組進行測試，如果完全沒有輸出則表示通過。你也可以找到幾個以_test開頭的函式，所有的測試用例都包含在這幾個函式中。使用方法參見模組文件和測試用例。

# -*- coding: UTF-8 -*-

'''
@summary: 驗證器
該模組提供了一個裝飾器用於驗證引數是否合法，使用方法為：

from validator import validParam, nullOk, multiType

@validParam(i=int)
def foo(i):
    return i+1

編寫驗證器：

1. 僅驗證型別：
@validParam(type, ...)
例如：
檢查第一個位置的引數是否為int型別：
@validParam(int)
檢查名為x的引數是否為int型別：
@validParam(x=int)

驗證多個引數：
@validParam(int, int)
指定引數名驗證：
@validParam(int, s=str)

針對*和**引數編寫的驗證器將驗證這些引數實際包含的每個元素：
@validParam(varargs=int)
def foo(*varargs): pass

@validParam(kws=int)
def foo7(s, **kws): pass

2. 帶有條件的驗證：
@validParam((type, condition), ...)
其中，condition是一個表示式字串，使用x引用待驗證的物件；
根據bool(表示式的值)判斷是否通過驗證，若計算表示式時丟擲異常，視為失敗。
例如：
驗證一個10到20之間的整數：
@validParam(i=(int, '10<x<20'))
驗證一個長度小於20的字串：
@validParam(s=(str, 'len(x)<20'))
驗證一個年齡小於20的學生：
@validParam(stu=(Student, 'x.age<20'))

另外，如果型別是字串，condition還可以使用斜槓開頭和結尾表示正規表示式匹配。
驗證一個由數字組成的字串：
@validParam(s=(str, '/^\d*$/'))

3. 以上驗證方式預設為當值是None時驗證失敗。如果None是合法的引數，可以使用nullOk()。
nullOk()接受一個驗證條件作為引數。
例如：
@validParam(i=nullOk(int))
@validParam(i=nullOk((int, '10<x<20')))
也可以簡寫為：
@validParam(i=nullOk(int, '10<x<20'))

4. 如果引數有多個合法的型別，可以使用multiType()。
multiType()可接受多個引數，每個引數都是一個驗證條件。
例如：
@validParam(s=multiType(int, str))
@validParam(s=multiType((int, 'x>20'), nullOk(str, '/^\d+$/')))

5. 如果有更復雜的驗證需求，還可以編寫一個函式作為驗證函式傳入。
這個函式接收待驗證的物件作為引數，根據bool(返回值)判斷是否通過驗證，丟擲異常視為失敗。
例如：
def validFunction(x):
    return isinstance(x, int) and x>0
@validParam(i=validFunction)
def foo(i): pass

這個驗證函式等價於：
@validParam(i=(int, 'x>0'))
def foo(i): pass

@author: HUXI
@since: 2011-3-22
@change: 
'''

import inspect
import re

class ValidateException(Exception): pass

def validParam(*varargs, **keywords):
    '''驗證引數的裝飾器。'''

    varargs = map(_toStardardCondition, varargs)
    keywords = dict((k, _toStardardCondition(keywords[k]))
                    for k in keywords)

    def generator(func):
        args, varargname, kwname = inspect.getargspec(func)[:3]
        dctValidator = _getcallargs(args, varargname, kwname,
                                    varargs, keywords)

        def wrapper(*callvarargs, **callkeywords):
            dctCallArgs = _getcallargs(args, varargname, kwname,
                                       callvarargs, callkeywords)

            k, item = None, None
            try:
                for k in dctValidator:
                    if k == varargname:
                        for item in dctCallArgs[k]:
                            assert dctValidator[k](item)
                    elif k == kwname:
                        for item in dctCallArgs[k].values():
                            assert dctValidator[k](item)
                    else:
                        item = dctCallArgs[k]
                        assert dctValidator[k](item)
            except:
                raise ValidateException,\
                       ('%s() parameter validation fails, param: %s, value: %s(%s)'
                       % (func.func_name, k, item, item.__class__.__name__))

            return func(*callvarargs, **callkeywords)

        wrapper = _wrapps(wrapper, func)
        return wrapper

    return generator

def _toStardardCondition(condition):
    '''將各種格式的檢查條件轉換為檢查函式'''

    if inspect.isclass(condition):
        return lambda x: isinstance(x, condition)

    if isinstance(condition, (tuple, list)):
        cls, condition = condition[:2]
        if condition is None:
            return _toStardardCondition(cls)

        if cls in (str, unicode) and condition[0] == condition[-1] == '/':
            return lambda x: (isinstance(x, cls)
                              and re.match(condition[1:-1], x) is not None)

        return lambda x: isinstance(x, cls) and eval(condition)

    return condition

def nullOk(cls, condition=None):
    '''這個函式指定的檢查條件可以接受None值'''

    return lambda x: x is None or _toStardardCondition((cls, condition))(x)

def multiType(*conditions):
    '''這個函式指定的檢查條件只需要有一個通過'''

    lstValidator = map(_toStardardCondition, conditions)
    def validate(x):
        for v in lstValidator:
            if v(x):
                return True
    return validate

def _getcallargs(args, varargname, kwname, varargs, keywords):
    '''獲取呼叫時的各引數名-值的字典'''

    dctArgs = {}
    varargs = tuple(varargs)
    keywords = dict(keywords)

    argcount = len(args)
    varcount = len(varargs)
    callvarargs = None

    if argcount <= varcount:
        for n, argname in enumerate(args):
            dctArgs[argname] = varargs[n]

        callvarargs = varargs[-(varcount-argcount):]

    else:
        for n, var in enumerate(varargs):
            dctArgs[args[n]] = var

        for argname in args[-(argcount-varcount):]:
            if argname in keywords:
                dctArgs[argname] = keywords.pop(argname)

        callvarargs = ()

    if varargname is not None:
        dctArgs[varargname] = callvarargs

    if kwname is not None:
        dctArgs[kwname] = keywords

    dctArgs.update(keywords)
    return dctArgs

def _wrapps(wrapper, wrapped):
    '''複製後設資料'''

    for attr in ('__module__', '__name__', '__doc__'):
        setattr(wrapper, attr, getattr(wrapped, attr))
    for attr in ('__dict__',):
        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))

    return wrapper

#===============================================================================
# 測試
#===============================================================================

def _unittest(func, *cases):
    for case in cases:
        _functest(func, *case)

def _functest(func, isCkPass, *args, **kws):
    if isCkPass:
        func(*args, **kws)
    else:
        try:
            func(*args, **kws)
            assert False
        except ValidateException:
            pass

def _test1_simple():
    #檢查第一個位置的引數是否為int型別：
    @validParam(int)
    def foo1(i): pass
    _unittest(foo1, 
              (True, 1), 
              (False, 's'), 
              (False, None))

    #檢查名為x的引數是否為int型別：
    @validParam(x=int)
    def foo2(s, x): pass
    _unittest(foo2, 
              (True, 1, 2), 
              (False, 's', 's'))

    #驗證多個引數：
    @validParam(int, int)
    def foo3(s, x): pass
    _unittest(foo3, 
              (True, 1, 2), 
              (False, 's', 2))

    #指定引數名驗證：
    @validParam(int, s=str)
    def foo4(i, s): pass
    _unittest(foo4, 
              (True, 1, 'a'), 
              (False, 's', 1))

    #針對*和**引數編寫的驗證器將驗證這些引數包含的每個元素：
    @validParam(varargs=int)
    def foo5(*varargs): pass
    _unittest(foo5,
              (True, 1, 2, 3, 4, 5),
              (False, 'a', 1))

    @validParam(kws=int)
    def foo6(**kws): pass
    _functest(foo6, True, a=1, b=2)
    _functest(foo6, False, a='a', b=2)

    @validParam(kws=int)
    def foo7(s, **kws): pass
    _functest(foo7, True, s='a', a=1, b=2)

def _test2_condition():
    #驗證一個10到20之間的整數：
    @validParam(i=(int, '10<x<20'))
    def foo1(x, i): pass
    _unittest(foo1, 
              (True, 1, 11), 
              (False, 1, 'a'), 
              (False, 1, 1))

    #驗證一個長度小於20的字串：
    @validParam(s=(str, 'len(x)<20'))
    def foo2(a, s): pass
    _unittest(foo2, 
              (True, 1, 'a'), 
              (False, 1, 1), 
              (False, 1, 'a'*20))

    #驗證一個年齡小於20的學生：
    class Student(object):
        def __init__(self, age): self.age=age

    @validParam(stu=(Student, 'x.age<20'))
    def foo3(stu): pass
    _unittest(foo3, 
              (True, Student(18)), 
              (False, 1), 
              (False, Student(20)))

    #驗證一個由數字組成的字串：
    @validParam(s=(str, r'/^\d*$/'))
    def foo4(s): pass
    _unittest(foo4, 
              (True, '1234'), 
              (False, 1), 
              (False, 'a1234'))

def _test3_nullok():
    @validParam(i=nullOk(int))
    def foo1(i): pass
    _unittest(foo1, 
              (True, 1), 
              (False, 'a'), 
              (True, None))

    @validParam(i=nullOk(int, '10<x<20'))
    def foo2(i): pass
    _unittest(foo2, 
              (True, 11), 
              (False, 'a'), 
              (True, None), 
              (False, 1))

def _test4_multitype():
    @validParam(s=multiType(int, str))
    def foo1(s): pass
    _unittest(foo1, 
              (True, 1),
              (True, 'a'),
              (False, None),
              (False, 1.1))

    @validParam(s=multiType((int, 'x>20'), nullOk(str, '/^\d+$/')))
    def foo2(s): pass
    _unittest(foo2, 
              (False, 1),
              (False, 'a'),
              (True, None),
              (False, 1.1),
              (True, 21),
              (True, '21'))

def _main():
    d = globals()
    from types import FunctionType
    print
    for f in d:
        if f.startswith('_test'):
            f = d[f]
            if isinstance(f, FunctionType):
                f()

if __name__ == '__main__':
    _main()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

# -*- coding: UTF-8 -*-

'''

@summary: 驗證器

該模組提供了一個裝飾器用於驗證引數是否合法，使用方法為：

from validator import validParam, nullOk, multiType

@validParam(i=int)

def foo(i):

return i+1

編寫驗證器：

1. 僅驗證型別：

@validParam(type, ...)

例如：

檢查第一個位置的引數是否為int型別：

@validParam(int)

檢查名為x的引數是否為int型別：

@validParam(x=int)

驗證多個引數：

@validParam(int, int)

指定引數名驗證：

@validParam(int, s=str)

針對*和**引數編寫的驗證器將驗證這些引數實際包含的每個元素：

@validParam(varargs=int)

def foo(*varargs): pass

@validParam(kws=int)

def foo7(s, **kws): pass

2. 帶有條件的驗證：

@validParam((type, condition), ...)

其中，condition是一個表示式字串，使用x引用待驗證的物件；

根據bool(表示式的值)判斷是否通過驗證，若計算表示式時丟擲異常，視為失敗。

例如：

驗證一個10到20之間的整數：

@validParam(i=(int, '10<x<20'))

驗證一個長度小於20的字串：

@validParam(s=(str, 'len(x)<20'))

驗證一個年齡小於20的學生：

@validParam(stu=(Student, 'x.age<20'))

另外，如果型別是字串，condition還可以使用斜槓開頭和結尾表示正規表示式匹配。

驗證一個由數字組成的字串：

@validParam(s=(str, '/^\d*$/'))

3. 以上驗證方式預設為當值是None時驗證失敗。如果None是合法的引數，可以使用nullOk()。

nullOk()接受一個驗證條件作為引數。

例如：

@validParam(i=nullOk(int))

@validParam(i=nullOk((int, '10<x<20')))

也可以簡寫為：

@validParam(i=nullOk(int, '10<x<20'))

4. 如果引數有多個合法的型別，可以使用multiType()。

multiType()可接受多個引數，每個引數都是一個驗證條件。

例如：

@validParam(s=multiType(int, str))

@validParam(s=multiType((int, 'x>20'), nullOk(str, '/^\d+$/')))

5. 如果有更復雜的驗證需求，還可以編寫一個函式作為驗證函式傳入。

這個函式接收待驗證的物件作為引數，根據bool(返回值)判斷是否通過驗證，丟擲異常視為失敗。

例如：

def validFunction(x):

return isinstance(x, int) and x>0

@validParam(i=validFunction)

def foo(i): pass

這個驗證函式等價於：

@validParam(i=(int, 'x>0'))

def foo(i): pass

@author: HUXI

@since: 2011-3-22

@change:

'''

import inspect

import re

class ValidateException(Exception): pass

def validParam(*varargs, **keywords):

'''驗證引數的裝飾器。'''

varargs = map(_toStardardCondition, varargs)

keywords = dict((k, _toStardardCondition(keywords[k]))

for k in keywords)

def generator(func):

args, varargname, kwname = inspect.getargspec(func)[:3]

dctValidator = _getcallargs(args, varargname, kwname,

varargs, keywords)

def wrapper(*callvarargs, **callkeywords):

dctCallArgs = _getcallargs(args, varargname, kwname,

callvarargs, callkeywords)

k, item = None, None

try:

for k in dctValidator:

if k == varargname:

for item in dctCallArgs[k]:

assert dctValidator[k](item)

elif k == kwname:

for item in dctCallArgs[k].values():

assert dctValidator[k](item)

else:

item = dctCallArgs[k]

assert dctValidator[k](item)

except:

raise ValidateException,\

('%s() parameter validation fails, param: %s, value: %s(%s)'

% (func.func_name, k, item, item.__class__.__name__))

return func(*callvarargs, **callkeywords)

wrapper = _wrapps(wrapper, func)

return wrapper

return generator

def _toStardardCondition(condition):

'''將各種格式的檢查條件轉換為檢查函式'''

if inspect.isclass(condition):

return lambda x: isinstance(x, condition)

if isinstance(condition, (tuple, list)):

cls, condition = condition[:2]

if condition is None:

return _toStardardCondition(cls)

if cls in (str, unicode) and condition[0] == condition[-1] == '/':

return lambda x: (isinstance(x, cls)

and re.match(condition[1:-1], x) is not None)

return lambda x: isinstance(x, cls) and eval(condition)

return condition

def nullOk(cls, condition=None):

'''這個函式指定的檢查條件可以接受None值'''

return lambda x: x is None or _toStardardCondition((cls, condition))(x)

def multiType(*conditions):

'''這個函式指定的檢查條件只需要有一個通過'''

lstValidator = map(_toStardardCondition, conditions)

def validate(x):

for v in lstValidator:

if v(x):

return True

return validate

def _getcallargs(args, varargname, kwname, varargs, keywords):

'''獲取呼叫時的各引數名-值的字典'''

dctArgs = {}

varargs = tuple(varargs)

keywords = dict(keywords)

argcount = len(args)

varcount = len(varargs)

callvarargs = None

if argcount <= varcount:

for n, argname in enumerate(args):

dctArgs[argname] = varargs[n]

callvarargs = varargs[-(varcount-argcount):]

else:

for n, var in enumerate(varargs):

dctArgs[args[n]] = var

for argname in args[-(argcount-varcount):]:

if argname in keywords:

dctArgs[argname] = keywords.pop(argname)

callvarargs = ()

if varargname is not None:

dctArgs[varargname] = callvarargs

if kwname is not None:

dctArgs[kwname] = keywords

dctArgs.update(keywords)

return dctArgs

def _wrapps(wrapper, wrapped):

'''複製後設資料'''

for attr in ('__module__', '__name__', '__doc__'):

setattr(wrapper, attr, getattr(wrapped, attr))

for attr in ('__dict__',):

getattr(wrapper, attr).update(getattr(wrapped, attr, {}))

return wrapper

#===============================================================================

# 測試

#===============================================================================

def _unittest(func, *cases):

for case in cases:

_functest(func, *case)

def _functest(func, isCkPass, *args, **kws):

if isCkPass:

func(*args, **kws)

else:

try:

func(*args, **kws)

assert False

except ValidateException:

pass

def _test1_simple():

#檢查第一個位置的引數是否為int型別：

@validParam(int)

def foo1(i): pass

_unittest(foo1,

(True, 1),

(False, 's'),

(False, None))

#檢查名為x的引數是否為int型別：

@validParam(x=int)

def foo2(s, x): pass

_unittest(foo2,

(True, 1, 2),

(False, 's', 's'))

#驗證多個引數：

@validParam(int, int)

def foo3(s, x): pass

_unittest(foo3,

(True, 1, 2),

(False, 's', 2))

#指定引數名驗證：

@validParam(int, s=str)

def foo4(i, s): pass

_unittest(foo4,

(True, 1, 'a'),

(False, 's', 1))

#針對*和**引數編寫的驗證器將驗證這些引數包含的每個元素：

@validParam(varargs=int)

def foo5(*varargs): pass

_unittest(foo5,

(True, 1, 2, 3, 4, 5),

(False, 'a', 1))

@validParam(kws=int)

def foo6(**kws): pass

_functest(foo6, True, a=1, b=2)

_functest(foo6, False, a='a', b=2)

@validParam(kws=int)

def foo7(s, **kws): pass

_functest(foo7, True, s='a', a=1, b=2)

def _test2_condition():

#驗證一個10到20之間的整數：

@validParam(i=(int, '10<x<20'))

def foo1(x, i): pass

_unittest(foo1,

(True, 1, 11),

(False, 1, 'a'),

(False, 1, 1))

#驗證一個長度小於20的字串：

@validParam(s=(str, 'len(x)<20'))

def foo2(a, s): pass

_unittest(foo2,

(True, 1, 'a'),

(False, 1, 1),

(False, 1, 'a'*20))

#驗證一個年齡小於20的學生：

class Student(object):

def __init__(self, age): self.age=age

@validParam(stu=(Student, 'x.age<20'))

def foo3(stu): pass

_unittest(foo3,

(True, Student(18)),

(False, 1),

(False, Student(20)))

#驗證一個由數字組成的字串：

@validParam(s=(str, r'/^\d*$/'))

def foo4(s): pass

_unittest(foo4,

(True, '1234'),

(False, 1),

(False, 'a1234'))

def _test3_nullok():

@validParam(i=nullOk(int))

def foo1(i): pass

_unittest(foo1,

(True, 1),

(False, 'a'),

(True, None))

@validParam(i=nullOk(int, '10<x<20'))

def foo2(i): pass

_unittest(foo2,

(True, 11),

(False, 'a'),

(True, None),

(False, 1))

def _test4_multitype():

@validParam(s=multiType(int, str))

def foo1(s): pass

_unittest(foo1,

(True, 1),

(True, 'a'),

(False, None),

(False, 1.1))

@validParam(s=multiType((int, 'x>20'), nullOk(str, '/^\d+$/')))

def foo2(s): pass

_unittest(foo2,

(False, 1),

(False, 'a'),

(True, None),

(False, 1.1),

(True, 21),

(True, '21'))

def _main():

d = globals()

from types import FunctionType

for f in d:

if f.startswith('_test'):

f = d[f]

if isinstance(f, FunctionType):

f()

if __name__ == '__main__':

_main()

Python裝飾器例項講解(三)
2023-02-16
Python
python - 驗證身份證合法性
2024-11-24
Python
裝飾器與後設資料反射（3）引數裝飾器
2019-02-16
反射
裝飾模式-使用裝飾器來寫表單驗證外掛
2019-02-16
模式
python裝飾器2：類裝飾器
2019-01-01
Python
Python 裝飾器
2019-06-24
Python
Python裝飾器
2021-02-15
Python
身份證合法性校驗
2020-12-12
可變引數例項
2024-08-17
帶引數的 Python 裝飾器讓你的程式碼更優雅
2024-11-10
Python
1.5.3 Python裝飾器
2019-01-19
Python
Python 裝飾器（一）
2018-09-27
Python
python的裝飾器
2018-08-18
Python
Python 裝飾器原理
2023-02-06
Python
Python裝飾器模式
2022-05-13
Python模式
用裝飾器封裝Flask-WTF表單驗證邏輯
2019-02-20
封裝Flask
python呼叫方法必須例項化麼
2021-09-11
Python
Python深入05 裝飾器
2019-11-29
Python
python 之裝飾器（decorator）
2019-12-17
Python
Python中的裝飾器
2022-03-26
Python
Python裝飾器詳解
2020-12-02
Python
JavaScript 表單驗證程式碼例項
2019-03-26
JavaScript
appium+python+android，如何驗證 RecyclerView 子項數量？
2020-07-21
APPPythonAndroidView
JS校驗身份證號的合法性
2019-02-22
JS
keycloak~使用jwks驗證token的合法性
2024-04-23
.net core 驗證 Options 引數
2019-01-16
gin json binding 引數驗證
2024-10-29
JSON
python裝飾器入門探究
2019-03-01
Python
python 裝飾器 part2
2019-02-16
Python
day11(python)裝飾器
2018-10-22
Python
python中裝飾器的原理
2018-11-02
Python
Python裝飾器高階用法
2019-02-24
Python
python 裝飾器小白學習
2018-05-28
Python
【python】閉包與裝飾器
2018-05-24
Python
Python裝飾器的前世今生
2018-05-28
Python
python的裝飾器@的用法
2024-05-05
Python
Python深入分享之裝飾器
2023-11-23
Python
Python 語法之裝飾器
2019-12-19
Python
Python3 裝飾器解析
2020-07-18
Python

Python裝飾器例項：呼叫引數合法性驗證

相關文章