4常用内置数据类型

4.1 python内置数据类型概述

4.1.1 数值数据类型

1.整数类型（int）：用于表示整数，如123，1024，-982

2.布尔类型（bool）：用于表示布尔逻辑值。例如True，False

3.浮点类型（float）：用于表示实数。例如3.14，-1.23，1.1E10，-3e-4

4.复数类型（complex）：用于表示复数。例如，3+4j，-2-4j，1.2+3.4j

4.1.2 序列数据类型

序列数据类型表示若干有序数据。python序列数据分为不可变序列数据类型和可变序列数据类型。

不可变序列数据类型

• 字符串（str)：表示Unicode字符序列。例如‘hello’。

• 元组类型（tuple）：表示任意类型数据的序列。例如，（1，2，3），（1，“2”）。

• 字节序列（bytes）：表示字节（8位)序列数据。例如，b‘abc’

  Python 中的字节序列 (bytes) 是一种不可变序列类型，它表示一组字节数据。它与 Python 中的字符串 (str) 类型类似，但是字符串是一组 Unicode 字符的序列，而字节序列则是一组字节的序列，可以包含任意的二进制数据，例如图像、音频、视频等。

  下面是一个使用字节序列的简单例子，首先将一个字符串转换为字节序列，然后将字节序列写入到磁盘文件中：

  # 将字符串转换为字节序列
  data = b"Hello, world!"
  
  # 将字节序列写入到文件中
  with open("example.dat", "wb") as f:
      f.write(data)
  

  在这个例子中，我们首先使用 b 前缀将一个字符串转换为字节序列，然后使用 open() 函数打开一个二进制文件，使用 “wb” 模式将文件打开为写入模式，最后使用 write() 方法将字节序列写入到文件中。

  字节序列是一种非常有用的数据类型，在处理各种二进制数据时都可以使用它。在实际开发中，我们经常会遇到需要读写二进制文件、网络传输二进制数据等情况，这时字节序列就是一种非常实用的数据类型。

  要输出文件 example.dat 中的内容，可以使用 Python 的文件读取操作。可以使用 open() 函数打开文件，并使用 read() 方法读取文件内容，如下所示：

  with open("example.dat", "rb") as f:
      data = f.read()
      print(data)
  

  在这个例子中，我们使用 open() 函数打开 example.dat 文件，并使用 “rb” 模式将文件打开为二进制读取模式。然后使用 read() 方法读取文件内容，并将结果存储在变量 data 中。最后使用 print() 函数将 data 输出到控制台中。

  需要注意的是，由于文件中的内容是二进制数据，因此在输出时可能会出现一些奇怪的字符，比如非 ASCII 字符、控制字符等。如果想要以可读的方式输出文件内容，可以将字节序列转换为字符串，如下所示：

  with open("example.dat", "rb") as f:
      data = f.read()
      text = data.decode("utf-8")
      print(text)
  

  在这个例子中，我们首先使用 read() 方法读取文件内容，并将结果存储在变量 data 中。然后使用 decode() 方法将字节序列转换为字符串，指定编码方式为 “utf-8”。最后使用 print() 函数将字符串输出到控制台中。

可变序列数据类型

• 列表类型（list）：表示可以修改的任意类型数据的序列。例如，[1,“two”]。

• 字节数组（bytearray）：表示可以修改的字节（8位）数组

  Python 中的字节数组 (bytearray) 类型与字节序列 (bytes) 类型类似，也是一种表示一组字节数据的不可变序列类型，但是它是可变的，可以通过下标索引和切片等方式修改字节数组中的元素。它与 Python 中的列表 (list) 类型类似，但是字节数组中的元素必须是整数值，且范围必须在 0 到 255 之间。

  下面是一个使用字节数组的简单例子，首先创建一个字节数组，然后将字节数组中的元素修改为新的值：

  # 创建一个字节数组
  data = bytearray(b"Hello, world!")
  
  # 修改字节数组中的元素
  data[0] = 72  # 将第一个字节修改为 ASCII 码值为 72 的字符 "H"
  data[1] = 105 # 将第二个字节修改为 ASCII 码值为 105 的字符 "i"
  
  # 将字节数组转换为字符串并输出
  text = data.decode("utf-8")
  print(text)
  

  输出结果

  Hillo, world!
  

  在这个例子中，我们首先使用 bytearray() 函数创建了一个字节数组，使用 b 前缀将字符串转换为字节序列，并将其作为参数传递给 bytearray() 函数。然后我们使用下标索引的方式修改字节数组中的元素，将第一个字节修改为字符 “H” 的 ASCII 码值 72，将第二个字节修改为字符 “i” 的 ASCII 码值 105。最后，我们使用 decode() 方法将字节数组转换为字符串，并使用 print() 函数输出字符串。

  需要注意的是，由于字节数组是可变的，因此在修改元素时需要确保修改后的值在 0 到 255 的范围内。此外，字节数组与字节序列不同，它是可变的，因此在处理需要修改字节的情况下，字节数组是一种非常有用的数据类型。

4.1.3 集合数据类型

Python 中的集合 (set) 数据类型是一种无序不重复元素的集合，它是一种可变序列类型，可以添加、删除元素，还支持集合之间的交、并、差等操作。Python 中还有一个不可变的集合类型，叫做 frozenset。

下面是一些集合操作的例子：

# 创建一个集合
s1 = set([1, 2, 3, 4, 5])  # 可以使用 set() 函数或者 {} 创建集合
s2 = {4, 5, 6, 7, 8}

# 求两个集合的交集
s3 = s1.intersection(s2)  # 可以使用 & 运算符求交集
print(s3)  # 输出 {4, 5}

# 求两个集合的并集
s4 = s1.union(s2)  # 可以使用 | 运算符求并集
print(s4)  # 输出 {1, 2, 3, 4, 5, 6, 7, 8}

# 求两个集合的差集
s5 = s1.difference(s2)  # 可以使用 - 运算符求差集
print(s5)  # 输出 {1, 2, 3}

# 判断一个元素是否在集合中
print(3 in s1)  # 输出 True
print(9 in s1)  # 输出 False

# 向集合中添加元素
s1.add(6)
print(s1)  # 输出 {1, 2, 3, 4, 5, 6}

# 从集合中删除元素
s1.remove(5)
print(s1)  # 输出 {1, 2, 3, 4, 6}

在这个例子中，我们首先使用 set() 函数创建了两个集合 s1 和 s2，然后演示了集合的交、并、差等操作，以及判断元素是否在集合中、向集合中添加元素、从集合中删除元素等操作。

集合是一种非常有用的数据类型，在去重、判断元素是否存在、集合运算等方面都非常方便快捷。如果需要处理一组无序不重复的元素，可以考虑使用集合。

frozenset 是 Python 中一种不可变的集合类型，与 set 类型类似，它也表示一组无序不重复的元素，但是它的内容不能修改。与 tuple 类型类似，frozenset 也是一种不可变序列类型。

下面是一个使用 frozenset 的例子，首先创建一个 frozenset，然后将其作为字典的键：

# 创建一个 frozenset
s = frozenset([1, 2, 3, 4, 5])

# 将 frozenset 作为字典的键
d = {s: "Hello, world!"}

# 输出字典的值
print(d[s])  # 输出 "Hello, world!"

在这个例子中，我们首先使用 frozenset() 函数创建了一个不可变集合 s，然后将其作为字典 d 的键，将字符串 “Hello, world!” 作为值。最后我们使用 s 作为键从字典中取出值并输出。

由于 frozenset 是不可变的，因此可以作为字典的键使用。在实际开发中，有时需要将一些不可变的对象作为字典的键，这时 frozenset 就是一个非常实用的数据类型。

4.1.4 字典数据类型

Python 中的字典 (dictionary) 数据类型是一种无序的键-值对集合，它是一种可变序列类型，可以添加、删除、修改键值对。Python 中的字典类似于其他编程语言中的哈希表、映射等数据结构，是一种非常强大和常用的数据类型。

下面是一些字典操作的例子：

# 创建一个字典
d = {"name": "Alice", "age": 25, "city": "New York"}

# 访问字典中的元素
print(d["name"])  # 输出 "Alice"
print(d.get("age"))  # 输出 25

# 修改字典中的元素
d["age"] = 26
print(d)  # 输出 {"name": "Alice", "age": 26, "city": "New York"}

# 添加新的键值对
d["gender"] = "female"
print(d)  # 输出 {"name": "Alice", "age": 26, "city": "New York", "gender": "female"}

# 删除字典中的元素
del d["city"]
print(d)  # 输出 {"name": "Alice", "age": 26, "gender": "female"}

# 检查字典中是否存在某个键
print("age" in d)  # 输出 True
print("city" in d)  # 输出 False

# 遍历字典中的元素
for key in d:
    print(key, d[key])

在这个例子中，我们首先使用 {} 符号创建了一个字典 d，包含三个键值对。然后演示了访问、修改、添加、删除、检查键是否存在等操作，以及遍历字典中的元素。

字典是一种非常常用和强大的数据类型，在处理键值对数据时非常方便快捷。如果需要处理一组键值对数据，可以考虑使用字典。

4.1.5 NoneType，NotImplementedType和EllipsisType

在 Python 中，NoneType、NotImplementedType 和 EllipsisType 都是特殊的内置类型。

1. NoneType：表示对象不存在，或者没有值。在 Python 中，NoneType 是一个特殊的对象，用于表示空值或者不存在的对象。在函数中，如果没有返回值，通常会返回 None。

2. NotImplementedType：表示某个操作没有被实现。在 Python 中，NotImplementedType 是一个特殊的对象，用于表示某个操作没有被实现。通常情况下，如果某个操作在一个对象上没有被实现，Python 会返回 NotImplementedType，而不是抛出异常。

3. EllipsisType：表示省略号。在 Python 中，EllipsisType 是一个特殊的对象，用于表示省略号。省略号通常用于表示某些操作或者语法中的省略部分，比如切片操作中的省略符号。

下面是一些示例代码，演示如何使用这些特殊类型：

# 使用 NoneType 表示空值
x = None
if x is None:
    print("x is None")

# 使用 NotImplementedType 表示某个操作没有被实现
class MyClass:
    def __eq__(self, other):
        return NotImplemented

x = MyClass()
y = MyClass()
if x == y:
    print("x and y are equal")

# 使用 EllipsisType 表示省略号
a = [1, 2, 3, 4, 5]
print(a[2:...])  # 输出 [3, 4, 5]

在这个例子中，我们演示了如何使用 NoneType、NotImplementedType 和 EllipsisType。在第一个示例中，我们使用 None 表示空值。在第二个示例中，我们在自定义类中使用 NotImplemented 表示某个操作没有被实现。在第三个示例中，我们使用省略号表示切片操作中的省略部分。

4.2 int类型

在 Python 中，int (integer) 是一种整数数据类型。Python 中的整数类型是一种非常基础和常用的数据类型，它可以表示任意大小的整数，包括正整数、负整数和零。

下面是一些整数操作的例子：

# 定义一个整数
x = 10

# 打印整数
print(x)  # 输出 10

# 执行整数运算
y = x + 5
z = x * y
print(y, z)  # 输出 15 150

# 使用内置函数转换整数类型
s = "123"
n = int(s)
print(n)  # 输出 123

# 使用内置函数进行进制转换
n1 = 0b1010  # 二进制
n2 = 0o12  # 八进制
n3 = 0x0A  # 十六进制
print(n1, n2, n3)  # 输出 10 10 10

在这个例子中，我们首先定义了一个整数 x，然后演示了打印整数、执行整数运算、使用内置函数转换整数类型、使用内置函数进行进制转换等操作。

整数是一种非常基础和常用的数据类型，在计算、统计、控制流程等方面都非常重要。如果需要处理整数数据，可以考虑使用整数类型。

4.3 float类型

在 Python 中，float (floating point number) 是一种浮点数数据类型。Python 中的浮点数类型可以表示带小数点的实数，包括正数、负数和零。Python浮点类型的精度与系统相关。

下面是一些浮点数操作的例子：

# 定义一个浮点数
x = 3.14

# 打印浮点数
print(x)  # 输出 3.14

# 执行浮点数运算
y = x + 1.86
z = x * y
print(y, z)  # 输出 4.999999999999999 15.6856

# 使用内置函数转换浮点数类型
s = "3.14"
f = float(s)
print(f)  # 输出 3.14

# 使用科学计数法表示浮点数
a = 1.23e-4  # 表示 0.000123
b = 1.23e+4  # 表示 12300
print(a, b)  # 输出 0.000123 12300.0

在这个例子中，我们首先定义了一个浮点数 x，然后演示了打印浮点数、执行浮点数运算、使用内置函数转换浮点数类型、使用科学计数法表示浮点数等操作。

浮点数是一种非常常用的数据类型，在科学计算、物理模拟、金融计算等方面都非常重要。如果需要处理实数数据，可以考虑使用浮点数类型。需要注意的是，由于计算机内部表示的限制，浮点数运算有时会产生精度误差。

方法	说明	实例
as_integer_ratio()	返回浮点数的分子和分母	3.14.as_integer_ratio() 返回 (157, 50)
is_integer()	判断浮点数是否为整数	3.0.is_integer() 返回 True，3.14.is_integer() 返回 False
hex()	将浮点数转换为十六进制表示	(3.14).hex() 返回 ‘0x1.91eb851eb851fp+1’

4.4 comloex类型

在 Python 中，complex 是一种内置类型，表示复数。复数是由一个实数部分和一个虚数部分组成的数，可以表示为 a + bi 的形式，其中 a 和 b 都是实数，i 是虚数单位。

语法格式：

z = complex(real, imag)

其中，real 表示实数部分，imag 表示虚数部分。如果省略 imag，则默认为 0。如果省略 real 和 imag，则默认为 0。

下面是一些创建复数的例子：

# 创建实部和虚部都为 0 的复数
z1 = complex()
print(z1)  # 输出 0j

# 创建实部为 3，虚部为 4 的复数
z2 = complex(3, 4)
print(z2)  # 输出 (3+4j)

# 创建实部为 3，虚部为 0 的复数
z3 = complex(3)
print(z3)  # 输出 (3+0j)

complex 对象具有一些常用的属性和方法，下面是一些常用的属性和方法：

属性/方法	说明	示例
real	返回复数的实数部分	z.real 返回 3.0
imag	返回复数的虚数部分	z.imag 返回 4.0
conjugate()	返回复数的共轭复数	z.conjugate() 返回 (3-4j)
abs()	返回复数的模	z.abs() 返回 5.0

下面是一些复数运算的例子：

# 复数加法
z1 = complex(3, 4)
z2 = complex(2, 1)
z3 = z1 + z2
print(z3)  # 输出 (5+5j)

# 复数减法
z4 = z1 - z2
print(z4)  # 输出 (1+3j)

# 复数乘法
z5 = z1 * z2
print(z5)  # 输出 (-5+14j)

# 复数除法
z6 = z1 / z2
print(z6)  # 输出 (2.2+0.4j)

在这个例子中，我们首先演示了如何创建复数对象，然后使用实数部分、虚数部分、共轭复数、模等属性和方法。最后，我们演示了复数加法、减法、乘法、除法等运算。

复数类型是一种非常有用的数据类型，在数学、物理、工程等方面都有广泛的应用。如果需要处理复数数据，可以考虑使用复数类型。

4.5 bool类型

bool数据类型包含两个值：True（真）或False（假）

在 Python 中，逻辑运算符包括 and、or 和 not 三种。

• and 运算符：如果两个操作数都为 True，则结果为 True，否则结果为 False。
• or 运算符：如果两个操作数中至少有一个为 True，则结果为 True，否则结果为 False。
• not 运算符：如果操作数为 True，则结果为 False，否则结果为 True。

逻辑运算符常用于条件语句和循环语句中，用于判断和控制程序的执行流程。

下面是一些逻辑运算符的示例代码：

# and 运算符
x = 3
y = 5
z = 7
result = (x < y) and (y < z)
print(result)  # 输出 True

result = (x > y) and (y < z)
print(result)  # 输出 False

# or 运算符
x = 3
y = 5
z = 7
result = (x > y) or (y < z)
print(result)  # 输出 True

result = (x > y) or (y > z)
print(result)  # 输出 False

# not 运算符
x = 3
y = 5
z = 7
result = not (x < y)
print(result)  # 输出 False

result = not (x > y)
print(result)  # 输出 True

在这个例子中，我们演示了逻辑运算符的使用，包括 and、or 和 not 运算符。在每个示例中，我们定义了一些变量，并使用逻辑运算符对它们进行条件判断，最后输出运算结果。

逻辑运算符是编程中常用的工具之一，可以用于判断和控制程序的执行流程。如果需要进行条件判断和控制流程，可以考虑使用逻辑运算符。

4.6 str类型

字符串（str）是一个有序的字符集合。在Python中没有独立的字符数据类型，字符即长度为1的字符串。Python的内置数据类型str用于字符串处理。str对象的值为字符系列。str对象（字符串）是不可变对象。

4.6.1 字符串字面量

在 Python 中，字符串字面量是一种表示字符串的语法。字符串字面量可以是单引号、双引号或三引号括起来的一段文本。例如：

s1 = 'hello'
s2 = "world"
s3 = '''Python is a popular programming language.'''

在上面的示例中，s1 和 s2 是使用单引号和双引号定义的字符串字面量，s3 是使用三引号定义的字符串字面量。三引号可以用来表示多行字符串，例如：

s4 = '''Hello,
world!'''

在这个例子中，s4 是一个包含多行文本的字符串，可以直接使用三引号来定义。

字符串字面量可以包含转义字符，例如 \n 表示换行符，\t 表示制表符，\ 表示反斜杠字符。例如：

s5 = 'This is a string with a newline character:\nHere is the next line.'
s6 = 'This is a string with a tab character:\tHere is the next tab.'
s7 = 'This is a string with a backslash character:\\Here is the next character.'

在这个例子中，s5 包含了一个换行符，s6 包含了一个制表符，s7 包含了一个反斜杠字符。

字符串字面量还支持字符串格式化操作，可以使用格式化字符串语法来将变量插入到字符串中，例如：

name = 'Alice'
age = 30
s8 = f'My name is {name} and I am {age} years old.'

在这个例子中，我们使用格式化字符串语法将变量 name 和 age 插入到字符串中，得到一个新的字符串 s8。

字符串字面量是 Python 中常用的数据类型之一，可以表示文本和字符数据，并支持多种操作和格式化操作。如果需要处理文本和字符数据，可以考虑使用字符串字面量。

4.6.2 转义字符

在 Python 中，转义字符是一种特殊的字符序列，它们以反斜杠字符 \ 开头，用于表示一些特殊的字符或字符序列。常见的转义字符包括：

转义字符	描述
\	反斜杠字符
’	单引号字符
"	双引号字符
\n	换行符
\t	制表符
\r	回车符
\b	退格符
\f	换页符
\ooo	八进制表示的字符，其中 ooo 是一个 1~3 位的八进制数
\xhh	十六进制表示的字符，其中 hh 是一个 1~2 位的十六进制数

下面是一些使用转义字符的示例代码：

# 反斜杠字符
s1 = 'A\\B\\C'
print(s1)  # 输出 A\B\C

# 单引号字符
s2 = 'It\'s a beautiful day.'
print(s2)  # 输出 It's a beautiful day.

# 双引号字符
s3 = "He said, \"Hello, world!\""
print(s3)  # 输出 He said, "Hello, world!"

# 换行符
s4 = 'Line 1\nLine 2'
print(s4)  # 输出 Line 1\nLine 2

# 制表符
s5 = 'Name:\tAlice\nAge:\t30'
print(s5)  # 输出 Name:  Alice\nAge:   30

# 八进制表示的字符
s6 = '\101\102\103'
print(s6)  # 输出 ABC

# 十六进制表示的字符
s7 = '\x41\x42\x43'
print(s7)  # 输出 ABC

在这个例子中，我们演示了一些常用的转义字符，包括反斜杠字符、单引号字符、双引号字符、换行符、制表符、八进制表示的字符和十六进制表示的字符。在每个示例中，我们定义了一个字符串变量，并使用转义字符来表示特殊的字符或字符序列。

转义字符是处理文本数据时常用的工具，可以用于表示特殊的字符或字符序列。如果需要处理文本数据，可以考虑使用转义字符。

4.6.3 字符串编码

在 Python 中，字符串编码是指将 Unicode 字符串转换为二进制数据的过程。Python 中支持多种字符串编码，包括 ASCII、UTF-8、UTF-16、GBK 等。不同的编码方式对应不同的二进制数据表示方法，这些编码方式之间的转换需要使用编解码函数来完成。

下面是一些常用的编码函数：

函数	描述
encode(encoding)	将字符串编码为指定的编码方式的二进制数据
decode(encoding)	将指定编码方式的二进制数据解码为 Unicode 字符串

下面是一些使用编码函数的示例代码：

# 将字符串编码为 UTF-8 格式的二进制数据
s1 = 'hello'
b1 = s1.encode('utf-8')
print(b1)  # 输出 b'hello'

# 将 UTF-8 格式的二进制数据解码为 Unicode 字符串
s2 = b1.decode('utf-8')
print(s2)  # 输出 hello

# 将字符串编码为 GBK 格式的二进制数据
s3 = '你好'
b2 = s3.encode('gbk')
print(b2)  # 输出 b'\xc4\xe3\xba\xc3'

# 将 GBK 格式的二进制数据解码为 Unicode 字符串
s4 = b2.decode('gbk')
print(s4)  # 输出 你好

在这个例子中，我们使用 encode 函数将字符串编码为指定格式的二进制数据，然后使用 decode 函数将二进制数据解码为 Unicode 字符串。在每个示例中，我们都指定了编码方式，例如 utf-8、gbk 等。

字符串编码是处理文本数据时常用的工具，可以将 Unicode 字符串转换为二进制数据，并根据需要将二进制数据解码为 Unicode 字符串。如果需要处理文本数据，可以考虑使用字符串编码。

4.6.4 str对象的属性和方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LorrWv8S-1686327751669)(C:\Users\29363\Desktop\笔记\python\img\str1.png)]

4.6.5 字符串的运算

在 Python 中，字符串是一种不可变序列类型，用于表示文本和字符数据。字符串可以进行多种运算，包括索引、切片、拼接、重复和比较等。

下面是一些常用的字符串运算：

运算	描述	示例
索引	获取字符串中指定位置的字符	s[0] 返回字符串 s 的第一个字符
切片	获取字符串中指定范围的子串	s[1:4] 返回字符串 s 中第 2~4 个字符组成的子串
拼接	将两个字符串拼接成一个新的字符串	s1 + s2 返回 s1 和 s2 拼接成的新字符串
重复	将一个字符串重复多次得到一个新的字符串	s * n 返回由 s 重复 n 次组成的新字符串
比较	比较两个字符串的大小关系	s1 == s2 判断 s1 和 s2 是否相等

下面是一些使用字符串运算的示例代码：

# 索引
s1 = 'hello'
print(s1[0])  # 输出 h

# 切片
s2 = 'world'
print(s2[1:4])  # 输出 orl

# 拼接
s3 = 'hello'
s4 = 'world'
s5 = s3 + ' ' + s4
print(s5)  # 输出 hello world

# 重复
s6 = 'python '
s7 = s6 * 3
print(s7)  # 输出 python python python 

# 比较
s8 = 'hello'
s9 = 'world'
print(s8 == s9)  # 输出 False

在这个例子中，我们演示了一些常用的字符串运算，包括索引、切片、拼接、重复和比较。在每个示例中，我们定义了一个字符串变量，并使用字符串运算来获取子串、拼接字符串、重复字符串和比较字符串等。

字符串是 Python 中常用的数据类型之一，可以表示文本和字符数据，并支持多种操作和运算。如果需要处理文本和字符数据，可以考虑使用字符串。

4.6.6 对象转换为字符串

使用内置函数str（）可以把数值转换为字符串。实际上，在使用print（123）输出数值时将自动调用str（123)函数把123转换为字符串，然后输出。python还内置了另一个函数repr（），该函数返回一个对象的更精确的字符串表示形式。

这两个函数的主要区别在于它们生成的字符串格式不同。

str() 函数返回一个可读性好的字符串，用于显示给用户看，而 repr() 函数返回一个准确的字符串，用于表示对象的内部结构。通常来说，如果一个对象需要打印输出或显示给用户看，应该使用 str() 函数；如果一个对象需要在代码中表示或进行调试，应该使用 repr() 函数。

x = 'hello'
print(str(x))   # 输出 hello
print(repr(x))  # 输出 'hello'

y = {'name': 'Alice', 'age': 30}
print(str(y))   # 输出 {'name': 'Alice', 'age': 30}
print(repr(y))  # 输出 {'name': 'Alice', 'age': 30}

z = [1, 2, 3]
print(str(z))   # 输出 [1, 2, 3]
print(repr(z))  # 输出 [1, 2, 3]

在这个例子中，我们使用 str() 和 repr() 函数将字符串、字典和列表等对象转换为字符串。在每个示例中，我们都分别使用了 str() 和 repr() 函数，并输出了它们生成的字符串。

从输出结果可以看出，str() 函数返回的字符串是可读性好的，包括了对象的值和类型信息；而 repr() 函数返回的字符串是准确的，包括了对象的值、类型和内部结构信息，通常带有引号和转义字符等。

4.6.7 字符串的格式化

在 Python 中，字符串格式化是将字符串中的占位符替换为具体的值的过程。Python 提供了多种字符串格式化方式，包括旧式格式化、新式格式化和 f-string 格式化。

下面是一些使用字符串格式化的示例代码：

# 旧式格式化
name = 'Alice'
age = 30
print('My name is %s, and I am %d years old.' % (name, age))

# 新式格式化
name = 'Bob'
age = 35
print('My name is {}, and I am {} years old.'.format(name, age))

# f-string 格式化
name = 'Charlie'
age = 40
print(f'My name is {name}, and I am {age} years old.')

在这个例子中，我们演示了三种不同的字符串格式化方式。在旧式格式化中，我们使用 % 运算符和占位符来表示要替换的值；在新式格式化中，我们使用 format 函数来对占位符进行替换；在 f-string 格式化中，我们使用 f 字符串和大括号来表示要替换的值。

不同的字符串格式化方式在语法和用法上有所不同，但它们都以类似的方式将占位符替换为具体的值，并生成新的字符串。如果需要进行字符串格式化，可以考虑使用这些字符串格式化方式之一。

这是一些关于字符串对齐的示例代码。在这些示例中，我们演示了使用字符串方法 center()、rjust() 和 format() 对字符串进行居中、右对齐和填充操作。

# 字符串居中
print("1".center(20))

# 使用 format() 函数居中
print(format("121","^20"))
print(format("12321","^20"))

# 字符串右对齐
print("1".rjust(20,"*"))

# 使用 format() 函数右对齐
print(format("121","*>20"))
print(format("12321","*>20"))

输出结果如下：

        1          
       121        
      12321       
*******************1
*****************121
***************12321

在这个例子中，我们使用了字符串方法 center()、rjust() 和 format() 对字符串进行了居中和右对齐操作。在每个示例中，我们都使用了不同的方法来实现字符串对齐。通过这些方法，我们可以方便地控制字符串在输出时的对齐方式和格式。

4.7 比较关系运算和条件表达式

4.7.1 条件表达式

在 Python 中，条件表达式是一种简洁的语法，用于在单行代码中实现条件判断。条件表达式通常由三个部分组成：一个条件、一个 if 关键字、一个表达式。如果条件为真，则返回表达式的值；否则返回另一个表达式的值。

下面是一些使用条件表达式的示例代码：

# 使用条件表达式实现求绝对值
x = -5
abs_x = x if x >= 0 else -x
print(abs_x)  # 输出 5

# 使用条件表达式实现求最大值
a = 10
b = 20
max_value = a if a >= b else b
print(max_value)  # 输出 20

# 使用条件表达式实现判断奇偶性
num = 7
is_even = "偶数" if num % 2 == 0 else "奇数"
print(is_even)  # 输出 奇数

在这个例子中，我们演示了三个不同的条件表达式。在第一个示例中，我们使用条件表达式实现求绝对值；在第二个示例中，我们使用条件表达式实现求最大值；在第三个示例中，我们使用条件表达式实现判断奇偶性。在每个示例中，我们都使用了条件表达式来实现条件判断，并返回相应的值。

条件表达式是一种简洁、高效的语法，可以在单行代码中实现条件判断。如果需要进行简单的条件判断，可以考虑使用条件表达式。

4.7.2 关系和测试运算符

在 Python 中，列表是一种有序的集合类型，可以存储多个元素，并支持多种操作和运算。其中，关系运算符和测试运算符是常用的列表运算符之一。

关系运算符用于比较两个列表之间的大小关系，包括等于、不等于、小于、小于等于、大于和大于等于六种运算符。测试运算符用于测试列表中是否包含某个元素，包括 in 和 not in 两种运算符。

下面是一些关于关系运算符和测试运算符的示例代码：

运算符	表达式	含义	示例	结果
等于	lst1 == lst2	判断 lst1 和 lst2 是否包含相同的元素	[1, 2, 3] == [1, 2, 3]	True
不等于	lst1 != lst2	判断 lst1 和 lst2 是否包含不同的元素	[1, 2, 3] != [4, 5, 6]	True
小于	lst1 < lst2	判断 lst1 是否在字典序上小于 lst2	[1, 2, 3] < [2, 3, 4]	True
小于等于	lst1 <= lst2	判断 lst1 是否在字典序上小于或等于 lst2	[1, 2, 3] <= [2, 3, 4]	True
大于	lst1 > lst2	判断 lst1 是否在字典序上大于 lst2	[2, 3, 4] > [1, 2, 3]	True
大于等于	lst1 >= lst2	判断 lst1 是否在字典序上大于或等于 lst2	[2, 3, 4] >= [1, 2, 3]	True
包含	x in lst	判断列表 lst 中是否包含元素 x	2 in [1, 2, 3]	True
不包含	x not in lst	判断列表 lst 中是否不包含元素 x	4 not in [1, 2, 3]	True
is	x is y	判断 x和y是不是同一个对象	x=y=1; x is y	True

在这个示例中，我们演示了关系运算符和测试运算符的使用方法和含义，并给出了相应的示例和结果。这些运算符可以用于比较两个列表之间的大小关系，以及测试列表中是否包含某个元素。如果需要进行列表的比较和测试操作，可以考虑使用这些运算符。

4.8 算术运算符和位运算符

4.8.1 算术运算符

以下是关于 Python 中算术运算符、关系运算符和测试运算符的综合表说明：

运算符	含义	优先级	示例	结果
+	加法运算符，用于将两个列表相加或者将列表中的元素进行加法运算	低	[1, 2] + [3, 4]	[1, 2, 3, 4]
-	减法运算符，用于将一个列表中的元素去掉另一个列表中存在的元素	低	[1, 2, 3] - [2]	[1, 3]
*	乘法运算符，用于将列表中的元素重复多次	中	[1, 2] * 3	[1, 2, 1, 2, 1, 2]
/	除法运算符，用于将列表中的元素进行除法运算	高	[1, 2, 3] / 2	报错，TypeError: unsupported operand type(s) for /: ‘list’ and ‘int’
**	乘幂运算符，用于求幂运算	最高	2 ** 3	8
//	整数除法运算符，用于求整数商	高	7 // 2	3
%	模数运算符，用于求除法的余数	高	7 % 2	1

4.8.2 位运算符

运算符	含义	优先级	实例	结果
&	按位与运算符，对两个整数二进制位进行“与”运算	低	5 & 3	1
|	按位或运算符，对两个整数二进制位进行“或”运算	低	5 | 3	7
^	按位异或运算符，对两个整数二进制位进行“异或”运算	低	5 ^ 3	6
~	按位取反运算符，对一个整数二进制位进行“取反”运算	低	~5	-6
<<	左移位运算符，将一个整数二进制位向左移动指定位数	中	5 << 1	10
>>	右移位运算符，将一个整数二进制位向右移动指定位数	中	5 >> 1	2

在这个示例中，我们列出了位运算符的名称、含义、优先级、用法和结果。位运算符对整数的二进制表示进行操作，可以用于位运算、加密和哈希函数等场景。其中按位与运算符、按位或运算符和按位异或运算符用于对两个整数的二进制位进行“与”、“或”和“异或”操作，按位取反运算符用于对一个整数的二进制位进行“取反”操作，左移位运算符和右移位运算符用于将一个整数的二进制位向左或向右移动指定位数。需要注意的是，位运算符的优先级比较低，可以使用括号来明确运算的优先级。

4.9 混合运算和数值类型转换

Python 中的混合运算指的是在表达式中同时使用多种不同类型的变量或常量进行运算，例如整数、浮点数、复数、字符串等。在进行混合运算时，Python 会根据一定的规则进行类型转换，以便进行数值计算。

下面是一个关于 Python 中混合运算和类型转换的例子：

a = 5
b = 3.14
c = complex(2, 3)
d = "hello"

# 混合运算
print(a + b) # 8.14
print(c - a) # ( -3 + 3j )
print(a * d) # hellohellohellohellohello
print(b / c) # (0.5952380952380953-0.4523809523809524j)

# 类型转换
print(int(b)) # 3
print(float(a)) # 5.0
print(complex(a)) # (5+0j)
print(str(c)) # (2+3j)

在这个例子中，我们定义了不同类型的变量和常量，包括一个整数、一个浮点数、一个复数和一个字符串。然后我们进行了混合运算，例如在整数和浮点数之间进行加法、在复数和整数之间进行减法、在整数和字符串之间进行乘法、在浮点数和复数之间进行除法等。在进行混合运算时，Python 会根据一定的规则进行类型转换，例如将整数转换为浮点数、将浮点数转换为复数、将字符串转换为数字等。需要注意的是，有些类型之间不能进行运算或类型转换，这时会产生错误。因此在进行混合运算时，需要注意类型的兼容性和转换规则。

4.10 内置标准数学函数

4.10.1 内置数学运算函数

以下是 Python 中一些内置的数学运算函数的三线表说明：

函数	含义	示例	结果
abs(x)	返回 x 的绝对值	abs(-2.5)	2.5
pow(x, y) 或 x ** y	返回 x 的 y 次幂	pow(2, 3) 或 2 ** 3	8
round(x, n)	返回 x 的四舍五入值，n 表示小数点后保留的位数	round(3.14159, 2)	3.14
int(x)	将 x 转换为整数	int(3.14)	3
float(x)	将 x 转换为浮点数	float(3)	3.0
complex(x, y)	返回实部为 x，虚部为 y 的复数	complex(2, 3)	(2+3j)
divmod(x, y)	返回 x 除以 y 的商和余数	divmod(10, 3)	(3, 1)
max(x1, x2, …, xn)	返回 x1, x2, …, xn 中的最大值	max(3, 5, 1, 2)	5
min(x1, x2, …, xn)	返回 x1, x2, …, xn 中的最小值	min(3, 5, 1, 2)	1
sum(iterable)	返回可迭代对象 iterable 中所有元素的和	sum([1, 2, 3, 4])	10

在这个示例中，我们列出了一些常用的数学运算函数的名称、含义、示例和结果。这些函数可以用于数值计算、数据分析、统计学和科学计算等领域。例如，abs 函数可以用于求绝对值，pow 函数可以用于求幂运算，round 函数可以用于四舍五入，int 和 float 函数可以用于类型转换，complex 函数可以用于创建复数，divmod 函数可以用于求商和余数，max 和 min 函数可以用于求最大值和最小值，sum 函数可以用于求和。需要注意的是，这些函数的参数和返回值可能是不同类型的，因此在使用时需要注意类型的兼容性和转换规则。

4.10.2 数制转换函数

函数	含义	示例	结果
bin(x)	将整数 x 转换为二进制字符串	bin(10)	‘0b1010’
oct(x)	将整数 x 转换为八进制字符串	oct(10)	‘0o12’
hex(x)	将整数 x 转换为十六进制字符串	hex(10)	‘0xa’
int(x, base=10)	将字符串 x 转换为整数，base 表示进制数，默认为 10	int(‘1010’, 2)	10

在这个示例中，我们列出了一些常用的数制转换函数的名称、含义、示例和结果。这些函数可以用于将不同进制的数字之间进行转换。例如，bin 函数可以将整数转换为二进制字符串，oct 函数可以将整数转换为八进制字符串，hex 函数可以将整数转换为十六进制字符串，int 函数可以将字符串转换为整数。在使用 int 函数进行进制转换时，需要将待转换的字符串作为第一个参数传递给函数，并将要转换的进制数作为第二个参数传递给函数。需要注意的是，转换函数的参数和返回值可能是不同类型的，因此在使用时需要注意类型的兼容性和转换规则。

案例：科学计算和数据分析

• 矩阵的运算

  import numpy as np
  C = np.array([[1,2,3],[4,5,6],[7,8,9]])
  D = np.array([[5,4,2],[2,7,8],[0,1,2]])
  C + D
  C - D
  np.dot(C,D)#矩阵的乘积
  C.T #矩阵的转置
  

• 线性方程的求解

------- |
| bin(x) | 将整数 x 转换为二进制字符串 | bin(10) | ‘0b1010’ |
| oct(x) | 将整数 x 转换为八进制字符串 | oct(10) | ‘0o12’ |
| hex(x) | 将整数 x 转换为十六进制字符串 | hex(10) | ‘0xa’ |
| int(x, base=10) | 将字符串 x 转换为整数，base 表示进制数，默认为 10 | int(‘1010’, 2) | 10 |

在这个示例中，我们列出了一些常用的数制转换函数的名称、含义、示例和结果。这些函数可以用于将不同进制的数字之间进行转换。例如，bin 函数可以将整数转换为二进制字符串，oct 函数可以将整数转换为八进制字符串，hex 函数可以将整数转换为十六进制字符串，int 函数可以将字符串转换为整数。在使用 int 函数进行进制转换时，需要将待转换的字符串作为第一个参数传递给函数，并将要转换的进制数作为第二个参数传递给函数。需要注意的是，转换函数的参数和返回值可能是不同类型的，因此在使用时需要注意类型的兼容性和转换规则。

案例：科学计算和数据分析

• 矩阵的运算

  import numpy as np
  C = np.array([[1,2,3],[4,5,6],[7,8,9]])
  D = np.array([[5,4,2],[2,7,8],[0,1,2]])
  C + D
  C - D
  np.dot(C,D)#矩阵的乘积
  C.T #矩阵的转置
  

• 线性方程的求解