如何在Oracle中的一个条件HAVING和AND中组合(How to combine in one condition HAVING and AND in Oracle)

 简而言之：是的，动态创建的函数就像在运行时创建的任何其他Python对象一样创建。 
 
 更长的答案：对于垃圾收集器管理的资源，例如没有绑定到外部资源的对象，Python和PyGTK将正确处理未使用的对象。 对于外部资源（如打开文件或正在运行的线程），您需要采取措施确保正确清理。 要准确回答您的问题，查看具体代码会很有用。 通常，以下内容适用于Python和GTK： 
 
 
 
 Python对象（包括动态创建的函数）在无法再从Python访问之后的一段时间内被释放。 在某些情况下，在对象无法访问后立即发生释放（如果对象不参与引用循环），而在其他情况下，您必须等待垃圾收集器启动。 
 
 
 销毁窗口小部件会立即清除与窗口小部件关联的GTK资源。 对象本身可以保持活着。 通过窗口小部件可以访问的回调应该立即解除引用，并且如果没有其他任何东西从Python中保留，很快就会被解除分配。 
 
 
 您可以使用weakref模块中的弱引用类型来测试它。 例如： 
 
>>> import gtk
>>> 
>>> def report_death(obj):
...     # arrange for the death of OBJ to be announced
...     def announce(wr):
...         print 'gone'
...     import weakref
...     report_death.wr = weakref.ref(obj, announce)
... 
>>> def make_dynamic_handler():
...     def handler():
...         pass
...     # for debugging - we want to know when the handler is freed
...     report_death(handler)
...     return handler
... 
>>> w = gtk.Window()
>>> w.connect('realize', make_dynamic_handler())
10L
>>> w.destroy()
gone
 
 现在，如果您将代码更改为handler以包含循环引用，例如通过修改它来提及自己： 
 
def handler():
    handler      # closure with circular reference
 
 ...对destroy的调用将不再导致立即打印 - 这将要求程序继续工作，或者显式调用gc.collect() 。 在大多数Python和PyGTK程序中，自动释放“只是工作”，你不需要努力来帮助它。 
 
 最终，唯一可靠的测试是否存在内存泄漏是在无限循环中运行可疑代码并监视进程的内存消耗 - 如果它无限制地增长，则某些内容不会被释放并且您有内存泄漏。 

In short: yes, it does, dynamically created functions are created just like any other Python objects created during run-time.
 
Longer answer: For resources managed by the garbage collector, such as objects not tied to an external resource, Python and PyGTK will correctly dispose of unused objects. For external resources, such as open files or running threads, you need to take steps to ensure their correct cleanup. To answer your question precisely, it would be useful to see concrete code. In general, the following things apply to Python and GTK:
 
 
 
Python objects, including dynamically created functions, are deallocated some time after they can no longer be reached from Python. In some cases deallocation happens immediately after the object becomes unreachable (if the object is not involved in reference cycles), while in others you must wait for the garbage collector to kick in.
 
 
Destroying a widget causes GTK resources associated with the widget to be cleared immediately. The object itself can remain alive. Callbacks reachable through the widget should be dereferenced immediately and, provided nothing else holds on to them from Python, soon deallocated.
 
 
You can use the weak reference type from the weakref module to test this. For example:
 
>>> import gtk
>>> 
>>> def report_death(obj):
...     # arrange for the death of OBJ to be announced
...     def announce(wr):
...         print 'gone'
...     import weakref
...     report_death.wr = weakref.ref(obj, announce)
... 
>>> def make_dynamic_handler():
...     def handler():
...         pass
...     # for debugging - we want to know when the handler is freed
...     report_death(handler)
...     return handler
... 
>>> w = gtk.Window()
>>> w.connect('realize', make_dynamic_handler())
10L
>>> w.destroy()
gone
 
Now, if you change the code to handler to include a circular reference, e.g. by modifying it to mention itself:
 
def handler():
    handler      # closure with circular reference
 
...the call to destroy will no longer cause gone to be immediately printed - that will require the program to keep working, or an explicit call to gc.collect(). In most Python and PyGTK programs automatic deallocation "just works" and you don't need to make an effort to help it.
 
Ultimately, the only reliable test whether there is a memory leak is running the suspect code in an infinite loop and monitoring the memory consumption of the process - if it grows without bounds, something is not getting deallocated and you have a memory leak.