提示：python中的序列型组合数据类型：字符串、列表、元组三个
文章目录
前言
python中的序列型组合数据类型：字符串、列表、元组三个。它们都是有序的数据结构，元素按照特定的顺序排列，并且可以通过索引访问。
本章节仅对字符串进行介绍。
一、序列型组合数据类型的通用操作
序列的通用操作：由于字符串、列表和元组都是序列类型，它们支持一些通用的操作。
| 函数名 | 描述 | 实例 |
|---|---|---|
| seq[index] | 索引访问 | 从左往右索引从 0 开始；从右往左索引从 -1 开始； |
| seq2=seq1[start：end：step] | 切片操作 | 范围为左闭右开的区间 [start，end），step是步长，默认为 1且省略,返回切片后的结果 |
| len(seq) | 长度计算 | 获取序列中元素的数量 |
| element in seq 或 element not in seq | 成员检查 | 可以检查某个元素是否存在于序列中 |
| for循环遍历序列中的每个元素 | 迭代 | 使用 for 循环遍历序列中的每个元素 |
| s1+s2 | 连接 | 使用 + 操作符可以将两个序列连接在一起 |
| s1 * n 或 n * s1 | 重复 | 使用 * 操作符可以将序列重复指定次数 |
| min() 和 max() | 获取可比较元素的序列中的最小值和最大值 | 若是字符串则返回ASCII值中最小/最大的字符；数值则按照最小/最大的值 |
| count() | 计数 | 可以统计序列中某个元素出现的次数 |
| index() | 查找 | 可以找到某个元素在序列中的第一个索引位置 |
| enumerate() | 枚举 | 可以同时获取序列的索引和元素 |
s1 = "hello"
s2 = "world"
lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 6]
t1 = (7, 8, 9, 10)
t2 = (9, 10, 11, 12)
print(s1[1]) # 输出：e
print(lst1[2]) # 输出：3
print(t1[-1]) # 输出：10
print(s1[1:4]) # 输出：ell
print(lst1[1:4]) # 输出：[2, 3, 4]
print(t1[1:4:2]) # 输出：(8, 10)
print(s1[::-1]) # 输出：olleh（反转字符串、列表、元组均可）
print(lst1 [::2]) # 输出：[1, 3, 5]（每隔一个元素取一个）
print(len(s1)) # 输出：5
print(len(lst1)) # 输出：5
print(len(t1)) # 输出：4
print("e" in s1) # 输出：True
print(3 in lst1) # 输出：True
print(19 not in t1) # 输出：True
for char in s1:
print(char) # 逐个打印字符 h e l l o
for num in lst1:
print(num) # 逐个打印列表元素 1 2 3 4 5
for item in t1:
print(item) # 逐个打印元组元素 7 8 9 10
print(s1 + " " + s2) # 输出：hello world
print(lst1 + lst2) # 输出：[1, 2, 3, 4, 5, 4, 5, 6, 6]
print(t1 + t2) # 输出：(7, 8, 9, 10, 9, 10, 11, 12)
print(s1 * 3) # 输出：hellohellohello
print(lst1 * 2) # 输出：[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
print(t1 * 3) # 输出：(7, 8, 9, 10, 7, 8, 9, 10, 7, 8, 9, 10)
print(min(s1)) # 输出：e（按字母顺序返回ASCII值中最小的字符）
print(max(lst1)) # 输出：5
print(min(t1)) # 输出：7
s3 = "hello"
lst3 = [1, 2, 3, 2, 4]
t3 = (5, 6, 7, 6, 8)
print(s3.count("l")) # 输出：2
print(lst3.count(2)) # 输出：2
print(t3.count(6)) # 输出：2
print(s3.index("l")) # 输出：2
print(lst3.index(2)) # 输出：1
print(t3.index(6)) # 输出：1
for index, char in enumerate(s1):
print(f"Index: {index}, Char: {char}")
# Index: 0, Char: h
# Index: 1, Char: e
# Index: 2, Char: l
# Index: 3, Char: l
# Index: 4, Char: o
for index, num in enumerate(lst1):
print(f"Index: {index}, Num: {num}")
# Index: 0, Num: 1
# Index: 1, Num: 2
# Index: 2, Num: 3
# Index: 3, Num: 4
# Index: 4, Num: 5
二、字符串（str）定义及特点
定义：字符串是由字符组成的不可变序列。一旦创建，字符串的内容不能被修改。
特点：
• 不可变：不能直接修改字符串中的某个字符，例如 s[0] = ‘h’ 会报错，可以使用支持的方法进行变换。
• 支持索引和切片：可以通过索引访问单个字符，通过切片获取子字符串。例如 ：print(s[1]) 、print(s[1:4])
• 支持字符串方法：如 upper() 、 lower() 、 replace() 等
三、字符串（str）类型的使用
3. 1 字符串规则
- 字符串是由字符组成的序列。
- 字符串是不可变对象。所谓不可变，是指不能在原地修改对象的内容。
3. 2 字符串界定符
字符串界定符用来区分字符串和其他词法单位，有以下三种形式
- 单引号 ’
- 双引号 ” (是一个字符，不是两个单引号)
- 三引号’’’/ ”””(是三个字符，可以是3个单引号或者3个双引号)
- 单引号中可以使用双引号，双引号中也可以使用单引号，这样就可以不使用转义字符。
- 单引号中使用单引号，双引号中使用双引号，这样必须使用转义字符。
s='ddd"ss"fdfsd'
print(s) # 输出: ddd"ss"fdfsd
s="ddd'ss'fdfsd"
print(s) # 输出: ddd"ss"fdfsd
3. 3 转义符和原始字符串
- 转义符是一些特殊的字符。python 用反斜杆（\）来转义字符，以便表示那些特殊字符。
| 转义字符 | 说明 |
|---|---|
| \ | 在字符串行尾的续行符，即一行未完，转到下一行继续写。 |
| \\ | 反斜线 |
| \’ | 单引号 |
| \" | 双引号 |
| \a | 蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。 |
| \b | 退格（Backspace），将光标位置移到前一列。 |
| \f | 换页 |
| \n | 换行符，将光标位置移到下一行开头。 |
| \r | 回车符，将光标位置移到本行开头。 |
| \t | 水平制表符，也即 Tab 键，一般相当于四个空格。 |
| \v | 纵向制表符 |
s=';klklkk\
fsdfsfsfds'
print(s) # 输出: ;klklkkfsdfsfsfds
s='aassa\\dfsd\'fs\'e"we"wwr'
print(s) # 输出: aassa\dfsd'fs'e"we"wwr
print('a12345\r67\t890a\bssa\\dfsd\'fs\'e"we"w\nwr')
# 输出：672345 890ssa\dfsd'fs'e"we"w
# wr
- 原始字符串：使用原字符 r/R 使字符串的转义字符不起作用。
注意1：最后的字符不能是基数个的反斜杆（\），否则报错
注意2：若最后是0个或以上偶数个的反斜杆（\），是可以的
>>> print(r'a12345\r67\t890a\bssa\\dfsd\'fs\'e"we"w\nwr\\\\')
>>> a12345\r67\t890a\bssa\\dfsd\'fs\'e"we"w\nwr\\\\
>>> print(r'a12345\r67\t890a\bssa\\dfsd\'fs\'e"we"w\nwr\\\')
SyntaxError: EOL while scanning string literal
3. 4 内置的对字符串中字符的函数操作
1. 字符串大小写转换
| 序号 | 函数名 | 功能 | 用法 |
|---|---|---|---|
| 1 | str.upper() | 将字符串中的所有字符转换为大写 | |
| 2 | str.lower() | 将字符串中的所有字符转换为小写 | |
| 3 | str.swapcase() | 字符串中的大写字符转换为小写，小写字符转换为大写 | |
| 4 | str.capitalize() | 字符串的第一个字符转换为大写，其余字符转换为小写 | |
| 5 | str.title() | 字符串中每个单词的首字母转换为大写，其余字符转换为小写 |
s = "Hello, World!"
print(s.upper()) # 输出：HELLO, WORLD! 全部大写
print(s.lower()) # 输出：hello, world! 全部小写
print(s.swapcase()) # 输出：hELLO, wORLD! 将字符串中大写转为小写，小写转为大写
s = "hello, woRld!"
print(s.capitalize()) # 输出：Hello, world! 将字符串的第一个字符转换为大写，其余字符转换为小写
print(s.title()) # 输出：Hello, World! 将字符串中每个单词的首字母转换为大写，其余字符转换为小写
2. 字符串查找和替换
| 序号 | 函数名 | 功能 | 用法 |
|---|---|---|---|
| 1 | str.find(sub[, start[, end]]) | 返回子字符串sub在字符串中的起始索引值，如果未找到则返回 -1 | 区间为左闭右开[start，end)，end省略时则到末尾 |
| 2 | str.rfind(sub) | 返回子字符串sub在字符串中的最后索引值，如果未找到则返回 -1 | |
| 3 | str.index(sub[, start[, end]]) | 与 find() 相同，仅未找到子字符串时会报错抛出 ValueError | 建议使用find()，不会报错 |
| 4 | str.replace(old, new[, count]) | 将字符串中的 old 子字符串替换为 new 子字符串， count 指定替换的次数（可选） |
s = "Hello, World!"
print(s.find("World")) # 输出：7 是索引值，从0开始到末尾
print(s.find("Python")) # 输出：-1 表示没有找到
print(s.find("o",4,9)) # 输出：4 左闭，从4开始且返回第一个符合索引
print(s.find("o",5,9)) # 输出：8 从5开始，区间[5,9)
print(s.find("o",5,8)) # 输出：-1 不包括8
print(s.find("o",8)) # 输出：8 从8开始
print(s.find("o",9)) # 输出：-1
print(s.rfind("o")) # 输出：8 找到最后一个“o”在索引值8
print(s.index("World")) # 输出：7 是索引值，从0开始
print(s.index("o",4,9)) # 输出：4 左闭，从4开始且返回第一个符合索引
print(s.index("o",5,9)) # 输出：8 从5开始，到8结束
print(s.index("o",8)) # 输出：8 从8开始
print(s.index("Python")) # 会报错，并抛出 ValueError: substring not found
print(s.replace("World", "Python")) # 输出：Hello, Python!
print(s.replace("WorlD", "Python")) # 输出：Hello, World! 大小写敏感，不匹配，保持不变
print(s.replace("l", "v")) # 输出：Hevvo, Worvd! 全部改变
print(s.replace("l", "v", 1)) # 输出：Hevlo, World! 仅改变第一个
print(s.replace("l", "v", 2)) # 输出：Hevvo, World! 仅改变第一、二个
print(s.replace("l", "v", -1)) # 输出：Hevvo, Worvd! 全部改变
3. 字符串分割和连接
| 序号 | 函数名 | 功能 | 用法 |
|---|---|---|---|
| 1 | str.split(sep=None, maxsplit=-1) | 根据分隔符 sep 将字符串分割为多个子字符串，返回一个列表。 maxsplit 指定最大分割次数（可选） | s.split() 默认按空白字符分割 |
| 2 | str.rsplit(sep=None, maxsplit=-1) | 与 split() 类似，但分割方向是从右向左 | |
| 3 | “分隔符”.join(iterable) | 将可迭代对象（如列表、元组）中的元素连接成一个字符串，元素之间用指定的分隔符连接 |
s = "Hello,World! Welcome to Python."
print(s.split()) # 输出：['Hello,World!', 'Welcome', 'to', 'Python.'] 默认按空白字符分割
print(s.split(",")) # 输出： ['Hello', 'World! Welcome to Python.'] 按指定分隔符分割
print(s.split("e",2)) # 按指定分隔符"e"分割2次 ['H', 'llo,World! W', 'lcome to Python.']
print(s.rsplit("e",2)) # 按指定分隔符"e"分割2次 ['Hello,World! W', 'lcom', ' to Python.']
lst = ["Hello", "World", "Python"]
print("， ".join(lst)) # 输出：Hello， World， Python 一个字符串
4. 字符串格式化
| 序号 | 函数名 | 功能 | 用法 |
|---|---|---|---|
| 1 | str.format(nane1, nane2…) | 使用占位符 {} 和 .format() 方法进行字符串格式化 | .format(name1, name2) 与前面字符串有无空格均可以 |
| 2 | f-string（Python 3.6+） | 使用 f 前缀和大括号 {} 进行字符串格式化 | f与后面字符串不允许有空格 |
name = "Bob"
age = 25
print("My name is {} and I am {} years old." .format(name, age))
# 输出：My name is Bob and I am 25 years old.
print(f"My name is {name} and I am {age} years old.")
# 输出：My name is Bob and I am 25 years old.
5. 字符串检查
| 序号 | 函数名 | 功能 | 用法 |
|---|---|---|---|
| 1 | str.isdigit() | 检查字符串是否只包含数字 | |
| 2 | str.isalpha() | 检查字符串是否只包含字母 | |
| 3 | str.isalnum() | 检查字符串是否只包含字母和数字 | |
| 4 | str.isspace() | 检查字符串是否只包含空白字符 | |
| 5 | str.startswith(prefix[, start[, end]]) | 检查字符串是否以指定的前缀开头 | |
| 6 | str.endswith(suffix[, start[, end]]) | 检查字符串是否以指定的后缀结尾 |
s1 = "12345"
s2 = "123.45"
print(s1.isdigit()) # 输出：True 检查是否只含有数字
print(s2.isdigit()) # 输出：False 因为存在小数点
s = "Hello"
print(s.isalpha()) # 输出：True 检查是否只含有字母
s = "Hello10023"
print(s.isalnum()) # 输出：True 检查是否只含有字母和数字
s = " "
print(s.isspace()) # 输出：True 检查是否只含有空白字符
s = "Hello, World!"
print(s.startswith("Hel")) # 输出：True 检查字符串是否以"Hello"开始
print(s.endswith("rld!")) # 输出：True 检查字符串是否以"World!"结尾
6. 字符串对齐和填充
| 序号 | 函数名 | 功能 | 用法 |
|---|---|---|---|
| 1 | str.center(width[, fillchar]) | 将字符串居中对齐，并用指定字符（默认为空格）填充到指定宽度 | |
| 2 | str.ljust(width[, fillchar]) | 将字符串左对齐，并用指定字符填充到指定宽度 | |
| 3 | str.rjust(width[, fillchar]) | 将字符串右对齐，并用指定字符填充到指定宽度 | |
| 4 | str.zfill(width) | 将字符串左端用零填充到指定宽度 |
s = "Python"
print(s.center(9, '*')) # 输出：**Python* 将居中对齐
print(s.center(10, '*')) # 输出：**Python**
print(s.center(2, '*')) # 输出：Python 小于长度保留Python
print(s.ljust(10, '-')) # 输出：Python---- 将左对齐，并用指定字符填充到指定宽度
print(s.ljust(2, '-')) # 输出：Python 小于长度保留Python
print(s.rjust(10, '?')) # 输出：????Python 将右对齐，并用指定字符填充到指定宽度
print(s.rjust(3, '?')) # 输出：Python 小于长度保留Python
print(s.zfill(10)) # 输出：0000Python 将左端用零填充到指定宽度
7. 字符串去除空白
空白字符：如空格、制表符、换行符等
| 序号 | 函数名 | 功能 | 用法 |
|---|---|---|---|
| 1 | str.strip([chars]) | 移除字符串两端的空白字符或指定字符 | 对两边都处理 |
| 2 | str.lstrip([chars]) | 移除字符串左侧的空白字符或指定字符 | 仅对左侧处理 |
| 3 | str.rstrip([chars]) | 移除字符串右侧的空白字符或指定字符 | 仅对右侧处理 |
s = " Hello, World! "
print(s.strip()) # 输出："Hello, World!" 若不指定则默认仅去除两端的空白
s = " d!Hello, World! "
print(s.strip("d! ")) # 输出："Hello, Worl"
print(s.strip(" !d")) # 输出："Hello, Worl"
print(s.strip("H!d l")) # 输出："ello, Wor"
# 将指定字符串按照字符，一一进行比对去除，与顺序无关
print(s.strip("d!")) # 输出：" d!Hello, World! " 保持不变，因两端与指定不匹配
print(s.lstrip()) # 与print(s.strip())相比，仅去除左侧
print(s.rstrip()) # 与print(s.strip())相比，仅去除右侧
8. 字符串的子串出现次数
| 序号 | 函数名 | 功能 | 用法 |
|---|---|---|---|
| 1 | str.count(sub[, start[, end]]) | 返回子字符串 sub 在字符串中出现的次数 |
s = "Hello, World! woo "
print(s.count("o")) # 输出：4 默认从头到尾
print(s.count("o",4)) # 输出：4 从索引4开始匹配
print(s.count("o",5)) # 输出：3 从索引5开始匹配，索引4就不在范围；
print(s.count("o",5,17)) # 输出：3 从索引5开始匹配，左闭右开区间[5,17)；
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
