[Python知识库]python内置函数

逻辑相关

bool(obj)

返回True或False。对于对象而言，在默认情况下都是返回True，只有当该对象所属类定义了__bool__并且返回False，或是定义了__len__返回0。

内置返回False的对象：

• None, False
• 数值为0：0、0.0 等
• 空的序列：’’, (), [], {}, set(), range(0)等

all(iterable)

如果iterable的所有元素均为True，则返回True，等价实现：

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

注意： 如果传入的是空的可迭代对象也是返回True

any(iterable)

如果iterable的其中一个元素为True则返回True，等价实现：

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

callable(obj)

如果obj可被调用(obj()不会触发异常)就返回True

对于对象需要定义__call__方法

类型相关

complex([real[, imag]])

返回一个real+imag*j的复数。如果real是字符串，则将它强转为复数。

对于自定义的对象，查找优先级__complex__ > __float__ > __index__ (python3.8)

class A:
    def __complex__(self):
        return complex(2, 3)
    def __float__(self):
        return 2.1
print(complex(A()))

float(x)

返回数值或字符串生成的浮点数

对于自定义的对象，查找优先级 __float__ > __index__

int(x, base=10)

返回一个字符串或者数值类型转化的整数，base为转为整数时的进制

bytearray([source[, encoding[, errors]]])

返回一个新的bytes数组，该类型是可变类型，包含可变类型的大部分方法

• 如果source是string类型，则encoding参数必须给定
• 如果source是一个integer类型，则使用该数字来初始化，并用null字节填充
• 如果source是bytes、bytearray或array.array类型
• 如果source是iterable类型，它的元素必须全是0 <= x < 256的整数

bytes([source[, encoding[, errors]]])

返回一个bytes对象，与bytearray不同的是，该类型为不可变类型

dict(iterable, **kwarg)

返回一个字典

frozenset([iterable])

返回一个不可变的集合

list([iterable])

返回一个列表

set([iterable])

返回一个集合

tuple([iterable])

返回一个元组

str(object=b’’, encoding=‘utf-8’, errors=‘strict’)

返回一个字符串

isinstance(obj, classinfo)

如果obj是classinfo的实例或子类返回True，clasinfo可以给定多个元素的元组，如果obj是其中之一的实例或子类返回True

issubclass(class, classinfo)

如果class是classinfo的子类返回True，classinfo也可以是元组

进制相关

bin(x)

将整数转化成0b开头的二进制字符串，对于对象需定义__index__

class A:
    def __index__(self):
        return -1
print(bin(A()))

hex(x)

将整数转为0x开头的十六进制字符串,对于对象需定义__index__, 浮点数的十六进制表示请用float.hex()

oct(x)

将整数转为0o开头的八进制字符串，对于对象需定义__index__

计算相关

abs(x)

计算数值的绝对值

自定义类可实现__abs__方法

class A:
    def __abs__(self):
        return -1
print(abs(A()))

divmod(a, b)

返回商和余数组成的元组

如果是整数：(a // b, a % b)
如果是浮点数: (q, a % b)，其中q=math.floor(a/b)

不管a，b是什么类型的值，都满足q * b + a % b == a

hash(obj)

返回obj的哈希值，返回的哈希值是整数类型。另外数值类型如果值相同，则他们具有相同的hash,比如1和1.0。可自定义__hash__

max(iterable, *[, key, default])

返回iterable中最大的元素，其中key是一个函数，用于提取实际比较的值

第二个例子是将字符串转为十六进制数再进行比较，最后一个例子是只比较字符串的最后一个字符，返回最大的那个字符串

min(iterable, *[, key, default])

返回iterable中最小的元素

pow(base, exp[, mod])

返回 base 的 exp 次幂,等价于base**exp。如果mod存在，则返回pow(base, exp) % mod的值，比这样取余更高效，

round(number[,ndigits])

返回数字number四舍五入到小数点后ndigits位的值

sum(iterable, /, start=0)

返回iterable全部加起来的总和

执行字符串代码

eval(expression[, globals[, locals]])

执行expression字符串代码并返回执行结果，globals和locals如果不给定，默认使用当前环境下的

exec(object[, globals[, locals]])

执行字符串代码，无返回值。与eval不同的是，exec用于执行代码段，而eval用于执行表达式

其他

chr(i)

返回整数i在Unicode码表的字符，i的范围：0-0x10FFFF

ord?

返回c字符在Unicode码表的整数

delattr(obj, name)

删除obj对象的name属性，等价于del obj.name

setattr(obj, name, value)

设置obj对象的name的值，等价于obj.name = value

getattr(obj, name[, default])

获取obj对象的name的值，约等于obj.name。如果obj没有name属性，则返回default给定的值，如果没给，则触发AttributeError异常

dir([obj])

返回obj对象的有效属性列表，可自定义__dir__

class A:
    def __dir__(self):
        return ("a", "b")
print(dir(A()))

如果不给参数则返回locals作用域的名称列表，约等价于list(locals().keys())

enumerate(iterable, start=0)

返回一个包含两个元素组成的元组的可迭代对象，第一个元素是个计数器，从start开始

等价实现：

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

globals()

返回全局作用域的字典

locals()

返回本地作用域的字典

help(obj)

返回obj的帮助信息

class A:
    def a(self, name:str) -> str:
        '''
        这是个函数
        '''
        return name
help(dir)
print('-'*100)
help(A)
print('-'*100)
help(A())
print('-'*100)
help(A().a)

id(obj)

返回obj的一个整数格式的"标识值"，该值在当前声明周期内是唯一且不会改变的

input([prompt])

阻塞接收标准输入的字符，prompt为提示信息

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

将信息输出到file指定的流中，默认是sys.stdout(标准输出)

• sep: 多个object输出之间使用的分隔符
• end：最后加上的字符
• flush：是否强制刷新到流

iter(obj[,sentinel])

返回一个iterable对象，obj可以是任意可迭代对象。如果是可被调用的对象，则必须给定sentinel参数，直到迭代的值等于sentinel触发StopIteration异常

next(iterator[, default])

取出iterator的下一个值，如果没有了，就返回default，否则触发StopIteration异常

len(s)

返回对象的长度(元素个数)

range(start, stop[,step])

返回从start到stop每间隔step的值组成的可迭代对象

reversed(seq)

返回一个反向的iterator，seq必须实现__reversed__，或者是支持该方法的对象如同时实现了__len__和__getitem__方法的对象

zip(*iterables)

创建一个聚合了来自每个可迭代对象中的元素的迭代器，等价实现：

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)

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

返回iterable排序后的列表，key和min函数一样，reverse表示是否反序

filter(function, iterable)

迭代iterable，依次执行function，并返回结果为True的所有值组成的可迭代对象，等价于(item for item in iterable if function(item))，如果function传None，则相当于bool

map(function, iterbale, …)

迭代iterable，依次执行function，并返回所有结果组成的可迭代对象。当有多个iterable，到元素最少的结束。等价于(function(item) for item in iterable)

type(name, bases, dict, **kwds)

如果只有一个参数，则返回该对象的类型，建议使用isinstance() 来判断类型

如果传入多个参数，表示定义一个新类，name是类名，bases是继承哪些类，dict表示定义哪些属性
X = type('X', (), dict(a=1))等价于:

class X:
    a = 1

再举个例子：

class B:
    pass
class A(B, object):
    def a(self, name:str) -> str:
        '''
        这是个函数
        '''
        return name
A1 = type("A", (B, object), {"a": lambda self, name:name})
print(A().a("cccccc"))
print(A1().a("cccccc"))

操作文件

open

open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• file: file一般是字符串
• mode：打开文件的模式

• buffering: 缓冲策略，0表示关闭缓冲(仅支持二进制模式) 1表示行缓冲 >1的整数则表示固定大小的块缓冲(单位：字节)。默认对二进制文件使用块缓冲，文本文件使用行缓冲
• encoding：编码
• errors：错误处理的方式，感觉没啥用
• newline ：行分隔符的处理方式，取值：None，''，'\n'，'\r'和 '\r\n'
  对于读取：如果为None，表示\n，\r`和 \r\n都会被转化成\n，如果是’’，则不会转化，如果是其他值，感觉没什么用
  对于写入：如果是None，写入的\n都会被替换成os.linesep, 如果是’’，则不会替换
• closefd: 如果是False，表示file传入的不是文件名而是文件描述符
• opener：看不懂

newline给个例子：

import os


print("linesep: ", repr(os.linesep))
with open('1.txt', 'w', newline=None, encoding='utf-8') as f:
    s = '\n\r\n\r'
    f.write(s)
    print("写入内容：", repr(s))
with open('1.txt', newline=None, encoding='utf-8') as f:
    s = f.read()
    print("读取：None, 写入：None, 读取结果: ", repr(s))
with open('1.txt',  newline='',encoding='utf-8') as f:
    s = f.read()
    print("读取：'', 写入：None 读取结果: ", repr(s))
with open('1.txt', 'w', newline='',encoding='utf-8') as f:
    f.write('\n\r\n\r')
with open('1.txt', newline='',encoding='utf-8') as f:
    s = f.read()
    print("读取：'', 写入：'' 读取结果: ", repr(s))
with open('1.txt', newline=None, encoding='utf-8') as f:
    s = f.read()
    print("读取：None, 写入：'' 读取结果: ", repr(s))

代码执行结果：

只有在读取和写入的newline都为空字符串时，读取的结果和写入的结果才是一样的