suchen
HeimBackend-EntwicklungPython-TutorialWas ist das Implementierungsprinzip des Debuggers in der virtuellen Python-Maschine?

Der Debugger ist ein sehr wichtiger Bestandteil einer Programmiersprache. Der Debugger ist ein Tool zur Diagnose und Behebung von Codefehlern (oder Bugs). Er ermöglicht es Entwicklern, den Status und das Verhalten des Codes während der Ausführung des Programms Schritt für Schritt anzuzeigen und zu analysieren ausgeführt wird, was Entwicklern dabei helfen kann, Codefehler zu diagnostizieren und zu beheben, das Programmverhalten zu verstehen und die Leistung zu optimieren. Der Debugger ist in jeder Programmiersprache ein sehr leistungsfähiges Werkzeug und kann die Entwicklungseffizienz und Codequalität verbessern.

Lassen Sie das Programm stoppen

Wenn wir ein Programm debuggen müssen, ist der wichtigste Punkt, dass wir den Status der Programmausführung nur beobachten können, wenn wir das Programm stoppen lassen. Wir müssen die 99-Multiplikationstabelle debuggen:

def m99():
    for i in range(1, 10):
        for j in range(1, i + 1):
            print(f"{i}x{j}={i*j}", end='\t')
        print()


if __name__ == '__main__':
    m99()

Führen Sie nun den Befehl python -m pdb pdbusage.py aus, um das obige Programm zu debuggen:

(py3.8) ➜ pdb_test git:(master) ✗ python -m pdb pdbusage.py
> /Users /xxxx/Desktop /workdir/dive-into-cpython/code/pdb_test/pdbusage.py(3)()
-> def m99():
(Pdb) s
> /Desktop/workdir /dive-into-cpython/code/pdb_test/pdbusage.py(10)()
-> if __name__ == '__main__':
(Pdb) s
> xxxx/Desktop/ workdir/dive-into-cpython/code/pdb_test/pdbusage.py(11)()
-> m99()
(Pdb) s
--Call--
> Users/xxxx/ Desktop/workdir/dive-into-cpython/code/pdb_test/pdbusage.py(3)m99()
-> def m99():
(Pdb) s
> /workdir/dive -into-cpython/code/pdb_test/pdbusage.py(4)m99()
-> für i in range(1, 10):
(Pdb) s
> /workdir/dive -into-cpython/code/pdb_test/pdbusage.py(5)m99()
-> für j in range(1, i + 1):
(Pdb) s
> /Desktop/workdir /dive-into-cpython/code/pdb_test/pdbusage.py(6)m99()
-> print(f"{i}x{j}={i*j}", end=' t')
(Pdb) p i
1
(Pdb)

Natürlich können Sie auch in der IDE debuggen:

Was ist das Implementierungsprinzip des Debuggers in der virtuellen Python-Maschine?

Nach unserer Debugging-Erfahrung ist es leicht zu wissen, dass das Erste und Wichtigste ist Um ein Programm zu debuggen, muss sich das Programm an der Position befinden, an der wir den Haltepunkt festlegen. Es muss in der Lage sein, den Königsmechanismus von Python zu stoppen – die Ablaufverfolgung. Die Frage ist nun, wie stoppt das obige Programm, wenn das Programm ausgeführt wird?

Laut der vorherigen Studie können wir verstehen, dass die Ausführung eines Python-Programms zunächst vom Python-Compiler in Python-Bytecode kompiliert und dann zur Ausführung an die virtuelle Python-Maschine übergeben werden muss, wenn das Programm gestoppt werden muss , Die virtuelle Maschine muss an die obere Ebene gesendet werden. Das Python-Programm stellt eine Schnittstelle bereit, sodass das Programm bei der Ausführung wissen kann, wo es gerade ausgeführt wird. Dieser mysteriöse Mechanismus ist im sys-Modul verborgen. Tatsächlich ist dieses Modul für fast alle Schnittstellen verantwortlich, die wir zur Interaktion mit dem Python-Interpreter verwenden. Eine sehr wichtige Funktion zum Implementieren des Debuggers ist die Funktion sys.settrace. Diese Funktion legt eine Tracking-Funktion für den Thread fest, wenn die virtuelle Maschine eine Codezeile ausführt oder sogar einen Bytecode ausführt wird ausgeführt.

Um einen Python-Quellcode-Debugger zu implementieren, müssen Sie Tracing-Funktionen im System einrichten. Diese Funktion ist threadspezifisch. Um das Multithread-Debugging zu unterstützen, muss für jeden zu debuggenden Thread eine Ablaufverfolgungsfunktion mit settrace() oder threading.settrace() registriert werden.

Die Tracking-Funktion sollte drei Parameter haben: Frame, Event und Argument. Frame ist der aktuelle Stack-Frame. Ereignis ist eine Zeichenfolge: 'call', 'line', 'return', 'Exception', 'opcode', 'c_call' oder 'c_exclusion'. arg hängt vom Ereignistyp ab.

Die Tracking-Funktion wird jedes Mal aufgerufen, wenn ein neuer lokaler Bereich eingegeben wird (Ereignis auf „Aufruf“ gesetzt); sie sollte einen Verweis auf die lokale Tracking-Funktion für den neuen Bereich zurückgeben, oder, falls dies in diesem Bereich nicht gewünscht ist, für die Verfolgung, Es wird keines zurückgegeben.

Wenn in der Trace-Funktion ein Fehler auftritt, wird dieser deaktiviert, genau wie beim Aufruf von settrace(None). Die Bedeutung des -Ereignisses ist wie folgt:

Aufruf, eine Funktion wird aufgerufen (oder es werden andere Codeblöcke eingegeben). Geben Sie beim Aufrufen einer lokalen Trace-Funktion arg als „None“ an und geben Sie die lokale Funktion im Rückgabewert an.

  • Zeile, eine neue Codezeile wird ausgeführt und der Wert des Parameters arg ist None .

  • return, die Funktion (oder ein anderer Codeblock) kehrt gleich zurück. Wenn ein Ereignis durch eine Ausnahme verursacht wird, wird die lokale Ablaufverfolgungsfunktion aufgerufen und gibt den Argumentwert „Keine“ zurück. Rückgabewerte von Trackingfunktionen werden ignoriert.

  • Ausnahme, eine Ausnahme ist aufgetreten. Rufen Sie die lokale Ablaufverfolgungsfunktion auf; arg ist ein Tupel (Ausnahme, Wert, Traceback); der Rückgabewert gibt die neue lokale Ablaufverfolgungsfunktion an.

  • opcode,解释器即将执行新的字节码指令。执行本地追踪函数,arg为空,返回一个新的本地追踪函数。默认情况下,不会发出每个操作码的事件:必须通过在帧上设置 f_trace_opcodes 为 True 来显式请求。

  • c_call,一个 c 函数将要被调用。

  • c_exception,调用 c 函数的时候产生了异常。

自己动手实现一个简单的调试器

我们将在此章节中实现一个简单的调试器,以帮助大家理解调试器的实现原理。调试器的实现代码如下所示,只有短短几十行却可以帮助我们深入去理解调试器的原理,我们先看一下实现的效果在后文当中再去分析具体的实现:

import sys

file = sys.argv[1]
with open(file, "r+") as fp:
    code = fp.read()
lines = code.split("\n")


def do_line(frame, event, arg):
    print("debugging line:", lines[frame.f_lineno - 1])
    return debug


def debug(frame, event, arg):
    if event == "line":
        while True:
            _ = input("(Pdb)")
            if _ == 'n':
                return do_line(frame, event, arg)
            elif _.startswith('p'):
                _, v = _.split()
                v = eval(v, frame.f_globals, frame.f_locals)
                print(v)
            elif _ == 'q':
                sys.exit(0)
    return debug


if __name__ == '__main__':
    sys.settrace(debug)
    exec(code, None, None)
    sys.settrace(None)

在上面的程序当中使用如下:

  • 输入 n 执行一行代码。

  • p name 打印变量 name 。

  • q 退出调试。

现在我们执行上面的程序,进行程序调试:

(py3.10) ➜  pdb_test git:(master) ✗ python mydebugger.py pdbusage.py
(Pdb)n
debugging line: def m99():
(Pdb)n
debugging line: if __name__ == '__main__':
(Pdb)n
debugging line:     m99()
(Pdb)n
debugging line:     for i in range(1, 10):
(Pdb)n
debugging line:         for j in range(1, i + 1):
(Pdb)n
debugging line:             print(f"{i}x{j}={i*j}", end='\t')
1x1=1   (Pdb)n
debugging line:         for j in range(1, i + 1):
(Pdb)p i
1
(Pdb)p j
1
(Pdb)q
(py3.10) ➜  pdb_test git:(master) ✗ 

Was ist das Implementierungsprinzip des Debuggers in der virtuellen Python-Maschine?

可以看到我们的程序真正的被调试起来了。

现在我们来分析一下我们自己实现的简易版本的调试器,在前文当中我们已经提到了 sys.settrace 函数,调用这个函数时需要传递一个函数作为参数,被传入的函数需要接受三个参数:

  • frame,当前正在执行的栈帧。

  • event,事件的类别,这一点在前面的文件当中已经提到了。

  • arg,参数这一点在前面也已经提到了。

  • 同时需要注意的是这个函数也需要有一个返回值,python 虚拟机在下一次事件发生的时候会调用返回的这个函数,如果返回 None 那么就不会在发生事件的时候调用 tracing 函数了,这是代码当中为什么在 debug 返回 debug 的原因。

我们只对 line 这个事件进行处理,然后进行死循环,只有输入 n 指令的时候才会执行下一行,然后打印正在执行的行,这个时候就会退出函数 debug ,程序就会继续执行了。python 内置的 eval 函数可以获取变量的值。

python 官方调试器源码分析

python 官方的调试器为 pdb 这个是 python 标准库自带的,我们可以通过 python -m pdb xx.py 去调试文件 xx.py 。这里我们只分析核心代码:

代码位置:bdp.py 下面的 Bdb 类

    def run(self, cmd, globals=None, locals=None):
        """Debug a statement executed via the exec() function.

        globals defaults to __main__.dict; locals defaults to globals.
        """
        if globals is None:
            import __main__
            globals = __main__.__dict__
        if locals is None:
            locals = globals
        self.reset()
        if isinstance(cmd, str):
            cmd = compile(cmd, "<string>", "exec")
        sys.settrace(self.trace_dispatch)
        try:
            exec(cmd, globals, locals)
        except BdbQuit:
            pass
        finally:
            self.quitting = True
            sys.settrace(None)

上面的函数主要是使用 sys.settrace 函数进行 tracing 操作,当有事件发生的时候就能够捕捉了。在上面的代码当中 tracing 函数为 self.trace_dispatch 我们再来看这个函数的代码:

    def trace_dispatch(self, frame, event, arg):
        """Dispatch a trace function for debugged frames based on the event.

        This function is installed as the trace function for debugged
        frames. Its return value is the new trace function, which is
        usually itself. The default implementation decides how to
        dispatch a frame, depending on the type of event (passed in as a
        string) that is about to be executed.

        The event can be one of the following:
            line: A new line of code is going to be executed.
            call: A function is about to be called or another code block
                  is entered.
            return: A function or other code block is about to return.
            exception: An exception has occurred.
            c_call: A C function is about to be called.
            c_return: A C function has returned.
            c_exception: A C function has raised an exception.

        For the Python events, specialized functions (see the dispatch_*()
        methods) are called.  For the C events, no action is taken.

        The arg parameter depends on the previous event.
        """
        if self.quitting:
            return # None
        if event == &#39;line&#39;:
            print("In line")
            return self.dispatch_line(frame)
        if event == &#39;call&#39;:
            print("In call")
            return self.dispatch_call(frame, arg)
        if event == &#39;return&#39;:
            print("In return")
            return self.dispatch_return(frame, arg)
        if event == &#39;exception&#39;:
            print("In execption")
            return self.dispatch_exception(frame, arg)
        if event == &#39;c_call&#39;:
            print("In c_call")
            return self.trace_dispatch
        if event == &#39;c_exception&#39;:
            print("In c_exception")
            return self.trace_dispatch
        if event == &#39;c_return&#39;:
            print("In c_return")
            return self.trace_dispatch
        print(&#39;bdb.Bdb.dispatch: unknown debugging event:&#39;, repr(event))
        return self.trace_dispatch

从上面的代码当中可以看到每一种事件都有一个对应的处理函数,在本文当中我们主要分析 函数 dispatch_line,这个处理 line 事件的函数。

    def dispatch_line(self, frame):
        """Invoke user function and return trace function for line event.

        If the debugger stops on the current line, invoke
        self.user_line(). Raise BdbQuit if self.quitting is set.
        Return self.trace_dispatch to continue tracing in this scope.
        """
        if self.stop_here(frame) or self.break_here(frame):
            self.user_line(frame)
            if self.quitting: raise BdbQuit
        return self.trace_dispatch

这个函数首先会判断是否需要在当前行停下来,如果需要停下来就需要进入 user_line 这个函数,后面的调用链函数比较长,我们直接看最后执行的函数,根据我们使用 pdb 的经验来看,最终肯定是一个 while 循环让我们可以不断的输入指令进行处理:

    def cmdloop(self, intro=None):
        """Repeatedly issue a prompt, accept input, parse an initial prefix
        off the received input, and dispatch to action methods, passing them
        the remainder of the line as argument.

        """
        print("In cmdloop")
        self.preloop()
        if self.use_rawinput and self.completekey:
            try:
                import readline
                self.old_completer = readline.get_completer()
                readline.set_completer(self.complete)
                readline.parse_and_bind(self.completekey+": complete")
            except ImportError:
                pass
        try:
            if intro is not None:
                self.intro = intro
            print(f"{self.intro = }")
            if self.intro:
                self.stdout.write(str(self.intro)+"\n")
            stop = None
            while not stop:
                print(f"{self.cmdqueue = }")
                if self.cmdqueue:
                    line = self.cmdqueue.pop(0)
                else:
                    print(f"{self.prompt = } {self.use_rawinput}")
                    if self.use_rawinput:
                        try:
                            # 核心逻辑就在这里 不断的要求输入然后进行处理
                            line = input(self.prompt) # self.prompt = &#39;(Pdb)&#39;
                        except EOFError:
                            line = &#39;EOF&#39;
                    else:
                        self.stdout.write(self.prompt)
                        self.stdout.flush()
                        line = self.stdin.readline()
                        if not len(line):
                            line = &#39;EOF&#39;
                        else:
                            line = line.rstrip(&#39;\r\n&#39;)

                line = self.precmd(line)
                stop = self.onecmd(line) # 这个函数就是处理我们输入的字符串的比如 p n 等等
                stop = self.postcmd(stop, line)
            self.postloop()
        finally:
            if self.use_rawinput and self.completekey:
                try:
                    import readline
                    readline.set_completer(self.old_completer)
                except ImportError:
                    pass
    def onecmd(self, line):
        """Interpret the argument as though it had been typed in response
        to the prompt.

        This may be overridden, but should not normally need to be;
        see the precmd() and postcmd() methods for useful execution hooks.
        The return value is a flag indicating whether interpretation of
        commands by the interpreter should stop.

        """
        cmd, arg, line = self.parseline(line)
        if not line:
            return self.emptyline()
        if cmd is None:
            return self.default(line)
        self.lastcmd = line
        if line == &#39;EOF&#39; :
            self.lastcmd = &#39;&#39;
        if cmd == &#39;&#39;:
            return self.default(line)
        else:
            try:
                # 根据下面的代码可以分析了解到如果我们执行命令 p 执行的函数为 do_p
                func = getattr(self, &#39;do_&#39; + cmd)
            except AttributeError:
                return self.default(line)
            return func(arg)

现在我们再来看一下 do_p 打印一个表达式是如何实现的:

    def do_p(self, arg):
        """p expression
        Print the value of the expression.
        """
        self._msg_val_func(arg, repr)

    def _msg_val_func(self, arg, func):
        try:
            val = self._getval(arg)
        except:
            return  # _getval() has displayed the error
        try:
            self.message(func(val))
        except:
            self._error_exc()

    def _getval(self, arg):
        try:
            # 看到这里就破案了这不是和我们自己实现的 pdb 获取变量的方式一样嘛 都是
            # 使用当前执行栈帧的全局和局部变量交给 eval 函数处理 并且将它的返回值输出
            return eval(arg, self.curframe.f_globals, self.curframe_locals)
        except:
            self._error_exc()
            raise

Das obige ist der detaillierte Inhalt vonWas ist das Implementierungsprinzip des Debuggers in der virtuellen Python-Maschine?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme
Dieser Artikel ist reproduziert unter:亿速云. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen
Python vs. C: Lernkurven und BenutzerfreundlichkeitPython vs. C: Lernkurven und BenutzerfreundlichkeitApr 19, 2025 am 12:20 AM

Python ist leichter zu lernen und zu verwenden, während C leistungsfähiger, aber komplexer ist. 1. Python -Syntax ist prägnant und für Anfänger geeignet. Durch die dynamische Tippen und die automatische Speicherverwaltung können Sie die Verwendung einfach zu verwenden, kann jedoch zur Laufzeitfehler führen. 2.C bietet Steuerung und erweiterte Funktionen auf niedrigem Niveau, geeignet für Hochleistungsanwendungen, hat jedoch einen hohen Lernschwellenwert und erfordert manuellem Speicher und Typensicherheitsmanagement.

Python vs. C: Speicherverwaltung und KontrollePython vs. C: Speicherverwaltung und KontrolleApr 19, 2025 am 12:17 AM

Python und C haben signifikante Unterschiede in der Speicherverwaltung und -kontrolle. 1. Python verwendet die automatische Speicherverwaltung, basierend auf der Referenzzählung und der Müllsammlung, um die Arbeit von Programmierern zu vereinfachen. 2.C erfordert eine manuelle Speicherverwaltung und liefert mehr Kontrolle, aber die Komplexität und das Fehlerrisiko. Welche Sprache zu wählen sollte, sollte auf Projektanforderungen und Teamtechnologie -Stack basieren.

Python für wissenschaftliches Computer: Ein detailliertes AussehenPython für wissenschaftliches Computer: Ein detailliertes AussehenApr 19, 2025 am 12:15 AM

Zu den Anwendungen von Python im wissenschaftlichen Computer gehören Datenanalyse, maschinelles Lernen, numerische Simulation und Visualisierung. 1.Numpy bietet effiziente mehrdimensionale Arrays und mathematische Funktionen. 2. Scipy erweitert die Numpy -Funktionalität und bietet Optimierungs- und lineare Algebra -Tools. 3.. Pandas wird zur Datenverarbeitung und -analyse verwendet. 4.Matplotlib wird verwendet, um verschiedene Grafiken und visuelle Ergebnisse zu erzeugen.

Python und C: Das richtige Werkzeug findenPython und C: Das richtige Werkzeug findenApr 19, 2025 am 12:04 AM

Ob die Auswahl von Python oder C von den Projektanforderungen abhängt: 1) Python eignet sich aufgrund seiner prägnanten Syntax und reichhaltigen Bibliotheken für schnelle Entwicklung, Datenwissenschaft und Skripten; 2) C ist für Szenarien geeignet, die aufgrund seiner Zusammenstellung und des manuellen Speichermanagements eine hohe Leistung und die zugrunde liegende Kontrolle erfordern, wie z. B. Systemprogrammierung und Spielentwicklung.

Python für Datenwissenschaft und maschinelles LernenPython für Datenwissenschaft und maschinelles LernenApr 19, 2025 am 12:02 AM

Python wird in Datenwissenschaft und maschinellem Lernen häufig verwendet, wobei hauptsächlich auf seine Einfachheit und ein leistungsstarkes Bibliotheksökosystem beruhen. 1) Pandas wird zur Datenverarbeitung und -analyse verwendet, 2) Numpy liefert effiziente numerische Berechnungen, und 3) Scikit-Learn wird für die Konstruktion und Optimierung des maschinellen Lernens verwendet. Diese Bibliotheken machen Python zu einem idealen Werkzeug für Datenwissenschaft und maschinelles Lernen.

Python lernen: Ist 2 Stunden tägliches Studium ausreichend?Python lernen: Ist 2 Stunden tägliches Studium ausreichend?Apr 18, 2025 am 12:22 AM

Ist es genug, um Python für zwei Stunden am Tag zu lernen? Es hängt von Ihren Zielen und Lernmethoden ab. 1) Entwickeln Sie einen klaren Lernplan, 2) Wählen Sie geeignete Lernressourcen und -methoden aus, 3) praktizieren und prüfen und konsolidieren Sie praktische Praxis und Überprüfung und konsolidieren Sie und Sie können die Grundkenntnisse und die erweiterten Funktionen von Python während dieser Zeit nach und nach beherrschen.

Python für die Webentwicklung: SchlüsselanwendungenPython für die Webentwicklung: SchlüsselanwendungenApr 18, 2025 am 12:20 AM

Zu den wichtigsten Anwendungen von Python in der Webentwicklung gehören die Verwendung von Django- und Flask -Frameworks, API -Entwicklung, Datenanalyse und Visualisierung, maschinelles Lernen und KI sowie Leistungsoptimierung. 1. Django und Flask Framework: Django eignet sich für die schnelle Entwicklung komplexer Anwendungen, und Flask eignet sich für kleine oder hochmobile Projekte. 2. API -Entwicklung: Verwenden Sie Flask oder Djangorestframework, um RESTFUFFUPI zu erstellen. 3. Datenanalyse und Visualisierung: Verwenden Sie Python, um Daten zu verarbeiten und über die Webschnittstelle anzuzeigen. 4. Maschinelles Lernen und KI: Python wird verwendet, um intelligente Webanwendungen zu erstellen. 5. Leistungsoptimierung: optimiert durch asynchrones Programmieren, Caching und Code

Python vs. C: Erforschung von Leistung und Effizienz erforschenPython vs. C: Erforschung von Leistung und Effizienz erforschenApr 18, 2025 am 12:20 AM

Python ist in der Entwicklungseffizienz besser als C, aber C ist in der Ausführungsleistung höher. 1. Pythons prägnante Syntax und reiche Bibliotheken verbessern die Entwicklungseffizienz. 2. Die Kompilierungsmerkmale von Compilation und die Hardwarekontrolle verbessern die Ausführungsleistung. Bei einer Auswahl müssen Sie die Entwicklungsgeschwindigkeit und die Ausführungseffizienz basierend auf den Projektanforderungen abwägen.

See all articles

Heiße KI -Werkzeuge

Undresser.AI Undress

Undresser.AI Undress

KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover

AI Clothes Remover

Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool

Undress AI Tool

Ausziehbilder kostenlos

Clothoff.io

Clothoff.io

KI-Kleiderentferner

AI Hentai Generator

AI Hentai Generator

Erstellen Sie kostenlos Ai Hentai.

Heiße Werkzeuge

SublimeText3 chinesische Version

SublimeText3 chinesische Version

Chinesische Version, sehr einfach zu bedienen

MinGW – Minimalistisches GNU für Windows

MinGW – Minimalistisches GNU für Windows

Dieses Projekt wird derzeit auf osdn.net/projects/mingw migriert. Sie können uns dort weiterhin folgen. MinGW: Eine native Windows-Portierung der GNU Compiler Collection (GCC), frei verteilbare Importbibliotheken und Header-Dateien zum Erstellen nativer Windows-Anwendungen, einschließlich Erweiterungen der MSVC-Laufzeit zur Unterstützung der C99-Funktionalität. Die gesamte MinGW-Software kann auf 64-Bit-Windows-Plattformen ausgeführt werden.

Dreamweaver CS6

Dreamweaver CS6

Visuelle Webentwicklungstools

mPDF

mPDF

mPDF ist eine PHP-Bibliothek, die PDF-Dateien aus UTF-8-codiertem HTML generieren kann. Der ursprüngliche Autor, Ian Back, hat mPDF geschrieben, um PDF-Dateien „on the fly“ von seiner Website auszugeben und verschiedene Sprachen zu verarbeiten. Es ist langsamer und erzeugt bei der Verwendung von Unicode-Schriftarten größere Dateien als Originalskripte wie HTML2FPDF, unterstützt aber CSS-Stile usw. und verfügt über viele Verbesserungen. Unterstützt fast alle Sprachen, einschließlich RTL (Arabisch und Hebräisch) und CJK (Chinesisch, Japanisch und Koreanisch). Unterstützt verschachtelte Elemente auf Blockebene (wie P, DIV),

Senden Sie Studio 13.0.1

Senden Sie Studio 13.0.1

Leistungsstarke integrierte PHP-Entwicklungsumgebung