Python基础教程2/4（复合数据结构）

1. 字符串的使用

1.字符串运算符：简单操作字符串

1.1. 字符串拼接（+）

作用：像"粘胶带"一样，将两个火多个字符串合并成一个。

示例：

print("a"+"b")

str1 = "你好"
str2 = "小帅"
print(str1 + str2)

注意：只能字符串和字符串拼接，不能直接和数字拼接（比如 "年龄" + 18 会报错，需要转换成字符串）。

1.2. 字符串重复（ * ）

作用：知道字符串重复的次数，快速生成重复内容。

示例：

# *字符串重复
print("哈哈" * 3) #输出3个哈哈

print(1)
print("-" * 10) #生成分割线
print(2)

1.3. 成员运算符（in / not in）

作用：检查一个字符串（字串）是否包含在另一个字符串里，返回True或False

示例：

str = "Hello World"
print("h" in str)   #False
print("H" in str)   #True
print("Hello" not in str)   #False
print("Hi" not in str)  #True

2. 索引与切片：精准提取字符串内容

2.1. 索引（下标）：按位置取单个字符

|--------|----|----|----|----|----|----|----|
| 字符串 | a | b | c | d | e | f | g |
| 正序 | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
| 倒序 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |

作用：字符串里的每个字符都有固定的"位置编号"，通过编号能精准取出单个字符。

编号规则：

• 从左往右：从0开始（第一个字符是0，第二个是1，以此类推）；
• 从右往左：从-1开始（最好一个字符是-1，倒数第二个是-2，以此类推）。

#索引（下标）
str = "Hello World"
print("h" in str)   #False
print("H" in str)   #True
print("Hello" not in str)   #False
print("Hi" not in str)  #True

2.2. 切片：截取字符串的一部分

作用：像"剪刀"一样，从字符串中截取一段内容，返回新字符串。

语法如下：

str[start:stop:step]

参数详解：

• start（可选）：起始索引（包含，默认从0开始）。
• stop（可选）：结束索引（不包含，默认到字符串末尾）。
• step（可选）：步长（截取间隔，默认1，负数表示从右往左截）。

示例：

#切片：字符串[起始索引:结束索引:步长]
myString="hello world,hello xiaoshuai"
#虽然可以省略，但是至少要写一个:，不然以为你写的是索引
print(myString[:])  #全部输出 hello world,hello xiaoshuai
#指定起始索引
print(myString[2 :])    #llo world,hello xiaoshuai
#指定结束索引（包前不包后）
print(myString[:2])   #he
#指定步长
#正数：从左往右
print(myString[::5])    #h dlaa
#负数：从右往左
print(myString[::-8])   #ixdl

print(myString[2:10:2]) #lowr
print(myString[-2:-10:-2])  #ahoi

3. 转义字符：处理特殊格式的文字

3.1. 什么是转义字符？

转义字符以 \ 开头，用来表示不能直接输入的特殊符号（比如换行、制表符），相对于"文件的特殊指令"。

3.2. 常用转义符

|---------|------------------------|
| 转义字符 | 描述 |
| \t | 制表符（类似按Tab键，对齐文本） |
| \n | 换行符（另起一行） |
| \\ | 显示单个反斜杠（比如文件路径） |
| \'或\" | 显示单引号/双引号（避免和字符串界定符冲突） |

示例：

# 制表符 \t
print("    hello")
print("\thello")

# 换行 \n
print("第一行\n第二行")
print("第一行\n第二行", end="")

# 单个反斜杠
print("D:\tools\Python")  # D:  ools\Python，虽然只是warning，但是路径还是有问题的
print("D:\\tools\\Python")

# 引号
print("I don't like it")
print('I don\'t like it')  # 要转义，不能和界定符一样

3.3. 原始字符串（r""）：取消转义

作用：字符串前面加r，里面的\会被当做普通字符，不用手动转义（适合文件路径、正则表达）。

示例：

# 原始字符串 r
print("D:\\tools\\Python")  #普通字符串要处理反斜杠
print(r"D:\tools\Python")   #原始字符串直接写反斜杠

4. 格式化字符串：优雅拼接变量和文字

4.1. 作用

把变量、数字或运算结果嵌入到字符串中，让输出更整齐（不用反复用+拼接，避免出错）。

4.2. 实现方式

Python提供了多种方式来实现格式化输出，包括旧式的%格式化、str.format() 以及较新的 f-strings (Python3.6及以上版本，推荐使用)。

4.3. f-string

4.3.1. 基本使用

语法：字符串前加 f 或 F ，用 { } 包裹变量/表达式。

示例：

# 格式化字符串
name = "小明"
age = 10
# 输出我的姓名：小明，我的年龄：10岁。
print("我的姓名：", name, "，我的年龄：", age, "岁。")  # 可读性差
#在字符串前面加f/F，用{}括起来，将变量插入到字符串中
print(f"我的姓名：{name}，我的年龄：{age}岁。")  # format格式化

4.3.2. 支持表达式

{ } 里面可以直接写算术运算，函数调用等，Python会自带计算结果。

示例：

# 支持表达式
n1 = 3
n2 = 4
print(f"{n1} + {n2} = {n1 + n2}")
print(f"{n1}对应的类型：{type(n1)}")

4.3.3. 数字格式化

对于整数，可以设置其显示的最小宽度，并使用零或空格作为填充字符以达到这个宽度。

示例：

# 数字格式化
# 整数：可以设定最小宽度，并且补零
id = 3
print("你的学号:123")
print(f"我的学号:{id:3}")  # 设置最小宽度为3，如果id小于3，则前面补空格
print(f"我的学号:{id:03}")  # 设置最小宽度为3，如果id小于3，则前面补0

对于浮点数，可以通过指定小数点后的位数来保留精度。

示例：

# 小数：设置精度
pi = 3.1415926
print(f"圆周率（保留10位小数）:{pi:.10f}")  # 不够补零
print(f"圆周率（保留3位小数）:{pi:.2f}")  # 四舍五入

4.3.4. 对齐与填充

语法：{变量:填充符+对齐方式+宽度}

对齐方式：

• >：右对齐
• <：左对齐
• ^：居中对齐

示例：

# 对齐与填充
name = "xiaoming"
print(f"姓名：{name:20}")  # 默认左对齐，宽度20，不足后面补空格
print(f"姓名：{name:<20}")  # 左对齐，宽度20，不足后面补空格
print(f"姓名：{name:>20}")  # 右对齐，宽度20，不足前面补空格
print(f"姓名：{name:^20}")  # 居中对齐，宽度20，不足两边补空格

print(f"姓名：{name:-^20}")  # 居中对齐，宽度20，不足两边补-
print(f"姓名：{name:*>20}") # 右对齐，宽度20，不足前面补*

5. 字符串常用内建函数：高效处理文字

5.1. 查找类函数（找字符/统计次数）

|------------|--------------------|
| 函数 | 作用 |
| find(sub) | 找子串首次出现的位置，没找到返回-1 |
| index(sub) | 找子串首次出现的位置，没找到报错 |
| count(sub) | 统计字串出现的次数，没找到返回0 |

示例：

# 字符串常见内建函数
# 查找类（find/index/count）
name = "xiaoming"
print(name.find("m"))
print(name.index("mi"))
print(name.count("xx"))  # -1

print(name.index("x"))
print(name.index("xx"))  # ValueError: substring not found

print(name.count("i"))
print(name.count("xx"))

5.2. 修改类函数（改内容/分割/去空格）

|-------------------|-----------------|
| 函数 | 作用 |
| replace(old, new) | 替换子串（可指定替换次数） |
| split(sep) | 按分隔符分割字符串，返回列表 |
| strip(chars) | 去除首位指定字符（默认去空格） |
| lower() | 所有字母转小写 |
| upper() | 所有字母转大写 |

示例：

# 修改类（replace / split / strip / lower / upper）
name = "xiaoming"
print(name.replace("i", "a"))  # 替换所有
print(name.replace("i", "a", 1))  # 指定替换次数

str = "hello world\nhello xiaoming"
# 默认使用空白（空格、\n、\t）分割，遇到这些字符旧分割
print(str.split())  # ['hello', 'world', 'hello', 'xiaoming']
print(str.split("\n"))  # ['hello world', 'hello xiaoming']
print(str.split(" ", 1))  # 指定分割次数['hello', 'world\nhello xiaoming']

str = "   hello python   "
print(str.strip())  # 去除字符串两端的空白
str = "xxxxpythonxxxx"
print(str.strip("x"))

str = "Hell,Python"
print(str.lower())
print(str.upper())

5.3. 判断类函数（判断字符串属性）

|--------------------|--------------|
| 函数 | 作用 |
| startswith(prefix) | 判断是否以指定前缀开头 |
| endswith(suffix) | 判断是否以指定前缀结尾 |
| islower() | 判断所有字母是否都是小写 |
| isupper() | 判断所有字母是否都是大写 |

示例：

# 判断类（startswith / endswith / isupper / islower）
str = "hello python"
print(str.startswith("hello"))
print(str.startswith("ell"))
print(str.endswith("python"))
print(str.endswith("pytho"))
print(str.isupper())
print(str.islower())

5.4. 编码解码（处理字符串/字节）

• encode()：字符串转字节（比如网络传输、文件写入），默认UTF-8编码；
• decode()：字节转字符串（解码时编码要和解码时一致）。

示例：

str = "你好"
bytes_data = str.encode()  # 编码，默认utf-8
print(bytes_data)

str = b'\xe4\xbd\xa0\xe5\xa5\xbd'  # b开头表示字节数据
print(str.decode())

6. 核心总结

1. 字符串基础：用单/双/三引号界定，+ 拼接、* 重复、in 判断包含关系；
2. 索引切片：左数从 0 开始，右数从 -1 开始；切片 start:stop:stop ，包前不包后，步长负则反转；
3. 转义与原始字符串：\n 换行、\t 制表符；路径用 r"" 取消转义，避免多写反斜杠；
4. 格式化首选 f-string ：f"{变量}" 直接嵌入，支持运算、数字格式化和对齐，简洁高效；
5. 常用函数：查找用find / index / count、修改用 replace / split / strip、判断用startswith / endswith / islower / isupper，按需调用；
6. 关键提醒：字符串是"不可修改"的，函数操作后返回新字符串。

2. 列表及其常见操作

引言：在Python中，列表就像一个"万能储物筐"，能一次性装下多个不同类型的数据（比如数字、文字、甚至另一个列表），并且支持随时添加、修改、删除内容，是编程中最常用的数据结构之一。学会运用列表，能快速实现数据的批量管理与灵活调整，显著降低基础数据处理的难度，是入门Python必须掌握的核心技能。

1. 认识列表

1.1. 什么是列表

列表是有序的"数据集合"，用方括号 包裹，元素直接用都好隔开，能存储数、字符串、小数等任意类型数据。

1.2. 格式

变量名 = [元素1, 元素2, 元素3, 元素4, ...]

示例：

# 定义列表
li = ['a', 'b', 'c']

# 输出列表及其类型
print(li, type(li))

1.3. 列表的索引与切片（和字符串用法一致）

1.3.1. 索引：按位置取单个元素

规则：左数从 0 开始，右数从 -1 开始，通过"列表名编号"取值。

示例：

# 定义列表
li = ['a', 'b', 'c']

print(li[0])    #输出： a（左数第一个）
print(li[2])    #输出： c（左数第三个）
print(li[-1])   #输出： c（右数第一个）
print(li[5])    # IndexError: list index out of range

1.3.2. 切片：截取列表的一部分

语法：列表start:stop:step (默认从0开始， start 起始位置含、stop 结束位置不含、step 步长)。

示例：

li = [1, 2, 3, 4, 5]
print(li[0:2])
print(li[:2])
print(li[::3])
print(li[::-3])  # 步长负数，从右边开始
print(li[1:8:2])  # 超出范围不会出错

1.4. 列表的特性：可修改

和字符串不同，列表的元素能直接修改，通过 列表名索引 = 新值 实现。

示例：

li = ['a', 'b', 'c', 'd']
li[1] = '你好'
print(li)

2. 列表嵌套：列表里装列表

列表嵌套就是一个列表里包含其它列表，像"储物筐里嵌套小储物筐"，适合存储多维数据（比如表格、矩阵）。

示例：

grades = [[90, 80], [80, 70], [70, 60]]  # 表示3个同学的成绩，90,80表示第一个同学的90分80分
print(grades[0])  # grades的第一个元素（子列表）
print(grades[0][0])  # 子列表中的第一个元素
print(grades[0][1])  # 子列表中的第二个元素
print(grades[1][0])

访问逻辑：先通过外层索引找到嵌套的小列表，再通过内层索引取小列表的元素。

3. 列表常见内建函数

3.1. 添加元素

|---------------|-------------|
| 函数 | 作用 |
| append(元素) | 在列表末尾添加1个元素 |
| extend(可迭代对象) | 在末尾加多个元素 |
| insert(索引，元素) | 在指定位置插入1个元素 |

示例：

grades = [100, 90, 80, 70, 60]
grades.append(59)
print(grades)  # 在末尾追加元素
# grades.extend(90)#TypeError: 'int' object is not iterable 只能放可迭代对象
# 将可迭代对象拆分成一个个元素，并追加到列表中
grades.extend("123")  # [100, 90, 80, 70, 60, 59, '1', '2', '3']
grades.extend([90, 80])  # [100, 90, 80, 70, 60, 59, '1', '2', '3', 90, 80]
grades.insert(1, 33)
print(grades)

3.2. 查找元素

|-----------|-------------------|
| 函数 | 作用 |
| index(元素) | 找元素第一次出现的索引，没找到报错 |
| count(元素) | 统计元素出现的次数，没找到返回0 |

示例：

li = [1, 2, 3, 2, 5, 2, 5, 8, 9, 10]
print(li.index(2))
print(li.count(2))
print(li.count(20))

3.4. 排序与反转

|--------------------|--------------|
| 函数 | 作用 |
| sort() | 默认升序（从小到大）排序 |
| sort(reverse=True) | 降序（从大到小）排序 |
| reverse() | 反转列表顺序（倒过来） |

示例：

li = [3, 1, 4, 1, 5, 8, 2]

li.reverse()
li.sort()
li.sort(reverse=True)
print(li)

4. 核心总结

1. 列表本质：有序的"万能储物筐"，用 定义，元素间用逗号分隔，支持任意数据类型。
2. 核心操作：
   1. 访问：索引（取单个）、切片（取部分），规则和字符串一致；
   2. 修改：直接修改 列表索引 = 新值 修改元素；
   3. 嵌套：列表里装列表，通过"外层索引 + 内层索引"访问嵌套元素。

3.常用函数

• 添加：append( )（加1个）、extend( ) （加多个）、insert( ) （指定位置加）；
• 查找：index( ) （找索引）、count( ) （统计次数）；
• 删除：remover( ) （删除第一个匹配值）；
• 排序：sort( ) （升/降序）、reverse( ) （反转）。

4. 关键提醒：列表是"可修改"的，操作后直接改变原列表；函数操作时注意不存在的元素会报错（如index( )、remover( ) ）。