def python里所有的错误类型(a):
    if a == BaseException:
        print('所有异常的基类')
    if a == Exception:
        print('常规异常的基类')
    if a == ArithmeticError:
        print('所有数值计算异常的基类')
    if a == FloatingPointError:
        print('浮点计算异常')
    if a == OverflowError:
        print('数值运算超出最大限制')
    if a == ZeroDivisionError:
        print('除数为零')
    if a == AssertionError:
        print('断言语句(assert)失败')
    if a == AttributeError:
        print('尝试访问未知的对象属性')
    if a == EOFError:
        print('没有内建输入,到达EOF标记')
    if a == EnvironmentError:
        print('操作系统异常的基类')
    if a == IOError:
        print('输入 / 输出操作失败')
    if a == OSError:
        print('操作系统产生的异常(例如打开一个不存在的文件)')
    if a == WindowsError:
        print('系统调用失败')
    if a == ImportError:
        print('导入模块失败的时候')
    if a == KeyboardInterrupt:
        print('用户中断执行')
    if a == LookupError:
        print('无效数据查询的基类')
    if a == IndexError:
        print('索引超出序列的范围')
    if a == KeyError:
        print('字典中查找一个不存在的关键字')
    if a == MemoryError:
        print('内存溢出(可通过删除对象释放内存)')
    if a == NameError:
        print('尝试访问一个不存在的变量')
    if a == UnboundLocalError:
        print('访问未初始化的本地变量')
    if a == ReferenceError:
        print('弱引用试图访问已经垃圾回收了的对象')
    if a == RuntimeError:
        print('一般的运行时异常')
    if a == NotImplementedError:
        print('尚未实现的方法')
    if a == SyntaxError:
        print('语法错误导致的异常')
    if a == IndentationError:
        print('缩进错误导致的异常')
    if a == TabError:
        print('Tab和空格混用')
    if a == SystemError:
        print('一般的解释器系统异常')
    if a == TypeError:
        print('不同类型间的无效操作')
    if a == ValueError:
        print('传入无效的参数')
    if a == UnicodeError:
        print('Unicode相关的异常')
    if a == UnicodeDecodeError:
        print('Unicode解码时的异常')
    if a == UnicodeEncodeError:
        print('Unicode编码错误导致的异常')
    if a == UnicodeTranslateError:
        print('Unicode转换错误导致的异常')

9 条评论

  • @ 2023-2-2 15:55:45
    
    
    ZeroDivisionError	除(或取模)零 (所有数据类型)
    ValueError	传入无效的参数
    AssertionError	断言语句失败
    StopIteration	迭代器没有更多的值
    IndexError	序列中没有此索引(index)
    IndentationError	缩进错误
    OSError	输入/输出操作失败
    ImportError	导入模块/对象失败
    NameError	未声明/初始化对象 (没有属性)
    AttributeError	对象没有这个属性
     	 
    GeneratorExit	生成器(generator)发生异常来通知退出
    TypeError	对类型无效的操作
    KeyboardInterrupt	用户中断执行(通常是输入^C)
    OverflowError	数值运算超出最大限制
    FloatingPointError	浮点计算错误
    BaseException	所有异常的基类
    SystemExit	解释器请求退出
    Exception	常规错误的基类
    StandardError	所有的内建标准异常的基类
    ArithmeticError	所有数值计算错误的基类
    EOFError	没有内建输入,到达EOF 标记
    EnvironmentError	操作系统错误的基类
    WindowsError	系统调用失败
    LookupError	无效数据查询的基类
    KeyError	映射中没有这个键
    MemoryError	内存溢出错误(对于Python 解释器不是致命的)
    UnboundLocalError	访问未初始化的本地变量
    ReferenceError	弱引用(Weak reference)试图访问已经垃圾回收了的对象
    RuntimeError	一般的运行时错误
    NotImplementedError	尚未实现的方法
    SyntaxError Python	语法错误
    TabError	Tab 和空格混用
    SystemError	一般的解释器系统错误
    UnicodeError	Unicode 相关的错误
    UnicodeDecodeError	Unicode 解码时的错误
    UnicodeEncodeError	Unicode 编码时错误
    UnicodeTranslateError	Unicode 转换时错误
    以下为警告类型	 
    Warning	警告的基类
    DeprecationWarning	关于被弃用的特征的警告
    FutureWarning	关于构造将来语义会有改变的警告
    OverflowWarning	旧的关于自动提升为长整型(long)的警告
    PendingDeprecationWarning	关于特性将会被废弃的警告
    RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
    SyntaxWarning	可疑的语法的警告
    UserWarning	用户代码生成的警告
    ————————————————
    
    
    • @ 2023-2-2 14:38:24
      #3. 冒泡排序
      
      def pop_sort(L):
          length = len(L)
          for i in range(1,length):
              for j in range(0,length - i):
                  if L[j] > L[j+1]:
                      temp = L[j]
                      L[j] = L[j+1]
                      L[j+1] = temp
      
      
      
      • @ 2023-2-2 14:34:31
        #Python 基本排序方法
        #1. 选择排序方法
        
        def select_sort(L):
                for i in range(0,len(L)):
                    minl = L[i]
                    for j in range(i+1,len(L)):
                        if L[j] < minl:
                            temp = L[j]
                            L[j] = minl
                            minl = temp
                L[i] = minl
        
        #2. 插入排序方法
        
        def insert_sort(L):
            for x in range(1,len(L)):
                for i in range(x-1,-1,-1):
                    if L[i] > L[i+1]:
                        temp = L[i+1]
                        L[i+1] = L[i]
                        L[i] = temp
        
        
        #4. 快速排序方法
        
        def quick_sort(L,start,end):
            if start < end:
                left = start
                right = end
                temp = L[start]
                while left < right:
                    while left < right and L[right] >= temp:
                        right = right - 1 
                    if(left < right):
                        L[left] = L[right]
                        left = left + 1
                    while left < right and L[left] <= temp:
                        left = left + 1
                    if(left < right):
                        L[left] = L[right]
                        right = right - 1
                L[left] = temp
                quick_sort(L,start,left-1)
                quick_sort(L,left+1,end)
        
        #5. 希尔排序方法
        
        def insert_shell(L):
            gap = (int)(len(L)/2)
            while(gap>=1):
                for i in range (gap,len(L)):
                    for j in range(i-gap,-1,-gap):
                        if L[j] > L[j+gap]:
                            temp = L[j+gap]
                            L[j+gap] = L[j]
                            L[j] = temp
                gap = (int)(gap/2)
        
        #6. 归并排序方法
        
        def mergearray(L,first,mid,last,temp):
            i = first
            j = mid + 1
            k = 0
            m = mid
            n = last
            while (i <= m) and (j <= n):
                if L[i] <= L[j]:
                    temp[k] = L[i]
                    k = k + 1
                    i = i + 1
                else:
                    temp[k] = L[j]
                    k = k + 1
                    j = j + 1
            while i <= m:
                temp[k] = L[i]
                k = k + 1
                i = i + 1
            while j <= n:
                temp[k] = L[j]
                k = k + 1
                j = j + 1
            for i in range(0,k):
                L[first + i] = temp[i]
        def mergesort(L,first,last,temp):
            if first < last:
                mid = (int)((first + last)/2)
                mergesort(L,first,mid,temp)
                mergesort(L,mid+1,last,temp)
                mergearray(a,first,mid,last,temp)
        
        #7. 堆排序方法
        
        def adjust(L,len,i):  #调整堆
            left = (int)(2*i+1)
            right = left + 1
            max = i
            #找大儿子
            if (left < len) and L[left]>L[max]:
                max = left
            if (right < len) and L[right]>L[max]:
                max = right
            if max!=i:
                temp = L[max]
                L[max] = L[i]
                L[i] = temp
                adjust(L,len,max)
        def heapsort(L,size):
            for i in range(int(size/2)-1,-1,-1):  #对每一个非叶节点进行堆调整,从最后一个非叶节点开始
                adjust(L,size,i)
            for i in range(size-1,0,-1):
                temp = L[0]
                L[0]=L[i]
                L[i]=temp  #将当前最大的放置到数组的末尾
                adjust(L,i,0)  #将未完成排序的部分继续进行堆排序
        
        #8. 基数排序
        
        #寻找最大数字的位数
        def max_nums(L):
            maxnum = L[0]
            for i in L:
                if maxnum < i:
                    maxnum = i
            flag = 0 #统计位数
            while (maxnum > 0):
                maxnum = (int)(maxnum/10)
                flag = flag + 1
            return flag
        #获取num从低位到高位的第pos个位的数据
        def get_num(num,pos):
            return ((int)(num/(10**(pos-1))))%10
        def radix_sort(L):
            count = 10*[None] #存放每个桶的数据统计个数
            bucket = (len(L))*[None]  #暂时存放排序结果
            for pos in range(1,max_nums(L)+1): #从个位开始循环
                for i in range(0,10):
                    count[i] = 0
                for i in range(0,len(L)): #统计当前位数的元素数目
                    j = get_num(int(L[i]),pos)
                    count[j] = count[j]+1
                for i in range(1,10):
                    count[i] = count[i] + count[i-1]
                for i in range(len(L)-1,-1,-1):
                    j = get_num(L[i],pos)
                    bucket[count[j] - 1] = L[i]
                    count[j] = count[j] - 1
                for i in range(0,len(L)):
                    L[i] = bucket[i]
        
        
      • @ 2023-2-2 14:26:25

        补充一下python 里的数据类型

        | 文本类型:   | `str`                              |
        | ------------ | ---------------------------------- |
        | 数值类型:   | `int`, `float`, `complex`          |
        | 序列类型:   | `list`, `tuple`, `range`           |
        | 映射类型:   | `dict`                             |
        | 集合类型:   | `set`, `frozenset`                 |
        | 布尔类型:   | `bool`                             |
        | 二进制类型: | `bytes`, `bytearray`, `memoryview` |
        
        • @ 2023-2-2 13:19:10

          顺便说一下提交后的评测状态

          • Waiting 评测:评测请求正在等待被评测机抓取
          • Fetched 评测:评测请求已被评测机抓取,正在准备开始评测
          • Compiling 评测:正在编译中
          • Judging 评测:编译成功,正在评测中
          • Accepted 通过:程序输出完全正确
          • Wrong Answer 不通过:程序输出与标准答案不一致(不包括行末空格以及文件末空行)
          • Time Limit Exceeded 不通过:程序运行时间超过了题目限制
          • Memory Limit Exceeded 不通过:程序运行内存空间超过了题目限制
          • Runtime Error 不通过:程序运行时错误(如数组越界、被零除、运算溢出、栈溢出、无效指针等)
          • Compile Error 不通过:编译失败
          • System Error 错误:系统错误(如果您遇到此问题,请及时在讨论区进行反馈)
          • Canceled 其他:评测被取消
          • Unknown Error 其他:未知错误
          • Ignored 其他:被忽略
          • @ 2023-2-2 13:20:03

            并非原创,勿喷

          • @ 2023-2-2 13:30:34

            这个大家不用理解,如果不是 100 分,就是有错记住就行啊


            还有,千万要在递交前在 Pycharm 上测试无误后在提问!!!!

            这是必须要知道的 debug 能力

        • @ 2023-2-2 9:57:49

          刚看到,针不戳👍 👍 👍

        • @ 2023-2-1 21:52:13

          这才是真正的讨论!👍

          • @ 2023-2-1 13:15:31

            不过你能整理出已经很不错了👍

            • @ 2023-2-1 13:12:22

              你可以写成这样:

              1、IndexError 索引超出序列范围

              2、KeyError 字典中查找一个不存在的关键字

              3、NameError 尝试访问一个不存在的变量

              4、IndentationError 缩进错误

              5、AttributeError 尝试访问未知的对象属性

              6、StopIteration 迭代器没有更多的值

              7、AssertionError 断言语句失败

              8、EOFError 用户输入文件末尾标志EOF

              9、FloatingPointError 浮点计算错误

              10、GeneratorExit generator.close()方法被调用的时候

              11、ImportError 导入模块失败

              12、KeyboardInterrupt 用户输入中断建

              13、MemoryError 内存溢出

              14、NotImplementedError 尚未实现的方法

              15、OSError 操作系统异常(例如打开一个不存在的文件)

              16、OverflowError 数值运算超出最大限制

              17、ReferenceError 试图访问一个已经被垃圾回收机制回收的对象

              18、RuntimError 运行错误

              19、SyntaxError 语法错误

              20、TabError Tab和空格混合使用

              21、SystemError 编译器系统错误

              22、SystemExit 编译器进程关闭

              23、TypeError 不同类型间的无效操作

              24、UnboundLocalError 访问一个未初始化的本地变量

              25、UnicodeError Unicode相关错误(ValueError的子类)

              26、UnicodeRndoceEroor Unicode编码时错误(UnicodeError的子类)

              27、UnicodeDecodeError Unicode解码时错误(UnicodeError的子类)

              28、UnicodeTranslateError Unicode转换时错误(UnicodeError的子类)

              29、ValueError 传入无效的参数

              30、ZeroDivisionError 除数为零

            • 1