ailearning/docs/da/012.md

# 列表

在**Python**中，列表是一个有序的序列。

列表用一对 `[]` 生成，中间的元素用 `,` 隔开，其中的元素不需要是同一类型，同时列表的长度也不固定。

In [1]:

```py
l = [1, 2.0, 'hello']
print l

```

```py
[1, 2.0, 'hello']

```

空列表可以用 `[]` 或者 `list()` 生成：

In [2]:

```py
empty_list = []
empty_list

```

Out[2]:

```py
[]
```

In [3]:

```py
empty_list = list()
empty_list

```

Out[3]:

```py
[]
```

## 列表操作

与字符串类似，列表也支持以下的操作：

### 长度

用 `len` 查看列表长度：

In [4]:

```py
len(l)

```

Out[4]:

```py
3
```

### 加法和乘法

列表加法，相当于将两个列表按顺序连接：

In [5]:

```py
a = [1, 2, 3]
b = [3.2, 'hello']
a + b

```

Out[5]:

```py
[1, 2, 3, 3.2, 'hello']
```

列表与整数相乘，相当于将列表重复相加：

In [6]:

```py
l * 2

```

Out[6]:

```py
[1, 2.0, 'hello', 1, 2.0, 'hello']
```

### 索引和分片

列表和字符串一样可以通过索引和分片来查看它的元素。

索引：

In [7]:

```py
a = [10, 11, 12, 13, 14]
a[0]

```

Out[7]:

```py
10
```

反向索引：

In [8]:

```py
a[-1]

```

Out[8]:

```py
14
```

分片：

In [9]:

```py
a[2:-1]

```

Out[9]:

```py
[12, 13]
```

与字符串不同的是，列表可以通过索引和分片来修改。

对于字符串，如果我们通过索引或者分片来修改，**Python**会报错：

In [10]:

```py
s = "hello world"
# 把开头的 h 改成大写
s[0] = 'H'

```

```py
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-10-844622ced67a> in <module>()
 1 s = "hello world"
 2 # 把开头的 h 改成大写
----> 3  s[0] = 'H'

TypeError: 'str' object does not support item assignment
```

而这种操作对于列表来说是可以的：

In [11]:

```py
a = [10, 11, 12, 13, 14]
a[0] = 100
print a

```

```py
[100, 11, 12, 13, 14]

```

这种赋值也适用于分片，例如，将列表的第2，3两个元素换掉：

In [12]:

```py
a[1:3] = [1, 2]
a

```

Out[12]:

```py
[100, 1, 2, 13, 14]
```

事实上，对于连续的分片（即步长为 `1` ），**Python**采用的是整段替换的方法，两者的元素个数并不需要相同，例如，将 `[11,12]` 替换为 `[1,2,3,4]`：

In [13]:

```py
a = [10, 11, 12, 13, 14]
a[1:3] = [1, 2, 3, 4]
print a

```

```py
[10, 1, 2, 3, 4, 13, 14]

```

这意味着，可以用这种方法来删除列表中一个连续的分片：

In [14]:

```py
a = [10, 1, 2, 11, 12]
print a[1:3]
a[1:3] = []
print a

```

```py
[1, 2]
[10, 11, 12]

```

对于不连续（间隔step不为1）的片段进行修改时，两者的元素数目必须一致：

In [15]:

```py
a = [10, 11, 12, 13, 14]
a[::2] = [1, 2, 3]
a

```

Out[15]:

```py
[1, 11, 2, 13, 3]
```

否则会报错：

In [16]:

```py
a[::2] = []

```

```py
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-16-7b6c4e43a9fa> in <module>()
----> 1  a[::2] = []

ValueError: attempt to assign sequence of size 0 to extended slice of size 3
```

### 删除元素

**Python**提供了删除列表中元素的方法 'del'。

删除列表中的第一个元素：

In [17]:

```py
a = [1002, 'a', 'b', 'c']
del a[0]
print a

```

```py
['a', 'b', 'c']

```

删除第2到最后一个元素：

In [18]:

```py
a = [1002, 'a', 'b', 'c']
del a[1:]
a

```

Out[18]:

```py
[1002]
```

删除间隔的元素：

In [19]:

```py
a = ['a', 1, 'b', 2, 'c']
del a[::2]
a

```

Out[19]:

```py
[1, 2]
```

### 测试从属关系

用 `in` 来看某个元素是否在某个序列（不仅仅是列表）中，用not in来判断是否不在某个序列中。

In [20]:

```py
a = [10, 11, 12, 13, 14]
print 10 in a
print 10 not in a

```

```py
True
False

```

也可以作用于字符串：

In [21]:

```py
s = 'hello world'
print 'he' in s
print 'world' not in s

```

```py
True
False

```

列表中可以包含各种对象，甚至可以包含列表：

In [22]:

```py
a = [10, 'eleven', [12, 13]]
a[2]

```

Out[22]:

```py
[12, 13]
```

a[2]是列表，可以对它再进行索引：

In [23]:

```py
a[2][1]

```

Out[23]:

```py
13
```

## 列表方法

### 不改变列表的方法

#### 列表中某个元素个数count

`l.count(ob)` 返回列表中元素 `ob` 出现的次数。

In [24]:

```py
a = [11, 12, 13, 12, 11]
a.count(11)

```

Out[24]:

```py
2
```

#### 列表中某个元素位置index

`l.index(ob)` 返回列表中元素 `ob` 第一次出现的索引位置，如果 `ob` 不在 `l` 中会报错。

In [25]:

```py
a.index(12)

```

Out[25]:

```py
1
```

不存在的元素会报错：

In [26]:

```py
a.index(1)

```

```py
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-26-ed16592c2786> in <module>()
----> 1  a.index(1)

ValueError: 1 is not in list
```

### 改变列表的方法

#### 向列表添加单个元素

`l.append(ob)` 将元素 `ob` 添加到列表 `l` 的最后。

In [27]:

```py
a = [10, 11, 12]
a.append(11)
print a

```

```py
[10, 11, 12, 11]

```

append每次只添加一个元素，并不会因为这个元素是序列而将其展开：

In [28]:

```py
a.append([11, 12])
print a

```

```py
[10, 11, 12, 11, [11, 12]]

```

#### 向列表添加序列

`l.extend(lst)` 将序列 `lst` 的元素依次添加到列表 `l` 的最后，作用相当于 `l += lst`。

In [29]:

```py
a = [10, 11, 12, 11]
a.extend([1, 2])
print a

```

```py
[10, 11, 12, 11, 1, 2]

```

#### 插入元素

`l.insert(idx, ob)` 在索引 `idx` 处插入 `ob` ，之后的元素依次后移。

In [30]:

```py
a = [10, 11, 12, 13, 11]
# 在索引 3 插入 'a'
a.insert(3, 'a')
print a

```

```py
[10, 11, 12, 'a', 13, 11]

```

#### 移除元素

`l.remove(ob)` 会将列表中第一个出现的 `ob` 删除，如果 `ob` 不在 `l` 中会报错。

In [31]:

```py
a = [10, 11, 12, 13, 11]
# 移除了第一个 11
a.remove(11)
print a

```

```py
[10, 12, 13, 11]

```

#### 弹出元素

`l.pop(idx)` 会将索引 `idx` 处的元素删除，并返回这个元素。

In [32]:

```py
a = [10, 11, 12, 13, 11]
a.pop(2)

```

Out[32]:

```py
12
```

#### 排序

`l.sort()` 会将列表中的元素按照一定的规则排序：

In [33]:

```py
a = [10, 1, 11, 13, 11, 2]
a.sort()
print a

```

```py
[1, 2, 10, 11, 11, 13]

```

如果不想改变原来列表中的值，可以使用 `sorted` 函数：

In [34]:

```py
a = [10, 1, 11, 13, 11, 2]
b = sorted(a)
print a
print b

```

```py
[10, 1, 11, 13, 11, 2]
[1, 2, 10, 11, 11, 13]

```

#### 列表反向

`l.reverse()` 会将列表中的元素从后向前排列。

In [35]:

```py
a = [1, 2, 3, 4, 5, 6]
a.reverse()
print a

```

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

```

如果不想改变原来列表中的值，可以使用这样的方法：

In [36]:

```py
a = [1, 2, 3, 4, 5, 6]
b = a[::-1]
print a
print b

```

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

```

如果不清楚用法，可以查看帮助：

In [ ]:

```py
a.sort?

```