本文罗列了一些自己常用的函数，并添加一些自己的见解。如有纰漏，望不吝赐教，谢谢！
参考资料 https://docs.python.org/zh-cn/3/library/functions.html

abs()

  • abs(x)
    返回一个数的绝对值。参数可以是整数、浮点数或任何实现了__abs__() 的对象。如果参数是一个复数，则返回它的模。

all()

  • all(iterable)
    如果 iterable 的所有元素均为真值（或可迭代对象为空）则返回 True。
    等价于:
    1
    2
    3
    4
    5
    def all(iterable):
        for element in iterable:
            if not element:
                return False
        return True

any()

  • any(iterable)
    如果 iterable 的任一元素为真值则返回 True。如果可迭代对象为空，返回 False。
    等价于:
    1
    2
    3
    4
    5
    def any(iterable):
        for element in iterable:
            if element:
                return True
        return False

bin()

  • bin(x)
    将一个整数转换为带前缀 “0b” 的二进制数字符串。例如：
    1
    2
    3
    4
    5
    6
    7
    8
    > bin(3)
    # '0b11'
    > bin(-10)
    # '-0b1010'
    > format(14, '#b'), format(14, 'b')
    # ('0b1110', '1110')
    > f'{14:#b}', f'{14:b}'
    # ('0b1110', '1110')

callable()

  • callable(object)
    如果 object 参数是可调用的则返回 True，否则返回 False。

    一般用来判断变量名是否已经声明

chr()

  • chr(i)
    返回 Unicode 码位为整数 i 的字符的字符串格式。这是 ord()的逆函数。例如：
    1
    2
    3
    4
    > chr(97)
    # 'a'
    > chr(8364)
    # '€'
    实参 i 的合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF）。如果 i 超过这个范围，会触发 ValueError 异常。

dict()

  • dict(**kwarg)
  • dict(mapping, **kwarg)
  • dict(iterable, **kwarg)
    创建一个新的字典。例如：
    1
    2
    3
    4
    5
    6
    > dict()
    # {}
    > dict(a='a', b='b', c='c')
    # {'a': 'a', 'b': 'b', 'c': 'c'}
    > dict([('a', 'a'), ('b', 'b'), ('c', 'c')])
    # {'a': 'a', 'b': 'b', 'c': 'c'}

enumerate()

  • enumerate(iterable, start=0)
    返回一个枚举对象。iterable 必须是一个序列，或其他支持迭代的对象。enumerate() 返回的迭代器的__next__() 方法返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。例如：
    1
    2
    3
    4
    5
    > seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    > list(enumerate(seasons))
    # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    > list(enumerate(seasons, start=1))
    # [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
    等价于:
    1
    2
    3
    4
    5
    def enumerate(iterable, start=0):
        n = start
        for elem in iterable:
            yield n, elem
            n += 1

eval()

  • eval(expression, globals=None, locals=None)
    实参是一个字符串，以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映射对象。
    返回值就是表达式的求值结果。语法错误将作为异常被报告。例如：
    1
    2
    3
    > x=1
    > eval('x+1')
    # 2
    官方解释

    表达式解析参数 expression 并作为 Python 表达式进行求值（从技术上说是一个条件列表），采用 globals 和 locals 字典作为全局和局部命名空间。如果存在 globals 字典，并且不包含 __builtins__键的值，则在解析 expression 之前会插入以该字符串为键以对内置模块 builtins 的字典的引用为值的项。这样就可以在将 globals 传给 eval() 之前通过向其传入你自己的 __builtins__字典来控制可供被执行代码可以使用哪些内置模块。如果 locals 字典被省略则它默认为 globals 字典。如果两个字典都被省略，则将使用调用 eval() 的环境中的 globals 和 locals 来执行该表达式。注意，eval() 无法访问闭包环境中的嵌套作用域 (非局部变量)。

提示：

  • exec() 函数支持语句的动态执行。globals() 和 locals() 函数分别返回当前的全局和本地字典，可供传给 eval () 或 exec () 使用。
  • 如果给出的源数据是个字符串，那么其前后的空格和制表符将被剔除。

另外可以参阅 ast.literal_eval()，该函数可以安全执行仅包含文字的表达式字符串。

不建议使用此函数，不仅执行效率低，而且可能会使代码存在风险。

float()

  • float(x=0.0)
    返回从数字或字符串 x 生成的浮点数。例如：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    > float('+1.23')
    # 1.23
    > float('   -12345\n')
    # -12345.0
    > float('1e-003')
    # 0.001
    > float('+1E6')
    # 1000000.0
    > float('-Infinity')
    # -inf

format()

hex()

  • hex(x)
    将整数转换为带前缀 “0x” 前缀的小写十六进制数字符串。例如：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    > hex(255)
    # '0xff'
    > hex(-42)
    # '-0x2a'
    > %#x' % 255, '%x' % 255, '%X' % 255
    # ('0xff', 'ff', 'FF')
    > format(255, '#x'), format(255, 'x'), format(255, 'X')
    # ('0xff', 'ff', 'FF')
    > f'{255:#x}', f'{255:x}', f'{255:X}'
    # ('0xff', 'ff', 'FF')

    如果要获取浮点数的十六进制字符串形式，请使用 float.hex() 方法。

input()

  • input()
  • input(prompt)
    如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。

int()

  • int(x=0)
  • int(x, base=10)
    返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。如果 x 定义了__int__()，则 int (x) 将返回 x.__int__()。如果 x 定义了__index__()，则将返回 x.__int__()。如果 x 定义了__trunc__()，则将返回 x.__trunc__()。对于浮点数，这将向零方向截断。

import

这个说起来有些复杂，参阅 Python 的 Import 陷阱和 python3 中关于 import 的疑难杂症，这里头说的很棒。

isinstance()

  • isinstance(object, classinfo)
    如果 object 参数是 classinfo 参数的实例，或者是其 (直接、间接或虚拟) 子类的实例则返回 True。如果 object 不是给定类型的对象，则该函数总是返回 False。例如：
    1
    2
    3
    4
    5
    6
    7
    > a=10
    > print(isinstance(a, int))
    # True
    > print(isinstance(a, str))
    # False
    > print(isinstance(a, (str, int, list)))
    # True

    classinfo 基本类型包括 int、float、bool、complex、str、list、dict、set 和 tuple。

len()

  • len(s)
    返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozenset 等）。

map()

  • map(function, iterable, *iterables)
    返回一个将 function 应用于 iterable 的每一项，并产生其结果的迭代器。例如：
    1
    2
    3
    4
    > def square(x):
    >   return x ** 2
    > list(map(square, [1, 2, 3, 4, 5]))
    # [1, 4, 9, 16, 25]

max()

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

min()

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

oct()

  • oct(x)
    将整数转换为带前缀 “0o” 的八进制数字符串。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    > oct(8)
    # '0o10'
    > oct(-56)
    # '-0o70'
    > '%#o' % 10, '%o' % 10
    # ('0o12', '12')
    > format(10, '#o'), format(10, 'o')
    # ('0o12', '12')
    > f'{10:#o}', f'{10:o}'
    # ('0o12', '12')

open()

ord()

  • ord(c)
    对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码的整数。例如 ord('a') 返回整数 97，ord('€') 返回 8364。这是 chr()的逆函数。

pow()

  • pow(base, exp, mod=None)
    返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）。两参数形式 pow(base, exp) 等价于乘方运算符 base ** exp。
    1
    2
    > pow(38, -1, mod=97)
    # 23

range()

  • range(stop)
  • range(start, stop, step=1)
    返回的结果是一个整数序列的对象，例如：
    1
    2
    3
    4
    5
    6
    > list(range(6))
    # [0, 1, 2, 3, 4, 5]
    > list(range(1, 6))
    # [1, 2, 3, 4, 5]
    > list(range(6, 1, -1))
    # [6, 5, 4, 3, 2]

print()

str()

  • str(object='')
  • str(object=b'', encoding='utf-8', errors='strict')
    返回一个 string 类型的 object。

sum()

  • sum(iterable, /, start=0)
    从 start 开始自左向右对 iterable 的项求和并返回总计值。iterable 为数字，start 值不允许为字符串。

    提示：拼接字符串序列的更好更快方式是调用''.join(sequence)。

type()

  • type(object)
  • type(name, bases, dict, **kwds)
    传入一个参数时，返回其类型。返回值是一个 type 对象，通常与 object.__class__所返回的对象相同。

    推荐使用 isinstance()内置函数来检测对象的类型，因为它会考虑子类的情况。

zip()

  • zip(*iterables, strict=False)
    在多个迭代器上并行迭代，从每个迭代器返回一个数据项组成元组。例如：
    1
    2
    3
    4
    5
    >for item in zip([1, 2, 3], ['a', 'c', 'c']):
    >    print(item)
    # (1, 'a')
    # (2, 'b')
    # (3, 'c')
    默认情况下（strict=False），zip() 在最短的迭代完成后停止。较长可迭代对象中的剩余项将被忽略，结果会裁切至最短可迭代对象的长度。
    提示：_*zip ()_ 运算符相结合可以用来拆解一个列表。
    1
    2
    3
    4
    5
    6
    7
    > x = [1, 2, 3]
    > y = [4, 5, 6]
    > list(zip(x, y))
    # [(1, 4), (2, 5), (3, 6)]
    > x2, y2 = zip(*zip(x, y))
    > x == list(x2) and y == list(y2)
    # True
许可协议

本文采用 CC BY-NC-SA 4.0 许可协议，转载请注明出处，谢谢！

分享文章
网站地图 | 状态监测 | 图片加密&解密 | File Server | 博友圈 | 博客说
Copyright 2022-2025 | Powered by Hexo 7.3.0 & Stellar 1.29.1
总访问量次 |