每一秒钟的时间都值得铭记

0%

Python序列

发表于 更新于 分类于
本文字数： 9.9k 阅读时长 ≈ 9 分钟

序列是一块用于存放多个值的连续的内存空间，并按照一定的顺序排列，每一个值（称为元素）都分配一个数字（称为索引或者位置）。通过索引可以取出对应位置的值。

序列的通用操作

在 Python 中，序列的主要结构有列表、元组、集合、字典和字符串。对于这些序列有一些通用操作，例如索引，切片，相加，相乘，序列长度，是否包含某个元素，序列最大值，序列最小值等等，其中集合和字典不支持索引、切片、相加、相乘操作。

索引

序列中的每一个元素都有一个编号，也称之为索引。序列从左往右开始数，第一个元素的索引是0，第二个元素的索引是1，以此类推。

值得一提的是，Python 的索引可以是负数，从右往左数，第一个元素的索引是-1，第二个元素的索引是-2，以此类推。

1
2
3
4
5
arr = ["第一个元素", "第二个元素", "第三个元素", "第四个元素"]
print(arr[0])
print(arr[1])
print(arr[-1])
print(arr[-2])

运行结果：

1
2
3
4
第一个元素
第二个元素
第四个元素
第三个元素

切片

切片操作是访问序列中元素的一种方法，可以用于访问序列中指定范围的元素，通过切片操作生成一个新的序列。

切片操作的语法为：

1
name[start : end : step]
  • name 为序列名称
  • start 为切片开始的索引，如果不指定，默认为0
  • end 为切片结束的索引 + 1，如果不指定，默认为序列的长度
  • step 为切片的步长，如果不指定，默认为1
1
2
3
4
5
arr = ["第一个元素", "第二个元素", "第三个元素", "第四个元素"]
print(arr[1:4])
print(arr[0:2])
print(arr[1:4:2])
print(arr[:])

运行结果：

1
2
3
4
['第二个元素', '第三个元素', '第四个元素']
['第一个元素', '第二个元素']
['第二个元素', '第四个元素']
['第一个元素', '第二个元素', '第三个元素', '第四个元素']

序列相加

在 Python 中，同类型的序列支持相加操作，相加之后的序列元素是原来两个序列的元素组合在一起，重复的元素不会去重，可以直接使用 + 运算符实现。

Python相加只支持同类型的序列，比如列表+列表，不支持列表+元组的操作。

1
2
3
arr1 = ["第一个元素", "第二个元素"]
arr2 = ["第三个元素", "第四个元素"]
print(arr1 + arr2)

运行结果：

1
['第一个元素', '第二个元素', '第三个元素', '第四个元素']

序列相乘

序列相乘的操作和序列相加的操作结果类似，相乘是将原来的序列元素乘以倍数，相当于倍数个序列相加。

1
2
arr = ["第一个元素", "第二个元素"]
print(arr * 3)

运行结果：

1
['第一个元素', '第二个元素', '第一个元素', '第二个元素', '第一个元素', '第二个元素']

序列长度

Python 提供了内置的函数计算序列的长度。

1
2
arr = ["第一个元素", "第二个元素", "第三个元素", "第四个元素"]
print("序列长度：", len(arr))

运行结果：

1
序列长度： 4

是否包含某个元素

在 Python 中，可以使用 in 关键字，判断某个元素是否是序列的成员。

1
2
arr = ["第一个元素", "第二个元素", "第三个元素", "第四个元素"]
print("第二个元素" in arr)

运行结果：

1
True

序列最大最小值

Python 同样提供了内置函数来计算序列中的最大元素和最小元素。

1
2
3
arr = [23, 234, 324, 1, 34, 23, 6, 34]
print(min(arr))
print(max(arr))

运行结果：

1
2
1
324

内置函数

Python 提供了大量的内置函数，用于操作序列。

内置函数 作用
list() 将序列转换为列表
str() 将序列转换为字符串
sum() 计算元素和（元素为数字类型）
sorted() 对元素进行排序
reversed() 反向序列中的元素
enumerate() 将序列组合为一个索引序列，多用在for循环中

列表

  • 可变序列。
  • 所有元素放在一对中括号 [] 中，每个元素之间使用英文逗号 , 分割开来。
  • 元素可以是任意类型。
  • 同一列表的元素类型可以不同。
  • 元素可重复。

创建空列表

1
emptylist = []

创建列表

1
list = ["第一个元素", "第二个元素", "第三个元素", "第四个元素"]

list() 函数

1
2
arr = list(range(10, 20, 2))
print(arr)

运行结果：

1
[10, 12, 14, 16, 18]

删除列表

1
2
list = ["第一个元素", "第二个元素", "第三个元素", "第四个元素"]
del list

遍历列表

1
2
3
4
5
6
7
list = ["第一个元素", "第二个元素", "第三个元素", "第四个元素"]
for item in list:
    print(item)
    
# 内置函数 enumerate()
for index, item in enumerate(list):
    print(index, item)

访问元素

1
2
list = ["第一个元素", "第二个元素", "第三个元素", "第四个元素"]
print(list[1])

添加元素

1
2
3
4
list = ["第一个元素", "第二个元素", "第三个元素", "第四个元素"]
print(list)
list.append("第五元素")
print(list)

运行结果：

1
2
['第一个元素', '第二个元素', '第三个元素', '第四个元素']
['第一个元素', '第二个元素', '第三个元素', '第四个元素', '第五元素']

修改元素

1
2
3
list = ["第一个元素", "第二个元素", "第三个元素", "第四个元素"]
list[0] = "修改后的第一个元素"
print(list)

运行结果：

1
['修改后的第一个元素', '第二个元素', '第三个元素', '第四个元素']

删除元素

1
2
3
list = ["第一个元素", "第二个元素", "第三个元素", "第四个元素"]
del list[1]
print(list)

运行结果：

1
['第一个元素', '第三个元素', '第四个元素']

列表计算

使用列表对象的 count() 方法，可以统计列表中包含的某个元素出现的次数，index() 方法，可以获取该对象在列表中首次出现的索引位置。

1
2
3
list = ["第一个元素", "第二个元素", "第三个元素", "第四个元素", "第二个元素"]
print(list.count("第二个元素"))
print(list.index("第二个元素"))

运行结果：

1
2
2
1

Python 的内置函数 sum() 可以对列表的元素进行统计。（列表的元素必须是数字类型）

1
2
list = [1, 3, 34, 451, 3]
print(sum(list))

运行结果：

1
492

可以使用列表对象的方法 sort() 或者 Python 的内置函数对列表进行排序。

1
2
3
4
5
6
7
list = [1, 3, 34, 451, 3]
list.sort()
print(list)
list.sort(reverse=True)
print(list)
print(sorted(list))
print(sorted(list, reverse=True))

运行结果：

1
2
3
4
[1, 3, 3, 34, 451]
[451, 34, 3, 3, 1]
[1, 3, 3, 34, 451]
[451, 34, 3, 3, 1]

值得一提的是，列表对象的 sort() 方法，是在原列表的基础上对列表元素进行排序，而内置函数 sorted()是建立了一个副本，对该副本的元素进行排序。

列表推导式

使用列表推导式，可以快速生成一个列表。

1
2
3
4
5
6
7
8
9
10
import random

list1 = [random.randint(10, 100) for i in range(10)]
print(list1)

list2 = [x * 2 for x in list1]
print(list2)

list3 = [x for x in list1 if x > 50]
print(list3)

运行结果：

1
2
3
[25, 98, 73, 70, 95, 30, 62, 15, 23, 69]
[50, 196, 146, 140, 190, 60, 124, 30, 46, 138]
[98, 73, 70, 95, 62, 69]

元组

  • 元组与列表唯一的不同是，元组是不可变序列，不能单独对元组的某一个元素进行修改。

创建空元组

1
emptytuple = ()

创建元组

1
tuplearr = ("第一个元素", "第二个元素", "第三个元素", "第四个元素")

tuple() 函数

1
print(tuple(range(5, 20)))

删除元组

1
2
tuplearr = ("第一个元素", "第二个元素", "第三个元素", "第四个元素")
del tuplearr

遍历元组

1
2
3
4
5
tuplearr = ("第一个元素", "第二个元素", "第三个元素", "第四个元素")
for item in tuplearr:
    print(item)
for index, item in enumerate(tuplearr):
    print(index, item)

访问元素

1
2
tuplearr = ("第一个元素", "第二个元素", "第三个元素", "第四个元素")
print(tuplearr[2])

运行结果：

1
第三个元素

修改元素

元组和列表最大的不同，就在于元组是不可变序列，元组内的元组不可以被修改。

1
2
tuplearr = ("第一个元素", "第二个元素", "第三个元素", "第四个元素")
tuplearr[1] = "第五个元素"

运行结果：报错

如果想要修改元组的元素，必须将整个元组全部重新赋值。

1
2
3
4
tuplearr = ("第一个元素", "第二个元素", "第三个元素", "第四个元素")
print(tuplearr)
tuplearr = ("第一个元素", "第五个元素", "第三个元素", "第四个元素")
print(tuplearr)

运行结果：

1
2
('第一个元素', '第二个元素', '第三个元素', '第四个元素')
('第一个元素', '第五个元素', '第三个元素', '第四个元素')

元组推导式

元组推导式和列表推导式不同的地方在于，列表推导式生成的是一个列表对象，而元组推导式生成的是一个生成器对象，我们需要使用 tuple() 函数将其转换为元组。

1
2
3
4
5
6
7
8
9
10
11
randomtuple1 = (random.randint(10, 20) for i in range(5))
randomtuple1 = tuple(randomtuple1)
print(randomtuple1)

randomtuple2 = (x * 2 for x in randomtuple1)
randomtuple2 = tuple(randomtuple2)
print(randomtuple2)

randomtuple3 = (x for x in randomtuple1 if x > 15)
randomtuple3 = tuple(randomtuple3)
print(randomtuple3)

运行结果：

1
2
3
(18, 10, 13, 17, 16)
(36, 20, 26, 34, 32)
(18, 17, 16)

列表与元组的区别

  • 列表是可变序列，列表元素可以修改；元组是不可变序列，元组元素不可以修改。
  • 列表可以使用 append() 、extend() 、insert() 、remove() 、pop() 等方法对列表进行修改，元组没有这些方法修改元素，同时元组也无法删除元素。
  • 列表支持用切片修改元素，元组不支持切片修改元素。
  • 元组的访问速度比列表快。
  • 列表不能作为字典的键，元组可以。

字典

  • 字典通过键值获取字典中保存的数据，不通过索引获取。
  • 字典是无序的。
  • 字典是可变序列的。
  • 字典的键值是唯一的，如果有相同键值，后面的会覆盖前面的。
  • 字典是键必须不可变。

创建空字典

1
2
dictionary = {}
dictionary = dict()

创建字典

1
2
3
4
5
6
7
8
9
10
dictionary = {"name": "肖总", "age": 18}
print(dictionary)

keylist = ["key1", "key2", "key3"]
valuelist = ["value1", "value2", "value3", "value4"]
dictionary = dict(zip(keylist, valuelist))
print(dictionary)

dictionary = dict(key1="value1", key2="value2", key3="value3")
print(dictionary)

运行结果：

1
2
3
{'name': '肖总', 'age': 18}
{'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
{'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

使用 zip() 函数创建字典，字典元素个数取两个列表长度较短的那个。

删除字典

1
dictionary.clear()
1
del dictionary

访问字典

字典只能通过键值去访问内部的元素。

1
2
3
4
5
dictionary = {"name": "肖总", "age": 18}
print(dictionary["name"])
print(dictionary.get("name"))
print(dictionary["age"])
print(dictionary.get("age"))

执行结果：

1
2
3
4
肖总
肖总
18
18

值得一提的是，如果直接使用 [键值]获得的时候，字典中不存在该键值，会直接爆错。

1
2
dictionary = {"name": "肖总", "age": 18}
print(dictionary["sex"])

运行结果：报错

使用 get()方法如果没有该键值会返回 None值，而且可以设置第二个参数为默认值。

1
2
3
dictionary = {"name": "肖总", "age": 18}
print(dictionary.get("sex"))
print(dictionary.get("sex", "未知"))

运行结果：

1
2
None
未知

遍历字典

可以使用字典的 items() 方法遍历字典。

1
2
3
4
5
dictionary = {"name": "肖总", "age": 18}
for item in dictionary.items():
    print(item)
for key, value in dictionary.items():
    print(key, value)

运行结果：

1
2
3
4
('name', '肖总')
('age', 18)
name 肖总
age 18

修改元素

字典可以直接通过添加键值的方式，对字典中的元素进行添加，修改等操作。

1
2
3
4
5
6
dictionary = {"name": "肖总", "age": 18}
print(dictionary)
dictionary["sex"] = "男"
print(dictionary)
dictionary["sex"] = "女"
print(dictionary)

运行结果：

1
2
3
{'name': '肖总', 'age': 18}
{'name': '肖总', 'age': 18, 'sex': '男'}
{'name': '肖总', 'age': 18, 'sex': '女'}

字典可以通过 del命令删除字典元素。

1
2
3
4
dictionary = {"name": "肖总", "age": 18}
print(dictionary)
del dictionary["age"]
print(dictionary)

运行结果：

1
2
{'name': '肖总', 'age': 18}
{'name': '肖总'}

如果删除一个不存在的键值，会直接报错。

1
2
dictionary = {"name": "肖总", "age": 18}
del dictionary["sex"]

运行结果：报错

正确的删除方式为：

1
2
3
dictionary = {"name": "肖总", "age": 18}
if "sex" in dictionary:
    del dictionary["sex"]

字典推导式

1
2
3
4
key = ["name", "age"]
value = ["肖总", "18"]
dictionary = {i: j + "~" for i, j in zip(key, value)}
print(dictionary)

运行结果：

1
{'name': '肖总~', 'age': '18~'}

集合

集合和列表一样，都是若干个元素的集合，不过集合和列表的区别在于，集合中如果有重复元素，只会保留一个。

创建集合

1
2
setname = {1, 2, 3, 4}
print(setname)

可以使用 set()函数，将列表，元组转换为集合。

1
2
3
4
5
6
list = [1, 2, 3, 4, 4]
print(list)
print(set(list))
tuple = (1, 2, 3, 4, 4)
print(tuple)
print(set(tuple))

运行结果：

1
2
3
4
[1, 2, 3, 4, 4]
{1, 2, 3, 4}
(1, 2, 3, 4, 4)
{1, 2, 3, 4}

修改集合

1
2
3
4
5
6
setname = {1, 2, 3, 4}
print(setname)
setname.add(5)
print(setname)
setname.remove(3)
print(setname)

运行结果：

1
2
3
{1, 2, 3, 4}
{1, 2, 3, 4, 5}
{1, 2, 4, 5}

集合运算

1
2
3
4
5
6
7
8
9
setname1 = {1, 2, 3, 4}
setname2 = {3, 4, 5}
# 交集
print(setname1 & setname2)
# 并集
print(setname1 | setname2)
# 差集
print(setname1 - setname2)
print(setname2 - setname1)

运行结果：

1
2
3
4
{3, 4}
{1, 2, 3, 4, 5}
{1, 2}
{5}

序列之间的区别

序列 是否可变 是否重复 是否有序 定义符号
列表(list） 可变 可重复 有序 []
元组(tuple） 不可变 可重复 有序 ()
字典(dictionary） 可变 不可重复 无序 {key:value}
集合(set） 可变 不可重复 无序 {}
坚持原创技术分享，您的支持将鼓励我继续创作！
-------------这是我的底线^_^-------------