Python 3.11 में नया क्या है — और क्या आपको इसकी परवाह करनी चाहिए?

Python ने पिछले चार वर्षों में तीन बार TIOBE "Language of the Year" पुरस्कार जीता है। यह लोकप्रिय प्रोग्रामिंग भाषा 2022 के मध्य तक TIOBE सूचकांक में शीर्ष पर बनी हुई है।

जून 2022 के लिए TIOBE सूचकांक में Python शीर्ष पर है।

Python की 12.74% रेटिंग का मतलब है कि “Python” कीवर्ड लगभग ~13% सभी प्रोग्रामिंग-संबंधित सर्च इंजन क्वेरी में दिखाई दिया। दूसरे शब्दों में, इंटरनेट पर हर 7वीं या 8वीं प्रोग्रामिंग संबंधी जिज्ञासा Python के बारे में है।

आज, Python का अक्सर डेटा साइंस और AI में सबसे बड़े ब्रेकथ्रू से संबंध जोड़ा जाता है। इसकी सादगी, असंख्य कार्यों के लिए अंतर्निहित और तृतीय-पक्ष लाइब्रेरीज़ का बड़ा सेट, और समुदाय—इन सबके लिए इसे सराहा जाता है।

3.11 का अंतिम स्थिर संस्करण 3 अक्टूबर, 2022 को आने के साथ, Python समुदाय विभिन्न स्वागतयोग्य अपडेट्स की प्रतीक्षा कर सकता है—जिनमें उल्लेखनीय स्पीड वृद्धि, बेहतर एरर हैंडलिंग और डीबगिंग, और स्टैंडर्ड लाइब्रेरीज़ में कई उपयोग-सुविधा सुधार शामिल हैं।

Python 3.11 की नई विशेषताएँ क्या हैं?

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

1. स्पीड में सुधार

डेटा वैज्ञानिकों को उत्साहित करने वाला पहला बड़ा बदलाव है स्पीड में सुधार—स्टैंडर्ड बेंचमार्क सूट 3.10 की तुलना में लगभग 25% तेज़ चलता है। Python दस्तावेज़ों के अनुसार, कुछ परिस्थितियों में 3.11 60% तक तेज़ हो सकता है। यहाँ बताया गया है कि आप स्वयं बेंचमार्क टेस्ट कैसे करें ताकि स्पीड सुधार को अपने हिसाब से परख सकें। 

Python 3.10 और 3.11 की स्पीड की तुलना करने के लिए, आपको एक Docker इंस्टॉलेशन की आवश्यकता होगी। Docker डेस्कटॉप चल रहा है यह सुनिश्चित करने के बाद, टर्मिनल में ये दो कमांड चलाएँ, जो Python के दोनों संस्करणों के लिए इमेज डाउनलोड करेंगे।

$ docker run -d python:3.10.4-bullseye

$ docker run -d python:3.11-rc-bullseyeसंचालित द्वारा

डाउनलोड की गई इमेजेज़ आपके Docker डैशबोर्ड में दिखनी चाहिए, जहाँ से आप उन्हें चला भी सकते हैं।

कंटेनर लॉन्च करने के बाद, आप docker ps चला सकते हैं ताकि कंटेनर ID, इमेज, उसकी स्थिति और अन्य विवरण देख सकें।

चल रहे कंटेनर आपके डैशबोर्ड के Containers टैब में भी दिखाई देंगे, जहाँ "Run/Stop" के बगल में CLI बटन मिलेंगे। दोनों कंटेनरों के लिए इन पर क्लिक करें ताकि कंटेनरों से जुड़े दो टर्मिनल टैब खुलें।

दोनों टैब में, pip के माध्यम से pyperformance पैकेज इंस्टॉल करें। फिर, प्रत्येक कंटेनर के टर्मिनल में नीचे दिए गए कमांड चलाएँ।

Python 3.10 के लिए

$ pyperformance run -r -o py310.jsonसंचालित द्वारा

Python 3.11 के लिए

$ pyperformance run -r -o py310.jsone run -r -o py311.jsonसंचालित द्वारा

ये कमांड स्टैंडर्ड लाइब्रेरीज़ की लगभग 60 Python फ़ंक्शनों के लिए बेंचमार्क टेस्ट चलाएँगे और JSON मेटाडेटा तैयार करेंगे। मैंने वैकल्पिक रूप से -r टैग जोड़ा है ताकि pyperformance को बता सकूँ कि मुझे अधिक कठोर (rigorous) परीक्षण चाहिए, जो अधिक समय लेता है। मेरे केस में, दोनों कंटेनर Windows मशीन पर AMD Ryzen 12-कोर CPU के साथ चल रहे हैं।

अब, हमारे पास दो कंटेनरों में दो JSON फ़ाइलें हैं, और स्पीड टेस्ट जारी रखने के लिए हमें दोनों को एक ही डायरेक्टरी में रखना होगा। इसके लिए, हम docker cp कमांड का उपयोग करेंगे ताकि Python 3.11 कंटेनर से JSON फ़ाइल 3.10 में कॉपी हो सके।

एक अलग टर्मिनल टैब में नीचे दिए गए कमांड चलाएँ, और पाथ को अपने कंप्यूटर के अनुरूप अपडेट करें:

$ docker cp crazy_snyder:/py311.json C:/Users/bex/Desktop

$ docker cp C:/Users/bex/Desktop/py311.json charming_proskuriakova:/संचालित द्वारा

मेरे केस में, crazy_snyder और charming_proskuriakova चल रहे कंटेनरों के ID हैं। अब दोनों JSON फ़ाइलें Python 3.10 कंटेनर में हैं। बेंचमार्क पूरा करने और परिणाम CSV के रूप में सहेजने के लिए, नीचे दिए गए कमांड चलाएँ।

$ pyperformance compare py310.json py311.json --csv comparison.csv

$ docker cp charming_proskuriakova:/comparison.csv C:/Users/bex/Desktop/articlesसंचालित द्वारा

अंत में, आइए CSV को Pandas में लोड करके विश्लेषण करें:

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

df = pd.read_csv("data/comparison.csv")
df.rename({"Base": "py310", "Changed": "py311", "Benchmark": "function"},
                   axis=1,
                   inplace=True)संचालित द्वारा

>>> df.shape
संचालित द्वारा

(59, 3)संचालित द्वारा

>>> df.sample(5)
संचालित द्वारा

डेटाफ्रेम की प्रत्येक पंक्ति दर्ज करती है कि दी गई Python फ़ंक्शन को चलाने में दोनों संस्करणों को कितना समय (मिलीसेकंड में) लगा। आइए स्पीडअप का एक हिस्टोग्राम प्लॉट करें।

df["speed_up"] = (df["py310"] / df["py311"]).round(3)

fig, ax = plt.subplots()

sns.histplot(df["speed_up"], bins=11)
ax.set(xlabel="Speedup (times)", 
           title="Python 3.10 vs. Python 3.11 - speedup comparison")

plt.show()संचालित द्वारा

प्लॉट से स्पष्ट है कि Python 3.11 में अधिकांश फ़ंक्शन लगभग 1.2 गुना (20%) तेज़ थे। हम औसत और माध्यिका से भी इस आकलन की पुष्टि कर सकते हैं।

>>> df["speed_up"].mean()
संचालित द्वारा

1.2605593220338982संचालित द्वारा

>>> df["speed_up"].median()
संचालित द्वारा

1.207संचालित द्वारा

ऐसा लगता है कि एक मामला ऐसा भी है जहाँ स्पीड वृद्धि 60% से अधिक रही। 

>>> df["speed_up"].max()
संचालित द्वारा

1.899संचालित द्वारा

ऐसे चार मामले भी हैं जहाँ Python 3.10 नई संस्करण से तेज़ था।

>>>  (df["speed_up"] <= 1).sum() 
संचालित द्वारा

4संचालित द्वारा

हालाँकि कागज़ पर प्रदर्शन में सुधार दिखता है, इन सुधारों का वास्तविक प्रभाव व्यक्ति और उपयोग-परिदृश्य के अनुसार बदलेगा, और Python 3.11 का स्थिर, अंतिम संस्करण अभी आना बाकी है। बेंचमार्क टेस्ट शुद्ध Python फ़ंक्शनों का उपयोग करता है, जिनका आप अपने दैनिक काम में उतना प्रयोग न करते हों, लेकिन Python 3.10 और 3.11 दोनों के लिए Docker इंस्टॉलेशन सेट करना आपको अपने विशिष्ट उपयोग मामलों के लिए स्पीड वृद्धि का अंदाज़ा लगाने देगा। 

2. बेहतर त्रुटि संदेश

Python 3.11 की एक और रोमांचक विशेषता है बेहतर एरर मैसेजिंग, जो त्रुटि के सटीक स्थान को इंगित करती है। 100-लाइन के ट्रेसबैक के बजाय, जो अंत में कोई ऐसा एरर संदेश देता है जिसे समझना मुश्किल हो, Python 3.11 सीधे उस अभिव्यक्ति की ओर इंगित करता है जिसने त्रुटि पैदा की।

ऊपर के उदाहरण में, Python इंटरप्रेटर उस x की ओर इंगित करता है, जिसने None मान के कारण स्क्रिप्ट को क्रैश किया। मौजूदा Python संस्करणों में त्रुटि अस्पष्ट होती, क्योंकि ‘x’ एट्रिब्यूट वाले दो ऑब्जेक्ट हैं। हालाँकि, 3.11 का एरर हैंडलिंग स्पष्ट रूप से समस्याग्रस्त अभिव्यक्ति पर उंगली रखता है। 

यह उदाहरण दिखाता है कि 3.11 कैसे गहराई से नेस्टेड डिक्शनरी से त्रुटि का पता लगाता है और स्पष्ट रूप से दिखा सकता है कि त्रुटि किस कुंजी से संबंधित है।

आपको जटिल अंकगणितीय अभिव्यक्तियों में भी यही सटीकता दिखाई देगी।

अपडेटेड त्रुटि संदेश निश्चित रूप से एक स्वागतयोग्य जोड़ हैं, खासकर उन डेटा वैज्ञानिकों के लिए जो स्क्रिप्ट डीबगिंग में जूझते हैं।

3. Exception Notes

“स्पष्ट, अप्रत्यक्ष से बेहतर है।”

ऊपर का वाक्य Zen of Python की दूसरी पंक्ति है—Python के 20 डिज़ाइन सिद्धांतों की सूची। यह नियम दर्शाता है कि Python कोड यथासंभव अभिव्यक्तिपूर्ण होना चाहिए।

इसी डिज़ाइन पैटर्न को मज़बूत करने के लिए, Python 3.11 exception notes (PEP 678) पेश करता है। अब, अपने except क्लॉज़ के अंदर, आप add_note() फ़ंक्शन को कॉल कर सकते हैं और त्रुटि उठाते समय एक कस्टम संदेश पास कर सकते हैं।

import math

try:
  math.sqrt(-1)
except ValueError as e:
  e.add_note("Negative value passed! Please try again.")
  raiseसंचालित द्वारा

यदि आपने नीचे जैसा कोई कस्टम exception क्लास लिखा है, तो आप सुरक्षित क्लास-स्तरीय एट्रिब्यूट __notes__ के अंदर क्लास में कई नोट्स जोड़ सकते हैं:

import math

class MyOwnError(Exception):
   # Should be a list of strings
   __notes__ = ["This is a custom error!"]

try:
   math.sqrt(-1)
except:
   raise MyOwnErrorसंचालित द्वारा

अब, जब इंटरप्रेटर त्रुटि पर पहुँचेगा, तो नियमित संदेश बॉडी के बाद वह कस्टम संदेश प्रदर्शित करेगा।

एक नया सिंटैक्स except* क्लॉज़ के साथ अपवाद उठाने का भी है, जिसे नए ExceptionGroup क्लास के साथ उपयोग किया जाता है। PEP 654 के अनुसार, आप इसे विभिन्न परिदृश्यों में असंबंधित कई त्रुटियाँ एक साथ उठाने के लिए उपयोग कर सकते हैं। इनमें से अधिकांश स्थितियाँ काफ़ी विशिष्ट हैं, जैसे वेब सॉकेट्स के साथ काम करना, asyncio के साथ concurrent प्रोग्रामिंग आदि—जो रोज़मर्रा के डेटा साइंस कार्य में कम ही आती हैं—लेकिन यदि आप रुचि रखते हैं, तो आप नए सिंटैक्स के बारे में यहाँ जान सकते हैं।

4. नई टाइपिंग विशेषता: Self

स्टैटिकली टाइप्ड भाषाएँ आपके कोड को पठनीय और आसानी से डीबग करने योग्य बनाती हैं। वेरिएबल्स, फ़ंक्शन इनपुट्स और आउटपुट्स के सटीक प्रकार परिभाषित करने से आपको घंटों की डीबगिंग से बचत हो सकती है और दूसरों के लिए आपका कोड पढ़ना आसान हो जाता है। टाइपिंग एनोटेशन जोड़ने से आधुनिक IDEs आपके नाम टाइप करते ही फ़ंक्शन परिभाषाएँ दिखा सकते हैं, जिससे दूसरों के लिए आपके फ़ंक्शनों की व्याख्या आसान हो जाती है।

अब तक, Python के शक्तिशाली typing मॉड्यूल में लगभग हर डेटा टाइप के लिए क्लासेज़ थीं—सिवाय उन क्लासेज़ के जो अपने ही इंस्टैंस लौटाएँ। मौजूदा Python संस्करणों में, नीचे दिया गया उदाहरण संभव नहीं है:

from typing import Self
class Language:

  def __init__(self, name, version, release_date):
      self.name = name
      self.version = version
      self.release_date = release_date

  def change_version(self, version) -> Self:
      self.version = version

      return Language(self.name, self.version, self.release_date)संचालित द्वारा

हालाँकि, Python 3.11 Self क्लास पेश करता है, जिसे आप किसी फ़ंक्शन की परिभाषा में जोड़ सकते हैं यदि उसका रिटर्न मान self या उसी क्लास का नया इंस्टैंस है।

5. स्टैंडर्ड लाइब्रेरीज़ में सुधार

स्टैंडर्ड लाइब्रेरीज़ में कुछ अन्य उपयोग-सुविधा सुधार भी हैं। सबसे पहले, math मॉड्यूल में दो लंबे समय से प्रतीक्षित फ़ंक्शंस जोड़े गए हैं।

>>> import math
>>> math.cbrt(9)  # Find the cube-root of x
2.080083823051904
>>> math.cbrt(27)
3.0000000000000004
>>> math.exp2(5)  # Raise 2 to the power of x
32.0संचालित द्वारा

यह तथ्य कि क्यूब-रूट फ़ंक्शन जोड़ने में Python को 28 वर्ष लग गए, काफ़ी चौंकाने वाला है, लेकिन जैसा कहा जाता है—देर आए दुरुस्त आए।  

fractions मॉड्यूल ने भी एक नया फ़ीचर जोड़ा है, जो आपको स्ट्रिंग से fractions बनाने देता है:

>>> from fractions import Fraction
>>> Fraction("22/7")  # New in Python 3.11
Fraction(22, 7)
>>> Fraction(numerator=22, denominator=7)
Fraction(22, 7)
>>> Fraction("3e-4")
Fraction(3, 10000)
>>> Fraction("-73/41")
Fraction(-73, 41)
>>> Fraction(3.1415)  # Find the closest approximation to the given float
Fraction(7074029114692207, 2251799813685248)संचालित द्वारा

जैसा कि आप देख सकते हैं, fractions मॉड्यूल कुछ अंकगणितीय कार्यों के लिए काफ़ी उपयोगी हो सकता है। मुख्यतः, मुझे यह पसंद है कि आप दिए गए float के सबसे नज़दीकी fraction का पता लगा सकते हैं। आप हर संख्या हर (denominator) की सीमा देकर इसे एक कदम और आगे ले जा सकते हैं:

>>> from math import pi
>>> Fraction(pi).limit_denominator(100000)
Fraction(312689, 99532)संचालित द्वारा

tomllib नाम का एक नया मॉड्यूल भी है जो TOML दस्तावेज़ों को पार्स करने के लिए है। TOML (Tom's Obvious Minimal Language) मानव-पठनीय कॉन्फ़िगरेशन फ़ाइलें लिखने के लिए एक लोकप्रिय फ़ाइल फ़ॉर्मेट है। यहाँ प्रोजेक्ट के होमपेज से एक छवि है:

import tomllib

toml_str = """
python-version = "3.11.0"
release_date = "2022-10-22"
"""

data = tomllib.loads(toml_str)
print(data)  # {'python-version': '3.11.0', 'release_date': '2022-10-22'}
print(data['python-version'])  # 3.11.0
print(data['release_date'])  # 2022-10-22संचालित द्वारा

Python 3.11 रिलीज़ तिथि

Python 3.11 का विकास 5 मई, 2021 को शुरू हुआ। तब से, सात अल्फा संस्करण जारी किए गए, और 8 मई, 2022 को पहला बीटा संस्करण आया। इस तारीख से लेकर आधिकारिक रिलीज़ तक Python में नई विशेषताएँ नहीं जोड़ी जाएँगी।

अंतिम, स्थिर रिलीज़ 3 अक्टूबर, 2022 को आएगी—इस बीच तीन और बीटा संस्करण और दो कैंडिडेट संस्करणों के बाद। आप निम्न संसाधनों को देखकर Python के बारे में और जान सकते हैं।