raise on its own will reraise the latest exception

A few thoughts:

• Would raise and raise exc have different behavior?
• If so, should we document why we're using raise instead of raise exc?
• If not, why not favor raise exc over raise, which is more explicit?

Good question, actually!

非常感谢“encode”成员再次关注这个问题。
Many thanks to the "encode" members for paying attention to this issue again.
我认为应该优先使用 raise exc。
I think it should be preferred to use raise exc.
这会让使用“drf”构建的应用程序更加具有可读性。
This will make applications built with "drf" more readable.
如果仅仅使用 raise` `我认为是不负责任的。 If I only use raise`` I think it is irresponsible.
请试想一下，如果一个程序员使用"drf"构建应用，在捕获异常时使用以下哪种方式更加优雅呢？
Imagine if a programmer uses "drf" to build an application, which of the following is more elegant when catching exceptions?
1.使用"raise"：
Use "raise"

try:
	drf code...
except Exception:
	write error log...

2.使用"raise exc"：
Use "raise exc"

try:
	drf code...
except (OSError, IOError):
	write panic log...
except CustomError:
	write log...

我认为第二种方式更加优雅和清晰。
I think the second way is more elegant and clear.
您可能认为在这里没有必要，但是这是个好的习惯，因为一些开发者习惯按住Ctrl键随时查看框架源代码。
You might think it's not necessary here, but it's a good habit because some developers are used to holding down the Ctrl key to view the framework source code at any time.

@tomchristie, had a bit of a think and raise exc seems like The Correct Thing To Do ^TM.

As an unlikely example, a user might override handle_exception, and generate a new exception object from the original. This exception would be passed, not raised, since we're already in the middle of the exception handler. However, a bare raise would raise the original exception, not the one the user passed. Compare the following (the latter is more "correct"):

>>> def handle(exc):
...     raise
... 
>>> try:
...     raise Exception('!!!')
... except Exception as exc:
...     handle(TypeError('???'))
... 
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
  File "<stdin>", line 2, in <module>
Exception: !!!

>>> def handle(exc):
...     raise exc
... 
>>> try:
...     raise Exception('!!!')
... except Exception as exc:
...     raise TypeError('???')
... 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
Exception: !!!

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
TypeError: ???

Either way, I can't think of a reason to keep a bare raise.