标签: with-statement

我是C#开发人员.我非常喜欢花括号,因为我来自C,C++和Java背景.但是,我也喜欢.NET系列的其他编程语言,比如VB.NET.如果你在.NET中编程了一段时间,那么在C#和VB.NET之间来回切换并不是什么大不了的事.这是我工作的公司非常常见的方法.作为C#的人,我非常喜欢withVB.NET编译器提供的XML文字和关键字.我希望微软也将这些功能包含在C#中.

我只是很好奇,其他开发者对它有什么看法!

我试图用 C++中的语句实现类似python的东西.正如我打算使用它主要使用Qt的OpenGL的方法被调用bind,并release(在python __enter__,__exit__).

我提出的代码:

标题:

#include <iostream>
#include <vector>

class With
{
public:
    class A
    {
    public:
        virtual ~A() { }
    };

    template <typename T>
    class B : public A
    {
    public:
        B(T& _t) : t(_t)
        {
            t.bind();
        }

        virtual ~B()
        {
            t.release();
        }

        T& t;
    };

    template <typename... Args>
    With(Args&... args)
    {
        set(args...);
    }

    ~With();

    template <typename T, typename... Args>
    void set(T& t, Args&... args)
    {
        set(t); …

我刚刚发现像C#一样,VB.NET也有using关键字.

到现在为止,我认为它没有它(愚蠢的我,我知道......)并做了这样的事情:

With New OleDbConnection(MyConnectionString)
   ' Do stuff
End With

与使用这样的using语句相比,这有什么影响

Using cn as New OleDBConnection(MyConnectionString)
    With cn
        ' Do stuff with cn
    End With
End using

更新:

我应该补充一点,我熟悉using语句的作用,因为它在退出构造时处理了对象.

但是,据我所知,With New ...构造将使对象在对象超出范围时将其标记为垃圾收集.

所以我的问题是,唯一的区别在于using我将立即释放内存,而对于With构造,只要GC感觉它就会被释放吗？或者我错过了更大的东西？

是否有最佳实践意义？我应该去重写所有的代码我用With New MyDisposableObject() ... End With的Using o as New MyDisposableObject()？

我正在使用这样的Python 3序列:

lock = threading.Lock()
res = lock.acquire(timeout=10)
if res:
    # do something ....
    lock.release()
else:
    # do something else ...

我更喜欢使用with语句而不是显式的"获取"和"释放",但我不知道如何获得超时效果.

通常,我们会使用它来读/写文件:

with open(infile,'r') as fin:
  pass
with open(outfile,'w') as fout:
  pass

要读取一个文件并输出到另一个文件,我可以只用一个with吗？

我一直在这样做:

with open(outfile,'w') as fout:
  with open(infile,'r') as fin:
    fout.write(fin.read())

是否有以下内容,(以下代码不起作用):

with open(infile,'r'), open(outfile,'w') as fin, fout:
  fout.write(fin.read())

使用一个with而不是多个有什么好处with？是否有一些PEP讨论这个？

我正在练习名为 concatenate 的 keras 方法。

在这个例子中使用 with 语句让我想到了这个语句的目的

示例代码如下所示：

import numpy as np 
import keras.backend as K
import tensorflow as tf

t1 = K.variable(np.array([ [[1, 2], [2, 3]], [[4, 4], [5, 3]]]))
t2 = K.variable(np.array([[[7, 4], [8, 4]], [[2, 10], [15, 11]]]))

d0 = K.concatenate([t1 , t2] , axis=-2)

init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    print(sess.run(d0))

然后我检查文档：tensorflow 并说：

会话可能拥有资源，例如 tf.Variable、tf.QueueBase 和 tf.ReaderBase。当不再需要这些资源时，释放这些资源很重要。为此，请在会话上调用 tf.Session.close 方法，或将会话用作上下文管理器。

我相信这已经解释了所有这些，但有人可以给我更直观的解释。

提前致谢，祝您有美好的一天！

在with语句中创建的变量的范围在with块之外(请参阅:使用with-statement在with-block之外可用的变量定义？).但是当我运行以下代码时:

class Foo:
    def __init__(self):
        print "__int__() called."

    def __del__(self):
        print "__del__() called."

    def __enter__(self):
        print "__enter__() called."
        return "returned_test_str"

    def __exit__(self, exc, value, tb):
        print "__exit__() called."

    def close(self):
        print "close() called."

    def test(self):
        print "test() called."

if __name__ == "__main__":
    with Foo() as foo:
        print "with block begin???"
        print "with block end???"

    print "foo:", foo  # line 1

    print "-------- Testing MySQLdb -----------------------"
    with MySQLdb.Connect(host="xxxx", port=0, user="xxx", passwd="xxx", db="test") as my_curs2:
        print …

我经常需要用别的东西临时切换一个变量的值，做一些依赖于这个变量的计算，然后将变量恢复到它的原始值。例如：

var = 0
# Assign temporary value and do computation
var_ori = var
var = 1
do_something_with_var()  # Function that reads the module level var variable
# Reassign original value
var = var_ori

这似乎是使用上下文管理器（with语句）的明显机会。Python 标准库是否包含任何这样的上下文管理器？

编辑

我知道这种事情通常由其他更好的方法处理，而不是临时更改变量。然而，我并不是要求明显的解决方法。

在我的实际工作案例中，我无法更改该do_something_with_var功能。实际上，这甚至不是一个函数，而是作为元编程的一部分在全局命名空间上下文中求值的一串代码。我给出的例子是我能想到的最简单的例子，它使我的问题与临时变量有关。我没有要求获得我的示例代码的解决方法（正确版本），而是要求获得我书面问题的答案。

从历史上看我一直使用以下在读取文件python：

with open("file", "r") as f:
    for line in f:
        # do thing to line

这仍然是推荐的方法吗？使用以下方法是否有任何缺点：

from pathlib import Path

path = Path("file")
for line in path.open():
    # do thing to line

我发现的大多数参考资料都使用with关键字来打开文件，以便不必明确关闭文件。这适用于这里的迭代器方法吗？

with open() 文档

我正在运行代码，有时几小时后有时几分钟后会失败并出现错误

OSError: [Errno 24] Too many open files

我在调试这个时遇到了很大的麻烦。错误本身总是由下面代码片段中的标记行触发

try:
    with open(filename, 'rb') as f:
        contents = f.read()       <----- error triggered here
except OSError as e:
    print("e = ", e)
    raise
else:
    # other stuff happens

但是，我在这部分代码中看不到任何问题（对吗？），所以我猜代码的其他部分没有正确关闭文件。然而，虽然我确实经常打开文件，但我总是使用“with”语句打开它们，并且我的理解是，即使发生错误，文件也会被关闭（对吗？）。所以我的代码的另一部分看起来像这样

    try:
        with tarfile.open(filename + '.tar') as tar:
            tar.extractall(path=target_folder)
    except tarfile.ReadError as e:
        print("e = ", e)
    except OSError as e:
        print("e = ", e)
    else:
        # If everything worked, we are done
        return

上面的代码确实经常遇到 ReadError，但即使发生这种情况，文件也应该关闭，对吧？所以我只是不明白我怎么会遇到太多打开的文件？抱歉，这对您来说是无法重现的，因为我无法对其进行足够的调试，我只是在这里寻找一些提示，因为我迷路了。任何帮助表示赞赏...

编辑：我在 MacBook 上。这是 ulimit -a 的输出

core file …