目录
1. 列表 list
2. 元组 tuple
3. 字符串 str
4. 切片
5. 集合 set
6. 字典 dict
7. 运算符
7.1 成员运算符——in、not in
7.2 加法、乘法用于拼接
| 比较项 | 列表 | 元组 | 字符串 | 集合 | 字典 |
|---|---|---|---|---|---|
| 是否支持多个元素 | 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次