Python列表、元组、字典、集合、字符串的异同总结

1.数据类型

列表、元组、字典、集合、字符串均属于python3的标准数据类型。

字符串和元组属于不可变数据，即创建后不可修改。

列表、字典、集合属于可变数据，即创建后可以修改元素。

2.创建有元素的对象

3.创建没有元素的对象

列表使用eval()或list()或中括号[]进行创建，元素之间使用逗号分隔。若不添加任何元素，则创建空列表。

# 使用[]创建
list_ = [1, 2, 3, 4, 5]
print(type(list_)) # <class 'list'>
# 使用eval()创建,eval()方法用来执行一个字符串表达式,并返回表达式的值
list_ = eval("[1,2,3,4,5]")
print(type(list_)) # <class 'list'>
# 使用list()创建,list()方法用于将元组转换为列表
list_ = list((1, 2, 3, 4, 5))
print(type(list_)) # <class 'list'>

元组使用eval()或tuple()或小括号()进行创建，元素之间使用逗号分隔。若不添加任何元素，则创建空元组。如果元组只有一个元素，则必须在这个元素后面加上逗号。

# 使用()创建
tuple_ = (1, 2, 3, 4, 5)
print(type(tuple_)) # <class 'tuple'>
# 使用eval()创建
tuple_ = eval("(1,2,3,4,5)")
print(type(tuple_)) # <class 'tuple'>
# 使用tuple()创建,tuple()函数用于将列表转换为元组
tuple_ = tuple([1, 2, 3, 4, 5])
print(type(tuple_)) # <class 'tuple'>

字典使用eval()或dict()函数或者大括号{}创建，元素之间用逗号分隔。每个元素必须是一个键(key)值(value)对。若不添加任何元素，则创建空字典。

# 使用{}创建
dict_ = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
print(type(dict_)) # <class 'dict'>
# 使用eval()创建
dict_ = eval("{'a':1,'b':2,'c':3,'d':4,'e':5}")
print(type(dict_)) # <class 'dict'>
# 使用dict()创建
dict_ = dict(a=1, b=2, c=3, d=4, e=5)  # 传入关键字方式来构造字典
print(type(dict_)) # <class 'dict'>
dict_ = dict(zip(['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]))  # 映射函数方式来构造字典
print(type(dict_)) # <class 'dict'>
dict_ = dict([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])  # 可迭代对象方式来构造字典
print(type(dict_)) # <class 'dict'>

集合使用eval()或set()或{}进行创建，元素之间使用逗号分隔。由于{}用于创建空字典，所以只能通过不传参的set()来创建空集合。

# 使用{}创建
set_ = {1, 2, 3, 4, 5}
print(type(set_)) # <class 'set'>
# 使用eval()创建
set_ = eval("{1,2,3,4,5}")
print(type(set_)) # <class 'set'>
# 使用set()创建,参数为可迭代对象
set_ = set("python")
print(type(set_)) # <class 'set'>

字符串使用str()或单引号''或双引号""进行创建，引号内元素为一个整体，不需要使用分隔符。若引号内不添加字符或str()不传参，则创建空字符串

# 使用引号创建
str_ = '12345'
print(type(str_)) # <class 'str'>
# 使用str()创建
str_ = str(12345)
print(type(str_)) # <class 'str'>

4.元素的类型

5.元素是否可以重复

6.元素顺序

列表内的元素可以为任意类型。元素之间可以重复。元素顺序遵循创建时的顺序。

list_ = [1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"}]
print(list_)  # [1, 2.5, 1, 'a', ['b'], ('c',), {'d': 'e'}, {'f'}]

元组内的元素可以为任意类型。元素之间可以重复。元素顺序遵循创建时的顺序。

tuple_ = (1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"})
print(tuple_)  # (1, 2.5, 1, 'a', ['b'], ('c',), {'d': 'e'}, {'f'})

字典中的键只能为数字、字符串、元组类型，值可以为任意类型。键(key)是唯一的，可以多次赋值(value)。若对应的键多次赋值，则后面赋的值会覆盖前面赋的值。元素顺序遵循创建时的顺序。

dict_ = {1: ["a"], 2.5:("b",), "c":{"d": "e"}, True:["f"], ("f",):{"g"}}
print(dict_)  # {1: ['f'], 2.5: ('b',), 'c': {'d': 'e'}, ('f',): {'g'}}  True际上是1，所以覆盖了前面的["a"]

集合内的元素只能为数字、字符串、元组类型。集合会在创建时自动剔除重复元素。元素顺序随机。

set_ = {1, 2.5, 1, "a", ("b",)}
print(set_)  # {'a', 1, 2.5, ('b',)}

字符串创建时，引号内可以是任意字符。若在引号前加r，则不对引号内的字符转义。不存在重复元素和元素顺序的说法，因为字符串创建后就不能修改了。

str_ = "123	abc"
print(str_)  # 123  abc
str_ = r'123	abc'
print(str_)  # 123	abc

7.访问元素

8.修改元素

列表、元组、字典、集合、字符串都可以使用for遍历所有元素。

列表使用索引访问和修改指定位置元素。

list_ = [1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"}]
print(list_[1])  # 2.5
list_[2] = 3
for e in list_:
    print(e, end="	")
# 1    2.5    3  a  ['b']  ('c',) {'d': 'e'} {'f'}

元组使用索引访问指定位置元素。元组创建后不可修改。

tuple_ = (1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"})
print(tuple_[6])  # {'d': 'e'}

字典使用键(key)访问和修改指定元素。

dict_ = {1: ["a"], 2.5: ("b",), "c": {"d": "e"}, True: ["f"], ("f",): {"g"}}
print(dict_[("f",)])  # {'g'}
dict_[True] = ["a"]
for e in dict_:
    print(str(e) + ":" + str(dict_[e]),end="	")
# 1:['a']  2.5:('b',) c:{'d': 'e'}   ('f',):{'g'}

集合不能使用索引访问和修改元素。但可以通过先删除后添加实现修改元素。

set_ = {1, 2.5, 1, "a", ("b",)}
set_.remove(1)
set_.add(3)
for i in set_:
    print(i, end="	")
# 2.5  3  a  ('b',)

字符串使用索引访问指定位置元素。字符串创建后不可修改。

str_ = r'123	abc'
print(str_[3])  # 

9.切片

可以使用索引访问的都可以切片。即列表、元组、字符串可切片。

list_ = [1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"}]
print(list_[3:6])  # ['a', ['b'], ('c',)]
tuple_ = (1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"})
print(tuple_[4:7])  # (['b'], ('c',), {'d': 'e'})
str_ = r'123	abc'
print(str_[3:])  # 	abc

10.添加元素

11.删除元素

列表使用list.append(单个元素)方法在list列表末端增加一个元素；使用list.extend([元素1，元素2])在list列表末端增加多个元素；使用list.insert(索引，元素)在列表指定位置增加一个元素。使用list.remove(元素)从列表中删除一个元素；使用del list[索引]从列表中删除指定位置的元素；使用list.pop(索引)从列表中删除指定位置元素，返回值为删除的元素值，如果空参默认删除末尾元素；使用list.clear()清空整个列表。

list_ = []
list_.insert(0, 0)
list_.append(1)
list_.extend([2, 3])
print(list_)  # [0, 1, 2, 3]
list_.remove(0)
del list_[0]
list_.pop(0)
print(list_)  # [3]
list_.clear()
print(list_)  # []

元组一旦创建就不可修改，所以没有添加和删除元素的方法。可将元组转化为列表进行相应操作后再转为元组。

tuple_ = ()
tuple_ = list(tuple_)
tuple_.insert(0, 0)
tuple_.append(1)
tuple_.extend([2, 3])
print(tuple(tuple_))  # (0, 1, 2, 3)
tuple_.remove(0)
del tuple_[0]
tuple_.pop(0)
print(tuple(tuple_))  # (3,)
tuple_.clear()
print(tuple(tuple_))  # ()

字典使用dict[key]=value添加元素，如果已存在该元素，则将其覆盖；使用dict.setdefault(key，value)添加元素，若该元素已存在，则不会将其覆盖，若只传一个参数，则key为该参数，value为None。使用dict.pop(key)删除元素，此方法必须传入一个key，若除key之外还传了一个参数，则这个参数作为key不存在时的方法返回值；使用dict.popitem()删除随机的一个元素；使用del dict[key]删除指定元素，使用dict.clear()清空整个字典。

dict_ = {0: ["a"]}
dict_.setdefault(1, ["a"])
dict_[True] = ["b"]
dict_[2.5] = ("c",)
dict_.setdefault("d")
print(dict_)  # {0: ['a'], 1: ['b'], 2.5: ('c',), 'd': None}
dict_.pop("d")
dict_.popitem()
print(dict_)  # {0: ['a'], 1: ['b']}
dict_.clear()
print(dict_)  # {}

集合使用set.add(元素)添加元素；使用set.update(元素)添加元素，此方法传参可以为多个，添加元素时会将参数中的列表、元组、字典、集合进行遍历添加。使用set.remove(元素)删除元素，元素不存在会报错KeyError；使用set.discard(元素)删除元素，元素不存在不会报错；使用set.pop()随即删除元素。

set_ = {1, 2.5, ("a",)}
set_.add(3)
set_.update([4, 5, 6], ("a",), {"b": 7}, {"c", "d"})
print(set_)  # {1, 2.5, 3, 4, 5, 6, 'a', 'b', 'd', 'c', ('a',)}
set_.remove(2.5)
set_.discard("a")
set_.pop()
print(set_)  # {3, 4, 5, 6, 'b', 'd', ('a',), 'c'}

字符串本质上不存在添加和删除元素的方法。可使用str.replace(old_str,new_str)进行字符串替换完成添加字符和删除字符的操作，也可以将其转化为列表进行添加和删除操作。