13-Python3内置函数总结

python中有许多内置函数，不像print那么广为人知，但它们却异常的强大，用好了可以大大提高代码效率。

Python3 内置函数

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()

逻辑判断：

all()：全部值为真，返回True。空值为真值

any()：任意一个值为真返回True

数学运算：

abs()：绝对值

divmod(x, y)：两个数字相除(x / y)，返回商和余数的元组

len()：返回列表、字符串、字典、元组、set的长度，字典长度按照字典的key计算

max(iterable)：返回列表、字符串、字典、元组、set中的最大值

min(iterable)：返回列表、字符串、元组、元组、set中的最小值

pow(x, y)：返回x的y次幂

range(start, stop, step)：返回一个从start开始，步长我step的不包含stop的迭代器

round(x, n)：返回x(整型、浮点数)的n位四舍五入的小数，n为0则取整

sum(iterable)：返回列表、元组、set中数字的总和

类型转换：

bool()：将非布尔类型转换为布尔类型，可以接受任意类型参数，在流程控制中可以不使用bool()方法，非空数据为真

bin(int)：十进制转换为二进制

hex(int)：十进制转换为十六进制

oct(int)：十进制转换为八进制

float(int)：将十进制整数转换为浮点数

int(obj)：将浮点数转换为整数

str(obj)：将对象转换为字符串，调用类中的__str__()方法，可读性好，为使用者准备，没有__str__()方法则调用__repr__()

repr()：调用类中的__repr__()方法，表示清楚，为开发者准备

byte(str, code)：接受一个字符串，和目标编码格式，返回一个字节流类型

iter(iterable)：接收一个列表、set、元组、字典(返回值的迭代器)、字符串，返回一个迭代器

dict(iterable)：接受一个包含一个key和value的可迭代对象，返回一个迭代器

list(itrable)：将元组、字典的键、set、字符串转换为列表类型，返回一个列表

tuple(iterable)：将列表、字典的键、set、字符串转换为元组类型

set(iterable)：创建一个无序不重复元素的集合

frozenset()：创建一个无序不可变元素的集合，相对于set()来说，set()是可变的

complex()：创建一个复数对象，可以是j或J

enumerate(seq, start=0)：接受一个序列，返回一个枚举对象的元组，包括下标和值，start表示开始的下标

ord(str)：返回ASCII对应的十进制整数

chr(int)：接受0-256的整数，返回整数对应的ASCII字符

ascii()：判断参数是否是ASCII编码，如果不是，输出字节码

高阶函数：

filter(func, iterable)：遍历序列中的每个元素，判断每个元素得到布尔值，如果是True则留下。func参数对传入的数据进行判断，返回一个布尔值，True则保留在新列表，False则过滤掉。接受两个参数，一个是函数，一个是可迭代对象。

import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
 
out:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
"""

 map(func, *iterable) ：处理序列中的每一个元素，得到的结果是一个list，该list元素个数及位置与原来一样，返回一个迭代器。func参数对传入的每一个元素进行处理，之后添加到新的序列中相同的位置。接受两个参数，一个函数地址，一个可迭代对象

l4 = map(lambda x,y:(x ** y,x + y),[1,2,3],[1,2])
for i in l4:
    print(i)
""" 长度不一致，多出的元素不处理
out:
(1, 2)
(4, 4)
"""

reduce(func, iterable)：对序列元素进行累计运算，func参数实现累计运算的逻辑，累加、累乘等，返回一个累计运算的结果。接受两个参数，函数名和可迭代对象

# 
from functools import reduce


def prod(x,y):   
    # 累乘运算  
    return x * y




print(reduce(prod, [2, 4, 5, 7, 12]))




"""
out:
3360
"""

序列排序：

reversed(sequence)：返回一个反转序列的迭代器

a = reversed(range(10))
list(a)


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

sorted(iterable, cmp, key, reverse)：对所有可迭代对象进行排序操作 sort与sorted区别：sort是应用在list上的方法，sorted可以对所有可迭代对象进行操作．

list的sort方法会对原列表进行操作，无返回值，而内建函数sorted方法不会进行原地操作，而是返回一个新的list

参数：

iterable：可迭代对象 cmp：比较的函数，大于则返回1，小于则返回-1，等于则返回0 key：用来比较的元素，只有一个参数，具体函数的参数就是取自可迭代对象中，指定可迭代对象中一个参数进行排序 reverse：排序规则，True降序，False升序

>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

其他

zip([iterable, ...])：将可迭代对象作为参数，将对象中对应的元素打包成一个元组，返回元组组成的对象，节约内存．可以使用list()和dict()来转换这个对象

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 返回一个对象，这个对象类似于迭代器，使用一次后变成空
>>> list(zipped)  # 使用一次之后，zip对象变成空
[(1, 4), (2, 5), (3, 6)]
>>> dict(zipped)
{1: 4, 2: 5, 3: 6}
>>> a1, b1 = zip(*zip(a, b))  # zip(*)解压对象，得到二维矩阵
>>> list(a1)
[1, 2, 3]
>>> list(b1)
[4, 5, 6]

eval(expression, globals, locals)：用来执行一个字符串表达式，并返回表达式的值 参数：

expression：表达式字符串

globals：变量作用于，全局命名空间，必须是一个字段对象

locals：变量作用域，局部命名空间，可以是任何映射对象

# 
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
 

exec(object, globals, locals) 参数：

object：必选参数，表示需要的指定的Python代码．它必须是字符串或者code对象，如果object是一个字符串，则该字符串先被解析成Python语句，然后执行．如果object是一个code对象，值会被简单执行 globals：可选，表示全局命名空间，必须是一个字典对象 locals：可选，表示局部命名空间，可以是任何对象，如果被忽略，会去与globals相同的值 没有返回值

exec('print("Hello World")')
Hello World
In [12]:  x = 10 
    ...: expr = """ 
    ...: z = 30 
    ...: sum = x + y + z 
    ...: print('x:', x) 
    ...: print('y:', y) 
    ...: print('z:', z) 
    ...: print(sum) 
    ...: """ 
    ...: def func(): 
    ...:     y = 20 
    ...:     exec(expr) 
    ...:     exec(expr, {'x': 1, 'y': 2}) 
    ...:     exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4}) 
    ...: func()
x: 10
y: 20
z: 30
60
x: 1
y: 2
z: 30
33
x: 1
y: 3
z: 30
34

callable(object)：检查一个对象是否可以调用，返回True，则对象可以被调用，False对象不可被调用

# 
callable('school')
False
super(type, object-or-type)：用语调用父类的方法，用来解决多继承的问题
class A:
    def add(self, x):
        y = x + 1
        print(y)
class B(A):
    def add(self, x):
        super().add(x)


b = B()
b.add(2)  # 3

__import__(name, globals, locals, fromlist, level)：用语动态加载类和函数，如果一个模块经常变化，就可以使用__import__()来动态载入．返回一个元组列表．

参考：无独有偶ZYX https://www.jianshu.com/p/58cf6f3bc4c1

《python小白入门系列教程》

01-python安装与特色介绍	02-python你应该知道这些
03-python—9个基础常识	04-python-15种字符串操作
05-列表-元祖-字典-集合操作	06 python循环与分支
07-Python函数详解	08-python中的包与模块关于
09-文件处理与输入输出	10-python面向对象
11-python异常处理	12-python时间处理大全

IT入门 感谢关注

程序员题库→ 程序员用的单词表→ 练习地址：www.520mg.com/it