Maison >développement back-end >Tutoriel Python >Introduction détaillée aux chaînes et au codage de caractères en Python
Introduction détaillée aux chaînes et au codage de caractères en Python
- 高洛峰original
- 2017-03-20 10:01:041193parcourir
1. Préface
Le codage de caractères en Python est un sujet courant et des collègues ont écrit de nombreux articles à ce sujet. Certaines personnes suivent ce qu’elles disent et d’autres écrivent en profondeur. Récemment, j'ai vu une vidéo pédagogique d'un établissement de formation bien connu parlant à nouveau de cette question, mais l'explication n'était toujours pas satisfaisante, j'ai donc voulu écrire cet article. D'une part, je veux trier les connaissances pertinentes, et d'autre part, j'espère aider les autres.
L'encodage par défaut de Python2 est ASCII, qui ne peut pas reconnaître les caractères chinois, et vous devez spécifier explicitement l'encodage des caractères ; l'encodage par défaut de Python3 est Unicode, qui peut reconnaître les caractères chinois.
Je crois que vous avez vu des explications comme celles ci-dessus pour le "traitement chinois en Python" dans de nombreux articles, et je crois que vous l'avez vraiment compris lorsque vous avez vu une telle explication pour la première fois. Mais après un long moment, si vous rencontrez encore et encore des problèmes connexes, vous aurez l'impression que vous ne semblez pas le comprendre aussi clairement. Si nous comprenons quel est le codage par défaut mentionné ci-dessus, nous comprendrons plus clairement le sens de cette phrase.
Il convient de noter que "qu'est-ce que le codage de caractères" et "le processus de développement du codage de caractères" ne sont pas les sujets abordés dans cette section. Pour ces contenus, vous pouvez vous référer à mon précédent <
>.
2. Concepts associés
1. Caractères et octets
Un caractère n'est pas équivalent à un octet, les caractères peuvent être reconnus par les humains Symboles, et ces symboles doivent être représentés par des octets que l'ordinateur peut reconnaître afin d'être enregistrés dans le stockage informatique. Un caractère a souvent plusieurs méthodes de représentation, et différentes méthodes de représentation utilisent différents nombres d'octets. Les différentes méthodes de représentation mentionnées ici font référence au codage de caractères. Par exemple, les lettres A à Z peuvent être représentées par du code ASCII (occupant un octet), UNICODE (occupant deux octets) ou UTF-8 (occupant un octet). Le rôle du codage de caractères est de convertir les caractères reconnaissables par l'homme en bytecodes reconnaissables par la machine, et le processus inverse.
UNICDOE est la vraie chaîne, tandis que les codages de caractères tels que ASCII, UTF-8, GBK, etc. représentent des chaînes d'octets. À ce sujet, on peut souvent voir de telles descriptions dans la documentation officielle de Python : "Unicode string", "traduire une chaîne Unicode en une séquence d'octets"
lorsque nous écrivons du code est écrit dans le fichier, et les caractères sont stockés dans le fichier sous forme d'octets, il est donc compréhensible que lorsque nous définissons une chaîne dans le fichier, elle soit traitée comme une chaîne d'octets. Cependant, nous avons besoin d’une chaîne, pas d’une chaîne d’octets. Un excellent langage de programmation doit distinguer strictement la relation entre les deux et fournir un support intelligent et parfait. Le langage JAVA est si bon qu'avant d'apprendre Python et PHP, je n'avais jamais envisagé ces problèmes qui ne devraient pas être traités par les programmeurs. Malheureusement, de nombreux langages de programmation tentent de confondre « chaîne » et « chaîne d'octets ». Ils utilisent des chaînes d'octets comme chaînes. PHP et Python2 appartiennent tous deux à ce type de langage de programmation. L'opération qui illustre le mieux ce problème est de prendre la longueur d'une chaîne contenant des caractères chinois :
Prenez la longueur de la chaîne, et le résultat doit être le nombre de toutes les chaînes, qu'elles soient Chinois ou anglais
La longueur de la chaîne d'octets correspondant à la chaîne est liée à l'encodage de caractères utilisé dans le processus d'encodage (par exemple : encodage UTF-8, un caractère chinois a besoin de 3 octets à représenter ; encodage GBK, un caractère chinois nécessite 2 octets pour représenter)
Remarque : l'encodage de caractères par défaut du terminal cmd Windows est GBK, donc l'encodage de caractères saisi en caractères chinois cmd doit être représenté par deux octets
>>> # Python2
>>> a = 'Hello,中国' # 字节串，长度为字节个数 = len('Hello,')+len('中国') = 6+2*2 = 10
>>> b = u'Hello,中国' # 字符串，长度为字符个数 = len('Hello,')+len('中国') = 6+2 = 8
>>> c = unicode(a, 'gbk') # 其实b的定义方式是c定义方式的简写，都是将一个GBK编码的字节串解码（decode）为一个Uniocde字符串
>>>
>>> print(type(a), len(a))
(<type 'str'>, 10)
>>> print(type(b), len(b))
(<type 'unicode'>, 8)
>>> print(type(c), len(c))
(<type 'unicode'>, 8)
>>>
La prise en charge des chaînes dans Python3 a été considérablement modifiée. Le contenu spécifique sera présenté ci-dessous.
2. Encodage et décodage
Faisons d'abord un peu de vulgarisation scientifique : l'encodage de caractères UNICODE est également un mappage de caractères et de nombres, mais les nombres ici sont appelés points de code. nombre hexadécimal.
La documentation officielle de Python contient cette description de la relation entre les chaînes Unicode, les chaînes d'octets et l'encodage :
La chaîne Unicode est une séquence de points de code, la plage de valeurs des points de code est 0 à 0x10FFFF (la valeur décimale correspondante est 1114111). Cette séquence de points de code doit être représentée dans le stockage (y compris la mémoire et le disque physique) comme un ensemble d'octets (valeurs comprises entre 0 et 255), et les règles de conversion des chaînes Unicode en séquences d'octets sont appelées encodages.
这里说的编码不是指字符编码，而是指编码的过程以及这个过程中所使用到的Unicode字符的代码点与字节的映射规则。这个映射不必是简单的一对一映射，因此编码过程也不必处理每个可能的Unicode字符，例如：
将Unicode字符串转换为ASCII编码的规则很简单--对于每个代码点：
如果代码点数值<128，则每个字节与代码点的值相同
如果代码点数值>=128，则Unicode字符串无法在此编码中进行表示（这种情况下，Python会引发一个UnicodeEncodeError异常）
将Unicode字符串转换为UTF-8编码使用以下规则：
如果代码点数值<128，则由相应的字节值表示（与Unicode转ASCII字节一样）
如果代码点数值>=128，则将其转换为一个2个字节，3个字节或4个字节的序列，该序列中的每个字节都在128到255之间。
简单总结：
编码(encode)：将Unicode字符串（中的代码点)转换特定字符编码对应的字节串的过程和规则
解码(decode)：将特定字符编码的字节串转换为对应的Unicode字符串(中的代码点)的过程和规则
可见，无论是编码还是解码，都需要一个重要因素，就是特定的字符编码。因为一个字符用不同的字符编码进行编码后的字节值以及字节个数大部分情况下是不同的，反之亦然。
三、Python中的默认编码
1. Python源代码文件的执行过程
我们都知道，磁盘上的文件都是以二进制格式存放的，其中文本文件都是以某种特定编码的字节形式存放的。对于程序源代码文件的字符编码是由编辑器指定的，比如我们使用Pycharm来编写Python程序时会指定工程编码和文件编码为UTF-8，那么Python代码被保存到磁盘时就会被转换为UTF-8编码对应的字节（encode过程）后写入磁盘。当执行Python代码文件中的代码时，Python解释器在读取Python代码文件中的字节串之后，需要将其转换为UNICODE字符串（decode过程）之后才执行后续操作。
上面已经解释过，这个转换过程（decode，解码）需要我们指定文件中保存的字节使用的字符编码是什么，才能知道这些字节在UNICODE这张万国码和统一码中找到其对应的代码点是什么。这里指定字符编码的方式大家都很熟悉，如下所示：
# -*- coding:utf-8 -*-
2. 默认编码
那么，如果我们没有在代码文件开始的部分指定字符编码，Python解释器就会使用哪种字符编码把从代码文件中读取到的字节转换为UNICODE代码点呢？就像我们配置某些软件时，有很多默认选项一样，需要在Python解释器内部设置默认的字符编码来解决这个问题，这就是文章开头所说的“默认编码”。因此大家所说的Python中文字符问题就可以总结为一句话：当无法通过默认的字符编码对字节进行转换时，就会出现解码错误(UnicodeEncodeError)。
Python2和Python3的解释器使用的默认编码是不一样的，我们可以通过sys.getdefaultencoding()来获取默认编码：
>>> # Python2 >>> import sys >>> sys.getdefaultencoding() 'ascii' >>> # Python3 >>> import sys >>> sys.getdefaultencoding() 'utf-8'
因此，对于Python2来讲，Python解释器在读取到中文字符的字节码尝试解码操作时，会先查看当前代码文件头部是否有指明当前代码文件中保存的字节码对应的字符编码是什么。如果没有指定则使用默认字符编码"ASCII"进行解码导致解码失败，导致如下错误：
SyntaxError: Non-ASCII character '\xc4' in file xxx.py on line 11, but no encoding declared; see http://python.org/dev/peps/pep-0263/ for details
对于Python3来讲，执行过程是一样的，只是Python3的解释器以"UTF-8"作为默认编码，但是这并不表示可以完全兼容中文问题。比如我们在Windows上进行开发时，Python工程及代码文件都使用的是默认的GBK编码，也就是说Python代码文件是被转换成GBK格式的字节码保存到磁盘中的。Python3的解释器执行该代码文件时，试图用UTF-8进行解码操作时，同样会解码失败，导致如下错误：
SyntaxError: Non-UTF-8 code starting with '\xc4' in file xxx.py on line 11, but no encoding declared; see http://python.org/dev/peps/pep-0263/ for details
3. 最佳实践
创建一个工程之后先确认该工程的字符编码是否已经设置为UTF-8
为了兼容Python2和Python3，在代码头部声明字符编码：-*- coding:utf-8 -*-
四、Python2与Python3中对字符串的支持
其实Python3中对字符串支持的改进，不仅仅是更改了默认编码，而是重新进行了字符串的实现，而且它已经实现了对UNICODE的内置支持，从这方面来讲Python已经和JAVA一样优秀。下面我们来看下Python2与Python3中对字符串的支持有什么区别：
Python2
Python2中对字符串的支持由以下三个类提供
class basestring(object) class str(basestring) class unicode(basestring)
执行help(str)和help(bytes)会发现结果都是str类的定义，这也说明Python2中str就是字节串，而后来的unicode对象对应才是真正的字符串。
#!/usr/bin/env python # -*- coding:utf-8 -*- a = '你好' b = u'你好' print(type(a), len(a)) print(type(b), len(b)) 输出结果： (<type 'str'>, 6) (<type 'unicode'>, 2)
Python3
Python3中对字符串的支持进行了实现类层次的上简化，去掉了unicode类，添加了一个bytes类。从表面上来看，可以认为Python3中的str和unicode合二为一了。
class bytes(object) class str(object)
实际上，Python3中已经意识到之前的错误，开始明确的区分字符串与字节。因此Python3中的str已经是真正的字符串，而字节是用单独的bytes类来表示。也就是说，Python3默认定义的就是字符串，实现了对UNICODE的内置支持，减轻了程序员对字符串处理的负担。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = '你好'
b = u'你好'
c = '你好'.encode('gbk')
print(type(a), len(a))
print(type(b), len(b))
print(type(c), len(c))
输出结果：
<class 'str'> 2
<class 'str'> 2
<class 'bytes'> 4
五、字符编码转换
上面提到，UNICODE字符串可以与任意字符编码的字节进行相互转换，如图：
那么大家很容易想到一个问题，就是不同的字符编码的字节可以通过Unicode相互转换吗？答案是肯定的。
Python2中的字符串进行字符编码转换过程是：
字节串-->decode('原来的字符编码')-->Unicode字符串-->encode('新的字符编码')-->字节串
#!/usr/bin/env python
# -*- coding:utf-8 -*-
utf_8_a = '我爱中国'
gbk_a = utf_8_a.decode('utf-8').encode('gbk')
print(gbk_a.decode('gbk'))
输出结果：
我爱中国
Python3中定义的字符串默认就是unicode，因此不需要先解码，可以直接编码成新的字符编码：
字符串-->encode('新的字符编码')-->字节串
#!/usr/bin/env python
# -*- coding:utf-8 -*-
utf_8_a = '我爱中国'
gbk_a = utf_8_a.encode('gbk')
print(gbk_a.decode('gbk'))
输出结果：
我爱中国
最后需要说明的是，Unicode不是有道词典，也不是google翻译器，它并不能把一个中文翻译成一个英文。正确的字符编码的转换过程只是把同一个字符的字节表现形式改变了，而字符本身的符号是不应该发生变化的，因此并不是所有的字符编码之间的转换都是有意义的。怎么理解这句话呢？比如GBK编码的“中国”转成UTF-8字符编码后，仅仅是由4个字节变成了6个字节来表示，但其字符表现形式还应该是“中国”，而不应该变成“你好”或者“China”。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!