Python学习字典

Python字典基础知识学习
字典基础知识：字典（dict）是可变的无序集合，是一种以**“键值对”**为基本元素的可以存储各种数据类型的集合，用大括号（{}）表示字典的开始和结束，元素之间用逗号（,）分隔。
**键值对：**由键（key）和值（value）组成，中间用冒号（:）分隔，如(Tim:18)，键为Tim，对应值为18，是紧密的一对一关系，由键值对可以看出，字典属于一对一映射的数据类型。
字典内部结构由哈希表构成，通过唯一的键返回对应的值，所以字典对象没有提供排序功能，字典数据类型是无序的，这是与列表，元组之间的一个明显区别。列表，元组的元素允许重复，字典的元素（其实就是键）不允许重复。
字典基本格式表示：

>>> {}  #空字典
{}
>>> d1={'Tim':18}  #定义一个元素的字典变量
>>> d1
{'Tim': 18}
>>> len(d1)
1
>>> d2={1:'car',2:'bus'}  #定义两个元素的字典变量
>>> d2
{1: 'car', 2: 'bus'}
>>> len(d2)
2

字典的键，值设置要求：
（1）唯一性：一个字典里所有键必须唯一。
如：

>>> d3={1:'car',2:'bus',2:'bus'}
>>> d3
{1: 'car', 2: 'bus'}  #字典把重复的元素归并成了一个
>>> len(d3)
2
>>> d4={1:'car',2:'bus',2:'train'}
>>> len(d4)
2
>>> d4
{1: 'car', 2: 'train'} #字典只保留了键相同的最后一个元素

（2）不可变性：不能对元素的键进行直接修改，只能通过其他方法处理。同理，不能接受可以修改的列表对象作为键被使用。
字典的基本方法：

方法	功能
clear	字典清空
copy	复制生成另外一个字典
fromkeys	使用给定的键建立新的字典，每个键默认对应的值为None
get	根据指定键，返回对应值；键不存在时，返回None
items	以元组数组的形式返回字典中的元素
keys	以可以浏览的类似列表形式返回字典中的键
pop	删除指定键的元素，并返回指定键对应的值
popitem	随机返回元素，并删除元素
setdefault	当字典中的键不存在时，设置键值对；当存在键时，获取键对应的值。
updata	利用一个字典更新另外一个字典
values	以可以浏览的类似列表的形式返回字典中的值

字典的一些操作

字典元素增加：
1、利用赋值为字典增加元素(前提是字典中没有新增的键，否则会修改指定键的值)

>>> d1={1:'car',2:'bus'}
>>> d1[3]='train'  #字典变量增加新元素3:'train'
>>> d1
{1: 'car', 2: 'bus', 3: 'train'}

2、利用setdefault()方法给字典增加元素
setdefault()的格式为：D.setdefault(k[,d])，D代表字典，k代表新增键，d代表新增键对应的值。（如果不提供值，则默认为None）这种方法新增键值对时，若指定键已经存在，则显示已经存在键的值。

>>> d1={1:'car',2:'bus'}
>>> d1.setdefault(3,'train') #新增3:'train'键值对
'train'                      #显示新增键的值
>>> d1
{1: 'car', 2: 'bus', 3: 'train'}
>>> d1.setdefault(4)         #新增键为4的元素，不指定值
>>> d1
{1: 'car', 2: 'bus', 3: 'train', 4: None} #返回None
>>> d1.setdefault(1)
'car'

字典值查找
1、字典名+[key]查找

>>> d2={1:'red',2:'green',3:'yellow'}
>>> d2[1]  #返回键为1的值
'red'
>>> d2[4]  #返回不存在的键对应的值，会报错。
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    d2[4]
KeyError: 4

2、利用get()方法查找
格式为D.get(k[,d])，D代表字典，k为指定的键，d为键对应的值（可选）

>>> d2={1:'red',2:'green',3:'yellow'}
>>> d2.get(2)  #查键为2的值
'green'
>>> d2.get(4) #查不存在的键的值，不返回任何值，但不会报错。更加符合实际需要

字典值修改
1、利用赋值修改键对应的值

>>> d2={1:'red',2:'green',3:'yellow'}
>>> d2[3]='blue' #要确保存在键，否则就变成了新增键值对
>>> d2
{1: 'red', 2: 'green', 3: 'blue'}

2、利用update()方法修改键对应的值
格式为D.update(d1)，D代表要更新的字典，d1为提供更新内容的字典。若d1里提供的键在D里存在，则更新D里对应的键值；若d1里提供的键在D里不存在，则增加键值对。

>>> d1={1:'red',2:'green',3:'yellow'}
>>> d2={1:'blue',3:'grey'}
>>> d1.update(d2) #调用update()方法用d2更新d1
>>> d1
{1: 'blue', 2: 'green', 3: 'grey'}

>>> d1={1:'red',2:'green',3:'yellow'}
>>> d2={4:'blue',5:'grey'}
>>> d1.update(d2) #调用update的方法为d1增加元素
>>> d1
{1: 'red', 2: 'green', 3: 'yellow', 4: 'blue', 5: 'grey'}

字典元素删除
1、利用del函数删除

>>> d1={1:'red',2:'green',3:'blue',4:'yellow'}
>>> del(d1[1]) #删除键值为1的元素
>>> d1
{2: 'green', 3: 'blue', 4: 'yellow'}
>>> 

2、利用pop()方法删除
pop()方法的使用格式为D.pop(k[,d])，其中，D代表字典对象，k为需要删除的元素的键，d为键对应的值（可选）

>>> d1={1:'red',2:'green',3:'blue',4:'yellow'}
>>> d1.pop(2)  #删除键为1的元素，并返回键为1的元素
'green'
>>> d1  
{1: 'red', 3: 'blue', 4: 'yellow'}
>>> 

3、利用popitem()方法删除
popitem()的方法的格式为D.popitem()，D为字典对象，随机返回一个键值对元组，并在字典中删除对应的元素。

>>> d1={1:'red',2:'green',3:'blue',4:'yellow'}
>>> k1,v1=d1.popitem()  #随机删除并返回一个键值对元组
>>> k1,v1
(4, 'yellow')
>>> d1
{1: 'red', 2: 'green', 3: 'blue'}
>>> d1.popitem() #随机删除并返回一个键值对元组
(3, 'blue')

字典遍历操作
1、遍历所有键值对
利用items()方法遍历所有键值对
格式为：D.items()。D代表字典对象。以元组数组形式返回字典的所有元素

>>> d1={1:'red',2:'green',3:'blue',4:'yellow'}
>>> for get_L in d1.items():  #循环获取元组
	print(get_L)

	
(1, 'red')
(2, 'green')
(3, 'blue')
(4, 'yellow')
>>> d1.items()
dict_items([(1, 'red'), (2, 'green'), (3, 'blue'), (4, 'yellow')])
>>> type(d1.items)
<class 'builtin_function_or_method'> #这是一个功能类和方法类

2、遍历所有键
1）利用字典变量循环遍历

>>> d1={1:'red',2:'green',3:'blue',4:'yellow'}
>>> for gets in d1:   #遍历所有键
	print(gets)

	
1
2
3
4

2）利用keys()方法获取字典键
keys()方法的使用格式为D.keys()，D代表字典变量

>>> d1={1:'red',2:'green',3:'blue',4:'yellow'}
>>> for k in d1.keys():   #keys()方法获得字典键
	print(k)

	
1
2
3
4

遍历所有值
1）通过键遍历值

>>> d1={1:'red',2:'green',3:'blue',4:'yellow'}
>>> for gets in d1:  #循环获取字典的键
	print(d1[gets])  #打印字典键对应的值

	
red
green
blue
yellow

2）利用values()方法获取字典值
格式为：D.values()，D为字典变量

>>> d1={1:'red',2:'green',3:'blue',4:'yellow'}
>>> for get_v in d1.values(): #循环获取所有值
	print(get_v)

	
red
green
blue
yellow
>>> d1.values()
dict_values(['red', 'green', 'blue', 'yellow'])
>>> type(d1.values)
<class 'builtin_function_or_method'>  #功能类和方法类

字典的一些其他操作方法
1）in成员操作
字典的元素对象、键对象、值对象，实质上构成了相应的集合，所以可以通过集合成员操作符号进行相关的操作。

>>> d1={1:'red',2:'green',3:'blue',4:'yellow'}
>>> 1 in d1
True
>>> 'red' in d1
False
>>> 'red' in d1.values()
True
>>> 1 in d1.keys()
True
>>> 

类似的成员操作还可以用于字典的items()，values()方法。

2）clear()方法
使用格式D.clear()，D代表字典变量。

>>> d1={1:"green",2:"red",3:"blue"}
>>> d1
{1: 'green', 2: 'red', 3: 'blue'}
>>> d1.clear()
>>> d1
{}
>>> 

3）copy()方法
使用格式D.copy()，D代表字典变量。

>>> d1={1:"green",2:"red",3:"blue"}
>>> d2=d1.copy()
>>> d2
{1: 'green', 2: 'red', 3: 'blue'}
>>> id(d1) #获取d1的内存地址
2434638115176
>>> id(d2) #获取d2的内存地址
2434638115248
>>> 

通过copy()方法的复制，可以避免字典变量之间直接赋值指向同一个地址的问题。
如直接赋值：

>>> d1={1:"green",2:"red",3:"blue"}
>>> d1
{1: 'green', 2: 'red', 3: 'blue'}
>>> d3=d1
>>> d3
{1: 'green', 2: 'red', 3: 'blue'}
>>> id(d1)
2434638283688
>>> id(d3)
2434638283688
>>> del(d1[1])
>>> d1
{2: 'red', 3: 'blue'}
>>> d3
{2: 'red', 3: 'blue'}

直接赋值会导致修改一个变量的元素，另外一个字典变量也同步改变的问题。

注意：
Python3.X版本中，字典的copy()复制是深度复制，复制后产生的两个字典变量完全没有关系，互不影响。

4）fromkeys()方法
使用格式为D.fromkeys(iterable)，D代表字典变量，iterable代表列表对象，用于指定字典键。生成的D的键对应的值默认为None。

>>> d3={}.fromkeys(['red','blue','green'])
>>> d3
{'red': None, 'blue': None, 'green': None}
>>> 

利用fromkeys()的只增加键而对应值为空的特点，可以应用于一些特定的应用场景，如超市商品开始时只能确定名称，不能确定单价的情况。