内置函数

内置函数

　　思维导图：https://www.processon.com/mindmap/5b72bae3e4b025cf49454149

详细说明：

　　1.abs()

　　说明：返回数字的绝对值；

　　语法：abs(n)

　　参数：n ---------> 数值表达式，可以是整数、浮点数、复数；

　　返回值：返回n(数字)的绝对值，如果参数是一个复数，则返回它的大小；

　　实例：

>>> print(abs(-40))
40
>>> print(abs(100.23))
100.23

　　2.all()

　　说明：用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False；

　　语法：all(iterable)

　　参数：iterable -------> 元组或列表，集合等可迭代对象；

　　函数描述：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

　　返回值：如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；

　　注意：空元组、空列表返回值为True，这里要特别注意；

　　实例：

#1.当list元素都不为空或0时；
>>> all([1,2,4,"as"])
True

#2.当存在一个空元素时；
>>> all([1,2,0,"as"])
False
>>> all([1,2,(),"as"])
False

#3.特殊的是只要是空字典、空列表、空集合、空元组却是True；
>>> all([])
True
>>> all(())
True
>>> all({})
True
>>> all(set())
True

　　3.any()

　　说明：用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True；

　　语法：any(iterable)

　　参数：iterable ---------> 可迭代对象；

　　返回值：如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true；

　　实例：

#1.都不为空；
>>> any([1,2,4,"as"])
True

#2.有一个为空；
>>> any([0,2,"","as"])
True

#3.元素都为空；
>>> any([0,"",False])
False

#4.空列表、空字典、空元组、空集合
>>> any([])
False
>>> any(())
False
>>> any({})
False
>>> any(set())
False

　　4.ascii()

　　说明：ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 x, u 或 U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值；

　　语法：ascii(obj)

　　参数：obj --------> 对象；

　　返回值：返回字符串；

　　实例：

>>> ascii("a")
"'a'"
>>> ascii("中")
"'\u4e2d'"
>>> ascii(5)
'5'

　　5.bin()

　　说明：返回一个整数 int 或者长整数 long int 的二进制表示；

　　语法：bin(n)

　　参数：n -----------> int或long int数字；

　　返回值：字符串；

　　实例：

#0x表示的是二进制
>>> bin(10)
'0b1010'
>>> bin(5)
'0b101'
>>> bin(12)
'0b1100'

　　6.bool()

　　说明：用于将给定参数转换为布尔类型，如果没有参数，返回 False；bool 是 int 的子类；

　　语法：bool ([x])

　　参数：x --------> 要进行转换的参数；

　　返回值：返回True或False；

　　实例：

>>> bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool("a")
True

#bool是int的子类
>>> issubclass(bool,int)
True

　　7.bytearray()

　　说明：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256；

　　语法：bytearray([source[,encoding[,errors]]])

　　参数：如果 source 为整数，则返回一个长度为 source 的初始化数组；

　　　　　如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；

　　　　　如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；

　　　　　如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray；

　　　　　如果没有输入任何参数，默认就是初始化数组为0个元素；

　　返回值：返回新字节数组；

　　实例：

>>> bytearray()
bytearray(b'')
>>> bytearray([1,2,3])
bytearray(b'x01x02x03')
>>> bytearray("zjk","utf-8")
bytearray(b'zjk')

　　8.bytes()

　　说明：返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本；

　　语法：bytes([source[, encoding[, errors]]])

　　参数：如果 source 为整数，则返回一个长度为 source 的初始化数组；

　　　　　如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；

　　　　　如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；

　　　　　如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray；

　　　　　如果没有输入任何参数，默认就是初始化数组为0个元素；

　　返回值：返回一个新的 bytes 对象；

　　实例：

>>> a = bytes([1,2,3,4])
>>> a
b'x01x02x03x04'
>>> type(a)
<class 'bytes'>
>>> 
>>> a = bytes("hello","ascii")
>>> a
b'hello'
>>> type(a)
<class 'bytes'>

　　9.callable()

　　说明：用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True；

　　语法：callable(object)

　　参数：object --------> 对象；

　　返回值：可调用返回 True，否则返回 False；

　　实例：

>>> callable(0)
False
>>> callable("zjk")
False
>>> def add(a,b):
...     return a+b
... 
>>> callable(add)
True
>>> 
>>> class A:
...     def func(self):
...             return 0
... 
>>> callable(A)
True
>>> a = A()
>>> callable(a)
False

　　10.chr()

　　说明：chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符；

　　语法：chr(i)

　　参数：i --------> 可以是10进制也可以是16进制的形式的数字;

　　返回值：返回值是当前整数对应的ascii字符；

　　实例：

#十六进制
>>> print(chr(0x31),chr(0x30),chr(0x61))
1 0 a

#十进制
>>> print(chr(49),chr(48),chr(50))
1 0 2

　　11.classmethod()

　　说明：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()
func2
1
foo

　　12.compile()

　　说明：将一个字符串编译为字节代码；

　　语法：compile(source, filename, mode[, flags[, dont_inherit]])

　　参数：source -------> 字符串或AST对象；

　　　　　filename -----> 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值；

　　　　　mode ---------> 指定编译代码的种类，可以指定为exec,eval,single；

　　　　　flags ----------> 变量作用域，局部命名空间，如果被提供，可以是任何映射对象；

　　　　　flags和dont_inherit -----> 用来控制编码时的标志；

　　返回值：返回表达式执行结果；

　　实例：

>>> st = "for i in range(0,10):print(i)"
>>> c = compile(st,"","exec")
>>> c
<code object <module> at 0x7f7054f46d20, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> st = "3*4+5"
>>> a = compile(st,"","eval")
>>> eval(a)
17

　　13.complex()

　　说明：用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数；

　　语法：complex([real[, imag]])

　　参数：real ------> int、long、float或字符串；

　　　　　imag -----> int、long、float

　　返回值：返回一个复数；

　　实例：

>>> complex(1,2)
(1+2j)
>>> complex(1)
(1+0j)
>>> complex("5")
(5+0j)
>>> complex("1+2j")
(1+2j)

　　14.delattr()

　　说明：函数用于删除属性；

　　语法：delattr(object, name)

　　参数：object -------> 对象；

　　　　　name -------> 必须是对象的属性；

　　实例：

>>> class zjk:
...     x = 10
...     y = 20
...     z = 30
... 
>>> z1 = zjk()
>>> print(z1.x,z1.y,z1.z)
10 20 30
>>> delattr(zjk,"z")
>>> print(z1.x,z1.y)
10 20
>>> print(z1.z)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'zjk' object has no attribute 'z'

　　15.dict()

　　说明：用于创建一个字典；

　　16.dir()

　　说明：dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息；

　　语法：dir([object])；

　　参数：object ------>  对象，变量，类型；

　　返回值：返回模块的属性列表；

　　实例：

#获取当前模块的属性列表；
>>> dir()
['A', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'add', 'c', 'i', 'st', 'z1', 'zjk']

#查看列表的方法；
>>> 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']

　　17.divmod()

　　说明：把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)；

　　语法：divmod(a, b)

　　参数：a ------> 数字；

　　　　　b ------> 数字；

　　实例：

>>> divmod(7,2)
(3, 1)
>>> divmod(10,5)
(2, 0)

　　18.enumerate()

　　说明：枚举，用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中；

　　语法：enumerate(sequence, [start=0])

　　参数：sequence -----> 一个序列、迭代器或其他支持迭代对象；

　　　　　start -----------> 下标其实位置，默认为0；

　　返回值：返回enumerate(枚举) 对象；

　　实例：

>>> li = ["I","love","you"]
>>> for i,n in enumerate(li,0):
...     print(i,n)
... 
0 I
1 love
2 you
>>> for i,n in enumerate(li,15):
...     print(i,n)
... 
15 I
16 love
17 you

　　19.eval()

　　说明：用来执行一个字符串表达式，并返回表达式的值；

　　语法：eval(expression[, globals[, locals]])

　　参数：expression -- 表达式；

　　　　　globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象；

　　　　　locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象；

　　返回值：返回表达式计算结果；

　　实例：

>>> x = 7
>>> eval("3 * x")
21
>>> eval("pow(2,2)")
4
>>> eval("1+2+3")
6

　　20.exec()

　　说明：执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码；

　　语法：exec(object[, globals[, locals]])

　　参数：object ------> 必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行；

　　　　　globals -------> 可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象;

　　　　　locals -------> 可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值

　　返回值：exec 返回值永远为 None；

　　实例：

#执行单行语句字符串；
>>> exec("print('hello world')")
hello world

#执行多行语句字符串；
>>> exec("""for i in range(5):
...     print("This is %s" % i)
... """)
This is 0
This is 1
This is 2
This is 3
This is 4

　　21.filter()

 　　说明：用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换；该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

　　语法：filter(function,iterable)

　　参数：function ---------> 具有判断功能的函数，此函数的返回值为True或False；

　　　　　iterable ----------> 可迭代的对象；

　　返回值：返回一个迭代器对象；

　　实例：

#将列表中所有姓王的名字去掉；
>>> li = ["王大锤","王小锤","张无忌","张铁林","灯火阑珊"]
>>> l1 = filter(lambda n:n[0]!="王",li)
>>> print(l1)
<filter object at 0x7f88074185f8>
>>> print(list(l1))
['张无忌', '张铁林', '灯火阑珊']

#将列表中的所有名字去掉，只剩下灯火阑珊，通过双重过滤实现；
>>> li = ["王大锤","王小锤","张无忌","张铁林","灯火阑珊"]
>>> l1 = filter(lambda n:n[0]!="王",filter(lambda i:i[0]!="张",li))
>>> print(list(l1))
['灯火阑珊']


#通过filter过滤字典;将字典中成绩大于90的过滤掉；
>>> lst = [
...     {"name":"汪峰", "score":48},
...     {"name":"章子怡", "score":39},
...     {"name":"哈哈","score":97},
...     {"name":"嘿嘿","score":90}
... ]
>>> l1 = filter(lambda n:n["score"]<90,lst)
>>> print(list(l1))
[{'name': '汪峰', 'score': 48}, {'name': '章子怡', 'score': 39}]

　　22.float()

　　说明：用于将整数和字符串转换成浮点数；

　　语法：float(x)

　　参数：x ------> 整数或字符串；

　　返回值：返回浮点数；

　　实例：

>>> float(1)
1.0
>>> float(153)
153.0
>>> float(-15.963)
-15.963
>>> float("666")
666.0

　　23.format()

　　详细信息请参考字符串文章中的format方法；在此不再进行说明；

　　24.frozneset()

　　说明：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素；

　　语法：frozenset([iterable])

　　参数：iterable --------> 可迭代对象；

　　返回值：返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合；

　　实例：

>>> a = frozenset(range(10))
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
>>> type(a)
<class 'frozenset'>
>>> hash(a)
3895031357313128696

　　25.getattr()

　　说明：用于返回一个对象属性值；

　　语法：getattr(object, name[, default])；

　　参数：object ------> 对象；

　　　　　name -------> 字符串，对象属性；

　　　　　default ------> 默认返回值，如果不提供该参数，在没有对应属性时，将触发AttributeError；

　　返回值：返回对象属性值；

　　实例：

>>> class A:
...     bar = 1
... 
>>> a = A()
>>> getattr(a,"bar")
1
>>> getattr(a,"bar1")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar1'
>>> getattr(a,"bar1",666)
666

　　26.globals()

　　说明：globals() 函数会以字典类型返回全局变量；

　　语法：globals()

　　返回值：返回全局变量的字典；

　　实例：

>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': <__main__.A object at 0x7f704d123dd8>, 'add': <function add at 0x7f7054f8f1e0>, 'A': <class '__main__.A'>, 'st': '3*4+5', 'c': <code object <module> at 0x7f7054f46d20, file "", line 1>, 'i': 4, 'zjk': <class '__main__.zjk'>, 'z1': <__main__.zjk object at 0x7f704d123c50>, 'li': ['I', 'love', 'you'], 'n': 'you', 'x': 7}

　　27.hasattr()

　　说明：用于判断对象是否包含对应的属性；

　　语法：hasattr(object, name)

　　参数：object -------> 对象；

　　　　　name -------> 字符串，属性名；

　　返回值：如果对象有该属性返回 True，否则返回 False；

　　实例：

>>> class zjk:
...     x = 10
...     y = 20
...     z = 30
... 
>>> a = zjk()
>>> print(hasattr(a,"x"))
True
>>> print(hasattr(a,"y"))
True
>>> print(hasattr(a,"z"))
True
>>> print(hasattr(a,"b"))
False

　　28.hash()

　　说明：用于获取取一个对象（字符串或者数值等）的哈希值；

　　语法：hash(object)

　　返回值：返回对象的哈希值；

　　实例：

>>> hash("zjk")
-4128750648655055189
>>> hash(1)
1
>>> hash((1,2,3,4))
485696759010151909

　　29.help()

　　说明：用于查看函数或模块用途的详细说明；

　　语法：help(object)

　　参数：object -------> 对象；

　　返回值：返回对象帮助信息；

　　实例：

#查看sys模块的帮助；
>>> help("sys")
Help on built-in module sys:
..........显示帮助信息..................

#查看str数据类型的帮助；
>>> help("str")
Help on class str in module builtins:
..........显示帮助信息..................

　　30.hex()

　　说明：用于将10进制整数转换成16进制，以字符串形式表示；

　　语法：hex(x)

　　参数：x -------> 10进制整数；

　　返回值：返回16进制数，以字符串形式表示；

　　实例：

>>> hex(255)
'0xff'
>>> hex(10)
'0xa'
>>> hex(5)
'0x5'
>>> hex(9)
'0x9'
>>> hex(15)
'0xf'

　　31.id()

　　说明：用于获取对象的内存地址；

　　语法：id(obj)

　　参数：obj -------> 对象；

　　返回值：返回对象的内存地址；

　　实例：

>>> a = [1,2,3,4]
>>> id(a)
140120293520072
>>> b = "zjk"
>>> id(b)
140120306105232

　　32.input()

　　说明：接收一个标准输入数据，返回str类型；

　　语法：input(pro)

　　参数：pro ------> 提示信息；

　　实例：

>>> a = input("[root@local]#")
[root@local]#pwd
>>> a
'pwd'

　　33.int()

　　具体信息见int数据类型；

　　34.isinstance()

　　说明：判断一个对象是否是一个已知的类型，类似 type()

　　语法：isinstance(object, classinfo)

　　参数：object -------> 实例对象；

　　　　　classinfo -----> 可以是直接或间接类名、基本类型或者由它们组成的元祖；

　　返回值：如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False；

　　和type区别：

　　　　　type() 不会认为子类是一种父类类型，不考虑继承关系；

　　　　　isinstance() 会认为子类是一种父类类型，考虑继承关系；

　　实例：

>>> a = 123
>>> isinstance(a,int)
True
>>> isinstance(a,str)
False
>>> isinstance(a,(str,int,list))
True


#type()和isinstance()区别：
>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(),A)
True
>>> type(A()) == A
True
>>> isinstance(B(),A)
True
>>> type(B()) == A
False

　　35.issubclass()

　　说明：用于判断参数 class 是否是类型参数 classinfo 的子类；

　　语法：issubclass(class, classinfo)

　　参数：class --------> 类

　　　　　classinfo ------> 类

　　返回值：如果 class 是 classinfo 的子类返回 True，否则返回 False；

　　实例：

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> issubclass(B,A)
True

　　36.iter()

　　说明：用来生成迭代器；

　　语法：iter(object[, sentinel])

　　参数：object -- 支持迭代的集合对象；

　　　　　sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object

　　返回值：迭代器对象；

　　实例：

>>> li = [1,2,3,4,5]
>>> for n in iter(li):
...     print(n)
... 
1
2
3
4
5

　　37.len()

　　说明：返回对象（字符、列表、元组等）长度或项目个数；

　　语法：len(s)

　　参数：s -------> 对象；

　　返回值：返回对象长度；

　　实例：

>>> li = [1,2,3,4,5]
>>> len(li)
5
>>> st = "zjk"
>>> len(st)
3

　　38.list()

　　具体信息见列表数据类型；

　　39.locals()

　　说明：以字典类型返回当前位置的全部局部变量；

　　语法：locals()

　　返回值：返回字典类型的局部变量；

　　实例：

>>> def zjk():
...     a = 123
...     b = "yy"
...     print(locals())
... 
>>> zjk()
{'a': 123, 'b': 'yy'}

　　39.map

 　　说明：map() 会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表；

　　语法：map(function,iterable,.....)

　　参数：function -------------> 函数；

　　　　　iterable -------------> 一个或多个序列

　　返回值：返回一个迭代器；

　　思想：分而治之： map(func1, map(func2, map(func3 , lst)))

　　实例：

#1.计算列表中每个数字的平方
>>> li = [1,3,5,7,9]
>>> l1 = map(lambda n:n**2,li)
>>> print(list(l1))
[1, 9, 25, 49, 81]


#2.计算两个列表中每个对应的数字相加；
>>> li = [1,3,5,7,9]
>>> li2 = [2,4,6,8,0]
>>> l1 = map(lambda x,y:x+y,li,li2)
>>> print(list(l1))
[3, 7, 11, 15, 9]


#3.map也是水桶效应，只取最短列；
>>> li = [1,3,5,7,9]
>>> li2 = [2,4,6,8]
>>> li3 = [12,13,14]
>>> l1 = map(lambda x,y,z:x+y+z,li,li2,li3)
>>> print(list(l1))
[15, 20, 25]

　　40.max()

　　说明：返回给定参数的最大值，参数可以为序列；

　　语法：max( x, y, z, .... )

　　参数：x -----> 数值表达式

　　　　　y -----> 数值表达式

　　　　　z -----> 数值表达式

　　返回值：返回给定参数的最大值；

　　实例：

>>> max(1,2,4,6,7,234,4321)
4321
>>> max([1,4,2,89,4,2,57,234])
234
>>> max((-1,-45,-345,234,-345))
234

　　41.memoryview()

　　说明：返回给定参数的内存查看对象(Momory view)；所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问；

　　语法：memoryview(obj)

　　参数：obj ------> 对象；

　　返回值：返回元组列表；

　　实例：

>>> v = memoryview(bytearray("abcdefg","utf-8"))
>>> v[1]
98
>>> v[-1]
103
>>> v[:4]
<memory at 0x7efc44aa1408>
>>> v[1:4]
<memory at 0x7efc44aa14c8>

　　42.min()

　　说明：返回给定参数的最小值，参数可以为序列；

　　语法：min( x, y, z, .... )

　　参数：x -----> 数值表达式

　　　　　y -----> 数值表达式

　　　　　z -----> 数值表达式

　　返回值：返回给定参数的最小值；

　　实例：

>>> min([1,6,34,0,435,3,-456])
-456

　　43.next()

　　说明：返回迭代器的下一个项目；

　　语法：next(iterator[, default])

　　参数：iterator -- 可迭代对象；

　　　　　default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常；

　　返回值：返回对象帮助信息；

　　实例：

>>> li = [1,2,3,4,5]
>>> l1 = li.__iter__()
>>> next(l1)
1

　　44.object()

　　45.otc()

　　说明：将一个整数转换成8进制字符串；

　　语法：oct(x)

　　参数：x --------> 整数；

　　返回值：返回8进制字符串；

　　实例：

#0o表示8进制；
>>> oct(5)
'0o5'
>>> oct(9)
'0o11'
>>> oct(8)
'0o10'

　　46.open()

　　具体请看文件操作文章；

　　47.ord()

　　说明：ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常；

　　语法：ord(x)

　　参数：x ------> 字符；

　　返回值：返回值是对应的十进制整数；

　　实例：

>>> ord("a")
97
>>> ord("b")
98
>>> ord("c")
99

　　48.pow()

　　说明：pow() 方法返回 x^y（x的y次方） 的值；

　　语法：pow(a,b,c)

　　参数：a -----> x;

　　　　　b ------> y

　　　　　c ------>pow(a,b) %c,取余

　　返回值：返回 x^y（x的y次方） 的值；

　　实例：

>>> pow(10,2,3)
1
>>> pow(10,2)
100
>>> pow(10,2,2)
0

　　49.print()

　　说明：用于打印输出，最常见的一个函数；

　　语法：print(*objects, sep=' ', end=' ', file=sys.stdout)

　　参数：objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔；

　　　　　sep -- 用来间隔多个对象，默认值是一个空格；

　　　　　end -- 用来设定以什么结尾。默认值是换行符 ，我们可以换成其他字符串；

　　　　　file -- 要写入的文件对象；

　　实例：

>>> print(1)
1
>>> print("hello world")
hello world
>>> print("hello""world")
helloworld
>>> print("hello","world")
hello world
>>> print("www","dhlanshan","cn",sep=".")
www.dhlanshan.cn

　　50.propery()

　　说明：是在新式类中返回属性值；

　　语法：property([fget[, fset[, fdel[, doc]]]])

　　参数：fget -- 获取属性值的函数

　　　　　fset -- 设置属性值的函数

　　　　　fdel -- 删除属性值函数

　　　　　doc -- 属性描述信息

　　返回值：返回新式类属性；

　　实例：

　　51.range()

　　说明：range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表；

　　语法：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);

　　实例：

>>> print(range(5))
range(0, 5)
>>> for n in range(5):
...     print(n)
... 
0
1
2
3
4
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(0))
[]

　　52.repr()

　　说明：将对象转化为供解释器读取的形式，也就是对象在程序内部中的存储样子；

　　语法：repr(object)

　　参数：object ---------> 对象；

　　返回值：返回一个对象的 string 格式；

　　实例：

>>> s = "zjkzjk"
>>> repr(s)
"'zjkzjk'"

　　注意：

　　repr()并不是完全原样输出，而是将数据以程序存储的形式显示给用户，真正完全原样输出的应该是以下例子：

>>> print(r"你好呀！\,	, 
 "")
你好呀！\,	, 
 "

　　53.reversed()

　　说明：返回一个反转的迭代器；

　　语法：reversed(seq)

　　参数：seq --------> 要转换的序列，可以是tuple、string、list或者range；

　　返回值：返回一个反转的迭代器；

　　实例：

>>> a = reversed([1,2,3,4,5,6,7,8])
>>> print(a)
<list_reverseiterator object at 0x7efc44ab8e10>
>>> list(a)
[8, 7, 6, 5, 4, 3, 2, 1]

　　54.round()

　　说明：返回浮点数x的四舍五入值；

　　语法：round( x [, n] )

　　参数：x ----------> 数字表达式；

　　　　　n ----------> 表示从小数点位数，其中x需要四舍五入，默认值为0

　　返回值：返回浮点数x的四舍五入值；

　　实例：

>>> round(12)
12
>>> round(3.1415926)
3
>>> round(3.48)
3
>>> round(3.50)
4
>>> round(3.51)
4

　　55.set()

　　具体信息见集合数据类型；

　　

　　56.setattr()

　　说明：setattr 函数对应函数 getatt()，用于设置属性值，该属性必须存在；

　　语法：setattr(object, name, value)

　　参数：object -- 对象；

　　　　　name -- 字符串，对象属性；

　　　　　value -- 属性值；

　　实例：

>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')          # 获取属性 bar 值
1
>>> setattr(a, 'bar', 5)       # 设置属性 bar 值
>>> a.bar
5

　　57.slice()

　　说明：slice() 函数实现切片对象，主要用在切片操作函数里的参数传递；

　　语法：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]

　　58.sorted()

　　说明：对所有可迭代的对象进行排序操作；

　　语法：sorted(iterable, key=None, reverse=False)；

　　参数：iterable -- 可迭代对象。

　　　　　key -- 定义一个排序方案，sorted函数内部会把可迭代对象中的每一个元素拿出来交给后面的key；后面的key计算出一个数字. 作为当前这个元素的权重, 整个函数根据权重进行排序

　　　　　reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

　　返回值：返回重新排序的列表；

　　sort 与 sorted 区别：

　　　　sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

　　　　list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

　　实例：

>>> sorted([3,5,71,60,3])
[3, 3, 5, 60, 71]

#以列表中的每个元素的长度为权重，进行排序；
>>> lst = ["聊斋", "西游记", "三国演义", "葫芦娃", "水浒传", "年轮", "亮剑"]
>>> ll = sorted(lst,key=lambda n:len(n))  #默认升序
>>> print(ll)
['聊斋', '年轮', '亮剑', '西游记', '葫芦娃', '水浒传', '三国演义']
>>> ll = sorted(lst,key=lambda n:len(n),reverse=True)  #设置为降序
>>> print(ll)
['三国演义', '西游记', '葫芦娃', '水浒传', '聊斋', '年轮', '亮剑']


#以字典的value为权重，进行排序；
>>> lst = [
...     {'name':"汪峰","age":48},
...     {"name":"章子怡",'age':38},
...     {"name":"alex","age":39},
...     {"name":"wusir","age":32},
...     {"name":"晓刚","age":28}
...     ]
>>> ll = sorted(lst,key=lambda n:n["age"])  #默认升序
>>> print(ll)
[{'name': '晓刚', 'age': 28}, {'name': 'wusir', 'age': 32}, {'name': '章子怡', 'age': 38}, {'name': 'alex', 'age': 39}, {'name': '汪峰', 'age': 48}]
>>> ll = sorted(lst,key=lambda n:n["age"],reverse=True)  #设置降序
>>> print(ll)
[{'name': '汪峰', 'age': 48}, {'name': 'alex', 'age': 39}, {'name': '章子怡', 'age': 38}, {'name': 'wusir', 'age': 32}, {'name': '晓刚', 'age': 28}]

　　59.staticmethod()

　　说明：返回函数的静态方法；

　　语法：staticmethod(function)

　　实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class C(object):
    @staticmethod
    def f():
        print('runoob');
 
C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()        # 也可以实例化后调用

　　60.str()

　　具体见字符串数据类型；

　　61.sum()

　　说明：对系列进行求和计算；

　　语法：sum(iterable[, start])

　　参数：iterable -- 可迭代对象，如：列表、元组、集合；

　　　　start -- 指定相加的参数，如果没有设置这个值，默认为0；

　　返回值：返回计算结果；

　　实例：

>>> sum([1,4,6])
11
>>> sum([1,4,6],3)
14

　　62.super()

　　说明：用于调用父类(超类)的一个方法；用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表；

　　

　　63.tuple()

　　具体信息见元组数据类型；

　　64.type()

　　说明：type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象；

　　语法：type(name, bases, dict)

　　参数：name -- 类的名称。

　　　　　bases -- 基类的元组。

　　　　　dict -- 字典，类内定义的命名空间变量

　　返回值：一个参数返回对象类型, 三个参数，返回新的类型对象；

　　实例：

>>> type("zjk")
<class 'str'>
>>> type("aaa")
<class 'str'>
>>> type(111)
<class 'int'>

　　65.vars()

　　说明：vars() 函数返回对象object的属性和属性值的字典对象；

　　语法：vars([object])

　　参数：object -- 对象

　　返回值：返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()；

　　实例：

>>> vars()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'my': slice(None, 5, None), 'li': [1, 2, 3, 4, 5, 6, 7, 8]}

　　66.zip()

　　说明：用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。；

　　如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表；

　　语法：zip([iterable1,iterable2,iterable3,iterable4.....])

　　参数：iterabl -- 一个或多个迭代器；

　　返回值：返回一个对象；

　　实例：

>>> a = ["张杰","张靓颖","黄渤","张国荣"]
>>> b = ["只要平凡","天下无双","最好舞台","倩女幽魂"]
>>> c = ["1000","1000","1000","1000"]
>>> tk = zip(a,b,c)
>>> list(tk)
[('张杰', '只要平凡', '1000'), ('张靓颖', '天下无双', '1000'), ('黄渤', '最好舞台', '1000'), ('张国荣', '倩女幽魂', '1000')]

>>> a = ["张杰","张靓颖","黄渤","张国荣"]
>>> b = ["只要平凡","天下无双","最好舞台","倩女幽魂"]
>>> c = ["1000","1000","1000"]
>>> tk1 = zip(a,b,c)
>>> list(tk1)
[('张杰', '只要平凡', '1000'), ('张靓颖', '天下无双', '1000'), ('黄渤', '最好舞台', '1000')]

　　67.__import__()

　　说明：__import__() 函数用于动态加载类和函数 。如果一个模块经常变化就可以使用 __import__() 来动态载入；

　　语法：__import__(name[, globals[, locals[, fromlist[, level]]]])

　　参数：name -- 模块名

　　返回值：返回元组列表；

　　实例：

import sys  
__import__('a')        # 导入 a.py 模块