Python总结(精简)

《Python总结(精简)》由会员分享，可在线阅读，更多相关《Python总结(精简)（50页珍藏版）》请在装配图网上搜索。

1、编码风格使用 4 空格缩进，而非 TAB。在小缩进（可以嵌套更深）和大缩进（更易读）之间，4 空格是一个很好的折中。TAB 引发了一些混乱，最好弃用。折行以确保其不会超过79 个字符。这有助于小显示器用户阅读，也可以让大显示器能并排显示几个代码文件。使用空行分隔函数和类，以及函数中的大块代码。可能的话，注释独占一行。使用文档字符串。把空格放到操作符两边，以及逗号后面，但是括号里侧不加空格：a=f(1,2)+g(3,4)统一函数和类命名。总是用self 作为方法的第一个参数。字符串利用三引号（）或（”）可以指示一个多行的字符串，在里面可以随便使用单引号和双引号。它也是文档字符串DocString

2、s def doc():Hi Hi pass print doc._doc_ Hi Hi 文档字符串第一行应该是关于对象用途的简介。如果文档字符串有多行，第二行应该空出来，与接下来的详细描述明确分离。转义符：whats up 等价于 whats up 表示反斜杠本身行末单独的一个表示在下一行继续，而不是新的一行：aaaaa dddd 等价于 aaaaadddd 原始字符串 r 如果我们生成一个“原始”字符串，n 序列不会被转义，而且行尾的反斜杠，源码中的换行符，都成为字符串中的一部分数据。hello=rThis is a rather long string containingn serve

3、ral lines of text much as you would do in C.print hello This is a rather long string containingn serveral lines of text much as you would do in C.hello=This is a rather long string containingn serveral lines of text much as you would do in C.print hello This is a rather long string containing server

4、al lines of text much as you would do in C 原始字符串的最后一个字符不能是“”，如果想要让字符串以单“”结尾，可以这样：print ree ee 如果是 print ree则会返回错误；如果是print ree则会返回 ee 字符串可以由+操作符连接，可以由*操作符重复。相邻的两个字符串文本自动连接在一起，它只用于两个字符串文本，不能用于字符串表达式。str.strip()str str jkl strjkl str.strip()jkl SyntaxError:invalid syntax str.strip()+jjj strjjj 字符串不可变，

5、向字符串文本的某一个索引赋值会引发错误。不过，组合文本内容生成一个新文本简单而高效。word=thank word0 t word0=f Traceback(most recent call last):File,line 1,in word0=f TypeError:str object does not support item assignment word:4+g thang 切片操作有个有用的不变性：i:s+is:等于 i。word:4+word4:thank 值被转换为字符串的两种机制：str、repr str 函数：把值转换为合理形式的字符串repr：创建一个字符串，以合法的Py

6、thon表达式的形式来表示值 print repr(hello,world!)hello,world!print str(hello,world!)hello,world!print repr(1000L)1000L print str(1000L)1000L input 与 raw_input:raw_input(e:)e:a a input(e:)e:a Traceback(most recent call last):File,line 1,in input(e:)File,line 1,in NameError:name a is not defined input(e:)e:a a

7、a=raw_input(e:)e:123 type(a)b=input(e:)e:123.01 type(b)raw_input(e:)e:1+2 1+2 input(e:)e:1+2 3 由上面的例子可以知道，两个函数均能接收字符串，区别是raw_input()直接读取控制台的输入（任何类型的输入它都可以接收），而 input()在接收字符串的时候需要加上引号，否则会引发错误。此外，在接收纯数字方面，input()具有自己的特性，并不是像raw_input()一样把所有输入都当做字符串看待。除此之外，input()会接收合法的 python 表达式 1+2 返回 int 型的 3。字符串大小

8、写变换：lower()小写upper()大写swapcase()大小写互换capitalize()首字符大写title()只有首字符大写，其余为小写。用于转换字符串为标题：thats all,folks.title()ThatS All,Folks string 模块的 capwords函数：import string string.capwords(thats all,folks)Thats All,folks 字符串在输出时候的对齐：ljust(width,fillchar)：左对齐，输出 width 个字符，不足部分用filchar 补足，默认的为空格。rjust（width，fillc

9、har）：右对齐。center(width,fillchar)：中间对齐。zfill(width)：把字符串变成 width 长，并在右对齐，不足部分用0 补足。string.capwords(whats all,forks.).ljust(20)Whats All,forks.string.capwords(whats all,forks.).rjust(20)Whats All,forks.string.capwords(whats all,forks.).center(40)Whats All,forks.string.capwords(whats all,forks.).zfill(2

10、0)000Whats All,forks.字符串中的搜索和替换及其他常用方法：find(subsrt,start,end)：返回字符串中第一个出现substr的第一个字母的标号，如果没有 subser则返回-1。start 和 end 的作用相当于在 start:end中搜索。srrrtripoopp.find(trip,-1,-4)-1 srrrtripoopp.find(trip)4 index(subsrt,start,end)：与 find 一样，只是在字符串中没有substr时，会返回一个运行时错误。rfind(subsrt,start,end)：返回字符串中最后出现substr 的

11、第一个字母的标号，如果字符串中没有substr，返回-1.rindex(subsrt,start,end)。count(subsrt,start,end)：计算 substr在字符串中出现的次数。replace(oldstr,newstr,count)：把字符串中的oldstr 替换为 newstr，count为替换的次数。strip(char)：把字符串中 前后有 char的字符全部去掉，默认去掉空格：aa bb.strip()aa bb *aaa*bbb*!*.strip(*)aaa*bbb*!当然还有 lstrip(char)、rstrip(char)：tsssssttt.lstrip(

12、t)sssssttt tsssssttt.rstrip(t)tsssss join 方法用来在队列中添加元素，但需要添加的队列元素都必须是字符串：seq=1,2,3,4,5 sep=+sep.join(seq)#连接数字列表Traceback(most recent call last):File,line 1,in sep.join(seq)TypeError:sequence item 0:expected string,int found seq=1,2,3,4,5#连接字符串列表 sep.join(seq)1+2+3+4+5 dirs=,usr,bin,eno /.join(dirs)

13、/usr/bin/eno print C:+.join(dirs)#注意 的转义问题SyntaxError:EOL while scanning string literal print C:+.join(dirs)C:usrbineno split 方法用来将字符串分割成序列：/usr/bin/env.split(/),usr,bin,env 如果不提供任何分隔符，程序会把所有空格作为分隔符：Using the default.split()Using,the,default translate 方法也是替换字符串中的的某些部分，但只处理单个字符。它的优势在于可以同时进行多个替换，有些时候比

14、replace 效率高的多。使用translate转换之前，需要完成一张转换表，通过string 模块里的 maketrans函数完成。maketrans 函数接受两个参数：两个等长的字符串，表示第一个字符串中的每个字符都用第二个字符串中的相同位置的字符替换：from string import maketrans table=maketrans(cs,kz)len(table)256#转换表是包含替换ASC 字符集中 256 个字符的替换字符的字符串 table97:123 abkdefghijklmnopqrztuvwxyz translate的第二个参数是可选的，用来指定要删除的字符：k

15、z cdds dffg.translate(table,f)kz kddz dg 字符串格式化：%操作符左侧放置一个需要格式化的字符串，这个字符串带有一个或多个嵌入的转换目标，都可以以%开始。如果需要在格式化字符串里面包括百分号，那么必须使用%。%右边放置一个或者多个对象，这些对象将会插入到左边想进行格式化字符串的一个或者多个转换目标位置上。如果要格式化实数（浮点数），可以使用 f 说明符类型，同时提供所需要的精度：一个句点再加上希望所保留的小数位数。因为格式化说明符总是一表示类型的字符结束，所以精度应该放在类型字符前面：%.3f。基本的转化说明符：1%字符：标记转换说明符的开始2转换标志：-

16、（减号）表示左对齐；+表示在转换值之前要加上正负号；“”（空白字符）表示正数之前保留空格；0 表示转换值若位数不够则用0 补充3最小字段宽度：转化后的字符串至少应该具有该值指定的宽度，如果是*，则宽度会从值元组中读出4点（.）后跟精度值：如果转换的是实数，精度值就表示出现在小数点后的位数。如果转换的是字符串，那么该数字就是表示最大字段宽度。如果是*，那么精度就会从元组中读出字符串格式化转换类型：c：字符f，F：十进制浮点数d，i：带符号的十进制整数o：不带符号的八进制n：不带符号的十进制C：单字符（接受整数或者单字符字符串）x：不带符号的十六进制（小写）X：不带符号的十六进制（大写）e：科学计

17、数法表示的浮点数（小写）E：科学计数法表示的浮点数（大写）g：如果指数大于-4 或者小于精度值则和e相同，其他情况与f 相同G：如果指数大于-4 或者小于精度值则和E 相同，其他情况与F 相同r：字符串（使用repr转换任意 Python对象）s：字符串（使用str转换任意 Python对象）一些简单的转换：Price of eggs:$%d%42 Price of eggs:$42 Hexadecimal price of eggs:%x%42 Hexadecimal price of eggs:2a from math import pi Pi:%f.%pi Pi:3.141593.Ver

18、y inexact estimate of pi:%i%pi Very inexact estimate of pi:3 Using str:%s%42L Using str:42 Using repr:%r%42L Using repr:42L 字段宽度和精度：这两个参数都是整数（首先是字段宽度，然后是精度），通过点号（.）分隔：%10f%pi 3.141593%10.2f%pi 3.14%.2f%pi 3.14%.5s%Guido can Rossum Guido 可以使用*作为字段宽度或者精度（或者两者都是用*），此时数值会从元组参数中读出：%*.*s%(10,5,Guido ddds

19、aaa)Guido 符号，对齐和 0 填充：%010.2f%pi 0000003.14%-10.2f%pi 3.14 print%5d%10+n+%5d%-10#用来对齐正负数10-10 print(%+5d%10)+n+(%+5d%-10)+10-10 标示符第一个字母只能是字母或者下划线，其他部分可以有数字，标示符对字母大小写是敏感的。比较字符串使用 cmp()函数，当两个字符串一样的时候，返回0。当 s是 t 的一部分的时候 cmp(s,t)返回-1，相反 s 长于 t 的时候返回 1。也可以对指定的长度比较 cmp(sm:n,tz,p)。模板字符串string 模块提供另外一种格式化值

20、的方法：模板字符串。substitute 这个模板方法会用传递进来的关键字参数foo 替换字符串中的$foo：from string import Template s=Template($x,glorious$x!)s.substitute(x=slurm)slurm,glorious slurm!如果替换字段是单词的一部分，那么参数名就必须使用括号括起来，从而准确指明结尾：s=Template(Its$xtastic!)s.substitute(x=slurm)Its slurmtastic!可以使用$插入美元符号。除了关键字参数外，还可以使用字典变量提供键/值对：s=Template(A

21、$thing must never$action.)d=dthing=gentleman daction=show his socks s.substitute(d)A gentleman must never show his socks.数据结构数据结构基本上就是用来存储一组相关数据的。Python有一种名为容器的数据结构，容器基本上是包含其他对象的任意对象。序列（Python有 6 种内建序列：列表、元组、字符串、Unicode 字符串、buffer 对象、xrange 对象）和映射（例如字典）是两类主要容器。序列中的每个元素都有自己的编号，而映射中的每个元素则有一个名字（也称为键）。既

22、不是序列也不是映射的容器类型，集合（set）就是个例子。列表list 是处理一组有序项目的数据结构，列表是可变的数据类型（可以修改元素），支持原处修改对象操作。列表的元素不必是同一类型。但列表和字符串是无法连接在一起的，两种相同类型的序列才能进行连接操作。索引与分片的赋值是原地进行的，是对列表的直接修改，而不是产生新的列表作为结果。列表方法：append(x)：把一个元素添加到列表的结尾extend(L)：将 L 中的所有元素添加到对象列表中insert(i,x)：在指定位置插入一个元素remove(x)：删除列表中值为 x 的第一个元素，如果没有这样的元素，就会返回一个错误。pop()从列表

23、中删除指定位置的元素，并将其返回。a.pop()默认返回（删除）最后一个元素。index(x)返回列表中第一个值为x 的元素的索引，如果没有匹配的元素就会返回一个错误。sort()对列表中的元素就地进行排序（直接修改了调用它的对象）。reverse()就地倒排列表中的元素。count(x)返回 x 在链表中出现的次数。sort 方法详解：x=4,6,2,1,7,9 x.sort()x 1,2,4,6,7,9 为了得到一个排好序的副本，且保持原列表不变，下面的方法是错误的：y=x.sort()print y None 因为 x.sort()返回的是 None，并不是一个排序好的列表，sort()

24、方法只是进行了“原地”操作。正确的做法是：x=4,6,2,1,7,9 y=x:y.sort()x 4,6,2,1,7,9 y 1,2,4,6,7,9 只是简单的把 x 赋值给 y 是没用的，因为这样就让 x、y 指向了同一个列表了：y=x y.sort()y 1,2,4,6,7,9 x 1,2,4,6,7,9 另一种获取已排序的列表副本的方法是，sorted函数：x=4,6,2,1,7,9 y=sorted(x)x 4,6,2,1,7,9 y 1,2,4,6,7,9 这个函数可以用于任何序列，却总是返回一个列表：sorted(Python)P,h,n,o,t,y sorted(2351)1,2

25、,3,5 高级排序cmp、key、reverse参数都可用于 sort()函数：1.cmp 参数：n=5,2,9,7 n.sort(cmp)n 2,5,7,9 2.key 参数：x=aaaawt,ert,j x.sort(key=len)x j,ert,aaaawt 3.reverse参数：x=4,6,2,1,7,9 x.sort(reverse=True)x 9,7,6,4,2,1 双端队列：把列表当队列使用（先进先出）：双端队列（Double-ended queue或称 deque）在需要按元素增加的顺序来移除元素时非常有用。collections 模块中的 deque类型（它为在首尾两端

26、快速插入和删除而设计）。双端队列通过可迭代对象（比如集合）创建，而且有些非常用用的方法，如下所示：from collections import deque q=deque(range(5)q.append(5)q.appendleft(6)q deque(6,0,1,2,3,4,5)q.pop()5 q.popleft()6 q.rotate(3)#右移 3 次 q deque(2,3,4,0,1)q.rotate(-1)#左移一次 q deque(3,4,0,1,2)双端队列好用的原因是它能有效地在开头（左侧）增加和弹出元素，这是在列表中无法实现的。除此之外，它还能够有效地旋转（rotat

27、e）元素（也就是将它们左移或右移，使头尾相连）。对于列表来讲，有三个内置函数非常有用：fileter,map,reduce filter(function,sequence)返 回 一 个 序 列，包 括 了 给 定 序 列 中 所 有 调 用function(item)后返回值为 True 的元素（如果可能的话，会返回相同的类型）。如果该序列是一个字符串或者元组，它返回值必定是同一类型，否侧，它总是list。例如，以下程序可以计算部分素数：def f(x):return x%2!=0 and x%3!=0 filter(f,range(2,25)5,7,11,13,17,19,23 map(

28、function,sequence)为每一个元素依次调用function(item)并将返回值组成一个链表返回。例如，以下程序计算立方：def cube(x):return x*x*x map(cube,range(1,11)1,8,27,64,125,216,343,512,729,1000 可以传入多个序列，函数也必须要有对应数量的参数，执行时会依次用各序列上对应的元素来调用函数（如果某些序列比其它的短，就用None 来代替）。如果把 None做为一个函数传入，则直接返回参数做为替代。例如：s=a,b,c,d t=a,b,c,l d=a,b,c,j map(add,s,t,d)aaa,bb

29、b,ccc,dlj map(None,s,t,d)(a,a,a),(b,b,b),(c,c,c),(d,l,j)reduce(func,sequence)返回一个单值，它是这样构造的：首先以序列的前两个元素调用函数function，再以返回值和第三个参数调用，依次执行下去。例如：def add(x,y):return x+y reduce(add,range(1,101)5050 如果序列中只有一个元素，就返回它，如果序列是空的，就抛出一个异常。列表推导式：列表推导式提供了一个创建链表的简单途径，无需使用map()，filter()以及lambda。以定义方式得到列表通常要比使用构造函数创建这

30、些列表更清晰。每一个列表推导式包括在一个for 语句之后的表达式，零或多个for 或 if 语句。返回值是由 for 或 if 子句之后的表达式得到的元素组成的列表。如果想要得到一个元组，必须要加上括号。freshfruit=banana,loganberry,passion fruit weapon.strip()for weapon in freshfruit banana,loganberry,passion fruit vec=2,4,6 3*x for x in vec 6,12,18 3*x for x in vec if x 3 12,18 3*x for x in vec if

31、 x x,x*2 for x in vec 2,4,4,16,6,36 x,x*2 for x in vec#error-parens required for tuples File,line 1,in?x,x*2 for x in vec SyntaxError:invalid syntax (x,x*2)for x in vec(2,4),(4,16),(6,36)vec1=2,4,6 vec2=4,3,-9 x*y for x in vec1 for y in vec2 8,6,-18,16,12,-36,24,18,-54 x+y for x in vec1 for y in vec

32、2 6,5,-7,8,7,-5,10,9,-3 vec1i*vec2i for i in range(len(vec1)8,12,-54 嵌套的列表推导式：考虑以下 3X3 矩阵的例子，一个列表包含了三个列表，每个一行：mat=1,2,3,4,5,6,7,8,9,现在，如果你想交换行和列，可以用列表推导式：print rowi for row in mat for i in 0,1,2 1,4,7,2,5,8,3,6,9 为了不被嵌套的列表推导式搞晕，从右往左读。接下来有一个更容易读的版本：for i in 0,1,2:for raw in mat:print rawi,print 实用中，你

33、可以利用内置函数完成复杂的流程语句。函数 zip()在这个例子中可以搞定大量的工作：zip(*mat)(1,4,7),(2,5,8),(3,6,9)删除语句：有个方法可以从列表中按给定的索引而不是值来删除一个子项：del 语句。它不同于有返回值的pop()方法。语句del 还可以从列表中删除切片或清空整个列表。例如：a=-1,1,66.25,333,333,1234.5 del a0 a 1,66.25,333,333,1234.5 del a2:4 a 1,66.25,1234.5 del a:a del 也可以删除整个变量：del a#此后再引用命名a 会引发错误（直到另一个值赋给它为止）

34、。当两个变量同时引用一个列表的时候：它们的确是同时引用了同一个列表。如果想避免出现这种情况，可以复制一个列表的副本。当在序列中做切片的时候，返回的切片总是一个副本。因此，如果你复制了整个列表的切片，将会达到一个副本：names=Mrs.Entity,Mrs.Thing n=names n is names True n=names True n0=Mr.D n Mr.D,Mrs.Thing names Mr.D,Mrs.Thing m=names:m is names False m=names True m0=Ms.P m Ms.P,Mrs.Thing names Mr.D,Mrs.Thin

35、g n Mr.D,Mrs.Thing y=x:与 y=x 不同，前者是得到完全复制x 后的另一个列表 y，后者是 x与 y 指的同一个列表。元组元组通常用在使语句或者用户定义的函数能够安全的采用一组值的时候，即被使用的元祖的值不会改变。元组也是一个序列。一个元组由数个逗号分隔的值组成，例如：t=12345,54321,hello!t0 12345 t(12345,54321,hello!)u=t,(1,2,3,4,5)#元组可以嵌套 u(12345,54321,hello!),(1,2,3,4,5)tuple 函数：以一个 序列作为参数 并把它转换为元组。tuple(1,2,3)(1,2,3)

36、tuple(abs)(a,b,s)tuple(1,2,3)(1,2,3)元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可以没有括号，不过经常括号都是必须的（如果元组是一个更大的表达式的一部分）。元组就像字符串，不可改变：不能给元组的一个独立的元素赋值（尽管你可以通过联接和切割来模拟）。还可以创建包含可变对象的元组，例如列表。一个特殊的问题是构造包含零个或一个元素的元组：为了适应这种情况，语法上有一些额外的改变。一对空的括号可以创建空元组；要创建一个单元素元组可以在值后面跟一个逗号（在括号中放入一个单值不够明确），丑陋，但是有效。例如：empty=()singleton=hello,

37、singleton(hello,)语句 t=12345,54321,hello!是元组封装（tuple packing）的一个例子：值 12345，54321和hello!被封装进元组。其逆操作可能是这样：x,y,z=t 这个调用等号右边可以是任何线性序列，称之为“序列拆封”非常恰当。“序列拆封”要求左侧的变量数目与序列的元素个数相同。要注意的是可变参数（multiple assignment）其实只是元组封装和序列拆封的一个结合。序列列表和元组都是序列。序列的两个主要特点是可以进行索引操作（从序列中抓取一个特定的项目）和切片操作（序列的一部分）以及加、乘、成员资格。len()、max()、m

38、in()也可以用于序列。list:返回整个序列的拷贝；list:-1 则得到一个反转的序列。在序列中循环时，索引位置和对应值可以使用enumerate()函数同时得到。for i,v in enumerate(tic,tac,toe):print i,v 0 tic 1 tac 2 toe 同时循环两个或更多的序列，可以使用zip()整体打包。questions=name,quest,favorite color answers=lancelot,the holy grail,blue for q,a in zip(questions,answers):print What is your 0

39、?It is 1.format(q,a)What is your name?It is lancelot.What is your quest?It is the holy grail.What is your favorite color?It is blue.需要逆向循环序列的话，先正向定位序列，然后调用reversed()函数：for i in reversed(range(1,10,2):print i,9 7 5 3 1 要按排序后的顺序循环序列的话，使用 sorted()函数，它不改动原序列，而是生成一个新的已排序的序列：basket=apple,orange,apple,pear

40、,orange,banana for f in sorted(set(basket):print f apple banana orange pear 字典只能使用不可变的对象（例如字符串）来作为字典的键，但可以把可变或者不可变的对象作为字典的值。基本上来说，你应该使用简单的对象作为键。如：d=key1:value1,key2:value2,键值对是没有顺序 的。序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。如果元组中只包含字符串和数字，它可以做为关键字，如果它直接或间接的包含了可变对象，就不能当做关键字。不能用列表做关键字，因为链

41、表可以用索引、切割或者append()和 extend()等方法改变。可以把字典看做无序的“键值”对（key:value pairs）集合，键必须是互不相同的。一对大括号创建一个空的字典：。字典的主要操作是依据键来存储和析取值。也可以用 del 来删除“键值”对（key:value）。如果你用一个已经存在的关键字存储值，以前为该关键字分配的值就会被遗忘。试图从一个不存在的键中取值会导致错误，但可以为一个不存在的键赋值。字典的 keys()方法返回由所有关键字组成的列表，该列表的顺序不定（如果你需要它有序，只能调用关键字链表的sort()方法）。可以用in 关键字检查字典中是否存在某一关键字。这

42、里有个字典用法的小例子：tel=jack:4098,sape:4139 telguido=4127 tel sape:4139,guido:4127,jack:4098 teljack 4098 del telsape telirv=4127 tel guido:4127,irv:4127,jack:4098 tel.keys()guido,irv,jack guido in tel True 创建字典：如果可以事先拼出整个字典，这种方法就很简单：d=如果需要第一次动态建立字典的一个字段，第二种比较合适：dname=wisdom dage=45 第三种关键字形式所需的代码是比较少，但必须都是字

43、符节才行：dict(name=wisdom,age=45)age:45,name:wisdom 如果需要在程序运行时把键和值逐步建成序列：dict(name,wisdom),(age,45)age:45,name:wisdom 字典方法举例：clear方法，清除字典中所有的项，这是个原地操作所以无返回值（或者说返回 None），例一：x=y=x xkey=value y key:value x=y key:value 例二：x=y=x xkey=value y key:value x.clear()y 在两个例子中，x 和 y 最初对应同一个字典，在一中，通过将x 关联到一个新的空字典来“清除

44、”它，这对于y 没有任何影响，y 仍然关联到原先的字典。这可能是所需要的行为，但是如果真的想要清空原始字典中所有的元素，必须使用 clear方法。正如例二中看到的，y 随后也被清空了。copy 方法，返回一个具有相同键-值对的新字典（这个方法实现的是浅复制（shallow copy），因为值本身就是相同的，而不是副本）：x=username:admin,machines:foo,bar,baz y=x.copy()yusername=mln ymachines.remove(bar)y username:mln,machines:foo,baz x username:admin,machine

45、s:foo,baz 可以看到，当在副本中替换值得时候，原始字典不受影响，但是，如果修改了某个值（原地修改，而不是替换），原始的字典也会改变，因为同样的值也存储在原字典中。避免这个问题的一种方法就是使用深复制（deep copy），复制其包含的所有的值。可以使用copy 模块的 deepcopy函数来完成操作。from copy import deepcopy d=dnames=Alfred,Bertrand c=d.copy()dc=deepcopy(d)dnames.append(Clirc)c names:Alfred,Bertrand,Clirc d names:Alfred,Bertr

46、and,Clirc dc names:Alfred,Bertrand fromkeys 方法，使用给定的键建立新的字典，每个键默认对应的值为None：.fromkeys(name,age)age:None,name:None 也可以直接在所有字典的类型dict 上面调用方法：dict.fromkeys(name,age)age:None,name:None 如果不想使用 None作为默认参数，也可以自己提供默认值：dict.fromkeys(name,age,unknown)age:(unknown),name:unknown get 方法，使用 get 访问一个不存在的键时，没有任何异常，而

47、得到了None值。还可以自定义默认值，替换None：d=print d.get(name)None print d.get(name,a)a print d.get(name,ann)ann d#get方法并没有创建键-值 如果键存在，get用起来就像普通的字典查询一样：dname=Dick d.get(name)Dick setdefault方法，类似 get，能够获得与给定键相关联的值，除此之外，setdefault还能在字典中不含有给定键的情况下设定相应的键-值，并相应的更新字典，默认值为 None：d=d.setdefault(name)d name:None#默认值为 None d.

48、setdefault(name,N)d name:None#说明通过 setdefault不能为已存在的键改变值 d.setdefault(tt,N)N#为不存在的键设置值 d tt:N,name:None dname=Gill#为已存在的键修改值 d tt:N,name:Gill has_key方法，可以检查字典中是否含有给出的键，d.has_key(k)相当于 k in d：d=d.has_key(name)False dname=Eric d.has_key(name)True keys 和 iterkeys 方法，keys 方法将字典中的键以列表形式返回，而iterkeys则返回针对键

49、的迭代器。d.keys()url,spam,title k=d.iterkeys()k items 和 iteritems 方法，items 方法将所有的字典项以列表方式返回，这些列表项中的每一项都来自于（键，值），但是项在返回时并没有特殊的顺序：d=title:Python,url:http,spam:0 d.items()(url,http),(spam,0),(title,Python)iteritems 方法的作用大致相同，但是会返回一个迭代器对象而不是列表：it=d.iteritems()it 使用 for 循环，关键字和对应的值可以使用iteritems()方法同时解读出来：kni

50、ghts=gallahad:the pure,robin:the brave for k,v in knights.iteritems():print k,v gallahad the pure robin the brave pop 方法，用来获得对应于给定键的值，然后将这个键-值对从字典中移除：d=title:Python,url:http,spam:0 d.pop(spam)0 d url:http,title:Python popitem 方法，类似于 list.pop，后者会弹出列表的最后一个元素。但不同的是，popitem 弹出随机的项，因为字典并没有“最后的元素”或者其他有关顺序

51、的概念。若想一个接一个的移除并处理项，这个方法就非常有效了（因为不用首先获取键的列表）：d=a:1,b:2,c:3 d.popitem()(a,1)d c:3,b:2 尽管 popitem和列表的 pop方法很类似，但字典中没有与 append等价的方法。因为字典是无序的，类似于append的方法是没有任何意义的。update方法，利用一个字典项更新另外一个字典：提供的字典中的项会被添加到旧字典中，若有相同的键则会进行覆盖：d=a:1,b:2,c:3 x=d:4 d.update(x)d a:1,c:3,b:2,d:4 values和 itervalues方法，values方法以列表的形式返回

52、字典中的值（itervalues返回值的迭代器），与返回键的列表不同的是，返回值的列表中可以包含重复的元素：d=a:1,b:2,c:3,d:2 d.values()1,3,2,2 列表中存储关键字-值对元组的话，可以从中直接构造字典。键-值对来自某个特定模式时，可以用列表推导式简单的生成关键字-值列表：dict(sape,4139),(guido,4127),(jack,4098)sape:4139,jack:4098,guido:4127 dict(x,x*2)for x in(2,4,6)#use a list comprehension 2:4,4:16,6:36 使用简单字符串作为关键

53、字的话，通常用关键字参数 更简单：dict(sape=4139,guido=4127,jack=4098)sape:4139,jack:4098,guido:4127 字典的格式化字符串：当以这种方式使用字典的时候，只要所有给出的键都能在字典中找到，就可以获得任意数量的转换说明符。这类字符串格式化在模板中非常有用（例如在HTML）：template=%(title)s%(title)s%(text)s data=title:My Home Page,text:Welcome!print template%data My Home Page My Home Page Welcome!zip 与

54、map：zip 将一个或者多个序列作为参数，然后分解组合返回列表：l1=name,age,addres l2=1,2,3,4 zip(l1,l2)(name,1),(age,2),(addres,3)dict(zip(l1,l2)age:2,name:1,addres:3 l3=10,20,30 zip(l1,l2,l3)(name,1,10),(age,2,20),(addres,3,30)map类似于 zip，但是因为程度不够的情况下，较短的序列使用 None 来补全：s1=strings s2=1234567890 map(s1,s2)Traceback(most recent call

55、 last):File,line 1,in map(s1,s2)TypeError:str object is not callable map(None,s1,s2)(s,1),(t,2),(r,3),(i,4),(n,5),(g,6),(s,7),(None,8),(None,9),(None,0)zip(s1,s2)(s,1),(t,2),(r,3),(i,4),(n,5),(g,6),(s,7)集合集合（set）是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。集合对象还支持union（联合），intersection（交），difference（差）和 sysmmetri

56、c difference（对称差集）等数学运算。可直接创建集合，（）里必须是列表：set(1,1,2,3,3)set(1,2,3)集合是由序列构建的。它们主要用于检查成员资格，因此副本是被忽略的：set(0,1,3,0,1,2,3)set(0,1,2,3)和字典一样，几何元素的顺序是随意的，因此我们不应该以元素的顺序作为依据进行编程：set(fee,fea,jj)set(fee,jj,fea)集合是可变的，所以不能用作字典中的键。另外一个问题就是集合本身只能包含不可变（可散列）值，所以也就不能包含其他集合。运算：a=set(abracadabra)b=set(alacazam)a#unique

57、 letters in a set(a,r,b,c,d)a-b#letters in a but not in b set(r,d,b)a|b#letters in either a or b set(a,c,r,d,b,m,z,l)a&b#letters in both a and b set(a,c)a b#letters in a or b but not both set(r,d,b,m,z,l)判断子集：a包含 b b.issubset(a)True a.issuperset(b)True 堆（heap）它是优先队列的一种。使用要优先队列能够以任意顺序增加对象，并且能在任意时间（可能

58、在增加对象的同时）找到（也可能是移除）最小的元素，也就是说它用于列表的min 方法有效率的多。Python中没有独立的堆类型，只有一个包含一些堆操作函数的模块，这个模块叫做 heapq（q 是 queue的缩写，即队列），包括 6 个函数：heappush（heap，x）将 x 入堆heappop（heap）将堆中最小元素弹出heapify（heap）将 heap属性强制应用到任意一个列表heapreplace（heap，x）将堆中最小元素弹出，同时将x 入堆nlargest（n，iter）返回 iter 中第 n 大的元素nsmallest（n，iter）返回 iter 中第 n 小的元素h

59、eappush函数用于堆加对的项。它只能用于通过各种堆函数建立的列表中。原因是元素的顺序很重要。from heapq import*from random import shuffle data=range(10)shuffle(data)#将列表元素顺序打乱 heap=for n in data:heappush(heap,n)heap 0,1,2,4,3,6,8,7,9,5 heappush(heap,0.5)heap 0,0.5,2,4,1,6,8,7,9,5,3 元素的顺序并不像看起来那么随意。它们虽然不是严格排序的，但是也有规则的：位于i 位置上的元素总比2*i 以及 2*i+1 位

60、置处的元素小。这是底层堆算法的基础，而这个特性称为堆属性（heap property）。heappop函数弹出最小的元素一般来说都是在索引0 处的元素。并且会确保剩余元素中最小的那个占据这个位置（保持堆属性）。一般来说，尽管弹出列表的第一个元素并不是很有效率，但是在这里不是问题，因为heappop在“幕后”会做一些精巧的移位操作：heappop(heap)0 heap 0.5,1,2,4,3,6,8,7,9,5 heappop(heap)0.5 heap 1,3,2,4,5,6,8,7,9 heapify 函数使用任意列表作为参数，并且通过尽可能少的移位操作，将其转换合法的堆（具有堆属性）。如

61、果没有用 heappush建立堆，那么在使用heappush和 heappop前应该使用这个函数：data 7,6,3,5,2,0,8,4,9,1 heapify(data)data 0,1,3,4,2,7,8,5,9,6 heapreplace函数不像其它函数那么常用，它弹出堆的最小元素，并且将新元素推入。这样做比调用heappop之后再调用 heappush更高效。heapreplace(data,0.8)0 data 0.8,1,3,4,2,7,8,5,9,6 heapreplace(data,10)0.8 data 1,2,3,4,6,7,8,5,9,10 引用当你创建一个对象并给它赋

62、一个变量的时候，这个变量仅仅引用那个对象。而不是表示这个对象本身！也就是说，变量名指向你计算机中存储那个对象的内存，这被称作名称到对象的绑定。条件、循环和其他语句为模块和函数提供别名 import math as foobar foobar.sqrt(4)2.0 from math import sqrt as ff ff(4)2.0 赋值魔法序列解包：多个赋值操作可同时进行：x,y,z=1,2,3 print x,y,z 1 2 3 也可以交换多个变量：x,y=y,x print x,y,z 2 1 3 事实上，这里所做的事情叫做序列解包（sequence unpacking）或可迭代解包将

63、多个值的序列解开，然后放到变量的序列中。更形象一点的表示出来就是：values=1,2,3 values(1,2,3)x,y,z=values x 1 当函数或者方法返回元组时，这个特性尤其有用。假设需要获取（和删除）字典中任意的键-值对，可以使用 popitem 方法，这个方法将键-值作为元组返回，那么这个元组就可以直接复制到两个变量中：d=name:Robin,girlfriend:Mraion key,value=d.popitem()key girlfriend value Mraion 链式赋值和增量赋值：将同一个值赋给多个变量，不过这里只处理一个值：x=y=somefunction

64、()等价于：y=somefunction()x=y 但不等价于：y=somefunction()x=somefunction()增量赋值：x+=1 x*=2 条件和条件语句这就是布尔变量的作用：这些值在作为布尔表达式的时候，会被解释器看做假（false）：Fales，none，0，()，除了它们，其他任何值都被解释为真：True True False False True=1 True False=0 True True+False+43 44 if,elif,else：is：同一性运算符：x is y 表示 x 和 y 是同一个对象 x=y=1,2,3 z=1,2,3 x=y True x

65、is y True x is z False y=z True x 和 z 相等却不等同，因为is 运算是判定同一性而不是相等性的。变量x 和y 都被绑定到同一个列表上，而变量z 被绑定在另一个具有相同数值和顺序的列表上。它们的值可能相等，但是却不是同一个对象。比较操作符 in 和 not in 审核值是否在一个区间之内。操作符 is 和 is not 比较两个对象是否相同；这只和诸如列表这样的可变对象有关。所有的比较操作符具有相同的优先级，低于所有的数值操作。比较操作可以传递。例如 a b=c审核是否 a小于 b 并且 b 等于 c。比较操作可以通过逻辑操作符and和 or 组合，比较的结果

66、可以用not 来取反义。这些操作符的优先级又低于比较操作符，在它们之中，not 具有最高的优先级，or 优先级最低，所以 A and not B or C 等于(A and(notB)or C。当然，括号也可以用于比较表达式。布尔运算：and，or：if number=1 if(cash price)or castomer_has_good_credit)and not_out_of_s:断言：如果需要确保程序中某个条件一定为真才能让程序正常工作的话，assert 语句就有用了，它可以在程序中置入检查点。条件后可以添加字符串，用来解释断言：a=-1 assert a=0,wrong 循环while 循环：用来在任何条件为真的情况下重复执行一个代码块：name=while not name:name=raw_input(enter:)enter:dd print Hello,%s%name Hello,dd for 循环：一般用于为一个集合（序列和其他可选迭代对象）的每个元素都执行一个代码块。可以在循环中使用序列解包：d=x:1,y:2,z:3 for key,value in d.it