总结：Python3.6版本
- (key:value，可嵌套)
- 创建字典：dict()【空字典】
- 创建字典：dict(**kwargs)【关键字参数】
- 创建字典：dict(mapping)【mapping object's (key, value) pairs】
- 创建字典：dict(iterable)【可迭代对象，二维元组、列表】
- 创建字典：dict(zip(key_list,value_list))【zip函数】
- 创建字典：{x:x*2 for x in iterable}【字典解析】
- 创建字典：dict.fromkeys(iterable,value)【用来初始化字典】
- 字典清空：dict.clear()【函数返回None，清除掉原字典的成员】
- 字典拷贝：dict.copy()【函数返回一个浅拷贝的字典】
- 数据获取：dict.get(k, d=None)【k存在返回k对应的value，不存在返回d，默认为None】
- 数据获取：dict.setdefault(k, d=None)【k存在返回k对应的value，不存在则返回d，d默认为None，并增加k:d】
- 成员展示：dict.items()【返回一个set-like的对象--包含列表--[(key,value),...]】
- keys展示: dict.keys()【返回一个set-like的对象--包含列表--[key,...]】
- value展示: dict.values()【返回一个对象--包含列表--[value,...]】
- 字典删除：dict.pop(k, d=None)【k存在删除k对应的value，不存在返回d，d不存在则抛出异常】
- 字典删除：dict.popitem()【随机删除一对key-value，并返回元组(key,value)】
- 字典合并：dict.update(E=None, **F)【参数为一个字典或者可迭代的二维数据】
- key测试：key in dict.keys()【运算符重载方法__contains__】
- 字典比较：【运算符重载，==、!=】【>、=、<= ***NotImplemented***,不能应用】
<code># 空字典【直接创建、类实例化】
print({}) # {}
print(dict()) # {}
# 创建字典【直接创建、位置参数、二维可迭代对象、zip、字典解析】
# 保证哈希算法准确，key必须是不可变类型
print({'a': 1, 'b': 2}) # {'a': 1, 'b': 2}
print(dict(a=1, b=2)) # {'a': 1, 'b': 2}
My_list = [(1, 2), (2, 2)]
print(dict(My_list)) # {1: 2, 2: 2}
My_dict = {}
for x, y in My_list:
My_dict[x] = y
print(My_dict) # {1: 2, 2: 2}
List1 = [1, 2]
List2 = [1, 2]
zip_object = zip(List1, List2) # zip object
print(dict(zip_object)) # {1: 1, 2: 2}
print({x: x*2 for x in '1'}) # {'1': '11'}
# Returns a new dict with keys from iterable and values equal to value
print(dict.fromkeys([1, 2], 1)) # {1: 1, 2: 1}
# 字典清空【clear函数返回None，清除掉原字典的成员】
My_dict = {1: 1, 2: 1}
print(My_dict.clear()) # None
print(My_dict) # {}
# 字典拷贝【函数返回一个浅拷贝的字典】
My_dict = {1: 1, 2: 1}
print(My_dict.copy()) # {1: 1, 2: 1}
# 数据获取【key存在返回对应值，不存在默认返回None，可指定】
My_dict = {1: 'a', 2: 'b'}
print(My_dict.get(1)) # a
print(My_dict.get(11)) # None
print(My_dict.get(11, 'fk')) # fk
# 数据获取【k存在返回k对应的value，不存在则返回d，d默认为None，并增加k:d】
My_dict = {1: 'a', 2: 'b'}
print(My_dict.setdefault(3)) # None
print(My_dict.setdefault(4, 'd')) # d
print(My_dict) # {1: 'a', 2: 'b', 3: None, 4: 'd'}
# 成员展示【【返回一个set-like的对象--包含列表--[(key,value),...]】
My_dict = {1: 'a', 2: 'b'}
print(My_dict.items()) # dict_items([(1, 'a'), (2, 'b')])
# keys展示【返回一个set-like的对象--包含列表--[key,...]】
My_dict = {1: 'a', 2: 'b'}
print(My_dict.keys()) # dict_keys([1, 2])
# values展示【返回一个对象--包含列表--[value,...]】
My_dict = {1: 'a', 2: 'b'}
print(My_dict.values()) # dict_values(['a', 'b'])
# 字典删除【key存在则删除对应值，不存在则返回参数二，不存在则抛出异常】
My_dict = {1: 'a', 2: 'b'}
print(My_dict.pop(1, 2)) # a
print(My_dict.pop(3, 'pop')) # pop
print(My_dict) # {2: 'b'}
# 字典删除【随机删除一对key-value，并返回元组(key,value)】
My_dict = {1: 'a', 2: 'b'}
print(My_dict.popitem()) # (2, 'b')
print(My_dict) # {1: 'a'}
# 字典合并【参数为一个字典或者可迭代的二维数据】
My_dict = {1: 'a', 2: 'b'}
a={3: 'c'}
aa=[(4, 'd')]
print(My_dict.update(a)) # None
print(My_dict.update(aa)) # None
print(My_dict) # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
# key值是否存在测试【运算符重载方法__contains__，in调用】
My_dict = {1: 'a', 2: 'b'}
print(My_dict.__contains__(11)) # True
print(My_dict.__contains__(1)) # True
if 1 in My_dict.keys():
print(True) # True
# 成员删除【运算符重载方法__contains__，del调用】
My_dict = {1: 'a', 2: 'b'}
print(My_dict.__delitem__(1)) # None
print(My_dict) # {2: 'b'}
del My_dict[2]
print(My_dict) # {}
# 字典比较【运算符重载，==、!=】
# 【>、=、<= ***NotImplemented***】
My_dict = {1: 'a', 2: 'b'}
my_dict = {1: 'a'}
print(My_dict == my_dict) # False
print(My_dict.__eq__(my_dict)) # False
print(My_dict.__ne__(my_dict)) # False/<code>
原型类或者方法：
<code>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)
#创建字典
def clear(self): ; restored from __doc__
D.clear() -> None. Remove all items from D.
pass
#清空字典
def copy(self): ; restored from __doc__
D.copy() -> a shallow copy of D
pass
#浅拷贝字典
@staticmethod # known case
def fromkeys(*args, **kwargs):
Returns a new dict with keys from iterable and values equal to value.
pass
#返回一个字典，适用于初始化，多对一 {keys to None}
def get(self, k, d=None): ; restored from __doc__
D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
pass
#获取k对应的值，如果K不存在则返回d，d默认为None，也可指定
def items(self): ; restored from __doc__
D.items() -> a set-like object providing a view on D's items
pass
#返回一个类似集合的对象显示字典的成员
def keys(self): ; restored from __doc__
D.keys() -> a set-like object providing a view on D's keys
pass
#返回一个类似集合的对象显示字典的key值
def pop(self, k, d=None): ; restored from __doc__
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
pass
#K存在则删除K：value，不存在则返回d，如果d没有给出则抛出异常
def popitem(self): ; restored from __doc__
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
pass
#随机删除一个key:value，并返回（key,value）
def setdefault(self, k, d=None): ; restored from __doc__
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
pass
#类似于get方法，k存在则返回对应的值，不存在则返回d，并增加一对数据 k:d
def update(self, E=None, **F): # known special case of dict.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]
pass
#合并两个字典 参数为一个字典或者二维可迭代对象---[(1,1),(2,2)...]
def values(self): ; restored from __doc__
D.values() -> an object providing a view on D's values
pass
#返回一个对象显示字典的值[value,...]
def __contains__(self, *args, **kwargs):
True if D has a key k, else False.
pass
#运算符重载方法，if k in dict.keys()
def __delitem__(self, *args, **kwargs):
Delete self[key].
pass
#运算符重载方法，del dict[key]
def __eq__(self, *args, **kwargs):
Return self==value.
pass
#运算符重载方法，dict == dict1
def __getattribute__(self, *args, **kwargs):
Return getattr(self, name).
pass
def __getitem__(self, y): ; restored from __doc__
x.__getitem__(y) <==> x[y]
pass
def __ge__(self, *args, **kwargs):
Return self>=value.
pass
def __gt__(self, *args, **kwargs):
Return self>value.
pass
def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
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)
# (copied from class doc)
pass
def __iter__(self, *args, **kwargs):
Implement iter(self).
pass
def __len__(self, *args, **kwargs):
Return len(self).
pass
def __le__(self, *args, **kwargs):
Return self<=value.
pass
def __lt__(self, *args, **kwargs):
Return self<value.> pass
@staticmethod # known case of __new__
def __new__(*args, **kwargs):
Create and return a new object. See help(type) for accurate signature.
pass
def __ne__(self, *args, **kwargs):
Return self!=value.
pass
def __repr__(self, *args, **kwargs):
Return repr(self).
pass
def __setitem__(self, *args, **kwargs):
Set self[key] to value.
pass
def __sizeof__(self): ; restored from __doc__
D.__sizeof__() -> size of D in memory, in bytes
pass
__hash__ = None/<value.>/<code>
分享到:
閱讀更多 少年風 的文章
