4.4. 列表和元组

列表可以理解为一组数据，这组数据里可以包含不同的类型，可以往列表里增加数据，也可以删除，同时列表是可迭代的，也就是说可以用for循环去遍历。元组和列表基本一样，唯一不一样的是元组定义好之后就不能变了，不能增加也不能删除，下面我们介绍一下常见用法

4.4.1. 定义一个列表

l1 = []  # 定义一个空列表
l2 = [1, 2, 3, 4, 5]  # 定义一个列表,里面包含同种类型的元素
l3 = [1, 'a', None, 2.1, int]  # 定义一个列表,里面包含不同类型的元素

4.4.2. append:向列表未尾增加元素

l1 = [1, 2, 3, 4, 5]
l1.append(6)
print(l1)

输出为:

[1, 2, 3, 4, 5, 6]

4.4.3. insert:加入到索引为1的位置

l1 = [1, 2, 3, 4, 5]
l1.insert('10',1)
print(l1)

输出为:

[1,'10', 2, 3, 4, 5, 6]

4.4.4. pop:移除列表最后一个元素，并返回该元素

l1 = [1, 2, 3, 4, 5]
poped_element = l1.pop()
print(poped_element)
print(l1)

输出为:

5
[1, 2, 3, 4]

4.4.5. 其他移除方法

fruit = ['apple','pear','grape','orange']
fruit.remove('peach') #删除指定元素

print(fruit)

输出为:

['apple', 'pear', 'grape', 'orange']
::

del fruit[2] #删除指定的索引 print(fruit)

输出为:

['apple', 'pear']

4.4.6. count:对其中的某个元素计数

l1 = [1, 1, 2, 3, 4, 5]
print(l1.count(1))

输出为:

2

4.4.7. sort:排序

l1 = [1, 5, 2, 3, 4, 0]
l1.sort()
print(l1)

输出为:

[0, 1, 2, 3, 4, 5]

4.4.8. reverse:倒置列表

l1 = ['a', 'b', 'c', 'd']
l1.reverse()
print(l1)

输出为:

['d', 'c', 'b', 'a']

4.4.9. index:查找其中某一个元素的位置

该方法有三个参数，index(v, i, j)，其中第一个为要查找的元素，第二个，第三个默认可以不用传，第二个参数是从第几个元素开始查找，第三个参数是查找到第几个元素结束:

l1 = [1, 5, 2, 3, 4, 0, 1]
print(l1.index(1))
print(l1.index(1, 1))
print(l1.index(1, 1, 5))

输出为:

0
6
Traceback (most recent call last):
  File "/Users/sunhui/PycharmProjects/ps/a.py", line 7, in <module>
    print(l1.index(1, 1, 5))
ValueError: 1 is not in list

4.4.10. extend:扩展列表

这个方法可以把一个列表拼接到另一个列表的后面:

l1 = [1, 5, 2, 3, 4, 0, 1]
l2 = ('a', 'b', 'c')  # l2只要是可迭代对象就行
l1.extend(l2)
print(l1)

输出结果为:

[1, 5, 2, 3, 4, 0, 1, 'a', 'b', 'c']

4.4.11. 列表相加

两个列表直接相加可以返回拼接后的列表:

l1 = [1, 2, 3]
l2 = ['a', 'b', 'c']
l3 = l1 + l2

print(l3)

输出为:

[1, 2, 3, 'a', 'b', 'c']

4.4.12. 遍历列表

使用for循环可以遍历列表:

l1 = [1, 2, 3, 4, 5]
for i in l1:
    print(i)

输出为:

1
2
3
4
5

4.4.13. 列表去重

list1 = [1,2,3,4,2,1]
list2 = list(set(list1))

输出为:

[1, 2, 3, 4]

4.4.14. 元组

因元组不能改，所以元组可以使用的方法比较少，常用的count和index，用法和列表是一样的:

In [9]: t1.
            t1.count
            t1.index

还有一些别的用法，如

  1. cmp(tuple1, tuple2) 比较两个元组元素 # python2。

  2. len(tuple) 计算元组元素个数。

  3. max(tuple) 返回元组中元素最大值。

  4. min(tuple) 返回元组中元素最小值。

  5. tuple(seq) 将列表转换为元组。

在python3中，取消了cmp的用法，需要比较元素可以引用operator模块:

>>> import operator
>>> a = (1,2)
>>> b = (1,3)
>>> c = (1,2)
>>> operator.eq(a, b)
False
>>> operator.eq(a, c)
True
>>>

4.4.15. 切片

还是先看一下下面的这个图，需要好好理解一下:

+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

l1 = ['p', 'y', 't', 'h', 'o', 'n']
print(l1[0])  # p
print(l1[5])  # n
print(l1[-1])  # n
print(l1[1:3])  # ['y', 't']
print(l1[-3:-1])  # ['h', 'o']
print(l1[3:])  # ['h', 'o', 'n']
print(l1[:-3])  # ['p', 'y', 't']
print(l1[::2])  # ['p', 't', 'o']

输出为:

p
n
n
['y', 't']
['h', 'o']
['h', 'o', 'n']
['p', 'y', 't']
['p', 't', 'o']

4.4.16. 元组和列表的区别

在python面试时，进程会被问到元组和列表的区别，大部分人只会回答：列表是可变的，元组是不可变的。这个回答显然过于简单了。我这边简单的整理了一下他们的区别，希望对大家有所帮助：

  • 列表是动态的，而元组是静态的

长度大小不固定，可以随意的增加、删减或者改变元素；而元组是静态的，长度大小固定，无法增加删减或者改变

  • 列表和元组的存储方式有差异

l = [1, 2, 3]
l.__sizeof__()
64
tup = (1, 2, 3)
tup.__sizeof__()
48

列表和元组，放置了相同的元素，但是元组的存储空间，却比列表要少16字节。 事实上，由于列表是动态的，所以它需要存储指针，来指向对应的元素（上述例子中，对于int型，8 字节）。另外，由于列表可变，所以需要额外存储已经分配的长度大小（8 字节），这样才可以实时追踪列表空间的使用情况，当空间不足时，及时分配额外空间。但是对于元组，情况就不同了。元组长度大小固定，元素不可变，所以存储空间固定。

  • 元组的性能略优于列表

列表和元组存储方式的差异，元组要比列表更加轻量级一些，所以总体上来说，元组的性能速度要略优于列表。 另外，Python 会在后台，对静态数据做一些资源缓存（resource caching）。通常来说，因为垃圾回收机制的存在，如果一些变量不被使用了，Python 就会回收它们所占用的内存，返还给操作系统，以便其他变量或其他应用使用。 但是对于一些静态变量，如元组，如果它不被使用并且占用空间不大时，Python 会暂时缓存这部分内存。这样，下次我们再创建同样大小的元组时，Python 就可以不用再向操作系统发出请求，去寻找内存，而是可以直接分配之前缓存的内存空间，这样就能大大加快程序的运行速度。

  • 列表是线程不安全的，元组是线程安全的

  • 列表不可哈希，元祖可哈希