admin管理员组

文章数量:1566631

相关阅读：python字符串-内建函数、转义字符、运算符

第3章 使用字符串

关于字符串与字符串的编码，可参考：廖雪峰的文章
Unicode ( https://www.unicode/ ) 是一种规范，旨在列出人类语言使用的每个字符，并为每个字符提供自己的唯一代码。Unicode 规范不断修订和更新，以添加新的语言和符号。
由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

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

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；

第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码：

如果.py文件本身使用UTF-8编码，并且也申明了# -*- coding: utf-8 -*-，打开命令提示符测试就可以正常显示中文：

在操作字符串时，我们经常遇到str和bytes的互相转换。为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。

3.1 字符串基本操作

所有标准序列操作（索引、切片、加法、乘法、成员检查、长度、最小值和最大值）都适合于字符串，但字符串是不可变的，因此所有的元素赋值和切片赋值都是非法的。

>>> site = 'http://www.python'
>>> site[:-3]
'http://www.python.'
>>> site[:-3]='com'
Traceback (most recent call last):
  File "<pyshell#21>", line 1, in <module>
    website[:-3]='com'
TypeError: 'str' object does not support item assignment

3.2 设置字符串的格式：精简版

Python提供了多种字符串格式设置方法。指定要设置其格式的值时，可使用单个值（如字符串或数字），可使用元组（如果要设置多个值的格式），还可使用字典（这将在下一章讨论），其中最常见的是元组。

什么是格式字符串
一个常见的问题是如何输出格式化的字符串。我们经常会输出类似'亲爱的xxx你好！你xx月的话费是xx，余额是xx'之类的字符串，而xxx的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的方式。


在Python中，采用的格式化方式和C语言是一致的，用%实现，举例如下：

>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'

你可能猜到了，%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
在字符串中通过格式占位符来代替字符串中变换的部分，然后通过数据或者变量确定变化

语法：包含占位符的字符串 % (值1, 值2, 值3...)

说明：

占位符说明
%s字符串占位符
%d整数占位符
%f小数占位符
%c字符占位符（可以将数字转化成对应字符）
%.Nf保留小数点后N位小数（会四舍五入）

() - 固定写法，字符串中只有一个占位符的时候这个括号可以省略
括号里面的值要和占位符位置和类型一一对应。

name = input('请输入名字：')
sex = input('请输入性别：')
message = '我叫%s,性别：%s 年龄%d岁'%(name, sex, 18)

使用字符串方法format
使用这种方法时，每个替换字段都用花括号括起，其中可能包含名称，还可能包含有关如何对相应的值进行转换和格式设置的信息。
在最简单的情况下，替换字段没有名称或将索引用作名称。

>>> "{}, {} and {}".format("first", "second", "third") 
'first, second and third' 
>>> "{0}, {1} and {2}".format("first", "second", "third") 
'first, second and third'

然而，索引无需像上面这样按顺序排列。

>>> "{3} {0} {2} {1} {3} {0}".format("be", "not", "or", "to") 
'to be or not to be'

命名字段的工作原理与你预期的完全相同。

>>> from math import pi 
>>> "{name} is approximately {value:.2f}.".format(value=pi, name="π") 
'π is approximately 3.14.'

当然，关键字参数的排列顺序无关紧要。在这里，我还指定了格式说明符.2f，并使用冒号
将其与字段名隔开。它意味着要使用包含2位小数的浮点数格式。如果没有指定.2f，结果将如下：

>>> "{name} is approximately {value}.".format(value=pi, name="π") 
'π is approximately 3.141592653589793.'

最后，如果变量与替换字段同名，还可使用一种简写。在这种情况下，可
使用f字符串——在字符串前面加上f。

>>> from math import e 
>>> f"Euler's constant is roughly {e}." 
"Euler's constant is roughly 2.718281828459045."

在这里，创建最终的字符串时，将把替换字段e替换为变量e的值。这与下面这个更明确一些的表达式等价：

>>> "Euler's constant is roughly {e}.".format(e=e) 
"Euler's constant is roughly 2.718281828459045."

替换字段名

混合使用未命名字段和命名字段

>>> "{foo} {} {bar} {}".format(1, 2, bar=4, foo=3) 
'3 1 4 2'

还可通过索引来指定要在哪个字段中使用相应的未命名参数，这样可不按顺序使用未命名参数。

>>> "{foo} {1} {bar} {0}".format(1, 2, bar=4, foo=3) 
'3 2 4 1'

以下内容选读，不适合初学者

3.3 设置字符串的格式：完整版

这里的基本思想是对字符串调用方法format，并提供要设置其格式的值。字符串包含有关如何设置格式的信息，而这些信息是使用一种**微型格式指定语言（mini-language）**指定的。每个值都被插入字符串中，以替换用花括号括起的替换字段。要在最终结果中包含花括号，可在格式字符串中使用两个花括号（即{{或}}）来指定。

>>> "{{ceci n'est pas une replacement field}}".format() 
"{ceci n'est pas une replacement field}"

在格式字符串中，最激动人心的部分为替换字段。替换字段由如下部分组成，其中每个部分都是可选的。

  • 字段名：索引或标识符，指出要设置哪个值的格式并使用结果来替换该字段。除指定值
    外，还可指定值的特定部分，如列表的元素。
  • 转换标志：跟在叹号后面的单个字符。当前支持的字符包括r（表示repr）、s（表示str）
    和a（表示ascii）。如果你指定了转换标志，将不使用对象本身的格式设置机制，而是使用指定的函数将对象转换为字符串，再做进一步的格式设置。
  • 格式说明符：跟在冒号后面的表达式（这种表达式是使用微型格式指定语言表示的）。格式说明符让我们能够详细地指定最终的格式，包括格式类型（如字符串、浮点数或十六进制数），字段宽度和数的精度，如何显示符号和千位分隔符，以及各种对齐和填充方式。
替换字段名

混合使用未命名字段和命名字段

>>> "{foo} {} {bar} {}".format(1, 2, bar=4, foo=3) 
'3 1 4 2'

还可通过索引来指定要在哪个字段中使用相应的未命名参数，这样可不按顺序使用未命名参数。

>>> "{foo} {1} {bar} {0}".format(1, 2, bar=4, foo=3) 
'3 2 4 1'

（高级）选读
你并非只能使用提供的值本身，而是可访问其组成部分（就像在常规Python代码中一样）

>>> fullname = ["Alfred", "Smoketoomuch"] 
>>> "Mr {name[1]}".format(name=fullname) 
'Mr Smoketoomuch' 
>>> import math 
>>> tmpl = "The {mod.__name__} module defines the value {mod.pi} for π" 
>>> tmpl.format(mod=math) 
'The math module defines the value 3.141592653589793 for π'

如你所见，可使用索引，还可使用句点表示法来访问导入的模块中的方法、属性、变量和函数（看起来很怪异的变量__name__包含指定模块的名称）。

3.3.2 基本转换

指定要在字段中包含的值后，就可添加有关如何设置其格式的指令了。首先，提供一个转换标志。

>>> print("{pi!s} {pi!r} {pi!a}".format(pi="π")) 
π 'π' '\u03c0'

上述三个标志（s、r和a）指定分别使用str、repr和ascii进行转换。函数str通常创建外观普通的字符串版本（没有对输入字符串做任何处理）。函数repr尝试创建给定值的Python表示（这里是一个字符串字面量）。函数ascii创建只包含ASCII字符的表示.。
还可指定要转换的值是哪种类型，更准确地说，是要将其视为哪种类型。例如，你可能提供一个整数，但将其作为小数进行处理。为此可在格式说明（即冒号后面）使用字符f（表示定点数）。

>>> "The number is {num}".format(num=42) 
'The number is 42' 
>>> "The number is {num:f}".format(num=42) 
'The number is 42.000000' 
你也可以将其作为二进制数进行处理。
>>> "The number is {num:b}".format(num=42) 
'The number is 101010'

这样的类型说明符有多个，完整的清单见表3-1。
表3-1 字符串格式设置中的类型说明符

类型含 义
b将整数表示为二进制数
c将整数解读为Unicode码点
d将整数视为十进制数进行处理，这是整数默认使用的说明符
e使用科学表示法来表示小数（用e来表示指数）
E与e相同，但使用E来表示指数
f将小数表示为定点数
F与f相同，但对于特殊值（nan和inf），使用大写表示
g自动在定点表示法和科学表示法之间做出选择。这是默认用于小数的说明符，但在默认情况下至少有1位小数
G与g相同，但使用大写来表示指数和特殊值
n与g相同，但插入随区域而异的数字分隔符
o将整数表示为八进制数
s保持字符串的格式不变，这是默认用于字符串的说明符
x将整数表示为十六进制数并使用小写字母
X与x相同，但使用大写字母
%将数表示为百分比值（乘以100，按说明符f设置格式，再在后面加上%）
3.3.3 宽度、精度和千位分隔符

设置浮点数（或其他更具体的小数类型）的格式时，默认在小数点后面显示6位小数，并根据需要设置字段的宽度，而不进行任何形式的填充。当然，这种默认设置可能不是你想要的，在这种情况，可根据需要在格式说明中指定宽度和精度。
宽度是使用整数指定的，如下所示：

>>> "{num:10}".format(num=3) 
' 3' 
>>> "{name:10}".format(name="Bob") 
'Bob '

如你所见，数和字符串的对齐方式不同。精度也是使用整数指定的，但需要在它前面加上一个表示小数点的句点。

>>> "Pi day is {pi:.2f}".format(pi=pi) 
'Pi day is 3.14'

这里显式地指定了类型f，当然，可同时指定宽度和精度。

>>> "{pi:10.2f}".format(pi=pi) 
' 3.14'

实际上，对于其他类型也可指定精度，但是这样做的情形不太常见。

>>> "{:.5}".format("Guido van Rossum") 
'Guido'

最后，可使用逗号来指出你要添加千位分隔符。

>>> 'One googol is {:,}'.format(10**100) 
'One googol is 10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000'

同时指定其他格式设置元素时，这个逗号应放在宽度和表示精度的句点之间①。

3.3.4 符号、对齐和用 0 填充

有很多用于设置数字格式的机制，比如便于打印整齐的表格。在大多数情况下，只需指定宽度和精度，但包含负数后，原本漂亮的输出可能不再漂亮。另外，正如你已看到的，字符串和数的默认对齐方式不同。在一栏中同时包含字符串和数时，你可能想修改默认对齐方式。在指定宽度和精度的数前面，可添加一个标志。这个标志可以是零、加号、减号或空格，其中零表示使用0来填充数字。

>>> '{:010.2f}'.format(pi) 
'0000003.14'

要指定左对齐、右对齐和居中，可分别使用<、>和^。

>>> print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'.format(pi)) 
3.14 
 3.14 
 3.14

可以使用填充字符来扩充对齐说明符，这样将使用指定的字符而不是默认的空格来填充。

>>> "{:$^15}".format(" WIN BIG ") 
'$$$ WIN BIG $$$'

还有更具体的说明符=，它指定将填充字符放在符号和数字之间。

>>> print('{0:10.2f}\n{1:10.2f}'.format(pi, -pi)) 
 3.14 
 -3.14 
>>> print('{0:10.2f}\n{1:=10.2f}'.format(pi, -pi)) 
 3.14 
-3.14

如果要给正数加上符号，可使用说明符+（将其放在对齐说明符后面），而不是默认的-。如果将符号说明符指定为空格，会在正数前面加上空格而不是+。

>>> print('{0:-.2}\n{1:-.2}'.format(pi, -pi)) #默认设置
3.1 
-3.1 
>>> print('{0:+.2}\n{1:+.2}'.format(pi, -pi)) 
+3.1 
-3.1 
>>> print('{0: .2}\n{1: .2}'.format(pi, -pi)) 
 3.1 
-3.1

需要介绍的最后一个要素是井号（#）选项，你可将其放在符号说明符和宽度之间（如果指定了这两种设置）。这个选项将触发另一种转换方式，转换细节随类型而异。例如，对于二进制、八进制和十六进制转换，将加上一个前缀。

>>> "{:b}".format(42) 
'101010' 
>>> "{:#b}".format(42) 
'0b101010'

对于各种十进制数，它要求必须包含小数点（对于类型g，它保留小数点后面的零）。

>>> "{:g}".format(42) 
'42' 
>>> "{:#g}".format(42) 
'42.0000'

在代码清单3-1所示的示例中，我分两次设置了字符串的格式，其中第一次旨在插入最终将作为格式说明符的字段宽度。这是因为这些信息是由用户提供的，我无法以硬编码的方式指定字段宽度。
代码清单3-1 字符串格式设置示例

# 根据指定的宽度打印格式良好的价格列表
width = int(input('Please enter width: ')) 
price_width = 10 
item_width = width - price_width 
header_fmt = '{{:{}}}{{:>{}}}'.format(item_width, price_width) 
fmt = '{{:{}}}{{:>{}.2f}}'.format(item_width, price_width) 
print('=' * width) 
print(header_fmt.format('Item', 'Price')) 
print('-' * width) 
print(fmt.format('Apples', 0.4)) 
print(fmt.format('Pears', 0.5)) 
print(fmt.format('Cantaloupes', 1.92)) 
print(fmt.format('Dried Apricots (16 oz.)', 8)) 
print(fmt.format('Prunes (4 lbs.)', 12)) 
print('=' * width)

这个程序的运行情况类似于下面这样：

Please enter width: 35 
=================================== 
Item Price 
----------------------------------- 
Apples 0.40 
Pears 0.50 
Cantaloupes 1.92 
Dried Apricots (16 oz.) 8.00 
Prunes (4 lbs.) 12.00 
```python
=================================== 
### 3.4 字符串方法
前面介绍了列表的方法，而字符串的方法要多得多，因为其很多方法都是从模块string那里“继承”而来的。（在较早的Python版本中，这些方法为模块string中的函数。如果需要，现在依然能够找到这些函数。）
字符串的方法太多了，这里只介绍一些最有用的。完整的字符串方法清单请参阅附录B。这里描述字符串的方法时，将列出其他相关的方法。如果这些相关方法在本章做了介绍，将用“另请参见”标识，否则用“附录B”标识。
**模块string未死**
虽然字符串方法完全盖住了模块string的风头，但这个模块包含一些字符串没有的常量和函数。下面就是模块string中几个很有用的常量①。
- string.digits：包含数字0～9的字符串。
- string.ascii_letters：包含所有ASCII字母（大写和小写）的字符串。
- string.ascii_lowercase：包含所有小写ASCII字母的字符串。
- string.printable：包含所有可打印的ASCII字符的字符串。
- string.punctuation：包含所有ASCII标点字符的字符串。
- string.ascii_uppercase：包含所有大写ASCII字母的字符串。
虽然说的是ASCII字符，但值实际上是未解码的Unicode字符串。
#### 3.4.1 center
方法center通过在两边添加填充字符（默认为空格）让字符串居中。
>>> "The Middle by Jimmy Eat World".center(39) 
' The Middle by Jimmy Eat World ' 
>>> "The Middle by Jimmy Eat World".center(39, "*") 
'*****The Middle by Jimmy Eat World*****'
附录B：ljust、rjust和zfill。
#### 3.4.2 find
方法find在字符串中查找子串。如果找到，就返回子串的第一个字符的索引，否则返回-1。
```python
>>> 'With a moo-moo here, and a moo-moo there'.find('moo') 
7 
>>> title = "Monty Python's Flying Circus" 
>>> title.find('Monty') 
0 
>>> title.find('Python') 
>>> title.find('Flying') 
15 
>>> title.find('Zirquss') 
-1

第2章初识成员资格时，我们在垃圾邮件过滤器中检查主题是否包含’$$$'。这种检查也可使用find来执行。（在Python 2.3之前的版本中，这种做法也管用，但in只能用于检查单个字符是否包含在字符串中。）

>>> subject = '$$$ Get rich now!!! $$$' 
>>> subject.find('$$$') 
0

注意 字符串方法find返回的并非布尔值。如果find像这样返回0，就意味着它在索引0处找到了指定的子串。你还可指定搜索的起点和终点（它们都是可选的）。

>>> subject = '$$$ Get rich now!!! $$$' 
>>> subject.find('$$$') 
0 
>>> subject.find('$$$', 1) # 只指定了起点
20 
>>> subject.find('!!!') 
16 
>>> subject.find('!!!', 0, 16) # 同时指定了起点和终点
-1

请注意，起点和终点值（第二个和第三个参数）指定的搜索范围包含起点，但不包含终点。这是Python惯常的做法。
附录B：rfind、index、rindex、count、startswith、endswith。

3.4.3 join

join是一个非常重要的字符串方法，其作用与split相反，用于合并序列的元素。

>>> seq = [1, 2, 3, 4, 5] 
>>> sep = '+' 
>>> sep.join(seq) # 尝试合并一个数字列表
Traceback (most recent call last): 
 File "<stdin>", line 1, in ? 
TypeError: sequence item 0: expected string, int found 
>>> seq = ['1', '2', '3', '4', '5'] 
>>> sep.join(seq) # 合并一个字符串列表
'1+2+3+4+5' 
>>> dirs = '', 'usr', 'bin', 'env' 
>>> '/'.join(dirs) 
'/usr/bin/env' 
>>> print('C:' + '\\'.join(dirs)) 
C:\usr\bin\env

如你所见，所合并序列的元素必须都是字符串。注意到在最后两个示例中，我使用了一系列目录，并按UNIX和DOS/Windows的约定设置其格式：通过使用不同的分隔符（并在DOS版本中添加了盘符）。
另请参见：split。

3.4.4 lower

方法lower返回字符串的小写版本。

>>> 'Trondheim Hammer Dance'.lower() 
'trondheim hammer dance'

在你编写代码时，如果不想区分字符串的大小写（即忽略大小写的差别），这将很有用。例如，假设你要检查列表中是否包含指定的用户名。如果列表包含字符串’gumby’，而指定的用户名为’Gumby’，你将找不到它。

>>> if 'Gumby' in ['gumby', 'smith', 'jones']: print('Found it!') 
... 
>>>

当然，如果列表包含’Gumby’，而指定的用户名为’gumby’或’GUMBY’，结果同样找不到。对于这种问题，一种解决方案是在存储和搜索时，将所有的用户名都转换为小写。这样做的代码类似于下面这样：

>>> name = 'Gumby' 
>>> names = ['gumby', 'smith', 'jones'] 
>>> if name.lower() in names: print('Found it!') 
... 
Found it! 
>>>

另请参见：islower、istitle、isupper、translate。
附录B：capitalize、casefold、swapcase、title、upper。
词首大写
一个与lower相关的方法是title（参见附录B）。它将字符串转换为词首大写，即所有单词的首字母都大写，其他字母都小写。然而，它确定单词边界的方式可能导致结果不合理。

>>> "that's all folks".title() 
"That'S All, Folks"

另一种方法是使用模块string中的函数capwords。

>>> import string 
>>> string.capwords("that's all, folks") 
That's All, Folks"

当然，要实现真正的词首大写（根据你采用的写作风格，冠词、并列连词以及不超过5个字母的介词等可能全部小写），你得自己编写代码。

3.4.5 replace

方法replace将指定子串都替换为另一个字符串，并返回替换后的结果。

>>> 'This is a test'.replace('is', 'eez') 
'Theez eez a test'

如果你使用过字处理程序的“查找并替换”功能，一定知道这个方法很有用。
另请参见：translate。
附录B：expandtabs。

3.4.6 split

split是一个非常重要的字符串方法，其作用与join相反，用于将字符串拆分为序列。

>>> '1+2+3+4+5'.split('+') 
['1', '2', '3', '4', '5'] 
>>> '/usr/bin/env'.split('/') 
['', 'usr', 'bin', 'env'] 
>>> 'Using the default'.split() 
['Using', 'the', 'default']

注意，如果没有指定分隔符，将默认在单个或多个连续的空白字符（空格、制表符、换行符等）处进行拆分。
另请参见：join。
附录B：partition、rpartition、rsplit、splitlines。

3.4.7 strip

方法strip将字符串开头和末尾的空白（但不包括中间的空白）删除，并返回删除后的结果。

>>> ' internal whitespace is kept '.strip() 
'internal whitespace is kept'

与lower一样，需要将输入与存储的值进行比较时，strip很有用。回到前面介绍lower时使用的用户名示例，并假定用户输入用户名时不小心在末尾加上了一个空格。

>>> names = ['gumby', 'smith', 'jones'] 
>>> name = 'gumby ' 
>>> if name in names: print('Found it!') 
... 
>>> if name.strip() in names: print('Found it!') 
... 
Found it! 
>>>

你还可在一个字符串参数中指定要删除哪些字符。

>>> '*** SPAM * for * everyone!!! ***'.strip(' *!') 
'SPAM * for * everyone'

这个方法只删除开头或末尾的指定字符，因此中间的星号未被删除。
附录B：lstrip、rstrip。

3.4.8 translate

方法translate与replace一样替换字符串的特定部分，但不同的是它只能进行单字符替换。这个方法的优势在于能够同时替换多个字符，因此效率比replace高。
这个方法的用途很多（如替换换行符或其他随平台而异的特殊字符），但这里只介绍一个比较简单（也有点傻）的示例。假设你要将一段英语文本转换为带有德国口音的版本，为此必须将字符c和s分别替换为k和z。
然而，使用translate前必须创建一个转换表。这个转换表指出了不同Unicode码点之间的转换关系。要创建转换表，可对字符串类型str调用方法maketrans，这个方法接受两个参数：两个长度相同的字符串，它们指定要将第一个字符串中的每个字符都替换为第二个字符串中的相应字符①。就这个简单的示例而言，代码类似于下面这样：

>>> table = str.maketrans('cs', 'kz')

如果愿意，可查看转换表的内容，但你看到的只是Unicode码点之间的映射。

>>> table 
{115: 122, 99: 107}

创建转换表后，就可将其用作方法translate的参数。

>>> 'this is an incredible test'.translate(table) 
'thiz iz an inkredible tezt'

调用方法maketrans时，还可提供可选的第三个参数，指定要将哪些字母删除。例如，要模仿语速极快的德国口音，可将所有的空格都删除。

>>> table = str.maketrans('cs', 'kz', ' ') 
>>> 'this is an incredible test'.translate(table) 
'thizizaninkredibletezt'

另请参见：replace、lower。

3.4.9 判断字符串是否满足特定的条件

很多字符串方法都以is打头，如isspace、isdigit和isupper，它们判断字符串是否具有特定的性质（如包含的字符全为空白、数字或大写）。如果字符串具备特定的性质，这些方法就返回True，否则返回False。
附录B：isalnum、isalpha、isdecimal、isdigit、isidentifier、islower、isnumeric、isprintable、isspace、istitle、isupper。
——————————
① 也可传入下一章将介绍的字典，将一些字符映射到其他字符（如果要删除这些字符，则映射到None）。

3.5 小结

本章介绍了字符串的两个重要方面。

  • 字符串格式设置：求模运算符（%）可用于将值合并为包含转换标志（如%s）的字符串，这让你能够以众多方式设置值的格式，如左对齐或右对齐，指定字段宽度和精度，添加符号（正号或负号）以及在左边填充0等。
  • 字符串方法：字符串有很多方法，有些很有用（如split和join），有些很少用到（如istitle和capitalize）。
3.5.1 本章介绍的新函数
函 数描 述
string.capwords(s[, sep])使
ascii(obj)创建指定对象的ASCII表示

3.6 Unicode、bytes和bytearray

Python字符串使用Unicode编码来表示文本。大致而言，每个Unicode字符都用一个码点（code point）表示，而码点是Unicode标准给每个字符指定的数字。这是让软件都能识别的方式表示129个文字系统中的12万个以上的字符。
鉴于计算机键盘不可能包含几十万个键，因此有一种指定Unicode字符的通用机制：使用16或32位的十六进制字面量（分别加上前缀\u或\U）或者使用字符的Unicode名称（\N{name}）。

>>> "\u00C6" 
'Æ' 
>>> "\U0001F60A" 
'☺'
>>> "This is a cat: \N{Cat}" 
'This is a cat: 🐈'

Unicode ( https://www.unicode/ ) 是一种规范，旨在列出人类语言使用的每个字符，并为每个字符提供自己的唯一代码。Unicode 规范不断修订和更新，以添加新的语言和符号。
要获悉字符的Unicode码点和名称，可参阅网站，https://www.rapidtables/code/text/unicode-characters.html。
Unicode的理念很简单，却带来了一些挑战，其中之一是编码问题。在内存和磁盘中，所有对象都是以二进制数字（0和1）表示的（这些数字每8个为一组，即1字节），字符串也不例外。字符串不过是字节序列而已。
Python提供了两种类似的类型：不可变的bytes和可变的bytearray。如果需要，可直接创建bytes对象（而不是字符串），方法是使用前缀b：

>>> b'Hello, world!' 
b'Hello, world!'

然而，1字节只能表示256个不同的值，离Unicode标准的要求差很远。Python bytes字面量只支持ASCII标准中的128个字符，而余下的128个值必须用转义序列表示，如\xf0表示十六进制值0xf0（即240）。
唯一的差别好像在于可用的字母表规模，但实际上并非完全如此。乍一看，好像ASCII和Unicode定义的都是非负整数和字符之间的映射，但存在细微的差别：Unicode码点是使用整数定义的，而ASCII字符是使用对应的数及其二进制编码定义的。这一点好像无关紧要，原因之一是整数0～255和8位二进制数之间的映射是固定的，几乎没有任何机动空间。问题是超过1字节后，情况就不那么简单了：直接将每个码点表示为相应的二进制数可能不再可行。这是因为不仅存在字节顺序的问题（即便对整数值进行编码，也会遇到这样的问题），而且还可能浪费空间。有一种Unicode编码标准是基于这种考虑的，它就是UTF-32（32位统一编码转换格式，Unicode Transformation Format 32 bits），但如果你主要处理的是使用互联网上常见语言书写的文本，那么使用这种编码标准将很浪费空间。
然而，有一种非常巧妙的替代方式：不使用全部32位，而是使用变长编码，即对于不同的字
符，使用不同数量的字节进行编码。通过使用这种编码，可节省占用的空间，就像摩尔斯码使用较少的点和短线表示常见的字母，从而减少工作量一样。具体地说，进行单字节编码时，依然使用ASCII编码，以便与较旧的系统兼容；但对于不在这个范围内的字符，使用多个字节（最多为6个）进行编码。下面来使用ASCII、UTF-8和UTF-32编码将字符串转换为bytes。

>>> "Hello, world!".encode("ASCII") 
b'Hello, world!' 
>>> "Hello, world!".encode("UTF-8") 
b'Hello, world!' 
>>> "Hello, world!".encode("UTF-32") 
b'\xff\xfe\x00\x00H\x00\x00\x00e\x00\x00\x00l\x00\x00\x00l\x00\x00\x00o\x00\x00\x00,\x00\x00\x00\x00\x00\x00w\x00\x00\x00o\x00\x00\x00r\x00\x00\x00l\x00\x00\x00d\x00\x00\x00!\x00\x00\x00'

从中可知，使用前两种编码的结果相同，但使用最后一种编码的结果长得多。再来看一个示例：

>>> len("How long is this?".encode("UTF-8")) 
17 
>>> len("How long is this?".encode("UTF-32")) 
72

只要字符串包含较怪异的字符，ASCII和UTF-8之间的差别便显现出来了：

>>> "Hællå, wørld!".encode("ASCII") 
Traceback (most recent call last):  
... 
UnicodeEncodeError: 'ascii' codec can't encode character '\xe6' in position 1: ordinal not in range(128)

æ和å没有对应的ASCII编码。如果必须使用ASCII编码（这样的情况肯定会遇到），可向encode提供另一个实参，告诉它如何处理错误。这个参数默认为strict，还可指定为其他值，以忽略或替换不在ASCII表中的字符。

>>> "Hællå, wørld!".encode("ASCII", "ignore") 
b'Hll, wrld!' 
>>> "Hællå, wørld!".encode("ASCII", "replace") 
b'H?ll?, w?rld!' 
>>> "Hællå, wørld!".encode("ASCII", "backslashreplace") 
b'H\\xe6ll\\xe5, w\\xf8rld!' 
>>> "Hællå, wørld!".encode("ASCII", "xmlcharrefreplace") 
b'H&#230;ll&#229;, w&#248;rld!'

几乎在所有情况下，都最好使用UTF-8。事实上，它也是默认使用的编码。

>>> "Hællå, wørld!".encode() 
b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'

这相比于Hello, world!，编码结果要长些；但使用UTF-32编码时，结果一样长。
可将字符串编码为bytes，同样也可将bytes解码为字符串。

>>> b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'.decode() 
'Hællå, wørld!'

与前面一样，默认编码也是UTF-8。你可指定其他编码，但如果指定的编码不正确，将出现错误消息或得到一堆乱码。bytes对象本身并不知道使用的是哪种编码，因此你必须负责指定。
可不使用方法encode和decode，而直接创建bytes和str（即字符串）对象，如下所示：

>>> bytes("Hællå, wørld!", encoding="utf-8") 
b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!' 
>>> str(b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!', encoding="utf-8") 
'Hællå, wørld!'

这种方法更通用一些，在你不知道类似于字符串或bytes的对象属于哪个类时，使用这种方法更管用。一个通用规则是，不要做过于严格的假设。

编码和解码的最重要用途之一是，将文本存储到磁盘文件中。然而，Python提供的文件读写机制通常会替你完成这方面的工作！只要文件使用的是UTF-8编码，就无需操心编码和解码的问题。但如果原本正常的文本变成了乱码，就说明文件使用的可能是其他编码。在这种情况下，对导致这种问题的原因有所了解将大有裨益。如果你想更详细地了解Python中的Unicode，请参阅

在线文档中有关该主题的HOWTO部分

注意 源代码也将被编码，且默认使用的也是UTF-8编码。如果你想使用其他编码（例如，如果
你使用的文本编辑器使用其他编码来存储源代码），可使用特殊的注释来指定。

# -*- coding: encoding name -*-

请将其中的encoding name替换为你要使用的编码（大小写都行），如utf-8或latin-1。

最后，Python还提供了bytearray，它是bytes的可变版。从某种意义上说，它就像是可修改的字符串，常规字符串是不能修改的。然而，bytearray其实是为在幕后使用而设计的，因此作为类字符串使用时对用户并不友好。例如，要替换其中的字符，必须将其指定为0～255的值。
因此，要插入字符，必须使用ord获取其序数值（ordinal value）。

>>> x = bytearray(b"Hello!") 
>>> x[1] = ord(b"u") 
>>> x 
>>> bytearray(b'Hullo!')

本文标签： 字符串基础教程读书笔记Python

版权声明：本文标题：Python基础教程(第3版)读书笔记：第3章 使用字符串 内容由热心网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：https://www.elefans.com/dianzi/1725295217a1017358.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。