Python语法

摘抄自《Python核心编程》

下划线(_)在解释器中有特别的含义, 表示最后一个表达式的值。所以上面的代码执行之后,
下划线变量会包含字符串:

>>> _
Hello World!

Python 的 print 语句,与字符串格式运算符( % )结合使用,可实现字符串替换功能,这
一点和 C 语言中的 printf()函数非常相似:

>>> print "%s is number %d!" % ("Python", 1)
Python is number 1!

%s 表示由一个字符串来替换, 而%d 表示由一个整数来替换, 另外一个很常用的就是%f, 它
表示由一个浮点数来替换。


range()函数经常和 len()函数一起用于字符串索引。 在这里我们要显示每一个元素及其
索引值:

>>> foo = 'abc'
>>> for i in range(len(foo)):
... print foo[i], '(%d)' % i
...
a (0)
b (1)
c (2)

不过, 这些循环有一个约束, 你要么循环索引, 要么循环元素。这导致了 enumerate()
函数的推出(Python2.3 新增)。 它同时做到了这两点:

>>> for i, ch in enumerate(foo):
... print ch, '(%d)' % i
...
a (0)    
b (1)
c (2)

Python 也提供了逻辑运算符:
and or not


列表解析使你可以在一行中使用一个 for 循环将所有值放到一个列表
当中:

>>> squared = [x ** 2 for x in range(4)]
>>> for i in squared:
... print i
0
1
4
9

列表解析甚至能做更复杂的事情, 比如挑选出符合要求的值放入列表:

>>> sqdEvens = [x ** 2 for x in range(8) if not x % 2]
>>>
>>> for i in sqdEvens:
... print i
0
4
16
36

如何打开文件
handle = open(file_name, access_mode = ‘r’)
file_name 变量包含我们希望打开的文件的字符串名字, access_mode 中 ‘r’ 表示读取,
‘w’ 表示写入, ‘a’ 表示添加。其它可能用到的标声还有 ‘+’ 表示读写, ‘b’表示二进制访
问. 如果未提供 access_mode , 默认值为 ‘r’。如果 open() 成功, 一个文件对象句柄会被
返回。所有后续的文件操作都必须通过此文件句柄进行。当一个文件对象返回之后, 我们就可
以访问它的一些方法, 比如 readlines() 和 close().文件对象的方法属性也必须通过句点属
性标识法访问。


要给你的代码添加错误检测及异常处理, 只要将它们封装在 try-except 语句当中。 try
之后的代码组, 就是你打算管理的代码。 except 之后的代码组, 则是你处理错误的代码。

try:
filename = raw_input('Enter file name: ')
fobj = open(filename, 'r')
for eachLine in fobj:
print eachLine, fobj.close()
except IOError, e:
print 'file open error:', e

程序员也可以通过使用 raise 语句故意引发一个异常。


反斜线 ( \ ) 继续上一行
分号 ( ; )将两个语句连接在一行中


“多元”赋值
另一种将多个变量同时赋值的方法我们称为多元赋值(multuple)。这不是官方 Python 术
语, 而是我们将 “mul-tuple”连在一起自造的。因为采用这种方式赋值时, 等号两边的对象
都是元组(我们在 2.8 节讲过元组是一种 Python 基本数据类型)。

>>> x, y, z = 1, 2, 'a string'
>>> (x, y, z) = (1, 2, 'a string')
>>> x
1
>>> y
2
>>> z
'a string'

在上面的 C 代码片段中,变量 x 和变量 y 的值被互相交换。 临时变量 tmp 用于在将 y 赋
值给 x 前先保存 x 的值。将 y 的值赋给 x 之后, 才可以将保存在 tmp 变量中的 x 的值赋给 y。
Python 的多元赋值方式可以实现无需中间变量交换两个变量的值。

# swapping variables in Python
>>> x, y = 1, 2
>>> x
1
>>> y
2
>>> x, y = y, x
>>> x
2
>>> y
1

显然, Python 在赋值之前已经事先对 x 和 y 的新值做了计算。


时刻记住一个事实,那就是所有的模块都有能力来执行代码。最高级别的 Python 语句--
也就是说, 那些没有缩进的代码行在模块被导入时就会执行, 不管是不是真的需要执行。由
于有这样一个“特性”,比较安全的写代码的方式就是除了那些真正需要执行的代码以外, 几
乎所有的功能代码都在函数当中。再说一遍, 通常只有主程序模块中有大量的顶级可执行代码,
所有其它被导入的模块只应该有很少的顶级执行代码,所有的功能代码都应该封装在函数或类
当中。

核心笔记:name 指示模块应如何被加载
由于主程序代码无论模块是被导入还是被直接执行都会运行, 我们必须知道模块如何决定
运行方向。一个应用程序可能需要导入另一个应用程序的一个模块,以便重用一些有用的代码
(否则就只能用拷贝粘贴那种非面向对象的愚蠢手段)。 这种情况下,你只想访问那些位于其
它应用程序中的代码,而不是想运行那个应用程序。因此一个问题出现了,“Python 是否有
一种方法能在运行时检测该模块是被导入还是被直接执行呢?” 答案就是……(鼓声雷
动)…..没错! name 系统变量就是正确答案。
如果模块是被导入, name 的值为模块名字
如果模块是被直接执行, name 的值为 ‘main


Python 中不但变量名无需事先声明, 而且也无需类型声明。Python 语言中,
对象的类型和内存占用都是运行时确定的。尽管代码被编译成字节码,Python 仍然是一种解释
型语言。在创建--也就是赋值时,解释器会根据语法和右侧的操作数来决定新对象的类型。
在对象创建后,一个该对象的应用会被赋值给左侧的变量。


当对象被创建并(将其引用)赋值给变量时,该对象的引用计数就被设置为 1。
当同一个对象(的引用)又被赋值给其它变量时,或作为参数传递给函数, 方法或类实例
时, 或者被赋值为一个窗口对象的成员时,该对象的一个新的引用,或者称作别名,就被创建
(则该对象的引用计数自动加 1)。


一个对象的引用计数在以下情况会减少:
z 一个本地引用离开了其作用范围。比如 foobar()(参见上一下例子)函数结束时。
z 对象的别名被显式的销毁。
del y # or del x
z 对象的一个别名被赋值给其它的对象
x = 123
z 对象被从一个窗口对象中移除
myList.remove(x)
z 窗口对象本身被销毁
del myList # or goes out-of-scope


del 语句
Del 语句会删除对象的一个引用,它的语法是:
del obj1[, obj2[,… objN]]
例如,在上例中执行 del y 会产生两个结果:
z 从现在的名字空间中删除 y
z x 的引用计数减一
引申一步, 执行 del x 会删除该对象的最后一个引用, 也就是该对象的引用计数会减为
0, 这会导致该对象从此“无法访问”或“无法抵达”。 从此刻起, 该对象就成为垃圾回收
机制的回收对象。 注意任何追踪或调试程序会给一个对象增加一个额外的引用, 这会推迟该
对象被回收的时间


类似 os.linesep 这样的名字需要解释器做两次查询:(1)查找 os 以确认它是一个模块,
(2)在这个模块中查找 linesep 变量。因为模块也是全局变量, 我们多消耗了系统资源。如
果你在一个函数中类似这样频繁使用一个属性,我们建议你为该属性取一个本地变量别名。 变
量查找速度将会快很多--在查找全局变量之前, 总是先查找本地变量。 这也是一个让你的
程序跑的更快的技巧: 将经常用到的模块属性替换为一个本地引用。代码跑得更快,而也不用
老是敲那么长的变量名了。


核心笔记:布尔值
所有标准对象均可用于布尔测试,同类型的对象之间可以比较大小。每个对象天生具有布
尔 True 或 False 值。空对象、 值为零的任何数字或者 Null 对象 None 的布尔值都是 False。
下列对象的布尔值是 False。
None
False (布尔类型)
所有的值为零的数:
0 (整型)
(浮点型)
0L (长整型)
0.0+0.0j (复数)
“” (空字符串)
[] (空列表)
() (空元组)
{} (空字典)


不同于很多其它语言,多个比较操作可以在同一行上进行,求值顺序为从左到右。

>>> 3 < 4 < 7 # same as ( 3 < 4 ) and ( 4 < 7 )
True
>>> 4 > 3 == 3 # same as ( 4 > 3 ) and ( 3 == 3 )
True
>>> 4 < 3 < 5 != 2 < 7
False

Python 提供了 is 和 is not
运算符来测试两个变量是否指向同一个对象。象下面这样执行一个测试
a is b
这个表达式等价于下面的表达式
id(a) == id(b)


a=1
b=1
print(id(a))
print(id(b))
a=1.0
b=1.0
print(id(a))
print(id(b))
a='123'
b='123'
print(id(a))
print(id(b))

out:
1395087088
1395087088
46350672
46350672
41148640
41148640

无论值是什么,只要有整型、浮点型、字符串出现,就会被python缓存起来,上面的a和b,实际上都是对同一个对象的引用。


内建函数 str() 和 repr() 或反引号运算符(``) 可以方便的以字符串的方式获取对象的
内容、类型、数值属性等信息。str()函数得到的字符串可读性好, 而 repr()函数得到的字符
串通常可以用来重新获得该对象, 通常情况下 obj == eval(repr(obj)) 这个等式是成立的。
这两个函数接受一个对象做为其参数, 返回适当的字符串。在下面的例子里, 我们会随机取
一些 Python 对象来查看他们的字符串表示。

>>> str(4.53-2j)
'(4.53-2j)'
>>>
>>> str(1)
'1'
>>>
>>> str(2e10)
'20000000000.0'
>>>
>>> str([0, 5, 9, 9])
'[0, 5, 9, 9]'
>>>
>>> repr([0, 5, 9, 9])
'[0, 5, 9, 9]' 
>>> `[0, 5, 9, 9]`
'[0, 5, 9, 9]'

尽管 str(),repr()和运算在特性和功能方面都非常相似, 事实上 repr() 和 做的
是完全一样的事情,它们返回的是一个对象的“官方”字符串表示, 也就是说绝大多数情况下
可以通过求值运算(使用 eval()内建函数)重新得到该对象,但 str()则有所不同。str() 致力
于生成一个对象的可读性好的字符串表示,它的返回结果通常无法用于 eval()求值, 但很适
合用于 print 语句输出。需要再次提醒一下的是, 并不是所有 repr()返回的字符串都能够用
eval()内建函数得到原来的对象:

>>> eval(`type(type))`)
File "<stdin>", line 1
eval(`type(type))`)
^
SyntaxError: invalid syntaxEdit By Vheavens
Edit By Vheavens
也就是说 repr() 输出对 Python 比较友好, 而 str()的输出对人比较友好。虽然如此,

很多情况下这三者的输出仍然都是完全一样的。


对象包含三个部分:id、值、类型


存储模型
分类 Python 类型
标量/原子类型 数值(所有的数值类型),字符串(全部是文字)
容器类型 列表、元组、字典
(一个能保存单个字面对象的类型
我们称它为原子或标量存储,那些可容纳多个对象的类型,我们称之为容器存储。(容器对象有
时会在文档中被称为复合对象, 不过这些对象并不仅仅指类型, 还包括类似类实例这样的对象)
容器类型又带来一个新问题,那就是它是否可以容纳不同类型的对象。所有的 Python 容器对
象都能够容纳不同类型的对象。字符串看上去像一个容器类型,因为它“包含”字符(并且经常多于一个字符),不过由
于 Python 并没有字符类型(参见章节 4.8),所以字符串是一个自我包含的文字类型。)

分类 Python 类型
可变类型 列表, 字典
不可变类型 数字、字符串、元组
(不可变意味着一旦对象被建立,其中的值就再也不能被更改)

>>> x = 'Python numbers and strings'
>>> print id(x)
16191392
>>> x = 'are immutable?!? What gives?'
>>> print id(x)
16191232
>>> i = 0
>>> print id(i)
7749552
>>> i = i + 1
>>> print id(i)Edit By Vheavens
7749600

访问模型
分类 Python 类型
直接访问 数字
顺序访问 字符串、列表、元组
映射访问 字典

(对非容器类型可以直接访问。所有的数值类型都归到这一类。
序列类型是指容器内的元素按从 0 开始的索引顺序访问。一次可以访问一个元素或多个元
素, 也就是大家所了解的切片(slice)。 字符串, 列表和元组都归到这一类。 我们前面提到过,
Python 不支持字符类型,因此,虽然字符串是简单文字类型,因为它有能力按照顺序访问子字
符串,所以也将它归到序列类型。
映射类型类似序列的索引属性,不过它的索引并不使用顺序的数字偏移量取值, 它的元素
无序存放, 通过一个唯一的 key 来访问, 这就是映射类型, 它容纳的是哈希键-值对的集合。 )


在 Python 中, 一切都是指针。因为是无法通过任何方式直接访问内存中的值,只能间接访问。


python中没有如下类型:
byte
char
指针
int vs short vs long
Python 的普通整数相当于标准整数类型,不需要类似 C 语言中的 int, short, long 这三
种整数类型。事实上 Python 的整数实现等同于 C 语言的长整数。 由于 Python 的整型与长整型
密切融合, 用户几乎不需要担心什么。 你仅需要使用一种类型, 就是 Python 的整型。即便
数值超出整型的表达范围, 比如两个很大的数相乘, Python 会自动的返回一个长整数给你而
不会报错
float VS double
C 语言有单精度和双精度两种浮点类型。 Python 的浮点类型实际上是 C 语言的双精度浮
点类型。 Python 认为同时支持两种浮点类型的好处与支持两种浮点类型带来的开销不成比例,
所以 Python 决定不支持单精度浮点数。对那些宁愿放弃更大的取值范围而需要更高精确度的
用户来说, Python 还有一种十进制浮点数类型 Decimal, 不过你必须导入 decimal 模块才可
以使用它。浮点数总是不精确的。Decimals 则拥有任意的精度。在处理金钱这类确定的值时,
Decimal 类型就很有用。 在处理重量,长度或其它度量单位的场合, float 足够用了。


幂运算操作符和一元操作符之间的优先级关系比较特别: 幂运算操作符比其左侧操作数
的一元操作符优先级低,比
起右侧操作数的一元操作符的优先级高


divmod()内建函数把除法和取余运算结合起来, 返回一个包含商和余数的元组。对整数来
说 , 它 的 返 回 值 就 是 地 板 除 和 取 余 操 作 的 结 果 。 对 浮 点 数 来 说 , 返 回 的 商 部 分 是
math.floor(num1/num2),对复数来说, 商部分是 ath.floor((num1/num2).real)。

>>> divmod(10,3)
(3, 1)
>>> divmod(3,10)Edit By Vheavens
Edit By Vheavens
(0, 3)
>>> divmod(10,2.5)
(4.0, 0.0)
>>> divmod(2.5,10)
(0.0, 2.5)
>>> divmod(2+1j, 0.5-1j)
(0j, (2+1j))

内建函数 round()用于对浮点数进行四舍五入运算。它有一个可选的小数位数参数。如果
不提供小数位参数, 它返回与第一个参数最接近的整数(但仍然是浮点类型)。第二个参数告
诉 round 函数将结果精确到小数点后指定位数。

>>> round(3)
3.0
>>> round(3.45)
3.0
>>> round(3.4999999)
3.0
>>> round(3.4999999, 1)
3.5

函数 coerce(),尽管从技术上讲它是一个数据类型转换函数,不过它的行为更像一个运算
符,因此我将它放到了这一小节。在 5.5.1 小节,我们讨论了 Python 如何执行数值类型转换。
函数 coerce()为程序员提供了不依赖 Python 解释器, 而是自定义两个数值类型转换的方法。
对一种新创建的数值类型来说, 这个特性非常有用。函数 coerce()仅回一个包含类型转换完
毕的两个数值元素的元组。下面是几个例子:

>>> coerce(1, 2)
(1, 2)
>>>
>>> coerce(1.3, 134L)
(1.3, 134.0)
>>>
>>> coerce(1, 134L)
(1L, 134L)
>>>
>>> coerce(1j, 134L)
(1j, (134+0j))
>>>
>>> coerce(1.23-41j, 134L)
((1.23-41j), (134+0j))

除此之
外, Python还提供了两个内建函数来返回字符串表示的 8进制和 16进制整数。它们分别是 oct()
和 hex()。它们都接受一个整数(任意进制的)对象,并返回一个对应值的字符串对象。下面
是几个示例:

>>> hex(255)
'0xff'Edit By Vheavens
Edit By Vheavens
>>> hex(23094823l)
'0x1606627L'
>>> hex(65535*2)
'0x1fffe'
>>>
>>> oct(255)
'0377'
>>> oct(23094823l)
'0130063047L'
>>> oct(65535*2)
'0377776'

Python 也提供了 ASCII(美国标准信息交换码)码与其序列值之间的转换函数。每个字符
对应一个唯一的整数(0-255)。对所有使用 ASCII 表的计算机来说, 这个数值是不变的。这
保证了不同系统之间程序行为的一致性。 函数 chr()接受一个单字节整数值, 返回一个字符串,
其值为对应的字符。函数 ord()则相反,它接受一个字符,返回其对应的整数值。

>>> ord('a')
97
>>> ord('A')
65
>>> ord('0')
48
>>> chr(97)
'a'
>>> chr(65L)
'A'
>>> chr(48)
'0

没有nonzero()方法的对象的默认值是 True。
对于值为零的任何数字或空集(空列表、空元组和空字典等)在 Python 中的布尔值都
是 False。
nonzero()

>>> class C: pass
>>> c = C()
>>>
>>> bool(c) True
>>> bool(C) True

重载 nonzero() 使它返回 False

>>> class C:
... def __nonzero__(self):
... return False
...
>>> c = C()
>>> bool(c) False
>>> bool(C) True

序列操作符 作用
seq[ind] 获得下标为 ind 的元素
seq[ind1:ind2] 获得下标从 ind1 到 ind2 间的元素集合
seq * expr 序列重复 expr 次
seq1 + seq2 连接序列 seq1 和 seq2
obj in seq 判断 obj 元素是否包含在 seq 中
obj not in seq 判断 obj 元素是否不包含在 seq 中

对列表来说,我们推荐读者用列表类型的extend()方法来把两个或者多个列表对象合并,因为它对原来的列表进行修改,不产生新的列表,因此也没有返回值。

当你需要需要一个序列的多份拷贝时,重复操作符非常有用,它的语法如下:
sequence * copies_int


切片时,::-1表示翻转,::2表示隔一个数取一个,::-2则表示翻转并隔一个取一个。

a=[1,2,3,4,5,6]
a[::-2]

[6, 4, 2]

a[-1]表示从后面数第一个数,以此类推。

>>> s = 'abcde'
>>> i = -1
>>> for i in range(-1, -len(s), -1):
... print s[:i]
... abcd
abc
ab
a

[:None]表示取全部
a[:None]

[1, 2, 3, 4, 5, 6]

list(iter) 把可迭代对象转换为列表
str(obj) 把 obj 对象转换成字符串(对象的字符串表示法)
unicode(obj) 把对象转换成 Unicode 字符串(使用默认编码)
basestring() 抽象工厂函数,其作用仅仅是为 str 和 unicode 函数提供父类,所以不能被
实例化,也不能被调用(详见第 6.2 节)
tuple(iter) 把一个可迭代对象转换成一个元组对象


a=[6,5,4,3,2,1]
b=enumerate(a)            #输入为任何可迭代对象,返回一个迭代器
tuple(b)

((0, 6), (1, 5), (2, 4), (3, 3), (4, 2), (5, 1))

len(seq) 返回 seq 的长度


max(arg0,arg1…,key=None)b 返回 iter 或(arg0,arg1,…)中的最大值,如果指定了 key,
这个 key 必须是一个可以传给 sort()方法的,用于比较的回
调函数.


min(iter, key=None) or
min(arg0, arg1…. key=None)

a=[6,5,4,3,2,1]
b=reversed(a)        #返回逆序的a的迭代器,注意输入只能为序列
tuple(b)

(1, 2, 3, 4, 5, 6)

sorted(iter,
func=None,
key=None,
reverse=False)c 接受一个可迭代对象作为参数,返回一个有序的列表;可选参数
func,key 和 reverse 的含义跟 list.sort()内建函数的参数含义一
样.

def s(x):
    return x*-1
c=range(10)
list(c)
v=sorted(c,reverse=False)
print(v)
sorted(c,reverse=False,key=s)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

zip() 返回一个列表,其第一个元素是 it0,it1,…这些元素的第
一个元素组成的一个元组,第二个…,类推.

a=zip([1,2,3],[4,5,6],[7,8,9])
print(list(a))

[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

跟数字类型一样,字符串类型也是不可变的


>>> str1 = 'abc'
>>> str2 = 'lmn'
>>> str3 = 'xyz'
>>> str1 < str2
True
>>> str2 != str3
True
>>> str1 < str3 and str2 == 'xyz'
False

在做比较操作的时候,字符串是按照 ASCII 值的大小来比较的


>>> 'Ni!' * 3
'Ni!Ni!Ni!'

Unicode 通过使用一个或多个字节来表示一个字符
ASCLL则使用一个字节来代表一个字符

Python 里面处理 Unicode 字符串跟处理 ASCII 字符串没什么两样.Python 把硬编码的字符串叫做字面上的字符串,默认所有字面上的字符串都用 ASCII 编码, 可以通过在字符串前面加一个’u’前缀的方式声明 Unicode 字符串,这个’u’前缀告诉 Python 后面的字符串要编码成 Unicode字符串

>>> "Hello World" # ASCII string
>>> u"Hello World" # Unicode string

codec 是 COder/DECoder 的首字母组合.它定义了文本跟二进制值的转换方式,跟 ASCII 那
种用一个字节把字符转换成数字的方式不同,Unicode 用的是多字节.这导致了 Unicode 支持多
种 不 同 的 编 码 方 式 . 比 如 说 codec 支 持 的 四 种 耳 熟 能 详 的 编 码 方 式 是 :ASCII,ISO
8859-1/Latin-1,UTF-8 和 UTF-16.

Python 字符串不是通过 NUL 或者’\0’来结束的


[123, 'abc', 'float replacer', ['inner', 'list'], (7-9j)]
>>> del aList[1]
>>> aList
[123, 'float replacer', ['inner', 'list'], (7-9j)]

a=[1,2,3]
a*2
[1, 2, 3, 1, 2, 3]

[x*2 for x in range(10)]

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

[x*2 for x in range(10) if x%2==0]

[0, 4, 8, 12, 16]

dir()查看类所包含的函数


List Method Operation
list.append(obj) 向列表中添加一个对象 obj
list.count(obj) 返回一个对象 obj 在列表中出现的次数
list.extend(seq)a 把序列 seq 的内容添加到列表中
list.index(obj, i=0,
j=len(list)) 返回 list[k] == obj 的 k 值,并且 k 的范围在 i<=k<j;否则
引发 ValueError 异常.
list.insert(index, obj) 在索引量为 index 的位置插入对象 obj.
list.pop(index=-1)a 删除并返回指定位置的对象,默认是最后一个对象
list.remove(obj) 从列表中删除对象 obj
list.reverse() 原地翻转列表
list.sort(func=None,key=None,reverse=False)b 以指定的方式排序列表中的成员,如果 func 和 key 参数指定,则按照指定的方式比较各个元素,如果 reverse 标志被置为
True,则列表以反序排列.


那些可以改变对象值的可变对象的方法是没有返回值的!


元组可以作为字典的key,而列表不行。
虽然元组对象本身是不可变的,但这并不意味着元组包含的可变对象也不可变了。
所有的多对象的,逗号分隔的,没有明确用符号定义的,比如说像用方括号表示列表和用圆括号表示元组一样,等等这些集合默认的类型都是元组

>>> x, y = 1, 2
>>> x, y
(1, 2)

def foo1():
    return obj1, obj2, obj3 #返回的是元组

(‘xyz’,)表示一个单元素元组,(’xyz’)表示的是字符串‘xyz’


方法 Keys() 或 values() 返回
一个列表,该列表是可排序的。 你还可以用 items()方法得到包含键、值对的元组的列表来排序。
由于字典本身是哈希的,所以是无序的。


>>> ddict = {}.fromkeys(('x', 'y'), -1)
>>> ddict
{'y': -1, 'x': -1}

>>> 'server' in dict2 # 或 dict2.has_key('server')
False
>>> 'name' in dict # 或 dict2.has_key('name')
True
>>> dict2['name']
'earth'

字典的键必须是不可修改的类型。


>>> dict(zip(('x', 'y'), (1, 2)))
{'y': 2, 'x': 1}
>>> dict([['x', 1], ['y', 2]])
{'y': 2, 'x': 1}
>>> dict([('xy'[i-1], i) for i in range(1,3)])
{'y': 2, 'x': 1}

如果输入参数是(另)一个映射对象,比如,一个字典对象,对其调用 dict()会从存在的字典里
复制内容来生成新的字典。新生成的字典是原来字典对象的浅复制版本, 它与用字典的内建方法
copy() 生成的字典对象是一样的。但是从已存在的字典生成新的字典速度比用 copy()方法慢,我们
推荐使用 copy()。

>>> dict(x=1, y=2)
{'y': 2, 'x': 1}

>>> dict2= {'host':'earth', 'port':80}
>>> dict3= {'host':'venus', 'server':'http'}
>>> dict2.update(dict3)
>>> dict2
{'server': 'http', 'port': 80, 'host': 'venus'}

>>> myDict = {'host': 'earth', 'port': 80}
>>> myDict.keys()
['host', 'port']
>>> myDict.items()
[('host', 'earth'), ('port', 80)]
>>> myDict.setdefault('port', 8080)
>>> myDict.setdefault('prot', 'tcp')
'tcp'
>>> myDict.items()
[('prot', 'tcp'), ('host', 'earth'), ('port', 80)]

>>> s = set('cheeseshop')
>>> s
set(['c', 'e', 'h', 'o', 'p', 's'])
>>> t = frozenset('bookshop')
>>> t
frozenset(['b', 'h', 'k', 'o', 'p', 's'])
>>> type(s)
<type 'set'>
>>> type(t)
<type 'frozenset'>
>>> len(s)
6
>>> len(s) == len(t) 
True
>>> s == t
False

frozenset是不可变集合,set是可变集合。


如果左右两个操作数的类型相同, 既都是可变集合或不可变集合, 则所产生的结果类型是相同
的,但如果左右两个操作数的类型不相同(左操作数是 set,右操作数是 frozenset,或相反情况),Edit By Vheavens
Edit By Vheavens
则所产生的结果类型与左操作数的类型相同