python使用笔记

列表

特性

列表数据类型还有很多的方法。这里是列表对象方法的清单：

list.append(x)

在列表的末尾添加一个元素。相当于 a[len(a):] = [x] 。

list.extend(iterable)

使用可迭代对象中的所有元素来扩展列表。相当于 a[len(a):] = iterable 。

list.insert(i, x)

在给定的位置插入一个元素。第一个参数是要插入的元素的索引，所以 a.insert(0, x) 插入列表头部， a.insert(len(a), x) 等同于 a.append(x) 。

list.remove(x)

移除列表中第一个值为 x 的元素。如果没有这样的元素，则抛出 ValueError 异常。

list.pop([i])

删除列表中给定位置的元素并返回它。如果没有给定位置，a.pop() 将会删除并返回列表中的最后一个元素。（ 方法签名中 i 两边的方括号表示这个参数是可选的，而不是要你输入方括号。你会在 Python 参考库中经常看到这种表示方法)。

list.clear()

删除列表中所有的元素。相当于 del a[:] 。

list.index(x[, start[, end]])

返回列表中第一个值为 x 的元素的从零开始的索引。如果没有这样的元素将会抛出 ValueError 异常。

可选参数 start 和 end 是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 start 参数。

list.count(x)

返回元素 x 在列表中出现的次数。

list.sort(key=None, reverse=False)

对列表中的元素进行排序（参数可用于自定义排序，解释请参见 sorted()）。

list.reverse()

反转列表中的元素。

list.copy()

返回列表的一个浅拷贝。相当于 a[:] 。

附： 浅拷贝VS 深拷贝
浅拷贝拷贝出来的a对象是引用x和y，当修改x或y的值时，a也会改变；
深拷贝会把里面的元素也重新拷贝一份，拷贝了一份x和y的值相等的两个元素，修改x和y的值，不会对b产生影响

作为栈、队列

栈是后进先出的，列表的 pop() 和append() 方法记为出栈和压栈

队列是先进先出的，列表作为队列较为低效，但引入collections.deque则可以快速从两端操作

>>>from collections import deque
>>>queue = deque(["Eric", "John", "Michael"])
>>>queue.append("Terry")
>>>queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

推导式

demo1

squares = list(map(lambda x: x**2, range(10)))

等价于

squares = [x**2 for x in range(10)]

demo2

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

等价于

>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

如果表达式是一个元组（例如上面的 (x, y)），那么就必须加上括号,demo

>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

不加括号会报错

推导式的嵌套

3 4的列表转置为4 3

>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

等价于

>>> transposed = []
>>> for i in range(4):
...     transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

使用内置函数更简洁：

>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

del

del方法可以按照索引引出元素，也可以清空列表
注意： del a 和 del a[:] 不同，前者将删除整个a变量

比较操作

逻辑运算

比较操作可以传递。例如 a < b == c 会校验是否 a 小于 b 并且 b 等于 c。

• 比较操作可以通过布尔运算符 and 和 or 来组合，并且比较操作（或其他任何布尔运算）的结果都可以用 not 来取反
• 这些操作符的优先级低于比较操作符；在它们之中，not 优先级最高， or 优先级最低
  因此 A and not B or C 等价于 (A and (not B)) or C。和之前一样，你也可以在这种式子里使用圆括号

布尔运算符 and 和 or 也被称为 短路 运算符：它们的参数从左至右解析，一旦可以确定结果解析就会停止。
例如，如果 A 和 C 为真而 B 为假，那么 A and B and C 不会解析 C。
当作用于普通值而非布尔值时，短路操作符的返回值通常是最后一个变量。

序列比较

序列对象可以与相同类型的其他对象比较。
它们使用 字典顺序 进行比较：

• 首先比较两个序列的第一个元素，如果不同，那么这就决定了比较操作的结果。
  如果它们相同，就再比较每个序列的第二个元素，以此类推，直到有一个序列被耗尽。
• 如果要比较的两个元素本身就是相同类型的序列，那么就递归进行字典顺序比较。
• 如果两个序列中所有的元素都相等，那么我们认为这两个序列相等。
• 如果一个序列是另一个序列的初始子序列，那么短序列就小于另一个。
• 字典顺序对字符串来说，是使用单字符的 Unicode 码的顺序。

‘ABC’ < ‘C’ < ‘Pascal’ < ‘Python’

(1, 2, (‘aa’, ‘ab’)) < (1, 2, (‘abc’, ‘a’), 4)