Python 常用函数.docx
《Python 常用函数.docx》由会员分享，可在线阅读，更多相关《Python 常用函数.docx（15页珍藏版）》请在冰豆网上搜索。
Python常用函数
Python函数
2016年4月14日
22:
07
1、join（）函数
以下实例展示了join（）的使用方法：
#!
/usr/bin/pythonstr="-";
seq=（"a","b","c"）;#字符串序列
printstr.join（seq）;
以上实例输出结果如下：
a-b-c
2、str.zfill（width）
将字符串str前面补0使得字符串长度为width
3、lambda函数（匿名函数）
a.lambda表达式返回可调用的函数对象.但不会把这个函数对象赋给一个标识符,而def则会把函数对象赋值给一个变量.
b.lambda它只是一个表达式,而def是一个语句
c.定义一些抽象的，不会别的地方再复用的函数
d.lambda语句中,冒号前是参数,可以有多个,用逗号隔开,冒号右边的返回值
定义了一个lambda表达式，求三个数的和。
用lambda表达式求n的阶乘。
这里也可以把def直接写成lambda形式。
如下
lambda函数可以很好和python中内建filter（）,map（）,reduce（）函数的应用程序结合起来,因为它们都带了一个可执行的函数对象.
4、filter（functionorNone,sequence）->list,tuple,orstring
给定一个'过滤函数'和一个对象的序列,每个序列元素都通过这个过滤器进行筛选,保留函数返回为真的对象.filter函数为已知的序列的每个元素调用给定布尔函数.每个filter返回的非零（true）值元素添加到一个列表中.
1
2
3
4
5
6
7
#!
/usr/bin/python2.5
fromrandomimportrandint
allNums=[]
foreachNuminrange（10）:
allNums.append（randint（1,100））
printfilter（lambdax:
x%2,allNums）#使用filter（）来移除所有偶数
1
2
root@10.1.6.200:
~#./getOdd.py
[89,45,41,29,5,29,85]
5、map（...）
map（function,sequence[,sequence,...]）->list
map（）内建函数与filter（）相似,因为它也能通过函数来处理序列,但map（）将函数调用'映射'到每个序列的元素上,并返回一个含有所有返回值的列表。
例如,映射函数是给每个进入的数字加10,并且将这个函数和一个数字的列表传给map（）.
1
2
>>>map（lambdax:
x+10,[0,1,2,3,4,5,6,7,8,9]）
[10,11,12,13,14,15,16,17,18,19]
>>>defadd100（x）:
…
returnx+100...
>>>hh=[11,22,33]
>>>map（add100,hh）
[111,122,133]
6、reduce（...）reduce（function,sequence[,initial]）->value
它通过取出序列的头两个元素.将他们传入二元函数来获得一个单一的值来实现.然后又用这个值和序列的下一个元素来获得又一个值,然后继续直到整个序列的内容都遍历完毕以后最后的值会被计算出来为止.
reduce（func,[1,2,3]）等同于func（func（1,2）,3）
例如:
计算从1加到10的和
1
2
>>>print'thetotalis:
',reduce（（lambdax,y:
x+y）,range（1,11））
thetotalis:
55
源文档<
源文档<
7、multiply（x,y）返回x乘以y
np.multiply（2.0,4.0）=8.0
numpy.sign（x[,out]）x可以是单个参数也可以是数组
Returnsanelement-wiseindicationofthesignofanumber.
Thesignfunctionreturns-1ifx<0,0ifx==0,1ifx>0.
Parameters:
x:
array_like
Inputvalues.
Returns:
y:
ndarray
Thesignofx.
Examples
>>>np.sign（[-5.,4.5]）
array（[-1.,1.]）
>>>np.sign（0）
0
8、urlencode（）函数原理就是首先把中文字符转换为十六进制，然后在每个字符前面加一个标识符%。
urldecode（）函数与urlencode（）函数原理相反，用于解码已编码的URL字符串，其原理就是把十六进制字符串转换为中文字符
Urlencode（）函数的参数为字典
Urllib.quote（）函数的参数为字符串
9、sys和操作系统相关的调用，系统相关的信息模块importsys
sys.argv是一个list,包含所有的命令行参数.
sys.stdoutsys.stdinsys.stderr分别表示标准输入输出,错误输出的文件对象.
sys.stdin.readline（）从标准输入读一行sys.stdout.write（"a"）屏幕输出a
sys.exit（exit_code）退出程序
sys.modules是一个dictionary，表示系统中所有可用的module
sys.platform得到运行的操作系统环境
sys.path是一个list,指明所有查找module，package的路径.
源文档<
10、文件操作
1、打开文件
f=open（"filename","r"）r只读w写rw读写rb读二进制wb写二进制w+写追加
2、读写文件
f.write（"a"）f.write（str）写一字符串f.writeline（）f.readlines（）与下read类同
f.read（）全读出来f.read（size）表示从文件中读取size个字符
f.readline（）读一行,到文件结尾,返回空串.f.readlines（）读取全部，返回一个list.list每个元素表示一行，包含"\n"\
f.tell（）返回当前文件读取位置
f.seek（off,where）定位文件读写位置.off表示偏移量，正数向文件尾移动，负数表示向开头移动。
where为0表示从开始算起,1表示从当前位置算,2表示从结尾算.
f.flush（）刷新缓存
3、关闭文件 ：
f.close（）
源文档<
11、Itertools.groupby（）：
把迭代器中相邻的重复元素挑出来放在一起：
>>>forkey,groupinitertools.groupby（'AAABBBCCAAA'）:
...print（key,list（group））
...
A['A','A','A']
B['B','B','B']
C['C','C']
A['A','A','A']
实际上挑选规则是通过函数完成的，只要作用于函数的两个元素返回的值相等，这两个元素就被认为是在一组的，而函数返回值作为组的key。
如果我们要忽略大小写分组，就可以让元素'A'和'a'都返回相同的key：
>>>forkey,groupinitertools.groupby（'AaaBBbcCAAa',lambdac:
c.upper（））:
...print（key,list（group））
...
A['A','a','a']
B['B','B','b']
C['c','C']
A['A','A','a']
∙groupby（things,itemgetter（0））以第0列为排序目标
∙groupby（things,itemgetter
（1））以第1列为排序目标
∙groupby（things）以整行为排序目标
fromitertoolsimportgroupby
fromoperatorimportitemgetter
things=[（'2009-09-02',11）,
（'2009-09-02',3）,
（'2009-09-03',10）,
（'2009-09-03',4）,
（'2009-09-03',22）,
（'2009-09-06',33）]
sss=groupby（things,itemgetter（0））
forkey,itemsinsss:
printkey
forsubiteminitems:
printsubitem
print'-'*20
结果
1
2
3
4
5
6
7
8
9
10
11
12
13
>>>
2009-09-02
（'2009-09-02', 11）
（'2009-09-02', 3）
--------------------
2009-09-03
（'2009-09-03', 10）
（'2009-09-03', 4）
（'2009-09-03', 22）
--------------------
2009-09-06
（'2009-09-06', 33）
--------------------
源文档<
源文档<
12、itemgetter（dis）返回迭代器的第dis维的数据，dis为序号
fromoperatorimportitemgetter
a=[1,2,3]
>>>b=operator.itemgetter
（1） //定义函数b，获取对象的第1个域的值
>>>b（a）
2
>>>b=operator.itemgetter（1,0） //定义函数b，获取对象的第1个域和第0个的值
>>>b（a）
（2,1）
源文档<
13、format（）格式化输出函数
Print（"{0}\t{1}\n".format（qq,cnt））其中"{0}\t{1}\n"是格式化字符串，{0}，{1}是占位符
1#使用str.format（）函数
2
3#使用'{}'占位符
4print（'I\'m{},{}'.format（'Hongten','Welcometomyspace!
'））
5
6print（'#'*40）
7
8#也可以使用'{0}','{1}'形式的占位符
9print（'{0},I\'m{1},myE-mailis{2}'.format（'Hello','Hongten','hongtenzone@'））
10#可以改变占位符的位置
11print（'{1},I\'m{0},myE-mailis{2}'.format（'Hongten','Hello','hongtenzone@'））
12
13print（'#'*40）
14
15#使用'{name}'形式的占位符
16print（'Hi,{name},{message}'.format（name='Tom',message='Howoldareyou?
'））
17
18print（'#'*40）
19
20#混合使用'{0}','{name}'形式
21print（'{0},I\'m{1},{message}'.format（'Hello','Hongten',message='Thisisatestmessage!
'））
22
23print（'#'*40）
24
25#下面进行格式控制
26importmath
27print（'ThevalueofPIisapproximately{}.'.format（math.pi））
28print（'ThevalueofPIisapproximately{!
r}.'.format（math.pi））
29print（'ThevalueofPIisapproximately{0:
.3f}.'.format（math.pi））
30
31
32table={'Sjoerd':
4127,'Jack':
4098,'Dcab':
7678}
33forname,phoneintable.items（）:
34print（'{0:
10}==>{1:
10d}'.format（name,phone））
35
36
37table={'Sjoerd':
4127,'Jack':
4098,'Dcab':
8637678}
38print（'Jack:
{0[Jack]:
d};Sjoerd:
{0[Sjoerd]:
d};''Dcab:
{0[Dcab]:
d}'.format（table））
14、maketrans（）方法语法：
fromstringimportmaketrans#引用maketrans函数。
str.maketrans（intab,outtab）
参数
∙intab--字符串中要替代的字符组成的字符串。
∙outtab--相应的映射字符的字符串。
15、translate（）方法
根据参数table给出的表（包含256个字符）转换字符串的字符,要过滤掉的字符放到del参数中。
str.translate（table[,deletechars]）;
∙table--翻译表，翻译表是通过maketrans方法转换而来。
∙deletechars--字符串中要过滤的字符列表。
以下实例展示了translate（）函数的使用方法：
#!
/usr/bin/python
fromstringimportmaketrans#引用maketrans函数。
intab="aeiou"
outtab="12345"
trantab=maketrans（intab,outtab）
str="thisisstringexample....wow!
!
!
";
printstr.translate（trantab）;
以上实例输出结果如下：
th3s3sstr3ng2x1mpl2....w4w!
!
!
以上实例去除字符串中的'x'和'm'字符：
#!
/usr/bin/python
fromstringimportmaketrans#Requiredtocallmaketransfunction.
intab="aeiou"
outtab="12345"
trantab=maketrans（intab,outtab）
str="thisisstringexample....wow!
!
!
";
printstr.translate（trantab,'xm'）;
以上实例输出结果：
th3s3sstr3ng21pl2....w4w!
!
!
源文档<
16、迭代器iterator
1）for循环可以用于Python中的任何类型，包括列表、元祖等等。
实际上，for循环可用于任何“可迭代对象”，这其实就是迭代器（实现了迭代器协议的对象）。
任何这类的对象在Python中都可以用for循环或其他遍历工具迭代，迭代工具内部会在每次迭代时调用next方法，并且捕捉StopIteration异常来确定何时离开。
使用迭代器一个显而易见的好处就是：
每次只从对象中读取一条数据，不会造成内存的过大开销。
比如要逐行读取一个文件的内容，利用readlines（）方法，我们可以这么写：
1
2
forlineinopen（"test.txt"）.readlines（）:
printline
这样虽然可以工作，但不是最好的方法。
因为他实际上是把文件一次加载到内存中，然后逐行打印。
当文件很大时，这个方法的内存开销就很大了。
利用file的迭代器，我们可以这样写：
1
2
forlineinopen（"test.txt"）:
#usefileiterators
printline
这是最简单也是运行速度最快的写法，他并没显式的读取文件，而是利用迭代器每次读取下一行。
17、生产器constructor
包含yield语句的函数会被特地编译成生成器。
当函数被调用时，他们返回一个生成器对象，这个对象支持迭代器接口。
不像一般的函数会生成值后退出，生成器函数在生成值后会自动挂起并暂停他们的执行和状态，他的本地变量将保存状态信息，这些信息在函数恢复时将再度有效【不像return生成值后函数会退出，包含yield语句的函数会继续执行后续代码】
来看一个yield的例子，用生成器生成一个Fibonacci数列：
1
2
3
4
5
6
7
8
9
10
deffab（max）:
a,b=0,1
whileayielda#返回a值，函数不退出
a,b=b,a+b
>>>foriinfab（20）:
...printi,",",
...
0,1,1,2,3,5,8,13,
源文档<
2，内积：
np.dot（a,b）就可以来计算a，b的内积，同样的np.inner（a,b）也可以，但是它要求最后一维度是要相同的,np.outer（a,b）则是将数组 展平为一维数组 再进行计算。
3，求和，平均值，方差：
比较简单，分别是np.sum（）,np.mean（）,np.var（）,np.std（）（这个是标准差），关键是在加入axis参数以后要很好的区分；看下面的例子应该就比较清楚了：
4，最值和排序：
最值有np.max（）,np.min（）他们都有axis和out（输出）参数,而通过np.argmax（）,np.argmin（）可以得到取得最大或最小值时的 下标。
排序通过np.sort（）,而np.argsort（）得到的是排序后的数据原来位置的下标。
源文档<
18、Zip（）
zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表。
1.示例1：
x=[1,2,3]
y=[4,5,6]
z=[7,8,9]
xyz=zip（x,y,z）
printxyz
运行的结果是：
[（1,4,7）,（2,5,8）,（3,6,9）]
2.示例2：
x=[1,2,3]
y=[4,5,6,7]
xy=zip（x,y）
printxy
运行的结果是：
[（1,4）,（2,5）,（3,6）]
5.示例5：
x=[1,2,3]
y=[4,5,6]
z=[7,8,9]
xyz=zip（x,y,z）
u=zip（*xyz）
printu
运行的结果是：
[（1,2,3）,（4,5,6）,（7,8,9）]
一般认为这是一个unzip的过程，它的运行机制是这样的：
在运行zip（*xyz）之前，xyz的值是：
[（1,4,7）,（2,5,8）,（3,6,9）]
那么，zip（*xyz）等价于zip（（1,4,7）,（2,5,8）,（3,6,9））
所以，运行结果是：
[（1,2,3）,（4,5,6）,（7,8,9）]
源文档<
19、collections.defaultdict（）
defaultdict（function_factory）构建的是一个类似dictionary的对象，其中指定了values的类型，是function_factory的类实例，而且具有默认值。
collections.defaultdict（list）使用起来效果和运用dict.setdefault（list）比较相似
源文档<
20、uniform（）函数
uniform（）方法将随机生成下一个实数，它在[x,y]范围内。
以下展示了使用uniform（）方法的实例：
#!
/usr/bin/python
#-*-coding:
UTF-8-*-
importrandom
print"uniform（5,10）的随机数为:
",
升级会员 