逻辑相关

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__方法，才能使用obj()

类型相关

complex([real[, imag]])

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

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

例如，下面的代码会优先访问__complex__：

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

float(x)

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

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

int(x, base=10)

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

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

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

• 如果source是string类型，则encoding参数必须给定
• 如果source是一个整数，则使用source个\x00来初始化
• 如果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 -1print(bin(A()))

hex(x)

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

oct(x)

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

计算相关

abs(x)

计算数值的绝对值

自定义类可实现__abs__方法

class A:    def __abs__(self):        return -1print(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)

返回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 namehelp(dir)print('-'*100)help(A)print('-'*100)help(A())print('-'*100)help(A().a)

id(obj)

返回obj的一个整数格式的"标识值"，该值在当前声明周期内是唯一且不会改变的。在c语言中，它是PyObject指针的内存地址

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:    passclass A(B, object):    def a(self, name:str) -> str:        '''        这是个函数        '''        return nameA1 = 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都为空字符串时，读取的结果和写入的结果才是一样的