精华内容
下载资源
问答
  • python提供了两个非常重要的功能来处理python程序在运行出现的异常和错误。你可以使用该功能来调试python程序 新手提醒  新手编写代码时,经常会遇到代码报错,很多小伙伴英文不好,不知道报错的是什么意思?现...

    前言

     python提供了两个非常重要的功能来处理python程序在运行中出现的异常和错误。你可以使用该功能来调试python程序

    新手提醒

     新手编写代码时,经常会遇到代码报错,很多小伙伴英文不好,不知道报错的是什么意思?现整理一份异常类型

    异常类型

    异常名称 描述
    BaseException 所有异常的基类
    SystemExit 解释器请求退出
    KeyboardInterrupt 用户中断执行(通常是输入^C)
    Exception 常规错误的基类
    StopIteration 迭代器没有更多的值
    GeneratorExit 生成器(generator)发生异常来通知退出
    StandardError 所有的内建标准异常的基类
    ArithmeticError 所有数值计算错误的基类
    FloatingPointError 浮点计算错误
    OverflowError 数值运算超出最大限制
    ZeroDivisionError 除(或取模)零 (所有数据类型)
    AssertionError 断言语句失败
    AttributeError 对象没有这个属性
    EOFError 没有内建输入,到达EOF 标记
    EnvironmentError 操作系统错误的基类
    IOError 输入/输出操作失败
    OSError 操作系统错误
    WindowsError 系统调用失败
    ImportError 导入模块/对象失败
    LookupError 无效数据查询的基类
    IndexError 序列中没有此索引(index)
    KeyError 映射中没有这个键
    MemoryError 内存溢出错误(对于Python 解释器不是致命的)
    NameError 未声明/初始化对象 (没有属性)
    UnboundLocalError 访问未初始化的本地变量
    ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了的对象
    RuntimeError 一般的运行时错误
    NotImplementedError 尚未实现的方法
    SyntaxError Python 语法错误
    IndentationError 缩进错误
    TabError Tab 和空格混用
    SystemError 一般的解释器系统错误
    TypeError 对类型无效的操作
    ValueError 传入无效的参数
    UnicodeError Unicode 相关的错误
    UnicodeDecodeError Unicode 解码时的错误
    UnicodeEncodeError Unicode 编码时错误
    UnicodeTranslateError Unicode 转换时错误
    Warning 警告的基类
    DeprecationWarning 关于被弃用的特征的警告
    FutureWarning 关于构造将来语义会有改变的警告
    OverflowWarning 旧的关于自动提升为长整型(long)的警告
    PendingDeprecationWarning 关于特性将会被废弃的警告
    RuntimeWarning 可疑的运行时行为(runtime behavior)的警告
    SyntaxWarning 可疑的语法的警告
    UserWarning 用户代码生成的警告

    在这里插入图片描述


    如果你不想再体验一次自学时找不到学习资料,没人解答问题,坚持几天便放弃的话,可以加我们的软件测试交流群【902061117】

    展开全文
  • python中参数类型有哪些 位置参数:也叫必备参数,指函数调用时,传入实参数量和位置、类型必须与函数定义时保持一致,即形参和实参位置数量必须一致 # 在调用func函数时,必须按位置传入name和age,多了少了...

    python中参数类型有哪些

    • 位置参数:也叫必备参数,指函数调用时,传入的实参数量和位置、类型必须与函数定义时保持一致,即形参和实参的位置数量必须一致
    # 在调用func函数时,必须按位置传入name和age,多了少了都不行,否则会抛出TypeError异常
    def func(name, age):
        """
        :param name: str
        :param age: int
        :return: tuple
        """
        print(name, age)
    
    func('lucy' ,18)
    func(*('lucy' ,18))  # 使用*解构
    
    # 结果
    '''
    lucy 18
    lucy 18
    '''
    
    • 默认参数

      • 函数定义时,为参数设置一个默认值,当函数调用时,没有传入这个参数值,直接使用这个默认值。指定有默认值的形参,必须是在没有默认值的参数的最后,否则会产生语法错误;而且默认参数必须指向不可变对象,如果指向可变对象,多次调用时,可能得到的不是意料之内的结果
      def func(x, y=0):
        """
        :param x: int
        :param x: int
        :return:
        """
        return x + y
      
      print(func(3))  # 传入参数x=3
      print(func(3, 4))  # 传入参数x=3, y=4
      
      # 结果
      '''
      3
      7
      '''
      
    • 关键字参数:函数调用时,是指使用形式参数的名字来确定输入的参数值,(形参的名字=输入的参数值),通过此方式指定函数实参时,不再需要与形参的位置完全一致,只要将参数名写正确即可;使用位置参数和关键字参数混合传参的方式时,关键字参数必须位于所有的位置参数(即前面必须传位置参数,最后在传关键字参数,位置得对应)。

    def func(x, y):
        """
        :param x: int
        :param x: int
        :return:
        """
        return x + y
    
    print(func(3, 4))  # 位置参数
    print(func(x=3, y=4))  # 关键字参数
    print(func(y=4, x=3))  # 关键字参数,位置改变
    print(func(3, y=4))  # 位置参数与关键字混合
    
    # 结果
    '''
    7
    7
    7
    7
    '''
    
    • 可变位置参数:定义参数时前面加一个*,表示这个参数是可变的,可以接受任意多个参数,这些参数构成一个元组,只能通过位置参数传递。
    # 可以接收不定参数,返回的类型是元组
    def func(*args):
        """
        :param args:
        :return:
        """
        print(type(args))
        sum = 0
        for i in args:
            sum += i
        return sum
    
    print(func(1, 2, 3))
    print(func(*(1, 2, 3)))  # 使用*解构
    
    # 结果
    '''
    <class 'tuple'>
    6
    <class 'tuple'>
    6
    '''
    
    • 可变关键字参数:定义参数时,在前面加**,**kwargs表示这个参数可变,可以接受零个或多个关键字参数,并以字典的形式传入函数体,关键字为字典的key,关键字绑定的值为value,如果可变关键字没有接收到任何参数,则传入函数体一个空字典{}。
    # 只接收可变关键字参数
    def func(**kwargs):
        """
        :param kwargs:
        :return:
        """
        kwargs_type = (str(type(kwargs))).split("'")[1]
        print("kwargs: 类型为{0}, 值为{1}".format(kwargs_type, kwargs))
    
    func()  # 未传任何参数,返回空字典
    func(x=1, y=2, z=3)  # 关键字对传参
    func(**{'x': 1, 'y': 2, 'z': 3})  # 使用**解包字典
    
    # 结果
    '''
    kwargs: 类型为dict, 值为{}
    kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3}
    kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3}
    '''
    
    # 可变位置参数与可变关键字参数一起使用,这是可变位置参数必须在前面
    def func(*args, **kwargs):
        """
        :param args:
        :param kwargs:
        :return:
        """
        args_type = (str(type(args))).split("'")[1]
        kwargs_type = (str(type(kwargs))).split("'")[1]
        print("args: 类型为{0}, 值为{1}".format(args_type, args))
        print("kwargs: 类型为{0}, 值为{1}".format(kwargs_type, kwargs))
    
    print("未传任何参数:")
    func()  # 未传任何参数,返回args为空元组,kwargs我空字典
    print("只传入可变位置参数:")
    func(1, 2, 3)
    print("只传入可变关键字参数:")
    func(x='a', y='b', z='c')
    print("传入可变位置参数和可变关键字参数:")
    func(1, 2, 3, x='a', y='b', z='c')
    func(1, 2, 3, **{'x': 1, 'y': 2, 'z': 3})  # 使用 **解包
    
    # 结果
    '''
    未传任何参数:
    args: 类型为tuple, 值为()
    kwargs: 类型为dict, 值为{}
    只传入可变位置参数:
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{}
    只传入可变关键字参数:
    args: 类型为tuple, 值为()
    kwargs: 类型为dict, 值为{'x': 'a', 'y': 'b', 'z': 'c'}
    传入可变位置参数和可变关键字参数:
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{'x': 'a', 'y': 'b', 'z': 'c'}
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3}
    '''
    
    # 位置参数,可变位置参数、默认参数、可变关键字参数结合
    # 参数定义顺序:位置参数->*args->默认参数->**kwargs
    def func(m, n, *args, flag=0, **kwargs):
        """
        :param args:
        :param kwargs:
        :return:
        """
        print("m: %s" % m)
        print("n: %s" % n)
        print("flag: %s" % flag)
        args_type = (str(type(args))).split("'")[1]
        kwargs_type = (str(type(kwargs))).split("'")[1]
        print("args: 类型为{0}, 值为{1}".format(args_type, args))
        print("kwargs: 类型为{0}, 值为{1}".format(kwargs_type, kwargs))
    
    
    print("只传位置参数:")
    func(22, 33)  # 这时默认参数flag=0
    print("以关键字参数形式传入位置参数:")
    func(m=22, n=33)
    print("传入位置参数和可变位置参数:")
    func(22, 33, 1, 2, 3)
    print("位置参数、可变位置参数、默认参数:")
    func(22, 33, 1, 2, 3, flag=666)
    print("位置参数、可变位置参数、默认参数和可变关键字参数:")
    func(22, 33, 1, 2, 3, flag=666, x='a', y='b', z='c')
    print("以**解包形式传入位置参数:")
    func(22, 33, 1, 2, 3, flag=666, **{'x': 1, 'y': 2, 'z': 3})
    
    # 结果
    '''
    只传位置参数:
    m: 22
    n: 33
    flag: 0
    args: 类型为tuple, 值为()
    kwargs: 类型为dict, 值为{}
    以关键字参数形式传入位置参数:
    m: 22
    n: 33
    flag: 0
    args: 类型为tuple, 值为()
    kwargs: 类型为dict, 值为{}
    传入位置参数和可变位置参数:
    m: 22
    n: 33
    flag: 0
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{}
    位置参数、可变位置参数、默认参数:
    m: 22
    n: 33
    flag: 666
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{}
    位置参数、可变位置参数、默认参数和可变关键字参数:
    m: 22
    n: 33
    flag: 666
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{'x': 'a', 'y': 'b', 'z': 'c'}
    以**解包形式传入位置参数:
    m: 22
    n: 33
    flag: 666
    args: 类型为tuple, 值为(1, 2, 3)
    kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3}
    '''
    
    • 仅限关键字参数:在*号之后的参数只能通过关键字参数传递的叫keyword-only参数。其中,可变位置参数之后的参数也是keyword-only参数
    # *号的参数用关键字参数形式传参
    def func(*, x):
        """
        :param x:
        :return:
        """
        print(x)
    
    func(x=3)
    
    # 结果
    '''
    3
    '''
    
    # 可变位置参数后的参数,也是仅限关键字参数
    def func(*args, x):
        """
        :param args:
        :param x:
        :return:
        """
        args_type = (str(type(args))).split("'")[1]
        print("args: 类型为{0}, 值为{1}".format(args_type, args))
        print("x: %s" % x)
    
    print("---- 只传关键字参数: ----")
    func(x=3)
    print("---- 传入可变位置参数和关键字参数:----")
    func(1,2,3, x=666)
    
    # 结果
    '''
    ---- 只传关键字参数: ----
    args: 类型为tuple, 值为()
    x: 3
    ---- 传入可变位置参数和关键字参数:----
    args: 类型为tuple, 值为(1, 2, 3)
    x: 666
    '''
    
    # 可变位置参数、普通参数、默认参数组成仅限关键字参数
    def func(*args, x, y=0):
        """
        :param args:
        :param x:
        :param y:
        :return:
        """
        args_type = (str(type(args))).split("'")[1]
        print("args: 类型为{0}, 值为{1}".format(args_type, args))
        print("x: %s" % x)
        print("y: %s" % y)
    
    print("---- 只传关键字参数: ----")
    func(x=3)
    print("---- 传入可变位置参数和关键字参数:----")
    func(1,2,3, x=666)
    print("---- 传入可变位置参数、关键字参数和默认参数:----")
    func(1,2,3, x=666, y=333)
    
    # 结果
    '''---- 只传关键字参数: ----
    args: 类型为tuple, 值为()
    x: 3
    y: 0
    ---- 传入可变位置参数和关键字参数:----
    args: 类型为tuple, 值为(1, 2, 3)
    x: 666
    y: 0
    ---- 传入可变位置参数、关键字参数和默认参数:----
    args: 类型为tuple, 值为(1, 2, 3)
    x: 666
    y: 333
    '''
    
    • 参数解构:参数解构发生在函数调用时,可变参数发生在函数定义的时
      • *解构:解构对象是可迭代对象,结构后的结果为位置参数
      • **解构:解构对象是字典,解构后的结果为关键字参数,这里key必须是str类型,且和函数定义的形参名一致,否则抛出TypeError异常
    def add(x, y):
        return x + y
    
    # 位置参数解构
    data1 = (1, 2)
    print(add(*data1))
    
    # 关键字参数解构
    data2 = {'x': 3, 'y': 4}
    print(add(**data2))
    
    # 结果
    '''
    3
    7
    '''
    
    展开全文
  • 职场人必学的Python自动化测试框架有哪些?常用的Python自动化测试框架有Robot Framework、Pytest、UnitTest/PyUnit、Behave、Lettuce。软件测试自动化在预设条件下运行系统或应用程序,评估运行结果,预先条件应...

    职场人必学的Python自动化测试框架有哪些?常用的Python自动化测试框架有Robot Framework、Pytest、UnitTest/PyUnit、Behave、Lettuce。软件测试的自动化在预设条件下运行系统或应用程序,评估运行结果,预先条件应包括正常条件和异常条件。自动化测试以人为驱动的测试行为转化为机器执行的一种过程。

    实现软件测试自动化用到一些Python自动化测试框架:

    一、Robot Framework

    Robot Framework主要被用在测试驱动类型的开发与验收中。虽然是由Python开发而来但也可以在基于.Net的IronPython和基于Java的Jython上运行。作为一个Python框架Robot还能够兼容诸如Windows、MacOS、以及Linux等平台。

    使用先决条件:在使用Robot Framework之前先安装Python 2.7.14及以上的版本。推荐使用Python 3.6.4以确保适当的注释能够被添加到代码段中并能够跟踪程序的更改。同时还需要安装Python包管理器–pip。下载相应的开发框架,如:在开发者圈子里比较流行的PyCharm社区版。另外由于其代码段本身并不依赖于任何IDE,因此完全可以沿用手头既有的IDE工具。

    二、Pytest

    适用于多种软件测试的Pytest是另一个Python类型的自动化测试框架。凭借着其开源和易学的特点该工具经常被QA团队、开发团队、个人团队、以及各种开源项目所使用。鉴于Pytest具有“断言重写”之类的实用功能许多大型互联网应用。

    使用先决条件:除了基本的Python知识用户并不需要更多的技术储备。另外用户只需要有一台带有命令行界面的测试设备,并安装好了Python包管理器、以及可用于开发的IDE工具。

    三、UnitTest/PyUnit

    UnitTest/PyUnit是一种标准化的针对单元测试的Python类自动化测试框架。基类TestCase提供了各种断言方法、以及所有清理和设置的例程。因此TestCase子类中的每一种方法都是以“test”作为名词前缀,以标识它们能够被作为测试用例所运行。用户可以使用load方法和TestSuite类来分组、并加载各种测试。也可以通过联合使用来构建自定义的测试运行器。正如我们使用Junit去测试Selenium那样,UnitTest也会用到UnitTest-sml-reporting、并能生成各种XML类型的报告。

    使用先决条件:由于UnitTest默认使用了Python,因此我们并不需要什么先决条件。除了需要具备Python框架的基本知识,也可以额外地安装pip、以及用于开发的IDE工具。

    四、Behave

    行为驱动开发(behavior-driven development,BDD),是一种基于敏捷软件开发的方法。它能够鼓励开发人员、业务参与者和QA人员,三者之间的协作。作为另一种Python测试框架,Behave允许团队避开各种复杂的情况,去执行BDD测试。从本质上说,该框架与SpecFlow和Cucumber非常相似,常被用于执行自动化测试。用户可以通过简单易读的语言来编写测试用例,并能够在其执行期间粘贴到代码之中。而且,那些被设定的行为规范与步骤,也可以被重用到其他的测试方案中。

    使用先决条件:任何具备Python基础知识的人都可以使用Behave。其他先决条件还包括:必须先安装Python 2.7.14及以上的版本。需要通过Python包管理器或pip来与Behave协作。大多数开发人员会选择Pycharm作为开发环境,当然也可以选用其他的IDE工具。

    五、Lettuce

    Lettuce是另一种基于Cucumber和Python的行为驱动类自动化工具。Lettuce主要专注于那些具有行为驱动开发特征的普通任务。它不但简单易用,而且能够使得整个测试过程更流畅、甚至更有趣。

    使用先决条件:需要安装带有IDE的Python 2.7.14、及以上的版本。当然,也可以使用Pycharm或任何其他IDE工具。同时,还需要安装Python包管理器。

    五种自动化测试的Python框架中Pytest、Robot Framework和UnitTest可主要用于功能与单元测试,而Lettuce和Behave仅适用于行为驱动测试。

    0基础小白收藏系列------软件测试自学资源

    展开全文
  • 在之前我们已经说过了Python中的内置的主要的几种对象类型,(数,字符串,列表,元组和字典)。而面向对象的核心任务还没出场呢 。那么我们常说的对象是什么类型的呢,其实他的类型就是“类”,有点抽象,但就是...

    在之前我们已经说过了 Python 中的内置的主要的几种对象类型,(数,字符串,列表,元组和字典)。而面向对象的核心人物还没出场呢 。那么我们常说的对象是什么类型的呢,其实他的类型就是“类”。继承封装和多态,这时通用的面向对象编程的思想 。

    继承是为了提高代码的复用性,子类可以通过继承父类来实现父类中的方法,这就是光明正大的偷懒 。举例:

    class Person():
        def eat(self):
            print("person can eat ...")
        def slepp(self):
            print("person can slepp ...")
    
    calss Man(Person):
        def hardWork(self):
            print("man should be work hard ...")
    
    # 测试
    m = Man()
    m.eat()
    # person can eat ...

    以上一个例子,说明了很多问题,首先,定义类是使用class关键字,定义方法使用def,默认传入一个参数,其实这个参数不一定非要叫self但是为了辨识性,我们这样定义,因为它代表的就是当前对象,类似 Java 中的 this 。当然还有我们的继承是通过一个括号+父类来定义的,那为什么Person没有写呢,其实这里省略了一个object 不写就表示默认继承 object 超类 。另外,Python 支持多继承,像这样即可,calss Man(Animal,Person) 一个问题需要注意,当多个父类中含有同一个方法时,以后面的为准 。但是,强烈不推荐大家使用多继承 。

    封装,理解起来很简单,就是将类中的属性信息隐藏起来,提供公共的方法以备调用,我们将属性进行 ” 私有化 “,在属性的前面加上两个下划线 __name 定义一个假的私有的属性 。看例子:

    class Man():
    
        def __init(self): # 这是对象的初始化方法,创建对象是默认执行
            self.__name = ''
    
        def set_name(self,name):
            self.__name = name
        def get_name(self):
            return self.__name
    
    m = Man() # 创建对象
    m.set_name('YJK923') # 设置 name 值 ( 其实是 _Man__name )
    m.get_name() # 获取 name 值 ( 其实是 _Man__name )
    'YJK923'
    m.name = 'YJK' #注意这里是另外添加了一个属性 name
    m.get_name() # 获取 name 值 ( 其实是 _Man__name )
    'YJK923'
    m.name # 获取的是刚刚为 m 创建的 name 的值
    'YJK'
    m._Man__name # 获取属性 _Man__name ,这就是 Python 猫腻的地方,其实并没有私有化,只是转化格式了 。
    'yu'

    还有就是多态了,简单理解,就是有多种状态,常见的就是同一个方法但是执行的效果却不一样,就像是同一个名字人有太多了,而每个人却又不一样,看吧,编程思想也都是来自于日常的生活 。举例吧 ,都是睡觉 ,但是有的人喜欢躺在床上,有的人喜欢睡在椅子上 。用代码怎么实现呢 ?看下面

    class People():
        def sleep(self):
            print("人睡觉 。。。")
    
    class Roommate(People):
        def sleep(self):
            print('睡在椅子上 。。。')

    看吧,同样是睡觉,Roommate 却是睡在椅子上,通过继承的方式实现多态只是实现多态的一种方式而已 。还可以通过其它的方式,比方说这样,方法的参数是超类。

    # 不同的对象调用同样的方法,结果却一样 。
    fun(obj):
        print( obj.__len__() )

    附加说几个比方常用的方法

    # 标准模块 random 中包含一个名为 choice 的函数,用于从序列中水机选择一个元素。
    from random import choice
    x = choice(['Hello,world !',[1,2,'e','e',4]])
    x.count('e')
    2 # 随机生成的,也可能不是 2
    
    # 判断类 A 是不是 B 的子类
    issubclass(A,B) # 儿子在前,老子在后
    
    # 查找类 A 的所有父类
    A.__bases__
    
    # 查找一个对象 A 中的所有属性
    A.__dict__
    
    # 查找对象 A 属于哪一个类
    A.__class__
    
    # 检查方法或属性是否存在与对象中
    hasattr(instance,'methedName | attrName')
    
    # 设置对象的属性
    setattr(instance,'attrName',value')

    关于抽象类:定义了一种规则(抽象方法),继承这个类的子类必须实现抽象类中的抽象方法 。而且,抽象类是不能被实例化的 。
    Python 中引入了 abc 模块来实现抽象类的定义,示例:

    # 下面表示定义了一个 抽象类 Talker , 包含一个抽象方法 talk .
    
    from abc import ABC,abstractmethod
    
    class Talker(ABC):
        @abstractmethod
        def talk(self):
            pass

    插播一曲关于面向对象设计的一些思考 。

    1. 将相关的东西放在一起,如果一个方法要使用全局变量,那就将他作为类的属性和方法
    2. 不要让对象之间过于亲密 。这就是所谓的解耦和吧 。
    3. 慎用继承,尤其是多重继承 。
    4. 保持简单,让方法尽可能的短小精悍 。
    如何将需求转化为具体的实体类呢 ? 我们可以尝试这样做 。
    将需求描述出来记录其中的名词,动词和形容词。
    在名词中找出可能的类,
    在动词中找出可能的方法,
    在形容词中找出可能的属性,
    最后将找出的方法和属性分配给各个类。
    这样类的模型就出来了,然后我们可以思考对象之间的关系,继承或是组合。
    后面再思考一下对应业务有哪些可以使用的模式,待各个业务模块都思考清楚后就可以着手编程了 。

    下面简单的说一下 Python 中的异常处理机制 。

    抛出异常使用关键字 raise 例如,raise Exception('exception msg !') 但是需要注意的是异常的抛出只能是 Exception 或 Exception 的子类 。

    捕获异常:我们可以使用try ... except : ... finally: ... 语句块来处理可能出现异常的代码 。

    try 
        1 / 0
    except ZeroDivisionError as e:
        print(e)
    else :
        print('No exception will run ...')
    finally :
        print('must be run ... ')

    自定义异常类,定义一个类继承 Exception 类即可 。

    class MyException(Exception):
        pass
    展开全文
  • 文章目录1. Python 3 print函数代替了print语句2. Python3 默认使用 UTF-8 编码3....在 Python2.x ,输出数据使用是 print 语句,例如: >>> print "3,4" 3,4 # 或者 >>> pr
  • 本文主要是认识python的异常有哪些类型,以及如何进行python异常处理?有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。如果有其它编程语言经验,如Java,可以理解的更深入些。 Python...
  • 断点调试作为pycharm基础测试,使我们每个学习了python小伙伴同样需要掌握。下面我们就其中行断点和异常断点为大家进行详细讲解。 断点源代码一种标记,可使程序在特定点暂停,检查程序运行情况。基本...
  • 在学习python异常处理之前,首先你要理解python有哪些常见错误类型,这些错误类型都是怎么产生。要熟悉这些错误类型,可以编写相应程序命令,出现相应错误类型以便快速熟悉python中常见错误。接着当你看到...
  • python题目集锦

    2020-06-01 14:46:04
    2.Python 内建数据类型有哪些? 3.简述 with 方法打开处理文件帮我我们做了什么? 4.列出 Python 可变数据类型和不可变数据类型,为什么? 5.Python 获取当前日期? 6.统计字符串每个单词出现次数 7.用 python ...
  • 1.列出 5 个常用 Python 标准库 2.Python 内建数据类型有哪些 3. 简述 with 方法打开处理文件帮我我们做了什么 4. 列出 Python 可变数据类型和不可变数据类型为什么 5.Python 获取当前日期 6. 统计字符串每个单词...
  • python3知识汇总

    2019-03-09 20:45:45
    1.什么是python Python 是一种编程语言,它有对象、模块、线程、异常处理和自动内存管理 Python 是一种解释型...2.python中的类型有哪些 number(数字) string(字符串) dictionary(字典) tuple(元组) list(列表)...
  • python报错合集

    2021-02-01 13:36:13
    我又来啦,今天让我们来看看python中有哪些常见的异常报错吧 说到python中的报错,我们总是脑壳疼 现在我们要学会去认识报错的类型 这样子,在我们出现报错的时候就可以知道报错的原因是什么啦 1.SyntaxError ...
  • python基础问题汇总

    万次阅读 2020-06-01 18:09:01
    2.Python的内建数据类型有哪些? string, int, list, tuple, dict 3.简述 with 方法打开处理文件帮我我们做了什么? with 语句适用于对资源进行访问场合,确保不管使用过程是否发生异常都会执行必要“清理”...
  • Python复习笔记

    2019-04-27 14:26:38
    Python适合开发哪些类型的应用呢? 首选是网络应用,包括网站、后台服务等等; - PythonWeb 其次是许多日常需要小工具,包括系统管理员需要脚本任务等等; - Python 另外就是把其他语言开发程序再包装...
  • Python编程入门经典

    热门讨论 2013-10-27 14:17:39
    8.3 os中的异常 119 8.3.1 路径 120 8.3.2 目录内容 122 8.3.3 获取文件信息 123 8.3.4 重命名、移动、复制和删除 文件 125 8.3.5 示例:轮换文件 126 8.3.6 创建和删除目录 127 8.3.7 通配 128 8.4 本章小结 129 ...
  • </li><li>diagnostics可以部分放到Python中支持,可以原生地处理各种Python异常</li><li>在全面支持Python3.6以后,甚至type checking也可以放到Python中去做</li></ol> 该设计问题 <ol><li>具有一定...
  • 3.python中的数据类型,哪些可变,哪些不可变 数字,字符串,元组不可变 列表,字典可变 集合包括可变集合和不可变集合 4.python异常处理有哪些? try/except 语句,检测try语句块错误,从而让except语句捕获异常...
  • 刚刚面试了百度医疗健康部门的日常实习算法岗,面经如下: 一面(一个小时20分钟) ...python数据类型有哪些 八种 列表和元祖的区别 python内存管理机制介绍 python如何用一条语句去除列表中的空...
  • 3.1.6 C变量存储类型有哪些? 3.1.7 动态规划本质 3.1.8 实践如何优化MySQL? 3.1.9 什么情况下设置了索引但无法使用? 3.2.0 SQL语句优化 3.2.1 数据库索引底层实现原理和优化 3.2.2 HTTP和HTTPS...
  • 使用Arouter注意事项有哪些?如何让代码变得更加容易让人维护? 直接看我这篇博客:https://juejin.im/post/5c46e6fb6fb9a049a5713bcc 4.6 存在待解决问题 动态管理组件,所以给每个组件添加几个生命周期...
  • 以下两图是实际问答运行过程中的截图: 项目运行方式 1、配置要求:要求配置neo4j数据库及相应的python依赖包。neo4j数据库用户名密码记住,并修改相应文件。 2、知识图谱数据导入:python build_medicalgraph.py...

空空如也

空空如也

1 2
收藏数 34
精华内容 13
关键字:

python中的异常类型有哪些

python 订阅