Python 测开27期 - WL - 学习笔记 - python 常用数据结构

学习笔记
1

Python 常用数据结构

list 列表

列表定义与使用

  • 列表是有序的可变元素的集合，使用中括号包围，元素之间用逗号隔开
  • 列表是动态的，了随时扩展和收缩，不需要提前声明，解释器会根据需要自动分配内存
  • 列表是异构的，可以同时存放不同类型的对象，可存放空值、数字、字符串、元组、列表、集合、字典
  • 列表中允许出现重复元素

创建列表

  • 通过构造函数创建
  • 中括号创建并填充
  • 列表推导式
    image

示例：

# *** list 列表创建 ***
# 1 构造方法
aa = list()
bb = list('happy')
print(type(bb),bb)
print(aa,type(aa))
# 2 中括号填充
cc = [1,2,3.03]
dd = ['e','r','t']
ff = [[99,98,97],96.66,{"didi":"thinks"}]
print(cc,dd,ff)
# 3 列表推导式
xx = [i for i in range(4,12) if i%2==0]
print(xx,type(xx))

列表常用方法

索引

  • 默认正向索引，编号从0开始，从左向右
  • 支持反向索引，编号从-1开始，从右向左
    image

示例

yy = [3.1,3.2,3.3,3.4]
# 1 正向索引
print(yy[2])
# 2 反向索引
print(yy[-2])

切片[start:stop:step]

  • start值：指示开始索引值，如果没有指定，默认开始值为0；
  • stop值：指示到哪个索引值结束，但不包括这个结束索引值，如果没有指定，则默认最大索引值；
  • strp值：步长值指示每一步大小，如果没有指定，默认步长值为1
  • 三个值均为选填项
    image
    image1329×333 51.3 KB

列表运算符

  • 重复：使用*运算符，可以重复生成列表元素
  • 合并：使用+运算符，可以将两个列表合二为一
    image

示例：

# 运算符
# 1 *号
yy = [1]
print(yy * 5)
# 打印值为：[1, 1, 1, 1, 1]
xx = [yy[0]*3]
print(xx * 4)
# 打印值为：[3, 3, 3, 3]
# 2 +号
yy1 = yy * 5
xx1 = xx *4
print(yy1 + xx1)
# 打印值为：[1, 1, 1, 1, 1, 3, 3, 3, 3]

成员检测

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

示例：

yy = [3.1,3.2,3.3,3.4,3.5,3.6,3.7,3.8,3.9,3.101,3.102,3.103,3.104]
# in
print(3.104 in yy)
# 打印值为：True
print('a' in yy)
# 打印值为：False
# not in
print('w' not in yy)
# 打印值为：True
print(3.101 not in yy)
# 打印值为：False

列表方法

  • 方法名、入参-是否接收参数、接收几个参数、是否必填、不填是否有默认值、返回值、没有返回值则默认返回None
往列表中添加新的元素
  • .append(item)：将一个对象item添加到列表的末尾，入参：item，返回值：None
    image

示例：

aa = []
aa.append(321)
aa.append('dd')
aa.append(3.66636)
aa.append([3,42,'a'])
aa.append({"name":"long","url":"https://www.baidu.com"})
aa.append(('a',1,2))

print(aa)
# 打印值为：[321, 'dd', 3.66636, [3, 42, 'a'], 
{'name': 'long', 'url': 'https://www.baidu.com'}, ('a', 1, 2)]
print(len(aa))
# 打印值为：6
  • .extend(iterable)：将一个可迭代对象的所有元素，添加到列表末尾，入参：iterable，返回值：None
    image

示例：

aa = []
aa.extend('school')
aa.extend([5,67,8])
aa.extend(('e','r','tt'))
aa.extend({"name":"long","school":"汉中"})
print(aa)
# 打印值为：['s', 'c', 'h', 'o', 'o', 'l', 
5, 67, 8, 'e', 'r', 'tt', 'name', 'school']
print(len(aa))
# 打印值为：14
  • .insert(index, item)：将一个对象插入到指定的索引位置，入参：索引值index，一个对象item，返回值：None，原索引位置及后边的元素后移一位
    image

示例

aa = [6,5,4]
aa.insert(1,[3,2,1])
print(aa)
# 打印值为：[6, [3, 2, 1], 5, 4]
移除列表中现有元素
  • .pop()或pop(index)：弹出并返回指定索引的元素，入参：index可以不传，返回：指定索引的元素，未指定索引则返回末尾元素，如果索引不正确或不存在，或列表已为空，则引发IndexError错误
    image
    image869×325 29.8 KB

示例：

aa = [6,5,[3,2,1],4]

print(aa.pop())
# 打印值为：4
print(aa)
# 打印值为：[6, 5, [3, 2, 1]]
print(aa.pop(2))
# 打印值为：[3, 2, 1]
print(aa.pop(2))
# 打印值为：IndexError: pop index out of range
  • .remove(item)：移除列表中第一个等于item的元素，入参：指定元素item，返回值为：None，目标元素必须存在，否则报错：ValueError
    image

示例：

aa = [6,5,4,[3,2,1],4]

aa.remove(4)
print(aa)
# 打印值为：[6, 5, [3, 2, 1], 4]
aa.remove(3)
# 打印值为：ValueError: list.remove(x): x not in list
给列表元素排序
  • .sort(key=None, reverse = False)：对列表进行原地排序，只使用<来进行各项间比较，入参：支持2个关键字参数，
    ** key：指定带有一个参数的函数，用于从每个列表元素中提取比较键
    ** reverse：默认值为False表示升序，为True则为降序
    ** 返回值为None
    image
    image812×484 48.8 KB

示例：

aa = [5,3,7,1,9,36,541,21,9]
aa.sort()
print(aa)
# 打印值为：[1, 3, 5, 7, 9, 9, 21, 36, 541]
aa.sort(reverse=True)
print(aa)
# 打印值为：[541, 36, 21, 9, 9, 7, 5, 3, 1]

xx = ['school','name','eye','happy','m','M','is']
xx.sort(key=len)
print(xx)
# 打印值为：['m', 'M', 'is', 'eye', 'name', 'happy', 'school']
  • .reverse()：将列表中的元素顺序反转，参数：无，返回：None，反转只针对索引值，元素之间不相互比较
    image

示例：

aa = [5,3,7,'a',9,36,541,21,'happy']

aa.reverse()
print(aa)
# 打印值为：['happy', 21, 541, 36, 9, 'a', 7, 3, 5]

列表嵌套

  • 嵌套列表是值在列表中存放列表
  • 列表的常用方法都适用于嵌套列表
    image

列表推导式

  • 列表推导式是指循环创建列表，相当于for循环创建列表的简化版
  • 语法：[x for x in list if x …]
    image
    image912×432 48.5 KB

示例：

# 循环方法
ss = []
for i  in range(0,20):
    if i % 2 ==0:
        ss.append(i ** 2)
print(ss)
# 打印值为：[0, 4, 16, 36, 64, 100, 144, 196, 256, 324]

# 列表推导式方法
xx = []
xx = [i ** 2 for i in range(0, 20) if i % 2 == 0]
print(xx)
# 打印值为：[0, 4, 16, 36, 64, 100, 144, 196, 256, 324]

tuple 元组

元组的定义与使用

元组定义

  • 元组是有序的不可变对象集合，可看作常量列表，元素的值不可以被修改
  • 元组使用小括号包围，各个对象之间使用逗号分隔
  • 元组是异构的，可以包含多种数据类型，如数字、字符串、元组、列表、集合、字典等

元组创建

  • 使用逗号分隔
  • 通过小括号填充元素
  • 通过构造方法tuple(iterable)
    image

示例：

# 1. 使用逗号分隔
tu1 = 1,2,3,3,4
print(type(tu1),tu1)
#打印值为：<class 'tuple'> (1, 2, 3, 3, 4)
# 2， 使用小括号填充元素
tu2 = ('a','b','c','d','e')
print(type(tu2),tu2)
#打印值为：<class 'tuple'> ('a', 'b', 'c', 'd', 'e')
# 3. 通过构造函数tuple(iterable)
tu3 = tuple()
print(type(tu3),tu3)
#打印值为：<class 'tuple'> ()
tu4 = tuple('happy')
print(type(tu4), tu4)
#打印值为：<class 'tuple'> ('h', 'a', 'p', 'p', 'y')
tu5 = tuple(['ff','ss','fff','ggg'])
print(type(tu5), tu5)
#打印值为：<class 'tuple'> ('ff', 'ss', 'fff', 'ggg')
# 4. 注意：单元素的元组，逗号不能缺失
aa = 1,
bb = (3,)
cc = tuple('d')
print(aa,bb,cc)
#打印值为：(1,) (3,) ('d',)

元组的使用

索引：可以通过索引值来访问对应的元素
  • 正向索引：默认编号从0开始，从左向右
  • 反向索引：默认编号从-1开始，从右向左
    image

示例：

# 索引
tu = ('you','happy','i','am','not','happy')
print(tu)
# 1 正向索引
print(tu[3]) #打印值为：am
# 2 反向索引
print(tu[-2]) #打印值为：not
元组切片[start:stop:step]
  • 三个值都是可选的，非必填
  • start：指示开始索引值，如果没有指定，默认开始值为0
  • stop：指示到哪个索引值结束，但不包含这个结束索引值，如果没有指定，则取最大索引值
  • step：步长值指示每一步大小，没有指定时，默认步长值为1
  • 当使用[::-1]时，可直接获取顺序反转的元组image

示例：

# 切片
tu = ('you','happy','i','am','not','happy',1,2,3,4,5,6,7,8,9)

print(tu[::2]) # 打印值为：('you', 'i', 'not', 1, 3, 5, 7, 9)
print(tu[3::2]) # 打印值为：('am', 'happy', 2, 4, 6, 8)
print(tu[7:12]) # 打印值为：(2, 3, 4, 5, 6)

元组常用方法

  • index(item)：返回与目标元素相匹配的首个元素的索引，目标必须在元组中存在，否则报错
    image

示例：

tu = (1,2,3,4,5,6,7,8,9)

print(tu.index(3)) # 打印值为：8
print(tu.index(11)) # 打印报错：ValueError: tuple.index(x): x not in tuple
  • count(item)：返回某个元素出现的次数，入参：item，返回值：此参数出现的次数
    image

示例：

tu = (1,2,3,4,5,6,7,8,9,1,2,1,2,3,1,1)

print(tu.count('a')) # 打印值为：0
print(tu.count(1)) # 打印值为：5
  • 元组解包：把一个可迭代对象里的元素，一并赋值到由对应的变量组成的元组中
    image

示例：

tup = (11,22,33)
print(tup)
# 传统赋值
a = tup[0]
b = tup[1]
c = tup[2]
print(a,b,c) # 打印值为：11 22 33
# 元组解包
a,b,c = tup
print(a,b,c,tup) # 打印值为：11 22 33 (11, 22, 33)

元组与列表

相同点

  • 都是有序的
  • 都是异构的，能够包含不同类型的对象
  • 都支持索引和切片

不同点

  • 声明方式不同，元组使用()，列表使用
  • 列表元素是可变的，元组元素是不可变的

set 集合

集合定义与使用

集合的定义

  • 无序的唯一对象集合，任何对象都不会重复
  • 用大括号包围，对象相互之间使用逗号分隔
  • 集合是动态的，可以随时添加或删除元素
  • 集合是异构的，可以包含不同类型的数据

集合的创建

  • 通过使用{}填充元素
  • 通过构造方法set()
  • 通过集合推导式
  • 注意：不要单独使用{}创建空集合
    image
    image826×554 46.7 KB

示例：

# 通过使用{}填充元素
set1 = {1,2,3,1}
print(set1,type(set1))
# 打印值为：{1, 2, 3} <class 'set'>
# 通过构造方法set()
set2 = set('happynewyear')
print(set2,type(set2))
# 打印值为：{'h', 'e', 'p', 'r', 'y', 'a', 'n', 'w'} <class 'set'>
set3 = set([9,8,56,14,23])
print(set3)
# 通过集合推导式
set4 = {i for i in range(0,5) if i % 2 ==0}
print(set4)
# 打印值为：{0, 2, 4}

成员检测

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

示例：

set1 = {'a','b','c','e','f','g'}
print('a' in set1) # 打印值为：True
print(1 in set1) # 打印值为：False
print(1 not in set1) # 打印值为：True
print('a' not in set1) # 打印值为：False

集合常用方法

集合增加元素

  • add(item)：将单个对象添加到集合中，入参：item，返回值为：None
    image

示例：

set1 = {1,2,3}
print(set1) # 打印值为：{1, 2, 3}
set1.add('a')
print(set1) # 打印值为：{1, 2, 3, 'a'}
set1.add(1)
print(set1) # 打印值为：{1, 2, 3, 'a'}
  • update(iterable)：批量添加来自可迭代对象中的所有元素，入参：可迭代对象iterable，返回值为：None
    image

示例：

set1 = {1,2,3}
aa = ['x','y','z',1,2]
print(set1) # 打印值为：{1, 2, 3}
set1.update(aa)
print(set1) # 打印值为：{1, 2, 3, 'y', 'z', 'x'}
set1.update('tree')
print(set1) # 打印值为：{1, 2, 3, 'z', 'y', 't', 'e', 'r', 'x'}

集合移除元素

  • remove(item)：从集合中移除指定元素item，入参：item，返回值为：None，如果item值不存在，则报错Key Error
    image

示例：

set1 = {1,2,3}
print(set1) # 打印值为：{1, 2, 3}
set1.remove(3)
print(set1) # 打印值为：{1, 2}
set1.remove(4)
print(set1) # 报错：KeyError: 4
  • discard(item)：从集合中移除指定对象item，入参：指定对象值，返回值为：None，元素item不存在也没有影响，不会抛出KetError错误
    image

示例：

set1 = {1,2,3}
print(set1) # 打印值为：{1, 2, 3}
set1.discard(3)
print(set1) # 打印值为：{1, 2}
set1.discard(4)
print(set1) # 打印值为：{1, 2}
  • pop()：随机从集合中移除并返回一个元素，入参：无，返回值为：被移除的元素，如果集合为空会报错KetError
    image

示例：

set1 = {1,2,3,'a','b','c'}
print(set1) # 打印值为：{1, 2, 3, 'a', 'c', 'b'}
print(set1,set1.pop()) # 打印值为：{1, 2, 3, 'b', 'c'} a

set2 = {1}
print(set2,set2.pop()) # 打印值为：set() 1
print(set2,set2.pop()) # 报错：KeyError: 'pop from an empty set'
  • clear()：清空集合，移除所有元素，入参：无，返回值：None
    image

示例：

set1 = {1,2,3,'a','b','c'}
print(set1) # 打印值为：{1, 2, 3, 'a', 'c', 'b'}
print(set1,set1.clear()) # 打印值为：set() None
print(set1,set1.clear()) # 打印值为：set() None

集合运算

  • 交集运算：两个集合中相同部分
    ** intersection()，操作符：&
    image

示例：

set1 = {1,2,3,'a','b','c'}
set2 = {30,40,50,60,3,'a'}
print(set1.intersection(set2)) # 打印值为：{3, 'a'}
print(set1 & set2) # 打印值为：{3, 'a'}
  • 并集运算：两个集合加起来的所有部分
    ** union()，操作符：|
    image

示例：

set1 = {1,2,3,'a','b','c'}
set2 = {30,40,50,60,3,'a'}
set3 = {'zz','汉字'}
print(set1.union(set2).union(set3))
# 打印值为：{1, 2, 3, 'b', 'c', 40, 'a', '汉字', 50, 'zz', 60, 30}
print(set1 | set2 | set3)
# 打印值为：{1, 2, 3, 'b', 'c', 40, 'a', '汉字', 50, 'zz', 60, 30}
  • 差集运算：某个集合中所有与另一个集合不同的部分
    ** difference()，操作符：-
    image

示例：

set1 = {1,2,3,'a','b','c'}
set2 = {30,40,50,60,3,'a'}
set3 = {'zz','汉字',1,2}

print(set1.difference(set2))
# 打印值为：{1, 2, 'c', 'b'}
print(set3.difference(set1.difference(set2)))
# 打印值为：{'zz', '汉字'}

集合推导式

  • 类似列表推导式，同样集合支持集合推导式
  • 语法：{x for x in … if …}
    image

示例：

set1 = {i **3 for i in range(0,8) if i %2 != 0}
print(set1) # 打印值为：{1, 27, 125, 343}

set2 = {k for k in 'dahuaxiyou2' if k in 'menghuanxiyou'}
print(set2) # 打印值为：{'i', 'h', 'y', 'a', 'o', 'x', 'u'}

dict 字典

字典定义与使用

字典定义

  • 字典是无序的键值对集合
  • 字典用大括号包围
  • 每个键值对的键与值之间需要用冒号分隔
  • 键值对与键值对之间需要用逗号分隔
  • 字典是动态的
  • 键有唯一性，值的类型不限制

创建字典

示例：

# 使用大括号填充键值对
dc1 = {"name":"xy2","year":3}
print(dc1,type(dc1))
# 打印值为：{'name': 'xy2', 'year': 3} <class 'dict'>
# 通过构造方法dict()
dc2 = dict([('name', 'xy1'),('year',2),('id', 12)])
print(dc2,type(dc2))
# 打印值为：{'name': 'xy1', 'year': 2, 'id': 12} <class 'dict'>
# 使用字典推导式
dc3 = {k:j for k,j in [('name', 'xy3'),('year',1),('id', 13)] }
print(dc3,type(dc3))
# 打印值为：{'name': 'xy3', 'year': 1, 'id': 13} <class 'dict'>

字典的使用

访问元素
  • 与字典也支持中括号记法[key]
  • 字典使用键来访问其关联的值
  • 访问时对应的key必须要存在
    image

示例：

dc1 = {'name': 'xy3', 'year': 1, 'id': 13}
print(dc1,type(dc1))
# 打印值为：{'name': 'xy3', 'year': 1, 'id': 13} <class 'dict'>
# 1 访问存在的key
print(dc1['name'])
# 打印值为：xy3

# 访问不存在的key
print(dc1['hommer'])
# 打印值为：KeyError: 'hommer'

操作元素

  • 语法：dict[key] = value
  • 添加元素：添加的键必须不存在
  • 修改元素：修改的键必须存在
    image

示例：

dc1 = {'name': 'xy3', 'year': 1, 'id': 13}
print(dc1,type(dc1))
# 打印值为：{'name': 'xy3', 'year': 1, 'id': 13} <class 'dict'>

# 修改年份
dc1['year'] = 2013
print(dc1)
# 打印值为：{'name': 'xy3', 'year': 2013, 'id': 13}
# 添加pet
dc1['pet'] = ['pig', 'dog', 'sheep', 'chicken','horse','Monkey',
'Snake','dragon','rat', 'ox', 'tiger', 'rabbit']
print(dc1)
# 打印值为：{'name': 'xy3', 'year': 2013, 'id': 13, 'pet': ['pig', 'dog', 'sheep',
 'chicken', 'horse', 'Monkey', 'Snake', 'dragon', 'rat', 'ox', 'tiger', 'rabbit']}

嵌套字典

字典常用方法

  • keys()：返回由字典键组成的一个新视图对象，入参：无，返回：新视图对象，可以被迭代
    image

  • values()：返回由字典值组成的一个新视图对象，入参：无，返回：新视图对象，可以被迭代
    image

  • items()：返回由字典项((键,值)对)组成的一个新视图对象，入参：无，返回：新视图对象，可以被迭代

    image
    image852×355 36 KB

示例：

dc1 = {'name': 'xy3', 'year': 1, 'id': 13}
print(dc1,type(dc1))
# 打印值为：{'name': 'xy3', 'year': 1, 'id': 13} <class 'dict'>

print(dc1.keys())
# 打印值为：dict_keys(['name', 'year', 'id'])
print(dc1.values())
# 打印值为：dict_values(['xy3', 1, 13])
print(dc1.items())
# 打印值为：dict_items([('name', 'xy3'), ('year', 1), ('id', 13)])

# ## 转换为list显示
print(list(dc1.keys()))
# 打印值为：['name', 'year', 'id']
print(list(dc1.values()))
# 打印值为：['xy3', 1, 13]
print(list(dc1.items()))
# 打印值为：[('name', 'xy3'), ('year', 1), ('id', 13)]
  • get(key)：获取指定key关联的值，入参：key必传，返回值：若key存在则返回对应值，若key不存在则返回None，无需担心key是否存在，不会引起KeyError错误
    image
    image823×324 29.6 KB

示例：

dc1 = {'name': 'xy3', 'year': 1, 'id': 13}
print(dc1,type(dc1))
# 打印值为：{'name': 'xy3', 'year': 1, 'id': 13} <class 'dict'>

print(dc1.get('name')) # 打印值为：xy3
print(dc1['name']) # 打印值为：xy3

print(dc1.get('pet')) # 打印值为：None
print(dc1['pet']) # 报错：KeyError: 'pet'
  • update(dict)：使用来自dict的键/值对更新字典，覆盖原有的键和值，入参：dc，字典对象，必穿，返回值：None
    image

示例：

dc1 = {'name': 'xy3', 'year': 1, 'id': 13}
print(dc1,type(dc1))
# 打印值为：{'name': 'xy3', 'year': 1, 'id': 13} <class 'dict'>

dc1.update({"id":16,'pet':'dog'})
print(dc1)
# 打印值为：{'name': 'xy3', 'year': 1, 'id': 16, 'pet': 'dog'}
  • pop(key)：删除指定key的键值对，并返回对应的value值，入参：key必传，返回值：若key存在则移除对应的键值对并返回key对应的值，若key不存在则报错KeyError
    image

示例：

dc1 = {'name': 'xy3', 'year': 1, 'id': 13}
print(dc1,type(dc1))
# 打印值为：{'name': 'xy3', 'year': 1, 'id': 13} <class 'dict'>

print(dc1,dc1.pop('id'))
# 打印值为：{'name': 'xy3', 'year': 1} 13
print(dc1,dc1.pop('pet'))
# 报错：KeyError: 'pet'

字典推导式

  • 可以从任何以键值对作为元素的可迭代对象中构建出字典
  • 实例：给定一个字典对象{‘a’:1,‘b’:2,‘c’:3}，找出其中所有大于1的键值对，同时value值进行平方运算
    image
    image821×333 31.8 KB

示例：

dc1 = {x: k for x, k in [('name', 'xy3'), ('year', 1), ('id', 13)]}
print(dc1, type(dc1))
# 打印值为：{'name': 'xy3', 'year': 1, 'id': 13} <class 'dict'>

dc2 = {'a': 1, 'b': 2, 'c': 3}
# 传统计算方法
dara = dict()
for k,v in dc2.items():
    if v > 1:
        dara[k] = v**2
print( dara)  # 打印值为：{'b': 4, 'c': 9}
# 字典推导式
dara2= {x:k**2 for x,k in dc2.items() if k >1}
print(dara2)  # 打印值为：{'b': 4, 'c': 9}

实例

image
image1517×234 36.7 KB

示例：

# 给定一个字典对象，请使用字典推导式，将key与value分别交换，就是key变成值，值变成key
# 输入：        {'a':1,'b':2,'c':3}
# 需要输出      {'1':'a','2':'b','3':'c'}
dc1 = {'a' :1 ,'b' :2 ,'c' :3}
# 传统方法
dc2 = {}
lis1 = list(dc1.keys())
lis2 = list(dc1.values())
for i in range(0, len(lis1)):
    dc2.update({lis2[i]:lis1[i]})
    i = i+1
print(dc2)
# 打印值为：{1: 'a', 2: 'b', 3: 'c'}
# 字典推导式
dc3 = {x:k for k,x in dc1.items() }
print(dc3)
# 打印值为：{1: 'a', 2: 'b', 3: 'c'}