您现在的位置是:首页 > 学无止境 > 其他网站首页其他 Python内置函数(一)

Python内置函数(一)

  • 莫愁
  • 其他
  • 2019-07-28
简介Python解释器内置了很多函数和类型,可以随时随地在编程中使用。其实,我们在前面的学习中已经接触过好多内置函数。

字数 9895

Python解释器内置了很多函数和类型,可以随时随地在编程中使用。其实,我们在前面的学习中已经接触过好多内置函数。

内置函数

这里把它们总结成下面的表格,方便我们学习它们的使用:

内置函数列表

说明:
上面这个表格包含的有“内置函数”和“内置类型”,其中的内置类型可以作为函数使用,把其它类型的对象转变为该类型的对象。比如int是一个内置类型,int('123')就是把字符串转换成整数。两者在使用上没有什么区别,官方文档中也是把内置类型当做内置函数介绍的。

通过ipython,我们可以查看表格中的是函数还是类型。比如:

In [14]: abs?Signature: abs(x, /)Docstring: Return the absolute value of the argument.Type:      builtin_function_or_methodIn [15]: int?Init signature: int(self, /, *args, **kwargs)Docstring:     int(x=0) -> integerint(x, base=10) -> integerConvert a number or string to an integer, or return 0 if no argumentsare given.  If x is a number, return x.__int__().  For floating pointnumbers, this truncates towards zero.If x is not a number or if base is given, then x must be a string,bytes, or bytearray instance representing an integer literal in thegiven base.  The literal can be preceded by '+' or '-' and be surroundedby whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.Base 0 means to interpret the base from the string as an integer literal.>>> int('0b100', base=0)4Type:           typeSubclasses:     bool, IntEnum, IntFlag, _NamedIntConstant

在ipython里面通过问号?来查看其对应的说明,其中的Type就是它的类型,可以看到abs是一个内置函数builtin_function_or_method,而int是一个类型type

我们把这些内置函数(类型)分成几类进行介绍。

 

数值型操作

abs(x)
求x的绝对值。x可以是整数或浮点数,如果是复数则返回它的模。

bin(x)
将一个整数转变为一个前缀为0b的二进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象,那它需要定义 index() 方法返回一个整数。比如:

In [26]: bin(5)Out[26]: '0b101'In [27]: bin(-5)Out[27]: '-0b101'

x 不能是浮点数,否则会报错。
还可以通过format()函数来进行转换:

In [30]: format(5, '#b')Out[30]: '0b101'In [31]: format(5, 'b')Out[31]: '101'

还可以用f-string格式化来转换:

In [32]: f'{5:#b}'Out[32]: '0b101'In [33]: f'{5:b}'Out[33]: '101'

chr(i)
返回 Unicode 码位为整数 i 的字符的字符串格式。例如,chr(97) 返回字符串 ‘a’,chr(20013) 返回字符串 ‘中’。这是 ord() 的逆函数。

实参的合法范围是 0 到 1,114,111(16 进制表示是 0x10FFFF)。如果 i 超过这个范围,会触发 ValueError 异常。

divmod(a, b)
它将两个(非复数)数字作为实参,并在执行整数除法时返回一对商和余数。对于混合操作数类型,适用双目算术运算符的规则。对于整数,结果和 (a // b, a % b) 一致。对于浮点数,结果是 (q, a % b) ,q 通常是 math.floor(a / b) 但可能会比 1 小。在任何情况下, q * b + a % b 和 a 基本相等;如果 a % b 非零,它的符号和 b 一样,并且 0 <= abs(a % b) < abs(b) 。

format(value[, format_spec])
将 value 转换为 format_spec 控制的“格式化”表示。

hex(x)
将整数转换为以“0x”为前缀的小写十六进制字符串。如果 x 不是 Python int 对象,则必须定义返回整数的 index() 方法。

oct(x)
将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象,那它需要定义 index() 方法返回一个整数。

ord(c)
对表示单个 Unicode 字符的字符串,返回代表它 Unicode 码点的整数。例如 ord(‘a’) 返回整数 97, ord(‘€’) (欧元符合)返回 8364 。这是 chr() 的逆函数。

pow(x, y[, z])
返回 x 的 y 次幂;如果 z 存在,则对 z 取余(比直接 pow(x, y) % z 计算更高效)。两个参数形式的 pow(x, y) 等价于幂运算符: x**y

round(number[, ndigits])
返回精确到小数点后ndigits精度的数。 如果省略ndigits或者为None,则返回其输入的最接近的整数。

对于支持round()的内置类型,值被舍入离前一位更近的一端(四舍六入); 如果距离两端相等(5)则保留到偶数一边。(例如,round(0.5)和round(-0.5)均为0,round(1.5)为2)。 任何整数值对ndigits(正数,零或负数)有效。如果省略ndigits或None,则返回值为整数。 否则返回值与number的类型相同。

对于一般的Python对象number,将代理舍入为number.__round__

注释: round()对于浮点数的行为可能令人惊讶,比如,round(2.675, 2)得出2.67,而不是期望的2.68。这不是bug,这是因为大多数十进制小数不能准确表示为二进制的浮点数。

sum(iterable[, start])

start开始由左到右累加可迭代的元素并返回总数。start默认为0. iterable的项通常是数字,起始值不允许是字符串。

对于某些用例,sum()有很好的替代方法。 连接字符串序列的首选快速方法是调用''.join(sequence)。 要以扩展精度累加浮点值,就用math.fsum()。要拼接一系列可迭代对象就考虑使用itertools.chain()

 

可迭代操作

all(iterable), any(iterable)
这两个函数,我们在前面学习list、dict等数据结构时已经多次学习。
all(): 如果iterable的所有元素都为真(或iterable为空)返回True;等价于:

def all(iterable):    for item in iterable:        if not item:            return False    return True

any():如果iterable的任一个元素为真则返回True。如果iterable为空,则返回False。等价于:

def any(iterable):    for item in iterable:        if item:        return True    return False

enumerate(iterable, start=0)
返回一个枚举对象。iterable 必须是一个序列,或 iterator,或其他支持迭代的对象。 enumerate() 返回的迭代器的 next() 方法返回一个元组,里面包含一个计数值(从 start 开始,默认为 0)和通过迭代 iterable 获得的值。

In [4]: ll = ['a', 'b', 'c', 'd']In [5]: list(enumerate(ll))Out[5]: [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]In [6]: list(enumerate(ll, start=1))Out[6]: [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

等价于:

def enumerate(sequence, start=0):    n = start    for elem in sequence:        yield n, elem        n += 1

filter(function, iterable)
用 iterable 中函数 function 返回真的那些元素,构建一个新的迭代器。iterable 可以是一个序列,一个支持迭代的容器,或一个迭代器。如果 function 是 None ,则会假设它是一个身份函数,即 iterable 中所有返回假的元素会被移除。

请注意, filter(function, iterable) 相当于一个生成器表达式,当 function 不是 None 的时候为 (item for item in iterable if function(item));function 是 None 的时候为 (item for item in iterable if item) 。
只有 function 返回 false 时才选取 iterable 中元素的补充函数。

map(function, iterable, …)
产生一个将 function 应用于迭代器中所有元素并返回结果的迭代器。如果传递了额外的 iterable 实参,function 必须接受相同个数的实参,并使用所有迭代器中并行获取的元素。当有多个迭代器时,最短的迭代器耗尽则整个迭代结束。如果函数的输入已经是元组实参,请参阅 itertools.starmap()。

zip(*iterables)
创建一个聚合来自每个可迭代的元素的迭代器。

返回元组的迭代器,其中第i个元组包含来自每个参数序列或迭代的第i个元素。当最短输入可迭代用尽时,迭代器停止。使用单个iterable参数,它返回一个1元组的迭代器。没有参数,它返回一个空迭代器。相当于:

def zip(*iterables):    # zip('ABCD', 'xy') --> Ax By    sentinel = object()    iterators = [iter(it) for it in iterables]    while iterators:        result = []        for it in iterators:            elem = next(it, sentinel)            if elem is sentinel:                return            result.append(elem)        yield tuple(result)

保证了迭代的从左到右的评估顺序。 这使得使用zip(*[iter(s)]*n)将数据系列聚类成n长度组的习惯成为可能。这会重复相同的迭代器n次,以便每个输出元组具有n次调用迭代器的结果。这具有将输入分成n长度块的效果。

当你不关心较长迭代的尾随,不匹配的值时,zip()只应与不等长度输入一起使用。如果这些值很重要,请改用itertools.zip_longest()

zip()与*运算符一起用于解压缩列表:

In [80]: a = [1, 2, 3]In [81]: b = ['a', 'b', 'c']In [82]: zipped = zip(a, b)In [83]: list(zipped)Out[83]: [(1, 'a'), (2, 'b'), (3, 'c')]In [84]: a2, b2 = zip(*zip(a, b))In [85]: a == list(a2) and b == list(b2)Out[86]: True

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
返回可迭代对象中最大的元素,或者返回两个及以上实参中最大的。

如果只提供了一个位置参数,它必须是非空 iterable,返回可迭代对象中最大的元素;如果提供了两个及以上的位置参数,则返回最大的位置参数。

有两个可选只能用关键字的实参。key 实参指定排序函数用的参数,如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空,并且没有给 default ,则会触发 ValueError。

如果有多个最大元素,则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])
返回可迭代对象中最小的元素,或者返回两个及以上实参中最小的。

如果只提供了一个位置参数,它必须是 iterable,返回可迭代对象中最小的元素;如果提供了两个及以上的位置参数,则返回最小的位置参数。

有两个可选只能用关键字的实参。key 实参指定排序函数用的参数,如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空,并且没有给 default ,则会触发 ValueError。

如果有多个最小元素,则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable, key=keyfunc) 保持一致。

reversed(seq)
返回反向迭代器。seq必须是一个具有reversed()方法的对象,或者支持序列协议(len()方法和getitem()方法,整数参数从0开始)。

sorted(iterable, *, key=None, reverse=False)

从iterable中的项返回一个新的排序列表。

有两个可选参数,必须指定为关键字参数。

key指定一个参数的函数,该函数用于从iterable中的每个元素中提取比较键(例如,key = str.lower)。默认值为None(直接比较元素)。

reverse是一个布尔值。 如果设置为True,则列表元素将按照每个比较相反的方式进行排序。

使用functools.cmp_to_key()将旧式cmp函数转换为键函数。

内置的sorted()函数保证稳定。 如果排序保证不改变比较相等的元素的相对顺序,则排序是稳定的 – 这有助于多次传递排序(例如,按部门排序,然后按工资等级排序)。

iter(object[, sentinel])
返回一个 iterator 对象。根据是否存在第二个实参,第一个实参的解释是非常不同的。如果没有第二个实参,object 必须是支持迭代协议(有 iter() 方法)的集合对象,或必须支持序列协议(有 getitem() 方法,且数字参数从 0 开始)。如果它不支持这些协议,会触发 TypeError。如果有第二个实参 sentinel,那么 object 必须是可调用的对象。这种情况下生成的迭代器,每次迭代调用它的 next() 方法时都会不带实参地调用 object;如果返回的结果是 sentinel 则触发 StopIteration,否则返回调用结果。

next(iterator[, default])
通过调用 iterator 的 next() 方法获取下一个元素。如果迭代器耗尽,则返回给定的 default,如果没有默认值则触发 StopIteration。

 

内置类型

class bool([x])
说明:在文档中,函数的参数用方括号[]括起来表示这个参数可有可无(在参数列表中)。
内置类型,返回一个布尔值:True或者Falsex使用标注的真值测试过程来转换,关于真值测试的知识可以再回顾一下前面我们关于布尔值的章节。
bool类是int的子类,这个bool类很特别,它不能被继承,且只有TrueFalse两个实例。

class bytearray([source[, encoding[, errors]]])
返回一个新的 bytes 数组。 bytearray 类是一个可变序列,包含范围为 0 <= x < 256 的整数。它有可变序列大部分常见的方法,同时有 bytes 类型的大部分方法。
可选形参 source 可以用不同的方式来初始化数组:

如果是一个 string,您必须提供 encoding 参数(errors 参数仍是可选的);bytearray() 会使用 str.encode() 方法来将 string 转变成 bytes。

  • 如果是一个 integer,会初始化大小为该数字的数组,并使用 null 字节填充。
  • 如果是一个符合 buffer 接口的对象,该对象的只读 buffer 会用来初始化字节数组。
  • 如果是一个 iterable 可迭代对象,它的元素的范围必须是 0 <= x < 256 的整数,它会被用作数组的初始内容。

如果没有实参,则创建大小为 0 的数组。

class bytes([source[, encoding[, errors]]])
返回一个新的“bytes”对象, 是一个不可变序列,包含范围为 0 <= x < 256 的整数。bytes 是 bytearray 的不可变版本 – 它有其中不改变序列的方法和相同的索引、切片操作。

因此,构造函数的实参和 bytearray() 相同。

class complex([real[, imag]])
返回值为 real + imag*1j 的复数,或将字符串或数字转换为复数。如果第一个形参是字符串,则它被解释为一个复数,并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型(包括复数)。如果省略了 imag,则默认值为零,构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略,则返回 0j。

注解 当从字符串转换时,字符串在 + 或 – 的周围必须不能有空格。例如 complex(‘1+2j’) 是合法的,但 complex(‘1 + 2j’) 会触发 ValueError 异常。
在 3.6 版更改: 您可以使用下划线将代码文字中的数字进行分组。

class float([x])
返回从数字或字符串 x 生成的浮点数。

如果实参是字符串,则它必须是包含十进制数字的字符串,字符串前面可以有符号,之前也可以有空格。可选的符号有 ‘+’ 和 ‘-‘ ; ‘+’ 对创建的值没有影响。实参也可以是 NaN(非数字)、正负无穷大的字符串。

class int([x])
class int(x, base=10)
返回一个使用数字或字符串 x 生成的整数对象,或者没有实参的时候返回 0 。如果 x 定义了 int(),int(x) 返回 x.int() 。如果 x 定义了 trunc(),它返回 x.trunc() 。对于浮点数,它向零舍入。

如果 x 不是数字,或者有 base 参数,x 必须是字符串、bytes、表示进制为 base 的 整数文字 的 bytearray 实例。该文字前可以有 + 或 – (中间不能有空格),前后可以有空格。一个进制为 n 的数字包含 0 到 n-1 的数,其中 a 到 z (或 A 到 Z )表示 10 到 35。默认的 base 为 10 ,允许的进制有 0、2-36。2、8、16 进制的数字可以在代码中用 0b/0B 、 0o/0O 、 0x/0X 前缀来表示。进制为 0 将安照代码的字面量来精确解释,最后的结果会是 2、8、10、16 进制中的一个。所以 int(‘010’, 0) 是非法的,但 int(‘010’) 和 int(‘010’, 8) 是合法的。

class str(object=”)
class str(object=b”, encoding=’utf-8′, errors=’strict’)

返回一个str类型的对象。str是内置字符串类

class list([iterable])
除了是函数,list 也是可变序列类型,详情请参阅 列表 和 Sequence Types — list, tuple, range。

tuple([iterable])
元组是内置的不可变序列类型。tuple()生成一个元组对象,可选参数iterable的元素将被加入到新元组。

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
创建一个新的字典。dict 对象是一个字典类
其他容器类型,请参见内置的 list、set 和 tuple 类,以及 collections 模块。

class set([iterable])
返回一个set对象。可选参数iterable的元素将被加入新set对象里面。

class frozenset([iterable])
返回一个新的 frozenset 对象,它包含可选参数 iterable 中的元素。 frozenset 是一个内置的类。

class object
返回一个没有特征的新对象。object 是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。

注解 由于 object 没有 dict,因此无法将任意属性赋给 object 的实例。

class range(stop)
class range(start, stop[, step])
range其实是个不可变数字序列类型而不是一个函数,通常用于在for循环中循环特定次数。
传给range的实参必须是整数(或是内置类型int,或是实现了index这个特殊方法的对象)。如果step参数省略了,则它默认为1.如果start省略了则默认为0。如果step为0,则报错:ValueError

如果step为整数,range 的内容决定于公式:r[i] = start + step*i,其中i >= 0, r[i] < stop

如果step是负数,range 的内容仍决定于公式:r[i] = start + step*i,其中i >= 0, r[i] > stop

如果r[0]不满足值约束,则range对象将为空。 range确实支持负索引,但这些索引被解释为从正索引确定的序列末尾开始的索引。

range被允许包含绝对值大于sys.maxsize的值,但是某些特性(如len())可能会报错:OverflowError
参看下面range的例子:

In [32]: list(range(9))Out[32]: [0, 1, 2, 3, 4, 5, 6, 7, 8]In [33]: list(range(3,9))Out[33]: [3, 4, 5, 6, 7, 8]In [34]: list(range(0, 20, 3))Out[34]: [0, 3, 6, 9, 12, 15, 18]In [35]: list(range(0, -10, -1))Out[35]: [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]In [36]: list(range(0))Out[36]: []In [37]: list(range(10, 0))Out[37]: []

range类型比通常的list或tuple的优点是,range对线下总是占用相同(小的)数量的内存,不管它表示的范围有多大。因为它只存储startstopstep的值,在需要的时候才计算单独的元素或子范围。

range对象实现了类似list或tuple序列的特性,比如包含测试,元素索引查找,切片和对负索引的支持。参见下面的例子:

In [43]: r = range(0, 10, 2)In [44]: rOut[44]: range(0, 10, 2)In [45]: 5 in rOut[45]: FalseIn [46]: 6 in rOut[46]: TrueIn [47]: r.index(8)Out[47]: 4In [48]: r[3]Out[48]: 6In [49]: r[:3]Out[49]: range(0, 6, 2)In [50]: r[-1]Out[50]: 8

通过==!=测试两个range对象的相等性是把它们当做序列进行比较。也就是说,如果两个range对象表示相同的值的序列就认为它们实时相等的。

注意:两个range对象相等但可能含有不同的startstopstep属性,比如range(0) == range(2, 1, 1)或者range(0, 3, 2) == range(0, 4, 2)

class slice(stop)
class slice(start, stop[, step])

返回一个切片对象,表示由range(start,stop,step)指定的索引集。start和step参数默认为None。Slice对象具有只读数据属性start,stop和step,它们只返回参数值(或它们的默认值)。他们没有其他明确的功能;但是它们被Numerical Python和其他第三方扩展使用。使用扩展索引语法时也会生成切片对象。例如:a[start:stop:step]或a[start:stop,i]。

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

传入一个参数object,则返回该对象的类型。返回值是一个type对象,通常和object.__class__返回的一样。
建议使用isinstance()内置函数来测试对象的类型,因为它需要考虑子类。
使用三个参数,返回一个新类型对象。 这实际上是类语句的动态形式。 名称字符串是类名,并成为name属性; 基元元组列出基类并成为bases属性; 并且dict字典是包含类主体定义的命名空间,并被复制到标准字典以成为dict属性。 例如,以下两个语句创建相同的类型对象:

In [77]: class A:     ...:     a = 1     ...:In [78]: A = type('A', (object,), dict(a=1))

编程中使用。其实,我们在前面的学习中已经接触过好多内置函数。


转载: 感谢您对莫愁个人博客网站平台的认可,非常欢迎各位朋友分享到个人站长或者朋友圈,但转载请说明文章出处“来源莫愁个人博客 https://www.mochoublog.com/study/290.html”。

文章评论

    • 评论
    人参与,条评论

技术在线

服务时间

周一至周日 12:00-22:00

关闭下雪
关闭背景特效

最新文章