具有以下特点：
1.可以用list()函数或者方括号[]创建，元素之间用逗号’,‘’分隔。
2.列表的元素不需要具有相同的类型
3.使用索引来访问元素
4.可切片
-
# 可用list()函数建立
-
list1 =
list((
1,
2))
-
# 用[]建立，可包含不同数据类型
-
list2 = [
1,
3,
'hello',
3.5]
-
# 可用下标访问
-
print(list1[
1])
-
# 切片
-
print(list2[
1:
3])
- 1
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
结果：
-
2
-
[
3,
'hello']
- 1
- 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(): | 将列表中成员排序 |
二.元组
元组跟列表很像，只不过元组用小括号来实现(),这里要区分好和生成器的区别，两者都可用小括号来实现的
具有以下特点：
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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
结果：
-
2
-
(
3,
'hello')
-
TypeError:
'tuple'
object does
not support
item assignment
- 1
- 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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
结果：
-
(
3,
'hello')
-
{
'name':
'kyda',
'age':
10}
-
lin
-
{
'name':
'lin',
'age':
23}
- 1
- 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
- 1
- 2
- 3
- 4
- 5
结果：自动将重复元素去除
-
{'a', 'y', 'd', 'k'}
-
{'jaja', 'abc', 'kyda'}
- 1
- 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
- 1
- 2
- 3
- 4
而我们在储存一个人的信息（名字，年龄，性别，假定只需要这三种信息，所以对象长度为3）的时候，就可以用元组来实现。
-
id = (
'kyda',
19,
'man')
-
print(id)
-
#
结果：
-
#
(
'kyda'
,
19
,
'man'
)
- 1
- 1
- 2
- 3
- 4
2.字典
字典主要应用于需要对元素进行标记的对象，这样在使用的时候便不必记住元素列表中或者元组中的位置，只需要利用键来进行访问对象中相应的值。
-
id = {
'name':
'kyda',
'age':
19, ‘sex
': 'man
')
-
print(id['age
'])
-
# 结果：
-
# 19
- 1
- 1
- 2
- 3
- 4
3.集合
集合中的元素不可重复的特点使它被拿来去重。比如我在爬去糗事百科全站的文章链接(存放与列表中）的时候，不可避免的会遇到重复的链接。这是我们只需将列表转换为集合便能有效的去除重复部分。
比如上面的例程。
4.在海量数据中查找元素时，最好将数据创建为字典，或者是集合
这是由于字典和集合背后的查找原理是散列（哈希）表。由于散列表在查找元素时的时间复杂度基本是O(1),这使查找时间很短。
在我的一篇博客专门实验了列表，元组，字典，集合在查找元素时所用的时间：
Python进阶（八）：in的详解
5.灵活运用推导来创建
推导可以说是python最灵活的特性之一。
例子：
list1 = [x for x in range(1, 10)]
- 1
- 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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
当然上面还可以运用zip()函数简化为：
ID = {x: y for x, y in zip(list1, list2)}
- 1
- 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
- 1
- 2
- 3
- 4
- 5
6.枚举元素
对于列表， 集合，集合都可以运用for…in…来进行枚举
-
set1 = {
'name',
'age',
'sex'}
-
-
for tmp
in set1:
-
print(tmp)
-
-
# 结果
-
# name
-
# age
-
# sex
- 1
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
有时候，我们需要用到元素的索引：
-
index =
0
-
for tmp in set1:
-
print(tmp,
index)
-
index +=
1
- 1
- 1
- 2
- 3
- 4
这样写太过于冗余，我可以用enumerate()函数来帮组我们实现：
-
for
index, tmp in enumerate(set1):
-
print(tmp,
index)
- 1
- 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'
)
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
