Python 代码执行流程：
- 编译 --> 执行
- 源代码 --> 字节码 --> 机器码 --> CPU执行
python 先将自己的源代码，编译成Python 字节码，不同语言的字节码，只有对应的编译器可以识别，运行时再将字节码转换成机器码在执行，经过了现两个转换的步骤，所以比 C 语言要慢一个量级。
Python 的几种实现：
python 作为一种编程语言，它有多种实现。这里的实现指的是符合Python语言规范的Python解释程序以及标准库等。这些实现虽然实现的是同一种语言，但是彼此之间，特别是与CPython之间还是有些差别的。
1、CPython：Python的官方版本，使用C语言实现，使用最为广泛，新的语言特性一般也最先出现在这里。
C 语言实现的 python --> C 解释器 --> .pyc(字节码) --> 机器码 --> CPU执行
2、Jpython：这是Python的Java实现，相比于CPython，它与Java语言之间的互操作性要远远高于CPython和C语言之间的互操作性。
java 实现的 python --> java 解释器 --> java字节码 --> 机器码 --> CPU执行
3、Python for .NET：它实质上是CPython实现的.NET托管版本，它与.NET库和程序代码有很好的互操作性。
4、IronPython：不同于Python for .NET，它是Python的C#实现，并且它将Python代码编译成C#中间代码（与Jython类似），然后运行，它与.NET语言的互操作性也非常好。
5、PyPy：Python的Python实现版本，原理是这样的，PyPy运行在CPython（或者其它实现）之上，用户程序运行在PyPy之上。它的一个目标是成为Python语言自身的试验场，因为可以很容易地修改PyPy解释器的实现（因为它是使用Python写的）。
python 源代码 --> py解释器 --> 字节码、机器码(编译过程中就已经生成机器码) --> CPU 执行
Python 执行过程：
- 语法分析 (检测你的语法是否有问题)
- 词法分析( 说明代码写的没问题)
- 编译代码(遇到函数与类解释的方式不同，生成字节码)
- 执行(转换成机器码)
Python 运行后，原目录下会生成 .pyc(Python 编译后生成的专有字节码文件) 可用工具反解。
Python 执行时会优先找 .pyc 文件，当没有 .pyc 会先执行 py 生成字节码，如果 py 文件被修改过，与 .pyc 文件中的内容不符，Python 会重新编译生成 .pyc 并替换。
字符集与字符编码：
1.字符集：
- 字符是各种文字和符号的总称，包括各个国家文字、标点符号、图形符号、数字等。字符集是多个字符的集合，字符集种类较多，每个字符集包含的字符个数不同。
- 常见字符集有：ASCII字符集、ISO 8859字符集、GB2312字符集、BIG5字符集、GB18030字符集、Unicode字符集等。
- 计算机要准确的处理各种字符集文字，需要进行字符编码，以便计算机能够识别和存储各种文字。
2.编码(encoding)：
- 编码(encoding)与字符集不同。字符集只是字符的集合，不一定适合作网络传送、处理，有时须经编码(encode)后才能应用。
- 如Unicode可依不同需要以 UTF-8、UTF-16、UTF-32等方式编码。
- 字符编码就是以二进制的数字来对应字符集中的字符。
使用哪些字符。也就是说哪些汉字，字母和符号会被收入标准中。所包含“字符”的集合就叫做“字符集”。
规定每个“字符”分别用一个字节还是多个字节存储，用哪些字节来存储，这个规定就叫做“编码”。
常用字符编码：
ASCII：
- （American Standard Code for Information Interchange，美国信息互换标准代码）是基于拉丁字母的一套电脑编码系统。它主要用于显示现代英语，而其扩展版本EASCII则可以勉强显示其他西欧语言。它是现今最通用的单字节编码系统（但是有被UniCode追上的迹象)
- ASCII 采用 7 位或 8 位 二进制数组合来表示 128 或 256 种可能出现的字符，在计算机没有大规模发展时，128位足以表示英文字符与数字，但后期计算机经过广泛发展，在世界的各个角落流行起来，采取传统的 8 位二进制数最多只能表示 256 种字符变化，对于纯英文来说足够，但是并不适于其它国家的语言，，已经不能满足其它国家对字符的表示需求。
Unicode：
万国码，它至少采用 2byte 来表示字符，表示范围是世界上各个国家的字符，范围很大，比如，汉字“严”的unicode是十六进制数4E25，转换成二进制数足足有15位（100111000100101），也就是说这个符号的表示至少需要2个字节。表示其他更大的符号，可能需要3个字节或者4个字节，甚至更多。
这就会出现两个严重的问题：
如何才能区别unicode和ascii？计算机怎么知道三个字节表示一个符号，而不是分别表示三个符号呢？第二个问题是，我们已经知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0来填充，这对于存储来说是极大的浪费，文本文件的大小会因此大出二三倍，这是无法接受的。
它们造成的结果是：
- 出现了unicode的多种存储方式，也就是说有许多种不同的二进制格式，可以用来表示unicode。
- unicode在很长一段时间内无法推广，直到互联网的出现。
Unicode：
互联网的普及，强烈要求出现一种统一的编码方式。UTF-8就是在互联网上使用最广的一种unicode的实现方式。其他实现方式还包括UTF-16和UTF-32，但只有 UTF-8 被广泛使用，注意：UTF-8是Unicode的实现方式之一。
- UTF-8最大的一个特点，它是一种变长的编码方式。它可以使用1~4个字节表示一个字符，根据不同的字符而变化字节长度，避免了 Unicode 中浪费磁盘空间的问题。
GBK：
- 专属用来表示中文的一种字符编码。
Python 编码：
- python 2.x 默认采用 Unicode 编码格式，让人非常头疼的问题就是编码问题。
- 如果想让 Python 支持中文字符需要在文件顶部声明编码格式为：utf-8
-
#-*- coding:utf-8 -*-
Unicode 与 GBK 之间需要互相转换，需要先解码(encode)成 Unicode 在编码(decode)成对应的编码。
-
- 如果想让 Python 支持中文字符需要在文件顶部声明编码格式为：utf-8
- python 3.x 默认采用 UTF-8 编码格式，原生支持中文。
传入参数：
import sys print sys.argv # 用于接收 Python 解释器传入的参数，argv 输出类型为列表
# sys 是 python 的标准模块，Python 解释器相关的功能都封装在 sys 模块中。
对于 Python 一切事物皆对象，对象基于类创建，类中有很多功能，都会被对象所继承。
1 print (type (tu)) # type 返回对象属于哪个类 2 print (dir(tu)) # dir 返回类中有哪些(成员) 方法
字符串格式化：
1、万恶的 + 号：
Python 是用 C 语言开发而来，在 C 语言中没有字符串的概念，C 只有字符数组。
str_1 = 'alex'
str_2 = 'Jay'
str_1在内存中存储为： ['a','l','e','x']
内存中的操作：
C 在内存中申请一段连续的空间 A0 用来存储 alex 这个字符数组，此时其它程序需要在内存空间来存储数据继续向内存申请 A0 后的空间 B1 ，当 str_1 + str_2 时，在 C 内部，会在内存中重新申请一段空间D1用来存储 ['a','l','e','x','J','a','y'] ，此时原有空间 A1 中存储的内容，没有任何意义，但并不会被立即释放掉，需要靠C 语言自己的内存回收机制。
当 + 号用的较多时，就浪费了很多内存空间。 所以在字符串拼接时，尽量不用 + 号两拼接两个字符串。
2、% 号连接字符串：
name = "Jay" age = 100 sex = "boy" print ("My name is %s age %d sex %s !" %(name,age,sex))
字符串操作：
S = "jay"
字符串大小写转换：
S.lower() # 将字符串 S 中内容转换为小写
S.upper() # 将字符串 S 中内容转换为大写
S.swapcase() # 将字符串 S 中内容大小写互转(原本 S 中大写字母转换为小写，原本 S 中小写字母转为大写)
S.capitalize() # 将字符串 S 中内容首字母变大写(不论 S 中原内容大写或小写，将首字母变成大写，其余字母统一转换成小写)
1 s = "Jay is JAY" 2 print (s.capitalize()) 3 > Jay is jay
S.title() # 将字符串 S 中内容的每个单词首字母变大写(其余字母统一变小写)
1 s = "Jay is JAY" 2 print (s.title()) 3 >Jay Is Jay
字符串输出对齐：
S.ljust(width,[fillchar]) # 输出 width 个字符，S 中内容左对齐，不足部分用 fillchar(可省略) 填充，默认为空格。
S.rjust(width,[fillchar]) # 输出 width 个字符，S 中内容右对齐，不足部分用 fillchar(可省略) 填充，默认为空格。
S.center(width,[fillchar]) # 输出 width 个字符，S 中内容居中对齐，不足部分用 fillchar(可省略) 填充，默认为空格。
S.zfill(width) # 将 S 变成 width 长，S中内容右对齐，不足部分以 0 填充。
1 s = "Jay is JAY" 2 print (s.zfill(100)) 3 > 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000Jay is JAY
字符串的搜索与替换：
S.find(substr, [start, [end]]) # 返回 S 中出现 substr 的第一个字母位置(区分大小写)，如 S 中没有指定的 substr 返回 -1，start,end 指定搜索的起始与结束位置(可省)。
S.rfind(substr, [start, [end]]) # 返回 S 中最后出现 substr 的第一个字母位置，其余同 find() 函数。
S.index(substr,[start,[end]]) # 与 find() 相同，区别在于 S 中没有 substr 时，程序中止并返回错误。
S.rindex(substr,[start,[end]]) # 返回 S 中最后出现 substr 的第一个字母位置，其余同 index 函数。
S.strip([chars]) # 将 S 内容中前后 chars 字符全部掉(只能去除字符两侧),chars 默认为空白。
1 name = " My name is Jay " 2 print (name.strip()) 3 > My name is Jay
S.lstrip([chars]) # 只去除左侧出现的内容，其余同上。
S.rstrip([chars]) # 只去除右侧出现的内容，其余同上。
S.count(substr, [start, [end]]) # 计算 substr 在 S 中出现的次数。
S.replace(oldstr,newstr,[count]) # 将 S 中 oldstr 替换为 newstr, count 为替换次数。
1 s = "Jay is JAY aa" 2 print (s.replace("a","Q",2)) 3 > JQy is JAY Qa
S.expandtabs([tabsize]) # 把 S 中的 tab 字符替换为空格，每个 tab 替换为 tabsize 个空格，tabsize 默认值为 8。
S.split([sep, [maxsplit]]) # 以 spe 为分隔符，把 S 分成一个 list。 maxsplit 为分隔次数，默认分割符为空格。
1 str = "Hello,world,My,name is Jay" 2 print (str.split(",",2)) 3 > ['Hello', 'world', 'My,name is Jay']
S.rsplit([sep,[maxsplit]]) # 从右侧开始分隔，其余同上。
S.splitlines([keepends]) # 将字符串根据"\n"(换行符)分割成列表。
1 str = "Hello World\n My name\n is Jay\n !!!" 2 print (str.splitlines()) 3 > ['Hello World', ' My name', ' is Jay', ' !!!']
S.join(seq) #连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新字符串。
1 #字符串： 2 str = "Hello World" 3 print ("-".join(str)) 4 > H-e-l-l-o- -W-o-r-l-d 5 6 #列表： 7 str = ['hello','good','world'] 8 print (":".join(str)) 9 > hello:good:world 10 11 #元组： 12 str = ('hello','good','world') 13 print (":".join(str)) 14 > hello:good:world 15 16 字典： 17 str = {'name':'jay','age':100,'sex':"boy"} 18 print ("-".join(str)) 19 > name-age-sex # 所有的键
字符串的判断：
S.startswith(prefix[,start[,end]]) # S 中的内容是否以 prefix 开头，返回 True 或 False。
1 str = "My name is Jay" 2 print (str.startswith("My")) 3 > True
S.endswith(suffix[,start[,end]]) # S 中的内容是否以 suffix 结尾，返回 True 或 False。
1 str = "My name is Jay" 2 print (str.endswith("ay")) 3 > True
len(str) # 返回 str 中内容的长度。
S.isalnum() # S 中内容是否全是字母和数字，并至少有一个字符，返回 True 或 False S内容为空时返回 False，S 内容中有空格时返回 False。
S.isalpha() # S 中内容是否全是字母，并至少有一个字符，返回 True 或 False S内容为空时返回 False，S 内容中有空格时返回 False。
S.isdigit() # S 中内容是否全是数字，并至少有一个字符，返回 True 或 False S内容为空时返回 False，S 内容中有空格时返回 False。
S.isspace() # S 中内容是否全是空白字符，并至少有一个字符，返回 True 或 False S内容为空时返回 False。
S.islower() # S 中内容是否全是小写，并至少有一个字符，返回 True 或 False S内容为空时返回 False，允许 S 中有空格。
S.isupper() # S 中内容是否全是大写，并至少有一个字符，返回 True 或 False S内容为空时返回 False，允许 S 中有空格。
S.istitle() # S 中内容是首字母大写，并至少有一个字符，返回 True 或 False S内容为空时返回 False，允许 S 中有空格。
注意：字符串对象是不可改变的，也就是说在 Python 创建一个字符串后，上面这些函数并不能将字符串中的某一部分改变，使用函数对字符串进行操作后，会返回一个新的字符串，原字符串并没有改变，可以用 S = 函数() 将结果保存下来，或直接用 print () 将结果输出出来。 并且函数中的参数区分大小写。
列表：
- 列表(list) 是 Python 以及其它语言中最常用到的数据结构之一，Python 使用中括号 [] 来解析列表，列表是可被改变的，它是 Python 中使用最频繁的数据类型。
- 有序
- 可变
列表的创建：
列表是Python 中非常非常常见的数据结构，所以Python提供了一种语法糖，将列表的创建方法list()封装为更简单的创建。
li=[1,2,3,4] 等同于 li=list(1,2,3,4)
列表常见操作：
1 li = [] #创建一个空列表 2 li = [1,2,3,4] # 创建一个纯数字列表 3 li = [1,'a',[2,3]] # 创建一个数字、字符串、嵌套列表 4 li = list('hello') # ['h','e','l','l','o'] # 将字符串变成列表 5 li = list(range(4)) # [0,1,2,3] # 取指定范围列表中内容 6 li = '1,2,3,4,5'.split(',') # ['1,','2,','3','4','5'] 将字符串以指定字符分隔成列表
索引：
1 li = ["a","b",'c',"d",'e','f',"g",'h'] 2 print (li[0]) 3 > a
列表的切片：
1 li = ["a","b",'c',"d",'e','f',"g",'h'] 2 3 print (li[1:]) 4 > ['b', 'c', 'd', 'e', 'f', 'g', 'h'] 5 6 print (li[:3]) 7 > ['a','b','c'] 8 # 输出从 索引 0 至 索引 3 的内容 9 10 print (li[1:3]) 11 > ['b','c'] 12 # Python 索引的输出是顾前不顾后的。 13 14 print (li[1:100]) 15 > [b",'c',"d",'e','f',"g",'h'] 16 # 输出位置 1 至 最后一个字符，但并不会报错 17 18 print (li[:]) 19 >["a","b",'c',"d",'e','f',"g",'h'] 20 # : 显示列表中所有内容
列表的修改：
1 li = ["a","b",'c',"d",'e','f',"g",'h'] 2 li[1] = "a" 3 print (li) 4 > ["a","a",'c',"d",'e','f',"g",'h'] 5 6 li = ["a","b",'c',"d",'e','f',"g",'h'] 7 li[1:] = list("hello") 8 print (li) 9 > ['a', 'h', 'e', 'l', 'l', 'o']
列表的插入：
1 li = ["a","b",'c',"d",'e','f',"g",'h'] 2 li[2:2] = "123" 3 print (li) 4 > ['a', 'b', '1', '2', '3', 'c', 'd', 'e', 'f', 'g', 'h']
删除序列：
1 li = ["a","b",'c',"d",'e','f',"g",'h'] 2 li[2:] = [] 3 print (li) 4 > ['a', 'b'] 5 6 li = ["a","b",'c',"d",'e','f',"g",'h'] 7 li[2:len(li)] = [] 8 print (li) 9 > ['a', 'b']
列表的函数：
append：向列表尾部添加元素
1 li = ["a","b",'c',"d"] 2 li.append("hello") 3 print (li) 4 > ['a', 'b', 'c', 'd', 'hello']
clear：清空列表
li = ["a","b",'c',"d"] li.clear() print (li) > []
extend：修改原列表，链接两个列表产生新的列表
1 li_1 = ["a","b","c"] 2 li_2 = ["d","e","f"] 3 li_1.extend(li_2) 4 print (li_1) 5 > ['a', 'b', 'c', 'd', 'e', 'f'] 6 7 li = ["a","b","c"] 8 li.extend(["d","e"]) # 先生成列表再扩展 9 print (li) 10 > ['a', 'b', 'c', 'd', 'e']
insert：将元素插入到列表的指定位置
1 li = ["a","b","c"] 2 li.insert(2,"hello") # 此处指定的位置就是元素插入进列表后的位置 3 print (li) 4 > ['a', 'b', 'hello', 'c']
index：返回列表中指定元素的下标(指定位置不存在返回异常)
1 li = ["a","b","c"] 2 print (li.index("c")) 3 > 2
count：返回列表中指定元素出现的次数
1 li = ["c","a","b","c","c"] 2 print (li.count("c")) 3 > 3
len：统计列表中元素的个数
1 li = ["cf","af","b",1,2] 2 print (len(li)) 3 > 5 # 返回的是列表中元素的个数
pop：移除列表指定位置的元素，并返回其值(默认列表的最后一个元素)
1 li = ["cf","af","b",1,2] 2 print (li.pop()) 3 > 2 # 默认移除最后一个元素并返回其值 4 5 li = ["cf","af","b",1,2] 6 print (li.pop(0)) 7 > cf # 指定下标移除，并返回
remove：移除列表中指定的元素
1 li = ["cf","af","b",1,"cf",2,"cf"] 2 li.remove("cf") 3 print (li) 4 > ['af', 'b', 1, 'cf', 2, 'cf'] # 指定元素内容，并移除，当指定元素出现多次时，只移除第一次的出现的元素 5 6 # 移除所有指定元素： 7 li = ["cf","af","b",1,"cf",2,"cf"] 8 while "cf" in li: # 直接循环列表，确定指定元素出现的次数 9 li.remove("cf") # 每循环一次，移除一次 10 print (li) 11 > ['af', 'b', 1, 2]
reverse：反转列表整体元素的位置
1 li = [1,2,3,4,5] 2 li.reverse() 3 print (li) 4 > [5, 4, 3, 2, 1]
sort：对列表中的内容进行排序
1 li = [5,3,6,1,7] 2 li.sort() #直接修改原列表中的内容 3 print (li) 4 >[1,3,5,6,7]
不修改原序列排序：
1 #方法 1： 2 #利用 sorted 函数 3 li = [5,3,6,1,7] 4 new_li = sorted(li) 5 print (li) 6 print (new_li) 7 > [5, 3, 6, 1, 7] 8 > [1, 3, 5, 6, 7] 9 10 11 #方法 2： 12 #创建副本 13 14 li = [5,3,6,1,7] 15 new_li = li[:] 16 new_li.sort() 17 print (li) 18 print (new_li) 19 > [5, 3, 6, 1, 7] 20 > [1, 3, 5, 6, 7]
关键字排序 key：
1 li = ['aa','bbbb','ccc','d'] 2 li.sort(key = len) 3 print (li) 4 > ['d', 'aa', 'ccc', 'bbbb']
关键字排序：reverse()
1 li = [3,2,13,20,4] 2 li.sort(reverse = True) # reverse = True 降序 3 print (li) 4 > [20, 13, 4, 3, 2] 5 6 li = [3,2,13,20,4] 7 li.sort(reverse = False) # reverse = False 升序 8 print (li) 9 > [2, 3, 4, 13, 20]
列表与元组的转换：
1 # 列表转元组： 2 li = [11,22,33,44] 3 li = tuple(li) 4 print (li) 5 > (11, 22, 33, 44) 6 7 # 元组转列表： 8 tu = (11,22,33,44) 9 tu = list(tu) 10 print (tu) 11 > [11, 22, 33, 44]
字典：
dictionary 字典是 Python 语言中唯一的映射类型，也是 Python 中最强大的数据类型之一。
1、键值对的集合(map)
2、字典以大括号 "{}" 包围的数据集合
3、字典是无序的，在字典中通过键来访问成员，可变、可嵌套、可在原处修改扩展。
4、字典的键，可以是字符串(大小写敏感)，数字常量或元组(不可变类型)，同一个字典的键可以混用类型。字典的键必须是可哈希的。
5、字典的值可以是任意类型，可以嵌套，可以自由修改。
6、映射类型对象里哈希值(键,key) 和指向的对象(值,value) 是一对多的关系，通常被认为是可变的哈希表。
7、字典对象是可变的，它是一个容器类型，能存储任意个数的 Python 对象，其中也可包括其他容器类型。
字典就是用大括号包裹的键值对集合。(键值也被称作项)
创建字典：
1 # 创建空字典 2 dic = {} 3 4 # 创建字典 5 dic = {key1:value2,key2:value2} 6 dic = dict(k1='v1',k2='v2')
- 键与值用冒号 : 分开
- 项与项用逗号 , 分开
- 字典中的键必须是唯一的，值可以不唯一
字典的基本操作：
1、访问字典中的值：
dic[key] 返回键 key 对应的值 value，如果 key 不在字典中会提示错误。
2、更新字典：
1 # 向字典中添加一个项 2 dic["new_key"] = "value" 3 4 # 修改字典中一个项 5 dic["old_key"] = "new_value" 6 7 # 删除字典中的项 8 del dic # 删除整个字典 9 dic.clear() # 清空整个字典中的内容 10 11 del dic[key] # 指定key 删除某一项 12 dic.pop[key) # 删除指定 key 的项并返回对应的 value 值
formakeys：根据字典中所有 key 生成 一个新字典
1 new_dic = dic.fromkeys(['k1','k2','k3'],'v1') 2 print (new_dic) 3 > {'k2': 'v1', 'k3': 'v1', 'k1': 'v1'}
get：根据 key 取出 key 对应的 value
1 # dic[key] 这种方式取字典中的数据时，如果指定的 key 不存在，则退出程序并返回异常。 2 dic = {'k1':'v1','k2':'v2','k3':'v3'} 3 print (dic.get('k8')) 4 > None # 当指定的 key 不存在时，返回 None 5 6 dic = {'k1':'v1','k2':'v2','k3':'v3'} 7 print (dic.get('k8','ok')) # 当 k8 不存在时，返回默认值 ok 8 > ok
keys：取出字典的所有 key 并以列表返回
1 dic = {'k1':'v1','k2':'v2','k3':'v3'} 2 print (dic.keys()) 3 > dict_keys(['k1', 'k2', 'k3'])
values：取出字典的所有 value 并以列表返回
1 dic = {'k1':'v1','k2':'v2','k3':'v3'} 2 print (dic.values())
3 > dict_values(['v1', 'v2', 'v3'])
items：取出字典的所有 key 与 value 并以列表返回
1 dic = {'k1':'v1','k2':'v2','k3':'v3'} 2 print (dic.items()) 3 > dict_items([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
循环取字典中的 Key 与 values：
1 dic = {'k1':'v1','k2':'v2','k3':'v3'} 2 3 for k in dic.keys(): 4 print (k) 5 > k3 6 > k2 7 > k1 8 9 for v in dic.values(): 10 print (v) 11 > v3 12 > v2 13 > v1 14 15 for k,v in dic.items(): 16 print (k,v) 17 > k3 v3 18 > k2 v2 19 > k1 v1
pop：移除字典中的某一项，并返回其 value
1 dic = {'k1':'v1','k2':'v2','k3':'v3'} 2 old_key = dic.pop('k1') # 字典是无序的 移除时必须指定移除哪一项 3 print (dic) 4 print (old_key) # 移除后会返回移除的项，指定变量接收返回值
5 > {'k2': 'v2', 'k3': 'v3'}
6 > v1
popitem：随机移除字典中的某 key 与对应的 value 并返回移除的 key 与 value
1 dic = {'k1':'v1','k2':'v2','k3':'v3'} 2 old_key = dic.popitem() # 随机移除 key 与 value 3 print (dic) 4 print (old_key) 5 > {'k2': 'v2', 'k3': 'v3'} 6 > ('k1', 'v1') # 此处返回的是元组
update：将指定字典的键值对更新至另一字典中
1 dic = {'name':'jay','sex':'boy',} 2 dicc = {'age':'123'} 3 4 dic.update(dicc) 5 print ("Value: %s" % dic) 6 > Value: {'name': 'jay', 'age': '123', 'sex': 'boy'}
setdefault(key[,default])：如果指定键在字典中，返回键对应的值，如果键不在字典中，向字典中插入这个键，并以 default 为这个键的值，反返回 default，default 值默认为 None
1 dic = {'name':'jay','sex':'boy','age':'123'} 2 print (dic.setdefault('age','456')) 3 > 123 # age 键在字典中，返回字典中 age 对应的值 4 5 dic = {'name':'jay','sex':'boy','age':'123'} 6 print (dic.setdefault('qq','123456')) 7 > 123456 # qq 键不在字典中，使用指定 default 的值 123456，并将对应键值插入字典中 8 > {'age': '123', 'sex': 'boy', 'name': 'jay', 'qq': '123456'}
posted on
