剑眉星目

深浅模式

整数、浮点、字符、布尔 ​

更新: 2025/2/24 字数: 0 字 时长: 0 分钟

数据类型是指在计算机中表示各种信息（如数字、文本、图像、音频等）的种类的抽象符号，它决定了数据的存储方式、取值范围以及可以进行的操作。数据类型是编程语言中非常重要的一个概念，它使得程序员能够明确地知道如何存储和操作数据。在 Python 语言中有多种数据类型，这里介绍 4 种基本数据类型：整数类型（int）、浮点类型（float）、字符串类型（str）、布尔类型（bool）。

整数类型（int） ​

整数类型：就是正整数、零、负整数的集合，用 int 来表示。

python
# 整数类型(int)：0、5、17、29、111
print(type(5))             # 输出：int。注释：type函数用于返回数值的数据类型。
print(isinstance(5, int))  # 输出：True。注释：isinstance函数用于判断数值的数据类型。

在除法（/）操作之外，整数类型之间进行的其他算术运算，结果仍然是整数类型。

python
print(2 + 2)   # 输出：4
print(2 - 2)   # 输出：0
print(2 * 2)   # 输出：4
print(2 % 2)   # 输出：0
print(2 / 2)   # 输出：1.0。注释：'/'除法返回的数据永远是浮点类型。
print(2 // 2)  # 输出：1。注释：'//'整除中只有整数除以整数结果才为整数。

浮点类型（float） ​

浮点类型：就是带小数点的数，用 float 来表示。

python
# 浮点类型(float)：0.5、3.14、10.52
print(type(10.52))               # 输出：float
print(isinstance(10.52, float))  # 输出：True

除了使用浮点数来表示小数外，还可以使用科学计数法（e 表示乘以 10 的某次方）来表示 。

python
# 科学计数法（e表示乘以10的某次方）
print(123e5)    # 输出：12300000.0。注释：123乘以10的5次方。
print(123e-5)   # 输出：0.00123。注释：123乘以10的-5次方。
print(12.3e-5)  # 输出：0.000123。注释：12.3乘以10的-5次方。

类型转换 ​

在 Python 中，当整数类型和浮点类型进行算术运算时，Python 的类型系统会进行隐式类型转换。由于浮点数可以表示更广泛的数值范围和精度，因此 Python 的类型系统会将整数类型自动转换为浮点类型，然后进行浮点类型之间的算术运算，结果自然也都是浮点类型。

python
print(2.0 + 2)   # 输出：4.0
print(2.0 - 2)   # 输出：0.0
print(2.0 * 2)   # 输出：4.0
print(2.0 % 2)   # 输出：0.0
print(2.0 / 2)   # 输出：1.0
print(2.0 // 2)  # 输出：1.0。注释：'//'整除中只要除数或被除数一方为浮点数结果都为浮点数。

精度误差 ​

在计算机中计算浮点数一定会遇到精度误差问题，其原因是计算机内部使用二进制数字信号来表示数字，而小数在二进制中的表示方式与十进制不同。例如，十进制中的 0.1 转到二进制中是一个值为的 0.00011001... 的无限循环小数，类似于十进制中的 1/3 = 0.333... 。由于计算机的存储空间有限，无法表示无限位数的二进制小数，只能用“有限位数的近似值”来表示，这导致有些十进制的小数在二进制中不能被精确表示，所以当进行浮点运算时，结果可能会带有微小的误差。

python
print(0.1 + 0.2)        # 输出：0.30000000000000004
print(0.1 + 0.2 + 0.3)  # 输出：0.6000000000000001
print(0.3 + 0.2 + 0.1)  # 输出：0.6

由于二进制计算机无法精确表示小数，所以在计算浮点数时会出现精度误差的问题，这个和编程语言无关，不管换哪一种编程语言都会出现这种情况。如果你不接受这种误差，就必须全部统一使用整数运算，方法也很简单就是先将所有的浮点数统一乘以 10 的 n 次方全部转化为整数后再进行计算，最后将结果除以 10 的 n 次方转化为浮点数再进行输出：

python
print((0.1 * 10 + 0.2 * 10) / 10)             # 输出：0.3
print((0.1 * 10 + 0.2 * 10 + 0.3 * 10) / 10)  # 输出：0.6
print((0.3 * 10 + 0.2 * 10 + 0.1 * 10) / 10)  # 输出：0.6

提醒

在涉及财务和货币的场合，浮点数的精度误差是不能接受的。因此在超市、银行等涉及金钱的结算系统中，通常采用“最小货币单位（如分、厘） + 整数运算”的方式处理货币。例如有一个金额 123.45 元，它会乘以 100 存储为 12345 分。在计算时，比如两个金额相加：12345 分 + 67890 分 = 80235 分。在输出时再除以 100，显示为 802.35 元。

字符串类型（str） ​

字符串类型：使用单引号、双引号、三引号包裹起来零个、单个或多个字符，用 str 来表示。

python
# 字符串类型(str)：'abc123'、"jn22dv838y@#$@#%$"、'''学习'''、"""读书"""
print(type('Hello World!'))             # 输出：str
print(isinstance('Hello World!', str))  # 输出：True

建议

值得说明的是，字符串所包含的字符个数就是字符串的长度，如果字符串中没有字符，则该字符串的长度为 0，一般称这样的字符串为空字符串。

在前面我们介绍 Python 的多行注释时，也是用三重引号包围的字符串被用作多行注释，但实际上在 Python 中没有多行注释的语法，而是使用多行字符串来模拟多行注释。虽然这些字符串是有效的 Python 代码，但它们通常没有被赋值给变量，因此被视为注释或文档字符串，不会对程序的执行产生任何影响。

python
"""
这是一个多行注释，
它实际上是一个多行字符串，
但由于它没有被赋值给任何变量，
所以被视为注释。
"""

重要

值得记住的是，字符串类型可以包含任意长度的任何符号，因此字符串类型的可表示范围比只包含数字的整数类型、只包含小数点和数字的浮点类型要大的多。

转义字符 ​

在字符串中，虽然所有字符都可以自由组合，但某些特定的字符组合后会表示另外的特殊含义，这样的字符被称作“转义字符”。它由反斜杠（\）开始，后面跟一个或几个字符。常见的 Python 转义字符包括 \n 表示换行符，\t 表示制表符，\b 表示退格，\r 表示回车，\f 表示换页，\' 表示 ' 单引号，\" 表示 " 双引号，\\ 表示 \ 反斜杠。

python
# 输出单\双引号或反斜杠
print('\'')   # 输出：'。注释：输出一个单引号。
print("\"")   # 输出："。注释：输出一个双引号。
print('\\')   # 输出：\。注释：输出一个反斜杠。

# 换行输出
print('床前明月光，\n疑是地上霜。')
'''
输出：
床前明月光，
疑是地上霜。
'''

# 回车输出
print("1\r2")  # 输出：2。注释：首先，字符"1"被打印。然后，遇到\r，光标回到行首。接着，字符"2"被打印，覆盖掉之前的"1"。最终，只会看到"2"。

警告

需要注意的是，转义字符虽然由多个字符组成，但它们代表的是一个特定的字符或控制序列，因此在计算字符串长度的时候，转义字符被视为一个字符，例如 \n 就是一个字符。

上面的案例中可以看到，转义字符是自动生效的，但在某些情况下，我们可能需要防止转义字符生效。例如，我在 C 盘中新建了一个名称为 net 的文件夹，那么该文件夹的路径就是 C:\net，这时 Python 字符串就会把路径中的 \n 自动转义为换行。现在我们就需要防止转义字符生效，具体做法也很简单，在字符串前面加小写 r 或大写 R，就可以防止转义字符生效，仅表示原始字符串。

python
print(r'床前明月光，\n疑是地上霜。')  # 输出：床前明月光，\n疑是地上霜。

提醒

需要说明一下的是，原始字符串常用于正则表达式或文件路径等场景。

字符操作 ​

字符拼接：通过 + 符号将多个字符串类型数据进行拼接。

  1. 这里 + 符号的含义不再是相加，而是拼接，而且只能是字符串类型数据与字符串类型数据相拼接，其他类型的数据均不能与字符串类型数据拼接。
python
print('5' + '3')           # 输出：53。注释：字符串类型之间相加就是拼接，不再是算术运算中相加的概念，而且没有-，/，%，//操作。
print('are you ok' + '?')  # 输出：are you ok ?。注释：字符串类型数据中的空格会原样输出。
print(2 + '3')             # 报错：整数类型和字符串类型不能相互拼接。
print(100.1 + '1024')      # 报错：浮点类型和字符串类型不能相互拼接。
  1. 如果需要拼接大量字符串，不建议使用 + 符号。具体来说，在 Python 中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能在原地修改它。因此在使用 + 符号拼接字符串的过程中，每次操作内存都会开辟一块新的空间，将原始字符串的内容复制出来和另一个字符数据拼接形成一个新的字符串对象放到新的空间中，这会导致内存中出现多个临时字符串对象，虽然 Python 解释器会对这些临时字符串对象进行垃圾回收，释放它们所占用的内存，但频繁创建临时字符串对象，内存也会频繁分配和复制开销。更好的方法是使用字符串的 join() 方法，因为它会先收集所有要拼接的字符串，然后一次性生成新字符串，避免了频繁创建新的字符串对象。
python
print('5' + '3' + '1')  # 输出：531。注释：Python解释器首先把字符5和3拼接，创建一个临时的字符串53对象，继续把字符串53和字符1拼接，再创建一个字符串531对象，再输出结果。中间的53字符串对象不会保留在内存中，也不会被引用，Python解释器会对这些临时字符串对象进行垃圾回收，释放它们所占用的内存。

重复输出：通过 * 符号可以将字符串指定倍数的重复输出。

python
print('a' * 6)    # 输出：aaaaaa
print('abc' * 2)  # 输出：abcabc

下标选择：字符串中的每个字符，都有对应的一个下标。第一个字符的下标等于 0，从 0 开始递增直到最后一个字符。最后一个字符的下标也可以等于 -1，反向从 -1 开始递减直到第一个字符。注意下标不能超界否则会报错。

python
print('abc'[0], 'abc'[1], 'abc'[2])     # 输出：a b c
print('abc'[3])                         # 报错：下标超界
print('abc'[-1], 'abc'[-2], 'abc'[-3])  # 输出：c b a
print('abc'[-4])                        # 报错：下标超界
print('ab\nc'[3])                       # 输出：c，注释：转移字符\n会占用一个字符长度。

切片操作：通过下标划定的范围对一个字符串进行切割。

  1. 切片操作的下标是前闭后开，后面下标的字符取不到。
python
print('abcd'[0:1])  # 输出：a
print('abcd'[0:2])  # 输出：ab
  1. 切片操作中没有下标，代表全部。
python
print('abcd'[1:])  # 输出：bcd
print('abcd'[:1])  # 输出：a
print('abcd'[:])   # 输出：abcd。注释：切片操作中没有下标，代表全部。
  1. 切片操作不存在索引越界的错误。
python
print('abcd'[2:5555])  # 输出：cd
  1. 通过两个下标（表示范围）和一个数字（表示步长，不能为 0）来截取字符串。
python
print('abcd'[::2])   # 输出：ac。注释：[::2]从下标0开始，隔两位取一个字符。
print('abcd'[1::2])  # 输出：bd。注释：[1::2]从下标1开始，隔两位取一个字符。
print('abcd'[::-1])  # 输出：dcba。注释：[::-1]从下标0开始，-代表反向取字符。
print('abcd'[::-2])  # 输出：db。注释：[::-2]从下标0开始，-代表反向，隔两位取一个字符。

禁止修改：字符串是不可变数据类型，因此不能直接修改字符串中的某个字符，任何试图修改的操作都会创建一个新的字符串对象。

python
str1 = 'abc'
str1[0] = 'A'          # 报错：字符串是不可变数据类型，禁止在原对象上进行修改操作。
str2 = 'A' + str1[1:]  # 注释：在原字符串上切片，生成了新的'bc'字符串对象，再与字符A拼接，生成了新的'Abc'字符串对象。
print(str2)            # 输出：Abc

比较大小：比较字符大小的实质是比较字符 ASCII 编码的数值大小。如果是比较字符串大小，则是从两边字符串开始依次往后比较每个字符的大小，直到遇到字符不一样为止。

python
# 字母A的编码值为65，字母a的编码值为97，字母b的编码值为98
print('a' < 'b')     # 输出：True
print('abc' > 'b')   # 输出：False
print('abc' > 'aa')  # 输出：True
print('Zbc' > 'aa')  # 输出：False

字符方法 ​

检测判断 ​

isalpha 方法：检测字符串中的字符是否全部由字母（包括非拉丁字母，如希腊字母、中文字符【汉字字符】等）组成，如果存在任何非字母字符（包括标点符号【包括中文的标点符号】、空格、数字【0 ~ 9】，还是特殊符号）会返回 False。

python
print("".isalpha())          # 输出：False。注释：空字符串，不包含任何字符，因此没有任何字母，结果为False。
print("ILoveYou".isalpha())  # 输出：True。注释：只包含大小写字母，结果为True。
print("l o v e".isalpha())   # 输出：False。注释：包含数字、空格或其他标点符号其中之一，结果为False。
print('小姐姐'.isalpha())     # 输出：True。注释：只包含中文字符（汉字），结果为True。
print('小姐姐520'.isalpha())  # 输出：False。注释：包含数字、空格或其他标点符号其中之一，结果为False。
print("ΑαΒβ".isalpha())      # 输出：True。注释：只包含大写字母和希腊字母，结果为True。
print("ΑαΒβ,".isalpha())     # 输出：False。注释：包含数字、空格或其他标点符号其中之一，结果为False。
print("ΑαΒβ，".isalpha())    # 输出：False。注释：包含数字、空格或其他标点符号（中文标点符号）其中之一，结果为False。

isalnum 方法：检测字符串中的字符是否全部由数字（0 ~ 9）或字母（包括非拉丁字母，如希腊字母、中文字符【汉字字符】等）组成，如果存在任何非数字和字母字符（包括空格、标点符号【包括中文的标点符号】等其他字符）会返回 False。

python
print("".isalnum())           # 输出：False。注释：注释：空字符串，不包含任何字符，因此没有任何字母、数字，结果为False。
print("ILoveYou".isalnum())   # 输出：True。注释：只包含大小写字母，结果为True。
print("l o v e".isalnum())    # 输出：False。注释：包含空格或其他标点符号其中之一，结果为False。
print("520".isalnum())        # 输出：True。注释：只包含数字，结果为True。
print("小姐姐".isalnum())      # 输出：True。注释：只包含中文字符（汉字），结果为True。
print("小姐姐520".isalnum())   # 输出：True。注释：只包含中文字符（汉字）和数字，结果为True。
print("小姐姐 520".isalnum())  # 输出：False。注释：包含空格或其他标点符号其中之一，结果为False。
print("小姐姐,520".isalnum())  # 输出：False。注释：包含空格或其他标点符号其中之一，结果为False。
print("ΑαΒβ123".isalnum())    # 输出：True。注释：只包含希腊字母和数字，结果为True。
print("ΑαΒβ，123".isalnum())  # 输出：False。注释：含空格或其他标点符号（中文标点符号）其中之一，结果为False。

isdigit 方法：检测字符串是否只由阿拉伯数字（0 ~ 9）组成。

python
print("12345678".isdigit())    # 输出：True
print("this2009".isdigit())    # 输出：False
print('一二三四五'.isdigit())    # 输出：False
print('零壹贰叁肆伍'.isdigit())  # 输出：False

isnumeric 方法：检测字符串是否只由阿拉伯数字（0 ~ 9）或其他数字字符（包括汉字数字【包括一、壹等】、罗马数字等）组成。

python
print("12345678".isnumeric())    # 输出：True
print("this2009".isnumeric())    # 输出：False
print('一二三四五'.isnumeric())    # 输出：True
print('零壹贰叁肆伍'.isnumeric())  # 输出：True

isupper 方法：检测字符串中所有的字母是否都为大写字母。

python
print('HELLO WORLD!'.isupper())  # 输出：True
print('Hello World!'.isupper())  # 输出：False

islower 方法：检测字符串中所有的字母是否都为小写字母。

python
print('hello world!'.islower())  # 输出：True
print('Hello world!'.islower())  # 输出：False

startswith 方法：检测该字符串指定范围是否是由某个字符或字符串开头。

endswith 方法：检测该字符串指定范围是否是由某个字符和字符串结尾。

python
"""
str1.startswith(str2, beg=0, end=len(str1))
str1.endswith(str2, beg=0, end=len(str1))
str1 -- 被检测的字符串。
str2 -- 查找的字符串。
beg -- 可选参数用于设置字符串检测的起始位置下标，默认等于0。
end -- 可选参数用于设置字符串检测的结束位置下标，默认等于str1长度。
"""
# startswith方法
print("this is".startswith('is'))                # 输出：False。注释：检测字符串是否以'is'开头。
print("this is".startswith('is', 2, 4))          # 输出：True。注释：检测字符串的[2,4)范围是否以'is'开头。
print("this is".startswith(('is', 'th')))        # 输出：True。注释：检测字符串是否以'is'或'th'开头。
print("this is".startswith(('is', 'th'), 2, 4))  # 输出：True。注释：检测字符串的[2,4)范围是否以'is'或'th'开头。
# endswith方法
print("this is".endswith('is'))                  # 输出：True。注释：检测字符串是否以'is'结尾。
print("this is".endswith('is', 2, 4))            # 输出：True。注释：检测字符串的[2,4)范围是否以'is'结尾。
print("this is".endswith(('is', 'th')))          # 输出：True。注释：检测字符串是否以'is'或'th'结尾。
print("this is".endswith(('is', 'th'), 2, 4))    # 输出：True。注释：检测字符串的[2,4)范围是否以'is'或'th'开头。

建议

需要说明一点，空字符串在理论上可以被认为存在于任何字符串的开头、结尾以及中间位置。因此在 Python 中，使用 startswith('') 或 endswith('') 永远会返回 True，这是由字符串包含关系的定义决定的。

替换字符 ​

upper 方法：将字符串所有字母转为大写。

python
print('abc'.upper())  # 输出：ABC

lower 方法：将字符串所有字母转为小写。

python
print('ABC'.lower())  # 输出：abc

capitalize 方法：将字符串首字母转为大写。

python
print('abc'.capitalize())  # 输出：Abc

title 方法：词组首字母大写。

python
print('abc.def.ghi'.title())  # 输出：Abc.Def.Ghi

replace 方法：将字符串中的字符串替换指定字符串，可指定替换次数，默认全部替换。

python
print('abcabc'.replace('a', 'd'))         # 输出：dbcdbc
print('abcabc'.replace('abc', 'cba'))     # 输出：cbacba
print('abcabc'.replace('abc', 'cba', 1))  # 输出：cbaabc。注释：最后的参数1，代表只替换1次。

查找子串 ​

index 方法：从左往右查找字符值首次在字符串中出现的位置下标，若找不到会报错。

rindex 方法：和 index 方法一样，只不过它是从右往左查找，若找不到会报错。

python
"""
str1.index/rindex(str2, beg=0, end=len(str1))
str1 -- 被找的字符串。
str2 -- 查找的字符串。
beg -- 可选参数用于设置字符串检测的起始位置下标，默认等于0。
end -- 可选参数用于设置字符串检测的结束位置下标，默认等于str1长度。
"""
# index方法
print('abcabc'.index('bc'))         # 输出：1。注释：在字符串中'bc'首次出现的位置下标为1。
print('abcabc'.index('bc', 2, 8))   # 输出：4。注释：在字符串[2:8)范围内'bc'首次出现的位置下标为4（开始下标和结束下标都可越界）。
print('abcabc'.index('ef'))         # 报错：未找到指定字符。
# rindex方法
print('abcabc'.rindex('bc'))        # 输出：4。注释：在字符串中'bc'首次出现的位置下标为4。
print('abcabc'.rindex('bc', 2, 8))  # 输出：4。注释：在字符串[2:8)范围内'bc'首次出现的位置下标为4（开始下标和结束下标都可越界）。
print('abcabc'.rindex('ef'))        # 报错：未找到指定字符。

建议

需要说明一点，空字符串在理论上可以被认为存在于任何字符串的开头、结尾以及中间位置。因此在 Python 中，使用 index('') 永远会返回 0，使用 rindex('') 永远会返回 字符串本身的长度。

find 方法：和 index 方法类似，唯一的区别就是，若找不到会返回 -1。

rfind 方法：和 rindex 方法类似，唯一的区别就是，若找不到会返回 -1。

python
"""
str1.find/rfind(str2, beg=0, end=len(str1))
str1 -- 被找的字符串。
str2 -- 查找的字符串。
beg -- 可选参数用于设置字符串检测的起始位置下标，默认等于0。
end -- 可选参数用于设置字符串检测的结束位置下标，默认等于str1长度。
"""
# find方法
print('abcabc'.find('bc'))         # 输出：1。注释：在字符串中'bc'首次出现的位置下标为1。
print('abcabc'.find('bc', 2, 8))   # 输出：4。注释：在字符串[2:8)范围内'bc'首次出现的位置下标为4（开始下标和结束下标都可越界）。
print('abcabc'.find('ef'))         # 输出：-1。注释：在字符串中未找到'ef'。
# rfind方法
print('abcabc'.rfind('bc'))        # 输出：4。注释：在字符串中'bc'首次出现的位置下标为4。
print('abcabc'.rfind('bc', 2, 8))  # 输出：4。注释：在字符串[2:8)范围内'bc'首次出现的位置下标为4（开始下标和结束下标都可越界）。
print('abcabc'.rfind('ef'))        # 输出：-1。注释：在字符串中未找到'ef'。

建议

需要说明一点，空字符串在理论上可以被认为存在于任何字符串的开头、结尾以及中间位置。因此在 Python 中，使用 find('') 永远会返回 0，使用 rfind('') 永远会返回 字符串本身的长度。

count 方法：查找指定字符串的出现次数。

python
print("5201314".count('6'))     # 输出：0。注释：在字符串中'6'出现了1次。
print("5201314".count('1'))     # 输出：2。注释：在字符串中'1'出现了2次。
print("5201314".count('1314'))  # 输出：1。注释：在字符串中'1314'出现了1次。
print("5201314".count(''))      # 输出：8。注释：计算空字符串在目标字符串中出现的次数，它在目标字符串中的每个字符之间和字符串的两端都出现了一次，所以总共出现了8次。

建议

需要说明一点，空字符串在理论上可以被认为存在于任何字符串的开头、结尾以及中间位置。因此在 Python 中，使用 count('') 永远会返回 字符串本身的长度+1。

连接切割 ​

join 方法：在可迭代对象（字符串、列表、集合、元组等）中的每个元素（限定字符串）之间插入指定的字符串，最终连接生成一个新的字符串。

python
# 字符串
print('-'.join('123'))              # 输出：1-2-3
print('*'.join('123'))              # 输出：1*2*3
print('+'.join('123'))              # 输出：1+2+3

# 列表
print(''.join(['1', 2, '3']))       # 报错：每个元素必须为字符型。
print(''.join(['1', '2', '3']))     # 输出：123
print('|||'.join(['1', '2', '3']))  # 输出：1|||2|||3

# 集合
print(''.join({'1', 2, '3'}))       # 报错：每个元素必须为字符型。
print(''.join({'1', '2', '3'}))     # 输出：123
print('|||'.join({'1', '2', '3'}))  # 输出：1|||2|||3

# 元组
print(''.join(('1', 2, '3')))       # 报错：每个元素必须为字符型。
print(''.join(('1', '2', '3')))     # 输出：123
print('|||'.join(('1', '2', '3')))  # 输出：1|||2|||3

split 方法：以括号里面的字符或字符串为切割点，将前面字符串进行切割，返回列表。当不指定分隔符时，默认使用空白字符（包括空格、制表符、换行符等）进行切割。

python
print('ahsj2ksjajsj'.split('sj'))              # 输出：['ah', '2k', 'aj', '']
print('ahsj2ksjajsj'.split('sj')[0])           # 输出：ah
print('ahsj27jksjajsj'.split('sj')[-2])        # 输出：aj
print('ahsj2ksjajsj'.split('sj', maxsplit=1))  # 输出：['ah', '2ksjajsj']。注释：maxsplit=1最大拆分1次。
print('ahsj2ksjajsj'.split(''))                # 报错：切割点不能是空字符串。

格式处理 ​

ljust 方法：字符串左对齐，即在字符串右侧填充指定字符至指定长度。

center 方法：字符串居中对齐，即在字符串两侧填充指定字符至指定长度。

rjust 方法：字符串右对齐，即在字符串左侧填充指定字符至指定长度。

python
# ljust方法
print('abc'.ljust(5, '*'))   # 输出：abc**。注释：在字符串右侧填充*号至长度5。
print('abc'.ljust(4, '*'))   # 输出：abc*。注释：在字符串右侧填充*号至长度4。
print('abc'.ljust(2, '*'))   # 输出：abc。注释：字符串长度大于左对齐空间，因此不会有*生成。
# center方法
print('abc'.center(5, '*'))  # 输出：*abc*。注释：在字符串两侧填充*号至长度5。
print('abc'.center(4, '*'))  # 输出：abc*。注释：在字符串两侧填充*号至长度4。
print('abc'.center(2, '*'))  # 输出：abc。注释：字符串长度大于居中对齐空间，因此不会有*生成。
# rjust方法
print('abc'.rjust(5, '*'))   # 输出：**abc。注释：在字符串左侧填充*号至长度5。
print('abc'.rjust(4, '*'))   # 输出：*abc。注释：在字符串左侧填充*号至长度4。
print('abc'.rjust(2, '*'))   # 输出：abc。注释：字符串长度大于右对齐空间，因此不会有*生成。

zfill 方法：在字符串左侧零填充。

python
print('abc'.zfill(5))  # 输出：00abc

strip 方法：修剪掉原字符串左右两端的指定字符，默认为空白字符（包括空格、制表符、换行符等）。除此之外，还有 lstrip 和 rstrip 两个版本，分别为剪掉左边或者右边的指定字符。

python
print('  [email protected]  \t\r\n'.strip())   # 输出：[email protected]
print('  [email protected]  \t\r\n'.rstrip())  # 输出：   [email protected]
print('  [email protected]  \t\r\n'.lstrip())  # 输出：[email protected]
print('[email protected]'.strip('.com'))   # 输出：123@126
print('[email protected]'.rstrip('.com'))  # 输出：.com123@126
print('[email protected]'.lstrip('.com'))  # 输出：[email protected]

占位符：通过 % 和字母的组合来表示一个数值的占位符。

python
# %s ---> 字符串占位符
print('我的名字叫%s' % '小明')     # 输出：我的名字叫小明
# %d ---> 整数占位符
print('我的年龄是%d岁' % 18)       # 输出：我的年龄是18岁
# %f ---> 浮点数占位符（通常显示小数点后6位）
print('我的钱包有%f元' % 12.50)    # 输出：我的钱包有12.500000元
# %.nf ---> 使用n值限制小数点后面的小数的位数
print('我的钱包有%.1f元' % 12.50)  # 输出：我的钱包有12.5元

警告

需要注意的是，字符串中的占位符和赋值数据的类型要一致，否则会报错。

format 方法 ​

从 Python 2.6 版本开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能，可以接受不限个数、位置不按顺序的参数，其基本语法：通过 {} 和 : 来代替以前的 %。

python
# 不设置指定位置，按默认顺序
print("{} {}".format("hello", "world"))                 # 输出：hello world
# 设置指定位置
print("{1} {0} {1}".format("hello", "world"))           # 输出：world hello world
# 通过变量设置参数
print("{name}{url}".format(name="hello", url="world"))  # 输出：hello world

f 方法 ​

从 Python 3.6 起有一个新特性，通过在 f'{}' 中的 {} 添加变量名来表示变量，使用过程中只要确保在 {} 中没有其他的 {} 即可，不用考虑类型转换的问题。

python
age = 18
name = '我'
# 占位符方法
print('%s今年%d岁' % (name, age))       # 输出：我今年18岁
# 类型转换法
print(name + '今年' + str(age) + '岁')  # 输出：我今年18岁
# format函数
print('{}今年{}岁'.format(name, age))   # 输出：我今年18岁
# f方法
print(f'{name}今年{age}岁')             # 输出：我今年18岁

下面展示了 f 方法格式化的多种方法：

python
# 长度填充
print(f'{1234:3}')      # 输出：1234。注释：数据超过长度，直接输出数据。
print(f'{1234:6}')      # 输出：  1234。注释：左边填充空格, 宽度为6。
print(f'{1234:0>6}')    # 输出：001234。注释：左边填充0, 宽度为6。
print(f'{1234:A<6}')    # 输出：1234AA。注释：右边填充A, 宽度为6。
print(f'{1234:S^6}')    # 输出：S1234S。注释：左右填充S, 宽度为6。

# 记数法
print(f'{1234:,}')      # 输出：1,234。注释：转换为千分位数字形式。
print(f'{1234:%}')      # 输出：123400.000000%。注释：转换为百分比格式。
print(f'{1234:.0%}')    # 输出：123400%。注释：保留0位小数的百分比格式。
print(f'{1234:e}')      # 输出：1.234000e+03。注释：转换为科学记数法。
print(f'{1234:.3e}')    # 输出：1.234e+03。注释：保留三位小数的科学记数法。
print(f'{1234:f}')      # 输出：1234.000000。注释：转换为小数形式。
print(f'{1234:.2f}')    # 输出：1234.00。注释：保留两位小数的小数形式。
print(f'{1234:+.2f}')   # 输出：+1234.00。注释：带符号保留两位小数的小数形式。
print(f'{-1234:+.2f}')  # 输出：-1234.00。注释：带符号保留两位小数的小数形式。

# 进制转换
print(f'{1234:b}')      # 输出：10011010010。注释：转换为二进制数。
print(f'{1234:o}')      # 输出：2322。注释：转换为八进制数。
print(f'{1234:x}')      # 输出：4d2。注释：转换为十六进制数（因为是小写x，返回a-f小写字母）。
print(f'{1234:04X}')    # 输出：04D2。注释：转换为四位的十六进制数，不足四位的用零填充（因为是大写X，返回A-F大写字母）。

布尔类型（bool） ​

布尔类型：只有 True（代表条件成立）和 False（代表条件不成立）这两个值，用 bool 表示。

python
# 布尔类型(bool)：True、False
print(type(True))               # 输出：bool
print(isinstance(True, bool))   # 输出：True
print(type(False))              # 输出：bool
print(isinstance(False, bool))  # 输出：True

print(5 <= 10)                  # 输出：True。注释：条件5<=10成立。
print(4 >= 8)                   # 输出：False。注释：条件4>=8不成立。

重要

需要记住的是，无论是 True 还是 False，它们的首字母都必须大写。

逻辑运算 ​

前面学习逻辑运算符提到，逻辑运算符用于组合多个条件语句，并根据这些条件语句的布尔值进行逻辑推理，因此布尔类型数据可以直接参与到逻辑运算中。举例如下：

  • 与（and）：多个布尔值中，只要有一个布尔值是 False，其结果就是布尔值 False。
python
print(True and True)    # 输出：True
print(True and False)   # 输出：False
print(False and False)  # 输出：False
  • 或（or）：多个布尔值中，只要有一个布尔值是 True，其结果就是布尔值 True。
python
print(True or True)    # 输出：True
print(True or False)   # 输出：True
print(False or False)  # 输出：False
  • 非（not）：布尔值是 False，那么结果就是布尔值 True；布尔值是 True，那么结果就是布尔值 False。
python
print(not True)   # 输出：False
print(not False)  # 输出：True

另外再说一点，整数类型数值 0 的布尔值是 False，其他整数类型数值的布尔值都是 True，还是以逻辑运算符举例如下：

  • 值1 and 值2：当 值1 的布尔值为 False 时，返回 值1；当 值1 的布尔值为 True 时，返回 值2。
python
print(0 and False)  # 输出：0
print(0 and True)   # 输出：0
print(0 and 1)      # 输出：0
print(1 and False)  # 输出：False
print(1 and True)   # 输出：True
print(1 and 0)      # 输出：0
  • 值1 or 值2：当 值1 的布尔值为 True 时，返回 值1；当 值1 的布尔值为 False 时，返回 值2。
python
print(0 or False)  # 输出：False
print(0 or True)   # 输出：True
print(0 or 1)      # 输出：1
print(1 or False)  # 输出：1
print(1 or True)   # 输出：1
print(1 or 1)      # 输出：1
  • 值1 and/or 值2 and/or 值3：多个逻辑运算符就从左往右依次看。
python
print(0 or 1 or 2)    # 输出：1
print(0 or 1 and 2)   # 输出：2
print(0 and 1 or 2)   # 输出：2
print(0 and 1 and 2)  # 输出：0
  • not 值1：多个逻辑运算符就从左往右依次看。
python
print(not 0)  # 输出：True
print(not 1)  # 输出：False
print(not 2)  # 输出：False
print(not 3)  # 输出：False

算术运算 ​

布尔类型数据可以直接参与到整数类型、浮点类型、布尔类型的算术运算中，当 True 参与算术运算时等于整数类型数值 1，当 False 参与算术运算时等于整数类型数值 0。

python
print(True + 1)       # 输出：2
print(True + 1.0)     # 输出：2.0
print(True + True)    # 输出：2
print(True + False)   # 输出：1
print(False - 1)      # 输出：-1
print(False - 1 < 0)  # 输出：True
print('1024' + True)  # 报错：字符串类型数据不能直接参与到算术运算中。