পাইথনে আমি কীভাবে মনিটরের রেজোলিউশন পাই?


125

মনিটরের রেজোলিউশন পাওয়ার সবচেয়ে সহজ উপায় কী (পছন্দসই একটি টিপলে)?


আপনি কি কোনও নির্দিষ্ট ইউআই টুলকিট ব্যবহার করছেন? (উদাঃ জিটিকে, ডাব্লুএক্সপিথন,
টিনকিটার

11
সঙ্গে Tkinterমডিউল দেখবেন, আপনি এটা করতে পারেন এই ভাবে । এটি স্ট্যান্ডার্ড পাইথন লাইব্রেরির অংশ এবং বেশিরভাগ ইউনিক্স এবং উইন্ডোজ প্ল্যাটফর্মগুলিতে কাজ করে।
martineau

1
সাধারণ ইউআইগুলির জন্য বিভিন্ন কৌশল সম্পর্কে একটি ভাল ওভারভিউ এই লিঙ্কটিতে
ImportanceOfBeingEnnest

উত্তর:


74

উইন্ডোজে:

from win32api import GetSystemMetrics

print("Width =", GetSystemMetrics(0))
print("Height =", GetSystemMetrics(1))

আপনি যদি উচ্চ রেজোলিউশনের স্ক্রিন নিয়ে কাজ করছেন তবে নিশ্চিত হন যে আপনার অজগর দোভাষী হাইটপিডিয়াওয়ার।

এই পোস্টের উপর ভিত্তি করে ।


9
মাল্টিপ্লাটফর্ম সম্পূর্ণ সমাধানের জন্য, এই উত্তরটি দেখুন
ধ্রুব রেশমওয়ালা

1
একাধিক মনিটর ব্যবহার করার সময়, এটি কেবলমাত্র প্রাথমিক প্রদর্শনের আকারটি ফিরিয়ে দেবে।
স্টিভয়েসিয়াক

1
অজগর দোভাষী আপনি কীভাবে সেট করবেন highdpiaware? উত্তরের অন্তর্ভুক্ত করার জন্য এটি দরকারী হবে।
এরিক

120

উইন্ডোজে আপনি সিটি টাইপগুলি এর সাথেও ব্যবহার করতে পারেন GetSystemMetrics():

import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)

যাতে আপনার পাইউইন 32 প্যাকেজটি ইনস্টল করার প্রয়োজন হয় না; পাইথনের নিজেই আসে না এমন কিছু দরকার নেই।

মাল্টি-মনিটর সেটআপগুলির জন্য, আপনি ভার্চুয়াল মনিটরের সম্মিলিত প্রস্থ এবং উচ্চতা পুনরুদ্ধার করতে পারেন:

import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)

11
গুরুত্বপূর্ণ দ্রষ্টব্য: ফিরে আসা মানগুলি ভুল হতে পারে যদি ডিপিআই স্কেলিং ব্যবহার করা হয় (যেমন: প্রায়শই 4 কে ডিসপ্লেতে কেস হয়), আপনাকে জিইউআই উপাদানগুলির সূচনা করার আগে সেটপ্রসেসডিপিআইএওয়াইয়ার কল করতে হবে (এবং গেটসিসটেমেট্রিক্স ফাংশনটি কল করার আগে নয়)। এটি win32 প্ল্যাটফর্মে বেশিরভাগ উত্তরের (জিটিকে, ইত্যাদি) ক্ষেত্রে সত্য।
টোটাম

1
একাধিক মনিটরের জন্য, আপনি গেটসিস্টেমমেট্রিক্স (78) এবং গেটসিস্টেমমেট্রিক্স (79)
ডেরেক

@ ডেরেক কি করে GetSystemMetrics(78)এবং GetSystemMetrics(79)ফিরে আসবে?
স্টিভয়েসিয়াক

@ স্টিভেনভ্যাসেল্লারো ভার্চুয়াল স্ক্রিনের প্রস্থ / উচ্চতা পিক্সেলগুলিতে। msdn.microsoft.com/en-us/library/windows/desktop/…
ডেরেক

93

আমি এই কারণে একটি পাইপিআই মডিউল তৈরি করেছি :

pip install screeninfo

কোড:

from screeninfo import get_monitors
for m in get_monitors():
    print(str(m))

ফলাফল:

monitor(1920x1080+1920+0)
monitor(1920x1080+0+0)

এটি একাধিক মনিটর পরিবেশকে সমর্থন করে । এর লক্ষ্য ক্রস প্ল্যাটফর্ম হতে হবে; আপাতত এটি সাইগউইন এবং এক্স 11 সমর্থন করে তবে টানুন অনুরোধগুলি সম্পূর্ণ স্বাগত।


2
উইন্ডোতে দুর্দান্ত কাজ করে তবে ম্যাকের জন্য আমি নিম্নলিখিত ত্রুটিটি পেয়েছি: আমদানি ত্রুটি: এক্স 11 লোড করা যায়নি
ক্রিস লুসিয়ান

5
উবুন্টুতে দুর্দান্ত কাজ করে। উবুন্টু 16.04 এ পরীক্ষিত।
ধ্রুব রেশমওয়ালা

3
এফওয়াইআই, উইন্ডোজ ডিপিআই স্কেলিং এখনও প্রযোজ্য। এই লাইনটি উইন্ডোজকে বলবে যে আপনি কাঁচা, আনসেলড রেজোলিউশন চান: "ctyype আমদানি করুন; ব্যবহারকারীর 32 = ctypes.windll.user32; user32.SetProcessDPIAware ()"। 1) আপনার উত্তর শীর্ষে হওয়া উচিত; ভাল করেছ. 2) আমার মন্তব্য উইন্ডোজ-ভিত্তিক, না গ্রন্থাগার নির্দিষ্ট (অর্থাত screeninfo) 3) কোড ripped এবং এখানে KobeJohn এর মন্তব্য থেকে পরীক্ষিত হয়: stackoverflow.com/a/32541666/2616321
Jason2616321

6
হ্যান্ডি মডিউল (+1)। pip install cython pyobjusযদিও
ওএসএক্সে

45

আপনি যদি ডাব্লুএক্স উইন্ডো ব্যবহার করছেন তবে আপনি কেবল তা করতে পারেন:

import wx

app = wx.App(False) # the wx.App object must be created first.    
print(wx.GetDisplaySize())  # returns a tuple

এটাই সেরা ... কার কাছে ডাব্লুএক্স নেই? :) প্লাস কয়েকটি চোখের পরিবর্তে কয়েকটি লাইন কোড unch এটি এখন আমার ডিফল্ট পদ্ধতি, আপনাকে ধন্যবাদ।
m3nda

1
এটি হওয়া উচিত app = wx.App(False)অন্যথায় আপনি "ডাব্লুএক্স। অ্যাপ্লিকেশন অবজেক্টটি তৈরি করতে হবে।" ত্রুটি. ২ votes টি ভোট এবং কেউ চেক করেনি? উইন্ডোজে কোনও চলককে ডাব্লুএক্স উদাহরণ না দিয়ে কাজ করে?
m3nda

2
ডাব্লুএক্স নেই কার? অনেক মানুষ?
মার্শ

43

এই পোস্টের উত্তর থেকে সরাসরি নেওয়া: টিকিনটারে স্ক্রিনের আকারটি কীভাবে পাবেন?

import tkinter as tk

root = tk.Tk()

screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()

8
আপনার যদি বাহ্যিক প্রদর্শনগুলি প্রাথমিক প্রদর্শনের পাশে প্রসারিত করে থাকে তবে এই পদ্ধতিটি বর্তমান প্রদর্শনের রেজোলিউশন নয়, সমস্ত ডিসপ্লে রেজোলিউশনের যোগফল দেয়।
jadelord

একাধিক স্ক্রিন পদক্ষেপের জন্য আমার উত্তর দেখুন
norok2

29

উইন্ডোজ 8.1 এ আমি সিটিপি বা টি কে হয় না থেকে সঠিক রেজোলিউশন পাচ্ছি না। সিটিপিসের জন্য অন্যান্য লোকেরাও একই সমস্যায় রয়েছেন: গেসিস্টেমমেট্রিকগুলি ভুল স্ক্রিনের আকারটি ফেরত দেয় উইন্ডোজ ৮.১-তে একটি উচ্চ ডিপিআই মনিটরের সঠিক সম্পূর্ণ রেজোলিউশন পেতে, আপনাকে অবশ্যই সেটপ্রসেসডিপিআইএআইওয়্যারের সাথে কল করতে হবে এবং নিম্নলিখিত কোডটি ব্যবহার করতে হবে:

import ctypes
user32 = ctypes.windll.user32
user32.SetProcessDPIAware()
[w, h] = [user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)]

সম্পূর্ণ বিবরণ নীচে:

আমি খুঁজে পেয়েছি যে এটি কারণ উইন্ডোজ একটি ছোট আকারের রেজোলিউশনের রিপোর্ট করছে। দেখা যাচ্ছে অজগরটি ডিফল্টরূপে একটি 'সিস্টেম ডিপিআই সচেতন' অ্যাপ্লিকেশন। ডিপিআই সচেতন অ্যাপ্লিকেশনগুলির প্রকারগুলি এখানে তালিকাভুক্ত করা হয়েছে: http : //msdn.mic्राস্টিক.com/

মূলত, সম্পূর্ণ মনিটরের রেজোলিউশনকে কন্টেন্ট প্রদর্শন করার পরিবর্তে, ফন্টগুলি ক্ষুদ্র করে তোলে, ফন্টগুলি যথেষ্ট বড় না হওয়া পর্যন্ত সামগ্রীটি ছোট করে দেওয়া হয়।

আমার মনিটরে আমি পাই:
শারীরিক রেজোলিউশন: 2560 x 1440 (220 ডিপিআই)
রিপোর্ট করা পাইথন রেজোলিউশন: 1555 x 875 (158 ডিপিআই)

এই উইন্ডোজ সাইটটির জন্য: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx রিপোর্ট করা সিস্টেম কার্যকর রেজোলিউশনের সূত্রটি হ'ল: (রিপোর্ট_পিএক্স * কারেন্ট_ডিপিআই) / (96 ডিপিআই) ) = শারীরিক_পেক্স

আমি নীচের কোড সহ সঠিক পূর্ণ পর্দার রেজোলিউশন এবং বর্তমান ডিপিআই পেতে সক্ষম। নোট করুন যে প্রোগ্রামটিকে আসল রেজোলিউশনটি দেখার অনুমতি দেওয়ার জন্য আমি সেটপ্রেসেসডিপিআইএআইওয়্যার () কল করি।

import tkinter as tk
root = tk.Tk()

width_px = root.winfo_screenwidth()
height_px = root.winfo_screenheight() 
width_mm = root.winfo_screenmmwidth()
height_mm = root.winfo_screenmmheight() 
# 2.54 cm = in
width_in = width_mm / 25.4
height_in = height_mm / 25.4
width_dpi = width_px/width_in
height_dpi = height_px/height_in 

print('Width: %i px, Height: %i px' % (width_px, height_px))
print('Width: %i mm, Height: %i mm' % (width_mm, height_mm))
print('Width: %f in, Height: %f in' % (width_in, height_in))
print('Width: %f dpi, Height: %f dpi' % (width_dpi, height_dpi))

import ctypes
user32 = ctypes.windll.user32
user32.SetProcessDPIAware()
[w, h] = [user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)]
print('Size is %f %f' % (w, h))

curr_dpi = w*96/width_px
print('Current DPI is %f' % (curr_dpi))    

যা ফিরে এসেছে:

Width: 1555 px, Height: 875 px
Width: 411 mm, Height: 232 mm
Width: 16.181102 in, Height: 9.133858 in
Width: 96.099757 dpi, Height: 95.797414 dpi
Size is 2560.000000 1440.000000
Current DPI is 158.045016

আমি 220 ডিপিআই সক্ষম মনিটরের সাথে উইন্ডোজ 8.1 চালাচ্ছি। আমার প্রদর্শন স্কেলিংটি আমার বর্তমান ডিপিআই 158 এ সেট করে।

আমি আমার ম্যাটপ্ল্লোটিব প্লটগুলি সঠিক আকারের তা নিশ্চিত করার জন্য 158 ব্যবহার করব: পাইলাব আমদানি থেকে আরসিপ্যারামস আরসিপ্যারাম ['ফিগার.ডিপি'] = curr_dpi


আপনার এখানে অনেক ভাল তথ্য রয়েছে তবে উত্তরটি নিজেই মাঝখানে সমাহিত। এটি পড়তে কিছুটা সহজ করার জন্য, আপনি উত্তরটি ঠিক কীটি ব্যাখ্যা করতে পারেন এবং তারপরে পটভূমির তথ্য সরবরাহ করতে পারেন?
skrrgwasme

আমি শুরুতে উত্তরটি দেখানোর জন্য আমার পোস্টটি সম্পাদনা করেছি, তারপরে বিশদটি পেতে। সাহায্য করার জন্য ধন্যবাদ.
মহাকাশচারী

1
দেখে মনে হচ্ছে এখানে গণনাগুলির মধ্যে কোনও ত্রুটি রয়েছে, যা এটি চিহ্নিত করা সহজ যে আপনি উল্লিখিত প্রস্থ এবং উচ্চতা (ইঞ্চি) থেকে একটি তির্যক আকার গণনা করুন। 13.3 ইঞ্চি তির্যক সহ আমার স্ক্রিনটি 15 ইঞ্চি হিসাবে প্রতিবেদন করা হয়েছে। দেখে মনে Tkinterহচ্ছে সঠিক পিক্সেল ব্যবহার করা হচ্ছে , তবে ডিপিআই স্কেলিং সম্পর্কে ভুল নয় এমনভাবে মিমি আকারের রিপোর্ট করা।
প্রাইমার

এটি উইন্ডোজ 10 এ কাজ করে না, সেখানে সেটসিস্টেমডিপিআইএওয়্যারওয়্যার () কোনও পার্থক্য বলে মনে হচ্ছে না। তবে, ctyype.windll.shcore.SetProcessDpiAwareness (2) কে কল করার পরিবর্তে কৌশলটি মনে হচ্ছে।
ক্লেমার শুট্ট

@ ক্লেমারশুট: ctypes.windll.shcore.SetProcessDpiAwareness(2)ত্রুটি ফেরায় OSError: [WinError 126] The specified module could not be found
অ্যাড্রিয়ান কেইস্টার

21

এবং সম্পূর্ণতার জন্য, ম্যাক ওএস এক্স

import AppKit
[(screen.frame().size.width, screen.frame().size.height)
    for screen in AppKit.NSScreen.screens()]

আপনাকে সমস্ত স্ক্রিন মাপযুক্ত টিপলগুলির একটি তালিকা দেবে (যদি একাধিক মনিটর উপস্থিত থাকে)


15

আপনি যদি Qtবিশেষভাবে টুলকিটটি ব্যবহার করে থাকেন তবে আপনি PySideনিম্নলিখিতগুলি করতে পারেন:

from PySide import QtGui
import sys

app = QtGui.QApplication(sys.argv)
screen_rect = app.desktop().screenGeometry()
width, height = screen_rect.width(), screen_rect.height()

13

লিনাক্স ব্যবহার করে, সহজ উপায় হ'ল বাশ কমান্ড চালানো

xrandr | grep '*'

এবং regexp ব্যবহার করে এর আউটপুট পার্স করুন।

এছাড়াও আপনি পাইগেমের মাধ্যমে এটি করতে পারেন: http://www.daniweb.com/forums/thread54881.html


পর্দার রেজোলিউশন পেতে আপনি কীভাবে পাইগেম ব্যবহার করবেন?
জেমি ট্যুইস

11

এখানে একটি দ্রুত ছোট পাইথন প্রোগ্রাম রয়েছে যা আপনার মাল্টি-মনিটর সেটআপ সম্পর্কিত তথ্য প্রদর্শন করবে:

import gtk

window = gtk.Window()

# the screen contains all monitors
screen = window.get_screen()
print "screen size: %d x %d" % (gtk.gdk.screen_width(),gtk.gdk.screen_height())

# collect data about each monitor
monitors = []
nmons = screen.get_n_monitors()
print "there are %d monitors" % nmons
for m in range(nmons):
  mg = screen.get_monitor_geometry(m)
  print "monitor %d: %d x %d" % (m,mg.width,mg.height)
  monitors.append(mg)

# current monitor
curmon = screen.get_monitor_at_window(screen.get_active_window())
x, y, width, height = monitors[curmon]
print "monitor %d: %d x %d (current)" % (curmon,width,height)  

এর ফলাফলের উদাহরণ এখানে দেওয়া হয়েছে:

screen size: 5120 x 1200
there are 3 monitors
monitor 0: 1600 x 1200
monitor 1: 1920 x 1200
monitor 2: 1600 x 1200
monitor 1: 1920 x 1200 (current)

না gtk.Window()পেতে gdk_default_root_window? আপনি কীভাবে নিশ্চিত হন যে .get_screenসমস্ত মনিটর রয়েছে?
ইয়াত্জি

আমি জিজ্ঞাসা করছি কারণ আমার কোডে আমি আপনার কোডটি প্রতিলিপি দেওয়ার চেষ্টা করছি, আমি এটি জাস্টিটাইপগুলিতে করছি, এবং এটি আমাকে 0 মনিটর বলতে চলেছে
ইয়াতজি

2
আমি সেই কোডটি লিখেছি তার কিছুক্ষণ পরে কিন্তু আমি যদি সঠিকভাবে স্মরণ করি তবে gtk.Window()নতুন উইন্ডোটি কী তৈরি করবে ( এখানে দেখুন )। get_screenমনিটরের তথ্য পেতে উইন্ডোটি ব্যবহারের একমাত্র উপায় । এটি উইন্ডোটি চালু থাকা স্ক্রিনটি ফেরত দেয় (বা এটি যদি কখনও প্রদর্শিত হয় তবে)। আমার ধারণা, এটি "স্ক্রিনে" সমস্ত "মনিটর" রয়েছে কিনা তা X কনফিগারেশনের উপর নির্ভর করে। এটি টুইনভিউয়ের সাথে আমার সিস্টেমে রয়েছে।
স্টারফাই

ধন্যবাদ @ স্টারফ্রাই! আমার কোনও ক্রস সমাধানের সন্ধান করা দরকার যা পর্দা নির্বিশেষে সমস্ত মনিটর এবং তাদের মাত্রা পায়। এরকম কিছু বিকাশের জন্য কি আপনার কোনও শৃঙ্খল আছে? :)
ইয়াতগ

পরবর্তী সরঞ্জামকিট সংস্করণগুলির বিকল্প:
সত্যগ্রহ

9

আমি নীচের মত আমার একটি প্রকল্পে একটি get_screen_resolution পদ্ধতি ব্যবহার করছি, যা মূলত একটি আমদানি শৃঙ্খলা। যে অংশগুলি প্রয়োজন হয় না সেগুলি সরিয়ে আপনি আপনার প্রয়োজন অনুসারে এটি সংশোধন করতে পারেন এবং আরও সম্ভাব্য বন্দরগুলি শৃঙ্খলে উপরের দিকে নিয়ে যেতে পারেন।

PYTHON_V3 = sys.version_info >= (3,0,0) and sys.version_info < (4,0,0):
#[...]
    def get_screen_resolution(self, measurement="px"):
        """
        Tries to detect the screen resolution from the system.
        @param measurement: The measurement to describe the screen resolution in. Can be either 'px', 'inch' or 'mm'. 
        @return: (screen_width,screen_height) where screen_width and screen_height are int types according to measurement.
        """
        mm_per_inch = 25.4
        px_per_inch =  72.0 #most common
        try: # Platforms supported by GTK3, Fx Linux/BSD
            from gi.repository import Gdk 
            screen = Gdk.Screen.get_default()
            if measurement=="px":
                width = screen.get_width()
                height = screen.get_height()
            elif measurement=="inch":
                width = screen.get_width_mm()/mm_per_inch
                height = screen.get_height_mm()/mm_per_inch
            elif measurement=="mm":
                width = screen.get_width_mm()
                height = screen.get_height_mm()
            else:
                raise NotImplementedError("Handling %s is not implemented." % measurement)
            return (width,height)
        except:
            try: #Probably the most OS independent way
                if PYTHON_V3: 
                    import tkinter 
                else:
                    import Tkinter as tkinter
                root = tkinter.Tk()
                if measurement=="px":
                    width = root.winfo_screenwidth()
                    height = root.winfo_screenheight()
                elif measurement=="inch":
                    width = root.winfo_screenmmwidth()/mm_per_inch
                    height = root.winfo_screenmmheight()/mm_per_inch
                elif measurement=="mm":
                    width = root.winfo_screenmmwidth()
                    height = root.winfo_screenmmheight()
                else:
                    raise NotImplementedError("Handling %s is not implemented." % measurement)
                return (width,height)
            except:
                try: #Windows only
                    from win32api import GetSystemMetrics 
                    width_px = GetSystemMetrics (0)
                    height_px = GetSystemMetrics (1)
                    if measurement=="px":
                        return (width_px,height_px)
                    elif measurement=="inch":
                        return (width_px/px_per_inch,height_px/px_per_inch)
                    elif measurement=="mm":
                        return (width_px/mm_per_inch,height_px/mm_per_inch)
                    else:
                        raise NotImplementedError("Handling %s is not implemented." % measurement)
                except:
                    try: # Windows only
                        import ctypes
                        user32 = ctypes.windll.user32
                        width_px = user32.GetSystemMetrics(0)
                        height_px = user32.GetSystemMetrics(1)
                        if measurement=="px":
                            return (width_px,height_px)
                        elif measurement=="inch":
                            return (width_px/px_per_inch,height_px/px_per_inch)
                        elif measurement=="mm":
                            return (width_px/mm_per_inch,height_px/mm_per_inch)
                        else:
                            raise NotImplementedError("Handling %s is not implemented." % measurement)
                    except:
                        try: # Mac OS X only
                            import AppKit 
                            for screen in AppKit.NSScreen.screens():
                                width_px = screen.frame().size.width
                                height_px = screen.frame().size.height
                                if measurement=="px":
                                    return (width_px,height_px)
                                elif measurement=="inch":
                                    return (width_px/px_per_inch,height_px/px_per_inch)
                                elif measurement=="mm":
                                    return (width_px/mm_per_inch,height_px/mm_per_inch)
                                else:
                                    raise NotImplementedError("Handling %s is not implemented." % measurement)
                        except: 
                            try: # Linux/Unix
                                import Xlib.display
                                resolution = Xlib.display.Display().screen().root.get_geometry()
                                width_px = resolution.width
                                height_px = resolution.height
                                if measurement=="px":
                                    return (width_px,height_px)
                                elif measurement=="inch":
                                    return (width_px/px_per_inch,height_px/px_per_inch)
                                elif measurement=="mm":
                                    return (width_px/mm_per_inch,height_px/mm_per_inch)
                                else:
                                    raise NotImplementedError("Handling %s is not implemented." % measurement)
                            except:
                                try: # Linux/Unix
                                    if not self.is_in_path("xrandr"):
                                        raise ImportError("Cannot read the output of xrandr, if any.")
                                    else:
                                        args = ["xrandr", "-q", "-d", ":0"]
                                        proc = subprocess.Popen(args,stdout=subprocess.PIPE)
                                        for line in iter(proc.stdout.readline,''):
                                            if isinstance(line, bytes):
                                                line = line.decode("utf-8")
                                            if "Screen" in line:
                                                width_px = int(line.split()[7])
                                                height_px = int(line.split()[9][:-1])
                                                if measurement=="px":
                                                    return (width_px,height_px)
                                                elif measurement=="inch":
                                                    return (width_px/px_per_inch,height_px/px_per_inch)
                                                elif measurement=="mm":
                                                    return (width_px/mm_per_inch,height_px/mm_per_inch)
                                                else:
                                                    raise NotImplementedError("Handling %s is not implemented." % measurement)
                                except:
                                    # Failover
                                    screensize = 1366, 768
                                    sys.stderr.write("WARNING: Failed to detect screen size. Falling back to %sx%s" % screensize)
                                    if measurement=="px":
                                        return screensize
                                    elif measurement=="inch":
                                        return (screensize[0]/px_per_inch,screensize[1]/px_per_inch)
                                    elif measurement=="mm":
                                        return (screensize[0]/mm_per_inch,screensize[1]/mm_per_inch)
                                    else:
                                        raise NotImplementedError("Handling %s is not implemented." % measurement)

1
এটি ভাগ করে নেওয়ার জন্য ধন্যবাদ, তবে যদি অন্যথায় মামলা পরিচালনা করতে কোনও ফাংশন ব্যবহার করে এটি অনেকটা ছোট করা যেত
উদয়রাজ দেশমুখ

8

পুরানো প্রশ্ন তবে এটি অনুপস্থিত। আমি অজগর থেকে নতুন তাই দয়া করে আমাকে বলুন এটি কোনও "খারাপ" সমাধান কিনা। এই সমাধানটি কেবল উইন্ডোজ এবং ম্যাকোএসের জন্য সমর্থিত এবং এটি কেবলমাত্র মূল পর্দার জন্য কাজ করে - তবে ওএসটি প্রশ্নের মধ্যে উল্লেখ করা হয়নি।

স্ক্রিনশট নিয়ে আকারটি পরিমাপ করুন। যেহেতু স্ক্রিনসাইজ পরিবর্তন করা উচিত নয় এটি কেবল একবার করা উচিত। আপনার যদি জিটিকে, ডাব্লুএক্স, ... ইনস্টল করার মতো গুই টুলকিট থাকে তবে আরও মার্জিত সমাধান রয়েছে।

দেখুন বালিশ

pip install Pillow

from PIL import ImageGrab

img = ImageGrab.grab()
print (img.size)

6

এক্স উইন্ডোজ সংস্করণ:

#!/usr/bin/python

import Xlib
import Xlib.display

resolution = Xlib.display.Display().screen().root.get_geometry()
print str(resolution.width) + "x" + str(resolution.height)

6

উপর সম্প্রসারিত @ user2366975 এর উত্তর, (পাইথন 2/3 মধ্যে কোড) Tkinter ব্যবহার করে একটি মাল্টি স্ক্রীন সেটআপ বর্তমান স্ক্রিন সাইজ পেতে:

try:
    # for Python 3
    import tkinter as tk
except ImportError:
    # for Python 2
    import Tkinter as tk


def get_curr_screen_geometry():
    """
    Workaround to get the size of the current screen in a multi-screen setup.

    Returns:
        geometry (str): The standard Tk geometry string.
            [width]x[height]+[left]+[top]
    """
    root = tk.Tk()
    root.update_idletasks()
    root.attributes('-fullscreen', True)
    root.state('iconic')
    geometry = root.winfo_geometry()
    root.destroy()
    return geometry

(ক্রস প্ল্যাটফর্মের কাজ করা উচিত, কেবল লিনাক্সে পরীক্ষা করা)



5

আপনি যদি পাইকিউটি 4 ইনস্টল করেছেন তবে নিম্নলিখিত কোডটি ব্যবহার করে দেখুন:

from PyQt4 import QtGui
import sys

MyApp = QtGui.QApplication(sys.argv)
V = MyApp.desktop().screenGeometry()
h = V.height()
w = V.width()
print("The screen resolution (width X height) is the following:")
print(str(w) + "X" + str(h))

পাইকিউটি 5 এর জন্য, নিম্নলিখিতগুলি কাজ করবে:

from PyQt5 import QtWidgets
import sys

MyApp = QtWidgets.QApplication(sys.argv)
V = MyApp.desktop().screenGeometry()
h = V.height()
w = V.width()
print("The screen resolution (width X height) is the following:")
print(str(w) + "X" + str(h))

5

একটি ক্রস প্ল্যাটফর্ম এবং এটি করার সহজ উপায় হ'ল টিকিন্টার ব্যবহার করে যা প্রায় সব পাইথন সংস্করণ সহ আসে যাতে আপনাকে কোনও কিছু ইনস্টল করতে না হয়:

import tkinter
root = tkinter.Tk()
root.withdraw()
WIDTH, HEIGHT = root.winfo_screenwidth(), root.winfo_screenheight()

3

লিনাক্স ব্যবহারের পরিবর্তে রেজিএক্সপেক্স প্রথম লাইনটি নিয়ে এবং বর্তমান রেজোলিউশন মানগুলি বের করে।

প্রদর্শনের বর্তমান রেজোলিউশন: 0

>>> screen = os.popen("xrandr -q -d :0").readlines()[0]
>>> print screen
Screen 0: minimum 320 x 200, current 1920 x 1080, maximum 1920 x 1920
>>> width = screen.split()[7]
>>> print width
1920
>>> height = screen.split()[9][:-1]
>>> print height
1080
>>> print "Current resolution is %s x %s" % (width,height)
Current resolution is 1920 x 1080

এটি xrandr 1.3.5 এ সম্পন্ন হয়েছিল, আমি জানি না যে অন্যান্য সংস্করণে আউটপুট আলাদা কিনা, তবে এটি নির্ধারণ করা সহজ করা উচিত।


দুর্ভাগ্যক্রমে মাল্টিমনিটার সেটআপগুলির সাথে খুব ভাল নয়। পাইথনের দোষ নয়, তবে এটি ব্যবহারের ফলে অপ্রত্যাশিত ফলাফল হতে পারে ...
কালো_প্প্পিডোগ

2

প্রতি পিক্সেল বিট পেতে:

import ctypes
user32 = ctypes.windll.user32
gdi32 = ctypes.windll.gdi32

screensize = (user32.GetSystemMetrics(0), user32.GetSystemMetrics(1))
print "screensize =%s"%(str(screensize))
dc = user32.GetDC(None);

screensize = (gdi32.GetDeviceCaps(dc,8), gdi32.GetDeviceCaps(dc,10), gdi32.GetDeviceCaps(dc,12))
print "screensize =%s"%(str(screensize))
screensize = (gdi32.GetDeviceCaps(dc,118), gdi32.GetDeviceCaps(dc,117), gdi32.GetDeviceCaps(dc,12))
print "screensize =%s"%(str(screensize))

gdi32 এ পরামিতি:

#/// Vertical height of entire desktop in pixels
#DESKTOPVERTRES = 117,
#/// Horizontal width of entire desktop in pixels
#DESKTOPHORZRES = 118,
#/// Horizontal width in pixels
#HORZRES = 8,
#/// Vertical height in pixels
#VERTRES = 10,
#/// Number of bits per pixel
#BITSPIXEL = 12,

2

পিয়াটোগুই চেষ্টা করে দেখুন:

import pyautogui
resolution = pyautogui.size()
print(resolution) 

এই কোডটি কেন কাজ করা উচিত সে সম্পর্কে আপনার সত্যিই কিছু ব্যাখ্যা যুক্ত করা উচিত - আপনি কোডটিতে নিজেই মন্তব্যগুলি যুক্ত করতে পারেন - এটির বর্তমান আকারে, এটি কোনও ব্যাখ্যা সরবরাহ করে না যা আপনার সম্প্রদায়ের বাকী অংশগুলিকে বুঝতে সহায়তা করতে পারে যে আপনি কী সমাধান করেছেন? /প্রশ্নটির উত্তর দাও. তবে এটি একটি খুব পুরানো প্রশ্ন - একটি স্বীকৃত উত্তর সহ ...
ইসমাইলমাকিতলা

2

আর একটি সংস্করণ ব্যবহার করে xrandr:

import re
from subprocess import run, PIPE

output = run(['xrandr'], stdout=PIPE).stdout.decode()
result = re.search(r'current (\d+) x (\d+)', output)
width, height = map(int, result.groups()) if result else (800, 600)

2

পিগেম ব্যবহার :

import pygame
pygame.init()
infos = pygame.display.Info()
screen_size = (infos.current_w, infos.current_h)

[1]

তবে, আপনি যদি নিজের উইন্ডোটিকে স্ক্রিনের আকারে সেট করার চেষ্টা করছেন, আপনি কেবল এটি করতে চাইবেন:

pygame.display.set_mode((0,0),pygame.FULLSCREEN)

আপনার প্রদর্শনটি পুরো স্ক্রিন মোডে সেট করতে। [2]


নিশ্চিত হয়েছে এটি উইন্ডোজে কাজ করে :) কোন দুর্দান্ত উইন্ডোজ নির্দিষ্ট পদ্ধতি!
লুকাশ কাজারভিনসকি

1

আপনি পাইমাউস ব্যবহার করতে পারেন । পর্দার আকার পেতে কেবল screen_size()বৈশিষ্ট্যটি ব্যবহার করুন :

from pymouse import PyMouse
m = PyMouse()
a = m.screen_size()

aএকটি টিউপল ফিরিয়ে দেবে (X, Y), যেখানে Xঅনুভূমিক অবস্থান এবং Yউল্লম্ব অবস্থান।

ডকুমেন্টেশন ফাংশন লিঙ্ক।


1

আপনি যদি উইন্ডোজ ওএসে কাজ করছেন তবে এটি পেতে আপনি ওএস মডিউলটি ব্যবহার করতে পারেন:

import os
cmd = 'wmic desktopmonitor get screenheight, screenwidth'
size_tuple = tuple(map(int,os.popen(cmd).read().split()[-2::]))

এটি একটি টিউপল (Y, X) ফিরিয়ে দেবে যেখানে Y অনুভূমিক আকার এবং এক্স অনুভূমিক আকার। এই কোডটি পাইথন 2 এবং পাইথন 3 এ কাজ করে


0

লিনাক্সে আমরা সাব-প্রসেস মডিউলটি ব্যবহার করতে পারি

import subprocess
cmd = ['xrandr']
cmd2 = ['grep', '*']
p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
p2 = subprocess.Popen(cmd2, stdin=p.stdout, stdout=subprocess.PIPE)
p.stdout.close()

resolution_string, junk = p2.communicate()
resolution = resolution_string.split()[0]
resolution = resolution.decode("utf-8") 
width = int(resolution.split("x")[0].strip())
heigth = int(resolution.split("x")[1].strip())

0

এটি রেটিনা স্ক্রিনের জন্য কিছুটা ঝামেলাযুক্ত, আমি নকল আকার পেতে টিন্টার ব্যবহার করি, আসল আকার পেতে পাইলট গ্র্যাব ব্যবহার করি:

import tkinter
root = tkinter.Tk()
resolution_width = root.winfo_screenwidth()
resolution_height = root.winfo_screenheight()
image = ImageGrab.grab()
real_width, real_height = image.width, image.height
ratio_width = real_width / resolution_width
ratio_height = real_height/ resolution_height

0

পাইজিটকের পরবর্তী সংস্করণগুলির জন্য:

import gi
gi.require_version("Gdk", "3.0")
from gi.repository import Gdk

display = Gdk.Display.get_default()
n_monitors = display.get_n_monitors()
print("there are %d monitors" % n_monitors)
for m in range(n_monitors):
  monitor = display.get_monitor(m)
  geometry = monitor.get_geometry()
  print("monitor %d: %d x %d" % (m, geometry.width, geometry.height))

0

লিনাক্সের জন্য, আপনি এটি ব্যবহার করতে পারেন:

import gi
gi.require_version("Gdk", "3.0")
from gi.repository import Gdk

s = Gdk.Screen.get_default()
screen_width = s.get_width()
screen_height = s.get_height()
print(screen_width)
print(screen_height)

0

pynputলাইব্রেরি ব্যবহার করে ইউটিলিটি স্ক্রিপ্ট । রেফার জন্য এখানে পোস্ট করা:

 
from pynput.mouse import Controller as MouseController

def get_screen_size():
    """Utility function to get screen resolution"""

    mouse = MouseController()

    width = height = 0

    def _reset_mouse_position():
        # Move the mouse to the top left of 
        # the screen
        mouse.position = (0, 0)

    # Reset mouse position
    _reset_mouse_position()

    count = 0
    while 1:
        count += 1
        mouse.move(count, 0)
        
        # Get the current position of the mouse
        left = mouse.position[0]

        # If the left doesn't change anymore, then
        # that's the screen resolution's width
        if width == left:
            # Add the last pixel
            width += 1

            # Reset count for use for height
            count = 0
            break

        # On each iteration, assign the left to 
        # the width
        width = left
    
    # Reset mouse position
    _reset_mouse_position()

    while 1:
        count += 1
        mouse.move(0, count)

        # Get the current position of the mouse
        right = mouse.position[1]

        # If the right doesn't change anymore, then
        # that's the screen resolution's height
        if height == right:
            # Add the last pixel
            height += 1
            break

        # On each iteration, assign the right to 
        # the height
        height = right

    return width, height

>>> get_screen_size()
(1920, 1080)
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.