字典、元祖、集合内置方法

字典的内置方法

 

d1 = {'name': 'jason','age': 18,'hobbies': ['play game', 'basketball']

 

1.按k取值(get 获取、获得)

print(d1['name'])  # 返回jason        键存在
print(d1['xxx'])  # 键不存在        直接报错（所以不是很好）


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

2.修改值  字典也是可变类型

print(id(d1))   #12833746327
d1['name'] = 'jasonDSB'  # 键存在是修改值
print(d1, id(d1))   # jasonDSB   12833746327

3.添加键值对

#与第二个相似
 d1['pwd'] = 123  # 键不存在则是新增一个键值对
print(d1)  #{'name': 'jason', 'age': 18, 'hobbies': ['play game', 'basketball'], 'pwd': 123}

4.统计键值对的个数 len

print(len(d1))  # 3

 

5.成员运算  仅能判断key键

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

6.删除键值对  del(删除)  pop（弹出的k值）  popitem（随机弹出）

del d1['name']  # 1.通用的删除方式
print(d1)  # {'age': 18, 'hobbies': ['play game', 'basketball']}


print(d1.pop('age'))  # 18       2.弹出，括号里面一定写k值，由于字典无序
print(d1)  # {'name': 'jason', 'hobbies': ['play game', 'basketball']}


d1.popitem()  # 由于字典无序，所以 3.随机弹出一个(使用频率很低 可以忽略)
print(d1)

7.分别获取所有的键 、值 、键值对  keys (键)   values（值） item(键值对)

print(d1.keys())  # dict_keys(['name', 'age', 'hobbies'])  可以看成是列表


print(d1.values())  # dict_values(['jason', 18, ['play game', 'basketball']])  可以看成是列表


print(d1.items())  # dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])  可以看成是列表套元组

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

字典了解即可的东西

1.更新字典 update （更新）

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

2.快速生成字典  forkeys

 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   键存在不改，键不存在新增

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

元组内置方法

 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
print(type(t2))  # str    这样子不对，类型混乱



 t2 = (11,)
print(type(t2))  # tuple   应该加逗号


"""
(1,)
[1,]
{1,}
{'name':'jason',}  #我们会习惯性的将所有可以存储多个数据的类型的数据,内部只有一个元素 也会加逗号
    """

 t1 = (11, 22, 33, 44, 55, 66)

1.索引取值

print(t1[0])  #11

2.切片操作

print(t1[1:4])  #(22, 33, 44)
print(t1[-1:-4:-1])  #(66, 55, 44)  前面两个数字表示索引范围，最后表示步长

3.间隔步长  略 上面2有

4.统计元素个数 len

print(len(t1))  # 6

5.成员运算

print(11 in t1)  # True

6.统计某个元素出现的次数 count

print(t1.count(22))  #1

7.元组内元素不能"修改": 元组内各个索引值指向的内存地址不能修改

t1[0] = 111  #元祖不可以修改，会报错

笔试题

"""
    笔试题
        tt = (11, 22, 33, [11, 22])
        tt[-1].append('heiheihei')
        问:执行之后的结果   正确答案选B
            A.报错    B.正常添加   C.不知道   
    """   #虽然元祖不可以修改，但是里面的列表可以修改，并且元祖的变量对应的值的地址还是不变

集合内置方法

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）去重

 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)    # [1, 'b', 'a']  注意：因为集合是没有顺序，所以比较混乱

（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'}

垃圾回收机制

 

"""python底层针对空间的申请和释放都是设计好的 不需要程序员操心"""
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来一次