享学课堂浅谈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中字典的内建函数用法是什么？

点击上方 "Python人工智能技术" 关注，星标或者置顶

22点24分准时推送，第一时间送达

后台回复“大礼包”，送你特别福利

编辑：乐乐 | 来自：pypypypy

上一篇：

正文

大家好，我是Pythn人工智能技术。

内置函数就是Python给你提供的，拿来直接用的函数，比如print.，input等。

截止到python版本3.6.2 ，python一共提供了68个内置函数，具体如下

abs() dict() help() min() setattr()

all() dir() hex() next() slice()

any() divmod() id() object() sorted()

ascii() enumerate() input() oct() staticmethod()

bin() eval() int() open() str()

bool() exec() isinstance() ord() sum()

bytearray() filter() issubclass() pow() super()

bytes() float() iter() print() tuple()

callable() format() len() property() type()

chr() frozenset() list() range() vars()

classmethod() getattr() locals() repr() zip()

compile() globals() map() reversed() __import__()

complex() hasattr() max() round()

delattr() hash() memoryview() set()

本文将这68个内置函数综合整理为12大类，正在学习Python基础的读者一定不要错过，建议收藏学习！

和数字相关 1. 数据类型

bool : 布尔型(True,False)

int : 整型(整数)

float : 浮点型(小数)

complex : 复数

2. 进制转换

bin() 将给的参数转换成二进制

otc() 将给的参数转换成八进制

hex() 将给的参数转换成十六进制

print(bin(10)) # 二进制:0b1010

print(hex(10)) # 十六进制:0xa

print(oct(10)) # 八进制:0o12

3. 数学运算

abs() 返回绝对值

divmode() 返回商和余数

round() 四舍五入

pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余

sum() 求和

min() 求最小值

max() 求最大值

print(abs(-2)) # 绝对值:2

print(divmod(20,3)) # 求商和余数:(6,2)

print(round(4.50)) # 五舍六入:4

print(round(4.51)) #5

print(pow(10,2,3)) # 如果给了第三个参数. 表示最后取余:1

print(sum([1,2,3,4,5,6,7,8,9,10])) # 求和:55

print(min(5,3,9,12,7,2)) #求最小值:2

print(max(7,3,15,9,4,13)) #求最大值:15

和数据结构相关 1. 序列

（1）列表和元组

list() 将一个可迭代对象转换成列表

tuple() 将一个可迭代对象转换成元组

print(list((1,2,3,4,5,6))) #[1, 2, 3, 4, 5, 6]

print(tuple([1,2,3,4,5,6])) #(1, 2, 3, 4, 5, 6)

（2）相关内置函数

reversed() 将一个序列翻转, 返回翻转序列的迭代器

slice() 列表的切片

lst = "你好啊"

it = reversed(lst) # 不会改变原列表. 返回一个迭代器, 设计上的一个规则

print(list(it)) #['啊', '好', '你']

lst = [1, 2, 3, 4, 5, 6, 7]

print(lst[1:3:1]) #[2,3]

s = slice(1, 3, 1) # 切片用的

print(lst[s]) #[2,3]

（3）字符串

str() 将数据转化成字符串

print(str(123)+'456') #123456

format() 与具体数据相关, 用于计算各种小数, 精算等.

s = "hello world!"

print(format(s, "^20")) #剧中

print(format(s, "20")) #左对齐

print(format(s, "20")) #右对齐

# hello world!

# hello world!

# hello world!

print(format(3, 'b' )) # 二进制:11

print(format(97, 'c' )) # 转换成unicode字符:a

print(format(11, 'd' )) # ⼗进制:11

print(format(11, 'o' )) # 八进制:13

print(format(11, 'x' )) # 十六进制(⼩写字母):b

print(format(11, 'X' )) # 十六进制(大写字母):B

print(format(11, 'n' )) # 和d⼀样:11

print(format(11)) # 和d⼀样:11

print(format(123456789, 'e' )) # 科学计数法. 默认保留6位小数:1.234568e+08

print(format(123456789, '0.2e' )) # 科学计数法. 保留2位小数(小写):1.23e+08

print(format(123456789, '0.2E' )) # 科学计数法. 保留2位小数(大写):1.23E+08

print(format(1.23456789, 'f' )) # 小数点计数法. 保留6位小数:1.234568

print(format(1.23456789, '0.2f' )) # 小数点计数法. 保留2位小数:1.23

print(format(1.23456789, '0.10f')) # 小数点计数法. 保留10位小数:1.2345678900

print(format(1.23456789e+3, 'F')) # 小数点计数法. 很大的时候输出INF:1234.567890

bytes() 把字符串转化成bytes类型

bs = bytes("今天吃饭了吗", encoding="utf-8")

print(bs) #b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'

bytearray() 返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)

ret = bytearray("alex" ,encoding ='utf-8')

print(ret[0]) #97

print(ret) #bytearray(b'alex')

ret[0] = 65 #把65的位置A赋值给ret[0]

print(str(ret)) #bytearray(b'Alex')

ord() 输入字符找带字符编码的位置

chr() 输入位置数字找出对应的字符

ascii() 是ascii码中的返回该值 不是就返回u

print(ord('a')) # 字母a在编码表中的码位:97

print(ord('中')) # '中'字在编码表中的位置:20013

print(chr(65)) # 已知码位,求字符是什么:A

print(chr(19999)) #丢

for i in range(65536): #打印出0到65535的字符

print(chr(i), end=" ")

print(ascii("@")) #'@'

repr() 返回一个对象的string形式

s = "今天\n吃了%s顿\t饭" % 3

print(s)#今天# 吃了3顿 饭

print(repr(s)) # 原样输出,过滤掉转义字符 \n \t \r 不管百分号%

#'今天\n吃了3顿\t饭'

2. 数据集合

字典：dict 创建一个字典

集合：set 创建一个集合

frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。

3. 相关内置函数

len() 返回一个对象中的元素的个数

sorted() 对可迭代对象进行排序操作 (lamda)

语法：sorted(Iterable, key=函数(排序规则), reverse=False)

Iterable: 可迭代对象

key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序

reverse: 是否是倒叙. True: 倒叙, False: 正序

lst = [5,7,6,12,1,13,9,18,5]

lst.sort() # sort是list里面的一个方法

print(lst) #[1, 5, 5, 6, 7, 9, 12, 13, 18]

ll = sorted(lst) # 内置函数. 返回给你一个新列表 新列表是被排序的

print(ll) #[1, 5, 5, 6, 7, 9, 12, 13, 18]

l2 = sorted(lst,reverse=True) #倒序

print(l2) #[18, 13, 12, 9, 7, 6, 5, 5, 1]

#根据字符串长度给列表排序

lst = ['one', 'two', 'three', 'four', 'five', 'six']

def f(s):

return len(s)

l1 = sorted(lst, key=f, )

print(l1) #['one', 'two', 'six', 'four', 'five', 'three']

enumerate() 获取集合的枚举对象

lst = ['one','two','three','four','five']

for index, el in enumerate(lst,1): # 把索引和元素一起获取,索引默认从0开始. 可以更改

print(index)

print(el)

# 1

# one

# 2

# two

# 3

# three

# 4

# four

# 5

# five

all() 可迭代对象中全部是True, 结果才是True

any() 可迭代对象中有一个是True, 结果就是True

print(all([1,'hello',True,9])) #True

print(any([0,0,0,False,1,'good'])) #True

zip() 函数用于将可迭代的对象作为参数, 将对象中对应的元素打包成一个元组, 然后返回由这些元组组成的列表. 如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同

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

lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']

lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']

print(zip(lst1, lst1, lst3)) #

for el in zip(lst1, lst2, lst3):

print(el)

# (1, '醉乡民谣', '美国')

# (2, '驴得水', '中国')

# (3, '放牛班的春天', '法国')

# (4, '美丽人生', '意大利')

# (5, '辩护人', '韩国')

# (6, '被嫌弃的松子的一生', '日本')

fiter() 过滤 (lamda)

语法：fiter(function. Iterable)

function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留留此项数据 , Iterable: 可迭代对象

搜索公众号顶级架构师后台回复“面试”，送你一份惊喜礼包。

def func(i): # 判断奇数

return i % 2 == 1

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

l1 = filter(func, lst) #l1是迭代器

print(l1) #

print(list(l1)) #[1, 3, 5, 7, 9]

map() 会根据提供的函数对指定序列列做映射(lamda)

语法 : map(function, iterable)

可以对可迭代对象中的每一个元素进行映射. 分别去执行 function

def f(i): return i

lst = [1,2,3,4,5,6,7,]

it = map(f, lst) # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器print(list(it)) #[1, 2, 3, 4, 5, 6, 7]

和作用域相关

locals() 返回当前作用域中的名字

globals() 返回全局作用域中的名字

def func():

a = 10

print(locals()) # 当前作用域中的内容

print(globals()) # 全局作用域中的内容

print("今天内容很多")

func()

# {'a': 10}

# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':

# _frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080,

# '__spec__': None, '__annotations__': {}, '__builtins__':

# (built-in), '__file__': 'D:/pycharm/练习/week03/new14.py', '__cached__': None,

# 'func': }

# 今天内容很多

和迭代器生成器相关

range() 生成数据

next() 迭代器向下执行一次, 内部实际使⽤用了__ next__()⽅方法返回迭代器的下一个项目

iter() 获取迭代器, 内部实际使用的是__ iter__()⽅方法来获取迭代器

for i in range(15,-1,-5):

print(i)

# 15

# 10

# 5

# 0

lst = [1,2,3,4,5]

it = iter(lst) # __iter__()获得迭代器

print(it.__next__()) #1

print(next(it)) #2 __next__()

print(next(it)) #3

print(next(it)) #4

字符串类型代码的执行

eval() 执行字符串类型的代码. 并返回最终结果

exec() 执行字符串类型的代码

compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值

s1 = input("请输入a+b:") #输入:8+9

print(eval(s1)) # 17 可以动态的执行代码. 代码必须有返回值

s2 = "for i in range(5): print(i)"

a = exec(s2) # exec 执行代码不返回任何内容

# 0

# 1

# 2

# 3

# 4

print(a) #None

# 动态执行代码

exec("""

def func():

print(" 我是周杰伦")

""" )

func() #我是周杰伦

code1 = "for i in range(3): print(i)"

com = compile(code1, "", mode="exec") # compile并不会执行你的代码.只是编译

exec(com) # 执行编译的结果

# 0

# 1

# 2

code2 = "5+6+7"

com2 = compile(code2, "", mode="eval")

print(eval(com2)) # 18

code3 = "name = input('请输入你的名字:')" #输入:hello

com3 = compile(code3, "", mode="single")

exec(com3)

print(name) #hello

输入输出

print() : 打印输出

input() : 获取用户输出的内容

print("hello", "world", sep="*", end="@") # sep:打印出的内容用什么连接,end:以什么为结尾

#hello*world@

内存相关

hash() : 获取到对象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空间换的时间 比较耗费内存

s = 'alex'print(hash(s)) #-168324845050430382lst = [1, 2, 3, 4, 5]print(hash(lst)) #报错,列表是不可哈希的 id() : 获取到对象的内存地址s = 'alex'print(id(s)) #2278345368944

文件操作相关

open() : 用于打开一个文件, 创建一个文件句柄

f = open('file',mode='r',encoding='utf-8')

f.read()

f.close()

模块相关

__ import__() : 用于动态加载类和函数

# 让用户输入一个要导入的模块

import os

name = input("请输入你要导入的模块:")

__import__(name) # 可以动态导入模块

帮 助

help() : 函数用于查看函数或模块用途的详细说明

print(help(str)) #查看字符串的用途

调用相关

callable() : 用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功

a = 10

print(callable(a)) #False 变量a不能被调用

def f():

print("hello")

print(callable(f)) # True 函数是可以被调用的

查看内置属性

dir() : 查看对象的内置属性, 访问的是对象中的__dir__()方法

print(dir(tuple)) #查看元组的方法

你还有什么想要补充的吗？

免责声明：本文内容来源于网络，文章版权归原作者所有，意在传播相关技术知识行业趋势，供大家学习交流，若涉及作品版权问题，请联系删除或授权事宜。

技术君个人微信

添加技术君个人微信即送一份惊喜大礼包

→ 技术资料共享

→ 技术交流社群

--END--

往日热文：

Python程序员深度学习的“四大名著”：

这四本书着实很不错！我们都知道现在机器学习、深度学习的资料太多了，面对海量资源，往往陷入到“无从下手”的困惑出境。而且并非所有的书籍都是优质资源，浪费大量的时间是得不偿失的。给大家推荐这几本好书并做简单介绍。

获得方式：

2.后台回复关键词：名著

python的内置函数有哪些,都是什么意思？

print-输出，input-输入，int-将字符串转数字（字符串必须是数字），str-将数字转为字符串，list-将字符串/数字转为列表，for-有限循环，while-无限循环……………………………………

python 2.7.6内置函数有哪些

内置函数，在python帮助文档中：Build-in Functions

在Python提示符下，输入下面语句，就会显示Python提供的内置函数列表

dir('__builtins__')

abs(_) 内置函数，绝对值或复数的模。

chr() 以单字节整数为参数，返回一个单字符的字符串，其内容是与之对于的ASCII字符。如chr(69)返回'E'。

cmp() 比较字符串，cmp('Xiao','Jian')返回1

coerce() (可以看成一个数值类型转换函数)有两个参数，都是数字，返回这两个数字的一个列表，将这两个数字的数据类型统一。如coerce(1,2j)，返回(1+0j,2j)

complex() 内置函数，把……转换成复数，如complex('2')返回(2+0j)，complex('2+3j')返回(2+3j)。

divmod() 内置函数，有两个参数，返回（商，余数）。如divmod(10,2.5)，返回(4.0,0.0)。

filter(function,list) 把函数应用于list中的每一项，并返回 从函数中返回真值的项。注：function可以为None，此时删除list中的0或空项。

float() 内置函数，把……转换成浮点数。

floor() 在math模块内，需要import math。向下取整，即向x轴负方向取整。如math.floor(1.9)返回1，math.floor(-2.5)返回-3。

hash() 散列功能，词典键的最精确功能需求是它一定是可散列的。对象的散列值是半唯一的、内部生成的数字，它可用于快速比较。

int() 内置函数，把字符串或者小数转换为一个整数。直接去掉小数部分。如int(5.3)返回5，int('5')返回5。

len(x) 序列x的长度

long() 内置函数，把数字 或 代表整数的字符串 转换成长整型

map(function,list[,list,...])

max() 找出字符串中最大的字符。如：min('find the minimum character')，返回' '，即空格。

min() 找出字符串中最小的字符。如：max('find the maximum character')，返回'x'。

oct() 将十进制数转换成八进制，再变成字符。

ord() 参数是单个的ASCII字符，返回该ASCII字符对应的整数值，如ord('a')返回97。

pow() 内置函数，乘方。如果有第三个参数，则表示乘方的结果对第三参数取余，如pow(2,3)返回8，pow(2,3,4)返回0。

print 输出到窗口

range() 生成一个向量，例如range(m,n,d)，从m到n，步长为d；range(m)则生成0：m-1，步长为1的向量。

raw_input() 输入函数，参数为字符串，作为输入时的提示语句。返回值为字符串。

reduce(func)

round() 内置函数，对数字进行四舍五入，第二个参数表示精确到小数点后指定的位数，默认值为0。如round(2.4)返回2，round(1.398,2)返回1.40。

type() 返回某数据的类型

Python常用函数三有哪些？这7个函数使用频率最高，总算搞明白了

1.1 例如：print(hex(2))案例

1.2 输出函数：print(hex(2))

1.3 输出结果：0x2

1.4 解析说明：返回16进制的数。

2.1 例如：print(chr(10))案例

2.2 输出函数：print(chr(10))

2.3 输出结果：0o12

2.4 解析说明：返回当前整数对应的ASCll码

3.1 例如：print(ord("b"))案例

3.2 输出函数：print(ord("b"))

3.3 输出结果：98

3.4 解析说明：返回当前ASCll码的10进制数

4.1 例如：print(chr(97))

4.2 输出函数：print(chr(97))

4.3 输出结果：b

4.4 解析说明：返回当前ASCll码的10进制数。

案例一：给你一个字符串,s = 'hello kitty'

1.1 输出函数：print(s.capitalize())

1.2 输出结果：0x2

1.3 解析说明：返回16进制的数。

2.1输出函数：print(s.replace('kitty','kuang'))

2.2 输出结果：hello kuang

2.3 解析说明：替换功能，将kitty换成kuang。

2.4 输出函数：print(s.replace('4','KK'))

2.5 输出结果：12KK12KK

2.6 解析说明：所有的4都替换成KK

2.7 输出函数：print(s.replace('4','KK'))

2.8 输出结果：12KK12KK124

2.9 解析说明：将前两个的4替换成go

案例一：给你一个字符串，ip = '192.168.1.1'

3.1 输出函数：print(ip.split(','))

3.2 输出结果：['192.168.1.1']

3.3 解析说明：将字符串分割成列表

案例一：给你一个字符串，ip = '192.168.1.1'

3.3 输出函数：print(ip.split(',',2))

3.4 输出结果：['192.168.1.1']

3.5 解析说明：从第二个开始分割成列表

Python中range()函数的用法

Python range()函数可创建一个整数列表，一般用在for循环中。

注意：Python3 range()返回的是一个可迭代对象，类型是对象，而不是列表类型，所以打印的时候不会打印列表。

函数语法：

range(start,stop[,step])

参数说明：

start：计数从start开始。默认是从0开始。例如range(5)等价于range(0,5);

stop：计数到stop结束，但不包括stop。例如：range(0,5)是[0,1,2,3,4]没有5;

step：步长，默认为1。例如：range(0,5)等价于range(0,5,1)。

实例：

range(10) # 从 0 开始到 9

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

range(1, 11) # 从 1 开始到 10

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

range(0, 30, 5) # 步长为 5

[0, 5, 10, 15, 20, 25]

range(0, 10, 3) # 步长为 3

[0, 3, 6, 9]

range(0, -10, -1) # 负数

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

range(0)

[]

range(1, 0)

[]

以下是range在for中的使用，循环出runoob的每个字母：

x = 'runoob'

for i in range(len(x)) :

... print(x[i])

...

r

u

n

o

o

b

文章名称：python的五个函数 python函数有几种类型
网页链接：http://ybzwz.com/article/dosedhi.html