Python में Altair ट्यूटोरियल: डेटा विज़ुअलाइज़ेशन्स

Altair और Movies Dataset का उपयोग करके Python में डेटा विज़ुअलाइज़ेशन्स बनाना सीखें।

अपडेट किया गया 25 सित॰ 2026 · 12 मि॰ पढ़ें

AI के साथ खोजें

DataCamp के साथ करियर बनाने के लिए Python स्किल्स

आसानी से समझ आने वाले, फिर भी परिष्कृत प्लॉट बनाना एक सफल डेटा साइंटिस्ट बनने के लिए बेहद अहम है। विज़ुअलाइज़ेशन बनाना आपके डेटा में छिपी कहानी बताने का बेहतरीन तरीका है। यह डेटा में मौजूद रिश्तों को उजागर करता है और ऐसी जानकारी दिखाता है जो सिर्फ अंकों से व्यक्त नहीं हो सकती लेकिन मानव आँख देख सकती है। पर डेटा विश्लेषण के लिए साधारण विज़ुअलाइज़ेशन से भी बेहतर क्या है? इंटरैक्टिव विज़ुअलाइज़ेशन!

दुर्भाग्यवश, शुरुआती लोगों को यह काम कठिन लग सकता है। Python और R दोनों इस काम में सहायता के लिए ढेरों टूल और ट्रिक्स देते हैं। इस ट्यूटोरियल में, हम आपको Altair से परिचित कराएँगे। Altair की मदद से आप बहुत कम कोड और कम समय में सार्थक, आकर्षक और प्रभावी विज़ुअलाइज़ेशन बना पाएँगे। आइए शुरू करते हैं!

Altair क्या है?

Altair सांख्यिकीय विज़ुअलाइज़ेशन के लिए डिज़ाइन की गई Python लाइब्रेरी है। यह घोषणात्मक (declarative) प्रकृति की है (हम आगे इस पर आएँगे)। यह Vega और Vega-Lite पर आधारित है, जो दोनों ऐसे visualization grammar हैं जो आपको किसी विज़ुअलाइज़ेशन की दृश्य उपस्थिति और इंटरैक्टिव व्यवहार को JSON फ़ॉर्मेट में वर्णित करने देते हैं।

इंपीरेटिव बनाम डिक्लेरेटिव API

जैसा कि पहले कहा, Python में डेटा विज़ुअलाइज़ेशन के लिए कई शानदार टूल और लाइब्रेरी हैं, और कई इंटरैक्टिव विज़ुअलाइज़ेशन भी सपोर्ट करते हैं। फिर Altair को खास क्या बनाता है?

इसका उत्तर इसकी घोषणात्मक प्रकृति में है, जो अन्य इंपीरेटिव API से अलग है।

इंपीरेटिव API में आपको 'क्या करना है' के बजाय 'कैसे करना है' पर ध्यान देना पड़ता है। आपको विज़ुअलाइज़ेशन बनाने के लिए आवश्यक कोड के बारे में सोचना होता है और प्लॉटिंग के स्टेप्स—जैसे अक्ष सीमा, आकार, रोटेशन, लैजेंड्स आदि—मैन्युअली बताने पड़ते हैं।

एक डेटा साइंटिस्ट के रूप में, Altair आपको अपने समय और प्रयास को डेटा पर केंद्रित करने देता है—उसे समझने, विश्लेषण करने और विज़ुअलाइज़ करने पर—ना कि उस कोड पर जिसकी आपको आवश्यकता होगी। यानी आप डेटा और अपेक्षित आउटपुट (अंतिम विज़ुअलाइज़ेशन कैसा दिखना चाहिए) परिभाषित करते हैं और Altair आवश्यक हेरफेर अपने-आप कर देता है।

इंस्टॉलेशन

इस ट्यूटोरियल में, हम Vega datasets के एक उदाहरण डेटासेट का उपयोग करेंगे। Altair को Vega datasets के साथ इंस्टॉल करने के लिए, अपने कंसोल में यह लिखें:

$ pip install altair vega_datasets

अगर आप conda पैकेज मैनेजर का उपयोग कर रहे हैं, तो समकक्ष कमांड यह है:

$ conda install -c conda-forge altair vega_datasets

इसके बाद, आप अपने Jupyter Notebook पर जाएँ और Altair इम्पोर्ट करके शुरू करें। Jupyter Notebook के बारे में और जानने के लिए DataCamp की Jupyter Notebook Definitive guide ज़रूर देखें।

डेटा

अब जब हमने Altair और Vega dataset इंस्टॉल कर लिया है, तो कुछ डेटा लोड करने का समय है। इन इम्पोर्ट्स से शुरू करें:

import pandas as pd
import altair as alt

Pandas क्यों इम्पोर्ट करें?

क्योंकि Altair में डेटा Pandas DataFrame के इर्द-गिर्द बना है, इसका मतलब है कि आप Altair में डेटा को उसी तरह मैनेज कर सकते हैं जैसे आप Pandas के DataFrame के साथ करते हैं।

और भले ही Altair आंतरिक रूप से डेटा को Pandas DataFrame के फ़ॉर्मेट में स्टोर करता है, डेटा इनपुट करने के कई तरीके हैं:

Pandas DataFrame के रूप में
Data या संबंधित ऑब्जेक्ट (जैसे UrlData, InlineData, NamedData) के रूप में
ऐसी URL स्ट्रिंग के रूप में जो JSON या CSV फ़ॉर्मेटेड टेक्स्ट फ़ाइल की ओर इशारा करे
ऐसे ऑब्जेक्ट के रूप में जो geo_interface सपोर्ट करता हो (जैसे, Geopandas GeoDataFrame, Shapely Geometries, GeoJSON Objects)

Movies Dataset

इस ट्यूटोरियल में, हम Vega dataset के Movies Dataset के साथ काम करेंगे। यह या इसी प्रकार का मूवी-सम्बंधित डेटासेट डेटा साइंस समुदाय में प्रसिद्ध है, खासकर Recommendation Engines के संदर्भ में। हालाँकि, हम यहाँ Altair के साथ विज़ुअलाइज़ेशन्स का उपयोग करते हुए केवल डेटा विश्लेषण करेंगे।

इस डेटासेट में मूवी से जुड़ी जानकारी होती है, जैसे मूवी का शीर्षक, अमेरिका और विश्व स्तर पर कमाई, साथ ही प्रोडक्शन बजट, जेनर, IMDB और Rotten Tomatoes से रेटिंग्स। हम सभी कॉलम पर काम नहीं करेंगे, बल्कि Altair को एक विज़ुअलाइज़ेशन टूल के रूप में समझने के लिए कुछ कॉलम ही उपयोग करेंगे।

आइए आगे बढ़ें, डेटासेट लें और उसे बेहतर समझने के लिए कुछ सरल विश्लेषण करें।

# Importing the Vega Dataset
from vega_datasets import data as vega_data

movies_df = pd.read_json(vega_data.movies.url)

# Checking the type of data that we get
print("movies_df is of the type: ", type(movies_df))

print("movies_df: ", movies_df.shape)

movies_df is of the type:  <class 'pandas.core.frame.DataFrame'>
movies_df:  (3201, 16)

जैसा आपने देखा, movies_df वास्तव में एक pandas DataFrame है और इसमें 3201 मूवीज़ (पंक्तियाँ) हैं, प्रत्येक में 16 फीचर (कॉलम) जानकारी। चलिए DataFrame के भीतर का डेटा देखते हैं।

movies_df.head(5)

	Title	US_Gross	Worldwide_Gross	US_DVD_Sales	Production_Budget	Release_Date	MPAA_Rating	Running_Time_min	Distributor	Source	Major_Genre	Creative_Type	Director	Rotten_Tomatoes_Rating	IMDB_Rating	IMDB_Votes
0	The Land Girls	146083.0	146083.0	NaN	8000000.0	Jun 12 1998	R	NaN	Gramercy	None	None	None	None	NaN	6.1	1071.0
1	First Love, Last Rites	10876.0	10876.0	NaN	300000.0	Aug 07 1998	R	NaN	Strand	None	Drama	None	None	NaN	6.9	207.0
2	I Married a Strange Person	203134.0	203134.0	NaN	250000.0	Aug 28 1998	None	NaN	Lionsgate	None	Comedy	None	None	NaN	6.8	865.0
3	Let's Talk About Sex	373615.0	373615.0	NaN	300000.0	Sep 11 1998	None	NaN	Fine Line	None	Comedy	None	None	13.0	NaN	NaN
4	Slam	1009819.0	1087521.0	NaN	1000000.0	Oct 09 1998	R	NaN	Trimark	Original Screenplay	Drama	Contemporary Fiction	None	62.0	3.4	165.0

कॉलम मान ये हैं:

movies_df.columns

Index(['Title', 'US_Gross', 'Worldwide_Gross', 'US_DVD_Sales',
       'Production_Budget', 'Release_Date', 'MPAA_Rating', 'Running_Time_min',
       'Distributor', 'Source', 'Major_Genre', 'Creative_Type', 'Director',
       'Rotten_Tomatoes_Rating', 'IMDB_Rating', 'IMDB_Votes'],
      dtype='object')

अब हम pandas के to_datetime फ़ंक्शन का उपयोग करके Release_Date कॉलम को वास्तविक तारीख में बदलेंगे और फिर उससे 'year' निकालेंगे। आगे हम इस नए बनाए गए कॉलम का उपयोग अपनी विज़ुअलाइज़ेशन्स में करेंगे।

def extract_year(value):
    return pd.to_datetime(value, format='%b %d %Y').year

movies_df["Year"] = movies_df["Release_Date"].apply(extract_year)

अगर अब आप कॉलम मान देखते हैं, तो आपको Year नाम का नया कॉलम दिखेगा जिसमें संबंधित मूवी का वर्ष मौजूद है।

movies_df.columns

Index(['Title', 'US_Gross', 'Worldwide_Gross', 'US_DVD_Sales',
       'Production_Budget', 'Release_Date', 'MPAA_Rating', 'Running_Time_min',
       'Distributor', 'Source', 'Major_Genre', 'Creative_Type', 'Director',
       'Rotten_Tomatoes_Rating', 'IMDB_Rating', 'IMDB_Votes', 'Year'],
      dtype='object')

अब हम कुछ प्लॉट बनाना शुरू करेंगे। लेकिन उससे पहले, यह कोड चलाएँ:

alt.renderers.enable('notebook')

RendererRegistry.enable('notebook')

ऊपर दिया कोड Altair को Jupyter notebook में इनलाइन रेंडर करने देता है, ताकि हम अपने बनाए फ़िगर्स देख सकें। यदि आपको कोई समस्या आए, तो Altair की troubleshooting पेज देखें।

डेटा पर पहली नज़र में, यह देखना रोचक होगा कि मूवी बनाने में कितने पैसे लगे (Production_Budget) और मूवी ने वास्तव में कितनी कमाई की (Worldwide_Gross) के बीच क्या संबंध है। हम इन मानों को X और Y अक्ष पर प्लॉट करेंगे।

हालाँकि, डेटासेट अपेक्षाकृत बड़ा है—क्योंकि हमारा फोकस Altair के साथ खेलना है। इसलिए फिलहाल हम कुछ ही डेटा पॉइंट्स के साथ काम करेंगे। चलिए देखते हैं किसी दिए गए वर्ष में हमारे डेटासेट में कितनी मूवीज़ हैं और एक वर्ष चुनते हैं जिस पर हम फोकस करेंगे।

movies_df["Year"].value_counts()

2006    220
2005    210
2002    208
2004    192
2000    188
       ...
1943      1
2015      1
2027      1
2037      1
1928      1
Name: Year, Length: 91, dtype: int64

आइए वर्ष 2000 पर ध्यान केंद्रित करें और movies_2000 नाम का नया DataFrame बनाएँ जिसमें केवल इसी वर्ष का डेटा हो। इसमें 188 पंक्तियाँ (मूवीज़) होनी चाहिए।

movies_2000 = movies_df[movies_df["Year"] == 2000]
movies_2000.shape

(188, 17)

अब हम अपनी पहली विज़ुअलाइज़ेशन की ओर बढ़ेंगे। इसके लिए Altair के फ़ॉर्मेट में थोड़ा और गहराई से उतरते हैं।

चार्ट्स

चार्ट्स Altair में एक मूलभूत ऑब्जेक्ट हैं, और यह एक आर्गुमेंट स्वीकार करते हैं—एक DataFrame। चार्ट इस तरह परिभाषित किया जाता है:

alt.Chart(DataFrame)

पर अपने-आप में, चार्ट कुछ नहीं करेगा सिवाय इसके कि वह बताएगा कि आप किस डेटा के साथ काम करना चाहते हैं। इसके बाद आपको बताना होगा कि डेटा के साथ आगे क्या करना है। यहीं हम marks का उपयोग करते हैं।

मार्क्स

मार्क प्रॉपर्टी यह बताती है कि डेटा को प्लॉट पर कैसे दर्शाना है। Altair द्वारा दी गई मूलभूत मार्क प्रॉपर्टीज़ निम्न हैं:

मार्क प्रॉपर्टी के लिए, हम चाहते हैं कि DataFrame के प्रत्येक मान को प्लॉट में एक बिंदु (वृत्त) के रूप में चिह्नित किया जाए। इसलिए, हम लिखेंगे:

alt.Chart(DataFrame).mark_point()

एन्कोडिंग्स

जब हमारे पास डेटा और उसका प्रस्तुतीकरण तय हो जाए—तो हमें यह बताना होता है कि उसे कहाँ दिखाना है। यानी स्थिति, आकार, रंग आदि सेट करना। यहीं हम encodings का उपयोग करते हैं। इसलिए हमारे पास होगा:

alt.Chart(DataFrame).mark_point().encode()

यह सब एक साथ रखते हुए और विवरण जोड़ते हुए अपनी पहली विज़ुअलाइज़ेशन बनाएँ:

alt.Chart(movies_2000).mark_point().encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross')
)

<vega.vegalite.VegaLite at 0x11709a1d0>

कमाल नहीं है? हमें ज़्यादा कुछ नहीं करना पड़ा—हमने कुछ टर्मिनोलॉजी समझीं और सब एक साथ रखा। अब हमारे पास एक प्लॉट है जहाँ हम खर्च बनाम कमाई देखते हैं, हमारे डेटासेट की वर्ष 2000 की मूवीज़ के लिए।

आइए इस ग्राफ़ को और दिलचस्प बनाते हैं। सभी बिंदु एक ही आकार के वृत्त से चिह्नित करने के बजाय, बिंदुओं का आकार उनके संबंधित US_Gross जितना बड़ा (या छोटा) करें। इसके लिए हम Size फीचर जोड़ेंगे। यानी वृत्त जितना बड़ा, उनकी US बॉक्स-ऑफिस कमाई उतनी अधिक। साथ ही, वृत्तों में सिर्फ आउटलाइन नहीं, रंग भी भरें; इसके लिए हम mark_point() में एक आर्गुमेंट जोड़ेंगे।

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross')
)

<vega.vegalite.VegaLite at 0x117cce790>

अब हमारे पास मात्र चार लाइनों में प्रत्येक मूवी के बजट को दर्शाने वाला प्लॉट है। क्या कमी है? रंग!

पर हम सिर्फ दिखावे के लिए कोई रैंडम रंग नहीं जोड़ेंगे! हम ग्राफ़ को रोचक बनाए रखेंगे और डेटासेट में मौजूद एक और जानकारी, Major_Genre, जोड़ेंगे। हम प्रत्येक जेनर को उसका अपना रंग देंगे—Color फीचर के साथ—और OpacityValue से रंग में थोड़ी पारदर्शिता जोड़ेंगे।

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7)
)

<vega.vegalite.VegaLite at 0x118e3ff50>

यह अच्छा है, पर अभी और बेहतर हो सकता है! अगर हम प्लॉट पर घूमकर उस मूवी के विवरण भी देख सकें जिसे कोई डेटा पॉइंट दर्शाता है, तो बढ़िया होगा। Tooltip हमें यही करने देता है...

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title'),
               alt.Tooltip('Production_Budget'),
               alt.Tooltip('Worldwide_Gross'),
               alt.Tooltip('US_Gross')
              ]
)

<vega.vegalite.VegaLite at 0x118e3ff90>

कमाल नहीं? पर ठहरिए, और करते हैं। याद है हमने शुरुआत में Altair क्यों चुना था? ताकि हम इंटरैक्टिव विज़ुअलाइज़ेशन बना सकें। tooltip पहले से ही तब कुछ इंटरैक्शन देता है जब आप डेटा पॉइंट्स पर होवर करते हैं। हालाँकि, जो हमारे पास है उसमें एक साधारण interactive() फ़ंक्शनलिटी जोड़ते हैं...

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title'),
               alt.Tooltip('Production_Budget'),
               alt.Tooltip('Worldwide_Gross'),
               alt.Tooltip('US_Gross')
              ]
).interactive()

<vega.vegalite.VegaLite at 0x118e3c750>

यह छोटा-सा कोड जोड़ने से ही आप किसी विशेष क्षेत्र में ज़ूम कर सकते हैं—अक्ष मान अपने-आप ठीक हो जाते हैं, ताकि आप रुचि के क्षेत्र पर फोकस कर सकें। पर कई और उन्नत इंटरैक्टिव फीचर्स भी हैं जिन्हें आप ग्राफ़ में जोड़ सकते हैं। आइए उनमें से एक देखें...

अब हमारे पास डेटा दिखाने के लिए एक शानदार प्लॉट है। आइए सभी डेटा पॉइंट्स लाएँ और उन्हें ग्राफ़ में रखें। पर रुकिए, क्या आपको नहीं लगता कि एक ही विज़ुअलाइज़ेशन में सभी डेटा पॉइंट्स रखना बहुत ज़्यादा हो जाएगा? साथ ही, हम निश्चित रूप से उन्हें उस Year मान के आधार पर अलग करना चाहते हैं जो हमने पहले बनाया था। ऐसा करने के लिए, हम एक उन्नत selection प्रॉपर्टी का उपयोग करेंगे।

select_year = alt.selection_single(
    name='Select', fields=['Year'], init={'Year': 1928},
    bind=alt.binding_range(min=1928, max=2046, step=10)
)

alt.Chart(movies_df).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title:N'),
               alt.Tooltip('Production_Budget:Q'),
               alt.Tooltip('Worldwide_Gross:Q'),
               alt.Tooltip('US_Gross:Q')
              ]
).add_selection(select_year).transform_filter(select_year)

<vega.vegalite.VegaLite at 0x117cd4cd0>

तो, हम add_selection प्रॉपर्टी का उपयोग करके select_year को चार्ट में सिंगल सेलेक्शन फीचर के रूप में जोड़ते हैं और फिर transform_filter() लगाकर वास्तव में प्लॉट पर यह ट्रांसफ़ॉर्मेशन लागू करते हैं।

क्या आपने कोड में एक और नया जोड़ देखा? Tooltip में लगा 'Q' और 'N'। यह डेटा टाइप बताने के लिए है: N-Nominal (श्रेणीबद्ध डेटा), Q-Quantitative (संख्यात्मक डेटा), O-Ordinal (क्रमबद्ध डेटा), या T-Temporal (समय बिंदु या अंतराल)।

डेटासेट में सबसे पुराना और नवीनतम वर्ष जाँचें।

print("The oldest year is: ", movies_df["Year"].min())
print("The latest year is: ", movies_df["Year"].max())

The oldest year is:  1928
The latest year is:  2046

जैसा कि आप देख सकते हैं, जब आप 'Select_Year' बार को खींचते हैं, तो 1928 - 1967 के वर्षों में बहुत कम मूवीज़ दर्शाई गई हैं। और 2018 के बाद किसी मूवी का डेटा रिकॉर्ड नहीं है और निश्चित ही 2046 तक तो नहीं। हम binding_range() प्रॉपर्टी का उपयोग वर्ष की रेंज और वर्ष के स्टेप साइज तय करने के लिए कर सकते हैं।

वास्तविक प्रोजेक्ट में, ऐसे निष्कर्ष महत्वपूर्ण होते हैं और यह आपके डेटा एकत्रीकरण चरण में या प्रक्रिया के दौरान कहीं त्रुटियों की ओर संकेत कर सकते हैं। आपको त्रुटियों को प्रभावी ढंग से संभालना होगा। यह डेटा प्रीप्रोसेसिंग के दौरान एक महत्वपूर्ण कदम है। इन महत्वपूर्ण चरणों की भूमिका जानने के लिए Data Preparation with pandas देखें।

आइए वर्षों को समायोजित करें, और इसके साथ ही हमारी अंतिम विज़ुअलाइज़ेशन तैयार है...

select_year = alt.selection_single(
    name='Select', fields=['Year'], init={'Year': 1968},
    bind=alt.binding_range(min=1968, max=2008, step=10)
)

alt.Chart(movies_df).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title:N'),
               alt.Tooltip('Production_Budget:Q'),
               alt.Tooltip('Worldwide_Gross:Q'),
               alt.Tooltip('US_Gross:Q')
              ]
).add_selection(select_year).transform_filter(select_year)

<vega.vegalite.VegaLite at 0x1180cda10>

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