பைத்தான் கோரூட்டீன் பிழைத்திருத்தம்: அசிங்கியோ பிழைத்திருத்த பயன்முறையில் தேர்ச்சி பெறுதல்

இந்த எச்சரிக்கைகள் வளக் கசிவுகளைக் கண்டறிந்து சரிசெய்ய உதவுகின்றன, இது செயல்திறன் குறைவதற்கும் கணினி ஸ்திரத்தன்மைக்கும் வழிவகுக்கும்.

4. மெதுவான கால்பேக் கண்டறிதல்

பிழைத்திருத்த பயன்முறை ஒரு குறிப்பிட்ட வரம்பை விட அதிக நேரம் எடுக்கும் கால்பேக்குகளைக் கண்டறிய முடியும். இது செயல்திறன் தடங்கல்களைக் கண்டறிய உதவுகிறது:

            asyncio | Task was destroyed but it is pending!
pending time: 12345.678 ms

            

              
                Copy
              
            
          

5. விதிவிலக்கு கையாளுதல்

பிழைத்திருத்த பயன்முறை கோரூட்டீன்களுக்குள் எழுப்பப்படும் விதிவிலக்குகளுக்கு, விதிவிலக்கு ஏற்பட்ட டாஸ்க் மற்றும் கோரூட்டீன் உட்பட கூடுதல் சூழலை வழங்குகிறது:

            asyncio | Task exception was never retrieved
future: () done, raised ValueError('Invalid value')>
            

              
                Copy
              
            
          

இந்த வெளியீடு Task-1 இல் ஒரு ValueError எழுப்பப்பட்டது மற்றும் அது சரியாகக் கையாளப்படவில்லை என்பதைக் குறிக்கிறது.

அசிங்கியோ பிழைத்திருத்த பயன்முறையுடன் பிழைத்திருத்தம் செய்வதற்கான நடைமுறை எடுத்துக்காட்டுகள்

பொதுவான சிக்கல்களைக் கண்டறிய asyncio பிழைத்திருத்த பயன்முறையை எவ்வாறு பயன்படுத்துவது என்பதற்கான சில நடைமுறை எடுத்துக்காட்டுகளைப் பார்ப்போம்:

1. மூடப்படாத சாக்கெட்டுகளைக் கண்டறிதல்

ஒரு சாக்கெட்டை உருவாக்கி ஆனால் அதைச் சரியாக மூடாத பின்வரும் குறியீட்டைக் கவனியுங்கள்:

            import asyncio
import socket

async def handle_client(reader, writer):
    data = await reader.read(100)
    message = data.decode()
    addr = writer.get_extra_info('peername')
    print(f"Received {message!r} from {addr!r}")

    print(f"Send: {message!r}")
    writer.write(data)
    await writer.drain()

    # Missing: writer.close()

async def main():
    server = await asyncio.start_server(
        handle_client,
        '127.0.0.1',
        8888
    )

    addr = server.sockets[0].getsockname()
    print(f'Serving on {addr}')

    async with server:
        await server.serve_forever()

if __name__ == "__main__":
    asyncio.run(main(), debug=True)
            

              
                Copy
              
            
          

இந்தக் குறியீட்டை பிழைத்திருத்த பயன்முறையில் இயக்கும்போது, மூடப்படாத சாக்கெட்டைக் குறிக்கும் ResourceWarning ஐப் பார்ப்பீர்கள்:

            ResourceWarning: unclosed 
            

              
                Copy
              
            
          

இதைச் சரிசெய்ய, சாக்கெட் சரியாக மூடப்பட்டிருப்பதை உறுதி செய்ய வேண்டும், எடுத்துக்காட்டாக, handle_client கோரூட்டீனில் writer.close() ஐச் சேர்த்து, அதற்காகக் காத்திருக்க வேண்டும்:

                writer.close()
    await writer.wait_closed()
            

              
                Copy
              
            
          

2. மெதுவான கால்பேக்குகளைக் கண்டறிதல்

ஒரு மெதுவான செயல்பாட்டைச் செய்யும் ஒரு கோரூட்டீன் உங்களிடம் இருப்பதாக வைத்துக்கொள்வோம்:

            import asyncio
import time

async def slow_function():
    print("Starting slow function")
    time.sleep(2)
    print("Slow function finished")
    return "Result"

async def main():
    task = asyncio.create_task(slow_function())
    result = await task
    print(f"Result: {result}")

if __name__ == "__main__":
    asyncio.run(main(), debug=True)
            

              
                Copy
              
            
          

இயல்பான பிழைத்திருத்த வெளியீடு மெதுவான கால்பேக்குகளை நேரடியாகக் குறிப்பிடவில்லை என்றாலும், கவனமாகப் பதிவிடுதல் மற்றும் cProfile அல்லது py-spy போன்ற சுயவிவரக் கருவிகளுடன் அதை இணைப்பது உங்கள் குறியீட்டின் மெதுவான பகுதிகளைக் குறைக்க உங்களை அனுமதிக்கிறது. மெதுவான செயல்பாடுகளுக்கு முன்னும் பின்னும் நேரமுத்திரைகளைப் பதிவு செய்வதைக் கவனியுங்கள். பின்னர் cProfile போன்ற கருவிகளை பதிவுசெய்யப்பட்ட செயல்பாட்டு அழைப்புகளில் பயன்படுத்தி தடங்கல்களைத் தனிமைப்படுத்தலாம்.

3. டாஸ்க் ரத்துசெய்தலை பிழைத்திருத்தம் செய்தல்

ஒரு டாஸ்க் எதிர்பாராதவிதமாக ரத்து செய்யப்படும் சூழ்நிலையைக் கவனியுங்கள்:

            import asyncio

async def worker():
    try:
        while True:
            print("Working...")
            await asyncio.sleep(0.5)
    except asyncio.CancelledError:
        print("Worker cancelled")

async def main():
    task = asyncio.create_task(worker())
    await asyncio.sleep(2)
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        print("Task cancelled in main")

if __name__ == "__main__":
    asyncio.run(main(), debug=True)
            

              
                Copy
              
            
          

பிழைத்திருத்த வெளியீடு டாஸ்க் ரத்து செய்யப்படுவதைக் காண்பிக்கும்:

            asyncio | execute  started at example.py:16>
Working...
Working...
Working...
Working...
asyncio | Task-1: cancelling
Worker cancelled
asyncio | Task-1: cancelled by  result=None>
Task cancelled in main
            

              
                Copy
              
            
          

இது டாஸ்க் main() கோரூட்டீனால் ரத்து செய்யப்பட்டது என்பதை உறுதிப்படுத்துகிறது. except asyncio.CancelledError தொகுதி, டாஸ்க் முழுமையாக நிறுத்தப்படுவதற்கு முன்பு சுத்தம் செய்ய அனுமதிக்கிறது, வளக் கசிவுகள் அல்லது சீரற்ற நிலையைத் தடுக்கிறது.

4. கோரூட்டீன்களில் விதிவிலக்குகளைக் கையாளுதல்

ஒத்திசைவற்ற குறியீட்டில் சரியான விதிவிலக்கு கையாளுதல் மிகவும் முக்கியமானது. கையாளப்படாத விதிவிலக்குடன் பின்வரும் எடுத்துக்காட்டைக் கவனியுங்கள்:

            import asyncio

async def divide(x, y):
    return x / y

async def main():
    result = await divide(10, 0)
    print(f"Result: {result}")

if __name__ == "__main__":
    asyncio.run(main(), debug=True)
            

              
                Copy
              
            
          

பிழைத்திருத்த பயன்முறை கையாளப்படாத விதிவிலக்கைப் புகாரளிக்கும்:

            asyncio | Task exception was never retrieved
future:  result=None, exception=ZeroDivisionError('division by zero')>
            

              
                Copy
              
            
          

இந்த விதிவிலக்கைக் கையாள, நீங்கள் try...except தொகுதியைப் பயன்படுத்தலாம்:

            import asyncio

async def divide(x, y):
    return x / y

async def main():
    try:
        result = await divide(10, 0)
        print(f"Result: {result}")
    except ZeroDivisionError as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    asyncio.run(main(), debug=True)
            

              
                Copy
              
            
          

இப்போது, விதிவிலக்கு பிடிக்கப்பட்டு நேர்த்தியாகக் கையாளப்படும்.

அசிங்கியோ பிழைத்திருத்தத்திற்கான சிறந்த நடைமுறைகள்

asyncio குறியீட்டை பிழைத்திருத்தம் செய்வதற்கான சில சிறந்த நடைமுறைகள் இங்கே:

• பிழைத்திருத்த பயன்முறையை இயக்கவும்: மேம்பாடு மற்றும் சோதனையின் போது எப்போதும் பிழைத்திருத்த பயன்முறையை இயக்கவும்.
• பதிவிடுதலைப் பயன்படுத்தவும்: உங்கள் கோரூட்டீன்களின் செயலாக்க ஓட்டத்தைக் கண்காணிக்க விரிவான பதிவிடுதலைச் சேர்க்கவும். அசிங்கியோ குறிப்பிட்ட நிகழ்வுகளுக்கு logging.getLogger('asyncio') ஐப் பயன்படுத்தவும், மற்றும் பயன்பாடு சார்ந்த தரவுகளுக்கு உங்கள் சொந்த பதிப்பான்களைப் பயன்படுத்தவும்.
• விதிவிலக்குகளைக் கையாளவும்: கையாளப்படாத விதிவிலக்குகள் உங்கள் பயன்பாட்டை செயலிழக்கச் செய்வதைத் தடுக்க வலுவான விதிவிலக்கு கையாளுதலைச் செயல்படுத்தவும்.
• டாஸ்க் குழுக்களைப் பயன்படுத்தவும் (Python 3.11+): டாஸ்க் குழுக்கள் தொடர்புடைய டாஸ்க்குகளின் குழுக்களுக்குள் விதிவிலக்கு கையாளுதல் மற்றும் ரத்துசெய்வதை எளிதாக்குகின்றன.
• உங்கள் குறியீட்டை சுயவிவரப்படுத்தவும்: செயல்திறன் தடங்கல்களைக் கண்டறிய சுயவிவரக் கருவிகளைப் பயன்படுத்தவும்.
• யூனிட் சோதனைகளை எழுதவும்: உங்கள் கோரூட்டீன்களின் நடத்தையைச் சரிபார்க்க முழுமையான யூனிட் சோதனைகளை எழுதவும்.
• வகை குறிப்புகளைப் பயன்படுத்தவும்: வகை தொடர்பான பிழைகளை முன்கூட்டியே பிடிக்க வகை குறிப்புகளைப் பயன்படுத்தவும்.
• ஒரு பிழைத்திருத்தியைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்: `pdb` அல்லது IDE பிழைத்திருத்திகள் போன்ற கருவிகளை அசிங்கியோ குறியீட்டின் வழியாகச் செல்லப் பயன்படுத்தலாம். இருப்பினும், ஒத்திசைவற்ற செயலாக்கத்தின் தன்மை காரணமாக கவனமாகப் பதிவிடுதலுடன் கூடிய பிழைத்திருத்த பயன்முறையை விட அவை பெரும்பாலும் குறைவான செயல்திறன் கொண்டவை.

மேம்பட்ட பிழைத்திருத்த நுட்பங்கள்

அடிப்படை பிழைத்திருத்த பயன்முறைக்கு அப்பால், இந்த மேம்பட்ட நுட்பங்களைக் கருத்தில் கொள்ளுங்கள்:

1. தனிப்பயன் நிகழ்வு வளையக் கொள்கைகள்

நிகழ்வுகளை இடைமறித்து பதிவு செய்ய நீங்கள் தனிப்பயன் நிகழ்வு வளையக் கொள்கைகளை உருவாக்கலாம். இது பிழைத்திருத்த செயல்முறையின் மீது இன்னும் நுணுக்கமான கட்டுப்பாட்டைப் பெற உங்களை அனுமதிக்கிறது.

2. மூன்றாம் தரப்பு பிழைத்திருத்த கருவிகளைப் பயன்படுத்துதல்

பல மூன்றாம் தரப்பு பிழைத்திருத்த கருவிகள் asyncio குறியீட்டை பிழைத்திருத்தம் செய்ய உங்களுக்கு உதவக்கூடும், அவை:

• PySnooper: உங்கள் குறியீட்டின் செயலாக்கத்தை தானாகவே பதிவு செய்யும் ஒரு சக்திவாய்ந்த பிழைத்திருத்த கருவி.
• pdb++: மேம்பட்ட அம்சங்களுடன் கூடிய நிலையான pdb பிழைத்திருத்தியின் மேம்படுத்தப்பட்ட பதிப்பு.
• asyncio_inspector: அசிங்கியோ நிகழ்வு வளையங்களை ஆய்வு செய்வதற்காக பிரத்யேகமாக வடிவமைக்கப்பட்ட ஒரு நூலகம்.

3. மங்கி பேட்சிங் (கவனத்துடன் பயன்படுத்தவும்)

தீவிரமான சந்தர்ப்பங்களில், பிழைத்திருத்த நோக்கங்களுக்காக asyncio செயல்பாடுகளின் நடத்தையை மாற்ற நீங்கள் மங்கி பேட்சிங்கைப் பயன்படுத்தலாம். இருப்பினும், இது கவனமாக செய்யப்பட வேண்டும், ஏனெனில் இது நுட்பமான பிழைகளை அறிமுகப்படுத்தலாம் மற்றும் உங்கள் குறியீட்டைப் பராமரிப்பதை கடினமாக்கலாம். இது முற்றிலும் அவசியமானாலன்றி பொதுவாக ஊக்கப்படுத்தப்படுவதில்லை.

முடிவுரை

ஒத்திசைவற்ற குறியீட்டை பிழைத்திருத்தம் செய்வது சவாலானதாக இருக்கலாம், ஆனால் asyncio பிழைத்திருத்த பயன்முறை செயல்முறையை எளிதாக்க மதிப்புமிக்க கருவிகள் மற்றும் நுண்ணறிவுகளை வழங்குகிறது. பிழைத்திருத்த பயன்முறையை இயக்குவதன் மூலமும், வெளியீட்டை விளக்குவதன் மூலமும், சிறந்த நடைமுறைகளைப் பின்பற்றுவதன் மூலமும், உங்கள் ஒத்திசைவற்ற பயன்பாடுகளில் பொதுவான சிக்கல்களைத் திறம்படக் கண்டறிந்து தீர்க்க முடியும், இது மிகவும் வலுவான மற்றும் செயல்திறன் மிக்க குறியீட்டிற்கு வழிவகுக்கும். சிறந்த முடிவுகளுக்கு பிழைத்திருத்த பயன்முறையை பதிவிடுதல், சுயவிவரப்படுத்துதல் மற்றும் முழுமையான சோதனை ஆகியவற்றுடன் இணைக்க நினைவில் கொள்ளுங்கள். பயிற்சி மற்றும் சரியான கருவிகளுடன், நீங்கள் asyncio கோரூட்டீன்களை பிழைத்திருத்தம் செய்யும் கலையில் தேர்ச்சி பெறலாம் மற்றும் அளவிடக்கூடிய, திறமையான மற்றும் நம்பகமான ஒத்திசைவற்ற பயன்பாடுகளை உருவாக்கலாம்.