python字典元组集合内置方法

python字典元组集合内置方法

字典内置方法

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

dict = {key1:value1,key:value2}

#键必须是唯一的，但值则不必。

1.字典取值

dict ={'username':'dlrb','age':18,'hobbies': ['play game', 'basketball']}

1.按key取值：
print(dict['username']) # dlrb
print(d1['xxx'])  # 键不存在直接报错

"""涉及到字典取值 更加推荐下面的方式"""

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

3.setdefault() 
 
setdefault() 方法和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值

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

2.字典修改值

dict ={'username':'dlrb','age':18,'hobbies': ['play game', 'basketball']}

dict['username'] = 'mark' # 键存在是修改值
print(dict) 

dict['class'] = 'first'
print(dict) 	# 键不存在则是新增一个键值对

#{'username': 'mark', 'age': 18, 'hobbies': ['play game', 'basketball'], 'class': 'first'}

3.字典统计键值对的个数

 dict ={'username':'dlrb','age':18,'hobbies': ['play game', 'basketball']}
    
    print(len(dict))  # 3

4.字典成员运算

dict ={'username':'dlrb','age':18,'hobbies': ['play game', 'basketball']}

print('username' in dict) #	True

print('dlrb' in dict) #	False

in 操作符用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false
	'只能判断key'

5.字典删除键值对

dict ={'username':'dlrb','age':18,'hobbies': ['play game', 'basketball']}

1.del 删除
del dict['username']
print(dict) #{'age': 18, 'hobbies': ['play game', 'basketball']}

2.pop()
print(dict.pop('age')) # 18  弹出
print(dict)   # {'name': 'jason', 'hobbies': ['play game', 'basketball']}

3. dict.popitem()  # 随机弹出一个(使用频率很低 可以忽略)
print(dict)
	#{'username': 'dlrb', 'age': 18}
    
    '''方法随机返回并删除字典中的一对键和值(一般删除末尾对)。

如果字典已经为空，却调用了此方法，就报出KeyError异常。'''

6.获取所有的键 所有的值 所有的键值对

keys() .获取所有的键 所有的值 所有的键值对

dict ={'username':'dlrb','age':18,'hobbies': ['play game', 'basketball']}

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

values() 方法以列表返回字典中的所有值

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

print(d1.items()) #	dict_items([('username', 'dlrb'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

'可以看成是列表套元组'
"""在python2中上述三个方法就是直接返回一个列表 """

7.字典的更新

 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.fromkeys()快速生成字典
函数用于创建一个新字典，以序列k1,k2,k3中元素做字典的键，value为字典所有键对应的初始值。

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

 dic['k1'].append(1)  # 三个键指向的是同一个列表
 print(dic)  # {'k1': [1], 'k2': [1], 'k3': [1]}

---

元组内置方法

1.元组的定义

元组其实就是不可变的列表
列表可读可改, 而元组只读不能改
同等数据类型下, 元组更加节省空间, 并且效率更高于列表
因为元组底层只提供读的机制, 而列表既有读也有改的机制

在 “( )” 内用逗号分隔开多个任意类型的元素
如果元组内只包含一个元素, 那么需要用逗号隔开: (111,)
元组不可变指的是第一层元素的内存地址不能改变
如果第一层里面包含一个子列表, 那么子列表的内存地址不能改变, 但可以改变子列表里面的元素(列表可变类型)
“工厂” : tuple

2.元组常用操作

# 可以看成是不可变的列表
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))  # 报错
    """
    一般情况下 我们会习惯性的将所有可以存储多个数据的类型的数据
    如果内部只有一个元素 也会加逗号
        (1,)
        [1,]
        {1,}
        {'name':'jason',}"""
2.索引取值

	tup = (11,22,33,44,55)
	
    print(tup[0]) # 11 正向取
    
    print(tup[-1]) # 55 反向取

3.切片操作 #顾头不顾尾

tup = (11,22,33,44,55)
    
    print(tup[1:4]) #	(22, 33, 44)
    print(tup[-1:-4:-1]) #	(55, 44, 33)
    print(tup[-4:-1]) #	(22, 33, 44)
    
    tup2 = tup[::-1]
    print(tup2) #	(55, 44, 33, 22, 11)
    
4.统计元组内元素的个数
 	print(len(tup))  # 5

5.成员运算 in 和 not in
	print(66 in tup) # 	False
    
    print(11 in tup) #	True

6.统计某个元素出现的次数
	tup = (11,22,11,33,11,44,11,55,11,66)
    print(tup.count(11))	#	5
    
7.元组内元素不能"修改": 元组内各个索引值指向的内存地址不能修改
    
        # t1[0] = 111
    """
    笔试题
        tt = (11, 22, 33, [11, 22])
        tt[-1].append('heiheihei')
        问:执行之后的结果   正确答案选B
            A.报错    B.正常添加   C.不知道   
    """
    tt = (11, 22, 33, [11, 22])
    print(id(tt[-1]))
    tt[-1].append('heiheihei')
    print(id(tt[-1]))
    print(tt)

---

集合内置方法

'''集合主要作用：去重；关系运算'''

集合的元素遵循三个原则：1：每个元素必须是不可变类型（可hash，可作为字典的key）；2：没有重复的元素；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))  # 报错
    """集合内元素只能是不可变类型"""
 
"""集合只会在去重和关系运算中使用 甚至有时候也不会用"""

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来一次

---