Python Language
Datavisualisering med Python

matplotlib

Matplotlib är ett matematiskt plottningsbibliotek för Python som tillhandahåller en mängd olika plottfunktioner.

Matplotlib-dokumentationen kan hittas här , där SO-dokumenten finns tillgängliga här .

Matplotlib tillhandahåller två distinkta metoder för att plotta, även om de till stor del är utbytbara:

• För det första tillhandahåller pyplot gränssnittet, direkt och enkelt att använda gränssnittet som möjliggör plottning av komplexa grafer i en MATLAB-liknande stil.
• För det andra tillåter matplotlib användaren att styra de olika aspekterna (axlar, linjer, fästingar, etc) direkt med hjälp av ett objektbaserat system. Detta är svårare men tillåter fullständig kontroll över hela tomten.

Nedan är ett exempel på att använda pyplot gränssnittet för att plotta vissa genererade data:

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

Observera att plt.show() är känt för att vara problematisk i vissa miljöer på grund av att matplotlib.pyplot körs i interaktivt läge, och i så fall kan blockeringsbeteendet åsidosättas uttryckligen genom att mata in ett valfritt argument, plt.show(block=True) , för att lindra problemet.

Seaborn

Seaborn är ett omslag runt Matplotlib som gör det enkelt att skapa gemensamma statistiska tomter. Listan över stödsdiagram innehåller univariata och bivariata fördelningsdiagram, regressionsdiagram och ett antal metoder för att plotta kategoriska variabler. Den fullständiga listan över tomter som Seaborn tillhandahåller finns i deras API-referens .

Att skapa grafer i Seaborn är lika enkelt som att kalla rätt grafningsfunktion. Här är ett exempel på att skapa ett histogram, uppskattning av kärntäthet och mattaplott för slumpmässigt genererade data.

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)

Plottens stil kan också kontrolleras med hjälp av en deklarativ syntax.

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

Som en extra bonus kan normala matplotlib-kommandon fortfarande tillämpas på Seaborn-tomter. Här är ett exempel på att lägga till axeltitlar till vårt tidigare skapade histogram.

# 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')

mayavi

MayaVI är ett 3D-visualiseringsverktyg för vetenskaplig data. Den använder Visualization Tool Kit eller VTK under huven. Med hjälp av kraften från VTK kan MayaVI producera olika tredimensionella tomter och figurer. Det finns som en separat programapplikation och även som ett bibliotek. I likhet med Matplotlib tillhandahåller detta bibliotek ett objektorienterat programmeringsspråkgränssnitt för att skapa tomter utan att behöva veta om VTK .

MayaVI finns endast i Python 2.7x-serien! Det hoppas att vara tillgängligt i Python 3-x-serien snart! (Även om viss framgång märks när man använder beroenden i Python 3)

Dokumentation kan hittas här . Några galleriexempel finns här

Här är ett exempel som skapats med MayaVI från dokumentationen.

# 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

Plotly är en modern plattform för planering och datavisualisering. Plotly är användbart för att producera en mängd olika tomter, särskilt för datavetenskap, som ett bibliotek för Python , R , JavaScript , Julia och, MATLAB . Det kan också användas som en webbapplikation med dessa språk.

Användare kan installera plottigt bibliotek och använda det offline efter användarautentisering. Installationen av detta bibliotek och autentisering offline är här . Tomterna kan också göras i Jupyter Notebooks .

För att använda detta bibliotek krävs ett konto med användarnamn och lösenord. Detta ger arbetsytan för att spara tomter och data på molnet.

Den kostnadsfria versionen av biblioteket har några något begränsade funktioner och är utformade för att göra 250 tomter per dag. Den betalade versionen har alla funktioner, obegränsade plotnedladdningar och mer privat datalagring. För mer information kan man besöka startsidan här .

För dokumentation och exempel kan man gå hit

Ett exempel på dokument från exempel på dokumentation:

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