精华内容
下载资源
问答
  • js的with语句使用方法

    2020-10-30 16:11:49
    js的with语句使用方法
  • 主要介绍了Javascript中With语句用法,实例分析了javascript中with语句的相关使用方法,类似VB语句的用法,需要的朋友可以参考下
  • 主要介绍了Python with语句用法原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Python with语句用法

    千次阅读 2017-08-30 18:01:26
    With语句是什么? Python’s with statement provides a very convenient way of dealing with the situation where you have to do a setup and teardown to make something happen. A very good example for this ...
     

    With语句是什么?

    Python’s with statement provides a very convenient way of dealing with the situation where you have to do a setup and teardown to make something happen. A very good example for this is the situation where you want to gain a handler to a file, read data from the file and the close the file handler. 有一些任务,可能事先需要设置,事后做清理工作。对于这种场景,Python的with语句提供了一种非常方便的处理方式。一个很好的例子是文件处理,你需要获取一个文件句柄,从文件中读取数据,然后关闭文件句柄。 Without the with statement, one would write something along the lines of: 如果不用with语句,代码如下:
    1
    2
    3
    file = open ( "/tmp/foo.txt" )
    data = file .read()
    file .close()
    There are two annoying things here. First, you end up forgetting to close the file handler. The second is how to handle exceptions that may occur once the file handler has been obtained. One could write something like this to get around this: 这里有两个问题。一是可能忘记关闭文件句柄;二是文件读取数据发生异常,没有进行任何处理。下面是处理异常的加强版本:
    1
    2
    3
    4
    5
    file = open ( "/tmp/foo.txt" )
    try :
         data = file .read()
    finally :
         file .close()
    While this works well, it is unnecessarily verbose. This is where with is useful. The good thing about with apart from the better syntax is that it is very good handling exceptions. The above code would look like this, when using with: 虽然这段代码运行良好,但是太冗长了。这时候就是with一展身手的时候了。除了有更优雅的语法,with还可以很好的处理上下文环境产生的异常。下面是with版本的代码:
    1
    2
    with open ( "/tmp/foo.txt" ) as file :
         data = file .read()

    with如何工作?

    while this might look like magic, the way Python handles with is more clever than magic. The basic idea is that the statement after with has to evaluate an object that responds to an __enter__() as well as an __exit__() function. 这看起来充满魔法,但不仅仅是魔法,Python对with的处理还很聪明。基本思想是with所求值的对象必须有一个__enter__()方法,一个__exit__()方法。 After the statement that follows with is evaluated, the __enter__() function on the resulting object is called. The value returned by this function is assigned to the variable following as. After every statement in the block is evaluated, the __exit__() function is called. 紧跟with后面的语句被求值后,返回对象的__enter__()方法被调用,这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后,将调用前面返回对象的__exit__()方法。 This can be demonstrated with the following example: 下面例子可以具体说明with如何工作:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #!/usr/bin/env python
    # with_example01.py
     
     
    class Sample:
         def __enter__( self ):
             print "In __enter__()"
             return "Foo"
     
         def __exit__( self , type , value, trace):
             print "In __exit__()"
     
     
    def get_sample():
         return Sample()
     
     
    with get_sample() as sample:
         print "sample:" , sample
    When executed, this will result in: 运行代码,输出如下
    1
    2
    3
    4
    bash - 3.2 $ . / with_example01.py
    In __enter__()
    sample: Foo
    In __exit__()
    As you can see, The __enter__() function is executed The value returned by it - in this case "Foo" is assigned to sample The body of the block is executed, thereby printing the value of sample ie. "Foo" The __exit__() function is called. What makes with really powerful is the fact that it can handle exceptions. You would have noticed that the __exit__() function for Sample takes three arguments - val, type and trace. These are useful in exception handling. Let’s see how this works by modifying the above example. 正如你看到的, 1. __enter__()方法被执行 2. __enter__()方法返回的值 - 这个例子中是"Foo",赋值给变量'sample' 3. 执行代码块,打印变量"sample"的值为 "Foo" 4. __exit__()方法被调用 with真正强大之处是它可以处理异常。可能你已经注意到Sample类的__exit__方法有三个参数- val, type 和 trace。 这些参数在异常处理中相当有用。我们来改一下代码,看看具体如何工作的。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #!/usr/bin/env python
    # with_example02.py
     
     
    class Sample:
         def __enter__( self ):
             return self
     
         def __exit__( self , type , value, trace):
             print "type:" , type
             print "value:" , value
             print "trace:" , trace
     
         def do_something( self ):
             bar = 1 / 0
             return bar + 10
     
    with Sample() as sample:
         sample.do_something()
    Notice how in this example, instead of get_sample(), with takes Sample(). It does not matter, as long as the statement that follows with evaluates to an object that has an __enter__() and __exit__() functions. In this case, Sample()’s __enter__() returns the newly created instance of Sample and that is what gets passed to sample. 这个例子中,with后面的get_sample()变成了Sample()。这没有任何关系,只要紧跟with后面的语句所返回的对象有__enter__()和__exit__()方法即可。此例中,Sample()的__enter__()方法返回新创建的Sample对象,并赋值给变量sample。 When executed: 代码执行后:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    bash - 3.2 $ . / with_example02.py
    type : < type 'exceptions.ZeroDivisionError' >
    value: integer division or modulo by zero
    trace: <traceback object at 0x1004a8128 >
    Traceback (most recent call last):
       File "./with_example02.py" , line 19 , in <module>
         sample.do_something()
       File "./with_example02.py" , line 15 , in do_something
         bar = 1 / 0
    ZeroDivisionError: integer division or modulo by zero
    Essentially, if there are exceptions being thrown from anywhere inside the block, the __exit__() function for the object is called. As you can see, the type, value and the stack trace associated with the exception thrown is passed to this function. In this case, you can see that there was a ZeroDivisionError exception being thrown. People implementing libraries can write code that clean up resources, close files etc. in their __exit__() functions. 实际上,在with后面的代码块抛出任何异常时,__exit__()方法被执行。正如例子所示,异常抛出时,与之关联的type,value和stack trace传给__exit__()方法,因此抛出的ZeroDivisionError异常被打印出来了。开发库时,清理资源,关闭文件等等操作,都可以放在__exit__方法当中。 Thus, Python’s with is a nifty construct that makes code a little less verbose and makes cleaning up during exceptions a bit easier. 因此,Python的with语句是提供一个有效的机制,让代码更简练,同时在异常产生时,清理工作更简单。 I have put the code examples given here on Github. 示例代码可以在 Github上面找到。 译注:本文原文见 Understanding Python's "With" Statement
    展开全文
  • python with语句用法

    千次阅读 2019-02-20 19:54:59
    在python语言中,with语句适用于资源相关操作,锁相关操作,文件相关操作,异常处理等相关操作情景,可以代替try...except...finally...的模式,让程序员不用写一些可能会忘写的收尾的代码,使代码更简洁。 如下...

    一、with的应用场景:

    在python语言中,with语句适用于资源相关操作,锁相关操作,文件相关操作,异常处理等相关操作情景,可以代替try...except...finally...的模式,让程序员不用写一些可能会忘写的收尾的代码,使代码更简洁。

    如下代码:在编码中可能会忘记关闭文件,或者在读取文件时发生异常,没有进行任何处理

    import os
    
    if not os.path.exists(u'F:/test'):
        os.makedirs('F:/test')
    f=open(u'F:/test/text.txt','r+')#打开文件,赋值给句柄
    print f.read()#操作句柄读取数据
    f.close()#关闭文件

     如下代码:对可能出现的异常进行处理,finally关闭文件

    import os
    
    if not os.path.exists(u'F:/test'):
        os.makedirs('F:/test')
    try:    
        f=open(u'F:/test/text.txt','r+')#打开文件,赋值给句柄
        print f.read()#操作句柄读取数据
    except:
        print 'fail to open'
        exit(-1)
    finally:
        f.close()#关闭文件
    

    为了代码简介,python用with来优雅的处理这段代码 

    import os
    
    if not os.path.exists(u'F:/test'):
        os.makedirs('F:/test')
      
    with open(u'F:/test/text.txt','r+') as f:#打开文件,赋值给句柄
        print f.read()#操作句柄读取数据

    二、with语句原理

    with expression [as target]:

            with-body

    expression是任意表达式,获取上下文管理器,as target可选,with-body是with语句的语句体 

    1. 计算expression,并获取上下文管理器
    2. 保存上下文管理器的__exit()__方法
    3. 调用上下文管理器__enter()__方法
    4. 如果有as target,__enter()__方法的返回值赋给target
    5. 执行with语句体的内容,eg:上面打印出利用文件对象读取的文件内容
    6. 不管是否出现异常,调用第二步保存的上下文管理器的__exit()__方法,这里如果with语句体执行机过程中发生异常导致程序退出,那么异常的type、value、traceback等作为参数传递给__exit()__方法,否则,传递三个None

    1、采用装饰器定义上下文管理器:

    #coding:utf-8
    from contextlib import contextmanager
    
    @contextmanager
    def demo():
        print '__enter()__'
        yield 'contextmangager demo'
        print '__exit()__'
        
    with demo() as demo:
        print 'with-body: '+demo
    __enter()__
    with-body: contextmangager demo
    __exit()__
    

     2、采用自定义支持closing的对象:

    #coding:utf-8
    class closing(object):
        def __init__(self,thing):
            self.thing=thing
        def __enter__(self):
            print '__enter()__'
            return self.thing
        def __exit__(self,*exc_info):
            print '__exit()__'
            self.thing.close()
            
    # 这里closing上下文管理器包装起来的对象必须具有close()方法的定义,否则会报错的
    class demo():
        def __init__(self):
            self.thing=open('C:\Users\***\Desktop\111.txt','w')
        def run(self):
            print "function running"
        def close(self):
            self.thing.close()
    
    with closing(demo()) as demo:
        demo.run()
    __enter()__
    function running
    __exit()__
    

     3、采用类定义上下文管理器(廖雪峰大神教程的webapp里面就有许多这样的例子)

    #coding:utf-8
    k=0
    m=0
    class Sample:
        def __init__(self):
            global k
            k+=1
            print k
        def __enter__(self):
            global k
            k+=1
            print k
            print "__enter__()"
            global m
            m+=1
            return m
        def __exit__(self, type, value, trace):
            print "__exit__()"
            
    with Sample() as sample:
        print sample
    1
    2
    __enter__()
    1
    __exit__()
    

    这里强调一点:看了许多博客,有的博客里面指出as target操作,是将expression赋值给target,这是不对的,从上面例子可以看出,是将__enter__()方法返回值赋值给target。

     

    展开全文
  • VBA之with语句用法

    千次阅读 2020-03-26 21:46:29
    想对一个工作表进行同样的操作,每次都要加前缀 sub test() sheet2.range(“a1”)=1 ...可以用with语句来简化,中间插入别的工作表的操作也不会影响他 Sub test() With Sheet2 .Range(“a1”) = 1 .r...

    想对一个工作表进行同样的操作,每次都要加前缀

    sub test()
    sheet2.range(“a1”)=1
    sheet2.range(“b1”)=1
    sheet2.range(“c1”)=1
    sheet2.range(“d1”)=1
    end sub

    可以用with语句来简化,中间插入别的工作表的操作也不会影响他

    Sub test()

    With Sheet2
    .Range(“a1”) = 1
    .range(“b1”)=1
    Sheet3.Range(“a1”) = 100
    range(“c1”)=1
    End With

    End Sub

    展开全文
  • oracle with 语句用法

    千次阅读 2014-01-10 15:14:15
    使用WITH AS 语句可以为一个子查询语句块定义一个名称,使用这个子查询名称可以 在查询语句的很多地方引用这个子查询。 Oracle 数据库像对待内联视图或临时表一样对待 被引用的子查询名称,从而起到一定的优化作用...

    2014/01/10

    使用WITH AS 语句可以为一个子查询语句块定义一个名称,使用这个子查询名称可以 在查询语句的很多地方引用这个子查询。

    Oracle 数据库像对待内联视图或临时表一样对待 被引用的子查询名称,从而起到一定的优化作用。with子句是9i新增语法。

    你可以在任何一个顶层的SELECT 语句以及几乎所有类型的子查询语句前,使用子查询定义子句。被定义的子查询名称可以在主查询语句以及所有的子查询语句中引用,但未定义前不能引用

    with子句中不能嵌套定义<也就是with子句中不能有with子句>,但子查询中出现的“子查询定义”语句可以引用已定义的子查询名称。<可以引用前面已经定义的with子句>


    1、在同级select前有多个查询定义的时候,第1个用with,后面的不用with,并且用逗号隔开。  

    2、最后一个with 子句与下面的查询之间不能有逗号,只通过右括号分割,with 子句的查询必须用括号括起来  

    3、如果定义了with子句,而在查询中不使用,那么会报ora-32035 错误:未引用在with子句中定义的查询名。(至少一个with查询的name未被引用,解决方法是移除未被引用的with查询),注意:只要后面有引用的就可以,不一定非要在主查询中引用,比如后面的with查询也引用了,也是可以的。


    4、前面的with子句定义的查询在后面的with子句中可以使用。但是一个with子句内部不能嵌套with子句。  

    5、with查询的结果列有别名,引用的时候必须使用别名或*。


    WITH语句的优点: 


    (1). SQL可读性增强。比如对于特定with子查询取个有意义的名字等。 
    (2)、with子查询只执行一次,将结果存储在用户临时表空间中,可以引用多次,增强性能。 举例:在进行导入EXCEL的过程中,有时候,需要将数据存储在临时表中,当下一次在进行导入的时候,进行清除临时表的数据,但是这时候,有时候发生并发问题的话,两个用户可能会分别操作对方的数据,所以,可能造成混乱,但是可以使用WITH函数和UNION语句拼接一个SQL语句,存储在SESSION中,当需要导出错误信息的时候,可以使用该语句构造数据。


    例子:

    1、查询出部门的总薪水大于所有部门平均总薪水的部门。部门表s_dept,员工表s_emp。分析:做这个查询,首先必须计算出所有部门的总薪水,然后计算出总薪水的平均薪水,再筛选出部门的总薪水大于所有部门总薪水平均薪水的部门。那么第1 步with 查询查出所有部门的总薪水,第2 步用with 从第1 步获得的结果表中查询出平均薪水,最后利用这两次 的with 查询比较总薪水大于平均薪水的结果,如下: 
     
    WITH DEPT_COSTS AS --查询出部门的总工资  

     (SELECT D.DNAME, SUM(E.SAL) DEPT_TOTAL  

         FROM DEPT D, EMP E  

        WHERE E.DEPTNO = D.DEPTNO  

        GROUP BY D.DNAME), 
      AVE_COST AS   --查询出部门的平均工资,在后一个WITH语句中可以引用前一个定义的WITH语句 
       (SELECT SUM(DEPT_TOTAL) / COUNT(*) AVG_SUM FROM DEPT_COSTS) 

      SELECT * 
        FROM DEPT_COSTS DC 
      WHERE DC.DEPT_TOTAL > (SELECT AC.AVG_SUM FROM AVE_COST AC)--进行比较 



    展开全文
  •  有了 With 语句,在存取对象属性和方法时就不用重复指定参考对象,在 With 语句块中,凡是 JavaScript 不识别的属性和方法都和该语句块指定的对象有关。  With 语句的语法格式如下所示:  With Object {  ...
  • class Kirin: def test(self): print("输出test") def __enter__(self): ... #切记:这里的retur返回的值会赋值给with表达式as后的变量标识符! #如果没返回具体值,那as后面的变量值为None r...
  • with 语句用法

    2019-09-12 23:20:16
    Oracle with语句是经常可以见到的语句,下面就为您详细介绍Oracle with语句用法,如果您对Oracle with语句感兴趣的话,不妨一看。 当查询中多次用到某一部分时,可以用Oracle with语句创建一个公共临时表。因为子...
  • Oracle with语句用法

    千次阅读 2019-07-19 09:28:46
    Oracle数据库中,使用with语句可以实现子查询,提高语句执行的效率,下文对with语句用法作了详细的介绍,供您参考学习。 Oracle with语句是经常可以见到的语句,下面就为您详细介绍Oraclewith语句的用法,如果...
  • with 语句是从 Python 2.5 开始引入的一种与异常处理相关的功能(2.5 版本中要通过 from __future__ import with_statement 导入后才可以使用),从 2.6 版本开始缺省可用(参考 What’s new in Python 2.6? 中 with...
  • 不知 JavaScript 设计之初是如何定位 with 语句的, 个人觉得它们之间有一定的相似度. 如: 代码如下: apple.banana.candy.dog.egg.fog.god.huh.index = 0; doSomething(apple.banana.candy.dog.egg.fog.god.huh....
  • 主要介绍了python with语句的原理与用法,结合实例形式详细分析了python with语句基本概念、原理、用法及操作注意事项,需要的朋友可以参考下
  • with语句用法

    2016-10-20 16:02:30
    JavaScript中对with语句描写很少,这里记录一下我自己的理解。 如下代码(function test(){ var aaa='111'; var location = {}; location.bbb = '123'; location.aaa='456'; with(location){ var aaa='222';...
  • 主要介绍了Vue js with语句原理及用法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 关于 with 语句的相关概念、用法、注意事项。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 361,095
精华内容 144,438
关键字:

with语句用法