day 8

字典的内置方法

类型转换

dict ()

按kye取值

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(d1['name'])  # jason  键存在
print(d1['xxx'])  # 键不存在直接报错

按get取值

涉及到字典取值更加推荐使用get

print(d1.get('name'))     # jason  键存在
print(d1.get('xxx'))      # None 键不存在不会报错，而是返回None
print(d1.get('xxx','这个键不存在'))     # 第二个参数不写默认返回None，写了则返回写了的
print(d1.get('name','这个键不存在'))      # 如果键存在则不需要使用到第二个参数

修改值与添加键值对

字典也是可变类型

print(id(d1))
d1['name'] = 'jasonkp'     # 键存在是修改值
d1['sewf'] = 'wrgewf'      # 键不存在则是新增一个键值对

统计字典中键值对的个数
```
print(len(d1))      # 3
```

成员运算

只能判断key

print('jason' in d1)        # False
print('name' in d1)         # true

删除键值对

del d1['name']    # 通用的删除方式
print(d1.pop('age'))     # 弹出
d1.popitem()        # 随机弹出一个，使用频率很低

获取所有的键，所有的值，所有的键值对

print(d1.keys())      # 获取所有的键，dict_keys(['name','age','hobbies'])  可以看成是列表
print(d1.values())     #  获取所有的值， 可以看成是列表
print(d1.items())  # dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

在Python 2中上述三个方法就是直接返回一个列表

update更新字典

用新字典跟新旧字典，有则修改，无则添加

dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
dic.update({'k1': 'JN', 'k4': 'xxx'})     # 键存在则修改，键不存在则添加

fromkeys快速生成字典

dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
print(dic)      # {'k1': [], 'k2': [], 'k3': []}

setdefault ( )

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

元组的内置方法

可以看成是不可变的列表

类型转换：

支持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))  # 报错

如果代码报错的话可以点击蓝色的字体查看是哪一行代码报错

元组的特性

当元组内只有一个元素的时候，一定要在元素的后面加上一个逗号
```
t2 = (11,)
print(type(t2))  # tuple
t2 = (11.11,)
print(type(t2))  # tuple
t2 = ('jason',)
print(type(t2))  # tuple
```
一般情况下，我们会习惯性的将所有可以储存多个数据的类型的数据，如果内部只有一个元素也会加上逗号
索引取值
```
print(t1[0])
print(t1[-1])
```

切片操作

print(t1[1:4])
print(t1[-1:-4:-1])
print(t1[-4:-1])

间隔
```
print(t1[1:4:2])  # (22, 44)
```
统计元组内的个数
```
print(len(t1))  # 6
```
成员运算
```
print(11 in t1)  # True
```
统计某个元素出现的次数
```
print(t1.count(22))
```

元组内元素不能修改：元组内各个索引值指向的内存地址不能修改

笔试题：

 tt = (11, 22, 33, [11, 22])
        tt[-1].append('heiheihei')
        '''执行之后的结果
        A.抱错    B.正常添加    C.不知道
        '''

集合内置方法

类型转换

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))  # 报错

集合内部元素只能是不可变类型

集合只会在去重和关系运算中使用，甚至有时候也不会用

两大功能

去重：集合内部不能出现重复的元素，如果出现了会被集合自动去重

关系运算：判断两个群体内的差异


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))  # 报错
'''集合内部只能是不可变类型'''

关系运算

f1 = {'jason', 'kevin', 'tony', 'jerry'}  # 小李的好友列表
f2 = {'jason', 'tom', 'jerry', 'jack'}  # 小王的好友列表
print(f1 & f2)  # {'jerry', 'jason'}    两个人的共同好友
print(f1 - f2)   # 小李的单独好友
print(f1 | f2)   # 求两个人所有的好友
print(f1 ^ f2)  #  两个人各自的好友

垃圾回收机制

python底层针对空间的申请和释放都是设计好的不需要程序员操心

引用计数：python会将引用计数为0的数据清除

name = 'jason'  # jason引用计数为1
        a = name        # jason引用计数为2
        '''内存中数据身上绑定的变量名的个数'''

标记清除

当内存空间即将溢出(满了)的时候 python会自动启动应急机制
停止程序的运行挨个检查值的引用计数并给计数为0的数据打上标记
然后一次性清理掉
分代回收

根据值存在的时间长短将值划分为三个等级(1,2,3)
等级1 检测机制每隔 5 s 来一次
等级2 检测机制每隔1 min来一次
等级3 检测机制每隔5 min来一次