पायथन का उपयोग करके एक plt.show () विंडो को अधिकतम कैसे करें

Question 1

बस जिज्ञासा के लिए मैं यह जानना चाहूंगा कि नीचे दिए गए कोड में यह कैसे करना है। मैं एक उत्तर की तलाश कर रहा हूं लेकिन बेकार है।

import numpy as np
import matplotlib.pyplot as plt
data=np.random.exponential(scale=180, size=10000)
print ('el valor medio de la distribucion exponencial es: ')
print np.average(data)
plt.hist(data,bins=len(data)**0.5,normed=True, cumulative=True, facecolor='red', label='datos tamano paqutes acumulativa', alpha=0.5)
plt.legend()
plt.xlabel('algo')
plt.ylabel('algo')
plt.grid()
plt.show()

Question 2

मैं आमतौर पर उपयोग करता हूं

mng = plt.get_current_fig_manager()
mng.frame.Maximize(True)

कॉल करने से पहले plt.show(), और मुझे एक अधिकतम विंडो मिलती है। यह केवल 'wx' बैकएंड के लिए काम करता है।

संपादित करें:

Qt4Agg बैकएंड के लिए, kwerenda का उत्तर देखें ।

Question 3

मैं एक Windows (WIN7) पर हूं, पायथन 2.7.5 और Matplotlib 1.3.1 चला रहा हूं।

मैं निम्नलिखित पंक्तियों का उपयोग करके TkAgg, QT4Agg और wxAgg के लिए चित्र विंडो को अधिकतम करने में सक्षम था:

from matplotlib import pyplot as plt

### for 'TkAgg' backend
plt.figure(1)
plt.switch_backend('TkAgg') #TkAgg (instead Qt4Agg)
print '#1 Backend:',plt.get_backend()
plt.plot([1,2,6,4])
mng = plt.get_current_fig_manager()
### works on Ubuntu??? >> did NOT working on windows
# mng.resize(*mng.window.maxsize())
mng.window.state('zoomed') #works fine on Windows!
plt.show() #close the figure to run the next section

### for 'wxAgg' backend
plt.figure(2)
plt.switch_backend('wxAgg')
print '#2 Backend:',plt.get_backend()
plt.plot([1,2,6,4])
mng = plt.get_current_fig_manager()
mng.frame.Maximize(True)
plt.show() #close the figure to run the next section

### for 'Qt4Agg' backend
plt.figure(3)
plt.switch_backend('QT4Agg') #default on my system
print '#3 Backend:',plt.get_backend()
plt.plot([1,2,6,4])
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
plt.show()

उम्मीद है कि पिछले जवाबों (और कुछ अतिरिक्त) के इस सारांश में एक काम करने वाले उदाहरण (कम से कम खिड़कियों के लिए) में संयुक्त मदद करता है। चियर्स

Question 4

Qt बैकएंड के साथ (चित्र प्रबंधक) उचित आदेश है:

figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()

Question 5

यह विंडो को मेरे लिए पूर्ण स्क्रीन तक ले जाता है, Ubuntu 12.04 के तहत TkAgg बैकएंड के साथ:

    mng = plt.get_current_fig_manager()
    mng.resize(*mng.window.maxsize())

Question 6

मेरे लिए उपरोक्त में से कुछ भी काम नहीं किया। मैं Ubuntu 14.04 पर Tk बैकएंड का उपयोग करता हूं जिसमें matplotlib 1.3.1 है।

निम्न कोड एक पूर्णस्क्रीन प्लॉट विंडो बनाता है जो अधिकतम के समान नहीं है, लेकिन यह मेरे उद्देश्य को अच्छी तरह से कार्य करता है:

from matplotlib import pyplot as plt
mng = plt.get_current_fig_manager()
mng.full_screen_toggle()
plt.show()

Question 7

यह काम करना चाहिए ( कम से कम TkAgg के साथ):

wm = plt.get_current_fig_manager()
wm.window.state('zoomed')

(ऊपर से अपनाया गया और टिंकर का उपयोग करके, क्या खिड़की को देखने के बिना प्रयोग करने योग्य स्क्रीन आकार प्राप्त करने का एक तरीका है? )

Question 8

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

fig = figure(figsize=(80, 60))

वास्तव में, Qt4Agg के साथ उबंटू में 16.04, यह विंडो को अधिकतम करता है (पूर्ण-स्क्रीन नहीं) यदि यह स्क्रीन से बड़ा है। (यदि आपके पास दो मॉनिटर हैं, तो यह इसे उनमें से एक पर अधिकतम करता है)।

Question 9

मुझे यह उबंटू पर पूर्ण स्क्रीन मोड के लिए मिला

#Show full screen
mng = plt.get_current_fig_manager()
mng.full_screen_toggle()

Question 10

मैं भी मिलता हूं mng.frame.Maximize(True) AttributeError: FigureManagerTkAgg instance has no attribute 'frame'।

फिर मैंने देखा कि विशेषताओं के माध्यम से mngहै, और मैंने पाया:

mng.window.showMaximized()

मेरे लिए वह काम कर गया।

तो जो लोग एक ही परेशानी के लिए है, आप यह कोशिश कर सकते हैं।

वैसे, मेरा Matplotlib संस्करण 1.3.1 है।

Question 11

एक समाधान जो विन 10 पर त्रुटिपूर्ण रूप से काम करता था।

import matplotlib.pyplot as plt

plt.plot(x_data, y_data)

mng = plt.get_current_fig_manager()
mng.window.state("zoomed")
plt.show()

Question 12

मेरा अब तक का सबसे अच्छा प्रयास, विभिन्न बैकेंड का समर्थन करना:

from platform import system
def plt_maximize():
    # See discussion: /programming/12439588/how-to-maximize-a-plt-show-window-using-python
    backend = plt.get_backend()
    cfm = plt.get_current_fig_manager()
    if backend == "wxAgg":
        cfm.frame.Maximize(True)
    elif backend == "TkAgg":
        if system() == "win32":
            cfm.window.state('zoomed')  # This is windows only
        else:
            cfm.resize(*cfm.window.maxsize())
    elif backend == 'QT4Agg':
        cfm.window.showMaximized()
    elif callable(getattr(cfm, "full_screen_toggle", None)):
        if not getattr(cfm, "flag_is_max", None):
            cfm.full_screen_toggle()
            cfm.flag_is_max = True
    else:
        raise RuntimeError("plt_maximize() is not implemented for current backend:", backend)

Question 13

एक भूखंड पर ध्यान केंद्रित किए जाने पर fकुंजी (या ctrl+f1.2rc1 में) दबाने से एक भूखंड की खिड़की फ़ुलस्क्रीन हो जाएगी। काफी अधिकतम नहीं है, लेकिन शायद बेहतर।

इसके अलावा, वास्तव में अधिकतम करने के लिए, आपको जीयूआई टूलकिट विशिष्ट कमांड (यदि वे आपके विशिष्ट बैकेंड के लिए मौजूद हैं) का उपयोग करने की आवश्यकता होगी।

HTH

Question 14

मेरे संस्करणों में (पायथन 3.6, एक्लिप्स, विंडोज 7), ऊपर दिए गए स्निपेट्स काम नहीं करते थे, लेकिन एक्लिप्स / पाइदेव द्वारा दिए गए संकेत के साथ (टाइप करने के बाद: mng।), मैंने पाया:

mng.full_screen_toggle()

ऐसा लगता है कि केवल स्थानीय विकास के लिए mng-कमांड का उपयोग करना ठीक है ...

Question 15

अतिरिक्त कीवर्ड तर्क के साथ 'चित्र.सेट_साइज़_ इंच' पद्धति का उपयोग करने का प्रयास करें forward=True। प्रलेखन के अनुसार , यह आंकड़ा विंडो का आकार बदलना चाहिए ।

क्या वास्तव में ऐसा होता है कि आप जिस ऑपरेटिंग सिस्टम का उपयोग कर रहे हैं, उस पर निर्भर करेगा।

Question 16

यहाँ @ पायथनियो के उत्तर पर आधारित एक समारोह है। मैं इसे एक फ़ंक्शन में इनकैप्सुलेट करता हूं जो स्वचालित रूप से पता लगाता है कि यह किस बैकेंड का उपयोग कर रहा है और संबंधित क्रियाएं करता है।

def plt_set_fullscreen():
    backend = str(plt.get_backend())
    mgr = plt.get_current_fig_manager()
    if backend == 'TkAgg':
        if os.name == 'nt':
            mgr.window.state('zoomed')
        else:
            mgr.resize(*mgr.window.maxsize())
    elif backend == 'wxAgg':
        mgr.frame.Maximize(True)
    elif backend == 'Qt4Agg':
        mgr.window.showMaximized()

Question 17

plt.figure(figsize=(6*3.13,4*3.13))साजिश को बड़ा बनाने की कोशिश करें ।

Question 18

ठीक है तो यह मेरे लिए काम किया है। मैंने पूरा शोमैक्सिमाइज़ () विकल्प किया और यह आपकी विंडो को आकृति के आकार के अनुपात में आकार देता है, लेकिन यह कैनवास का विस्तार और 'फिट' नहीं करता है। मैंने इसे हल किया:

mng = plt.get_current_fig_manager()                                         
mng.window.showMaximized()
plt.tight_layout()    
plt.savefig('Images/SAVES_PIC_AS_PDF.pdf') 

plt.show()

Question 19

यह आवश्यक रूप से आपकी खिड़की को अधिकतम नहीं करता है, लेकिन यह आपकी खिड़की को आकार के आकार के अनुपात में बदलता है:

from matplotlib import pyplot as plt
F = gcf()
Size = F.get_size_inches()
F.set_size_inches(Size[0]*2, Size[1]*2, forward=True)#Set forward to True to resize window along with plot in figure.
plt.show() #or plt.imshow(z_array) if using an animation, where z_array is a matrix or numpy array

यह भी मदद कर सकता है: http://matplotlib.1069221.n5.nabble.com/Resizing-figure-windows-td11424.html

Question 20

निम्नलिखित सभी बैकएंड के साथ काम कर सकता है, लेकिन मैंने इसे केवल क्यूटी पर परीक्षण किया:

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

plt.switch_backend('QT4Agg') #default on my system
print('Backend: {}'.format(plt.get_backend()))

fig = plt.figure()
ax = fig.add_axes([0,0, 1,1])
ax.axis([0,10, 0,10])
ax.plot(5, 5, 'ro')

mng = plt._pylab_helpers.Gcf.figs.get(fig.number, None)

mng.window.showMaximized() #maximize the figure
time.sleep(3)
mng.window.showMinimized() #minimize the figure
time.sleep(3)
mng.window.showNormal() #normal figure
time.sleep(3)
mng.window.hide() #hide the figure
time.sleep(3)
fig.show() #show the previously hidden figure

ax.plot(6,6, 'bo') #just to check that everything is ok
plt.show()

Question 21

import matplotlib.pyplot as plt
def maximize():
    plot_backend = plt.get_backend()
    mng = plt.get_current_fig_manager()
    if plot_backend == 'TkAgg':
        mng.resize(*mng.window.maxsize())
    elif plot_backend == 'wxAgg':
        mng.frame.Maximize(True)
    elif plot_backend == 'Qt4Agg':
        mng.window.showMaximized()

तब फ़ंक्शन को कॉल maximize()करने से पहलेplt.show()

Question 22

GTK3Agg के बैकएंड के लिए , maximize()विशेष रूप से - कम केस m के साथ :

manager = plt.get_current_fig_manager()
manager.window.maximize()

पाइथन 3.8 के साथ उबंटू 20.04 में परीक्षण किया गया।

Question 23

Tk- आधारित बैकएंड (TkAgg) के लिए, ये दो विकल्प विंडो को अधिकतम और फुलस्क्रीन करते हैं:

plt.get_current_fig_manager().window.state('zoomed')
plt.get_current_fig_manager().window.attributes('-fullscreen', True)

कई विंडो में प्लॉट करते समय, आपको प्रत्येक विंडो के लिए यह लिखना होगा:

data = rasterio.open(filepath)

blue, green, red, nir = data.read()
plt.figure(1)
plt.subplot(121); plt.imshow(blue);
plt.subplot(122); plt.imshow(red);
plt.get_current_fig_manager().window.state('zoomed')

rgb = np.dstack((red, green, blue))
nrg = np.dstack((nir, red, green))
plt.figure(2)
plt.subplot(121); plt.imshow(rgb);
plt.subplot(122); plt.imshow(nrg);
plt.get_current_fig_manager().window.state('zoomed')

plt.show()

यहाँ, दोनों 'आकृतियों' को अलग-अलग विंडो में प्लॉट किया गया है। एक चर का उपयोग करना जैसे

figure_manager = plt.get_current_fig_manager()

दूसरी विंडो को अधिकतम नहीं किया जा सकता है, क्योंकि चर अभी भी पहली विंडो को संदर्भित करता है।