前言

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 – 类的名称；

bases – 基类的元组；

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

例子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：

总结

到此这篇关于Python中内建函数的文章就介绍到这了,更多相关Python内建函数内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！