Python FAQ（常见问题解答）（1）

1、python的帮助： help(str)  可以查看str字符类的帮助信息。
2、python没有括号来表明语句块，而是采用缩进来表示这一语法。
3、一定要用自然字符串处理正则表达式。否则会需要使用很多的反斜杠。例如，后向引用符可以写成'\\1'或r'\1'。 
4、for循环的区间是半开区间：range(1,5,2)给出[1,3]。记住，range 向上延伸到第二个数，即它不包含第二个数。
5、print语句的结尾使用了一个 逗号 来消除每个print语句自动打印的换行符。
6、列表的sort方法来对列表排序。需要理解的是，这个方法影响列表本身，而不是返回一个修改后的列表——这与字符串工作的方法不同。
    这就是我们所说的列表是 可变的 而字符串是 不可变的 。
7、因为从文件读到的内容已经以换行符结尾，所以我们在print语句上使用逗号来消除自动换行。最后，我们用close关闭这个文件。
8、 安全使用  and-or  技巧: (1 and [a] or [b] )[0]  
    由于 [a] 是一个非空列表，所以它决不会为假。即使 a 是 0 或者 '' 或者其它假值，列表 [a] 也为真，因为它有一个元素。
    在 Python 语言的某些情况下 if 语句是不允许使用的，比如在 lambda 函数中。
9、从notepad++执行python代码：cmd /k python "$(FULL_CURRENT_PATH)" & PAUSE & EXIT  然后 run -> run设置快捷键
10、python 3 开始默认utf-8的编码模式，因此在2.x版本下要注意字符编码的问题：
    #!/usr/bin/python
    #coding:utf-8           #如果出现编码问题，需在开头加上这句
    movies=[]
    print('movies List的长度是：'+str(len(movies)))      #注意不像java隐式类型转换，要str显示转换类型
11、转置一个元组：
    a = (1,2,3,4,5)
    b = list(a)[::-1]
    print b   #[5, 4, 3, 2, 1]
    或者直接调用revered函数：
    >>> a = (1,2,3,4,5)
    >>> aa=tuple(reverse(a))
    >>> print (aa)
    (5, 4, 3, 2, 1)
    >>> 
12、*和**作为参数列表的区别：
    不定长参数 *para,**para
    参数格式为 *para 表示接受一个元组
    为 **para 表示接受一个字典
    *para要在**para之前
13、三元表达式推荐写法：foo = val1 if condition else val2
14、为啥[""]为真而("")为假呢
    那是因为 ("") 是空的字符串，而不是元组对象。 而前者则是一个 list 对象。
15、python的颜色设置：
    def inred( s ):
        return "%s[31;2m%s%s[0m"%(chr(27), s, chr(27))
    print 'this is a very '+inred('important')+' thing'    
16、有人知道以lambda作为参数的函数应该怎么写？可以用lambda作回调处理的
    def test(a,b):
    return a(b)
    test(lambda a:a+1, 1)
    是这种还是在test里返回函数？
    那直接用函数做参数行吗？
    当然可以
    不用把java的思维带进来，python里函数也是可传递的 
17、json.dumps在默认情况下，对于非ascii字符生成的是相对应的字符编码，而非原始字符，例如：
    >>> import json
    >>> js = json.loads('{"haha": "哈哈"}')
    >>> print json.dumps(js)
    {"haha": "\u54c8\u54c8"}
    解决办法很简单:
    >>> print json.dumps(js, ensure_ascii=False)  
    {"haha": "哈哈"}  
18、关于python打印乱码的问题：
    （1）、print list 出现：a1\xc7\xc9\xba\xc3\xd3\xc3\xb5\xc4\xd2\xf4\xc1\xbf\xbf\xd8\xd6
    （2）、print str 正常
    原因：
    在执行 print 时，如果是一个字符串，就直接输出。如果是其它的对象，python会调用这个对象的 __str__ 或 __repr__
    来进行处理，对象list本身不是一个字符串，你要打印它，python会自动调用 repr(list) 来处理，这样就生成 list
    所表示的字符串，然后打印出来了。所以你看到的是 list 的字符串表示。其中的字符串都转为 \x这种内码表示形式了。
    例如：
    >>> a={}
    >>> a["abc"]="中国"
    >>> print a
    {'abc': '\xe4\xb8\xad\xe5\x9b\xbd'}
    >>> print a["abc"]
    中国
    >>>
    （3）、print会解释内嵌换行符，以友好显示 （P198）
    >>>bytes = open('datafile.txt').read()
    >>>bytes
    "apam\n43\n"
    >>>print bytes
    apam
    43
    因此，我们不得不使用其他转换工具，把文本文件中的字符串转换成真正的python对象。鉴于python不会自动把字符串转
    换为数字或其他对象类型，如果我们需要使用诸如索引、加法等普通对象工具，就得这么做。
    f = open('datafile.txt')
    line = f.readline()
    line
    'spam\n'
    line.rstrip()   #也可 line[:-1] ，但只有确定所有行都含有 "\n" 的时候才行（文件中最后一行有时会没有）
    'spam'
19、判断模块是否已安装
    模块加载后，会储存在sys.modules这个字典里，只需要在这个字典里查找，即可判断是否已安装。print sys.modules
20.python命令行求和：
    python -c "print reduce(lambda x,y:x+y,range(1,101))"
    python -c "print map(sum,zip([1],[2]))"
    python -c "print sum(range(101))"
21.python 简单模拟清屏方法：
    print ">>>\n"*40
22.python的高精度浮点运算：
    >>> from __future__ import division
    >>> print "%.2f" %(1/3)
    0.33
23.2.7版本以上直接设置千分位分隔符
    format(1234567890,',')
24.通过join来连接字符串：
    [ 1 ,   2 ,   3 ]
    >>> s = ['a', 'b', 'c', 'd']
    >>> print " ".join(s)
    a b c d
    >>> print "-".join(s)
    a-b-c-d                                #可以设置分隔符
    >>>
    a = 'hello'
    b = 'python'
    c = 1
    print '%s %s %s %s' % (a, b, c, s)   #连接多个变量
25.python计时：python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'reduce(lambda x,y: x+y,l)'
26.python取前两天的日期
    >>> from datetime import timedelta, date
    >>> print date.today() + timedelta(days = -2)
    2011-10-09
    >>> 
27.python 中元素是否设置：isset(var)
28.Python统计列表中元素出现的次数
    Python列表可以进行简单的统计，比如list的函数count()可以直接统计元素出现的次数。
    mylist = [2,2,2,2,2,2,3,3,3,3]
    myset = set(mylist)
    for item in myset:
        print mylist.count(item), " of ", item, " in list"
29.一个空 list 本身等同于 False    
30.遍历 list 的同时获取索引:
    for i, element in enumerate(mylist):
        pass
31.python全局替换：
    a="\t\t\t123\t456"
    print a
    print ",".join(a.split("\t"))
    或者
    re.sub
    或者 print a.replace("\t",",")
32.minidom的值：text、data、nodeValue
33.python的几大应用场景：系统维护，测试，web原型开发 
34.如何让 json 以 gbk 编码：
    按照JSON标准，中文首先被转换成unicode，然后转换成\uxxxx的格式。
    json采用gbk编码：
    a = {'key':'中文'}
    print json.dumps(a, ensure_ascii=True, encoding='gbk')
35.python的双重for循环：
    >>> a = ('la','luo','lao')
    >>> b =('hua','huo')
    >>> print [(x,y) for x in a for y in b]
    [('la', 'hua'), ('la', 'huo'), ('luo', 'hua'), ('luo', 'huo'), ('lao', 'hua'), ('lao', 'huo')]
    >>> print zip(a,b)
    [('la', 'hua'), ('luo', 'huo')]
    >>>
36.python颜色输出：
    WHITE = '\033[97m'
    CYAN = '\033[96m'
    BLUE = '\033[94m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    RED = '\033[91m'
    ENDC = '\033[0m' 
    print (GREEN + '    [>80]:' + BLUE + ' #%d(%d)' + WHITE + ':%s') % (i, len(line), line) + ENDC 
37.python自带的简单的 http 服务器：
    python -m SimpleHTTPServer
38.python命令行将ascii转换成十六进制：
    python -c 'print "hello".encode("hex")'
39.python 中双斜杠代表单斜杠：python解析一次，正则解析一次：
    >>> r"123\\\121\3".replace("\\\\","\\")
    '123\\\\121\\3'                                # 注意 命令行 会对其做一次转义，以便可以还原
    >>> print r"123\\\121\3".replace("\\\\","\\")
    123\\121\3                                    # print 就会显示最终的效果
    >>>
40.python 行列倒序输出：类似 ...|rev|tac
    >>> print '''1 2 
    ... 3 4
    ... 5 6
    ... 7 8'''[::-1]
    8 7
    6 5
    4 3
    2 1
    >>> 
41.python 自动关闭文件句柄：
    在python 2.5之后 由于有了context manager, 就可以使用with语法, 在with语句结束时, 有系统来保证自动关闭文件句柄.
    with open("Output.txt", "w") as text_file:
        text_file.write("Purchase Amount: %s"%TotalAmount)
42.python对字符的转义：
    echo 'a\\\b'|python -c 'import sys;a=sys.stdin.readlines();print a;'
    ['a\\\\\\b\n']
    echo 'a\\\b'|python -c 'import sys;a=sys.stdin.readlines();print a[0].replace("\\\\","-")'
    a-\b
43.遍历当前文件夹获取顶级文件夹：
    [ os.path.join(os.getcwd(), name) for name in os.listdir(os.getcwd()) if os.path.isdir(name)]
44.python产生空洞文件：
    bigFile= open(_filename_, 'w')
    bigFile.seek(1024*1024*1024* fileSize-1) #大小自己定,需要几个G, fileSize就是几，速度绝对快
    bigFile.write('\x00')
    bigFile.close()
45.json美化输出：
    chrome插件JSONView 或者 tool模块：echo '{"a": 1, "b": 2}' | python -m json.tool
    echo '{"a": 1, "b": 2}'|python -c 'import json,sys;print json.dumps(json.loads(sys.stdin.readlines()[0].strip()), indent=4)'
46.python字典 dict 默认是无序的，要有序请用collection中的orderdict：
    >>> d=collections.OrderedDict()
    >>> d['c']=1
    >>> d['d'] =2
    >>> d['b']=4
    >>> d
    OrderedDict([('c', 1), ('d', 2), ('b', 4)])
    #当往前台传递时
    >>> json.dumps(d)
    '{"c": 1, "d": 3, "b": 2}'
47.lamada的妙用：将下划线的字符串处理为Camel的表示形式：
    re.sub('^\w|_\w', lambda x:x.group()[-1].upper(), 'blog_view') 输出 'BlogView'。
48.getattr利用变量构造引用类属性：
    property in ['name','age','sex']:
    print getattr(user,property)
49.标准的JSON是使用双引号的，javascript支持使用单引号格式的json文本，而python的json库只支持双引号，
    如果有单引号的，需要 replace("'",'"') 全部替换成双引号，否则会报错
50.用 minidom 格式化输出 xml：
    python -c 'import xml.dom.minidom;print xml.dom.minidom.parseString("<Root><Head><a>20130221144501</a><b>1</b></Head><Records><c>1</c><d><e><f></f><g>20121022103334</g></e></d></Records></Root>").toprettyxml()'
51.使用 itertools 模块进行排列组合：
    python -c "from itertools import permutations;print [''.join(i) for i in list(permutations(['a','b','c']))]"
    print([''.join(x) for x in itertools.product('ATCG', repeat=4)])
52.解码16进制字符串：也可以直接 print 出来
    >>> b='\xd1\xee\xba\xea\xc1\xc1\n'
    >>> print unicode(b, 'gbk').encode('utf8')
53.python 中的正则 split：
    print re.compile(r"a{1,2}").split('baac')
    >>> re.split('\W+', 'Words, words, words.')
    ['Words', 'words', 'words', '']
    >>> re.split('(\W+)', 'Words, words, words.')
    ['Words', ', ', 'words', ', ', 'words', '.', '']
    >>> re.split('\W+', 'Words, words, words.', 1)
    ['Words', 'words, words.']
    >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
    ['0', '3', '9']
    >>> re.split('(\W+)', '...words, words...')
    ['', '...', 'words', ', ', 'words', '...', '']
54.python标准输出无缓存：
    export PYTHONUNBUFFERED=1     # python -u cmd
55.如何在循环中获取下标
    >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    >>> list(enumerate(seasons))
    [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    >>> list(enumerate(seasons, start=1))
    [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
56.foo is None 和 foo == None的区别：
    is是身份测试，==是值相等测试
    (ob1 is ob2) 等价于 (id(ob1) == id(ob2))
57.为何1 in [1,0] == True执行结果是False
    这里python使用了比较运算符链，类似 a < b < c 会被转为 (a < b) and (b < c) # b不会被解析两次
58.Python中的switch替代语法：
    python中没有switch，有什么推荐的处理方法么？使用字典:
    def f(x):
        return {
            'a': 1,
            'b': 2,
        }.get(x, 9)

59.字符串转为float/int：
    a = "545.2222"; int(float(a)) 或者 ast.literal_eval("545.2222")
60.如何随机生成大写字母和数字组成的字符串
    ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(N))
61.python中字符串的contains
    if not "blah" in somestring: continue        # 可读性、可维护性差，不推荐！
    if "blah" not in somestring: continue
62.如何判断一个字符串是数字
    a.isdigit()        # 缺点，对非整数无能为力，float(s) 或 正则
63.将一个字符串转为一个字典
    从python2.6开始，你可以使用内建模块 ast.literal_eval，这个做法比直接eval更安全
    ast.literal_eval("{'muffin' : 'lolz', 'foo' : 'kitty'}")
64.如何获取一个字符的ASCII码
    >>> ord('a')
    97
    >>> chr(97)
    'a'
    >>> chr(ord('a') + 3)
    'd'
    >>>
    另外对于unicode
    >>> unichr(97)
    u'a'
    >>> unichr(1234)
    u'\u04d2'
65.如何填充 0 到数字字符串中保证统一长度
    print n.zfill(3)
    print '%03d' % n
    print "{0:03d}".format(4) 
66.如何创建不存在的目录结构
    if not os.path.exists(directory):
        os.makedirs(directory)
    需要注意的是，当目录在exists和makedirs两个函数调用之间被创建时，makedirs将抛出OSError
67.如何拷贝一个文件
    shutil.copyfile(src, dst)
    将src文件内容拷贝到dst，目标文件夹必须可写，否则将抛出IOError异常，如果目标文件已存在，将被覆盖
    另外特殊文件，比如字符文件，块设备文件，无法用这个方法进行拷贝
68.逐行读文件去除换行符(perl chomp line)
    比较pythonic的做法: "line 1\nline 2\r\nline 3\nline 4".splitlines()
69.如何获取一个文件的创建和修改时间
    print "last modified: %s" % time.ctime(os.path.getmtime(file))
    print "created: %s" % time.ctime(os.path.getctime(file))
    (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(file)
    print "last modified: %s" % time.ctime(mtime)
70.如何将字符串转换为datetime
    可以查看下time模块的strptime方法，反向操作是strftime
    date_object = datetime.strptime('Jun 1 2005  1:33PM', '%b %d %Y %I:%M%p')
71.如何找到一个目录下所有.txt文件
    os.chdir("/mydir")
    for files in glob.glob("*.txt"):
        print files
        
    os.chdir("/mydir")
    for files in os.listdir("."):
        if files.endswith(".txt"):
            print files
    
    for r,d,f in os.walk("/mydir"):
        for files in f:
            if files.endswith(".txt"):
                print os.path.join(r,files)
72.读文件到列表中
    f = open('filename')
    lines = f.readlines()
    f.close()
    等价
    with open(fname) as f:
        content = f.readlines()
    往文件中追加文本
    with open("test.txt", "a") as myfile:
        myfile.write("appended text")
73.如何列出一个目录的所有文件
    onlyfiles = [ f for f in listdir(mypath) if isfile(join(mypath,f)) ]
    f = []
    for (dirpath, dirnames, filenames) in walk(mypath):
        f.extend(filenames)
        break
    print glob.glob("/home/adam/*.txt")
74.如何从标准输入读取内容stdin
    for line in fileinput.input(): pass
75.在Python中如何展示二进制字面值
    十六进制可以

    >>> 0x12AF
    4783
    >>> 0x100
    256
    八进制可以
    
    >>> 01267
    695
    >>> 0100
    64
    二进制如何表示？
    Python 2.5 及更早版本: 可以表示为 int('01010101111',2) 但没有字面量
    Python 2.6 beta: 可以使用0b1100111 or 0B1100111 表示
    Python 2.6 beta: 也可以使用 0o27 or 0O27 (第二字字符是字母 O)
    Python 3.0 beta: 同2.6，但不支持027这种语法
76.如何将一个十六进制字符串转为整数
    >>> int("a", 16)
    10
    >>> int("0xa",16)
    10
77.如何强制使用浮点数除法
    from __future__ import division；c = a / b
    或者转换,如果除数或被除数是浮点数，那么结果也是浮点数
    c = a / float(b)
78.如何合并两个列表
    1.不考虑顺序：listone + listtwo    #linstone.extend(listtwo)也行，就是会修改listone
    2.考虑顺序做些处理： itertools.chain(listone, listtwo)
79.如何随机地从列表中抽取变量
    print random.choice(['a', 'b', 'c', 'd', 'e'])
80.获取列表的最后一个元素
    result = l[-1]
    result = l.pop()
81.如何将一个列表切分成若干个长度相同的子序列
    想要得到这样的效果
    l = range(1, 1000)
    print chunks(l, 10) -> [ [ 1..10 ], [ 11..20 ], .., [ 991..999 ] ]
    使用yield:
    def chunks(l, n):
        """ Yield successive n-sized chunks from l.
        """
        for i in xrange(0, len(l), n):
            yield l[i:i+n]
    list(chunks(range(10, 75), 10))
    直接处理
    def chunks(l, n):
        return [l[i:i+n] for i in range(0, len(l), n)]
82.如何获取list中包含某个元素所在的下标
    ["foo","bar","baz"].index('bar')
83.如何扁平一个二维数组
    l = [[1,2,3],[4,5,6], [7], [8,9]]
    变为[1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 9]
    列表解析
    [item for sublist in l for item in sublist]
    itertools
    >>> import itertools
    >>> list2d = [[1,2,3],[4,5,6], [7], [8,9]]
    >>> merged = list(itertools.chain(*list2d))
    # python >= 2.6
    >>> import itertools
    >>> list2d = [[1,2,3],[4,5,6], [7], [8,9]]
    >>> merged = list(itertools.chain.from_iterable(list2d))
    sum
    sum(l, [])    
84.使用列表解析创建一个字典
    python 2.6
    d = dict((key, value) for (key, value) in sequence)
    python 2.7+ or 3, 使用 字典解析语法
    d = {key: value for (key, value) in sequence}
85.如何在单一表达式中合并两个Python字典
    >>> x = {'a':1, 'b': 2}
    >>> y = {'b':10, 'c': 11}
    >>> z = x.update(y)
    print x
    我想要最终合并结果在z中，不是x，我要怎么做？
    这种情况下，可以使用
    z = dict(x.items() + y.items())
    这个表达式将会实现你想要的，最终结果z，并且相同key的值，将会是y中key对应的值
    >>> x = {'a':1, 'b': 2}
    >>> y = {'b':10, 'c': 11}
    >>> z = dict(x.items() + y.items())
    >>> z
    {'a': 1, 'c': 11, 'b': 10}
    如果在Python3中,会变得有些复杂
    >>> z = dict(list(x.items()) + list(y.items()))
    >>> z
    {'a': 1, 'c': 11, 'b': 10}
86.排序一个列表中的所有dict，根据dict内值
    如何排序如下列表，根据name或age
    [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
    简单的做法
    newlist = sorted(list_to_be_sorted, key=lambda k: k['name'])
    高效的做法
    from operator import itemgetter
    newlist = sorted(list_to_be_sorted, key=itemgetter('name'))
87.如何获取一个函数的函数名字符串
    my_function.__name__
    >>> import time
    >>> time.time.__name__
    'time'
88.用函数名字符串调用一个函数
    假设模块foo有函数bar:
    import foo
    methodToCall = getattr(foo, 'bar')
    result = methodToCall()
    或者一行搞定
    result = getattr(foo, 'bar')()
89.检查是否是str或者str的子类
    isinstance(o, str)
    注意，你或许想要的是
    isinstance(o, basestring)
    因为unicode字符串可以满足判定(unicode 不是str的子类，但是str和unicode都是basestring的子类)
    可选的，isinstance可以接收多个类型参数，只要满足其中一个即True
    isinstance(o, (str, unicode))
    判断变量的类型可以使用 type
90.json和simplejson的区别
    json就是simple，加入到标准库. json在2.6加入，simplejson在2.4+,2.6+,更有优势
    另外，simplejson更新频率更高，如果你想使用最新版本，建议用simplejson
    好的做法是
    try: 
        import simplejson as json
    except ImportError: 
        import json
91.有什么方法可以获取系统当前用户名么?
    os.getusername()、os.getuid()、getpass.getuser()
92.Python中有没有简单优雅的方式定义单例类
    我不认为有必要，一个拥有函数的模块（不是类）可以作为很好的单例使用，它的所有变量被绑定到这个模块，无论如何都不能被重复实例化
    如果你确实想用一个类来实现，在python中不能创建私有类或私有构造函数,所以你不能隔离多个实例而仅仅通过自己的API来访问属性
    我还是认为将函数放入模块，并将其作为一个单例来使用是最好的办法
    顺带说下 staticmethod，静态方法在调用时，对类及实例一无所知
    仅仅是获取传递过来的参数，没有隐含的第一个参数，在Python里基本上用处不大，你完全可以用一个模块函数替换它
93.如何获取Python的site-packages目录位置
    python -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())"
94.如何获取安装的python模块列表
    >>> help('modules')
95.什么是迭代？
    任何你可用 "for... in..." 处理的都是可迭代对象：列表，字符串，文件.... 这些迭代对象非常便捷，因为你可以尽可能多地获取你想要的东西
    但当你有大量数据并把所有值放到内存时，这种处理方式可能不总是你想要的
96.什么是生成器？
    生成器是迭代器，但你只能遍历它一次(iterate over them once) 因为生成器并没有将所有值放入内存中，而是实时地生成这些值
    >>> mygenerator = (x*x for x in range(3))
    >>> for i in mygenerator:
    ...    print(i)
    0
    1
    4
    这和使用列表解析地唯一区别在于使用()替代了原来的[]
    注意，你不能执行for i in mygenerator第二次，因为每个生成器只能被使用一次: 计算0，并不保留结果和状态，接着计算1，然后计算4，逐一生成
97.yield 的意义与作用？
    yield是一个关键词，类似return, 不同之处在于，yield返回的是一个生成器
    >>> def createGenerator():
    ...    mylist = range(3)
    ...    for i in mylist:
    ...        yield i*i
    ...
    >>> mygenerator = createGenerator() # create a generator
    >>> print(mygenerator) # mygenerator is an object!
    <generator object createGenerator at 0xb7555c34>
    >>> for i in mygenerator:
    ...     print(i)
    0
    1
    4
    这个例子并没有什么实际作用,仅说明当你知道你的函数将产生大量仅被读取一次的数据时,使用生成器将是十分有效的做法
    要掌握yield,你必须明白 - 当你调用这个函数，函数中你书写的代码并没有执行。这个函数仅仅返回一个生成器对象
    这有些狡猾 :-)
    然后，在每次for循环使用生成器时,都会执行你的代码
    然后，是比较困难的部分：
    第一次函数将会从头运行，直到遇到yield，然后将返回循环的首个值. 然后，每次调用，都会执行函数中的循环一次，返回下一个值，直到没有值可以返回
    当循环结束，或者不满足"if/else"条件，导致函数运行但不命中yield关键字，此时生成器被认为是空的，然后就结束迭代
98.迭代器的内部机制
    迭代过程包含可迭代对象(实现__iter__()方法) 和迭代器(实现__next__()方法)
99.字典批量添加或更新
    d['key'] = 'newvalue'
    #另一个字典
    d.update({'key':'newvalue'})  #这里支持一整组值
    #元组列表
    d.update( [ ('a',1), ('b',2) ] ) #每个元组两个元素，(key,value)
    #**key
    d.update(c=3, e=4)
    d.setdefault('name', 'ken') #若原来没有，设置，否则原值不变
100.字典删除
    del d['key']
    value = d.pop('key') #删除并返回值
    d.clear() #清空