python中列表、元组、字典、集合的异同 - 好文

转载地址 http://blog.csdn.net/weixin_37720172/article/details/78769301

<> 一.前言

一直想写写这四种类型的相同点，与不同点在哪里，以及在什么情况下应该使用哪种类型。无奈水平不够，怕写出来不够深刻，所以一直拖着。今天想了想还是写出来吧，如果以后还有新的见解或者技巧我会继续更上去的。

<> <>二.列表（list）

具有以下特点：
1.可以用list()函数或者方括号[]创建，元素之间用逗号’,‘’分隔。
2.列表的元素不需要具有相同的类型
3.使用索引来访问元素
4.可切片

* # 可用list()函数建立
* list1 = list((1, 2))
* # 用[]建立，可包含不同数据类型
* list2 = [1, 3, 'hello', 3.5]
* # 可用下标访问
* print(list1[1])
* # 切片
* print(list2[1:3])
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
结果：

* 2
* [3, 'hello']
* 1
* 2
方法:

操作解释
list.append(): 追加成员
list.count(x): 计算列表中参数x出现的次数
list.extend(L): 向列表中追加另一个列表L
list.index(x): 获得参数x在列表中的位置
list.insert(): 向列表中插入数据
list.pop(): 删除列表中的成员（通过下标删除）
list.remove(): 删除列表中的成员（直接删除）
list.reverse(): 将列表中成员的顺序颠倒
list.sort(): 将列表中成员排序
<> <>三.元组

元组跟列表很像，只不过元组用小括号来实现(),这里要区分好和生成器
<http://blog.csdn.net/weixin_37720172/article/details/78482291>的区别，两者都可用小括号来实现的

具有以下特点：
1.可以用tuple()函数或者方括号()创建，元素之间用逗号’,‘’分隔。
2.元组的元素不需要具有相同的类型
3.使用索引来访问元素
4.可切片
5.元素的值一旦创建就不可修改!!!!!(这是区别与列表的一个特征）

* # 可用tuple()函数创建
* tuple1 = tuple([1, 2])
* # 用()建立，可包含不同数据类型
* tuple2 = (1, 3, 'hello', 3.5)
* # 可用下标访问
* print(tuple1[1])
* # 可切片
* print(tuple2[1:3])
* # 不可以修改元素
* tuple1[1] = 10
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
* 9
* 10
结果：

* 2
* (3, 'hello')
* TypeError: 'tuple' object does not support item assignment
* 1
* 2
* 3
可进行的操作:元组由于它的不可变性（第五点特点），相比列表的操作少了很多，只保留了index()，count()函数，用法同列表。

当然也可以用内置函数来对他进行操作，这些内置函数对于列表也适用。

操作解释
cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(seq) 将列表转换为元组。
上面第五点在列表中的操作为（参考上面示例代码的第一点）：

操作解释
list(seq) 将元组转换为列表。
<> <>四.字典(Dictionary)

字典是另一种可变容器模型，且可存储任意类型对象。

具有以下特点：
1.元素由键（key）和值（value）组成
2.可以用dict()函数或者方括号()创建，元素之间用逗号’,‘’分隔，键与值之间用冒号”:”隔开
3.键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组
4.使用键（key）来访问元素

* # 用dict()函数创建
* dict1 = dict([('name', 'kyda'), ('e', 10)])
* # 用{}创建
* dict2 = {'name': 'lin', 'age': 21}
* print(dict1)
* # 使用键（key）来访问元素
* print(dict2['name'])
* # 使用键（key）来访问元素，并修改元素的值
* dict2['age'] = 23
* print(dict2)
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
* 9
* 10
结果：

* (3, 'hello')
* {'name': 'kyda', 'age': 10}
* lin
* {'name': 'lin', 'age': 23}
* 1
* 2
* 3
* 4
字典的方法:

操作解释
adict.keys() 返回一个包含字典所有KEY的列表；
adict.values() 返回一个包含字典所有value的列表；
adict.items() 返回一个包含所有（键，值）元祖的列表；
adict.clear() 删除字典中的所有项或元素；
adict.copy() 返回一个字典浅拷贝的副本；
adict.fromkeys(seq, val=None)
创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值（默认为None）；
adict.get(key, default = None)
返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）；
adict.has_key(key) 如果key在字典中，返回True，否则返回False。现在用 in 、 not in；
adict.iteritems() adict.iterkeys() adict.itervalues()
与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表；
adict.pop(key[,default])
和get方法相似。如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发keyerror异常；
adict.setdefault(key, default=None) 和set()方法相似，但如果字典中不存在Key键，由 adict[key] =
default 为它赋值；
adict.update(bdict) 将字典bdict的键值对添加到字典adict中。
<> <>五.集合(set)

具有以下特点：
1.可以用set()函数或者方括号{}创建，元素之间用逗号”,”分隔。
2.与字典相比少了键
3.不可索引，不可切片
4.不可以有重复元素

* # 两种方法创建
* set1 = set('kydaa')
* set2 = {'abc', 'jaja', 'abc', 'kyda'}
* print(set1)
* print(set2)
* 1
* 2
* 3
* 4
* 5
结果：自动将重复元素去除

* {'a', 'y', 'd', 'k'}
* {'jaja', 'abc', 'kyda'}
* 1
* 2
集合的方法:

操作解释
s.issubset(t)，s <= t 测试是否 s 中的每一个元素都在 t 中
s.issuperset(t)，s >= t 测试是否 t 中的每一个元素都在 s 中
s.union(t)，s | t 返回一个新的 set 包含 s 和 t 中的每一个元素
s.intersection(t)，s & t 返回一个新的 set 包含 s 和 t 中的公共元素
s.difference(t),s - t 返回一个新的 set 包含 s 中有但是 t 中没有的元素
s.symmetric_difference(t),s ^ t 返回一个新的 set 包含 s 和 t 中不重复的元素
s.copy() 返回 set “s”的一个浅复制
<> <>六.同异

1.列表和元组

列表和元组有很多相似的地方，操作也差不多。不过列表是可变序列，元组为不可变序列。
也就是说列表主要用于对象长度不可知的情况下，而元组用于对象长度已知的情况下，而且元组元素一旦创建变就不可修改。
例如我们在打开一个文本时，并不知道里面有多少行文字，所以用列表来保存。

* with open('test.txt', 'r') as f:
* print(f.readlines())
* # 结果：
* # ['hello world\n', 'hi kyda\n', 'this is my program']
* 1
* 2
* 3
* 4
而我们在储存一个人的信息（名字，年龄，性别，假定只需要这三种信息，所以对象长度为3）的时候，就可以用元组来实现。

* id = ('kyda', 19, 'man')
* print(id)
* # 结果：
* # ('kyda', 19, 'man')
* 1
* 2
* 3
* 4
2.字典
字典主要应用于需要对元素进行标记的对象，这样在使用的时候便不必记住元素列表中或者元组中的位置，只需要利用键来进行访问对象中相应的值。

* id = {'name': 'kyda', 'age': 19, ‘sex': 'man')
* print(id['age'])
* # 结果：
* # 19
* 1
* 2
* 3
* 4
3.集合
集合中的元素不可重复的特点使它被拿来去重
。比如我在爬去糗事百科全站的文章链接(存放与列表中）的时候，不可避免的会遇到重复的链接。这是我们只需将列表转换为集合便能有效的去除重复部分。
比如上面的例程。

4.在海量数据中查找元素时，最好将数据创建为字典，或者是集合

这是由于字典和集合背后的查找原理是散列（哈希）表。由于散列表在查找元素时的时间复杂度基本是O(1),这使查找时间很短。

在我的一篇博客专门实验了列表，元组，字典，集合在查找元素时所用的时间：
Python进阶（八）：in的详解
<http://blog.csdn.net/weixin_37720172/article/details/78636314>

5.灵活运用推导来创建
推导可以说是python最灵活的特性之一。
例子：
list1 = [x for x in range(1, 10)]
* 1
元组和集合都可以用上面的推导方式进行简单创建

对于字典来说我们也可以运用双重推导（笛卡尔积）来创建：

* list1 = ['name', 'age', 'sex']
* list2 = ['kyda', 19, 'man']
*
* ID = {x: y for x in list1 for y in list2}
* print(ID)
* # 结果
* # {'name': 'man', 'age': 'man', 'sex': 'man'}
* 1
* 2
* 3
* 4
* 5
* 6
* 7
当然上面还可以运用zip()函数简化为：
ID = {x: y for x, y in zip(list1, list2)}
* 1
列表和元组也可以运用双重推导（笛卡尔积）来创建。比如我们要生成一个二维坐标数组：

* coordinate = [(x, y) for x in range(2)
* for y in range(2)]
* print(coordinate)
* # 结果
* # [(0, 0), (0, 1), (1, 0), (1, 1)]
* 1
* 2
* 3
* 4
* 5
6.枚举元素

对于列表，集合，集合都可以运用for…in…来进行枚举

* set1 = {'name', 'age', 'sex'}
*
* for tmp in set1:
* print(tmp)
*
* # 结果
* # name
* # age
* # sex
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
* 9
有时候，我们需要用到元素的索引：

* index = 0
* for tmp in set1:
* print(tmp, index)
* index += 1
* 1
* 2
* 3
* 4
这样写太过于冗余，我可以用enumerate()函数来帮组我们实现：

* for index, tmp in enumerate(set1):
* print(tmp, index)
* 1
* 2
效果是一样的，可这样看起来更加简洁了

而对于字典，我们要枚举时就有点麻烦。不过还好，字典的方法中有三个方法帮助我们解决这个问题：

操作解释
adict.keys() 返回一个包含字典所有KEY的列表；
adict.values() 返回一个包含字典所有value的列表；
adict.items() 返回一个包含所有（键，值）元祖的列表；
示例：

* list1 = ['name', 'age', 'sex']
* list2 = ['kyda', 19, 'man']
*
* ID = {x: y for x, y in zip(list1, list2)}
* for tmp in ID.items():
* print(tmp)
* # 结果：
* # ('age', 19)
* # ('sex', 'man')
* # ('name', 'kyda')

转载地址 http://blog.csdn.net/weixin_37720172/article/details/78769301

<> 一.前言

一直想写写这四种类型的相同点，与不同点在哪里，以及在什么情况下应该使用哪种类型。无奈水平不够，怕写出来不够深刻，所以一直拖着。今天想了想还是写出来吧，如果以后还有新的见解或者技巧我会继续更上去的。

<> <>二.列表（list）

具有以下特点：
1.可以用list()函数或者方括号[]创建，元素之间用逗号’,‘’分隔。
2.列表的元素不需要具有相同的类型
3.使用索引来访问元素
4.可切片

* # 可用list()函数建立
* list1 = list((1, 2))
* # 用[]建立，可包含不同数据类型
* list2 = [1, 3, 'hello', 3.5]
* # 可用下标访问
* print(list1[1])
* # 切片
* print(list2[1:3])
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
结果：

* 2
* [3, 'hello']
* 1
* 2
方法:

操作解释
list.append(): 追加成员
list.count(x): 计算列表中参数x出现的次数
list.extend(L): 向列表中追加另一个列表L
list.index(x): 获得参数x在列表中的位置
list.insert(): 向列表中插入数据
list.pop(): 删除列表中的成员（通过下标删除）
list.remove(): 删除列表中的成员（直接删除）
list.reverse(): 将列表中成员的顺序颠倒
list.sort(): 将列表中成员排序
<> <>三.元组

元组跟列表很像，只不过元组用小括号来实现(),这里要区分好和生成器
<http://blog.csdn.net/weixin_37720172/article/details/78482291>的区别，两者都可用小括号来实现的

具有以下特点：
1.可以用tuple()函数或者方括号()创建，元素之间用逗号’,‘’分隔。
2.元组的元素不需要具有相同的类型
3.使用索引来访问元素
4.可切片
5.元素的值一旦创建就不可修改!!!!!(这是区别与列表的一个特征）

* # 可用tuple()函数创建
* tuple1 = tuple([1, 2])
* # 用()建立，可包含不同数据类型
* tuple2 = (1, 3, 'hello', 3.5)
* # 可用下标访问
* print(tuple1[1])
* # 可切片
* print(tuple2[1:3])
* # 不可以修改元素
* tuple1[1] = 10
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
* 9
* 10
结果：

* 2
* (3, 'hello')
* TypeError: 'tuple' object does not support item assignment
* 1
* 2
* 3
可进行的操作:元组由于它的不可变性（第五点特点），相比列表的操作少了很多，只保留了index()，count()函数，用法同列表。

当然也可以用内置函数来对他进行操作，这些内置函数对于列表也适用。

操作解释
cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(seq) 将列表转换为元组。
上面第五点在列表中的操作为（参考上面示例代码的第一点）：

操作解释
list(seq) 将元组转换为列表。
<> <>四.字典(Dictionary)

字典是另一种可变容器模型，且可存储任意类型对象。

具有以下特点：
1.元素由键（key）和值（value）组成
2.可以用dict()函数或者方括号()创建，元素之间用逗号’,‘’分隔，键与值之间用冒号”:”隔开
3.键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组
4.使用键（key）来访问元素

* # 用dict()函数创建
* dict1 = dict([('name', 'kyda'), ('e', 10)])
* # 用{}创建
* dict2 = {'name': 'lin', 'age': 21}
* print(dict1)
* # 使用键（key）来访问元素
* print(dict2['name'])
* # 使用键（key）来访问元素，并修改元素的值
* dict2['age'] = 23
* print(dict2)
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
* 9
* 10
结果：

* (3, 'hello')
* {'name': 'kyda', 'age': 10}
* lin
* {'name': 'lin', 'age': 23}
* 1
* 2
* 3
* 4
字典的方法:

操作解释
adict.keys() 返回一个包含字典所有KEY的列表；
adict.values() 返回一个包含字典所有value的列表；
adict.items() 返回一个包含所有（键，值）元祖的列表；
adict.clear() 删除字典中的所有项或元素；
adict.copy() 返回一个字典浅拷贝的副本；
adict.fromkeys(seq, val=None)
创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值（默认为None）；
adict.get(key, default = None)
返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）；
adict.has_key(key) 如果key在字典中，返回True，否则返回False。现在用 in 、 not in；
adict.iteritems() adict.iterkeys() adict.itervalues()
与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表；
adict.pop(key[,default])
和get方法相似。如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发keyerror异常；
adict.setdefault(key, default=None) 和set()方法相似，但如果字典中不存在Key键，由 adict[key] =
default 为它赋值；
adict.update(bdict) 将字典bdict的键值对添加到字典adict中。
<> <>五.集合(set)

具有以下特点：
1.可以用set()函数或者方括号{}创建，元素之间用逗号”,”分隔。
2.与字典相比少了键
3.不可索引，不可切片
4.不可以有重复元素

* # 两种方法创建
* set1 = set('kydaa')
* set2 = {'abc', 'jaja', 'abc', 'kyda'}
* print(set1)
* print(set2)
* 1
* 2
* 3
* 4
* 5
结果：自动将重复元素去除

* {'a', 'y', 'd', 'k'}
* {'jaja', 'abc', 'kyda'}
* 1
* 2
集合的方法:

操作解释
s.issubset(t)，s <= t 测试是否 s 中的每一个元素都在 t 中
s.issuperset(t)，s >= t 测试是否 t 中的每一个元素都在 s 中
s.union(t)，s | t 返回一个新的 set 包含 s 和 t 中的每一个元素
s.intersection(t)，s & t 返回一个新的 set 包含 s 和 t 中的公共元素
s.difference(t),s - t 返回一个新的 set 包含 s 中有但是 t 中没有的元素
s.symmetric_difference(t),s ^ t 返回一个新的 set 包含 s 和 t 中不重复的元素
s.copy() 返回 set “s”的一个浅复制
<> <>六.同异

1.列表和元组

列表和元组有很多相似的地方，操作也差不多。不过列表是可变序列，元组为不可变序列。
也就是说列表主要用于对象长度不可知的情况下，而元组用于对象长度已知的情况下，而且元组元素一旦创建变就不可修改。
例如我们在打开一个文本时，并不知道里面有多少行文字，所以用列表来保存。

* with open('test.txt', 'r') as f:
* print(f.readlines())
* # 结果：
* # ['hello world\n', 'hi kyda\n', 'this is my program']
* 1
* 2
* 3
* 4
而我们在储存一个人的信息（名字，年龄，性别，假定只需要这三种信息，所以对象长度为3）的时候，就可以用元组来实现。

* id = ('kyda', 19, 'man')
* print(id)
* # 结果：
* # ('kyda', 19, 'man')
* 1
* 2
* 3
* 4
2.字典
字典主要应用于需要对元素进行标记的对象，这样在使用的时候便不必记住元素列表中或者元组中的位置，只需要利用键来进行访问对象中相应的值。

* id = {'name': 'kyda', 'age': 19, ‘sex': 'man')
* print(id['age'])
* # 结果：
* # 19
* 1
* 2
* 3
* 4
3.集合
集合中的元素不可重复的特点使它被拿来去重
。比如我在爬去糗事百科全站的文章链接(存放与列表中）的时候，不可避免的会遇到重复的链接。这是我们只需将列表转换为集合便能有效的去除重复部分。
比如上面的例程。

4.在海量数据中查找元素时，最好将数据创建为字典，或者是集合

这是由于字典和集合背后的查找原理是散列（哈希）表。由于散列表在查找元素时的时间复杂度基本是O(1),这使查找时间很短。

在我的一篇博客专门实验了列表，元组，字典，集合在查找元素时所用的时间：
Python进阶（八）：in的详解
<http://blog.csdn.net/weixin_37720172/article/details/78636314>

5.灵活运用推导来创建
推导可以说是python最灵活的特性之一。
例子：
list1 = [x for x in range(1, 10)]
* 1
元组和集合都可以用上面的推导方式进行简单创建

对于字典来说我们也可以运用双重推导（笛卡尔积）来创建：

* list1 = ['name', 'age', 'sex']
* list2 = ['kyda', 19, 'man']
*
* ID = {x: y for x in list1 for y in list2}
* print(ID)
* # 结果
* # {'name': 'man', 'age': 'man', 'sex': 'man'}
* 1
* 2
* 3
* 4
* 5
* 6
* 7
当然上面还可以运用zip()函数简化为：
ID = {x: y for x, y in zip(list1, list2)}
* 1
列表和元组也可以运用双重推导（笛卡尔积）来创建。比如我们要生成一个二维坐标数组：

* coordinate = [(x, y) for x in range(2)
* for y in range(2)]
* print(coordinate)
* # 结果
* # [(0, 0), (0, 1), (1, 0), (1, 1)]
* 1
* 2
* 3
* 4
* 5
6.枚举元素

对于列表，集合，集合都可以运用for…in…来进行枚举

* set1 = {'name', 'age', 'sex'}
*
* for tmp in set1:
* print(tmp)
*
* # 结果
* # name
* # age
* # sex
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
* 9
有时候，我们需要用到元素的索引：

* index = 0
* for tmp in set1:
* print(tmp, index)
* index += 1
* 1
* 2
* 3
* 4
这样写太过于冗余，我可以用enumerate()函数来帮组我们实现：

* for index, tmp in enumerate(set1):
* print(tmp, index)
* 1
* 2
效果是一样的，可这样看起来更加简洁了

而对于字典，我们要枚举时就有点麻烦。不过还好，字典的方法中有三个方法帮助我们解决这个问题：

操作解释
adict.keys() 返回一个包含字典所有KEY的列表；
adict.values() 返回一个包含字典所有value的列表；
adict.items() 返回一个包含所有（键，值）元祖的列表；
示例：

* list1 = ['name', 'age', 'sex']
* list2 = ['kyda', 19, 'man']
*
* ID = {x: y for x, y in zip(list1, list2)}
* for tmp in ID.items():
* print(tmp)
* # 结果：
* # ('age', 19)
* # ('sex', 'man')
* # ('name', 'kyda')

热门工具换一换