software - python tutorial




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

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

उदाहरण के लिए

>>> from __future__ import print_function

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

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

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

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

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

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

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

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


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

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

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

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

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


पहले से ही कुछ शानदार उत्तर हैं, लेकिन इनमें से कोई भी वर्तमान में __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+ दुभाषियों के उपयोग को मजबूर करता है, जो रनटाइम अपवाद फेंक देगा।

संदर्भ:


पाइथन 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__ एक छद्म-मॉड्यूल है जो प्रोग्रामर नई भाषा सुविधाओं को सक्षम करने के लिए उपयोग कर सकते हैं जो वर्तमान दुभाषिया के अनुकूल नहीं हैं । उदाहरण के लिए, अभिव्यक्ति 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)

__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