Python Unicode实战

约定不等于承诺〃 2022-09-08 15:44 135阅读 0赞

### 文章目录 ###

*  1. 各种编码的简要发展史
 *  2. Python Unicode实战
 *   *  2.1 操作单个字符
     *   *  2.1.1 判断单个字符所属类型
         *  2.1.2 判断单个字符是否属于中文
         *  2.1.3 判断是否是空白符
         *  2.1.4 判断是否是控制符
         *  2.1.5 是否为标点符号
     *  2.2 字符串处理
     *   *  2.2.1 将文本转换成Unicode
         *  2.2.2 清理文本中的无效字符
         *  2.2.3 清理文本中的重音符号
         *  2.2.4 将字符串中的文本和标点符号进行划分
         *  2.2.5 对文本进行分词

首先说明一下，本文代码以Python3版本为主（暂时不考虑和Python2的代码兼容）。

# 1. 各种编码的简要发展史 #

最早的`ASCII`使用8位二进制(字节)来对字符进行编码，其中8位二进制可以表示2^8=256个字符。其中0~127用来表示英文字母、数字、控制字符等符号，可详见链接：[https://ttssh2.osdn.jp/manual/4/en/macro/appendixes/ascii.html][https_ttssh2.osdn.jp_manual_4_en_macro_appendixes_ascii.html]。这样一来，英文在计算机中的表示和存储就迎刃而解了。与此同时，128~255也暂时闲置下来了。

随着计算机的逐渐发展，其他国家也需要将本国的语言在计算机中进行表示。部分国家使用128~255进行字母和符号进行表示。但是对于中文来说，剩余的256个位置根本无法表示汉字。既然一个字节无法表示中文，那么就用两个来表示吧。为了兼容原有的字符，所以当单个字节小于128时，就表示原有字符。当**连续两个字节**都大于128，具体来说是`高字节`位于区间\[0xA1,0xF7\]时，`低字节`位于区间\[0xA1, 0xFE\]时，就表示一个汉字。上述编码也就是`GB2312`，具体可参考链接：[https://www.wikiwand.com/zh-hans/GB\_2312][https_www.wikiwand.com_zh-hans_GB_2312]。

但是GB2312也无法表示全部的汉字，所以将高低字节的范围都进行了扩展，高字节的范围区间修改为了\[81, FE\]，而低字节的范围区间修改为了\[40, 7E\]和\[80, FE\]。这种编码也就是`GBK`。具体可参考链接：[https://www.wikiwand.com/zh-hans/GBK][https_www.wikiwand.com_zh-hans_GBK]。

与此同时，其他国家也为自己国家的语言设计了相应的编码。但结果导致除了英文以外，各国语言的编码都无法进行兼容。国际标谁化组织(ISO)意识到问题的严重性，设计了一种包含所有国家语言单元的编码，也就是`Unicode`。考虑到性能和资源的平衡，最终使用两个字节来表示字符，由于2^16=65535，所以可以基本上涵盖绝大多数语言的字符单元。相比于之前的单双字节并存的编码方式，双字节是如何对原有单字节对应的字符进行表示呢？其实很简单，添加全0作为高字节，原有单字节作为低字节。但这样一来，英文字符就得用两个字节来进行表示，就会造成资源的浪费。举例来说，It’s 日报对应的Unicode编码如下所示：

I 00000000 01001001
    t 00000000 01110100
    ' 00000000 00100111
    s 00000000 01110011
      00000000 00100000
    日 01100101 11100101
    报 01100010 10100101

那么能否依然使用单字节表示英文字符，从而节省资源呢。`UTF-8`就应运而生，UTF-8的设计思想如下所示：

1.  单字节的字符，字节的第一位设为0，对于英语文本，UTF-8码只占用一个字节，和ASCII码完全相同；
2.  n个字节的字符(n>1)，第一个字节的前n位设为1，第n+1位设为0，后面字节的前两位都设为10，这n个字节的其余空位填充该字符unicode码，高位用0补足。这样就形成了如下的UTF-8标记位：

0xxxxxxx
    110xxxxx 10xxxxxx
    1110xxxx 10xxxxxx 10xxxxxx
    11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
    111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
    1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx... ...

所以It’s 日报的编码就变成了：

I 01001001
    t 01110100
    ' 00100111
    s 01110011
      00100000
    日 11100110 10010111 10100101
    报 11100110 10001010 10100101

和上边的方案对比一下，英文短了，每个中文字符却多用了一个字节。但是整个字符串只用了11个字节，比上边的14个字节短了一些。所以对于字符串来说，更多的使用的是UTF-8编码。

# 2. Python Unicode实战 #

## 2.1 操作单个字符 ##

### 2.1.1 判断单个字符所属类型 ###

对单个字符进行处理，最常用的函数为unicodedata.category()。将部分常用的返回类型列举如下：

*  \[Cc\] Other, Control
 *  \[Cf\] Other, Format
 *  
 *  \[Pc\] Punctuation, Connector
 *  \[Pd\] Punctuation, Dash
 *  \[Pe\] Punctuation, Close
 *  \[Pf\] Punctuation, Final quote (may behave like Ps or Pe depending on usage)
 *  \[Pi\] Punctuation, Initial quote (may behave like Ps or Pe depending on usage)
 *  \[Po\] Punctuation, Other
 *  \[Ps\] Punctuation, Open
 *  
 *  \[Mn\] Mark, Nonspacing
 *  \[Zs\] Separator, Space

其他类型可详见链接：[https://www.wikiwand.com/en/Unicode\_character\_property][https_www.wikiwand.com_en_Unicode_character_property]。

### 2.1.2 判断单个字符是否属于中文 ###

def is_chinese_char(cp):
        """Checks whether CP is the codepoint of a CJK character."""
        # This defines a "chinese character" as anything in the CJK Unicode block:
        # https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
        #
        # Note that the CJK Unicode block is NOT all Japanese and Korean characters,
        # despite its name. The modern Korean Hangul alphabet is a different block,
        # as is Japanese Hiragana and Katakana. Those alphabets are used to write
        # space-separated words, so they are not treated specially and handled
        # like the all of the other languages.
        if ((cp >= 0x4E00 and cp <= 0x9FFF) or  #
            (cp >= 0x3400 and cp <= 0x4DBF) or  #
            (cp >= 0x20000 and cp <= 0x2A6DF) or  #
            (cp >= 0x2A700 and cp <= 0x2B73F) or  #
            (cp >= 0x2B740 and cp <= 0x2B81F) or  #
            (cp >= 0x2B820 and cp <= 0x2CEAF) or
            (cp >= 0xF900 and cp <= 0xFAFF) or  #
            (cp >= 0x2F800 and cp <= 0x2FA1F)):  #
          return True
    
        return False

### 2.1.3 判断是否是空白符 ###

如果不考虑Unicode编码的话，空白符即为\\r、\\t、\\n和空格。

def is_whitespace(char):
        """Checks whether `chars` is a whitespace character."""
        # \t, \n, and \r are technically contorl characters but we treat them
        # as whitespace since they are generally considered as such.
        if char == " " or char == "\t" or char == "\n" or char == "\r":
            return True
        cat = unicodedata.category(char)
        if cat == "Zs":
            return True
        return False

### 2.1.4 判断是否是控制符 ###

Unicode中除了空格以外的空白符均认为是控制符，具体如下所示：

import unicodedata
    print(unicodedata.category('\r'))
    print(unicodedata.category('\t'))
    print(unicodedata.category('\n'))

![在这里插入图片描述][015af33169a5408499a4ae0c2748096f.png_pic_center]  
  所以正确的处理逻辑是先判断是否为空白符（不包含空格），然后再通过unicodedata判断是否为控制符。

def _is_control(char):
        """Checks whether `chars` is a control character."""
        # These are technically control characters but we count them as whitespace
        # characters.
        if char == "\t" or char == "\n" or char == "\r":
            return False
        cat = unicodedata.category(char)
        if cat in ("Cc", "Cf"):
            return True
        return False

### 2.1.5 是否为标点符号 ###

如果不考虑unicode编码，则只需保留第一个分支：

def is_punctuation(char):
        """Checks whether `chars` is a punctuation character."""
        cp = ord(char)
        # We treat all non-letter/number ASCII as punctuation.
        # Characters such as "^", "$", and "`" are not in the Unicode
        # Punctuation class but we treat them as punctuation anyways, for
        # consistency.
        if ((cp >= 33 and cp <= 47) or (cp >= 58 and cp <= 64) or
                (cp >= 91 and cp <= 96) or (cp >= 123 and cp <= 126)):
            return True
        cat = unicodedata.category(char)
        if cat.startswith("P"):
            return True
        return False

## 2.2 字符串处理 ##

### 2.2.1 将文本转换成Unicode ###

在Python3中，字符串的默认编码方式均为UTF-8。

def convert_to_unicode(text):
        """Converts `text` to Unicode (if it's not already), assuming utf-8 input."""
            if isinstance(text, str):
                return text
            elif isinstance(text, bytes):
                return text.decode("utf-8", "ignore")
            else:
                raise ValueError("Unsupported string type: %s" % (type(text)))

### 2.2.2 清理文本中的无效字符 ###

除了清理无效字符以外，顺便把所有空白符转换成了空格。

def clean_text(text):
        """Performs invalid character removal and whitespace cleanup on text."""
        output = []
        for char in text:
            cp = ord(char)
            if cp == 0 or cp == 0xfffd or is_control(char):
                continue
            if is_whitespace(char):
                output.append(" ")
            else:
                output.append(char)
        return "".join(output)

### 2.2.3 清理文本中的重音符号 ###

def strip_accents(text):
        """Strips accents from a piece of text."""
        text = unicodedata.normalize("NFD", text)
        output = []
        for char in text:
            cat = unicodedata.category(char)
            if cat == "Mn":
                continue
            output.append(char)
        return "".join(output)

### 2.2.4 将字符串中的文本和标点符号进行划分 ###

有时候需要把字符串中的标点符号单独划分处理，从而输入一个字符串得到多个字符串构成的列表，使用下列函数即可达到如此效果：

def split_on_punc(text):
        """Splits punctuation on a piece of text."""
        chars = list(text)
        i = 0
        start_new_word = True
        output = []
        while i < len(chars):
            char = chars[i]
            if is_punctuation(char):
                output.append([char])
                start_new_word = True
            else:
                if start_new_word:
                    output.append([])
                start_new_word = False
                output[-1].append(char)
            i += 1
    
        return ["".join(x) for x in output]

### 2.2.5 对文本进行分词 ###

def tokenize(text):
        """Tokenizes a piece of text."""
        text = convert_to_unicode(text)
        text = clean_text(text)
        text = tokenize_chinese_chars(text)
    
        orig_tokens = whitespace_tokenize(text)# str to list of str
        split_tokens = []
        for token in orig_tokens:# get str of list of str
            if self.do_lower_case:
                token = token.lower()
                token = strip_accents(token)
            split_tokens.extend(split_on_punc(token))# list of str
    
        output_tokens = whitespace_tokenize(" ".join(split_tokens))# list of str
        return output_tokens

留个小疑问，为什么在orig\_tokens = whitespace\_tokenize(text)后又进行了output\_tokens = whitespace\_tokenize(" ".join(split\_tokens))，也就是whitespace\_tokenize执行两次的意义是在哪里呢？

[https_ttssh2.osdn.jp_manual_4_en_macro_appendixes_ascii.html]: https://ttssh2.osdn.jp/manual/4/en/macro/appendixes/ascii.html
[https_www.wikiwand.com_zh-hans_GB_2312]: https://www.wikiwand.com/zh-hans/GB_2312
[https_www.wikiwand.com_zh-hans_GBK]: https://www.wikiwand.com/zh-hans/GBK
[https_www.wikiwand.com_en_Unicode_character_property]: https://www.wikiwand.com/en/Unicode_character_property
[015af33169a5408499a4ae0c2748096f.png_pic_center]: /images/20220829/0b661d5c8fe645ddb8708ff04dd3d512.png