Daha çox

Parametrlər Python skript alətində Açılır siyahı qurulur?

Parametrlər Python skript alətində Açılır siyahı qurulur?


Yazdığım bir python skriptindən yaratdığım siyahını götürəcək və girişdən biri kimi bitmiş alətdə açılan menyu kimi istifadə edəcək bir vasitə yaratmağa çalışıram (məsələn, əlavə edilmiş şəkilə baxın):

İstifadə etdiyim siyahı, Vermont əyalətindəki bütün şəhərləri özündə cəmləşdirən böyük bir siyahıdır və onu bir cədvəldən skriptdə hazırlayıram (aşağıdakı kodu bax). Bu anda problemimin yalnız bu siyahını götürüb istifadəçi üçün açılan siyahı yaratmaq üçün istifadə etmək üçün Xüsusiyyətlər alətini təyin etməkdə olduğuna şübhə edirəm. Parametrdə istifadə üçün siyahı yaradan kod bloku budur - alətin bu kod ucunda kimsə problem görmürmü?

import arcpy arcpy.env.workspace = "Z:  OPS  TechnicalServices  Culverts  GetCulverts  GetCulverts.gdb" towns = "Verilənlər Bazası Əlaqələri  GDB_GEN.sde  GDB_Gen.VTRANS_ADMIN.townindex" arcpy.MakeFeatureLay_ (towns, "towns_lyr") NameList = [] NameListArray = set () rows = arcpy.SearchCursor ("towns_lyr") satırdakı sıra üçün: value = row.getValue ("TOWNNAME") NameListArray-da deyilsə: NameList.append (dəyər) şəhər = NameList şəhər = arcpy.GetParameterAsText (0)

Varsayılan doğrulama kodu ilə birlikdə Tool xüsusiyyətlərinin bir görüntüsü də var - bu doğrulama kodunu dəyişdirməliyəm?

Bu doğrulama kodunu dəyişdirmək barədə məlumat axtardım, ancaq açılır siyahıları formatlaşdırmaq üçün istifadə haqqında məlumat tapa bilmədim.


Alət doğrulayıcı sinif kodunu bu şəkildə qurmağa çalışın:

idxal arcpy sinfi ToolValidator (obyekt): "" "Alətin parametr dəyərlərini təsdiqləmək və alət dialoqunun davranışını idarə etmək üçün sinif." "" def __init __ (self): "" "Arcpy və alət parametrlərinin siyahısını qurun." " "self.params = arcpy.GetParameterInfo () def initializeParameters (self):" "" Alətin parametrlərinin xüsusiyyətlərini dəqiqləşdirin. Bu metod alət açıldıqda adlanır. "" "def updateParameters (self)": "return". Daxili doğrulama aparılmadan əvvəl parametrlərin dəyərlərini və xüsusiyyətlərini dəyişdirin. Bu metod bir parametr dəyişdirildikdə çağırılır. "" "Towns =" ​​Database Connections  GDB_GEN.sde  GDB_Gen.VTRANS_ADMIN.townindex "rows = arcpy.SearchCursor (towns) self.params [0] .filter.list = sorted (list (set (r.getValue ('TOWNNAME') r in r inows))) del rows return def updateMessages (self): "" "Mesajları dəyişdirin hər bir alət parametri üçün daxili doğrulama ilə yaradılmışdır. Bu metod daxili doğrulamadan sonra adlanır. "" "qayıt

Javascript və JQuery Mobile UI-dən Python CGI Scriptlərini çalışdırmaq

Bir dəstə sürgü ilə JQuery UI var. Hər bir sürgü kodu belə görünür:

Buna bənzər bir şey edən bəzi müşayiət edən JQuery olmalıdır:

Aydındır ki, JS haqqında iki əsas şey dəyişməlidir. Birincisi, kaydırıcının sərbəst buraxıldığı zaman yerinə yetirilməlidir (səhifə yüklənmir), ikincisi isə kaydırıcının dəyərini Python skriptinə necə keçməsi lazımdır. Sadəcə test etmək üçün belə qurdum. Səhifəni yüklədiyim zaman, bu test python skripti düzgün şəkildə yerinə yetirilir və Raspberry Pi-yə qoşulmuş bəzi avadanlıqlar düzgün idarə olunur. Slidestop hadisəsini istifadə etməli olduğumu bilirəm, amma işə yaramadıram. Python skriptinə bəzi dəyişənləri göndərməyin ən yaxşı yolunun nə olduğuna da əmin deyiləm.

Python skriptim elə indi görünür: #! / Usr / bin / python

Beləliklə, hər hansı bir daxil olan məlumatları axtarmır, sadəcə çağırılır və bəzi Serial məlumatları yazır. AJAX zəngindən məlumat ala bilməli və aldığı məlumata əsasən Serial yazı əmrini tənzimləməlidir. Bu məlumatı işləyə biləcəyim dəyişənlərə çevirmək üçün köməyə ehtiyacım var. Hesab edirəm ki, bir növ "Bitirdim" mesajını JavaScript zəng funksiyasına geri göndərməliyəm.

İnsanlar ya yüksək səviyyəli məsələlər, ya da burada sadaladığım daha spesifik problemləri həll etmək yolları ilə bağlı ola biləcək hər hansı bir məlumatı gözləyirəm.


Qalıcı run / debug konfiqurasiyaları yaradın

PyCharm qalıcı bir run / debug konfiqurasiyası yaratmaq üçün aşağıdakı yolları təqdim edir:

Bir şablondan yaradın və ya mövcud bir konfiqurasiyanı kopyalayın.

Müvəqqəti bir konfiqurasiyanı qalıcı olaraq qeyd edin

Çalıştır / ayıklama konfiqurasiya dəyişdiricisində müvəqqəti bir konfiqurasiya seçin və sonra Konfiqurasiyanı Saxla vurun.

Müvəqqəti konfiqurasiyanı saxladıqdan sonra qalıcı olur və & ltproject kataloqu & gt / .idea / qovluğunda ayrı bir XML sənədində qeyd olunur. Məsələn, MyProject / .idea / Car.xml.

Alternativ olaraq, Çalıştır / ayıklama konfiqurasiyaları dialoqundan müvəqqəti bir konfiqurasiya seçin və alətlər panelini vurun.

PyCharm, müxtəlif dillər, alətlər və çərçivələr üçün run / debug konfiqurasiya şablonları təqdim edir. Mövcud şablonların siyahısı quraşdırılmış / paketləşdirilmiş plaginlərdən asılı olaraq dəyişir.

Bir şablondan bir run / debug konfiqurasiyası yaradın

Aşağıdakı yollardan birində Çalıştır / Ayıklama Konfiqurasiyasını açın:

Çalıştır | seçin Əsas menyudan Konfiqurasiyaları redaktə edin.

Naviqasiya çubuğu görünən olduqda (Görünüş | Görünüş | Naviqasiya Çubuğu), run / debug konfiqurasiya seçicisindən Konfiqurasiyaları Düzəliş et seçin.

Alt + Shift + F10 düymələrini basın, sonra 0 düyməsini basın və ya açılan pəncərədən konfiqurasiyanı seçin və F4 düyməsini basın.

Çalıştır / Hata Ayıklama Konfiqurasiyasında alətlər panelini vurun və ya Alt + Daxil edin. Siyahıda run / debug konfiqurasiya şablonları göstərilir.

İstədiyiniz şablonu seçin. Hansı şablonu seçəcəyinizdən əmin deyilsinizsə, müəyyən şablonlar haqqında daha çox məlumat üçün Konfiqurasiyanı işə sal / həll etmə dialoquna baxın.

Adı sahəsində run / debug konfiqurasiya adını göstərin. Bu ad mövcud run / debug konfiqurasiyaları siyahısında göstəriləcək.

Konfiqurasiyanın birdən çox nümunəsinin eyni vaxtda işləməsinə icazə vermək istəyirsinizsə, Paralel işə icazə ver seçin. Bu seçim deaktiv edildikdə, konfiqurasiyanı yenidən işə salmaq aktiv seansı sonlandıracaq.

Başlamadan əvvəl bölməsində tətbiqi başlamazdan əvvəl hər hansı bir xüsusi hərəkət etmək istədiyinizi müəyyənləşdirin, məsələn, run / debug konfiqurasiyasını başlamazdan əvvəl bəzi alətləri və ya skriptləri icra edin.

Xüsusi işə başlamazdan əvvəl fəaliyyətlər haqqında məlumat üçün, işə başlamazdan əvvəl baxın

Dəyişiklikləri tətbiq edin və informasiya qutusunu bağlayın.


Parametrlər Python skript alətində Açılır siyahı qurulur? - Coğrafi İnformasiya Sistemləri

Fərqli parametrlərin nə üçün olduğunu öyrənmək üçün siçan işarənizi redaktə qutusuna / onay qutusuna bir saniyə buraxın. və faydalı bir ipucu açılır.

Ümumi parametrlər

Şəkil 4.72. Ayarlar Dialoqu, Ümumi Səhifə


Bu informasiya qutusu, seçdiyiniz dili və Subversion üçün xüsusi parametrləri təyin etməyə imkan verir.

İstifadəçi interfeysinizin dilini seçir. Əlbəttə, əvvəlcədən İngilis dilindən başqa bir UI dili əldə etmək üçün əvvəlcə müvafiq dil paketini qurmalısınız.

TortoiseSVN, proqramın daha yeni bir versiyasının olub olmadığını görmək üçün mütəmadi olaraq yükləmə saytı ilə əlaqə quracaqdır. Varsa, öhdəlik dialoqunda bildiriş bağlantısını göstərəcəkdir. Dərhal cavab istəyirsinizsə indi yoxlayın. Yeni versiya yüklənməyəcək, sadəcə yeni versiyanın mövcud olduğunu bildirən bir informasiya qutusu alırsınız.

TortoiseSVN-də varsayılan olaraq quraşdırılmış üç xüsusi səs var.

Windows İdarəetmə Panelini istifadə edərək fərqli səslər seçə bilərsiniz (və ya bu səsləri tamamilə söndürə bilərsiniz). Konfiqurasiya - İdarəetmə Panelinin qısayoludur.

Windows Vista və sonrakı sistemlərdə bu, dialoqların Aero üslubundan istifadə edib etmədiyini idarə edir.

Windows 7-də sisteminizdə müxtəlif yerlərə səpələnmiş iş nüsxələrini qruplaşdıracaq bir Kitabxana yarada bilərsiniz.

Qlobal görməməzlik nümunələri, yönləndirilməmiş faylların, məsələn, görünməməsi üçün istifadə olunur öhdəlik dialoqunda. Nümunələrə uyğun olan fayllar da idxal ilə nəzərə alınmır. Adları və ya uzantıları yazaraq faylları və ya qovluqları görməyin. Nümunələr boşluqlarla ayrılır, məs. bin obj * .bak *.

?? * .jar *. [Tt] mp. Bu naxışlarda heç bir yol ayırıcı olmamalıdır. Qeyd edək ki, faylları və qovluqları bir-birindən ayırmağın bir yolu yoxdur. Nümunəyə uyğun sintaksis haqqında daha çox məlumat üçün “Siyahıları Yoxlamadakı Nümunə Uyğunluğu” adlı bölümü oxuyun.

Burada qeyd etdiyiniz laqeyd naxışları komanda xətti klienti daxil olmaqla, PC-də işləyən digər Subversion müştərilərini də təsir edəcəyini unutmayın.

Diqqət

Subversion konfiqurasiya sənədini qlobal olaraq görməməzlikdən gələn bir nümunə təyin etmək üçün istifadə edirsinizsə, burada etdiyiniz parametrləri ləğv edəcəkdir. Subversion konfiqurasiya sənədinə, aşağıda göstərildiyi kimi Düzəliş istifadə edərək əldə edilir.

Bu laqeyd model bütün layihələrinizi təsir edəcəkdir. Versiya deyil, buna görə digər istifadəçilərə təsir etməyəcəkdir. Buna qarşı versiya svn: ignore or svn: global-ignores xassəsini versiyaların nəzarətindən çıxarmaq üçün istifadə edə bilərsiniz. Daha çox məlumat üçün “Dosyaları və Kataloqları Yoxlama” adlı bölümü oxuyun.

Fayl tarixlərini "son işləmə vaxtı" olaraq təyin edin

Bu seçim TortoiseSVN-ə bir ödəmə və ya bir yeniləmə edərkən fayl tarixlərini son işləmə tarixinə təyin etməsini söyləyir. Əks təqdirdə TortoiseSVN cari tarixdən istifadə edəcəkdir. Proqram inkişaf etdirirsinizsə, ümumiyyətlə cari tarixi istifadə etmək yaxşıdır, çünki qurma sistemləri normal olaraq hansı sənədlərin tərtib edilməsinə qərar vermək üçün tarix möhürlərinə baxır. "Son öhdəlik vaxtı" nı istifadə edirsinizsə və köhnə bir sənəd düzəlişinə qayıdırsınızsa, layihəniz gözlədiyiniz kimi tərtib edilə bilməz.

Subversion konfiqurasiya faylı

Subversion konfiqurasiya sənədini birbaşa redaktə etmək üçün Düzəlişdən istifadə edin. Bəzi parametrlər birbaşa TortoiseSVN tərəfindən dəyişdirilə bilməz və bunun əvəzinə burada qurulması lazımdır. Subversion konfiqurasiya faylı haqqında daha ətraflı məlumat üçün İşləmə vaxtı konfiqurasiya sahəsi . Bölmə Avtomatik Əmlak Ayarı xüsusi maraq doğurur və burada konfiqurasiya edilmişdir. Qeyd edək ki, Subversion bir neçə yerdən konfiqurasiya məlumatlarını oxuya bilər və hansının üstünlük verdiyini bilməlisiniz. Baxın Konfiqurasiya və Windows Qeyd dəftəri daha çox məlumat əldə etmək.

Yenilənərkən svn: eksternallara yerli dəyişiklikləri tətbiq edin

Bu seçim TortoiseSVN-ə işləmə nüsxəsini yeniləyərkən svn: externals xassəsinə həmişə yerli dəyişikliklər tətbiq etməsini söyləyir.

Kontekst Menyu Ayarları

Şəkil 4.73. Ayarlar Dialoqu, Kontekst Menyu Səhifəsi


Bu səhifə əsas kontekst menyusunda TortoiseSVN kontekst menyu girişlərindən hansının görünəcəyini və TortoiseSVN alt menyusunda görünəcəyini təyin etməyə imkan verir. Varsayılan olaraq, əksər elementlər qeyd olunmur və alt menyuda görünür.

Get Lock üçün xüsusi bir iş var. Əlbəttə ki, yuxarıdakı siyahıdan istifadə edərək onu ən üst səviyyəyə yüksəldə bilərsiniz, lakin əksər faylların kilidlənməsinə ehtiyac olmadığı üçün sadəcə qarışıqlıq əlavə edir. Bununla birlikdə, svn: needs-lock xassəsi olan bir fayl hər dəfə düzəldildikdə bu əməliyyata ehtiyac duyur, bu halda ən üst səviyyədə olması çox faydalıdır. Buradakı xananın işarələnməsi svn: needs-lock xassəsi olan bir fayl seçildikdə, Get Lock həmişə ən üst səviyyədə görünəcəkdir.

Çox vaxt, Subversion tərəfindən versiya nəzarəti altında olan qovluqlardan başqa TortoiseSVN kontekst menyusuna ehtiyacınız olmayacaq. Versiyonlaşdırılmayan qovluqlar üçün yalnız ödəmə etmək istədiyiniz zaman kontekst menyusuna ehtiyacınız var. Yenidən yönləndirilməmiş yollar üçün menyuları gizlə seçimini yoxlayırsınızsa, TortoiseSVN daxilolmalarını dəyişməyən qovluqlar üçün kontekst menyusuna əlavə etməz. Ancaq girişlər versiyalı bir qovluqdakı bütün maddələr və yollar üçün əlavə olunur. Və basılı tutaraq dəyişdirilməmiş qovluqlar üçün girişləri geri ala bilərsiniz Shift kontekst menyusunu göstərərkən düyməni aşağı basın.

Kompüterinizdə TortoiseSVN-in kontekst menyusunun ümumiyyətlə görünməməsini istədiyiniz bəzi yollar varsa, bunları altındakı qutuda sadalaya bilərsiniz.

TortoiseSVN Dialoq Ayarları 1

Şəkil 4.74. Ayarlar Dialoqu, Dialoqlar 1 Səhifə


Bu informasiya qutusu, TortoiseSVN-in bəzi dialoqlarını istədiyiniz şəkildə konfiqurasiya etməyə imkan verir.

TortoiseSVN-i ilk dəfə seçdiyiniz zaman TortoiseSVN-in aldığı günlük mesajlarının sayını məhdudlaşdırır → Yavaş server əlaqələri üçün Faydalı göstər. Daha çox mesaj almaq üçün hər zaman Hamısını göstər və ya sonrakı 100 istifadə edə bilərsiniz.

Günlük mesajının özünü Revision Log dialoqunun orta bölməsində və Log mesajlarını tərtib edərkən Commit dialoqunda göstərmək üçün istifadə olunan şrift üzünü və ölçüsünü seçir.

Günlük mesajlarında qısa tarix / vaxt formatı

Standart uzun mesajlar ekranınızda çox yer tutursa, qısa formatı istifadə edin.

Əvvəlki düzəlişlə müqayisə etmək üçün jurnal siyahısına iki dəfə klikləyə bilərsiniz

Gündəlik informasiya qutusunun yuxarı hissəsindəki düzəlişləri müqayisə edərək özünüzü tez-tez taparsanız, bu əməliyyatı cüt kliklə təmin etmək üçün istifadə edə bilərsiniz. Varsayılan olaraq effektiv deyil, çünki diffin alınması çox vaxt uzun müddətdir və bir çox insan təsadüfi bir cüt vuruşdan sonra gözləməkdən çəkinməyə üstünlük verir, bu səbəbdən bu seçim varsayılan olaraq aktivləşdirilmir.

Əməliyyat səhvsiz başa çatdıqda TortoiseSVN bütün irəliləmə dialoqlarını avtomatik olaraq bağlaya bilər. Bu parametr, informasiya qutularını bağlamaq üçün şərtləri seçməyə imkan verir. Varsayılan (tövsiyə olunan) ayar bütün mesajları nəzərdən keçirməyə və nə baş verdiyini yoxlamağa imkan verən əl ilə bağlayın. Bununla birlikdə, bəzi mesaj növlərini görməməzlikdən gəlmək və kritik dəyişiklik olmadığı təqdirdə informasiya qutusunu avtomatik olaraq bağlamaq istədiyinizə qərar verə bilərsiniz.

Heç birləşdirilmirsə, əlavə və ya silinmirsə avtomatik bağlama, sadə yeniləmələr olduğu təqdirdə irəliləmə dialoqunun bağlanacağı deməkdir, ancaq anbardakı dəyişikliklər sizinlə birləşdirilmişsə və ya hər hansı bir fayl əlavə edilərsə və ya silinmişsə, dialoq açıq qalacaqdır. Əməliyyat zamanı hər hansı bir ziddiyyət və ya səhv varsa, açıq qalacaq.

Heç bir ziddiyyət olmadığı təqdirdə avtomatik bağlayın, meyarları daha da yumşaldır və birləşmə, əlavə və ya silmə olmasına baxmayaraq dialoqu bağlayacaqdır. Lakin hər hansı bir ziddiyyət və ya səhv varsa, informasiya açıq qalır.

Çatışmalar olsa da heç bir səhv olmadığı təqdirdə avtomatik olaraq qapanma avtomatik olaraq bağlanır. Dialoqu açıq saxlayan yeganə şərt, Subversion-un tapşırığı yerinə yetirə bilməməsi ilə nəticələnən bir səhv şərtidir. Məsələn, server əlçatmaz olduğundan bir yeniləmə uğursuz olur və ya işləyən nüsxə köhnəldiyindən öhdəlik alınmır.

Yerli əməliyyatlar üçün həmişə dialoqları bağlayın

Fayl əlavə etmək və ya dəyişiklikləri geri qaytarmaq kimi lokal əməliyyatların anbarla əlaqə qurub tez bir zamanda tamamlanmasına ehtiyac yoxdur, buna görə də irəliləmə dialoqu çox vaxt az maraqlanır. Bu əməliyyatlardan sonra səhvlər olmadığı təqdirdə irəliləmə dialoqunun avtomatik olaraq bağlanmasını istəyirsinizsə bu seçimi seçin.

Geri qayıtdıqda zibil qutusundan istifadə edin

Yerli dəyişiklikləri geri qaytardığınız zaman dəyişiklikləriniz silinir. TortoiseSVN, təmiz surəti geri gətirmədən əvvəl dəyişdirilmiş faylı zibil qutusuna göndərərək sizə əlavə bir təhlükəsizlik şəbəkəsi verir. Zibil qutusunu atlamağa üstünlük verirsinizsə, bu seçimin işarəsini götürün.

Varsayılan “Kimdən:” URL olaraq WC URL'sini istifadə edin

Birləşdirmə dialoqunda, varsayılan davranış birləşmə arasında xatırlanacaq Kimdən: URL-dir. Bununla birlikdə, bəzi insanlar hiyerarşilərindəki bir çox fərqli nöqtədən birləşmələri yerinə yetirməyi sevirlər və cari işləyən nüsxənin URL-i ilə başlamağı asanlaşdırırlar. Daha sonra başqa bir filialdakı paralel yola istinad etmək üçün düzəliş edilə bilər.

Kassalar üçün standart yolu təyin edə bilərsiniz. Bütün ödəmələrinizi bir yerdə saxlasanız, sürücünün və qovluğun əvvəlcədən doldurulması faydalıdır, belə ki, yalnız yeni qovluq adını sonuna əlavə etməlisiniz.

Kassalar üçün standart URL-ni də təyin edə bilərsiniz. Çox böyük bir layihənin alt layihələrini tez-tez ödəmisinizsə, URL-in əvvəlcədən doldurulması faydalı ola bilər, buna görə yalnız alt layihə adını sonuna əlavə etməlisiniz.


Bunu splat operatorundan istifadə edərək edə bilərsiniz:

Bu, funksiyanın hər bir siyahı elementini ayrı bir parametr olaraq qəbul etməsinə səbəb olur. Burada bir açıqlama var: http://docs.python.org/tutorial/controlflow.html#unpacking-argument-lists

Buna artıq mükəmməl cavab verildi, ancaq bu səhifəyə yeni gəldiyimdən və dərhal anlamadığım üçün sadəcə sadə, lakin tam bir nümunə əlavə edəcəyəm.


Basın

Click ilə Argparse ilə müqayisədə asanlıqla CLI qura bilərsiniz. Tıkla eyni problemi həll edir argparse həll edir, ancaq bunu etmək üçün bir az fərqli bir yanaşma istifadə edir. Anlayışından istifadə edir dekorativlər. Bunun dekorativlərdən istifadə edərək bükülə bilən funksiyalar olması üçün əmrlərə ehtiyac var.

Aşağıdakı kimi arqument və seçim əlavə edə bilərsiniz:

Yuxarıdakı skriptləri işlədirsinizsə, bunları almalısınız:

Hər şeyi bir yerə yığaraq Google Kitablarda kitab sorğusu etmək üçün sadə bir CLI qura bildim.

Daha çox məlumat üçün rəsmi sənədlərdən Klik haqqında ətraflı məlumat əldə edə bilərsiniz


Redaktə və naviqasiya¶

Redaktor pəncərələri¶

IDLE, parametrlərdən və IDLE-ni necə başlatdığınızdan asılı olaraq başladığı zaman redaktor pəncərələrini aça bilər. Bundan sonra Fayl menyusundan istifadə edin. Verilmiş bir fayl üçün yalnız bir açıq redaktor pəncərəsi ola bilər.

Başlıq çubuğunda faylın adı, tam yolu və pəncərəni işləyən Python və IDLE versiyası var. Vəziyyət çubuğu sətir nömrəsini (‘Ln’) və sütun nömrəsini (‘Sütun’) ehtiva edir. Xətt nömrələri 0 ilə 1 sütun nömrələri ilə başlayır.

IDLE, bilinən .py * uzantılı faylların Python kodunu ehtiva etdiyini və digər sənədlərin olmadığını fərz edir. Python kodunu Çalıştır menyusu ilə çalıştırın.

Açar bağlamalar¶

Bu hissədə ‘C’, Windows və Unix-də Control düyməsinə və macOS-da Command düyməsinə istinad edir.

Backspace sola silin, sağa silin

C-Backspace silmək sözü solda C-Del silmək sözü sağda

Ətrafında hərəkət etmək üçün ox düymələri və Səhifə Yuxarı / Səhifə Aşağı

C-LeftArrow və C-RightArrow sözlərlə hərəkət edir

Ev / Bitiş xəttin başlanğıcına / sonuna gedin

C-Home / C-End faylın başlanğıcına / sonuna gedir

Bəzi faydalı Emacs bağlamaları Tcl / Tk-dən miras qalır:

  • C-sətrin başlanğıcı

  • Xəttin sonu

  • C-k kill line (lakin onu panoya qoymur)

  • Əlavə nöqtəsinin ətrafındakı C-l mərkəzi pəncərə

  • C-b silinmədən bir simvol geri çəkin (ümumiyyətlə bunun üçün kursor düyməsini də istifadə edə bilərsiniz)

  • C-f silinmədən bir simvol irəli gedin (ümumiyyətlə bunun üçün kursor düyməsini də istifadə edə bilərsiniz)

  • C-p bir sətir yuxarı qalxın (ümumiyyətlə bunun üçün kursor düyməsini də istifadə edə bilərsiniz)

  • C-d növbəti işarəni silin

Standart klavişlər (kopyalamaq üçün C-c və yapışdırmaq üçün C-v kimi) işləyə bilər. Keybindings Configure IDLE informasiya qutusunda seçilir.

Avtomatik girinti¶

Blok açılış ifadəsindən sonra növbəti sətir 4 boşluqla girilir (Python Shell pəncərəsində bir nişanla). Müəyyən açar sözlərdən (break, return və s.) Sonra növbəti sətir ayrılır. Girintili aparıcı vəziyyətdə, Backspace orada olduqda 4 boşluğu silir. Tab boşluqlar əlavə edir (Python Shell pəncərəsində bir nişan), nömrə girinti genişliyindən asılıdır. Hal-hazırda sekmeler Tcl / Tk məhdudiyyətləri səbəbindən dörd boşluqla məhdudlaşır.

Format menyusundakı girinti / ayrılma bölgəsi əmrlərinə də baxın.

Tamamlama¶

Tamamlamalar tələb edildikdə və mövcud olduqda modul adları, siniflərin və ya funksiyaların xüsusiyyətləri və ya fayl adları üçün verilir. Hər bir sorğu metodu mövcud adları olan bir tamamlama qutusunu göstərir. (İstisna üçün aşağıdakı nişan tamamlamalarına baxın.) Hər hansı bir qutu üçün tamamlanan adı və qutuda vurgulanan elementi yuxarı, aşağı, PageUp, PageDown, Home və End düymələrinə basaraq və simvolları silməklə dəyişdirin. qutunun içərisinə vurun. Qutunu Escape, Enter və qutunun xaricindəki Tab düymələri və ya kliklərlə ikiqat bağlayın. Qutunun içərisindəki cüt vuruş seçir və bağlayır.

Bir qutu açmağın bir yolu bir əsas simvol yazmaq və əvvəlcədən təyin edilmiş bir fasilə gözləməkdir. Bu, 2 saniyəyə ayarlanaraq parametrlər dialoqunda fərdiləşdirilir. (Avtomatik popupların qarşısını almaq üçün gecikməni 100000000 kimi çox sayda milisaniyə olaraq təyin edin.) İdxal olunan modul adları və ya sinif və ya funksiya atributları üçün ‘.’ Yazın. Kök qovluğundakı fayl adları üçün açılış təklifindən dərhal sonra os.sep və ya os.altsep yazın. (Windows-da əvvəlcə bir sürücü təyin etmək olar.) Bir kataloq adı və bir ayırıcı yazaraq alt qovluqlara keçin.

Gözləmək əvəzinə və ya bir qutu bağlandıqdan sonra Düzəliş menyusunda Tamamlamaları Göstərməklə dərhal bir tamamlama qutusunu açın. Varsayılan isti düymə C boşluğudur. Qutunu açmazdan əvvəl istədiyiniz ad üçün bir prefiks yazarsa, ilk uyğunluq və ya yaxın miss görsənir. Nəticə, qutu göstərildikdən sonra bir prefiks daxil etdiyi kimidir. Sitat bir kök qovluğu əvəzinə cari qovluqdakı fayl adlarını tamamladıqdan sonra Tamamlamaları göstərin.

Bir prefiksdən sonra Tab-a vurmaq, ümumiyyətlə, Tamamlamaları Göstərməklə eyni təsirə malikdir. (Heç bir prefikslə girilmir.) Ancaq prefiksə yalnız bir uyğunluq varsa, o eşleme bir qutu açılmadan dərhal redaktor mətninə əlavə olunur.

Sətrin xaricində və əvvəlki ‘.’ Olmadan ‘Tamamlamaları Göstər’ çağırmaq və ya bir prefiksdən sonra Sekme vurmaq açar sözlər, yerləşmiş adlar və mövcud modul səviyyəli adlarla bir qutu açır.

Bir redaktorda kodu düzəldərkən (Shell-in əksinə olaraq) kodunuzu işə salmaqla və sonra Shell-i yenidən başlamadan mövcud modul səviyyəsində adları artırın. Bu, xüsusən də bir faylın yuxarı hissəsinə idxal əlavə etdikdən sonra faydalıdır. Bu da mümkün atribut tamamlamalarını artırır.

Tamamlama qutuları, ‘_’ ilə başlayan və ya modullar üçün ‘__all__’ a daxil olmayan adları içəridən istisna edir. Gizli adlara qutu açılmadan əvvəl və ya sonra ‘.’ Yazaraq ‘.’ Yazaraq əldə edilə bilər.

Zənglər¶

Bir yazı tipi (an adından sonra) avtomatik yazıldıqda göstərilir əlçatandır funksiya. Funksiya adı ifadəsinə nöqtələr və abunəçilər daxil ola bilər. Çağırış zəngi vurulana qədər, kursor mübahisə zonasından kənarlaşdırılana və ya) yazılana qədər qalır. Kursor bir tərifin mübahisə hissəsində olduqda, menyudan Düzəliş et və “Zəng Tövsülünü Göstər” seçin və ya zəng işarəsini göstərmək üçün qısayolunu daxil edin.

Çağırış işarəsi funksiyanın imzasından və sonuncunun ilk boş sətirinə və ya beşinci boş olmayan sətrinə qədər sənədlərdən ibarətdir. (Bəzi daxili funksiyalarda əlçatan bir imza yoxdur.) İmzadakı bir ‘/’ və ya ‘*’ əvvəlki və sonrakı arqumentlərin yalnız mövqe və ya ad (açar söz) ilə ötürüldüyünü göstərir. Ətraflı məlumat dəyişdirilə bilər.

Shell-də, əldə edilə bilən funksiyalar, İdle özü tərəfindən idxal edilənlər də daxil olmaqla istifadəçi prosesinə hansı modulların gətirildiyinə və son yenidən başladan bəri hansı təriflərin işlədildiyinə bağlıdır.

Məsələn, Shell-i yenidən başladın və itertools.count (. İdle öz istifadə üçün istifadəçi prosesinə itertools idxal etdiyinə görə bir zəng işarəsi görünür. (Bu dəyişə bilər.) Turtle.write daxil edin (və heç bir şey görünmür. Boşluq özü tısbağanı idxal etmir.) Menyu girişi və qısayol da heç bir şey etmir, idxal tısbağasını daxil edin, bundan sonra turtle.write (zəng mövzusunu göstərəcəkdir.

Bir redaktorda, faylı işlədənə qədər idxal hesabatlarının heç bir təsiri yoxdur. İdxal hesabatları yazdıqdan, funksiya tərifləri əlavə etdikdən və ya mövcud bir faylı açdıqdan sonra bir fayl çalıştırmaq istəyə bilər.

Kod Bağlamı¶

Python kodunu ehtiva edən bir redaktor pəncərəsində, pəncərənin yuxarı hissəsində bir bölməni göstərmək və ya gizlətmək üçün kod kontekstini dəyişdirmək olar. Göstərildikdə, bu bölmə blok kodu üçün açılma xəttlərini dondurur, məsələn sinif, def və ya açar sözlər ilə başlayanlar, əks halda görünüş xaricinə keçir. Panelin ölçüsü, bütün mövcud kontekst səviyyələrini göstərmək üçün ehtiyac olduqda genişləndiriləcək və müqavilə bağlayacaqdır, IDLE-i Yapılandır dialoqunda müəyyən edilmiş maksimum sətir sayına qədər (bu, əvvəlcədən 15-ə bərabərdir). Cari kontekst sətirləri yoxdursa və xüsusiyyət işə salındıqda, tək bir boş sətir görünəcəkdir. Kontekst bölməsində bir sətirə vurmaq həmin sətri redaktorun yuxarı hissəsinə daşıyacaq.

Kontekst bölməsi üçün mətn və arxa rənglər IDLE-i konfiqurasiya dialoqundakı Xüsusiyyətlər nişanı altında konfiqurasiya edilə bilər.

Python Shell pəncərəsi¶

IDLE’s Shell ilə tam ifadələri daxil edir, düzəldir və geri çağırır. Əksər konsollar və terminallar hər dəfə yalnız bir fiziki xəttlə işləyir.

Kod Shell-ə ​​yapışdırıldıqda, Return-a vurana qədər tərtib olunmur və bəlkə də icra olunmur. Əvvəlcə yapışdırılmış kodu düzəldə bilər. Biri daha çox bir ifadəni Shell-ə ​​yapışdırarsa, birdən çox ifadələr olduğu kimi tərtib edildikdə nəticə SyntaxError olacaqdır.

Əvvəlki alt hissələrdə təsvir olunan tənzimləmə xüsusiyyətləri kod interaktiv olaraq daxil olduqda işləyir. IDLE’s Shell pəncərəsi də aşağıdakı düymələrə cavab verir.

C-c icra olunan əmri kəsir

& Gt & gt & gt komutuna yazıldıqda C-d fayl sonunu pəncərəni bağlayır.

Alt- / (Expand word) yazmağı azaltmaq üçün də faydalıdır

Alt-p yazdığınızla uyğun əvvəlki əmri alır. MacOS-da C-p istifadə edin.

Alt-n bundan sonra alır. MacOS-da C-n istifadə edin.

Əvvəlki hər hansı bir əmrdə bu əmri alırkən qayıdın

Mətn rəngləri¶

Varsayılanlar ağ mətndə qara rəngə çevrilir, lakin mətni xüsusi mənalarla rəngləndirir. Kabuk üçün bunlar qabıq çıxışı, qabıq xətası, istifadəçi çıxışı və istifadəçi səhvidir. Python kodu üçün, qabıq istəməsində və ya redaktorda bunlar açar sözlər, daxili sinif və funksiya adları, sinif və defdən sonrakı adlar, simlər və şərhlərdir. Hər hansı bir mətn pəncərəsi üçün bunlar imlec (mövcud olduqda), tapılmış mətn (mümkün olduqda) və seçilmiş mətndir.

Mətn rənglənməsi arxa planda edilir, buna görə rəngsiz mətn bəzən görünür. Rəng sxemini dəyişdirmək üçün IDLE konfiqurasiya dialoqunu Vurğulayan nişanından istifadə edin. Hata ayıklayıcı kəsmə nöqtəsi xətlərinin redaktorda işarələnməsi və pop-up və informasiya qutularındakı mətn istifadəçi tərəfindən konfiqurasiya olunmur.


Sürətli bir GUI hazırlamaq

PySimpleGUI nə vaxt faydalıdır? Dərhal, bir GUI lazım olduqda. GUI yaratmaq və sınamaq beş dəqiqədən az vaxt aparır. GUI hazırlamağın ən sürətli yolu PySimpleGUI Yemək Kitabından kopyalamaqdır. Bu addımları izləyin:

  • Yaratmaq istədiyinizə bənzər bir GUI tapın
  • Yemək kitabından kodu kopyalayın
  • IDE-yə yapışdırın və işə salın

Kitabdakı ilk reseptə baxaq.

Bu kifayət qədər ölçülü bir formadır.


Python Fərdiləşdirmə ilə ArcGIS’in Standart Yamac Alətinin Ardınca gedin

Rəqəmsal hündürlük modelləri bir çox coğrafi məlumat sistemi məlumat dəsti və tədqiqatlarının vacib bir hissəsidir. Bundan əlavə, bir landşaft boyunca topoqrafik atributların paylanması və xarakteristikası, geomorfoloji, hidroloji və bioloji tətbiqetmələr üçün vacib məlumat ola bilər (Moore et al. 1991). DEM-lərdən hesablanan parametrlər eyni dərəcədə vacibdir. Yamac bəlkə də ən çox yayılmışdır. Bununla birlikdə, ArcGIS (10.4.1) standart yamac aləti yalnız 3x3 məhəlləsini araşdırır və mərkəz hüceyrəni daxil etmir. [Yamac hesablamalarının daha mükəmməl bir müzakirəsi üçün baxın Hickey et al (1994) və Dunn and Hickey (1998).] Bu yamacın daha geniş miqyaslı müayinəsi üçün məqbul olsa da, ArcGIS ərazi işləmə alətlərinin Python kodu ilə uyğunlaşdırılması kömək edə bilər tədqiqatçının ehtiyaclarına uyğun istiqamətlər üzrə yamacı hesablayırıq. İstiqamətli bir yamac alətinin nəzəri tətbiqinə bir axın təbii yolu boyunca yamacın tapılması, bir səthdən axan suyun istiqamətinin təxmin edilməsi, müxtəlif ərazilərdə meşə yanğının hərəkət istiqamətinin araşdırılması və ya bir yürüyüş yolu boyunca nisbi yamac istiqamətinin ölçülməsi daxil ola bilər.

Bu məqalə bir axın istiqaməti ızgarası boyunca yamacın hesablanması üçün bir üsula müraciət edir. Hidroloji nümunədə, bu, aşağı enmə meylinin açısının hesablanmasına bərabər olacaqdır. İstifadəçi başqa bir istiqamət üzrə yamacla maraqlanırsa - məsələn, hərəkətli bir atəş, axın və ya cığır istiqamətində - araşdırılan xüsusiyyət boyunca hərəkət istiqamətini əks etdirən bir FD şəbəkəsi yaradılmalıdır.

Kodlaşdırma

Bu layihənin məqsədi bir DEM və FD hesablamasının nəticəsi əsasında yamac açısını hesablamaqdır. FD-yə giriş ümumiyyətlə bir DEM-dir və çıxış sətirdə ən dik yamac meylinin istiqaməti ilə ətrafdakı səkkiz hüceyrədən birini müəyyənləşdirir. Çıxış Şəkil 1-də göstərildiyi kimi kodlaşdırılır.

Şəkil 1: FLOWDIRECTION çıxışı

Alternativ olaraq, FD hər hansı digər raster qatından hesablana bilər. Məsələn, bir istifadəçi yanğın hərəkətini əks etdirən bir raster verilənlər bazası yarada bilər və sonra FD bu məlumatlardan əlavə bir DEM hesablana bilər.

Nəzərdə tutulan tətbiqetmədən asılı olmayaraq, burada təqdim olunan kod DEM və axın istiqaməti çıxış rastrlarını götürür və mərkəz nüvə hüceyrəsindən sonrakı FD raster boyunca tək bitişik hüceyrəyə yamac (qalxma / qaçış) hesablayaraq istiqamətli yamacı hesablayır.

Maraqlı olanlar üçün iş axını aşağıda AML kodunda göstərilmişdir (Hickey et al, 1994). FLOW FD ızgarasıdır (bax Şəkil 1), DEM doldurulmuş DEM, SIZE piksel ölçüsü, DIAG 1,4 * piksel ölçüsüdür (və ya iki bitişik piksel arasındakı diaqonal məsafə) və ANGLE hesablanmış yamacdır:

Python istifadə edərək bu yanaşmanı həyata keçirmək üçün rasteri NumPy massivinə çevirdik. NumPy, riyaziyyat və rəqəmlərlə işləmək üçün xüsusi bir Python moduludur. Bir NumPy massivi bir şəbəkədə satır və sütunları təmsil edən dəyərləri saxlaya bilər. Proqramçı daha sonra hücrənin sətirinə və sütununa istinad edərək rasterdəki istənilən hüceyrənin dəyərini əldə edə bilər. Bu, yalnız yamacın fərdiləşdirilməsi üçün deyil, həm də hər hansı bir qonşuluq statistikası üçün bitişik olan şəbəkə hüceyrələrinin dəyərlərindən istifadə edərək xüsusi hesablamalar aparmağa imkan verir.

DEM və axın istiqaməti rasterlərini bu kimi NumPy massivlərinə çevirin:

Kodun sonrasında, bitişik hüceyrələr üçün rook və diaqonal hüceyrələr üçün diaq terminindən istifadə edərək, bəzi axın istiqamətləri Python cədvəllərini qurduq.

Daha sonra, FD boyunca piksellər arasındakı yüksəklik fərqini tapdıqdan sonra axın istiqamətinə görə doğru yamac hesablamasını tətbiq edə bilərik. Aşağıdakı Python kodu yamacın faiz olaraq göstərildiyini, yuxarıdakı AML-nin istifadə dərəcələri olduğunu unutmayın. Riyaziyyatı dəyişdirərək istədiyiniz yanaşmanı tətbiq edə bilərsiniz:

Bunun düzgün işləməsi üçün bütün girişlər bir fayl məlumat bazasında olmalıdır. Unutmayın ki, hər hansı bir raster qonşuluq əməliyyatı üçün xarici sətirlər / sütunlar hər zaman səhvdir və istifadəçi lazım olduqdan daha böyük bir iş sahəsi üzərində işləməlidir və bütün analizlər bitdikdən sonra yalnız son sahəyə keçməlidir.

Məqalənin sonunda tam kodu bir keçid verilir.

Nümunə Layihə Yolu

Tədqiqat sahəsi Ellensburg, Wash xaricində məşhur bir yürüyüş parkurunun yaxınlığındadır (şəkil 2). Nisbətən düz topoqrafiya, bitki örtüyünün olmaması, (kol çöl ekosistemi) və müəlliflərə tanışlığı səbəbindən seçilmişdir. Məqsədlərimiz əvvəlcə aşağı enmə meylinin açısını (su axını istiqamətində yamac) hesablamaq və sonra süni bir atəşin yayıla biləcəyi istiqamət boyunca yamac hesablamaq idi. Tədqiqat sahəsi miqyasını əhatə edən 10 metrlik bir DEM, USGS onlayn məlumat kitabxanası olan Earth Explorer-dən yüklənmiş, .dem formatında saxlanılmış və ArcGIS fayl geodatabase-ə gətirilmişdir. Bütün məlumatlar NAD27 - UTM zonası 10N istifadə edərək məkan baxımından istinad edilmişdir. Bütün məlumatlar maraq sahəsindən bir qədər böyük bir sahəyə kəsildi. Sonra lavabonları və kiçik məlumat problemlərini aradan qaldırmaq üçün DEM-də Doldurma alətini işə saldıq. [Müəllifin qeydləri: Həmişə Fill çalıştırın, yükləyə biləcəyiniz hər hansı bir DEM-də yayılmış kimi görünən kiçik problemləri təmizləyir.]

Şəkil 2. Tədqiqat sahəsinin cənuba baxan oblik görünüşü. Yanma sahəsi qırmızı rənglə vurğulanır, yanğın sağdan (qərbdən) başlayır.

Tədqiqat sahəsi məlumat klipi və DEM doldurma əməliyyatından sonra, FD raster yaratmaq üçün FlowDirection istifadə edildi. Nəhayət, təqdim olunan istiqamətli yamac skripti məlumatlar üzərində işlənmişdir. Çıxış maksimum enmə meyl bucağıdır (şəkil 3).

Şəkil 3. Yuxarı sol, istinad üçün yanğın aoi olan iş sahəsinin DEM. Yuxarı sağ, təpə kölgəsi. Sol alt, axın istiqamətində çıxış. Aşağı aşağı, maksimum eniş meyl açısı.

To examine the slope along which a simulated fire would travel, we digitized a series of fire lines, assuming these represented the location of the fire line at different times. We also created a polygon file representing the total area burned. It’s important that these vector files be in the same datum/coordinate system as the DEM.

We then assigned “elevations” to the fire. The numbers themselves don’t really matter as long as the highest values are where the fire started and the lowest, where it finished. We then ran the Topo to Raster tool on the fire lines. When doing this, make sure to use the clipped DEM as the input to the “output cell size” and “output extent” (Figure 4). This will ensure that the DEM and your new fire raster overlay exactly. Run Fill on this fire raster, then FlowDirection. This FD layer will represent the direction the ‘fire’ is moving (Figure 5).

Figure 4: DEM created from the fire lines. Fire lines (with labels, 100 was where the fire started it finished at 30) and fire AOI for reference. This is the same AOI as is shown in Figure 3.

Figure 5: FLOWDIRECTION output based on the fire dem in Figure 4.

We then ran our script using the DEM and the fire FD layers as inputs. The output is the slope of the land according to the direction of the moving fire (Figure 6).

Figure 6: Slope angle along the direction of fire movement. Note, negative values represent areas where the fire is moving uphill green is downhill.

Debugging List

Are you getting odd results? Very high or low values? Or even large areas with a 0 slope? Here are some suggestions for things to check:

  • Is everything in the same datum/coordinate system? Never use geographic (lat/long) coordinates when working with raster data.
  • Did you remember to run Fill on your DEM?
  • Ensure that all the raster layers overlay perfectly and have the same number of rows, columns, and cell size.
  • Ensure that the vertical units are the same as the horizontal units (meters or feet).
  • All your input files should be within a file geodatabase.

Nəticələr

If you need to go beyond the out-of-the-box functionality of the ArcGIS raster analysis tools, you can use the ArcPy site package to write custom tools. A particularly powerful way to work with DEMs is to use NumPy arrays to iterate through each cell and apply your own formulas. We’ve demonstrated this by implementing a calculation to find directional slope. The walkthrough project describes how such a tool can be applied toward either modeling the path of a wildfire or of water flowing downhill. The code is available at http://www.onlinegeographer.com/slope/slope.html.

Dunn, M. and R. Hickey, 1998, The Effect of Slope Algorithms on Slope Estimates within a GIS. Cartography. V. 27, no. 1, pp. 9–15.

Hickey, R, A. Smith, and P. Jankowski, 1994, Slope length Calculations from a DEM with in ARC/INFO GRID. Computers, Environment and Urban Systems, v. 18, no. 5, pp. 365 - 380.

Moore, I. D., Grayson, R. B., & Ladson, A. R. (1991). Digital terrain modelling: a review of hydrological, geomorphological, and biological applications. Hydrological processes, 5(1), 3-30.


Layihənin təsviri

Geolocation is a simple and clever application which uses google maps api.

  1. Geocode Module allows you to easily and quickly get information about given location.
  • country,
  • country short form,
  • city,
  • route/street,
  • street number,
  • postal code,
  • formatted address,
  • administrative areas,
  • lat,
  • lng.
  1. Distance Module allows you to get information about travel distance and time for a matrix of origins and destinations.
  • origin address,
  • destination address,
  • duration,
  • distance: kilometers, meters, miles.

20 CONTROLLING THE KEYBOARD AND MOUSE WITH GUI AUTOMATION

Knowing various Python modules for editing spreadsheets, downloading files, and launching programs is useful, but sometimes there just aren’t any modules for the applications you need to work with. The ultimate tools for automating tasks on your computer are pro­grams you write that directly control the keyboard and mouse. These programs can control other applications by sending them virtual keystrokes and mouse clicks, just as if you were sitting at your computer and interacting with the applications yourself.

This technique is known as graphical user interface automation, və ya GUI automation for short. With GUI automation, your programs can do anything that a human user sitting at the computer can do, except spill coffee on the keyboard. Think of GUI automation as programming a robotic arm. You can program the robotic arm to type at your keyboard and move your mouse for you. This technique is particularly useful for tasks that involve a lot of mindless clicking or filling out of forms.

Some companies sell innovative (and pricey) “automation solutions,” usually marketed as robotic process automation (RPA). These products are effectively no different than the Python scripts you can make yourself with the pyautogui module, which has functions for simulating mouse movements, button clicks, and mouse wheel scrolls. This chapter covers only a subset of PyAutoGUI’s features you can find the full documentation at https://pyautogui.readthedocs.io/.

Installing the pyautogui Module

The pyautogui module can send virtual keypresses and mouse clicks to Windows, macOS, and Linux. Windows and macOS users can simply use pip to install PyAutoGUI. However, Linux users will first have to install some software that PyAutoGUI depends on. Open a terminal window and enter the following commands:

  • sudo apt-get install scrot
  • sudo apt-get install python3-tk
  • sudo apt-get install python3-dev

To install PyAutoGUI, run pip install --user pyautogui . Don’t use sudo with pip you may install modules to the Python installation that the operating system uses, causing conflicts with any scripts that rely on its original configuration. However, you should use the sudo command when installing applications with apt-get .

Appendix A has complete information on installing third-party modules. To test whether PyAutoGUI has been installed correctly, run import pyautogui from the interactive shell and check for any error messages.

Don’t save your program as pyautogui.py. When you run import pyautogui , Python will import your program instead of the PyAutoGUI and you’ll get error messages like AttributeError: module 'pyautogui' has no attribute 'click' .

Setting Up Accessibility Apps on macOS

As a security measure, macOS doesn’t normally let programs control the mouse or keyboard. To make PyAutoGUI work on macOS, you must set the program running your Python script to be an accessibility application. Without this step, your PyAutoGUI function calls will have no effect.

Whether you run your Python programs from Mu, IDLE, or the Terminal, have that application open. Then open the System Preferences and go to the Accessibility tab. The currently open applications will appear under the “Allow the apps below to control your computer” label. Check Mu, IDLE, Terminal, or whichever app you use to run your Python scripts. You’ll be prompted to enter your password to confirm these changes.

Staying on Track

Before you jump into a GUI automation, you should know how to escape problems that may arise. Python can move your mouse and type keystrokes at an incredible speed. In fact, it might be too fast for other programs to keep up with. Also, if something goes wrong but your program keeps moving the mouse around, it will be hard to tell what exactly the program is doing or how to recover from the problem. Like the enchanted brooms from Disney’s The Sorcerer’s Apprentice, which kept filling&mdashand then overfilling&mdashMickey’s tub with water, your program could get out of control even though it’s following your instructions perfectly. Stopping the program can be difficult if the mouse is moving around on its own, preventing you from clicking the Mu Editor window to close it. Fortunately, there are several ways to prevent or recover from GUI automation problems.

Pauses and Fail-Safes

If your program has a bug and you’re unable to use the keyboard and mouse to shut it down, you can use PyAutoGUI’s fail-safe feature. Quickly slide the mouse to one of the four corners of the screen. Every PyAutoGUI function call has a 10th-of-a-second delay after performing its action to give you enough time to move the mouse to a corner. If PyAutoGUI then finds that the mouse cursor is in a corner, it raises the pyautogui.FailSafeException exception. Non-PyAutoGUI instructions will not have this 10th-of-a-second delay.

If you find yourself in a situation where you need to stop your PyAutoGUI program, just slam the mouse toward a corner to stop it.

Shutting Down Everything by Logging Out

Perhaps the simplest way to stop an out-of-control GUI automation program is to log out, which will shut down all running programs. On Windows and Linux, the logout hotkey is CTRL-ALT-DEL. On macOS, it is -SHIFT-OPTION-Q. By logging out, you’ll lose any unsaved work, but at least you won’t have to wait for a full reboot of the computer.

Controlling Mouse Movement

In this section, you’ll learn how to move the mouse and track its position on the screen using PyAutoGUI, but first you need to understand how PyAutoGUI works with coordinates.

The mouse functions of PyAutoGUI use x- and y-coordinates. Figure 20-1 shows the coordinate system for the computer screen it’s similar to the coordinate system used for images, discussed in Chapter 19. The mənşə, harada xy are both zero, is at the upper-left corner of the screen. The x-coordinates increase going to the right, and the y-coordinates increase going down. All coordinates are positive integers there are no negative coordinates.

Figure 20-1: The coordinates of a computer screen with 1920×1080 resolution

Sənin resolution is how many pixels wide and tall your screen is. If your screen’s resolution is set to 1920×1080, then the coordinate for the upper-left corner will be (0, 0), and the coordinate for the bottom-right corner will be (1919, 1079).

The pyautogui.size() function returns a two-integer tuple of the screen’s width and height in pixels. Enter the following into the interactive shell:

>>> import pyautogui
>>> wh = pyautogui.size() # Obtain the screen resolution.
>>> wh
Size(width=1920, height=1080)
>>> wh[0]
1920
>>> wh.width
1920

The pyautogui.size() function returns (1920, 1080) on a computer with a 1920×1080 resolution depending on your screen’s resolution, your return value may be different. The Size object returned by size() is a named tuple. Named tuples have numeric indexes, like regular tuples, and attribute names, like objects: both wh[0] and wh.width evaluate to the width of the screen. (Named tuples are beyond the scope of this book. Just remember that you can use them the same way you use tuples.)

Moving the Mouse

Now that you understand screen coordinates, let’s move the mouse. The pyautogui.moveTo() function will instantly move the mouse cursor to a specified position on the screen. Integer values for the x- and y-coordinates make up the function’s first and second arguments, respectively. An optional duration integer or float keyword argument specifies the number of seconds it should take to move the mouse to the destination. If you leave it out, the default is 0 for instantaneous movement. (All of the duration keyword arguments in PyAutoGUI functions are optional.) Enter the following into the interactive shell:

>>> import pyautogui
>>> for i in range(10): # Move mouse in a square.
. pyautogui.moveTo(100, 100, duration=0.25)
. pyautogui.moveTo(200, 100, duration=0.25)
. pyautogui.moveTo(200, 200, duration=0.25)
. pyautogui.moveTo(100, 200, duration=0.25)

This example moves the mouse cursor clockwise in a square pattern among the four coordinates provided a total of 10 times. Each movement takes a quarter of a second, as specified by the duration=0.25 keyword argument. If you hadn’t passed a third argument to any of the pyautogui.moveTo() calls, the mouse cursor would have instantly teleported from point to point.

The pyautogui.move() function moves the mouse cursor relative to its current position. The following example moves the mouse in the same square pattern, except it begins the square from wherever the mouse happens to be on the screen when the code starts running:

>>> import pyautogui
>>> for i in range(10):
. pyautogui.move(100, 0, duration=0.25) # right
. pyautogui.move(0, 100, duration=0.25) # down
. pyautogui.move(-100, 0, duration=0.25) # left
. pyautogui.move(0, -100, duration=0.25) # up

The pyautogui.move() function also takes three arguments: how many pixels to move horizontally to the right, how many pixels to move vertically downward, and (optionally) how long it should take to complete the movement. A negative integer for the first or second argument will cause the mouse to move left or upward, respectively.

Getting the Mouse Position

You can determine the mouse’s current position by calling the pyautogui.position() function, which will return a Point named tuple of the mouse cursor’s xy positions at the time of the function call. Enter the following into the interactive shell, moving the mouse around after each call:

>>> pyautogui.position() # Get current mouse position.
Point(x=311, y=622)
>>> pyautogui.position() # Get current mouse position again.
Point(x=377, y=481)
>>> p = pyautogui.position() # And again.
>>> p
Point(x=1536, y=637)
>>> p[0] # The x-coordinate is at index 0.
1536
>>> p.x # The x-coordinate is also in the x attribute.
1536

Of course, your return values will vary depending on where your mouse cursor is.

Controlling Mouse Interaction

Now that you know how to move the mouse and figure out where it is on the screen, you’re ready to start clicking, dragging, and scrolling.

Clicking the Mouse

To send a virtual mouse click to your computer, call the pyautogui.click() method. By default, this click uses the left mouse button and takes place wherever the mouse cursor is currently located. You can pass x- and y-coordinates of the click as optional first and second arguments if you want it to take place somewhere other than the mouse’s current position.

If you want to specify which mouse button to use, include the button keyword argument, with a value of 'left' , 'middle' , or 'right' . For example, pyautogui.click(100, 150, button='left') will click the left mouse button at the coordinates (100, 150), while pyautogui.click(200, 250, button='right') will perform a right-click at (200, 250).

Enter the following into the interactive shell:

>>> import pyautogui
>>> pyautogui.click(10, 5) # Move mouse to (10, 5) and click.

You should see the mouse pointer move to near the top-left corner of your screen and click once. A full “click” is defined as pushing a mouse button down and then releasing it back up without moving the cursor. You can also perform a click by calling pyautogui.mouseDown() , which only pushes the mouse button down, and pyautogui.mouseUp() , which only releases the button. These functions have the same arguments as click() , and in fact, the click() function is just a convenient wrapper around these two function calls.

As a further convenience, the pyautogui.doubleClick() function will perform two clicks with the left mouse button, while the pyautogui.rightClick() and pyautogui.middleClick() functions will perform a click with the right and middle mouse buttons, respectively.

Dragging the Mouse

Dragging means moving the mouse while holding down one of the mouse buttons. For example, you can move files between folders by dragging the folder icons, or you can move appointments around in a calendar app.

PyAutoGUI provides the pyautogui.dragTo() and pyautogui.drag() functions to drag the mouse cursor to a new location or a location relative to its current one. The arguments for dragTo() and drag() are the same as moveTo() and move() : the x-coordinate/horizontal movement, the y-coordinate/vertical movement, and an optional duration of time. (macOS does not drag correctly when the mouse moves too quickly, so passing a duration keyword argument is recommended.)

To try these functions, open a graphics-drawing application such as MS Paint on Windows, Paintbrush on macOS, or GNU Paint on Linux. (If you don’t have a drawing application, you can use the online one at https://sumopaint.com/.) I will use PyAutoGUI to draw in these applications.

With the mouse cursor over the drawing application’s canvas and the Pencil or Brush tool selected, enter the following into a new file editor window and save it as spiralDraw.py:

import pyautogui, time
? time.sleep(5)
? pyautogui.click() # Click to make the window active.
distance = 300
change = 20
while distance > 0:
? pyautogui.drag(distance, 0, duration=0.2) # Move right.
? distance = distance &ndash change
? pyautogui.drag(0, distance, duration=0.2) # Move down.
? pyautogui.drag(-distance, 0, duration=0.2) # Move left.
distance = distance &ndash change
pyautogui.drag(0, -distance, duration=0.2) # Move up.

When you run this program, there will be a five-second delay ? for you to move the mouse cursor over the drawing program’s window with the Pencil or Brush tool selected. Sonra spiralDraw.py will take control of the mouse and click to make the drawing program’s window active ? . The active window is the window that currently accepts keyboard input, and the actions you take&mdashlike typing or, in this case, dragging the mouse&mdashwill affect that window. The active window is also known as the fokuslanmışdır və ya foreground window. Once the drawing program is active, spiralDraw.py draws a square spiral pattern like the one on the left of Figure 20-2. While you can also create a square spiral image by using the Pillow module discussed in Chapter 19, creating the image by controlling the mouse to draw it in MS Paint lets you make use of this program’s various brush styles, like in Figure 20-2 on the right, as well as other advanced features, like gradients or the fill bucket. You can preselect the brush settings yourself (or have your Python code select these settings) and then run the spiral-drawing program.

Figure 20-2: The results from the pyautogui.drag() example, drawn with MS Paint’s different brushes

The distance variable starts at 200 , so on the first iteration of the while loop, the first drag() call drags the cursor 200 pixels to the right, taking 0.2 seconds ? . distance is then decreased to 195 ? , and the second drag() call drags the cursor 195 pixels down ? . The third drag() call drags the cursor &ndash195 horizontally (195 to the left) ? , distance is decreased to 190, and the last drag() call drags the cursor 190 pixels up. On each iteration, the mouse is dragged right, down, left, and up, and distance is slightly smaller than it was in the previous iteration. By looping over this code, you can move the mouse cursor to draw a square spiral.

You could draw this spiral by hand (or rather, by mouse), but you’d have to work slowly to be so precise. PyAutoGUI can do it in a few seconds!

At the time of this writing, PyAutoGUI can’t send mouse clicks or keystrokes to certain programs, such as antivirus software (to prevent viruses from disabling the software) or video games on Windows (which use a different method of receiving mouse and keyboard input). You can check the online documentation at https://pyautogui.readthedocs.io/ to see if these features have been added.

Scrolling the Mouse

The final PyAutoGUI mouse function is scroll() , which you pass an integer argument for how many units you want to scroll the mouse up or down. The size of a unit varies for each operating system and application, so you’ll have to experiment to see exactly how far it scrolls in your particular situation. The scrolling takes place at the mouse cursor’s current position. Passing a positive integer scrolls up, and passing a negative integer scrolls down. Run the following in Mu Editor’s interactive shell while the mouse cursor is over the Mu Editor window:

You’ll see Mu scroll upward if the mouse cursor is over a text field that can be scrolled up.

Planning Your Mouse Movements

One of the difficulties of writing a program that will automate clicking the screen is finding the x- and y-coordinates of the things you’d like to click. The pyautogui.mouseInfo() function can help you with this.

The pyautogui.mouseInfo() function is meant to be called from the interactive shell, rather than as part of your program. It launches a small application named MouseInfo that’s included with PyAutoGUI. The window for the application looks like Figure 20-3.

Figure 20-3: The MouseInfo application’s window

Enter the following into the interactive shell:

>>> import pyautogui
>>> pyautogui.mouseInfo()

This makes the MouseInfo window appear. This window gives you information about the mouse’s cursor current position, as well the color of the pixel underneath the mouse cursor, as a three-integer RGB tuple and as a hex value. The color itself appears in the color box in the window.

To help you record this coordinate or pixel information, you can click one of the eight Copy or Log buttons. The Copy All, Copy XY, Copy RGB, and Copy RGB Hex buttons will copy their respective information to the clipboard. The Log All, Log XY, Log RGB, and Log RGB Hex buttons will write their respective information to the large text field in the window. You can save the text in this log text field by clicking the Save Log button.

By default, the 3 Sec. Button Delay checkbox is checked, causing a three-second delay between clicking a Copy or Log button and the copying or logging taking place. This gives you a short amount of time in which to click the button and then move the mouse into your desired position. It may be easier to uncheck this box, move the mouse into position, and press the F1 to F8 keys to copy or log the mouse position. You can look at the Copy and Log menus at the top of the MouseInfo window to find out which key maps to which buttons.

For example, uncheck the 3 Sec. Button Delay, then move the mouse around the screen while pressing the F6 button, and notice how the x- and y-coordinates of the mouse are recorded in the large text field in the middle of the window. You can later use these coordinates in your PyAutoGUI scripts.

For more information on MouseInfo, review the complete documentation at https://mouseinfo.readthedocs.io/.

Working with the Screen

Your GUI automation programs don’t have to click and type blindly. PyAutoGUI has screenshot features that can create an image file based on the current contents of the screen. These functions can also return a Pillow Image object of the current screen’s appearance. If you’ve been skipping around in this book, you’ll want to read Chapter 17 and install the pillow module before continuing with this section.

On Linux computers, the scrot program needs to be installed to use the screenshot functions in PyAutoGUI. In a Terminal window, run sudo apt-get install scrot to install this program. If you’re on Windows or macOS, skip this step and continue with the section.

Getting a Screenshot

To take screenshots in Python, call the pyautogui.screenshot() function. Enter the following into the interactive shell:

>>> import pyautogui
>>> im = pyautogui.screenshot()

The im variable will contain the Image object of the screenshot. You can now call methods on the Image object in the im variable, just like any other Image object. Chapter 19 has more information about Image objects.

Analyzing the Screenshot

Say that one of the steps in your GUI automation program is to click a gray button. Before calling the click() method, you could take a screenshot and look at the pixel where the script is about to click. If it’s not the same gray as the gray button, then your program knows something is wrong. Maybe the window moved unexpectedly, or maybe a pop-up dialog has blocked the button. At this point, instead of continuing&mdashand possibly wreaking havoc by clicking the wrong thing&mdashyour program can “see” that it isn’t clicking the right thing and stop itself.

You can obtain the RGB color value of a particular pixel on the screen with the pixel() function. Enter the following into the interactive shell:

>>> import pyautogui
>>> pyautogui.pixel((0, 0))
(176, 176, 175)
>>> pyautogui.pixel((50, 200))
(130, 135, 144)

Pass pixel() a tuple of coordinates, like (0, 0) or (50, 200), and it’ll tell you the color of the pixel at those coordinates in your image. The return value from pixel() is an RGB tuple of three integers for the amount of red, green, and blue in the pixel. (There is no fourth value for alpha, because screenshot images are fully opaque.)

PyAutoGUI’s pixelMatchesColor() function will return True if the pixel at the given x- and y-coordinates on the screen matches the given color. The first and second arguments are integers for the x- and y-coordinates, and the third argument is a tuple of three integers for the RGB color the screen pixel must match. Enter the following into the interactive shell:

>>> import pyautogui
? >>> pyautogui.pixel((50, 200))
(130, 135, 144)
? >>> pyautogui.pixelMatchesColor(50, 200, (130, 135, 144))
Doğru
? >>> pyautogui.pixelMatchesColor(50, 200, (255, 135, 144))
Yalan

After using pixel() to get an RGB tuple for the color of a pixel at specific coordinates ? , pass the same coordinates and RGB tuple to pixelMatchesColor() ? , which should return True . Then change a value in the RGB tuple and call pixelMatchesColor() again for the same coordinates ? . This should return false . This method can be useful to call whenever your GUI automation programs are about to call click() . Note that the color at the given coordinates must exactly matç. If it is even slightly different&mdashfor example, (255, 255, 254) instead of (255, 255, 255) &mdashthen pixelMatchesColor() will return False .

Image Recognition

But what if you do not know beforehand where PyAutoGUI should click? You can use image recognition instead. Give PyAutoGUI an image of what you want to click, and let it figure out the coordinates.

For example, if you have previously taken a screenshot to capture the image of a Submit button in submit.png, the locateOnScreen() function will return the coordinates where that image is found. To see how locateOnScreen() works, try taking a screenshot of a small area on your screen then save the image and enter the following into the interactive shell, replacing 'submit.png' with the filename of your screenshot:

>>> import pyautogui
>>> b = pyautogui.locateOnScreen('submit.png')
>>> b
Box(left=643, top=745, width=70, height=29)
>>> b[0]
643
>>> b.left
643

The Box object is a named tuple that locateOnScreen() returns and has the x-coordinate of the left edge, the y-coordinate of the top edge, the width, and the height for the first place on the screen the image was found. If you’re trying this on your computer with your own screenshot, your return value will be different from the one shown here.

If the image cannot be found on the screen, locateOnScreen() returns None . Note that the image on the screen must match the provided image perfectly in order to be recognized. If the image is even a pixel off, locateOnScreen() raises an ImageNotFoundException exception. If you’ve changed your screen resolution, images from previous screenshots might not match the images on your current screen. You can change the scaling in the display settings of your operating system, as shown in Figure 20-4.

Figure 20-4: The scale display settings in Windows 10 (left) and macOS (right)

If the image can be found in several places on the screen, locateAllOnScreen() will return a Generator object. Generators are beyond the scope of this book, but you can pass them to list() to return a list of four-integer tuples. There will be one four-integer tuple for each location where the image is found on the screen. Continue the interactive shell example by entering the following (and replacing 'submit.png' with your own image filename):

>>> list(pyautogui.locateAllOnScreen('submit.png'))
[(643, 745, 70, 29), (1007, 801, 70, 29)]

Each of the four-integer tuples represents an area on the screen. In the example above, the image appears in two locations. If your image is only found in one area, then using list() and locateAllOnScreen() returns a list containing just one tuple.

Once you have the four-integer tuple for the specific image you want to select, you can click the center of this area by passing the tuple to click() . Enter the following into the interactive shell:

>>> pyautogui.click((643, 745, 70, 29))

As a shortcut, you can also pass the image filename directly to the click() function:

The moveTo() and dragTo() functions also accept image filename arguments. Remember locateOnScreen() raises an exception if it can’t find the image on the screen, so you should call it from inside a try statement:

try:
location = pyautogui.locateOnScreen('submit.png')
except:
print('Image could not be found.')

Without the try and except statements, the uncaught exception would crash your program. Since you can’t be sure that your program will always find the image, it’s a good idea to use the try and except statements when calling locateOnScreen() .

Getting Window Information

Image recognition is a fragile way to find things on the screen if a single pixel is a different color, then pyautogui.locateOnScreen() won’t find the image. If you need to find where a particular window is on the screen, it’s faster and more reliable to use PyAutoGUI’s window features.

As of version 0.9.46, PyAutoGUI’s window features work only on Windows, not on macOS or Linux. These features come from PyAutoGUI’s inclusion of the PyGetWindow module.

Obtaining the Active Window

The active window on your screen is the window currently in the foreground and accepting keyboard input. If you’re currently writing code in the Mu Editor, the Mu Editor’s window is the active window. Of all the windows on your screen, only one will be active at a time.

In the interactive shell, call the pyautogui.getActiveWindow() function to get a Window object (technically a Win32Window object when run on Windows).

Once you have that Window object, you can retrieve any of the object’s attributes, which describe its size, position, and title:

left, right, top, bottom A single integer for the x- or y-coordinate of the window’s side

topleft, topright, bottomleft, bottomright A named tuple of two integers for the (x, y) coordinates of the window’s corner

midleft, midright, midleft, midright A named tuple of two integers for the (x, y) coordinate of the middle of the window’s side

width, height A single integer for one of the window’s dimensions, in pixels

size A named tuple of two integers for the (width, height) of the window

area A single integer representing the area of the window, in pixels

center A named tuple of two integers for the (x, y) coordinate of the window’s center

centerx, centery A single integer for the x- or y-coordinate of the window’s center

box A named tuple of four integers for the (left, top, width, height) measurements of the window

title A string of the text in the title bar at the top of the window

To get the window’s position, size, and title information from the window object, for example, enter the following into the interactive shell:

>>> import pyautogui
>>> fw = pyautogui.getActiveWindow()
>>> fw
Win32Window(hWnd=2034368)
>>> str(fw)
'<Win32Window left="500", top="300",,, title="Mu 1.0.1 &ndash test1.py">'
>>> fw.title
'Mu 1.0.1 &ndash test1.py'
>>> fw.size
(2070, 1208)
>>> fw.left, fw.top, fw.right, fw.bottom
(500, 300, 2070, 1208)
>>> fw.topleft
(256, 144)
>>> fw.area
2500560
>>> pyautogui.click(fw.left + 10, fw.top + 20)

You can now use these attributes to calculate precise coordinates within a window. If you know that a button you want to click is always 10 pixels to the right of and 20 pixels down from the window’s top-left corner, and the window’s top-left corner is at screen coordinates (300, 500), then calling pyautogui.click(310, 520) (or pyautogui.click(fw.left + 10, fw.top + 20) if fw contains the Window object for the window) will click the button. This way, you won’t have to rely on the slower, less reliable locateOnScreen() function to find the button for you.

Other Ways of Obtaining Windows

While getActiveWindow() is useful for obtaining the window that is active at the time of the function call, you’ll need to use some other function to obtain Window objects for the other windows on the screen.

The following four functions return a list of Window objects. If they’re unable to find any windows, they return an empty list:

pyautogui.getAllWindows() Returns a list of Window objects for every visible window on the screen.

pyautogui.getWindowsAt(x, y) Returns a list of Window objects for every visible window that includes the point (x, y).

pyautogui.getWindowsWithTitle(title) Returns a list of Window objects for every visible window that includes the string title in its title bar.

pyautogui.getActiveWindow() Returns the Window object for the window that is currently receiving keyboard focus.

PyAutoGUI also has a pyautogui.getAllTitles() function, which returns a list of strings of every visible window.

Manipulating Windows

Windows attributes can do more than just tell you the size and position of the window. You can also set their values in order to resize or move the window. For example, enter the following into the interactive shell:

>>> import pyautogui
>>> fw = pyautogui.getActiveWindow()
? >>> fw.width # Gets the current width of the window.
1669
? >>> fw.topleft # Gets the current position of the window.
(174, 153)
? >>> fw.width = 1000 # Resizes the width.
? >>> fw.topleft = (800, 400) # Moves the window.

First, we use the Window object’s attributes to find out information about the window’s size ? and position ? . After calling these functions in Mu Editor, the window should move ? and become narrower ? , as in Figure 20-5.

Figure 20-5: The Mu Editor window before (top) and after (bottom) using the Window object attributes to move and resize it

You can also find out and change the window’s minimized, maximized, and activated states. Try entering the following into the interactive shell:

>>> import pyautogui
>>> fw = pyautogui.getActiveWindow()
? >>> fw.isMaximized # Returns True if window is maximized.
Yalan
? >>> fw.isMinimized # Returns True if window is minimized.
Yalan
? >>> fw.isActive # Returns True if window is the active window.
Doğru
? >>> fw.maximize() # Maximizes the window.
>>> fw.isMaximized
Doğru
? >>> fw.restore() # Undoes a minimize/maximize action.
? >>> fw.minimize() # Minimizes the window.
>>> import time
>>> # Wait 5 seconds while you activate a different window:
? >>> time.sleep(5) fw.activate()
? >>> fw.close() # This will close the window you're typing in.

The isMaximized ? , isMinimized ? , and isActive ? attributes contain Boolean values that indicate whether the window is currently in that state. The maximize() ? , minimize() ? , activate() ? , and restore() ? methods change the window’s state. After you maximize or minimize the window with maximize() or minimize() , the restore() method will restore the window to its former size and position.

The close() method ? will close a window. Be careful with this method, as it may bypass any message dialogs asking you to save your work before quitting the application.

The complete documentation for PyAutoGUI’s window-controlling feature can be found at https://pyautogui.readthedocs.io/. You can also use these features separately from PyAutoGUI with the PyGetWindow module, documented at https://pygetwindow.readthedocs.io/.

Controlling the Keyboard

PyAutoGUI also has functions for sending virtual keypresses to your computer, which enables you to fill out forms or enter text into applications.

Sending a String from the Keyboard

The pyautogui.write() function sends virtual keypresses to the computer. What these keypresses do depends on what window is active and what text field has focus. You may want to first send a mouse click to the text field you want in order to ensure that it has focus.

As a simple example, let’s use Python to automatically type the words Hello, world! into a file editor window. First, open a new file editor window and position it in the upper-left corner of your screen so that PyAutoGUI will click in the right place to bring it into focus. Next, enter the following into the interactive shell:

>>> pyautogui.click(100, 200) pyautogui.write('Hello, world!')

Notice how placing two commands on the same line, separated by a semicolon, keeps the interactive shell from prompting you for input between running the two instructions. This prevents you from accidentally bringing a new window into focus between the click() and write() calls, which would mess up the example.

Python will first send a virtual mouse click to the coordinates (100, 200), which should click the file editor window and put it in focus. The write() call will send the text Hello, world! to the window, making it look like Figure 20-6. You now have code that can type for you!

Figure 20-6: Using PyAutogGUI to click the file editor window and type Hello, world! into it

By default, the write() function will type the full string instantly. However, you can pass an optional second argument to add a short pause between each character. This second argument is an integer or float value of the number of seconds to pause. For example, pyautogui.write('Hello, world!', 0.25) will wait a quarter-second after typing H, another quarter-second after e, və sair. This gradual typewriter effect may be useful for slower applications that can’t process keystrokes fast enough to keep up with PyAutoGUI.

For characters such as A və ya !, PyAutoGUI will automatically simulate holding down the SHIFT key as well.

Key Names

Not all keys are easy to represent with single text characters. For example, how do you represent SHIFT or the left arrow key as a single character? In PyAutoGUI, these keyboard keys are represented by short string values instead: 'esc' for the ESC key or 'enter' for the ENTER açar.

Instead of a single string argument, a list of these keyboard key strings can be passed to write() . For example, the following call presses the A key, then the B key, then the left arrow key twice, and finally the X and Y keys:

Because pressing the left arrow key moves the keyboard cursor, this will output XYab. Table 20-1 lists the PyAutoGUI keyboard key strings that you can pass to write() to simulate pressing any combination of keys.

You can also examine the pyautogui.KEYBOARD_KEYS list to see all possible keyboard key strings that PyAutoGUI will accept. The 'shift' string refers to the left SHIFT key and is equivalent to 'shiftleft' . The same applies for 'ctrl' , 'alt' , and 'win' strings they all refer to the left-side key.

Table 20-1: PyKeyboard Attributes

Keyboard key string

'a' , 'b' , 'c' , 'A' , 'B' , 'C' , '1' , '2' , '3' , '!' , '@' , '#' , and so on


Videoya baxın: 12 Beginner Python Projects - Coding Course