python的函数总结表,python表格函数

python 高阶函数有哪些

1、高阶函数

成都创新互联公司坚持“要么做到,要么别承诺”的工作理念,服务领域包括:成都网站建设、成都网站设计、企业官网、英文网站、手机端网站、网站推广等服务,满足客户于互联网时代的吴中网站设计、移动媒体设计的需求,帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴!

变量可以指向函数,函数的参数可以接收变量,那么函数可以接收另一个函数作为参数,这种函数称为高阶函数。

(1)把函数作为实参

(2)把函数作为返回值

2、系统的内置高阶函数

(1)map函数:接收两个参数,一个是函数,一个是序列,map将传入的函数依次作用到序列的每个元素,并且把结果作为新的列表返回

(2)reduce函数:把一个函数作用到一个序列上,这个函数必须接收两个参数,reduce把结果和序列的下一个元素做累积计算

(3)filter函数:也接收一个函数和一个序列,和map函数不同的是,filter函数把传入的函数依次作用于每个元素,然后返回返回值是True的元素

(4)sorted函数:排序函数

把用户名按照首字母不区分大小写排序

(5)sorted()函数按照关键字排序

关键字:商品个数

(6)sorted()函数按照关键字排序,用键值来查找

(7)lambda匿名函数:有时候传参数时不需要显示自定义的函数,直接传入匿名函数更方便;冒号前面的x,y表示函数参数,匿名函数不需要担心函数名的冲突,匿名函数也是一个函数对象,可以把匿名函数赋值给一个变量,再利用变量来调用函数,匿名函数也可以作为返回值返回

3、高阶函数的应用:

(1)sorted函数:

(2)sorted函数默认是从小到大排序

4、装饰器

装饰器就是用来装饰函数的:想要增加原有函数的功能,但是不希望修改原有函数的定义,在代码运行期间动态增加功能的方式

(1)此装饰器的功能:计算函数的运行时间

import functools

@functools.wraps(f)   ##保留原有函数的属性

运行结果:

(2)此装饰器的功能:用户登录认证

运行结果:

(3)此装饰器的功能:认证用户的同时,显示用户的转账金额

import inspect

inspect.getcallargs()将传的参数封装为一个字典,字典的key值是形式参数,value值是实参

(4)此装饰器的功能:确保收到的每个参数都是整数,是整数就求和,否则抛出错误

(5)此装饰器的功能:给装饰器传参数,是整数和浮点数就求和

python学习网,大量的免费python视频教程,欢迎在线学习!

Python输出函数print()总结

print() 方法用于打印输出,是python中最常见的一个函数。

该函数的语法如下:

参数的具体含义如下:

objects --表示输出的对象。输出多个对象时,需要用 , (逗号)分隔。

sep -- 用来间隔多个对象。

end -- 用来设定以什么结尾。默认值是换行符 \n,我们可以换成其他字符。

file -- 要写入的文件对象。

无论什么类型的数据,包括但不局限于:数值型,布尔型,列表变量,字典变量...都可以直接输出。

在C语言中,我们可以使用printf("%-.4f",a)之类的形式,实现数据的的格式化输出。

在python中,我们同样可以实现数据的格式化输出。我们可以先看一个简单的例子:

和C语言的区别在于,Python中格式控制符和转换说明符用%分隔,C语言中用逗号。

接下来我们仔细探讨一下格式化输出

(1).%字符:标记转换说明符的开始。

%字符的用法可参考上例,不再赘述。

最小字段宽度:转换后的字符串至少应该具有该值指定的宽度。如果是*(星号),则宽度会从值元组中读出。

点(.)后跟精度值:如果需要输出实数,精度值表示出现在小数点后的位数。如果需要输出字符串,那么该数字就表示最大字段宽度。如果是*,那么精度将从元组中读出。

可参考C语言的实现方式。

注:字段宽度中,小数点也占一位。

转换标志:-表示左对齐;+表示在数值前要加上正负号;" "(空白字符)表示正数之前保留空格();0表示转换值若位数不够则用0填充。

具体的我们可以看一下例子:

格式字符 说明 格式字符 说明

%s 字符串采用str()的显示 %x 十六进制整数

%r 字符串(repr())的显示 %e 指数(基底写e)

%c 单个字符 %E 指数(基底写E)

%b 二进制整数 %f,%F 浮点数

%d 十进制整数 %g 指数(e)或浮点数(根据显示长度)

%i 十进制整数 %G 指数(E)或浮点数(根据显示长度)

%o 八进制整数 %% 字符%

在python中,输出函数总是默认换行,比如说:

而显然,这种输出太占“空间”,我们可以进行如下改造:

参考文本第一部分对end参数的描述:end -- 用来设定以什么结尾。默认值是换行符 \n,我们可以换成其他字符。

太全了!Python3常用内置函数总结

数学相关

abs(a) : 求取绝对值。abs(-1)

max(list) : 求取list最大值。max([1,2,3])

min(list) : 求取list最小值。min([1,2,3])

sum(list) : 求取list元素的和。 sum([1,2,3]) 6

sorted(list) : 排序,返回排序后的list。

len(list) : list长度,len([1,2,3])

divmod(a,b): 获取商和余数。 divmod(5,2) (2,1)

pow(a,b) : 获取乘方数。pow(2,3) 8

round(a,b) : 获取指定位数的小数。a代表浮点数,b代表要保留的位数。round(3.1415926,2) 3.14

range(a[,b]) : 生成一个a到b的数组,左闭右开。range(1,10) [1,2,3,4,5,6,7,8,9]

类型转换

int(str) : 转换为int型。int('1') 1

float(int/str) : 将int型或字符型转换为浮点型。float('1') 1.0

str(int) : 转换为字符型。str(1) '1'

bool(int) : 转换为布尔类型。 str(0) False str(None) False

bytes(str,code) : 接收一个字符串,与所要编码的格式,返回一个字节流类型。bytes('abc', 'utf-8') b'abc' bytes(u'爬虫', 'utf-8') b'xe7x88xacxe8x99xab'

list(iterable) : 转换为list。 list((1,2,3)) [1,2,3]

iter(iterable): 返回一个可迭代的对象。 iter([1,2,3]) list_iterator object at 0x0000000003813B00

dict(iterable) : 转换为dict。 dict([('a', 1), ('b', 2), ('c', 3)]) {'a':1, 'b':2, 'c':3}

enumerate(iterable) : 返回一个枚举对象。

tuple(iterable) : 转换为tuple。 tuple([1,2,3]) (1,2,3)

set(iterable) : 转换为set。 set([1,4,2,4,3,5]) {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) {1,2,3}

hex(int) : 转换为16进制。hex(1024) '0x400'

oct(int) : 转换为8进制。 oct(1024) '0o2000'

bin(int) : 转换为2进制。 bin(1024) '0b10000000000'

chr(int) : 转换数字为相应ASCI码字符。 chr(65) 'A'

ord(str) : 转换ASCI字符为相应的数字。 ord('A') 65

相关操作

eval****() : 执行一个表达式,或字符串作为运算。 eval('1+1') 2

exec() : 执行python语句。 exec('print("Python")') Python

filter(func, iterable) : 通过判断函数fun,筛选符合条件的元素。 filter(lambda x: x3, [1,2,3,4,5,6]) filter object at 0x0000000003813828

map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) [6,8,10]

zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) [(1, 4), (2, 5), (3, 6)]

type():返回一个对象的类型。

id(): 返回一个对象的唯一标识值。

hash(object):返回一个对象的hash值,具有相同值的object具有相同的hash值。 hash('python') 7070808359261009780

help():调用系统内置的帮助系统。

isinstance():判断一个对象是否为该类的一个实例。

issubclass():判断一个类是否为另一个类的子类。

globals() : 返回当前全局变量的字典。

next(iterator[, default]) : 接收一个迭代器,返回迭代器中的数值,如果设置了default,则当迭代器中的元素遍历后,输出default内容。

reversed(sequence) : 生成一个反转序列的迭代器。 reversed('abc') ['c','b','a']

python常用列表函数

1

len(list)

列表元素个数

2

max(list)

返回列表元素最大值

3

min(list)

返回列表元素最小值

4

list(seq)

将元组转换为列表

序号

方法

1

list.append(obj)

在列表末尾添加新的对象

2

list.count(obj)

统计某个元素在列表中出现的次数

3

list.extend(seq)

在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

4

list.index(obj)

从列表中找出某个值第一个匹配项的索引位置

5

list.insert(index, obj)

将对象插入列表

6

list.pop([index=-1])

移除列表中的一个元素(默认最后一个元素),并且返回该元素的值

7

list.remove(obj)

移除列表中某个值的第一个匹配项

8

list.reverse()

反向列表中元素

9

list.sort( key=None, reverse=False)

对原列表进行排序

10

list.clear()

清空列表

11

list.copy()

复制列表

享学课堂浅谈Python序列内建函数都有哪些

1、Python类型操作符和内建函数总结

表4.5列出了所有操作符和内建函数,其中操作符顺序是按优先级从高到低排列的。同一种灰度的操作符拥有同样的优先级。注意在operator模块中有这些(和绝大多数Python)操作符相应的同功能的函数可供使用。

表4.5 标准类型操作符和内建函数

操作符/函数

描 述

结 果a

字符串表示

``

对象的字符串表示

str

内建函数

cmp(obj1, obj2)

比较两个对象

int

repr(obj)

对象的字符串表示

str

str(obj)

对象的字符串表示

str

type(obj)

检测对象的类型

type

值比较

小于

bool

大于

bool

=

小于或等于

bool

=

大于或等于

bool

==

等于

bool

!=

不等于

bool

不等于

bool

对象比较

is

bool

is not

不是

bool

布尔操作符

not

逻辑反

bool

and

逻辑与

bool

or

逻辑或

bool

2、Python数值类型操作符和内建函数

一、工厂函数

数值工厂函数总结类(工厂函数) 操作

bool(obj) b 返回obj对象的布尔值,也就是 obj.__nonzero__()方法的返回值。

int(obj, base=10)   返回一个字符串或数值对象的整数表 示, 类似string.atoi();

从Python 1.6起, 引入了可选的进制参数。

long(obj, base=10) 返回一个字符或数据对象的长整数表 示,类似string.atol(),

从Python1.6起, 引入了可选的进制参数 float(obj) ,

返回一个字符串或数据对象的浮点数 表示,类似string.atof()。

complex(str) or返回一个字符串的复数表示,或 者根据给定的实数,

complex(real, imag=0.0)  (及一个可选 的虚数部分)生成一个复数对象。

二、内建函数

1、分类

Python 有五个运算内建函数用于数值运算:

abs(num), coerce(num1,num2), divmod(num1,num2), pow(num1,num2,mod=1)和 round(flt,ndig=0)

其中abs()返回给定参数的绝对值。如果参数是一个复数, 那么就返回math.sqrt(num.real2 + num.imag2).

coerce()是一个数据类型转换函数,不过它的行为更像一个运算符.数coerce()为程序员提供了不依赖Python 解释器,而是自定义两个数值类型转换的方法。对一种新创建的数值类型来说, 这个特性非常有用.函数coerce()仅返回一个包含类型转换完毕的两个数值元素的元组.

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

pow()它和双星号 (**)运算符都可以进行指数运算.不过二者的区别并不仅仅在于一个是运算符,一个是内建函数.在Python 1.5 之前,并没有 ** 运算符,内建函数pow()还接受第三个可选的参数,一个余数参数.如果有这个参数的, pow() 先进行指数运算,然后将运算结果和第三个参数进行取余运算.这个特性主要用于密码运算,并且比 pow(x,y) % z 性能更好, 这是因为这个函数的实现类似于C 函数pow(x,y,z).

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

2、函数int()/round()/math.floor()它们之间的不同之处:

函数 int()直接截去小数部分.(返回值为整数)

函数 floor() 得到最接近原数但小于原数的整数.(返回值为浮点数)

函数 round() 得到最接近原数的整数.(返回值为浮点数)

3、进制转换函数:

返回字符串表示的8 进制和16 进制整数,它们分别是内建函数:

oct()和 hex(). oct(255)='0377'/hex(255)='0xff'

函数chr()接受一个单字节整数值(0到255),返回一个字符串(ASCII),其值为对应的字符.chr(97)='a'

函数ord()则相反,它接受一个字符(ASCII 或 Unicode),返回其对应的整数值.ord('A')=65

3、Python字符串函数

(一)标准类型操作符和标准内建函数

1)、标准类型操作符

,,=,=,==,!=,对象值得比较

注:做比较时字符串是按ASCII值的大小来比较的

is 对象身份比较

and,or,not 布尔类型

2)标准内建函数

type(obj)

cmp(obj1,obj2)

str(obj)和repr(obj) 或反引号运算符(``) 可以方便的以字符串的方式获取对象的

内容、类型、数值属性等信息。str()函数得到的字符串可读性好, 而repr()函数得到的字符

串通常可以用来重新获得该对象, 通常情况下 obj == eval(repr(obj)) 这个等式是成立的

isinstance(obj,type) 判断对象的类型

(二)序列操作

1、序列操作

字符串属于序列对象,可以使用所有序列的操作和函数

切片 [] [:] [::]

简单总结:

*索引(S[i])获取特定偏移的元素。

——第一个元素偏移为0

——(S[0])获取第一个元素。

——负偏移索引意味着从最后或右边反向进行计数

——(S[-2])获取倒数第二个元素(就像S[len(s)-2]一样

*分片[S[i:j]提取对应的部分作为一个序列

——右边界不包含在内

——分片的边界默认为0和序列的长度,如果没有给出的话S[:]

——(S[1:3])获取了从偏移为1,直到但不包括偏移为3的元素

——(S[1:])获取从偏移为1到末尾之间的元素

——(S[:3])获取从偏移为0直到但不包括偏移为3的元素

——(S[:-1])获取从偏移为0直到但不包括最后一个元素之间的元素

——(S[:])获取从偏移为0到末尾之间的元素,这有效地实现了顶层S拷贝

拷贝了一个相同值,但是是不同内存区域的对象。对象字符串这样不可变的对象不是很有用,但是对于可以实地修改的对象来说很有用。

比如列表。

扩展分片:第三个限制值 【步进】

完整形式:X[I:J:K]:这标识索引X对象的元素,从偏移为I直到J-1,每隔K元素索引一次。第三个限制值,K,默认为1

实例

Python Code

1

2

3

4

5

S='abcdefghijk'

S[1:10]

'bcdefghij'

S[1:10:2]

'bdfhj

也可以使用负数作为步进。

分片表达式

Python Code

1

2

"hello"[::-1]

'olleh'

通过负数步进,两个边界的意义实际上进行了反转。

3、成员操作符 in ,not in

返回布尔值True 或False

可以使用string模块来判断输入字符的合法性,可见成品中的idcheck.py

4、字符串连接

+ 连接字符串 ‘name’+' '+'jin'

字符串格式化 '%s %s' % ('name','jin')

join()方法 ' '.join(('name','jin')) ' '.join(['name','jin'])

5、删除清空字符串

del aString

aString=''

(三)、序列函数

序列类型函数

len(str) 返回字串的长度

enumerate(iter):接受一个可迭代对象作为参数,返回一个enumerate

max(str)/min(str):max()和min()函数对其他的序列类型可能更有用,但对于string类型它们能很好地运行,返回最大或者最小的字符(按照ASCII 码值排列),

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

reversed(seq)c 接受一个序列作为参数,返回一个以逆序访问的迭代器(PEP 322)

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

注意:

sorted等需要在原处修改的函数无法用在字符串对象,但可以产生新的对象

sum处理的对象是数字,不能用在字符串

sorted(s)

['a', 'e', 'e', 'g', 'g', 'g', 'o']

(四)只适合于字符串类型的函数

1)raw_input()函数

内建的raw_input()函数使用给定字符串提示用户输入并将这个输入返回,下面是一个使

用raw_input()的例子:

user_input = raw_input("Enter your name: ")

prin user_input

2)str() and unicode()

str()和unicode()函数都是工厂函数,就是说产生所对应的类型的对象.它们接受一个任

意类型的对象,然后创建该对象的可打印的或者Unicode 的字符串表示. 它们和basestring 都

可以作为参数传给isinstance()函数来判断一个对象的类型

3)chr(), unichr(), and ord()

chr()函数用一个范围在range(256)内的(就是0 到255)整数做参数,返回一个对应的字符.unichr()跟它一样,只不过返回的是Unicode 字符

ord()函数是chr()函数(对于8 位的ASCII 字符串)或unichr()函数(对于Unicode 对象)

的配对函数,它以一个字符(长度为1 的字符串)作为参数,返回对应的ASCII 数值,或者Unicode

数值,如果所给的Unicode 字符超出了你的Python 定义范围,则会引发一个TypeError 的异常

(五)、只适用于字符串的操作符

1、格式化操作符 %

字符串格式化符号

格式化字符 转换方式

%c 转换成字符(ASCII 码值,或者长度为一的字符串)

%ra 优先用repr()函数进行字符串转换

%s 优先用str()函数进行字符串转换

%d / %i 转成有符号十进制数

%ub 转成无符号十进制数

%ob 转成无符号八进制数

%xb/%Xb (Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大

小写)

%e/%E 转成科学计数法(e/E 控制输出e/E)

%f/%F 转成浮点数(小数部分自然截断)

%g/%G %e 和%f/%E 和%F 的简写

%% 输出%

格式化操作符辅助指令

符号 作用

* 定义宽度或者小数点精度

- 用做左对齐

+ 在正数前面显示加号( + )

sp 在正数前面显示空格

# 在八进制数前面显示零('0'),在十六进制前面显示'0x'或者'0X'(取决于

用的是'x'还是'X')

0 显示的数字前面填充‘0’而不是默认的空格

% '%%'输出一个单一的'%'

(var) 映射变量(字典参数)

m.n m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

2、字符串模板: 更简单的替代品

由于新式的字符串Template 对象的引进使得string 模块又重新活了过来,Template 对象

有两个方法,substitute()和safe_substitute().前者更为严谨,在key 缺少的情况下它会报一

个KeyError 的异常出来,而后者在缺少key 时,直接原封不动的把字符串显示出

3、原始字符串操作符( r/R )

字符串抑制转义r'带特殊符号的字串'

myfile=open(r'C:\new\text.data','w')

4、Unicode 字符串操作符( u/U )

u'abc' U+0061 U+0062 U+0063

u'\u1234' U+1234

u'abc\u1234\n' U+0061 U+0062 U+0063 U+1234 U+0012

(六)字符串对象的方法:

1、删减

T2.lstrip() 移除字符串前面字符(默认空格),返回字符串

T2.rstrip() 移除字符串后面字符(默认空格),返回字符串

T2.strip() 移除字符串前后面空格,返回字符串 默认空格,可以其他字符 S.strip('"')

2、切割

partition(sep),

rpartition(sep),

splitlines([keepends]),#把S按照行分割符分为一个list,keepends是一个bool值,如果为真每行后而会保留行分割符

split([sep [,maxsplit]]),#以sep为分隔符,把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符

rsplit([sep[,maxsplit]]) #从右到左切割

备注:

partition()函数族是2.5版本新增的方法。它接受一个字符串参数,并返回一个3个元素的 tuple 对象。

如果sep没出现在母串中,返回值是 (sep, ‘’, ‘’);

否则,返回值的第一个元素是 sep 左端的部分,第二个元素是 sep 自身,第三个元素是 sep 右端的部分。

S.partition(';')

('', ';', ' generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n')

参数 maxsplit 是分切的次数,即最大的分切次数,所以返回值最多有 maxsplit+1 个元素。

s.split() 和 s.split(‘ ‘)的返回值不尽相同

' hello world!'.split()

['hello', 'world!']

' hello world!'.split(' ')

['', '', 'hello', '', '', 'world!']

S.split('\n',3)

['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n']

超过最大切割个数后面的全部为一个元素

按行切割

S

'; generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n'

S.splitlines()

['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2', 'nameserver 178.79.131.110', 'nameserver 202.96.199.133']

产生差异的原因在于当忽略 sep 参数或sep参数为 None 时与明确给 sep 赋予字符串值时 split() 采用两种不同的算法。

对于前者,split() 先去除字符串两端的空白符,然后以任意长度的空白符串作为界定符分切字符串

即连续的空白符串被当作单一的空白符看待;

对于后者则认为两个连续的 sep 之间存在一个空字符串。因此对于空字符串(或空白符串),它们的返回值也是不同的:

''.split()

[]

''.split(' ')

['']

3、变形

lower(),#全部小写

upper(),#全部小写

capitalize(),#首字母大写

swapcase(),#大小写交换

title()#每个单词第一个大写,其他小写

备注

因为title() 函数并不去除字符串两端的空白符也不会把连续的空白符替换为一个空格,

所以建议使用string 模块中的capwords(s)函数,它能够去除两端的空白符,再将连续的空白符用一个空格代替。

Python Code

1

2

3

4

' hello world!'.title()

' Hello World!'

string.capwords(' hello world!')

'Hello World!'

4、连接

join(seq)

join() 函数的高效率(相对于循环相加而言),使它成为最值得关注的字符串方法之一。

它的功用是将可迭代的字符串序列连接成一条长字符串,如:

conf = {'host':'127.0.0.1',

... 'db':'spam',

... 'user':'sa',

... 'passwd':'eggs'}

';'.join("%s=%s"%(k, v) for k, v in conf.iteritems())

'passswd=eggs;db=spam;user=sa;host=127.0.0.1'

S=''.join(T) #使用空字符串分割把字符列表转换为字符串

5、查找

count( sub[, start[, end]]),#计算substr在S中出现的次数

find( sub[, start[, end]]),#返回S中出现sub的第一个字母的标号,如果S中没有sub则返回-1。start和end作用就相当于在S[start:end]中搜索

index( substr[, start[, end]]),#与find()相同,只是在S中没有substr时,会返回一个运行时错误

rfind( sub[, start[,end]]),#返回S中最后出现的substr的第一个字母的标号,如果S中没有substr则返回-1,也就是说从右边算起的第一次出现的substr的首字母标号

rindex( sub[, start[, end]])

T2.find('ie') 字符串方法调用:搜索

find()----找到的第一个符合字符的index

rfind()-----找到最后一个符合的字符的index

备注:

find()函数族找不到时返回-1,index()函数族则抛出ValueError异常。

另,也可以用 in 和 not in 操作符来判断字符串中是否存在某个模板

6、替换

replace(old, new[,count]),#把S中的oldstar替换为newstr,count为替换次数。这是替换的通用形式,还有一些函数进行特殊字符的替换

translate(table[,deletechars]) #使用上面的函数产后的翻译表,把S进行翻译,并把deletechars中有的字符删掉

备注:

replace()函数的 count 参数用以指定最大替换次数

translate() 的参数 table 可以由 string.maketrans(frm, to) 生成

translate() 对 unicode 对象的支持并不完备,建议不要使用

7、判定

isalnum(),#是否全是字母和数字,并至少有一个字符

isalpha(),是否全是字母,并至少有一个字符

isdigit(),是否全是数字,并至少有一个字符 ,如果是全数字返回True,否则返回False

islower(),#S中的字母是否全是小写

isupper(),#S中的字母是否是大写

isspace(),#是否全是空白字符,并至少有一个字符

istitle(),S是否是首字母大写的

startswith(prefix[, start[, end]]), #是否以prefix开头

endswith(suffix[,start[, end]]),#以suffix结尾

备注:

这些函数都比较简单,顾名知义。需要注意的是*with()函数族可以接受可选的 start, end 参数,善加利用,可以优化性能。

另,自 Py2.5 版本起,*with() 函数族的 prefix 参数可以接受 tuple 类型的实参,当实参中的某人元素能够匹配,即返回 True。

8、填充

字符串在输出时的对齐:

center(width[, fillchar]), 字符串中间对齐

ljust(width[, fillchar]), 字符串左对齐,不足部分用fillchar填充,默认的为空格

rjust(width[, fillchar]), 字符串右对齐,不足部分用fillchar填充,默认的为空格

zfill(width), 把字符串变成width长,并在右对齐,不足部分用0补足

expandtabs([tabsize])把字符串中的制表符(tab)转换为适当数量的空格。

fillchar 参数指定了用以填充的字符,默认为空格

zfill的z为zero的缩写,顾名思义,是以字符0进行填充,用于数值输出

expandtabs()的tabsize 参数默认为8。它的功能是把字符串中的制表符(tab)转换为适当数量的空格。

9、编码

encode([encoding[,errors]]),

decode([encoding[,errors]])

这是一对互逆操作的方法,用以编码和解码字符串。因为str是平台相关的,它使用的内码依赖于操作系统环境,

而unicode是平台无关的,是Python内部的字符串存储

Python的函数参数总结

import math

a = abs

print(a(-1))

n1 = 255

print(str(hex(n1)))

def my_abs(x):

# 增加了参数的检查

if not isinstance(x, (int, float)):

raise TypeError('bad operand type')

if x = 0:

return x

else:

return -x

print(my_abs(-3))

def nop():

pass

if n1 = 255:

pass

def move(x, y, step, angle=0):

nx = x + step * math.cos(angle)

ny = y - step * math.sin(angle)

return nx, ny

x, y = move(100, 100, 60, math.pi / 6)

print(x, y)

tup = move(100, 100, 60, math.pi / 6)

print(tup)

print(isinstance(tup, tuple))

def quadratic(a, b, c):

k = b * b - 4 * a * c

# print(k)

# print(math.sqrt(k))

if k 0:

print('This is no result!')

return None

elif k == 0:

x1 = -(b / 2 * a)

x2 = x1

return x1, x2

else:

x1 = (-b + math.sqrt(k)) / (2 * a)

x2 = (-b - math.sqrt(k)) / (2 * a)

return x1, x2

print(quadratic(2, 3, 1))

def power(x, n=2):

s = 1

while n 0:

n = n - 1

s = s * x

return s

print(power(2))

print(power(2, 3))

def enroll(name, gender, age=8, city='BeiJing'):

print('name:', name)

print('gender:', gender)

print('age:', age)

print('city:', city)

enroll('elder', 'F')

enroll('android', 'B', 9)

enroll('pythone', '6', city='AnShan')

def add_end(L=[]):

L.append('end')

return L

print(add_end())

print(add_end())

print(add_end())

def add_end_none(L=None):

if L is None:

L = []

L.append('END')

return L

print(add_end_none())

print(add_end_none())

print(add_end_none())

def calc(*nums):

sum = 0

for n in nums:

sum = sum + n * n

return sum

print(calc(1, 2, 3))

print(calc())

l = [1, 2, 3, 4]

print(calc(*l))

def foo(x, y):

print('x is %s' % x)

print('y is %s' % y)

foo(1, 2)

foo(y=1, x=2)

def person(name, age, **kv):

print('name:', name, 'age:', age, 'other:', kv)

person('Elder', '8')

person('Android', '9', city='BeiJing', Edu='人民大学')

extra = {'city': 'Beijing', 'job': 'Engineer'}

person('Jack', 24, **extra)

def person2(name, age, *, city, job):

print(name, age, city, job)

person2('Pthon', 8, city='BeiJing', job='Android Engineer')

def person3(name, age, *other, city='BeiJing', job='Android Engineer'):

print(name, age, other, city, job)

person3('Php', 18, 'test', 1, 2, 3)

person3('Php2', 28, 'test', 1, 2, 3, city='ShangHai', job='Pyhton Engineer')

def test2(a, b, c=0, *args, key=None, **kw):

print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'key=', key, 'kw =', kw)

test2(1, 2, 3, 'a', 'b', 'c', key='key', other='extra')

args = (1, 2, 3, 4)

kw = {'d': 99, 'x': '#'}

test2(*args, **kw)


文章名称:python的函数总结表,python表格函数
链接地址:http://scyanting.com/article/hcgspp.html