关于Python3的内置函数整合及详解
Python3的内置函数
前面写了字符串列表等的内建函数, 这次写写Python内置函数
参考了runoob.com的函数跟官方的帮助文档.应该比他们的更详细或更便于理解.
每个函数都会写更直观易懂的举例. 本篇函数按首字母升序排序.
本篇的函数名称如下:abs, all, any, ascii, bin, bool, bytearray, bytes, callable, chr, classmethod, compile, complex, delattr, dict, dir, divmod, enumerate, eval, exec, filter, float, formal, frozenset, getattr, globals, hasattr, hash, help, hex, id, input, int, isinstance, issubclass, iter, len, list, locals, map, max, memoryview, min, next, object, oct, open, ord, pow, print, property, range, repr, reversed, round, set, setattr, slice, sorted, staticmethod, str, sum, super, tuple, type, vars, zip, __import__.
1. abs ( x )
该函数需要一个number类型的参数. 返回数字的绝对值. 例:
>>> abs(-1.1) 1.1
2. all ( iterable )
传入一个可迭代参数, 并判断该参数的所有元素是否全为True值, 即非0非空非False非None值. 全为True值则返回True, 否则返回False. 例：
>>> a, b = [1, 2, 3], [0, 1, 2] >>> all(a) True >>> all(b) False
3. any ( iterable )
判断传入的可迭代序列是否有一个元素为True, 即非None非0非空非False的值. 如果全为False则返回False, 否则返回True.
>>> a, b = [0, 1, 2], [0, '', False] >>> any(a) True >>> any(b) False
4. ascii ( obj )
传入一个对象，返回ASCII编码对应的字符串形式， 如果存在非ASCII字符, 则生成unicode编码格式返回.
>>> ascii([3, 5, 'hello']) "[3, 5, 'hello']" >>> ascii("你好") "'\\u4f60\\u597d'"
5. bin ( number )
传入一个整数, 并返回该整数二进制表示的字符串. 该
>>> bin(255) '0b11111111'
6. bool ( [x] )
将传入的参数转换成布尔值. 如果不传入参数则返回False. 例:
>>> bool('hello') True >>> bool() False
7. bytearray ( [object] )
构造一个bytearray对象, 即字节数组. 该方法有如下5种构造形式
bytearray()
返回一个空的字节数组.例:
>>> bytearray() bytearray(b'')
bytearray ( int )
传入的对象, 如果为非负整数,则返回一个长度为该整数值的初始化的字节数组. 例:
>>> bytearray(5) bytearray(b'\x00\x00\x00\x00\x00')
bytearray ( string, encoding [, errors] )
传入字符串,则需要指定encoding编码格式, 返回包含字节序列的字节数组. 例:
>>> bytearray('Hello, World', 'utf-8') bytearray(b'Hello, World')
bytearray ( iterable_of_ints )
传入可迭代的整数序列, 则序列的元素必须为0-255的整数.返回16进制形式的字节数组. 例:
>>> bytearray([1, 2, 255]) bytearray(b'\x01\x02\xff') >>> bytearray([123, 125, 255]) bytearray(b'{}\xff')
注意:该字节数组内的字符也会进行转义.
bytearray ( bytes_or_buffer )
传入buffer或bytes对象的话, 则返回一个复制过来的buffer或bytes的可变对象.
即可用bytes对象初始化bytearray对象, 例:
>>> a b'\x00\x00\x00\x00\x00' >>> bytearray(a) bytearray(b'\x00\x00\x00\x00\x00')
8. bytes()
构造一个bytes对象并返回, 构造方式跟上面的bytearray一样有五种形式.
bytes()
返回一个空的bytes对象.
>>> a = bytes() >>> a b''
bytes ( int )
返回一个int长度的, 并用空字节初始化的bytes对象..
>>> bytes(5) b'\x00\x00\x00\x00\x00'
bytes ( string, encoding [, error] )
传入字符串并指定编码格式, 返回相应的bytes对象.
>>> bytes('Hello World', 'utf-8') b'Hello World'
bytes ( iterable_of_ints )
传入可迭代的整数序列, 该序列的每个元素必须在0-255之间.
>>> bytes([0, 1, 255]) b'\x00\x01\xff'
bytes ( bytes_or_buffer )
传入bytes或buffer对象, 返回一个复制过来的, 不可变的bytes对象.
>>> a b'hello world' >>> b = bytes(a) >>> b b'hello world'
这是跟上面的字节数组唯一不一样的地方了.bytes是不可变的, bytearray是可变的.
9. callable ( obj )
判断传入的对象是否可以调用并返回布尔值.
>>> def hello(): ... print("Hello World!") ... >>> callable(hello) True
10. chr ( i )
传入一个整数, 返回对应unicode字符串. i的范围: 0 <= i <= 0x10ffff. 即在0到1114111之间.
>>> chr(23456) '宠' >>> chr(97) 'a'
11. classmethod ( object )
将函数转换成类方法. (Convert a function to be a class method)
该函数一般作为修饰符以"@classmethod"出现, 用来修饰类的方法.类似staticmethod, 但需要传递参数.
被该修饰符修饰的方法可以直接以 class_name.method_name进行调用. 也可以在类实例调用.
被修饰的方法需要一个表示自身类的参数作为第一个参数.
>>> class A: ... @classmethod ... def hello(a): ... print("Hello World") ... >>> A.hello() Hello World
12. compile ( source, filename, mode [, flags, [dont_inherit] ] )
将源代码编译成可由exec()或eval()函数执行的对象.
参数:
source: 源代码
filename: 文件名, 将用于该对象运行时产生的错误消息的辨识关键字
mode: 编译模式可选参数:exec, single, eval. exec编译成模块, single编译成单个的交互语句, eval编译成一个表达式.
flags: 该参数为可选参数, 控制可能会出现影响编译的语句.
dont_inherit: 该参数如果为真， 非继承编译。
例：
>>> he = "print('Hello World')" >>> a = compile(he, '', 'single') >>> exec(a) Hello World
13. complex( [real [, imag] ] )
传入number, 返回一个复数.
等同于 real + imag * 1j , 其中imag默认为0. 例:
>>> complex(4, 8) (4+8j)
该函数也可以将字符串转换成复数类型. 例:
>>> complex('4+8j') (4+8j)
注意:字符之间不允许有空格出现, 字符串头和末尾可以
14. delattr ( obj, name )
删除传入对象的指定的属性. 等同于 del obj_name.attr_name 例:
>>> class A: ... a, b, c = 1, 2, 3 ... >>> a = A() >>> a.a 1 >>> delattr(A, 'a') >>> a.a Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'A' object has no attribute 'a'
15. dict ( [object] )
该函数用于构造一个字典对象. 支持三种传入的参数类型进行构造.
键赋值传入
>>> a = dict(a=4, b='2', c=3) >>> a {'a': 4, 'b': '2', 'c': 3}
映射表传入
>>> a = dict(zip(['a', 'b', 'c'], [1, 2, 3])) >>> a {'a': 1, 'b': 2, 'c': 3}
可迭代对象传入
>>> a = dict([('a', 1), ('b', 2), ('c', 3)]) >>> a {'a': 1, 'b': 2, 'c': 3}
16. dir ( [object] )
返回对象所拥有的属性及方法, 按名称排列. 如果不带参数则返回当前范围的变量和方法.
如果参数包含方法 __dir__(), 该方法将会被调用.
>>> dir() ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__'] >>> dir(bytes) ['__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', 'center', 'count', 'decode', 'endswith', 'expandtabs', 'find', 'fromhex', 'hex', 'index', 'isalnum', 'isalpha', 'isascii', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
17. divmod ( x, y )
传入两个number类型的参数, 返回一个包含了 x//y , x%y 的元组.
该方法不支持复数(complex)类型的参数.
>>> divmod(188, 2) (94, 0) >>> divmod(188.8, 2) (94.0, 0.8000000000000114)
18. enumerate ( iterable [, start ])
传入一个可迭代对象, 返回一个枚举对象. start参数可指定下标的起始.
一般用作遍历, 可以将遍历的数据对象组合成一个新的带索引的序列.如下返回
(0, seq[0]), (1, seq[1]), (2, seq[2]), ...
例:
>>> a = {'a', 'b', 'c'}
>>> for i, j in enumerate(a):
... print(i, j)
...
0 b
1 a
2 c
19. eval ( source [, globals [, locals] ] )
执行传入的source源代码, source可以是字符串表达式, 也可是是compile()函数返回的代码对象.
globals全局变量作用域, locals局部变量作用域.
globals必须是字典(dictionary)对象, locals可以是任何映射对象(mapping).
如果只给globals参数, 那么locals参数默认也是它.
>>> eval("print('Hello World')") Hello World
20. exec ( source [, globals [, locals]] )
在全局和局部作用域执行给定的源代码.
source源代码参数, 可以是字符串表示的一句或多句python语句, 也可以是compile()函数返回的代码对象.
globals和locals参数跟eval()函数一样. globals必须为字典, locals可以为任何的映射表.
>>> exec("""for i in range(1, 5): ... print(i) ... """) 1 2 3 4
注意:exec()比eval()函数可传入的source的参数不同, exec()的可执行的范围更广.
21. filter ( function_or_None, iterable)
将传入的 iterable 可迭代序列使用function函数过滤, 返回一个迭代器对象.
该对象可以用 list(),set() 等函数转换成对应的序列
如果传入None， 则返回一个包含所有为True元素的迭代器. (非0非False非None非空)
>>> a = [0, 1, 2, 3, 4, 5, 6] >>> def filt(a): ... return a % 2 == 0 ... >>> list(filter(filt, a)) [0, 2, 4, 6] >>> list(filter(None, ['', 0, 1, False, 2])) [1, 2]
22. float ( objcet )
将整数或字符串转换成浮点数. 例:
>>> float('222') 222.0
23. format ( value [, format_spec] )
返回 value.__format__(format_spec).
即格式化, format_spec格式化规范, 默认为空. 因为不同的value有不同的格式化方式, 所以该函数一般是调用value中的__format__(format_spec) 方法. 例:
>>> format(3.14159, 'E') '3.141590E+00'
该函常用于字符串格式化. 即 str.format() . 例:
>>> "{}, {}".format('Hello', 'World') 'Hello, World'
更多的字符串格式化方法, 直接看我另一篇, 字符串相关操作.
24. frozenset ( [iterable] )
传入序列并返回冻结后的冻结对象, 该对象是不可修改, 无序且元素不重复的集合.
如果不传入参数则返回空的冻结对象.
>>> frozenset([1, 2 ,3 ,4 ,5]) frozenset({1, 2, 3, 4, 5})
25. getattr ( object, name [, default] )
获取并返回对象的属性值. 等价于 object_name.attr_name
object参数是对象
name参数是需要获取的属性名称
default参数表示没有该属性时返回的默认值.
如果不给default并且没有没有找到对应name的属性, 程序会抛出对应的AttributeError错误.
>>> class A(): ... a, b = 1, 2 ... >>> a = A() >>> getattr(a, 'a') 1 >>> getattr(a, 'c', 3) 3
26. 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 0xb737f190>, 'i': 5, 'A': <class '__main__.A'>}
27. hasattr ( object, name )
判断是名为name的属性是否包含在object中. 返回布尔值.
>>> class B: ... a, b = 10 ,20 ... >>> b = B() >>> hasattr(b, 'a') True
28. hash ( obj )
返回obj的哈希值. 例:
>>> hash('hello') 1743487763
29. help ( [thing] )
如果传入thing, 返回对应的函数或模块的帮助信息. 按q退出.
>>> help(max) Help on built-in function max in module builtins: max(...) max(iterable, *[, default=obj, key=func]) -> value max(arg1, arg2, *args, *[, key=func]) -> value With a single iterable argument, return its biggest item. The default keyword-only argument specifies an object to return if the provided iterable is empty. With two or more arguments, return the largest argument. (END)
如果不传入任何事物, 则进入help的交互式会话. 每输入一条就会返回对应的帮助信息.
>>> help() Welcome to Python 3.9's help utility! ... ...... help>
ps: 本篇的大部分的理解都来自于help()函数
30. hex ( number )
返回传入的number的十六进制表示的字符串. 例:
>>> hex(65535) '0xffff'
31. id ( obj )
返回传入的对象的唯一标识符.
CPython中, 用于获取对象的内存地址. 我这里用的就是自带的CPython编译。
>>> a, b, c = 1, 2, a >>> id(a) 3077657760 >>> id(b) 3077657776 >>> id(c) 3077657760 >>> a = 22 >>> id(a) 3077658096
这里可以直观的看到变量只是对值的引用, a和c指向的地址是一样, 当a的值发生改变, 那么id(a)也会发生改变.
32. input（[prompt]）
读取标准输入并返回字符串, prompt用于提示.
如果给了prompt参数, 那么将被打印出来, 如果没有, 那么将在读取输入之前, 进行换行
>>> input("input your number:") input your number:8 '8' >>> input() 8 '8'
33. int ( [ x, [base] ] )
将字符串或数字转换成整数. 不传入x参数时返回0, base可指定x的进制数. 默认为10进制.
>>> int() 0 >>> int('16', 16) 22 >>> int('0xff', 16) 255
34. isinstance( obj, class_or_tuple )
返回一个布尔值, 判断 obj 是否是 class 的实例或其子类的实例.
可以以元组(tuple)形式传入多个class. 判断是否是其中一个的类或子类的实例.
即 isinstance(x, (A, B, ...)) 等效于 isinstance(x, A) or isinstance(x, B) or ... , 例:
>>> class A: ... a = 1 ... >>> class B: ... b = 2 ... >>> a = A() >>> isinstance(a, (A, B)) #传入元组, a为元组中的A的实例 True >>> class C(A): ... c = 3 ... >>> c = C() >>> isinstance(c, A) #c为A子类实例 True
35. issubclass ( cls, class_or_tuple )
返回布尔值, 判断传入的cls是否是class的子类.
第二个参数可以传入一个class, 也可以传入多个包含class的元组, 如果传入的cls参数是该元组中其中一个class的子类
那么返回True。例：
>>> class A: ... a = 1 ... >>> class B(A): ... b = 2 ... >>> issubclass(B, A) True
36. iter( )
返回一个迭代器. 有两种构造方式
iter ( iterable )
传入一个序列, 返回迭代器.例:
>>> for i in iter([1, 2, 3, 4]): ... print(i) ... 1 2 3 4
iter ( callable, sentinel )
使用该方式返回的迭代器, 每一次迭代时都会调用一次callable, 直到它返回sentinel时停止.
.callable必须是可调用的对象, 一般为函数.
>>> a = iter([2, 3, 4, 8, 7, 9]) #迭代器对象 >>> def caller(): ... return next(a) #迭代, 返回迭代器的下一个元素 ... >>> for i in iter(caller, 7): #该函数给的sentinel为7, 遇到7则停止调用callable的函数并返回. ... print(i) ... 2 3 4 8
37. len( obj )
返回obj容器中元素的个数.
该函数多用于序列或字符串. 例:
>>> len("Hello World") 11 >>> len([2, 8 ,8 ,9]) 4
38. list ( [iterable] )
传入可迭代对象, 并构造一个可变序列. 即列表.
如果不给参数, 将返回一个空的列表.
>>> list('hello') ['h', 'e', 'l', 'l', 'o']
39. locals()
返回当前范围的局部变量.
>>> def hello(): ... a, b = 12, 13 ... print(locals()) ... >>> hello() {'a': 12, 'b': 13}
40. map( function, *iterables )
map函数会对传入的每个可迭代对象的元素进行调用function函数.
并返回所有元素调用后, 组合形成新的map对象.
>>> def square(n): ... return n * n ... >>> a = map(square, [1, 2, 3]) >>> list(a) [1, 4, 9]
41. max ()
返回最大值
该函数有两种传入方式.
max ( iterable, *[, default=obj, key=func] )
传入可迭代对象 ( iterable ), 返回该对象中的最大的元素.
default: 如果传入的可迭代序列为空, 可指定一个默认的返回的参数.
key: 如果给定key, 将对象的每个值传入func后返回的结果进行对比.
>>> a = [] >>> max(a, default=8) 8
max ( arg, arg2, *args, *[, key=func] )
传入多个参数, 返回最大值
如果给定key, 返回将所有参数传入key后返回的结果进行对比后的最大参数.
>>> max(2, -4, -3, key=square) #square上个函数讲解定义过, 该函数返回传入参数的平方数 -4 >>> max(2, -4, -3) 2
42. memoryview ( object )
返回object的内存视图对象.
>>> a = bytes('hello', 'utf-8') >>> b = memoryview(a) >>> a b'hello' >>> b <memory at 0xb76a1c28>
该函数需要类似 bytes 之类的对象作为参数.
43. min()
同上面第41个函数max()相似. 返回的是最小值.
该函数有两种传入方式.
min ( iterable, *[, default=obj, key=func] )
传入可迭代对象 ( iterable ), 返回该对象中的最小的元素.
default: 如果传入的可迭代序列为空, 可指定一个默认的返回的参数.
key: 如果给定key, 将对象的每个值传入func后返回的结果进行对比. 例:
>>> min([], default=5) 5
min ( arg, arg2, *args, *[, key=func] )
传入多个参数, 返回最小值.
如果给定key, 返回将所有参数传入key后返回的结果进行对比后的最小参数.例:
>>> min(-2, 3, 1, -4, key=square) 1
44. next ( iterator [default] )
返回iterator迭代器的下一个元素.
如果给出default默认值, 在迭代器耗尽时（没有下一个可迭代元素）, 它将返回这个默认值, 而不是引发StopIteration的错误。
>>> a = iter([1, 2 ,3]) >>> next(a) 1 >>> next(a) 2 >>> next(a) 3 >>> next(a, 4) 4
>>> next(a) #迭代器耗尽, 无可迭代元素
Traceback (most recent call last): File "<stdin>", line 1, in <module>StopIteration
45. objcet()
返回一个空的实例对象.
该函数不接受任何参数, 并返回的是没有实例属性的, 不能被赋予任何属性的实例对象.
>>> a = object() >>> a <object object at 0xb77b3290>
46. oct ( number )
返回传入的整数的八进制表示的字符串.
>>> oct(64) '0o100'
47. open ( file [, mode='r' ] [, buffering=-1] [, encoding=None] [, errors=None] [, newline=None] [, closefd=True] [, opener=None] )
打开文件并返回一个文件流. 参数如下
file : 文件路径及名称 (如果是当前路径可以省略路径直接写文件名称)
mode : 文件模式. 默认为'rt' , 参数如下
r : 可读模式 (默认)
w : 可写模式
x : 创建和写入一个新文件
a : 追加模式.
b : 二进制模式
t : 文本模式 (默认)
+ : 更新文件(可读写模式)
U : 通用换行模式 (已弃用)
buffering : 可选的整数, 用于设置缓冲. 不给参数则使用默认的缓冲策略(默认-1). 参数如下:
0:关闭缓冲
1:选择行缓冲
>1 : 大于1的整数指定固定块缓冲区的大小
encoding : 指定文本的编码格式, 如果不给该参数, 会默认为本地的首选编码. 该参数不建议在二进制模式(binary mode)下使用.
errors : 可选的字符串参数. 在编码错误时返回的错误信息. 该参数不建议在二进制模式下使用.
newline : 设置换行通用符的工作模式, 该参数仅适用于文本模式. 该值的参数有 None, ' ','\n' '\r', 'r\n'.
关于参数如下两种情况
输入 （input）
默认None, 换行通用符号为可用， 类似 '\n', '\r', '\r\n' 结尾在返回结果之前会转换成'\n'.
如果该值为空字符串' ', 模式也是为可用,但是在行尾并不会进行任何转换.
其他合法值会在行尾由给定的字符串值返回.
输出 （output）
默认的None值， 每个'\n'都将会转换成系统默认的分隔符.
空字符 ' ' 或 '\n' : 不进行转换.
其他合法的值会将每个 '\n' 转换成给定的字符串.
closefd : 默认为True。 当给定了文件名， 这个参数必须为True。 False参数下, 当文件关闭的时候底层文件描述符将会保持开启.
opener : 默认为None, 通过可调用的对象自定义一个opener开启器. 可使用(file, flags)来调用opener并获得文件对象的底层描述符. opener必须返回一个开启的文件描述符.
例:
>>> f = open('hello.txt') >>> f.read() 'Hello World\n\n'
参数太多, 很多也不常用,这里就不一一举例每个参数的用法.
48. ord ( c )
该函数跟chr()对应, 返回对应的ascii码或unicode编码
>>> ord('a') 97 >>> ord('宠') 23456
49. pow ( base ,exp [, mod=None])
返回base的exp次方, 即等同于 base ** exp.
如果给定第三个参数mod参数， 那么等同于 base ** exp % mod.
>>> pow(2, 3) 8 >>> pow(2, 3, 3) # 2 三次方是 8, 8 除 3 的余数是 2 2
50. print ( value [, ...] [, sep=' '] [, end='\n'] [, file=sys.stdout] [, flush=False] )
打印value值到文件流(stream)或系统默认的标准输出流(sys.stdout).
value为必需的参数. 第二个参数表示可以是传入多个的value值, 其他可选参数如下:
sep : 将字符串插入到多个value值之间, 默认为一个空格
end : 将字符串添加到末尾, 默认为一个换行符.
file : 要写入的文件对象 (流), 默认为当前的 sys.stdout.
flush : 是否强制刷新流.
>>> print('Hello', 'World', sep=' , ', end='!\n') # seq在两个字符串中插入了个逗号, 结尾加入了!和换行 Hello , World!
51. property ( [fget=None [, fset=None [, fdel=None [, doc=None] ] ] ] )
对类属性的控制函数. 参数如下:
fget : 用于获取属性值的函数.
fset : 用于设定属性值的函数.
fdel : 用于删除属性的函数
doc : 文档字符串. 用于描述属性的信息.
典型的用法如下, 用于定义一个可控的属性.
>>> class C(object): ... 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")
如果用该类实例化一个对象c, 那么当我们使用c.x, c.x = value, del c.x时候, 都会调用相对的getx, setx, delx.
上面的写法可以简化成以下写法.
>>> class C(object): ... @property ... def x(self): ... "I am thr 'x' propertry" ... return self._x ... @x.setter ... def x(self, value): ... self._x = value ... @x.deleter ... def x(self): ... del self._x
52. range ( [start, ] stop [, step] )
返回从start开始到stop停止的整数生成的序列对象. start为可选, 默认为0, step为步长(生成间隔), 默认为1.
>>> list(range(1, 20, 2)) [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
53. repr ( obj )
返回对象的规范的字符串表示.
>>> repr([1 ,2, 5]) '[1, 2, 5]'
54. reversed ( sequence )
返回一个将序列反转的迭代器.
>>> list(reversed((1, 2 ,3))) [3, 2, 1]
55. round ( number [, ndigits=None] )
返回十进制数字的四舍五入值.
ndigits参数表示保留的小数位数. 默认为None，不保留.
>>> round(3.1415926, 3) 3.142
56. set ( [iterable] )
传入可迭代对象返回一个集合对象. 不传入参数则返回空的集合对象.集合是不重复且无序的对象.
>>> set((1, 2, 3, 2, 1)) {1, 2, 3}
57. setattr ( obj, name, value )
用于设置对象的属性值. obj是传入的对象, name是属性名称, value是需要给属性的值. 即 setattr(x, 'y', v) 等同于 x.y = v.
>>> class A: ... a = 10 ... >>> a = A() >>> setattr(a, 'a', 20) >>> getattr(a, 'a') #这句等同于 a.a, 用于获取对象的属性值 20
ps: 如果要设置的对象的属性不存在那么将创建一个该名字的属性并赋值.
58. slice ()
slice ( stop )
slice ( [start, ] stop [, step] )
创建一个切片对象. start为切片起始位置, stop为终止位置, step为步长.
>>> sli = slice(2, 7, 2) >>> a = range(0, 10) >>> list(a)[sli] #下标为2到7之间的偶数 [2, 4, 6]
59. sorted ( iterable [, key=None] [, reverse=False] )
返回将传入的可迭代对象排序后的新列表.
key可以自己设置一个函数用于自定义排序顺序.
reverse用于降序或升序.默认False为升序.
>>> sorted([8, 7, 2, 4, 9]) [2, 4, 7, 8, 9]
60. staticmethod ( function )
将函数转换成静态方法. 该方法不要求强制传递参数.
该方法一般以修饰符出现. 被修饰的方法可以以 class_name.method_name的方式进行调用, 也可实例化后调用.
>>> class C: ... @staticmethod ... def hel(): ... print("Hello World!") ... >>> C.hel() #直接调用类里面的hel()方法 Hello World!
61. str ( )
str ( object=' ' )
str ( bytes_of_buffer [,encoding [, errors]] )
将传入的对象转换成字符串类型并返回.
如果指定encoding或errors参数, 那么该对象必须是一个buffer或bytes并且能够被指定的encoding解码和error处理的对象
否则将会返回对象的__str__()方法(如果有定义的话).
encoding默认为 sys.getdefaultencoding()方法返回的编码.
errors默认为 'strict'.
>>> str([1, 2, 3 ,4, 5]) '[1, 2, 3, 4, 5]'
62. sum ( iterable [, start ] )
对序列进行求和计算. 如果给了start的值, 那么将start也加上, start默认为0.
>>> sum([1, 2, 3], 4) 10
63. super ( type [, type_or_obj] )
代表父类.用于调用父类的方法. 可以有效的避免多继承造成的各种问题等.
>>> class A: ... def square(self, x): ... sq = x * x ... print(sq) ... >>> class B(A): ... def square(self, x): ... super().square(x) ... >>> b = B() >>> b.square(5) 25
64. tuple ( [iterable] )
构造一个不可变的序列. 即元组.
如果不给参数,将会返回一个空的元组. 如果指定了iterable可迭代的参数, 将会被用于初始化元组.
>>> tuple([1, 2 ,5]) (1, 2, 5)
65. type()
type (object)
如果只给了object参数, 那么将返回对象的类型.
type (name, bases, dict)
如果给了三个参数, 则返回一个新的类型对象.
name为对象名称. bases为基类(该参数必须是元组形式), dict为字典.
>>> class A: ... a = 1 ... >>> b = type('A', (object,), dict(a=1)) >>> b <class '__main__.A'>
66. vars ( [object] )
返回对象的属性和属性值的字典对象.
如果不给参数, 相当于 locals() ,有参数则相当于 objcet.__dict__.
>>> class A: ... a = 1 ... >>> vars(A) mappingproxy({'__module__': '__main__', 'a': 1, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None})
67. zip( * iterables )
将传入个各个可迭代对象打包成一个个元组. 并返回一个zip对象. 可以有效的节省内存空间.
可以用list()将zip转换成列表, 返回的列表元素个数, 与可迭代对象最短的那个序列的元素个数一致.
>>> a = zip([1, 2], (8, 6, 9, 7), {2, 5, 8}) >>> list(a) [(1, 8, 8), (2, 6, 2)] #该列表只有两个元组. 与上方传入的列表对象的长度一致.
68. __import__( name [, globals=None] [, locals=None] [fromlist=()] [level=0] )
导入一个模块.
因为该函数是供python解释器使用,而不是一般用途. 所有还是建议使用importlib.import_module()程序化导入一个模块.
上面的是官方文档的说明...(可能英语水平有限, 但大致意思就是不建议用__import__导入)
这里写写import的方法.
>>> import sys #导入整个模块 >>> sys.getdefaultencoding() #调用时候前面要加上模块的名称, 这里返回的是系统默认的字符编码格式 'ascii' >>> from random import random #导入模块中的某个函数 >>> random() #可直接调用导入进来的函数 0.30382455833832134
总结
总算是写完了.. 官方的英语文档读着有点饶, 可能是我水平不太好.
本文虽然长, 但是基本都比较详细了.
写完这篇我应该不会再写python相关的函数api.
本文中如果有不正确或不够详尽的地方.记得指点一下.
夜深了.. .. .. 希望今晚不会失眠睡个好梦... ....
2021-08-23 00:28:50
