คู่มือสำหรับผู้เริ่มต้น aiohttp ใน Python

เมื่อทำงานกับ Python เพื่อโต้ตอบกับเว็บ API โดยเฉพาะอย่างยิ่งเมื่อจัดการคำขอหลายรายการ คุณอาจเคยพบกับความล่าช้าบางอย่าง ไม่ว่าจะเป็นการดาวน์โหลดไฟล์ การขูดข้อมูล หรือการส่งคำขอไปยัง API การรอให้แต่ละงานเสร็จสิ้นสามารถทำให้สิ่งต่างๆ ช้าลงอย่างมาก นี่คือจุดที่การเขียนโปรแกรมแบบอะซิงโครนัสเข้ามาช่วย และหนึ่งในเครื่องมือที่ดีที่สุดในระบบนิเวศของ Python สำหรับสิ่งนี้คือไลบรารี aiohttp

หากคุณไม่คุ้นเคยกับการเขียนโปรแกรมแบบอะซิงโครนัส ไม่ต้องกังวล! ฉันจะอธิบายให้เข้าใจง่ายๆ และอธิบายว่า aiohttp สามารถช่วยปรับปรุงคำขอเว็บของคุณได้อย่างไร ทำให้เร็วขึ้นและมีประสิทธิภาพมากขึ้น

ก่อนที่เราจะเจาะลึก เรามาพูดถึงสิ่งที่นักพัฒนาทุกคนต้องเผชิญกัน: การทดสอบ API และถ้าคุณเหมือนกับทีมส่วนใหญ่ คุณอาจใช้ Postman สำหรับสิ่งนั้น

ฉันเข้าใจ—Postman เป็นเครื่องมือที่คุณคุ้นเคย แต่พูดตามตรง เราทุกคนไม่ได้สังเกตหรือว่ามันเริ่มน่าสนใจน้อยลงทุกปีใช่ไหม? แต่คุณก็ยังอยู่ที่นี่ ทำงานเป็นทีม และคุณต้องการเครื่องมือการทำงานร่วมกันเพื่อให้กระบวนการพัฒนาเป็นไปอย่างราบรื่น แล้วคุณจะทำอย่างไร? คุณลงทุนใน Postman Enterprise ในราคา 49 ดอลลาร์ต่อเดือน

แต่สิ่งสำคัญคือ: คุณไม่จำเป็นต้องทำเช่นนั้น

ใช่ คุณอ่านไม่ผิด มีวิธีที่ดีกว่าและมีประสิทธิภาพมากกว่าในการจัดการการทดสอบ API และการทำงานร่วมกันเป็นทีมโดยไม่ต้องเสียเงินจำนวนมากให้กับเครื่องมือที่พูดตามตรงแล้วไม่ได้นำเสนอในสิ่งที่เคยทำ มาสำรวจทางเลือกที่ดีกว่ากันเถอะ!

APIDog: คุณได้รับทุกอย่างจาก Postman รุ่นที่ต้องชำระเงิน แต่ถูกกว่า
ถูกต้องแล้ว APIDog ให้คุณสมบัติทั้งหมดที่มาพร้อมกับ Postman รุ่นที่ต้องชำระเงิน ในราคาเพียงเศษเสี้ยวของราคา การย้ายข้อมูลทำได้ง่ายมากจนคุณเพียงแค่คลิกไม่กี่ปุ่ม และ APIDog จะทำทุกอย่างให้คุณ

APIDog คุ้มค่าที่จะลองอย่างแน่นอน แต่ถ้าคุณเป็นหัวหน้าทีมเทคโนโลยีของทีม Dev ที่ต้องการทิ้ง Postman เพื่อสิ่งที่ดีกว่าและถูกกว่า ลองดู APIDog!

aiohttp คืออะไร?

aiohttp เป็นไลบรารี Python ยอดนิยมที่ช่วยให้คุณเขียนไคลเอนต์และเซิร์ฟเวอร์ HTTP แบบอะซิงโครนัสได้ ลองนึกภาพว่ามันเหมือนกับไลบรารี requests ของ Python แต่มีเทอร์โบชาร์จด้วยพลังของการเขียนโปรแกรมแบบอะซิงโครนัส

มันถูกสร้างขึ้นบนเฟรมเวิร์ก asyncio ของ Python ซึ่งหมายความว่ามันสามารถจัดการคำขอจำนวนมากพร้อมกันได้โดยไม่ต้องรอให้แต่ละรายการเสร็จสมบูรณ์ก่อนที่จะไปยังรายการถัดไป

ลองนึกภาพว่าคุณอยู่ที่ร้านกาแฟ และแทนที่จะรอคิวเพื่อให้แต่ละคำสั่งเสร็จสิ้นทีละรายการ บาริสต้าหลายคนเริ่มทำงานตามคำสั่งของคุณพร้อมกัน

ด้วย aiohttp มันเหมือนกับว่าคุณกำลังทำงานกับทีมบาริสต้า ทั้งหมดกำลังชงกาแฟ (หรือในกรณีนี้ กำลังดึงข้อมูล) ในเวลาเดียวกัน ผลลัพธ์? ผลลัพธ์ที่เร็วขึ้นโดยใช้เวลารอน้อยลง

ทำไมคุณควรใส่ใจเกี่ยวกับ aiohttp?

มาพูดถึงว่าทำไม aiohttp จึงมีความสำคัญสำหรับคุณ ไม่ว่าคุณจะเป็นผู้เริ่มต้น Python นักวิทยาศาสตร์ข้อมูล นักขูดเว็บ หรือแม้แต่นักพัฒนาที่มีประสบการณ์

• ประสิทธิภาพ: เหตุผลหลักในการใช้ aiohttp คือประสิทธิภาพ หากคุณต้องการโทร API หลายครั้งหรือส่งคำขอไปยังเว็บไซต์ aiohttp สามารถจัดการได้พร้อมกัน
  แทนที่จะประมวลผลทีละรายการ คุณสามารถดำเนินการคำขอหลายสิบหรือหลายร้อยรายการในเวลาเดียวกัน
• ความสามารถในการปรับขนาด: การขูดเว็บหรือการเรียก API หลายรายการอาจเป็นกระบวนการที่ช้าและปิดกั้นโดยใช้การเขียนโปรแกรมแบบซิงโครนัส อย่างไรก็ตาม ด้วย aiohttp คุณสามารถจัดการงานได้มากขึ้นในเวลาที่น้อยลง ซึ่งหมายความว่าแอปพลิเคชันของคุณสามารถจัดการความต้องการที่เพิ่มขึ้นหรือชุดข้อมูลที่ใหญ่ขึ้นได้
• ลดเวลารอ: โปรแกรมแบบซิงโครนัสแบบดั้งเดิมต้องรอให้งานหนึ่งเสร็จสิ้นก่อนที่จะเริ่มงานถัดไป
  ด้วยโค้ดแบบอะซิงโครนัส งานไม่ต้องรอ คุณสามารถดาวน์โหลดข้อมูลจากหลาย URL พร้อมกัน ซึ่งช่วยลดเวลาทำงานโดยรวมได้อย่างมาก
• การใช้ทรัพยากรอย่างมีประสิทธิภาพ: การเขียนโปรแกรมแบบอะซิงโครนัส และ aiohttp โดยเฉพาะอย่างยิ่ง ทำให้การใช้ทรัพยากรของระบบของคุณมีประสิทธิภาพมากขึ้น
  แทนที่จะปิดกั้นเธรดหรือกระบวนการทั้งหมดเพื่อรอการตอบสนอง aiohttp ช่วยให้งานอื่นๆ ทำงานได้ในขณะที่รอการดำเนินการ I/O ให้เสร็จสมบูรณ์

aiohttp ทำงานอย่างไร?

มาเจาะลึกว่า aiohttp ทำงานอย่างไรในทางปฏิบัติ
ก่อนอื่น เรามาอธิบายว่าการเขียนโปรแกรมแบบอะซิงโครนัสหมายถึงอะไรจริงๆ ในโปรแกรมแบบซิงโครนัส แต่ละงานต้องเสร็จสิ้นก่อนที่งานถัดไปจะเริ่มต้น

หากคุณกำลังรอให้เว็บเซิร์ฟเวอร์ตอบสนองต่อคำขอของคุณ โปรแกรมทั้งหมดจะหยุดจนกว่าการตอบสนองนั้นจะมาถึง การเขียนโปรแกรมแบบอะซิงโครนัสช่วยให้โปรแกรมสามารถดำเนินการงานอื่นๆ ต่อไปได้ในขณะที่รอการตอบสนอง

aiohttp ใช้ประโยชน์จากโมเดลแบบอะซิงโครนัสนี้เพื่อให้คุณสามารถส่งคำขอ HTTP หลายรายการพร้อมกัน จากนั้นจัดการการตอบสนองเมื่อเข้ามา นี่คือตัวอย่างที่แสดงให้เห็นสิ่งนี้ในวิธีง่ายๆ:

วิธีส่งคำขอเว็บด้วย aiohttp: พื้นฐาน

ไดอะแกรมนี้ (รูปที่ 2) เปรียบเทียบโฟลว์แบบซิงโครนัส (งานหนึ่งเสร็จสมบูรณ์ก่อนงานถัดไป) และโฟลว์แบบอะซิงโครนัส (งานหลายรายการทำงานพร้อมกัน)
กล่องสีน้ำเงินแสดงถึงงานแบบซิงโครนัส ในขณะที่กล่องสีเขียวแสดงถึงงานแบบอะซิงโครนัส
ลูกศรระบุโฟลว์ของการดำเนินการสำหรับทั้งกระบวนการแบบซิงโครนัสและอะซิงโครนัส

การแสดงภาพ Event Loop (กลไก Loop ภายในโมเดลอะซิงโครนัสของ Python)

ไดอะแกรมนี้ (รูปที่ 3) แสดงให้เห็นกลไก event loop ในโมเดลการเขียนโปรแกรมแบบอะซิงโครนัสของ Python
โหนดแสดงถึงขั้นตอนต่างๆ เช่น การเริ่มต้นงาน การรอการดำเนินการ I/O และการดำเนินการเรียกกลับ
ลูกศรที่กำกับแสดงให้เห็นว่างานเริ่มต้นอย่างไร พวกเขารอการดำเนินการ I/O อย่างไร และ event loop จัดการการเรียกกลับและเริ่มงานใหม่ได้อย่างไร

การดึง URL พร้อมกันใน aiohttp

ไดอะแกรม USe case (รูปที่ 4) แสดงให้เห็นว่า aiohttp สามารถจัดการคำขอ URL หลายรายการพร้อมกันได้อย่างไร แต่ละกระบวนการ "ดึง URL" ได้รับการจัดการพร้อมกันและส่งไปยังโหนดประมวลผลกลาง

ไดอะแกรมนี้แสดงให้เห็นว่า aiohttp สามารถดึง URL หลายรายการพร้อมกันในสถานการณ์การขูดเว็บหรือคำขอ API ได้อย่างไร

ไดอะแกรมเวิร์กโฟลว์

ไดอะแกรมเวิร์กโฟลว์แสดงภาพไปป์ไลน์ข้อมูลพื้นฐาน โดยแสดงขั้นตอนการดึง ประมวลผล ทำความสะอาด และจัดเก็บข้อมูล

ตัวอย่าง: การส่งคำขอแบบอะซิงโครนัสด้วย aiohttp

import aiohttp
import asyncio

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [
        "https://jsonplaceholder.typicode.com/posts/1",
        "https://jsonplaceholder.typicode.com/posts/2",
        "https://jsonplaceholder.typicode.com/posts/3",
    ]
    
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        responses = await asyncio.gather(*tasks)
        
        for i, response in enumerate(responses):
            print(f"Response {i+1}: {response[:60]}...")  # Print first 60 characters of each response

Run the event loop
asyncio.run(main())

การดาวน์โหลดเนื้อหาแบบซิงโครนัส
ก่อนอื่น เรามาลองทำสิ่งนี้แบบซิงโครนัสโดยใช้ไลบรารี requests สามารถติดตั้งได้โดยใช้:

pip.python3.7 -m pip install requests

การดาวน์โหลดทรัพยากรออนไลน์โดยใช้ requests นั้นง่ายมาก

import requestsresponse = requests.get("https://www.python.org/dev/peps/pep-8010/")print(response.content)

มันจะพิมพ์เนื้อหา HTML ของ PEP 8010 หากต้องการบันทึกไว้ในเครื่องในไฟล์:

filename = "sync_pep_8010.html"with open(filename, "wb") as pep_file:pep_file.write(content.encode('utf-8'))

ไฟล์ sync_pep_8010.html จะถูกสร้างขึ้น

กรณีการใช้งานจริงสำหรับ aiohttp

1. การขูดเว็บ
หากคุณกำลังขูดหลายหน้าจากเว็บไซต์ การรอให้แต่ละหน้าโหลดอาจเป็นกระบวนการที่ช้าอย่างเจ็บปวด ด้วย aiohttp คุณสามารถขูดหลายหน้าพร้อมกันได้ ซึ่งช่วยเร่งกระบวนการได้อย่างมาก ลองนึกภาพการดึงหลายร้อยหน้าพร้อมกันแทนที่จะรอให้แต่ละหน้าโหลดตามลำดับ
2. คำขอ API
เมื่อทำงานกับ API โดยเฉพาะอย่างยิ่ง API ที่มีขีดจำกัดอัตราหรือตอบสนองช้า คุณสามารถส่งคำขอหลายรายการพร้อมกันได้โดยใช้ aiohttp ตัวอย่างเช่น หากคุณกำลังสอบถาม API สภาพอากาศเพื่อรับข้อมูลสำหรับหลายเมือง aiohttp สามารถช่วยคุณรวบรวมผลลัพธ์ได้เร็วขึ้น
3. การรวบรวมข้อมูล
ไม่ว่าคุณจะทำงานกับข้อมูลตลาดหุ้น ฟีดโซเชียลมีเดีย หรือเว็บไซต์ข่าว aiohttp สามารถเปลี่ยนเกมสำหรับการจัดการคำขอ HTTP จำนวนมากพร้อมกันได้ ทำให้คุณสามารถรวบรวมข้อมูลได้เร็วขึ้นและมีประสิทธิภาพมากขึ้น

นี่คือตัวอย่างการใช้งานจริงสามตัวอย่างของไลบรารี aiohttp ของ Python พร้อมขั้นตอนและโค้ดตัวอย่าง:

1. การส่งคำขอ HTTP แบบอะซิงโครนัส

ตัวอย่างนี้แสดงให้เห็นวิธีการส่งคำขอ HTTP แบบอะซิงโครนัสหลายรายการโดยใช้ aiohttp

ขั้นตอน:

1. นำเข้าโมดูลที่จำเป็น
2. กำหนดฟังก์ชันแบบอะซิงโครนัสเพื่อดึง URL
3. สร้างรายการ URL ที่จะดึง
4. ตั้งค่า async event loop
5. เรียกใช้ฟังก์ชัน async สำหรับแต่ละ URL พร้อมกัน

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [
        'https://api.github.com',
        'https://api.github.com/events',
        'https://api.github.com/repos/python/cpython'
    ]
    
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        responses = await asyncio.gather(*tasks)
        
        for url, response in zip(urls, responses):
            print(f"URL: {url}\nResponse length: {len(response)}\n")

asyncio.run(main())

2. การสร้างเซิร์ฟเวอร์ API อย่างง่าย

ตัวอย่างนี้แสดงวิธีการสร้างเซิร์ฟเวอร์ API พื้นฐานโดยใช้ aiohttp

ขั้นตอน:

1. นำเข้าโมดูลที่จำเป็น
2. กำหนดตัวจัดการเส้นทาง
3. สร้างแอปพลิเคชันและเพิ่มเส้นทาง
4. เรียกใช้แอปพลิเคชัน

from aiohttp import web

async def handle_root(request):
    return web.json_response({"message": "Welcome to the API"})

async def handle_users(request):
    users = [
        {"id": 1, "name": "Alice"},
        {"id": 2, "name": "Bob"},
        {"id": 3, "name": "Charlie"}
    ]
    return web.json_response(users)

app = web.Application()
app.add_routes([
    web.get('/', handle_root),
    web.get('/users', handle_users)
])

if __name__ == '__main__':
    web.run_app(app)

3. เซิร์ฟเวอร์แชท Websocket

ตัวอย่างนี้แสดงให้เห็นวิธีการสร้างเซิร์ฟเวอร์แชทที่ใช้ websocket อย่างง่ายโดยใช้ aiohttp

ขั้นตอน:

1. นำเข้าโมดูลที่จำเป็น
2. สร้างชุดเพื่อจัดเก็บ websockets ที่ใช้งานอยู่
3. กำหนดตัวจัดการ websocket
4. สร้างแอปพลิเคชันและเพิ่มเส้นทาง
5. เรียกใช้แอปพลิเคชัน

import aiohttp
from aiohttp import web
import asyncio

active_websockets = set()

async def websocket_handler(request):
    ws = web.WebSocketResponse()
    await ws.prepare(request)
    
    active_websockets.add(ws)
    
    try:
        async for msg in ws:
            if msg.type == aiohttp.WSMsgType.TEXT:
                for client in active_websockets:
                    if client != ws:
                        await client.send_str(f"User{id(ws)}: {msg.data}")
            elif msg.type == aiohttp.WSMsgType.ERROR:
                print(f"WebSocket connection closed with exception {ws.exception()}")
    finally:
        active_websockets.remove(ws)
    
    return ws

app = web.Application()
app.add_routes([web.get('/ws', websocket_handler)])

if __name__ == '__main__':
    web.run_app(app)

ในการทดสอบเซิร์ฟเวอร์ websocket นี้ คุณสามารถใช้ไคลเอนต์ websocket หรือสร้างหน้า HTML อย่างง่ายด้วย JavaScript เพื่อเชื่อมต่อกับเซิร์ฟเวอร์

ตัวอย่างเหล่านี้แสดงให้เห็นถึงแง่มุมต่างๆ ของ aiohttp ตั้งแต่การส่งคำขอแบบอะซิงโครนัสไปจนถึงการสร้างเว็บเซิร์ฟเวอร์และการจัดการ websockets พวกเขาให้รากฐานที่มั่นคงสำหรับการสร้างแอปพลิเคชันที่ซับซ้อนมากขึ้นโดยใช้ไลบรารีอันทรงพลังนี้

สรุป

ในโลกที่ขับเคลื่อนด้วยข้อมูลในปัจจุบัน ความเร็วมีความสำคัญ และความสามารถในการจัดการงานจำนวนมากพร้อมกันสามารถให้ข้อได้เปรียบแก่คุณได้ aiohttp เป็นเครื่องมือที่ต้องมีในชุดเครื่องมือ Python ของคุณ หากคุณกำลังจัดการกับการขูดเว็บ คำขอ API หรืองานอื่นๆ ที่ต้องส่งคำขอ HTTP จำนวนมาก

ด้วยการทำแบบอะซิงโครนัส คุณไม่เพียงแต่ประหยัดเวลาเท่านั้น แต่ยังทำให้โค้ดของคุณมีประสิทธิภาพและปรับขนาดได้มากขึ้น
ดังนั้น หากคุณกำลังมองที่จะนำคำขอเว็บ Python ของคุณไปสู่อีกระดับ ลองใช้ aiohttp

คุณจะเห็นได้อย่างรวดเร็วว่าทำไมมันถึงเป็นตัวเลือกยอดนิยมในหมู่นักพัฒนาที่จัดการกับแอปพลิเคชันที่ใช้ I/O หนัก

คุณพบว่าหน้านี้มีประโยชน์หรือไม่? ฉันหวังว่านี่จะเป็นวัสดุที่สมบูรณ์มากสำหรับคุณ!
ขอให้คุณโชคดีที่สุด!