数据类型的内置方法

今日学习笔记

1.字典的内置方法

# 字典是可变类型的 但是字典里面的k:v键值对中的k是不可变的类型，v可以是任意数据类型
1.类型转换
	dict()
2.取值
	1.按k取值
    	这种情况下如果你取的值不在字典里会直接报错，所以涉及到字典取值应该使用get的方式
    2.get取值
    	get取的值如果不在字典中会默认返回None,也就是空的意思，如果get里面写了第二个参数的话，如果第一个参数没有在字典中就会返回第二个参数，否则返回字典里有的值
        # print(d1.get('name'))  # jason  键存在
        # print(d1.get('xxx'))  # None  键不存在不会报错 而是返回None
        # print(d1.get('xxx', '这个键不存在'))  # 第二个参数不写默认返回None 写了则返回写了的
        # print(d1.get('name', '这个键不存在'))  # 如果键存在 则不需要使用到第二个参数
	3.修改值与添加键值对
    	修改值需要用k来修改如果k存在的话就是修改值，如果不存在就是添加一个键值对
        # d1['name'] = 'jasonDSB'  # 键存在是修改值
        # print(d1, id(d1))
        # d1['pwd'] = 123  # 键不存在则是新增一个键值对
        # print(d1)
    4.统计字典中的键值对的个数
    	用len()即可
    5.成员运算
    	只能判断k，如果k在就为True，否则为false
        # print('jason' in d1)  # False
        # print('name' in d1)  # True
    6.删除键值对
    	1.del:
            通用的删除方式
            # del d1['name']  # 通用的删除方式
            # print(d1)  # {'age': 18, 'hobbies': ['play game', 'basketball']}
        2.pop():
            默认弹出尾部元素，也可指定k删除
            # print(d1.pop('age'))  # 18  弹出
            # print(d1)  # {'name': 'jason', 'hobbies': ['play game', 'basketball']}
        3.popitem():
            随机弹出一个键值对(使用频率很低)
    7.获取所有的键
    	在字典名后面加入.keys()就可以了，可以把取出来的键看成一个列表
       	# print(d1.keys())  # dict_keys(['name', 'age', 'hobbies'])  
    8.获取所有的值
    	在字典名后面加入.values()，也可以看成一个列表
        # print(d1.values())  # dict_values(['jason', 18, ['play game', 'basketball']]) 
    9.获取所有的键值对
    	在字典名后面加入.items()可以看成列表套元组
        # print(d1.items())  # dict_items([('name','jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
        
                   # 在python2中这三种方法返回的就是一个列表，在python3中会节省空间

2.字典需要了解的操作

1.updata
	更新字典，如果键存在的话就会修改值，如果键不存在就新增值
    	# dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
        # dic.update({'k1': 'JN', 'k4': 'xxx'})
        # print(dic)  # 键存在则修改 键不存在则新增
2.formkeys
	快速生成字典，在formkeys括号里放入两个列表，第一个列表中放入字典的键，第二个列表中放入值但是它们的k会指向同一个值
        # dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
        # print(dic)  # {'k1': [], 'k2': [], 'k3': []}
        # dic['k1'].append(111)  # 三个键指向的是同一个列表
        # print(dic)  # {'k1': [111], 'k2': [111], 'k3': [111]}
3.setdefault
	如果它括号里面加入的键不存在则新增一个键值对并且返回结果是它括号里面的值，如果存在的话就返回字典里面的值
    # print(dic.setdefault('k3', 333))  # 键不存在则新增键值对 并且有返回结果是新增的v
	# print(dic)
	# print(dic.setdefault('k1', '嘿嘿嘿'))  # 键存在 则返回对应的值 不做修改
	# print(dic)

3.元组内置方法

1.类型转换
	支持for循环的数据类型都可以转成元组
    	# print(tuple(11))  # 报错
        # print(tuple(11.11))  # 报错
        # print(tuple('jason'))
        # print(tuple([11,22,33,44]))
        # print(tuple({'name':'jason'}))
        # print(tuple({11,22,33,44}))
        # print(tuple(True))  # 报错
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
        """当元组内只有一个元素的时候 一定要在元素的后面加上逗号"""
        # t2 = (11,)
        # print(type(t2))  # tuple
        # t2 = (11.11,)
        # print(type(t2))  # tuple
        # t2 = ('jason',)
        # print(type(t2))  # tuple
        
    # 一般情况下 如果有可以存储多个数据的数据类型里面只有一个元素时要习惯性在元素后面加逗号
3.索引取值
    # print(t1[0])
    # print(t1[-1])
4.切片操作
    # print(t1[1:4])
    # print(t1[-1:-4:-1])
    # print(t1[-4:-1])
5.步长
	# print(t1[1:4:2])  # (22, 44)
6.统计元组内的某个元素出现的次数
	len()
7.元组中的元素不能修改:
    元组内的各个索引值指向的内存地址不能修改

4.集合内置方法

1.类型转换
	也是支持for循环的数据类型都可以转换
	# 集合内的元素只能是不可变类型
2.两大功能
	1.去重
    	集合会自带去重特性，要是集合里面有相同元素也会自动去重，但是去重之后打印出来打乱顺序
        # s1 = {1,1,1,1,1,1,2,2,2,2,2,1,2,3,2,2,1,2,3,2,3,4,3,2,3}
        # print(s1)  # {1, 2, 3, 4}
        # l = ['a', 'b', 1, 'a', 'a']
        # s1 = set(l)
        # l = list(s1)
        # print(l)
    2.关系运算
    	判断两个集合里面的差异
		# f1 = {'jason', 'kevin', 'tony', 'jerry'}  # 小李的好友列表
    	        # f2 = {'jason', 'tom', 'jerry', 'jack'}  # 小王的好友列表
        1.&
        	将两个集合中相同的元素合成一个集合
            # print(f1 & f2)  # {'jerry', 'jason'}
        2.-
        	第一个集合减第二个集合中第一个集合多出来的部分
            # print(f1 - f2)  # {'kevin', 'tony'}
        3.|
        	将两个集合中所有的元素合成一个集合，并将相同的元素去掉
            # print(f1 | f2)  # {'kevin', 'jack', 'tom', 'jason', 'jerry', 'tony'}
        4.^
        	将两个集合中不相同的元素合成一个元素
            # print(f1 ^ f2)  # {'jack', 'tony', 'tom', 'kevin'}

5.垃圾回收机制

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