本文详细介绍了Python内置的数学函数如绝对值、除法余数、幂运算、舍入、字符转换、进制转换等，以及转换函数如字符串格式化、ASCII编码、布尔转换等，适合深入理解Python基础操作。
Python 内置函数
官方手册：https://docs.python.org/zh-cn/3/library/functions.html
数学函数
# 绝对值
abs(x)
abs(-32) # 32
abs(-3.2) # 3.2
abs(-3+2j) # 3.605551275463989 # 这是什么？
abs(-True) # 1
# 计算两数相除的商和余数
divmod(a, b)
divmod(5, 3) # (1, 2)
a, b = divmod(5, 3)
# 计算 base**exp 或 (base**exp) % mod
pow(base, exp[, mod])
pow(2, 10) # 1024
pow(2, 10, 100) # 24
# 将 number 舍入到小数点后 ndigits 位，ndigits 默认为 None
# 不要苛求最后一位的精确度，因为大多数十进制小数不能以浮点数精确地表示。
round(number[, ndigits])
round(0.25, 1) # 0.2
round(0.225, 2) # 0.23
转换函数
# 字符转 Unicode 码点/Unicode 码点转字符
ord(c)
chr(i)
ord('好') # 22909
chr(22909) # '好'
# 整数转二进制/八进制/十六进制字符串（带有 0b/0o/0x）
bin(x)
oct(x)
hex(x)
bin(60) # '0b111100'
oct(60) # '0o74'
hex(60) # '0x3c'
# 将单个对象格式化为字符串
format(value[, format_spec])
format(60, 'b') # '111100'
format(60, 'o') # '74'
format(60, 'x') # '3c'
format(60, '.3f') # '60.000'
format(60, '_^8d') # '___60___'
# 将对象转换为 ASCII 字符串
ascii(object)
ascii('Hello 世界！') # "'Hello \\u4e16\\u754c\\uff01'"
ascii(object()) # '<object object at 0x7f83876cb520>'
# 将对象转换为整数/浮点数/复数
class int([x])
class float([x])
class complex([real[, imag]])
int() # 0
int(3.2) # 3
int('3.2') # 失败
int('32') +1 # 33
float() # 0.0
float('3.2') + 1 # 4.2
float(32) # 32.0
complex() # 0j
complex(3.2, -3.2) # (3.2-3.2j)
complex('3.2, -3.2') # (3.2-3.2j)
complex('3.2', -3.2) # 失败
complex('3.2-3.2j') # (3.2-3.2j)
complex('3.2-3.2') # 失败
# 将对象转换为布尔值
class bool([x])
bool() # False
bool(0) # False
bool(0j) # False
bool('') # False
bool(None) # False
bool([]) # False
bool(100) # True
bool(3+2j) # True
bool('Hello World!') # True
bool(object()) # True
bool([1,2,3]) # True
# 将字符串转换为整数，指定進位制
class int(x, base=10)
int('0xFF', 16) # 255
int('FF', 16) # 255
int('ZZ', 36) # 1295
# 将对象转换为字符串
# errors 是错误处理函数（字符串）
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')
str(3.2) + 'abc' # '3.2abc'
str('Hello \n World!') # 'Hello \n World!'
str(b'\xe5\xa5\xbd', 'utf8') # 好
# 将对象转换为字符串，其中的转义字符会被特殊处理
repr(object)
repr(3.2) + 'abc' # '3.2abc'
repr('Hello \n World!') # "'Hello \\n World!'"
repr('''Hello
World!''') # "'Hello \\n World!'"
repr(b'\xe5\xa5\xbd') # "b'\\xe5\\xa5\\xbd'"
# 将对象转换为字节串（只读）
class bytes([source[, encoding[, errors]]])
bytes('好', 'utf8') # b'\xe5\xa5\xbd'
# 将对象转换为字节串（读写）
class bytearray([source[, encoding[, errors]]])
bytearray('好', 'utf8') # bytearray(b'\xe5\xa5\xbd')
# 将对象转换为内存视图（指针）
class memoryview(obj)
memoryview(bytes()) # <memory at 0x7f8387558940>
memoryview(bytearray()) # <memory at 0x7f8387558a00>
可迭代对象
# 返回一个迭代器对象
# 如果没有第二个参数，则 object 必须是支持迭代协议（有 __iter__() 方法）的对象，
# 或支持序列协议（有 __getitem__() 方法，且数字参数从 0 开始）的对象。
# 如果不支持这些协议，则会触发 TypeError。
# 如果有第二个参数，则 object 必须是可调用对象。这种情况下，每次迭代时都会调用 object，
# 如果 object 返回 sentinel 则触发 StopIteration，否则返回 object 的结果。
iter(object[, sentinel])
# 获取迭代器的下一个元素
# 如果迭代器耗尽，则返回 default，如果没有 default 则触发 StopIteration。
next(iterator[, default])
# 示例1：通过字符串实现迭代器，迭代器耗尽会触发 StopIteration，会被 next 捕捉
r = iter('Hello World!')
# next 捕捉到 StopIteration，会返回 None
e = next(r, None)
while e:
print(e)
e = next(r, None)
# 示例2：通过函数实现迭代器
def data(n):
def f():
nonlocal n
n -= 1
return n
return f # 返回闭包函数
# 如果 data 返回 0 则触发 StopIteration，表示迭代器耗尽
r = iter(data(10), 0)
for e in r:
print(e)
# 将 iterable 中的元素依次交给 function 处理，用返回真的那些元素构建一个新的迭代器。
filter(function, iterable)
# 示例：过滤偶数
def f(i):
return not (i % 2)
r = filter(f, range(1, 10))
list(r) # [2, 4, 6, 8]
# 将 iterable 中的元素依次交给 function 处理，用返回值构建一个新的迭代器。
# 如果传入了多个的 iterable 参数，则 function 必须接受所有的 iterable 参数。
# 当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。
map(func, *iterables)
# 示例1：将 ASCII 码转换为字符
r = map(chr, range(65, 72))
list(r)
# ['A', 'B', 'C', 'D', 'E', 'F', 'G']
# 示例2：拼接多个序列
def f(a, b, c):
return a + b + c
r = map(f, (1,2,3), (4,5,6), (7,8,9))
list(r) # [12, 15, 18] # 1+4+7=12 2+5+8=15 3+6+9=18
# 返回一个迭代器，其中第 i 个元素包含了来自每个参数的第 i 个元素。
# 当参数中最短的一个被耗尽时，迭代器将停止迭代。
# 如果你关心较长参数尾部不匹配的值，则应改用 itertools.zip_longest()。
zip(*iterables)
# 示例
x = [1, 2, 3, 4, 5]
y = ['a', 'b', 'c']
z = zip(x, y)
list(z) # [(1, 'a'), (2, 'b'), (3, 'c')]
# 排序，返回一个列表
# key 是一个函数，用于从 iterable 中依次提取元素并转换后進行比较
# reverse 表示是否反转结果
sorted(iterable, *, key=None, reverse=False)
sorted('World') # ['W', 'd', 'l', 'o', 'r']
sorted('World', key=str.lower) # ['d', 'l', 'o', 'r', 'W']
sorted('World', key=str.lower, reverse=True) # ['W', 'r', 'o', 'l', 'd']
# 反转序列，返回一个可迭代对象
reversed(seq)
list(reversed('Hello')) # ['o', 'l', 'l', 'e', 'H']
# 序列求和，start 是额外要相加的数
# 拼接字符串序列的更好更快方式是调用 ''.join(sequence)。
# 要以扩展精度对浮点值求和，请参阅 math.fsum()。
# 要拼接一系列可迭代对象，请考虑使用 itertools.chain()。
sum(iterable, start=0)
sum((1,3,5,7,9)) # 25
sum((1,3,5,7,9), 5) # 30
# 是否所有元素都为真（无元素则返回 True）
all(iterable)
all(()) # True
all((1, True, 'a', 3.0)) # True
all((1, True, 'a', None)) # False
# 是否有一个元素为真（无元素则返回 False）
any(iterable)
any(()) # False
any((0, False, '', None)) # False
any((0, False, '', object())) # True
# 返回参数中最大的元素
# key 是一个函数，用于从 iterable 中依次提取元素并转换后進行比较。
# default 表示当 iterable 为空时返回的值。
# 如果 iterable 为空，并且没有给 default，则会触发 ValueError。
# 如果有多个最大元素，则返回第一个找到的。
max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
max('Hello World!') # 'r'
max('Hello World!', key=str.lower) # 'W'
max(-1, 3, -5, 7, -9) # 7
max(-1, 3, -5, 7, -9, key=abs) # -9
max('', default=0) # 0
# 返回参数中最小的元素
min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])
# 将对象转换为元组/列表/集合/冻结集合
class tuple([iterable])
class list([iterable])
class set([iterable])
class frozenset([iterable])
# 集合中重复的元素会被合并：1 == 1.0 == True 0 = False
set((1, 1.0, True, 0, False, '', None)) # {0, 1, None, ''}
frozenset((1, 1.0, True, 0, False, '', None)) # frozenset({0, 1, None, ''})
# 创建字典对象
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
dict((['a',1], ['b',2], ['c',3])) # {'a': 1, 'b': 2, 'c': 3}
dict(zip('abc', [1, 2, 3])) # {'a': 1, 'b': 2, 'c': 3}
dict({'a':1, 'b':2}, c=3, d=4) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict(zip('ab', [1,2]), c=3, d=4) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# 创建一个 range 对象
class range(stop)
class range(start, stop[, step])
range(0, 5) # range(0, 5)
list(range(0, 5)) # [0, 1, 2, 3, 4]
list(range(0, 5, -1)) # []
list(range(5, 0, -1)) # [5, 4, 3, 2, 1]
# 创建一个切片对象。切片对象可以当做下标使用
class slice(stop)
class slice(start, stop[, step])
s = slice(2, 5)
s # slice(2, 5, None)
a = [*'Hello World!']
a # ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!']
a[s] # ['l', 'l', 'o']
# 返回一个枚举对象。iterable 必须是一个序列，或 iterator，或其他支持迭代的对象
enumerate(iterable, start=0)
list(enumerate('abc', 10)) # [(10, 'a'), (11, 'b'), (12, 'c')]
# 批量修改列表元素
r = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for k, v in enumerate(r):
r[k] = v+1;
r # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 返回对象的长度
len(s)
len('Hello World!') # 12 # 字符串
len({'a':1, True:2}) # 2 # 字典
len({1, 1.0， True}) # 1 # 集合 1 == 1.0 == True 合并了
len(range(5)) # 5 # range 对象
输入输出
# 从标准输入中读取一行文本，如果遇到 EOF 则触发 EOFError
# prompt 是提示信息
input([prompt])
# 将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。
# 如果 flush 关键字参数为真值，流会被强制刷新。
# sep, end, file 和 flush 如果存在，它们必须以关键字参数的形式给出。
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
类和对象
# 返回一个没有特征的新对象。
# object 是所有类的基类。它具有所有 Python 类实例的通用方法。
# 由于 object 没有 __dict__，因此无法将任意属性赋给 object 的实例。
class object()
dir(object())
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
# 返回对象的唯一编号
id(object)
id(object()) # 140202889491760
id(1) # 140202889746736
id(int) # 140202912493152
# 返回对象的 Hash 值
hash(object)
hash(object()) # 8762680593230
hash(0) # 0
hash(1024) # 1024
hash(3.2) # 461168601842739203
hash(int) # 8762682030822
# 获取一个对象的类型
class type(object)
class type(name, bases, dict)
# 只传入一个参数时，返回对象的类型，通常与 object.__class__ 所返回的对象相同。
# 推荐使用 isinstance() 内置函数来检测对象的类型，因为它会考虑子类的情况。
type(3) == int # True # 都是 int 类型
type(int) == type(str) # True # 都是 type 类型
# 传入三个参数时，返回一个新的类型。这在本质上是 class 语句的一种动态形式，
# name 字符串即类名并会成为 __name__ 属性；
# bases 元组包含基类并会成为 __bases__ 属性；如果为空则会添加 object。
# dict 字典包含类的属性和方法定义；它在成为 __dict__ 属性之前可能会被拷贝或包装。
# 下面两条语句会创建相同的类：
class X: a = 1
X # <class '__main__.X'>
Y = type('X', (), dict(a=1))
Y # <class '__main__.X'>
X == Y # False
id(X) == id(Y) # False
# 判断对象的属性是否存在
hasattr(object, name)
# 获取对象属性，如果属性不存在，则返回 default（未指定 default 则触发 AttributeError）
getattr(object, name[, default])
# 设置对象属性
setattr(object, name, value)
# 删除对象的指定属性
delattr(object, name)
# 示例：修改函数参数的默认值
def f(a=1, b=2): print(a+b)
f() # 3
getattr(f, '__defaults__') # (1, 2) # 获取 f 的参数的默认值
setattr(f, '__defaults__', (3, 4)) # 修改 f 的参数的默认值
f() # 7
# fget 是获取属性值的函数。fset 是设置属性值的函数。fdel 是删除属性值的函数。doc 是文档字符串。
class property(fget=None, fset=None, fdel=None, doc=None)
# 一个典型的用法是定义一个托管属性
# 如果 c 是 C 的实例，c.x 将调用getter，c.x = value 将调用setter， del c.x 将调用deleter。
class C:
def __init__(self): self._x = None
def getx(self): return self._x
def setx(self, value): self._x = value
def delx(self): del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
# 如果给出 doc，将成为该 property 的文档字符串。否则将拷贝 fget 的文档字符串（如果存在）。
# 这可以很容易地使用 property() 作为 decorator 来创建只读属性
class Parrot:
def __init__(self):
self._voltage = 100000
# @property 装饰器会将 voltage() 方法转化为一个具有相同名称的只读属性的 'getter'，
# 并将 voltage 的文档字符串设置为 'Get the current voltage.'
@property
def voltage(self):
'''Get the current voltage.'''
return self._voltage
# property 对象具有 getter, setter 以及 deleter 方法，它们可用作装饰器来创建该 property 的副本，
# 并将相应的访问函数设为所装饰的函数：
class C:
def __init__(self):
self._x = None
@property
def x(self):
'''I'm the 'x' property.'''
return self._x
@x.setter
def x(self, value): self._x = value
@x.deleter
def x(self): del self._x
# 上述代码与第一个例子完全等价。注意一定要给附加函数与原始的 property 相同的名称 (在本例中为 x)
# 返回的 property 对象同样具有与构造器参数相对应的属性 fget, fset 和 fdel。
# 判断 object 是否为 classinfo 的实例或是其 (直接、间接或 虚拟) 子类。
isinstance(object, classinfo)
isinstance(1, int) # True
isinstance(1, bool) # False
isinstance(True, int) # True
isinstance(True, bool) # True
# 判断 object 是否为 classinfo 的 (直接、间接或 虚拟) 子类。
issubclass(class, classinfo)
issubclass(int, int) # True
issubclass(bool, int) # True
issubclass(int, bool) # False
# 返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。
super([type[, object-or-type]])
# 示例
class C(B):
def method(self, arg):
super().method(arg) # 等同与 super(C, self).method(arg)
# 把一个方法转换为类方法。一个类方法把类自身作为第一个实参。
@classmethod
# 要声明一个类方法，请使用此语法
class C:
@classmethod
def f(cls, arg1, arg2, ...): ...
# 把一个方法转换为静态方法。静态方法不会接收第一个隐式参数。
@staticmethod
# 要声明一个静态方法，请使用此语法
class C:
@staticmethod
def f(arg1, arg2, ...): ...
调用代码
# 判断对象是否可调用
callable(object)
callable(abs) # True
# 执行单条 Python 表达式
# expression 是表达式字符串。
# globals 全局命名空间，如果被提供，则必须是一个字典对象。
# locals 局部命名空间，如果被提供，可以是任何映射对象。
eval(expression[, globals[, locals]])
eval('1+2') # 3
eval('1+2; 3+4') # 错误，只能执行一条语句
# 局部作用域会覆盖全局作用域
eval('a+b+c', {'a':1, 'b':2}, {'a':3, 'c':4}) # 9
eval('vars()', {'a':1, 'b':2}, {'a':3, 'c':4}) # {'a': 3, 'c': 4}
eval('globals()', {'a':1, 'b':2}, {'a':3, 'c':4}) # {'a': 1, 'b': 2, ... }
def f(): print('Hello World!')
eval(f.__code__) # Hello World!
# 执行 Python 表达式
# object 是字符串或代码对象。
# globals 全局命名空间，如果被提供，则必须是一个字典对象。
# locals 局部命名空间，如果被提供，可以是任何映射对象。
exec(object[, globals[, locals]])
exec('1+2; 3+4') # 不显示结果
exec('a=1; b=2; print(a+b)') # 3
def f(): print('Hello World!')
exec(f.__code__) # Hello World!
# 将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
# source 可以是常规的字符串、字节字符串，或者 AST 对象。
# filename 是源文件路径，如果不是从文件读取源码，可设置为一些可辨识的值（经常会使用 '<string>'）。
# mode 指定模式。如果 source 是语句序列，可以是 'exec'；如果是单一表达式，可以是 'eval'；如果是单个交互式语句，可以是 'single'。（在最后一种情况下，如果表达式执行结果不是 None 将会被打印出来。）
# flags：要附加的编译器选项和 future 语句
# dont_inherit：是否继承默认的编译器选项。
# 如果 flags 和 dont_inherit 都未提供（或都为零），则使用当前编译器选项。
# 编译器选项和 future 语句是由比特位通过“或运算”来指明的。
# https://docs.python.org/zh-cn/3/library/ast.html#ast-compiler-flags
# optimize 指定编译器的优化级别。
# -1：（默认值）选择与解释器的 -O 选项相同的优化级别。
# 0：没有优化；__debug__ 为真
# 1：断言被删除，__debug__ 为假
# 2：断言被删除，__debug__ 为假，文档字符串也被删除
c = compile('1+2', '', 'eval')
eval(c) # 3
exec(c) # 不显示结果
# 单条语句可以用 'eval' 模式
c = compile('print("Hello World!")', '', 'eval')
eval(c) # Hello World!
exec(c) # Hello World!
# 多条语句必须用 'exec' 模式
c = compile('for i in range(5):print(i)', '', 'exec')
eval(c) # 0 1 2 3 4
exec(c) # 0 1 2 3 4
文件
# 打开 file 并返回对应的 file object。如果该文件不能被打开，则引发 OSError。
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
# file 是文件路径
# mode：'r' 读（默认）'w'清空写（或创建）'x'创建（存在则失败）'a'追加（或创建）'+'读写
# 'b'二进制't'文本模式（默认）
# buffering 缓冲策略，0 关闭缓冲（仅二进制模式），1 行缓冲（仅文本模式），>1 缓冲区大小（字节单位）。
# 如果没有给出 buffering，则默认缓冲策略的工作方式如下：
# 二进制文件以固定大小的块进行缓冲；使用启发式方法选择缓冲区的大小，尝试确定底层设备的“块大小”或
# 使用 io.DEFAULT_BUFFER_SIZE。在许多系统上，缓冲区的长度通常为 4096 或 8192 字节。
# “交互式”文本文件（isatty() 返回 True 的文件）使用行缓冲。其他文本文件使用上述二进制文件策略。
# encoding 编码（用于文本文件）
# errors 错误处理函数（字符串）用于指定如何处理编码和解码错误
# newline 换行符格式，可以是 None、''、'\n'、'\r'、'\r\n'。它的工作原理：
# 从流中读取输入时，如果 newline 为 None，则启用通用换行模式。输入中的行结束符可以是 '\n'、'\r'、'\r\n'，这些行在返回呼叫者之前被翻译成 '\n'。如果是 ''，则启用通用换行模式，但行结束符将原样返回给调用者。否则输入中的行仅以给定的字符串终止，并且行结束符将返回给调用者。
# 将输出写入流时，如果 newline 为 None，则写入的任何 '\n' 都将转换为系统默认行结束符 os.linesep。如果 newline 是 '' 或 '\n'，则不进行转换。否则写入的任何 '\n' 将被转换为给定的字符串。
# 如果 closefd 是 False 并且 file 给出了文件描述符而不是文件名，那么当文件关闭时，底层文件描述符将保持打开状态。如果 file 给出的是文件名，则 closefd 必须为 True （默认值），否则将引发错误。
# opener 是自定义开启器。通过使用参数（file，flags）调用 opener 获得文件对象的基础文件描述符。
# opener 必须返回一个打开的文件描述符（使用 os.open as opener 时与传递 None 的效果相同）。
# 当以文本模式 ('w', 'r', 'wt', 'rt' 等) 打开文件时，它将返回 io.TextIOBase（特别是 io.TextIOWrapper）的一个子类。
# 当使用缓冲以二进制模式打开文件时，返回的类是 io.BufferedIOBase 的一个子类。
# 在只读的二进制模式下，它将返回 io.BufferedReader；
# 在写入二进制和追加二进制模式下，它将返回 io.BufferedWriter；
# 而在读/写模式下，它将返回 io.BufferedRandom。
# 当禁用缓冲时，则会返回原始流，即 io.RawIOBase 的一个子类 io.FileIO。
# 创建文件并写入数据
f = open('test.txt', 'w', 1024, 'utf8')
f.write('Hello World!') # 12
f.seek(0, 0) # 0
f.readline() # 不可读
f.close()
# 打开文件并读写数据（使用 with 语句时，文件会在最后自动关闭）
with open('test.txt', 'a+', 1024, 'utf8') as f:
print('Hello Python', file=f)
f.seek(0, 0) # 0
f.readline() # 'Hello World!Hello Python\n'
# 下面的示例使用 os.open() 函数的 dir_fd 的形参，从给定的目录中用相对路径打开文件:
import os
dir_fd = os.open('somedir', os.O_RDONLY)
def opener(path, flags):
return os.open(path, flags, dir_fd=dir_fd)
with open('spamspam.txt', 'w', opener=opener) as f:
print('This will be written to somedir/spamspam.txt', file=f)
os.close(dir_fd) # 别忘记关闭文件描述符
其它
# 内置帮助系统
help([object])
# 返回当前作用域（或指定对象）中的名称列表
dir([object])
# 返回模块、类、实例或任何其它具有 __dict__ 属性的对象的 __dict__ 属性。
vars([object])
# 返回当前全局符号表字典
globals()
# 返回当前本地符号表字典
locals()
# 下断点，進入调试器
# 具体来说，它调用 sys.breakpointhook() ，直接传递 args 和 kws。
breakpoint(*args, **kws)
# 此函数会由 import 语句发起调用。
# 它可以被替换（通过导入 builtins 模块并给 builtins.__import__ 赋值）以便修改 import 语句的语义，
# 但是强烈建议不要这样做，因为使用导入钩子通常更容易实现同样的目标，并且不会导致代码问题，
# 因为许多代码都会假定所用的是默认实现。
# 同样也不建议直接使用 __import__() 而应该用 importlib.import_module()。
# 这是一个日常 Python 编程中不需要用到的高级函数。
__import__(name, globals=None, locals=None, fromlist=(), level=0)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
