07 - 元组&字典&集合

07 - 元组&字典&集合

1 . 元组简介
  • 元组 tuple

  • 元组是一个不可变(一般希望数据不可改变时,使用元组,其他情况基本使用列表)

    • my_tuple = (1,2,3,4,5)
      print(type(my_tuple),my_tuple)
      # <class 'tuple'> (1, 2, 3, 4, 5)
      
  • 使用 ()创建元组

  • 元组不为空 至少有一个逗号(,)当元组不是空元组时,括号可以省略

    • my_tuple = 1,
      print(my_tuple)
      # (1,)
      
  • 元组解包 : 元组当中每一个元素都赋值给一个变量

    • my_tuple = (1,2,3,4,5)
      my_tuple[2] = 10
      # TypeError: 'tuple' object does not support item assignment
      
      my_tuple = 10,20,30,40
      a,b,c,d = my_tuple
      print(a,b,c,d)
      # 10 20 30 40
      
      a,b = my_tuple
      print(my_tuple)
      # ValueError: too many values to unpack (expected 2)
      
      a,b,*c = my_tuple
      print(a,b,c)
      # 10 20 [30, 40]
      
      a,*b,c = my_tuple
      print(a,b,c)
      # 10 [20, 30] 40
      
      *a,b,c = my_tuple
      print(a,b,c)
      # [10, 20] 30 40
      
      *a,*b,c = my_tuple
      print(a,b,c)
      # SyntaxError: two starred expressions in assignment
      
      # 字符串解包
      a,b,*c = 'hello world'
      print(a,b,c)
      #   h e ['l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
      
      # 列表解包
      a,*b,c = [1,2,3,4,5,6,7]
      print(a,b,c)
      # 1 [2, 3, 4, 5, 6] 7
      
      
2 . 字典简介
2.1 字典的基本介绍
  • 字典属于一种新的数据结构称为映射(mapping)

  • 字典的作用与列表类似,都是用来存储对象的容器

  • 列表存储数据的性能好,但查询数据的性能差,字典正好与之相反

  • 在字典中每一个元素都有唯一的名字,通过这个唯一的名字可以找到指定的元素

  • 这个唯一的名字我们称之为KEY,通过KEY可以快速查询VALUE,也可以称之为值

  • 字典 也可以称之为键值对(key - value)结构

  • 每个字典中都可以有多个键值对,每一个键值对称之为一项(item)

  • 创建一个有数据的字典 语法 {key : value}

  • 字典的值可以是任意对象 字典的键可以是任意的不可变对象 (int str bool tuple …)

  • 字典的键是不能重复的,如果出现重复的后面的会替换前面的

    • d = {'name':'钢铁侠','age':38,'sex':'男','name':'葫芦娃'}
      # 需要根据键来获取值
      print(d['name'],d['age'],d['sex'])
      # 葫芦娃 38 男
      
      print(len(d))
      # 3
      
      print('name' in d )
      # True
      
      print('age' not in d )
      # False
      
      print(d['name'])
      # 葫芦娃
      
      print(d['n'])
      # KeyError: 'n'
      
2.2 字典的使用
  • dict() 函数来创建字典

    • d = dict(name='奥尼尔',age=48,MVP='YES')
      print(d)
      # {'name': '奥尼尔', 'age': 48, 'MVP': 'YES'}
      
  • get(key[,default]) 根据键来获取字典的值。第二个参数可以指定一个默认值,当获取不到值的时候会返回默认值

    • d = {'name':'钢铁侠','age':38,'sex':'男','name':'葫芦娃'}
      print(d.get('name','age'),d.get('age')) # get里面只能带一个键
      # 葫芦娃 38
      print(d.get('hello'))
      # None
      
  • 添加、修改字典元素

    • d = {'name':'钢铁侠','age':38,'sex':'男','name':'葫芦娃'}
      d['name'] = '科比'
      d['phone'] = '123456789'
      print(d)
      #{'name': '科比', 'age': 38, 'sex': '男', 'phone': '123456789'}
      
    • update() 将其他字典的key - value 添加到当前的字典中

      • d1 = {'a':1,'b':2,'c':3 }
        d2 = {'d':4,'e':5,'f':6 }
        d1.update(d2)
        print(d1)
        print(d2)
        # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
        # {'d': 4, 'e': 5, 'f': 6}
        
    • setdefault(key,[default]) 向字典中添加 key-value,如果这个key已经存在于字典当中,则返回key值,不会对字典有任何的影响;如果Key不存在 则向字典中添加这个key 并设置value

      • d = {'name':'钢铁侠','age':38,'sex':'男','name':'葫芦娃'}
        res = d.setdefault('name','詹姆斯')
        res = d.setdefault('MVP','Jordan')
        print(res)
        print(d)
        # Jordan
        # {'name': '葫芦娃', 'age': 38, 'sex': '男', 'MVP': 'Jordan'}
        
  • del 删除字典中的key - value

    • d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
      del d1['b']
      print(d1)
      # {'a': 1, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
      
  • popitem() 删除字典最后的一个key - value 这个方法是有返回值的。删除后会将删除的key - value作为返回值返回

    • d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
      d1.popitem()
      print(d1)
      # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
      
      res = d1.popitem()
      print(res)
      print(d1)
      # ('e', 5)
      # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
      
  • pop(key[,default]) 根据key删除自定中的value。第二个参数可以指定一个默认值,当获取不到值的时候会返回默认值

    • d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
      res = d1.pop('g','Key值不存在!')
      print(res)
      # Key值不存在!
      
  • clear() 清空字典

    • d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
      d1.clear()
      print(d1)
      # {}
      
2.3 copy()
  • copy() 方法用来对字典进行浅复制

  • 注意: 浅复制只会复制字典本身,如果字典中还有个字典是不会进行复制的

    • d = {'a':{'name':'黑猫警长','age':18},'b':2,'c':3}
      d2 = d
      d2['a']['name'] ='葫芦娃'
      print(d,id(d))
      print(d2,id(d2))
      #{'a': {'name': '葫芦娃', 'age': 18}, 'b': 2, 'c': 3} 2648041179320
      #{'a': {'name': '葫芦娃', 'age': 18}, 'b': 2, 'c': 3} 2648041179320
      
      d = {'a':{'name':'黑猫警长','age':18},'b':2,'c':3}
      d2 = d.copy()
      d['b'] = 100
      print(d,id(d))
      print(d2,id(d2))
      # {'a': {'name': '黑猫警长', 'age': 18}, 'b': 100, 'c': 3} 2648053062376
      # {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 2648053060376
      
3. 遍历字典

通过三种方式 对字典进行遍历

  • key() 返回字典所有key

    • d = {'name':'钢铁侠','age':38,'sex':'男'}
      print(d.keys())
      # dict_keys(['name', 'age', 'sex'])
      
      d = {'name':'钢铁侠','age':38,'sex':'男'}
      for k in d.keys():
          print(k,type(k),end='\t')
      # name <class 'str'>	age <class 'str'>	sex <class 'str'>
      
  • value() 返回一个序列,序列中保存有字典的值

    • d = {'name':'钢铁侠','age':38,'sex':'男'}
      print(d.values())
      # dict_values(['钢铁侠', 38, '男'])
      
      d = {'name':'钢铁侠','age':38,'sex':'男'}
      for v in d.values():
          print(v,type(v),end='\t')
      # 钢铁侠 <class 'str'>	  38 <class 'int'>	 男 <class 'str'>
      
  • item() 返回字典中的所有项 。返回一个序列,序列中包含有双值子序列。双值分别是字典中的key和value

    • d = {'name':'钢铁侠','age':38,'sex':'男'}
      print(d.items())
      # dict_items([('name', '钢铁侠'), ('age', 38), ('sex', '男')])
      
      d = {'name':'钢铁侠','age':38,'sex':'男'}
      for k,v in d.items():
          print(k, '=' , v,end='\t')
      # name = 钢铁侠	age = 38	sex = 男	
      
4. 集合
4.1 集合简介
  • 集合 : set 集合和列表非常相似

  • 不同点

    • 集合只能存储不可变对象

    • 集合中存储的对象是无序的

    • 集合不能出现重复元素

      • s = {20,10,1,2,3,4,100,1,2,3,4,1,1,1}
        print(s,type(s))
        # {1, 2, 3, 4, 100, 10, 20} <class 'set'>
        
  • 使用 {} 来创建集合

    • s1 = {1,2,3,4}
      s2 = {} 
      s3 = {6,2,4,1,1,1,1,1,1,1,1}
      print(s1,type(s1),s2,type(s2),s3,type(s3)) 
      # {1, 2, 3, 4} <class 'set'> 
      # {} <class 'dict'> 
      # {1, 2, 4, 6} <class 'set'>
      
  • 可以使用set() 将序列和字典转换成集合

    • s = set([1,2,3,4,5,1,2,3,5,5])
      print(s)
      # {1, 2, 3, 4, 5}
      
      s = set('hello')
      print(s)
      # {'l', 'o', 'h', 'e'}
      
      s = set({'a':1,'b':2,'c':3})
      print(s)
      # {'a', 'c', 'b'}
      
  • len() 获取集合中元素的数量

    • s = set('hello')
      print(len(s))
      # 4
      
  • add() 向集合中添加元素

    • s = {'a','b',1,2,3}
      s.add(500)
      print(s)
      # {1, 2, 3, 'b', 500, 'a'}
      
  • update() 将一个集合中的元素添加到另一个集合中

    • s = {'a','b',1,2,3}
      s2 = set('python')
      s.update(s2)
      print(s)
      # {1, 2, 3, 'o', 'b', 'y', 'h', 'n', 't', 'a', 'p'}
      
  • pop() 随机删除集合中的一个元素 默认删除第一个元素

    • s = {1, 2, 3, 'o', 'b', 'y', 'h', 'n', 't', 'a', 'p'}
      s.pop()
      print(s)
      s.pop()
      print(s)
      s1 = s.pop()
      print(s1)
      # {2, 3, 'o', 'b', 'y', 'h', 'n', 't', 'a', 'p'}
      # {3, 'o', 'b', 'y', 'h', 'n', 't', 'a', 'p'}
      # 3
      
  • remove() 删除集合中指定的元素

    • s = {1, 2, 3, 'o', 'b', 'y', 'h', 'n', 't', 'a', 'p'}
      s.remove(3)
      print(s)
      # {1, 2, 'o', 'b', 'y', 'h', 'n', 't', 'a', 'p'}
      
  • clear() 清空集合

    • s = {1, 2, 3, 'o', 'b', 'y', 'h', 'n', 't', 'a', 'p'}
      s.clear()
      print(s)
      # set()
      
4.2 集合的运算
  • & 交集运算

  • | 并集运算

  • - 差集运算

  • ^ 亦或集

  • <= 检查一个集合是否是另一个集合的子集

  • < 检查一个集合是否是另一个集合的真子集

  • >= 检查一个集合是否是另一个集合的超集

  • > 检查一个集合是否是另一个集合的真超集

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值