轻松初探 Python 篇(四)—list tuple ra

发表于

这是「AI 学习之路」的第 4 篇，「Python 学习」的第 4 篇
小之的公众号 : WeaponZhi

今天的主题是 Python 的序列类型(Sequence Types)，内容很多，干货很足，也是我们平时经常使用的，大家准备好小板凳纸笔吧！

注意，我不准备再将循环语句和条件语句方面的知识了，比较简单，每种语言这方面的写法区分不大，有兴趣的大家可以自行去查阅一下。

list

list 是一种有序集合，在很多语言里面都有支持，像 Java 中的 List ，可以简单理解 List 是一个顺序表，可以对它进行添加和删除元素的操作，但和 Java 不同，Java 的 List 并不是内置的，它的一些实现类比如 ArrayList 是用 Java 代码另外实现的，而 list 在 Python 中是一种内置数据类型，它是和语言本身是一体的。

list 的使用很简单，用方括号[]表示，内部的元素用逗号「,」区分。比如，我们用 list 来表示我国的几个城市的名字：

1
2
3
复制代码>>> city = ['北京','上海','天津','重庆']
>>> city
['北京','上海','天津','重庆']

我们可以用索引来访问 list 中指定位置的元素，这部分有点像 Java 的数组

1
2
3
4
5
6
7
8
复制代码>>> city[0]
'北京'
>>> city[3]
'重庆'
>>> len(city)
4
>>> city[4]
IndexError:list index out of range

这里要注意下，索引是从 0 开始，而不是从 1，所以最后一个重庆的索引实际上是 3，当我们试图访问位置为 4 的时候，就会产生索引越界的错误。

通过 len() 函数可以获取 list 的长度，所以实际上 list 的最后一个元素的索引是len(city)-1。

空的 list 长度为 0：

1
2
3
复制代码>>> L = []
>>> len(L)
0

当然我们也可以从后往前进行索引，-1代表最后一个，-2代表倒数第二个，以此类推。

1
2
3
4
5
6
复制代码>>> city[-1]
重庆
>>> city[-2]
天津
>>> city[-5]
IndexError:list index out of range

list 中元素的数据类型是不一定是一样的，甚至可以再嵌套一个 list:

1
2
3
复制代码>>> L = ['小之',23,False,['Android','Python','Java']]
>>> len(L)
4

L 中的另一个 list 整体只算一个元素，你可以把它理解为一个二维数组，可以通过L[3][1]调用到这个 list 中的Python元素。

list 常用的函数

list 是一个可变有序表，所以可以往 list 中塞数据，使用append()函数将把元素塞到末尾

1
2
3
复制代码>>> city.append('南京')
>>> city
['北京','上海','天津','重庆','南京']

我们还可以使用insert()来把元素插入到指定位置

1
2
3
复制代码>>> city.insert(2,'苏州')
>>> city
['北京','上海','苏州','天津','重庆','南京']

通过pop()可以获取 list 末尾的元素，并且删除该元素，pop(i)可以删除并返回指定位置的元素

1
2
3
4
5
6
复制代码>>> city.pop()
'南京'
>>> city.pop(0)
'北京'
>>> city
['上海','苏州','天津','重庆']

使用remove(x)来移除某一个特定的元素x

1
2
3
复制代码>>> city.remove('上海')
>>> city
['苏州','天津','重庆']

使用reverse()来将 list 逆序

1
2
3
复制代码>>> city.reverse()
>>> city
['重庆','天津','苏州']

如果想作拼接可以有两种方式，一种是通过extend()，一种是通过+

1
2
3
4
5
6
复制代码>>> L2 = ['北京']
>>> L+L2
['重庆','天津','苏州','北京']
>>> L.extend(L2)
>>> L
['重庆','天津','苏州','北京']

注意，L+L2并不会改变 L 的值，而extend是会改变调用 list 本身的值的，所以extend实际上可以和L += L2等价

你还可以通过city *= n来将 list 重复 n 次塞入到本身

1
2
3
4
复制代码>>> L = ['1','2']
>>> L *= 3
>>> L
['1','2','1','2','1','2']

tuple

tuple 叫元祖，是另一种有序列表，tuple 和 list 很像，但是 tuple 初始化后就不能再被修改了，除了一些插入删除操作比如append,pop不能使用，其他的使用和 list 基本一致。

1
2
3
4
5
复制代码>>> city = ('北京','上海','南京')
>>> city[0]
'北京'
>>> city[-1]
'南京'

注意，在定义一个 tuple 的时候，tuple 的元素就被确定下来了，之后你将无法改变它，这样做的意义是 tuple 的不可变性可以使得代码更加安全，如果可以，你应该尽量使用 tuple 来替代 list。

当你定义只有一个元素的 tuple 的时候，注意需要在后面加一个「,」号，以免引起歧义。(1)是可以代表数字 1 的。

1
2
3
4
5
6
复制代码>>> t = (1)
>>> t
1
>>> t = (1,)
>>> t
(1,)

tuple 的「不可变」并不意味着元素完全不可变，而是代表 tuple 元素的指向是不可变的，tuple 的元素可以是一些「可变的」元素，比如 list:

1
2
3
4
复制代码>>> t = ('北京','上海',['重庆','南京'])
>>> t[2][0] = '天津'
>>> t
('北京','上海',['天津','南京'])

我们可以看到 tuple 中的 list 元素已经改变了，但实际上 tuple 的元素指向的仍然还是这个 list，总而言之，tuple 需要保证的是「指向不变」，而如果你需要保证内容不变，那就得保证元素本身是不可变的。

range

我们最后介绍一下range。range 也是一个不可变的序列，它通常是使用在一些循环语句中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
复制代码>>> list(range(10))
[0,1,2,3,4,5,6,7,8,9]
>>> list(range(1,11))
[1,2,3,4,5,6,7,8,9,10]
>>> list(range(0,30,5))
[0,5,10,15,20,25]
>>> list(range(0,10,3))
[0,3,6,9]
>>> list(range(0,-10,-1))
[0,-1,-2,-3,-4,-5,-6,-7,-8,-9]
>>> list(range(0))
[]
>>> list(range(1,0))
[]

list 函数将把可遍历的数据类型转化为 list。我们通过以上代码发现，range(10)是 0-9 的数列，在一个参数的时候是从 0 开始的序列。range(1,11)代表从第一个参数开始，第二个参数为止的数列，注意，这里的范围是[1,11)，包括第一个参数，不包括第二个参数。三个参数，在两个参数的基础上增加了一个 step 用来表示每次增幅的数量，如果某一次增幅超过了一边范围，则割舍掉这个值。

如果没有第三个参数，则默认所有的 step 都是 +1，如果开始值和结束值大小写反了，将会返回一个空列表。

一般我们会在 for 语句中使用 range()

1
2
3
4
5
6
复制代码>>> L = []
>>> for i in range(10):
...     L.append(i)
...
>>> L
[0,1,2,3,4,5,6,7,8,9]

序列类型的一些其他用法

通用序列操作

下面说的操作和函数都是通用操作，不管是不是可变序列，都可以使用。我们先定义一个测试列表:

1
复制代码L = [1,2,3,4,5]

x in L, x not in L

x 代表元素，L 代表列表，x in L 中如果 L 中有元素和 x 相等，就返回 True，否则返回 False，x not in L 相反。

1
2
3
4
5
6
7
8
复制代码>>> 1 in L
True
>>> 0 in L
False
>>> 1 not in L
False
>>> 0 not in L
True

L + T

这个我们之前也讲过了，通过「+」可以拼接两个序列

1
2
3
复制代码>>> T = [6]
>>> L + T
[1,2,3,4,5,6]

L * n

将 L 重复塞入自己 n 次，得到一个新的列表

1
2
复制代码>>> L * 2 
[1,2,3,4,5,6,1,2,3,4,5,6]

len(L)

获取列表长度

1
2
复制代码>>> len(L)
12

min(L)、max(L)

获取列表中的最大最小值

1
2
3
4
复制代码>>> min(L)
1
>>> max(L)
6

L.index(x)

获取 x 在 L 中第一次出现的位置

1
2
3
复制代码>>> L = (1,2,1,3)
>>> L.index(1)
0

index 还有两个变种，可以添加两个参数，index(x,i)和 index(x,i,j)。

如果只增加一个参数，那就是获取从这个参数位置开始到列表结尾这个范围中，第一次出现 x 的位置，如果增加两个参数，则返回从 i 至 j (不包括 j)范围中第一次出现 x 的位置。

1
2
3
4
复制代码>>> L.index(1,1)
2
>>> L.index(1,1,3)
2

如果找不到，将会抛出ValueError错误

L.count(x)

返回 x 在 L 中出现的次数

1
2
复制代码>>> L.count(1)
2

可变序列操作

下面介绍一些可变序列独有的操作，tuple 是无法使用的。

除了之前介绍 list 时提到的诸如append、remove以外，还有一些比较有用的函数。

L.clear()

清空列表中所有的元素

1
2
3
复制代码>>> L.clear()
>>> L
[]

L.copy

新建一份相同的列表。

1
2
3
4
5
6
7
8
9
复制代码>>> L = [1,2,3]
>>> A = L.copy()
>>> A
[1,2,3]
>>> A.append(1)
>>> A
[1,2,3,1]
>>> L
[1,2,3]

以上介绍了一些序列类型的一些基本操作，还有一些类似「切片」、「迭代」、「生成器」等高级操作，将在后续的文章中为大家介绍。

欢迎关注我的公众号

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%