1.序列
在Python中最基础的数据结构是序列，数据结构可以理解为具有某种功能的特殊数据类型，序列中每个元素都有编号，表示其位置或者索引，其中第一个元素的索引值为0，其意义是指出某个元素相对于序列开题的偏移量。
1.1 序列
序列是python中的一种数据结构，和C语言中的数组比较类似，只是在Python中序列存储的数据不限类别，也不需要所有的序列元素都是同一种类别。最常用的序列是：列表和元组。
列表和元组的主要区别在于列表可以修改而元组不可修改。当需要一系列的值时就可以考虑使用序列，当然序列中也可以存储序列。
序列的使用距举例：
>>
>
a
=
[
'I'
,
'love'
]
>>
>
b
=
[
'you'
,
2
]
>>
>
c
=
(
a
,
b
)
>>
>
c
(
[
'I'
,
'love'
]
,
[
'you'
,
2
]
)
1.2 通用序列操作
通用的序列操作包括 索引 、 切片 、 相加 、 相乘 和 成员资格检查 。
索引
序列中所有的元素都有编号——从0开始递增，索引使用举例：
>>
>
g
=
'Hello'
>>
>
g
[
0
]
'H'
当使用的索引值为负数时，Python会从后往前数，索引值为正数时从前往后数比如：
>>
>
g
[
-
1
]
'o'
>>
>
g
[
1
]
'e'
切片
切片用来访问特定范围内的元素，可以使用两个索引，用冒号分开，从第一个索引值开始取，一直到第二个索引值，但不包括第二个索引的元素，索引为负时也是一样，只是方向上是反的比如
>>
>
tag
=
'0123456789'
>>
>
tag
[
1
:
6
]
'12345'
>>
>
tag
[
-
5
:
-
1
]
'5678'
切片也可以简写，操作如下：
>>
>
tag
=
'0123456789'
>>
>
tag
[
1
:
]
# 省略后面的数字默认到序列的最后
'123456789'
>>
>
tag
[
:
1
]
# 省略第一个数字默认从序列头开始
'0'
同时切片也可以指定步长，步长大小一般是切片的第三个参数，步长标记了切片取到的元素之间的间隔距离，比如：
>>
>
tag
=
'0123456789'
>>
>
>>
>
tag
[
1
:
9
:
1
]
# 步长为1，取的元素之间没有跳跃性
'12345678'
>>
>
tag
[
1
:
9
:
2
]
# 步长为2，每取完一个元素会跳过一个元素，相当于一步多夸了一个单位
'1357'
>>
>
tag
[
1
:
9
:
3
]
# 步长为3，一下子跨越了三个元素
'147'
序列相加
序列之间跨越通过相加来合并，但是两个不同类型的序列不能相加，举例：
>>
>
list1
=
[
1
,
2
,
3
]
>>
>
list1
+
[
4
,
5
,
6
]
[
1
,
2
,
3
,
4
,
5
,
6
]
>>
>
list1
+
'abc'
Traceback
(
most recent call last
)
:
File
"
"
,
line
1
,
in
<
module
>
TypeError
:
can only concatenate
list
(
not
"str"
)
to
list
序列乘法
序列可以通过乘以一个数字n来重复n次，举例：
>>
>
a
=
[
1
,
2
,
3
]
>>
>
a
*
2
[
1
,
2
,
3
,
1
,
2
,
3
]
成员资格
可以通过in来判断一个元素是否在一个序列中，返回布尔型的数据，具体的实现会在迭代器中详解，举例：
>>
>
a
=
[
1
,
2
,
3
]
>>
>
2
in
a
True
>>
>
4
in
a
False
2.列表
列表是一种序列，非常类似于C语言中的数组，但使用起来会简单很多，列表的定义可以通过以下两种方式进行：
>>
>
list1
=
[
1
,
2
,
3
]
# 直接通过[]定义列表
>>
>
list1
[
1
,
2
,
3
]
>>
>
list2
=
list
(
'123'
)
# 通过list方法定义列表
>>
>
list2
[
'1'
,
'2'
,
'3'
]
2.1列表基本操作：
2.1.1 列表修改
直接使用列表的索引值对指定地方的元素进行修改，举例：
>>
>
list1
=
[
1
,
1
,
1
]
>>
>
list1
[
1
]
=
2
>>
>
list1
[
1
,
2
,
1
]
注意 ：不能给不存在的元素赋值。
2.1.2 删除元素
使用del语句可以删除列表的元素，举例：
>>
>
list1
=
[
1
,
2
,
3
]
>>
>
del
list1
[
2
]
>>
>
list1
[
1
,
2
]
2.1.3 给切片赋值
切片的功能强大，可以给索引范围内的元素赋值，多于部分会自动删除，举例：
>>
>
name
=
list
(
'lalalalalala'
)
>>
>
name
[
'l'
,
'a'
,
'l'
,
'a'
,
'l'
,
'a'
,
'l'
,
'a'
,
'l'
,
'a'
,
'l'
,
'a'
]
>>
>
name
[
2
:
]
=
list
(
'ar'
)
>>
>
name
[
'l'
,
'a'
,
'a'
,
'r'
]
2.2 列表方法
方法是与对象相关的一些函数，可以增加序列使用的灵活性。
2.2.1 增加元素的方法append
append方法用于向列表尾端加一个对象，举例：
>>
>
list1
=
[
1
,
2
,
3
]
>>
>
list1
.
append
(
4
)
>>
>
list1
[
1
,
2
,
3
,
4
]
2.2.2 清空列表的方法clear
clear用于将列表清空，举例;
>>
>
list1
=
[
1
,
2
,
3
]
>>
>
list1
.
clear
(
)
>>
>
list1
[
]
2.2.3 复制列表的方法copy
常规复制只是将另一个名称关联到列表，没有生成新的列表，举例：
>>
>
a
=
[
1
,
2
]
>>
>
b
=
a
# 常规复制，没有生成新的列表，b与a的地址一样，所以改变a同时也会改变b
>>
>
b
[
1
,
2
]
>>
>
id
(
a
)
1921407627400
>>
>
id
(
b
)
1921407627400
>>
>
b
=
a
.
copy
(
)
# 使用copy复制，生成了新的列表
>>
>
b
[
1
,
2
]
>>
>
id
(
b
)
1921407642376
2.2.4 统计方法count
方法count统计指定的元素在列表中出现的次数，举例：
>>
>
a
=
[
1
,
2
,
2
,
3
,
3
,
3
,
4
,
4
,
4
,
4
]
>>
>
a
.
count
(
3
)
3
2.2.5 附加方法extend
extend方法可以将多个值加到目标列表的尾端，一般指定参数也是一种序列，举例：
>>
>
a
=
[
1
,
2
,
3
]
>>
>
b
=
[
4
,
5
,
6
]
>>
>
a
.
extend
(
b
)
>>
>
a
[
1
,
2
,
3
,
4
,
5
,
6
]
注意 ：与序列的相加不同的是，序列相加后生成了一个新的序列，而extend方法是在原序列的基础上加上了一段，没有生成新的序列。
2.2.6 索引查找方法index
index方法在列表中查找第一个出现的目标元素的索引，举例：
>>
>
lst
=
[
'a'
,
'b'
,
'c'
,
'c'
]
>>
>
lst
.
index
(
'c'
)
2
2.2.7 元素插入方法insert
方法insert用于将一个对象插入列表中，举例：
>>
>
a
=
[
1
,
2
,
3
]
>>
>
a
.
insert
(
1
,
4
)
# 在索引为1的位置插入4这个元素
>>
>
a
[
1
,
4
,
2
,
3
]
2.2.8 删除并返回删除元素的方法pop
方法pop从列表中删除一个元素，并将删除的值返回，当pop方法传入索引值时删除对应索引值的元素，否则删除最后一个元素，举例：
>>
>
a
=
[
1
,
2
,
3
,
4
]
>>
>
a
.
pop
(
)
4
>>
>
a
.
pop
(
0
)
1
>>
>
a
[
2
,
3
]
2.2.9 按元素值删除元素的方法remove
方法remove用于删除第一个为指定值的元素，举例：
>>
>
a
=
[
'to'
,
'as'
,
'the'
,
'qaq'
,
'to'
,
'as'
]
>>
>
a
.
remove
(
'as'
)
>>
>
a
[
'to'
,
'the'
,
'qaq'
,
'to'
,
'as'
]
2.2.10 翻转列表的方法reverse
reverse将列表按相反的顺序排列，举例;
>>
>
a
=
[
1
,
2
,
3
]
>>
>
a
.
reverse
(
)
>>
>
a
[
3
,
2
,
1
]
2.2.11 排序方法sort
sort方法若不带参数则将列表就地排序，带特殊参数可以按照特殊需求排序，举例;
>>
>
a
=
[
1
,
2
,
3
,
5
,
6
,
7
,
8
,
4
,
9
]
>>
>
a
.
sort
(
)
# 默认排序，按从小到大排列
>>
>
a
[
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
]
>>
>
a
=
[
'asdd'
,
'asdhjfuekqj'
,
'a'
,
'sdf'
,
'dhjucne'
]
>>
>
a
.
sort
(
key
=
len
)
# 按字符串长度排序
>>
>
a
[
'a'
,
'sdf'
,
'asdd'
,
'dhjucne'
,
'asdhjfuekqj'
]
>>
>
a
=
[
1
,
5
,
3
,
2
,
6
,
4
,
7
,
8
,
9
]
>>
>
a
.
sort
(
reverse
=
True
)
# 按从大到小排列
>>
>
a
[
9
,
8
,
7
,
6
,
5
,
4
,
3
,
2
,
1
]
3 元组
元组是一种不能更改的序列，性质与列表类似，采用（）包裹，举例：
>>
>
1
,
2
,
3
# 直接用逗号隔开的数字可以构成一个元组
(
1
,
2
,
3
)
>>
>
(
)
#空括号也能构成元组
(
)
>>
>
42
,
(
42
,
)
可以通过tuple方法将一个序列变成元组，举例：
>>
>
tuple
(
[
1
,
2
,
3
]
)
(
1
,
2
,
3
)
