字典、元组、集合的内置方法

本章内容详解

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

字典内置方法

# 类型转换
	dict()

	l = {
        'name' : 'tony',
        'age' : 20,
        'genger' : 'male',
        'hobbies' : ['football', 'basketball']
    }
1.按key取值
    print(l['name'])  # tony
    print(l['xxx'])  # 键不存在直接报错
 """关于字典取值，推荐使用get  如下："""
    print(l.get('age'))  # 20
    print(l.get('tall'))   # None
    print(l.get('tall', 这个K不存在))  # 这个K不存在
    print(l.get('age', 这个K不存在))    # 20
2. 修改值
    print(id(l))     # 2230049042648
    l['name'] = 'jason'  
    print(l)  # {'name': 'jason', 'age': 20, 'genger': 'male', 'hobbies': ['football', 'basketball']}
    print(id(l))      # 2230049042648
3.添加键值对
    l['pdd', 18]
    print(l)    #{'name': 'tony', 'age': 20, 'genger': 'male', 'hobbies': ['football', 'basketball'], 'pdd': 18}
4.统计字典中键值对的个数
    print(len(l))    # 4
5.成员运算
    print('ped' in l)  # False
6.删除键值对
    del l['name']      
    print(l)         	#  # False
    print(l.pop('name'))  # tony
    print(l)           # {'age': 20, 'genger': 'male', 'hobbies': ['football', 'basketball']}
    l.popitem()   # 随机弹出一个元素
7.获取所有的键 所有的值 所有的键值对
    print(l.keys())  # dict_keys(['name', 'age', 'genger', 'hobbies'])
    print(l.values())  # dict_values(['tony', 20, 'male', ['football', 'basketball']])
    print(l.items())    # dict_items([('name', 'tony'), ('age', 20), ('genger', 'male'), ('hobbies', ['football', 'basketball'])])  相当于列表套元组
    

# """""""""""""""""""""""""   需要来了解的操作""""""""""""""""""""""""" 

1.update 更新字典
    dic = {'1':'jason','2':'tony','3':'kevin'}
    dic.update({'1' : 'tom','4': '老刘'})
    print(dic)   # {'1': 'tom', '2': 'tony', '3': 'kevin', '4': '老刘'}
    # 更新还可以添加新的元素进入到字典内，键存在则修改，不存在则新增
2.快速生成字典
    dic = dict.fromkeys(['a', 'b', 'c', 'd'], [])
    print(dic)   # {'a': [], 'b': [], 'c': [], 'd': []}
3.setdefault()
    dic = {'a':1,'b':2, 'c':3}
    print(dic)   # {'a': 1, 'b': 2, 'c': 3}
    dic.setdefault('a', 4)  
    dic.setdefault('d', 4)  
    print(dic)   # {'a': 1, 'b': 2, 'c': 3, 'd': 4} 键存在 则返回对应的值 不做修改
    print(dic.setdefault('d', 4))   # 4  键不存在则新增键值对 并且有返回结果是新增的v 
    
    

元组的内置方法

1.类型转换
"""可以进行for循环的数据类型都可以转换为元组"""
    print(tuple(11))      # 报错
    print(tuple(11.11))   #报错
    print(tuple('jason'))  # ('j', 'a', 's', 'o', 'n')
    print(tuple([1, 2, 3, 4])) # (1, 2, 3, 4)
    print(tuple({'name': 'jason', 'age': '20'})) # ('name', 'age')
    print(tuple({1, 2, 3, 4, 5}))  # (1, 2, 3, 4, 5)
2.元组的特性
"""当元组内只有一个元素的时候 一定要在元素的后面加上逗号，否则它会转换成其他的类型"""
    a = (11)
    b = (11.11)
    c = ('name')
    d = (['name'])
    e = ({'name': 'jsaon'})
    f = (True)
    print(type(a), type(b), type(c), type(d), type(e), type(f))
    # 打印结果如下所示：
    <class 'int'> <class 'float'> <class 'str'> <class 'list'> <class 'dict'> <class 'bool'>
3.元组也支持列表的操作，例如：
	# 索引取值：
    s = (1,2,3,4,5,6,7)   # 
    print(s[0])           # 1
    print(s[-1])          # 7
    # 切片               
    print(s[0:4])         # (1,2,3,4)
    print(s[-1:-4:-1])    # (7, 6, 5) 	
    print(s[-4:-1])       # (4, 5, 6)
    # 间隔
    print(s[0:5:2])        # (1, 3, 5)
    # 统计元组内的元素个数
    print(len(s))      # 7
    # 成员运算
    print(2 in s)    # True
    # 统计某个元素出现的个数
    print(s.count(1))      #  1
    # 元组内的元素不可修改：元组内的各个索引值指向的内存地址不能修改
    """
       笔试题
        tt = (11, 22, 33, [11, 22])
        tt[-1].append('heiheihei')
        问:执行之后的结果   正确答案选B
            A.报错    B.正常添加   C.不知道   
    """
    tt = (11, 22, 33, [11, 22])
    print(id(tt[-1]))   # 2315831499656
    tt[-1].append('14')
    print(id(tt[-1]))   # 2315831499656
    print(tt)           # (11, 22, 33, [11, 22,14])

集合内置方法

1.类型转换
	# print(set(11))  # 报错
        # print(set(11.11))  # 报错
        # print(set('jason'))
        # print(set([11,22,33,44]))
        # print(set({'name':'jason'}))
        # print(set((11,22,33)))
        # print(set(True))  # 报错
"""集合内的元素只能是不可变类型"""

2.功能
	1.去重
    	集合内不能出现重复的元素(自带去重特性)
        如果出现了 会被集合自动去重eg:
            
        s = {12,22,2,2,2,2,2,4,4,4,6,6,7,7,7,7,7}
        print(s)          # {2, 4, 6, 7, 12, 22}
        l = ['a','b','c','a','a']
        l1 = set(l)
        print(l1)         # {'a', 'c', 'b'}  元素排列是无序的
        l2 = list(l1)     # ['a', 'c', 'b']
        print(l2)
    2.关系运算
    	判断两个群体内的差异	
        	eg:共同好友 共同关注 共同点赞
         
        a = {'tom','jerry','lim','tony','kevin'}
        b = {'tom', 'lim', 'jsaon', 'acli', 'oscar'}
        # 1. 共同好友
        print(a & b)      # {'tom', 'lim'}
        # 2. 求b的单独好友
        print(b - a)      # {'jsaon', 'oscar', 'acli'}
        # 3.求全部的好友
        print(a | b)    # {'kevin', 'acli', 'tony', 'jsaon', 'tom', 'jerry', 'lim', 'oscar'}
        # 4.求两人各自的好友
        print(a ^ b)    # {'tony', 'kevin', 'jsaon', 'jerry', 'acli', 'oscar'}

垃圾回收机制

1.引用计数
	python会将引用计数为0的数据清除
    	name = 'jason'  # jason引用计数为1
        a = name        # jason引用计数为2
        '''内存中数据身上绑定的变量名的个数'''
        # ps:还可以了解一下循环引用的情况
2.标记清除
    当内存空间即将溢出(满了)的时候 python会自动启动应急机制
    停止程序的运行 挨个检查值的引用计数并给计数为0的数据打上标记
    然后一次性清理掉
3.分代回收
	根据值存在的时间长短 将值划分为三个等级(1,2,3)
    	等级1 检测机制每隔固定的时间来一次
        等级2 检测机制每隔固定的时间(比上一个等级要多)来一次
        等级3 检测机制每隔固定的时间(比上一个等级要多)来一次
        
        以此类推.....