Loading

字典、集合、元组内置方法,垃圾回收机制

字典的内置方法

  1. 类型转换

    dict()
    eg:
       print(dict(a='a', b='b', c=2))
       #{'a': 'a', 'b': 'b', 'c': 2}
  2. 按key取值

    d1 = {'name': 'tuzi',
         'age': 3,
         'hobby': 'game'
        }
    print(d1['name'])  # tzui
    print(d1['xxx'])  # 键值不存在直接报错
    # 推荐使用get来进行字典取值
    print(d1.get('name'))  # tzui
    print(d1.get['xxx'])  # None
    也可以在后面再添加一个,键存在,则不适用第二个参数
    print(d1.get('xxx','你不在我就出来了')) # 你不在我就出来了
    print(d1.get('age','你不在我就出来了'))  # 3
  3. 修改值

    字典也是可变类型,修改的是V值,用K值定位

    d1 = {'name': 'tuzi',
         'age': 3,
         'hobby': 'game'
        }
    print(id(d1))  # 2178905689832
    d1['name'] = 'qwe'
    print(d1)  # {'name': 'qwe', 'age': 3, 'hobby': 'game'}
    print(id(d1))  # 2178905689832
  4. 添加键值对

    键不存在则直接添加一个键值对
    d1 = {'name': 'tuzi',
         'age': 3,
         'hobby': 'game'
        }
    d1['glass'] = 'ren'
    print(d1)
    # {'name': 'tuzi', 'age': 3, 'hobby': 'game', 'glass': 'ren'}
  5. 统计字典中键值对的个数

    d1 = {'name': 'tuzi',
         'age': 3,
         'hobby': 'game'
        }
    print(len(d1))  # 3

     

  6. 成员运算

    只能判断K值

    print('name' in d1)  # True
    print('tuzi'in d1)  # False
  7. 删除键值对

    d1 = {'name': 'tuzi',
         'age': 3,
         'hobby': 'game'
        }
    del d1['name']  # 通用的方式
    print(d1)
    # {'age': 3, 'hobby': 'game'}
    'pop','popitem'
    # pop用来弹出一个值
    print(d1.pop('age'))  # 3
    print(d1)  # {'name': 'tuzi', 'hobby': 'game'}
    # popitem 用来随机弹出一个值,pychorm中给默认为弹出最后一个值了
    print(d1.popitem())  # ('hobby', 'game')
    print(d1)  # {'name': 'tuzi', 'age': 3}
  8. 获取所有的键、值、键值对

    d1 = {'name': 'tuzi',
         'age': 3,
         'hobby': 'game'
        }
    print(d1.keys()) # keys 获取所有的键值 可以看成是列表
    # dict_keys(['name', 'age', 'hobby'])
    print(d1.values())  # 获取所有的V值,可以看成是列表
    # dict_values(['tuzi', 3, 'game'])
    print(d1.items())#获取所有的键值对可以看成是列表套元组
    # dict_items([('name', 'tuzi'), ('age', 3), ('hobby', 'game')])
    '在python2中三个方法就是直接返回一个列表'
  9. update更新字典

    d1 = {'name': 'tuzi',
    'age': 3,
    'hobby': 'game'
    }
    d1.update({'name':'qwe','glass':'ren'})
    print(d1)
    #{'name': 'qwe', 'age': 3, 'hobby': 'game', 'glass': 'ren'}
    # K值存在就修改,不存在就直接添加一个KV键值对
  10. formkeys快速生成字典

d2 = dict.fromkeys(['k1','k2','k3'],[])
print(d2)
# {'k1': [], 'k2': [], 'k3': []}
# 后面列表里填入元素则会,将整个列表的元素加入到每个K对应的V值里
"""笔试题"""
# dic['k1'].append(111) # 三个键指向的是同一个列表
# print(dic) # {'k1': [111], 'k2': [111], 'k3': [111]}
  1. setdefault

    键不存在则新增键值对,并且有返回结果是新增的V

    d2 = {'k1':111,'k2':222,'k3':333}
    d2.setdefault('k4',444)
    # 键不存在则新增键值对 并且有返回结果是新增的v
    print(d2)
    # {'k1': 111, 'k2': 222, 'k3': 333, 'k4': 444}
    print(d2.setdefault('k1', '阿达'))
    # 111
    # 键存在则返回对应的值,不做修改

img

元组内置方法

可以看成是不可变的列表

  1. 类型转换

    支持for循环的数据类型都可以转为元组

    可以转换:字符串,列表,字典,集合

    不可以转换:整型,浮点型,布尔型

  2. 元组的特性

    当元组内只有一个元素的时候 一定要在元素的后面加上逗号

    t1 = (11, 22, 33, 44)
    print(type(t1))
    # <class 'tuple'>
    t2 = (11)
    print(type(t2))
    # int
    t2 = (11.11)
    print(type(t2))
    # float
    t2 = ('jason')
    print(type(t2))
    # str
    """针对这种只有一个元素的情况,在严肃的后面加一个逗号就可以解决了"""
  3. 索引取值

    t1 = (11,22,33,44,55,66,77,88,99)
    print(t1[4])
    # 55
  4. 切片操作

    t1 = (11,22,33,44,55,66,77,88,99)
    print(t1[1:5])
    # (22, 33, 44, 55)
  5. 间隔

    t1 = (11,22,33,44,55,66,77,88,99)
    print(t1[2:8:2])
    # (33, 55, 77)
  6. 统计元组内元素的个数

    len()

    t1 = (11,22,33,44,55,66,77,88,99)
    print(len(t1))
    # 9
  7. 成员运算

    in

    t1 = (11,22,33,44,55,66,77,88,99)
    print(18 in t1) # False
  8. 统计字符串中元素出现的次数

    count()

    t1 = (1,2,1,2,12,1,2,12,1,21,1,2,1,1,3,1,1,1,2,)
    print(t1.count(1)) # 10
  9. 元组内元素不能"修改": 元组内各个索引值指向的内存地址不能修改

    image-20220310162108967

       """
    笔试题
    tt = (11, 22, 33, [11, 22])
    tt[-1].append('heiheihei')
    问:执行之后的结果 正确答案选B
    A.报错 B.正常添加 C.不知道
    """
    # tt索引取的是[11,22]列表,根据上图原理,列表属于可变类型,所以可以被修改
  10. 集合的内置方法

    类型转换

    可以转换:字符串,列表,字典,元组

    不可以转换:整型,浮点型,布尔型(会报错)

    set()
    print(set('tuzi'))
    print(set([1,2,3]))
    print(set({'name':'tuzi','age':18}))
    print(set((11,22,33)))
    # 集合内的元素是不可变类型

    集合会用于去重和关系运算

    去重:集合内不能重复的元素(自带去重属性),如果出现了会被集合自动去重

    关系运算:判断两个群体内的差异(共同好友,共同关注,共同点赞)

    去重:

    s1 = {1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3}
    print(s1)
    # {1, 2, 3}

    关系运算

    s1 = {'tuzi','tom','qwe','jerry'}
    s2 = {'tuzi','asd','jerry','shazi'}
    print(s1 & s2) # &判断两个集合里共有的
    # {'tuzi', 'jerry'}
    print(s1 - s2) # - 判断s1里面s2没有的数据
    # {'tom', 'qwe'}
    print(s1 | s2) # | 两个集合加起来所有的数据
    #{'jerry', 'tom', 'asd', 'qwe', 'tuzi', 'shazi'}
    print(s1 ^ s2) # 两个集合共同没有对方的数据,相当于两个人各自的好友

     

垃圾回收机制

1.引用技术
python会将引用为0的数据除
2.标记清除
当内存空间即将移除(满了)的时候,python会自动启动应急机制
停止程序的运行,挨个检查值的引用计数并给计数为0的数据打上标记
然后一次性清理掉
3.分代回收
根据值存在的时间长短,将值划分为三个等级(1,2,3)
等级1 检测机制每隔5s来一次,经常引用的数据移到等级2中
等级2 检测机制每隔1min来一次,经常引用的数据移到等级3中
等级3 检测机制每隔5min来一次

 

posted @ 2022-03-10 20:36  香菜根  阅读(55)  评论(0编辑  收藏  举报