全局函数
import 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’, ‘breakpoint’, ‘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’]
1.abs() #求绝对值 a=-1 abs(a) 结果 1 2.all() #判断可迭代对象中的元素是否不为0,空,None,False，返回值是True,Flase。有任意一个元素为假，则为假 注：空的可迭代对象返回值True all([‘a’, ‘b’, ‘c’, ‘d’]) #列表元素都不为空或0 True all([‘a’, ‘b’, ‘’, ‘d’]) #列表存在一个为空的元素 False all([0, 1,2, 3]) #列表存在一个为0的元素 False all([]) #空列表 True all(()) # 空元组 True
3.any() #判断可迭代对象不全为0,空,None,False，返回值是True,Flase。有任意一个元素为真，则就为真 any([‘a’, ‘b’, ‘c’, ‘d’]) # 列表元素都不为空或0 True any([‘a’, ‘b’, ‘’, ‘d’]) # 列表元素至少有一个为真 True any([0, ‘’, False]) # 列表元素全为0,’’,false False any([]) # 空列表 False any(()) # 空元组 False
4.ascii() #返回一个表示对象的字符串，如果参数是ascii字符，则返回一个字符串对象；如果参数不是ascii字符，则返回含有\u \U x的字符串对象 ascii(“my name is python”) “‘my name is python’” “’\u4e2d\u56fd’” 5.bin() #返回一个整型的二进制形式 ‘0b111’
6.bool() #将给定参数转换为布尔类型，如果没有参数，返回 False bool(0) False bool(’’) False bool(None) False bool(False) False bool(1) True 7.bytearray() #返回一个新的字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x <256 bytearray() bytearray(b’’) bytearray([1,2,3]) bytearray(b’\x01\x02\x03’) bytearray(‘name’,‘utf-8’) bytearray(b’name’)
8.bytes() #返回一个新的字节对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本 bytes() b’’ bytes([1,2,3]) b’\x01\x02\x03’ bytes(‘name’,‘utf-8’) b’name’ bytes(‘name’,‘ascii’) b’name’
9.callable() #检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。 callable(0) False callable(“name”) 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
10.chr() #将整型转换为字符型（整型数值可以用十进制、八进制、十六进制表示） chr(0x30) ‘0’ chr(48) ‘0’ 11.classmethodclassmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。 #!/usr/bin/python(utf-8) 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（Abstract Syntax Trees）对象。。 filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。 mode – 指定编译代码的种类。可以指定为 exec, eval, single。 flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。 flags和dont_inherit是用来控制编译源码时的标志
str = “for i in range(0,10): print(i)” c = compile(str,’’,‘exec’) # 编译为字节代码对象 c <code object at 0x10141e0b0, file “”, line 1> exec©
13.complex() #创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数 complex([real[, imag]]) real – int, long, float或字符串； imag – int, long, float；
complex(1, 2) complex(1) # 数字 (1 + 0j) complex(“1”) # 当做字符串处理 (1 + 0j)
14.delattr() #用于删除某个对象的某个属性。delattr(x, ‘foobar’) 相等于 del x.foobar。 delattr(object, name) object – 对象。 name – 必须是对象的属性。
#!/usr/bin/python encoding"utf-8" class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print('x = ',point1.x) print('y = ',point1.y) print(‘z = ‘,point1.z) delattr(Coordinate, ‘z’) print(’–删除 z 属性后–’) print('x = ',point1.x) print('y = ',point1.y)
15.dict() #创建一个字典 d=dict({“name”:“python”}) 结果： {‘name’: ‘python’} 16.dir(模块/类/对象) #显示该对象/模块/类的所有方法属性；不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。 dir() # 获得当前模块的属性列表 [‘annotations’, ‘builtins’, ‘doc’, ‘loader’, ‘name’, ‘package’, ‘spec’] import random dir(random) #获得random模块的属性和方法 [‘BPF’, ‘LOG4’, ‘NV_MAGICCONST’, ‘RECIP_BPF’, ‘Random’, ‘SG_MAGICCONST’, ‘SystemRandom’, ‘TWOPI’, ‘_BuiltinMethodType’, ‘_MethodType’, ‘_Sequence’, ‘_Set’, ‘all’, ‘builtins’, ‘cached’, ‘doc’, ‘file’, ‘loader’, ‘name’, ‘package’, ‘spec’, ‘_acos’, ‘_bisect’, ‘_ceil’, ‘_cos’, ‘_e’, ‘_exp’, ‘_inst’, ‘_itertools’, ‘_log’, ‘_pi’, ‘_random’, ‘_sha512’, ‘_sin’, ‘_sqrt’, ‘_test’, ‘_test_generator’, ‘_urandom’, ‘_warn’, ‘betavariate’, ‘choice’, ‘choices’, ‘expovariate’, ‘gammavariate’, ‘gauss’, ‘getrandbits’, ‘getstate’, ‘lognormvariate’, ‘normalvariate’, ‘paretovariate’, ‘randint’, ‘random’, ‘randrange’, ‘sample’, ‘seed’, ‘setstate’, ‘shuffle’, ‘triangular’, ‘uniform’, ‘vonmisesvariate’, ‘weibullvariate’]
17.divmod() #接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b) divmod(4,2) 结果： (2, 0)
18.enumerate() #用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中 enumerate(sequence, [start=0]) seasons = [‘Spring’, ‘Summer’, ‘Fall’, ‘Winter’] list(enumerate(seasons)) [(0, ‘Spring’), (1, ‘Summer’), (2, ‘Fall’), (3, ‘Winter’)]
19.eval() #执行一个字符串表达式，并返回表达式的值;将字符串转换成脚本 eval((‘print(“Hello World”)’)) #有时候可理解为去掉引号 a,b=eval(input(“请输入两个数”)) 请输入两个数1,2 a 1 b 2
20.exec() #执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码 exec (""“for i in range(5): … print (“iter time: %d” % i) … “””) 结果： iter time: 0 iter time: 1 iter time: 2 iter time: 3 iter time: 4 #执行字符串中的语句 x = 10 expr = “”" z = 30 sum = x + y + z print(sum) “”" def func(): y = 20 exec(expr) exec(expr, {‘x’: 1, ‘y’: 2}) exec(expr, {‘x’: 1, ‘y’: 2}, {‘y’: 3, ‘z’: 4})
22.filter() #用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。 #!/usr/bin/python3 def is_odd(n): return n % 2 == 1 tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) newlist = list(tmplist) print(newlist)
23.float() #将其他类型转换成浮点型 f=2 ype(f) <class ‘int’> float(f) 2.0 f=‘2’ float(f) 2.0
24.format() #格式化字符串，str.format()，它增强了字符串格式化的功能
a=2 b=3 rint(“a为{},b为{}”.format(a,b)) a为2,b为3
25.frozrnset() #返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
a = frozenset(range(10)) # 生成一个新的不可变集合 a frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
26.getattr() #返回一个对象属性值 class A(object): … bar = 1 … a = A() getattr(a, ‘bar’) # 获取属性 bar 值
getattr(a, ‘bar2’) # 属性 bar2 不存在，触发异常 Traceback (most recent call last): File “”, line 1, in AttributeError: ‘A’ object has no attribute ‘bar2’ getattr(a, ‘bar2’, 3) # 属性 bar2 不存在，但设置了默认值
27.globals() #以字典类型返回当前位置的全部全局变量
a=‘runoob’ print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。 {‘builtins’: <module ‘builtin’ (built-in)>, ‘name’: ‘main’, ‘doc’: None, ‘a’: ‘runoob’, ‘package’: None}
28.hasattr() #判断对象是否包含对应的属性
#!/usr/bin/python class Coordinate: x = 10 y = -5 z = 0
point1 = Coordinate() print(hasattr(point1, ‘x’)) print(hasattr(point1, ‘y’)) print(hasattr(point1, ‘z’)) print(hasattr(point1, ‘no’)) # 没有该属性 输出结果： True True True False
28.hash() #获取一个对象（字符串或者数值等）的哈希值
hash(‘test’) # 字符串 2314058222102390712 hash(1) # 数字 1 hash(str([1,2,3])) # 集合 1335416675971793195 hash(str(sorted({‘1’:1}))) # 字典 7666464346782421378
29.help() #帮助函数，查看函数或模块用途的详细说明
import sys help(‘sys’) # 查看 sys 模块的帮助 ……显示帮助信息…… help(‘str’) # 查看 str 数据类型的帮助 ……显示帮助信息……
30.hex() #将一个指定数字转换为 16 进制数 hex(255) ‘0xff’ hex(-42) ‘-0x2a’ hex(12) ‘0xc’
31.id() #用于获取对象的内存地址
b = 1 id(b) 140588731085608
32.input() #标准输入函数，返回值类型是字符串
a=input(“请输入”) 请输入1 type(a) <class ‘str’>
33.int() #将其他类型转换成整型 a=2.2 int(a) 2 a=‘2’ int(a) 2
34.isinstance() #判断一个对象是否是一个已知的类型，类似 type() isinstance() 与 type() 区别： type() 不会认为子类是一种父类类型，不考虑继承关系。isinstance() 会认为子类是一种父类类型，考虑继承关系。如果要判断两个类型是否相同推荐使用 isinstance() a = 2 isinstance (a,int) True isinstance (a,str) False isinstance (a,(str,int,list)) #判断a是否是str或int或list类型 True type() 与 isinstance()区别： class A: pass
class B(A): pass
35.issubclass() #判断一个参数是否是另一个参数的子类
#!/usr/bin/python class A: pass class B(A): pass print(issubclass(B,A)) # 返回 True
36.iter() #用来生成迭代器 lst = [1, 2, 3] for i in iter(lst): … print(i) …
37.len() #对象（字符、列表、元组等）长度或项目个数 str = “python” en(str) # 字符串长度 6 l = [1,2,3,4,5] en(l) # 列表元素个数 5
38.list() #将元组或字符串转换为列表 注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中
str=“Hello World” ls=list(str) print ("列表元素 : ", ls) 结果如下： 列表元素 : [‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ’ ', ‘W’, ‘o’, ‘r’, ‘l’, ‘d’]
39.locals() #会以字典类型返回当前位置的全部局部变量 def show(arg): # 两个局部变量：arg、z … z = 1 … print (locals()) … show(4) {‘z’: 1, ‘arg’: 4} # 返回一个名字/值对的字典
40.map() # 会根据提供的函数对指定序列做映射。 它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回
def square(x) : # 计算平方数 … return x ** 2 … map(square, [1,2,3,4,5]) # 计算列表各个元素的平方 map(lambda x: x ** 2, [1, 2, 3, 4, 5]) #使用lambda匿名函数 [1, 4, 9, 16, 25]
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) [3, 7, 11, 15, 19]
41.max() #返回给定参数的最大值，参数可以为可迭代对象 str=“asnc” max(str) ‘s’ ls=[1,2,3] max(ls) 3
42.memoryview() #返回给定参数的内存查看对象 内存查看对象:是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问
v = memoryview(bytearray(“abcefg”, ‘utf-8’)) print(v[1]) 98 print(v[-1]) 103 print(v[1:4]) <memory at 0x10f543a08>
43.min() #返回给定参数的最小值，参数可以为可迭代对象
str=“asnc” min(str) ‘a’ ls=[1,2,3] min(ls) 1
44.next() #返回迭代器的下一个项目。 next() 函数要和生成迭代器的iter() 函数一起使用 #!/usr/bin/python
it = iter([1, 2, 3, 4, 5])
while True: try: # 获得下一个值: x = next(it) print(x) except StopIteration: # 遇到StopIteration就退出循环 break
45.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’] help(object) Help on class object in module builtins:
class object | The most base type
46.oct() #将一个整数转换成8进制字符串
oct(10) ‘012’ oct(20) ‘024’ oct(15) ‘017’
47.open() #用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。 注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。 完整的语法格式为： 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: mode 参数有： t 文本模式 (默认)。 x 写模式，新建一个文件，如果该文件已存在则会报错。 b 二进制模式。
打开一个文件进行更新(可读可写)。 U 通用换行模式（不推荐）。 r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 r+ 打开一个文件用于读写。文件指针将会放在文件的开头。 rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 默认为文本模式，如果要以二进制模式打开，加上 b 。测试文件 test.txt，内容如下：
RUNOOB1 RUNOOB2 f = open(‘test.txt’) f.read() ‘RUNOOB1\nRUNOOB2\n’
48.ord() #chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值
ord(‘a’) 97 ord(‘€’) 8364
49.pow() #返回x的y次方 的值，与math.pow()功能一样
pow(2,2) 4 import math math.pow(2,2) 4.0
50.print() #标准输出函数
print(“hello”) hello
51.property() #是在新式类中返回属性值
class C(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, “I’m the ‘x’ property.”) 1 52.quit() #退出python解释器，与exit()方法功能一样 quit()
53.range() #返回的是一个可迭代对象（类型是对象),前闭后开
for i in range(5): … print(i) … 0 1 2 3 4
54.repr() #将对象转化为供解释器读取的形式 s = ‘name’ repr(s) “‘name’” dict={“name”:“python”} repr(dict) “{‘name’: ‘python’}”
55.reversed() #返回一个反转的迭代器对象 #字符串 seqString = ‘Runoob’ print(list(reversed(seqString))) #元组 seqTuple = (‘R’, ‘u’, ‘n’, ‘o’, ‘o’, ‘b’) print(list(reversed(seqTuple))) #range seqRange = range(5, 9) print(list(reversed(seqRange))) #列表 seqList = [1, 2, 4, 3, 5] print(list(reversed(seqList))) 以上实例输出结果为：
[‘b’, ‘o’, ‘o’, ‘n’, ‘u’, ‘R’] [‘b’, ‘o’, ‘o’, ‘n’, ‘u’, ‘R’] [8, 7, 6, 5] [5, 3, 4, 2, 1]
56.round() #四舍五入。奇数时，是标准的四舍五入；偶数时，以5为分界点，小于等于5则就舍，大于5则就入 round(5.5) 6 round(4.50000000000) 4
57.set() #创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等
x = set(‘runoob’) y = set(‘google’) x, y (set([‘b’, ‘r’, ‘u’, ‘o’, ‘n’]), set([‘e’, ‘o’, ‘g’, ‘l’])) # 重复的被删除 x & y # 交集 set([‘o’]) x | y # 并集 set([‘b’, ‘e’, ‘g’, ‘l’, ‘o’, ‘n’, ‘r’, ‘u’]) x - y # 差集 set([‘r’, ‘b’, ‘u’, ‘n’])
58.setattr() #用于设置属性值，该属性不一定是存在的 class A(object): … bar = 1 … a = A() getattr(a, ‘bar’) # 获取属性 bar 值 1 setattr(a, ‘bar’, 5) # 设置属性 bar 值 a.bar 5
59.slice() #实现切片对象，主要用在切片操作函数里的参数传递
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]
60.staticmethod() #返回函数的静态方法
class C(object): @staticmethod def f(): print(‘runoob’);
C.f(); # 静态方法无需实例化 cobj = C() cobj.f() # 也可以实例化后调用 以上实例输出结果为： runoob runoob 61.str() #将其他类型转换为字符串 62.sum() #求和计算 sum([0,1,2]) 3 sum((2, 3, 4), 1) # 元组计算总和后再加 1 10 sum([0,1,2,3,4], 2) # 列表计算总和后再加 2 12
63.super() #用于调用父类(超类)的一个方法 64.tuple() #生成元组
t=tuple((1,2,3)) t (1, 2, 3) ls=[1,2,3] ls [1, 2, 3] t=tuple(ls) t (1, 2, 3)
65.type() #查看对象类型 a=1 type(a) <class ‘int’> s=[1,2] type(ls) <class ‘list’>
66.vars() #返回对象object的属性和属性值的字典对象 print(vars()) {‘builtins’: <module ‘builtin’ (built-in)>, ‘name’: ‘main’, ‘doc’: None, ‘package’: None} class Runoob: … a = 1 … print(vars(Runoob)) {‘a’: 1, ‘module’: ‘main’, ‘doc’: None}
67.zip() #用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。 a = [1,2,3] b = [4,5,6] c = [4,5,6,7,8] zipped = zip(a,b) # 返回一个对象 zipped <zip object at 0x103abc288> list(zipped) # list() 转换为列表 [(1, 4), (2, 5), (3, 6)] list(zip(a,c)) # 元素个数与最短的列表一致 [(1, 4), (2, 5), (3, 6)] a1, a2 = zip(zip(a,b)) # 与 zip 相反，zip() 可理解为解压，返回二维矩阵式 list(a1) [1, 2, 3] list(a2) [4, 5, 6]
