python3词法分析（三）识别token

最新推荐文章于 2025-01-07 15:26:48 发布
最新推荐文章于 2025-01-07 15:26:48 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/happytree001/article/details/122850178
版权

python3.10.2
主要分析Parser/tokenizer.c的tok_get函数

一、预处理行首

1、跳过空白字符

1.1.1 空格、Tab、\014

static int
tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
{
    ...

    /* Get indentation level */
    if (tok->atbol) { //atbol => at begin of line, 在行开头
        int col = 0;
        int altcol = 0;
        tok->atbol = 0;
        for (;;) {//死循环，一直跳过空格、\t、\014
            c = tok_nextc(tok);
            if (c == ' ') {
                col++, altcol++;
            }
            else if (c == '\t') {
                col = (col / tok->tabsize + 1) * tok->tabsize;
                altcol = (altcol / ALTTABSIZE + 1) * ALTTABSIZE;
            }
            else if (c == '\014')  {/* Control-L (formfeed) */
                col = altcol = 0; /* For Emacs users */
            }
            else {//其他字符，退出for
                break;
            }
        }
        tok_backup(tok, c); //将正常的字符放回缓冲区中
        ...

1.1.2 处理空白行

对于注释行、空行、以及续行处理，判断是否需要整行忽略

static int
tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
{
    ...

    /* Get indentation level */
    if (tok->atbol) { //atbol => at begin of line, 在行开头
    ...
    
		if (c == '#' || c == '\n' || c == '\\') {
            /* Lines with only whitespace and/or comments
               and/or a line continuation character
               shouldn't affect the indentation and are
               not passed to the parser as NEWLINE tokens,
               except *totally* empty lines in interactive
               mode, which signal the end of a command group. */
            if (col == 0 && c == '\n' && tok->prompt != NULL) {
                blankline = 0; /* Let it through */
            }
            else if (tok->prompt != NULL && tok->lineno == 1) {
                /* In interactive mode, if the first line contains
                   only spaces and/or a comment, let it through. */
                blankline = 0;
                col = altcol = 0;
            }
            else {
                blankline = 1; /* Ignore completely */
            }
            /* We can't jump back right here since we still
               may need to skip to the end of a comment */
        }
        ...

1.1.3 填写标识符列位置

static int
tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
{
    ...
    /* Get indentation level */
    if (tok->atbol) {
    ...
    
    	//对非空白行以及level=0时，填写标识符的列信息
		if (!blankline && tok->level == 0) {
            if (col == tok->indstack[tok->indent]) {
                /* No change */
                if (altcol != tok->altindstack[tok->indent]) {
                    return indenterror(tok);
                }
            }
            else if (col > tok->indstack[tok->indent]) {
                /* Indent -- always one */
                if (tok->indent+1 >= MAXINDENT) {
                    tok->done = E_TOODEEP;
                    tok->cur = tok->inp;
                    return ERRORTOKEN;
                }
                if (altcol <= tok->altindstack[tok->indent]) {
                    return indenterror(tok);
                }
                tok->pendin++;
                tok->indstack[++tok->indent] = col;
                tok->altindstack[tok->indent] = altcol;
            }
            else /* col < tok->indstack[tok->indent] */ {
                /* Dedent -- any number, must be consistent */
                while (tok->indent > 0 &&
                    col < tok->indstack[tok->indent]) {
                    tok->pendin--;
                    tok->indent--;
                }
                if (col != tok->indstack[tok->indent]) {
                    tok->done = E_DEDENT;
                    tok->cur = tok->inp;
                    return ERRORTOKEN;
                }
                if (altcol != tok->altindstack[tok->indent]) {
                    return indenterror(tok);
                }
            }
        }

2、处理pendin

static int
tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
{
...
    tok->start = tok->cur;

    /* Return pending indents/dedents */
    if (tok->pendin != 0) {
        if (tok->pendin < 0) {
            tok->pendin++;
            return DEDENT;
        }
        else {
            tok->pendin--;
            return INDENT;
        }
    }
...

3、预读一个字符

/* Peek ahead at the next character */
    c = tok_nextc(tok);
    tok_backup(tok, c);

4、处理async

 /* Check if we are closing an async function */
    if (tok->async_def
        && !blankline
        /* Due to some implementation artifacts of type comments,
         * a TYPE_COMMENT at the start of a function won't set an
         * indentation level and it will produce a NEWLINE after it.
         * To avoid spuriously ending an async function due to this,
         * wait until we have some non-newline char in front of us. */
        && c != '\n'
        && tok->level == 0
        /* There was a NEWLINE after ASYNC DEF,
           so we're past the signature. */
        && tok->async_def_nl
        /* Current indentation level is less than where
           the async function was defined */
        && tok->async_def_indent >= tok->indent)
    {
        tok->async_def = 0;
        tok->async_def_indent = 0;
        tok->async_def_nl = 0;
    }

二、识别行中的各个token

1、跳过空白字符

 again:
    tok->start = NULL;
    /* Skip spaces */
    do {
        c = tok_nextc(tok);
    } while (c == ' ' || c == '\t' || c == '\014');

    /* Set start of current token */
    tok->start = tok->cur - 1;

2、跳过注释

/* Skip comment, unless it's a type comment */
    if (c == '#') {
        const char *prefix, *p, *type_start;

        while (c != EOF && c != '\n') {
            c = tok_nextc(tok);
        }

        if (tok->type_comments) {
            p = tok->start;
            prefix = type_comment_prefix;
            while (*prefix && p < tok->cur) {
                if (*prefix == ' ') {
                    while (*p == ' ' || *p == '\t') {
                        p++;
                    }
                } else if (*prefix == *p) {
                    p++;
                } else {
                    break;
                }

                prefix++;
            }

            /* This is a type comment if we matched all of type_comment_prefix. */
            if (!*prefix) {
                int is_type_ignore = 1;
                const char *ignore_end = p + 6;
                tok_backup(tok, c);  /* don't eat the newline or EOF */

                type_start = p;

                /* A TYPE_IGNORE is "type: ignore" followed by the end of the token
                 * or anything ASCII and non-alphanumeric. */
                is_type_ignore = (
                    tok->cur >= ignore_end && memcmp(p, "ignore", 6) == 0
                    && !(tok->cur > ignore_end
                         && ((unsigned char)ignore_end[0] >= 128 || Py_ISALNUM(ignore_end[0]))));

                if (is_type_ignore) {
                    *p_start = ignore_end;
                    *p_end = tok->cur;

                    /* If this type ignore is the only thing on the line, consume the newline also. */
                    if (blankline) {
                        tok_nextc(tok);
                        tok->atbol = 1;
                    }
                    return TYPE_IGNORE;
                } else {
                    *p_start = type_start;  /* after type_comment_prefix */
                    *p_end = tok->cur;
                    return TYPE_COMMENT;
                }
            }
        }
    }

3、结束检查

 /* Check for EOF and errors now */
    if (c == EOF) {
        if (tok->level) {
            return ERRORTOKEN;
        }
        return tok->done == E_EOF ? ENDMARKER : ERRORTOKEN;
    }

4、识别标识符

大小写字母，下划线，以及ASCII值大于等于128的字符开头，后跟大小写字母，下划线，以及ASCII值大于等于128的字符以及数字0-9

#define is_potential_identifier_start(c) (\
              (c >= 'a' && c <= 'z')\
               || (c >= 'A' && c <= 'Z')\
               || c == '_'\
               || (c >= 128))

#define is_potential_identifier_char(c) (\
              (c >= 'a' && c <= 'z')\
               || (c >= 'A' && c <= 'Z')\
               || (c >= '0' && c <= '9')\
               || c == '_'\
               || (c >= 128))

 /* Identifier (most frequent token!) */
    nonascii = 0;
    if (is_potential_identifier_start(c)) {
        /* Process the various legal combinations of b"", r"", u"", and f"". */
        int saw_b = 0, saw_r = 0, saw_u = 0, saw_f = 0;
        while (1) {
            if (!(saw_b || saw_u || saw_f) && (c == 'b' || c == 'B'))
                saw_b = 1;
            /* Since this is a backwards compatibility support literal we don't
               want to support it in arbitrary order like byte literals. */
            else if (!(saw_b || saw_u || saw_r || saw_f)
                     && (c == 'u'|| c == 'U')) {
                saw_u = 1;
            }
            /* ur"" and ru"" are not supported */
            else if (!(saw_r || saw_u) && (c == 'r' || c == 'R')) {
                saw_r = 1;
            }
            else if (!(saw_f || saw_b || saw_u) && (c == 'f' || c == 'F')) {
                saw_f = 1;
            }
            else {
                break;
            }
            c = tok_nextc(tok);
            if (c == '"' || c == '\'') {
                goto letter_quote;
            }
        }
        while (is_potential_identifier_char(c)) {
            if (c >= 128) {
                nonascii = 1;
            }
            c = tok_nextc(tok);
        }
        tok_backup(tok, c);
        if (nonascii && !verify_identifier(tok)) {
            return ERRORTOKEN;
        }

        *p_start = tok->start;
        *p_end = tok->cur;

        /* async/await parsing block. */
        if (tok->cur - tok->start == 5 && tok->start[0] == 'a') {
            /* May be an 'async' or 'await' token.  For Python 3.7 or
               later we recognize them unconditionally.  For Python
               3.5 or 3.6 we recognize 'async' in front of 'def', and
               either one inside of 'async def'.  (Technically we
               shouldn't recognize these at all for 3.4 or earlier,
               but there's no *valid* Python 3.4 code that would be
               rejected, and async functions will be rejected in a
               later phase.) */
            if (!tok->async_hacks || tok->async_def) {
                /* Always recognize the keywords. */
                if (memcmp(tok->start, "async", 5) == 0) {
                    return ASYNC;
                }
                if (memcmp(tok->start, "await", 5) == 0) {
                    return AWAIT;
                }
            }
            else if (memcmp(tok->start, "async", 5) == 0) {
                /* The current token is 'async'.
                   Look ahead one token to see if that is 'def'. */

                struct tok_state ahead_tok;
                const char *ahead_tok_start = NULL;
                const char *ahead_tok_end = NULL;
                int ahead_tok_kind;

                memcpy(&ahead_tok, tok, sizeof(ahead_tok));
                ahead_tok_kind = tok_get(&ahead_tok, &ahead_tok_start,
                                         &ahead_tok_end);

                if (ahead_tok_kind == NAME
                    && ahead_tok.cur - ahead_tok.start == 3
                    && memcmp(ahead_tok.start, "def", 3) == 0)
                {
                    /* The next token is going to be 'def', so instead of
                       returning a plain NAME token, return ASYNC. */
                    tok->async_def_indent = tok->indent;
                    tok->async_def = 1;
                    return ASYNC;
                }
            }
        }

        return NAME;
    }

5、识别换行

/* Newline */
    if (c == '\n') {
        tok->atbol = 1;
        if (blankline || tok->level > 0) {
            goto nextline;
        }
        *p_start = tok->start;
        *p_end = tok->cur - 1; /* Leave '\n' out of the string */
        tok->cont_line = 0;
        if (tok->async_def) {
            /* We're somewhere inside an 'async def' function, and
               we've encountered a NEWLINE after its signature. */
            tok->async_def_nl = 1;
        }
        return NEWLINE;
    }

6、识别DOT

/* Period or number starting with period? */
    if (c == '.') {
        c = tok_nextc(tok);
        if (isdigit(c)) {
            goto fraction;
        } else if (c == '.') {
            c = tok_nextc(tok);
            if (c == '.') {
                *p_start = tok->start;
                *p_end = tok->cur;
                return ELLIPSIS;
            }
            else {
                tok_backup(tok, c);
            }
            tok_backup(tok, '.');
        }
        else {
            tok_backup(tok, c);
        }
        *p_start = tok->start;
        *p_end = tok->cur;
        return DOT;
    }

7、识别数值

/* Number */
    if (isdigit(c)) {
        if (c == '0') {
            /* Hex, octal or binary -- maybe. */
            c = tok_nextc(tok);
            if (c == 'x' || c == 'X') {
                /* Hex */
                c = tok_nextc(tok);
                do {
                    if (c == '_') {
                        c = tok_nextc(tok);
                    }
                    if (!isxdigit(c)) {
                        tok_backup(tok, c);
                        return syntaxerror(tok, "invalid hexadecimal literal");
                    }
                    do {
                        c = tok_nextc(tok);
                    } while (isxdigit(c));
                } while (c == '_');
                if (!verify_end_of_number(tok, c, "hexadecimal")) {
                    return ERRORTOKEN;
                }
            }
            else if (c == 'o' || c == 'O') {
                /* Octal */
                c = tok_nextc(tok);
                do {
                    if (c == '_') {
                        c = tok_nextc(tok);
                    }
                    if (c < '0' || c >= '8') {
                        if (isdigit(c)) {
                            return syntaxerror(tok,
                                    "invalid digit '%c' in octal literal", c);
                        }
                        else {
                            tok_backup(tok, c);
                            return syntaxerror(tok, "invalid octal literal");
                        }
                    }
                    do {
                        c = tok_nextc(tok);
                    } while ('0' <= c && c < '8');
                } while (c == '_');
                if (isdigit(c)) {
                    return syntaxerror(tok,
                            "invalid digit '%c' in octal literal", c);
                }
                if (!verify_end_of_number(tok, c, "octal")) {
                    return ERRORTOKEN;
                }
            }
            else if (c == 'b' || c == 'B') {
                /* Binary */
                c = tok_nextc(tok);
                do {
                    if (c == '_') {
                        c = tok_nextc(tok);
                    }
                    if (c != '0' && c != '1') {
                        if (isdigit(c)) {
                            return syntaxerror(tok,
                                    "invalid digit '%c' in binary literal", c);
                        }
                        else {
                            tok_backup(tok, c);
                            return syntaxerror(tok, "invalid binary literal");
                        }
                    }
                    do {
                        c = tok_nextc(tok);
                    } while (c == '0' || c == '1');
                } while (c == '_');
                if (isdigit(c)) {
                    return syntaxerror(tok,
                            "invalid digit '%c' in binary literal", c);
                }
                if (!verify_end_of_number(tok, c, "binary")) {
                    return ERRORTOKEN;
                }
            }
            else {
                int nonzero = 0;
                /* maybe old-style octal; c is first char of it */
                /* in any case, allow '0' as a literal */
                while (1) {
                    if (c == '_') {
                        c = tok_nextc(tok);
                        if (!isdigit(c)) {
                            tok_backup(tok, c);
                            return syntaxerror(tok, "invalid decimal literal");
                        }
                    }
                    if (c != '0') {
                        break;
                    }
                    c = tok_nextc(tok);
                }
                char* zeros_end = tok->cur;
                if (isdigit(c)) {
                    nonzero = 1;
                    c = tok_decimal_tail(tok);
                    if (c == 0) {
                        return ERRORTOKEN;
                    }
                }
                if (c == '.') {
                    c = tok_nextc(tok);
                    goto fraction;
                }
                else if (c == 'e' || c == 'E') {
                    goto exponent;
                }
                else if (c == 'j' || c == 'J') {
                    goto imaginary;
                }
                else if (nonzero) {
                    /* Old-style octal: now disallowed. */
                    tok_backup(tok, c);
                    return syntaxerror_known_range(
                            tok, (int)(tok->start + 1 - tok->line_start),
                            (int)(zeros_end - tok->line_start),
                            "leading zeros in decimal integer "
                            "literals are not permitted; "
                            "use an 0o prefix for octal integers");
                }
                if (!verify_end_of_number(tok, c, "decimal")) {
                    return ERRORTOKEN;
                }
            }
        }
        else {
            /* Decimal */
            c = tok_decimal_tail(tok);
            if (c == 0) {
                return ERRORTOKEN;
            }
            {
                /* Accept floating point numbers. */
                if (c == '.') {
                    c = tok_nextc(tok);
        fraction:
                    /* Fraction */
                    if (isdigit(c)) {
                        c = tok_decimal_tail(tok);
                        if (c == 0) {
                            return ERRORTOKEN;
                        }
                    }
                }
                if (c == 'e' || c == 'E') {
                    int e;
                  exponent:
                    e = c;
                    /* Exponent part */
                    c = tok_nextc(tok);
                    if (c == '+' || c == '-') {
                        c = tok_nextc(tok);
                        if (!isdigit(c)) {
                            tok_backup(tok, c);
                            return syntaxerror(tok, "invalid decimal literal");
                        }
                    } else if (!isdigit(c)) {
                        tok_backup(tok, c);
                        if (!verify_end_of_number(tok, e, "decimal")) {
                            return ERRORTOKEN;
                        }
                        tok_backup(tok, e);
                        *p_start = tok->start;
                        *p_end = tok->cur;
                        return NUMBER;
                    }
                    c = tok_decimal_tail(tok);
                    if (c == 0) {
                        return ERRORTOKEN;
                    }
                }
                if (c == 'j' || c == 'J') {
                    /* Imaginary part */
        imaginary:
                    c = tok_nextc(tok);
                    if (!verify_end_of_number(tok, c, "imaginary")) {
                        return ERRORTOKEN;
                    }
                }
                else if (!verify_end_of_number(tok, c, "decimal")) {
                    return ERRORTOKEN;
                }
            }
        }
        tok_backup(tok, c);
        *p_start = tok->start;
        *p_end = tok->cur;
        return NUMBER;
    }

8、识别string

/* String */
    if (c == '\'' || c == '"') {
        int quote = c;
        int quote_size = 1;             /* 1 or 3 */
        int end_quote_size = 0;

        /* Nodes of type STRING, especially multi line strings
           must be handled differently in order to get both
           the starting line number and the column offset right.
           (cf. issue 16806) */
        tok->first_lineno = tok->lineno;
        tok->multi_line_start = tok->line_start;

        /* Find the quote size and start of string */
        c = tok_nextc(tok);
        if (c == quote) {
            c = tok_nextc(tok);
            if (c == quote) {
                quote_size = 3;
            }
            else {
                end_quote_size = 1;     /* empty string found */
            }
        }
        if (c != quote) {
            tok_backup(tok, c);
        }

        /* Get rest of string */
        while (end_quote_size != quote_size) {
            c = tok_nextc(tok);
            if (c == EOF || (quote_size == 1 && c == '\n')) {
                assert(tok->multi_line_start != NULL);
                // shift the tok_state's location into
                // the start of string, and report the error
                // from the initial quote character
                tok->cur = (char *)tok->start;
                tok->cur++;
                tok->line_start = tok->multi_line_start;
                int start = tok->lineno;
                tok->lineno = tok->first_lineno;

                if (quote_size == 3) {
                    return syntaxerror(tok,
                                       "unterminated triple-quoted string literal"
                                       " (detected at line %d)", start);
                }
                else {
                    return syntaxerror(tok,
                                       "unterminated string literal (detected at"
                                       " line %d)", start);
                }
            }
            if (c == quote) {
                end_quote_size += 1;
            }
            else {
                end_quote_size = 0;
                if (c == '\\') {
                    tok_nextc(tok);  /* skip escaped char */
                }
            }
        }

        *p_start = tok->start;
        *p_end = tok->cur;
        return STRING;
    }

9、识别多字符token

识别如==，–,+=等

    /* Check for two-character token */
    {
        int c2 = tok_nextc(tok);
        int token = PyToken_TwoChars(c, c2);
        if (token != OP) {
            int c3 = tok_nextc(tok);
            int token3 = PyToken_ThreeChars(c, c2, c3);
            if (token3 != OP) {
                token = token3;
            }
            else {
                tok_backup(tok, c3);
            }
            *p_start = tok->start;
            *p_end = tok->cur;
            return token;
        }
        tok_backup(tok, c2);
    }

10、处理括号嵌套

通过栈操作确定括号是否配对。

 /* Keep track of parentheses nesting level */
    switch (c) {
    case '(':
    case '[':
    case '{':
        if (tok->level >= MAXLEVEL) {
            return syntaxerror(tok, "too many nested parentheses");
        }
        tok->parenstack[tok->level] = c;
        tok->parenlinenostack[tok->level] = tok->lineno;
        tok->parencolstack[tok->level] = (int)(tok->start - tok->line_start);
        tok->level++;
        break;
    case ')':
    case ']':
    case '}':
        if (!tok->level) {
            return syntaxerror(tok, "unmatched '%c'", c);
        }
        tok->level--;
        int opening = tok->parenstack[tok->level];
        if (!((opening == '(' && c == ')') ||
              (opening == '[' && c == ']') ||
              (opening == '{' && c == '}')))
        {
            if (tok->parenlinenostack[tok->level] != tok->lineno) {
                return syntaxerror(tok,
                        "closing parenthesis '%c' does not match "
                        "opening parenthesis '%c' on line %d",
                        c, opening, tok->parenlinenostack[tok->level]);
            }
            else {
                return syntaxerror(tok,
                        "closing parenthesis '%c' does not match "
                        "opening parenthesis '%c'",
                        c, opening);
            }
        }
        break;
    }

    /* Punctuation character */
    *p_start = tok->start;
    *p_end = tok->cur;
    return PyToken_OneChar(c);
简单词法分析器，输出token和简单符号表
04-15
非常基础的词法分析器，能够将各个单词分开，判断各个单词的类型，并输出相应的tokens和符号表。还存在一些BUG，希望大家不吝赐教。
Python实现词法分析器.rar
11-30
除了`tokenize`模块，我们还可以使用第三方库如`ply`（Python Lex and Yacc）来实现词法分析和语法分析。`ply`提供了一套完整的工具，包括词法分析器（lex）和解析器（yacc），它们允许程序员自定义规则，以处理更...
python中出现SyntaxError: invalid character in identifier和SyntaxError: EOL while scanning string literal
qq_43231176的博客
04-02 344
出现这个原因一般是从别处复制过来的代码直接粘贴运行，错误的原因是空格等符号的编码格式不对，建议把代码在txt文本里面重新保存一下在用 2. 出现这个错误一般是符号问题，我出现这个错误的原因是引号用中文格式了 ...
Python接口自动化之Token详解及应用
最新发布
软件测试技术分享官
01-07 720
以下介绍Token原理及在自动化中的应用。
python实现token解析
bobi的博客
09-23 5844
产生条件 HTTP是无状态的协议，这个协议是无法记录用户访问状态的，其每次请求都是独立的无关联的，而我们的网站都是设计成多个页面的，所以，我们每个页面都需要对用户的身份进行认证 cookie 服务器给一个用户开辟出来的一段内存空间用于保存这次会话的一些内容，如果浏览器不支持Cookie（如大部分手机中的浏览器）或者把Cookie禁用了，Cookie功能就会失效 token 客户端收到 ...
02 词法分析
xuqidong5的专栏
10-04 594
词法分析是编译器工作的第一步，接收源码作为输入，输出对应的词法单元。
词法分析练习一:简单提取token
weixin_31980479的博客
09-05 1949
语法分析练习一:简单提取token 思路: 第一次碰到字母,下划线: 开启新token, 设置type=identify; 直到遇见非(字母,数字,下划线 截止), 则以上为一个标识符 第一次碰到数字: 开启新token, 设置type=number; 直到遇见非(数字,字母U,L,u,l)截止, 则以上为一个数字 typedef char bool; #define true 1 #defi...
词法分析
-琥珀-的专栏
05-27 850
#include <stdio.h> #include <stdlib.h> #include <string.h> #define _KEY_WORD_END "waiting for your expanding" typedef struct { int typenum; char *word; }WORD; char input[255]; char token[255] =
python实现词法分析器
09-19
### Python 实现词法分析器知识点详解 #### 一、词法分析器概念与作用 词法分析器（Lexical Analyzer）是编译原理中的一个关键环节，它负责将源代码字符串分解为一系列的标记（Token）。每个标记代表源代码中的...
python 词法分析器的实现
06-03
词法分析是从左向右扫描每行源程序的符号，拼成单词，换成统一的机内表示形式——TOKEN字，送给语法分析程序，TOKEN字是一个二元式：（单词种别码，单词属性值），单词属性包括了常数、变量、关键字、运算符、界符等...
python的词法_Python的词法分析
weixin_39681621的博客
02-21 738
吐槽：出的题目没有大佬做吗？俺很伤心哇从本周开始我们正式进入Python的编译和解释环节。今天我们先来谈谈Python运行环节前的词法执行环节。由于这部分开始都比较复杂，我会采用实际的例子来逐步分析。两章一篇，第一部分讲大致流程，第二部分讲详细实现过程。词法分析的流程本质上，Python提供了两种执行Python的方式：PyRun_File系列PyRun_String系列故名思义，前者接受一个py...
python token 访问控制_Python接口自动化之Token详解及应用
weixin_39858132的博客
11-29 399
介绍了cookie、session原理及在自动化过程中如何利用cookie、session保持会话状态。以下介绍Token原理及在自动化中的应用。​一、Token基本概念及原理1、Token作用为了验证用户登录情况以及减轻服务器的压力，减少频繁的查询数据库，使服务器更加健壮。2、什么是TokenToken是服务端生成的一串字符串，以作客户端进行请求的一个令牌，当第一次登录后，服务器生成一个Toke...
语法分析
tasty
09-08 3092
#### 写在前面： 词法分析的工作是扫描文本，提取一个个独立的单词 语法分析的工作是分析一个个独立的单词之间的组合规则从而获得文本的含义 例： 词法分析：定义词法规则（正则表达式） Number为[0-9]+ ，Letters为[a-zA-Z]+ ，不在规则中的抛弃 则，扫描文本"This is 233"时得出LettersLettersNumber 语法分析：
词法分析实战
代码菌的blog
12-16 1831
题目： 在这部分中，你将使用图转移算法手工实现一个小型的词法分析器。 * 分析器的输入：存储在文本文件中的字符序列，字符取自ASCII字符集。文件中可能包括四种记号：关键字if、符合C语言标准的标识符、空格符、回车符\n。 * 分析器的输出：打印出所识别的标识符的种类、及行号、列号信息。 根据题目的要求，定义如下的Token类： enum TokenType{ TT_ID, TT
笔记 | 编译原理L2：词法分析（lexical analysis）
Tancilon的博客
04-21 6444
词法分析(lexical analysis)，也称scanning, 编译程序的第一阶段,其作用是识别单词(程序意义上)并找出词法错误. 读入源程序的输入字符、将它们拆分成词素，生成并输出一个词法单元序列，每个词法单元对应于一个词素回顾词法分析在整个编译过程的位置![[【笔记】编译原理L1#^53d248| 回顾编译原理的各个模块顺序]]作用：沟通，交流，传递信息自然语言：英语，中文，日语无限的集合字符组成了单词;单词组成了句子;句子携带了信息语言是形式化的内容提取——
编译原理（一）——词法分析
lengjiayi的博客
03-12 3019
词法分析 1、基本概念 词法单元(Token)：由词法单元名和属性值（可选）组成。其中属性值用于区分同一符号表中重复的同种词法单元。 模式(Pattern)：描述一类词法单元可能具有的形势。 词素(Lexeme)：源程序中的一个字符序列，可以和某个词法单元的模式匹配，并被词法分析器识别为该词法单元的一个实例。 可以看出，词法单元、模式和词素是&amp;quot;一对一对多&amp;quot;的关系，下图给出了c语言词法一个示例：...
编译原理入门（三）——词法分析简介
m0_37914588的博客
10-05 7530
    上一篇博文介绍了编译器翻译的过程，本篇博文对翻译过程的第一步词法分析进行讲解。      词法分析     词法分析的主要任务：1.对源程序的代码进行从左到右的逐行扫描，识别出各个单词，从而确定单词的类型。                                         2.将识别出的单词转换为统一的机内表示——词法单元（token）形式，token：&lt;种别码，...
SyntaxError: invalid decimal literal解决方法
热门推荐
weixin_42598278的博客
01-11 5万+
"SyntaxError: invalid decimal literal" 是一种 Python 编程错误，通常表示在程序中使用了无效的十进制字面量。这通常是因为使用了非数字字符，如字母或符号，或者尝试将非数字字符串转换为数字导致的。 解决这个错误的方法是检查程序中使用的所有十进制字面量，确保它们都是有效的数字。如果使用了字符串，需要使用 int() 或 float() 将它们转换为数字。 另外...
Python实现词法分析器详解及代码
词法分析器的主要任务是从源代码中识别出一个个的词法单元（token），这些单元可以是关键字、标识符、常量、运算符或其他符号。在Python中，词法分析通常包括以下几个步骤： 1. **预处理**：这可能涉及去除源代码中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值