笔者：风起怨江南出处：https://blog.csdn.net/JackMengJin 笔者原创，文章欢迎转载，如果喜欢请点赞+关注，感谢支持！

序列的概念和列表的用法

一、序列

在之前的Python学习里，我们学习了字符串、数字等数据类型。这篇主要讲关于数据类型列表的用法。在研究列表之前需要先讲一下序列的概念。

1.1 数据结构——序列

引入Python里一个新的概念：数据结构。

数据结构是以某种方式（比如编号）组合起来的数据元素（如数、字符、乃至其他的数据结构）集合。序列就是最基本的数据结构。序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引为1，以此类推。

所以这也是为什么《Python学习》系列里是从00开始作为标题，而不是从01开始。

Python内置多种序列，而最常用的两种就是：列表和元组，当然字符串也是序列，在后面的内容中会讲到。

列表和元组的不同：

列表是可以修改的，而元组是不可以修改的。所以在编写程序的时候，大多数的元组都可以被列表所代替，只有在将元组用作字典键的时候是不能用列表来代替元组的，因为字典键是不允许修改的。

列表适用于需要中途添加元素的情形，而元组适用于处于目中考虑需要禁止修改序列的情况。禁止修改序列通常用于技术方面的考虑，与Python的内部工作原理相关。这也是有些内置函数返回元组的原因所在。

Python支持一种数据结构的基本概念：容器。容器基本上就是可包含其他对象的对象。序列（如列表和元组）和映射（如字典）

都是容器。这里先不展开去将容器的概念，现在只需要知道：

在序列中，每个元素都有编号。
在映射中，每个元素都有名称（键）。
还有一种容器——集合（set）既不是序列也不是映射。

1.2 序列的操作

索引、切片、相加、相乘、成员资格检查、迭代（迭代相关内容后续详细讲解）。

索引

序列中所有元素都有编号，从0递增。比如使用编号访问各个元素：

str = 'School'
print(str[0])

一个字符就是只包含一个元素的字符串，字符串就是字符组成的序列。

负数索引：

str = 'School'
print(str[-1])

Python将从右（即从最后一个元素）开始往左数，因此-1是最后一个元素的位置，以此类推。

切片

索引访问单个元素，切片（slicing）来访问特定范围内的元素，为此，可以使用两个索引，并用冒号分隔（由于当前还未讲到列表，所以都由字符串来进行举例）：

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[2:8])

tps://

需要注意的是：提供的两个索引来制定切换的边界，其中第一个索引制定的元素包含在切片内，第二个索引制定的元素不包含在切片内。所以索引为8的字符并没能打印出来。

如何访问字符串中的最后三个字符？使用负数索引：

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[-3:-1])

Ji

这里可以看到索引-3是字符J，打印从J开始，到i结束。也就是索引-1是不包含最后一位字符的。使用索引0行么？

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[-3:0])

在运行一下看下结果：

显然结果不是我们想要的。那是为什么呢？

实际上在执行切片操作时，如果第一个索引指定的元素位于第二个索引指定的元素后面（-3位于0后面，也就是倒数第3个元素位于第1个元素后面），结果为空序列。

所以这里我们用简写：如果切片位于序列末尾，可以省略第二个索引，从倒数第3个字符到末尾:

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[-3:])

Jin

再比如，从正数第4个字符到末尾：

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[3:])

ps://blog.csdn.net/JackMengJin

再或者从开头到正数第4个字符：

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[:4])

http

如果将两个索引都省略，相当于复制整个序列：

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[:])

https://blog.csdn.net/JackMengJin

切片步长的概念

普通切片里步长都是为1，意味着从一个元素移到下一个元素：

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[1:8:1])

ttps://

如果指定的步长大于1，将跳过一些元素。例如：当步长为2时，将从起点和终点之间每隔一个元素提取一个元素：

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[1:8:2])

tp:/

例如要从序列中每隔3个元素提取1个，只需提供步长4即可：

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[::4])

hsb.ntcnn

需要注意的是，步长不能为0。但可以为负数，即从向左提取元素。

步长为-1时：：

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[::-1])

niJgneMkcaJ/ten.ndsc.golb//:sptth

步长为-3时：

myCSDN = 'https://blog.csdn.net/JackMengJin'
print(myCSDN[14:2:-3])

sgb:

相加

可以使用加法运算符+来拼接序列。

words = 'welcome to my CSDN:'
myCSDN = 'https://blog.csdn.net/JackMengJin'
print(words + myCSDN)

welcome to my CSDN:https://blog.csdn.net/JackMengJin

注意，不能拼接不同类型的序列。

相乘

将序列与数x相乘时，将重复这个序列x次来创建一个新序列：

words = 'welcome to my CSDN!'
print(words * 5)

welcome to my CSDN!welcome to my CSDN!welcome to my CSDN!welcome to my CSDN!welcome to my CSDN!

乘法在列表中的使用放在后面讲解。

成员资格检查

要检查特定的值是否包含在序列中，可使用运算符in，称为布尔运算符。

返回的值：满足时返回True，不满足时返回False。称为布尔值。

words = 'welcome to my CSDN!'
print('w' in words)
print('3' in words)

True
False

需要注意，判断正确错误是区分字母大小写的：

words = 'welcome to my CSDN!'
print('W' in words)
print('w' in words)

False
True

1.3 内置函数len、min和max

长度、最小值和最大值。

函数len返回序列包含的元素个数，而min和max分别返回序列中最小和最大的元素：

numbers = '0123456789'
print(max(numbers))
print(len(numbers))
print(min(numbers))

9
10
0

max和min函数可以直接指定实参，直接将数作为实参使用，而不是序列，当然len函数不行这么操作：

print(max(1,2,3,4,5,6,7,8,9))
print(min(1,2,3,4,5,6,7,8,9))

9
1

print(len(1,2,3,4,5,6,7,8,9))

Traceback (most recent call last):
  File "G:/helloWorld/python/pycharm/NingMeng/demo377.py", line 3, in <module>
    print(len(1,2,3,4,5,6,7,8,9))
TypeError: len() takes exactly one argument (9 given)

成员资格检查在列表中的使用放在后面讲解。

二、列表

列表能够在一个地方存储成组的信息，可以包含几个元素，也可以包含数万个元素。列表是新手可以直接使用的最强大的Python功能（之一）。

2.1 列表的定义

列表由一系列按特定顺序排列的元素组成。

在Python中用方括号来表示列表，并用逗号来分隔其中元素：

numbers = [1,2,3,4,5,6,7,8,9,0]
names = ['Jack','Rose','Kobe','James']

由于列表是序列的一种，所以序列的所有操作（索引、切片、相加、相乘、成员资格检查）都可以在列表中使用：

索引：

names = ['Jack','Rose','Kobe','James']
print(names[1])
print(names[-2])

Rose
Kobe

切片：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names[1:5])
print(names[1:8:2])
print(names[::-1])
print(names[::-2])

['Rose', 'Kobe', 'James', 'Jane']
['Rose', 'James', 'King', 'Jone']
['Tina', 'May', 'Mary', 'Jone', 'Bill', 'King', 'Jane', 'James', 'Kobe', 'Rose', 'Jack']
['Tina', 'Mary', 'Bill', 'Jane', 'Kobe', 'Jack']

相加：

numbers = [1,2,3,4,5,6,7,8,9,0]
names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names + numbers)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina', 1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

相乘：

numbers = [1,2,3,4,5,6,7,8,9,0]
print(numbers * 8)

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

成员资格检查：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print('jack' in names)
print('Jack' in names)

False
True

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(min(names))
print(max(names))
print(len(names))

Bill
Tina
11

2.2 列表与元组和字符串的不同

列表不同于元组和字符串的地方在于——列表是可变的，即可以修改其内容，而且列表有很多特有的方法。

鉴于不能向修改列表那样修改字符串，因此可以使用函数list，使用字符串来创建按列表：

print(list('hello'))

['h', 'e', 'l', 'l', 'o']

可将任何序列（不仅仅是字符串）作为list的参数。

将字符列表转换为字符串

print(['h', 'e', 'l', 'l', 'o'])
print(type(['h', 'e', 'l', 'l', 'o']))
#将列表转换为字符串
print(' '.join(['h', 'e', 'l', 'l', 'o']))
print(type(' '.join(['h', 'e', 'l', 'l', 'o'])))

['h', 'e', 'l', 'l', 'o']
<class 'list'>
h e l l o
<class 'str'>

2.3 访问列表元素

想要访问列表元素，指出列表的名称，在指出元素的索引，放在方括号内即可：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names[6])

Bill

当请求获取列表元素时，Python只返回该元素，而不包括括号和引号。

同时可以对列表元素使用字符串方法：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names[8])
print(names[8].lower())
print(names[8].upper())
print(names[8].swapcase())

Mary
mary
MARY
mARY

2.4 修改列表元素

之前写到列表是可变的，那么如何修改列表元素呢?

修改列表元素的语法与访问列表元素的语法类似：先指定列表名和要修改元素的索引，再给该元素赋值。

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
names[4] = 'Gigi'
print(names)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Jack', 'Rose', 'Kobe', 'James', 'Gigi', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']

可以通过打印看到，修改索引4的值已经换成了新值，而列表其他元素的值是不受影响的。

需要注意的是，不能给不存在的元素赋值：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
names[21] = 'Gigi'
print(names)

Traceback (most recent call last):
  File "G:/helloWorld/python/pycharm/NingMeng/demo377.py", line 6, in <module>
    names[21] = 'Gigi'
IndexError: list assignment index out of range
['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']

2.5 添加列表元素

Python里方法是什么？

方法就是用来描述对象所具有的行为。方法是与对象（列表、数字、字符串、元组等）联系紧密的函数。

方法的分类

普通方法：直接用self调用的方法。

私有方法：__函数名，只能在类中被调用的方法。

属性方法：@property，将方法伪装成为属性，让代码看起来更合理。

特殊方法(双下划线方法)：以__init__为例，是用来封装实例化对象的属性，只要是实例化对象就一定会执行__init方法，如果对象子类中没有则会寻找父类（超类），如果父类（超类）也没有，则直接继承object（python 3.x）类，执行类中的__init__方法。

类方法：通过类名的调用去操作公共模板中的属性和方法。

静态方法：不用传入类空间、对象的方法，作用是保证代码的一致性，规范性，可以完全独立类外的一个方法，但是为了代码的一致性统一的放到某个模块（py文件）中。

方法的调用

通过“对象.方法名”的方式进行调用。

更多Python方法的概念会在之后函数学习中具体讨论，这里不再详细说明。

在列表末尾添加元素——方法append()

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
names.append('Carter')
print(names)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina', 'Carter']

方法append最大的作用是动态地创建列表。

先创建一个空列表，在使用一系列的append()方法来添加元素：

cars = []
print(cars)
cars.append('奥迪')
cars.append('别克')
cars.append('大众')
print(cars)

[]
['奥迪', '别克', '大众']

这种创建列表的方式是极其常见的，由于经常要等程序运行后才知道用户要在程序中存储哪些数据。为了控制用户，首先创建空列表，用于存储用户将要输入的值，再将用户提提供的每个新值添加到列表中。

在列表中插入元素——方法insert()

方法insert()可以在列表的任何位置添加新元素，前提是需要指定新元素的索引和值：

cars = []
print(cars)
cars.append('奥迪')
cars.append('别克')
cars.append('大众')
print(cars)
cars.insert(0,'宝马')
print(cars)

[]
['奥迪', '别克', '大众']
['宝马', '奥迪', '别克', '大众']

方法insert()在索引0出添加空间，并将'宝马'存储到这个地方，其他每个元素都右移一个位置。

2.6 删除列表元素

有添加就有删除，下面来看看如何删除列表元素。

使用del语句删除元素

如果知道了要删除元素在列表中的位置，可以使用del语句来删除：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
del names[2]
print(names)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Jack', 'Rose', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']

使用del可以删除任何位置的列表元素，前提是知道其索引，当然不能超出索引范围。

注意：使用del语句删除列表中元素后，就无法再访问到它了。

使用方法pop()删除元素

pop()的应用场景在于删除元素后，继续使用该值。同样的pop()可以删除列表末尾的元素，可以理解为：列表就像是一个栈，删除列表的末尾相当于弹出栈顶元素。

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
name_pop = names.pop()
print(names)
print(name_pop)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May']
Tina

同样pop()可以来删除列表中任何位置的元素，需要在括号中指定要删除的元素的索引：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
name_pop = names.pop(6)
print(names)
print(name_pop)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Jone', 'Mary', 'May', 'Tina']
Bill

如果删除后不再使用该值，则用del语句删除；如果还要继续使用删除的值，则用pop()方法。

根据具体值删除元素

如果只知道删除元素的值而不知道索引的话，使用方法remove()：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
names.remove('Jone')
print(names)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Mary', 'May', 'Tina']

remove()方法同样是删除元素后，就彻底删除，无法再访问到该值：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
name_remove = names.remove('Jone')
print(names)
print(name_remove)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Mary', 'May', 'Tina']
None

不过如果将要删除的值存储在变量中，再通过remove()方法删除该变量，变量里的值可以继续使用，不受影响：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
name_re = 'Jone'
names.remove(name_re)
print(names)
print(name_re)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Mary', 'May', 'Tina']
Jone

当然，如果删除不存在的值，那是不可以的：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
name_re = 'J123'
names.remove(name_re)

Traceback (most recent call last):
  File "G:/helloWorld/python/pycharm/NingMeng/demo377.py", line 7, in <module>
    names.remove(name_re)
ValueError: list.remove(x): x not in list

2.7 给列表排序

当需要以特定的顺序呈现列表信息时，则需要给列表排序。

永久性排序

sort()方法按字母、数字顺序排列：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
names.sort()
print(names)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Bill', 'Jack', 'James', 'Jane', 'Jone', 'King', 'Kobe', 'Mary', 'May', 'Rose', 'Tina']

numbers = [8,91,81,7,6,11,23,45,1,0,134,342,2,76,32]
print(numbers)
numbers.sort()
print(numbers)

[8, 91, 81, 7, 6, 11, 23, 45, 1, 0, 134, 342, 2, 76, 32]
[0, 1, 2, 6, 7, 8, 11, 23, 32, 45, 76, 81, 91, 134, 342]

还可以按照相反的顺序排列列表元素，需要向sort()方法传递参数reverse = True，同样也是对排序进行永久性的修改：

numbers = [8,91,81,7,6,11,23,45,1,0,134,342,2,76,32]
print(numbers)
numbers.sort(reverse=True)
print(numbers)
names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
names.sort(reverse=True)
print(names)

[8, 91, 81, 7, 6, 11, 23, 45, 1, 0, 134, 342, 2, 76, 32]
[342, 134, 91, 81, 76, 45, 32, 23, 11, 8, 7, 6, 2, 1, 0]
['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Tina', 'Rose', 'May', 'Mary', 'Kobe', 'King', 'Jone', 'Jane', 'James', 'Jack', 'Bill']

临时排序

函数sort()可以按特定顺序显示列表元素，同时不影响在列表中的原始排列顺序：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
names_sorted = sorted(names)
print(names_sorted)
print(names)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Bill', 'Jack', 'James', 'Jane', 'Jone', 'King', 'Kobe', 'Mary', 'May', 'Rose', 'Tina']
['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']

同样的，要按顺序相反显示还是需要向函数sorted()传递参数reverse = true：

names = ['Jack','Rose','Kobe','James','Jane','King','Bill','Jone','Mary','May','Tina']
print(names)
names_sorted = sorted(names,reverse=True)
print(names_sorted)
print(names)

['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']
['Tina', 'Rose', 'May', 'Mary', 'Kobe', 'King', 'Jone', 'Jane', 'James', 'Jack', 'Bill']
['Jack', 'Rose', 'Kobe', 'James', 'Jane', 'King', 'Bill', 'Jone', 'Mary', 'May', 'Tina']

注：关于列表操作的内容，会放到后面for、while循环里具体讨论。

以上便是《Python学习04讲》所有内容，更多python学习请继续关注我的博客——风起怨江南，不定期更新，原创不易，如果喜欢请点赞和关注，谢谢大家的支持！

获得更多免费的学习资料请添加微信公众号——风起怨江南，谢谢大家的关注和支持！

孟锦翔

发布了10 篇原创文章 · 获赞 14 · 访问量 4万+

私信关注

Python学习04：序列的概念和列表的用法

目录