Python学习笔记（三） 数据结构与常用方法

数据结构是计算机内部对数据按一定的结构进行排列组织的存放，以达到快速查找，提取但目的

常见的数据结构有：列表、字典、元组、集合、双端队列、区间

列表

列表是一种常用的数据结构，可以容纳各种类型的数据

#两种创建列表的方式
list1=[]
list2=list()  #python的一个内置函数，可以直接使用
#更推荐第一种方式

#列表中的元素可以是任意的数据类型（也可以嵌套其他的数据结构）
list1=[1,'2354',False,[1,2]]

print(type(list1))
#列表的数据类型为list

#内置的转换函数list
tuple1=(1,2,3)
print(type(tuple1))  #输出tuple
tuple1= list(tuple1)
print(type(tuple1))  #输出的不是tuple而是list

#序列：是一种数据结构对象。某个对象以数据结构的形式保存数据
list1=[1,2,3] #也可以将其称之为一个列表序列，是一个对象

#列表的索引，与字符串的索引相同
list1=[1,2,3,4,5,6]
print(list1[3])  #查看list索引位3的元素，输出4
print(list1[0:4]) #查看索引位0开始，索引位3结束（不包含4）
print(list1[1:]) #查看索引位1开始，输出到最后
print(list1[:4]) #查看索引0开始到第三位
print(list1[1:-1]) #查看索引1开始到倒数第二位
#带有步长的查询
print(list1[1:5:2]) #查看索引1开始到索引5，步长为2，输出结果为2,4,6

#列表的加法
list1=[1,2,3,4,5,6]
list2=[1,2,3]
print(list1 + list2)
#[1, 2, 3, 4, 5, 6, 1, 2, 3]，将两个列表进行了组合

#列表的乘法
print(list2 * 2)
#输出[1, 2, 3, 1, 2, 3]，只能乘数字

#列表添加元素append
list1=[1,2,3,4]
list1.append('12345sq') #一次只能传递一个元素,在尾部添加
print(list1)
#[1, 2, 3, 4, '12345sq']
list1.append([1,2]) #传递进去一个列表
print(list1)
#[1, 2, 3, 4, '12345sq', [1, 2]]

#列表添加元素insert
list1=[1,2,3,4]
list1.insert(0,'wqe') #在索引0的位置前插入元素，也只能一次传递一个元素
print(list1)
#['wqe', 1, 2, 3, 4]

#列表中删除元素remove,pop,del
list1=[1,2,3,4]
list1.remove(4) #制定要删除的内容，输入这个元素
print(list1)
#[1,2,3]
list1.pop()     #弹出末尾的一个元素，但pop会把这个元素返回
var=list1.pop() #把最后一位‘2’,弹出并赋值到var
print(var)
#2
del list[0]    #删除指定索引0的元素
#del 是一个关键字，而不是和remove、pop一样是一种方法

#列表修改和查看元素
list1=[1,2,3,4,5]
list1[0]='ws'
print(list1)
#[ws,2,3,4,5]

#列表修改和查看元素——索引叠加
list1=[1,2,3,4,5,['ws','qwe',['ert','uty']]]
print(list1[5][2][1])
#uty

#列表的元素排序——reverse倒叙排序
list1=[1,2,3,4,5]
list1.reverse()
print(list1)
#[5, 4, 3, 2, 1]

#列表的元素排序——sort可自定义排序
list1=['qwe','asdc','szcqqq','aaaaaaa','a']
#参数reverse=Ture代表倒序排序，False为正序排序
#参数key作为排序依据 
list1.sort(key=len,reverse=False)  #key=len说明以字符以多到少排序
print(list1)
#['a', 'qwe', 'asdc', 'szcqqq', 'aaaaaaa']

内置函数len max min

list1=[1,2,3,4,5]
list2=['10','20','30','40','50']
str1='ABCDE edcba'

#len函数 返回字符串长度
print(len(list1)) #输出5
print(len(list2)) #输出5
print(len(str1)) #输出11

#max函数 返回ASCII码值最大的
print(max(list1))  #输出5
print(max(list2))  #输出5，对字符串处理时逐个处理
print(max(str1))   #输出e

#min函数 返回ASCII码值最小的，同上

方法count、index

#count——统计元素出现的次数
list1=[1,2,3,4,5,6,1]
print(list1.count(1))
#2

#index——统计元素的位置
list1=[1,2,3,4,5,6,1]
print(list1.index(4)) #返回元素的索引的位置
#3

list1=[1,2,3,[4,5],6,1] 
print(list1.index(5)) #无法搜索嵌套列表的值
#报错
list1=[1,2,3,['4',5],6,1]
print(list1.index('4')) #无法搜索嵌套列表的值
#报错
list1=[1,2,3,['4',5],6,1]
print(list1[3].index('4')) #通过指定列表所在位置
#0

字典

通过键值对key=value的形式保存元素的一种数据结构

#创建字典
dict1={'ws':123,'qwe':'weq','王':'sheng'} #字典的key不允许相同、且key必须为常量
print(type(dict1)) #

#创建字典，用内置函数的方式
dict1=dict([['qwe','ewq'],['asd','dsa']])
print(dict1)
#{'qwe': 'ewq', 'asd': 'dsa'}

#字典通过key查找value
dict1={'ws':123,'qwe':'weq','王':'sheng'}
print(dict1['ws'])
#123
print(dict1['NA'])
#报错

#字典通过get方法查找value 不会报错
print(dict1.get('NA'))
#None

#在字典中添加元素——直接赋值新的key
dict1={'ws':123,'qwe':'weq','王':'sheng'}
dict1['ads']='qcvx'
print(dict1)
#{'ws': 123, 'qwe': 'weq', '王': 'sheng', 'ads': 'qcvx'}

#在字典中添加元素——setdefault传参
dict1={'ws':123,'qwe':'weq','王':'sheng'}
dict1.setdefault('ads','wqw') #前面为key，后面为value，如果没有value则会记为空
print(dict1)
#{'ws': 123, 'qwe': 'weq', '王': 'sheng', 'ads': 'wqw'}
#{'ws': 123, 'qwe': 'weq', '王': 'sheng', 'ads': None}

#在字典中删除元素——del、pop
dict1={'ws':123,'qwe':'weq','王':'sheng'}
del dict1['ws']
print(dict1)
#{'qwe': 'weq', '王': 'sheng'}
dict1={'ws':123,'qwe':'weq','王':'sheng'}
var=dict1.pop('ws')
print(var)
#123
print(dict1)
#{'qwe': 'weq', '王': 'sheng'}

#字典中修改value——重新赋值、update
dict1={'ws':123,'qwe':'weq','王':'sheng'}
dict1['ws']='ws'
print(dict1)
#{'ws': 'ws', 'qwe': 'weq', '王': 'sheng'}
dict1.update({'ws':'wsc'})
print(dict1)
#{'ws': 'wsc', 'qwe': 'weq', '王': 'sheng'}

#获取字典的key、value与键值对——keys(),values(),items()
dict1={'ws':123,'qwe':'weq','王':'sheng'}
print(dict1.keys())
print(dict1.values())
print(dict1.items())
#dict_keys(['ws', 'qwe', '王'])
#dict_values([123, 'weq', 'sheng'])
#dict_items([('ws', 123), ('qwe', 'weq'), ('王', 'sheng')])

元组

一种不可变的数据结构，一旦创建不能添加、删除与修改 出于数据安全考虑的，安全性很高

#创建元组
tuple1=(1,'2',True,[2,4],(1,2))
print(type(tuple1)) #

#内置转换函数tuple
list1=[1,2,3]
tuple1=tuple(list1)
print(tuple1)
#(1, 2, 3)

#可以通过赋予变量的重新创建对元组进行修改
tuple1=(1,'2',True,[2,4],(1,2))
var1=2
tuple1=(var1,'2',True,[2,4],(1,2))
print(tuple1)
#(2, '2', True, [2, 4], (1, 2))

封包与解包

封包：将多个值赋值给一个变量 解包：将一个元组或列表赋值给多个变量

#解包，一一赋值，多或少都会导致报错
tuple1=(1,2,3,4)
var1,var2,var3,var4=tuple1
print(var1,var2,var3,var4)
#1 2 3 4

#封包————让变量赋值多元素
tuple1=(1,2,3,4)
*var1,var2,var3=tuple1
print(var1,var2,var3)
#[1, 2] 3 4 用列表来承载多元素

集合

分为可变集合set和不可变集合fornzset

特点：不支持索引，元素随机排列，只能包含常量，不能重复，有重复自动删除

#创建集合
set1={1,2,3,5,6,7,8,7,8,True,(1,3)}
print(type(set1)) #
print(set1)
#{1, 2, 3, (1, 3), 5, 6, 7, 8}

#可变集合添加元素add
set1={1, 2, 3, (1, 3), 5, 6, 7, 8}
set1.add('ws')
print(set1)
#{1, 2, (1, 3), 3, 5, 6, 7, 8, 'ws'}

#可变集合删除元素remove、discord
set1.remove('ws')
print(set1)
#{1, 2, (1, 3), 3, 5, 6, 7, 8}
set1.remove('ws')
print(set1)
#报错
set1.discard('ws')
print(set1)
#不会报错，什么都不执行

#pop也可以在集合中使用，同理

#集合用以消除 在列表相加而出现的重复元素
list1=[1,2,3,4]
list2=[2,3,4,5,6]
list3=list(set(list1 + list2))
print(list3)
#[1, 2, 3, 4, 5, 6]

集合的关系测试

set1={1,2,'qwe'}
set2={2,3,'erq'}
set3={1,5,4,'qwe'}

#包含关系判断issubclass、issuperset
print(set1.issubset(set2)) # 测试前面的集合是不是后面集合的子集
#False
print(set1.issuperset(set2)) # 测试前面的集合是否完全包含后面的集合
#False

#集合相减difference、difference_update
print(set1.difference(set3)) #difference集合相减
set1-set3 #等同于
print(set1) #set1不会有变化吗，需要再次赋值之后才行
#{1, 2, 'qwe'}
set1.difference_update(set3) #difference_update集合相减立即生效
print(set1)
#{2}

#集合相交intersection、intersection_update
set1=set1.intersection(set3) #n找出相交的元素，通过赋值给予
set1 & set3 #等同于
print(set1)
set1.intersection_update(set2) #立即成效给set1
print(set1)

#集合并集union、update
set1=set1.union(set2)
print(set1)
#{'erq', 1, 2, 'qwe', 3}
set1.update(set2)
print(set1)
#{1, 2, 3, 'erq', 'qwe'}

不可变集合

和元组差不多，所以不支持自动生效的关系测试的方法，例如只支持关系判断issubclass，集合相减difference，集合相交intersection，集合并集union

元组是有序的，但不可变集合是无序的

#创建
fest1=frozenset([1,2,3,4])
print(type(fest1))
#