Fluent Python2 【Chapter4_QA】

第四章：

1.Unicode是什么？

答：Unicode 是一种国际标准，用于字符的编码和表示。它的目标是为世界上几乎所有的字符提供唯一的标识，并为这些字符分配一个独一无二的码点。Unicode 旨在成为全球通用的字符编码标准，能够涵盖各种语言、符号和表情。

Unicode 的主要特点包括：

1. 统一性： Unicode 提供了一个统一的字符集，允许不同的文本和字符数据在不同的系统和应用程序之间进行互操作。

2. 多语言支持： Unicode 设计用于支持世界上的各种语言，包括拉丁字母、希腊字母、西里尔字母、中文、日文、韩文等。

3. 扩展性： Unicode 不断扩展以涵盖新的字符和符号。每个 Unicode 字符都有一个唯一的码点，这个码点是一个非负整数。

4. 字符编码： Unicode 字符可以以不同的编码方案进行存储，例如 UTF-8、UTF-16、UTF-32 等。这些编码方案允许将 Unicode 字符映射到具体的字节序列。

Unicode 的标准由 Unicode 联盟（Unicode Consortium）维护和发展。Unicode 字符集的最新版本可以在 Unicode 官方网站上找到。Unicode 已成为计算机领域中最广泛使用的字符编码标准之一，用于处理文本和字符数据。

 

2. Unicode码点的概念的理解？

答：Unicode 的码点是一个用于标识 Unicode 字符的整数值。每个 Unicode 字符都有一个唯一的码点，它是一个非负整数。

Unicode 码点的表示通常以 "U+" 开头，后面跟着一个或多个十六进制数字。例如，字母 "A" 的 Unicode 码点是 U+0041。

 

举例说明：

• 字母 "A" 的 Unicode 码点是 U+0041。
• 汉字 "中" 的 Unicode 码点是 U+4E2D。
• 表情符号 "😊" 的 Unicode 码点是 U+1F60A。

你可以使用 Python 中的 ord() 函数来获取一个字符的 Unicode 码点。例如：

print(ord('A'))     # 输出：65
print(ord('中'))    # 输出：20013
print(ord('😊'))   # 输出：128522

注意，Unicode 码点是一个抽象的概念，与实际的字符编码方案（如 UTF-8、UTF-16 等）有所区别。不同的字符编码方案将 Unicode 码点映射到具体的字节序列。

 类比理解：可以将字符序列和码点之间的关系类比为地球上的经纬度定位。让我们来做一个类比：

1. 字符序列类比地球上的位置： 每个字符序列就像地球上的一个独特位置，可以通过一组特定的符号（字符）来表示。

2. 码点类比经纬度： 每个字符在计算机中有一个唯一的标识，称为码点。码点就像地球上的经纬度一样，是用于唯一标识一个特定位置的值。

3. 编码方案类比坐标系： 字符序列和码点之间的映射关系由编码方案决定，类似于地图上的坐标系。常见的编码方案有 ASCII、UTF-8、UTF-16 等，它们规定了如何将字符映射到码点，从而构成字符序列。

4. 字节表示类比地球上的标记或坐标表示： 在计算机中，字符序列需要以字节的形式存储。这就好比地球上的位置可以用数字（经纬度的具体值）来表示。

总体而言，这个类比可以帮助理解字符编码的概念。不同的编码方案就像不同的坐标系，它们定义了字符序列和码点之间的映射规则。在这个类比中，字符序列的存储方式就类似于地球上某一位置的坐标值的存储方式。

 

 

3. Unicode、UTF-8 和 GBK 的关系。

好的，让我们通过一个通俗易懂的例子来解释 Unicode、UTF-8 和 GBK 的关系。

假设有个字母 "A"：

1. Unicode： Unicode 规定了字母 "A" 对应的码点，假设是 U+0041。这个码点是一个唯一的整数标识，但并没有规定这个整数应该如何在计算机中存储。

2. UTF-8： UTF-8 是一种将 Unicode 码点编码为字节序列的方式。对于 "A"（U+0041），它在 UTF-8 中用一个字节表示，即 41（16进制）。这里 "A" 在 UTF-8 中的表示和 Unicode 码点是一一对应的。

3. GBK： GBK 是一种专门用于汉字的字符集，它在扩展 GB2312 的基础上加入了更多字符。但对于字母 "A" 来说，GBK 也将其编码为两个字节的序列，具体的编码取决于 GBK 字符集的规定。

举例：

• 字母 "A" 在 Unicode 中的码点是 U+0041。
• 在 UTF-8 中，它的字节序列是 41。
• 在 GBK 中，也可能会有一个对应的两个字节的编码。

也就是说，可以把 Unicode 想象成一个大的字符集，UTF-8 是一种编码方式，而 GBK 则是另一种专门用于中文的编码方式。

Unicode 提供了字符集的标准，而 UTF-8 和 GBK 是实际用于在计算机中存储和传输这些字符的方式。

 

4. Unicode和ASCII码的异同

答：Unicode 和 ASCII 都是字符编码标准，但有一些重要的区别。

ASCII（美国信息交换标准代码）：

1. 范围： ASCII 编码是最早的字符编码标准，仅包含 128 个字符，用于表示英语中的常见字符、数字、标点符号和控制字符。

2. 编码方式： 每个 ASCII 字符都用 7 位二进制数字表示，可以表示的字符范围是 0 到 127。

3. 扩展： 随着时间的推移，为了支持更多语言和字符，一些扩展的 ASCII 变体出现，如 ISO-8859 等。但它们仍然有限制，无法涵盖全球范围内的所有字符。

Unicode：

1. 范围： Unicode 是一个更加全面和广泛的字符编码标准，涵盖了世界上几乎所有的字符，包括各种语言的字母、符号、表情等。

2. 编码方式： Unicode 使用不同的编码方案，最常见的是 UTF-8、UTF-16 和 UTF-32。这些方案允许表示数百万甚至上千万个字符。

3. 多语言支持： 由于 Unicode 的广泛性，它不仅支持英语字符，还支持亚洲、欧洲、非洲等地区的字符，以及各种古代文字和表情符号。

举例说明：

• ASCII：字符 "A" 在 ASCII 中的表示是 01000001（二进制），对应的十进制是 65。

• Unicode：字符 "A" 在 Unicode 中的表示是 U+0041，对应的二进制表示可能依赖于所采用的具体编码方案（如 UTF-8 中的 01000001）。

Unicode 的优势在于它的全球性和广泛性，能够表示几乎所有的字符，而 ASCII 主要适用于英语字符的表示。随着全球化的发展，Unicode 越来越被广泛采用，成为计算机系统中主要的字符编码标准。

 

5. bytes.fromhex()函数的理解。

# 案例1

# 使用 bytes.fromhex() 转换十六进制字符串为 bytes 对象
hex_string = "48656c6c6f20576f726c64"  # 十六进制表示的字符串
# hex_string = "41656c6c6f20576f726c64"  # 十六进制表示的字符串
binary_data = bytes.fromhex(hex_string)

# 打印转换后的结果
print(binary_data)
b'Hello World'

# 案例2
hex_string = "48656c6c6f20576f726c64"  # 十六进制表示的字符串
binary_data = bytes.fromhex(hex_string)

# 打印每个字符和对应的 ASCII 码
for byte in binary_data:
    print(f"{chr(byte)}的十进制是: {byte} 对应十六进制是: {hex(byte)}")

H的十进制是: 72 对应十六进制是: 0x48
e的十进制是: 101 对应十六进制是: 0x65
l的十进制是: 108 对应十六进制是: 0x6c
l的十进制是: 108 对应十六进制是: 0x6c
o的十进制是: 111 对应十六进制是: 0x6f
的十进制是: 32 对应十六进制是: 0x20
W的十进制是: 87 对应十六进制是: 0x57
o的十进制是: 111 对应十六进制是: 0x6f
r的十进制是: 114 对应十六进制是: 0x72
l的十进制是: 108 对应十六进制是: 0x6c

 
6. 如何找出字节序列编码

import chardet

def detect_encoding(byte_data):
    result = chardet.detect(byte_data)
    return result['encoding']

# 示例
byte_sequence = b'\xe4\xbd\xa0\xe5\xa5\xbd'  # 这是UTF-8编码的“你好”
detected_encoding = detect_encoding(byte_sequence)
print(detected_encoding) 
# 返回：True


possible_encodings = ['utf-8', 'latin-1', 'gb2312']

def try_decoding(byte_data, encoding):
    try:
        decoded_text = byte_data.decode(encoding)
        return decoded_text
    except UnicodeDecodeError:
        return None

# 示例
byte_sequence = b'\xe4\xbd\xa0\xe5\xa5\xbd'  # 这是UTF-8编码的“你好”

for encoding in possible_encodings:
    result = try_decoding(byte_sequence, encoding)
    if result is not None:
        print(f"Successfully decoded using {encoding}: {result}")
        break

# 返回：Successfully decoded using utf-8: 你好

 

7. 关于Unicode 规范化形式NFC缩写的理解，此外还有那些其他规范化形式？

"NFC" 的全称是 "Normalization Form Canonical Composition"，中文翻译为规范组合形式。它是 Unicode 规范化的一种形式，用于将字符序列表示为规范组合的形式，确保相同文本的不同表示形式被规范为相同的形式。通过应用规范化，可以更准确地处理和比较 Unicode 字符。

Unicode 规范化有四种形式，分别是：

1. NFC: 规范组合形式（Normalization Form Canonical Composition）
2. NFD: 规范分解形式（Normalization Form Canonical Decomposition）
3. NFKC: 兼容规范组合形式（Normalization Form Compatibility Composition）
4. NFKD: 兼容规范分解形式（Normalization Form Compatibility Decomposition）

"NFC" 主要用于将字符表示为规范组合的形式，而 "NFD" 用于将字符表示为规范分解的形式。

 

8.关于str.maketrans()方法

str.maketrans() 方法是字符串类型 str 的一个方法，用于生成字符映射表。它的作用是创建一个转换表，可以用于字符串的替换、删除等操作。这个方法通常与 str.translate() 方法一起使用。

概念： str.maketrans() 方法的参数是两个等长的字符串，它们分别表示要映射的字符和对应的目标字符。这两个字符串的长度必须相同。

作用： str.maketrans() 方法生成一个转换表，将第一个参数字符串中的每个字符映射到第二个参数字符串中的相应字符。生成的转换表可以传递给 str.translate() 方法，从而对字符串进行相应的字符替换。

# 使用 str.maketrans() 创建字符映射表
translation_table = str.maketrans("abc", "123")

print(translation_table)
{97: 49, 98: 50, 99: 51}

# 将字符映射表传递给 str.translate() 方法 
result = "abcde".translate(translation_table) 

print(result)

# 123de

# 补充：97,98等这些数字的来由。

print(ord('a'), ord('b'), ord('c'), ord('1'), ord('2'), ord('3'))
97 98 99 49 50 51

 

9. 如何理解：“bytes和bytearray中的项是0~255(含)的整数”？

这句话描述了Python中bytes和bytearray对象中元素值的范围限制。让我们逐一解释一下:

1.bytes和bytearray

bytes对象是Python中的一种不可变(immutable)序列类型,它存储一系列不可变的字节值(0-255)。bytearray则是它的可变(mutable)版本,也存储字节值,但可以对其进行就地修改。

2.中的项

这里的"项"指的是bytes或bytearray对象中的每个元素或成员。

3.是0~255(含)的整数

这个范围限制规定了bytes和bytearray中的每个元素必须是0到255(包括0和255)之间的整数值。

这是因为bytes和bytearray本质上是用来存储二进制数据的,每个元素代表一个字节(8位),而一个字节的取值范围就是0到255。例如:

# 有效的bytes对象
valid_bytes = bytes([0, 128, 255])

# 无效的bytes对象
invalid_bytes = bytes([256, -1])  # ValueError: bytes must be in range(0, 256)

这种范围限制有以下几个原因:

1. 与底层计算机存储方式一致,1个字节就是8个二进制位,最大值为2^8 - 1 = 255。
2. 方便与二进制数据进行交互,每个元素都对应一个字节值。
3. 防止存储无效数据,超出范围可能导致未定义行为。

因此,在处理bytes和bytearray对象时,必须确保它们中的每个元素都在0到255的范围内,否则将会引发ValueError异常。这是Python为了保证这两种类型的数据完整性和一致性而设置的限制。

 

10. 字符串的translate()方法详解

Python字符串的translate()方法用于将字符串中的某些字符替换成其他字符或者完全删除。该方法接受一个字典或映射表作为参数,字典的键表示需要被替换或删除的字符,而值则表示要替换成的字符。

如果值为None,则表示删除该字符。translate()方法会遍历原字符串,对于每一个字符,如果它在映射表中存在,则用映射表中对应的值来替换它,否则保持原样。

使用translate()方法的主要作用有:

1. 删除字符串中不需要的字符,例如删除标点符号或特殊字符。
2. 替换字符串中的部分字符,例如将小写字母转换为大写字母。
3. 实现字符串的简单加密或解密。

下面是translate()方法的基本用法:

# 删除字符串中的特殊字符
original_str = "Hello, World! 123#@"
remove_chars = str.maketrans('', '', '!#@,.')
new_str = original_str.translate(remove_chars)
print(new_str)  # 输出: Hello World 123

# 替换字符串中的字符
original_str = "Hello, World!"
replace_chars = str.maketrans('lo', '12')
new_str = original_str.translate(replace_chars)
print(new_str)  # 输出: He112, W2r1d!

# 简单的字符串加密
original_str = "Hello, World!"
encrypt_map = str.maketrans("abcdefghijklmnopqrstuvwxyz", "zyxwvutsrqponmlkjihgfedcba")
encrypted_str = original_str.translate(encrypt_map)
print(encrypted_str)  # 输出: Svool, Tloimw!

 

11. python中的isidentifier()方法的理解

Python 中的 str.isidentifier() 是字符串的一个方法,用于检查指定的字符串是否是一个有效的 Python 标识符。Python 标识符是用于命名变量、函数、类等对象的字符串。

概念

str.isidentifier() 方法根据以下规则检查字符串是否为有效的 Python 标识符:

1. 字符串必须由字母、数字或下划线(_)构成。
2. 字符串不能以数字开头。
3. 字符串中不能包含任何空白字符。
4. 字符串不能与 Python 保留关键字相同。

作用

• 检查用户输入的变量名或函数名是否合法
• 验证从其他来源(如配置文件、网络请求等)获取的标识符是否符合 Python 命名规范
• 在自动化代码生成或重构工具中确保生成的名称是有效的

使用说明

str.isidentifier() 方法的基本语法如下:

string.isidentifier()

其中，string 是要测试的字符串。该方法返回一个布尔值，如果字符串是有效的 Python 标识符则返回 True，否则返回 False。

示例:

# 有效的标识符
print('hello_world'.isidentifier())  # True
print('_underscore'.isidentifier())  # True
print('Python3'.isidentifier())  # True

# 无效的标识符
print('3hello'.isidentifier())  # False (以数字开头)
print('hello world'.isidentifier())  # False (包含空格)
print('for'.isidentifier())  # False (Python 关键字)
print('my-name'.isidentifier())  # False (包含非法字符 -)

注意，str.isidentifier() 方法是对整个字符串进行检查。如果只想检查单个字符是否是有效的标识符组成部分，可以使用 str.isalnum() 或 str.isalpha()。

总之，str.isidentifier() 方法提供了一种简单的方式来验证字符串是否符合 Python 标识符的命名规范,对于确保代码质量和可读性非常有帮助。

 

12. casefold() 方法是 Python 字符串对象的一个方法，用于将字符串中的所有字符转换为小写，并处理特定语言的特殊字符，使其更适合于进行不区分大小写的比较。

通俗地说，casefold() 方法可以帮助我们在字符串比较时忽略大小写，并且可以处理一些特殊字符，确保比较的准确性。

举例说明：

string1 = "Hello"
string2 = "hello"
string3 = "Héllö"

# 普通的小写转换
print(string1.casefold())  # 输出: hello
print(string2.casefold())  # 输出: hello

# 处理特殊字符
print(string3.casefold())  # 输出: héllö

在上面的例子中，casefold() 方法将字符串中的所有字符转换为小写，并将特殊字符转换为对应的小写形式。这样，我们可以确保在进行字符串比较时不会受到大小写和特殊字符的影响。

 

13. unicodedata.combining()

unicodedata.combining()是Python中unicodedata模块的一个函数,它用于判断一个Unicode字符是否为组合字符(Combining Character)。也就是说这个字符是否可以和其他字符形成组合。

含义:

组合字符是一种特殊的Unicode字符,它们被设计用于与其他字符组合在一起,以产生不同的外观或发音。例如,重音符号(如àéîö)就是组合字符,它们需要与其他字母组合才能表示不同的发音。

作用:

unicodedata.combining()函数的主要作用是帮助我们识别和处理组合字符。它对于处理一些特殊的Unicode字符非常有用,例如规范化字符串、排序字符串等。

举例说明:

import unicodedata

# 组合字符
combining_char = '\u0301'  # 组合重音符号(顶部加重音符)
print(unicodedata.combining(combining_char))  # True

# 非组合字符
non_combining_char = 'a'
print(unicodedata.combining(non_combining_char))  # False

# 组合字符与非组合字符组合
combined_char = 'a' + '\u0301'
print(combined_char)  # á

在上面的示例中:

1. 我们首先导入unicodedata模块。
2. 定义一个组合字符\u0301(顶部加重音符)。
3. 使用unicodedata.combining(combining_char)判断该字符是否为组合字符,输出为True。
4. 定义一个非组合字符'a'。
5. 使用unicodedata.combining(non_combining_char)判断该字符是否为组合字符,输出为False。
6. 将组合字符与非组合字符相加,得到一个新的字符'á'。

这个示例展示了如何使用unicodedata.combining()函数来识别组合字符,以及如何将组合字符与非组合字符组合在一起产生新的字符。这在处理包含重音符号或其他特殊字符的字符串时非常有用。

 

14. print(f'U+{code:04X}\t{char}\t{name}') 的理解

这部分代码是打印 Unicode 字符的相关信息，具体含义如下：

print(f'U+{code:04X}\t{char}\t{name}')

• f'U+{code:04X}': 这部分代码使用 f-string 格式化输出，{code:04X} 的作用是将变量 code 格式化为四位十六进制数，并确保不足四位的数用零填充。U+ 表示 Unicode 字符的标识，后面跟着表示字符 Unicode 编码的十六进制数。
• \t: 表示输出一个制表符，用于在输出中对齐。
• {char}: 输出 Unicode 字符本身。
• {name}: 输出 Unicode 字符的名称，如果字符没有名称，则输出 None。

因此，第7行的代码的作用是以一种格式化的方式打印 Unicode 字符的编码、字符本身和字符名称。

 

 15. 转义序列具有位模式，位模式是什么？

在计算机领域,位(bit)是信息的最小单位,它只有0和1两种状态。而位模式(bit pattern)是指用二进制数字(0和1)组成的序列。转义序列具有位模式,是指转义序列在内存中是以二进制位模式的形式存储和表示的。

让我们通过一个具体的例子来理解什么是位模式:

在Python中,回车符\r是一个转义序列。它在内存中是用两个字节(16位)表示的,位模式是:

0000000000001101

这就是\r在内存中的位模式表示。每一位(0或1)都代表\r这个字符的一个特征。

再举一个例子,小写字母a在内存中占据一个字节(8位),它的位模式是:

01100001

可以看出,不同的字符在内存中都有自己对应的位模式表示。

位模式的概念主要源自于计算机存储和处理信息的本质 - 使用二进制数字。所有数据(文本、图像、声音等)在计算机中都是以二进制的形式存储和处理的。不同的数据有不同的位模式表示,因此位模式成为了描述和区分数据的一个重要方式。

通俗地说,位模式就是用0和1这两个数字按顺序排列,形成只有计算机能读懂的秘密代码,代表不同的字符或数据。就像我们使用不同的文字(如中文、英文字母等)来表示不同的意思一样,计算机使用位模式来区分和存储各种信息。

所以,当我们说转义序列具有位模式时,其实就是指它在计算机内存中是以二进制数字的形式存储的,这种二进制表示方式就是它的位模式。掌握位模式的概念,有助于理解计算机是如何存储和处理各种信息的。

 

16. 如下描述中"机器字"、"变长表述"的概念如何理解？

Python3对int类型的处理方式也像字符串表述一样灵活；如果一个整数在一个机器字中放得下，那就存储在一个机器字中；否则解释器采用变长表述，类似于python2中的long类型那样。

 

在如上的描述中,涉及到两个重要的概念:"机器字"和"变长表述"。下面是对它们的解释:

1. 机器字(machine word):
   • 概念:机器字是指计算机系统中一个基本存储单元的长度,通常是32位或64位。
   • 作用:它决定了整数在内存中存储的最大容量。
   • 通俗解释:就像房子有不同的大小一样,机器字决定了整数数值存储空间的"大小"。
   • 举例:在32位系统中,一个机器字可以存储-2,147,483,648到2,147,483,647范围内的整数。在64位系统中,这个范围变为-9,223,372,036,854,775,808到9,223,372,036,854,775,807。
2. 变长表述(variable-length representation):
   • 概念:变长表述是一种存储方式,它允许一个数据类型使用不同数量的内存来存储不同大小的值。
   • 作用:它使得整数可以存储任意大小,不受机器字长度的限制。
   • 通俗解释:就像可以随时扩建房子一样,变长表述允许整数"无限扩展"存储空间。
   • 举例:在Python 2中,long类型就是一种变长表述,可以存储任意大小的整数。在Python 3中,int类型采用了变长表述,所以理论上可以存储无限大的整数。

回到你提供的描述,它解释了Python 3如何处理int类型的整数:

1. 如果整数值在一个机器字中可以容纳,Python 3就会使用机器字来存储它(节省内存)。
2. 如果整数值太大,无法存储在一个机器字中,Python 3就会采用变长表述,类似于Python 2中的long类型(可以无限扩展存储空间)。

这种处理方式同时考虑了存储效率和存储容量,对于大多数应用来说是非常合理的。它使Python 3中的int类型可以存储任意大小的整数,而不会像之前的Python版本那样需要区分int和long类型。

 

 17. 如下代码中，为什么要有and query.issubset(name.split())这一行？起什么作用？

 首先 A.issubset(B), 表达的是A是否为B的子集，返回的是bool值，不要弄错顺序了。

比如：A.issubset(B) 的确是判断集合A是否是集合B的子集,返回一个布尔值(True或False)。

具体来说:

• 如果A是B的子集,即A中的每个元素都包含在B中,那么A.issubset(B)返回True。
• 如果A不是B的子集,即A中至少有一个元素不包含在B中,那么A.issubset(B)返回False。

你提醒的"不要弄错顺序"也是非常重要的一点。A.issubset(B)和B.issubset(A)的结果可能不同,因为子集的关系是单向的。

例如:

A = {1, 2}
B = {1, 2, 3}

print(A.issubset(B))  # True,因为A是B的子集
print(B.issubset(A))  # False,因为B不是A的子集

如下是包含and query.issubset(name.split())的完整代码

#!/usr/bin/env python3
import sys
import unicodedata

START, END = ord(' '), sys.maxunicode + 1           # <1>

def find(*query_words, start=START, end=END):       # <2>
    query = {w.upper() for w in query_words}        # <3>
    for code in range(start, end):
        char = chr(code)                            # <4>
        name = unicodedata.name(char, None)         # <5>
        if name and query.issubset(name.split()):   # <6>
            print(f'U+{code:04X}\t{char}\t{name}')  # <7>

def main(words):
    if words:
        find(*words)
    else:
        print('Please provide words to find.')

if __name__ == '__main__':
    main(sys.argv[1:])

在以上的代码中, query.issubset(name.split()) 这一行的作用是检查输入的查询单词是否都包含在当前 Unicode 字符的名称中。

具体来说:

1. name.split() 将当前字符的名称按空格拆分成一个单词列表。比如对于字符 'é', 它的名称是 'LATIN SMALL LETTER E WITH ACUTE', name.split() 会返回 ['LATIN', 'SMALL', 'LETTER', 'E', 'WITH', 'ACUTE']。
2. query.issubset(name.split()) 会检查查询集合 query 中的所有单词是否都是 name.split() 返回的单词列表的子集。
3. 如果 query.issubset(name.split()) 为 True,表示当前字符的名称包含了所有查询单词,因此会打印出这个字符的信息。
4. 如果 query.issubset(name.split()) 为 False,表示当前字符的名称不包含所有查询单词,则跳过打印。

这一行的作用是筛选出名称中包含所有查询单词的 Unicode 字符,从而实现了根据单词查找相关 Unicode 字符的功能。

例如,如果查询单词是 ['LATIN', 'LETTER'],那么会打印出所有包含 "LATIN" 和 "LETTER" 这两个单词的 Unicode 字符,比如 'é' 就会被打印出来。

这一行代码提供了一种灵活的方式,允许用户输入任意单词组合来查找符合条件的 Unicode 字符。

 

17. r' ', 还有rb' '的含义理解

import re

re_numbers_str = re.compile(r'\d+')     # <1>
re_words_str = re.compile(r'\w+')
re_numbers_bytes = re.compile(rb'\d+')  # <2>
re_words_bytes = re.compile(rb'\w+')

text_str = ("Ramanujan saw \u0be7\u0bed\u0be8\u0bef"  # <3>
            " as 1729 = 1³ + 12³ = 9³ + 10³.")        # <4>

text_bytes = text_str.encode('utf_8')  # <5>

print(f'Text\n  {text_str!r}')
print('Numbers')
print('  str  :', re_numbers_str.findall(text_str))      # <6>
print('  bytes:', re_numbers_bytes.findall(text_bytes))  # <7>
print('Words')
print('  str  :', re_words_str.findall(text_str))        # <8>
print('  bytes:', re_words_bytes.findall(text_bytes))    # <9>

在Python中,r''和rb''都是用于字符串前缀的特殊符号,它们具有不同的含义和用途。

1. r''(Raw String):
   • 概念: 原始字符串前缀,告诉Python不要对反斜杠(\)进行任何转义处理。
   • 含义: 在普通字符串中,反斜杠会被解释为转义字符(如\n表示新行)。而在原始字符串中,反斜杠将被当作普通字符对待。
   • 通俗解释: 就像在Word文档中,你想输入\这个符号,而不是让它表示特殊含义,那么你就需要在字符串前加r。
   • 举例

print(r'c:\newdir\name.txt')  # 输出: c:\newdir\name.txt
print('c:\\newdir\\name.txt')  # 输出: c:\newdir\name.txt

2. rb''(Bytes String):

• 概念: 字节字符串前缀,告诉Python将字符串当作一系列字节(bytes)对象,而不是Unicode字符。
• 含义: 通常在处理二进制数据(如网络传输或文件I/O)时使用,避免出现解码/编码错误。
• 通俗解释: 就像你在网上下载了一个文件,你需要用字节来表示和处理这个文件的内容。
• 举例:

data = rb'Hello, World!'
print(data)  # 输出: b'Hello, World!'

在你提供的代码示例中:

1. re.compile(r'\d+')创建了一个正则表达式对象,用于匹配一个或多个数字字符,而r''前缀使得反斜杠不会被转义。
2. re.compile(rb'\d+')创建了一个字节正则表达式对象,用于匹配一个或多个数字字符,rb''前缀表示这是一个字节字符串。
3. text_str是一个普通的Unicode字符串,包含一些特殊字符。
4. text_bytes是将text_str编码为UTF-8字节序列后的结果。
5. 对text_str和text_bytes分别使用字符串正则和字节正则进行匹配和查找。

总的来说,r''和rb''在处理字符串和二进制数据时能够提供方便,避免一些不必要的转义和编码错误。它们为Python提供了更好的字符串处理能力。

 

18. 这里的最后一行代码的含义

import locale
import sys

expressions = """
        locale.getpreferredencoding()
        type(my_file)
        my_file.encoding
        sys.stdout.isatty()
        sys.stdout.encoding
        sys.stdin.isatty()
        sys.stdin.encoding
        sys.stderr.isatty()
        sys.stderr.encoding
        sys.getdefaultencoding()
        sys.getfilesystemencoding()
    """

my_file = open('dummy', 'w')

for expression in expressions.split():
    value = eval(expression)
    print(f'{expression:>30} -> {value!r}') # 要理解这里最好的

【个人总结】要理解这一行代码，最好的方式是ABtest实验思路

把>去掉，然后打印出来试试；

把>改成<，然后打印出来试试；

把!r去掉，然后打印出来试试。

 

这一行代码使用了 Python 3 中的 f-string 格式化字符串,同时也用到了字符串格式化的一些技巧。让我来详细解释一下:

1. f'{expression:>30}'
   • 这是 f-string 格式化字符串的一部分
   • expression 是要格式化的变量
   • :>30 是一个格式说明符
     • > 表示右对齐
     • 30 表示该字段至少占用 30 个字符的宽度,不足则用空格填充
2. -> 是一个字符串,用作分隔符
3. {value!r}
   • value 是要格式化的变量
   • !r 是一个字符串转换标志
     • r 表示使用 repr() 函数来获取该值的字符串表示形式
     • 这种表示形式通常会加上引号,显示出对象的类型信息,方便调试

综合来看,这一行代码的作用是:

1. 以至少 30 个字符宽度右对齐输出 expression 变量
2. 输出一个分隔符 ->
3. 输出 value 变量的 repr() 形式的字符串表示

这样的输出格式使得打印结果整齐对齐,可读性更好。同时使用 repr() 输出可以更清晰地看到对象的类型信息,方便调试。

例如,如果 expression 是 'sys.stdout.encoding'、value 是 'UTF-8'的话,输出将是:

sys.stdout.encoding -> 'UTF-8'

 

19. 理解下如下代码

import locale
my_locale = locale.setlocale(locale.LC_COLLATE, 'pt_BR.UTF-8') # 这一行解释下
print(my_locale)
fruits = ['caju', 'atemoia', 'cajá', 'açaí', 'acerola']
sorted_fruits = sorted(fruits, key=locale.strxfrm) # 这一行也解释下
print(sorted_fruits)

好的,我逐个参数解释这两行代码:

1. locale.setlocale(locale.LC_COLLATE, 'pt_BR.UTF-8')

locale.setlocale()是Python的locale模块中的一个函数,用于设置程序的区域设置。它有两个参数:

• locale.LC_COLLATE - 这个参数表示我们要设置的区域类别是"字符串排序(collation)规则"。不同语言的字符排序规则可能不同。
• 'pt_BR.UTF-8' - 这个字符串表示我们要设置的具体区域为"用UTF-8编码的巴西葡萄牙语区域"。

所以这行代码的作用是将当前程序线程的字符串排序规则设置为遵循巴西葡萄牙语的排序习惯。

2. key=locale.strxfrm

这不是一个完整的语句,它缺少了上下文。在代码中,它可能是作为sorted()函数的key参数使用的,例如:

sorted_list = sorted(original_list, key=locale.strxfrm)

locale.strxfrm是一个函数,它会根据当前设置的区域规则,将字符串转换为规范化的形式,以便正确排序。

当sorted()对一个列表进行排序时,它会先调用key函数对列表中的每个元素进行处理,得到处理后的值,然后根据这些值的大小关系进行排序。

所以key=locale.strxfrm的作用是,在排序前,先用locale.strxfrm根据当前区域规则规范化每个字符串,然后再按照规范化后的字符串进行排序。这可以确保排序结果符合该区域语言的排序习惯。

 

20. int(c, 16)是什么意思？

int(c, 16) 是 Python 中的一个函数调用,用于将一个字符串形式的十六进制数转换为对应的十进制整数。

具体解释如下:

• int() 是 Python 内置的函数,用于将一个字符串或数字转换为一个整数。
• 该函数接收两个参数,第一个参数是要被转换的对象,第二个参数是可选的,用于指定要转换对象所使用的进制。
• 在这里,第一个参数 c 是一个字符串,代表一个十六进制数。比如 c 可以是 '0x2A' 或者 '2A'。
• 第二个参数 16 表示这个字符串是一个十六进制数,因此 int() 函数会将其解释为一个十六进制数,并转换为对应的十进制整数。

举几个例子:

• int('2A', 16) 将返回 42,因为 0x2A 或 2A 在十六进制中代表十进制数 42。
• int('FF', 16) 将返回 255,因为 0xFF 或 FF 在十六进制中代表十进制数 255。
• int('10', 16) 将返回 16,因为 0x10 或 10 在十六进制中代表十进制数 16。

如果没有指定进制,则 int() 默认按十进制解析字符串。因此 int('2A') 将引发 ValueError,因为 '2A' 不是一个有效的十进制数字串。

所以 int(c, 16) 的作用是将一个十六进制字符串转换为对应的十进制整数。