Python字典

一.创建和使用字典

列表 元组
共同点：都是通过索引引用元素值
不同点：列表是可读写的，元组是只读的

names = ["Bill", "Mike", "John", "Mary"]
numbers = ["1234", "4321", "6789", "6543"]
print(numbers[names.index("Mike")])
print(names[numbers.index("6543")])
结果：
4321
Mary
# key和value
phoneBook = {"Bill":"1234","Mike":"4321","John":"6645","Mary":"7753"}
print(phoneBook)
print(phoneBook["Bill"])
结果：
{'Bill': '1234', 'Mike': '4321', 'John': '6645', 'Mary': '7753'}
1234

1.1.1 dict函数

items = [['Bill',"4321"],("Mike","7891"),['John','4567']]
d = dict(items)
print(d)
结果：
{'Bill': '4321', 'Mike': '7891', 'John': '4567'}

1、为dict函数传入一个列表类型参数值，列表的每一个元素（或者是一个列表，或者是一个元祖）包含两个值，第一个表示键，第二个表示值。
2、dict函数通过关键字来创建字典

在这里插入代码片
dict1 = dict(name="Bill", number=6543, age=34)
print(dict1)
结果：
{'name': 'Bill', 'number': 6543, 'age': 34}

1.1.2字典的格式化字符串

# 用format_map方法格式化字符串
values1 = (1,2,'hello')
str1 = "abc %d   xyz, %d   %s world"
print(str1 % values1)
结果：
abc 1   xyz, 2   hello world

1.1.3 序列与迭代

1.获取字典中key的列表

dict={"x":1,"y":2,"z":3}
for key in dict:
    print(key,end=" ")
结果：x y z 

2.获取字典中key—value对的列表
如果要同时获取字典中的key和value，除了在上面的代码中使用dict[ ]获取值外，还可以使用字典中的items方法同时获取key和value。

dict={"x":1,"y":2,"z":3}
for key,value in dict.items():
    print(key,value)
结果：
x 1
y 2
z 3

dict={"x":1,"y":2,"z":3}
for key,value in dict.items():
    print(key,value,end=" ")
结果：x 1 y 2 z 3 

3.并行迭代
如果同时迭代两个或者多个序列，那么可以使用range函数获取序列索引的范围，然后使用for语句进行迭代。对多个序列进行迭代，一般要求序列中的元素个数相同。

names=["Bill","Mary","John"]
ages=[30,40,20]
for i in range(len(names)):
    print(names[i],ages[i])
结果：
Bill 30
Mary 40
John 20

4.压缩序列
这里的压缩序列是指使用zip函数将两个或者多个序列的对应元素作为一个元祖放到一起，进行压缩的两个或者多个序列的元素个数如果不相同，以元素个数最少的为准。

company=["百度","谷歌","小米"]
web=["https://www.baidu.com","https://www.google.com"]
for i in zip(company,web):
    print(i)
结果：
('百度', 'https://www.baidu.com')
('谷歌', 'https://www.google.com')

5.反转序列迭代
通过reversed函数将一个序列反转

company=reversed(["百度","谷歌","小米"])
print(company)
结果：<list_reverseiterator object at 0x0000000001D86550>

company=reversed(["百度","谷歌","小米"])
for i in company:
    print(i,end=" ")
结果：小米 谷歌 百度 

二.字典方法

2.1.1 clear方法

names1 = {"Bill":20, "Mike":30,"John":50}
names2 = names1
names1["Bill"] = 45
print(names2)
names1.clear()
print(names2)
结果：
{'Bill': 45, 'Mike': 30, 'John': 50}
{}

2.1.2 copy方法和deepcopy方法

浅拷贝（copy）
浅拷贝是对于一个对象的顶层拷贝----通俗的理解是：拷贝了引用，并没有拷贝内容

其中，C语言是真正的复制对象中的内容

import copy
a=[11,12]
b=[22,23]
c=[a,b]
print(c)      结果：[[11, 12], [22, 23]]

e=copy.copy(c)
print(id(c))  结果：165886536
print(id(e))  结果:31244488
print(e)      结果：[[11, 12], [22, 23]]

深拷贝
深拷贝是对于一个对象所有层次的拷贝(递归)
进一步理解深拷贝

拷贝的其他方式
分片表达式可以赋值一个序列

字典的copy方法可以拷贝一个字典

注意点：
浅拷贝对不可变类型和可变类型的copy不同
①copy.copy对于可变类型，会进行浅拷贝
②copy.copy对于不可变类型，不会拷贝，仅仅是指向

In [88]: a = [11,22,33]
In [89]: b = copy.copy(a)
In [90]: id(a)
Out[90]: 59275144
In [91]: id(b)
Out[91]: 59525600
In [92]: a.append(44)
In [93]: a
Out[93]: [11, 22, 33, 44]
In [94]: b
Out[94]: [11, 22, 33]
-----------------------------------------------------------
In [95]: a = (11,22,33)
In [96]: b = copy.copy(a)
In [97]: id(a)
Out[97]: 58890680
In [98]: id(b)
Out[98]: 58890680

2.1.3 fromkeys方法

fromkeys方法用于根据key建立新的字典（该方法的返回值就是新的字典）。在新的字典中，所有的key都有相同的默认值。在默认情况下，fromkeys方法会为每一个key指定None为其默认值。不过可以使用fromkeys方法的第2个参数设置新的默认值。

#在一个空字典上调用fromkeys方法创建一个新的字典（newdict），通过列表指定key
newdict1 = {}.fromkeys(['name','age','company'])
print(newdict1)
#输出结果：{'name': None, 'age': None, 'company': None}


#在newdict1上调用fromkeys方法创建一个新的字典（newdict2），通过元组指定key
newdict2 = newdict1.fromkeys(('name','age','company'))
print(newdict2)
#输出结果：{'name': None, 'age': None, 'company': None}


#通过fromkeys方法的第2个参数指定key的默认值，通过列表指定key
newdict3 = newdict1.fromkeys(['name','age','company'],'没有值')
print(newdict3)
#输出结果：{'name': '没有值', 'age': '没有值', 'company': '没有值'}

2.1.4 get( )方法

当使用dict[key]形式从字典获取value时，如果key在dict中不存在，那么程序会抛出异常。

dict = {"name":"Bill", "age":30}
print(dict["age"])
#dict['salary'] = 3000
print(dict['salary'])
结果：
Traceback (most recent call last):
  File "D:/pycharm/工程/网页爬虫/练习.py", line 5, in <module>
    print(dict['salary'])
KeyError: 'salary'

get()方法用于更宽松的访问字典项的方法。如果Key不存在，使用get()没有任何异常，仅仅返回None值.

dict = {"name":"Bill", "age":30}
print(dict["age"])
#dict['salary'] = 3000
print(dict.get('salary',3000))
结果：
30
3000

2.1.5 items( )方法和keys( )方法

items方法用于返回字典中所有key-value对。获得的每一个key-value对用一个元组表示。items方法返回的值是一个被称为字典视图的特殊类型，可以被用于迭代（如果用在for循环中）。items方法的返回值与字典使用了同样的值，也就是说，修改了字典或items方法的返回值，修改的结果就会反映在另一个方法上。keys方法用于返回字典中所有的key，返回值类型与items方法类似，可以用于迭代。
【2.1.4】本例演示了如何使用items方法获取字典中的key-value对，以及使用keys方法获取字典中所有的key，并通过for循环迭代items方法和keys方法的返回值。

#定义一个字典
dict = {'help':'帮助','bike':'自行车','banana':'香蕉','China':'中国'}

#在控制台输出字典中所有的key-value对
print(dict.items())

#通过for循环对dict中所有的值对进行迭代
for key_value in dict.items():
    print('key','=',key_value[0],'value','=',key_value[1])

#判断('bike','自行车')是否在items方法的返回值中
print(('bike','自行车') in dict.items())


#获取key-value对
dict_items = dict.items()
#修改字典中的值
dict['bike'] = '自行车;摩托车;电动车;'

#修改字典中的值后，dict_items中的值也会随着变化
print(dict_items)

#输出字典中所有的key
print(dict.keys())

#对字典中所有的key进行迭代
for key in dict.keys():
    print(key,end = ' ')

结果：

dict_items([('help', '帮助'), ('bike', '自行车'), ('banana', '香蕉'), ('China', '中国')])
key = help value = 帮助
key = bike value = 自行车
key = banana value = 香蕉
key = China value = 中国
True
dict_items([('help', '帮助'), ('bike', '自行车;摩托车;电动车;'), ('banana', '香蕉'), ('China', '中国')])
dict_keys(['help', 'bike', 'banana', 'China'])
help bike banana China 
Process finished with exit code 0

2.1.6 pop( )方法和popitem( )方法

pop方法与popitem方法都用于弹出字典中的元素。pop方法用于获取指定key的值，并从字典中弹出这个key-value对。popitem方法用于返回字典中最后一个key-value对，并弹出这个key-value对。对于字典来说，里面的元素并没有顺序的概念，也没有append或类似的方法，所以这里所说的最后一个key-value对，也就是为字典添加key-value对时的顺序，最后一个添加的key-value对就是最后一个元素。

# pop方法，用于获取指定的key的值，并从字典中弹出这个key-value对
# popitem方法用于返回字典中最后一个key-value对，并弹出key-value对
d = {'c':10,'a':40,'b':12,'x':45}
d['1'] = 20
d['5'] = 100

print(d.pop('a'))
print(d)

for i in range(len(d)):
    print(d.popitem())

结果：

40
{'c': 10, 'b': 12, 'x': 45, '1': 20, '5': 100}
('5', 100)
('1', 20)
('x', 45)
('b', 12)
('c', 10)

2.1.7 setdefault()方法

setdefault方法用于设置key的默认值。该方法接收两个参数，第1个参数表示key，第2个参数表示默认值。如果key在字典中不存在，那么setdefault方法会向字典中添加这个key，并用第2个参数作为key的值。该方法会返回这个默认值。如果未指定第2个参数，那么key的默认值是None。如果字典中已经存在这个key，setdefault不会修改key原来的值，而且该方法会返回key原来的值。

d = {"name":"Bill", "age":30}
d['salary'] = 2000
d['age'] = 50

# None
print(d.setdefault("location","中国"))
print(d)
print(d.setdefault("location", "德国"))
print(d)

print(d.setdefault("abc"))
print(d)

结果：

中国
{'name': 'Bill', 'age': 50, 'salary': 2000, 'location': '中国'}
中国
{'name': 'Bill', 'age': 50, 'salary': 2000, 'location': '中国'}
None
{'name': 'Bill', 'age': 50, 'salary': 2000, 'location': '中国', 'abc': None}

2.1.8 update( )方法

1.用一个字典中的key-value对更新另外一个字典，该方法接收一个参数
2.该参数表示用作更新数据的字典数据源。
3.dict1.update(dict2),dict2中的元素更新dict1。

d1 = {
    'title':'美好',
    'website':'小米',
    'description':'手机'
}

d2 = {
    'title':'百度',
    'products':['贴吧','博客','读书频道','百度文库'],
    'description':'搜索'
    }
d1.update(d2)
print(d1)

结果：

{'title': '百度', 'website': '小米', 'description': '搜索', 'products': ['贴吧', '博客', '读书频道', '百度文库']}

2.1.9 values( ) 方法

values方法用于以迭代器形式返回字典中值的列表。与keys方法不同的是，values方法返回的值的列表可以有重复。而keys方法返回的键值列表不会有重复的key。

d = {
    'a':1,
    'b':2,
    'c':2,
    'd':4,
    'e':1,
}
print(d.values())
#对值列表进行迭代
for value in d.values():
    print(value)

结果：

dict_values([1, 2, 2, 4, 1])
1
2
2
4
1