Python—组合数据类型的基本使用

宋正兵 on 2022-07-05

列表

列表由一系列按特定顺序排列的元素组成,元素可以是任意的数据类型。使用[]定义列表,元素之间使用逗号分隔。列表是Python中内置的可变序列。

1
2
3
  0 ,  1 ,  2  ,... ,  N-2 , N-1 #正向递增
元素1,元素2,元素3,... ,元素n-1,元素n
-N ,-N+1,-N+2, ... , -2 , -1 #反向递减

创建以及删除

列表的创建可以通过如下方式:

  • 直接使用[]创建列表

    1
    列表名 = [element1, element2, ..., elementN]
  • 使用内置方法list()创建列表

    1
    2
    3
    #列表名 = list(序列)
    lst1 = list('helloworld')
    lst2 = list(range(1, 11)) #[1, 2, ..., 10]

列表的删除可以通过如下方式:

1
del 列表名

遍历

  • 使用for遍历循环

  • 遍历循环for与range()函数和len()函数组合遍历

  • 遍历循环for与enumerate()函数组合遍历元素和索引

    1
    2
    for index, item in enumerate():
    print(index, item)
    • index:元素的索引
    • item:元素值

相关操作方法

方法 描述
lst.append(e) 在列表lst最后增加一个元素
lst.insert(index, e) 在列表第index位置处,增加一个元素
lst.clear() 清除列表lst中所有元素
lst.pop(index) 将列表lst中第index位置的元素取出,并从列表中将其删除。如未指定index的值,默认是列表末尾
lst.remove(e) 将列表lst中出现的第一个元素e删除
lst.reverse() 将列表lst中的元素反转
lst.copy() 拷贝列表lst中的所有元素,生成一个新的列表

列表排序

  • 列表对象的sort()方法

    对原列表中的元素进行排序,排序之后原列表中元素的顺序将发生改变

    1
    lst.sort(key=None, reverse=False)
    • key:指定带有一个参数的函数,用于从每个列表元素中提取比较键(例如key=str.lower。对应于列表中每一项的键会被计算一次,然后在整个排序过程中使用。 默认值 None 表示直接对列表项排序而不计算一个单独的键值。
    • reverse:为一个布尔值。 如果设为 True,则每个列表元素将按反向顺序比较进行排序。

    sort()方法是稳定排序。

  • 内置的sorted()函数

    使用sorted()函数排序后,原列表元素顺序不变,排序后产生一个新的列表对象

    1
    sorted(iterable, key=None, reverse=False)

更多排序相关内容,参考官方给出的文档:Sorting HOW TO — Python 3.10.5 documentation

列表生成式

  • 生成指定范围的数值列表

    1
    lst = [expression for item in range]
  • 从列表中选择符合条件的元素组成新列表

    1
    lst = [expression for item in 列表 if condition]

元组

元组由一系列按特定顺序排列的元素组成,元素可以是任意的数据类型。使用()定义元组,元素之间使用逗号分隔。元组是Python中的不可变序列。

创建以及删除

列表的创建可以通过如下方式:

  • 直接使用()创建元组

    1
    t = (元素1, 元素2, ...)
  • 使用内置函数tuple()创建元组

    1
    2
    3
    t  = tuple('helloword')
    t2 = tuple([1, 2, 3, 4])
    t3 = tuple(range(1, 11))

列表的删除可以通过如下方式:

1
del 元组名

遍历

元组的遍历与列表的遍历方式相同。

元组生成式

元组生成式与列表生成式语法相同,区别在于,元组生成式的结果是一个生成器对象generator,需要转换成元组或列表才能查看到元素内容。如果使用__next__()函数(该函数每次访问生成器都会从中取出一个元素,并将该元素从生成器中删除)遍历生成器后,再想重新遍历必须重新创建一个生成器对象,因为遍历后原生成器对象已经不存在了。

1
2
3
4
t = (i for i in range(1, 11)) #结果是一个生成器对象(generator)
print(t, type(t)) # <generator object <genexpr> at 0x0000029AA2FA2500> <class 'generator'>
t = tuple(t)
print(t, type(t)) # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) <class 'tuple'>

元组和列表的区别

列表 元组
可变序列 不可变序列
append()、insert()、remove()、pop()等方法实现添加和删除列表元素 无法实现添加、删除和修改元素的操作
支持切片访问和修改列表中的元素 支持切片访问元素,不支持修改操作
访问和处理速度慢 访问和处理速度快
不能作为字典的键 可以作为字典的键

字典

字典是无序的键值对集合,通过键从字典中获取对应的值,但不能通过索引来获取。使用{}定义字典,键值对之间用逗号分隔,键和值之间用冒号分隔。字典中的键必须是唯一的,如果出现两次,后出现的将覆盖先出现的。并且键要求是不可变序列。字典是Python中的可变序列。

创建以及删除

字典的创建可以通过如下方式:

  • 直接使用{}创建字典

    1
    d = {key1: value1, key2: value2...}
  • 使用内置函数dict()创建字典

    • 通过映射函数创建字典

      1
      2
      3
      4
      5
      6
      #zip(lst1, lst2)
      lst1 = [1, 2, 3]
      lst2 = ['a', 'b', 'c']
      zip_obj = zip(lst1, lst2)
      d = dict(zip_obj)
      print(d) #{1: 'a', 2: 'b', 3: 'c'}
    • 通过给定关键字创建字典

      1
      2
      # dict(key1 = value1, key2 = value2...)
      d = dict(a=1, b=2) #但是反过来数字不能在左边,可能是因为key必须是不可变的

字典的删除可以通过如下方式:

1
del 字典名

访问和遍历

字典元素可以通过如下方式进行访问:

1
2
d[key]或者d.get(key)
#get(key[, default]),如果key存在于字典中则返回对应的值,反正返回default。default未给出则默认返回None。

字典元素可以通过如下方式进行遍历:

1
2
3
4
5
6
#方式1
for element in d.items():
pass
#方式2
for key, value in d.items():
pass

相关操作方法

方法 描述
d.keys() 获取所有的key数据
d.values() 获取所有的value数据
d.pop(key, default) key存在获取对应的vaule,同时删除可键值对,否则获取默认值default
d.popitem() 随机从字典中取出一个键值对,如果为元组类型,同时将该键值对从字典中删除
d.clear() 清空字典中所有的键值对

字典生成式

  • 使用指定范围的数作为key生成字典

    1
    2
    3
    #d = {key: value for item in range}
    import random
    d = {item: random.randint(1, 100) for item in range(4)}
  • 使用映射函数生成字典

    1
    d = {key: value for key, value in zip(lst1, lst2)}

集合

Python中的集合与数学中集合的概念一致,使用{}定义,元素之间使用逗号分隔。集合只能存储不可变数据类型(字符串、整数、浮点数、元组),集合中的元素要求是唯一的,并且集合中的key是无序的。集合可分为可变集合set与不可变集合frozenset。

创建以及删除

集合的创建可以通过如下方式:

  • 直接使用{}创建集合

    1
    s={元素1, 元素2, ..., 元素N}
  • 使用内置函数set()创建集合

    1
    s=set(可迭代对象)

集合的删除可以通过如下方式:

1
del 集合名

集合的操作符

1
2
3
4
5
6
7
8
9
10
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
# 交集
print(A & B) #{4, 5}
# 并集
print(A | B) #{1, 2, 3, 4, 5, 6, 7, 8}
# 差集
print(A - B) #{1, 2, 3}
# 补集
print(A ^ B) #{1, 2, 3, 6, 7, 8}

遍历

  • 使用遍历循环for

    1
    2
    for item in s:
    pass
  • 使用for循环和enumerate()函数

    1
    2
    for index, item in enumerate(s, 10): #10表示元素的序号,不是索引,可以任意指定
    pass

相关操作方法

方法 描述
s.add(e) 如果e不在集合s中,则将e添加到集合s
s.remove(e) 如果e在集合中,将其删除;如果不在集合中,程序报错
s.clear() 清楚集合中所有元素

集合生成式

1
2
3
4
5
s={i for i in range(11)}
print(s) #{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
#选择符合条件的元素组成新集合
s={i for i in range(11) if i%2==0}
print(s) #{0, 2, 4, 6, 8, 10}

列表、元组、字典和集合的区别

数据类型 序列类型 是否重复 是否有序 定义符号
列表list 可变序列 可重复 有序 []
元组tuple 不可变序列 可重复 有序 ()
字典dict 可变序列 key不可重复
value可重复
无序 {key:value}
集合set 可变序列 不可重复 无序 {}