Self-study Python Fish-C Note9 P37to39

字典

导入例子 （摩斯密码表）

使用列表实现

# 法1
## 摩斯密码表
c_table = ['._', '_...', '_._.', '_..', '.', '.._.', '__.', '....', '..', '.___', '_._', '._..', '__', '_.', '___', '.__.', '__._', '._.',
           '...', '_', '.._', '..._', '.__', '_.._', '_.__', '__..', '.____', '..___', '...__', '...._', '.....', '_....', '__...', '___..', '____.', '_____']

## 摩斯明文表
d_table = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
           'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0']

code = input('请输入摩斯密码： ')
split_code = code.split(' ')
result = [d_table[c_table.index(each)] for each in split_code] # 列表推导式
print(result)

请输入摩斯密码：  ._ _... _._.


['A', 'B', 'C']

# 法2
## 摩斯密码对比表
c_table = ['A', '._', 'B', '_...', 'C', '_._.', 'D', '_..', 'E', '.', 'F', '.._.', 'G', '__.', 'H', '....', 'I', '..', 'J', '.___', 'K', '_._', 'L', '._..',
           'M', '__', 'N', '_.', 'O', '___', 'P', '.__.', 'Q', '__._', 'R', '._.', 'S', '...', 'T', '_', 'U', '.._', 'V', '..._', 'W', '.__', 'X', '_.._',
           'Y', '_.__', 'Z', '__..', '1', '.____', '2', '..___', '3', '...__', '4', '...._', '5', '.....', '6', '_....', '7', '__...', '8', '___..', '9', '____.', '0', '_____']

code = input('请输入摩斯密码： ')
split_code = code.split(' ')
result = [c_table[c_table.index(each)-1] for each in split_code]
print(result)

请输入摩斯密码：  ._ _... _._.


['A', 'B', 'C']

使用字典实现
NB：在映射类型数据的获取上，字典的效率是远远快于列表的

dic = {'._': 'A', '_...': 'B', '_._.': 'C', '_..': 'D', '.': 'E', '.._.': 'F', '__.': 'G', '....': 'H', '..': 'I', '.___': 'J', '_._': 'K', '._..': 'L',
       '__': 'M', '_.': 'N', '___': 'O', '.__.': 'P', '__._': 'Q', '._.': 'R', '...': 'S', '_': 'T', '.._': 'U', '..._': 'V', '.__': 'W', '_.._': 'X',
       '_.__': 'Y', '__..': 'Z', '.____': '1', '..___': '2', '...__': '3', '...._': '4', '.....': '5', '_....': '6', '__...': '7', '___..': '8', 
       '____.': '9', '_____': '0'}

code = input('请输入摩斯密码： ')
split_code = code.split(' ')
result = [dic[each] for each in split_code]
print(result)

请输入摩斯密码：  ._ _... _._.


['A', 'B', 'C']

创建字典

例子：
比如定义字典 dic = {'A': '1', 'B': '2'} 这里有两对映射关系，: 左边为字典的键，右边为字典的值。
NB:
（1）与序列不同，序列是通过位置的偏移来存取数据的，而字典则是通过键来实现写入和读取。事实上在 python3.7 之前，字典内部的存储顺序是得不到保证的，所以不能通过下标来切片。
（2）与序列不同，在序列中元素是可以重复的。字典中的键值对（项），一个键就是对应一个值，不可以存在重复的键。重复了就会用新的值覆盖原来的值。
（3）区分集合的创建

dic = {'A': '1', 'B': '2'}
type(dic) # 这里是字典

dict

se = {'A', '1', 'B', '2'}
type(se) #这里是集合

set

(4) 字典的索引需要用键值

dic['A']

'1'

（5）我们可以通过指定一个不存在于字典中的键， 来创建一个新的键值对

dic['C'] = '3'
print(dic['C'])

3

（6）创建字典的方法 （官方文档里的6种）

# method 1: using {} and :
dic1 = {'A': '1', 'B': '2'}

# method 2: dic() function
dic2 = dict(A = '1', B = '2')
## 注意 dict 函数使用时，不可以给键加引号 dict('A' = '1', 'B' = '2') 会报错

# method 3: 使用列表作为参数，列表中的每一个元素是使用元组包裹起来的键值对
dic3 = dict([('A', '1'), ('B', '2')])

# method 4: 将法一作为参数传递给dict
dic4 = dict({'A': '1', 'B': '2'})

# method 5: 混合方法
dic5 = dict({'A': '1'}, B = '2')

# method 6: zip function
## zip 函数的作用是创建一个聚合多个可迭代对象的迭代器，可以将这个迭代器作为参数传递给 dic 函数
dic6 = dict(zip(['A', 'B'], ['1', '2']))

dic1 == dic2 == dic3 == dic4 == dic5 == dic6

True

字典的方法 （增删改查）

增

1. fromkeys(iterable[,values]) 方法

介绍： fromkeys(iterable[,values]) 可以使用 iterable 参数指定的可迭代对象来创建一个新的字典，并将所有的值初始化为 values 参数指定的值。
这种方法适用于从无到有，创建一个所有键的值都相同的字典，即快速初始化一个字典。

dic1 = dict.fromkeys('ABC', 0)
dic1

{'A': 0, 'B': 0, 'C': 0}

如果需要修改某个键的值：

dic1['A'] = 1
dic1

{'A': 1, 'B': 0, 'C': 0}

2. 通过指定一个不存在于字典中的键， 来创建一个新的键值对

dic1 = {'A': '1', 'B': '2'}
dic1['D'] = 4
print(dic1['D'])

4

删

1. pop(key[,default]) 方法

介绍：删除字典中指定的元素, 返回的是指定元素对应的值。
注意如果pop一个不存在的键就会抛出异常。可以通过 default 参数避免异常，返回给的 default 参数

dic1 = {'A': '1', 'B': '2'}
dic1.pop('A')

'1'

# default 参数
dic1 = {'A': '1', 'B': '2'}
dic1.pop('C', 'not exist')

'not exist'

2. popitem() 方法

介绍：在 python3.7 之前是随机删除一个键值对。在 python 3.7 之后是删除最后一个加入字典的键值对。返回删除的那个键值对。

dic1 = {'A': '1', 'B': '2'}
dic1['Z'] = 3
dic1.popitem()

('Z', 3)

dic1

{'A': '1', 'B': '2'}

3. del 语句

# 删除字典里的一个元素
dic1 = {'A': '1', 'B': '2', 'C': '3'}
del dic1['C']
dic1

{'A': '1', 'B': '2'}

del 也可以直接删掉整个字典 如： del dic1

4. clear() 方法

描述：清空字典里的内容

dic1 = {'A': '1', 'B': '2', 'C': '3'}
dic1.clear()
dic1 # 变成了一个空字典

{}

改

1. 指定键，修改对应值

dic1 = {'A': '1', 'B': '2'}
dic1['B'] = 3
dic1

{'A': '1', 'B': 3}

2. update([other])方法

描述：可以同时修改多个键值对，也可以直接传入另外一个字典，或者一个包含键值对的一个可迭代对象

dic1 = dic.fromkeys('abc')
dic1

{'a': None, 'b': None, 'c': None}

dic1.update({'a': '1', 'b': '2'})
dic1

{'a': '1', 'b': '2', 'c': None}

dic1.update({'a': '2', 'b': '3', 'e': '5'})
dic1

{'a': '2', 'b': '3', 'c': None, 'e': '5'}

dic1.update(a=3,e=6)
dic1

{'a': 3, 'b': '3', 'c': None, 'e': 6}

查

1. 指定键，返回对应值

dic1 = {'A': '1', 'B': '2'}
dic1['B'] 

'2'

但是如果指定一个不存在的键，就会报错 如 dic1['b']。 要避免这一点可以使用接下来的 get() 方法

2. get(key[,default]) 方法

描述：可以传入一个 default 参数，用来指定当找不到对应键时，返回的值

dic1 = {'A': '1', 'B': '2'}
dic1.get('C', 'not exist')

'not exist'

3. setdefault(key[,default]) 方法

描述：查找某个键是否存在于字典中，若存在返回该键对应的值，若不存在赋予一个新的值

dic1 = {'A': '1', 'B': '2'}
dic1.setdefault('B', '3') # 此时返回的是 B 键对应的值

'2'

dic1.setdefault('C', '3') # 此时返回 3， 并且字典发生更新加入了一个新的键值对

'3'

dic1

{'A': '1', 'B': '2', 'C': '3'}

4. items(), keys(), values() 方法

描述：分别用于获取字典的键值对，键，和值三者的视图对象
视图对象：视图对象是字典的动态视图，这就意味着当字典的内容发生改变的时候，视图对象的内容也会相应地跟着改变。

# 创建三个视图对象
d = dict.fromkeys('abcde', 1)
keys = d.keys() # 创建字典键的视图对象
velues = d.values() # 创建字典值的视图对象
items = d.items() # 创建字典的键值对的视图对象

print(keys)
print(velues)
print(items)

dict_keys(['a', 'b', 'c', 'd', 'e'])
dict_values([1, 1, 1, 1, 1])
dict_items([('a', 1), ('b', 1), ('c', 1), ('d', 1), ('e', 1)])

当字典的内容发生改变的时候，视图对象的内容也会相应地跟着改变。

d.pop('d')
print(keys)
print(velues)
print(items)

dict_keys(['a', 'b', 'c', 'e'])
dict_values([1, 1, 1, 1])
dict_items([('a', 1), ('b', 1), ('c', 1), ('e', 1)])

5. copy() 方法

描述：与序列相同，这里提供字典的浅拷贝

a = d.copy()
a

{'a': 1, 'b': 1, 'c': 1, 'e': 1}

字典的方法 （一些非字典的内置方法）

1. 内置函数 len() 来获取字典中键值对的数量

d2 = dict.fromkeys('abcde', 1)
len(d2)

5

2. in 与 not in 判断某个键是否存在于字典中

'a' in d2

True

'f' not in d2

True

3. list() 将字典转化为列表

注意默认返回的是字典中所有的键构成的列表

list(d2) # 即 list(d2.keys)

['a', 'b', 'c', 'd', 'e']

# 返回 所有值 构成的列表
list(d2.values())

[1, 1, 1, 1, 1]

# 返回 所有键值对构成的列表
list(d2.items())

[('a', 1), ('b', 1), ('c', 1), ('d', 1), ('e', 1)]

4. iter() 函数

描述：将字典的键构成一个迭代器

a = iter(d2)
for i in a:
    print(i)
# iter(d2.values) OR iter(d2.items) 会报错：TypeError: 'builtin_function_or_method' object is not iterable

a
b
c
d
e

a = iter(d2.values())
b = iter(d2.items())
for i in a:
    print(i)

for i in b:
    print(i)
# iter(d2.values) OR iter(d2.items) 会报错：TypeError: 'builtin_function_or_method' object is not iterable 注意加括号

1
1
1
1
1
('a', 1)
('b', 1)
('c', 1)
('d', 1)
('e', 1)

5. reversed() 函数 （python 3.8 往上）

描述：对字典内部键值对进行逆向操作 （python 3.7 之前字典是无序的，不能使用）

d2 = {'a': 1, 'b': 2, 'c':3}
list(reversed(d2.keys())) # 返回的是迭代器

['c', 'b', 'a']

list(reversed(d2.values()))

[3, 2, 1]

list(reversed(d2.items()))

[('c', 3), ('b', 2), ('a', 1)]

6. 嵌套

字典也可以嵌套，比如某个键的值是另外一个字典

d2 = {'a': ['yes',2,3], 'b': 2, 'c': {'a':100, 'b': 2}} # 嵌套了a 对应一个列表，c 对应一个字典
d2

{'a': ['yes', 2, 3], 'b': 2, 'c': {'a': 100, 'b': 2}}

d2['c']['a']

100

d2['a'][0]

'yes'

7. 字典推导式

例1：键值调换

d2 = {'a': 1, 'b': 2, 'c':3}
print(d2.items())
d3 = {v:k for k,v in d2.items()}
d3

dict_items([('a', 1), ('b', 2), ('c', 3)])





{1: 'a', 2: 'b', 3: 'c'}

# 加一个条件
d3 = {v:k for k,v in d2.items() if v>1}
d3

{2: 'b', 3: 'c'}

例2： 求字符串编码值

d2 = {x:ord(x) for x in 'abcde'}
d2

{'a': 97, 'b': 98, 'c': 99, 'd': 100, 'e': 101}

例3：易错点

d2 = {x:y for x in [1,3,5] for y in [2,4,6]}
d2

{1: 6, 3: 6, 5: 6}

# 原因是两个 for 循环不是并列的，第一个x的循环为大循环，y的循环为小循环。相当于循环了9次，最后全被6覆盖
## 即：
for x in [1,3,5]:
    for y in [2,4,6]:
        print((x,y))
# 如果最后只到 4
d2 = {x:y for x in [1,3,5] for y in [2,4]}
d2

(1, 2)
(1, 4)
(1, 6)
(3, 2)
(3, 4)
(3, 6)
(5, 2)
(5, 4)
(5, 6)





{1: 4, 3: 4, 5: 4}

附言：
题目：Self-study Python Fish-C Note-9 P37-P39
本文为自学B站上鱼C的python课程随手做的笔记。一些概念和例子我个人为更好的理解做了些查询和补充
因本人水平有限，如有任何问题，欢迎大家批评指正！
原视频链接：https://www.bilibili.com/video/BV1c4411e77t?p=8