经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Python » 查看文章
Python常用的数据结构
来源：cnblogs　　作者：九幽帝君　　时间：2022/1/17 11:11:10　　对本文有异议

一、list 列表

1、列表的特点

有序的，元素可以重复，列表中的元素可以进行增上改查，可以存放不同的数据类型

2、创建列表

  • 中括号创建并填充 --->[]

  • 通过构造函数创建 list()

  • 列表推导式 ---> [x for x in li if x ...]

  1. """创建列表"""
  2. # 1、通过构造函数创建 list()
  3. li = list()
  4. print(li, type(li))
  5. li1 = list('helloworld')
  6. print(li1, type(li1))
  7. # 2、中括号创建并填充 []
  8. li2 = [1, 2, 3, 4, 4]
  9. li3 = ['helloworld', 'apple']
  10. li4 = [1, 3.4, True, 'tea', [1, 2, 3]]
  11. print(li2, type(li2))
  12. print(li3, type(li3))
  13. print(li4, type(li4))
  14. # 3、列表推导式
  15. li5 = [i for i in range(1, 10) if i % 2 == 0]
  16. print(li5, type(li5))
3、列表索引

  • 默认正向索引，编号从 0 开始。

  • 支持反向索引，编号从-1 开始。

  1. "列表索引"
  2. list1 = [1, 3, 5, 6, 8, 10]
  3. # 默认正向索引，编号从 0 开始。
  4. print(list1[0])
  5. print(list1[3])
  6. # 支持反向索引，编号从-1 开始。
  7. print(list1[-6])
  8. print(list1[-3])
4、列表切片 [start:stop:step]

  • start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；

  • stop 值: 指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取列表允许的最大索引值；

  • step 值: 步长值指示每一步大小，如果没有指定，则默认步长值为 1。

  • 三个值都是可选的，非必填

  1. li = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']
  2. print(li[2:4])
  3. print(li[3:6])
  4. print(li[2:7])
  5. print(li[2:])
  6. print(li[3:6:2])
  7. print(li[2:8:4])
  8. print(li[2:8:])
  9. print(li[2::])
  10. print(li[:2])
  11. print(li[::3])
  12. print(li[::-1])  # 逆序打印
5、列表运算符

  • 重复

    • 使用 * 运算符可以重复生成列表元素。

  • 合并

    • 使用 + 加号运算符，可以将两个列表合二为一

  1. li1 = [1, 2] * 5
  2. li2 = [1, 2, 3]
  3. li3 = [1, 2, 4, 5]
  4. # 重复   使用 `*` 运算符可以重复生成列表元素。
  5. print(li1)
  6. # 合并   使用 `+` 加号运算符，可以将两个列表合二为一。
  7. print(li2 + li3)
6、列表成员检测

  • in：检查一个对象是否在列表中，如果在则返回 True，否则返回 False。

  • not in：检查一个列表是否不包含某个元素。如果不在返回 True，否则返回 False。

  1. li3 = [1, 2, 4, 5]
  2. print(1 in li3)
  3. print(6 not in li3)
  4. print(8 is li3)
7、列表方法

  • append()

append(item)：将一个对象 item 添加到列表的末尾。
入参：对象 item
返回：None 
  1. # append()
  2. list1 = []
  3. print(list1)
  4. list1.append(1)
  5. list1.append(3.14)
  6. list1.append("apple")
  7. print(list1)
  • extend()
extend(iterable)：将一个可迭代对象的所有元素，添加到列表末尾。
入参：可迭代对象 iterable
返回：None 
  1. # extend()
  2. list1 = [1, 2, 3, 4, 'apple']
  3. print(list1)
  4. list1.extend('HelloWorld')  # 添加的是字符串的所有字母
  5. list1.extend([8, 89, 185])  # 接收列表的所有元素
  6. list1.extend((1, 5))  # 接收元组的所有元素
  7. list1.extend({"a": 1}) # 接收字典的所有key值
  8. print(list1)
  • insert()
insert(index, item)：将一个对象插入到指定的索引位置
入参：索引值 index ，一个对象 item
返回：None
原索引位置及后面的元素后移一位 
  1. # insert()
  2. lis1 = [1, 2, 4, 6, 9]
  3. print(lis1)
  4. lis1.insert(0, 3)
  5. print(lis1)
  6. lis1.insert(4, "apple")
  7. print(lis1)
  • pop()
pop(index) 或 pop()
弹出并返回所指定索引的元素。
入参：索引值 index，可不传
返回：指定索引的元素
返回：未指定索引则返回末尾元素
如果索引值不正确，或者列表已经为空，则引发 IndexError 错误 
  1. # pop()
  2. letters = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']
  3. print(letters, len(letters))
  4. # letters.pop(8)  # 报错：IndexError: pop index out of range
  5. letters.pop(0)
  6. print(letters, len(letters))
  7. letters.pop()
  8. print(letters, len(letters))
  9. letters.pop()
  10. print(letters, len(letters))
  11. letters.pop(3)
  12. print(letters, len(letters))
  • remove()
remove(item)
移除列表中第一个等于 item 的元素
入参：指定元素 item
返回：None
目标元素必须已存在，否则会报 ValueError 
  1. # remove()
  2. letters = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']
  3. print(letters, len(letters))
  4. # letters.remove('p')  # 报错，不存在 ValueError: list.remove(x): x not in list
  5. letters.remove('t')
  6. print(letters, len(letters))
  • sort()
sort(key=None, reverse=False)
对列表进行原地排序，只使用 < 来进行各项间比较。
入参：支持 2 个关键字参数：
key：指定带有一个参数的函数，用于从每个列表元素中提取比较键。
reverse：默认值为 False 表示升序，为 True 表示降序
返回：None 
  1. # sort()
  2. nums = [2, 4, 3, 1, 5]
  3. print(nums)
  4. # 不传参数，默认升序，数字从小到大排列
  5. nums.sort()
  6. print(nums)
  7. # 指定key=len，按元素的长度排序
  8. words = ['Python', 'Java', 'R', 'Go']
  9. print(words)
  10. words.sort(key=len)
  11. print(words)
  12. # 指定reverse=True，降序
  13. lis1 = [1, 2, 4, 6, 9]
  14. print(lis1)
  15. lis1.sort(reverse=True)
  16. print(lis1)
  • reverse()
reverse()：将列表中的元素顺序反转
参数：无
返回：None
反转只是针对索引值，元素之间不相互比较。 
  1. # reverse()
  2. nums = [8, 1, 5, 2, 77]
  3. print(nums)
  4. nums.reverse()
  5. print(nums)
8、列表嵌套

  • 创建嵌套列表

  • 访问嵌套列表的元素

  1. """列表嵌套"""
  2. # 创建嵌套列表
  3. num = [[1, 2, 3], [3, 8, 98]]
  4. print(num, len(num))
  5. # 访问嵌套列表的元素
  6. print(num[0][1])
  7. print(num[1][2])
  8. num[1].append("李梓杰")
  9. print(num)
9、列表推导式
列表推导式是指循环创建列表，相当于 for 循环创建列表的简化版
语法：[x for x in li if x ...] 
  1. """列表推导式"""
  2. # 语法：[x for x in li if x ...]
  3. # 实例1：将 1-10 中的所有偶数平方后组成新的列表
  4. # 普通的
  5. result = []
  6. for a in range(1, 11):
  7.     if a % 2 == 0:
  8.         result.append(a ** 2)
  9. print(result)
  10. # 列表推导式
  11. res = [b ** 2 for b in range(1, 11) if b % 2 == 0]
  12. print(res)
  14. # 实例2：将 20-30 中的所有基数组成新的列表
  15. # 普通
  16. d = []
  17. for c in range(20, 31):
  18.     if c % 2 != 0:
  19.         d.append(c)
  20. print(d)
  21. # 列表推导式
  22. f = [v for v in range(20, 31) if v % 2 != 0]
  23. print(f)

二、tuple 元组

1、元组的特点

有序，元素可以重复，元组中的元素是不可以修改的，可以存放不同的数据类型

2、创建元组

  • 使用逗号分隔

  • 通过小括号填充元素

  • 通过构造方法 tuple(iterable)

  1. """创建元组"""
  2. # 1、使用逗号分隔
  3. tup1 = 1, 2, 3
  4. print(tup1, type(tup1))
  5. # 2、过小括号填充元素
  6. tup2 = (1, 2, 3, 4, 5)
  7. tup3 = (1, 2, 4.5, True, "TTTT", (1, 2, 3), [1, 99, 555])
  8. print(tup2, type(tup3))
  9. print(tup3, type(tup3))
  10. # 3、通过构造方法 tuple(iterable)
  11. a = tuple()
  12. print(a, type(a))
  13. a1 = tuple((1, 2, 3))  # 添加组，单个无法添加
  14. print(a1, type(a1))
  15. a2 = tuple([1, 2, 4])
  16. print(a2, type(a2))
3、元组索引

  • 正向索引，默认编号从 0 开始

  • 反向索引，默认编号从-1 开始

  1. """元组索引"""
  2. # 正向索引，默认编号从 0 开始
  3. tup2 = (1, 2, 3, 4, 5)
  4. print(tup2[2])
  5. tup1 = (range(1, 9))
  6. print(tup1[3])
  7. # 反向索引，默认编号从-1 开始
  8. print(tup2[-3])
  9. print(tup1[-3])
4、元组切片[start: stop: step]
  1. """元组切片"""
  2. tup2 = (1, 2, 3, 4, 5, 8, 9)
  3. print(tup2[:])  # 打印整个元素
  4. print(tup2[:-2]) 
  5. print(tup2[2:4]) 
  6. print(tup2[2:7:2])
5、元组常用方法

  • index()

index(item)
返回与目标元素相匹配的首个元素的索引。
目标必须在元组中存在的，否则会报错ValueError 
  1. # 1、index() # 查看元组中元素的索引值
  2. tup2 = (1, 2, 3, 4, 5, 8, 9)
  3. print(tup2.index(3))
  4. print(tup2.index(9))
  5. # print(tup2.index(20))  # 目标必须在元组中存在的，否则会报错 ValueError: tuple.index(x): x not in tuple
  6. tup3 = ('H', 'e', 'l', 'l', 'o')
  7. print(tup3.index('H'))
  8. # print(tup3.index('0')) # 目标必须在元组中存在的，否则会报错 ValueError: tuple.index(x): x not in tuple
  • count()
count(item)：返回某个元素出现的次数。
入参：对象 item
返回：次数 
  1. tup3 = (1, 1, 1, 1, 3, 3, 8)
  2. print(tup3.count(3))
  3. print(tup3.count(1))
  4. print(tup3.count(8))
6、元组的解包

把一个可迭代对象里的元素，一并赋值到由对应的变量组成的元组中。

  • 传统逐个赋值的方式

  • 使用元组解包，一气呵成

  1. # 传统逐个赋值的方式
  2. t = (1, 2, 3)
  3. a = t[0]  # 索引
  4. b = t[1]
  5. c = t[2]
  6. print(a, b, c)
  7. # 使用元组解包，一气呵成
  8. a, b, c = (1, 2, 3)
  9. print(a, b, c)
7、元组与列表

  • 相同点

    • 都是有序的，元素可以重复

    • 都是异构的，能够包含不同类型的对象

    • 都支持索引和切片

  • 区别

    • 声明方式不同，元组使用()，列表使用 []

    • 列表是可变的，元组是不可变的

三、set 集合

1、集合的特点

无序、用大括号{}包围、添加或删除元素、可以存放不同的数据类型、去重

2、创建集合

  • 通过使用{}填充元素

  • 通过构造方法 set()

  • 通过集合推导式

  1. """创建集合"""
  2. # 1、使用大括号{}填充元素
  3. set1 = {1, 2, 3, 4.5, "ll"}
  4. print(set1)
  5. set2 = {1, 1, 2, 3, 3}
  6. print(set2)  # 去重set()
  7. # 2、使用构造方法创建集合 set()
  8. a = set('hello')
  9. print(a)
  10. b = set()  # 空集
  11. print(b)
  12. # 3、使用集合推导式
  13. set3 = {x for x in range(1, 11)}
  14. print(set3)
  15. set4 = {x * 2 for x in range(1, 11) if x % 2 == 0}
  16. print(set4)
  17. # 注意：不要单独使用{ }来创建空集合
  18. set4 = {}  # 这是字典类型
  19. print(set4, type(set4))
3、集合成员检测

  • in 判断元素是否在集合中存在

  • not in 判断元素是否在集合中不存在

  1. set1 = {1, 2, 3, 4.5, "ll"}
  2. # in
  3. print(1 in set1)
  4. print(6 in set1)
  5. # not
  6. print("ll" not in set1)
  7. print(6 not in set1)
4、集合方法

  • add()

add(item)：将单个对象添加到集合中
入参：对象 item
返回：None 
  1. # add() 随机添加位置
  2. set1 = {1, 2, 3, 5}
  3. print(set1, len(set1))  # len()函数 计算长度
  4. set1.add('happy')
  5. set1.add(96)  
  6. set1.add(12)
  7. set1.add("hh")
  8. set1.add(4.6)
  9. print(set1, len(set1))
  • update()
update(iterable) 批量添加来自可迭代对象中的所有元素
入参：可迭代对象 iterable
返回：None 
  1. a = set()
  2. print(a)
  3. a.update('hello')  # 随机填入
  4. print(a)
  5. # 1、批量添加列表中的元素
  6. a.update([1, 2, 3])
  7. print(a)
  8. # 2、批量添加元组中的元素
  9. a.update((1, 2, 4))
  10. print(a)
  11. # 3、批量添加集合中的元素
  12. a.update({99, 88})
  13. print(a)
  • remove()
remove(item)：从集合中移除指定元素 item。
入参：指定元素值
返回：None
如果 item 不存在于集合中则会引发 KeyError 
  1. set1 = {1, 2, 3, 5}
  2. print(set1)
  3. # 1、删除已存在的元素
  4. set1.remove(1)
  5. print(set1)
  6. # 2、删除不存在的元素  报错：KeyError: 6
  7. set1.remove(6)
  8. print(set1)
  • discard()
discard(item)：从集合中移除指定对象 item。
入参：指定元素值
返回：None
元素 item 不存在没影响，不会抛出 KeyError 错误。 
  1. set1 = {1, 2, 3, 6}
  2. print(set1)
  3. set1.discard(6)
  4. print(set1)  # 没有元素，也不会报错
  5. set1.discard(888)
  • pop()
pop()：随机从集合中移除并返回一个元素。
入参：无。
返回：被移除的元组。
如果集合为空则会引发 KeyError。 
  1. set1 = {1, 2, 3, 7}
  2. print(set1)
  3. # 1、随机删除某个对象
  4. set1.pop()
  5. print(set1)
  6. # 2、集合本身为空会报错 # KeyError: 'pop from an empty set'
  7. set2 = set()
  8. set2.pop()
  9. print(set2)
  • clear()
clear()：清空集合，移除所有元素
入参：无
返回：None 
  1. st = {1, 2, 3, 4, 5}
  2. print(st)
  3. st.clear()
  4. print(st)
5、集合运算
交集运算并集运算差集运算
intersection() union() difference()
操作符：& 操作符：｜ 操作符： - 
  1. """集合运算"""
  2. st = {1, 2, 3, 4, 5}
  3. st2 = {5, 8, 7, 1, 2}
  4. # 交集运算
  5. # 1 、intersection()
  6. # 2、操作符： &
  7. print(st.intersection(st2))
  8. print(st & st2)
  9. # 并集运算
  10. # 1、union()
  11. # 2、操作符：｜
  12. print(st.union(st2))
  13. print(st | st2)
  14. # 差集运算
  15. # 1、difference()
  16. # 2、操作符： -
  17. print(st.difference(st2))
  18. print(st - st2)
6、集合的推导式

语法：{x for x in ... if ...}

  1. # 语法 {x for x in ... if ...}
  2. b = set()
  3. for y in 'hogwarts':
  4.     if y in 'hello world':
  5.         b.add(y)
  6. print(b)
  8. a = {x for x in 'hogwarts' if x in 'hello world'}
  9. print(a)

四、dict 字典

1、字典的特征

无序的，用大括号{}包围，键值对的形式，键是不可以重复的

2、创建字典

  • 使用大括号填充键值对 {}

  • 通过构造方法 dict()

  • 使用字典推导式

  1. # 1、使用大括号填充键值对 {}
  2. a = {'name': '张学友', "age": 50}
  3. print(a, type(a))
  4. # 2、通过构造方法 dict()
  5. a1 = dict()
  6. print(a1, type(a1))
  7. a2 = dict(name='李梓杰', age=24)
  8. print(a2, type(a2))
  9. dc3 = dict([("name", "Harry Potter"), ("age", 18)])
  10. print(type(dc3), dc3)
  11. # 3、使用字典推导式
  12. dc4 = {k: v for k, v in [("name", "Harry Potter"), ("age", 18)]}
  13. print(type(dc4), dc4)
3、访问字典中元素

  • 访问存在的key

  • 访问不存在的key，会报KeyError错误

  1. """访问字典中元素"""
  2. a = {'name': '理财友', "age": 50}
  3. # 1、访问存在的[key]
  4. print(a['name'], a['age'])
  5. # 2、访问不存在的key，会报KeyError错误
  6. print(a['hobby'])
4、字典操作元素（添加修改）

  • 语法：dict[key] = value

  • 添加元素

    • 键不存在

  • 修改元素

    • 键已经存在

  1. a = {'name': '理财友', "age": 50}
  2. print(a, type(a))
  3. # 语法：dict[key] = value
  4. # 1、添加元素 键不存在
  5. a['hobby'] = '骑马'
  6. print(a, type(a))
  7. # 2、修改元素 键已经存在
  8. a['name'] = '王彬彬'
  9. print(a)
5、字典嵌套

  • 嵌套字典

  • 字典的值可以是字典对象

  1. """嵌套字典"""
  2. a = {'name': '理财友', "age": 50, 'mark': {'python': 30, 'math': 56}}
  3. print(a)
  4. # 1、获取课程math的值
  5. print(a['mark']['math'])
  6. # 2、把python分数改成100分
  7. a['mark']['python'] = 89
  8. print(a)
6、字典方法
keys()values()items()
返回由字典键组成的一个新视图对象。 返回由字典值组成的一个新视图对象。 返回由字典项 ((键, 值) 对) 组成的一个新视图对象。 
  1. # keys()、values()、items()
  2. dc = {"name": "Harry Potter", "age": 18}
  3. # 1、返回由字典键组成的一个新视图对象。  keys()
  4. a = dc.keys()
  5. print(a)
  6. # 2、返回由字典值组成的一个新视图对象。  values()
  7. a1 = dc.values()
  8. print(a1)
  9. # 3、返回由字典项 ((键, 值) 对) 组成的一个新视图对象。 items()
  10. a2 = dc.items()
  11. print(a2)
  • get()
获取指定 key 关联的 value 值。
入参: key：字典的键，必传。
返回： 如果Key存在于字典中，返回Key关联的Value值 如果Key不存在，则返回None
此方法的好处是无需担心 key 是否存在，永远都不会引发 KeyError 错误。 
  1. dc = {"name": "Harry Potter", "age": 18}
  2. # 1、访问存在的key
  3. print(dc.get('name'))
  4. # 2、访问不存在的key
  5. print(dc.get('hobby'))  # None
  • update()
使用来自 dict 的键/值对更新字典，覆盖原有的键和值。
入参：字典对象，必传
返回：None 
  1. dc = {"name": "Harry Potter", "age": 18}
  2. print(dc)
  3. dc.update({'mark': {'english': 30, 'math': 88}})
  4. print(dc)
  • pop()
删除指定 key 的键值对，并返回对应 value 值。
入参： key：必传
返回： 如果 key 存在于字典中，则将其移除并返回 value 值 如果 key 不存在于字典中，则会引发 KeyError 
  1. dc = {"name": "Harry Potter", "age": 18, 'mark': {'english': 30, 'math': 88}}
  2. print(dc)
  3. # 1、弹出
  4. dc.pop('name')
  5. print(dc) 
  6. # 2、删除不存在的key  # 报错KeyError
  7. dc.pop('dog')
  8. print(dc)
7、字典推导式

实例1：给定一个字典对象{'a': 1, 'b': 2, 'c': 3}，找出其中所有大于 1 的键值对，同时 value 值进行平方运算。

实例2：给定一个字典对象，请使用字典推导式，将它的key和value分别进行交换。也就是key变成值，值变成key。 输入: {'a': 2, 'b': 8, 'c': 4} 输出: {2: 'a',8: 'b', 4: 'c'}

  1. """字典推导式"""
  2. """
  3. 实例1：给定一个字典对象{'a': 1, 'b': 2, 'c': 3}，找出其中所有大于 1 的键值对，同时 value 值进行平方运算。
  4. """
  5. # 未使用字典推导式的写法
  6. a = {'a': 1, 'b': 2, 'c': 3}
  7. b = dict()
  8. for k, v in a.items():
  9.     if v > 1:
  10.         b[k] = v ** 2
  11. print(b)
  12. # 使用字典推导式
  13. c = {k: v ** 2 for k, v in a.items() if v > 1}
  14. print(c)
  16. """
  17. 实例2:给定一个字典对象，请使用字典推导式，将它的key和value分别进行交换。也就是key变成值，值变成key。
  18. 输入: {'a': 2, 'b': 8, 'c': 4}
  19. 输出: {2: 'a',8: 'b', 4: 'c'}
  20. """
  21. dc = {'a': 2, 'b': 8, 'c': 4}
  23. f = {v: k for k, v in dc.items()}
  24. print(f)

 

本文来自博客园，作者：{jiuyou-emperor}，转载请注明原文链接：{https://www.cnblogs.com/jiuyou-emperor/}

原文链接：http://www.cnblogs.com/jiuyou-emperor/p/15808838.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Python热门文章

  • Python | 新冠肺炎疫情数据的爬取与可视化分析
  • Python爬小草1024图片，盖达尔的诱惑（urllib.request）
  • pytorch如何获得模型的计算量和参数量
  • 计算曲线与坐标轴的面积
  • 基于Python实现语音合成小工具
  • PyQt5笔记之弹出窗口大全
  • python反编译学习之字节码详解
  • Python爬虫基础讲解（二十）：多进程——multiprocessing模块的使用
  • python?OpenCV计算图片相似度的5种算法
  • matplotlib 设置图形大小时 figsize 与 dpi 的关系

    • Python推荐文章

  • python 音频处理（2)——提取PPG特征之whisper库的使用（2.1）
  • 《最新出炉》系列初窥篇-Python+Playwright自动化测试-60 - 判断元素是否显示 - 下篇 - 北京-宏哥
  • [python] 启发式算法库scikit-opt使用指北
  • 《最新出炉》系列初窥篇-Python+Playwright自动化测试-59 - 判断元素是否显示 - 上篇 - 北京-宏哥
  • 界面自动化测试录制工具，让python selenium自动化测试脚本开发更加方便
  • 《最新出炉》系列入门篇-Python+Playwright自动化测试-56- 多文件上传 - 下篇 - 北京-宏哥
  • 音频文件降噪及python示例
  • 全网最适合入门的面向对象编程教程：20 类和对象的 Python 实现-组合关系的实现与 CSV 文件保存
  • 张高兴的 MicroPython 入门指南：（一）环境配置、Blink、部署
  • Python——比 Seaborn 更好的相关性热力图：Biokit Corrplot

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号