Python Tkinter/Pygments：突出显示的奇怪结果

我尝试根据标记突出显示文本。标记可以通过以下代码突出显示，但会出现一些不需要的结果。一些例子：

假设是这样，我键入：

a=“a”

尽管第一个“a”是标记.Name，第二个“a”是标记.Literal.String.Double

另一个不需要的情况是，当我键入“if”时，该词会高亮显示，如果我继续向“if”添加一些字母，则该词的颜色会按预期发生变化。然而，当我删除这个词的一些字母，直到这个词再次变成“如果”时，这个词不会像以前那样突出显示

你能帮我理解这个问题吗

代码：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from pygments import lex
from pygments.token import Token
from pygments.lexers import Python3Lexer
try:
    import Tkinter as tk
except ImportError:
    import tkinter as tk

ROOT = tk.Tk()
TEXT = tk.Text(master=ROOT, fg="white", bg="black", font="TkDefaultFont 10")
TEXT.pack(fill="both", expand=True)


def tag(event):

    def colorize(word, color):
        index = []
        index1 = TEXT.search(word, "1.0", "end")
        while index1:
            index2 = ".".join([index1.split(".")[0], str(int(index1.split(".")[1]) + len(word))])
            index.append((index1, index2))
            index1 = TEXT.search(word, index2, "end")
        for i, j in index:
            TEXT.tag_add(word, i, j)
            TEXT.tag_configure(word, foreground=color)

    for token, content in lex(TEXT.get("1.0", "end"), Python3Lexer()):
        if token == Token.Literal.Number.Integer:
            colorize(content, color="purple")
        elif token == Token.Keyword:
            colorize(content, color="orange")
        elif token == Token.Operator.Word:
            colorize(content, color="red")
        elif token == Token.Name.Builtin:
            colorize(content, color="blue")
        elif token == Token.Comment.Hashbang or token == Token.Comment.Single:
            colorize(content, color="grey")
        elif token == Token.Keyword.Namespace:
            colorize(content, color="yellow")
        elif token == Token.Namespace:
            colorize(content, color="green")
        elif token == Token.Punctuation:
            colorize(content, color="brown")
        elif token == Token.Literal.String.Double:
            colorize(content, color="cyan")
        elif token == Token.Name:
            colorize(content, color="white")


TEXT.bind("<KeyRelease>", tag)
ROOT.mainloop()

#/usr/bin/env蟒蛇3
#-*-编码：utf-8-*-
从pygments导入lex
从pygments.token导入令牌
从pygments.lexer导入Python3Lexer
尝试：
将Tkinter作为tk导入
除恐怖外：
将tkinter作为tk导入
ROOT=tk.tk（）
TEXT=tk.TEXT（master=ROOT，fg=“白色”，bg=“黑色”，font=“TkDefaultFont 10”）
TEXT.pack（fill=“both”，expand=True）
def标签（事件）：
def colorize（文字、颜色）：
索引=[]
index1=文本搜索（单词“1.0”、“结束”）
而index1：
index2=“.”join（[index1.split（“.”[0]，str（int（index1.split（“.”[1]）+len（word）））
追加索引（（index1，index2））
index1=文本搜索（单词，index2，“结束”）
对于索引中的i，j：
TEXT.tag_add（word，i，j）
TEXT.tag\u配置（单词，前景=颜色）
对于令牌，lex中的内容（TEXT.get（“1.0”，“end”），Python3Lexer（））：
如果token==token.Literal.Number.Integer：
着色（内容，颜色=“紫色”）
elif令牌==令牌。关键字：
着色（内容，颜色=“橙色”）
elif token==token.Operator.Word：
着色（内容，color=“红色”）
elif token==token.Name.Builtin:
着色（内容，color=“蓝色”）
elif标记==token.Comment.Hashbang或标记==token.Comment.Single：
着色（内容，颜色=“灰色”）
elif token==token.Keyword.Namespace:
着色（内容，颜色=“黄色”）
elif令牌==令牌。命名空间：
着色（内容，颜色=“绿色”）
elif标记==标记。标点符号：
着色（内容，颜色=“棕色”）
elif token==token.Literal.String.Double：
着色（内容，颜色=“青色”）
elif令牌==令牌。名称：
着色（内容，颜色=“白色”）
TEXT.bind（“，标记）
ROOT.mainloop（）

---

`

通过以下代码解决了问题

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import sys
if sys.version_info.major == 2:
    exit()
elif sys.version_info.major == 3:
    import builtins as builtins
    import tkinter as tk
import io
import tokenize
import keyword


root = tk.Tk()
text = tk.Text(master=root, fg="white", bg="black", font="TkDefaultFont 10")
text.pack(fill="both", expand=True)

count = 0


def colorize(*args):
    global count
    row1, col1 = args[0].startz
    row1, col1 = str(row1), str(col1)
    row2, col2 = args[0].end
    row2, col2 = str(row2), str(col2)
    start = ".".join((row1, col1))
    end = ".".join((row2, col2))
    text.tag_add(str(count), start, end)
    try:
        text.tag_config(str(count), foreground=args[1], font=args[2])
    except IndexError:
        text.tag_config(str(count), foreground=args[1])
    count += 1


def search(event):
    try:
        for i in tokenize.tokenize(io.BytesIO(text.get("1.0", "end").encode("utf-8")).readline):
            if i.type == 1:
                if i.string in keyword.kwlist:
                    colorize(i, "orange")
                elif i.string in dir(builtins):
                    colorize(i, "blue")
                else:
                    colorize(i, "white")
            elif i.type == 2:
                colorize(i, "cyan")
            elif i.type == 3:
                colorize(i, "purple")
            elif i.type == 53:
                if i.string == "," or i.string == "." or i.string == ":":
                    colorize(i, "orange")
                elif i.string == "(" or i.string == ")" or i.string == "[" \
                        or i.string == "]" or i.string == "{" or i.string == "}":
                    colorize(i, "darkred")
                else:
                    colorize(i, "green")
            elif i.type == 57:
                colorize(i, "grey", "TkDefaultFont 10 italic")
    except tokenize.TokenError:
        pass


text.bind("<KeyRelease>", search)
root.mainloop()

#/usr/bin/env蟒蛇3
#-*-编码：utf-8-*-
导入系统
如果sys.version_info.major==2：
退出（）
elif sys.version_info.major==3：
将内置项作为内置项导入
将tkinter作为tk导入
输入io
导入标记化
导入关键字
root=tk.tk（）
text=tk.text（master=root，fg=“白色”，bg=“黑色”，font=“TkDefaultFont 10”）
text.pack（fill=“both”，expand=True）
计数=0
def colorize（*args）：
全局计数
行1，col1=args[0]。startz
行1，col1=str（行1），str（col1）
行2，col2=args[0]。结束
第2行，第2列=str（第2行），str（第2列）
start=“.”.join（（第1行，第1列））
end=“.”.join（（第2行，第2列））
text.tag_添加（str（计数）、开始、结束）
尝试：
text.tag_config（str（count），前台=args[1]，font=args[2]）
除索引器外：
text.tag_config（str（count），前台=args[1]）
计数+=1
def搜索（事件）：
尝试：
对于tokenize.tokenize（io.BytesIO（text.get（“1.0”，“end”）.encode（“utf-8”））.readline）中的i：
如果i.type==1：
如果关键字.kwlist中的i.string：
着色（i，“橙色”）
目录中的elif i.string（内置）：
着色（i，“蓝色”）
其他：
着色（i，“白色”）
elif i.type==2：
着色（i，“青色”）
elif i.type==3：
着色（i，“紫色”）
elif i.type==53：
如果i.string==“，”或i.string==”，或i.string==“：”：
着色（i，“橙色”）
elif i.string==”（“或i.string==”）或i.string==”[“\
或i.string==“]”或i.string==“{”或i.string==“}”：
着色（我称之为“暗色”）
其他：
着色（i，“绿色”）
elif i.type==57：
着色（i，“灰色”、“TkDefaultFont 10斜体”）
除tokenize.TokenError外：
通过
text.bind（“，搜索）
root.mainloop（）

您做了哪些调试工作？例如，您是否在循环运行时打印出变量的值以验证它们是否是您认为应该的值？我在for循环中放置了一个print语句来打印内容和标记。那么，您是否声称所有内容和标记都是正确的，索引都是正确的，但这是错误的？我只想说，一旦一个单词被识别为标记，该单词将在另一个单词中突出显示。例如，如果程序可以将

“a”

识别为Token.Literal.String.Double，则此字符将突出显示。但不仅仅是这个字符串文字，还有文本小部件中的所有a。在这里你可以看到截图。所以我想，在解析中有一个问题。