列表 []

目录

• 一、关于列表
• 二、对象创建 & 赋值
  • [] 空列表
  • 列表推导式
    • 方法调用
    • 条件过滤
    • 用两个变量来生成 list
  • 使用 range
  • 字符串和列表
    • 应用
• 属性
• 查找遍历
  • 索引
  • 使用for循环遍历
  • 使用next()遍历
  • in/not in 是否存在
• 增加 & 删除
  • append 添加 & pop 删除
  • del 删除
• 运算
  • 身份运算 is & ==
  • 数学运算
  • 逻辑运算
• 列表运算符
• 函数
  • 1、Python 内置函数
  • 2、列表自身方法
    • 将列表当做堆栈使用
    • 将列表当作队列使用
• 嵌套列表

---

一、关于列表

列表对象的本质是一个有序的、可迭代、可切片、可变的序列，内部元素支持任意对象。

是写在方括号 [] 之间、用逗号分隔开的元素列表。

# 声明一个列表对象的变量l
>>> l = ['l', 'i', 'm', 'a', 'n', 'm', 'a', 'n']
>>> type(l)
<type 'list'>

# 查看list类型的定义
>>> help(list)

# 查看list类型的属性和方法
>>> dir(list)

# 让Python2中也可以兼容Python3的print函数用法
>>> from __future__ import print_function

---

二、对象创建 & 赋值

赋值运算：向内存申请一空闲内存单元存储列表，然后将变量名指向此内存单元首地址，就可通过变量名操作此内存单元数据。

>>> l = ['5', '2', '1']

# 方式1: 通过字面量形式创建
>>> l = ['5', '2', '1']

# 方式2: 通过类型创建
"""
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
"""
>>> l = list('521')
['5', '2', '1']

---

[] 空列表

>>> list()
[]

---

列表推导式

英文全称：List Comprehensions。

列表推导式提供了从 序列 创建列表的简单途径。

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]

>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]

---

方法调用

# 这里调用 .strip() 方法去除前后空格
>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']

# 使用 .lower() 将内容改为小写
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

# 使用复杂表达式或嵌套函数
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

---

条件过滤

>>> [3*x for x in vec if x > 3]
[12, 18]

>>> [3*x for x in vec if x < 2]
[]

---

以下是一些关于循环和其它技巧的演示：

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]

>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]

>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]

---

用两个变量来生成 list

for循环其实可以同时使用两个甚至多个变量，比如dict的items()可以同时迭代key和value：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> for k, v in d.items():
...     print(k, '=', v)
...
y = B
x = A
z = C

---

因此，列表生成式也可以使用两个变量来生成list：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

---

使用 range

set[x:y:z] 是一个完整的函数

a = range(0,5)
type(a)   # range
print(a)  # range(0, 3)
 
>>> l = list(range(5))
[0, 1, 2, 3, 4]

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

---

字符串和列表

>>> s = '123'
>>> s[::-1]  # 字符串反向遍历
'321'

>>> s  # 不会改变原来的值
'123'

>>> list(s)
['1', '2', '3']

>>> list(s)[::1]
['1', '2', '3']

>>> ''.join(list(s)[::1])
'123'


# 使用列表的 reverse 方法
>>> a =  list(s)
>>> a
['1', '2', '3']
>>> a.reverse()
>>> a
['3', '2', '1']

---

应用

列出目录名：列出当前目录下的所有文件和目录名，可以通过一行代码实现：

>>> import os # 导入os模块，模块的概念后面讲到
>>> [d for d in os.listdir('.')] # os.listdir可以列出文件和目录
['.ssh', '.Trash', 'Adlm', 'Applications', 'Desktop', 'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures', 'Public', 'VirtualBox VMs', 'Workspace']

---

属性

>>>len([1, 2, 3])
3

>>> max(['d', '2', 'a']) 
'd'

>>> max(['d', '2', 'ag'])
'd'

---

查找遍历

索引

>>> a=['Google', 'Runoob', 'Taobao']
>>> a[2]
'Taobao'

>>> a[-2]
'Runoob'

>>> a[1:]
['Runoob', 'Taobao']

---

使用for循环遍历

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
...

---

使用next()遍历

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
...
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

---

in/not in 是否存在

>>>3 in [1, 2, 3]
True

>>> for x in [1, 2, 3]: print(x, end=" ")

---

增加 & 删除

---

append 添加 & pop 删除

列表是可变的：可以不改变物理地址指向的前提下，实现原地修改。方法：append，pop。

# 添加对象到最后
>>> l.append('!')
>>> l
['a', 'b', 'c', 'd', '!']

>>> id(l)
140550742839456

# 从列表中删除指定索引位置的对象,L.pop([index]) -> item,默认index的值为-1
>>> l.pop(-1)
'!'
>>> l
['a', 'b', 'c', 'd']
>>> id(l)
140550742839456

>>> l = ['5', '2', '1']

# .append(object)
>>> l.append('!')
>>> l
['5', '2', '1', '!']

# .count(value)
>>> l.count('!')
1
>>> l.count('?')
0

# .extend(iterable)
>>> l.extend('1314')  # 自动切割了元素
>>> l
['5', '2', '1', '!', '1', '3', '1', '4']

# .index(value, [start, [stop]])  # 查找值出现在了哪个位置
>>> l.index('!')
3
>>> l.index('?')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: '?' is not in list

    
# .insert(index, object)
>>> l.insert(len(l), '?')
>>> l
['5', '2', '1', '!', '1', '3', '1', '4', '?']

# .pop([index])
>>> l.pop(-1)
'?'
>>> l.pop(len(l))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: pop index out of range
>>> l
['5', '2', '1', '!', '1', '3', '1', '4']

---

# .remove(value)
>>> l.remove('!')
>>> l.remove('?')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> l
['5', '2', '1', '1', '3', '1', '4']
        
# .reverse()
>>> l.reverse()
>>> l
['4', '1', '3', '1', '1', '2', '5']

# .sort(cmp=None, key=None, reverse=False)
>>> l.sort(key=lambda i: i, reverse=True)
>>> l
['5', '4', '3', '2', '1', '1', '1']


>>> l = ['5', '2', '1', '1', '3', '1', '4']  
>>> 'x' in l and l.remove('x') # 加上这个判断，删除不存在的就不会报错
False

>>> '1' in l and l.remove('1')  # 只删除第一次找到的
>>> l
['5', '2', '1', '3', '1', '4']

---

del 删除

• 使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。

• 可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。例如：

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print("原始列表 : ", list)
del list[2]
print("删除第三个元素 : ", list)

以上实例输出结果：

原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

---

>>> a = [1, 2, 3, 4, 5, 6]
>>> del a[0]
>>> a
[2, 3, 4, 5, 6]

>>> a = [1, 2, 3, 4, 5, 6]
>>> del a[2:4]
>>> a
[1, 2, 5, 6]

# 删除全部
>>> del a[:]
>>> a
[]

---

也可以用 del 删除实体变量：

>>> del a

---

运算

---

身份运算 is & ==

常用于比较两个对象是否指向同一个 内存单元

is 比较地址，== 比较数值

>>> l is ['5', '2', '1']
False

>>> l  = ['5', '2', '1']
>>> l  ==  ['5', '2', '1']
True

---

数学运算

结果总是隐式转换为复杂类型

# 加法,可结合赋值运算+=
>>>[1, 2, 3] + [4, 5, 6] 
[1, 2, 3, 4, 5, 6]

>>> l = [1, 2, 3]
>>> l += [4, 5, 6] 
>>> l
[1, 2, 3, 4, 5, 6]

# 乘法,可结合赋值运算*=
>>> l * 2
[1, 2, 3, 1, 2, 3]

>>>['Hi!'] * 4 
['Hi!', 'Hi!', 'Hi!', 'Hi!']

---

逻辑运算

# 与, 都为真为真
>>> [] and l
[]

# 或, 一个真即真
>>> [] or l
['5', '2', '1']

# 非,总是隐式转换为布尔对象
>>> not l
False

由于列表对象为可变对象, + = / * = 操作的本质为向变量指向的原内存空间添加新的对象,所以指向的内存地址不变

---

列表运算符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

操作符	描述
+	组合
*	重复
[num]	索引
[:]	截取
in	元素是否存在于列表中
not in

---

函数

1、Python 内置函数

函数	说明
len(list)	列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表

---

2、列表自身方法

• . 开头是列表自身方法，非内置方法。

• 方法中 方括号[] 表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。

方法	描述
l.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
l.extend(l1)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = l1。
l.insert(i, x)	在指定位置插入一个元素，原地修改。
第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
l.remove(x)	删除列表中值为 x 的第一个元素，原地修改。如果没有这样的元素，就会返回 ValueError错误。
l.pop([i])	从列表的指定位置移除元素，并将其返回。
索引超出则抛出IndexError异常，index默认为-1( 索引超出则抛出IndexError异常，index默认为-1)
l.clear()	移除列表中的所有项，等于del a[:]。
l.index(value, [start, [stop]])	计算从start到stop中间value在列表中的索引值并返回,不存在抛出ValueError异常
l.count(x)	返回 x 在列表中出现的次数。
l.sort(cmp=None, key=None, reverse=False)	将列表按照key对应的函数排序，reverse是否倒序，原地修改
l.reverse()	将列表的元素倒序，原地修改
l.copy()	浅复制，等于a[:]。
l.index(value, [start, [stop]])	计算从start到stop中间value在列表中的索引值并返回,不存在抛出ValueError异常
l.insert(index, object)	将object插入列表中索引为index的位置,

---

将列表当做堆栈使用

append、pop

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。

---

将列表当作队列使用

append、popleft

也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> 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'])

---

嵌套列表

以下实例展示了3X4的矩阵列表：

>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]

---

以下实例将 3X4 的矩阵列表转换为 4X3 列表：

>>> [[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]]

---

另外一种实现方法：

>>> transposed = []
>>> for i in range(4):
...     # the following 3 lines implement the nested listcomp
...     transposed_row = []
...     for row in matrix:
...         transposed_row.append(row[i])
...     transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

---

---