建议先阅读我之前的博客，掌握一定的Python前置知识后再阅读本文，链接如下：
带你从入门到精通——Python（一. 基础知识）-CSDN博客
带你从入门到精通——Python（二. 判断语句和循环语句）-CSDN博客
带你从入门到精通——Python（三. 函数基础）-CSDN博客
带你从入门到精通——Python（四. 五大容器一）-CSDN博客
目录
五. 五大容器二
5.1 字符串
5.1.1 字符串的定义
字符串是一种有序的存储字符的容器，一个字符串可以存放任意数量的字符，且字符可以重复，其具体定义格式如下：
# 定义空字符串
s1 = ''
s2 = ""
s3 = ''''''
s4 = """"""
s5 = str()
# 定义非空字符串
s6 = 'abcd'
s7 = "abcd"
s8 = '''ab
cd'''
s9 = """ab
cd"""注意：使用三引号定义的字符串如果不使用变量接收则表示注释，如果使用变量接收则表示字符串，且字符串的其中的内容可以换行。
注意：引号可以嵌套包裹，格式如下：
# 如果要嵌套单引号，外层引号必须使用双引号或者单三引号或者双三引号
s1 = "十分感谢'点赞'、'收藏'和'关注'"
# 输出: 十分感谢'点赞'、'收藏'和'关注'
# 如果要嵌套双引号，外层引号必须使用单引号或者单三引号或者双三引号
s2 = '十分感谢"点赞"、"收藏"和"关注"'
# 输出: 十分感谢"点赞"、"收藏"和"关注"
# 如果要嵌套单三引号，外层引号必须使用双引号或者双三引号
s3 = "十分感谢点赞、'''收藏'''和关注"
# 输出: 十分感谢点赞、'''收藏'''和关注
# 如果要嵌套双三引号，外层引号必须使用单引号或者单三引号
s4 = '十分感谢点赞、"""收藏"""和关注'
# 输出: 十分感谢点赞、"""收藏"""和关注5.1.2 字符串的查询和删除
字符串与列表和元组一样，支持下标索引操作，可以使用索引取出相应位置的单个字符，字符串也支持两套索引，正索引即从左到右，从0开始依次递增，负索引即从右到左，从-1开始依次递减，此外，字符串还和元组一样是一个不可修改的数据类型，因此字符串只有查询和删除操作，而没有添加和修改操作。
对于字符串来说查询主要有以下方法：
字符串名[索引]：查询指定索引位置处的元素。
字符串名.count(元素)：查询指定元素在字符串中出现的次数，注意：如果元素不存在则返回0。
字符串名.index(元素)：查询指定元素在字符串中出现的索引位置，注意:如果元素不存在会报错，如果有重复元素，则默认返回最靠左的第一个元素的索引位置。
len(字符串名)：查询指定字符串的元素总个数。
s = "aabbbcccc"
print(s[2])
# 输出'b'
print(s.count('a'))
# 输出2
print(s.index('c'))
# 输出5
print(len(s))
# 输出9对于字符串来说删除主要有以下方法：
del 字符串名：删除整个字符串。
5.1.3 字符串的特有操作
对于字符串来说常见的特有操作主要有：
replace(旧子字符串，新子字符串，cnt)：把指定旧子字符串替换为新子字符串，cnt参数表示替换次数，如果不传入则默认替换所有。
s = 'aaaaabbbb'
s = s.replace('b', 'c')
print(s)
# 输出'aaaaacccc'strip(ch)：去除字符串两端的ch字符，如果不传入ch参数，则默认去除两端的空白。
s = ' aaaaabbbb '
s = s.strip()
print(s)
# 输出'aaaaabbbb'lstrip(ch)：去除字符串左端的ch字符，如果不传入ch参数，则默认去除左端的空白。
s = ' aaaaabbbb a'
s = s.lstrip()
print(s)
# 输出'aaaaabbbb a'rstrip(ch)：去除字符串右端的ch字符，如果不传入ch参数，则默认去除右端的空白。
s = 'aaaaabbbba '
s = s.rstrip()
print(s)
# 输出'aaaaabbbba'split(ch，cnt)：表示根据指定分隔符ch切割字符串，并以列表的格式返回，如果不传入ch参数，则默认将原字符串放到列表中，cnt参数表示切割次数，如果不传入则默认切割所有。
ch.join(存储了字符串的容器)：用指定分隔符ch把容器中的字符串拼接一个大字符串。
s = '1.2.3'
s = s.split('.')
print(s)
# 输出['1', '2', '3']
s = '-'.join(s)
print(s)
# 输出1-2-3startswith(字符串)：判断是否以指定字符串开头。
endswith(字符串)：判断是否以指定字符串结尾。
s = 'aaaa111bbbb'
print(s.startswith('a'))
# 输出True
print(s.endswith('1'))
# 输出Falseencode(编码格式)：将字符串按指定编码格式编码为二进制数据，常见的编码格式有：GBK、UTF-8等。
decode(编码格式)：将二进制数据按指定编码格式解码为字符串。
s = '点赞'
s = s.encode('UTF-8')
print(s)
# 输出b'\xe7\x82\xb9\xe8\xb5\x9e'
s = s.decode('UTF-8')
print(s)
# 输出'点赞'upper()：把所有字母都转为大写。
lower()：把所有字母都转为小写。
s = 'aBcD'
s = s.upper()
print(s)
# 输出'ABCD'
s = s.lower()
print(s)
# 输出'abcdfind(元素)：查找指定元素在字符串中第一次出现的索引位置，如果不存在就返回-1。
rfind(元素)：查找指定元素在字符串中最后一次出现的索引位置，如果不存在就返回-1。
s = 'aaaa'
print(s.find('a'))
# 输出0
print(s.rfind('a'))
# 输出3isdigit()：判断字符串内容是否全为数字。
isalpha()：判断字符串内容是否全为字母或者汉字。
isalnum()：判断字符串内容是否全为字母、汉字或数字。
s = 'aaaa'
print(s.isdigit())
# 输出False
s = 'aaaa'
print(s.isalpha())
# 输出True
s = 'aaaa111点赞'
print(s.isalnum())
# 输出True5.1.4 字符串的遍历
与列表和元组相同，字符串也支持while循环和for循环两种遍历方式，具体格式和示例如下：
# while循环格式
index = 0
while index < len(字符串名):
元素变量 = 字符串名[index]
循环体
index += 1
# while循环示例
s = 'abcd'
index = 0
while index < len(s):
ch = s[index]
print(ch)
index += 1
# for循环格式
for 元素变量 in 字符串名:
循环体
# for循环示例
s = 'abcd'
for ch in s:
print(ch)5.2 序列
5.2.1 序列的切片
序列是指内容连续、有序，可使用下标索引的一类数据容器，列表、元组、字符串，均可以可以视为序列。
序列均支持切片，它是指从一个序列中，取出一个子序列的操作。
切片具体语法格式为：序列[起始下标:结束下标:步长]，表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列。
起始下标表示从何处开始，可以留空，留空视作从头开始。
结束下标表示何处结束，可以留空，留空视作截取到结尾，注意这里的结束下标是取不到的，例如如果结束下标为5，则切片操作取到序列下标为4的元素即停止切片。
步长表示，依次取元素的间隔，步长1表示，一个个取元素；步长2表示，每次跳过1个元素取 步长N表示，每次跳过N-1个元素取；步长为负数表示反向取元素即从右到左取（注意，起始下标和结束下标也要反向即开始下标要大于结束下标）
注意，切片操作不会影响序列本身，而是会得到一个新的序列。
lst = [1,2,3,4,5,6,7]
print(lst[:3])
# 输出[1, 2, 3]
print(lst[1:3])
# 输出[2, 3]
print(lst[2::2])
# 输出[3, 5, 7]
print(lst[1:5:2])
# 输出[2, 4]
print(lst[::-1])
# 输出[7, 6, 5, 4, 3, 2, 1]
print(lst[4:1:-1])
# 输出[5, 4, 3]5.2.2 序列的运算
序列支持如下两种数学运算操作：
+: 序列+序列，会将两个序列内容拼接并返回一个新序列。
*：序列*x，会将序列的内容复制x份并放到一个新的序列中返回。
s = 'abcde'
print(s + s)
# 输出'abcdeabcde'
print(s * 3)
# 输出'abcdeabcdeabcde'5.3 集合
5.3.1 集合的定义
集合可以容纳多个元素，它是一种不支持重复元素即自带去重功能且内容无序的可变类型容器，其具体定义格式如下：
# 定义空集合
s1 = set()
# 定义非空集合(元素无序不重复)
# 注意: 集合会自动去重!!!
s2 = {10, 20, 10, 10, 20, 30, 40, 10, 50}
print(s2)
# 输出{40, 10, 50, 20, 30}
# 集合嵌套
# 注意: 集合中元素只能是不可变类型!!!
s3 = {10, 3.14, True, '点赞', (1, 2, 3), (1, 2, 3)}
print(s3)
# 输出{True, 3.14, 10, (1, 2, 3), '点赞'}5.3.2 集合的增删改查
对于集合来说增加元素主要有以下方法：
集合名.add(元素)：把指定元素添加到对应集合中。
st = {1,2,3,4}
st.add(5)
print(st)
# 输出{1, 2, 3, 4, 5}对于集合来说删除主要有以下方法：
集合名.pop()：随机删除一个元素
集合名.remove(元素)：把指定元素直接从集合中删除，注意:一次只会删除一个元素。
集合名.clear()：清空集合中所有元素。
del 集合名: 删除整个集合。
st = {1, 2, 3, 4, 5}
st.pop()
print(st)
# 输出{2, 3, 4, 5}
st.remove(3)
print(st)
# 输出{2, 4, 5}
st.clear()
print(st)
# 输出set()
del st对于集合来说修改元素主要有以下方法：
集合1.difference_update(集合2)：修改集合1的内容为它和集合2元素的差集，差集即为集合1中存在，但集合2中不存在的元素。
集合1.update(集合2)：修改集合1的内容为它和集合2的并集。
集合1.intersection_update(集合2)：修改集合1的内容为它和集合2的交集。
st1 = {1, 2, 3, 4, 5}
st2 = {3, 4, 5, 6, 7}
st3 = {5, 6}
st1.difference_update(st2)
print(st1)
#输出{1, 2}
st1.update(st2)
print(st1)
#输出{1, 2, 4, 3, 5, 6, 7}
st1.intersection_update(st3)
print(st1)
#输出{5, 6}对于集合来说查询主要有以下方法：
len(集合名): 查询集合元素的总个数。
st = {1, 2, 3, 4, 5}
print(len(st)
# 输出55.3.3 集合的遍历
在集合中不支持下标索引，因此集合也不支持使用while循环，所以要遍历集合中的元素只能使用for循环，其具体格式和示例如下：
# for循环格式
for 元素变量 in 集合名:
循环体
# for循环示例
names = {'张三', '李四', '王五', '赵六'}
# for循环遍历
for name in names:
print(name)5.4 字典
5.4.1 字典的定义
字典可以提供基于key检索value的场景实现，字典与集合同样使用{}表示，不过字典内存储的元素是一个个的键值对，每一个键值对包含key和value（用冒号分隔），各个键值对之间使用逗号分隔，注意: key不能是可变类型数据，而value可以是任意类型的数据，key的值不可重复，重复会覆盖原有数据，而value的值可以重复。
注意：字典同集合一样，不可以使用下标索引，但是字典可以通过key值来取得对应的value值，字典具体定义格式如下：
# 定义空字典
d1 = {}
d2 = dict()
# 定义非空字典
d3 = {'点赞': 66, '关注': 88, '收藏': 99}
# 注意：键key只能是不可变类型且不能重复，值value可以是任意类型且可以重复
# 字典可以嵌套字典dic = {'点赞': 66, '关注': 88, '收藏': 99}
dic['转发'] = 11
print(dic)
# 输出{'点赞': 66, '关注': 88, '收藏': 99, '转发': 11}5.4.2 字典的增删改查
对于字典来说增加元素主要有以下方法：
字典名[新key] = value：在字典中添加一个键值对 新key:value。
dic = {'点赞': 66, '关注': 88, '收藏': 99}
dic['转发'] = 11
print(dic)
# 输出{'点赞': 66, '关注': 88, '收藏': 99, '转发': 11}对于字典来说修改元素主要有以下方法：
字典名[旧key] = value：在字典中修改旧key对应的值为value。
dic = {'点赞': 66, '关注': 88, '收藏': 99}
dic['点赞'] = 33
print(dic)
# 输出{'点赞': 33, '关注': 88, '收藏': 99}对于字典来说删除主要有以下方法：
字典名.pop(key)：根据key删除对应的键值对。
del 字典名[key]：根据key删除对应的键值对。
字典名.clear()：清空字典中所有元素。
del 字典名：删除整个字典。
dic = {'点赞': 66, '关注': 88, '收藏': 99}
dic.pop('点赞')
print(dic)
# 输出{'关注': 88, '收藏': 99}
del dic['关注']
print(dic)
# 输出{'收藏': 99}
dic.clear()
print(dic)
# 输出{}
del dic对于字典来说查询主要有以下方法：
字典名[key]：根据key获取value。
字典名.get(key)：根据key获取value。
len(字典名)：获取字典中键值对的个数。
字典名.keys()：获取所有的key。
字典名.values()：获取所有的value。
字典名.items()：获取所有的键值对，注意: 每个键值对都单独封装为元组。
dic = {'点赞': 66, '关注': 88, '收藏': 99}
print(len(dic))
# 输出3
print(dic['点赞'])
# 输出66
print(dic.get('关注'))
# 输出88
print(dic.keys())
# 输出dict_keys(['点赞', '关注', '收藏'])
print(dic.values())
# 输出dict_values([66, 88, 99])
print(dic.items())
# 输出dict_items([('点赞', 66), ('关注', 88), ('收藏', 99)])注意：字典名.keys()，字典名.values()和字典名.items()的返回值并不是列表，而是单独封装的可迭代的特殊类。
5.4.3 字典的遍历
与集合一样，在字典中不支持下标索引，因此字典也不支持使用while循环，所以要遍历字典中的元素只能使用for循环，其具体格式如下：
# 字典的四种for循环格式
for k in 字典:
v = 字典.get(k)
循环体
for k, v in 字典.items():
循环体
for k in 字典.keys():
循环体
for v in 字典.values():
循环体5.5 五大容器总结
5.5.1 容器的拆包和装包
在Python中，可以对容器进行拆包和装包操作，拆包是指将一个容器中的元素分配给多个变量的过程，五大容器均可进行拆包，具体格式和示例如下：
# 格式
x, y, z = 容器
# 字符串拆包
vec = 'abc'
x, y, z = vec
print(x, y, z)
# 输出 a b c
# 列表拆包
vec = [1, 2, 3]
x, y, z = vec
print(x, y, z)
# 输出 1 2 3
# 元组拆包
vec = (1, 2, 3)
x, y, z = vec
print(x, y, z)
# 输出 1 2 3
# 集合拆包
vec = {1, 2, 3}
x, y, z = vec
print(x, y, z)
# 输出 1 2 3
# 字典拆包
vec = {1:'a', 2:'b', 3:'c'}
x, y, z = vec
print(x, y, z)
# 输出 1 2 3注意，变量的个数需要与容器内元素的个数相等才能够进行拆包。
装包是指将多个值收集到一个容器中，在Python中，如果单独出现多个以逗号分割的元素，会将这些元素自动装包到元组中，示例如下：
v = 1, 3, 5
print(v, type(v))
# 输出 (1, 3, 5) <class 'tuple'>5.5.2 五大容器的特点
五大容器的特点对比如下：
基于各类数据容器的特点，它们的应用场景如下：
列表：一批数据，可修改、可重复的存储场景。
元组：一批数据，不可修改、可重复的存储场景。
字符串：一串字符串的存储场景。
集合：一批数据，需要去重的存储场景。
字典：一批数据，需用key检索value的存储场景。
5.5.3 五大容器的通用函数
五大容器的均可使用的通用函数如下：
注意：如果要对容器使用min()、max()以及sorted()函数，需要保证容器中的元素类型一致，且为可比较类型，如整数、字符串等。
使用sorted()函数排序后，会得到一个新的列表（list）对象。
列表、元组、字符串还额外支持while循环。
5.5.4 五大容器的类型转换
五大容器基本上都可以相互转换（但列表、元组、字符串和集合不能转换为字典），五大容器的类型转换函数如下：
定义如下容器：
# 定义非空列表
l = [2, 1, 3, 1]
# 定义非空元组
t = (2, 1, 3, 1)
# 定义非空字符串
s = '2131'
# 定义非空集合
ss = {2, 1, 3}
# 定义非空字典
d = {2: 'a', 3: 'a', 4: 'a', 1: 'a'}使用list()函数进行类型转换：
print(list(t))
print(list(s))
print(list(ss))
print(list(d))
使用tuple()函数进行类型转换：
print(tuple(l))
print(tuple(s))
print(tuple(ss))
print(tuple(d))
使用set()函数进行类型转换：
print(set(l))
print(set(t))
print(set(s))
print(set(d))
使用str()函数进行类型转换：
print(str(l))
print(str(t))
print(str(ss))
print(str(d)) 
注意：使用str()函数转换后的列表、元组、集合以及字典的具体形式是'[2, 1, 3, 1]'、'(2, 1, 3, 1)'、'{1, 2, 3}'、"{2: 'a', 1: 'a', 3: 'a'}"，也就是说‘[’、‘{’、‘(’、‘ ’等特殊字符也被算入了转换后的字符串中，因此，如果直接对转换后的字符串使用list()、tuple()以及set()函数将无法获得原来的列表、元组和集合，此时需要使用eval()函数来去除字符串两端的引号，将字符串转换为原始的容器，示例如下：
lst = [2, 1, 3, 1]
s = str(lst)
print(s)
# 输出 [2, 1, 3, 1]
lst1 = list(s)
print(lst1)
# 输出 ['[', '2', ',', ' ', '1', ',', ' ', '3', ',', ' ', '1', ']']
lst2 = eval(s)
print(lst2)
# 输出 [2, 1, 3, 1]
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
