金沙国际官网_金沙国际平台登录

因为这个金沙国际官网_金沙国际平台登录网站与很多的大型澳门赌场都有合作,金沙国际官网_金沙国际平台登录尽职尽责,高效执行,保持好奇心,不断学习,追求卓越,点击进入金沙国际官网_金沙国际平台登录马上体验吧,所以现在也正式地开始了营业。

您的位置:金沙国际官网 > 编程 > 元素等待机制,python之with语句的原理金沙国际官

元素等待机制,python之with语句的原理金沙国际官

发布时间:2019-11-03 05:54编辑:编程浏览(196)

        expected_conditions模块提供了多样定义好的嵌入条件,供给分外WebDriverWait使用。

    简单的try catch

    首先是二个try中尚无十分的亲自去做:

     static void Main(string[] args)
            {
                string result =GetStr();
                Console.WriteLine(result);
                Console.ReadLine();
            }
            public static string GetStr()
            {
                try
                {
                    Console.WriteLine("走到:try");
                    return "这里是try返回值";
                }
                catch (Exception e)
                {
                    Console.WriteLine("走到:catch");
                    return "这里是catch返回值";
                }
                finally
                {
                    Console.WriteLine("走到:finally");
                }
                return "这里是方法底部返回值";
            }
    

    运转结果:

    金沙国际官网 1

    推行剖析:

    那是最简便最广大的亲自去做,未有发出分外,然后未有走catch,实施顺序是try=>finally=>return;

    全体我们收获三个还不鲜明的结果在GetStr方法中不会进行措施本人的return;

    不过finally方法块都会实行;

     

    (八) 总结

    多个再度catch

    那么重复八个catch哪?那个是足以的比方下边作者这么:

      try
                {
                    str = "修改成了a";
                    Console.WriteLine("走到:try");
                    // return "这里是try返回值";
                    return str;
                }
                catch(InvalidCastException e) {
                }
                catch (Exception e)
                {
                    Console.WriteLine("走到:catch");
                    return "这里是catch返回值";
                }
    

    这一个是被允许的,因为那是有含义的写法。

    头阵时间:2018-02-23 15:28

    expected_conditions类提供了三种定义好的内置条件(预期等待条件卡塔尔国,未有放置条件符适那个时候候,也得以透过WebDriverWait自定义前置条件。

    来个特别的:

    上面大家让try方法块出错就好了,然后大家修正一下代码如下:

     public static string GetStr()
            {
                try
                {
                    int value = 0;
                    Console.WriteLine("走到:try");
                    var i = 1 / value;//这里会出错 0不能被整除
                    return "这里是try返回值";
                }
                catch (Exception e)
                {
                    Console.WriteLine("走到:catch");
                    return "这里是catch返回值";
                }
                finally
                {
                    Console.WriteLine("走到:finally");
                }
                return "这里是方法底部返回值";
            }
    

    运营结果:

    金沙国际官网 2

    试行深入分析:

    那边在try产生了充足,然后没有健康重回,步入到了catch方法块:try=>catch=>finally=>return;

    这里我们得以显著:

    • 不管try有未有出错finally方法块都会被实施。【快记笔记,知识点。】
    • 纵使try和catch方法都有return,finally都会举行;
    • 只要try或者catch return返回,try catch 之外的return都无效;

    谈到这里某个不精通人大概会有疑难?那在finally写个return是什么结果哪?很不佳的告诉你,无法这么写,写了会怎么,哼会提醒:调节不可能离开finally子句主体;

    谷歌(Google卡塔 尔(英语:State of Qatar)翻译成汉语就是:

    with语句用于选择由上下文物管理理器定义的秘诀来封装块的实行(请参见使用语句上下文物管理理器生机勃勃节卡塔 尔(英语:State of Qatar)。 那允许通用的try…except…finally使用方式被封装以便于重用【那句话大约意思正是“with语句”肖似于try…except…finally封装之后的的动静】。

    包蕴二个“项目”的with语句的实践进程如下:
    1.上下文表达式(在with_item中付出的表明式卡塔 尔(阿拉伯语:قطر‎被评估以获得上下文物处理理器。【会区分种类来管理,如文件,进度等都能够应用with语句】
    2.上下文物管理理器的__exit __(卡塔 尔(阿拉伯语:قطر‎被加载供之后选择。【担当上下文的退出】
    3.上下文微处理器的__enter __(卡塔尔方法被调用。【担负上下文的进去】
    4.只要在with语句中饱含指标,则将__enter __(卡塔尔国的重回值分配给它。【借使with后边跟着as 对象(如with open() as f卡塔尔国,那么此目的得到with上下文对象的__enter__()的重返值,(附:应该是相近操作数据库时的连年对象和游标的分别卡塔 尔(英语:State of Qatar)】

    注意
    with语句有限支撑,要是__enter __(卡塔 尔(阿拉伯语:قطر‎方法重回时尚未不当,那么将始终调用__exit __(卡塔尔国。 因而,如若在分配给指标列表时期产生错误,它将被视为与套件内爆发的乖谬形似。 请参阅上面包车型大巴第6步。

    5.该套件已推行。【意思就是语句体中的进度进行完结,试行完成就到第六步--调用__exit__()来退出】
    6.上下文微型机的__exit __(卡塔尔国方法被调用。 倘使不行招致套件退出,则其连串,值和回想作为参数字传送递给__exit __(卡塔尔。 不然,将提供八个无参数。

    关于退出返回值:
    
    If the suite was exited due to an exception, and the return value from the __exit__() method was false, the exception is reraised. If the return value was true, the exception is suppressed, and execution continues with the statement following the with statement.
    
    If the suite was exited for any reason other than an exception, the return value from __exit__() is ignored, and execution proceeds at the normal location for the kind of exit that was taken.
    
    中文:
    如果套件由于异常而退出,并且__exit __()方法的返回值为false,则会重新对异常进行重新评估。 如果返回值为true,则异常被抑制,并继续执行with语句后面的语句。
    
    如果套件由于除了异常之外的任何原因而退出,则__exit __()的返回值将被忽略,并且执行将在正常位置继续进行。
    
     
    
     
    
     
    
    意思就是:
    
    如果是异常退出,那么会返回false,(根据文档中的exit的描述“that __exit__() methods should not reraise the passed-in exception; this is the caller’s responsibility.”,大概意思就是exit()不会处理异常,会重新抛出异常抛出给外面,由调用者处理,因为这是调用者的责任)
    
     
    
    如果返回 True,则忽略异常,不再对异常进行处理【(在exit内部处理完异常后,可以让”__exit__()”方法返回True,此时该异常就会不会再被抛出,with会认为它的执行体没有发生异常)】
    
     
    
     
    

    (with会识别再次来到值,依据再次回到值来拍卖,假设是False,那么with会将推行体中的非常抛出,借使是True,那么with会认为并未生出十分(忽视分外卡塔尔,而继续推行外面包车型大巴讲话,但鉴于在这之中调用的了__exit__(),所以在充裕之后的话语是不会运营的卡塔 尔(英语:State of Qatar)

     

    沾满多少个文档中提供的一个关于with中动用锁的事例:

    金沙国际官网 3

     

     

    起来进级

    缘何要一定写try-catch-finally 作者只写此中意气风发部分不得以呢?


    until_not(method, message=''卡塔尔国:直到再次回到值为false,其余和until相似

    验证return的值

    地点大家知晓了哪些都会实践finally,可是举行了finally对大家的正再次来到值有未有印象哪,举个例子作者在try里面临二个变量赋值为a字符串,举行了回到,可是在finally里面矫正成了b字符串。会不会被改正哪?

    咱俩照旧老代码,然后纠正成我们想的标准:

    public static string GetStr()
            {
                string str = "";
                try
                {
                    str = "修改成了a";
                    Console.WriteLine("走到:try");
                    // return "这里是try返回值";
                    return str;
                }
                catch (Exception e)
                {
                    Console.WriteLine("走到:catch");
                    return "这里是catch返回值";
                }
                finally
                {
                    str = "修改成了b";
                    Console.WriteLine("走到:finally");
                }
                return "这里是方法底部返回值";
            }
    

    运营结果:

    金沙国际官网 4

    施行深入分析:

    还未有丰裕或许老样子:实施各样是try=>finally=>return;

    可是我们在finally改正了str字符串,但是通过输出结果大家得到的依旧a字符串,

    负有大家赢得结论:虽然finally方法会被施行不过,再次来到结果不会被转移,也等于如果finally是在return随后实行的那么他会把重回结果先保存起来,然后不管finally代码实行了哪些,都不会潜移暗化到再次来到结果,等finally试行到位在回来结果。

     

     1 from selenium import webdriver
     2 from selenium.webdriver.support.ui import WebDriverWait
     3 from selenium.webdriver.support import expected_conditions
     4 from selenium.webdriver.common.by import By
     5 
     6 driver = webdriver.Firefox()
     7 driver.maximize_window()
     8 driver.get('https://www.cnblogs.com/')
     9 
    10 # try:
    11 #     #等待博客园首页的【找找看】按钮可见并可用
    12 #     search_btn = WebDriverWait(driver,10).until(expected_conditions.element_to_be_clickable((By.CLASS_NAME,'search_btn')))
    13 #     print(search_btn.get_attribute('value'))
    14 
    15 # try:
    16 #     login_area = driver.find_element_by_css_selector('#login_area')
    17 #     login = login_area.find_element_by_link_text('登录')
    18 #     login.click()
    19 #     remember_me = driver.find_element_by_id('remember_me')
    20 #     remember_me.click()
    21 #     #等待直到登录页面的复选框被选中
    22 #     WebDriverWait(driver, 10).until(expected_conditions.element_located_to_be_selected((By.ID, 'remember_me')))
    23 
    24 # try:
    25 #     search_file = driver.find_element_by_id('zzk_q')
    26 #     search_btn = driver.find_element_by_class_name('search_btn')
    27 #     search_file.send_keys('python')
    28 #     search_btn.click()
    29 #     #网页标题是否包含 python
    30 #     WebDriverWait(driver, 10).until(expected_conditions.title_contains('python'))
    31 
    32 try:
    33     search_file = driver.find_element_by_id('zzk_q')
    34     #检查元素是否出现在DOM中,是可见的,并且宽和高都大于0
    35     search_file = WebDriverWait(driver,10).until(expected_conditions.visibility_of(search_file))
    36     print(search_file)
    37 finally:
    38     driver.quit()
    

     try-catch

    这就是说大家本次不写finally试豆蔻梢头试呢。try方法块未有特别已经毫无测了,因为地点大家曾经承认过了。会回去try的从头到尾的经过。那么就try格外吧。

     public static string GetStr()
            {
                try
                {
                    Console.WriteLine("走到:try");
                    int value = 0;
                    int s = 1 / value;              
                    return "这里是try返回值";
                }
                catch (Exception e)
                {
                    Console.WriteLine("走到:catch");
                    return "这里是catch返回值";
                }
                return "这里是方法底部返回值";
            }
    

    运行结果:

    金沙国际官网 5

    实行解析:

    由此方可健康运作大家领略这么写一些主题素材都不曾,所以结果正是

    • finally亦不是必需的。
    • 若果catch没有return 就能回去后面部分return方法。那是我们的常识。

    那样做有啥样功用照旧意义哪,经常我们得以上面说的概念三个catch来检验格外,还应该有八个用途正是忽略至极,就是这种特别你系统能够被运转,就能够catch内不写return正常跳过非常实行上边包车型地铁方法体。可是或不是很被提出,

    测量试验2:当else中强制重回为True时:

     

    import time
    class myContextDemo(object):
        def __init__(self,gen):
            self.gen = gen
        def __enter__(self):
            print("enter in ")
            return self.gen
        def __exit__(self, exc_type, exc_val, exc_tb):
    #exc_type是exception_type  exc_val是exception_value  exc_tb是exception_trackback
            print("exit in ")
            if exc_type is None:#如果是None 则继续执行
                print("None:",exc_type, exc_val, exc_tb)
    
            else: #异常不为空时执行,这一步,如果with语句体中发生异常,那么也会执行
                print("exception:", exc_type, exc_val, exc_tb)
                print("all done")
                return True #这里如果返回true可以看到发生异常后,main continue可以执行
                #即,如果exc_type是true,那么会继续执行,实际上,也可以在这里处理一下异常再返回true
    
    
    if __name__=="__main__":
        gen=(i for i in range(5,10))
        G=myContextDemo(gen)
        with G as f :
            print("hello")
            for i in f:
                print(i,end="t")
            raise Exception("母鸡啊")
            # print("continue")#这里不会执行
        print("main continue")
    

    结果展现:金沙国际官网 6

    1.回到True之后,with会忽视至极,继续实践,所以这里“main continue”能实行

    2.尽管忽视分外,在with体中极其之后的说话依旧不会实行

    附:理论上能够在重回True以前管理一下十分

     

     

     

     

     

     

     

    PS:若是我们想要精晓得更详尽,能够友善尝尝去读一下官方文书档案。

    依赖关于with语句的详细介绍官方文书档案:


    上面那些是WebDriverWait类自带的局地注释。

     多少个重复try

    那就是说我们能够写三个try{}try{}这样的口舌吗?不行,会平素报错,其实那样写未有别的意义。

    几个测量检验:

    driver.implicitly_wait(10)

    大致示例:

    既然有了疑问就带着疑问想办法验证吧,上边大家因此多个例子来一步一步的解析获得大家想要的结果。

    1.施行体中产生万分:

    import time
    class myContextDemo(object):
        def __init__(self,gen):
            self.gen = gen
        def __enter__(self):
            print("enter in ")
            return self.gen
        def __exit__(self, exc_type, exc_val, exc_tb):
    #exc_type是exception_type  exc_val是exception_value  exc_tb是exception_trackback
            print("exit in ")
            if exc_type is None:#如果是None 则继续执行
                print("None:",exc_type, exc_val, exc_tb)
    
            else: #异常不为空时执行,这一步,如果with语句体中发生异常,那么也会执行
                print("exception:", exc_type, exc_val, exc_tb)
                print("all done")
    
    
    
    if __name__=="__main__":
        gen=(i for i in range(5,10))
        G=myContextDemo(gen)
        with G as f :
            print("hello")
            for i in f:
                print(i,end="t")
            #测试1:执行体中发生异常
            raise Exception("母鸡啊")
        print("main continue")
    

    结果显示:金沙国际官网 7

    1.抛出非常后,前边main continue不再推行

    2.__exit__()中的else会执行

     

     

    介绍

    任由是新手或许办事几年的老油条,对try{}catch{}来讲是不不熟悉的。他得以来提携我们收获非常音信,在try中的代码现身谬误,火灾catch代码块中被抓走到。官方也给了详实的表明:。

    抛出非常时,公共语言运转库(CLTiguan卡塔 尔(阿拉伯语:قطر‎会招来catch拍卖此特别的言辞。即使当前正值执行的办法不分包这样的catch块,则CL汉兰达会查看调用当前情势的章程,依此类推调用货仓。要是未catch找到别的块,则CL812 Superfast向客商体现未管理的十二分音讯并结束实施该程序。

    以上的那一个根基大家只怕都打听。不过你确实掌握他的运作步骤吗?笔者便是带着那些难题进行了一下的多少个测量检验。

    后边看来黄金年代篇博客说博主python面试时遇会合试官提问with的原理,而那位博主的博文未有聊到with原理,故有此文。

    (五) expected_conditions模块

    try-finally

    那么try-finally哪,那样写也是被允许的。

    那般单独写第豆蔻年华正是在finally语句块内做try的财富自由。平常情形下try未有卓殊,在finally中管理try语句块的财富自由。

    其次正是try爆发了相当,其实finally起到的功用依旧相同的。但是此间分别在于大器晚成旦不行未经管理,大概就导致程序退出了。全部执不实行业已漠不关切了。大家来个可怜示例:

    金沙国际官网 8金沙国际官网 9

    static void Main(string[] args)
            {
                string result = "";
                try
                {
                    result = GetStr();
                }
                catch (Exception e)
                {
                    Console.WriteLine("主方法catch:");
                }
                Console.WriteLine(result);
                Console.ReadLine();
            }
            public static string GetStr()
            {
                try
                {
                    Console.WriteLine("走到:try");
                    int value = 0;
                    int s = 1 / value;               
                    return "这里是try返回值";
                }
    
                finally
                {
                    Console.WriteLine("走到:finally");
                }
    
                return "这里是方法底部返回值";
            }
    

    View Code

    运行结果:

    金沙国际官网 10

    进行解析:

    try爆发了那么些,但是因为finally始终都会实施全部也会实行,然后非常被调用方法内的catch捕获试行顺序:try=>finally=>catch(主方法)

    具有大家拿到结果:

    • try-finally能够运维
    • try若无catch可是爆发极其会进步找catch方法块来捕获。知道未有系统崩溃。

    以上的事例都以非调控(系统现身卓殊就自行抛出了卡塔尔国的抛出特别,那么我们能够垄断(monopoly卡塔 尔(英语:State of Qatar)特其余抛出点吗?当然能够。

    关于with语句,官方文书档案中是这么描述的:

    The with statement is used to wrap the execution of a block with methods defined by a context manager (see section With Statement Context Managers). This allows common try...except...finally usage patterns to be encapsulated for convenient reuse.

    with_stmt ::= "with" with_item ("," with_item)* ":" suite

    with_item ::= expression ["as" target]

    The execution of the with statement with one “item” proceeds as follows:

    The context expression (the expression given in the with_item) is evaluated to obtain a context manager.

    The context manager’s __exit__() is loaded for later use.

    The context manager’s __enter__() method is invoked.

    If a target was included in the with statement, the return value from __enter__() is assigned to it.

    Note
    The with statement guarantees that if the __enter__() method returns without an error, then __exit__() will always be called. Thus, if an error occurs during the assignment to the target list, it will be treated the same as an error occurring within the suite would be. See step 6 below.

    The suite is executed.

    The context manager’s __exit__() method is invoked. If an exception caused the suite to be exited, its type, value, and traceback are passed as arguments to __exit__(). Otherwise, three None arguments are supplied.

     

    本文由金沙国际官网发布于编程,转载请注明出处:元素等待机制,python之with语句的原理金沙国际官

    关键词:

上一篇:没有了

下一篇:没有了