integer division or modulo by zero（关于Python中的一段为Python脚本添加行号脚本）

本文目录

• 关于Python中的一段为Python脚本添加行号脚本
• python Process finished with exit code 1
• Python 为什么不能捕获如下的除零异常
• 我执行一段python脚本报错了，怎么解决
• python出错，请问是什么问题
• 在python中用try except能输出哪行报错吗

关于Python中的一段为Python脚本添加行号脚本

C语言有__LINE__来表示源代码的当前行号，经常在记录日志时使用。Python如何获取源代码的当前行号？
The C Language has the __LINE__ macro, which is wildly used in logging, presenting the current line of the source file. And how to get the current line of a Python source file?
exception输出的函数调用栈就是个典型的应用：
A typical example is the output of function call stack when an exception:
python代码
File "D:\workspace\Python\src\lang\lineno.py", line 19, in 《module》
afunc()
File "D:\workspace\Python\src\lang\lineno.py", line 15, in afunc
errmsg = 1/0
ZeroDivisionError: integer division or modulo by zero
那么我们就从错误栈的输出入手，traceback模块中：
Now that, Let’s begin with the output of an exception call stack, in the traceback module:
python代码
def print_stack(f=None, limit=None, file=None):
"""Print a stack trace from its invocation point.
The optional ’f’ argument can be used to specify an alternate
stack frame at which to start. The optional ’limit’ and ’file’
arguments have the same meaning as for print_exception().
"""
if f is None:
try:
raise ZeroDivisionError
except ZeroDivisionError:
f = sys.exc_info().tb_frame.f_back
print_list(extract_stack(f, limit), file)
def print_list(extracted_list, file=None):
"""Print the list of tuples as returned by extract_tb() or
extract_stack() as a formatted stack trace to the given file."""
if file is None:
file = sys.stderr
for filename, lineno, name, line in extracted_list:
_print(file,
’ File "%s", line %d, in %s’ % (filename,lineno,name))
if line:
_print(file, ’ %s’ % line.strip())
traceback模块构造一个ZeroDivisionError，并通过sys模块的exc_info()来获取运行时上下文。我们看到，所有的秘密都在tb_frame中，这是函数调用栈中的一个帧。
traceback constructs an ZeroDivisionError, and then call the exc_info() of the sys module to get runtime context. There, all the secrets hide in the tb_frame, this is a frame of the function call stack.
对，就是这么简单！只要我们能找到调用栈frame对象即可获取到行号！因此，我们可以用同样的方法来达到目的，我们自定义一个lineno函数：
Yes, It’s so easy! If only a frame object we get, we can get the line number! So we can have a similar implemetation to get what we want, defining a function named lineno:
python代码
import sys
def lineno():
frame = None
try:
raise ZeroDivisionError
except ZeroDivisionError:
frame = sys.exc_info().tb_frame.f_back
return frame.f_lineno
def afunc():
# if error
print "I have a problem! And here is at Line: %s"%lineno()
是否有更方便的方法获取到frame对象？当然有！
Is there any other way, perhaps more convinient, to get a frame object? Of course YES!
python代码
def afunc():
# if error
print "I have a proble! And here is at Line: %s"%sys._getframe().f_lineno
类似地，通过frame对象，我们还可以获取到当前文件、当前函数等信息，就像C语音的__FILE__与__FUNCTION__一样。其实现方式，留给你们自己去发现。
Thanks to the frame object, similarly, we can also get current file and current function name, just like the __FILE__ and __FUNCTION__ macros in C. Debug the frame object, you will get the solutions.

python Process finished with exit code 1

1.python运行结束出现：processfinishedwithexitcode0说明，程序正常运行完。例如：test1.py文件如下代码a=1/1printa运行后出现：1Processfinishedwithexitcode0＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝2.如果出现：processfinishedwithexitcode1说明程序出错，也就是代码有问题。例如：test2.pya=1/0printa运行后出现：Traceback(mostrecentcalllast):File"/Users/pwd/work/project/AnyData/data/test3.py",line36,ina=1/0ZeroDivisionError:integerdivisionormodulobyzero［报错：0不能被除］Processfinishedwithexitcode1

Python 为什么不能捕获如下的除零异常

把try expect放在exe()函数里面
如果在程序出错的时候捕捉到这个错误，被用自己的方式来处理它，或者不想让使用程序的用户了解程序出错的详细信息，这个时候我们就需要捕捉异常，可以使用 try和except 语言。
》》》 a = 10
》》》 b = 0
》》》 print a / b
》》》
这样，程序运行之后会产生异常错误，信息如下：
Traceback (most recent call last):
File "《pyshell#2》", line 1, in 《module》
print a /b
ZeroDivisionError: integer division or modulo by zero
如何处理上面的除零错误，并且返回自己想要的内容，请看下面的代码：
try:
a = 10
b = 0
print a / b
except ZeroDivisionError:
pirnt “除零错误，已经捕获！”
如果需要同时捕捉多个可能的异常错误，可以把异常的类型，放入一个元组中，举例说明：
except (ZeroDivisionError, TypeError, NameError)

我执行一段python脚本报错了，怎么解决

在程序运行的过程中，如果发生了错误，可以事先约定返回一个错误代码，这样，就可以知道是否有错，以及出错的原因。在操作系统提供的调用中，返回错误码非常常见。比如打开文件的函数open()，成功时返回文件描述符（就是一个整数），出错时返回-1。
用错误码来表示是否出错十分不便，因为函数本身应该返回的正常结果和错误码混在一起，造成调用者必须用大量的代码来判断是否出错：
复制代码代码如下:
def foo():
r = some_function()
if r==(-1):
return (-1)
# do something
return r
def bar():
r = foo()
if r==(-1):
print ’Error’
else:
pass
一旦出错，还要一级一级上报，直到某个函数可以处理该错误（比如，给用户输出一个错误信息）。
所以高级语言通常都内置了一套try...except...finally...的错误处理机制，Python也不例外。
try
让我们用一个例子来看看try的机制：
复制代码代码如下:
try:
print ’try...’
r = 10 / 0
print ’result:’, r
except ZeroDivisionError, e:
print ’except:’, e
finally:
print ’finally...’
print ’END’
当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕。
上面的代码在计算10 / 0时会产生一个除法运算错误：
复制代码代码如下:
try...
except: integer division or modulo by zero
finally...
END
从输出可以看到，当错误发生时，后续语句print ’result:’, r不会被执行，except由于捕获到ZeroDivisionError，因此被执行。最后，finally语句被执行。然后，程序继续按照流程往下走。
如果把除数0改成2，则执行结果如下：
复制代码代码如下:
try...
result: 5
finally...
END
由于没有错误发生，所以except语句块不会被执行，但是finally如果有，则一定会被执行（可以没有finally语句）。
你还可以猜测，错误应该有很多种类，如果发生了不同类型的错误，应该由不同的except语句块处理。没错，可以有多个except来捕获不同类型的错误：
复制代码代码如下:
try:
print ’try...’
r = 10 / int(’a’)
print ’result:’, r
except ValueError, e:
print ’ValueError:’, e
except ZeroDivisionError, e:
print ’ZeroDivisionError:’, e
finally:
print ’finally...’
print ’END’
int()函数可能会抛出ValueError，所以我们用一个except捕获ValueError，用另一个except捕获ZeroDivisionError。
此外，如果没有错误发生，可以在except语句块后面加一个else，当没有错误发生时，会自动执行else语句：
复制代码代码如下:
try:
print ’try...’
r = 10 / int(’a’)
print ’result:’, r
except ValueError, e:
print ’ValueError:’, e
except ZeroDivisionError, e:
print ’ZeroDivisionError:’, e
else:
print ’no error!’
finally:
print ’finally...’
print ’END’
Python的错误其实也是class，所有的错误类型都继承自BaseException，所以在使用except时需要注意的是，它不但捕获该类型的错误，还把其子类也“一网打尽”。比如：
复制代码代码如下:
try:
foo()
except StandardError, e:
print ’StandardError’
except ValueError, e:
print ’ValueError’
第二个except永远也捕获不到ValueError，因为ValueError是StandardError的子类，如果有，也被第一个except给捕获了。
Python所有的错误都是从BaseException类派生的
使用try...except捕获错误还有一个巨大的好处，就是可以跨越多层调用，比如函数main()调用foo()，foo()调用bar()，结果bar()出错了，这时，只要main()捕获到了，就可以处理：
复制代码代码如下:
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar(’0’)
except StandardError, e:
print ’Error!’
finally:
print ’finally...’
也就是说，不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。这样一来，就大大减少了写try...except...finally的麻烦。
调用堆栈
如果错误没有被捕获，它就会一直往上抛，最后被Python解释器捕获，打印一个错误信息，然后程序退出。来看看err.py：
复制代码代码如下:
# err.py:
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
bar(’0’)
main()
执行，结果如下：
复制代码代码如下:
$ python err.py
Traceback (most recent call last):
File "err.py", line 11, in 《module》
main()
File "err.py", line 9, in main
bar(’0’)
File "err.py", line 6, in bar
return foo(s) * 2
File "err.py", line 3, in foo
return 10 / int(s)
ZeroDivisionError: integer division or modulo by zero
出错并不可怕，可怕的是不知道哪里出错了。解读错误信息是定位错误的关键。我们从上往下可以看到整个错误的调用函数链：
错误信息第1行：
复制代码代码如下:
Traceback (most recent call last):
告诉我们这是错误的跟踪信息。
第2行：
复制代码代码如下:
File "err.py", line 11, in 《module》
main()
调用main()出错了，在代码文件err.py的第11行代码，但原因是第9行：
复制代码代码如下:
File "err.py", line 9, in main
bar(’0’)
调用bar(’0’)出错了，在代码文件err.py的第9行代码，但原因是第6行：
复制代码代码如下:
File "err.py", line 6, in bar
return foo(s) * 2
原因是return foo(s) * 2这个语句出错了，但这还不是最终原因，继续往下看：
复制代码代码如下:
File "err.py", line 3, in foo
return 10 / int(s)
原因是return 10 / int(s)这个语句出错了，这是错误产生的源头，因为下面打印了：
复制代码代码如下:
ZeroDivisionError: integer division or modulo by zero
根据错误类型ZeroDivisionError，我们判断，int(s)本身并没有出错，但是int(s)返回0，在计算10 / 0时出错，至此，找到错误源头。
记录错误
如果不捕获错误，自然可以让Python解释器来打印出错误堆栈，但程序也被结束了。既然我们能捕获错误，就可以把错误堆栈打印出来，然后分析错误原因，同时，让程序继续执行下去。
Python内置的logging模块可以非常容易地记录错误信息：
复制代码代码如下:
# err.py
import logging
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar(’0’)
except StandardError, e:
logging.exception(e)
main()
print ’END’
同样是出错，但程序打印完错误信息后会继续执行，并正常退出：
复制代码代码如下:
$ python err.py
ERROR:root:integer division or modulo by zero
Traceback (most recent call last):
File "err.py", line 12, in main
bar(’0’)
File "err.py", line 8, in bar
return foo(s) * 2
File "err.py", line 5, in foo
return 10 / int(s)
ZeroDivisionError: integer division or modulo by zero
END
通过配置，logging还可以把错误记录到日志文件里，方便事后排查。
抛出错误
因为错误是class，捕获一个错误就是捕获到该class的一个实例。因此，错误并不是凭空产生的，而是有意创建并抛出的。Python的内置函数会抛出很多类型的错误，我们自己编写的函数也可以抛出错误。
如果要抛出错误，首先根据需要，可以定义一个错误的class，选择好继承关系，然后，用raise语句抛出一个错误的实例：
复制代码代码如下:
# err.py
class FooError(StandardError):
pass
def foo(s):
n = int(s)
if n==0:
raise FooError(’invalid value: %s’ % s)
return 10 / n
执行，可以最后跟踪到我们自己定义的错误：
复制代码代码如下:
$ python err.py
Traceback (most recent call last):
...
__main__.FooError: invalid value: 0
只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型（比如ValueError，TypeError），尽量使用Python内置的错误类型。
最后，我们来看另一种错误处理的方式：
复制代码代码如下:
# err.py
def foo(s):
n = int(s)
return 10 / n
def bar(s):
try:
return foo(s) * 2
except StandardError, e:
print ’Error!’
raise
def main():
bar(’0’)
main()
在bar()函数中，我们明明已经捕获了错误，但是，打印一个Error!后，又把错误通过raise语句抛出去了，这不有病么？
其实这种错误处理方式不但没病，而且相当常见。捕获错误目的只是记录一下，便于后续追踪。但是，由于当前函数不知道应该怎么处理该错误，所以，最恰当的方式是继续往上抛，让顶层调用者去处理。
raise语句如果不带参数，就会把当前错误原样抛出。此外，在except中raise一个Error，还可以把一种类型的错误转化成另一种类型：
复制代码代码如下:
try:
10 / 0
except ZeroDivisionError:
raise ValueError(’input error!’)
只要是合理的转换逻辑就可以，但是，决不应该把一个IOError转换成毫不相干的ValueError。
小结
Python内置的try...except...finally用来处理错误十分方便。出错时，会分析错误信息并定位错误发生的代码位置才是最关键的。
程序也可以主动抛出错误，让调用者来处理相应的错误。但是，应该在文档中写清楚可能会抛出哪些错误，以及错误产生的原因。

python出错，请问是什么问题

要把代码发现来才知道，以下是常见的错误
下面终于要讲到当你用到更多的Python的功能（数据类型，函数，模块，类等等）时可能碰到的问题了。由于篇幅有限，这里尽量精简，尤其是对一些高级的概念。要想了解更多的细节，敬请阅读Learning Python, 2nd Edition的“小贴士”以及“Gotchas”章节。
打开文件的调用不使用模块搜索路径
当你在Python中调用open()来访问一个外部的文件时，Python不会使用模块搜索路径来定位这个目标文件。它会使用你提供的绝对路径，或者假定这个文件是在当前工作目录中。模块搜索路径仅仅为模块加载服务的。
不同的类型对应的方法也不同
列表的方法是不能用在字符串上的，反之亦然。通常情况下，方法的调用是和数据类型有关的，但是内部函数通常在很多类型上都可以使用。举个例子来说，列表的reverse方法仅仅对列表有用，但是len函数对任何具有长度的对象都适用
不能直接改变不可变数据类型
记住你没法直接的改变一个不可变的对象（例如，元组，字符串）：
T = (1, 2, 3)
T = 4 # 错误
用切片，联接等构建一个新的对象，并根据需求将原来变量的值赋给它。因为Python会自动回收没有用的内存，因此这没有看起来那么浪费：
T = T + (4,) # 没问题了: T 变成了 (1, 2, 4)
使用简单的for循环而不是while或者range
当你要从左到右遍历一个有序的对象的所有元素时，用简单的for循环（例如，for x in seq:）相比于基于while-或者range-的计数循环而言会更容易写，通常运行起来也更快。除非你一定需要，尽量避免在一个for循环里使用range：让Python来替你解决标号的问题。在下面的例子中三个循环结构都没有问题，但是第一个通常来说更好；在Python里，简单至上。
S = "lumberjack"

for c in S: print c # 最简单

for i in range(len(S)): print S # 太多了

i = 0 # 太多了
while i 《 len(S): print S; i += 1
不要试图从那些会改变对象的函数得到结果
诸如像方法list.append()和list.sort()一类的直接改变操作会改变一个对象，但不会将它们改变的对象返回出来（它们会返回None）；正确的做法是直接调用它们而不要将结果赋值。经常会看见初学者会写诸如此类的代码：
mylist = mylist.append(X)
目的是要得到append的结果，但是事实上这样做会将None赋值给mylist，而不是改变后的列表。更加特别的一个例子是想通过用排序后的键值来遍历一个字典里的各个元素，请看下面的例子：
D = {...}
for k in D.keys().sort(): print D
差一点儿就成功了——keys方法会创建一个keys的列表，然后用sort方法来将这个列表排序——但是因为sort方法会返回None，这个循环会失败，因为它实际上是要遍历None（这可不是一个序列）。要改正这段代码，将方法的调用分离出来，放在不同的语句中，如下：
Ks = D.keys()
Ks.sort()
for k in Ks: print D
只有在数字类型中才存在类型转换
在Python中，一个诸如123+3.145的表达式是可以工作的——它会自动将整数型转换为浮点型，然后用浮点运算。但是下面的代码就会出错了：
S = "42"
I = 1
X = S + I # 类型错误
这同样也是有意而为的，因为这是不明确的：究竟是将字符串转换为数字（进行相加）呢，还是将数字转换为字符串（进行联接）呢？在Python中，我们认为“明确比含糊好”（即，EIBTI（Explicit is better than implicit）），因此你得手动转换类型：
X = int(S) + I # 做加法: 43
X = S + str(I) # 字符串联接: "421"
循环的数据结构会导致循环
尽管这在实际情况中很少见，但是如果一个对象的集合包含了到它自己的引用，这被称为循环对象（cyclic object）。如果在一个对象中发现一个循环，Python会输出一个，以避免在无限循环中卡住：
》》》 L = # 在 L中又引用L自身会
》》》 L.append(L) # 在对象中创造一个循环
》》》 L
除了知道这三个点在对象中表示循环以外，这个例子也是很值得借鉴的。因为你可能无意间在你的代码中出现这样的循环的结构而导致你的代码出错。如果有必要的话，维护一个列表或者字典来表示已经访问过的对象，然后通过检查它来确认你是否碰到了循环。
赋值语句不会创建对象的副本，仅仅创建引用
这是Python的一个核心理念，有时候当行为不对时会带来错误。在下面的例子中，一个列表对象被赋给了名为L的变量，然后L又在列表M中被引用。内部改变L的话，同时也会改变M所引用的对象，因为它们俩都指向同一个对象。
》》》 L = # 共用的列表对象
》》》 M = # 嵌入一个到L的引用
》》》 M

》》》 L = 0 # 也改变了M
》》》 M
通常情况下只有在稍大一点的程序里这就显得很重要了，而且这些共用的引用通常确实是你需要的。如果不是的话，你可以明确的给他们创建一个副本来避免共用的引用；对于列表来说，你可以通过使用一个空列表的切片来创建一个顶层的副本：
》》》 L =
》》》 M = # 嵌入一个L的副本

》》》 L = 0 # 仅仅改变了L，但是不影响M
》》》 L
》》》 M
切片的范围起始从默认的0到被切片的序列的最大长度。如果两者都省略掉了，那么切片会抽取该序列中的所有元素，并创造一个顶层的副本（一个新的，不被公用的对象）。对于字典来说，使用字典的dict.copy()方法。
静态识别本地域的变量名
Python默认将一个函数中赋值的变量名视作是本地域的，它们存在于该函数的作用域中并且仅仅在函数运行的时候才存在。从技术上讲，Python是在编译def代码时，去静态的识别本地变量，而不是在运行时碰到赋值的时候才识别到的。如果不理解这点的话，会引起人们的误解。比如，看看下面的例子，当你在一个引用之后给一个变量赋值会怎么样：
》》》 X = 99
》》》 def func():
... print X # 这个时候还不存在
... X = 88 # 在整个def中将X视作本地变量
...
》》》 func( ) # 出错了！
你会得到一个“未定义变量名”的错误，但是其原因是很微妙的。当编译这则代码时，Python碰到给X赋值的语句时认为在这个函数中的任何地方X会被视作一个本地变量名。但是之后当真正运行这个函数时，执行print语句的时候，赋值语句还没有发生，这样Python便会报告一个“未定义变量名”的错误。
事实上，之前的这个例子想要做的事情是很模糊的：你是想要先输出那个全局的X，然后创建一个本地的X呢，还是说这是个程序的错误？如果你真的是想要输出这个全局的X，你需要将它在一个全局语句中声明它，或者通过包络模块的名字来引用它。
默认参数和可变对象
在执行def语句时，默认参数的值只被解析并保存一次，而不是每次在调用函数的时候。这通常是你想要的那样，但是因为默认值需要在每次调用时都保持同样对象，你在试图改变可变的默认值（mutable defaults）的时候可要小心了。例如，下面的函数中使用一个空的列表作为默认值，然后在之后每一次函数调用的时候改变它的值：
》》》 def saver(x=): # 保存一个列表对象
... x.append(1) # 并每次调用的时候
... print x # 改变它的值
...
》》》 saver() # 未使用默认值
》》》 saver() # 使用默认值
》》》 saver() # 每次调用都会增加！
》》》 saver()
有的人将这个视作Python的一个特点——因为可变的默认参数在每次函数调用时保持了它们的状态，它们能提供像C语言中静态本地函数变量的类似的一些功能。但是，当你第一次碰到它时会觉得这很奇怪，并且在Python中有更加简单的办法来在不同的调用之间保存状态（比如说类）。
要摆脱这样的行为，在函数开始的地方用切片或者方法来创建默认参数的副本，或者将默认值的表达式移到函数里面；只要每次函数调用时这些值在函数里，就会每次都得到一个新的对象：
》》》 def saver(x=None):
... if x is None: x = # 没有传入参数？
... x.append(1) # 改变新的列表
... print x
...
》》》 saver() # 没有使用默认值
》》》 saver() # 这次不会变了
》》》 saver()
其他常见的编程陷阱
下面列举了其他的一些在这里没法详述的陷阱：
在顶层文件中语句的顺序是有讲究的：因为运行或者加载一个文件会从上到下运行它的语句，所以请确保将你未嵌套的函数调用或者类的调用放在函数或者类的定义之后。
reload不影响用from加载的名字：reload最好和import语句一起使用。如果你使用from语句，记得在reload之后重新运行一遍from，否则你仍然使用之前老的名字。
在多重继承中混合的顺序是有讲究的：这是因为对superclass的搜索是从左到右的，在类定义的头部，在多重superclass中如果出现重复的名字，则以最左边的类名为准。
在try语句中空的except子句可能会比你预想的捕捉到更多的错误。在try语句中空的except子句表示捕捉所有的错误，即便是真正的程序错误，和sys.exit()调用，也会被捕捉到。

在python中用try except能输出哪行报错吗

异常信息的获取对于程序的调试非常重要，可以有助于快速定位有错误程序语句的位置。下面介绍几种python中获取异常信息的方法，这里获取异常（Exception）信息采用try...except...程序结构。

1、str(e)返回字符串类型，只给出异常信息，不包括异常信息的类型，如1/0的异常信息’integer division or modulo by zero’。

2、repr(e)，给出较全的异常信息，包括异常信息的类型，如1/0的异常信息"ZeroDivisionError(’integer division or modulo by zero’,)"。

3、e.message，获得的信息同str(e)。

4、采用traceback模块，需要导入traceback模块，此时获取的信息最全，与python命令行运行程序出现错误信息一致。使用traceback.print_exc()打印异常信息到标准错误，就像没有获取一样，或者使用traceback.format_exc()将同样的输出获取为字符串。你可以向这些函数传递各种各样的参数来限制输出，或者重新打印到像文件类型的对象。