Что такое __future__ в Python, который используется и как/когда его использовать, и как он работает

Ответ 1

С включением модуля __future__ вы можете постепенно привыкать к несовместимым изменениям или к таким, которые вводят новые ключевые слова.

Например, для использования менеджеров контекста вам пришлось делать from __future__ import with_statement в 2.5, поскольку ключевое слово with было новым и больше не должно использоваться в качестве имен переменных. Для того, чтобы использовать with в качестве ключевого слова Python в Python 2.5 или старше, вам нужно будет использовать импорт из выше.

Другой пример

from __future__ import division
print 8/7  # prints 1.1428571428571428
print 8//7 # prints 1

Без __future__ вещей, как print выражение напечатает 1.

Внутренняя разница заключается в том, что без этого импорта / отображается на метод __div__(), а вместе с ним используется __truediv__(). (В любом случае // вызывает __floordiv__().)

Кстати, print: print становится функцией в 3.x, теряя свое специальное свойство как ключевое слово. Так что все наоборот.

>>> print

>>> from __future__ import print_function
>>> print
<built-in function print>
>>>

Ответ 2

Когда вы это сделаете

from __future__ import whatever

На самом деле вы не используете оператор import, а будущий оператор. Вы читаете неправильные документы, так как вы фактически не импортируете этот модуль.

Будущие заявления являются особенными - они меняют порядок анализа вашего модуля Python, поэтому они должны быть в верхней части файла. Они дают новое или другое значение для слов или символов в вашем файле. Из документов:

Будущий оператор является директивой для компилятора о том, что конкретный модуль должен быть скомпилирован с использованием синтаксиса или семантики, которые будут доступны в указанной будущей версии Python. Будущий оператор предназначен для облегчения перехода на будущие версии Python, которые вносят несовместимые изменения в язык. Он позволяет использовать новые функции для каждого модуля перед выпуском, в котором эта функция становится стандартной.

Если вы действительно хотите импортировать модуль __future__, просто выполните

import __future__

и затем получить доступ к нему, как обычно.

Ответ 3

__future__ - псевдомодуль, который программисты могут использовать для включения новых языковых функций, которые не совместимы с текущим интерпретатором. Например, выражение 11/4 в настоящее время оценивается как 2. Если модуль, в котором он выполняется, включил истинное деление, выполнив:

from __future__ import division

выражение 11/4 будет оцениваться до 2.75. Импортируя модуль __future__ и оценивая его переменные, вы можете увидеть, когда новая функция была впервые добавлена ​​на язык и когда она станет стандартной:

  >>> import __future__
  >>> __future__.division
  _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

Ответ 4

Его можно использовать для использования функций, которые будут отображаться в более новых версиях, имея более старую версию Python.

Например

>>> from __future__ import print_function

позволит вам использовать print как функцию:

>>> print('# of entries', len(dictionary), file=sys.stderr)

Ответ 5

Уже есть несколько __future__ ответов, но ни один из них не содержит полного списка того, что в настоящее время поддерживает оператор __future__.

Проще говоря, оператор __future__ вынуждает интерпретаторов Python использовать новые возможности языка.

В настоящее время он поддерживает следующие функции:

nested_scopes:

До Python 2.1 следующий код вызывал бы ошибку NameError:

def f():
    ...
    def g(value):
        ...
        return g(value-1) + 1
    ...

from __future__ import nested_scopes позволит включить эту функцию.

generators:

Введены функции генератора, такие как приведенная ниже, для сохранения состояния между последовательными вызовами функций:

def fib():
    a, b = 0, 1
    while 1:
       yield b
       a, b = b, a+b

division:

Классическое разделение используется в версиях Python 2.x. Это означает, что некоторые операторы деления возвращают разумное приближение к делению ("истинное деление"), а другие возвращают слово ("деление по полу"). Начиная с Python 3.0, истинное деление определяется как x/y, тогда как разделение пола определяется как x//y.

from __future__ import division заставляет использовать разделение на стиль Python 3.0.

absolute_import:

Позволяет заключить в скобки несколько операторов import. Например:

from Tkinter import (Tk, Frame, Button, Entry, Canvas, Text,
    LEFT, DISABLED, NORMAL, RIDGE, END)

Вместо:

from Tkinter import Tk, Frame, Button, Entry, Canvas, Text, \
    LEFT, DISABLED, NORMAL, RIDGE, END

Или же:

from Tkinter import Tk, Frame, Button, Entry, Canvas, Text
from Tkinter import LEFT, DISABLED, NORMAL, RIDGE, END

with_statement:

Добавляет оператор "with" в качестве ключевого слова в Python, чтобы исключить необходимость использования операторов try/finally. Обычно это используется при выполнении файлового ввода-вывода, например:

with open('workfile', 'r') as f:
     read_data = f.read()

print_function:

Принудительное использование вызова функции print стиле скобок Python 3 вместо оператора print MESSAGE стиле print print MESSAGE.

unicode_literals:

Вводит буквальный синтаксис для объекта bytes. Это означает, что такие выражения, как bytes('Hello world', 'ascii') могут быть просто выражены как b'Hello world'.

generator_stop:

Заменяет использование исключения StopIteration используемого внутри функций генератора, на исключение RuntimeError.

Еще одно использование, не упомянутое выше, заключается в том, что оператор __future__ также вызывает использование интерпретаторов Python 2. 1+, так как использование более старой версии вызовет исключение времени выполнения.

Рекомендации:

• https://docs.python.org/2/library/future.html
• https://docs.python.org/3/library/future.html
• https://docs.python.org/2.2/whatsnew/node9.html
• https://www.python.org/dev/peps/pep-0255/
• https://www.python.org/dev/peps/pep-0238/
• https://www.python.org/dev/peps/pep-0328/
• https://www.python.org/dev/peps/pep-3112/
• https://www.python.org/dev/peps/pep-0479/

Ответ 6

Или это как сказать "Поскольку это Python v2.7, используйте эту другую функцию" печать ", которая также была добавлена в Python v2.7, после того, как она была добавлена в Python 3. Так что мой" print "больше не будет операторами (например, print "message"), но функции (например, print ("message", options)). Таким образом, когда мой код выполняется в python 3, "print" не сломается ".

В

from __future__ import print_function

print_function - это модуль, содержащий новую реализацию print в соответствии с его поведением в python v3.

Это имеет больше объяснения: http://python3porting.com/noconv.html

Ответ 7

Одним из видов использования, которое, как мне показалось, очень полезно, является print_function из модуля __future__.

В Python 2.7 я хотел, чтобы символы из разных операторов печати печатались на одной строке без пробелов.

Это можно сделать с помощью запятой (",") в конце, но она также добавляет дополнительное пространство. Вышеприведенное выражение при использовании в качестве:

from __future__ import print_function
...
print (v_num,end="")
...

Это будет печатать значение v_num с каждой итерации в одной строке без пробелов.

Ответ 8

Явное лучше, чем неявное

from __future__ import braces
  File "<stdin>", line 1
SyntaxError: not a chance

[Предоставлено: @mdeous]

Ответ 9

После Python 3.0, печать уже не просто оператор, а его функция. и включен в PEP 3105.

Также я думаю, что у пакета Python 3.0 все еще есть эти специальные функции. Давайте посмотрим на его удобство использования с помощью традиционной программы Pyramid в Python:

from __future__ import print_function

class Star(object):
    def __init__(self,count):
        self.count = count

    def start(self):
        for i in range(1,self.count):
            for j in range (i): 
                print('*', end='') # PEP 3105: print As a Function 
            print()

a = Star(5)
a.start()

Output:
*
**
***
****

Если мы используем обычную функцию печати, мы не сможем добиться того же выхода, так как print() имеет дополнительную строку новой строки. Поэтому каждый раз, когда выполняется цикл inner for, он печатает * на следующей строке.