python内置了很多功能很方便的函数，供我们可以直接使用
我们可以通过在python命令行中输入dir(__builtins__查看所有的内置属性和内置函数
>>> dir(__builtins__) ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
忽略内置的属性，我们重点归纳总结一下各个函数的使用。
数学函数
abs()
返回数字的绝对值
语法：abs(x)
示例：
>>> print("abs(-1)=%s" %abs(-1)) abs(-1)=1 >>> print("abs(11.2)=%s" %abs(11.2)) abs(11.2)=11.2 >>>
divmod()
函数接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)。在 python 3.x 版本该函数不支持复数。
语法：divmod(a, b)
a: 数字，非复数。
b: 数字，非复数。示例：
>>> divmod(7, 2) (3, 1) >>> divmod(8, 2) (4, 0) >>> divmod(8, -2) (-4, 0) >>> divmod(3, 1.3) (2.0, 0.3999999999999999)
如果参数 a 与 参数 b 都是整数，函数返回的结果相当于 (a // b, a % b)。
如果其中一个参数为浮点数时，函数返回的结果相当于 (q, a % b)，q 通常是 math.floor(a / b)，但也有可能是 1 ，比小，不过 q * b + a % b 的值会非常接近 a。
如果 a % b 的求余结果不为 0 ，则余数的正负符号跟参数 b 是一样的，若 b 是正数，余数为正数，若 b 为负数，余数也为负数，并且 0 <= abs(a % b) < abs(b)。
sum()
对系列进行求和计算
语法：sum(iterable[, start]) iterable -- 可迭代对象，如：列表、元组、集合。 start -- 指定相加的参数，如果没有设置这个值，默认为0。
示例：
>>> sum([1,2,3]) 6 >>> sum([1,2,3],4) 10 >>> sum((1,2,3,4),5) 15
round()
返回浮点数x的四舍五入值。
语法：round( x [, n] ) x -- 数字表达式。 n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。
示例：
>>> round(1.234) 1 >>> round(1.234,1) 1.2 >>> round(1.234,3)1.234
pow()
方法返回 xy（x的y次方） 的值。
语法：pow(x, y[, z]) 函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z x -- 数值表达式。 y -- 数值表达式。 z -- 数值表达式。
示例：
>>> pow(100,2) 10000 >>> pow(2,10) 1024 >>> pow(123,0) 1 >>> pow(2,-2) 0.25
min()
返回给定参数的最小值，参数可以为序列。
语法：min( x, y, z, .... ) x -- 数值表达式。 y -- 数值表达式。 z -- 数值表达式。
示例：
>>> min(1,2,3) 1 >>> min(-100, -10, -1) -100
max()
返回给定参数的最大值，参数可以为序列。
语法：min( x, y, z, .... ) x -- 数值表达式。 y -- 数值表达式。 z -- 数值表达式。
示例：
>>> max(1,2,3) 3 >>> max(-100, -10, -1) -1
数据转换函数
hex()
用于将一个指定数字转换为 16 进制数。
语法：hex(x) x -- 一个整数
示例：
>>> hex(0) '0x0' >>> hex(15) '0xf' >>> hex(16) '0x10' >>> hex(255) '0xff' >>> hex(-255) '-0xff'
oct()
将一个整数转换成8进制字符串。
语法：oct(x) x -- 整数。
示例：
>>> oct(0) '0o0' >>> oct(7) '0o7' >>> oct(8) '0o10' >>> oct(10) '0o12' >>> oct(-10) '-0o12'
bin()
返回一个整数 int 或者长整数 long int 的二进制表示。
语法：bin(x) x -- int 或者 long int 数字
示例：
>>> bin(0) '0b0' >>> bin(2) '0b10' >>> bin(255) '0b11111111' >>> bin(-255) '-0b11111111'
int()
用于将一个字符串或数字转换为整型。
语法：
class int(x, base=10) x -- 字符串或数字。 base -- 进制数，默认十进制。
示例：
>>> int() 0 >>> int(5) 5 >>> int(12.3) 12>>> int(-12.3) -12 >>> int('12', 8) 10float()
用于将整数和字符串转换成浮点数。
语法：class float([x]) x -- 整数或字符串
示例：
>>> float(0) 0.0 >>> float(1) 1.0 >>> float('12345') 12345.0str()
将对象转化为适于人阅读的形式。
语法：class str(object='') object -- 对象。
示例：
>>> s = 'this is a string' >>> str(s) 'this is a string' >>> dict = {'name': 'Robort', 'age': 22, 'gender': 'male'} >>> str(dict) "{'name': 'Robort', 'age': 22, 'gender': 'male'}"bool()
用于将给定参数转换为布尔类型，如果没有参数，返回 False。
语法：class bool([x]) x -- 要进行转换的参数。
示例：
>>> bool() False >>> bool(0) False >>> bool(1) True >>> bool('a') Trueord()
chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。>>>ord('a') 97 >>> ord('￥') 65509chr()
用一个整数作参数，返回一个对应的字符。
语法：chr( x) x -- int
示例：
>>>chr(0x30) '0'>>> chr(97) 'a' >>> chr(65509) '￥'
tuple()
将列表转换为元组。
语法：tuple( seq ) seq -- 要转换为元组的序列。
示例：
>>> list1 = ['abc', 123, 'def'] >>> print(tuple(list1)) ('abc', 123, 'def')list()
用于将元组或字符串转换为列表。
语法：list( seq )
示例：
>>> t1 = ('abc', 123, 'def') >>> print(list(t1)) ['abc', 123, 'def'] >>> s = 'Hello World!' >>> print(list(s)) ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!']repr()
将一个对象转化为解释器阅读形式
语法：repr(object) object -- 对象。
示例：
>>> s = 'Hello World!' >>> repr(s) "'Hello World!'" >>> dict1 = {'name': 'Robort', 'age': 22, 'gender': 'male'} >>> repr(dict1) "{'name': 'Robort', 'age': 22, 'gender': 'male'}"ascii()
函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值。
语法：ascii(object) object -- 对象。
示例：
>>> ascii('Hello World!') "'Hello World!'"complex()
用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
语法：class complex([real[, imag]]) real -- int, long, float或字符串； imag -- int, long, float；
示例：
>>> c1 = 2+3j*3+4j >>> c2=complex(2,3) >>> c3=complex('3+4j') >>> print("complex(2,3)*complex('3+4j') = ", c2*c3) complex(2,3)*complex('3+4j') = (-6+17j) >>> print("2+3j*3+4j = ", c1) 2+3j*3+4j = (2+13j) >>> print("(2+3j)*(3+4j) = ", (2+3j)*(3+4j)) (2+3j)*(3+4j) = (-6+17j)
对象创建函数
dict()
用于创建一个字典。class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg)
示例：
>>>dict() # 创建空字典{} >>> dict(a='a', b='b', t='t') # 传入关键字 {'a': 'a', 'b': 'b', 't': 't'} >>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典 {'three': 3, 'two': 2, 'one': 1} >>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典 {'three': 3, 'two': 2, 'one': 1}open()
用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
语法：open(file, mode='r') open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) file: 必需，文件路径（相对或者绝对路径）。 mode: 可选，文件打开模式 buffering: 设置缓冲 encoding: 一般使用utf8 errors: 报错级别 newline: 区分换行符 closefd: 传入的file参数类型 opener:
示例：
>>>f = open('a.txt') >>>f.read()bytearray()
方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
语法：class bytearray([source[, encoding[, errors]]]) 如果 source 为整数，则返回一个长度为 source 的初始化数组； 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列； 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数； 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。 如果没有输入任何参数，默认就是初始化数组为0个元素。
示例：
>>>bytearray() bytearray(b'') >>> bytearray([1,2,3]) bytearray(b'\x01\x02\x03') >>> bytearray('test', 'utf-8') bytearray(b'test')frozenset()
返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
语法：class frozenset([iterable]) iterable -- 可迭代的对象，比如列表、字典、元组等等。
示例：
a = frozenset(range(10)) # 生成一个新的不可变集合 >>> afrozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> b = frozenset('Hello World!') >>> bfrozenset({'o', 'H', 'e', ' ', 'r', 'd', 'W', 'l', '!'}) # 创建不可变集合range()
函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
语法：range(stop) range(start, stop[, step]) start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）; stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5 step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
示例：
>>> range(10) range(0, 10) >>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> [x for x in range(10)] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> [x for x in range(1,9)] [1, 2, 3, 4, 5, 6, 7, 8] >>> [x for x in range(1,10,2)] [1, 3, 5, 7, 9]
set()
创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
语法：class set([iterable])
示例：
>>> x = set("Hello") >>> y = set("World") >>> x {'o', 'l', 'H', 'e'} >>> y {'o', 'r', 'd', 'W', 'l'} >>> x & y{'o', 'l'} >>> x | y {'e', 'd', 'l', 'o', 'H', 'r', 'W'} >>> x - y {'H', 'e'}
迭代器操作函数
all()
函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True。
语法：all(iterable) iterable -- 元组或列表。
示例：
>>> all([0,1,2,3,4]) False >>> all([1,2,3,4,5]) True >>> all(['a', 'b','c', 'd']) True >>> all(['a', 'b','c', 'd', '']) False >>> all(('a', 'b','c', 'd', '')) Falseany()
用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。元素除了是 0、空、FALSE 外都算 TRUE。
语法：any(iterable) iterable -- 元组或列表。
示例：
>>> any([1,2,3,4,5]) True >>> any([0,1,2,3,4]) True >>> any(('a', 'b','c', 'd', '')) True >>> any((0, '', False)) False >>> any([]) Falseiter()
用来生成迭代器。
语法：iter(object[, sentinel]) object -- 支持迭代的集合对象。 sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
示例：
class add: def __init__(self, _start, _end): self.start = _start self.end = _end def get_next(self): s = self.start if(self.start < self.end): self.start += 1 else: raise StopIteration return s >>> a = add(1, 10) >>> it = iter(a.get_next, 5) >>> for i in it: print(i) 1234
next()
返回迭代器的下一个项目。
语法：next(iterator[, default]) iterator -- 可迭代对象 default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
示例：
>>> it =iter([1,2,3,4,5,6]) >>> while True: y = next(it, 0) if y: print(y) else: break 123456 >>>
sorted()
函数对所有可迭代的对象进行排序操作。sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。语法：
sorted(iterable, key=None, reverse=False) iterable -- 可迭代对象。 key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
示例：
>>> sorted([6,3,8,4,1,7,4]) [1, 3, 4, 4, 6, 7, 8] >>> sorted({3:'c', 6:'f', 1:'a', 4:'d', 2: 'b', 5:'e'}) [1, 2, 3, 4, 5, 6] >>> sorted({3:'c', 6:'f', 1:'a', 4:'d', 2: 'b', 5:'e'}, reverse=True) [6, 5, 4, 3, 2, 1]enumerate()
用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
语法：enumerate(sequence, [start=0]) sequence -- 一个序列、迭代器或其他支持迭代对象。 start -- 下标起始位置。
示例：
>>> num = ['python', 'java', '.net', 'c++', 'php'] >>> enumerate(num) <enumerate object at 0x000001CFD1ECD558> >>> list(enumerate(num)) [(0, 'python'), (1, 'java'), (2, '.net'), (3, 'c++'), (4, 'php')] >>> list(enumerate(num, 11)) [(11, 'python'), (12, 'java'), (13, '.net'), (14, 'c++'), (15, 'php')]
filter()
用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
语法：filter(function, iterable)
function -- 判断函数
iterable -- 可迭代对象示例：
>>> def is_male(item): gender = item[1] if gender == 'male': return True return False >>> employees = [('张工','male'), ('王工','female'), ('李工','male'), ('郑工','female'),('夏工','male'),] >>> filter(is_male, employees) <filter object at 0x000001CFD1EC0BA8> >>> print(list(filter(is_male, employees))) [('张工', 'male'), ('李工', 'male'), ('夏工', 'male')] >>>zip()
函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
语法：zip([iterable, ...])
iterabl -- 一个或多个迭代器;示例：
>>> a = [1,2,3,4] >>> b = ['a', 'b', 'c', 'd', 'e'] >>> zip_ab = zip(a,b) >>> zip_ab <zip object at 0x0000028AC2E45388> >>> list(zip(a,b)) [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')] >>> c, d = zip(*zip_ab) >>> c (1, 2, 3, 4) >>> d ('a', 'b', 'c', 'd')map()
会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
语法：map(function, iterable, ...)
function -- 函数
iterable -- 一个或多个序列示例：
>>> def func(x): return 2**x >>> list1 = [x for x in range(10)] >>> result = map(func, list1) >>> result <map object at 0x0000028AC2E40780> >>> list(result) [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] >>> map(lambda x,y: x**y, [1,2,3,4,5,6],[1,2,3,4,5,6]) <map object at 0x0000028AC2E406D8> >>> list(map(lambda x,y: x**y, [1,2,3,4,5,6],[1,2,3,4,5,6])) [1, 4, 27, 256, 3125, 46656]
reverse()
返回一个反转的迭代器。
语法：reversed(seq)
seq -- 要转换的序列，可以是 tuple, string, list 或 range。示例：
>>> a = 'Hello World!' >>> reversed(a) <reversed object at 0x0000028AC2E405F8> >>> list(reversed(a)) ['!', 'd', 'l', 'r', 'o', 'W', ' ', 'o', 'l', 'l', 'e', 'H']['e', 'd', 'c', 'b', 'a'] >>> l = ['a', 'b', 'c', 'd', 'e'] >>> list(reversed(l)) ['e', 'd', 'c', 'b', 'a'] >>> t = (1,2,3,4,5) >>> list(reversed(t)) [5, 4, 3, 2, 1]
对象属性操作函数
setattr()
对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
语法：setattr(object, name, value)
object -- 对象。
name -- 字符串，对象属性。
value -- 属性值。示例：
>>> class Student(): def __init__(self, _name): self.name = _name >>> a = Student('ZhangSan') >>> a <__main__.Student object at 0x0000028AC2E406D8> >>> a.age Traceback (most recent call last): File "<stdin>", line 1, in <module>AttributeError: 'Student' object has no attribute 'age' >>> setattr(a, 'age', 19) >>> a.age 19getattr()
用于返回一个对象属性值。
语法：getattr(object, name[, default])
object -- 对象。
name -- 字符串，对象属性。
default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。示例：
>>> class Student(): def __init__(self, _name): self.name = _name >>> a = Student('ZhangSan') >>> a <__main__.Student object at 0x0000028AC2E406D8> >>> getattr(a, 'name')' ZhangSan' >>> getattr(a, 'age') Traceback (most recent call last): File "<stdin>", line 1, in <module>AttributeError: 'Student' object has no attribute 'age'hasattr()
用于判断对象是否包含对应的属性。
语法：hasattr(object, name)
object -- 对象。
name -- 字符串，属性名。示例：
>>> class Student(): def __init__(self, _name): self.name = _name >>> a = Student('ZhangSan') >>> hasattr(a, 'name') True >>> hasattr(a, 'age') False >>> setattr(a, 'age', 16) >>> hasattr(a, 'age') Truedelattr()
用于删除属性。
delattr(x, 'foobar') 相等于 del x.foobar。
语法：delattr(object, name)
object -- 对象。
name -- 字符串，属性名。示例：
>>> class Student(): def __init__(self, _name, _age): self.name = _name self.age = _age >>> a = Student('ZhangSan', 17) >>> hasattr(a, 'age') True >>> delattr(a, 'age') >>> hasattr(a, 'age') Falseproperty()
在新式类中返回属性值。
语法：class property([fget[, fset[, fdel[, doc]]]])
fget -- 获取属性值的函数
fset -- 设置属性值的函数
fdel -- 删除属性值函数
doc -- 属性描述信息示例：
>>> class Student(object): 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, '"X" Property') >>> a = Student() >>> a.name = "ZhangSan" >>> a <__main__.Student object at 0x0000013EE01F0588> >>> a.age = 19>>> a.gender = 'male' >>> a.gender 'male' >>> del a.gender >>> a.gender Traceback (most recent call last): File "<stdin>", line 1, in <module>AttributeError: 'Student' object has no attribute 'gender'
vars()
返回对象object的属性和属性值的字典对象。语法：
vars([object])
object -- 对象示例：
>>> vars() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>,'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>} >>> class Student(): def __init__(self, _name): self.name = _name >>> vars(Student) mappingproxy({'__module__': '__main__', '__init__': <function Student.__init__ at 0x00000171F1272EA0>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}) >>> a = Student() Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: __init__() missing 1 required positional argument: '_name' >>> a = Student("ZhangSan") >>> vars(a){'name': 'ZhangSan'}
对象操作函数
id()
用于获取对象的内存地址。
语法：id([object])
object -- 对象。示例：
>>> a = 'Hello World!' >>> id(a) 1588888884144 >>> b = 123 >>> id(b) 1559804144
eval()
用来执行一个字符串表达式，并返回表达式的值。
语法：eval(expression[, globals[, locals]])
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。示例：
>>> x = 123 >>> y = 456 >>> a = "(x+111)*y" >>> eval(a) 106704
exec()
exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
语法：exec(object[, globals[, locals]])
object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法：错误）。如果object是一个code对象，那么它只是被简单的执行。
globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。示例：
>>> a = "print('Hello World!')" >>> exec(a)Hello World!compile()
将一个字符串编译为字节代码。
语法：compile(source, filename, mode[, flags[, dont_inherit]])
source -- 字符串或者AST（Abstract Syntax Trees）对象。。
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志示例：
>>> str = "3 * 4 + 5" >>> a = compile(str,'','eval') >>> eval(a) 17
isinstance()
判断一个对象是否是一个已知的类型，类似 type()。
语法：isinstance(object, classinfo)
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。示例：
>>> isinstance(1, int) True >>> isinstance('123', str) True >>> isinstance(123, str) False >>> isinstance(123, (str, list, int)) Truestaticmethod
返回函数的静态方法。
语法：staticmethod(function)
示例：
>>> class C(object): @staticmethod def f(): print('runoob'); >>> C.f(); # 静态方法无需实例化 >>> cobj = C() >>> cobj.f() # 也可以实例化后调用issubclass()
语法：staticmethod(function)
super()
用于调用父类(超类)的一个方法。
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
语法：super(type[, object-or-type])
type -- 类。
object-or-type -- 类，一般是 self示例：
>>> class A: def add(self, x): y = x+1 print(y) class B(A): def add(self, x): super().add(x) >>> b = B() >>> b.add(2) # 3
callable()
函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True。
语法：callable(object)
object -- 对象示例：
>>> callable(0) False >>> callable("runoob") False >>> def add(a, b): ... return a + b ... >>> callable(add) # 函数返回 True True >>> class A: # 类... def method(self): ... return 0 ... >>> callable(A) # 类返回 True True >>> a = A() >>> callable(a) # 没有实现 __call__, 返回 False False >>> class B: ... def __call__(self): ... return 0 ... >>> callable(B) True >>> b = B() >>> callable(b) # 实现 __call__, 返回 True Truetype()
type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
语法：type(object)
type(name, bases, dict)
name -- 类的名称。
bases -- 基类的元组。
dict -- 字典，类内定义的命名空间变量。isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。示例：
>>> type(1) <class 'int'> >>> type([]) <class 'list'> >>> type({}) <class 'dict'> >>> class A(object): ... a = 'a' ... >>> a = A() >>> type(a) <class '__main__.A'>locals()
locals() 函数会以字典类型返回当前位置的全部局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。
语法：locals()
示例：
>>> def add(a, b): res = a+b print(locals()) >>> >>> add(123, 456) {'res': 579, 'b': 456, 'a': 123}globals()
globals() 函数会以字典类型返回当前位置的全部全局变量。
语法：globals()
示例：
>>> a = "Hello World!" >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': 'Hello World!'} >>>__import__()
__import__() 函数用于动态加载类和函数。
如果一个模块经常变化就可以使用 __import__() 来动态载入。
语法：__import__(name[, globals[, locals[, fromlist[, level]]]])
name -- 模块名示例：
import os print ('在 a.py 文件中 %s' % id(os)) >>> import sys __import__('a') # 导入 a.py 模块hash()
hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
语法：hash(object)
object -- 对象；示例：
>>> a = "Hello World" >>> hash(a) 5016083600221294254 >>> b = object() >>> hash(b) 99303549471
memoryview()
memoryview() 函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
语法：memoryview(obj)
obj -- 对象示例：
>>> v = memoryview('abcefg') >>> v[1] 'b' >>> v[-1] 'g' >>> v[1:4] <memory at 0x77ab28> >>> v[1:4].tobytes() 'bce' >>> >>> print(memoryview(bytearray("gbk", "utf-8", "gb2312"))) #获取bytearray数组的内存查看对象 <memory at 0x00000171F1653AC8>
其它常用函数
dir()
不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
语法：dir([object])
示例：
>>> dir() ['Student', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'list1', 'x', 'y'] >>> a = 'Hello World!' >>> dir(a) ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']>>> dir([])['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] >>>
format()
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。
语法："...".format()
示例：
>>> '姓名：{}；性别：{}'.format('ZhangSan', '男') '姓名：ZhangSan；性别：男' >>> '姓名：{name}；性别：{gender}'.format(name='ZhangSan', gender='男') '姓名：ZhangSan；性别：男'input()
Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
语法：input([prompt])
prompt: 提示信息示例：
>>> a = input("input:") input:123 # 输入整数 >>> type(a) <class 'str'>slice()
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
语法：class slice(stop)
class slice(start, stop[, step])
start -- 起始位置
stop -- 结束位置
step -- 间距示例：
>>> myslice = slice(5) # 设置截取5个元素的切片 >>> myslice slice(None, 5, None) >>> arr = range(10) >>> arr [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> arr[myslice] # 截取 5 个元素[0, 1, 2, 3, 4]>>>
len()
方法返回对象（字符、列表、元组等）长度或项目个数。
语法：len(s)
s -- 对象。示例：
>>> a = 'Hello World' >>> len(a)11 >>> list1 = [x for x in range(10)] >>> len(list1) 10
help()
查看函数或模块用途的详细说明。
语法：help([object])
object -- 对象；示例：
>>>help('sys') # 查看 sys 模块的帮助……显示帮助信息…… >>>help('str') # 查看 str 数据类型的帮助显示帮助信息…… >>>a = [1,2,3] >>>help(a) # 查看列表 list 帮助信息……显示帮助信息…… >>>help(a.append) # 显示list的append方法的帮助……显示帮助信息……
转载请注明：禅思 » Python内置函数总结？
