内置方法之dict，tuple，set

内容概要

• 字典(dict)的内置方法
• 元组(tuple)的内置方法
• 集合(set)的内置方法
• 垃圾回收机制

一、字典的内置方法

类型转换

    dict() 
  
    '''外层可以是列表、元组或集合，里层可以是元组或者列表'''
 
    ret = dict([(1, 2), [3, 4]])  # 外层列表 里层元组和列表
    print(ret)      # {1: 2, 3: 4}    
  

常用操作

    dt = {'name': 'jack', 'age': 73, 'sex': 'male'}
 
    1.按key取值
      print(dt['name'])  # value键 jack 存在
      print(dt['height'])  # value键不存在 报错
      1.2 get方法
        print(dt.get('name'))  # value键 jack 存在
        print(dt.get('hhh'))  # None  键不存在不会报错 而是返回None
        print(dt.get('money', '没有钱'))  # 第二个参数不写默认返回None 写了则返回写了的  如果键存在 则不会使用到第二个参数
 
    2.可修改，添加值   字典是可变类型
      dt['name'] = 'jasonDSB'  # 键存在是修改值
      dt['height'] = '188'     # 键不存在是添加值
      print(dt)  # {'name': 'jasonDSB', 'age': 73, 'sex': 'male', 'height': '188'} 
 
    3.统计字典中键值对的个数(长度)
      print(len(dt))  # 3
 
    4.成员运算  只能判断key
      print('name' in dt)   # True
      print('weight' in dt)  # False
 
    5.删除键值对
        5.1 del方法删除
          del dt['name']  # 通用的删除方式
          print(dt)   # {'age': 73, 'sex': 'male'}
        5.2 pop弹出 popitem随机弹出
          print(dt.pop('sex'))  # male 
          print(dt)    # {'name': 'jack', 'age': 73}
          dt.popitem()  # popitem随机弹出
          print(dt)  
 
    6. 获取所有的键(keys) 所有的值(values) 所有的键值对(items)
      print(dt.keys())  # dict_keys(['name', 'age', 'sex']) 可以看成是列表
      print(dt.values())  # dict_values(['jack', 73, 'male']) 可以看成是列表
      print(dt.items())  # dict_items([('name', 'jack'), ('age', 73), ('sex', 'male')]) 可以看成是列表套元组
 
    7.清空字典clear
      print(dt.clear())  # None
 
    8.update更新字典
      dt.update({'age': '18', 'hobby': 'battle'})  # 将age和hobby进行更新
      print(dt)  # 键存在则修改 键不存在则新增
 
    9.fromkeys()快速生成字典
      dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
      print(dic)  # {'k1': [], 'k2': [], 'k3': []}
 

元组内置方法

类型转换

  -----支持for循环的数据类型都可以转成元组-----
    # print(tuple(11))  # 报错
    # print(tuple(11.11))  # 报错
    print(tuple('column'))  # ('c', 'o', 'l', 'u', 'm', 'n')
    print(tuple([15, 25, 35, 45]))  # (15, 25, 35, 45)
    print(tuple({'name':'aile'}))  # ('name',)
    print(tuple({11,22,33,44}))  # (33, 11, 44, 22)
    # print(tuple(True))  # 报错  

元组的特性

    """
    当元组内只有一个元素的时候 一定要在元素的后面加上逗号 否则括号内的元素会变为原本的类型
    """
    tp = (15,)
    print(type(tp))  # <class 'tuple'>
    tp = (15) 
    print(type(tp))  # <class 'int'>

常用操作

      tp = (1, 2, 3, 4, 5, 2, 2)
    1.索引取值
      print(tp[0])  # 1
      print(tp[-1])  # 2
 
    2.切片操作
      print(tp[1:4])  # (2, 3, 4)
      print(tp[-1:-4:-1])  # (2, 2, 5)
      print(tp[-4:-1])  # (4, 5, 2)
 
    3.间隔（步长）
      print(tp[1:4:2])  # (2, 4)
 
    4.统计元组内元素的个数
      print(len(tp))  # 7
 
    5.成员运算
      print(3 in tp)  # True
 
    6.统计某个元素出现的次数
      print(tp.count(2))  # 3
 
    7.元组内元素不能"修改": 元组内各个索引值指向的内存地址不能修改
       tp[0] = 111  # 报错

集合内置方法

类型转换

     """集合内元素只能是不可变类型"""
     -----不能进行for循环的数据类型不能进行类型转换如int float bool 型-----               
      print(set('column'))  # 字符串转换集合 字符逐个拆开 无序 {'c', 'n', 'u', 'o', 'm', 'l'}
      print(set([11,22,33,44]))  # 列表转换集合 无序的 {33, 11, 44, 22}
      # print(set({'name':'aile'}))  # 字典转换集合 只打印key {'name'}
      # print(set((11,22,33)))  # 元组转换集合 无序的 {33, 11, 22}

两大功能

    1.去重
      集合内不能出现重复的元素(自带去重特性)
        如果出现了 会被集合自动去重
        eg:
          st = {1, 2, 3, 1, 1}
          print(st)  # {1, 2, 3}
 
 
    2.关系运算
        判断两个群体内的差异	
      pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}  # python 课名单
      linuxs={'oscar','tony','gangdan'}   # linux 课名单
 
      1. 即报名python又报名linux课程的学员名字集合
      print(pythons & linuxs)  # {'oscar', 'gangdan'}
 
      2. 所有报名的学生名字集合
      print(pythons | linuxs)  # {'oscar', 'gangdan'}
 
      3. 只报名python课程的学员名字
      print(pythons - linuxs)  # {'ricky', 'kevin', 'jason', 'biubiu'}
 
      4. 没有同时这两门课程的学员名字集合
      print(pythons ^ linuxs)  # {'ricky', 'tony', 'kevin', 'jason', 'biubiu'}

垃圾回收机制

    '''本质为了节省空间'''
    1.引用计数
      python会将引用计数为0的数据清除
        name = 'jason'  # jason引用计数为1
        a = name        # jason引用计数为2
        '''内存中数据身上绑定的变量名的个数'''
 
    2.标记清除
      当内存空间即将溢出(满了)的时候 python会自动启动应急机制
      停止程序的运行 挨个检查值的引用计数并给计数为0的数据打上标记
      然后一次性清理掉
 
    3.分代回收  # 减轻回收机制的负担
      根据值被使用的次数和存在的多久来进行检查分类 等级(1,2,3)
    	等级1 检测机制每隔5s来一次  # 没被使用的会被清除 被使用的进入下一级
        等级2 检测机制每隔1min来一次  # 就经常使用的进入下一级
        等级3 检测机制每隔5min来一次  # 可以更加节省资源