9.python字典基础操作

字典

‘’’
1.python字典是属于python数据类型的-映射类型的一种数据类型，采用键-值的方式进行存储数据，
2.它是一种可变的容器模型，可以动态处理/存储数据
3.字典中键值（key）必须是唯一不可重复的，而value是可以重复的
4.字典中键值是不可变的，所以一般是数字，字符串，元组等

‘’’

创建字典

‘’’
python创建字典可以使用大括号【{}】的方式创建，也可以使用内置函数：dict()方式进行创建

‘’’

print('console'.center(50,'-'))

dict_1 = {} #创建一个空字典

dict_2 ={'name':'xw','age':18} #创建一个非空字典

dict_3 = dict() #使用内置函数创建一个空字典

dict_4 = dict(name='xw',age=19) #使用内置函数创建一个非空字典，关于dict()详细方法，后续在内置函数中详细说明
print(type(dict_1))
print(dict_1)

print(type(dict_2))
print(dict_2)

print(type(dict_3))
print(dict_3)

print(type(dict_4))
print(dict_4)
---------------------console----------------------
<class 'dict'>
{}
<class 'dict'>
{'name': 'xw', 'age': 18}
<class 'dict'>
{}
<class 'dict'>
{'name': 'xw', 'age': 19}

访问字典中指定的键的值

‘’’
访问字典的值，一般常用的方法主要有两种
使用中括号’[]’ 或 get()方法进行获取

使用中括号[key]进行获取指定value，如果key不存在，则会抛出错误
使用get(key)进行获取指定的value,如果key不存在，则返回默认值，也可以设置指定的默认值
‘’’

print('console'.center(50,'-'))
dict_1 = dict(name='xw',age=19)

dict_name_value = dict_1['name'] #获取指定key的value值

print(dict_name_value)
#dict_name_value = dict_1['namexx'] #key值不存在则会抛出错误

dict_name_value = dict_1.get('name') #获取指定key的value值

print(dict_name_value)


dict_name_value = dict_1.get('namexx','no namexx') #获取指定key的value值,不存在则返回指定的默认值值，默认为None
print(dict_name_value)
---------------------console----------------------
xw
xw
no namexx

字典的遍历

dict.items():返回一个dict_item类型对象

#遍历字典，返回二元元组构成的dict_item类型对象
#dict_item类型对象可以遍历，但是不可以修改

print('console'.center(50,'-'))
dict_1 = {'name':'xw','age':18}

dict_items = dict_1.items()

print(type(dict_items))
print(dict_items)

print('-'*20)
for item in dict_items:
    print(type(item))
    print(item)

print('-'*20)

for key,value in dict_items:
    print(type(key),type(value))
    print(key,value)
---------------------console----------------------
<class 'dict_items'>
dict_items([('name', 'xw'), ('age', 18)])
--------------------
<class 'tuple'>
('name', 'xw')
<class 'tuple'>
('age', 18)
--------------------
<class 'str'> <class 'str'>
name xw
<class 'str'> <class 'int'>
age 18

dict.keys():返回字典的键(keys)dict_keys对象

#dict_keys对象可以遍历，但是不可以修改
print('console'.center(50,'-'))
dict_1 = {'name':'xw','age':18}
dict_keys = dict_1.keys()
print(type(dict_keys))
print(dict_keys)
print('-'*20)
for key in dict_1.keys():#遍历
    print(key)

print('-'*20)
list_keys = list(dict_keys) #转成列表形式
print(type(list_keys))
print(list_keys)
---------------------console----------------------
<class 'dict_keys'>
dict_keys(['name', 'age'])
--------------------
name
age
--------------------
<class 'list'>
['name', 'age']

dict.values():返回字典的值(value)dict_values对象

#dict_values对象可以遍历，但是不可以修改
print('console'.center(50,'-'))
dict_1 = {'name':'xw','age':18}
dict_values = dict_1.values()
print(type(dict_values))
print(dict_values)

print('-'*20)
for value in dict_1.values(): #遍历
    print(value)

print('-'*20)
list_values = list(dict_values) #转成列表形式
print(type(list_values))
print(list_values)
---------------------console----------------------
<class 'dict_values'>
dict_values(['xw', 18])
--------------------
xw
18
--------------------
<class 'list'>
['xw', 18]

字典的删除/清除

‘’’
字典的删除和清除方法会有很多，例如clear(),del,pop(),popitem()方法
‘’’

dict.clear():清空字典

#clear方法会清空字典列表，产生一个空的字典

print('console'.center(50,'-'))
dict_1 = {'name':'xw','age':18}
dict_1.clear()
print(type(dict_1))
print(dict_1)
---------------------console----------------------
<class 'dict'>
{}

del ：删除字典/删除键值

print('console'.center(50,'-'))
dict_1 = {'name':'xw','age':18}

del dict_1['name'] #删除name的键值

print(dict_1)

del dict_1 #删除整个字典

#print(dict_1) #会抛出错误，变量在内存中已经不存在了，无法获取到改变量参数
---------------------console----------------------
{'age': 18}

dict.pop(key):删除给定的键对应的值

#dict.pop(key)会删除给定的键所对应的值并返回被删除的值

print('console'.center(50,'-'))
dict_1 = {'name':'xw','age':18}
dict_pop_name = dict_1.pop('name')
print(dict_pop_name)
print(dict_1)
---------------------console----------------------
xw
{'age': 18}

dict.popitem(key): 随机返回并删除字典中的最后一对键和值-元组类型。

#popitem():如果字典为空，则会抛出异常
print('console'.center(50,'-'))
dict_1 = {'name':'xw','age':18}
dict_popitem = dict_1.popitem()
print(type(dict_popitem))
print(dict_popitem)
print(dict_1)
---------------------console----------------------
<class 'tuple'>
('age', 18)
{'name': 'xw'}

修改字典

使用中括号[]修改键的值

print('console'.center(50,'-'))
dict_1 = {'name':'xw','age':18}

dict_1['name'] = 'Mr.xu'  #如果键存在，则进行修改
print(dict_1)

dict_1['sex'] = 'man' #如果键不存在，则进行新增
print(dict_1)
---------------------console----------------------
{'name': 'Mr.xu', 'age': 18}
{'name': 'Mr.xu', 'age': 18, 'sex': 'man'}

dict.setdefault(key,value):键不存在则会进行新增

#如果key值存在，则不进行修改，如果key值不存在则会进行修改，value非必填，默认为None
print('console'.center(50,'-'))
dict_1 = {'name':'xw','age':18}
dict_1.setdefault('sex') # value值默认为None
print(dict_1)

dict_1.setdefault('hobby','play basketball') #指定key对应的value值
print(dict_1)

dict_1.setdefault('name','Mr.xu') #key值已经存在则不进行修改
print(dict_1)
---------------------console----------------------
{'name': 'xw', 'age': 18, 'sex': None}
{'name': 'xw', 'age': 18, 'sex': None, 'hobby': 'play basketball'}
{'name': 'xw', 'age': 18, 'sex': None, 'hobby': 'play basketball'}

dict.update(dict1): 将参数的字典更新到另一个字典中

print('console'.center(50,'-'))
dict_1 = {'name':'xw','age':18}
dict_2 = {'sex':'man','name':'Mr.xu'}

dict_1.update(dict_2)#如果键存在重复，则会去重，对应的键对应的值会获取参数对应的键值
print(dict_1)
---------------------console----------------------
{'name': 'Mr.xu', 'age': 18, 'sex': 'man'}

dict.copy()：返回一个浅复制字典

print('console'.center(50,'-'))
dict_1 = {'name':'xw','age':18,'sport':['basketball','football']}
dict_copy = dict_1.copy() #使用浅复制，只是深复制父对象，子对象不拷贝，只是引用
print(type(dict_copy))
print(dict_copy)

dict_1['name']='xu.Mr' #修改原始的值
dict_1['sport'][0]='ping-pong' #修改原始的值
print(dict_copy) #会发现name不回进行修改，但是sport会进行修改
---------------------console----------------------
<class 'dict'>
{'name': 'xw', 'age': 18, 'sport': ['basketball', 'football']}
{'name': 'xw', 'age': 18, 'sport': ['ping-pong', 'football']}

dict.fromkeys(seq, value):生成一个字典

'''
参数说明：
seq: 字典键列表
value: 默认为空，如果设置指定的值，那么对应键值就是指定的值
'''
print('console'.center(50,'-'))
seq_1 = ('name', 'age', 'sex')
dict_1 = dict.fromkeys(seq_1) #键对应的值为None
print(type(dict_1))
print(dict_1)

dict_2 = dict.fromkeys(seq_1,20) #键对应的值为指定的值
print(dict_2)
---------------------console----------------------
<class 'dict'>
{'name': None, 'age': None, 'sex': None}
{'name': 20, 'age': 20, 'sex': 20}

in:判断键是存在存在字典中

print('console'.center(50,'-'))
dict_1 =  {'name':'xw','age':18}
is_exist = 'name' in dict_1 #存在返回True
print(is_exist)

is_exist = 'namexx' in dict_1 #不存在则返回False
print(is_exist)
---------------------console----------------------
True
False