本篇文章非原创，几乎所有内容都来自：c语言中文网-Python列表（list）、元组（tuple）、字典（dict）和集合（set）详解
序列
字符串、列表、元组。
序列索引
正向：从左到右，0下标开始。
反向：从右到左，-1下标开始。
str = "Hello,world!"
print(str[0], str[-6]) # H w
print(str[5], str[-1]) # , !
序列切片
sname[start : end : step]
- start：开始位置（包括该位置），默认为 0，可不写，从序列的开头进行切片；
- end：结束位置（不包括该位置），如果不指定，默认为序列的长度；
- step：隔几个存储位置（包含当前位置）取一次元素，若要设置 step 的值，必须写第二个:。
str = "Hello,world!"
print(str[:2])
print(str[::2])
print(str[:]) # 取整个字符串
结果：
He
Hlowrd
Hello,world!
列表
列表是序列的一种。
列表可以存储整数、小数、字符串、列表、元组等任何类型的数据。
同一个列表中元素的类型也可以不同。
创建列表
1、直接创建
num = [1, 2, 3, 4, 5, 6, 7]
2、list()创建
#将字符串转换成列表
list1 = list("hello")
print(list1)
#将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)
#将字典转换成列表
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)
#将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)
#创建空列表
print(list())
结果：
[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]
[‘Python’, ‘Java’, ‘C++’, ‘JavaScript’]
[‘a’, ‘b’, ‘c’]
[1, 2, 3, 4, 5]
[]
访问列表元素
url = list("https://www.w3school.com.cn/python/python_strings.asp")
#索引访问 某个元素
print(url[3]) #使用正数索引
print(url[-4]) #使用负数索引
#切片访问 一组元素
print(url[9: 18]) #使用正数切片
print(url[9: 18: 3]) #指定步长
print(url[-6: -1]) #使用负数切片
结果：
p
.
[‘w’, ‘w’, ‘.’, ‘w’, ‘3’, ‘s’, ‘c’, ‘h’, ‘o’]
[‘w’, ‘w’, ‘c’]
[‘g’, ‘s’, ‘.’, ‘a’, ‘s’]
添加列表元素
1、+
language = ["Python", "C++", "Java"]
birthday = [1991, 1998, 1995]
info = language + birthday
print("info =", info) # info = ['Python', 'C++', 'Java', 1991, 1998, 1995]
2、append()
list = ['Python', 'C++', 'Java']
list.append('PHP')
print(list)
t = ('JavaScript', 'C#', 'Go')
list.append(t)
print(list)
list.append(['Ruby', 'SQL'])
print(list)
结果：
[‘Python’, ‘C++’, ‘Java’, ‘PHP’]
[‘Python’, ‘C++’, ‘Java’, ‘PHP’, (‘JavaScript’, ‘C#’, ‘Go’)]
[‘Python’, ‘C++’, ‘Java’, ‘PHP’, (‘JavaScript’, ‘C#’, ‘Go’), [‘Ruby’, ‘SQL’]]
可见，不管参数中有多少数据，append()都会将其视作一条数据插入list中。
3、extend()
与append()不同，extend()不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。
list = ['Python', 'C++', 'Java']
list.extend('PHP')
print(list)
t = ('JavaScript', 'C#', 'Go')
list.extend(t)
print(list)
list.extend(['Ruby', 'SQL'])
print(list)
插入列表元素
insert(index, element)方法仅将元素插入列表，没有返回值。
list=[1, 2, 3, 4, 5]
list.insert(3, 8) # [1, 2, 3, 8, 4, 5]
list.insert(10, 11) # 等价list.insert(6, 11)
print(list) # [1, 2, 3, 8, 4, 5, 11]
list.insert(-1, 12)
print(list) # [1, 2, 3, 8, 4, 5, 12, 11]
修改列表元素
list = list("hello w")
list[2] = 'L' # 索引修改单个
print(list)
list[3:5] = "XYZ" # 切片修改一群
print(list)
结果：
[‘h’, ‘e’, ‘L’, ‘l’, ‘o’, ’ ', ‘w’]
[‘h’, ‘e’, ‘L’, ‘X’, ‘Y’, ‘Z’, ’ ', ‘w’]
查找列表元素
1、index()
listname.index(obj, start, end)，返回obj在列表中第一次出现的位置。
- start 和 end 可以都不写，检索整个列表；
- 只写 start 不写 end，检索从 start 到末尾的元素；
- start 和 end 都写，检索 start 和 end 之间的元素。
nums = [1, 2, 100, 4, 2, 6, 99, 1, 7, 3, 88, 2]
print(nums.index(2))
print(nums.index(99, 3, 7))
print(nums.index(7, 4))
print(nums.index(55))
1
6
8
ValueError: 55 is not in list
⚠️：当list中不存在obj时，会出现ValueError，所以查找之前最好count()一下。
2、count()
统计某个元素在列表中出现的次数。
list = [1, 2, 100, 4, 2, 6, 99, 1, 7, 3, 88, 2]
print("元素2出现了" + str(list.count(2)) + "次") # 元素2出现了3次
删除列表元素
1、del
lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
del lang[2]
print(lang)
del lang[-2]
print(lang)
del lang[1: 3]
print(lang)
lang.extend(["SQL", "C#", "Go"])
del lang[-4: -2]
print(lang)
结果：
[‘Python’, ‘C++’, ‘PHP’, ‘Ruby’, ‘MATLAB’]
[‘Python’, ‘C++’, ‘PHP’, ‘MATLAB’]
[‘Python’, ‘MATLAB’]
[‘C#’, ‘Go’]
2、pop()
删除给定位置的值，如果没给，删除最后一位，类似栈，但没有对应的push()，可以用append、extend代替push。
nums = [1, 2, 3, 4, 5, 6, 7]
nums.pop(3)
print(nums)
nums.pop()
print(nums)
结果：
[1, 2, 3, 5, 6, 7]
[1, 2, 3, 5, 6]
3、remove()
删除某个固定的值，如果这个值有多个，则删除第一个。
nums = [1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 10]
nums.remove(3)
print(nums)
nums.remove(6) # 6有两个
print(nums)
结果：
[1, 2, 4, 5, 6, 6, 7, 8, 9, 10]
[1, 2, 4, 5, 6, 7, 8, 9, 10]
4、清空列表
list.clear()
元组
元组可以存储整数、实数、字符串、列表、元组等任何类型的数据。
在同一个元组中，元素的类型可以不同。
元组（tuple）和列表（list）的不同之处在于：
- 列表元素可修改，为可变序列，包括修改元素值，删除和插入元素；
- 元组一旦被创建，元素不可修改，是不可变序列。
创建元组
1、直接创建
x = (1, 2, 3, 4, 5, 6)
y = ("Python", 19, [1, 2], {1: 2})
z1 = 'a', 'b', 'c' # 不写()时，有,分割的，按照元组处理
z2 = 'a' # 普通变量声明
z3 = ('a') # 普通变量声明
z4 = ('a',) # 元组
print(x)
print(y)
print(z1)
print(z2)
print(z3)
print(z4)
结果：
(1, 2, 3, 4, 5, 6)
(‘Python’, 19, [1, 2], {1: 2})
(‘a’, ‘b’, ‘c’)
a
a
(‘a’,)
2、tuple()创建
#将字符串转换成元组
tuple1 = tuple("hello")
print(tuple1)
#将列表转换成元组
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tuple2 = tuple(list1)
print(tuple2)
#将字典转换成元组
dict1 = {'a':100, 'b':42, 'c':9}
tuple3 = tuple(dict1)
print(tuple3)
#将区间转换成元组
range1 = range(1, 6)
tuple4 = tuple(range1)
print(tuple4)
#创建空元组
print(tuple())
结果：
(‘h’, ‘e’, ‘l’, ‘l’, ‘o’)
(‘Python’, ‘Java’, ‘C++’, ‘JavaScript’)
(‘a’, ‘b’, ‘c’)
(1, 2, 3, 4, 5)
()
访问元组元素
url = tuple("https://www.w3school.com.cn/python/python_strings.asp")
#索引访问 某个元素
print(url[3]) #使用正数索引
print(url[-4]) #使用负数索引
#切片访问 一组元素
print(url[9: 18]) #使用正数切片
print(url[9: 18: 3]) #指定步长
print(url[-6: -1]) #使用负数切片
结果：
p
.
(‘w’, ‘w’, ‘.’, ‘w’, ‘3’, ‘s’, ‘c’, ‘h’, ‘o’)
(‘w’, ‘w’, ‘c’)
(‘g’, ‘s’, ‘.’, ‘a’, ‘s’)
修改元组元素
只能通过给tuple重新赋值、+拼接的形式修改元组元素。
url = tuple("hello")
url += ('!',)
print(url)
url = tuple("world")
print(url)
结果：
(‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘!’)
(‘w’, ‘o’, ‘r’, ‘l’, ‘d’)
字典
字典，数据类型dict，以key：value（键值对）的形式存储，无序、可变。相当于Java、c++中的Map对象。
区分列表list、元组tuple：dict的元素在存储时无序，数据不占据连续的存储空间。
创建dict
1、直接声明：
dictname = {'key':'value1', 'key2':'value2', ...}
其中，dictname 表示字典变量名，key为键，value为对应的值，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。同一字典中的键必须唯一，不能重复。
例：
scores = {'数学': 95, '英语': 92, '语文': 84}
⚠️：key可以是整数、字符串或者元组，value可以是python支持的任何数据类型。
2、list为参，赋初始值
list = ['语文', '数学', '英语']
scores = dict.fromkeys(list, 60)
print(scores) # {'语文': 60, '数学': 60, '英语': 60}
3、dict()函数赋初始值
方法一：dict() 函数参数：各自是包含 2 个元素的列表或元组，第一个元素为键，第二个元素为值。
# demo = [('two',2), ('one',1), ('three',3)]
# demo = [['two',2], ['one',1], ['three',3]]
# demo = (('two',2), ('one',1), ('three',3))
demo = (['two',2], ['one',1], ['three',3])
a = dict(demo)
print(a) # {'two': 2, 'one': 1, 'three': 3}
方法二：a = dict(str1=value1, str2=value2, str3=value3)，使用此方式创建字典时，字符串不能带引号。
a = dict(two=2, one=1, three=3)
print(a) # {'two': 2, 'one': 1, 'three': 3}
⚠️：dict()创建空字典{}
访问字典
1、dictname[key]
dict = {'语文': 90, '数学': 80, '英语': 70}
print(dict['语文']) # 90
2、dictname.get(key[,default])
dict = {'语文': 90, '数学': 80, '英语': 70}
print(dict.get('语文'))
print(dict.get('计算机'))
print(dict.get('计算机', "您寻找的键不存在"))
结果：
90
None
您寻找的键不存在
增删改字典元素
- key无法修改，可修改value
dict = {'语文': 90, '数学': 80, '英语': 70}
# 对已有数据赋值，修改
dict['语文'] = 99
# 对不存在数据赋值，新增
dict['计算机'] = 66
print(dict) # {'语文': 99, '数学': 80, '英语': 70, '计算机': 66}
# 通过key删除元素
del dict['计算机']
print(dict) # {'语文': 99, '数学': 80, '英语': 70}
删除字典元素，还有pop()、popitem()方法，甚至可以使用setdefault()在某些情况下增改键值对，见“常用字典方法”。
常用字典方法
keys()、values()、items()
- keys() ，返回字典中的所有键（key）
- values() ，返回字典中所有键对应的值（value）
- items() ，返回字典中所有的键值对（key-value）
dict = {'语文': 90, '数学': 80, '英语': 70}
print(dict.keys())
print(dict.values())
print(dict.items())
print(dict)
结果：
dict_keys([‘语文’, ‘数学’, ‘英语’])
dict_values([90, 80, 70])
dict_items([(‘语文’, 90), (‘数学’, 80), (‘英语’, 70)])
{‘语文’: 90, ‘数学’: 80, ‘英语’: 70}
也可以这么用：
dict = {'语文': 90, '数学': 80, '英语': 70}
for key in dict.keys():
print(key, end=" ") # 语文 数学 英语
for value in dict.values():
print(value, end=" ") # 90 80 70
for k,v in dict.items():
print("{0}:{1}".format(k, v), end=" ") # 语文:90 数学:80 英语:70
copy()
copy()方法对最表层的键值对进行深拷贝（重新分配内存地址），对value值为列表等复合数据类型的拷贝为浅拷贝（共享内存地址），如下例子中，dict和dictC里的‘b’本质是列表，但复制后指向的仍是同一块内存区域。
dict = {'a':100, 'b':[1, 2, 3]}
list = [1, 2, 3, 4, 5]
dictC = dict.copy()
listC = list.copy()
print(dictC) # {'a': 100, 'b': [1, 2, 3]}
print(listC) # [1, 2, 3, 4, 5]
print(id(dict) == id(dictC)) # False
print(id(list) == id(listC)) # False
print(id(dict.get('b')) == id(dictC.get('b'))) # True
pop()、popitem()
- pop()通过key删除，返回被删除的value
- popitem()随机删除一条字典元素，一般遵循“出栈”原则，删除最后一个元素。返回值为被删除的键值对。
dict = {'语文': 90, '数学': 80, '英语': 70}
print(dict.pop("语文"))
print(dict)
print(dict.popitem())
print(dict)
结果：
90
{‘数学’: 80, ‘英语’: 70}
(‘英语’, 70)
{‘数学’: 80}
那么有没有一种情况，不必遍历整个字典，直接设置：key存在的话，其值不可改变，key不存在的话，添加指定的键值对呢？可以：
setdefault()
dict = {'语文': 90, '数学': 80, '英语': 70}
print(dict)
#key不存在，添加新键值对，给默认值
dict.setdefault('物理', 94)
print(dict)
#key不存在，添加新key，value没给时默认为None
dict.setdefault('化学')
print(dict)
#key存在，就不更改已有的value，默认值给了也没用
dict.setdefault('数学', 100)
print(dict)
结果：
{‘语文’: 90, ‘数学’: 80, ‘英语’: 70}
{‘语文’: 90, ‘数学’: 80, ‘英语’: 70, ‘物理’: 94}
{‘语文’: 90, ‘数学’: 80, ‘英语’: 70, ‘物理’: 94, ‘化学’: None}
{‘语文’: 90, ‘数学’: 80, ‘英语’: 70, ‘物理’: 94, ‘化学’: None}
集合
和字典类似，Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔。
同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典这些可变数据类型。
同一集合中，数据必须唯一。
set 是无序的，每次输出时元素的顺序可能都不相同。
创建集合
1、直接创建
s = {1, 1, 2, 'a', (1, 2, 3)}
print(s)
print(type(s))
结果：
{1, 2, (1, 2, 3), ‘a’}
<class ‘set’>
2、set()创建
set1 = set("hello")
set2 = set([1,2,3,4,5])
set3 = set((1,2,3,4,5))
print("set1:",set1)
print("set2:",set2)
print("set3:",set3)
结果：
set1: {‘o’, ‘l’, ‘h’, ‘e’}
set2: {1, 2, 3, 4, 5}
set3: {1, 2, 3, 4, 5}
访问集合元素
因为set无序，所以无法通过访问位置等方式读取元素数据，只能遍历访问：
set1 = set("hello")
for e in set1:
print(e)
修改集合元素
set1 = set("1122345")
set1.add('a') # 不能添加可变数据
print(set1)
set1.remove('1') # 移除不存在的元素时，会报KeyError
print(set1)
set1.discard("0")# 与remove()不同，不会报KeyError
print(set1)
# 非要向set中添加列表、字典元素使用
set1.update(['5', '6'])
set1.update({'k':'v'})
print(set1)
结果：
{‘4’, ‘5’, ‘1’, ‘a’, ‘2’, ‘3’}
{‘4’, ‘5’, ‘a’, ‘2’, ‘3’}
{‘4’, ‘5’, ‘a’, ‘2’, ‘3’}
{‘4’, ‘5’, ‘k’, ‘a’, ‘6’, ‘2’, ‘3’}
交集、并集、差集、对称差集
| 操作 | 运算符 | 含义 |
|---|---|---|
| 交集 | & | 取两者都有的元素 |
| 并集 | | | 取两者合并后的所有元素，相同项保留一个 |
| 差集 | - | 例：a-b，取a中所有b里没有的元素 |
| 对称差集 | ^ | 取两者中所有不属于a&b的元素 |
a = {1, 2, 3}
b = {3, 4, 5}
print(a & b)
print(a | b)
print(a - b)
print(b - a)
print(a ^ b)
结果：
{3}
{1, 2, 3, 4, 5}
{1, 2}
{4, 5}
{1, 2, 4, 5}
扫一扫
593
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
