Python 基础变量类型里的字符串与数字类型

在 Python 编程的广阔世界里，基础变量类型构成了程序的基石。其中，字符串和数字类型是最常用的类型，无论是处理文本数据还是进行数值计算，它们都扮演着至关重要的角色。今天，就让我们深入探索 Python 的字符串和数字类型。

一、字符串类型（str）

1.1 什么是字符串

字符串（String）是由零个或多个字符组成的序列，用于表示文本信息。在 Python 中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能改变它的内容（但可以通过重新赋值来更改变量所引用的字符串）。

在 Python 中，字符串可以用单引号（‘ ）、双引号（"）或三引号（’’’ ）、（“”" ）括起来。以下是几种创建字符串的方式示例：

# 使用单引号创建字符串 str1 = 'Hello, Python!' # 使用双引号创建字符串 str2 = "这也是一个字符串" # 使用三引号创建字符串（可以包含多行文本） str3 = '''这是一个 多行字符串''' str4 = """同样是 多行字符串"""

1.2 转义字符

如果字符串中包含单引号，除了可以使用另外一种引号来避免冲突之外，还可以使用转义字符来避免冲突。在 Python 中，转义字符用于在字符串中表示特殊字符或行为，以反斜杠（\）开头。例如，若要在字符串中包含单引号，可以这样写：

str_with_quote = 'It\'s a beautiful day'

除了表示引号的转义字符，Python 中常用的转义字符还有：

• \n：换行符，用于在字符串中创建新的一行。例如：

multiline_str = "第一行\n第二行" print(multiline_str)

运行结果将是：

第一行 第二行

• \t：制表符，用于在字符串中插入一个水平制表位，使文本对齐更美观。比如：

aligned_str = "姓名\t年龄\n张三\t25\n李四\t30" print(aligned_str)

输出结果为：

姓名    年龄 张三    25 李四    30

• \\：表示一个反斜杠字符本身。当需要在字符串中显示反斜杠时使用，例如文件路径中：

file_path = "C:\\Program Files\\Python"

1.3 原始字符串

在 Python 中，前缀 r 或 R 用于创建原始字符串（raw string）。原始字符串的特点是反斜杠（\）不会被解释为转义字符，而是作为普通字符处理。这在处理包含反斜杠的字符串时特别有用，例如文件路径、正则表达式等。

# 普通字符串表示文件路径 normal_path = "C:\\Users\\username\\Documents" # 原始字符串表示文件路径 raw_path = r"C:\Users\username\Documents"

对于正则表达式，假设要匹配一个以数字开头的字符串，在普通字符串中可能需要这样写：

import re pattern = "\\d.*" text = "123abc" match = re.search(pattern, text) if match:     print("匹配成功")

而使用原始字符串会更简洁：

import re pattern = r"\d.*" text = "123abc" match = re.search(pattern, text) if match:     print("匹配成功")

1.4 字符串的格式化输出

在 Python 中，有多种方式可以进行字符串格式化输出，以将变量的值嵌入到字符串中。

1. 百分号（%）格式化：这是最早的字符串格式化方式，类似于 C 语言中的 printf。

name = "Alice" age = 25 formatted_string = "Name: %s, Age: %d岁" % (name, age) print(formatted_string)

输出结果为：Name: Alice, Age: 25岁

其中，%s 是字符串占位符，%d 是整数占位符。还有其他占位符，如 %f 用于浮点数。

2. str.format () 方法：这种方法使用花括号（{}）作为占位符，更加灵活。

name = "Bob" age = 30 formatted_string = "Name: {}, Age: {}岁".format(name, age) print(formatted_string)

也可以通过索引标识位置：

formatted_string = "{1}今年{0}岁".format(35, "Charlie") print(formatted_string)

或者使用关键字参数：

formatted_string = "Name: {n}, Age: {a}岁".format(n="David", a=38) print(formatted_string)

f-strings（格式化字符串字面值）：从 Python 3.6 开始引入，这种方式使用前缀 f 并在字符串中直接嵌入变量。

name = "Eve" age = 42 formatted_string = f"Name: {name}, Age: {age}岁" print(formatted_string)

模板字符串（Template Strings）：使用 string 模块中的 Template 类，可用于更复杂或安全要求更高的情况。

from string import Template name = "Frank" age = 45 t = Template("Name: $n, Age: $a岁") formatted_string = t.substitute(n=name, a=age) print(formatted_string)

1.5 字符串的拼接与重复

1. 字符串拼接：字符串拼接是指将两个或多个字符串连接成一个新的字符串。在 Python 中，可以使用加号（+）来拼接字符串。

str1 = "Hello" str2 = "World" result = str1 + ", " + str2 + "!" print(result)

输出：Hello, World!

需要注意的是，字符串拼接时，加号两边必须是字符串类型，否则会引发类型错误。例如：

num = 10 # 下面这行会报错，因为num是整数类型 # result = str1 + num

正确的做法是先将整数转换为字符串：

num = 10 result = str1 + str(num) print(result)

1. 字符串的重复：可以使用星号（*）来重复字符串。

str_repeat = "Ha" * 3 print(str_repeat)

输出：HaHaHa

1.6 访问字符串中的字符

字符串中的字符可以通过索引（下标）来访问，索引就是编号。Python 支持正向索引和负向索引，正向索引从左往右开始编号，起始值从 0 开始，负向索引表示从字符串末尾开始计数，从右向左，起始值从 - 1 开始。

str_example = "Python" # 正向索引访问 print(str_example[0])  # 输出 'P' print(str_example[2])  # 输出 't' # 负向索引访问 print(str_example[-1])  # 输出 'n' print(str_example[-3])  # 输出 'h'

1.7 字符串切片

切片是指从字符串中提取一部分子字符串。切片通过指定起始索引和结束索引来实现，语法为 (start:end)，其中 start 是起始索引（包含），end 是结束索引（不包含）。如果省略 start，则表示从字符串开头开始；如果省略 end，则表示到字符串结尾为止。

str_slicing = "Hello, Python!" # 从索引2到索引6（不包含6） sub_str = str_slicing[2:6] print(sub_str)  # 输出 'llo,' # 从开头到索引5（不包含5） sub_str = str_slicing[:5] print(sub_str)  # 输出 'Hello' # 从索引7到结尾 sub_str = str_slicing[7:] print(sub_str)  # 输出 'Python!'

除了基本的切片操作，Python 还支持带步长的切片，语法为 (start:end:step)，其中 step 表示步长，可以是正数或负数。

# 从索引0到索引9，步长为2 sub_str = str_slicing[0:9:2] print(sub_str)  # 输出 'Hlo,y' # 步长为负数时，可以实现字符串反转 reversed_str = str_slicing[::-1] print(reversed_str)  # 输出 '!nohtyP,olleH'

1.8 操作字符串的内置函数

在 Python 中，有一些常用的公共内置函数可用于处理字符串。

len()：返回对象的长度或项目个数。对于字符串而言，返回字符串中字符的数量。

str_len = "Hello, World!" length = len(str_len) print(length)  # 输出 13

max () 和 min ()：返回可迭代对象中的最大值和最小值。对于字符串而言，返回字符串中按字典序的最大和最小字符。

str_example = "abcdef" max_char = max(str_example) min_char = min(str_example) print(max_char)  # 输出 'f' print(min_char)  # 输出 'a'

sorted()：对可迭代对象进行排序，并返回一个新的已排序列表。对于字符串而言，返回字符串中字符按字典序排序后的新列表。

str_sort = "banana" sorted_list = sorted(str_sort) print(sorted_list)  # 输出 ['a', 'a', 'a', 'b', 'n', 'n'] # 设置参数reverse=True可以实现降序排序 sorted_list_desc = sorted(str_sort, reverse=True) print(sorted_list_desc)  # 输出 ['n', 'n', 'b', 'a', 'a', 'a']

type()：返回对象的类型。对于字符串而言，返回 <class'str'>。

str_type = "This is a string" print(type(str_type))  # 输出 <class'str'>

str()：将对象转换为字符串。虽然这不是一个专门用于处理字符串的内置函数，但在需要将其他类型的数据（如数字、列表、元组等）转换为字符串时非常有用。

num = 123 num_str = str(num) print(type(num_str))  # 输出 <class'str'>

format()：用于格式化字符串，将变量的值插入到字符串的占位符中，前面已经在字符串格式化输出部分详细介绍过。

chr () 和 ord ()：chr() 函数用于将 Unicode 码点转换为对应的字符，ord() 函数用于将字符转换为对应的 Unicode 码点。

# 将Unicode码点97转换为字符 char = chr(97) print(char)  # 输出 'a' # 将字符 'A' 转换为Unicode码点 code_point = ord('A') print(code_point)  # 输出 65

二、数字类型

在 Python 中，数字类型用于存储数值，是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。Python 支持四种不同的数字类型：int（有符号整型）、float（浮点型）、complex（复数），另外还有 bool（布尔型）可以看作是整数的子类。

2.1 整数类型（int）

整数是用于表示没有小数部分的数值，可以是正数、负数或零。在 Python 中，整数的表示非常直观，直接书写数字即可。

# 正数 positive_int = 100 # 负数 negative_int = -20 # 零 zero_int = 0

Python 中的整数可以用十进制、二进制、八进制和十六进制来表示：

• 十进制：我们日常生活中最常用的计数系统，在 Python 中，十进制整数直接书写数字即可，如 123、456。
• 二进制：计算机内部使用的计数系统，由 0 和 1 组成。在 Python 中，二进制整数以 0b 或 0B 开头。例如：

binary_num = 0b1010  # 表示十进制的10

• 八进制：在某些特定场景下会用到，以 0o 或 0O 开头。比如：

octal_num = 0o12  # 表示十进制的10

• 十六进制：常用于表示颜色、内存地址等，以 0x 或 0X 开头。例如：

hex_num = 0xA  # 表示十进制的10

Python 支持丰富的整数运算，包括基本的算术运算、位运算以及一些特殊的运算操作。

1.基本算术运算：

加法（+）：将两个整数相加。例如：

result = 3 + 5 print(result)  # 输出 8

减法（-）：从一个整数中减去另一个整数。例如：

result = 10 - 3 print(result)  # 输出 7

乘法（*）：将两个整数相乘。例如：

result = 4 * 6 print(result)  # 输出 24

除法（/）：结果为浮点数。例如：

result = 10 / 3 print(result)  # 输出 3.3333333333333335

整除（//）：取整除结果，即商的整数部分。例如：

result = 10 // 3 print(result)  # 输出 3

取余（%）：返回除法的余数。例如：

result = 10 % 3 print(result)  # 输出 1

幂运算（**）：计算一个数的幂。例如：

result = 2 ** 3 print(result)  # 输出 8

2.位运算：对整数的二进制表示进行操作。

按位与（&）：将两个整数的二进制对应位进行与操作，只有当两位都为 1 时，结果位才为 1。例如：

a = 5  # 二进制为 0b101 b = 3  # 二进制为 0b011 result = a & b print(result)  # 二进制为 0b001，输出 1

按位或（|）：将两个整数的二进制对应位进行或操作，只要有一位为 1，结果位就为 1。例如：

a = 5  # 二进制为 0b101 b = 3  # 二进制为 0b011 result = a | b print(result)  # 二进制为 0b111，输出 7

按位异或（^）：将两个整数的二进制对应位进行异或操作，当两位不同时，结果位为 1。例如：

a = 5  # 二进制为 0b101 b = 3  # 二进制为 0b011 result = a ^ b print(result)  # 二进制为 0b110，输出 6

按位取反（~）：对整数的二进制表示按位取反，即 0 变为 1，1 变为 0。例如：

a = 5  # 二进制为 0b101 result = ~a print(result)  # 二进制为 0b-110，输出 -6

左移（<<）：将整数的二进制表示向左移动指定的位数，右边用 0 填充。例如：

a = 5  # 二进制为 0b101 result = a << 2 print(result)  # 二进制为 0b10100，输出 20

右移（>>）：将整数的二进制表示向右移动指定的位数，左边用符号位填充（正数用 0，负数用 1）。例如：

a = 5  # 二进制为 0b101 result = a >> 1 print(result)  # 二进制为 0b010，输出 2

3.特殊运算：例如 divmod 函数，它同时返回整除结果和取余结果。

a = 17 b = 5 quotient, remainder = divmod(a, b) print(quotient</doubaocanvas> , remainder)  # 输出 3 2

- `abs()` 函数：返回整数的绝对值。例如： ```python num = -15 abs_num = abs(num) print(abs_num)  # 输出 15

pow() 函数：用于计算一个数的幂，与 ** 运算符类似，但可以接受三个参数，即 pow(base, exp, mod)，表示 (base** exp) % mod。例如：

result1 = pow(2, 3) print(result1)  # 输出 8 result2 = pow(2, 3, 5) print(result2)  # 输出 3（因为 8 % 5 = 3）

2.2 浮点型（float）

浮点型用于表示带有小数部分的数值，在 Python 中，浮点数可以用十进制形式或科学计数法表示。

1.十进制形式：直接书写带有小数点的数字。例如：

float1 = 3.14 float2 = -0.5 float3 = 100.0

2.科学计数法：当表示非常大或非常小的浮点数时，使用科学计数法会更方便，用 e 或 E 表示指数部分。例如：

# 表示 123000000.0 float_sci1 = 1.23e8 # 表示 0.000000456 float_sci2 = 4.56e-7

浮点数的运算与整数类似，也支持基本的算术运算（加、减、乘、除、整除、取余、幂运算等）。但由于浮点数在计算机中的存储方式，可能会存在精度问题。例如：

result = 0.1 + 0.2 print(result)  # 输出 0.30000000000000004，而不是 0.3

这是因为 0.1 和 0.2 在二进制中无法精确表示，导致相加后出现微小的误差。在需要高精度计算的场景，可以使用 decimal 模块。

from decimal import Decimal, getcontext # 设置精度 getcontext().prec = 10 a = Decimal('0.1') b = Decimal('0.2') result = a + b print(result)  # 输出 0.3

2.3 复数类型（complex）

复数由实部和虚部组成，在 Python 中，复数的虚部用 j 或 J 表示。例如：

# 实部为 3，虚部为 4 的复数 complex1 = 3 + 4j # 实部为 0，虚部为 -2 的复数 complex2 = 0 - 2j # 实部为 5.5，虚部为 1 的复数 complex3 = 5.5 + 1J

可以通过复数的 real 属性获取实部，通过 imag 属性获取虚部。

c = 3 + 4j print(c.real)  # 输出 3.0 print(c.imag)  # 输出 4.0

复数也支持一些基本的运算，如加法、减法、乘法、除法等。

c1 = 1 + 2j c2 = 3 + 4j # 加法 result_add = c1 + c2 print(result_add)  # 输出 (4+6j) # 减法 result_sub = c1 - c2 print(result_sub)  # 输出 (-2-2j) # 乘法 result_mul = c1 * c2 print(result_mul)  # 输出 (-5+10j) # 除法 result_div = c1 / c2 print(result_div)  # 输出 (0.44+0.08j)

2.4 布尔类型（bool）

布尔类型只有两个取值：True（真）和 False（假），分别对应整数 1 和 0。在 Python 中，布尔类型可以看作是整数的子类，因此可以参与整数的运算。

print(True + 1)  # 输出 2 print(False * 5)  # 输出 0

布尔类型常用于条件判断，例如 if 语句、while 语句等。

age = 18 is_adult = age >= 18 if is_adult:     print("已成年") else:     print("未成年")

在 Python 中，很多值可以被转换为布尔值。以下情况转换为 False：

• 布尔值 False
• 数字 0（包括整数 0、浮点数 0.0、复数 0j）
• 空字符串 ""
• 空列表 []、空元组 ()、空字典 {}、空集合 set()
• None

其他情况一般转换为 True。可以使用 bool() 函数来测试一个值的布尔值。

print(bool(0))  # 输出 False print(bool("hello"))  # 输出 True print(bool([]))  # 输出 False print(bool([1, 2, 3]))  # 输出 True

三、字符串与数字类型的转换

在实际编程中，经常需要在字符串和数字类型之间进行转换。

3.1 字符串转换为数字

1.转换为整数：使用 int() 函数。但需要注意，字符串必须表示一个有效的整数，否则会抛出 ValueError。

str_num1 = "123" num1 = int(str_num1) print(num1, type(num1))  # 输出 123 <class 'int'> # 下面的转换会报错，因为字符串不是有效的整数 # str_num2 = "123.45" # num2 = int(str_num2)

2.转换为浮点数：使用 float() 函数。字符串可以表示整数或浮点数。

str_num3 = "123.45" num3 = float(str_num3) print(num3, type(num3))  # 输出 123.45 <class 'float'> str_num4 = "678" num4 = float(str_num4) print(num4, type(num4))  # 输出 678.0 <class 'float'>

3.转换为复数：使用 complex() 函数，字符串需要符合复数的表示形式。

str_complex = "3+4j" complex_num = complex(str_complex) print(complex_num, type(complex_num))  # 输出 (3+4j) <class 'complex'>

3.2 数字转换为字符串

使用 str() 函数可以将数字类型转换为字符串。

num_int = 123 str_int = str(num_int) print(str_int, type(str_int))  # 输出 123 <class 'str'> num_float = 45.67 str_float = str(num_float) print(str_float, type(str_float))  # 输出 45.67 <class 'str'> num_complex = 2 + 3j str_complex = str(num_complex) print(str_complex, type(str_complex))  # 输出 (2+3j) <class 'str'>

四、总结

字符串和数字类型是 Python 中最基础且常用的变量类型。字符串用于处理文本数据，具有丰富的操作方法，如拼接、切片、格式化等；数字类型包括整数、浮点数、复数和布尔值，各自有其特点和适用场景，支持多种运算操作。掌握这些基础变量类型的使用，是进行 Python 编程的基础，能够为后续学习更复杂的数据结构和算法打下坚实的基础。在实际开发中，根据具体的需求选择合适的变量类型，并灵活运用它们的操作方法，可以提高编程效率和代码质量。