内置函数
内置函数
思维导图：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'\x01\x02\x03') >>> 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'\x01\x02\x03\x04' >>> 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() 方法返回 xy（x的y次方） 的值；
语法：pow(a,b,c)
参数：a -----> x;
b ------> y
c ------>pow(a,b) %c,取余
返回值：返回 xy（x的y次方） 的值；
实例：
>>> pow(10,2,3) 1 >>> pow(10,2) 100 >>> pow(10,2,2) 0
49.print()
说明：用于打印输出，最常见的一个函数；
语法：print(*objects, sep=' ', end='\n', file=sys.stdout)
参数：objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔；
sep -- 用来间隔多个对象，默认值是一个空格；
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串；
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"你好呀！\\,\t, \n \"") 你好呀！\\,\t, \n \"
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 模块
