python字典(dict)类型

字典(dict)=键(key)+值(value)

1. 键(key)组成：数字，字符串，元组；不可修改
2. 注意：字典定义时，出现键(key)重复情况，默认最后一次键(key)中的值(value)将覆盖之前键(key)中的值(value)。
3. 访问值(value)的前提是对于键(key)的指定
4. 键(key)与值(value)用冒号“：”分开

快速访问字典

    stu1={'A':7,'B':1,'C':9}
    print('1.',stu1)
    print('2.',stu1['C'])
    #输出 1. {'A': 7, 'B': 1, 'C': 9}
         2.9`

快速修改字典数据

    stu2={'A':7,'B':1,'C':9}
    stu2['B']=7
    print('3.',stu2)
    #输出 3. {'A': 7, 'B': 7, 'C': 9}

涉及修改字典数据的相关函数—程序说明

stu3={'A':7,'B':3,'C':9}
print('4.',stu3.keys())
#输出4. dict_keys(['A', 'B', 'C'])
#.keys()以列表形式返回stu中所有键(key)


print('5.',stu3.values())
#输出5. dict_values([7, 3, 9])
#.values()以列表形式返回stu中所有值（value）


print('6.',stu3.items())
#输出6. dict_items([('A', 7), ('B', 3), ('C', 9)])
#.items()以列表形式返回stu中所有键-值


stu4=stu3
stu5=stu3.copy()
print('7.',id(stu3),id(stu4),id(stu5))
print('8.',stu3.items(),stu4.items(),stu5.items())
#输出7. 2073389484216 2073389484216 2073389500816
8. dict_items([('A', 7), ('B', 3), ('C', 9)]) dict_items([('A', 7), ('B', 3), ('C', 9)]) dict_items([('A', 7), ('B', 3), ('C', 9)])
#.copy()当前stu字典(键-值)数据拷贝(浅与深的id区别)


stu6=(1,2,'A','B')
stu9=(1,2,'A,B')
stu10=dict.fromkeys(stu9)
stu7=dict.fromkeys(stu6)
stu8=dict.fromkeys(stu6,'AB')
#stu10=dict.fromkeys(seq1,'AB'，1)
#错误提示TypeError: fromkeys expected at most 2 arguments, got 3------所以stu10不合理
print('9.',stu7)
print('10.',stu8)
print('11.',stu9)
#输出9. {1: None, 2: None, 'A': None, 'B': None}
10. {1: 'AB', 2: 'AB', 'A': 'AB', 'B': 'AB'}
11. (1, 2, 'A,B')
#.fromkeys(seq[,value]) 创建一个字典，以stu中的值作当前字典的键；vale指定值作当前字典的值，当未指定时默认用None
stu3={'A':7,'B':3,'C':9}
stu6={'A':7,'B':3,'C':9}
stu7={'A':7,'B':3,'C':9}
stu9={'A':7,'B':3,'C':9}
stu11={'A':7,'B':3,'C':9}
stu13={'A':7,'B':3,'C':9}
stu14={'A':7,'B':3,'C':9}
stu16={'A':7,'B':3,'C':9}
stu18={'A':7,'B':3,'C':9}
stu19={'A':7,'B':3,'C':9}
stu20={'A':7,'B':3,'C':9}
stu21={'A':7,'B':3,'C':9}

stu4=stu3
stu4.setdefault('C',9)
stu5=stu6
stu5.setdefault('D',9)

stu10={'99'}
stu9.update(stu10)
print('17.',stu9)

stu12={'9'}
stu11.update(stu12)
print('18.',stu11)
#ValueError: dictionary update sequence element #0 has length 1; 2 is required------所以stu11不合理

stu13.clear()
print('19.',stu13)

stu15=stu14.pop('B')
print('20.',stu15)
print('21.',stu14)

stu17=stu16.popitem()
print('22.',stu17)
print('23.',stu16)

del stu18['B']
print('24.',stu18)

del stu19
print('25.',stu19)
#.del stu 情况字典的键-值，再次访问会报错

if 'A' in stu20:
 print('25.',stu20['A'])

if 'M' not in stu21:
 stu21.setdefault('M')
 print('26.',stu21)


stu8={'D':'99'}
stu7.update(stu8)
print('16.',stu7)

print('12.',stu4)
print('13.',stu3)
print('14.',id(stu3),id(stu4),id(stu5),id(stu6))
print('15.',stu5)
#输出12. {'A': 7, 'B': 3, 'C': 9}
 13. {'A': 7, 'B': 3, 'C': 9}
 14. 1668581946568 1668581946568 1668581946208 1668581946208
 15. {'A': 7, 'B': 3, 'C': 9, 'D': 9}
 16. {'A': 7, 'B': 3, 'C': 9, 'D': '99'}
 17. {'A': 7, 'B': 3, 'C': 9, '9': '9'}
 19. {}
 20. 3
 21. {'A': 7, 'C': 9}
 22. ('C', 9)
 23. {'A': 7, 'B': 3}
 24. {'A': 7, 'C': 9}
 25. 7
 26. {'A': 7, 'B': 3, 'C': 9, 'M': None}
#.setdefault(key,default=None) 创建键不住当前字典中，就添加键并将值设置default
#.update(dict2)把指定的键/值添加进原来的字典stu中
#.clear() 情况字典的键-值，再次访问不会报错，但无数据
#.pop(key) 删除指定键的值，有返回值为被删除的指定键中的值（stu15）
#.popitem() 删除当前字典最后一项键-值，有返回值为被删除的指定键和值（stu17）
#.del stu['key'] 根据指定的键(key)，删除包含指定键(key)以及相对应的值(value)
#in指运算符  判定指定键是否在当前字典中
#not in运算符与 .setdefault组合 没有相关键(key),实现自行添加（未指定对应值用None）

.setdefault与.get区别—程序说明

stu3= {'A':7,'B':3,'C':9}
stu3.get('D')
print(stu3)
#输出：{'A': 7, 'B': 3, 'C': 9}


stu4= {'A':7,'B':3,'C':9}
stu4.get('D',99)
print(stu4)
#输出：{'A': 7, 'B': 3, 'C': 9}
#.get(key,default=None) 创建键不住当前字典中，就返回默认值default


stu5= {'A':7,'B':3,'C':9}
stu5.setdefault('D',99)
print(stu5)
#输出：{'A': 7, 'B': 3, 'C': 9, 'D': 99}


stu6= {'A':7,'B':3,'C':9}
stu6.setdefault('D')
print(stu6)
#输出：{'A': 7, 'B': 3, 'C': 9, 'D': None}

字典(dict)帮助文档

print(help(dict))
Help on class dict in module builtins:
class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |  (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |  d = {}
 |  for k, v in iterable:
 |  d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |  in the keyword argument list.  For example:  dict(one=1, two=2)
 |  
 |  Methods defined here:
 |  
 |  __contains__(self, key, /)
 |  True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |  Delete self[key].
 |  
 |  __eq__(self, value, /)
 |  Return self==value.
 |  
 |  __ge__(self, value, /)
 |  Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |  Return getattr(self, name).
 |  
 |  __getitem__(...)
 |  x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |  Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |  Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |  Implement iter(self).
 |  
 |  __le__(self, value, /)
 |  Return self<=value.
 |  
 |  __len__(self, /)
 |  Return len(self).
 |  
 |  __lt__(self, value, /)
 |  Return self<value.
 |  
 |  __ne__(self, value, /)
 |  Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |  Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |  Return repr(self).
 |  
 |  __setitem__(self, key, value, /)
 |  Set self[key] to value.
 |  
 |  __sizeof__(...)
 |  D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |  D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |  D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |  Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |  D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |  D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |  D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |  D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |  If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |  D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |  2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |  D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |  D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |  If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |  If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |  In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |  D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

---

未完待续(2018-12-8 1:53:22 )