Python学习笔记（五）元组与列表

元组

序列类型的Tuple（元组）对象，其元素具有顺序性但不能任意更改位置。

创建元组

使用小括号创建元组（Tuple）对象，它所存放的元素，同样使用索引来对应存放元素的位置。在Python中有时也能省略小括号。

>>> a = (12,34,56)
>>> type(a)
<class 'tuple'>
>>> a = 12,34,56
>>> type(a)
<class 'tuple'>

• tuple()函数

内置tuple()函数可将列表和字符串转换成元组，且只能转换可迭代对象，如果给与一般数值，就会发生TypeError。

• count()和index()方法

由于元组（tuple）不可变的特性，支持的方法只有count()和index()。用count()方法统计某个元素出现的次数，或者用index()方法获取某个元素第一次出现的索引编号。

>>> data.count(11)
2
>>> data.index(11)
0

• 读取元组元素

因为元素类型是可迭代的，所以可以用for/in循环

>>> tp = 12,34,56
>>> for item in tp:
	print(item, end = ' ')

12 34 56 

元组的相关操作

• Unpacking元素

>>> wd = 'ABC'
>>> a, b, c = wd
>>> print(a, b, c, end = ' ')
A B C 

有时会因程序的需求，将存放在元组（Tuple）中的元素快速拆分（Unpacking），在赋值给多个变量来使用。

• Tuple元素排序

>>> data = 23, 34, 67, 39
>>> sorted(data)
[23, 34, 39, 67]
>>> sorted(data, reverse = True)
[67, 39, 34, 23]
>>> data
(23, 34, 67, 39)

• 切片运算

>>> tp = 11, 22, 33, 44
>>> tp[1:3]
(22, 33)
>>> tp[-2:-1]
(33,)

列表

• 有序集合：任何元素都可以通过元素来呈现，只要按顺序排列即可。
• 具有索引值：通过索引就能获取某个元素的值，也支持切片运算。
• 长度不受限：列表对象可通过len()返回长度，其长度可长可短。
• 可变性：元组属于不可变序列，列表是可变的。

创建列表

>>> data = []
>>> type(data)
<class 'list'>

• append()方法和extend()方法

append()方法是将一个元素加到列表的最后。extend()方法强调的是有顺序的对象（可迭代的）。

>>> num1 = [11, 22]
>>> num2 = [33, 44]
>>> num2.extend(num1)
>>> num2
[33, 44, 11, 22]

>>> num3 = 11
>>> num2.extend(num3)
Traceback (most recent call last):
  File "<pyshell#36>", line 1, in <module>
    num2.extend(num3)
TypeError: 'int' object is not iterable
>>> num2.append(num3)
>>> num2
[33, 44, 11, 22, 11]

数据排序

在元组（Tuple）中，可以用内置函数sorted()的排序，列表中提供sort()方法进行排序。

data = [12,55,45,123]
data.sort()
print(data)

[12, 45, 55, 123]

data = ['Allen','Tom','Tim','Bob']
data.sort()
print(data)

['Allen', 'Bob', 'Tim', 'Tom']

在元组中使用sort()方法会弹出错误，若要在元组中使用sort()方法，必须进行显式转换。

>>> data = 23, 34, 45, 56
>>> data = list(data)
>>> data.sort()
>>> data
[23, 34, 45, 56]

• sorted()函数和sort()方法的不同

BIF的sorted()函数使用复制排序（copied sorting），按照用户指定的次序排序之后会返回一个已排序的副本，原有对象的次序并未改变。

使用列表（List）中提供的sort()方法，则是采用就地排序（in-place sorting），按照用户指定的顺序排序后，原有的列表元素也会改变。

列表推导式

推导式（Comprehension）可以将一个或多个迭代器聚集在一起，再以for循环作为条件测试。由于列表（List）对于元素的存放采用更开放的方式，因此编写程序代码更加简洁。

num = []
for item in range(5, 50):
    if item % 7 == 0:
        num.append(item)
print(num)

[7, 14, 21, 28, 35, 42, 49]

上述式子可以写得更为简洁：

print([item for item in range(5, 50)if(item % 7 == 0)])

二维表达式

序列中还可以含有序列，也成为矩阵（Matrixes），多维列表或嵌套列表。

• 创建矩阵

number = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

• 读取矩阵

number = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row, one in enumerate(number):
    print(row,' : ',end = ' ')
    for line in one:
        print(line, end = ' ')
    print()
else:
    print('end')

0  :  1 2 3 
1  :  4 5 6 
2  :  7 8 9 
end

• 内置函数zip()

同时遍历两个或更多的序列，使用zip()函数可以成对读取元素。

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

• 不规则列表

内置函数isinstance()

列表与复制

对于Python来说，只有对象（Object）和对象引用（Object Reference），所以复制的是对象和复制的对象引用会产生不同的结果。

• 浅复制（Shallow copy）：只复制对象引用，不复制对象本身。
• 深复制（Deep copy）：要调用copy模块的deepcopy方法来执行复制。

列表与浅复制

对于列表对象来说，下列方法可以实现浅复制：

• 使用“*”运算符。
• 使用切片运算
• 使用序列类型提供的copy方法，等同于切片运算的[:]。

• 浅复制——*运算符

>>> x = [12, 34]
>>> y = x * 2
>>> y
[12, 34, 12, 34]

• 浅复制——切片

>>> data = [34, 56, 78, 'abc']
>>> a = data[0 : 2]
>>> a
[34, 56]

• 调用列表的copy()方法

>>> a = [12, 34, [56, 78]]
>>> b = a[:]; c = a.copy() #相当于切片运算
>>> b; c             
[12, 34, [56, 78]]
[12, 34, [56, 78]]

copy模块的copy()方法

import copy
a = [12, 34, 56, 78]
b = copy.copy(a)
print(a == b)

True

deepcopy()方法复制对象本身

import copy
a = [12, [34, 56], 78, 90]
b = copy.deepcopy(a)
print(a == b)

深复制和浅复制

查找了描述文档之后，对于浅复制和深复制有更加清晰的定义

源代码： Lib/copy.py

Python中的赋值语句不复制对象，它们在目标和对象之间创建绑定。对于可变的或包含可变项的容器，有时需要一个副本，所以可以改变一个副本而不改变另一个。此模块提供通用的浅层和深层复制操作（如下所述）。
接口概要：

• copy.copy(x) : 返回x的浅拷贝。
• copy.deepcopy(x) : 返回x的深度副本。
• exception copy.error : 引发模块特定错误。

浅层和深层复制之间的区别仅与复合对象（包含其他对象，如列表或类实例的对象）有关：

浅拷贝构建一个新的复合对象，然后（尽可能地）将引用插入到原始对象中。
深拷贝构造一个新的复合对象，然后递归地在原始对象中找到的对象中插入副本。

对于浅拷贝操作，深拷贝操作通常不存在两个问题：

递归对象（直接或间接包含对自身引用的复合对象）可能导致递归循环。

因为深拷贝一切它可能拷贝太多，例如甚至应该在拷贝之间共享的管理数据结构。

deepcopy()函数通过以下方式避免了这些问题：

保持在当前复制过程中已经复制的对象的“备忘录”字典；和
让用户定义的类覆盖复制操作或复制的组件集。

最后

以上就是伶俐裙子为你收集整理的Python学习笔记（五）元组与列表的全部内容，希望文章能够帮你解决Python学习笔记（五）元组与列表所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。