python tutorial पायथन में__future__ क्या है और इसका उपयोग कैसे किया जाता है, और यह कैसे काम करता है




python tutorial (7)

मेरे __future__ लोगों को पता है कि पाइथन में कुछ ऐसा है जिसे __future__ कहा जाता है और यह मैंने पढ़े कुछ मॉड्यूल में दिखाई देता है। और पाइथन के __future__ दस्तावेज़ पढ़ने के बाद भी मेरे जैसे सुस्त लोग नहीं जानते कि यह क्यों है, और इसका उपयोग कैसे किया __future__

तो क्या इसका प्रदर्शन करने के लिए उदाहरणों के साथ कोई समझाता है?

मुझे मूल उपयोग के संदर्भ में कुछ जवाब मिल गए हैं, जो सभी सही दिखते हैं।

हालांकि और यह भी समझने के लिए कि __future__ कैसे काम करता है:

मुझे बस एक महत्वपूर्ण चीज का एहसास हुआ जो मुझे समझने की कोशिश कर रहा था, यानी, वर्तमान पायथन रिलीज में कुछ ऐसा शामिल है जो भविष्य में रिलीज में जारी किया जाएगा? और भविष्य में अजगर रिलीज में एक नई सुविधा का उपयोग करने वाला प्रोग्राम वर्तमान पायथन रिलीज द्वारा सफलतापूर्वक संकलित किया जा सकता है?

तो, मुझे लगता है कि, वर्तमान रिलीज ने कुछ संभावित विशेषताओं को पहले ही पैक कर लिया है जिन्हें भविष्य में रिलीज में शामिल किया जाएगा - क्या यह सही है? लेकिन विशेषताएं केवल __future__ द्वारा उपलब्ध हैं, क्योंकि यह अभी तक मानक नहीं बनती है - क्या मैं सही हूँ?


पहले से ही कुछ शानदार उत्तर हैं, लेकिन इनमें से कोई भी वर्तमान में __future__ कथन का समर्थन करने की पूरी सूची को __future__ करता है।

बस रखें, __future__ कथन भाषा की नई विशेषताओं का उपयोग करने के लिए पायथन दुभाषियों को मजबूर करता है।

वर्तमान में जो विशेषताएं समर्थित हैं वे निम्न हैं:

nested_scopes :

पायथन 2.1 से पहले, निम्न कोड नामररगाह उठाएगा:

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 :

क्लासिक डिवीजन का उपयोग पायथन 2.x संस्करणों में किया जाता है। मतलब है कि कुछ विभाजन बयान विभाजन के उचित अनुमान ("सच्चे विभाजन") लौटाते हैं और अन्य फर्श ("फर्श विभाजन") लौटते हैं। पायथन 3.0 से शुरू, सच्चा विभाजन x/y द्वारा निर्दिष्ट किया गया है, जबकि फर्श विभाजन x//y द्वारा निर्दिष्ट किया गया है।

from __future__ import division निर्देश से पायथन 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 :

try/finally बयानों की आवश्यकता को खत्म करने के लिए पायथन में एक कीवर्ड के रूप में "साथ" कथन जोड़ता है। इसका सामान्य उपयोग फ़ाइल I / O करते समय करते हैं जैसे कि:

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

print_function :

print MESSAGE शैली प्रिंट स्टेटमेंट के बजाय पायथन 3 कोष्ठक-शैली print फ़ंक्शन कॉल का उपयोग करने के लिए print MESSAGE है।

unicode_literals :

bytes ऑब्जेक्ट के लिए शाब्दिक वाक्यविन्यास प्रस्तुत करता है। मतलब यह है कि bytes('Hello world', 'ascii') b'Hello world' bytes('Hello world', 'ascii') जैसे बयान को बस b'Hello world' रूप में व्यक्त किया जा सकता है।

generator_stop :

StopIteration अपवाद के साथ जनरेटर फ़ंक्शंस के अंदर उपयोग किए गए StopIteration अपवाद के उपयोग को RuntimeError है।

उपरोक्त वर्णित एक अन्य उपयोग यह है कि __future__ कथन भी पुराने संस्करण का उपयोग करने के बाद पाइथन 2.1+ दुभाषियों के उपयोग को मजबूर करता है, जो रनटाइम अपवाद फेंक देगा।

संदर्भ:


जब तुम करोगे

from __future__ import whatever

आप वास्तव में एक import कथन का उपयोग नहीं कर रहे हैं, लेकिन एक भविष्य का बयान । आप गलत दस्तावेज़ पढ़ रहे हैं, क्योंकि आप वास्तव में उस मॉड्यूल को आयात नहीं कर रहे हैं।

भविष्य के बयान विशेष हैं - वे बदलते हैं कि आपके पायथन मॉड्यूल को कैसे पार्स किया जाता है, यही कारण है कि वे फ़ाइल के शीर्ष पर होना चाहिए। वे नई - या अलग - आपकी फ़ाइल में शब्दों या प्रतीकों का अर्थ देते हैं। दस्तावेज़ों से:

भविष्य का बयान संकलक के लिए एक निर्देश है कि एक विशेष मॉड्यूल को सिंटैक्स या सेमेन्टिक्स का उपयोग करके संकलित किया जाना चाहिए जो कि पाइथन के निर्दिष्ट भविष्य में रिलीज में उपलब्ध होगा। भविष्य का बयान का उद्देश्य पायथन के भविष्य के संस्करणों में माइग्रेशन को आसान बनाना है जो भाषा में असंगत परिवर्तन पेश करता है। यह रिलीज से पहले प्रति-मॉड्यूल आधार पर नई सुविधाओं का उपयोग करने की अनुमति देता है जिसमें सुविधा मानक बन जाती है।

यदि आप वास्तव में __future__ मॉड्यूल आयात करना चाहते हैं, तो बस करें

import __future__

और फिर इसे सामान्य रूप से एक्सेस करें।


इसका उपयोग उन सुविधाओं का उपयोग करने के लिए किया जा सकता है जो पाइथन की पुरानी रिलीज होने पर नए संस्करणों में दिखाई देंगे।

उदाहरण के लिए

>>> from __future__ import print_function

आपको फ़ंक्शन के रूप में print का उपयोग करने की अनुमति देगा:

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

पाइथन 3.0 के बाद, प्रिंट अब सिर्फ एक कथन नहीं है, इसके बजाय एक फ़ंक्शन है। और पीईपी 3105 में शामिल है।

मुझे लगता है कि पाइथन 3.0 पैकेज में अभी भी ये विशेष कार्यक्षमता है। चलिए पाइथन में पारंपरिक "पिरामिड प्रोग्राम" के माध्यम से इसकी उपयोगिता देखते हैं:

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:
*
**
***
****

यदि हम सामान्य प्रिंट फ़ंक्शन का उपयोग करते हैं, तो हम एक ही आउटपुट प्राप्त नहीं कर पाएंगे, क्योंकि प्रिंट () एक अतिरिक्त नई लाइन के साथ आता है। तो हर बार लूप निष्पादित करने के लिए आंतरिक, यह * अगली पंक्ति पर * प्रिंट करेगा।


उपयोगों में से एक जो मैंने बहुत उपयोगी पाया है __future__ मॉड्यूल से __future__ है।

पायथन 2.7 में, मैं अलग-अलग प्रिंट स्टेटमेंट्स से वर्णों को रिक्त स्थान के बिना उसी पंक्ति पर मुद्रित करना चाहता था।

यह अंत में एक अल्पविराम (",") का उपयोग करके किया जा सकता है, लेकिन यह अतिरिक्त जगह भी जोड़ता है। उपरोक्त कथन जब इस प्रकार उपयोग किया जाता है:

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

यह प्रत्येक पुनरावृत्ति से v_num के मान को रिक्त स्थान के बिना एक पंक्ति में मुद्रित करेगा।


या यह कहने की तरह है "चूंकि यह पायथन v2.7 है, इसलिए उस अलग-अलग 'प्रिंट' फ़ंक्शन का उपयोग करें जिसे पायथन 3 में जोड़ा गया था, इसके बाद पाइथन v2.7 में जोड़ा गया है। इसलिए मेरा 'प्रिंट' अब विवरण नहीं होगा (उदाहरण के लिए "संदेश" प्रिंट करें) लेकिन फ़ंक्शंस (उदाहरण के लिए, प्रिंट ("संदेश", विकल्प)। इस तरह जब मेरा कोड पायथन 3 में चलाया जाता है, तो 'प्रिंट' तोड़ नहीं जाएगा। "

में

from __future__ import print_function

print_statement मॉड्यूल है जिसमें 'प्रिंट' का नया कार्यान्वयन है कि यह पाइथन v3 में कैसा व्यवहार कर रहा है।

इसमें अधिक स्पष्टीकरण है: http://python3porting.com/noconv.html


__future__ मॉड्यूल के समावेशन के साथ, आप धीरे-धीरे असंगत परिवर्तनों या नए कीवर्ड पेश करने वाले लोगों के आदी हो सकते हैं।

उदाहरण के लिए, संदर्भ प्रबंधकों का उपयोग करने के लिए, आपको from __future__ import with_statement 2.5 from __future__ import with_statement करना था, क्योंकि कीवर्ड नया था और अब वेरिएबल नामों के रूप में उपयोग नहीं किया जाना चाहिए। एक प्रोग्राम का उपयोग करने में सक्षम होने के लिए जो चर नामों का उपयोग करता है, उपर्युक्त आयात विवरण की आवश्यकता है।

एक और उदाहरण है

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>
>>>




python