บันทึก : ควบคุมเมาส์และคีย์บอร์ดใน Python กับ pyautogui
เราสามารถใช้เพื่อสั่งให้เครื่องคอมทำอะไรต่างๆเองตามที่เราเขียนโปรแกรมไว้ได้ เหมือนเป็นการสร้างบอตขึ้นมาช่วยทำงานแทนเรา
การติดตั้ง และเริ่มใช้งาน
สามารถติดตั้งได้ง่ายดายโดยใช้ pip สำหรับ windows นั้นสามารถลง pyautogui ได้ทันที
แต่สำหรับ mac นั้นจะต้องลงอย่างอื่นก่อน ตามนี้
pip install pyobjc
pip install pyautogui
หลังลงเสร็จแล้วพอต้องการใช้ก็ import ตามปกติ
เนื่องจากชื่อยาวอาจเป็นการดีที่จะย่อมันสักหน่อยเวลาใช้ อย่างไรก็ตามตัวอย่างส่วนใหญ่ที่เจอก็ใช้เต็มไม่ได้ย่อดังนั้นในที่นี้ก็จะเขียนเต็มๆตามนั้น
เริ่มลองจากคำสั่งแรกคือ click
แค่ลองพิมพ์ไปว่า
พอรันโค้ดเมาส์ก็จะถูกคลิกตรงตำแหน่งที่วางอยู่ทันที
แต่หากต้องการระบุว่าจะคลิกตรงไหนก็ให้ใส่พิกัดตำแหน่งลงไปด้วย โดยค่าที่ใส่คือค่าตำแหน่งนับจากบนซ้ายสุด โดยหน่วยเป็นพิกเซล เช่น
เท่านี้เมาส์ก็จะเลื่อนไปยังตำแหน่งนั้นแล้วค่อยคลิก
เพียงแต่การที่จะใช้วิธีนี้ได้เราจะต้องรู้ว่าสิ่งที่ต้องการคลิกอยู่ตรงไหน เพื่อที่จะรู้ได้มีคำสั่งที่สะดวกมากอยู่ นั่นก็คือ position
แค่พิมพ์ว่า
พอรันไปมันก็จะแสดงตำแหน่งที่เมาส์ชี้อยู่ปัจจุบัน พอเราได้ค่าตำแหน่งของสิ่งต่างๆที่ต้องการแล้วก็เอามาใช้กับคำสั่ง click หรือคำสั่งอื่นๆที่ต้องการระบุตำแหน่ง แบบนี้ก็สะดวกดี
นอกจากนี้หากอยากรู้ว่าจอเรากว้างเท่าไหร่ก็ใช้คำสั่ง size ได้ จะคืนค่าขนาดของจอออกมา เช่น
การคลิกเมาส์หลายครั้ง
ปกติคำสั่ง click จะทำการคลิกเมาส์แค่ครั้งเดียว แต่หากต้องการคลิกหลายครั้งก็ทำได้ง่ายโดยเพิ่มอาร์กิวเมนต์ตัวที่ ๓ เข้าไป เป็นจำนวนครั้ง เช่น ถ้าต้องการให้คลิก ๓ ครั้งก็
หรือถ้าจะไม่ระบุตำแหน่งก็ใส่ในรูปคีย์เวิร์ด clicks ได้
ปกติแล้วเมาส์จะคลิกกดอย่างต่อเนื่องในพริบตา แต่หากต้องการให้เว้นช่วงก็ทำได้โดยเพิ่มคียเวิร์ด interval ลงไป โดยใส่ระยะเวลาที่ต้องการเว้นเป็นหน่วยวินาที
แบบนี้ก็จะเป็นการคลิก ๗ ครั้งโดยเว้นระยะห่างครั้งละครึ่งวินาที
นอกจากนี้กรณีคลิก ๒ หรือ ๓ ครั้งมีคำสั่งที่อาจใช้แทนได้อีก นั่นคือ doubleClick สำหรับคลิก ๒ ครั้ง และ tripleClick สำหรับคลิก ๓ ครั้ง
เช่น
pyautogui.tripleClick(250,300)
การคลิกขวาและคลิกกลาง
คำสั่ง click (รวมถึง doubleClick, tripleClick) ปกติจะเป็นการคลิกซ้าย แต่หากต้องการให้เป็นการคลิกขวาหรือคลิกกลางก็สามารถทำได้โดยเพิ่มคีย์เวิร์ด button
หากต้องการคลิกกลางให้ใส่ค่าเป็น middle หรือ 2
หากต้องการคลิกขวาให้ใส่ค่าเป็น right หรือ 3
ส่วนคลิกซ้ายนั้นที่จริงไม่ต้องใส่ก็ไดด้แต่ถ้าจะใส่ก็ใส่เป็น left หรือ 1
ตัวอย่างเช่น
แบบนี้ก็จะเป็นการคลิกขวา
นอกจากนี้ยังมีคำสั่งเฉพาะสำหรับคลิกขวาด้วย คือ rightClick และคำสั่งสำหรับคลิกกลางคือ middleClick เช่น หากพิมพ์
ก็จะให้ผลเหมือนกับที่ใช้ button=3
เพียงแต่ว่าคำสั่ง rightClick กับ middleClick จะกำหนดจำนวนครั้งที่คลิกไม่ได้ ปกติจะใช้คลิกครั้งเดียว
การเลื่อนเมาส์
คำสั่งที่ใช้เลื่อนเมาส์ให้ไปยังจุดที่ต้องการคือ moveTo โดยใส่ตำแหน่งจุดที่ต้องการให้เมาส์ย้ายไป
เมาส์จะย้ายไปตำแหน่งที่ระบุทันที
แต่หากต้องการให้เมาส์ย้ายโดยกำหนดตำแหน่งเมื่อเทียบกับตำแหน่งปัจจุบันให้ใช้คำสั่ง moveRel เช่น
เมาส์จะเลื่อนไปทางขวาบนเทียบกับตำแหน่งเดิม
หากไม่ต้องการให้เมาส์ย้ายไปตรงนั้นทันทีแต่ต้องการให้รอเวลาสักหน่อยก็ทำได้โดยใส่อาร์กิวเมนต์ตัวที่ ๓ ลงไปเป็นค่าระยะเวลา เช่น
แบบนี้เมาส์ก็จะค่อยๆเคลื่อนไปโดยใช้เวลา ๓ วินาที
การกดเมาส์ค้างและลาก
ปกติเวลาใช้คำสั่ง click คือการคลิกเมาส์นั่นคือการกดเมาส์แล้วตามด้วยปล่อยเมาส์ทันที แต่หากต้องการแค่กดเมาส์ลงโดยไม่ปล่อยเมาส์ก็ใช้คำสั่ง mouseDown และหากต้องการปล่อยเมาส์ก็ใช้คำสั่ง mouseUp
ตัวอย่างเช่นหากสั่งแบบนี้ก็จะเป็นการกดเมาส์แล้วปล่อยทันที เท่ากับการใช้คำสั่ง click ทีเดียว
pyautogui.mouseUp()
ทั้งสองคำสั่งก็สามารถระบุตำแหน่งพิกัดได้เช่นเดียวกับ click เช่นหากต้องการให้เมาส์ลากจากจุดหนึ่งไปอีกจุดหนึ่งก็ พิมพ์เป็น
pyautogui.mouseUp(188, 343)
สำหรับการลากเมาส์นั้นยังอาจใช้อีกคำสั่งซึ่งสะดวกกว่า นั่นคือ dragTo คำสั่งนี้จะทำการลากเมาส์จากจุดที่เมาส์อยู่ตอนแรกไปยังจุดที่ระบุ
หากลองพิมพ์
pyautogui.dragTo(188, 343)
ก็จะให้ผลเหมือนกับที่ใช้ mouseDown และ mouseUp
นอกจากนี้ยังมีคำสั่ง dragRel ซึ่งเอาไว้เลื่อนในตำแหน่งที่สัมพัทธ์กับตำแหน่งเดิม
เช่น ให้เลื่อนไปทางขวาล่างร้อยพิกเซล
ทั้ง mouseDown, mouseUp, dragTo และ dragRel ต่างก็สามารถใช้กับเมาส์กลางและเมาส์ขวาได้โดยกำหนดคีย์เวิร์ด button
dragTo และ dragRel สามารถกำหนดระยะเวลาลากได้ด้วยการใส่อาร์กิวเมนต์ตัวที่ ๓ ลงไปเป็นระยะเวลาเช่นเดียวกับใน moveTo และ moveRel
เช่นลองให้ค่อยๆลากไปโดยใช้เวลา ๒ วินาที
การหมุนลูกเลื่อนเมาส์
หากต้องการหมุนลูกเลื่อนเมาส์ก็ใช้คำสั่ง scroll โดยต้องใส่ค่าปริมาณการหมุนลงไป โดยถ้าค่าบวกเป็นการหมุนขึ้นบน ค่าถ้าลบเป็นการหมุนลงข้างล่าง เช่น
แบบนี้จะเป็นการหมุนลงข้างล่าง
สำหรับใน mac สามารถหมุนลูกเลื่อนในแนวนอนได้ด้วย จะสามารถใช้คำสั่ง hscroll เพื่อหมุนแนวนอนได้ เช่น
คำสั่งสำหรับพิมพ์ตัวอักษรจากคีย์บอร์ดเสมือนกับว่าเรากำลังเอามือกดแป้นพิมพ์อยู่ก็คือ typewrite การใช้ก็แค่ใส่ข้อความที่ต้องการพิมพ์ลงไป เช่น
เพียงแต่ต้องระวังว่าตัวที่ใส่ต้องเป็นอักษรที่อยู่บนแป้นคีย์บอร์ดภาษาอังกฤษเท่านั้น คำสั่งนี้แค่เป็นตัวสั่งให้กดแป้นคีย์บอร์ดแป้นนั้น หากต้องการพิมพ์ภาษาอื่นก็ต้องเทียบตำแหน่งแป้นพิมพ์เอา
ดังนั้นหากต้องการพิมพ์คำว่า "สวัสดี" ก็ให้ตั้งคีย์บอร์ดเป็นภาษาไทยไว้แล้วพิมพ์ว่า
หากต้องการให้เว้นระยะเวลาในการพิมพ์แต่ละตัวก็ให้ใส่คีย์เวิร์ด interval เพิ่มเข้าไป เช่น
ในการใส่อักษรจะใส่ในรูปของลิสต์ทีละตัวอักษรก็ทำได้เช่นกัน
การสั่งให้กดปุ่ม
นอกจากปุ่มบนแป้นพิมพ์ที่เป็นตัวอักษรแล้วยังสามารถสั่งพวกปุ่มคำสั่งต่างๆบนแป้นพิมพ์ได้ด้วย เช่น
แบบนี้จะเป็นการกด enter
เพียงแต่ว่าต้องเขียนในรูปของลิสต์ ถ้าใส่เป็น
แบบนี้จะกลายเป็นเราสั่งให้พิมพ์คำว่า enter แบบนี้ไม่มีความหมาย
นอกจากนี้ยังมีอีกคำสั่งที่ใช้สั่งให้กดปุ่มได้เช่นกัน คือ press ถ้าต้องการให้กด enter ก็แค่พิมพ์
หากอยากรู้ว่าปุ่มไหนใช้ได้สามารถดูได้ที่ค่าแอตทริบิวต์ KEYBOARD_KEYS
เท่านี้ปุ่มทั้งหมดที่ใช้ได้ก็จะแสดงออกมา
หากต้องการกดหลายปุ่มต่อๆกันไปก็ใส่ในรูปของลิสต์ กรณีนี้จะใช้ press หรือ typewrite ก็เหมือนกัน
# หรือ pyautogui.typewrite(['enter','left'])
แต่ press สามารถสั่งให้กดปุ่มเดิมซ้ำหลายครั้งได้ เช่น
# เท่ากับ pyautogui.typewrite(['enter','enter','enter','enter'])
จะให้วนซ้ำเป็นชุดหลายตัวก็ได้
press สามารถใส่คีย์เวิร์ด interval ได้เช่นเดียวกัน แต่ความหมายจะต่างจากใช้กับ typewrite คือจะเป็นการเว้นช่วงในแต่ละรอบที่มีการซ้ำ ไม่ใช่การเว้นระหว่างแต่ละคีย์ในรอบ
เช่น ลองให้พิมพ์แล้วลบ สลับไปเรื่อยๆ
การกดปุ่มค้างไว้และการใช้ฮ็อตคีย์
เวลาใช้ press จะเป็นการกดปุ่มแล้วปล่อยทันที แต่หากต้องการแค่ให้กดปุ่มแช่ไว้ก็จะใช้คำสั่ง keyDown
จากนั้นเมื่อต้องการให้ปล่อยปุ่มก็ใช้คำสั่ง keyUp
ตัวอย่างเช่น ลองให้เขียนตัวอักษรขึ้นมาแล้วลากคลุมให้หมด
pyautogui.keyDown('shift')
pyautogui.press('left',5)
pyautogui.keyUp('shift')
หรือกรณีที่จะใช้ฮ็อตคีย์ เช่น ctrl-a (ใน mac เป็น command-a) คือการลากคลุมอักษรทั้งหมด ก็กดแบบนี้
pyautogui.press('a')
pyautogui.keyUp('ctrl')
การเขียนแบบนี้ออกจะดูยุ่งยากเล็กน้อย ที่จริงแล้วมีคำสั่งที่ช่วยให้ทำแบบนี้ได้ง่ายกว่า นั่นคือใช้คำสั่ง hotkey
เช่น สามบรรทัดนั้นอาจเขียนแทนด้วย
# สำหรับ mac จะเป็น pyautogui.hotkey('command','a')
แบบนี้ก็เท่ากับการกดปุ่ม ctrl แล้วค่อยกด a จากนั้นก็ค่อยปล่อย ctrl อีกที
จะใส่ทีกี่ตัวก็ได้ เช่น ๓ ตัว
การหน่วงเวลา
ปกติถ้าเราเขียนคำสั่งต่อเนื่องเวลารันแล้วคำสั่งจะถูกทำต่อเนื่องไปทันที แต่ถ้าหากหน่วงเวลาให้มีการเว้นช่วงก็สามารถทำได้โดยใช้คำสั่ง sleep จากมอดูล time
เช่น
pyautogui.click(200,200)
time.sleep(1)
pyautogui.click(400,300)
แบบนี้จะเป็นการหยุด ๑ วินาทีหลังคำสั่งแรก
หรืออีกวิธีหนึ่งที่น่าจะง่ายกว่าก็คือการเพิ่มคีย์เวิร์ด pause ลงไปในฟังก์ชัน ก็จะเป็นการหยุดหลังจากทำคำสั่งเสร็จตามเวลาที่กำหนด เช่น
pyautogui.moveRel(60,100)
ทุกคำสั่งของ pyautogui สามารถใส่ pause ลงไปได้หมด
นอกจากนี้สำหรับบางฟังก์ชัน เช่น click หรือ press ก็มีอีกวิธีหนึ่งก็คือใส่ interval ก็จะให้ผลเหมือนกับใส่ pause
pyautogui.click(400,300)
เพราะปกติ interval ใช้กำหนดช่วงเวลาที่รอระหว่างการคลิกแต่ละครั้ง ถ้าคลิกครั้งเดียวก็จะเป็นการรอเพื่อเว้นช่วงระหว่างการทำคำสั่งต่อไป
ถ้าหากใส่ทั้ง interval ทั้ง pause ระยะเวลาที่รอก็จะบวกกันไป
และนอกจากนี้แล้ว หากต้องการให้มีการหน่วงเวลาเหมือนกันหมดไม่ว่าจะทำคำสั่งอะไรก็ให้ไปแก้ค่าแอตทริบิวต์ PAUSE ของมอดูลเอาไว้ก่อนเริ่มใช้คำสั่ง เช่นทำแบบนี้
ทีนี้แล้วไม่ว่าจะใช้คำสั่งไหนไปก็จะถูกเว้นครึ่งวินาทีก่อนจะทำคำสั่งต่อไปเสมอ โดยไม่ต้องใส่คีย์เวิร์ด pause ตลอด
เพียงแต่ว่าหากคำสั่งไหนใส่คีย์เวิร์ด pause ลงไปก็จะเว้นระยะเวลาหยุดตามที่ใส่ลงไปนั้นแทน
การหยุดฉุกเฉิน
ระหว่างที่สั่งให้มันทำงานไปเรื่อยๆนั้นปกติโปรแกรมจะไม่สามารถหยุดเองได้จนกว่าจะสิ้นสุดการทำงาน หรือเกิดข้อผิดพลาดขึ้นกลางคัน
ในสภาวะแบบนี้ถ้าปล่อยให้มันทำไปแล้วเกิดข้อผิดพลาดขึ้นมากลางคันอาจทำให้ทุกอยากรวน เป็นอันตรายได้เหมือนกัน ดังนั้นจึงควรรู้วิธีที่จะหยุดกลางคัน
การหยุดกลางคันสามารถทำได้โดยเลื่อนเมาส์ไปยังมุมซ้ายบนสุดของหน้าจอ เท่านี้การทำงานทั้งหมดก็จะหยุด
แต่บางครั้งเราอาจไม่ต้องการ เช่นกลัวจะเผลอเลื่อนเมาส์ไปตรงนั้นระหว่างกำลังทำงานอยู่โดยไม่ได้ตั้งใจ ในกรณีแบบนั้นก็สามารถยกเลิกการใช้วิธีการหยุดฉุกเฉินนี้ได้โดยพิมพ์
# หรือ pyautogui.FAILSAFE = False
เท่านี้ก็จะไม่มีทางหยุดการทำงานได้กลางคันแล้ว (ค่าตั้งต้นจะเป็น True)
แต่นอกจากนี้ก็ยังมีวิธีอื่นในการหยุดอยู่อีก คือไปกลับยังคอมมานด์ไลน์ที่ใช้ตอนสั่งรันโปรแกรม แล้วสั่งหยุดโปรแกรมด้วย ctrl-c ตามปกติ แบบนี้ก็ได้เช่นกัน
การบันทึกภาพหน้าจอ
pyautogui นั้นนอกจากจะใช้ควบคุมเมาส์และคีย์บอร์ดแล้วก็ยังมีคำสั่งที่เกี่ยวกับการจัดการภาพที่แสดงบนหน้าจอด้วย
นั่นเพราะการรับรู้ว่าหน้าจอขณะนั้นหน้าตาเป็นอย่างไรก็เป็นสิ่งสำคัญในการสร้างบอตเหมือนกัน เช่น เราอาจตรวจสอบสิ่งที่อยู่บนหน้าจอเพื่อใช้ตั้งเงื่อนไขว่าต้องทำยังไงต่อไป หรืออาจต้องการหาตำแหน่งภาพที่เราต้องการเพื่อจะรู้ว่าต้องกดอะไรตรงไหน
คำสั่งสำหรับบันทึกภาพหน้าจอก็คือ screenshot
ตัวอย่างการใช้
เพียงแค่นี้ภาพก็จะถูกบันทึกอยู่ในไฟล์ชื่อ ss.png
หากต้องการแค่บางส่วนบนหน้าจอให้ใส่คีย์เวิร์ด region เพิ่มเข้าไป โดยใส่ค่าเป็นทูเพิลของตำแหน่งซึ่งมีค่า ๔ ตัว คือ (ซ้ายสุด,บนสุด,ความกว้าง,ความสูง)
เช่น
# หรือ pyautogui.screenshot('ss.png',(0,0,100,100))
แบบนี้ภาพก็จะตัดแค่ส่วนมุมบนซ้ายสุดขนาดกว้างร้อยสูงร้อย
การเอาข้อมูลสีของภาพบนหน้าจอ
หากไม่ต้องการให้เซฟภาพก็แค่ใส่คีย์เวิร์ด region ไปโดยไม่ต้องใส่อาร์กิวเมนต์ตัวแรกเป็นชื่อไฟล์ลงไป
เช่น
ได้
จะเห็นว่าผลที่ได้ออกมาเป็นออบเจ็กต์ชนิด PIL ซึ่งเป็นออบเจ็กต์ที่เก็บข้อมูลสีของจุดภาพแต่ละจุดเอาไว้ เราสามารถเอาไปเขียนโปรแกรมเพื่อจัดการอะไรๆต่อได้
วิธีการนำไปใช้อาจมีอยู่หลากหลาย แต่ในที่นี่จะใช้วิธีการแปลงเป็นอาเรย์ของ numpy เพื่อนำไปใช้
เช่น
ss = pyautogui.screenshot(region=(86,32,2,3))
ss = np.array(ss)
print(ss)
print(ss.shape)
ได้
[ 0 102 182]]
[[144 58 0]
[102 182 255]]
[[ 58 0 102]
[182 255 255]]
[[ 0 102 182]
[255 255 255]]]
(3, 2, 3)
พอแปลงเป็นอาเรย์แบบนี้แล้วก็จะได้อาเรย์สามมิติที่มีขนาดเป็น (ความสูง,ความกว้าง,3) โดยมิติสุดท้ายที่เพิ่มเข้ามาคือค่าสี (แดง,เขียว,น้ำเงิน) จะมี ๓ ค่าเสมอ
หรือหากต้องการภาพแค่จุดเดียวอาจใช้คำสั่ง pixel ก็ได้ โดยใส่ตำแหน่งของจุดที่ต้องการหาค่าสีลงไป เช่น
ถ้าต้องการหาสีตำแหน่งที่เมาส์ชี้อยู่ก็อาจเขียนแบบนี้
หากแค่ต้องการเทียบว่าสีของจุดนั้นๆตรงกับค่าที่ต้องการหรือไม่ก็อาจใช้คำสั่ง pixelMatchesColor
จะได้ค่า Trur หรือ False ออกมา
เทียบเท่ากับการพิมพ์ว่า
การค้นหาภาพที่ต้องการในหน้าจอ
ต่อไปเป็นตัวอย่างการประยุกต์ใช้งานเพื่อหาตำแหน่งของเป้าหมายบางอย่างบนหน้าจอให้เจอเพื่อจะทำการคลิก
สมมุติว่าเราต้องการจะกดเลือกโปรแกรมโน้ตแพ็ดบนทัสก์บาร์ ไอคอนโน้ตแพ็ดใน windows10 รูปร่างหน้าตาเป็นแบบนี้
ลองหาค่าสีของไอคอนโดยใช้ screenshot เอาค่าสีในตำแหน่งไอคอนนั้นมาเก็บค่าเอาไว้ อาจใช้แค่ไม่กี่จุด พอที่จะให้ไม่เผลอไปซ้ำกับสีที่อื่นโดยบังเอิญได้ ในที่นี้ใช้ ๕ จุดในแนวนอนบริเวณแถวกลางๆไอคอน
print(ssnp[0])
ได้
[146 202 215]
[138 198 212]
[137 193 207]
[210 227 232]]
จากนั้นสามารถหำตำแหน่งที่โน้ตแพ็ดตั้งอยู่ได้โดย screenshot เอาค่าสีในบริเวณแถวทัสก์บาร์ จากนั้นไล่ค้นหาสีที่ต้องการ
ss = np.array(pyautogui.screenshot(region=(0,776,1280,1)))
for x in range(1276):
if(np.all(ss[0,x:x+5]==notepad)):
pyautogui.click(x,776)
break
else: raise
เท่านี้โปรแกรมก็จะทำการค้นหาตำแหน่งไอคอนโน้ตแพ็ดบนทัสก์บาร์แล้วก็คลิกตรงนั้น แต่ถ้าหาไม่เจอก็จะขึ้น error
ในตัวอย่างนี้เรารู้ตำแหน่งในแนวตั้งอยู่แล้วจึงให้โปรแกรมแค่ไล่หาตามแนวนอน จึงง่ายและทำได้รวดเร็ว
แต่กรณีที่ไม่รู้ตำแหน่งตามแนวตั้งด้วยก็ต้องไล่หาตามแนวตั้งด้วย อาจเขียนใหม่ได้ดังนี้
ss = np.array(pyautogui.screenshot(region=(0,0,1280,800)))
for x,y in ((x,y) for y in range(800) for x in range(1276)):
if(np.all(ss[y,x:x+5]==notepad)):
pyautogui.click(x,y)
break
else: raise
แบบนี้ก็จะซับซ้อนขึ้น และระยะเวลาในการค้นหาก็จะค่อนข้างนาน กว่าจะกวาดหาจบทั้งหน้าจอ ดังนั้นหากรู้ขอบเขตว่ามันควรอยู่ตรงไหนอยู่แล้วหาแค่แถวๆนั้นจะเร็วกว่ามาก
นี่เป็นแค่ตัวอย่างการลองใช้ ยังไงก็สามารถลองไปปรับใช้ดูอีกที
การสร้างกล่องข้อความอย่างง่าย
pyautogui ยังมีคำสั่งสำหรับสร้างกล่องข้อความแบบง่ายๆขึ้นมาด้วย อาจเอาไว้ใช้ให้เด้งขึ้นมาในกรณีที่โปรแกรมมีปัญหาเพื่อเราจะได้ดูว่าจะทำยังไงต่อ หรือสำหรับหยุดพักก่อนเริ่มทำอะไรในขั้นต่อไป
คำสั่งสำหรับสร้างกล่องข้อความให้เด้งขึ้นมาอย่างง่ายสุดคือ alert เป็นหน้าต่างง่ายๆที่มีปุ่มให้กดอันเดียว
ตัวอย่างการใช้
# หรือ pyautogui.alert('ข้อความ','หัวข้อ','ปุ่มกด')
ผลที่ได้
ค่าที่ต้องใส่มี ๓ ตัวดังที่เห็นนี้ ถ้าใส่ตามลำดับแล้วจะเขียนในรูปอาร์กิวเมนต์ธรรมดาโดยไม่ต้องใส่คีย์เวิร์ดเลยก็ได้
ค่าตั้งต้นจะเป็น text='', title='', button='OK'
คำสั่งต่อมาที่ใช้ได้คือ confirm จะคล้ายกับ alert แต่จะใส่ปุ่มได้หลายอัน
ตัวอย่าง
ผลที่ได้
พอกดปุ่มไหนไปมันก็จะคืนค่าข้อความบนปุ่มนั้นกลับออกมาด้วย สามารถนำไปใช้ในโปรแกรมต่อได้ เช่นใช้เพื่อกำหนดทางแยกให้เราตัดสินใจว่าจะทำยังไงต่อดี
ค่าตั้งต้นเป็น text='', title='', buttons=['OK', 'Cancel']
สร้างกล่องข้อความให้ป้อนข้อความ
นอกจากกล่องข้อความง่ายๆที่มีแค่ให้กดปุ่มก็ยังสามารถสร้างกล่องข้อความที่มีให้พิมพ์ข้อความอะไรได้ สามารถทำได้โดยใช้คำสั่ง prompt
ตัวอย่าง
ผลที่ได้
จากนั้นถ้ากด ok จะคืนค่าข้อความที่พิมพ์กลับมา นำไปใช้ในโปรแกรมต่อ
ถ้ากด cancel ไปจะไม่มีการคืนค่ากลับมา
ค่าตั้งต้นคือว่างเปล่าไม่มีอะไรเลย text='', title='', default=''
สำหรับกรณีที่สิ่งที่ต้องการพิมพ์นั้นเป็นพวกพาสเวิร์ดก็ใช้คำสั่ง password กล่องข้อความจะไม่แสดงข้อความที่พิมพ์ไปจริงๆ
ตัวอย่าง
ผลที่ได้
mask ในที่นี้คือตัวกำหนดว่าพอพิมพ์ลงไปจะกลายเป็นอักษรอะไร ถ้าไม่ใส่ก็จะเป็นดอกจัน *
ค่าตั้งต้นคือ text='', title='', default='', mask='*'
อ้างอิง
http://tony-mooori.blogspot.com/2016/05/guipython.html
http://www.slideshare.net/goyoki/pyautoguipython
https://muxuezi.github.io/posts/doc-pyautogui.html