GUI -automatisering ved bruk av Pyautogui, Python

Pyautogui er en automatiseringsmodul levert av Python for å kontrollere tastatur- og musefunksjoner via programmet. Denne modulen har nesten alle funksjonene som kan utføres med tastatur og mus. Vi kan bruke disse funksjonene til å automatisere mus- og tastaturhandlinger.

Installere Pyautogui

Før du bruker funksjoner av Pyautogui Modul, vi må installere den. For å installere denne modulen, kjør følgende kommando i terminalen.

$ pip installer pyautogui

ELLER

$ pip3 installer pyautogui

Nå Pyautogui er klar til bruk.

Få oppløsning av displayet

Før du automatiserer musehandlinger, er det en god praksis å kjenne oppløsningen på skjermen. Vi kan få oppløsningen av skjermen ved hjelp av .størrelse() Metode av

Pyautogui. Se nedenfor Få oppløsning av skjermen i form av 'bredde x høyde':

Python 2.7.15+ (standard, 7. oktober 2019, 17:39:04)
[GCC 7.4.0] på linux2

Skriv inn "hjelp", "copyright", "studiepoeng" eller "lisens" for mer informasjon.

>>> Importer Pyautogui
>>> bredde, høyde = pyautogui.størrelse()
>>> utskrift (bredde)
1366
>>> utskrift (høyde)
768

Det betyr at vi har 1366 piksler i horisontal visningsretning og 768 piksler i vertikal visningsretning.

Flytte musen på skjermen

Så vi kjenner oppløsningen på displayet vårt. Nå kan vi flytte musen hvor som helst på displayet innenfor grensene for oppløsning av displayet. Vi kan flytte musen ved hjelp av .flytte til() Metode for Pyautogui. Eksempel nedenfor om å flytte mus til (100.100) posisjon på 2 sekunder

>>> Importer Pyautogui
>>> Pyautogui.Moveto (100.100, varighet = 2)

Vi har gitt tre argumenter til .Moveto () -metode. De to første argumentene er obligatoriske og viser bestemmelsesposisjonen, men tredje argument er ikke obligatorisk. Hvis vi ikke passerer det tredje argumentet, flytter musen til destinasjonen innen kort tid.

Klikk, rulle og dra mus

Pyautogui gir noen metoder for å kontrollere mushandlinger. Vi kan klikke, bla og dra mus ved hjelp av forskjellige metoder.

Å klikke på handling av mus kan utføres ved hjelp av .klikk () Metode. Før du klikker, flytt musen til den nødvendige pikselen og bruk deretter .Klikk () Metode for å klikke. Følgende er eksemplet for å utføre musens klikking. Eksempel nedenfor vil flytte mus til (300.201) piksel og klikke på musen.

>>> Importer Pyautogui
>>> Pyautogui.Moveto (300,201)
>>> Pyautogui.Klikk ()

Du kan dobbeltklikke på musen ved hjelp av .Dobbeltklikk() metode.

>>> Pyautogui.Moveto (300,201)
>>> Pyautogui.Dobbeltklikk()

Pyautogui gir en metode .rulle () å bla musen opp eller ned. Denne metoden tar et heltall som et argument, og ruller deretter opp eller ned avhengig av heltall. Hvis du passerer et positivt heltall, vil det bla opp og for et negativt heltall vil det bla nedover. Hvor mye det vil bla? Det avhenger av verdien av heltall.

>>> Importer Pyautogui
>>> Pyautogui.rulle (20)
>>> Pyautogui.bla (-20)

I eksemplet ovenfor, først vil musen bla opp i 20 enheter, og deretter vil den bla ned i 20 enheter.

Draging Operation of Mouse kan også påføres ved hjelp av .drago () Metode for Pyautogui -modulen. Dra midler, bevege musen mens du trykker på en av museknappene. Denne metoden tar tre argumenter, de to første argumentene som viser destinasjonskoordinatene, og det siste argumentet er varighetstid som betyr hvor mye tid det vil ta å flytte til destinasjonen.

For å se dra -operasjonen, åpne malingen, maksimere vinduet, velg blyanten og kjør følgende kommandoer inn i det interaktive skallet. Koden vil flytte mus til (138.229) piksel på 2 sekunder, og deretter dra mus fra nåværende piksel til påkrevd piksel også på 2 sekunder.

>>> Importer Pyautogui
>>> Pyautogui.Moveto (138, 229, varighet = 2)
>>> Pyautogui.Dragto (238, 229, varighet = 2)
>>> Pyautogui.Dragto (238, 329, varighet = 2)
>>> Pyautogui.Dragto (138, 329, varighet = 2)
>>> Pyautogui.Dragto (138, 229, varighet = 2)

Over koden vil lage et firkant på malingsprogram ved å dra musen.

Hvordan finne koordinatene til en katalog eller filikon

For å finne koordinatene til en fil eller en katalog, .posisjon() metoden brukes. Denne metoden returnerer koordinatene som musen for øyeblikket er til stede. Følg de gitte trinnene for å finne koordinater

1. Åpne Python -konsollen
2. Typeposisjon ()
3. Før du trykker på "Enter" -tasten, flytter du musepilen til ikonet, der du vil finne koordinater
4. Trykk deretter ENTER for å utføre kommandoen

Håndtering av pause og mislykkes

Du skriver et skript for å automatisere mushandlingene dine, og du trenger en kort pause mellom hver kommando. Hvordan vil du administrere det? Vil du bruke .sove() Metode av TID modul etter hver kommando? Men det vil øke lengden på koden din. Dette kan gjøres ved å sette Pyautogui.PAUSE variabel til antall sekunder du vil ha en pause. Dette vil skape en pause etter hver kommando. Eksemplet nedenfor pauser 3 sekunder mellom hver kommando.

>>> Importer Pyautogui
>>> Pyautogui.Pause = 3
>>> Pyautogui.Moveto (100.100)
>>> Pyautogui.Moveto (200.200)

Python har også en Mislykkes trekk. For å aktivere denne funksjonen, setter vi Pyautogui.Mislykkes til sant. Hvordan dette fungerer? For eksempel har skjermen en oppløsning på 1366 x 768. Hvis du flytter musen til (1500.1500), vil programmet krasje ved å heve FailSafeException. Du kan håndtere dette unntaket enten ved å bruke prøve og unntatt uttalelse eller ved å deaktivere Pyautogui.Mislykkes. Ved å deaktivere FailSafe -funksjonen, vil ikke programmet heve dette unntaket.

>>> Importer Pyautogui
>>> Pyautogui.FailSafe = falsk
>>> Pyautogui.størrelse()
Størrelse (bredde = 1366, høyde = 768)
>>> Pyautogui.Moveto (1500.1500)
>>> Pyautogui.Moveto (100.100)

I eksemplet ovenfor flyttet vi musen på (1500.1500) piksel, men skjermen har (1366.768) piksler. Program ignorerte dette unntaket.

Sende en streng fra tastaturet

Pyautogui gir en funksjon for å passere en streng fra tastaturet. Dette kan gjøres ved hjelp av .Typewrite () -metode for denne modulen. Før du fører streng fra tastaturet, fokuserer du på vinduet der du skal passere strengen. For å fokusere på det nødvendige vinduet, kan vi bruke .klikk () Metode.

Vi brukte en semikolon mellom de to kommandoene da den fokuserer på tekstredigereren og passerer strengen en bak den andre. Nå er spørsmålet hvordan vi kan passere 'alt' eller 'skift' -nøkler. Disse nøklene kan være representert med korte strengverdier. Noen strengverdier er gitt nedenfor.

Tastene strengverdier
Venstre og høyre alt Keys 'Altleft', 'Altright'
Venstre og høyre skift Keys 'ShiftLeft', 'Shiftright'
Venstre og høyre kontrollnøkler 'Ctrlleft', 'Ctrlright'
Side opp og side ned tastene 'Pageup', 'Pagedown'
Backspace og Delete Keys 'Backspace', 'Delete'
Opp, ned, venstre og høyre piltaster 'opp', 'ned', 'venstre', 'høyre'
Caps Lock Key 'Capslock'
Skriv inn tast 'Enter'
ESC Key 'ESC'
Tab -tast 'Tab'
Hjemme- og sluttnøkler 'Home', 'End'
F1 til F12 -tastene 'F1', 'F2', .. . , 'F12'
Num låsetast 'numlock'
PRTSC -tast 'Printscreen'
Sett inn tasten 'Sett inn'

For å passere en av de ovennevnte tastene, bruker vi disse strengverdiene i form av liste. Følgende eksempel vil avklare dette. Koden passerer 'Capslock' to ganger. Første gang i form av liste og andre gang enkelt streng. Passerende 'Capslock' i listen trykker på 'Caps Lock' -tasten. Og andre 'Capslock' Simply Writ 'Capslock' i hovedstaden som 'Capslock' -tasten er trykket først.

>>> Importer Pyautogui
>>> Pyautogui.skrivemaskin (['capslock']); pyautogui.skrivemaskin ('Capslock')
Capslock >>> Capslock

Pressende snarveier

En snarvei er kombinasjonen av nøkler til å utføre noen oppgaver. For eksempel 'alt+f4' snarveis brukes til å lukke det nåværende vinduet. En kombinasjon av nøkler kan også sendes fra tastaturet ved hjelp av Pyautogui -modulen. For å trykke på 'Alt+F4', trykker vi først og holder 'Alt' -tasten og trykker deretter på 'F4' -tasten. Etter å ha gitt ut 'F4' -tasten slipper vi 'Alt' -tasten. Her vil vi bruke .KeyUp () og .KeyDown () Metoder for å trykke på en kombinasjon av nøkler. Følgende eksempel viser å trykke og holde 'alt' nøkkel og trykke og holde 'F4' -tasten sammen.

Importer Pyautogui
Importer tid
Pyautogui.Keydown ('Alt')
Pyautogui.KeyDown (<'f4')
tid.sove(.5)
Pyautogui.Keyup ('F4')
Pyautogui.Keyup ('Alt')

MERK: I eksemplet ovenfor brukte vi ikke listen over strengverdien til 'Alt' og 'F4' -tasten. Liste over strengverdien sendes bare til .skrivemaskin () metode.

Det er veldig komplisert å trykke og holde 'Alt' -tasten og trykk deretter 'F4' -tasten og etter å ha sluppet 'F4' -tasten deretter Release 'Alt' -tasten. Dette kan gjøres bare ved å bruke .Hotkey () metode. Følgende eksempel vil fjerne konseptet.

Importer Pyautogui
Importer tid
Pyautogui.Hotkey ('Alt', 'F4')

Tar og analyserer skjermbilde

Vi kan også ta skjermbilde ved hjelp av Python. Pyautogui -modulen tilbyr .Skjermbilde () Metode for å ta skjermbildet på gjeldende skjerm. Skjermbilde kan vises ved å bruke .forestilling() metode. Kjør følgende kommando for å ta et skjermbilde og vise det.

>>> Importer Pyautogui
>>> img = pyautogui.Skjermbilde ()
>>> img.forestilling()

Når du kjører kommandoene ovenfor for å ta skjermbilde, vil det bli lagret i 'IMG' variabel. Nå kan vi kalle ytterligere metoder på 'IMG' variabel.

Vi kan få en tuple av RGB -verdiene til vår nødvendige piksel ved å bruke .getPixel () Metode på 'IMG' variabel. Argument gikk videre til .getPixel () -metode er en tuple som inneholder x- og y -koordinatene til skjermbildet. Kjør følgende kommando inn i det interaktive skallet.

>>> img.getPixel ((2,3)))
(85, 82, 74)

Videre kan vi få bildestørrelsen ved å bruke følgende kommando

>>> img.størrelse
(1366, 768)

Vi kan sjekke om de gitte pikslene med skjermbilder samsvarer med den gitte RGB -verdien eller ikke. Dette kan gjøres ved hjelp av .PixelMatchScolor () metode. Totalt tre argumenter sendes til denne metoden. De første to argumentene er X- og Y -koordinater for skjerm, og tredje argument er en tuple av RGB -verdier. Denne metoden returnerer 'True' hvis fargen samsvarer med Pixel ellers 'False'. Denne metoden kan brukes som følger

>>> Pyautogui.PixelMatchescolor (2,3, (85,82,74)))
ekte
>>> Pyautogui.PixelMatchescolor (3,5, (52,85,74)))
Falsk

Vi har sett noen grunnleggende ting, og nå i de følgende seksjoner vil vi se noen brukstilfeller av å automatisere GUI ved hjelp av Pyautogui -modulen.

Åpner automatisk forskjellige filer for deg

Hver dag på kontoret ditt, må du åpne mange filer for å legge inn noen data om ansatte manuelt. Det er litt kjedelig å gjøre. Gå først til Documents Directory, og gå deretter til en annen katalog og åpne en fil, og gå deretter tilbake til dokumentkatalogen og Goto en annen katalog og gjør det samme osv.

Dette kan gjøres bare ved å skrive et Python -skript. Det du må gjøre er bare å kjøre skriptet, og skriptet åpner alle filene.

For å utføre denne oppgaven, først og fremst, må du finne koordinatene til følgende

1. Ikon for hver katalog
2. Ikonet for hver fil
3. Minimer filen på filer

Hvordan finne koordinatene er blitt forklart tidligere.

# Importere Pyautogui -modulen
Importer Pyautogui
# generere en pause på 1.5 sekund etter hver kommando
Pyautogui.Pause = 1.5
# Flytte musen til 'dette PC' -ikonet på oppgavelinjen
Pyautogui.Moveto (346,752)
# Klikk på 'dette PC' -ikonet
Pyautogui.Klikk ()
# Flytte musen til "Dokumenter" -ikonet
Pyautogui.Moveto (95,184)
# Klikk på Documents '-katalogen
Pyautogui.Klikk ()
# Flytte musen til katalogen i 'Documents' katalog
Pyautogui.Moveto (249,107)
# dobbeltklikk for å åpne katalogen
Pyautogui.Dobbeltklikk()
# Flytt musen på filen for å åpne
Pyautogui.Moveto (249.108)
# dobbeltklikk på filen for å åpne
Pyautogui.Dobbeltklikk()
# Flytt musen på minimer -knappen
Pyautogui.Moveto (1310,47)
# Klikk for å minimere filen
Pyautogui.Klikk ()

I koden ovenfor åpner vi bare en fil. På samme måte kan du utvide koden for å åpne flere filer.

Ser opptatt på systemet

Du er i jobben din, og du jobber ikke med system, men systemet ditt har en app installert som kan gjette om du sitter på tomgang eller jobber med systemet ved hjelp av musen. Så du vil automatisere musen for å bevege deg etter hvert kort tidsintervall.

Dette kan gjøres ved å skrive et lite Python -skript ved hjelp av Pyautogui modul.

Importer Pyautogui
# generere en pause på 5 sekunder mellom musebevegelsen
Pyautogui.Pause = 5
prøve:
# Kjører uendelig sløyfe
Mens sant:
# Flytting av mus til (200.300) koordinater på 1 sekund
Pyautogui.Moveto (200.300, varighet = 1)
# Flytting av mus til (201,310) koordinat på 1 sekund
Pyautogui.Moveto (201,310, varighet = 1)
unntatt tastaturinterrupt:
trykk ('Slipp')

I koden ovenfor flytter vi musen fra ett sted til et annet sted etter hvert 5. sekund. Vi kan slutte med denne koden ved å trykke på 'Ctrl+C'.

Konklusjon

I denne bloggen diskuterte vi hvordan du kan bruke Pyautogui -modulen for å automatisere GUI av systemet. Ulike funksjoner av denne modulen er blitt forklart, og du kan automatisere nesten alt som kan gjøres ved hjelp av tastatur og mus ved hjelp av disse funksjonene.