Python3字典基础

字典{},由大括号创建，内部每个元素由：进行分割，称之为键值对。

字典的value可以是任何值，如字符串、数字、列表、元组、字典、bool

1 dict1 = {2: 'a', 3: 123, 4: {0: 'xx'}, 5: (123, 123,), 6: ['sss', 123], 7: True}
2 print(dict1)

　　输出：

1 {2: 'a', 3: 123, 4: {0: 'xx'}, 5: (123, 123), 6: ['sss', 123], 7: True}

 

字典的key只能用能够hash的数据类型，比如字符串、数字、元组、bool，不能是列表、字典。

bool值True和False在内存中以1和0进行存储，因此在字典中True作为键是等同于1，False等同0，所以在字典存储是应避免与数字0和1冲突。

1 dict2 = {2: 'a', True: 123, 'aaa': {0: 'xx'}, (444,): (123, 123,), 6: ['sss', 123]}
2 print(dict2)

　　输出：

1 {2: 'a', True: 123, 'aaa': {0: 'xx'}, (444,): (123, 123), 6: ['sss', 123]}

 

字典特点：

  • 字典是无序的。
  • 可以通过索引key进行取值。
 1 # 可以通过索引key进行取值，因为无序所以无法通过切片方法进行取值。
 2 dict2 = {2: 'a', True: 123, 'aaa': {0: 'xx'}, (444,): {(123, 123,): 'sadfa'}, 6: ['sss', 123]}
 3 v1 = dict2[2]
 4 v2 = dict2[(444,)]
 5 v3 = dict2['aaa']
 6 v4 = dict2[(444,)][(123, 123,)]
 7 print('字典输出结果：', dict2)
 8 print(v1)
 9 print(v2)
10 print(v3)
11 print(v4)

　　输出：

1 字典输出结果： {2: 'a', True: 123, 'aaa': {0: 'xx'}, (444,): {(123, 123): 'sadfa'}, 6: ['sss', 123]}
2 a
3 {(123, 123): 'sadfa'}
4 {0: 'xx'}
5 sadfa

 

  • 支持del删除键值对
1 # 支持del删除键值对
2 dict3 = {2: 'a', True: 123, 'aaa': {0: 'xx'}, (444,): {(123, 123,): 'sadfa'}, 6: ['sss', 123]}
3 print('字典输出结果：', dict3)
4 del dict3[2]
5 print('删除了key为2的键值对：', dict3)
6 del dict3[(444,)][(123,123,)]
7 print('删除了key为(444,)中的(123,123,)键值对：', dict3)

　　输出：

1 字典输出结果： {2: 'a', True: 123, 'aaa': {0: 'xx'}, (444,): {(123, 123): 'sadfa'}, 6: ['sss', 123]}
2 删除了key为2的键值对： {True: 123, 'aaa': {0: 'xx'}, (444,): {(123, 123): 'sadfa'}, 6: ['sss', 123]}
3 删除了key为(444,)中的(123,123,)键值对： {True: 123, 'aaa': {0: 'xx'}, (444,): {}, 6: ['sss', 123]}

 

  • 支持for循环，默认for循环只有key
1 dict4 = {2: 'a', True: 123, 'aaa': {0: 'xx'}, (444,): {(123, 123,): 'sadfa'}, 6: ['sss', 123]}
2 for item in dict4:
3     print(item)

　　输出：

1 2
2 True
3 aaa
4 (444,)
5 6

　　如果想同时输出key和value：

1 dict4 = {2: 'a', True: 123, 'aaa': {0: 'xx'}, (444,): {(123, 123,): 'sadfa'}, 6: ['sss', 123]}
2 # for item in dict4:
3 #     print(item)
4 # 如果想同时输出key和value：
5 for item in dict4:
6     print(item, " : ", dict4[item])

　　输出：

1 2  :  a
2 True  :  123
3 aaa  :  {0: 'xx'}
4 (444,)  :  {(123, 123): 'sadfa'}
5 6  :  ['sss', 123]

　　对于获取key，可以用内置的dict.keys()方法：

1 dict4 = {2: 'a', True: 123, 'aaa': {0: 'xx'}, (444,): {(123, 123,): 'sadfa'}, 6: ['sss', 123]}
2 # 对于获取key，可以用内置的dict.keys()方法：
3 for item in dict4.keys():
4     print(item)

　　输出：

1 2
2 True
3 aaa
4 (444,)
5 6

　　对于获取value，可以用内置的dict.values()方法：

1 dict4 = {2: 'a', True: 123, 'aaa': {0: 'xx'}, (444,): {(123, 123,): 'sadfa'}, 6: ['sss', 123]}
2 
3 # 对于获取value，可以用内置的dict.values()方法：
4 for item in dict4.values():
5     print(item)

　　输出：

1 a
2 123
3 {0: 'xx'}
4 {(123, 123): 'sadfa'}
5 ['sss', 123]

　　如果同时获取key和value，可以用内置的dict.item()方法：

1 # 如果同时获取key和value，可以用内置的dict.item()方法，他会将每个键值对保存到一组元组中
2 dict4 = {2: 'a', True: 123, 'aaa': {0: 'xx'}, (444,): {(123, 123,): 'sadfa'}, 6: ['sss', 123]}
3 for item in dict4.items():
4     print(item)

　　输出：

1 (2, 'a')
2 (True, 123)
3 ('aaa', {0: 'xx'})
4 ((444,), {(123, 123): 'sadfa'})
5 (6, ['sss', 123])

 Python3字典方法

  • dict.fromkeys(*args,**kwargs)方法

 1 # dict.fromkeys(*args, **kwargs)方法,@staticmethod静态方法，静态方法可以用dict类进行调用
 2 # 可以根据传递的参数创建新的字典，第一个参数为key，第二个参数为value，未指定第二个参数，则用None替代
 3 # 传入的第一个参数必须是可迭代数据类型，如元组、字符串、列表
 4 dict1 = dict.fromkeys((1, 2, 3,))  # 传递的第一个参数为元组，经过迭代后创建3个值为None的字典元素
 5 print(dict1)
 6 dict2 = dict.fromkeys([1, 2, 3], 'test')  # 传递的第一个参数为列表，value为字符串，经过迭代后创建3个值字典元素
 7 print(dict2)
 8 dict3 = dict.fromkeys("abcd", (1, 2, 3, 4,))
 9 # 传递的第一个参数为字符串，value为元组，经过迭代后创建成为每个字符串的字符作为key，元组整体作为value
10 print(dict3)

　　输出：

1 {1: None, 2: None, 3: None}
2 {1: 'test', 2: 'test', 3: 'test'}
3 {'a': (1, 2, 3, 4), 'b': (1, 2, 3, 4), 'c': (1, 2, 3, 4), 'd': (1, 2, 3, 4)}

  • dict.clear()方法

1 # dict.clear()方法
2 # 清空字典中的内容
3 dict4 = {1: 'test', 2: 'test', 3: 'test'}
4 print("原字典值：", dict4)
5 dict4.clear()
6 print("新字典值：", dict4)

　　输出：

1 原字典值： {1: 'test', 2: 'test', 3: 'test'}
2 新字典值： {}

 

  • dict.get()方法

 1 # dict.get(k,d=None)方法
 2 # 根据字典的key获取value,至少传入一个参数，第一个参数是key，第二个参数是返回值value默认为none
 3 dict5 = {"k1": "1", 'k2': "2"}
 4 v1 = dict5.get('k1')
 5 print(dict5, v1)
 6 v2 = dict5.get('k111')  # 如果没有该key，获取的是返回值None
 7 print(dict5, v2)
 8 v3 = dict5.get('k1', 123)  # 如果查到key，那么返回key所对应的value
 9 print(dict5, v3)
10 v4 = dict5.get('k1111', (123,))  # 如果没有查到key，那么返回给定的值
11 print(dict5, v4)

　　输出：

1 {'k1': '1', 'k2': '2'} 1
2 {'k1': '1', 'k2': '2'} None
3 {'k1': '1', 'k2': '2'} 1
4 {'k1': '1', 'k2': '2'} (123,)

 

  • dict.update()方法

1 # dict.update()方法
2 # 更新字典中的对象，如果key存在更新对应的value，如果不存在则添加
3 dict6 = {"k1": "1", 'k2': "2"}
4 print("原字典：", dict6)
5 dict6.update({'k1': 123, 'k11': 'xxx'})
6 print("新字典：", dict6)
7 dict6.update(k1=456, k2='test', k4=(1, 2, 3,))  # 相当于将参数在内部构造成一个字典
8 print("新字典：", dict6)

　　输出：

1 原字典： {'k1': '1', 'k2': '2'}
2 新字典： {'k1': 123, 'k2': '2', 'k11': 'xxx'}
3 新字典： {'k1': 456, 'k2': 'test', 'k11': 'xxx', 'k4': (1, 2, 3)}

 

  • dict.setdefault()方法

 1 # dict.setdefault()方法
 2 # 等同于添加新的键值对，如果key已经在字典中存在，那么不会修改现有的键值对
 3 # 如果key不存在，那么会在字典中添加一个键值对，如果value未指定，那么添加的key的value默认为None
 4 dict5 = {"k1": "1", 'k2': "2"}
 5 print("原字典：", dict5)
 6 dict5.setdefault('k1', 123)  # 在字典中查到了key
 7 print("新字典：", dict5)
 8 print("原字典：", dict5)
 9 dict5.setdefault('k111')  # 新Key的value默认为None
10 print("新字典：", dict5)
11 print("原字典：", dict5)
12 dict5.setdefault('k23', 123)  # 新Key的value为指定的第二个参数
13 print("新字典：", dict5)

　　输出：

1 原字典： {'k1': '1', 'k2': '2'}
2 新字典： {'k1': '1', 'k2': '2'}
3 原字典： {'k1': '1', 'k2': '2'}
4 新字典： {'k1': '1', 'k2': '2', 'k111': None}
5 原字典： {'k1': '1', 'k2': '2', 'k111': None}
6 新字典： {'k1': '1', 'k2': '2', 'k111': None, 'k23': 123}

  • dict.pop()方法

1 # dict.pop(k)方法
2 # 删除字典中的键值对，必须传递一个key，如果key找到了则默认返回对应键值，否返回None或者自定义的value。
3 dict7 = {"k1": "1", 'k2': "2"}
4 print("原字典：", dict7)
5 v = dict7.pop("k11", 123)
6 print("新字典：", dict7, v)

　　输出：

原字典： {'k1': '1', 'k2': '2'}
新字典： {'k1': '1', 'k2': '2'} 123

 

  • dict.popitem()方法

1 # dict.popitem()方法
2 # 默认删除字典中最后一个键值对，返回一个包含key和value的元组，也可以将返回值赋给2个变量
3 dict8 = {"k1": "1", 'k2': "2", 'k3': 123}
4 print("原字典：", dict8)
5 v = dict8.popitem()
6 print("新字典：", dict8, v)
7 v1, v2 = dict8.popitem()    # 因为返回的是key和value，所以可以将key和value同时付给2个变量
8 print("新字典：", dict8, '返回的key:', v1, '返回的value：', v2)

　　输出：

1 原字典： {'k1': '1', 'k2': '2', 'k3': 123}
2 新字典： {'k1': '1', 'k2': '2'} ('k3', 123)
3 新字典： {'k1': '1'} 返回的key: k2 返回的value： 2

 

  • dict.copy()方法

 1 # dict.copy()方法
 2 # 将字典copy到一个新的字典中，该copy是浅复制,删除原字典键值对，不会影响新的字典。
 3 # 同样的，删除新字典的键值对，不会影响原字典
 4 dict9 = {"k1": "1", 'k2': "2", 'k3': 123}
 5 print("原字典：", dict9)
 6 dic = dict9.copy()
 7 print("新字典：", dic)
 8 dict9.popitem()
 9 print("原字典：", dict9, "新字典：", dic)
10 dic.popitem()
11 dic.popitem()
12 print("原字典：", dict9, "新字典：", dic)

　　输出：

1 原字典： {'k1': '1', 'k2': '2', 'k3': 123}
2 新字典： {'k1': '1', 'k2': '2', 'k3': 123}
3 原字典： {'k1': '1', 'k2': '2'} 新字典： {'k1': '1', 'k2': '2', 'k3': 123}
4 原字典： {'k1': '1', 'k2': '2'} 新字典： {'k1': '1'}

 字典的in操作：

  • 　　字典也可以用in操作，默认对字典进行遍历是对字典中的key进行遍历。
  • 　　如果相对value进行遍历可以采用字典的values()方法
 1 # 字典的in操作：
 2 # 字典也可以用in操作，默认对字典进行遍历是对字典中的key进行遍历.
 3 dict10 = {"k1": "1", 'k2': "2", 'k3': 123}
 4 print("原字典：", dict10)
 5 for item in dict10:
 6     print(item)
 7 
 8 v1 = 'k1' in dict10
 9 print(v1)
10 v2 = 123 in dict10
11 print(v2)
12 
13 v3 = 123 in dict10.values()
14 print(v3)
15 v4 = 'k2' in dict10.keys()
16 print(v4)

　　输出：

1 原字典： {'k1': '1', 'k2': '2', 'k3': 123}
2 k1
3 k2
4 k3
5 True
6 False
7 True
8 True

 关于bool值

　　bool值为假的有None、[]、{}、‘’、0、set()、() 

 1 >>> bool(0)
 2 False
 3 >>> bool({})
 4 False
 5 >>> bool(-1)
 6 True
 7 >>> bool([])
 8 False
 9 >>> bool('')
10 False
11 >>> bool("")
12 False
13 >>> bool(None)
14 False
15 >>> bool(set())
16 False
17 >>>

 

posted @ 2018-04-08 15:07  忙碌的捕快  阅读(150)  评论(0)    收藏  举报
levels of contents