Python Language
पायथन के साथ डेटा विज़ुअलाइज़ेशन

matplotlib

Matplotlib पायथन के लिए एक गणितीय प्लॉटिंग लाइब्रेरी है जो विभिन्न प्लॉटिंग कार्यक्षमता की एक किस्म प्रदान करता है।

Matplotlib प्रलेखन यहाँ पाया जा सकता है , इसलिए SO डॉक्स यहाँ उपलब्ध हैं ।

Matplotlib प्लॉटिंग के लिए दो अलग-अलग तरीके प्रदान करता है, हालांकि वे अधिकांश भाग के लिए विनिमेय हैं:

• सबसे पहले, matplotlib pyplot इंटरफ़ेस, प्रत्यक्ष और सरल-से-उपयोग इंटरफ़ेस प्रदान करता है जो MATLAB जैसी शैली में जटिल ग्राफ़ की साजिश रचने की अनुमति देता है।
• दूसरे, matplotlib उपयोगकर्ता को ऑब्जेक्ट-आधारित सिस्टम का उपयोग करके विभिन्न पहलुओं (अक्षों, रेखाओं, टिकों आदि) को सीधे नियंत्रित करने की अनुमति देता है। यह अधिक कठिन है लेकिन पूरे भूखंड पर पूर्ण नियंत्रण की अनुमति देता है।

नीचे कुछ उत्पन्न डेटा को प्लॉट करने के लिए pyplot इंटरफ़ेस का उपयोग करने का एक उदाहरण है:

import matplotlib.pyplot as plt

# Generate some data for plotting.
x = [0, 1, 2, 3, 4, 5, 6]
y = [i**2 for i in x]

# Plot the data x, y with some keyword arguments that control the plot style.
# Use two different plot commands to plot both points (scatter) and a line (plot).

plt.scatter(x, y, c='blue', marker='x', s=100) # Create blue markers of shape "x" and size 100
plt.plot(x, y, color='red', linewidth=2) # Create a red line with linewidth 2.

# Add some text to the axes and a title.
plt.xlabel('x data')
plt.ylabel('y data')
plt.title('An example plot')

# Generate the plot and show to the user.
plt.show()

ध्यान दें कि इंटरैक्टिव मोड में matplotlib.pyplot चलाने के कारण plt.show() कुछ वातावरण में समस्याग्रस्त होने के लिए जाना जाता है, और यदि ऐसा है, तो वैकल्पिक तर्क, plt.show(block=True) में पास होने से अवरुद्ध व्यवहार को स्पष्ट रूप से ओवरराइड किया जा सकता है। plt.show(block=True) , इस मुद्दे को कम करने के लिए।

Seaborn

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

सीबॉर्न में ग्राफ बनाना उतना ही सरल है जितना कि उपयुक्त ग्राफिंग फ़ंक्शन को कॉल करना। यहाँ बेतरतीब ढंग से उत्पन्न डेटा के लिए हिस्टोग्राम, कर्नेल घनत्व अनुमान और गलीचा साजिश बनाने का एक उदाहरण है।

import numpy as np  # numpy used to create data from plotting
import seaborn as sns  # common form of importing seaborn

# Generate normally distributed data
data = np.random.randn(1000)

# Plot a histogram with both a rugplot and kde graph superimposed
sns.distplot(data, kde=True, rug=True)

एक घोषणात्मक वाक्यविन्यास का उपयोग करके प्लॉट की शैली को भी नियंत्रित किया जा सकता है।

# Using previously created imports and data.

# Use a dark background with no grid.
sns.set_style('dark')
# Create the plot again
sns.distplot(data, kde=True, rug=True)

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

# Using previously created data and style

# Access to matplotlib commands
import matplotlib.pyplot as plt

# Previously created plot. 
sns.distplot(data, kde=True, rug=True)
# Set the axis labels.
plt.xlabel('This is my x-axis')
plt.ylabel('This is my y-axis')

मायावी

मायावी वैज्ञानिक डेटा के लिए एक 3D विज़ुअलाइज़ेशन उपकरण है। यह हुड के नीचे विज़ुअलाइज़ेशन टूल किट या वीटीके का उपयोग करता है। की शक्ति का उपयोग VTK , मायावी 3 आयामी भूखंडों और आंकड़े की एक किस्म के उत्पादन में सक्षम है। यह एक अलग सॉफ्टवेयर एप्लिकेशन के रूप में और लाइब्रेरी के रूप में भी उपलब्ध है। Matplotlib के समान, यह लाइब्रेरी VTK के बारे में जाने बिना प्लॉट बनाने के लिए ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग लैंग्वेज इंटरफ़ेस प्रदान करती है।

मायावी केवल पायथन 2.7x श्रृंखला में उपलब्ध है! यह जल्द ही पायथन 3-एक्स श्रृंखला में उपलब्ध होने की उम्मीद है! (हालांकि पायथन 3 में इसकी निर्भरता का उपयोग करते समय कुछ सफलता देखी गई है)

प्रलेखन यहाँ पाया जा सकता है । कुछ गैलरी उदाहरण यहां पाए जाते हैं

यहाँ प्रलेखन से मायावी का उपयोग करके बनाया गया एक नमूना प्लॉट है।

# Author: Gael Varoquaux <[email protected]>
# Copyright (c) 2007, Enthought, Inc.
# License: BSD Style.


from numpy import sin, cos, mgrid, pi, sqrt
from mayavi import mlab

mlab.figure(fgcolor=(0, 0, 0), bgcolor=(1, 1, 1))
u, v = mgrid[- 0.035:pi:0.01, - 0.035:pi:0.01]

X = 2 / 3. * (cos(u) * cos(2 * v)
        + sqrt(2) * sin(u) * cos(v)) * cos(u) / (sqrt(2) -
                                                 sin(2 * u) * sin(3 * v))
Y = 2 / 3. * (cos(u) * sin(2 * v) -
        sqrt(2) * sin(u) * sin(v)) * cos(u) / (sqrt(2)
        - sin(2 * u) * sin(3 * v))
Z = -sqrt(2) * cos(u) * cos(u) / (sqrt(2) - sin(2 * u) * sin(3 * v))
S = sin(u)

mlab.mesh(X, Y, Z, scalars=S, colormap='YlGnBu', )

# Nice view from the front
mlab.view(.0, - 5.0, 4)
mlab.show()

Plotly

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

उपयोगकर्ता प्रमाणीकरण के बाद ऑफ़लाइन लाइब्रेरी स्थापित कर सकते हैं और उसका उपयोग कर सकते हैं। इस लाइब्रेरी की स्थापना और ऑफ़लाइन प्रमाणीकरण यहाँ दिया गया है । साथ ही, जुपिटर नोटबुक में भी प्लॉट बनाए जा सकते हैं।

इस लाइब्रेरी के उपयोग के लिए उपयोगकर्ता नाम और पासवर्ड के साथ एक खाते की आवश्यकता होती है। यह प्लॉट और डेटा को क्लाउड पर सहेजने के लिए कार्यक्षेत्र देता है।

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

प्रलेखन और उदाहरणों के लिए, कोई भी यहां जा सकता है

प्रलेखन उदाहरण से एक नमूना साजिश:

import plotly.graph_objs as go
import plotly as ply

# Create random data with numpy
import numpy as np

N = 100
random_x = np.linspace(0, 1, N)
random_y0 = np.random.randn(N)+5
random_y1 = np.random.randn(N)
random_y2 = np.random.randn(N)-5

# Create traces
trace0 = go.Scatter(
    x = random_x,
y = random_y0,
mode = 'lines',
name = 'lines'
)
trace1 = go.Scatter(
    x = random_x,
    y = random_y1,
    mode = 'lines+markers',
    name = 'lines+markers'
)
trace2 = go.Scatter(
    x = random_x,
    y = random_y2,
    mode = 'markers',
    name = 'markers'
)
data = [trace0, trace1, trace2]

ply.offline.plot(data, filename='line-mode')