pythonerror类型

A. python typeerror 不同类型间的无效操作是什么意思

AssertionError 断言语句（assert）失败
AttributeError 尝试访问未知的对象属性
EOFError 用户输入文件末尾标志EOF（Ctrl+d）
FloatingPointError 浮点计算错误
GeneratorExit generator.close()方法被调用的时候
ImportError 导入模块失败的时候
IndexError 索引超出序列的范围
KeyError 字典中查找一个不存在的关键字
KeyboardInterrupt 用户输入中断键（Ctrl+c）
MemoryError 内存溢出（可通过删除对象释放内存）
NameError 尝试访问一个不存在的变量
NotImplementedError 尚未实现的方法
OSError 操作系统产生的异常（例如打开一个不存在的文件）
OverflowError 数值运算超出最大限制
ReferenceError 弱引用（weak reference）试图访问一个已经被垃圾回收机制回收了的对象
RuntimeError 一般的运行时错误
StopIteration 迭代器没有更多的值
SyntaxError Python的语法错误
IndentationError 缩进错误
TabError Tab和空格混合使用
SystemError Python编译器系统错误
SystemExit Python编译器进程被关闭
TypeError 不同类型间的无效操作
UnboundLocalError 访问一个未初始化的本地变量（NameError的子类）
UnicodeError Unicode相关的错误（ValueError的子类）
UnicodeEncodeError Unicode编码时的错误（UnicodeError的子类）
UnicodeDecodeError Unicode解码时的错误（UnicodeError的子类）
UnicodeTranslateError Unicode转换时的错误（UnicodeError的子类）
ValueError 传入无效的参数
ZeroDivisionError 除数为零

B. 关于python的类型错误

不是很明白你的意思（向量乘积？）
但这个错误的意思是：tuple类型（元组）不支持这种乘法操作
你的n1和n2都是tuple类型，这样做乘法是会出错的
你可以 n1 * num , num 为int类型
即 乘法操作满足， type * int，有一个乘数需得是int

C. python错误

异常名称 异常说明
AssertionError 断言语句（assert）失败
AttributeError 尝试访问未知的对象属性
EOFError 用户输入文件末尾标志EOF（Ctrl+d）
FloatingPointError 浮点计算错误
GeneratorExit generator.close()方法被调用的时候
ImportError 导入模块失败的时候
IndexError 索引超出序列的范围
KeyError 字典中查找一个不存在的关键字
KeyboardInterrupt 用户输入中断键（Ctrl+c）
MemoryError 内存溢出（可通过删除对象释放内存）
NameError 尝试访问一个不存在的变量
NotImplementedError 尚未实现的方法
OSError 操作系统产生的异常（例如打开一个不存在的文件）
OverflowError 数值运算超出最大限制
ReferenceError 弱引用（weak reference）试图访问一个已经被垃圾回收机制回收了的对象
RuntimeError 一般的运行时错误
StopIteration 迭代器没有更多的值
SyntaxError Python的语法错误
IndentationError 缩进错误
TabError Tab和空格混合使用
SystemError Python编译器系统错误
SystemExit Python编译器进程被关闭
TypeError 不同类型间的无效操作
UnboundLocalError 访问一个未初始化的本地变量（NameError的子类）
UnicodeError Unicode相关的错误（ValueError的子类）
UnicodeEncodeError Unicode编码时的错误（UnicodeError的子类）
UnicodeDecodeError Unicode解码时的错误（UnicodeError的子类）
UnicodeTranslateError Unicode转换时的错误（UnicodeError的子类）
ValueError 传入无效的参数
ZeroDivisionError 除数为零

D. 如何解决的Python类型错误

1.Python异常类

Python是面向对象语言，所以程序抛出的异常也是类。常见的Python异常有以下几个，大家只要大致扫一眼，有个映像，等到编程的时候，相信大家肯定会不只一次跟他们照面（除非你不用Python了）。

异常 描述
NameError 尝试访问一个没有申明的变量
ZeroDivisionError 除数为0
SyntaxError 语法错误
IndexError 索引超出序列范围
KeyError 请求一个不存在的字典关键字
IOError 输入输出错误（比如你要读的文件不存在）
AttributeError 尝试访问未知的对象属性
ValueError 传给函数的参数类型不正确，比如给int()函数传入字符串形
2.捕获异常
Python完整的捕获异常的语句有点像：
复制代码 代码如下:

try:
try_suite
except Exception1,Exception2,...,Argument:
exception_suite
...... #other exception block
else:
no_exceptions_detected_suite
finally:
always_execute_suite

额...是不是很复杂？当然，当我们要捕获异常的时候，并不是必须要按照上面那种格式完全写下来，我们可以丢掉else语句，或者finally语句；甚至不要exception语句，而保留finally语句。额，晕了？好吧，下面，我们就来一一说明啦。
2.1.try...except...语句
try_suite不消我说大家也知道，是我们需要进行捕获异常的代码。而except语句是关键，我们try捕获了代码段try_suite里的异常后，将交给except来处理。
try...except语句最简单的形式如下：
复制代码 代码如下:

try:
try_suite
except:
exception block

上面except子句不跟任何异常和异常参数，所以无论try捕获了任何异常，都将交给except子句的exception block来处理。如果我们要处理特定的异常，比如说，我们只想处理除零异常，如果其他异常出现，就让其抛出不做处理，该怎么办呢？这个时候，我们就要给except子句传入异常参数啦！那个ExceptionN就是我们要给except子句的异常类（请参考异常类那个表格），表示如果捕获到这类异常，就交给这个except子句来处理。比如：
复制代码 代码如下:

try:
try_suite
except Exception:
exception block

举个例子：
复制代码 代码如下:

>>> try:
... res = 2/0
... except ZeroDivisionError:
... print "Error:Divisor must not be zero!"
...
Error:Divisor must not be zero!

看，我们真的捕获到了ZeroDivisionError异常！那如果我想捕获并处理多个异常怎么办呢？有两种办法，一种是给一个except子句传入多个异常类参数，另外一种是写多个except子句，每个子句都传入你想要处理的异常类参数。甚至，这两种用法可以混搭呢！下面我就来举个例子。
复制代码 代码如下:

try:
floatnum = float(raw_input("Please input a float:"))
intnum = int(floatnum)
print 100/intnum
except ZeroDivisionError:
print "Error:you must input a float num which is large or equal then 1!"
except ValueError:
print "Error:you must input a float num!"
[root@Cherish tmp]# python test.py
Please input a float:fjia
Error:you must input a float num!
[root@Cherish tmp]# python test.py
Please input a float:0.9999
Error:you must input a float num which is large or equal then 1!
[root@Cherish tmp]# python test.py
Please input a float:25.091
4

上面的例子大家一看都懂，就不再解释了。只要大家明白，我们的except可以处理一种异常，多种异常，甚至所有异常就可以了。
大家可能注意到了，我们还没解释except子句后面那个Argument是什么东西？别着急，听我一一道来。这个Argument其实是一个异常类的实例（别告诉我你不知到什么是实例），包含了来自异常代码的诊断信息。也就是说，如果你捕获了一个异常，你就可以通过这个异常类的实例来获取更多的关于这个异常的信息。例如：
复制代码 代码如下:

>>> try:
... 1/0
... except ZeroDivisionError,reason:
... pass
...
>>> type(reason)
<type 'exceptions.ZeroDivisionError'>
>>> print reason
integer division or molo by zero
>>> reason
ZeroDivisionError('integer division or molo by zero',)
>>> reason.__class__
<type 'exceptions.ZeroDivisionError'>
>>> reason.__class__.__doc__
'Second argument to a division or molo operation was zero.'
>>> reason.__class__.__name__
'ZeroDivisionError'

上面这个例子，我们捕获了除零异常，但是什么都没做。那个reason就是异常类ZeroDivisionError的实例，通过type就可以看出。
2.2try ... except...else语句
现在我们来说说这个else语句。Python中有很多特殊的else用法，比如用于条件和循环。放到try语句中，其作用其实也差不多：就是当没有检测到异常的时候，则执行else语句。举个例子大家可能更明白些：
复制代码 代码如下:

>>> import syslog
>>> try:
... f = open("/root/test.py")
... except IOError,e:
... syslog.syslog(syslog.LOG_ERR,"%s"%e)
... else:
... syslog.syslog(syslog.LOG_INFO,"no exception caught\n")
...
>>> f.close()

2.3 finally子句
finally子句是无论是否检测到异常，都会执行的一段代码。我们可以丢掉except子句和else子句，单独使用try...finally，也可以配合except等使用。
例如2.2的例子，如果出现其他异常，无法捕获，程序异常退出，那么文件 f 就没有被正常关闭。这不是我们所希望看到的结果，但是如果我们把f.close语句放到finally语句中，无论是否有异常，都会正常关闭这个文件，岂不是很 妙
复制代码 代码如下:

>>> import syslog
>>> try:
... f = open("/root/test.py")
... except IOError,e:
... syslog.syslog(syslog.LOG_ERR,"%s"%e)
... else:
... syslog.syslog(syslog.LOG_INFO,"no exception caught\n")
... finally:
>>> f.close()

大家看到了没，我们上面那个例子竟然用到了try,except,else,finally这四个子句！:-)，是不是很有趣？到现在，你就基本上已经学会了如何在Python中捕获常规异常并处理之。
3.两个特殊的处理异常的简便方法
3.1断言（assert）
什么是断言，先看语法：
复制代码 代码如下:

assert expression[,reason]

其中assert是断言的关键字。执行该语句的时候，先判断表达式expression，如果表达式为真，则什么都不做；如果表达式不为真，则抛出异常。reason跟我们之前谈到的异常类的实例一样。不懂？没关系，举例子！最实在！
复制代码 代码如下:

>>> assert len('love') == len('like')
>>> assert 1==1
>>> assert 1==2,"1 is not equal 2!"
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
AssertionError: 1 is not equal 2!

我们可以看到，如果assert后面的表达式为真，则什么都不做，如果不为真，就会抛出AssertionErro异常，而且我们传进去的字符串会作为异常类的实例的具体信息存在。其实，assert异常也可以被try块捕获：
复制代码 代码如下:

>>> try:
... assert 1 == 2 , "1 is not equal 2!"
... except AssertionError,reason:
... print "%s:%s"%(reason.__class__.__name__,reason)
...
AssertionError:1 is not equal 2!
>>> type(reason)
<type 'exceptions.AssertionError'>

3.2.上下文管理（with语句）
如果你使用try,except,finally代码仅仅是为了保证共享资源（如文件，数据）的唯一分配，并在任务结束后释放它，那么你就有福了！这个with语句可以让你从try,except,finally中解放出来！语法如下：
复制代码 代码如下:

with context_expr [as var]:
with_suite

是不是不明白？很正常，举个例子来！
复制代码 代码如下:

>>> with open('/root/test.py') as f:
... for line in f:
... print line

上面这几行代码干了什么？
（1）打开文件/root/test.py
（2）将文件对象赋值给 f
（3）将文件所有行输出
（4）无论代码中是否出现异常，Python都会为我们关闭这个文件，我们不需要关心这些细节。
这下，是不是明白了，使用with语句来使用这些共享资源，我们不用担心会因为某种原因而没有释放他。但并不是所有的对象都可以使用with语句，只有支持上下文管理协议（context management protocol）的对象才可以，那哪些对象支持该协议呢？如下表：
file
decimal.Context
thread.LockType
threading.Lock
threading.RLock
threading.Condition
threading.Semaphore
threading.BoundedSemaphore
至于什么是上下文管理协议，如果你不只关心怎么用with,以及哪些对象可以使用with，那么我们就不比太关心这个问题：）
4.抛出异常(raise)
如果我们想要在自己编写的程序中主动抛出异常，该怎么办呢？raise语句可以帮助我们达到目的。其基本语法如下：
复制代码 代码如下:

raise [SomeException [, args [,traceback]]

第一个参数，SomeException必须是一个异常类，或异常类的实例
第二个参数是传递给SomeException的参数，必须是一个元组。这个参数用来传递关于这个异常的有用信息。
第三个参数traceback很少用，主要是用来提供一个跟中记录对象（traceback）
下面我们就来举几个例子。
复制代码 代码如下:

>>> raise NameError
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError
>>> raise NameError() #异常类的实例
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError
>>> raise NameError,("There is a name error","in test.py")
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
>>> raise NameError("There is a name error","in test.py") #注意跟上面一个例子的区别
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError: ('There is a name error', 'in test.py')
>>> raise NameError,NameError("There is a name error","in test.py") #注意跟上面一个例子的区别
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError: ('There is a name error', 'in test.py')

其实，我们最常用的还是，只传入第一个参数用来指出异常类型，最多再传入一个元组，用来给出说明信息。如上面第三个例子。
5.异常和sys模块
另一种获取异常信息的途径是通过sys模块中的exc_info()函数。该函数回返回一个三元组:(异常类，异常类的实例，跟中记录对象)
复制代码 代码如下:

>>> try:
... 1/0
... except:
... import sys
... tuple = sys.exc_info()
...
>>> print tuple
(<type 'exceptions.ZeroDivisionError'>, ZeroDivisionError('integer division or molo by zero',), <traceback object at 0x7f538a318b48>)
>>> for i in tuple:
... print i
...
<type 'exceptions.ZeroDivisionError'> #异常类
integer division or molo by zero #异常类的实例
<traceback object at 0x7f538a318b48> #跟踪记录对象

E. python运行错误怎么办

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

F. 在python中error哪一类的是什么意思，warning，以及剩下的那些是什么意思，那种句子用得到

err 出现你代码就彻底挂了,这类基本都是语法错误,比如多了个空格,格式没对齐,函数少了参数

warning 出现 不一定会挂.可以继续往下跑,比如变量没定义,没初始化.函数参数类型不对等

G. Python 运行报错NameError出现原因，怎么解决

python程序，报错NameError: name XX is not defined 是没有声明造成的，需要在文件的前两行进行声明编码，声明方法为：

1、写一个python文件，文件中有中文字符，且未声明编码。

H. python错误类型TypeError: 'Symbol' object is not callable

调用函数、变量的方式错误；
检查下 Symbol 变量名和函数名是不是用重复了
比如：
>>>str="abc"
>>>x=123
>>>str(x)
就会报错TypeError: 'str' object is not callable,因为上面已经定义了str变量，定义之后下面的str()函数就变成不可调用的了，变量名和函数名重复了

I. python 错误处理不知道是什么错误类型

random.uniform
用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b， 则 b <= n <= a。

J. python出现这个错误是什么原因

搜集了一些python最重要的内建异常类名，并做了简单的介绍：

AttributeError：属性错误，特性引用和赋值失败时会引发属性错误

NameError：试图访问的变量名不存在

SyntaxError：语法错误，代码形式错误

Exception：所有异常的基类，因为所有python异常类都是基类Exception的其中一员，异常都是从基类Exception继承的，并且都在exceptions模块中定义。

IOError：一般常见于打开不存在文件时会引发IOError错误，也可以解理为输出输入错误

KeyError：使用了映射中不存在的关键字（键）时引发的关键字错误

IndexError：索引错误，使用的索引不存在，常索引超出序列范围，什么是索引

TypeError：类型错误，内建操作或是函数应于在了错误类型的对象时会引发类型错误

ZeroDivisonError：除数为0，在用除法操作时，第二个参数为0时引发了该错误

ValueError：值错误，传给对象的参数类型不正确，像是给int()函数传入了字符串数据类型的参数