Python之路，第八篇：Python入门与基础8

python3    字典（dict）

概念：1 ，字典是一种可变的容器，可以存储任意类型的数据；

2， 字典中的每个数据都是用“键”（key）进行索引，而不像序列可以用下标进行索引；

3， 字典中的数据没有先后关系，字典的存储是无序的；

4， 字符的数据是以键（key）-值（value）

5，字典的表示方式以{} 括起来，以冒号（：）分隔键值对， 各键值对之间用逗号隔开；

6， 字典的键不能重复，值可以重复；

创建空字典的方法：

d = {}    # 空字典

d = dict（） #空字典（迭代）

创建非空字典的方法：

d = {‘a’:1 , 'b':2 }

d = {'name': None , 'age':18 }

字典的值（value）可以为任意类型：

字典的值可以是布尔值，数据， 字符串， None，列表， 元组，字典，以及集合，函数，类对象等所有类型

 >>>
 >>> {'a':123}
 {'a': 123}
 >>> {'a':"abc"}
 {'a': 'abc'}
 >>> {'a':True}
 {'a': True}
 >>> {'a':None}
 {'a': None}
 >>> {'a':(1,2,3)}
 {'a': (1, 2, 3)}
 >>> {'a':[1,2,3]}
 {'a': [1, 2, 3]}
 >>> {'a':{"aa":1}}
 {'a': {'aa': 1}}
 >>> 

字典的键（key） 必须为不可变类型的值

不可变的类型： bool  、int 、 float 、 complex 、 str 、 tuple 、frozenset  （包括：None）

不能充当键的类型有：

列表list，字典dict，集合set

例子： {}

 >>> {"a":"a"}
 {'a': 'a'}
 >>> {100:""}
 {100: ''}
 >>> {True:"True"}
 {True: 'True'}
 >>> {None:"abc"}
 {None: 'abc'}
 >>> {(1911,1,1):"aaa"}
 {(1911, 1, 1): 'aaa'}
 >>> 

练习：

回文

 #!/usr/bin/python

 s = input("Please enter:")
 n = len(s) // 2
 for x in range(0, n + 1):
     if s[x] != s[ -( x+1)]:
         print("不是回文")
         break
 else:
     print("是回文")
 >>> ================================ RESTART ================================
 >>>
 Please enter:123321
 是回文
 >>> ================================ RESTART ================================
 >>>
 Please enter:abccba
 是回文
 >>> ================================ RESTART ================================
 >>>
 Please enter:21352656121
 不是回文
 >>> ================================ RESTART ================================
 >>>
 Please enter:fargserwaqrg
 不是回文
 >>> 

 #!/usr/bin/python

 s = input("Please enter:")
 l = list(s) #正序列表
 l2 = list(reversed(s)) ##反序列表
 if l == l2:
     print("是回文")
 else:
     print("不是回文")
 >>> ================================ RESTART ================================
 >>>
 Please enter:asddsa
 是回文
 >>>     

 #!/usr/bin/python

 s = input("Please enter:")
 print(s)
 print(s[::-1])
 if s == s[::-1]:
     print("是回文")
 else:
     print("不是回文")

数字出现次数

 #!/usr/bin/python

 exist = [] # 已访问过的列表
 s = input("请输入一串数字：")
 for x in s:
     if x not in exist:
         print(x, '出现', s.count(x), '次')
         exist.append(x)

 #for x in s:
 #    if x in exist:
 #        pass
 #    else:
 #        print(x, '出现'， s.count(x), '次')
 #        exist.append(x)
 >>> ================================ RESTART ================================
 >>>
 请输入一串数字：7324525901243
 7 出现 1 次
 3 出现 2 次
 2 出现 3 次
 4 出现 2 次
 5 出现 2 次
 9 出现 1 次
 0 出现 1 次
 1 出现 1 次
 >>> 

字典符访问：

用方括号访问字典内的成员，字典[‘’键‘’] ；

 >>> d = {'a':1 , 'b':2}
 >>> d['a']
 1
 >>> d['b']
 2
 >>> 

添加或修改字典的键的值：

字典[ "键" ] = 值

如果，键存在，修改键绑定的值； 如果键不存在，创建键并帮定值；

 >>> d1 = {}    #创建空字典
 >>> type(d1)
 <class 'dict'>
 >>> d1['name'] = 'xiaoming'  #添加键值对
 >>> d1['age'] = 18              ##添加键值对
 >>> d1['age'] = 19               #修改键的值
 >>> 

删除字典元素  del

del     字典【键】

 >>> d1
 {'age': 19, 'name': 'xiaoming'}
 >>> del d1['age']
 >>> d1
 {'name': 'xiaoming'}
 >>

获取字典元素个数的函数：

len（dict） 返回字典元素（键值对）个数；

字典的成员资格判断in   、not in 运算符；

用in  、not in 来判断一个键是否存在于字典中，如果存在则返回True， 如果不存在则返回False；

 >>> d1
 {'age': 16, 'name': 'xiaoming'}
 >>>
 >>>
 >>> 'name' in d1
 True
 >>> 16 in d1
 False
 >>> 

字典的生成函数：

dict（）    生成一个函数，等同于{ }

dict(iterable)   用可迭代对象初始化字典

dict（**kwargv ） 关键字参数形式生成一个字典

例子： d  = dict（）

>>> d = dict([('name','xiaoming'),('age', 18)])      #{'age': 18, 'name': 'xiaoming'}    返回字典

d = dict(name="xiaoli", age=19)      #{'age': 19, 'name': 'xiaoli'}

d = {}   # name = "zhangsan"      {'name' : name}     {'name': 'zhangsan'}

字典的方法：

D     代表字典对象

D.clear（）                     清空字典

D.pop（key）                 移除键，同时返回此键所对应的值

D.copy（）                     返回字典D的副本，只复制一层，（浅拷贝）

D.update（D2）             将字典D2合并到字典D中，如果键相同则值取D2的值作为新值；

D.get(key , default)        返回键key所对应的值，如果没有此键则返回default

D.keys()                         返回可迭代的dict_keys 集合对象

D.values()                      返回可迭代的dict_values 值对象

D.items()                        返回可迭代的dict_iterm对象

 >>> help(d.get)
 Help on built-in function get:

 get(...) method of builtins.dict instance
     D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.

 >>> d
 {'age': 19, 'name': 'xiaoli'}
 >>>
 >>>
 >>> d.clear
 <built-in method clear of dict object at 0x000000000372B948>
 >>> d
 {'age': 19, 'name': 'xiaoli'}
 >>> d.clear()
 >>> d
 {}
 >>> d={'age': 19, 'name': 'xiaoli'}
 >>> d
 {'age': 19, 'name': 'xiaoli'}
 >>> d.pop('name')
 'xiaoli'
 >>> d1
 {'age': 16, 'name': 'xiaoming'}
 >>> del d1
 >>> d2
 Traceback (most recent call last):
   File "<pyshell#47>", line 1, in <module>
     d2
 NameError: name 'd2' is not defined
 >>> d1
 Traceback (most recent call last):
   File "<pyshell#48>", line 1, in <module>
     d1
 NameError: name 'd1' is not defined
 >>> d.copy(d1)
 Traceback (most recent call last):
   File "<pyshell#49>", line 1, in <module>
     d.copy(d1)
 NameError: name 'd1' is not defined
 >>> d1 = d.copy()
 >>> d1
 {'age': 19}
 >>> d
 {'age': 19}
 >>> d.get('name', "没找到")
 '没找到'
 >>> d
 {'age': 19}
 >>> d2 = {'aa':1,'bb':2}
 >>> d.update(d2)
 >>> d
 {'age': 19, 'bb': 2, 'aa': 1}
 >>> d2
 {'bb': 2, 'aa': 1}
 >>> d.keys()
 dict_keys(['age', 'bb', 'aa'])
 >>> d.values()
 dict_values([19, 2, 1])
 >>> d.items()
 dict_items([('age', 19), ('bb', 2), ('aa', 1)])
 >>>
 >>> d.items()
 dict_items([('age', 19), ('bb', 2), ('aa', 1)])
 >>> for k in d.keys():
     print(k)

 age
 bb
 aa
 >>> for k,v in d.items():
     print(k,v)

 age 19
 bb 2
 aa 1
 >>> for v in d.values():
     print(v)

 19
 2
 1
 >>> 

字典推导式：

语法：   { 键表达式 ： 值表达式  for  变量  in 可迭代对象   （if 条件表达式） }

字典推导式可以嵌套的

 >>> name
 ['xiaoming', 'xiaoli', 'xiaogang', 'zhangsan']
 >>> numbers = [1001, 1002, 1003, 1004]

 >>> an = { numbers[i] : name[i] for i in range(4) if numbers[i] % 2 == 0}
 >>> an
 {1002: 'xiaoli', 1004: 'zhangsan'}
 >>> 

 >>> list1 = ['a','b','c']
 >>> list2 = [1,2,3]
 >>> dict_a = { list1[i] : list2[i] for i in range(3)}
 >>> dict_a
 {'a': 1, 'c': 3, 'b': 2}
 >>> 

字典和列表的比较：

in 、 not in

列表的in 操作通常要每个都进行比较；

字典的in 操作不需要比较；

字典的基本函数操作：

len（x）      返回字典的长度

max（x）     返回字典键的最大值

min（x）      返回字典键的最小值

sum（x）      返回字典中所有键的和

any（x）       真值测试，任意键为真，则返回True，否则为False

all（x）          真值测试，所有键为真，则返回True，否则为False

例子