1 > 字典内置方法
1.1 > 字典的类型转换1.2 > 字典的常规操作
1.2.1 > 字典的取值1.2.2 > 字典的取值 ---- get()1.2.3 > 字典的修改1.2.4 > 统计字典中键值对个数1.2.5 > 字典的成员运算1.2.6 > 字典的删除
1.2.6 - 1 > 通常方法1.2.6 - 2 > pop() 的用法1.2.6 - 3 > .popitem() 的用法 1.2.7 > 获取字典中所有的，键、值、键值对
1.2.7 - 1 > 获取所有键 key()1.2.7 - 2 > 获取所有值 values()1.2.7 - 3 > 获取所有键值对 items() 1.2.8 > 字典中仅需理解的一些功能
1.2.8 -1 > update更新字典1.2.8 -2 > fromkeys()快速生成字典1.2.8 -3 > setdefault() 2 > 元组内置方法
2.1 > 元组的类型转换2.2 > 元组的特性2.3 > 元组的常规操作
2.3.1 > 索引取值2.3.2 > 切片操作2.3.3 > 间隔2.3.4 > 统计元组内元素的个数 len()2.3.5 > 成员运算2.3.6 > 统计某个元素出现的次数 count()2.3.7 > 元组内元素不能"修改" 3 > 集合内置方法
3.1 > 类型转换3.2 > 集合的两大功能
3.2.1> 去重3.2.2> 关系运算 4 > 垃圾回收机制
4.1 > 引用计数4.2 > 标记清除4.2 > 标记清除
1 > 字典内置方法 1.1 > 字典的类型转换
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
1.2 > 字典的常规操作
1.2.1 > 字典的取值
当取值时，键若存在便可以直接取到键所对应的值。若键不存在则会报错，例如：
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print(d1['name'])
# 打印 》》》 jason
print(d1['name1']) # name1这个键不存在
# 报错
所以针对上面的情况，推荐在进行字典取值时使用一个 get() 方法。
1.2.2 > 字典的取值 ---- get()get() 方法使用的时候若键存在，则会直接打印键所对应的值。若不存在会返回一个 None，当我们在后面再加上一个参数时，它就不会返回None，返回我们所定义的第二个参数的内容。 例如：
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print(d1.get('name'))
# 打印 >>>>> jason
print(d1.get('name1', '这个键不存在')) # 此时没有name1这个值
# 打印 >>> 这个键不存在
1.2.3 > 字典的修改
字典是一个可变类型的。字典在进行修改的时候，当键是存在的就直接修改所对应的值，当不存在时则会自动添加一个新的键值对。例如：
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
d1['name'] = 'bob'
print(d1)
# 打印 》》》》 'name': 'bob',
'age': 18,
'hobbies': ['play game', 'basketball']
d1['pwd'] = '1234' # 此时，键 pwd 不存在
print(d1)
# 打印 》》》》 'name': 'bob',
'age': 18,
'hobbies': ['play game', 'basketball']
'pwd': '1234' # 新增加了键值对
1.2.4 > 统计字典中键值对个数
统计个数几乎都是使用 len() 这个方法统计，所以字典也不例外。例如：
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print(len(d1))
# 打印 》》》 3
1.2.5 > 字典的成员运算
字典在进行成员运算时判断的只是字典当中的键是否存在字典当中，若键存在即返回Ture，不存在则返回 False。例如：
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print('jason' in d1) # 这里判断了这个值是否存在，
# 打印 》》》》 False 因为d1当中没有jason这个键
print('name' in d1) # 这里判断的是这个键是否存在
# 打印 》》》 Ture
1.2.6 > 字典的删除
1.2.6 - 1 > 通常方法
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
del d1['name']
# 打印 》》》》 {'age': 18, 'hobbies': ['play game', 'basketball']}
1.2.6 - 2 > pop() 的用法
弹出对应的键值对
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
d1.pop('age') # 弹出 age 和这个键所对应的值
print(d1)
# 打印》》》》 { 'name': 'jason','hobbies': ['play game', 'basketball']}
1.2.6 - 3 > .popitem() 的用法
随机弹出键值对
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
d1.popitem('age') # 随即弹出d1当中的键值对
print(d1)
# 打印》》》》 { 'name': 'jason','age': 18}
1.2.7 > 获取字典中所有的，键、值、键值对
1.2.7 - 1 > 获取所有键 key()
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print(d1.keys()) # 获取d1所有键
# 打印 >>>> dict_keys(['name', 'age', 'hobbies'])
1.2.7 - 2 > 获取所有值 values()
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print(d1.values()) # 获取d1所有值
# 打印 》》》》 dict_values(['jason', 18, ['play game', 'basketball']])
1.2.7 - 3 > 获取所有键值对 items()
d1 = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print(d1.items()) # 获取d1所有键值对
# 打印 》》》》 dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
1.2.8 > 字典中仅需理解的一些功能
1.2.8 -1 > update更新字典
dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
dic.update({'k1': 'JN', 'k4': 'xxx'})
print(dic) # 键存在则修改 键不存在则新增
# 打印 》》》{'k1': 'JN', 'k2': 'Tony', 'k3': 'JY'}
1.2.8 -2 > fromkeys()快速生成字典
dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
print(dic)
#打印 》》》 {'k1': [], 'k2': [], 'k3': []}
"""笔试题"""
dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
print(dic)
# {'k1': [], 'k2': [], 'k3': []}
dic['k1'].append(111) # 三个键指向的是同一个列表
print(dic)
# {'k1': [111], 'k2': [111], 'k3': [111]}
1.2.8 -3 > setdefault()
dic = {'k1': 111, 'k2': 222}
print(dic.setdefault('k3', 333))
# 键不存在则新增键值对 并且有返回结果是新增的v
#打印 》》》 333
print(dic.setdefault('k1', '嘿嘿嘿'))
# 键存在 则返回对应的值 不做修改
#打印 》》》 111
print(dic)
# 打印 》》》{'k1': 111, 'k2': 222, 'k3': 333}
2 > 元组内置方法
2.1 > 元组的类型转换
# 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.2 > 元组的特性
当元组内只有一个元素的时候 一定要在元素的后面加上逗号,不然元组的类型就会转换成元素的数据类型了。 例如：
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
2.3 > 元组的常规操作
2.3.1 > 索引取值
t1 = (11, 22, 33, 44, 55, 66) print(t1[0]) # 11 print(t1[-1]) # 662.3.2 > 切片操作
t1 = (11, 22, 33, 44, 55, 66) print(t1[0:4]) # (11, 22, 33 ,44) print(t1[-1:-4:-1]) # (66 55 44) print(t1[-4:-1]) # (33, 44, 55)2.3.3 > 间隔
t1 = (11, 22, 33, 44, 55, 66) print(t1[1:4:2]) # (22, 44)2.3.4 > 统计元组内元素的个数 len()
统计个数几乎都是使用 len() 这个方法统计，所以字典也不例外。例如：
t1 = (11, 22, 33, 44, 55, 66) print(len(t1)) # 62.3.5 > 成员运算
t1 = (11, 22, 33, 44, 55, 66) print(11 in t1) # Ture2.3.6 > 统计某个元素出现的次数 count()
t1 = (11, 22, 33, 44, 55, 66) print(t1.count(22)) # 12.3.7 > 元组内元素不能"修改"
元组内各个索引值指向的内存地址不能修改,所以元组也是一个不可变的类型，但当元素是列表是情况特殊，是可以改动的例如。
tt = (11, 22, 33, [11, 22])
tt[-1].append('heiheihei')
问:执行之后的结果 正确答案选B
A.报错 B.正常添加 C.不知道
3 > 集合内置方法
3.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)) # 报错
3.2 > 集合的两大功能
3.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}
3.2.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'}
4 > 垃圾回收机制
垃圾回收它的机制最主要的依据有三点 ，引用计数、标记清除、分代回收。
4.1 > 引用计数在python当中，python会将引用计数为 0 的数据清除，引用计数的意思能就一个数据它在内存空间当中身上所绑定的变量名个数。所以当一个数据身上没有绑定变量名了 它就会被python所清除。
4.2 > 标记清除在python当中，当内存空间即将溢出的时候，python它会自动启动一个应急机制，将程序停止运行，然后挨个检查数据的引用计数，给引用计数为0 的数据打上标签，最后再一次性将其清理掉。
4.2 > 标记清除python它会根据数据存在的时间长短，将值划分为三个等级（1.2.3）。每一级的检测机制的检测时间不同，每升一级检测的频率就会降低一个等级。这样的好处就是大大节约了内存空间。
