माटप्लोटलिब 2 सबप्लॉट्स, 1 कलरबार


235

मैंने पूरी तरह से बहुत लंबे समय तक शोध किया है कि कैसे दो सबप्लॉट प्राप्त करने के लिए एक ही y- अक्ष को मैटप्लोटलिब में दोनों के बीच साझा किए गए एक ही रंग-अक्ष के साथ साझा करें।

क्या हो रहा था कि जब मैंने colorbar()फ़ंक्शन को या तो बुलाया subplot1या subplot2, तो यह प्लॉट को ऑटोस्कोप करेगा जैसे कि प्लम्बर और प्लॉट 'सबप्लॉट' बाउंडिंग बॉक्स के अंदर फिट होंगे, जिससे दो साइड-बाय-प्लॉट दो अलग-अलग होंगे आकार।

इसके आस-पास जाने के लिए, मैंने एक तीसरा सबप्लॉट बनाने की कोशिश की, जिसे मैंने तब हैक किया था, जब कोई प्लॉट मौजूद नहीं था। एकमात्र समस्या यह है कि अब दो भूखंडों की ऊँचाई और चौड़ाई असमान हैं, और मैं यह नहीं समझ सकता कि मैं कैसे ठीक दिखूं।

यहाँ मेरा कोड है:

from __future__ import division
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import patches
from matplotlib.ticker import NullFormatter

# SIS Functions
TE = 1 # Einstein radius
g1 = lambda x,y: (TE/2) * (y**2-x**2)/((x**2+y**2)**(3/2)) 
g2 = lambda x,y: -1*TE*x*y / ((x**2+y**2)**(3/2))
kappa = lambda x,y: TE / (2*np.sqrt(x**2+y**2))

coords = np.linspace(-2,2,400)
X,Y = np.meshgrid(coords,coords)
g1out = g1(X,Y)
g2out = g2(X,Y)
kappaout = kappa(X,Y)
for i in range(len(coords)):
    for j in range(len(coords)):
        if np.sqrt(coords[i]**2+coords[j]**2) <= TE:
            g1out[i][j]=0
            g2out[i][j]=0

fig = plt.figure()
fig.subplots_adjust(wspace=0,hspace=0)

# subplot number 1
ax1 = fig.add_subplot(1,2,1,aspect='equal',xlim=[-2,2],ylim=[-2,2])
plt.title(r"$\gamma_{1}$",fontsize="18")
plt.xlabel(r"x ($\theta_{E}$)",fontsize="15")
plt.ylabel(r"y ($\theta_{E}$)",rotation='horizontal',fontsize="15")
plt.xticks([-2.0,-1.5,-1.0,-0.5,0,0.5,1.0,1.5])
plt.xticks([-2.0,-1.5,-1.0,-0.5,0,0.5,1.0,1.5])
plt.imshow(g1out,extent=(-2,2,-2,2))
plt.axhline(y=0,linewidth=2,color='k',linestyle="--")
plt.axvline(x=0,linewidth=2,color='k',linestyle="--")
e1 = patches.Ellipse((0,0),2,2,color='white')
ax1.add_patch(e1)

# subplot number 2
ax2 = fig.add_subplot(1,2,2,sharey=ax1,xlim=[-2,2],ylim=[-2,2])
plt.title(r"$\gamma_{2}$",fontsize="18")
plt.xlabel(r"x ($\theta_{E}$)",fontsize="15")
ax2.yaxis.set_major_formatter( NullFormatter() )
plt.axhline(y=0,linewidth=2,color='k',linestyle="--")
plt.axvline(x=0,linewidth=2,color='k',linestyle="--")
plt.imshow(g2out,extent=(-2,2,-2,2))
e2 = patches.Ellipse((0,0),2,2,color='white')
ax2.add_patch(e2)

# subplot for colorbar
ax3 = fig.add_subplot(1,1,1)
ax3.axis('off')
cbar = plt.colorbar(ax=ax2)

plt.show()

जवाबों:


319

बस अपने स्वयं के अक्ष में colorbar रखें और इसके subplots_adjustलिए जगह बनाने के लिए उपयोग करें।

एक त्वरित उदाहरण के रूप में:

import numpy as np
import matplotlib.pyplot as plt

fig, axes = plt.subplots(nrows=2, ncols=2)
for ax in axes.flat:
    im = ax.imshow(np.random.random((10,10)), vmin=0, vmax=1)

fig.subplots_adjust(right=0.8)
cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])
fig.colorbar(im, cax=cbar_ax)

plt.show()

यहां छवि विवरण दर्ज करें

नोट रंग श्रेणी अंतिम छवि द्वारा निर्धारित किया जाएगा कि साजिश रची (कि को जन्म दिया है im) मानों की श्रेणी द्वारा निर्धारित है, भले ही vminऔर vmax। यदि कोई अन्य भूखंड है, उदाहरण के लिए, एक उच्च अधिकतम मूल्य, एक imसमान रंग में दिखाए जाने वाले अधिकतम की तुलना में उच्च मूल्यों के साथ इंगित करता है ।


4
इस सटीक उद्देश्य के लिए ImageGrid भी बहुत उपयोगी है।
फिलिप क्लाउड

5
यदि आपको tight_layout () का उपयोग करने की आवश्यकता है, तो आप सब कुछ subplots_adjust के बाद tight_layout के बाद करना चाहेंगे, और फिर subplots_adjust और add_axes के लिए निर्देशांक मैन्युअल रूप से ट्विक करें।
user1748155

2
मेरे पास दो अलग-अलग तितर बितर भूखंडों के लिए एक ही रंग पट्टी कैसे हो सकती है? मैंने ऊपर कोशिश की लेकिन मुझे नहीं पता कि उपयुक्त चर के साथ "im" को कैसे स्थानापन्न किया जाए। मान लें कि मेरे तितर बितर भूखंड हैं प्लॉट 1 = pylib.scatter (x, y, z) और प्लॉट 2 = pylib.scatter (a, b, c)
Rotail

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

2
यदि भूखंडों के मूल्यों की सीमा अलग-अलग है, तो colorbar रेंज केवल अंतिम प्लॉट की सीमा दिखाएगा, है ना? कोई सुझाव?
लुकास

132

आप कुल्हाड़ियों की एक सूची के axपैरामीटर का उपयोग करके जो किंग्टन के कोड को सरल बना सकते हैं figure.colorbar()। से प्रलेखन :

कुल्हाड़ी

कोई नहीं | पैरेंट एक्सिस ऑब्जेक्ट (ओं) से नए रंगबार अक्षों के लिए किस स्थान पर चोरी की जाएगी। यदि कुल्हाड़ियों की एक सूची दी गई है, तो वे सभी को कलरबार कुल्हाड़ियों के लिए जगह बनाने के लिए आकार बदला जाएगा।

import numpy as np
import matplotlib.pyplot as plt

fig, axes = plt.subplots(nrows=2, ncols=2)
for ax in axes.flat:
    im = ax.imshow(np.random.random((10,10)), vmin=0, vmax=1)

fig.colorbar(im, ax=axes.ravel().tolist())

plt.show()

1


4
इस समाधान ने यहां बहुत अच्छा काम किया, और सबसे आसान लगता है।
काकंड

8
यदि आप nrows को 1 में बदलते हैं, तो दोनों प्लॉट colorbar की तुलना में shoter हैं। तो, कैसे इस समस्या को हल कर सकते हैं?
जिन

6
अफ़सोस कि यह तंग_लेआउट के साथ काम नहीं करता है, लेकिन फिर भी अच्छा समाधान है।
मार्क

1
बस याद करने के लिए ... मैं इस समाधान से प्यार करता हूँ! तिन्हहिं कतार सीर भयउँ!
इरी simoes-sousa

1
इस उत्तर का महत्वपूर्ण हिस्सा है fig.colorbar(im, ax=axes.ravel().tolist())। यदि आप छोड़ देते हैं ax=axes.ravel().tolist(), तो कलरबार को एक सबप्लॉट के भीतर रखा जाएगा।
nyanpasu64

55

इस समाधान के लिए कुल्हाड़ियों के स्थानों या रंग-पट्टी के आकार के मैनुअल ट्विकिंग की आवश्यकता नहीं है, बहु-पंक्ति और एकल-पंक्ति लेआउट के साथ काम करता है, और साथ काम करता है tight_layout()। यह matplotlib के AxesGrid टूलबॉक्स से उपयोग करके, एक गैलरी उदाहरण से अनुकूलित किया गया है ।ImageGrid

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import ImageGrid

# Set up figure and image grid
fig = plt.figure(figsize=(9.75, 3))

grid = ImageGrid(fig, 111,          # as in plt.subplot(111)
                 nrows_ncols=(1,3),
                 axes_pad=0.15,
                 share_all=True,
                 cbar_location="right",
                 cbar_mode="single",
                 cbar_size="7%",
                 cbar_pad=0.15,
                 )

# Add data to image grid
for ax in grid:
    im = ax.imshow(np.random.random((10,10)), vmin=0, vmax=1)

# Colorbar
ax.cax.colorbar(im)
ax.cax.toggle_label(True)

#plt.tight_layout()    # Works, but may still require rect paramater to keep colorbar labels visible
plt.show()

छवि ग्रिड


डबल +1, यह एक महान दृष्टिकोण है
Brett

वास्तव में तंग_लेआउट के साथ काम करता है, लेकिन मुझे नहीं पता कि उस रंग पट्टी में एक लेबल कैसे जोड़ा जाए। यह kws लेबल, शीर्षक, पाठ ... कुछ भी स्वीकार नहीं करता है! और डॉक्स ज्यादा मदद नहीं करते हैं।
टॉमचो

3
@TomCho एक लेबल सेट करने के लिए, जब आप इसे टाइप करते हैं, तो आप कलरबार के हैंडल को पकड़ सकते हैं thecb = ax.cax.colorbar(im):। फिर आप कर सकते हैंthecb.set_label_text("foo")
पालक जूल

1
कॉलोरामैप कैसे बदलें?
सिगुर

1
@ सिगर मुझे यकीन है कि आपने अब तक इसका पता लगा लिया है, लेकिन दूसरों के लिए, आप im घोषित करते समय cmap बदल सकते हैं: im = ax.imshow (डेटा, vmin = 0, vmax = 1, cmap = 'a_cmap_here')
शॉन लोइस

38

उपयोग make_axesकरना और भी आसान है और बेहतर परिणाम देता है। यह कलरबार की स्थिति को अनुकूलित करने की संभावनाएं भी प्रदान करता है। subplotsएक्स और वाई एक्सिस साझा करने के विकल्प पर भी ध्यान दें ।

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl

fig, axes = plt.subplots(nrows=2, ncols=2, sharex=True, sharey=True)
for ax in axes.flat:
    im = ax.imshow(np.random.random((10,10)), vmin=0, vmax=1)

cax,kw = mpl.colorbar.make_axes([ax for ax in axes.flat])
plt.colorbar(im, cax=cax, **kw)

plt.show()


7
जब सबप्लॉट चौकोर नहीं होता है तो यह विधि काम नहीं करती है। यदि आप बदलते हैं nrows=1, तो कलरबार फिर से सबप्लॉट से बड़ा हो जाता है।
वेस्ले तन्से

आपकी matplotlib चूक क्या है? ये बहुत अच्छा दिखता है!
राफेलवेल

18

एक शुरुआत करने वाले के रूप में जो इस धागे को ठोकर मारता है , मैं अबेवीरमोटा के बहुत प्यारे जवाब के लिए एक अजगर-के-डमीज अनुकूलन को जोड़ना चाहता हूं (क्योंकि मैं इस स्तर पर हूं कि मुझे क्या काम करना है उनका कोड कर रहा था):

import numpy as np
import matplotlib.pyplot as plt

fig, ((ax1,ax2,ax3),(ax4,ax5,ax6)) = plt.subplots(2,3)

axlist = [ax1,ax2,ax3,ax4,ax5,ax6]

first = ax1.imshow(np.random.random((10,10)), vmin=0, vmax=1)
third = ax3.imshow(np.random.random((12,12)), vmin=0, vmax=1)

fig.colorbar(first, ax=axlist)

plt.show()

बहुत कम पायथोनिक, मेरे जैसे नोक के लिए बहुत आसान है यह देखने के लिए कि वास्तव में यहां क्या हो रहा है।


17

जैसा कि अन्य जवाबों में कहा गया है, विचार यह है कि रंगकर्बर के निवास के लिए एक कुल्हाड़ी को आमतौर पर परिभाषित करना है। ऐसा करने के विभिन्न तरीके हैं; एक जिसका उल्लेख अभी तक नहीं किया गया है, वह सीधे उपपट्ट निर्माण में colorbar axes को सीधे निर्दिष्ट करेगा plt.subplots()। लाभ यह है कि कुल्हाड़ियों की स्थिति को मैन्युअल रूप से सेट करने की आवश्यकता नहीं है और सभी मामलों में स्वत: पहलू के साथ रंगबार बिल्कुल सबप्लॉट के समान ऊंचाई होगी। यहां तक ​​कि कई मामलों में जहां छवियों का उपयोग किया जाता है, परिणाम नीचे दिखाए अनुसार संतोषजनक होगा।

उपयोग करते समय plt.subplots(), gridspec_kwतर्क का उपयोग अन्य अक्षों की तुलना में कलरबार कुल्हाड़ियों को बहुत छोटा करने की अनुमति देता है।

fig, (ax, ax2, cax) = plt.subplots(ncols=3,figsize=(5.5,3), 
                  gridspec_kw={"width_ratios":[1,1, 0.05]})

उदाहरण:

import matplotlib.pyplot as plt
import numpy as np; np.random.seed(1)

fig, (ax, ax2, cax) = plt.subplots(ncols=3,figsize=(5.5,3), 
                  gridspec_kw={"width_ratios":[1,1, 0.05]})
fig.subplots_adjust(wspace=0.3)
im  = ax.imshow(np.random.rand(11,8), vmin=0, vmax=1)
im2 = ax2.imshow(np.random.rand(11,8), vmin=0, vmax=1)
ax.set_ylabel("y label")

fig.colorbar(im, cax=cax)

plt.show()

यहां छवि विवरण दर्ज करें

यह अच्छी तरह से काम करता है, अगर भूखंड का पहलू आटोस्केल्ड है या चौड़ाई दिशा (जैसा कि ऊपर) में उनके पहलू के कारण छवियां सिकुड़ गई हैं। यदि, हालांकि, चित्र व्यापक हैं, तो उच्च, परिणाम निम्नानुसार दिखेगा, जो अवांछित हो सकता है।

यहां छवि विवरण दर्ज करें

सबप्लॉट ऊंचाई के लिए colorbar ऊंचाई को ठीक करने के लिए एक समाधान mpl_toolkits.axes_grid1.inset_locator.InsetPositionछवि subplot axes के सापेक्ष colorbar axes सेट करने के लिए उपयोग किया जाएगा ।

import matplotlib.pyplot as plt
import numpy as np; np.random.seed(1)
from mpl_toolkits.axes_grid1.inset_locator import InsetPosition

fig, (ax, ax2, cax) = plt.subplots(ncols=3,figsize=(7,3), 
                  gridspec_kw={"width_ratios":[1,1, 0.05]})
fig.subplots_adjust(wspace=0.3)
im  = ax.imshow(np.random.rand(11,16), vmin=0, vmax=1)
im2 = ax2.imshow(np.random.rand(11,16), vmin=0, vmax=1)
ax.set_ylabel("y label")

ip = InsetPosition(ax2, [1.05,0,0.05,1]) 
cax.set_axes_locator(ip)

fig.colorbar(im, cax=cax, ax=[ax,ax2])

plt.show()

यहां छवि विवरण दर्ज करें


मुझे यकीन नहीं है कि अगर मुझे यहां यह पूछने की अनुमति है, लेकिन क्या ax = fig.add_subplot()इसके बजाय इस समाधान को लागू करने का एक तरीका है ? मैं पूछ रहा हूं क्योंकि मैं यह नहीं जान सकता कि इसे बेसमैप के साथ कैसे इस्तेमाल किया जाए।
lanadaquenada

1
@lanadaquenada हाँ संभव है कि, लेकिन आप एक की आपूर्ति करने की आवश्यकता होगी GridSpecकरने के लिए add_subplot()उस मामले में।
ImportanceOfBeingErnest

10

Abevieiramota द्वारा कुल्हाड़ियों की एक सूची का उपयोग करने का समाधान तब तक बहुत अच्छी तरह से काम करता है जब तक आप केवल एक पंक्ति की छवियों का उपयोग नहीं करते हैं, जैसा कि टिप्पणियों में बताया गया है। figsizeमदद के लिए एक उचित पहलू अनुपात का उपयोग करना , लेकिन अभी भी सही से दूर है। उदाहरण के लिए:

import numpy as np
import matplotlib.pyplot as plt

fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(9.75, 3))
for ax in axes.flat:
    im = ax.imshow(np.random.random((10,10)), vmin=0, vmax=1)

fig.colorbar(im, ax=axes.ravel().tolist())

plt.show()

1 एक्स 3 छवि सरणी

Colorbar समारोह प्रदान करता है shrinkपैरामीटर जो colorbar कुल्हाड़ियों के आकार के लिए एक स्केलिंग कारक है। इसके लिए कुछ मैनुअल ट्रायल और एरर की जरूरत होती है। उदाहरण के लिए:

fig.colorbar(im, ax=axes.ravel().tolist(), shrink=0.75)

सिकुड़ रंगबार के साथ 1 एक्स 3 छवि सरणी


4

@ Abevieiramota के शानदार जवाब में जोड़ने के लिए, आप विवश_लेआउट के साथ तंग_लेआउट की यूरोपीयता प्राप्त कर सकते हैं। यदि आप imshowइसके pcolormeshद्वारा लगाए गए 1: 1 पहलू अनुपात के बजाय उपयोग करते हैं, तो भी आपको बड़े क्षैतिज अंतराल मिलेंगे imshow

import numpy as np
import matplotlib.pyplot as plt

fig, axes = plt.subplots(nrows=2, ncols=2, constrained_layout=True)
for ax in axes.flat:
    im = ax.pcolormesh(np.random.random((10,10)), vmin=0, vmax=1)

fig.colorbar(im, ax=axes.flat)
plt.show()

यहां छवि विवरण दर्ज करें


1

मैंने देखा कि लगभग हर समाधान में शामिल थे ax.imshow(im, ...)और कई सबफ़िगर के लिए रंगबार को प्रदर्शित रंगों को सामान्य नहीं किया था। imMappable पिछले उदाहरण से लिया जाता है, लेकिन क्या हुआ अगर एक से अधिक के मूल्यों im-s अलग हैं? (मुझे लगता है कि इन mappables का इलाज उसी तरह से किया जाता है जैसे कि समोच्च-सेट और सतह-सेट का इलाज किया जाता है।) मेरे पास एक 3 डी सतह की साजिश का उपयोग करके एक उदाहरण है जो 2x2 सबप्लॉट (एक पंक्ति के लिए एक colorbar) के लिए दो colorbars बनाता है। )। हालाँकि यह प्रश्न एक अलग व्यवस्था के लिए स्पष्ट रूप से पूछता है, मुझे लगता है कि उदाहरण कुछ चीजों को स्पष्ट करने में मदद करता है। मैं plt.subplots(...)दुर्भाग्य से 3 डी कुल्हाड़ियों की वजह से अभी तक यह करने का एक तरीका नहीं मिला है ।

उदाहरण प्लॉट

अगर केवल मैं बेहतर तरीके से कलरबार को स्थिति में ला सकता था ... (ऐसा करने के लिए शायद एक बेहतर तरीका है, लेकिन कम से कम इसका पालन करना बहुत मुश्किल नहीं होना चाहिए।)

import matplotlib
from matplotlib import cm
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D

cmap = 'plasma'
ncontours = 5

def get_data(row, col):
    """ get X, Y, Z, and plot number of subplot
        Z > 0 for top row, Z < 0 for bottom row """
    if row == 0:
        x = np.linspace(1, 10, 10, dtype=int)
        X, Y = np.meshgrid(x, x)
        Z = np.sqrt(X**2 + Y**2)
        if col == 0:
            pnum = 1
        else:
            pnum = 2
    elif row == 1:
        x = np.linspace(1, 10, 10, dtype=int)
        X, Y = np.meshgrid(x, x)
        Z = -np.sqrt(X**2 + Y**2)
        if col == 0:
            pnum = 3
        else:
            pnum = 4
    print("\nPNUM: {}, Zmin = {}, Zmax = {}\n".format(pnum, np.min(Z), np.max(Z)))
    return X, Y, Z, pnum

fig = plt.figure()
nrows, ncols = 2, 2
zz = []
axes = []
for row in range(nrows):
    for col in range(ncols):
        X, Y, Z, pnum = get_data(row, col)
        ax = fig.add_subplot(nrows, ncols, pnum, projection='3d')
        ax.set_title('row = {}, col = {}'.format(row, col))
        fhandle = ax.plot_surface(X, Y, Z, cmap=cmap)
        zz.append(Z)
        axes.append(ax)

## get full range of Z data as flat list for top and bottom rows
zz_top = zz[0].reshape(-1).tolist() + zz[1].reshape(-1).tolist()
zz_btm = zz[2].reshape(-1).tolist() + zz[3].reshape(-1).tolist()
## get top and bottom axes
ax_top = [axes[0], axes[1]]
ax_btm = [axes[2], axes[3]]
## normalize colors to minimum and maximum values of dataset
norm_top = matplotlib.colors.Normalize(vmin=min(zz_top), vmax=max(zz_top))
norm_btm = matplotlib.colors.Normalize(vmin=min(zz_btm), vmax=max(zz_btm))
cmap = cm.get_cmap(cmap, ncontours) # number of colors on colorbar
mtop = cm.ScalarMappable(cmap=cmap, norm=norm_top)
mbtm = cm.ScalarMappable(cmap=cmap, norm=norm_btm)
for m in (mtop, mbtm):
    m.set_array([])

# ## create cax to draw colorbar in
# cax_top = fig.add_axes([0.9, 0.55, 0.05, 0.4])
# cax_btm = fig.add_axes([0.9, 0.05, 0.05, 0.4])
cbar_top = fig.colorbar(mtop, ax=ax_top, orientation='vertical', shrink=0.75, pad=0.2) #, cax=cax_top)
cbar_top.set_ticks(np.linspace(min(zz_top), max(zz_top), ncontours))
cbar_btm = fig.colorbar(mbtm, ax=ax_btm, orientation='vertical', shrink=0.75, pad=0.2) #, cax=cax_btm)
cbar_btm.set_ticks(np.linspace(min(zz_btm), max(zz_btm), ncontours))

plt.show()
plt.close(fig)
## orientation of colorbar = 'horizontal' if done by column

यदि एकाधिक ims के मान अलग-अलग हैं, तो उन्हें एक ही
रंग पट्टी का

0

यह विषय अच्छी तरह से कवर किया गया है, लेकिन मैं अभी भी थोड़ा अलग दर्शन में एक और दृष्टिकोण का प्रस्ताव करना चाहूंगा ।

यह सेट-अप करने के लिए थोड़ा अधिक जटिल है लेकिन यह (मेरी राय में) थोड़ा अधिक लचीलापन देता है। उदाहरण के लिए, कोई प्रत्येक सबप्लॉट / कलरबार के संबंधित अनुपात के साथ खेल सकता है:

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.gridspec import GridSpec

# Define number of rows and columns you want in your figure
nrow = 2
ncol = 3

# Make a new figure
fig = plt.figure(constrained_layout=True)

# Design your figure properties
widths = [3,4,5,1]
gs = GridSpec(nrow, ncol + 1, figure=fig, width_ratios=widths)

# Fill your figure with desired plots
axes = []
for i in range(nrow):
    for j in range(ncol):
        axes.append(fig.add_subplot(gs[i, j]))
        im = axes[-1].pcolormesh(np.random.random((10,10)))

# Shared colorbar    
axes.append(fig.add_subplot(gs[:, ncol]))
fig.colorbar(im, cax=axes[-1])

plt.show()

यहां छवि विवरण दर्ज करें

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.