PYTHONRAISE(如何用pdb进行python调试)

PYTHONRAISE，如何用pdb进行python调试？

本文章讲述了如何用Pdb进行python调试讲解. 当手边没有IDE,面对着python调试犯愁时,你就可以参考下本文;(pdb 命令调试) 和 (pdb)help 用pdb进行python调试,用法基本和gdb差不多, 先看一个简单的例子: epdb1.py .# epdb1.py -- experiment with the Python debugger, pdb a = "aaa" b = "bbb" c = "ccc" final = a + b + c print final 比如要对这个程序进行调试: 1:在文件前面加上这一句,引入调试的模块。 import pdb 2:在要开始调试的一行加上pdb.set_trace()文件变成: # epdb1.py -- experiment with the Python debugger, pdb import pdb a = "aaa" pdb.set_trace() b = "bbb" c = "ccc" final = a + b + c print final 可以运行这个程序,到断点出会停下来,和gdb类似, 可以执行命令: 直接回车是重复前一条命令! p(print) 查看一个变量值 n(next) 下一步 s(step) 单步,可进入函数 c(continue)继续前进 l(list)看源代码用pdb调试有多种方式可选: 1.命令行启动目标程序,加上-m参数,这样调用myscript.py的话断点就是程序的执行第一行之前 python -m pdb myscript.py 2. 在Python交互环境中启用调试 >>> import pdb >>> import mymodule >>> pdb.run('mymodule.test()') 3.比较常用的,就是在程序中间插入一段程序,相对于在一般IDE里面打上断点然后启动debug,不过这种方式是hardcode的 if __name__ == "__main__" : a = 1 importpdb pdb .set_trace() b = 2 c = a + b print( c) 然后正常运行脚本,到了pdb.set_trace()那就会定下来,就可以看到调试的提示符(Pdb)了常用的调试命令 h(elp),会打印当前版本Pdb可用的命令,如果要查询某个命令,可以输入 h [command],例如:"h l" - 查看list命令 l(ist),可以列出当前将要运行的代码块 (Pdb) l 497 pdb.set_trace() 498 base_data = {} 499 new_data = {} 500 try: 501 execfile(base_file_name,{},base_data) 502 -> execfile(new_file_name,{},new_data) 503 except: 504 logger.writeLog("error! load result log error!") 505 print "load cmp logs error!" 506 raise Exception, "load cmp logs error!" 507>断点设置 (Pdb)b10 #断点设置在本py的第10行或(Pdb)bots.py:20 #断点设置到 ots.py第20行删除断点(Pdb)b #查看断点编号 (Pdb)cl 2 #删除第2个断点 >运行 (Pdb)n #单步运行 (Pdb)s #细点运行也就是会下到,方法 (Pdb)c #跳到下个断点 >查看 (Pdb)p param #查看当前变量值 (Pdb)l #查看运行到某处代码 (Pdb)a #查看全部栈内变量 b(reak), 设置断点,例如 "b 77″,就是在当前脚本的77行打上断点,还能输入函数名作为参数,断点就打到具体的函数入口,如果只敲b,会显示现有的全部断点 (Pdb) b 504 Breakpoint 4 at /home/jchen/regression/regressionLogCMP.py:504 condition bpnumber [condition],设置条件断点,下面语句就是对第4个断点加上条件"a==3" (Pdb) condition 4 a==3 (Pdb) b Num Type Disp Enb Where 4 breakpoint keep yes at /home/jchen/regression/regressionLogCMP.py:504 stop only if a==3 cl(ear),如果后面带有参数,就是清除指定的断点(我在Python2.4上从来没成功过!!!);如果不带参数就是清除所有的断点 (Pdb) cl Clear all breaks? y disable/enable,禁用/激活断点 (Pdb) disable 3 (Pdb) b Num Type Disp Enb Where 3 breakpoint keep no at /home/jchen/regression/regressionLogCMP.py:505 n(ext),让程序运行下一行,如果当前语句有一个函数调用,用n是不会进入被调用的函数体中的 s(tep),跟n相似,但是如果当前有一个函数调用,那么s会进入被调用的函数体中 c(ont(inue)),让程序正常运行,直到遇到断点 j(ump),让程序跳转到指定的行数 (Pdb) j 497 > /home/jchen/regression/regressionLogCMP.py(497)com pareLog() -> pdb.set_trace() a(rgs),打印当前函数的参数 (Pdb) a _logger = _base = ./base/MRM-8137.log _new = ./new/MRM-8137.log _caseid = 5550001 _toStepNum = 10 _cmpMap = {'_bcmpbinarylog': 'True', '_bcmpLog': 'True', '_bcmpresp': 'True'} p,最有用的命令之一,打印某个变量 (Pdb) p _new u'./new/MRM-8137.log' !,感叹号后面跟着语句,可以直接改变某个变量 q(uit),退出调试 ============================================================================================== 在python中使用pdb模块可以进行调试 import pdb pdb.set_trace() 也可以使用python -m pdb mysqcript.py这样的方式 (Pdb) 会自动停在第一行，等待调试,这时你可以看看帮助 (Pdb) h 说明下这几个关键命令 >断点设置 (Pdb)b 10 #断点设置在本py的第10行或(Pdb)b ots.py:20 #断点设置到 ots.py第20行删除断点（Pdb）b #查看断点编号 (Pdb)cl 2 #删除第2个断点 >运行 (Pdb)n #单步运行 (Pdb)s #细点运行也就是会下到，方法 (Pdb)c #跳到下个断点 >查看 (Pdb)p param #查看当前变量值 (Pdb)l #查看运行到某处代码 (Pdb)a #查看全部栈内变量 (Pdb)w 列出目前call stack 中的所在层。 (Pdb)d 在call stack中往下移一层 (Pdb)u 在call stack中往上移一层。如果在上移一层之后按下 n ,则会在上移之后的一层执行下一个叙述,之前的 function call 就自动返回。 (Pdb)cl 清除指定的断点。如果没有带参数,则清除所有断点。 (Pdb)disable 取消所有断点的功能,但仍然保留这些断点。 (Pdb)enable 恢复断点的功能。 (Pdb)ignore 设定断点的忽略次数。如果没指定 count,其初始为 0。当 count 为 0 时,断点会正常动作。若有指定 count,则每次执行到该中断, count 就少 1,直到 count 数为 0。 (Pdb)condition bpnumber [condition] (Pdb)j(ump) lineNo. 跳到某行执行。只有在 call stack 的最底部才能作用。 (Pdb)l 列出目前所在档案中的位置。连续地 l 命令会一直列到档案结尾,可以使用指定行数或范围来打印。 (Pdb)pp 和 p 命令类似,但是使用 pprint module(没用过 pprint,详情请参考 Python Library Reference)。 (Pdb)alias 以一个"别名"代替"一群除错命令",有点类似 c/c 的 macro(详情请参考 Python Library Reference)。 (Pdb)unalias 取消某个 alias。 (Pdb)[!]statement 在目前的环境(context)中执行叙述。转载

false为什么不是python语言的保留字？

在python中，`False`是一个布尔类型的常量，表示逻辑上的假。虽然`False`在Python中是一个关键字，但它不是Python语言的保留字。

保留字是指编程语言中被保留用于特定目的的单词或符号，不能用作标识符或变量名。在Python中，保留字包括`and`、`as`、`assert`、`break`、`class`、`continue`、`def`、`del`、`elif`、`else`、`except`、`finally`、`for`、`from`、`global`、`if`、`import`、`in`、`is`、`lambda`、`nonlocal`、`not`、`or`、`pass`、`raise`、`return`、`try`、`while`、`with`和`yield`。

虽然`False`是Python中的关键字，但它不是保留字，因为它可以被重新定义为变量名。例如，您可以将`False`重新定义为一个变量名，如下所示：

```python

False = 0

```

这样做虽然不推荐，但是在某些情况下可能是有用的。因此，Python将`False`作为关键字而不是保留字。

raise干什么的？

有异常了可以用rasie决定异常了该做什么

不过即使没有异常也可以raise来定义满足特定条件后抛弃什么异常

try:

count[t]+=1

except KeyError:

count[t]=1

if count[t]>1:

raise forms.ValidationError("tag '%s' 重复出现了%s次"%(str(t),str(count[t])))

Python有什么奇技淫巧？

Python奇技淫巧

当发布python第三方package时, 并不希望代码中所有的函数或者class可以被外部import, 在 __init__.py 中添加 __all__ 属性,

该list中填写可以import的类或者函数名, 可以起到限制的import的作用, 防止外部import其他函数或者类

#!/usr/bin/env python

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

frombaseimportAPIBase

fromclientimportClient

fromdecoratorimportinterface, export, stream

fromserverimportServer

fromstorageimportStorage

fromutilimport(LogFormatter, disable_logging_to_stderr,

enable_logging_to_kids, info)

__all__ = ['APIBase','Client','LogFormatter','Server',

'Storage','disable_logging_to_stderr','enable_logging_to_kids',

'export','info','interface','stream']

with的魔力

with语句需要支持上下文管理协议的对象 , 上下文管理协议包含 __enter__ 和 __exit__ 两个方法. with语句建立运行时上下文需要通过这两个方法执行进入和退出操作.

其中上下文表达式是跟在with之后的表达式, 该表示大返回一个上下文管理对象

# 常见with使用场景

withopen("test.txt","r")asmy_file:# 注意, 是__enter__()方法的返回值赋值给了my_file,

forlineinmy_file:

print line

详细原理可以查看这篇文章, 浅谈 Python 的 with 语句

知道具体原理, 我们可以自定义支持上下文管理协议的类, 类中实现 __enter__ 和 __exit__ 方法

#!/usr/bin/env python

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

classMyWith(object):

def__init__(self):

print"__init__ method"

def__enter__(self):

print"__enter__ method"

returnself# 返回对象给as后的变量

def__exit__(self, exc_type, exc_value, exc_traceback):

print"__exit__ method"

ifexc_tracebackisNone:

print"Exited without Exception"

returnTrue

else:

print"Exited with Exception"

returnFalse

deftest_with():

withMyWith()asmy_with:

print"running my_with"

print"------分割线-----"

withMyWith()asmy_with:

print"running before Exception"

raiseException

print"running after Exception"

if__name__ =='__main__':

test_with()

执行结果如下:

__init__ method

__enter__ method

running my_with

__exit__ method

ExitedwithoutException

------分割线-----

__init__ method

__enter__ method

running before Exception

__exit__ method

ExitedwithException

Traceback(most recent call last):

File"bin/python", line34,in

exec(compile(__file__f.read(), __file__, "exec"))

File"test_with.py", line33,in

test_with()

File"test_with.py", line28,intest_with

raiseException

Exception

证明了会先执行 __enter__ 方法, 然后调用with内的逻辑, 最后执行 __exit__ 做退出处理, 并且, 即使出现异常也能正常退出

filter的用法

相对 filter 而言, map和reduce使用的会更频繁一些, filter 正如其名字, 按照某种规则过滤掉一些元素

#!/usr/bin/env python

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

lst = [1,2,3,4,5,6]

# 所有奇数都会返回True, 偶数会返回False被过滤掉

print filter(lambda x: x % 2!=0, lst)

#输出结果

[1,3,5]

一行作判断

当条件满足时, 返回的为等号后面的变量, 否则返回else后语句

lst = [1,2,3]

new_lst = lst[0]iflstisnotNoneelseNone

printnew_lst

# 打印结果

装饰器之单例

使用装饰器实现简单的单例模式

# 单例装饰器

defsingleton(cls):

instances = dict() # 初始为空

def_singleton(*args, **kwargs):

ifclsnotininstances:#如果不存在, 则创建并放入字典

instances[cls] = cls(*args, **kwargs)

returninstances[cls]

return_singleton

@singleton

classTest(object):

pass

if__name__ =='__main__':

t1 = Test()

t2 = Test()

# 两者具有相同的地址

printt1, t2

staticmethod装饰器

类中两种常用的装饰, 首先区分一下他们

普通成员函数, 其中第一个隐式参数为对象

classmethod装饰器 , 类方法(给人感觉非常类似于OC中的类方法), 其中第一个隐式参数为类

staticmethod装饰器 , 没有任何隐式参数. python中的静态方法类似与C++中的静态方法

#!/usr/bin/env python

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

classA(object):

# 普通成员函数

deffoo(self, x):

print "executing foo(%s, %s)"% (self, x)

@classmethod# 使用classmethod进行装饰

defclass_foo(cls, x):

print "executing class_foo(%s, %s)"% (cls, x)

@staticmethod# 使用staticmethod进行装饰

defstatic_foo(x):

print "executing static_foo(%s)"% x

deftest_three_method():

obj = A()

# 直接调用噗通的成员方法

obj.foo("para")# 此处obj对象作为成员函数的隐式参数, 就是self

obj.class_foo("para")# 此处类作为隐式参数被传入, 就是cls

A.class_foo("para")#更直接的类方法调用

obj.static_foo("para")# 静态方法并没有任何隐式参数, 但是要通过对象或者类进行调用

A.static_foo("para")

if__name__=='__main__':

test_three_method()

# 函数输出

executing foo(

executing class_foo(

executing static_foo(para)

property装饰器

定义私有类属性

将 property 与装饰器结合实现属性私有化( 更简单安全的实现get和set方法 )

#python内建函数

property(fget=None, fset=None, fdel=None, doc=None)

fget 是获取属性的值的函数, fset 是设置属性值的函数, fdel 是删除属性的函数, doc 是一个字符串(like a comment).从实现来看，这些参数都是可选的

property有三个方法 getter() , setter() 和 delete() 来指定fget, fset和fdel。这表示以下这行

classStudent(object):

@property #相当于property.getter(score) 或者property(score)

defscore(self):

returnself._score

@score.setter #相当于score = property.setter(score)

defscore(self, value):

ifnotisinstance(value, int):

raiseValueError('score must be an integer!')

ifvalue 100:

raiseValueError('score must between 0 ~ 100!')

self._score = value

iter魔法

通过yield和 __iter__ 的结合, 我们可以把一个对象变成可迭代的

通过 __str__ 的重写, 可以直接通过想要的形式打印对象

#!/usr/bin/env python

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

classTestIter(object):

def__init__(self):

self.lst = [1,2,3,4,5]

defread(self):

foreleinxrange(len(self.lst)):

yieldele

def__iter__(self):

returnself.read()

def__str__(self):

return','.join(map(str, self.lst))

__repr__ = __str__

deftest_iter():

obj = TestIter()

fornuminobj:

printnum

printobj

if__name__ =='__main__':

test_iter()

神奇partial

partial使用上很像C++中仿函数(函数对象).

在stackoverflow给出了类似与partial的运行方式

defpartial(func, *part_args):

defwrapper(*extra_args):

args = list(part_args)

args.extend(extra_args)

returnfunc(*args)

returnwrapper

利用用闭包的特性绑定预先绑定一些函数参数, 返回一个可调用的变量, 直到真正的调用执行

#!/usr/bin/env python

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

fromfunctoolsimportpartial

defsum(a, b):

returna + b

deftest_partial():

fun = partial(sum, 2)# 事先绑定一个参数, fun成为一个只需要一个参数的可调用变量

printfun(3)# 实现执行的即是sum(2, 3)

if__name__ =='__main__':

test_partial()

# 执行结果

神秘eval

eval我理解为一种内嵌的python解释器(这种解释可能会有偏差), 会解释字符串为对应的代码并执行, 并且将执行结果返回

看一下下面这个例子

#!/usr/bin/env python

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

deftest_first():

return3

deftest_second(num):

returnnum

action = { # 可以看做是一个sandbox

"para":5,

"test_first": test_first,

"test_second": test_second

}

deftest_eavl():

condition = "para == 5 and test_second(test_first) > 5"

res = eval(condition, action) # 解释condition并根据action对应的动作执行

printres

if__name__ =='_

exec

exec在Python中会忽略返回值, 总是返回None, eval会返回执行代码或语句的返回值

exec 和 eval 在执行代码时, 除了返回值其他行为都相同

在传入字符串时, 会使用 compile(source, '

#!/usr/bin/env python

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

deftest_first():

print"hello"

deftest_second():

test_first()

print"second"

deftest_third():

print"third"

action = {

"test_second": test_second,

"test_third": test_third

}

deftest_exec():

exec"test_second"inaction

if__name__ =='__main__':

test_exec() # 无法看到执行结果

getattr

getattr(object, name[, default]) Return the value of

the named attribute of object. name must be a string. If the string is

the name of one of the object’s attributes, the result is the value of

that attribute. For example, getattr(x, ‘foobar’) is equivalent to

x.foobar. If the named attribute does not exist, default is returned if

provided, otherwise AttributeError is raised.

通过string类型的name, 返回对象的name属性(方法)对应的值, 如果属性不存在, 则返回默认值, 相当于object.name

# 使用范例

classTestGetAttr(object):

test = "test attribute"

defsay(self):

print"test method"

deftest_getattr():

my_test = TestGetAttr()

try:

printgetattr(my_test,"test")

exceptAttributeError:

print"Attribute Error!"

try:

getattr(my_test, "say")()

exceptAttributeError:# 没有该属性, 且没有指定返回值的情况下

print"Method Error!"

if__name__ =='__main__':

test_getattr()

# 输出结果

test attribute

test method

命令行处理

defprocess_command_line(argv):

"""

Return a 2-tuple: (settings object, args list).

`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.

"""

ifargvisNone:

argv = sys.argv[1:]

# initialize the parser object:

parser = optparse.OptionParser(

formatter=optparse.TitledHelpFormatter(width=78),

add_help_option=None)

# define options here:

parser.add_option( # customized description; put --help last

'-h','--help', action='help',

help='Show this help message and exit.')

settings, args = parser.parse_args(argv)

# check number of arguments, verify values, etc.:

ifargs:

parser.error('program takes no command-line arguments; '

'"%s" ignored.'% (args,))

# further process settings & args if necessary

returnsettings, args

defmain(argv=None):

settings, args = process_command_line(argv)

# application code here, like:

# run(settings, args)

return0# success

if__name__ =='__main__':

status = main()

sys.exit(status)

读写csv文件

# 从csv中读取文件, 基本和传统文件读取类似

importcsv

withopen('data.csv','rb')asf:

reader = csv.reader(f)

forrowinreader:

printrow

# 向csv文件写入

importcsv

withopen('data.csv','wb')asf:

writer = csv.writer(f)

writer.writerow(['name','address','age'])# 单行写入

data = [

( 'xiaoming ','china','10'),

( 'Lily','USA','12')]

writer.writerows(data) # 多行写入

各种时间形式转换

只发一张网上的图, 然后差文档就好了, 这个是记不住的

字符串格式化

一个非常好用, 很多人又不知道的功能

>>>name ="andrew"

>>>"my name is {name}".format(name=name)

'my name is andrew'

python中如何理解装饰器代码？

先分解一下楼主提出的问题：

如何理解return一个函数，它与return一个值得用法区别在哪？在wrapper函数中，为什么能返回一个在wrapper函数中没有定义的func函数？

在简单概括一下这两个问题涉及到的Python 知识点：

问题1：Python的函数对象，函数可以被赋值，函数可以作为参数传递，函数可以作为返回值。

问题2：Python 的闭包

接下来，我们根据实例，逐一的介绍一下：

函数对象

Python一切皆对象，函数这一语法结构也是一个对象。函数被称为第一类对象，函数可以被当做数据传递。在函数对象中，我们像使用一个普通对象一样使用函数对象，比如更改函数对象的名字，或者将函数对象作为参数进行传递。

函数可以被赋值

执行上述代码，输出如下，请留意代码中的注释信息。

函数可以作为参数传递

执行上述代码，输出如下，请留意代码中的注释信息。

函数可以作为返回值

如上示例中，当函数（不带括号）作为返回值时，返回的是函数的内存地址，代码执行顺序及结果，如下：

与上面代码不同的是，接下来我们尝试一下让fun_b返回 return fun()，多了一个括号，代码如下：

当执行 return fun() 时，实际上是先调用fun_a函数，再将fun_a的返回结果作为fun_c的返回，运行代码，结果如下：

闭包

定义：在计算机科学中，闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。

结合上面例子，一个闭包可以简单理解为调用了一个函数fun_a，这个函数fun_a返回了一个函数fun_b。这个返回的函数fun_b就叫做闭包。在调用函数fun_a的时候传递的参数a、c就是自由变量。

上面例子中，函数 fun_b 与环境变量 a,c 构成闭包。在创建闭包的时候，我们通过fun_a 的参数 a，c明确这两个环境变量的取值，因此确定了函数的最终形式(y = 2b + 10)。我们只需要变换参数a，b就可以获得不同的直线表达函数。由此，我们可以看到，闭包的引入提高代码了代码的可复用性，更加简洁。执行代码，输出结果如下：

修饰器

顾名思义，从字面意思可以理解为，它是用来"装饰"Python的工具，使得代码更具有Python简洁的风格。装饰器本质上是Python函数，能够实现让其他函数在不需要做任何代码变动的前提下增加额外功能。

可以看出，fun_a(fun_b)的执行过程如下：

执行函数fun_a，将fun_b当作参数传进去，fun_b()本身也是对象。执行print (fun()) 代码时，先执行了 fun_b()，然后打印'Run Function B' , 返回 2019-06-11 21:17:27 。print(fun()) 打印了fun_b()的返回结果 2019-06-11 21:17:27 。

使用修饰器进行改造，如下：

执行fun_b相当于 fun_b = fun_a(fun_b) ，只是在定义fun_b时，在其前使用@fun_a 进行修饰。

再引入闭包进行改造，如下：

在fun_a内部的函数retry()，是如何获取fun这个参数来执行的？执行fun_a函数return的是retry这个函数，而retry并没有接受fun这个传参。这就是Python里的闭包的概念，闭包就是指运行时自带上下文（自由变量）的函数，如这里的retry函数，他运行的时候自带了上层函数fun_a传给他的fun这个参数，所以才可以在运行时对fun进行处理和输出。

修饰器实现重试机制

简单的重试机制实现

复杂的重试机制实现

支持重试次数和等待时间，如下：

进一步深入了解修饰器，可以阅读这篇文章：

https://www.toutiao.com/i6731320536732795405/