abs() 函数返回数字的绝对值。
语法abs( x )
参数x – 数值表达式。
返回值函数返回x（数字）的绝对值。
实例 print("abs(-45) : %s" % abs(-45)) print("abs(100.12) : %s" % abs(100.12)) 运行结果all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。 元素除了是 0、空、None、False 外都算 True。
函数等价于：
def all(iterable): for element in iterable: if not element: return False return True 语法all(iterable)
参数iterable – 元组或列表。
返回值如果iterable的所有元素不为0、’’、False或者iterable为空，all(iterable)返回True，否则返回False；
注意：空元组、空列表返回值为True，这里要特别注意。
实例 print(all(['a', 'b', 'c', 'd'])) # 列表list，元素都不为空或0 print(all(['a', 'b', '', 'd'])) # 列表list，存在一个为空的元素 print(all([0, 1, 2, 3])) # 列表list，存在一个为0的元素 print(all([])) # 空列表 print("*" * 20) print(all(('a', 'b', 'c', 'd'))) # 元组tuple，元素都不为空或0 print(all(('a', 'b', '', 'd'))) # 元组tuple，存在一个为空的元素 print(all((0, 1, 2, 3))) # 元组tuple，存在一个为0的元素 print(all(())) # 空元组 运行结果any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。 元素除了是 0、空、FALSE 外都算 TRUE。
函数等价于：
def any(iterable): for element in iterable: if element: return True return False 语法any(iterable)
参数iterable – 元组或列表。
返回值如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true
注意：空元组、空列表返回值为false，这里要特别注意。
实例 print(any(['a', 'b', 'c', 'd'])) # 列表list，元素都不为空或0 print(any(['a', 'b', '', 'd'])) # 列表list，存在一个为空的元素 print(any([0, 1, 2, 3])) # 列表list，存在一个为0的元素 print(any([])) # 空列表 print("*" * 20) print(any(('a', 'b', 'c', 'd'))) # 元组tuple，元素都不为空或0 print(any(('a', 'b', '', 'd'))) # 元组tuple，存在一个为空的元素 print(any((0, 1, 2, 3))) # 元组tuple，存在一个为0的元素 print(any(())) # 空元组 运行结果ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值。
语法ascii(object)
参数object – 对象。
返回值返回字符串。
实例 print("小胖") print(ascii("小胖")) 运行结果bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
语法bin(x)
参数x – int 或者 long int 数字
返回值返回字符串。
实例 print(bin(100)) 运行结果bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
bool 是 int 的子类。
语法bool(x)
参数x – 要进行转换的参数。
返回值返回 True 或 False。
实例 print(bool()) print(bool(0)) print(bool(1)) print(issubclass(bool, int)) # bool 是 int 子类 运行结果bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
语法class bytearray([source[, encoding[, errors]]])
参数如果 source 为整数，则返回一个长度为 source 的初始化数组； 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列； 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数； 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。 如果没有输入任何参数，默认就是初始化数组为0个元素
返回值返回新字节数组。
实例 print(bytearray()) print(bytearray([1, 2, 3])) print(bytearray('runoob', 'utf-8')) 运行结果bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
语法class bytes([source[, encoding[, errors]]])
参数如果 source 为整数，则返回一个长度为 source 的初始化数组； 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列； 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数； 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。 如果没有输入任何参数，默认就是初始化数组为0个元素。
返回值返回一个新的 bytes 对象。
实例 print(bytes()) print(bytes([1, 2, 3])) print(type(bytes([1, 2, 3]))) print(bytes('runoob', 'utf-8')) 运行结果callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True。
语法callable(object)
参数object – 对象。
返回值可调用返回 True，否则返回 False。
实例 print(callable(0)) print(callable("runoob")) def add(a, b): return a + b print(callable(add)) # 函数返回 True class A: # 类 def method(self): return 0 print(callable(A)) # 类返回 True a = A() print(callable(a)) # 没有实现 __call__, 返回 False class B: def __call__(self): return 0 print(callable(B)) b = B() print(callable(b)) # 实现 __call__, 返回 True 运行结果chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
语法chr(i)
参数i – 可以是10进制也可以是16进制的形式的数字。
返回值返回值是当前整数对应的 ASCII 字符。
实例 print(chr(0x30), chr(0x31), chr(0x61)) # 十六进制 print(chr(48), chr(49), chr(97)) # 十进制 运行结果classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
语法classmethod
参数无。
返回值返回函数的类方法。
实例 class A(object): bar = 1 def func1(self): print ('foo') @classmethod def func2(cls): print('func2') print(cls.bar) cls().func1() # 调用 foo 方法 A.func2() 运行结果dict() 函数用于创建一个字典。
语法class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg)
参数**kwargs – 关键字 mapping – 元素的容器。 iterable – 可迭代对象。
返回值返回一个字典。
实例 print(dict()) # 创建空字典 print(dict(a='a', b='b', t='t')) # 传入关键字 print(dict(zip(['one', 'two', 'three'], [1, 2, 3]))) # 映射函数方式来构造字典 print(dict([('one', 1), ('two', 2), ('three', 3)])) # 可迭代对象方式来构造字典 运行结果filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
注意: Pyhton2.7 返回列表，Python3.x 返回迭代器对象
语法filter(function, iterable)
参数function – 判断函数。 iterable – 可迭代对象。
返回值Pyhton2.7 返回列表，Python3.x 返回迭代器对象
实例 将列表中的奇数过滤出来 List3 = [1, 3, 4, 5, 6, 8, 11] List4 = list(filter(lambda x: x % 2 == 1, list3)) Print(list4) 运行结果[1, 3, 5, 11]
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
format 函数可以接受不限个参数，位置可以不按顺序。
实例 a = "{} {}".format("hello", "world") # 不设置指定位置，按默认顺序 print(a) a = "{0} {1}".format("hello", "world") # 设置指定位置 print(a) a = "{1} {0} {1}".format("hello", "world") # 设置指定位置 print(a) print("网站名：{name}, 地址 {url}".format(name="百度首页", url="http://www.baidu.com")) # 通过字典设置参数 site = {"name": "百度首页", "url": "http://www.baidu.com"} print("网站名：{name}, 地址 {url}".format(**site)) # 通过列表索引设置参数 my_list = ['百度首页', 'http://www.baidu.com'] print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的 运行结果 数字格式化 数字格式输出描述3.1415926{:.2f}3.14保留小数点后两位3.1415926{:+.2f}+3.14带符号保留小数点后两位-1{:+.2f}-1.00带符号保留小数点后两位2.71828{:.0f}3不带小数5{:0>2d}05数字补零 (填充左边, 宽度为2)5{:x<4d}5xxx数字补x (填充右边, 宽度为4)10{:x<4d}10xx数字补x (填充右边, 宽度为4)1000000{:,}1,000,000以逗号分隔的数字格式0.25{:.2%}25.00%百分比格式1000000000{:.2e}1.00e+09指数记法13{:>10d}13右对齐 (默认, 宽度为10)13{:<10d}13左对齐 (宽度为10)13{:^10d}13中间对齐 (宽度为10) 进制‘{:b}’.format(11) 1011
‘{:d}’.format(11) 11
{：o}.format(11) 13
‘{:x}’.format(11) b
‘{:#x}’.format(11) 0xb
‘{:#X}’.format(11) 0XB
sinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别： type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()
。
语法isinstance(object, classinfo)
参数object – 实例对象。 classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
返回值如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。
实例 a = 2 print(isinstance(a, int)) print(isinstance(a, str)) print(isinstance(a, (str, int, list))) # 是元组中的一个返回 True # type()与isinstance()区别： class A: pass class B(A): pass print(isinstance(A(), A)) # returns True print(type(A()) == A) # returns True print(isinstance(B(), A)) # returns True print(type(B()) == A) # returns False 运行结果issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
语法issubclass(class, classinfo)
参数class – 类。 classinfo – 类
返回值如果 class 是 classinfo 的子类返回 True，否则返回 False。
实例 class A: pass class B(A): pass class C: pass print(issubclass(B, A)) # 返回 True print(issubclass(C, A)) # 返回 False 运行结果iter() 函数用来生成迭代器。
语法iter(object[, sentinel])
参数object – 支持迭代的集合对象。 sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
返回值迭代器对象。
实例 lst = [1, 2, 3] b = iter(lst) print(b) for i in b: print(i) 运行结果map() 会根据提供的函数对指定序列做映射。 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
语法map(function, iterable, …)
参数function – 函数名 iterable – 一个或多个序列。
返回值Python 2.x 返回列表。 Python 3.x 返回迭代器。
实例 def square(x): # 计算平方数 return x ** 2 a = map(square, [1, 2, 3, 4, 5]) # 计算列表各个元素的平方 print(list(a)) a = map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数 print(list(a)) # 提供了两个列表，对相同位置的列表数据进行相加 b = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) print(list(b)) 运行结果next() 返回迭代器的下一个项目。
语法next(iterator[, default])
参数iterator – 可迭代对象 default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
实例 # 首先获得Iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: while True: try: # 获得下一个值: x = next(it) print(x) except StopIteration: # 遇到StopIteration就退出循环 break 运行结果pow() 方法返回 xy（x的y次方） 的值。
语法以下是 math 模块 pow() 方法的语法:
import math
math.pow( x, y )
内置的 pow() 方法 pow(x, y[, z]) 函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z
注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
参数x – 数值表达式。 y – 数值表达式。 z – 数值表达式。
返回值返回 xy（x的y次方） 的值。
实例 import math # 导入 math 模块 print("math.pow(100, 2) : %s" % math.pow(100, 2)) # 使用内置，查看输出结果区别 print("pow(100, 2) : %s" % pow(100, 2)) print("math.pow(100, -2) : %s" % math.pow(100, -2)) print("math.pow(2, 4) : %s" % math.pow(2, 4)) print("math.pow(3, 0) : %s" % math.pow(3, 0)) 运行结果reduce() 函数会对参数序列中元素进行累积。 函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
Python2.x可以直接使用 Python3.x将函数直接封装到functools
语法reduce(function, iterable[, initializer])
参数function – 函数，有两个参数 iterable – 可迭代对象 initializer – 可选，初始参数
返回值返回函数计算结果
实例 from functools import reduce def add(x, y): # 两数相加 return x + y a = reduce(add, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5 print(a) b = reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函数 print(b) 运行结果reverse() 函数用于反向列表中元素。
语法list.reverse()
返回值该方法没有返回值，但是会对列表的元素进行反向排序。
实例 aList = [123, 'xyz', 'zara', 'abc', 'xyz'] aList.reverse() print(f"List : {aList}") 运行结果round() 方法返回浮点数x的四舍五入值。
语法round( x [, n] )
参数x – 数值表达式。 n – 数值表达式。
返回值返回浮点数x的四舍五入值
实例 print("round(80.23456, 2) : ", round(80.23456, 2)) print("round(100.000056, 3) : ", round(100.000056, 3)) print("round(-100.000056, 3) : ", round(-100.000056, 3)) 运行结果slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
语法class slice(stop) class slice(start, stop[, step])
参数start – 起始位置 stop – 结束位置 step – 间距
返回值返回一个切片对象。
实例 myslice = slice(5) # 设置截取5个元素的切片 print(myslice) arr = range(10) print(arr) a = arr[myslice] # 截取 5 个元素 print(a) 运行结果sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别： sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。 list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
语法sorted(iterable, cmp=None, key=None, reverse=False)
参数 iterable – 可迭代对象。cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。 返回值返回重新排序的列表。
实例 a = [5, 7, 6, 3, 4, 1, 2] b = sorted(a) # 保留原列表 print(a) print(b) L = [('b', 2), ('a', 1), ('c', 3), ('d', 4)] b = sorted(L, key=lambda x: x[1]) # 利用key print(b) students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] c = sorted(students, key=lambda s: s[2]) # 按年龄升序排列 print(c) c = sorted(students, key=lambda s: s[2], reverse=True) # 按年龄降序排列 print(c) 运行结果zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。 如果需要了解 Pyhton3 的应用，可以参考 Python3 zip()。
语法zip([iterable, …])
参数objiterabl – 一个或多个迭代器;
返回值返回元组列表。
实例 a = [1,2,3] b = [4,5,6] c = [4,5,6,7,8] zipped = zip(a,b) # 打包为元组的列表 print(list(zipped)) d = zip(a,c) # 元素个数与最短的列表一致 print(list(d)) 运行结果