一篇文章弄懂Python中的内建函数

前言

python内建函数指的是python自带的函数，这种函数不需要定义，并且不同的内建函数具有不同的功能，可以直接使用。

A类

abs() 函数，返回数字的绝对值。

语法：abs(x)

参数 x ― 数值表达式

函数返回 x（数字）的绝对值;

例子1：

all() 函数，判断给定的可迭代参数 ble 中的元素是否都为 True，若是返回 True，反之返回 False;

元素除了是 0、空、False、None外 都算 True;

语法：all(iterable)

参数: iterable ― 元组或列表

若 iterable 的所有元素不为 0、‘ '、False、或 ble 为空，函数返回 True，反之返回 False；

注意： 空元组、空列表返回值为 True，需要特别注意；

例子2：

any() 函数，判断给定的可迭代参数 ble 是否全部为 False，若是返回 False，若有一个为 True，返回 True；
元素除了是 0、空、False 外都算是 True；

语法：any(iterable)

参数：iterable ― 元组或列表

若都为 空、0、False ，返回 False，若不都为 空、0、False，返回 True ;

例子3：

B类

basestring() 方法，是 str 和 unicode 的超类（父类），也是抽象类，不能被调用和实例化，但可用来判断一个对象是否为 str 或 unicode 的实例；isinstance(obj,(str,unicode)) 等价于 isinstance(obj,bsestring)；

语法：basestring()

例子4：

注意：Python 3 不支持 basestring（）函数，应改用 str（）函数。

bin() 函数，返回一个整数 int 或长整数 long int 的二进制表示。

语法：bin(x)

参数：x ― int 或 long int 数字

返回 x 的二进制表示；

例子5：

bool() 函数，将给定参数转换为布尔类型，若没有参数，返回 false;

bool 是 int 的子类；

语法：calss bool([x])

参数：x ― 要进行转换的参数

返回 True 或 False；

例子6：

bytearray() 函数，返回一个新字节数组；数组的元素是可变的，每个元素的值范围 0 <= x <256 ；

语法：calss bytearray([source[,encoding[,errors]]])

参数：若 source 为整数，返回一个长度为 source 的初始化数组；

若 source 为字符串，按照指定的 encoding 将字符串转换为字节序列；

若 source 为可迭代类型，元素必须为 [0，256] 中的整数；

若 source为与 buffer 接口一致的对象，此对象也可被用于初始化 bytearray ；

若没有输入任何参数，默认就是初始化数组为 0 个元素；

返回新字节数组。

例子7：

C类

callable() 函数，检查一个对象是否为可调用；若返回 True ，ble 仍可能调用失败；若返回 False ，调用对象 ble 肯定不会成功。

函数、方法、lambda 函式、类及实现了 call 方法的类实例，都会返回 True。

语法：callable(object)

参数： object ― 对象

当对象可调用时返回 True，反之返回 False；

例子8：

chr() 函数，用一个范围在 range（0~256）内的整数作为参数，返回一个对应的字符；

语法：chr(i)

参数：i ― 为10进制或16进制的形式的数字

返回值是当前整数对应的 ASCII 字符；

例子9：

classmethod 修饰符，对应的函数不用实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可用来调用类的属性，类的方法，实例化对象等；

语法：classmethod

返回函数的类方法；

例子10：

compile() 函数，讲一个字符串编译为字节代码。

语法：compile(source,filename,mode[,flags[,dont_inherit]])

参数：source ― 字符串或 AST（Abstract Syntx Trees）对象；

filename ― 代码文件名称，若不是从文件读取代码则传递一些可辨认的值；

mode ― 指定编译代码的种类。可指定为 exec，eval，single；

flags ― 变量作用域，局部命名空间，若被提供，可以是任何映射对象；

flags 和 dont_inherit 是用来控制编译源码时的标志；

返回表达式执行结果；

例子12：

cmplex() 函数，创建一个值为 real + imag * j 的复数或转化一个字符换或数为复数。若第一个参数为字符串，则不需要指定第二个参数；

语法：class complex([real[,imag]])

参数：real ― int、long、float 或 字符串；

imag ― int、long、float；

返回一个复数；

例子13：

注意： ‘3+8j' 的 ‘+' 号两边不能有 空格，否则会报错

D类

delattr() 函数，删除属性；

delattr( x,‘foobar' ) 等价于 del x. foobar ；

语法：delattr(object.name)

参数：object ― 对象；

name ― 必须是对象的属性；

例子14：

dict() 函数，创建一个字典。

语法：class dick(**kwargs) class dict(mpping,**kwarg) class dict(iterable,**kwarg)

参数：**kwarge ― 关键字；

mapping ― 元素的容器；

iterable ― 可迭代对象；

返回一个字典；

例子15：

**dir()**函数，不带参数时，返回当前范围内的变量、方法 和 定义的类型列表；带参数时，返回参数的 属性、方法、列表。若参数包含方法 __dir()__ ，该方法将被调用；若参数不含方法 dir() ，该方法将最大限度地收集参数信息；

语法：dir([object])

参数：object ― 对象、变量、类型

返回模块的属性列表；

例子16：

divmond() 函数，把除法和余数运算结合起来，返回一个包含商和余数的元组（a // b, a%b）；

语法：divmod(a,b)

参数：a ― 数字 ，b ― 数字；

例子17：

我的进行复数运算，报错，可能是有些Python 版本不支持负数运算！

E类

enumerate() 函数，将一个可遍历的数据对象（如 元组、列表或字符串）组合成一个索引序列，同时列出数据和数据下标，常用在 for 循环中；

语法：enumerate（sequence,[start = 0]）

参数： sequence ― 一个序列、迭代器 或其他可支持迭代的对象；

start ― 下标起始位置；

返回 enumerate（枚举）对象；

例子18：

eval() 函数，执行一个字符串表达式，并返回表达式的值；

语法：eval(expression[, globals[, locals]])

参数：expression ― 表达式；

globals ― 变量作用域，全局命名空间，若被提供，则必须是一个字典对象；

locals ― 变量作用域，局部命名空间，若被提供，可为任何映射对象；

返回表达式计算的结果；

例子19：

excfile() 函数，执行一个文件。

语法：excfile(filename[, globals[, locals]])

参数：filename ― 文件名；

globals ― 变量作用域，全局命名空间，若被提供，不需是一个字典对象；

locals ―变量作用域，局部命名空间，若被提供，可是任何映射对象。

返回表达式执行结束;

例子20：

execfile() 函数在 Python3 中用不了，可用 exec () 函数替代；

语法：exec(open("ble").read);

注意：运用 exec() 函数时，必须确保文件时在 Python 解释器当前的目录下，若不在，就算代码没错也会报异常；所以要先import os，调用 os 模块，再os.chdir("文件所在目录")，再用 exec() 函数打开文件；

F类

file() 函数，创建一个 file 对象，也可以叫 open()，都是内置函数；参数以字符串形式传递;

语法：file(name,[, mode[, buffering]])

参数：name ― 文件名；

mode ― 打开模式；

buffering ― 0 表示不缓冲，如果为 1 表示进行行缓冲，大于 1 为缓冲区大小；

例子21：

filter() 函数，过滤序列，过滤不符合条件的元素，返回由符合条件元素组成的列表；接受两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素存放到新列表中；

Python 3.x 返回迭代器对象；

语法：filter(functin , iterable)

参数：function ― 判断函数；

iterable ― 可迭代对象；

返回列表；

例子22：

format() 函数，接受不限个参数，位置随意；str.format()，格式化字符串，函数增强了字符串格式化的功能；
语法：用 {} 、: 代替 %；

例子23：

str.format() 格式化数字的方法如下所示：

frozenset() 函数，返回一个冻结的集合，冻结点后的集合不能再添加、删除任何元素；

语法：class frozenset([bba])

返回新的 ble 对象，若不提供任何参数，默认生成空集合；

例子24：

G类

getattr() 函数，返回一个对象属性值；

语法：getattr(object,name [, default])

参数：object ― 对象；

name ― 字符串，对象属性；

default ― 默认返回值，若不提供该参数，没有队形属性时，会出发 AttributeError;

返回对象属性；

例子25：

globals() 函数，以字典类型返回当前位置的全局变量；

语法：flobals()

返回全局变量的字典；

例子26：

H类

hasattr() 函数，判断对象是否包含对应的属性；

语法：hasattr(object,name)

参数：object ― 对象；

name ― 字符串，属性名；

若对象有该属性会返回 True，反之返回 False；

例子27：

hash() 函数，获取一个对象（字符串或数值等）的哈希值；

语法：hash(object)

参数：object ― 对象；

返回对象的哈希值；

例子28：

help() 函数，查看函数或块等的帮助说明；

语法：help([object])

参数：object ― 对象

例子29：

hex() 函数，将十进制整数转换为十六进制，以字符串形式表示；

语法：hex(x)

参数：x ― 十进制整数

例子30：

I类

id() 函数，返回对象的唯一标识符，标识符是一个整数；

CPython（即官方版本解释器，这解释器是用C语言开发的）中 id() 函数用于获取对象的内存地址；

语法：id([object])

参数：object ― 对象

返回对象的内存地址；

例子31：

input() 函数，接收一个标准输入数据，返回 string 类型；

input()，能够读取一个合法的 Python 表达式（即输入的字符串必须括起来，否者会抛出异常）；Python 3 里的 input() 默认接受的是 str 类型；

语法：input([prompt])

参数：prompt ― 提示信息

注意：在 Python 3.8.0 中已经取消了 raw_iput；

例子32：

int() 函数，将一个数字或字符串转换为整型， 返回整型数据；

语法：class int(z,base = 10)

参数：z ― 数字或字符串；

base ― 进制数，默认十进制；

例子33：

isinstance() 函数，判断一个对象是否是一个已知的类型，和 tpye() 类似；

isinstance() 与 tpye() 的区别：

tyep() 不会认为子类是一种父类类型，不考虑继承关系；

ininstance（）会认为子类是一种父类类型，考虑继承关系；

语法：isinstance(object,classinfo)

参数：object ― 实例对象；

classinfo ― 可是直接或间接类名、基本类型或由他们组成的元组；

若对象的类型与参数的类型（classionfo）相同则返回 True，反之返回 False；

例子34：

issubclass() 函数，判断参数 class 师傅是类型参数 classinfo 的子类；

语法：issubclass(class,classinfo)

参数：class ― 类；

classinfo ― 类；

若 class 是 classinfo 的子类返回 True，否则返回 False；

例子35：

iter() 函数，生成迭代器；

语法：iter(object[,sentinel])

参数：object ― 支持迭代的集合对象；

sentine ― 若出传递第二个参数，参数 object 必须是一个可调用的对象（如：函数）；iter() 创建了一个迭代器对象，每次调用这个对象的 __next__ 方法时，都会 object；

例子36：

L类

len() 函数，返回对象（字符、列表、元组等）长度或项目的元素个数；

语法：len(n)

参数：n ― 对象

例子37：

list() 函数，将元组转换为列表（元组跟列表非常类似，区别于元素的元组不能修改，元组是放在括号中，列表是放于方括号中）；

语法：list(tuple)

参数：tuple ― 要转换为列表的元组

例子38：

locals() 函数，以字典类型返回当前位置的全部局部变量；对于函数、方法、lambda 函数、类，以及实现了__call__方法的类实例，都返回 True；

语法：locals()

返回字典类型的局部变量；

例子39：

M类

map() 函数，根据提供的函数指定序列做映射；

第一个参数 function 以参数序列中的每一个元素调用 funciton 函数，返回包含每次 function 函数返回值的新列表；

语法：map(function,iterable, ...)

参数：function ― 函数；

iterable ― 一个或多个序列；

返回迭代器；

例子41：

max() 函数，返回给定参数的最大值，参数可以是序列；

语法：max(x,y,z, ... )

参数：x、y、z ― 数值表达式

例子42：

memoryview() 函数，返回给定参数的内存查看对象（memory view）；内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象的基础上允许 Python 代码访问；

语法：memoryview(obj)

参数：obj ― 对象；

返回元组列表；

例子43：

min() 函数，返回给定参数的最小值，参数可以是序列；

语法：min(x,y,z,... )

参数：x、y、z ― 数值表达式

例子44：

N类 next() 函数，返回迭代器下一个项目；搭配生成迭代器的 iter() 函数使用；

语法：next(iterable[, default])

参数：iterable ― 可迭代对象；

default ― 可选，用来设置在没有下一个元素时返回该默认值，若不设置，又没有下一个元素则会触发 Stoplter ation 异常；

例子45：

O类

oct() 函数，将一个整数转换为 八进制字符串；

Python 3.x 的八进制以 0 作为前缀表示；

语法： oct(x)

参数： x ― 整数

返回 八进制字符串；

例子46：

open() 函数，打开一个文件，创建一个 file 对象，相关的方法才可调用它进行读写；

语法：open(name[, mode[, buffering]])

参数：name ― 一个包含了你要访问的文件名称的字符串值；

mode ― 决定了打开文件的模式：只读、写入、追加等；这个参数是非强制性的，默认文件访问模式为只读（r）；所有可取值如下表所示；

buffering ― 若 buffering 的值被设为 0 ，就不会有寄存；若 buffering 的值为 1，访问文件时会寄存行；若将 buffering的值设为大于 1 的整数，表明这就是寄存区的缓冲大小；若取赋值，寄存区的缓冲大小则为系统默认；

Python 的不同模式的完全列表

file 对象方法：

file.read([sizet])：size 未指定则返回整个文件，若文件大小 > 2 倍内存则有问题，f.read() 读到文件尾时返回 “ ”（空字符串）；

file.readline()：返回一行；

file.readlines([size])：返回包含 size 行的列表，size 未指定则会返回全部行；

for line in f : print line ：通过迭代器访问；

f.write(“hello\n”)：若要写入字符以外的数据，先将它转换为字符串；

f.tell()：返回一个整数，表示当前文件指针的位置（就是到文件头的字节数）；

f.seek(偏移量，[起始位置])：用于移动文件指针，

偏移量 ― 单位为字符，正负都可；

起始位置 ― 0，文件头，默认值；1，当前位置；2，文件尾

f.close() :关闭文件

例子47：

ord() 函数，和 chr() 函数（对于 8 位的 ASCII 字符串）或 unichr() 函数（对于 Unicode 对象）的配对函数，以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或 UNicode 数值，若所给的 Unicode 字符超出了 Python 定义范围，会抛出 TypeError 异常；

语法：ord(x)

参数：x ― 字符

返回对应的十进制整数；

例子48：

P类 pow() 函数，返回 幂运算的值（即x的y次方）；

语法：1、 math模块 pow() 方法：

import math
 math.pow(x,y)

2、内置的 pow() 方法

 pow(x,y[,z])

若 z 存在，则再对结果进行取模，即 pow(x,y) %z；

注意： pow() 方法通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会吧参数转换为 float；
参数：x、y、z ― 数值表达式；

例子49：

print() 函数，打印输出，常用到的一个函数；

语法：print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

参数：object ― 复数，表示可一次性输出多个对象，输出多个对象时，需用到 , 逗号分隔；

sep ― 间隔多个对象，默认值是一个空格；

end ― 用来设定什么结尾，默认值是换行符 \n，可换成其他字符；

file ― 要写入的文件对象；

flush ― 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，会被强制刷新；

例子50：

property() 函数，在新式类中返回属性值；

语法：class property([ fget [ , fset [ , fdel [ , doc]]]])

参数：fget ― 获取属性值的函数；

fset ― 设置属性值的的函数；

fdel ― 删除属性值函数；

doc ― 属性描述信息；

例子51：

R类

range() 函数，返回一个可迭代对象（即类型），而不是列表类型，所以打印的时候不会打印列表；

语法：range(start,stip [, step])

参数：start ― 技术从start 开始，默认从 0 开始；

stip ― 技术到 stop 结束，但不包括 stop（即半开区间）；

step ― 步长，默认为 1（与分片的步长相同）；

例子52：

reduce() 函数，对参数序列中元素进行累积；

函数将一个数据集合（链表、元组等）中的所有数据进行：用传给 reduce 中的函数 **function （有两个参数）**先对集合中的第 1、 2 个元素进行操作，得到的结果再与第 3 个数据用 function 函数运算，最后得到一个结果；

注意：Python 3.x 的 reduce() 被移动到 functiools 模块里，若需要使用，可引入 functils 模块来调用 reduce() 函数；from functools import reduce

语法：reduce(function,iterable[, initializer)

参数：function ― 函数，有两个参数；

iterable ― 可迭代对象；

initializer ― 可选，初始参数

返回函数计算结果；

例子53：

reload() 函数，重新载入之前载入的模块；

语法：reload(module)

参数：module ― 模块对象

返回模块对象；

例子54：

repr() 函数，将对象转化为供解释器读取的形式；

语法：repr(object)

参数：object ― 对象

返回一个对象的 string 格式

例子55：

reverse() 函数，作用于反向列表中元素；

语法：list.reverse()

没有返回值，但会对列表中的元素进行反向排序；

例子56：

round() 函数，返回浮点数 x 的四舍五入的值；

语法：round(x [, n])

参数： x ― 数值表达式

n ― 数值表达式，表示小数点位数；

例子57：

S类

set() 函数，创建一个无序不重要的元素集，可以进行关系测试，用来删除重复数据、计算交集、差集、并集等；

语法：class set([iterable])

参数：iterable ― 可迭代对象

返回新的集合对象；

例子58：

setattr() 函数，和 getattr() 为对应函数，用来设置属性值，该属性不一定是存在的；

语法：setattr(object, name, value)

参数：object ― 对象；

name ― 字符串，对象属性；

value ― 属性值；

例子59：

slice() 函数，对对象进行切片，主要是切片操作函数里的参数传递；

语法：

class slice(stop)

 class slice(start,stip [, step])

参数：start ― 其实位置；

stop ― 结束位置；

step ― 简距；

返回一个切片对象；

例子60：

sorted() 函数，对所有可迭代的对象进行排序；

注意：sort 与 sorted 区别：

sort 是应用在 list （列表）上的方法，sorted 可对所有的迭代的对象进行排序；

list 里的 sort 方法返回的是对已经存在的列表进行操作，无返回值 ；而 sorted 方法返回的是一个新的 list ，不是在原来的基础上进行操作；

语法：sorted(iterable,cmp = Nome,key = Nome,reverse = False)

参数： iterable ― 可迭代对象；

cmp ― 比较函数，具有两个参数，参数的值都是从可迭代对象中取，此函数须遵守：大于则返回 1 ，小于则返回 -1，等于则返回 0；

key ― 用来比较的元素，只有一个参数，具体函数的参数取自可迭代对象中，指定可迭代对象中的要给元素来进行排序；

reverse ― 排序规则，reverse = True 降序，reverse = False 升序（默认）；

返回重新排序的列表；

例子61：

staticmethod() 函数，返回函数的静态方法；

语法：staticmethod(fumction)

例子62：

str() 函数，将对象转化为适合人阅读的形式；

语法：class str(object = ' ')

参数：object ― 对象

返回一个对象的 string 格式；

例子63：

sum() 函数，对序列进行求和计算； 返回计算结果；

语法：sum(iterable[,strart])

参数：iterable ― 可迭代对象（列表、元组、集合）；

start ― 指定相加的参数，若没有设置，默认为0；

例子64：

super() 函数，调用父类（超类）和解决多重继承问题的，直接用类名调用父类方法在使用单继承时没有问题，若使用多继承，会涉及查找顺序（MPO）、重复调用等问题；

语法：super(type[,object-or-type)

参数：type ― 类；

object-or-type ― 类，一般是 self

例子65：

T类

tuple() 函数，将列表转换为元组；加粗样式

语法：tuple(iterable)

参数：iterable ― 要转换为元组的可迭代序列

例子66：

type() 函数，若只有第一个参数则返回对象的类型，三个参数返回新的类型对象；

注意： isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关；

isinstance() 会认为子类是一种父类类型，考虑继承关系；

如果要判断两个类型是否相同推荐使用 isinstance()；

语法：

type(object)
type(name, bases, dict)

参数：name ?C 类的名称；

bases ?C 基类的元组；

dict ?C 字典，类内定义的命名空间变量；

例子67：

V类 vars() 函数，返回对象 object 的属性和属性值的字典对象；

语法：vars([object])

参数：object ― 对象

返回对象 object 的属性和属性值的字典对象，若没有参数，就打印当前调用位置的属性和属性值，类似 locals();

例子68：

Z类

zip() 函数，将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表；

若各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表；

语法：zip([iterable,...])

参数：iterabl ― 一个或多个迭代器

返回一个对象；

例子69：

__import__() 函数，用于动态加载类和函数，若一个模块经常变化就可用 __import__() 来动态载入；

语法：__import__(name[,globals[,locals[,fromlist[,level]]]])

参数：name ― 模块名

返回元组列表；

例子70：

总结