目录
比较项 | 列表 | 元组 | 字符串 | 集合 | 字典 |
---|---|---|---|---|---|
是否支持多个元素 | Y | Y | Y | Y | Y |
元素类型 | 任意 | 任意 | 字符 | 任意 | key通常是字符串或数字,value任意 |
是否支持元素重复 | Y | Y | Y | N | key不可以重复,value可以重复 |
是否有序 | Y | Y | Y | N | 3.6版本之前无序,3.6版本之后有序 |
是否支持索引 | Y | Y | Y | N | N |
可修改性/可变性 | Y | N | N | Y | Y |
使用场景 | 可修改、可重复的多个数据 | 不可修改、可重复的多个数据 | 字符串 | 不可重复的多个数据 | 键值对 |
定义符号 | [] | () | ""或'' | {} | {key: value} |
1. 列表 list
列表可以存放不同的数据类型。
list1 = [3, 3.14, "圆周率", "π"]
print(list1)
print(type(list1))
print("--------------------")
list2 = [3, 3.14, ["圆周率", "π"]]
print(list2)
print(type(list2))
列表索引从0开始,下一个为1;也可以从尾部开始,最后一个元素索引为-1,上一个为-2。
list1 = [3, 3.14, "圆周率", "π"]
# while循环正向遍历列表
i = 0
while i < len(list1):
print(f"第{i+1}个元素是{list1[i]}")
list1[i] = i * 100 # 修改列表中的元素
i += 1
print("--------------------")
# while循环反向遍历列表
i = -1
while i >= -len(list1):
print(f"倒数第{-i}个元素为{list1[i]}")
i -= 1
列表推导式用法:
list1 = [elem * 2 for elem in range(1, 5)]
print(list1)
list2 = [int(elem / 2) for elem in list1]
print(list2)
list3 = [elem + elem for elem in "coding"]
print(list3)
'''
[2, 4, 6, 8]
[1, 2, 3, 4]
['cc', 'oo', 'dd', 'ii', 'nn', 'gg']
'''
方法 | 描述 |
---|---|
list.append(obj) | 追加对象 |
list.count(obj) | 返回次数 |
list.extend(seq) | 追加序列 |
list.index(obj) | 返回第一个索引 |
list.insert(index, obj) | 插入 |
list.pop([index=-1]) | 删除,并返回值 |
list.remove(obj) | 删除第一个obj |
list.reverse() | 逆序 |
list.sort(key=None, reverse=False) | 排序 |
list.clear() | 清空 |
list.copy() | 返回拷贝 |
2. 元组 tuple
可以修改元组内列表的内容。
tuple1 = (3, 3.14, ["圆周率", "π"])
print(type(tuple1))
tuple1[2][1] = "pi"
print(tuple1)
'''
<class 'tuple'>
(3, 3.14, ['圆周率', 'pi'])
'''
函数 | 描述 |
---|---|
tuple.count(obj) | 返回次数 |
tuple.index(obj) | 返回第一个索引 |
3. 字符串 str
字符串是不可变序列。
方法 | 描述 |
---|---|
str.replace(old, new[, count]) | 前count个子串old都会被替换成new,没给count则全部替换 返回替换后的字符串 |
str.split(sep=None, maxsplit=-1) | 以sep分割字符串,分割次数为maxsplit,默认全部分割 返回分割后的字符串列表 |
str.count(sub) | 返回次数 |
str.index(sub) | 返回第一个索引 |
str.strip([chars]) | 移除头尾指定的字符,默认移除空格,chars包含了要移除的字符 返回移除后的字符串 |
str.lower() | 返回小写 |
str.upper() | 返回大写 |
4. 切片
切片就是从一个序列中取出子序列。
基本语法:
序列[起始索引:结束索引:步长]
- 切片操作是前闭后开的,即在[起始索引,结束索引)区间内截取。
- 如果省略步长,则默认为1。步长为正数表示正向截取,步长为负数表示正向截取。
- 当步长为正数时:
如果省略起始索引,则默认为0。
如果省略结束索引,则默认截取到结尾。 - 当步长为负数时:
如果省略起始索引,则默认为-1。
如果省略结束索引,则默认截取到开头。
# 对列表进行切片
list1 = ["apple", "orange", "banana", "pear"]
# 截取"orange","banana","pear"
list1_slice = list1[1::]
print(list1_slice)
# 对元组进行切片
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8, 9)
# 截取3,6
tuple1_slice = tuple1[2:6:3]
print(tuple1_slice)
# 对字符串进行切片
str1 = "abcd"
# 截取cba
str1_slice = str1[-2::-1]
print(str1_slice)
5. 集合 set
集合是由不重复元素组成的无序容器。列表、元组是可以重复的,且有序。
无序,就是你定义元素的顺序和取出的顺序不能保证一致。
集合底层会按照自己的一套算法来存储和取数据,所以每次取出顺序是不变的。
set1 = {8, 8, 5, 6, 5, 7}
print(set1)
print(type(set1))
'''
{8, 5, 6, 7}
<class 'set'>
'''
集合不支持索引。
所以对集合进行遍历只能用for循环,不能用while循环。
set1 = {5, 6, 3, 4, 5, 7}
for elem in set1:
print(elem)
创建空集合只能用set(),{}创建的是空字典。
set1 = set()
dict1 = {}
print(type(set1))
print(type(dict1))
'''
<class 'set'>
<class 'dict'>
'''
集合推导式和列表推导式类似,区别是使用{}:
set1 = {elem * 2 for elem in range(1, 5)}
print(set1)
set2 = {int(elem / 2) for elem in set1}
print(set2)
set3 = {elem + elem for elem in "coding"}
print(set3)
'''
{8, 2, 4, 6}
{1, 2, 3, 4}
{'oo', 'gg', 'ii', 'nn', 'cc', 'dd'}
'''
方法 | 描述 |
---|---|
set.add(obj) | 添加 |
set.remove(obj) | 移除指定对象 |
set.pop() | 移除随机一个对象,并返回 |
set.clear() | 清空 |
set.intersection(*others) | 返回交集 等价于set & other & ... |
set.union(*others) | 返回并集 等价于set | other | ... |
set.difference(*others) | 返回差集 等价于set - other - ... |
6. 字典 dict
字典的key不可变,可以是字符串或数字或元组,不能是列表,value可以是任意数据类型。
dict1 = {
"one": 1,
"TWO": [2, "two"],
"李相夷": {
"性别": "男",
"武力值": 100,
"武器": "少师剑"
},
3: ("three", "三")
}
print(dict1)
print(type(dict1))
'''
{'one': 1, 'TWO': [2, 'two'], '李相夷': {'性别': '男', '武力值': 100, '武器': '少师剑'}, 3: ('three', '三')}
<class 'dict'>
'''
和集合一样,字典不支持索引,只能用for循环遍历。
dict1 = {"one": 1, "two": 2, "three": 3}
# 遍历方式1
# 依次取出key,再通过dict[key]取出对应的value
for key in dict1:
print(f"{key}-{dict1[key]}")
# 遍历方式2
# 依次取出value
for value in dict1.values():
print(f"value: {value}")
# 遍历方式3
# 依次取出key-value
for k, v in dict1.items():
print(f"{k}-{v}")
字典的key必须是唯一的,如果你指定了多个相同的key,后面的键值对会覆盖前面的。
dict1 = {"one": 1, "two": 2, "one": "一"}
print(dict1["one"]) # 一
字典推导式用法:
# 简单用法
dict1 = {ch: ch.upper() for ch in "abc"}
print(dict1)
# 复杂用法
nums = [1, 2, 3]
words = ["one", "two", "three"]
dict2 = {num: word for num, word in zip(nums, words)}
# zip将对象中对应的元素打包成元组,然后返回由这些元组组成的列表
print(dict2)
'''
{'a': 'A', 'b': 'B', 'c': 'C'}
{1: 'one', 2: 'two', 3: 'three'}
'''
方法 | 描述 |
---|---|
dict.keys() | 返回key列表 |
dict.values() | 返回value列表 |
dict.items() | 返回(key, value)元组列表 |
dict.pop(key[, default]) | 参数:
返回值:
|
dict.clear() | 清空 |
7. 运算符
7.1 成员运算符——in、not in
- elem in seq 如果elem在seq里,返回True,否则返回False
- elem not in seq 如果elem不在seq里,返回True,否则返回False
7.2 加法、乘法用于拼接
- seq1 + seq2 seq1和seq2拼接
- seq * n seq重复n次