__future__ en Python

1. Utilisez __future__ pour print_function en Python
2. Utilisez __future__ pour unicode_laterals en Python
3. Utilisez __future__ pour la division en Python
4. Utilisez __future__ pour absolute_import en Python
5. Utilisez __future__ pour les annotations en Python
6. Utilisez __future__ pour les portées imbriquées
7. Utilisez __future__ pour les générateurs Python
8. Utilisez __future__ pour la déclaration with

__future__ a été introduit dans Python 2.1, et ses instructions changent la façon dont Python interprète le code. Il indique à l’interpréteur de compiler certaines déclarations en tant que déclarations qui seront disponibles dans les futures versions de Python, c’est-à-dire que Python utilise from __future__ import feature ​​pour rétroporter les fonctionnalités des versions Python supérieures vers l’interpréteur actuel.

Chaque fois que vous voyez from __future__ import, cela signifie qu’une fonctionnalité de la dernière version ou d’une version à venir de Python a été rétroportée dans une version antérieure.

Ce didacticiel abordera les fonctionnalités déjà activées dans Python 3 dans les versions antérieures de Python à l’aide de __future__.

Utilisez __future__ pour print_function en Python

L’utilisation du mot-clé print en tant que fonction au lieu d’une instruction lui apporte beaucoup de flexibilité, ce qui permet d’étendre la capacité du mot-clé print. La fonction principale de from __future__ import print_function est de transférer la fonction print de Python 3 dans Python 2.

Par example,

from __future__ import print_function

for x in range(0, 10):
    print(x, sep=" ", end="")

Production:

0123456789

Notez que print ici est utilisé comme une fonction, qui était auparavant utilisée comme une instruction dans Python 2.x

Utilisez __future__ pour unicode_laterals en Python

Cela vous permet de changer le type de littéraux de chaîne.

Les littéraux de chaîne sont str par défaut dans Python 2, mais si nous utilisons from __future__ import unicode_literals, le type de littéral de chaîne devient Unicode.

Par example,

type("h")

Production:

<type 'str'> 

Mais avec from __future__ import unicode_literals, nous obtenons la sortie suivante.

from __future__ import unicode_literals

type("h")

Production:

<type 'unicode'>

Notez qu’en utilisant from __future__ import, nous n’avons pas à préfixer chaque chaîne avec u pour la traiter comme un Unicode.

Utilisez __future__ pour la division en Python

Dans les versions Python 2.x, la division classique est utilisée.

print(8 / 7)

Production

0

Une simple division de 8 par 7 renvoie 0 dans Python 2.x.

L’utilisation de from __future__ import division permet à un programme Python 2 d’utiliser __truediv__().

Par example,

from __future__ import division

print(8 / 7)

Production:

1.1428571428571428

Utilisez __future__ pour absolute_import en Python

Dans Python 2, vous ne pouviez avoir que des importations relatives implicites, alors que dans Python 3, vous pouvez avoir des importations explicites ou des importations absolues. __future__ import absolute_import permet à la parenthèse d’avoir plusieurs instructions d’importation entre crochets.

Par example,

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

Notez que sans la fonctionnalité __future__ import absolute_import, vous ne pourrez pas inclure plusieurs instructions import dans une seule ligne de code.

Utilisez __future__ pour les annotations en Python

Les annotations sont des expressions Python associées à différentes parties d’une fonction.

Ici, l’utilisation de from __future__ import annotations modifie la façon dont les annotations sont saisies et évaluées dans un module Python. Il reporte l’évaluation des annotations et traite comme par magie toutes les annotations comme des annotations différées.

Par example,

from __future__ import annotations


class C:
    @classmethod
    def make(cls) -> C:
        return cls

Notez que le code ci-dessus ne fonctionnera que si __future__ import est écrite en haut du code, car cela modifie la façon dont Python interprète le code, c’est-à-dire qu’il traite les annotations comme des chaînes individuelles.

Utilisez __future__ pour les portées imbriquées

Avec l’ajout de __future__ import nested_scopes, des portées imbriquées statiquement ont été introduites dans Python. Il permet aux types de code suivants de s’exécuter sans renvoyer d’erreur.

def h():
    ...

    def m(value):
        ...
        return m(value - 1) + 1

    ...

Notez que le code ci-dessus aurait généré une NameError avant Python 2.1.

Utilisez __future__ pour les générateurs Python

Un générateur est une fonction en Python définie comme une fonction régulière. Pourtant, il le fait avec le mot-clé yield plutôt qu’avec le retour chaque fois qu’il a besoin de générer une valeur spécifique.

Ici, avec l’utilisation de from __future__ import generators , des fonctions génératrices ont été introduites pour sauvegarder les états entre les appels de fonction successifs.

Par example,

def gen():
    c, d = 0, 1
    while 1:
        yield d
        c, d = d, c + d

Utilisez __future__ pour la déclaration with

Cela élimine l’utilisation des instructions try...except en ajoutant l’instruction with comme mot-clé en Python. Il est principalement utilisé lors des E/S de fichiers, comme illustré dans l’exemple ci-dessous.

with open("workfile", "h") as a:
    read_data = a.read()