python中mapping_python-学习-ORM中遇到的 mapping 详解并再总结字典dict

python里的字典dict(mapping)如何使用

Python字典的构造函数有三个，dict()、dict(**args)、dict(mapping),其中第一个、第二个构造函数比较好理解也比较容易使用，

而dict(mapping)这个构造函数的使用比较难理解。

1. dict()构造函数可以返回一个空的字典

In [7]: d = dict()

In [8]: print (d)

{}

2. dict(**arg)构造函数，传入参数用赋值表达式，可多个复制表达式，用逗号间隔即可。

In [9]: d = dict(a = 12, b = 13, c = 15)

In [10]: print d

{'a': 12, 'c': 15, 'b': 13}

3. 映射类型 dict(mapping)构造python字典构造函数

一个mapping对象将可哈希的值映射为任意对象。映射是可变对象。目前Python中只有一种标准映射类型，就是字典(dict)。dcit和Set集合一样也是用花括号表示，但是花括号中的每个元素都是一个键值对(key:value)。字典中的键值对也是无序的，且key必须是可哈希的不可变类型，如字符串、数字、布尔值和不包含可变类型的tuple。而list和包含可变类型的tuple是不能做字典的key的。另外，同一个字典中，key不能重复，否则会覆盖之前的值(key最好不用数字)

dict类构建函数

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

上面的dict构建函数会返回一个新的字典，这个新的字典是从一个可选的位置参数和一组可能为空关键字参数初始化的。

dict的构建方式

将以逗号分隔的 key:value (键值对)列表放置在一对花括号中：{ },{'Tom':1, 'Jerry':2, 'Peter':3}

使用不传递位置参数的构建函数，创建空字典：dict(),等同于{ }

如果给定了位置参数，并且它是映射对象，则使用与该映射对象相同的键值对创建字典；否则，位置参数必须是可迭代对象。可迭代对象中的每个条目本身必须是具有两个对象的可迭代对象。每个条目的第一个对象将会成为新字典中的键，第二个对象将会成为对应的值。如果键多次出现，则该键的最后一个值将成为新字典中的相应值。

如果给出了关键字参数，则将关键字参数及其值添加到从位置参数创建的字典中。如果要添加的键已经存在，则来自关键字参数的值将替换位置参数中的值。

>>> a = {'one': 1, 'two': 2, 'three': 3} # 将以逗号分隔的键值对列表放置在一对花括号中

>>> b = dict(one=1, two=2, three=3) # 使用dict构建函数，并传递关键字参数

>>> c = dict([('two', 2), ('one', 1), ('three', 3)]) # 使用dict构建函数，并传递可迭代对象为位置参数

>>> d = dict({'three': 3, 'two': 2, 'one': 1}) # 使用dict构建函数，并传递可迭代对象作为位置参数

>>> e = dict({'three': 3, 'two': 2, 'one': 1}, four=4, five=5) # 使用dict构建函数，同时传递可迭代位置参数和关键字参数

>>> e

{'five': 5, 'two': 2, 'three': 3, 'one': 1, 'four': 4}

>>> a == b == c == d

True

dict支持的操作

len(d) # 返回字典d中的条目数

key in d # 如果字典d中包含key这个键则返回True, 否则返回False

key not in d # 与上面刚好相反

d[key] # 返回key对应的条目的值，如果key不存在会抛出KeyError异常

get(key[, default]) # 如果key存在则返回其对应的值，否则返回default参数指定的值。如果default没有被指定，则default取None，因此该方法永远不会抛出KeyError异常。

setdefault(key[,default]) # 如果key存在则返回这个key对应的值，如果key不存在则插入一个键值对key:default并返回default的值。default默认值为None。

classmethod fromkeys(seq[,value]) # 这是个类方法，用于创建一个新的字典。seq序列中的元素将作为新字典中的key，而value将会是这些key共同的值，value默认为None。

copy() # 返回该dict的一个浅拷贝

keys() # 返回一个字典键的新视图

values() # 返回一个字典值的新视图

items() # 返回一个字典条目的新视图：(key, value)

iter(d) # 返回字典键的一个迭代器，这是iter(d.keys())的简写方式

d[key] = value # 如果key不存在则表示新增一个条目，如果key已经存在则表示修改该条目的值

update([other]) # 用other中的键值对更新字典的内容，覆盖现有的key。other可以是一个字典对象或键/值对(比如长度为2的元组或其它可迭代对象)。如果指定了关键字参数，字典将会使用关键字参数对字典的键/值对更新，如：d.update(红色=1, 蓝色=2)

del d[key] # 删除key对应的表木，如果key不存在会抛出KeyError异常

popitem() # 从字典中删除并返回一个任意(key, value)对，如果字典为空会抛出KeyError异常。该方法对于破坏性的遍历字典很有用，常用于集合算法。

pop(key[,default]) # 如果key存在就删除它并返回它的值，否则返回default的值。如果default没有被给出并且key不存在，则抛出KeyError异常。

clear() # 清空dict中的所有条目

操作实例 (简单，参照即可)

>>> d = {'one': 1, 'two': 2, 'three': 3}

>>> len(d)

3

>>> 'two' in d

True

>>> 'two' not in d

False

>>>

>>> d['three']

3

>>> d['four']

Traceback (most recent call last):

File "", line 1, in

KeyError: 'four'

>>> d.get('three')

3

>>> d.get('four', 'default')

'default'

>>> d

{'one': 1, 'two': 2, 'three': 3}

>>> d.setdefault('three', 'default')

3

>>> d

{'one': 1, 'two': 2, 'three': 3}

>>> d.setdefault('four', 'default')

'default'

>>> d

{'one': 1, 'two': 2, 'four': 'default', 'three': 3}

>>> dict.fromkeys(['one', 'two', 'three'])

{'one': None, 'two': None, 'three': None}

>>> dict.fromkeys(['one', 'two', 'three'], 'default')

{'one': 'default', 'two': 'default', 'three': 'default'}

>>>

>>> d.copy()

{'one': 1, 'two': 2, 'four': 'default', 'three': 3}

>>> d['four'] = 4

>>> d

{'one': 1, 'two': 2, 'four': 4, 'three': 3}

>>> d['five'] = 5

>>> d

{'one': 1, 'two': 2, 'five': 5, 'four': 4, 'three': 3}

>>> d.update({'two': 'II', 'six': 6})

>>> d

{'one': 1, 'two': 'II', 'four': 4, 'five': 5, 'six': 6, 'three': 3}

>>> d.update(two=2, seven=7)

>>> d

{'one': 1, 'two': 2, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'three': 3}

>>> d.update([('three', 'III'), ('eight', 8)])

>>> d

{'one': 1, 'two': 2, 'four': 4, 'five': 5, 'eight': 8, 'six': 6, 'seven': 7, 'three': 'III'}

>>>

>>> d.keys()

dict_keys(['one', 'two', 'four', 'five', 'eight', 'six', 'seven', 'three'])

>>> d.values()

dict_values([1, 2, 4, 5, 8, 6, 7, 'III'])

>>> d.items()

dict_items([('one', 1), ('two', 2), ('four', 4), ('five', 5), ('eight', 8), ('six', 6), ('seven', 7), ('three', 'III')])

>>> iter(d)

>>> iter(d.keys())

>>>

>>> del d['eight']

>>> d

{'one': 1, 'two': 2, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'three': 'III'}

>>> d.popitem()

('one', 1)

>>> d

{'two': 2, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'three': 'III'}

>>> d.pop('three')

'III'

>>> d

{'two': 2, 'four': 4, 'five': 5, 'six': 6, 'seven': 7}

>>> d.pop('three')

Traceback (most recent call last):

File "", line 1, in

KeyError: 'three'

>>> d.pop('three',None)

>>> d.pop('three','default')

'default'

>>> d.clear()

>>> d.popitem()

Traceback (most recent call last):

File "", line 1, in

KeyError: 'popitem(): dictionary is empty'

字典视图对象(Dictionary view objects)

对于dict.keys()、dict.values()和dict.items()这些函数，在Python 2.x中返回的是list对象，而在Python 3.x中返回的是一个叫做字典视图的对象。

>>> d = {'one': 1, 'two': 2, 'three': 3}

>>> dkeys = d.keys()

>>> dkeys

dict_keys(['one', 'three', 'two'])

>>> dvalues = d.values()

>>> dvalues

dict_values([1, 3, 2])

>>> ditems = d.items()

>>> ditems

dict_items([('one', 1), ('three', 3), ('two', 2)])

字典视图在字典条目上提供了一个动态视图，这意味着当字典发生变化时，相应的视图也会发生变化。要保存固定的值需要将字典视图强制转换为其他类型的对象进行保存，通常保存为list类型。

>>> d['four'] = 4

>>> d

{'one': 1, 'three': 3, 'two': 2, 'four': 4}

>>> dkeys

dict_keys(['one', 'three', 'two', 'four'])

>>> dvalues

dict_values([1, 3, 2, 4])

>>> ditems

dict_items([('one', 1), ('three', 3), ('two', 2), ('four', 4)])

总结

回看廖神的元类里一段代码

class Model(dict, metaclass=ModelMetaclass):

def __init__(self, **kw):

super(Model, self).__init__(**kw)

def __getattr__(self, key):

try:

return self[key]

except KeyError:

raise AttributeError(r"'Model' object has no attribute '%s'" % key)

def __setattr__(self, key, value):

self[key] = value

def save(self):

fields = []

params = []

args = [] # Model继承了元类ModelMetaclass里的mappings定义！

for k, v in self.__mappings__.items(): # 这里mappings不是函数，而是ModelMetaclass里的 mappings = dict() ！

fields.append(v.name)

params.append('?')

args.append(getattr(self, k, None))

sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))

print('SQL: %s' % sql)

print('ARGS: %s' % str(args))