标签: with-statement

在下面的代码块中,如果VB.NET优雅地退出With块Var1 = 2？

With MyObject
    .Property1 = "test"
    If Var1 = 2 Then
        Return True
    End If
    .Property2 = "Test2"
End With

Return False

我记得这是VB6中的一个问题并导致令人头疼的行为 - 这与VB.NET是一样的吗？

由于某种原因，当我的函数体位于 with() 表达式内时，调试模式似乎不允许我进入 with() 部分。为什么会这样，有办法解决这个问题吗？下面是一个愚蠢的（但希望可以重现）演示。

    ff=function(x){
      print("Hello")
      with(iris,{
        y=x;
        z=y+mean(Sepal.Width);
        return(z);})
    }

现在进入调试模式并尝试该功能...

    debugonce(ff);debugonce(with);
    ff(10)

调试模式只是跳过 with() 子句，并返回答案 (13.05733)。我如何进入这些内部条款？

我最近在Python的with语句中遇到了一个奇怪的行为。我有一个代码，它使用 Python 的上下文管理器来回滚__exit__方法中的配置更改。经理return False在finally 块中有一个值__exit__。我在以下代码中隔离了这种情况 - 唯一的区别是 return 语句的缩进：

class Manager1(object):

    def release(self):
        pass # Implementation not important

    def rollback(self):
        # Rollback fails throwing an exception:
        raise Exception("A failure")

    def __enter__(self):
        print "ENTER1"

    def __exit__(self, exc_type, exc_val, exc_tb):
        print "EXIT1"
        try:
            self.rollback()
        finally:
            self.release()
            return False          # The only difference here!


class Manager2(object):

    def release(self):
        pass # Implementation not important

    def rollback(self):
        # Rollback fails throwing an exception:
        raise Exception("A failure")

    def __enter__(self):
        print …

这里是来自 Java 背景的 Python 新手。我对此仍然感到困惑：

with open(...) as f:
    do_something(f)

即使在谷歌搜索并阅读这里的一些答案之后（我只是无法理解它们）。

我的理解是，有一种称为上下文管理器的东西，它是某种包装器，其中包含对所创建文件的引用。关于

as f:

上面的“as”和下面的“as”一样

import numpy as np

这只是一个别名。“f”不是指文件，而是指上下文管理器。上下文管理器使用装饰器模式，实现了打开的文件所执行的所有方法，以便我可以将其视为文件对象（并通过调用适当的方法来获取文件对象，这些方法将在文件上调用在上下文管理器中）。当然，当块完成时文件将被关闭（这就是重点）。

这就引出了一个问题： open() 通常返回一个文件（或对文件的引用），还是一个上下文管理器？它是否通常返回上下文管理器，而这正是我们一直在不知不觉中使用的？或者，当返回不同的内容（例如上下文管理器）时，它是否返回文件类型（除了在此特殊上下文中）。

这近乎正确吗？有人愿意澄清一下吗？

试图更深入地理解事物。

如果我打开一个文件、一个网络请求、张量流会话或任何可以用with语句处理的东西；有没有什么时候我不应该使用with声明？

例如，是否有某个时候我应该使用更通用/通用的try except结构？

我真正的问题是，真正的底层结构是什么with？我读了一些很好的有用提示以及文档本身，但对我来说，它的一些内部工作原理仍然with有点像黑魔法。我试图揭开神奇成分的神秘面纱。

与 Python 的“with”语句对应的 OCaml 是什么？

with open('test.txt', 'r') as f:
    # Do stuff with f
# At this point, f will always be closed, even in case of exceptions

即：OCaml中安全确保某个资源（打开的文件、数据库连接、HTTP 连接等）在某个时间点总是被释放的首选方式是什么？等待垃圾收集器在这里是没有选择的，异常不应该阻止资源被释放。

当然，在 OCaml 中，您始终可以使用 try-finally 并“手动”关闭文件，就像在 Python 中一样。但是，这种代码容易​​出错。这就是 Python 引入“with”语句的原因。什么 OCaml 习惯用法可以使这种代码更易于阅读且不易出错？

请注意，这个问题与在 OCaml 中模拟 try-with-finally的问题非常不同，因为这是更进一步的一步：我不只是想在 OCaml 中模拟 try-finally！（顺便说一下[%finally ...]，Lwt做得很好。）我想更进一步，首先不需要编写那些 finally 子句——就像在 Python 中可以做到的那样。

还要注意，这个问题不是关于实现细节，而是关于习惯用法：所有可能的设计和解决方案中哪些在 OCaml 社区中获得了一些牵引力并被普遍接受？

使用 BigQuery 我想删除 id 为Common Table Expression或 的行with

这是我的查询：

WITH
  redundant AS (
  SELECT
    id,
    MAX(updated_at) AS updated_at,
    COUNT(*) AS counter
  FROM
    t1
  GROUP BY
    id
  HAVING
    counter >= 2)
DELETE
FROM
  t1
WHERE
  id IN (redundant.id)
  AND updated_at NOT IN (redundant.updated_at )

我预计这些行将被删除，但我收到此错误消息：
Syntax error: Expected "(" or keyword SELECT but got keyword DELETE at [13:1]

我正在编写 python 上下文管理器，它运行异步任务。如果我的经理的任何任务抛出异常，我希望我的经理终止。这是示例代码：

class MyClass:
  def __init__(self):
    if asyncio.get_event_loop().is_closed():
      asyncio.set_event_loop(asyncio.new_event_loop())

    self.loop = asyncio.get_event_loop()

  def __enter__(self):
    return self

  def __exit__(self, excType, excValue, tb):
    try:
      self.loop.run_until_complete(self._exit_loop())
    finally:
      self.loop.close()

    if excType is not None:
      print(excType.__name__, ':', excValue)
      traceback.print_tb(tb)

  async def _exit_loop(self):
    tasks = [task for task in asyncio.all_tasks(self.loop) if
             task is not asyncio.current_task(self.loop)]
    list(map(lambda task: task.cancel(), tasks))

    results = await asyncio.gather(*tasks, return_exceptions=True)
    self.loop.stop()


  async def func1(self):
    while True:
      print('func1')
      await asyncio.sleep(1)

  async def func2(self):
    i = 5
    while i > 0:
      print('func2')
      await …

我正在努力实现类似于

from tempfile import TemporaryFile

def open_head(file_path):
   with open(file_path, 'r') as f,
        TemporaryFile() as tf:
       for i in range(0,10):
           tf.write(f.read_line())
       return tf

以便调用者获得临时文件的所有权。

特别是，我不希望该with语句关闭TemporaryFile. 但是如果在 之前出现任何问题return，我仍然希望TemporaryFile被with语句关闭。

理想情况下，我想将调用者写为

with open_head(file_path):
    # more code here

这有可能吗？例如，通过编写return do_not_close(tf)或其他一些实用功能？

或者我是否完全错误地处理了这个问题，并且TemporaryFiles在保证异常安全的同时，还有一种更 Pythonic 的方式来返回 a或其他资源，在函数之间？

我正在寻找 Pythonwith语句的 Java 等效项，并且我阅读了有关实现AutoCloseable接口以及对资源使用 try 的内容。

在Python中，上下文管理器（with语句）使用两种方法：__enter__和__exit__，但在Java中，try with resources块仅使用close，这相当于__exit__。

该方法是否有等效__enter__方法，以便在进入 try with resources 块时自动执行某个方法，而不仅仅是在该块结束时？