Python 3.7 - traceback

ट्रेसबैक - स्टैक ट्रेसबैक को प्रिंट करें या पुनः प्राप्त करें




python

ट्रेसबैक - स्टैक ट्रेसबैक को प्रिंट करें या पुनः प्राप्त करें

स्रोत कोड: Lib/traceback.py

यह मॉड्यूल पायथन कार्यक्रमों के स्टैक ट्रैस को निकालने, प्रारूपित करने और प्रिंट करने के लिए एक मानक इंटरफ़ेस प्रदान करता है। यह बिल्कुल पायथन दुभाषिया के व्यवहार की नकल करता है जब यह एक स्टैक ट्रेस को प्रिंट करता है। यह उपयोगी है जब आप प्रोग्राम कंट्रोल के तहत स्टैक के निशान को प्रिंट करना चाहते हैं, जैसे कि दुभाषिया के चारों ओर "आवरण"।

मॉड्यूल ट्रेसबैक ऑब्जेक्ट का उपयोग करता है - यह ऑब्जेक्ट प्रकार है जिसे sys.last_traceback चर में संग्रहीत किया जाता है और sys.exc_info() से तीसरे आइटम के रूप में लौटाया जाता है।

मॉड्यूल निम्नलिखित कार्यों को परिभाषित करता है:

traceback.print_tb(tb, limit=None, file=None)

यदि सीमा सकारात्मक है, तो ट्रेसबैक ऑब्जेक्ट टीबी (कॉलर के फ्रेम से शुरू) से स्टैक ट्रेस प्रविष्टियों को सीमित करने के लिए प्रिंट करें। अन्यथा, अंतिम abs(limit) प्रविष्टियों को प्रिंट करें। यदि सीमा को छोड़ दिया गया है या None , तो सभी प्रविष्टियां मुद्रित हैं। यदि फ़ाइल को छोड़ दिया गया है या None , तो आउटपुट sys.stderr जाता है; अन्यथा यह आउटपुट प्राप्त करने के लिए एक खुली फ़ाइल या फ़ाइल जैसी वस्तु होनी चाहिए।

संस्करण 3.5 में परिवर्तित: नकारात्मक सीमा समर्थन जोड़ा गया।

traceback.print_exception(etype, value, tb, limit=None, file=None, chain=True)

अपवाद जानकारी प्रिंट करें और ट्रेसबैक ऑब्जेक्ट टीबी से फाइल में ट्रेस ट्रेस प्रविष्टियां। यह निम्नलिखित तरीकों से print_tb() से भिन्न होता है:

  • अगर tb कोई None , तो यह एक शीर्ष लेख Traceback (most recent call last): प्रिंट करता है Traceback (most recent call last):
  • यह स्टैक ट्रेस के बाद अपवाद etype और मान प्रिंट करता है
  • यदि टाइप (मान) SyntaxError और मान का उपयुक्त प्रारूप है, तो यह उस रेखा को प्रिंट करता है जहां वाक्य रचना में त्रुटि के साथ अनुमानित त्रुटि का संकेत होता है।

वैकल्पिक सीमा तर्क का print_tb() लिए समान अर्थ है। यदि श्रृंखला सत्य है (डिफ़ॉल्ट), तो जंजीरों के अपवाद ( __cause__ या __context__ अपवाद की विशेषताएँ) को भी मुद्रित किया जाएगा, जैसे दुभाषिया अपवाद को प्रिंट करते समय दुभाषिया खुद करता है।

संस्करण 3.5 में बदला गया: etype तर्क को अनदेखा किया गया है और मूल्य के प्रकार से अनुमान लगाया गया है।

traceback.print_exc(limit=None, file=None, chain=True)

यह print_exception(*sys.exc_info(), limit, file, chain) लिए एक शॉर्टहैंड है।

traceback.print_last(limit=None, file=None, chain=True)

यह print_exception(sys.last_type, sys.last_value, sys.last_traceback, limit, file, chain) लिए एक शॉर्टहैंड है। सामान्य तौर पर यह एक इंटरेक्टिव प्रॉम्प्ट ( sys.last_type देखें) तक पहुंचने के बाद ही काम करेगा।

traceback.print_stack(f=None, limit=None, file=None)

यदि सीमा सकारात्मक है, तो स्टैक ट्रेस प्रविष्टियों को सीमित करने के लिए प्रिंट करें (मंगलाचरण बिंदु से शुरू)। अन्यथा, अंतिम abs(limit) प्रविष्टियों को प्रिंट करें। यदि सीमा को छोड़ दिया गया है या None , तो सभी प्रविष्टियां मुद्रित हैं। वैकल्पिक f तर्क का उपयोग वैकल्पिक स्टैक फ्रेम को शुरू करने के लिए निर्दिष्ट करने के लिए किया जा सकता है। वैकल्पिक फ़ाइल तर्क का print_tb() लिए समान अर्थ है।

संस्करण 3.5 में परिवर्तित: नकारात्मक सीमा समर्थन जोड़ा गया।

traceback.extract_tb(tb, limit=None)

एक StackSummary ऑब्जेक्ट लौटें जो ट्रेसबैक ऑब्जेक्ट tb से निकाली गई "पूर्व-संसाधित" स्टैक ट्रेस प्रविष्टियों की सूची का प्रतिनिधित्व करता है। यह स्टैक निशान के वैकल्पिक स्वरूपण के लिए उपयोगी है। वैकल्पिक सीमा तर्क का print_tb() लिए समान अर्थ है। "प्री-प्रोसेस्ड" स्टैक ट्रेस प्रविष्टि एक FrameSummary ऑब्जेक्ट है, जिसमें आमतौर पर स्टैक ट्रेस के लिए मुद्रित की जाने वाली जानकारी का प्रतिनिधित्व करने वाले filename , lineno , name और line होती है। line एक स्ट्रिंग है जिसमें प्रमुख और पीछे वाले व्हाट्सएप को पीछे छोड़ दिया जाता है; यदि स्रोत उपलब्ध नहीं है तो यह None

traceback.extract_stack(f=None, limit=None)

वर्तमान स्टैक फ्रेम से कच्चे ट्रेसबैक निकालें। वापसी मान में extract_tb() के समान प्रारूप है। वैकल्पिक f और सीमा तर्क का एक ही अर्थ है जैसे कि print_stack()

traceback.format_list(extracted_list)

FrameSummary या FrameSummary वस्तुओं की एक सूची को देखते हुए, जैसा कि extract_tb() या extract_stack() द्वारा लौटाया गया है, छपाई के लिए तैयार तार की सूची extract_stack() । परिणामी सूची में प्रत्येक स्ट्रिंग तर्क सूची में समान सूचकांक के साथ आइटम से मेल खाती है। प्रत्येक स्ट्रिंग एक नई रेखा में समाप्त होती है; स्ट्रिंग में आंतरिक न्यूलाइन्स भी हो सकते हैं, उन वस्तुओं के लिए जिनकी स्रोत टेक्स्ट लाइन कोई None

traceback.format_exception_only(etype, value)

ट्रेसबैक के अपवाद भाग का फ़ॉर्मेट। तर्क अपवाद प्रकार और मूल्य हैं जैसे कि sys.last_type और sys.last_value द्वारा दिए गए हैं। वापसी मूल्य स्ट्रिंग्स की एक सूची है, प्रत्येक एक नई पंक्ति में समाप्त होता है। आम तौर पर, सूची में एक ही तार होता है; हालाँकि, SyntaxError अपवादों के लिए, इसमें कई पंक्तियाँ होती हैं जो (जब मुद्रित होती हैं) विस्तृत जानकारी प्रदर्शित करती हैं कि वाक्य रचना त्रुटि कहाँ हुई। यह संदेश कि कौन सा अपवाद हुआ, सूची में हमेशा अंतिम स्ट्रिंग है।

traceback.format_exception(etype, value, tb, limit=None, chain=True)

स्टैक ट्रेस और अपवाद जानकारी स्वरूपित करें। तर्कों का वही अर्थ है जो print_exception() के संगत तर्कों के रूप में है। वापसी मूल्य स्ट्रिंग्स की एक सूची है, प्रत्येक एक नई पंक्ति में समाप्त होता है और कुछ में आंतरिक न्यूलाइन्स होते हैं। जब इन पंक्तियों को print_exception() और मुद्रित किया जाता है, तो ठीक उसी तरह का पाठ मुद्रित किया जाता है जैसे कि print_exception()

संस्करण 3.5 में बदला गया: etype तर्क को अनदेखा किया गया है और मूल्य के प्रकार से अनुमान लगाया गया है।

traceback.format_exc(limit=None, chain=True)

यह print_exc(limit) तरह है, लेकिन एक फ़ाइल को प्रिंट करने के बजाय एक स्ट्रिंग देता है।

traceback.format_tb(tb, limit=None)

format_list(extract_tb(tb, limit)) लिए एक शॉर्टहैंड।

traceback.format_stack(f=None, limit=None)

format_list(extract_stack(f, limit)) लिए एक शॉर्टहैंड।

traceback.clear_frames(tb)

प्रत्येक फ्रेम ऑब्जेक्ट की clear() विधि को कॉल करके ट्रेसबैक टीबी में सभी स्टैक फ्रेम के स्थानीय चर को साफ करता है।

संस्करण 3.4 में नया।

traceback.walk_stack(f)

दिए गए फ्रेम से f.f_back बाद एक स्टैक को f.f_back , प्रत्येक फ्रेम के लिए फ्रेम और लाइन नंबर की पैदावार करें। यदि एफ None , तो वर्तमान स्टैक का उपयोग किया जाता है। इस सहायक का उपयोग StackSummary.extract() साथ किया जाता है।

संस्करण 3.5 में नया।

traceback.walk_tb(tb)

प्रत्येक फ्रेम के लिए फ्रेम और लाइन नंबर उपज tb_next बाद एक ट्रेसबैक tb_next । इस सहायक का उपयोग StackSummary.extract() साथ किया जाता है।

संस्करण 3.5 में नया।

मॉड्यूल निम्नलिखित वर्गों को भी परिभाषित करता है:

TracebackException ऑब्जेक्ट

संस्करण 3.5 में नया।

TracebackException ऑब्जेक्ट को वास्तविक अपवादों से बनाया गया है ताकि बाद में मुद्रण के लिए डेटा को हल्के अंदाज में कैप्चर किया जा सके।

class traceback.TracebackException(exc_type, exc_value, exc_traceback, *, limit=None, lookup_lines=True, capture_locals=False)

बाद में प्रतिपादन के लिए एक अपवाद पर कब्जा। StackSummary वर्ग के लिए सीमा , लुकअप_लाइंस और कैप्चर_लोकल्स हैं।

ध्यान दें कि जब स्थानीय लोगों को पकड़ लिया जाता है, तो उन्हें ट्रेसबैक में भी दिखाया जाता है।

__cause__

मूल __cause__ का एक __cause__

__context__

मूल __context__ का एक __context__

__suppress_context__

मूल अपवाद से __suppress_context__ मान।

stack

एक StackSummary ट्रेसबैक का प्रतिनिधित्व करता है।

exc_type

मूल ट्रेसबैक की श्रेणी।

filename

सिंटैक्स त्रुटियों के लिए - फ़ाइल नाम जहां त्रुटि हुई।

lineno

वाक्यविन्यास त्रुटियों के लिए - वह पंक्ति संख्या जहाँ त्रुटि हुई।

text

वाक्यविन्यास त्रुटियों के लिए - वह पाठ जहाँ त्रुटि हुई।

offset

सिंटैक्स त्रुटियों के लिए - उस पाठ में ऑफसेट जहां त्रुटि हुई।

msg

सिंटैक्स त्रुटियों के लिए - संकलक त्रुटि संदेश।

classmethod from_exception(exc, *, limit=None, lookup_lines=True, capture_locals=False)

बाद में प्रतिपादन के लिए एक अपवाद पर कब्जा। StackSummary वर्ग के लिए सीमा , लुकअप_लाइंस और कैप्चर_लोकल्स हैं।

ध्यान दें कि जब स्थानीय लोगों को पकड़ लिया जाता है, तो उन्हें ट्रेसबैक में भी दिखाया जाता है।

format(*, chain=True)

अपवाद स्वरूप।

यदि श्रृंखला True नहीं है, तो __cause__ और __context__ को प्रारूपित नहीं किया जाएगा।

वापसी मूल्य स्ट्रिंग्स का एक जनरेटर है, प्रत्येक एक नई रेखा में समाप्त होता है और कुछ में आंतरिक न्यूलाइन्स होते हैं। print_exception() इस विधि के चारों ओर एक आवरण है जो बस लाइनों को एक फ़ाइल में प्रिंट करता है।

यह दर्शाता है कि कौन सा अपवाद हुआ, यह आउटपुट में अंतिम स्ट्रिंग है।

format_exception_only()

ट्रेसबैक के अपवाद भाग को प्रारूपित करें।

वापसी मूल्य स्ट्रिंग्स का एक जनरेटर है, प्रत्येक एक नई रेखा में समाप्त होता है।

आम तौर पर, जनरेटर एक स्ट्रिंग का उत्सर्जन करता है; हालाँकि, SyntaxError अपवादों के लिए, यह कई पंक्तियों का उत्सर्जन करता है जो (जब मुद्रित) सिंटैक्स त्रुटि हुई के बारे में विस्तृत जानकारी प्रदर्शित करता है।

यह दर्शाता है कि कौन सा अपवाद हुआ, यह आउटपुट में अंतिम स्ट्रिंग है।

StackSummary ऑब्जेक्ट्स

संस्करण 3.5 में नया।

StackSummary ऑब्जेक्ट स्वरूपण के लिए तैयार कॉल स्टैक का प्रतिनिधित्व करते हैं।

class traceback.StackSummary
classmethod extract(frame_gen, *, limit=None, lookup_lines=True, capture_locals=False)

फ़्रेम जनरेटर से एक StackSummary ऑब्जेक्ट का निर्माण (जैसे कि walk_stack() या walk_tb() ) द्वारा लौटाया गया है।

यदि सीमा की आपूर्ति की जाती है, तो यह केवल कई फ्रेम फ्रेम_जेन से लिया जाता है। यदि लुकअप_लाइन्स False , तो लौटे FrameSummary ऑब्जेक्ट्स ने अभी तक अपनी लाइनों को नहीं पढ़ा होगा, जिससे StackSummary बनाने की लागत सस्ती हो जाएगी (जो कि मूल्यवान हो सकती है अगर यह वास्तव में स्वरूपित नहीं हो सकती है)। यदि FrameSummary True , तो प्रत्येक FrameSummary में स्थानीय चर ऑब्जेक्ट प्रतिनिधित्व के रूप में कैप्चर FrameSummary जाते हैं।

classmethod from_list(a_list)

FrameSummary ऑब्जेक्ट्स या FrameSummary पुरानी-शैली सूची की आपूर्ति की गई सूची से एक StackSummary ऑब्जेक्ट का निर्माण करें। प्रत्येक टपल को तत्वों के रूप में फाइलनाम, लिनेनो, नाम, रेखा के साथ एक 4-ट्यूपल होना चाहिए।

format()

मुद्रण के लिए तैयार तार की एक सूची देता है। परिणामी सूची में प्रत्येक स्ट्रिंग स्टैक से एकल फ्रेम से मेल खाती है। प्रत्येक स्ट्रिंग एक नई रेखा में समाप्त होती है; स्रोत टेक्स्ट लाइनों के साथ उन आइटमों के लिए स्ट्रिंग्स में आंतरिक रूप से अच्छी तरह से हो सकता है।

एक ही फ्रेम और लाइन के लंबे अनुक्रमों के लिए, पहले कुछ पुनरावृत्तियां दिखाई जाती हैं, इसके बाद एक सारांश रेखा और आगे की पुनरावृत्ति की सटीक संख्या बताती है।

संस्करण 3.6 में परिवर्तित: दोहराए गए फ़्रेम के लंबे अनुक्रम अब संक्षिप्त हैं।

फ़्रेमस्मेररी ऑब्जेक्ट्स

संस्करण 3.5 में नया।

FrameSummary ऑब्जेक्ट एक ट्रेसबैक में एकल फ़्रेम का प्रतिनिधित्व करते हैं।

class traceback.FrameSummary(filename, lineno, name, lookup_line=True, locals=None, line=None)

ट्रेसबैक या स्टैक में एक एकल फ़्रेम का प्रतिनिधित्व करें जो स्वरूपित या मुद्रित किया जा रहा है। वैकल्पिक रूप से इसमें शामिल फ्रेम लोकल का एक कड़ा संस्करण हो सकता है। यदि लुकिंग_लाइन False , तो सोर्स कोड तब तक दिखाई नहीं देता है जब तक कि FrameSummary में line एट्रिब्यूट एक्सेस न हो जाए (जो तब भी होता है जब इसे ट्यूपल में FrameSummary है)। line सीधे प्रदान की जा सकती है, और लाइन लुकिंग को बिल्कुल भी होने से रोकेगी। लोकल एक वैकल्पिक स्थानीय वैरिएबल डिक्शनरी है, और अगर सप्लाई किया गया वैरिएबल रिप्रेजेंटेशन बाद के डिस्प्ले के लिए सारांश में स्टोर किया जाता है।

ट्रेसेबैक उदाहरण

यह साधारण उदाहरण मानक पायथन इंटरएक्टिव इंटरप्रेटर लूप के समान (लेकिन इससे कम उपयोगी) एक बुनियादी रीड-इवल-प्रिंट लूप को लागू करता है। दुभाषिया लूप के अधिक पूर्ण कार्यान्वयन के लिए, code मॉड्यूल का संदर्भ लें।

import sys, traceback

def run_user_code(envdir):
    source = input(">>> ")
    try:
        exec(source, envdir)
    except Exception:
        print("Exception in user code:")
        print("-"*60)
        traceback.print_exc(file=sys.stdout)
        print("-"*60)

envdir = {}
while True:
    run_user_code(envdir)

निम्न उदाहरण अपवाद और ट्रेसबैक को प्रिंट करने और प्रारूपित करने के विभिन्न तरीकों को प्रदर्शित करता है:

import sys, traceback

def lumberjack():
    bright_side_of_death()

def bright_side_of_death():
    return tuple()[0]

try:
    lumberjack()
except IndexError:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    print("*** print_tb:")
    traceback.print_tb(exc_traceback, limit=1, file=sys.stdout)
    print("*** print_exception:")
    # exc_type below is ignored on 3.5 and later
    traceback.print_exception(exc_type, exc_value, exc_traceback,
                              limit=2, file=sys.stdout)
    print("*** print_exc:")
    traceback.print_exc(limit=2, file=sys.stdout)
    print("*** format_exc, first and last line:")
    formatted_lines = traceback.format_exc().splitlines()
    print(formatted_lines[0])
    print(formatted_lines[-1])
    print("*** format_exception:")
    # exc_type below is ignored on 3.5 and later
    print(repr(traceback.format_exception(exc_type, exc_value,
                                          exc_traceback)))
    print("*** extract_tb:")
    print(repr(traceback.extract_tb(exc_traceback)))
    print("*** format_tb:")
    print(repr(traceback.format_tb(exc_traceback)))
    print("*** tb_lineno:", exc_traceback.tb_lineno)

उदाहरण के लिए आउटपुट इस तरह दिखेगा:

*** print_tb:
  File "<doctest...>", line 10, in <module>
    lumberjack()
*** print_exception:
Traceback (most recent call last):
  File "<doctest...>", line 10, in <module>
    lumberjack()
  File "<doctest...>", line 4, in lumberjack
    bright_side_of_death()
IndexError: tuple index out of range
*** print_exc:
Traceback (most recent call last):
  File "<doctest...>", line 10, in <module>
    lumberjack()
  File "<doctest...>", line 4, in lumberjack
    bright_side_of_death()
IndexError: tuple index out of range
*** format_exc, first and last line:
Traceback (most recent call last):
IndexError: tuple index out of range
*** format_exception:
['Traceback (most recent call last):\n',
 '  File "<doctest...>", line 10, in <module>\n    lumberjack()\n',
 '  File "<doctest...>", line 4, in lumberjack\n    bright_side_of_death()\n',
 '  File "<doctest...>", line 7, in bright_side_of_death\n    return tuple()[0]\n',
 'IndexError: tuple index out of range\n']
*** extract_tb:
[<FrameSummary file <doctest...>, line 10 in <module>>,
 <FrameSummary file <doctest...>, line 4 in lumberjack>,
 <FrameSummary file <doctest...>, line 7 in bright_side_of_death>]
*** format_tb:
['  File "<doctest...>", line 10, in <module>\n    lumberjack()\n',
 '  File "<doctest...>", line 4, in lumberjack\n    bright_side_of_death()\n',
 '  File "<doctest...>", line 7, in bright_side_of_death\n    return tuple()[0]\n']
*** tb_lineno: 10

निम्न उदाहरण स्टैक को प्रिंट करने और प्रारूपित करने के विभिन्न तरीकों को दिखाता है:

>>> import traceback
>>> def another_function():
...     lumberstack()
...
>>> def lumberstack():
...     traceback.print_stack()
...     print(repr(traceback.extract_stack()))
...     print(repr(traceback.format_stack()))
...
>>> another_function()
  File "<doctest>", line 10, in <module>
    another_function()
  File "<doctest>", line 3, in another_function
    lumberstack()
  File "<doctest>", line 6, in lumberstack
    traceback.print_stack()
[('<doctest>', 10, '<module>', 'another_function()'),
 ('<doctest>', 3, 'another_function', 'lumberstack()'),
 ('<doctest>', 7, 'lumberstack', 'print(repr(traceback.extract_stack()))')]
['  File "<doctest>", line 10, in <module>\n    another_function()\n',
 '  File "<doctest>", line 3, in another_function\n    lumberstack()\n',
 '  File "<doctest>", line 8, in lumberstack\n    print(repr(traceback.format_stack()))\n']

यह अंतिम उदाहरण अंतिम कुछ प्रारूपण कार्यों को प्रदर्शित करता है:

>>> import traceback
>>> traceback.format_list([('spam.py', 3, '<module>', 'spam.eggs()'),
...                        ('eggs.py', 42, 'eggs', 'return "bacon"')])
['  File "spam.py", line 3, in <module>\n    spam.eggs()\n',
 '  File "eggs.py", line 42, in eggs\n    return "bacon"\n']
>>> an_error = IndexError('tuple index out of range')
>>> traceback.format_exception_only(type(an_error), an_error)
['IndexError: tuple index out of range\n']