一个小白的网安学习之路之Python入门二：Python的数据结构（列表、元组、字典、集合）

python数据结构

列表

列表的创建

• 使用中括号

  lst=['程序员','python']
  

• 调用内置函数

  lst2=list(['程序员','python'])
  

列表的内存示意图

列表的特点

• 列表可以任意数据混存

• 列表可以根据需要动态回收和分配内存

• 索引

  

列表元素的索引查询index()

x = ['hello', 'james', 56,'hello'] #索引从0开始
print(x.index('hello')) #如果列表中元素重复, 只打印首次出现元素的索引位置
print(x.index('xxxx')) #报错, 不存在
print(x.index('hello',1,3)) #从1位置开始查, 到第3个位置, 但不包括3，所以这里也是报错

列表的存在查询in

• in与not in

  lst = [10,20,30,'james']
  print(20 in lst)#True
  print(40 in lst)#False
  print(40 not in lst)#True
  

• 列表元素的遍历

  for str in lst: #[10,20,30,'james']
      print(str)
  

切片操作

• 语法格式：列表名[start : stop : step]

  

  小总结：Python中，[start : stop : step]类似的组合经常出现，规律有三点：一是三者顺序不变；二是范围是从start开始到stop，但不包含stop；三是省去start，就默认从0开始，省去stop，就默认到最后一位，省去step，默认为1。

  • 切片操作：[start : stop : step]（省时冒号不去）
  • range(start : stop : step)（省时冒号去）
  • index(‘str’,start,stop)

添加元素

append()

• 在列表的末尾添加一个元素

  lst = [10,20,30]
  lst.append(100) #追加列表最右侧
  

extend()

• 在列表末尾至少添加一个元素

  lst = [10,20,30]
  lst2 = ['hello', 'James']
  #lst.append(lst2)是不对的
  lst.extend(lst2)
  

insert()

• 在列表的任意位置添加一个元素

  lst = [10,20,30]
  lst.insert(1,90)
  print(lst)#结果是10,90,20,30
  

切片

• 在列表的任意一个位置添加至少一个元素

  # 原始列表
  original_list = [1, 2, 3, 4]
  
  # 要插入的元素
  new_elements = [10, 20
                  
  # 确定插入位置
  start_index = 2
  original_list[start_index:start_index] = new_elements  
                  
  print(original_list)  # 输出: [1, 2, 10, 20, 3, 4]
  

删除操作

remove()

• 一次删除一个元素

• 重复元素只删除第一个

• 元素不存在则抛出ValueError

  lst = [10,20,30,40,50,60,30]
  lst.remove(30) #删除列表从左到右的第一次出现30的元素
  

pop()

• 删除一个指定索引位置上的元素

• 指定索引不存在则抛出IndexError

• 不指定索引，删除列表最后一个元素

  #根据索引来删
  lst = [10,20,30,40,50,60,30]
  lst.pop(1)
  lst.pop() #不指定要删除哪个索引, 会去删除列表右侧最后的1个
  

切片

• 一次至少删除一个元素

  #切片来删除
  lst = [10,20,30,40,50,60,30]
  lst[1:3] = []
  

clear()

• 清空列表

  lst.clear()
  

del

• 删除列表

  del lst
  

列表元素排序

sort()

• 调用sort()方法，列有中的所有元素默认按照升序（从小到大）的顺序进行排序，可以指定reverse=True，进行降序排序

  lst = [10,45,23,78,12]
  lst.sort() #升序排序
  #通过一些关键字
  lst.sort(reverse=True) #True从大到小, 降序进行排序
  lst.sort(reverse=False)
  

sorted()

• 调用内置函数sorted()，升序排列，可以指定reverse=True，进行降序排序，原列表不发生改变

  lst = [10,45,23,78,12]
  new_lst = sorted(lst) #升序排序
  new_lst = sorted(lst,reverse=True)#降序排列
  

列表生成式

• 语法格式

  #举例说明
  lst = [i*i for i in range(1,10)]
  #lst生成结果是[1,4,9,16,25,36,49,64,81]
  

元组

元组的定义

• Python内置的数据结构之一，是一个不可变序列

  • 不可变序: 字符串、元组（没有增、删，改的操作）
  • 可变序列: 列表、字典、集合（可以对序列执行增、删、改操作，对象地址不变）

元组的创建

• 直接使用小括号 ( )

  #使用()
  t = ('James','帅','开玩笑的',[20,30])
  print(t)
  print(type(t))
  
  #不加括号也行
  tt = 'James','帅','开玩笑的',[20,30]
  print(tt)
  print(type(tt))
  
  #注意点：只有一个元素要加括号和逗号
  ttt = ('James',)
  print(ttt)
  print(type(ttt))
  

• 使用内置函数tuple( )

  #使用tuple()进行创建
  t2 = tuple(('James','帅','开玩笑的',[20,30]))
  print(t2)
  print(type(t2))
  

  小总结：

  • lst = [] #空的列表
    lst1 = list()

  • d = {}#空的字典
    d1 = dict()

  • t3 = ()#空的元组
    t3 = tuple()

元组设置为不可变序列的原因

• 在多任务环境下，同时操作对象时不需要加锁

• 因此，在程序中尽量使用不可变序列

  注意事项：元组中存储的是对象的引用（地址）

  • a)如果元组中对象本身不可对象，则不能再引用其它对象

  • b)如果元组中的对象是可变对象，则可变对象的引用（地址）不允许改变，但数据可以改变

  

元组的遍历

• 元组是可迭代对象，所以可以使用for…in进行遍历

  t = ('James','真帅' ,'这是开玩笑的')
  
  #遍历元组
  for it in t:
      print it)
  

字典

字典的创建

• 定义：Python中的字典是根据key查找value所在的位置

• 使用花括号创建

  order = {'订单号':10032, '时间 ':20210807, '价格':9.9, '金额':99}
  

• 使用内置函数dict()

  order = dict(订单号='10032', 时间 ='20210807')
  

获取字典中的元素

• [ ]取值

  s = {'张呈':100, 'James':101, '王根基':70}
  print(s['James'])
  

  [ ]取值如果字典中不存在指定的key，抛出keyError异常

• get()方法取值

  s = {'张呈':100, 'James':101, '王根基':70}
  s.get('James')
  

  get()方法取值，如果字典中不存在指定的key，并不会抛出KeyError而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回

字典Key的存在判断

• in与not in

  s = {'张呈':100, 'James':101, '王根基':70}
  print('James' in s)#True
  print('James' not in s)#Flase
  

元素增删改

• 删除元素

  s = {'张呈':100, 'James':101, '王根基':70}
  del s['张呈']
  

• 新增元素

  s['xxx']=60 #新增一个元素
  

• 修改元素

  s['James']=200 #修改
  

字典的视图

• 获取字典所有key

  s = {'张呈':100, 'James':101, '王根基':70}
  
  keys = s.keys() #获取字典s所有的key
  print(keys)#dict_keys(['张呈', 'James', '王根基'])
  print(type(keys))#dict_keys
  print(list(keys)) #将所有的key转成列表
  

• 获取字典所有value

  values = s.values() #获取字典里所有的value
  print(values)#dict_values([100, 101, 70])
  print(type(values))#dict_values
  print(list(values)) #将所有的value转成列表
  

• 获取字典所有key-value

  items = s.items()#获取字典所有的key-value
  print(items) #dict_items([('张呈', 100), ('James', 101), ('王根基', 70)])
  #元组, 后面会讲
  print(list(items))#[('张呈', 100), ('James', 101), ('王根基', 70)]
  

字典元素的遍历

• 使用for in

  for item in scores:
  	print(item)
  

字典的特点

• 字典中的所有元素都是一个key-value对,
• key不允许重复, value可以重复字典中的元素是无序的字典中的
• key必须是不可变对象
• 字典也可以根据需要动态地伸缩
• 字典会浪费较大的内存,是一种使用空间换时间的数据结构

字典生成式

• 内置函数zip()

  用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表

  

• 字典生成式

  

  items = ['James', 'Sail', 'Hock']
  wifes = ['TeacherCang','Fengjie','yangmi','xiaozhe','zbz']
  
  d = {item:wife for item, wife in zip(items,wifes)}#遍历for x in xs，生成形式item:wife
  print(d)
  

集合

集合的定义

• python内置数据结构，与列表字典一样是可变类型的序列，相当于没有value的字典（与字典一样key不可重复）

  

集合的创建

• 使用大括号 { }

  #第一种创建集合的方式
  s1 = {1,2,3,4,5,6,7} #集合
  s2 = {11,223,33,44,55}
  print(s1)
  

• 使用内置函数set( )

  #第二种:set()方法来创建集合--列表list()  字典dict()  元组tuple()
  s1 = set(range(6))
  print(s1, type(s1))
  
  ss = set((1,2,3,4,5,3,3,5)) #元组变集合，自动去掉重复的元素 
  print(ss, type(ss))
  sss = set([1,2,3,4,5,3,3,5]) #列表变集合，自动去掉重复的元素
  print(ss, type(ss))
  

• 如何定义空的集合

  #如何定义一个空的集合
  ssss = {} #空的字典
  print(type(ssss))
  sssss = set() #空的集合
  print(type(sssss))
  

集合的查、增、删

集合的存在查询

• in或not in

  #集合的in  not in
  s1 = {1,2,3,4,5,6,7} #集合
  print(1 in s1)
  print(1 not in s1)
  print(100 not in s1)
  print(100  in s1)
  

集合元素的新增

• add( )方法，一次添加一个元素

  #向集合里新增数据
  s1 = {1,2,3,4,5,6,7} #集合
  s1.add(8)
  print(s1)
  

• update( )方法，至少添加一个元素

  #增加多个元素
  s1 = {1,2,3,4,5,6,7} #集合
  s1.update({100,200,300})
  print(s1)
  

集合元素的删除操作

• remove( )方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError

  #集合删除的操作
  s1.remove(88)
  

• discard( )方法，一次删除一个指定元素，如果指定的元素不存在不抛出异常

  s1.discard(23)
  

• pop( )方法，一次只删除一个任意元素

  s1.pop()
  

• clear( )方法，清空集合

  s1.clear()
  

集合间的关系

• 相等：==或!=

  s = {1,2,3,4} #集合
  s1 = {2,3,4,1}
  print(s == s1)
  

• A是B的子集：A.issubset(B)

  #集合中的子集判断
  s1 = {1,2,3,4}
  s2 = {1,2}
  s3 = {1,2,5}
  print(s2.issubset(s1)) #true
  print(s3.issubset(s1)) #False
  

• A是B的超集：A.issuperset(B)

  #判断一个集合是不是另一个集合超集
  s1 = {1,2,3,4}
  s2 = {1,2}
  s3 = {1,2,5}
  print(s1.issuperset(s2)) #True
  print(s1.issuperset(s3)) #False
  

• 两个集合是否没有交集：A.isdisjoint(B)

  #两集合之间有没有相交的地方
  s1 = {1,2,3,4}
  s2 = {1,2}
  s3 = {1,2,5}
  print(s2.isdisjoint(s3)) #有相交的地方, 它返回False
  s4={77,88}
  print(s2.isdisjoint(s4)) #没有交集返回True
  

集合的数据操作

• 数据操作包括：交集、并集、差集、对称差集

  

• 交集

  #交集
  print(s1.intersection(s2))
  print(s1 & s2)
  

• 并集

  #并集
  print(s1.union(s2))
  print(s1 | s2)
  

• 差集

  #差集
  print(s2.difference(s1))
  print(s2-s1)
  

• 对称差集

  #对称差集
  print(s1.symmetric_difference(s2))
  print(s1^s2)
  

集合生成式

• 公式

  

  #集合生成式
  s = {i*i for i in range(10)} #和列表生成式的区别是花括号
  print(s)
  

列表、元组、字典、集合总结

• 不可变序 : 字符串、元组（没有增、删，改的操作）

• 可变序列 : 列表、字典、集合（可以对序列执行增、删、改操作，对象地址不变）

• 集合虽然是可变序列，但是其元素必须是不可变的

• 列表一般需要动态修改数据时使用

• 元组一般数据是固定的或者数据需要保护时使用