【Python】数据容器

目录

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常用方法

方法	描述
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常用方法

函数	描述
tuple.count(obj)	返回次数
tuple.index(obj)	返回第一个索引

3. 字符串 str

字符串是不可变序列。

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常用方法

方法	描述
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常用方法

方法	描述
dict.keys()	返回key列表
dict.values()	返回value列表
dict.items()	返回(key, value)元组列表
dict.pop(key[, default])	参数： key - 要删除的键 default - 当键 key 不存在时返回的值 返回值： 如果 key 存在 - 删除字典中对应的元素，并返回value 如果 key 不存在 - 返回设置指定的默认值 default 如果 key 不存在且默认值 default 没有指定 - 触发 KeyError 异常
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次