Uses of Python's "from" keyword?

Question

Are there any other uses for Python's "from" keyword aside from import statements?

Positively

Answer 1

No and yes.

According to the official Python 2.7.2 grammar, the only occurrence of the word from is in the clause import_from, so no.

In the Python 3.1.3 grammar a new clause

raise_stmt: 'raise' [test ['from' test]]

appears, so yes.

Deprived

Answer 2

There is a new syntax for delegating to a subgenerator in Python 3.3 which uses the from keyword.

Sternlight

So in conclusion, from Python 3.3+ from can be used with raise and yield in addition to imports? – Clabber

Answer 3

In Python 2.x, the only use of from is for the from x import y statement. However, for Python 3.x, it can be used in conjunction with the raise statement, e.g.:

try:
    raise Exception("test")
except Exception as e:
    raise Exception("another exception") from e

Rustice

What does this do, exactly? Is the original exception implicitly chained somehow? That seems un-Pythonic to me; better to explicitly take it as a constructor parameter... so surely it does something else? – Caseinogen

Personally I've never used it -- I just know it exists, and it's intended to be for raising an exception that was directly caused by another. – Rustice

Answer 4

Since there are a lot of updates to python from the time of posting the question, here is a new use case of from keyword in python3 will show you the use with an example

def flatten(l):
    for element in l:
        if type(element) == type(list()):
            yield from flatten(element)
        else:
            yield element

def flatten2(l):
    for element in l:
        if type(element) == type(list()):
            yield flatten2(element)
        else:
            yield element


unflatted_list = [1,2,3,4,[5,6,[7,8],9],10]
flatted_list = list(flatten(unflatted_list))
flatted_list2 = list(flatten2(unflatted_list))
print(flatted_list) # [1,2,3,4,5,6,7,8,9,10]
print(flatted_list2) # [1, 2, 3, 4, <generator object flatten2 at 0x000001F1B4F9B468>, 10]

Eboat

the type(...) == list comparison here is redundant since yield from <expr> only works when <expr> is an Iterable. – Clabber

Answer 5

The following use

from __future__ import some_feature

is syntactically identical to an import statement but instead of importing a module, it changes the behavior of the interpreter in some fashion, depending on the value of some_feature.

For example, from __future__ import with_statement allows you to use Python's with statement in Python 2.5, even though the with statement wasn't added to the language until Python 2.6. Because it changes the parsing of source files, any __future__ imports must appear at the beginning of a source file.

See the __future__ statement documentation for more information.

See the __future__ module documentation for a list of possible __future__ imports and the Python versions they are available in.

Jog

Did you mean to post this as an answer for another question? It seems only tangentially related to this one... – Caseinogen

Actually, it does import from the __future__ module, too. – Vergievergil

@Karl: No, I did not. Yes, __future__ is a module, and importing from __future__ is an import statement. But my point is that while importing from future is syntactically the same as any other import, the semantics are different from a vanilla import. It's not just importing other symbol names, it's also changing the behavior of the interpreter in an important way. – Jog

@Karl @Benj - The Python docs specifically call this a __future__ statement -- it looks like an import statement but it's not. If you actually want to import the __future__ module, you have to do import __future__. – Sternlight

Answer 6

With the finalization of PEP 3134, the from keyword can be used when an exception is generated (raise) as a consequence of catching an exception in a try-except block.

try:
    <some code>
except <exception type> as e:
    raise <exception> from e

The keyword from allows to keep track of the caught exception e in the new excaption raised. The exception e will be stored in the attribute __cause__ of the new exception.

Mcdade