python语法基础学习笔记Task06:字典与集合

1、字典

创建字典

• 字典是另一种可变容器模型，且可存储任意类型对象
• 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
• 键必须是唯一的，但值则不必
• 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组

#格式
d = {key1 : value1, key2 : value2 }
#例子
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }

访问字典

dict = {'Name': 'python', 'Age': 7, 'Class': 'First'}
 
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])
'''
dict['Name']:  python
dict['Age']:  7
'''

• 如果用字典里没有的键访问数据，会输出错误如下

dict = {'Name': 'python', 'Age': 7, 'Class': 'First'}
print ("dict['Alice']: ", dict['Alice'])
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'

修改字典

dict = {'Name': 'python', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8               # 更新 Age
dict['School'] = "LG"  # 添加信息
print ("dict['Age']: ", dict['Age'])#dict['Age']:  8
print ("dict['School']: ", dict['School'])#dict['School']: LG

删除字典元素

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable
#引发一个异常，执行 del 操作后字典不再存在

• 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

dict = {'Name': 'python', 'Age': 7, 'Name': 'LG'}
print ("dict['Name']: ", dict['Name'])#dict['Name']:  LG

• 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

dict = {['Name']: 'Runoob', 'Age': 7}
print ("dict['Name']: ", dict['Name'])
Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

字典内置函数
字典内置方法

字典的赋值和拷贝

• 赋值引用----b = a: a 和 b 都指向同一个对象
• 浅拷贝----b = a.copy(): a 和 b父对象是一个独立的对象，但他们的子对象还是指向统一对象（是引用）
• 深拷贝----b = copy.deepcopy(a): 完全拷贝了父对象及其子对象，a 和 b 的父对象及其子对象，两者都是完全独立的

import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象 
b = a                        #赋值，传对象的引用
c = copy.copy(a)             #对象拷贝，浅拷贝
d = copy.deepcopy(a)         #对象拷贝，深拷贝  
a.append(5)                  #修改对象a
a[4].append('c')             #修改对象a中的['a', 'b']数组对象
print( 'a = ', a )           #a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
print( 'b = ', b )           #b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
print( 'c = ', c )           #c =  [1, 2, 3, 4, ['a', 'b', 'c']]
print( 'd = ', d )           #d =  [1, 2, 3, 4, ['a', 'b']]

字典的排序

• 利用key排序

d = {'d1':2, 'd2':4, 'd4':1,'d3':3,}
for k in sorted(d):
    print(k,d[k])
'''
d1 2
d2 4
d3 3
d4 1
'''

• 利用value排序：getitem

d = {'d1':2, 'd2':4, 'd4':1,'d3':3,}
for k in sorted(d,key=d.__getitem__):
    print(k,d[k])
'''
d4 1
d1 2
d3 3
d2 4
'''

• 反序：reverse=True

d = {'d1':2, 'd2':4, 'd4':1,'d3':3,}
for k in sorted(d,key=d.__getitem__,reverse=True):
    print(k,d[k])
'''d2 4
d3 3
d1 2
d4 1
'''

• 对dict_items进行排序

d = {'d1':2, 'd2':4, 'd4':1,'d3':3,}
res = sorted(d.items(),key=lambda d:d[1],reverse=True)
print(res)
# [('d2', 4), ('d3', 3), ('d1', 2), ('d4', 1)]

2、集合

• 集合（set）是一个无序的不重复元素序列
• 可以使用大括号 { } 或者 set() 函数创建集合
• 创建一个空集合必须用 set() 而不是 { }； { } 是用来创建一个空字典

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)     # 去重功能
{'orange', 'banana', 'pear', 'apple'}

• 快速判断元素是否在集合内

>> 'orange' in basket        
True
>>> 'crabgrass' in basket
False

• 两个集合间的运算

>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

添加元素

• s.add( x )----将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

• s.update( x )----添加元素，且参数可以是列表，元组，字典等

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

移除元素

• s.remove( x )----将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'

• s.discard( x )----还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

• s.pop()----设置随机删除集合中的一个元素

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print(x)
'''
$ python3 test.py 
Runoob
多次执行测试结果都不一样
'''

• 在交互模式，pop 是删除集合的第一个元素（排序后的集合的第一个元素）

>>>thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
>>> thisset.pop()
'Facebook'
>>> print(thisset)
{'Google', 'Taobao', 'Runoob'}

• len(s)----计算集合元素个数

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3

• s.clear()----清空集合

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()

• x in s----判断元素是否在集合中存在

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False

集合内置方法

参考文献

• https://www.runoob.com/python3/python3-set.html
• https://www.runoob.com/python3/python3-dictionary.html
• https://www.cnblogs.com/kilometerwine/p/9712329.html
• https://www.cnblogs.com/faithfu/p/10825965.html