dict(待补充)

dict

---

help(dict)

Help on class dict in module __builtin__:

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:
 |  
 |  __cmp__(...)
 |      x.__cmp__(y) <==> cmp(x,y)
 |  
 |  __contains__(...)
 |      D.__contains__(k) -> True if D has a key k, else False
 |  
 |  __delitem__(...)
 |      x.__delitem__(y) <==> del x[y]
 |  
 |  __eq__(...)
 |      x.__eq__(y) <==> x==y
 |  
 |  __ge__(...)
 |      x.__ge__(y) <==> x>=y
 |  
 |  __getattribute__(...)
 |      x.__getattribute__('name') <==> x.name
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(...)
 |      x.__gt__(y) <==> x>y
 |  
 |  __init__(...)
 |      x.__init__(...) initializes x; see help(type(x)) for signature
 |  
 |  __iter__(...)
 |      x.__iter__() <==> iter(x)
 |  
 |  __le__(...)
 |      x.__le__(y) <==> x<=y
 |  
 |  __len__(...)
 |      x.__len__() <==> len(x)
 |  
 |  __lt__(...)
 |      x.__lt__(y) <==> x<y
 |  
 |  __ne__(...)
 |      x.__ne__(y) <==> x!=y
 |  
 |  __repr__(...)
 |      x.__repr__() <==> repr(x)
 |  
 |  __setitem__(...)
 |      x.__setitem__(i, y) <==> x[i]=y
 |  
 |  __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(...)
 |      dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
 |      v defaults to None.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  has_key(...)
 |      D.has_key(k) -> True if D has a key k, else False
 |  
 |  items(...)
 |      D.items() -> list of D's (key, value) pairs, as 2-tuples
 |  
 |  iteritems(...)
 |      D.iteritems() -> an iterator over the (key, value) items of D
 |  
 |  iterkeys(...)
 |      D.iterkeys() -> an iterator over the keys of D
 |  
 |  itervalues(...)
 |      D.itervalues() -> an iterator over the values of D
 |  
 |  keys(...)
 |      D.keys() -> list of 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 present and has a .keys() method, does:     for k in E: D[k] = E[k]
 |      If E present and lacks .keys() method, 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() -> list of D's values
 |  
 |  viewitems(...)
 |      D.viewitems() -> a set-like object providing a view on D's items
 |  
 |  viewkeys(...)
 |      D.viewkeys() -> a set-like object providing a view on D's keys
 |  
 |  viewvalues(...)
 |      D.viewvalues() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
 |  
 |  __new__ = <built-in method __new__ of type object>
 |      T.__new__(S, ...) -> a new object with type S, a subtype of T

#两种写法，推荐第一种,但要记住用{}定义的还有set
dict1={'F':70,'C':67,'h':104,'i':105,'s':115}
dict2=dict((('F',70),('i',105),('s',115),('h',104),('C',67)))

dict1

{'C': 67, 'F': 70, 'h': 104, 'i': 105, 's': 115}

dict2

{'C': 67, 'F': 70, 'h': 104, 'i': 105, 's': 115}

dict1['C']

67

type(dict1)

dict

#_*_coding=utf-8_*_
brand = ['李宁', '耐克', '阿迪达斯', '鱼C工作室']
slogan = ['一切皆有可能', 'Just do it', 'Impossible is nothing', '让编程改变世界']
print'鱼C工作室的口号是：', slogan[brand.index('鱼C工作室')]

print brand[1]

鱼C工作室的口号是： 让编程改变世界
耐克

#在Python中，带不带括号输出”Hello World”都很正常。但如果在圆括号中同时输出多个对象时，就会创建一个元组，这是因为在Python 2中，
#print是一个语句，而不是函数调用。

from platform import python_version
print 'python',python_version()
print('a','b')
print'a','b'

python 2.7.11
('a', 'b')
a b

a = dict(one=1, two=2, three=3)
b = {'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({'three': 3, 'one': 1, 'two': 2})

print a,b,c,d,e

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

data = "1000,小甲鱼,男"

MyDict = {}

# 还记得字符串的分割方法吧，别学过就忘啦^_^

(MyDict['id'], MyDict['name'], MyDict['sex']) = data.split(',') 

print "ID:   " + MyDict['id']
print "Name: " + MyDict['name']
print "Sex   " + MyDict['sex']

ID:   1000
Name: 小甲鱼
Sex   男

print MyDict

#在python 下面一个包含中文字符串的列表（list）或字典，直接使用print整个字典会出现以下的结果：

{'sex': '\xe7\x94\xb7', 'id': '1000', 'name': '\xe5\xb0\x8f\xe7\x94\xb2\xe9\xb1\xbc'}

import json
#在输出处理好的数据结构的时候很不方便，需要使用以下方法进行输出：
print json.dumps(MyDict,encoding="UTF-8", ensure_ascii=False)

{"sex": "男", "id": "1000", "name": "小甲鱼"}

#python默认是使用ascii输出utf8字符

import sys 
sys.getdefaultencoding()

'ascii'

#遍历
for key in MyDict:
    print key,'corr',MyDict[key]

sex corr 男
id corr 1000
name corr 小甲鱼