python3.7.1 内置函数列表
常用/分类
求值类：
- abs(x)：绝对值
- complex([real[, imag]])：创建一个 'real + imag*j'的复数，或者转化一个字符串或者数字为复数
- divmod(a,b)：求 a/b 的商和余数
- int([x])、int(x, base=10)：整数
- float([x])：浮点数
- len(s)：求长度
- pow(x, y[, z])： 只有 x、y参数，返回x的y次方的值（x**y）。三个参数都有返回x的y次方除以z取模 (x**y)%z
- round(number[, ndigits])：返回 number 四舍五入后的值。如果 ndigits 为空或者None，则返回最接近number的整数。
- sum(iterable[, start])：计算 iterable 中所有元素和 start 的总和
真假判断：
- all(iterable)：是否全为真
- any(iterable)：是否有一个为真
- bool(x)：判断元素真假
- callable(object)：判断对象是否可以调用
- hasattr()：判断是否具有某属性值
- isinstance(object,classinfo)：判断object是不是classinfo的直接、间接或者子类的实例
- issubclass(class, classinfo)：判断 class 是否是 classinfo 直接、间接或者虚拟的子类
进制转换：
- bin(x)：二进制。 '0b'
- hex(x)：十六进制。 '0x'
- oct(x)：八进制。 '0o'
编码字节：
- bytearray([source[,encoding[,errors]]])：可变字节数组
- bytes([source[, encoding[, errors]]])：不可变字节对象
- chr(i)：把一个整数转换为Unicode编码表中对应的字符。
- ord(c)：返回一个Unicode字符串的整数编号位置。
- repr(object)：将 object 转换为可供解释器读取的字符串形式。
类相关：
- @classmethod：把类中的一个方法转换为类方法，使得它可以在不实例化的情况下调用。
- delattr(object,name)：删除object中名称为 name 属性
- getattr(object, name[, default])：获取属性值
- hasattr(object, name)：判断是否具有某属性值
- setattr(object, name, value)：如果object允许，函数将会把value赋值给name。
- isinstance(object,classinfo)：判断object是不是classinfo的直接、间接或者子类的实例
- issubclass(class, classinfo)：判断 class 是否是 classinfo 直接、间接或者虚拟的子类
- property(fget=None, fset=None, fdel=None, doc=None)：将类中的方法像类属性一样调用，规范化的访问类的属性和修改类属性的值的一种方法
- @staticmethod：将类中的一个方法转换为静态方法。
- super([type[, object-or-type]])：在子类内调用父类的方法
- type(object)、type(name, bases, dict)：一个参数，返回对象的类型。三个参数，返回一个新的类型对象。
- _import_(name, globals=None, locals=None, fromlist=(), level=0)：用于动态的加载类和函数
字符串的执行：
- compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)：编译一段字符串/字节字符串/AST对象，通过exec或者eval或者single执行
- eval(expression, globals=None, locals=None)：获取表达式 expression 的值
- exec(object[, globals[, locals]])：执行 object 代码块
类型/对象：
- dict(**kwarg)、dict(mapping, **kwarg)、dict(iterable, **kwarg)：创建一个字典。
- frozenset([iterable])：生成一个冻结的集合。
- list([iterable])：将元组或者字符串转换为列表。
- set([iterable])：创建一个set对象。
- str(object='')、str(object=b'', encoding='utf-8', errors='strict')：把一个对象转换为 str。
- tuple([iterable])：把 iterable 转换为一个元组。
- iter(object[, sentinel])：用于生成一个迭代器。
- range(stop)，range(start,stop[,step])：返回一个可迭代对象。
- memoryview(obj)：根据传入的对象创建一个内存查看对象。
- open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)：打开文件并返回响应的文件对象。
- reversed(seq)：返回一个反向的迭代器
其他1：
- filter(function, iterable)：通过指定函数过滤迭代器内的元素并返回一个新的迭代对象
- map(function, iterable, ...)：把一个迭代器内的元素或多个迭代器内同一位置的元素，带入 function 内执行，返回一个结果的迭代器。（多个迭代器，以最短的为标准）
- max(iterable, *[, key, default])、max(arg1, arg2, *args[, key])：返回 iterable 内或 arg1、arg2...中的最大项。iterable 为空返回 default。 key 不为空时，以key指定的函数为标准。根据ord()获取对应字符串在ASCII中的位置来比较大小
- min(iterable, *[, key, default])、min(arg1, arg2, *args[, key])：返回 iterable 内或 arg1、arg2...中的最小项。iterable 为空返回 default。 key 不为空时，以key指定的函数为标准。根据ord()获取对应字符串在ASCII中的位置来比较大小
- sorted(iterable, *, key=None, reverse=False)：对iterable进行排序操作。指定了key，把iterable内的元素逐个带入函数内，并根据返回的值的排序来对iterable进行排序
其他2：
- locals()：当前环境的局部变量
- globals()：获取当前环境的全局变量字典
- vars([object])：返回带有__dict__属性的模块、类、实例或任何其他对象的__dict__属性。
- dir([object])：获取 object 的方法、属性列表
其他3：
- enumerate(iterable, start=0)：获取可迭代对象内元素以 start 开头的序列和元素值的元组。
- format(value[,format_spec])：字符串格式化
- hash(object)：获取某个对象的哈希值
- help([object])：获取帮助信息
- id(object)：获取对象的内存标识
- input([prompt])：获取一个标准输入
- ascii(object)：返回可打印对象的字符串表示形式
- breakpoint(*args, **kws)：断点调试
- object：所有类的基类，具有所有python类都通用的方法。
- print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)：将对象打印到文本流文件中，以sep分隔，以end结尾。sep、end、file和flush如果存在，必须作为关键字参数给出。
- slice(stop)、slice(start, stop[, step])：返回一个切片对象。
- zip(*iterables)：将可迭代的对象作为参数，将各个对象中对应索引位置的元素打包成一个个元组，然后返回由这些元组组成的对象。如果给定的可迭代对象长度不等，则以最短的迭代对象为准。
abs(x)
描述
返回一个数字的绝对值。参数可以是整数或浮点数。如果参数是复数，则返回其大小。
参数
- x：整数、浮点数、复数
返回值
返回数字的绝对值
示例
>>> abs(22) #整数
22
>>> abs(22.33) #浮点数
22.33
>>> abs(1+1.0j) #复数
1.4142135623730951
all(iterable)
描述
判断给定的可迭代对象内所有元素是否都为真。如果都为真，则返回True，反之则返回False。（当可迭代对象为空时，返回值为True）
函数等价于：
def all(iterable):
for element in iterable:
if not element:
return False
return True
参数
- iterable：可迭代对象，如：列表、元组
返回值
True或False
示例
>>> all(['a','b','c']) #列表，元素都不为空或0
True
>>> all(['a','b','c','']) #列表，元素存在一个为空
False
>>> all([1,2,3,0]) #列表，元素存在一个为0
False
>>> all(('a','b','c')) #元组，元素都不为空或0
True
>>> all(('a','b','c','')) #元组，元素存在一个为空
False
>>> all((1,2,3,0)) #元组，元素存在一个为0
False
>>> all([]) #空列表
True
>>> all(()) #空元组
True
any(iterable)
描述
判定给定的可迭代对象内的元素是否有一个为真。如果有一个为真，则返回True,反之则返回False。（当可迭代对象为空时，返回值为False
函数等价于：
def any(iterable):
for element in iterable:
if element:
return True
return False
参数
- iterable：可迭代对象，如：列表、元组
返回值
True或False
示例
>>> any(['a','b','c']) #列表，元素都为True
True
>>> any(['a','b','c','']) #列表，元素存在一个为空
True
>>> any(['',0,None]) #列表，元素都为False
False
>>> any(('a','b','c')) #元组，元素都为True
True
>>> any(('a','b','c','')) #元组，元素存在一个为空
True
>>> any(('',0,None)) #元组，元素都为False
False
>>> any([]) #空列表
False
>>> any(()) #空元组
False
ascii(object)
描述
返回一个可打印对象的字符串表示方式，如果是非ascii字符就输出\x,\u或\U等字符。
参数
- object：可打印对象
返回值
字符串
示例
>>> ascii(1111) #数字
'1111'
>>> ascii('aaaaaa') #字符串
"'aaaaaa'"
>>> ascii([1,2,3]) #列表
'[1, 2, 3]'
>>> ascii({'a':1,'b':2}) #字典
"{'a': 1, 'b': 2}"
>>> ascii('十万伏特') #非ascii字符
"'\\u5341\\u4e07\\u4f0f\\u7279'"
bin(x)
描述
把一个整数转换为以 0b 开头的二进制
参数
- x：整数
返回值
二进制
示例
>>> bin(22)
'0b10110'
>>> bin(-33)
'-0b100001'
class bool([X])
描述
将给定的指定参数转换为布尔类型（True或者False)，可用来判定一个元素的真假。如果参数为空则返回False。bool是int的一个子类。
参数
- x：需要进行转换的参数
返回值
True或False
示例
>>> bool(1)
True
>>> bool('aa')
True
>>> bool([1,2])
True
>>> bool((1,2))
True
>>> bool({'a':1})
True
>>> bool()
False
>>> bool('')
False
>>> bool(None)
False
>>> bool([])
False
>>> bool(())
False
>>> bool({})
False
>>> issubclass(bool,int) #判读bool是否是int的子类
True
breakpoint(*args, **kws)
描述
在未设置 PYTHONBREAKPOINT 的情况下，breakpoint() 会中断当前程序并进入 pdb 调试器。用于断点调试。
示例
>\#!/usr/bin/env python3
>\# _*_ coding:utf-8 _*_
>\# Created by fjg on 2018/10/25
>def guess_num(num_guess: str) -> str:
> user_guess: str = input("猜想的数字：")
> breakpoint()
> if user_guess == num_guess:
> return "猜对了"
> else:
> return "猜错了"
>
>
>if __name__ == '__main__':
> right_num: int = 555
> print(guess_num(right_num))
执行结果
E:\dev\lye\venv\Scripts\python.exe E:/dev/lye/test/test_breakpoint.py
猜想的数字：111
> e:\dev\lye\test\test_breakpoint.py(7)guess_num()
-> if user_guess == num_guess:
(Pdb) locals()
{'num_guess': 555, 'user_guess': '111'}
(Pdb)
calss bytearray([source[,encoding[,errors]]])
描述
返回一个可变的字节数组。数组内每个元素的范围：0<=x<256
参数
- x：
- 整数：返回一个长度为source的初始化数组
- 字符串：如果是字符串，必须给定一个编码方式（encoding参数）。bytearray将使用str.endcode()把字符串转换为字节。
- 可迭代类型：可迭代的类型中的元素必须为[0,255]中的整数
- 空：初始化一个有0个元素的数组
- 如果source为与buffer接口一直的对象，则此对象可用于初始化bytearray
- encoding：编码格式
- errors：指定如何处理编码和解码错误
返回值
一个可变的字节数组
示例
>>> bytearray(10) # 整数
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
>>> bytearray("python",'utf-8') # 字符串
bytearray(b'python')
>>> bytearray([1,2,3]) # 可迭代类型，元素为[0,255]中的整数
bytearray(b'\x01\x02\x03')
>>> bytearray(["1",2,3]) # 可迭代类型，元素中有个字符串，就报错了
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: an integer is required
>>> bytearray() # 空
bytearray(b'')
class bytes([source[, encoding[, errors]]])
描述
返回一个新的bytes对象，该对象是一个0<=x<256区间内的整数不可变数列。它是bytearray的不可变版本。
参数
参照bytearray()
返回值
返回一个新的bytes对象
示例
>>> bytes(10)
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
>>> bytes('python','utf-8')
b'python'
>>> bytes([1,2,3])
b'\x01\x02\x03'
>>> bytes(["1",2,3])
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer
>>> bytes()
b''
callable(object)
描述
如果对象参数是可调用的返回True,反之则返回False。如果返回True,这个对象有可能还会调用失败，如果返回False，则一定不可能被调用成功。如果这个对象具有__call__()方法，它都会返回True.
参数
- object：一个对象
返回值
True或False
示例
>>> callable(0)
False
>>> callable('python')
False
>>> def add(a,b):
... return a+b
...
>>> callable(add)
True
>>> class A:
... def add(self):
... return 0
...
>>> callable(A)
True
>>> a = A()
>>> callable(a)
False
>>> class B:
... def __call__(self):
... return 0
...
>>> b = B()
>>> callable(B)
True
>>> callable(b)
True
chr(i)
描述
返回其Unicode编码位是整数i字符的字符串，i 的有效值范围为[0,1114112].超过这个范围则会抛出 ValueError
参数
- i：[0,1114112]，可以是十进制也可以是十六进制
示例
>>> chr(0)
'\x00'
>>> chr(97)
'a'
>>> chr(48) # 十进制
'0'
>>> chr(1114111) # 可取的最大值
'\U0010ffff'
>>> chr(1114112) # 超出取值范围
Traceback (most recent call last):
File "<input>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)
>>> chr(0x00)
'\x00'
>>> chr(0x61)
'a'
>>> chr(0x30) # 十六进制
'0'
@classmethod
描述
将一个方法转换为类方法的装饰器。可以在不实例化一个类的前提下，调用这个方法（可以在类上面调用，也可以在实例上面调用）。在类下面的该方法不需要self参数，但是第一个参数需要是表示自身类的cls参数，可以用来调用类的属性，方法，实例化对象等。
返回值
返回该函数的类方法。
示例
>>> class A(object):
... aa = 1
... def func1(self):
... print('this is func1')
... @classmethod
... def func2(cls):
... print('this is func2')
... print(cls.aa) # 调用类属性
... cls().func1() # 利用cls实例化A并调用func1方法
...
>>> A.func2() # 在类上面调用
this is func2
1
this is func1
>>> A().func2() # 在实例上调用
this is func2
1
this is func1
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
描述
将 source 编译为代码或者AST对象。代码可以通过exec()或者eval()执行。
参数
- source: source 可以是普通的字符串、字节字符串或者AST对象。
- filename: filename 参数应该是可以读取代码的文件位置。如果没有从文件中读取代码，则需要传递一些可识别的参数（通常是给 "" 空的字符串 ）
- mode: mode 指定代码的编译种类。如果是一系列流程语句，可以使用 'exec'；如果是单个表达式，可以使用'eval';如果是一个交互式语句，则可以使用 'single'。
- optimize：指定编译器的优化级别，默认值-1选择的解释器的优化级别为-O选项。具体级别有：0（无优化，__debug__为true），1（移除断言，__debug__为false）或2（移除文档字符串）。
示例
>>> str1='for i in range(5):print(i)'
>>> a1 = compile(str1,'','exec') # 流程语句
>>> a1
<code object <module> at 0x041224F0, file "", line 1>
>>> exec(a1)
0
1
2
3
4
>>> str2 = "1*4+2*3"
>>> a2 = compile(str2,'','eval') # 表达式
>>> a2
<code object <module> at 0x04162860, file "", line 1>
>>> exec(a2)
>>> eval(a2)
10
>>> str3="bb3 = input('输入')"
>>> a3 = compile(str3,'','single') # 交互式语句
>>> a3
<code object <module> at 0x04122F40, file "", line 1>
>>> exec(a3)
输入>? python
>>> print(bb3)
python
class complex([real[, imag]])
描述
用于创建一个 real+imag*j 的复数或者转化一个字符串或者数字为复数。如果第一个参数为字符串，则不需要指定第二个参数。第二个参数绝对不可以是字符串。每个参数可以是任何数字类型（包括复数）。
注意： 当转化字符串时，在 + 或者 - 两侧不能有空格，否则会抛出 ValueError的异常。
参数
- real: 整数、浮点数、字符串。
- imag: 整数、浮点数
返回值
一个复数
示例
>>> complex()
0j
>>> complex(1,2)
(1+2j)
>>> complex(1.1,2.2)
(1.1+2.2j)
>>> complex("1")
(1+0j)
>>> complex("1+2j")
(1+2j)
>>> complex("1 + 2j") # + 周围有空格 报错。
Traceback (most recent call last):
File "<input>", line 1, in <module>
ValueError: complex() arg is a malformed string
delattr(object, name)
描述
与 setattr() 相对。参数是一个对象和一个字符串。字符串必须是对象属性中的一个名字，如果对象允许，delattr将删除该名称的属性。
参数
- object: 对象
- name: 必须是对象属性的名称
示例
>>> class A(object):
... a = 1
... b = 2
... c = 3
...
>>> aa = A()
>>> aa.a
1
>>> aa.b
2
>>> aa.c
3
>>> delattr(A,"b")
>>> aa.a
1
>>> aa.b
Traceback (most recent call last):
File "<input>", line 1, in <module>
AttributeError: 'A' object has no attribute 'b'
>>> aa.c
3
class dict(**kwarg)、class dict(mapping, **kwarg)、class dict(iterable, **kwarg)
描述
用于创建一个字典
参数
- **kwarg: 关键字
- mapping: 元素的容器
- iterable: 可迭代对象
返回值
一个字典
示例
>>> dict()
{}
>>> dict(a=1,b=2,c=3)
{'a': 1, 'b': 2, 'c': 3}
>>> dict([('a',1),('b',2),('c',3)])
{'a': 1, 'b': 2, 'c': 3}
>>> dict(zip(['a','b','c'],[1,2,3]))
{'a': 1, 'b': 2, 'c': 3}
dir([object])
描述
如果不带参数，则返回当前范围内的变量、方法和定义的类型列表。带参数时，返回参数的有效属性列表（属性、方法）。如果对象带有 __dir__()方法,则该方法将会被调用，并且一定返回一个有效属性列表。对象允许通过__getattr__()或者__getattribute__()函数来自定义 dir() 的内容。
当对象不提供__dir__()方法时，并且定义了__dict__()属性，函数将试着通过对象的__dict__()及其类型对象中尽可能的获取信息。结果列表可能不完整，并且当对象拥有__getattr__()属性时，可能不准确。
参数
dir() 对不同的对象类型有不同的处理机制。 它试图展示最相关的信息而不是最完整的。
- 如果对象是一个模块对象，则列表包含这个模块的名称。
- 如果对象是一个类或者类对象，则列表包含其属性名称和它的基础属性。
- 否则，列表包含对象的属性名、类的属性名以及类的基类的属性的递归名称。
返回值
一个列表
示例
>>> import struct
>>> dir()
['__builtins__', '__name__', 'struct']
>>> dir(struct)
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
'__initializing__', '__loader__', '__name__', '__package__',
'_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
'unpack', 'unpack_from']
>>> class Shape:
... def __dir__(self):
... return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']
divmod(a,b)
描述
将两个(非复数)数字作为参数，并在使用整数除法时返回由它们的商和余数组成的一对数字。
参数
- a,b：a和b可以为整数或者浮点数，不能为复数
返回值
一个商和余数的元组
示例
>>> divmod(1,2) # 整数
(0, 1)
>>> divmod(0.3,0.2) # 浮点数
(1.0, 0.09999999999999998)
>>> divmod(0.3,0.4)
(0.0, 0.3)
>>> divmod(1+2j,1+0.5j) # 复数报错
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: can't take floor or mod of complex number.
>>> a = divmod(1,2)
>>> type(a) # 返回的是一个元组
<class 'tuple'>
enumerate(iterable, start=0)
描述
enumerate()返回的迭代器的__next__()方法返回一个元组，该元组包含一个计数(从默认值为0的开始)和通过iterable进行迭代获得的值。
该函数等同于：
def enumerate(sequence, start=0):
n = start
for elem in sequence:
yield n, elem
n += 1
参数
- iterable: 必须是序列、迭代器或者是其他可迭代的对象。
- start: 计数器开始的数值。整数
返回值
返回一个enumerate对象
示例
>>> a = ['a','b','c','d']
>>> list(enumerate(a,start=0))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(a,start=1))
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]
eval(expression, globals=None, locals=None)
描述
执行一段字符串表达式，并返回表达式的值，解析expression参数并作为一个python表达式进行计算。
参数
- expression： 一个字符串表达式
- globals: 全局命名空间，如果提供，则必须是一个字典对象。指定全局变量
- locals: 局部命名空间，如果提供，可以是任何映射对象。指定局部变量
返回值
返回字符串表达式计算的结果
示例
请注意提供不同参数，变量调用的差异。
>>> a = 1
>>> eval('a+1') # 不提供 globals和locals
2
>>> a = 1
>>> g={'a':11}
>>> eval('a+1',g) # 提供 globals,不提供locals
12
>>> a = 1
>>> g = {'a':11}
>>> l = {'a':111}
>>> eval('a+1',g,l) # 同时提供globals和locals
112
exec(object[, globals[, locals]])
描述
用于python代码的动态执行
参数
- object: 必须是字符串或者代码对象。如果是字符串，则字符串会被解析为一段python代码并执行，除非它出现语法错误。如果它是代码对象，则直接执行它。
- globals: 可选参数。指定全局变量，必须是一个字典。
- locals: 可选参数。指定局部变量，它可以是任何映射类型。
返回值
永远为None。
示例
>>> a = 1
>>> exec("a=11")
>>> a
11
>>> a = 1
>>> b = 2
>>> g = {'a':11,'b':22}
>>> exec("global a;print(a,b)",g)
11 22
>>> a = 1
>>> b = 2
>>> c = 3
>>> g = {'a':11,'b':22}
>>> l = {'b':222,'c':33}
>>> exec("global a;print(a,b,c)",g,l)
11 222 33
filter(function, iterable)
描述
把 iterable 中的元素逐个传入 function 内，将所有返回值为True的元素重新构建一个迭代器对象。可以通过list()把返回的迭代器对象转换为列表
参数
- function： 判断函数
- iterable：序列、支持迭代的容器或者迭代器
返回值
返回一个迭代器对象
示例
>>> def get_odd(x):
... return x % 2 == 1
...
>>> odd_list = filter(get_odd,[1,2,3,4,5,6,7,8,9,10])
>>> type(odd_list)
<class 'filter'>
>>> print(odd_list)
<filter object at 0x045D94B0>
>>> list(odd_list)
[1, 3, 5, 7, 9]
class float([x])
描述
返回由字符串或者数字 x 构成的浮点数。
参数
- x：数字或者字符串
返回值
浮点数
示例
>>> float('+1.23')
1.23
>>> float(' -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf
format(value[,format_spec])
描述
字符串格式化
参考博客：字符串
class frozenset([iterable])
描述
使用iterable内的元素生成一个冻结的集合，该集合不能添加和删除元素。
参数
- iterabel：可迭代的对象。如列表、元组、字典等
返回值
一个新的frozenset对象。
示例
>>> a = frozenset(range(10))
>>> type(a)
<class 'frozenset'>
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
>>> b = frozenset('hello world')
>>> b
frozenset({'l', 'o', 'h', 'e', 'w', 'r', 'd', ' '})
getattr(object, name[, default])
描述
返回 object 对象 name 属性的值。
参数
- object：对象
- name: name必须是一个字符串，如果字符串是对象属性名称之一，则返回该对象的值。如果指定的对象不存在则返回 default 的值。否则引发 AttributeError 报错。
- default: 默认返回值，如果不提供。在没有对应属性值时，会触发AttributeError.
返回值
返回对象的属性值
示例
>>> class A(object):
... a = 1
...
>>> aa = A()
>>> getattr(aa,'a')
1
>>> getattr(aa,'b')
Traceback (most recent call last):
File "<input>", line 1, in <module>
AttributeError: 'A' object has no attribute 'b'
>>> getattr(aa,'b',2)
2
globals()
描述
返回当前环境的全局变量的字典。
返回值
所有全局变量的字典
示例
>>> globals()
{'__builtins__': {'__name__': 'builtins', '__package__': '', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>), '__build_class__': <built-in function __build_class__>, '__import__': <bound method ImportHookManager.do_import of <module '_pydev_bundle.pydev_import_hook.import_hook'>>, 'abs': <built-in function abs>, 'all': <built-in function all>, 'any': <built-in function any>,
......省略......
'bin': <built-in function bin>, 'breakpoint': <built-in function breakpoint>, 'callable': <built-in function callable>, 'chr': <built-in function chr>, 'compile': <built-in function compile>, 'delattr': <built-in function delattr>, 'dir': <built-in function dir>, 'divmod': <built-in function divmod>, 'eval': <built-in function eval>, 'exec': <built-in function exec>,}, 'sys': <module 'sys' (built-in)>}
hasattr(object, name)
描述
判断 name 是不是 object 属性之一，如果是则返回True,否则返回False
参数
- object: 对象
- name: 要判断的属性名，字符串
返回值
True或False
示例
>>> class A(object):
... a = 1
... b = 2
... def c(self):
... return 0
...
>>> hasattr(A,'a')
True
>>> hasattr(A,'b')
True
>>> hasattr(A,'c')
True
>>> hasattr(A,'d')
False
hash(object)
描述
用于获取一个对象的哈希值（如果有的话），如果是数字的话，等值的数字的哈希值是一致的。如：1.0和1 尽管它们属于不同的类型。
参数
- object：对象
返回值
对象的哈希值
示例
>>> hash(1)
1
>>> hash('python')
1817897009
>>> hash([1,2,3])
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> hash(str([1,2,3]))
-970184530
>>> hash(str({'a':1,'b':2}))
1261408225
help([object])
描述
调用内置的帮助系统。
参数
对象。如果参数是字符串，那么将查找该字符串作为模块、函数、类、方法、关键字或文档主题的名称，并在控制台打印帮助页面。如果参数是任何其他类型的对象，就会生成对象上的帮助页面。如果没有参数，将启动一个帮助控制台。
返回值
返回对象的帮助信息，或者进入帮助控制台
示例
>>> help()
Welcome to Python 3.7's help utility!
...省略...
help> q
>>> help('sys')
Help on built-in module sys:
NAME
sys
MODULE REFERENCE
https://docs.python.org/3.7/library/sys
...省略...
>>> a = [1,2,3]
>>> help(a.append)
Help on built-in function append:
append(object, /) method of builtins.list instance
Append object to the end of the list.
hex(x)
描述
把一个整数转换为以'0x'开头的小写十六进制字符串。如果 x 不是一个整数对象，它必须定义一个返回整数的 index() 方法。
参数
十进制整数
返回值
十六进制字符串
示例
>>> hex(233)
'0xe9'
>>> hex(-233)
'-0xe9'
>>> type(hex(28))
<class 'str'>
id(object)
描述
返回对象的内存标识，也就是所谓的内存地址。
参数
对象
返回值
对象的内存地址
示例
>>> a = 1
>>> id(a)
257017984
>>> b = a
>>> id(b)
257017984
>>> class A(object):
... a = 11
... b = 22
...
>>> c = A()
>>> id(c)
72534064
input([prompt])
描述
接收一个标准数据输入，返回值为字符串。如果存在 prompt ，则会获取一个标准输入，并去掉行位的换行符。
参数
提示信息
返回值
字符串
示例
>>> a = input('num:')
num:>? 111
>>> type(a)
<class 'str'>
class int([x])、class int(x, base=10)
描述
返回由数字或字符串x构造的整数对象，如果没有给出参数，则返回0。如果 x 定义了 int()，则 int(x) 返回 x.int() . 如果 x 定义了 trunc(), 则返回 x.trunc()。对于浮点数，将直接忽略小数点后面的数字。
如果x不是一个数字或者给了base参数，则x必须是一个字符串、bytes或bytearray实例。
参数
- x：字符串或者数字
- base：进制数，默认是十进制。如果带有base参数，则x必须是字符串。
返回值
返回一个整型数据
示例
>>> int()
0
>>> int(3)
3
>>> int(1.9)
1
>>> int('12',16)
18
>>> int(12,16)
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: int() can't convert non-string with explicit base
isinstance(object, classinfo)
描述
如果 object 是 classinfo 参数的实例，或者其直接、间接或虚拟子类的实例，则返回true。如果对象不是给定类型的对象，则返回false。如果classinfo是类型对象的元组(或者递归地，其他的元组)，如果object是其中任何一个类型的实例，返回true。如果classinfo不是类型或类型的元组，那么就会 TypeError 错误异常。
参数
- object：实例对象。
- classinfo：可以是直接或间接类名、基本类型或者由他们组成的元组。常见的classinfo：int、float、bool、complex、str、list、dict、set、tuple
返回值
True或者False
示例
>>> a = 1
>>> isinstance(a,str)
False
>>> isinstance(a,int)
True
>>> isinstance(a,(int,str))
True
>>> class A(object):
... pass
...
>>> class B(A):
... pass
...
>>> isinstance(A(),A)
True
>>> isinstance(B(),A)
True
issubclass(class, classinfo)
描述
如果class是classinfo直接、间接或者虚拟的子类，则返回True，反之则返回False。class被认为是class自己的子类。classinfo可以是一个元组，如果class是元组其中之一的子类则返回True，反之则为False。
参数
- class：类
- classinfo：类或者类的元组
返回值
True或False
示例
>>> class A(object):
... pass
...
>>> class B(A): # B继承A
... pass
...
>>> class C(B): # C继承B
... pass
...
>>> class D(object):
... pass
...
>>> class E(object):
... pass
...
>>> issubclass(A,A) # A是自己的子类
True
>>> issubclass(B,A) # B是A的子类
True
>>> issubclass(C,A) # C也是A的子类
True
>>> issubclass(C,D) # C不是D的子类
False
>>> issubclass(C,(A,B)) # C是A和B的子类
True
>>> issubclass(C,(A,B,D))
True
>>> issubclass(C,(D,E)) # C不是D和E的子类
False
iter(object[, sentinel])
描述
用来生成迭代器
参数
- object：应是一个容器，支持迭代协议(即定义有__iter__()函数)，或者支持序列访问协议（即定义有__getitem__()函数），否则会返回TypeError异常。
- sentinel：当第二个参数sentinel出现时，参数callable应是一个可调用对象(实例)，即定义了__call__()方法，当枚举到的值等于哨兵时，就会抛出异常StopIteration。
返回值
返回一个迭代器对象。
示例
无第二参数：
>>> a = [1, 2, 3, 4, 5]
>>> for i in iter(a):
... print(i)
...
1
2
3
4
5
有第二参数
class TestIter(object):
def __init__(self):
self.l = [1, 2, 4, 5, 'a', 6, 7, 8]
self.i = iter(self.l)
def __call__(self): # 定义了__call__方法的类的实例是可调用的
item = next(self.i)
print("__call__ is called,which would return", item)
return item
def __iter__(self): # 支持迭代协议(即定义有__iter__()函数)
print("__iter__ is called!!")
return iter(self.l)
t = TestIter() # t是可调用的
t1 = iter(t, 'a') # t必须是callable的，否则无法返回callable_iterator
print(callable(t))
for i in t1:
print(i)
输出结果
True
__call__ is called,which would return 1
1
__call__ is called,which would return 2
2
__call__ is called,which would return 4
4
__call__ is called,which would return 5
5
__call__ is called,which would return a
Process finished with exit code 0
len(s)
描述
返回对象的长度(项的数量)
参数
参数可以是序列(例如字符串、字节、元组、列表或范围)或集合(例如字典、集合或冻结集合)。
返回值
对象的长度
示例
>>> len('python')
6
>>> len([1,2,3,4,5])
5
class list([iterable])
描述
用于将元组或字符串转换为列表
参数
元组或字符串
返回值
一个列表
示例
>>> a = 'python'
>>> list(a)
['p', 'y', 't', 'h', 'o', 'n']
>>> b = (1,2,3,4,5)
>>> list(b)
[1, 2, 3, 4, 5]
locals()
描述
以字典的方式返回当前所在位置的全部局部变量，
参数
无
返回值
局部变量的字典
示例
>>> def A(b):
... a = 1
... print(locals())
...
>>> A(2)
{'b': 2, 'a': 1}
map(function, iterable, ...)
描述
把 iterable 内的元素逐个带入到 function 内，然后把得到的结果放入一个迭代器内返回。如果传入了多个 iterable 则会按照序列把每个 iterable 内的相同位置的元素同时传入 function 内执行。直到最短的那个 iterable 执行完成。
参数
- function：函数
- iterable：一个或多个迭代器
返回值
迭代器
示例
>>> def A(x):
... return x ** 2
...
>>> a = map(A,[1,2,3,4]) # 单个迭代器
>>> type(a)
<class 'map'>
>>> a
<map object at 0x03C88470>
>>> list(a)
[1, 4, 9, 16]
>>> b = map(lambda x: x ** 2,[1,2,3,4]) # 使用匿名函数
>>> list(b)
[1, 4, 9, 16]
>>> c = map(lambda x ,y: x + y,[1,2,3,4],[1,2,3,4,5,6,7]) # 同时传入两个迭代器，最短的取完元素就结束了。
>>> list(c)
[2, 4, 6, 8]
max(iterable, *[, key, default])、max(arg1, arg2, *args[, key])
描述
返回可迭代对象 iterable 或者两个或多个参数arg1,arg2... 中最大的项。如果只有一个参数，那么它必须是可迭代的对象，并返回其中最大的项。如果提供了两个或多个参数，则返回这些参数中最大的参数。如果 iterable 为空，默认参数指定要返回的对象。如果 iterable 为空且没有提供默认值，则会引发 ValueError 。根据ord()获取对应字符串在ASCII中的位置来比较大小。
参数
- iterable：可迭代对象。
- key：当key不为空时，以key的函数对象作为比较的标准
返回值
返回给定参数的最大值
示例
>>> a = range(10)
>>> max(a)
9
>>> b = 'python'
>>> max(b)
'y'
>>> max(a, key=lambda x: x > 3)
4
>>> max(1, 4, 5, 7, 8, 0, 5, 54, 65, 7)
65
>>> max('an', 'bg', key=lambda x: x[1])
'an'
>>> c = range(0, 10, 2)
>>> max(a, c, key=lambda x: x[1])
range(0, 10, 2)
>>> def A(x):
... return x[2]
...
>>> max('an1','bg9',key=A)
'bg9'
memoryview(obj)
描述
根据传入的对象创建一个内存查看对象。所谓的内存查看对象，是指对支持缓冲区协议的数据进行包装，使它在不需要复制对象的基础上允许python代码访问。
参数
obj必须支持缓存协议。支持缓存协议的内置对象包括 bytes 和 bytearray
返回值
memoryview对象
示例
>> a = b'python'
>>> b = bytearray('python','utf-8')
>>> aa = memoryview(a)
>>> bb = memoryview(b)
>>> aa[1]
121
>>> bb[1]
121
>>> aa[:3]
<memory at 0x046B7B90>
>>> bb[:3]
<memory at 0x046B7AC0>
>>> aa.readonly
True
>>> bb.readonly
False
>>> aa[:3].tobytes()
b'pyt'
>>> bb[:3].tobytes()
b'pyt'
min(iterable, *[, key, default])、min(arg1, arg2, *args[, key])
与max是相对的。
next(iterator[, default])
描述
通过调用 iterable 的__next__()方法从迭代器中检索下一个项目。如果给定 default ，那么当迭代器耗尽时，返回该值，否则将引发 StopIteration 错误。
参数
- iterable：可迭代对象
- default：当迭代器耗尽时的默认值
返回值
迭代器中的元素
示例
>>> a = iter([1,2,3,4,5])
>>> while True:
... try:
... b = next(a)
... print(b)
... except StopIteration:
... break
...
1
2
3
4
5
class object
描述
object是所有类的基类，它具有所有python类都通用的方法。这个函数不接受任何参数。
oct(x)
描述
将整数转换为以“0o”开头的八进制字符串。如果 x 不会一个int对象，那它必须定义有一个返回整数的 index() 方法。
参数
整数
返回值
以"0o"开头的八进制字符串
示例
>>> oct(10)
'0o12'
>>> oct(111)
'0o157'
>>> class A(object):
... def __index__(self):
... return 10
...
>>> aa = A()
>>> oct(aa)
'0o12'
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
描述
打开文件并返回响应的文件对象。如果文件无法打开，则返回一个 OSError 错误。
参数
- file：文件的位置。文件的绝对路径或者相对于当前工作目录的相对路径。
- mode：文件的打开模式。
- r：只读模式，文件指针会在放在文件的开头。
- t：文本模式（默认）
- x：写模式，新加你一个文件，如果文件存在则会报错。
- b：二进制模式
- +：更新一个文件（可读，可写）
- U：通用换行模式
- rb：以二进制格式、只读方式打开文件件。文件指针在文件开头。一般用于非文本文件如图片等。
- r+：打开一个文件用于读写。文件指针在开头。
- rb+：以二进制格式、只读方式打开一个文件用于读写。一般用于非文本文件如图片等。
- w：打开一个文件用于写入。如果文件已经存在，则会清空原有文件内容，从头开始编辑写入。如果文件不存在，则创建新文件。
- wb：以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
- w+：打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
- wb+：以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
- a：打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
- ab：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
- a+：打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
- ab+：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
- buffering：设置缓冲策略。当没有指定buffering时：二进制文件以固定大小的块进行缓冲。通过启发式方法尝试获取底层设备的块大小，并返回到 io.DEFAULT_BUFFER_SIZE 。在大多数系统中，缓冲区大小通常为4096或者8192字节；“交互式”文本文件(isatty()返回True的文件)使用行缓冲。其他文本文件对二进制文件使用上述策略。
- 0：关闭缓冲。只能在二进制模式下使用。
- 1：行缓冲。只能在文本模式下使用。
- >1：大于1的整数。指定缓冲区块的字节大小。
- encoding：指定编码或解码方式。这个只能用在文本模式中。默认的编码方式取决于所用平台（locale.getpreferredencoding()的返回值）。
- errors：可选的字符串，指定如何处理编码和解码错误（不能在二进制模式中使用）。
- newline：控制通用换行模式的工作方式(它只适用于文本模式)。它可以是：None、''、'\n'、'\r'、'\n\r'。
- closefd：如果closefd为False，并且提供了文件描述符(而不是文件名)，那么在关闭文件时，底层文件描述符将保持打开状态。如果给定文件名closefd必须为真(默认)，否则将引发错误。
- opener：
ord(c)
描述
给定一个表示一个Unicode字符的字符串，返回一个表示该字符的Unicode编码点的整数编号。
参数
一个字符串
返回值
Unicode编码表内的整数编号
示例
>>> ord('1')
49
>>> ord('a')
97
>>> ord('A')
65
>>> ord('中')
20013
>>> ord('国')
22269
pow(x, y[, z])
描述
返回x**y的值，如果给定了 z 参数，则返回 x**y%z的值
参数
x,y,z：必须具有数字类型。对于混合操作数类型，应用二进制算术运算符的强制规则。对于int操作数，结果具有与操作数相同的类型(强制后)，除非第二个参数为负;在这种情况下，所有参数都转换为float，并交付float结果。如果第二个参数为负数，则必须省略第三个参数。如果z存在，x和y必须是整数类型，y必须是非负的。
返回值
x的y次方、x的y次方除以Z取模
示例
>>> pow(2,4)
16
>>> pow(2,4,3)
1
>>> pow(2.1, 2)
4.41
>>> pow(2.1, 2, 2)
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: pow() 3rd argument not allowed unless all arguments are integers
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
描述
将对象打印到文本流文件中，以sep分隔，以end结尾。sep、end、file和flush如果存在，必须作为关键字参数给出。sep 和 end 必须是字符串。也可以是 None，这就代表使用默认值。如果没有给定 objects 则将只会输出 end .
参数
- objects：复数，可以一次输出多个对象。输出多个对象时，以 ',' 分隔。
- sep：当输出多个对象时，用来分隔对象。默认值是空格
- end：用来设定以什么结尾。默认值时换行符。
- file：必须是具有 write(string) 方法的对象。如果未指定或设置为 None，将使用 sys.stdout。由于打印参数被转换为文本字符串，所以print()不能用于二进制模式文件对象。对于这些，使用file.write(…)代替。
- flush：是否强制刷新缓存。
示例
>>> print('a')
a
>>> print('a','b')
a b
>>> print('a','b',sep='...')
a...b
>>> print('a','b',sep='...',end='+++')
a...b+++
class property(fget=None, fset=None, fdel=None, doc=None)
描述
将类中的方法像类属性一样调用，规范化的访问类的属性和修改类属性的值的一种方法
参数
- fget：获取属性值的函数
- fset：设置属性值的函数
- fdel：深处属性值的函数
- doc：返回属性说明的函数
返回值
返回一个property类
示例
第一种
>>> class A(object):
... def __init__(self, a, b):
... self.a = a
... self.b = b
...
... def getValue(self):
... return self.a, self.b
...
... def setValue(self, size):
... self.a, self.b = size
...
... def delValue(self):
... del self.a
...
... size = property(fget=getValue, fset=setValue, fdel=delValue, doc="十万伏特")
...
>>> test = A(22, 33)
>>> print(test.a, test.b)
22 33
>>> print(test.size)
(22, 33)
>>> test.size = 2222, 3333
>>> print(test.size)
(2222, 3333)
>>> del test.b
>>> print(test.size)
Traceback (most recent call last):
File "<input>", line 1, in <module>
File "<input>", line 7, in getValue
AttributeError: 'A' object has no attribute 'b'
>>> A.size.__doc__
'十万伏特'
第二种
>>> class B(object):
... def __init__(self, a, b):
... self.a = a
... self.b = b
...
... @property
... def Values(self):
... """十万伏特"""
... return self.a, self.b
...
... @Values.setter
... def Values(self, size):
... self.a, self.b = size
...
... @Values.deleter
... def Values(self):
... del self.b
... del self.a
...
>>> bb = B(44, 55)
>>> bb.a
44
>>> bb.b
55
>>> bb.Values
(44, 55)
>>> bb.Values = 4444, 5555
>>> bb.Values
(4444, 5555)
>>> bb.a
4444
>>> bb.b
5555
>>> del bb.a
>>> bb.b
5555
>>> bb.a
Traceback (most recent call last):
File "<input>", line 1, in <module>
AttributeError: 'B' object has no attribute 'a'
range(stop)，range(start,stop[,step])
描述
返回一个可迭代对象，而不是列表类型
参数
- start：计数从start开始
- stop：计数到stop结束，但不包括stop。
- step：步长，默认值为1.
返回值
一个可迭代对象
示例
>>> a = range(5)
>>> type(a)
<class 'range'>
>>> a
range(0, 5)
>>> from collections import Iterable
>>> isinstance(a,Iterable)
True
>>> for i in a:
... print(i)
...
0
1
2
3
4
>>> b = range(2, 6, 2)
>>> type(b)
<class 'range'>
>>> b
range(2, 6, 2)
>>> isinstance(b,Iterable)
True
>>> for i in b:
... print(i)
...
2
4
repr(object)
描述
将 object 转换为可供解释器杜旭的字符串形式。通常情况下，object = eval(repr(object))，否则，返回一个用尖括号括起来的字符串，其中包含object的名称以及附加信息(通常包括对象的名称和地址)。
参数
- repr：对象
返回值
字符串
示例
>>> a = [1, 2, 3, 4]
>>> repr(a)
'[1, 2, 3, 4]'
>>> aa = eval(repr(a))
>>> aa
[1, 2, 3, 4]
>>> a
[1, 2, 3, 4]
class B(object):
def A(self):
return 111
b = B()
repr(b)
'<B object at 0x039E6350>'
b
<B object at 0x039E6350>
reversed(seq)
描述
返回一个反向的迭代器。
参数
seq必须是一个具有__reversed__()方法或支持序列协议(len()方法和__getitem__()方法的对象，整数参数从0开始)。
返回值
反向迭代器
示例
>>> "".join(list(reversed('python')))
'nohtyp'
>>> list(reversed([1,2,3,4,5]))
[5, 4, 3, 2, 1]
>>> tuple(reversed((1,2,3,4,5)))
(5, 4, 3, 2, 1)
round(number[, ndigits])
描述
返回 number 四舍五入后的值。如果 ndigits 为空或者None，则返回最接近number的整数。
参数
- number：数字表达式
- ndigits：小数点位数，默认为0
返回值
返回number的四舍五入值
示例
>>> round(2.345)
2
>>> round(2.345,1)
2.3
>>> round(2.345,2)
2.35
>>> round(2.345,3)
2.345
>>> round(2.345,4)
2.345
>>> round(2.00000567,3)
2.0
>>> round(-2.00000567,3)
-2.0
>>> round(-2.00000567,5)
-2.00001
# 需要注意的几个
>>> round(0.5) #取整到偶数部分
0
>>> round(-0.5)
0
>>> round(2.5)
2
>>> round(3.5)
4
>>> round(10.5)
10
>>> round(11.5)
12
>>> round(2.675,2) # 并不是bug，有些浮点数在计算机中并不能像整数那样被精准的表达，它可能是一个近似值。
2.67
class set([iterable])
描述
创建一个set对象。或者使用iterable中的元素生成一个set对象。
参数
- iterable：可迭代对象
返回值
新的集合对象
示例
>>> a = set()
>>> a
set()
>>> set('python')
{'p', 'o', 'y', 'h', 't', 'n'}
>>> set('hello world')
{' ', 'e', 'w', 'd', 'o', 'l', 'h', 'r'}
setattr(object, name, value)
描述
和 getattr 相似，如果 object 允许，函数将会把 value 赋值给 name。
参数
- object：对象
- name：字符串，对象属性名。可以是现有属性或是新属性。
- value：属性值
示例
>>> class A(object):
... a = 1
...
>>> aa = A()
>>> aa.a
1
>>> getattr(aa,'a')
1
>>> setattr(aa,'a', 2) # 设置现有属性
>>> getattr(aa,'a')
2
>>> setattr(aa,'b', 2) # 设置新属性
>>> aa.b
2
>>> getattr(aa,'b')
2
class slice(stop)、class slice(start, stop[, step])
描述
返回一个切片对象，该对象是一组由rang(start,stop,step)指定的索引集合。start、step 参数的默认值为None。 slice 对象具有只读数据属性 start、stop 和 step，他们将返回设定的参数值或者默认值。
参数
- start：起始位置
- stop：结束位置
- step：间距
返回值
一个切片对象
示例
>>> a = slice(5)
>>> a.start,a.stop,a.step
(None, 5, None)
>>> a
slice(None, 5, None)
>>> aa = range(10)
>>> list(aa)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aa[a]
range(0, 5)
>>> list(aa[a])
[0, 1, 2, 3, 4]
>>> b = slice(2, 8, 2)
>>> b.start,b.stop,b.step
(2, 8, 2)
>>> aa[b]
range(2, 8, 2)
>>> list(aa[b])
[2, 4, 6]
sorted(iterable, *, key=None, reverse=False)
描述
对 iterable 进行排序操作，并返回一个新的list
参数
- iterable：可迭代对象
- key：指定一个函数，并把 iterable 中的每一个元素带入函数中，并根据返回的值的排序来对iterable进行排序。默认值是None
- reverse：是否反转。False 升序，True 降序。
返回值
重新排列后的iterable
示例
>>> sorted([5,2,5,7,1,6])
[1, 2, 5, 5, 6, 7]
>>> sorted(('a', 'b', '1', '4', '7', '5', '3', 'A'))
['1', '3', '4', '5', '7', 'A', 'a', 'b']
>>> a = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
>>> def By_name(x):
... return x[0][0].lower()
...
>>> sorted(a,key=By_name)
[('Adam', 92), ('Bob', 75), ('Bart', 66), ('Lisa', 88)]
>>> def By_num(x):
... return x[1]
...
>>> sorted(a,key=By_num)
[('Bart', 66), ('Bob', 75), ('Lisa', 88), ('Adam', 92)]
>>> sorted(a, key=By_num, reverse=True)
[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]
@staticmethod
描述
将一个方法转换为静态方法。在类中，静态方法不会隐式的接收第一个参数。
示例
>>> class A(object):
... @staticmethod
... def B():
... print('刀剑神域')
...
>>> A.B() # 静态方法可以在不实例化类的情况下调用
刀剑神域
>>> a = A()
>>> a.B()
刀剑神域
class str(object='')、class str(object=b'', encoding='utf-8', errors='strict')
描述
返回对象的 str 版本
参数
- object=''：需要转换成字符串的对象，默认是空字符串。
- object=b''：需要转换成字符串的对象，参数必须是一个类字节对象（如：bytes、bytearray），默认是空字节对象
- encoding：转换成字符串时使用的编码，默认编码是 utf-8
- errors：转换字符串时，设置报告错误的级别。参数必须是系统中定义的错误级别，默认为strict.
返回值
返回转换后的字符串
示例
>>> str('关于我转生变成史莱姆这档事')
'关于我转生变成史莱姆这档事'
>>> str([1,2,3,4,5])
'[1, 2, 3, 4, 5]'
>>> str(b'Angels of Death','utf-8')
'Angels of Death'
sum(iterable[, start])
描述
计算 iterabel 中所有元素和 start 的总和。iterable中的元素通常为数字，start 不可以为字符串。在有些实例中，sum()不是最优选择。如：连接字符串优先使用 ''.join(sequence)；对比较精准的浮点数进行计算优先使用math.fsum()；连接迭代器优先使用itertools.chain()
参数
- iterable：可迭代对象
- start：指定相加的参数，默认值为0
返回值
返回计算结果
示例
>>> sum([1,2,3])
6
>>> sum([1,2,3],4)
10
super([type[, object-or-type]])
描述
用于子类调取父类的方法。
参数
- type：类
- object-or-type：类，一般为self
示例
>>> class Base(object):
... def __init__(self):
... print("in base")
... print('out base')
...
>>> class A(Base):
... def __init__(self):
... print("in A")
... super().__init__()
... print("out A")
...
>>> class B(Base):
... def __init__(self):
... print("in B")
... super(B, self).__init__()
... print("out B")
...
>>> class C(A, B):
... def __init__(self):
... print("in C")
... super().__init__()
... print("out C")
>>> cc = C()
in C
in A
in B
in base
out base
out B
out A
out C
tuple([iterable])
描述
不是一个函数，而是一个不可变的序列类型。
参数
- 要转换成元组的可迭代对象
返回值
元组
示例
>>> tuple(range(5))
(0, 1, 2, 3, 4)
>>> tuple('python')
('p', 'y', 't', 'h', 'o', 'n')
>>> tuple(['a,','b','c','d'])
('a,', 'b', 'c', 'd')
class type(object)、class type(name, bases, dict)
描述
对于一个参数，返回对象的类型。返回值是一个类型对象，通常与object.__class__返回的对象相同。推荐使用isinstance()内置函数来测试对象的类型，因为它考虑了子类。对于三个参数返回新的类型对象。
参数
- object：需要进行判断的对象
- name：字符串形式的类名
- bases：元组形式的基类序列
- dict：类内定义的命名空间变量。（类属性、类方法等组成的字典）
返回值
一个参数返回对象的类型。三个参数，返回新的类型对象。
示例
# 一个参数
>>> type('python')
<class 'str'>
>>> type(1)
<class 'int'>
>>> type(range(5))
<class 'range'>
# 三个参数 B等价于A
>>> def bb(self):
... print(self.b)
...
>>> B = type('B',(object,),dict(b = 1, bb = bb))
>>> B
<class 'B'>
>>> bb = B()
>>> bb.b
1
>>> bb.bb()
1
>>> class A(object):
... def __init__(self):
... self.a = 1
... def aa(self):
... print(self.a)
...
>>> A
<class 'A'>
>>> aa = A()
>>> aa.a
1
>>> aa.aa()
1
vars([object])
描述
返回带有__dict__属性的模块、类、实例或任何其他对象的__dict__属性。
参数
对象
返回值
一个字典，对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。
示例
>>> class A(object):
... a = 1
... b = 2
... def __init__(self):
... self.c = 3
... self.d = 4
...
>>> vars(A)
mappingproxy({'__module__': 'builtins', 'a': 1, 'b': 2, '__init__': <function A.__init__ at 0x0456C108>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None})
>>> A.__dict__
mappingproxy({'__module__': 'builtins', 'a': 1, 'b': 2, '__init__': <function A.__init__ at 0x0456C108>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None})
>>> vars()
{'__builtins__': {'__name__': 'builtins', '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.", '__package__': '', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>), '__build_class__': <built-in function __build_class__>, '__import__': <bound method ImportHookManager.do_import of <module '_pydev_bundle.pydev_import_hook.import_hook'>>, 'abs': <built-in function abs>, 'all': <built-in function all>,
........省略...............
'license': See http://www.python.org/3.7/license.html, 'help': Type help() for interactive help, or help(object) for help about object., 'execfile': <function execfile at 0x044C5228>, 'runfile': <function runfile at 0x04520C00>, '_': None}, 'sys': <module 'sys' (built-in)>, 'A': <class 'A'>}
>>> locals()
{'__builtins__': {'__name__': 'builtins', '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.", '__package__': '', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>), '__build_class__': <built-in function __build_class__>, '__import__': <bound method ImportHookManager.do_import of <module '_pydev_bundle.pydev_import_hook.import_hook'>>, 'abs': <built-in function abs>, 'all': <built-in function all>,
.................省略.................
'license': See http://www.python.org/3.7/license.html, 'help': Type help() for interactive help, or help(object) for help about object., 'execfile': <function execfile at 0x044C5228>, 'runfile': <function runfile at 0x04520C00>, '_': None}, 'sys': <module 'sys' (built-in)>, 'A': <class 'A'>}
zip(*iterables)
描述
将可迭代的对象作为参数，将各个对象中对应索引位置的元素打包成一个个元组，然后返回由这些元组组成的对象。如果给定的可迭代对象长度不等，则以最短的迭代对象为准。
参数
一个或多个迭代器
返回值
返回一个zip对象
示例
>>> a = [1,2,3,4]
>>> b = (5,6,7,8)
>>> zip(a,b)
<zip object at 0x037A4760>
>>> list(zip(a,b))
[(1, 5), (2, 6), (3, 7), (4, 8)]
>>> c = [9,10,11,12,13,14]
>>> list(zip(a,c))
[(1, 9), (2, 10), (3, 11), (4, 12)]
>>> ab = zip(a,b)
>>> aa,bb = zip(*ab)
>>> aa,bb
((1, 2, 3, 4), (5, 6, 7, 8))
__import__(name, globals=None, locals=None, fromlist=(), level=0)
描述
用于动态的加载类和函数，只接收字符串作为参数，比如希望加载某个文件夹下的所有模块，但是其下面的模块又是会经常变化，这里就可以使用这个函数动态的加载所有模块了，常见的场景是插件功能的支持。import语句就是调用这个函数进行导入工作的，import os 等于 sys = import('sys')。
拓展
使用字符串动态的重载模块。
实现方法是先取消导入的模块然后在重新导入。利用 sys.modules 查看所有已经加载并成功的模块。然后利用 del sys.modules['模块名']。
a.py
#!/usr/bin/env python3
# * coding:utf-8 *
# Created by fjg on 2018/11/9import os
print("this is a.",id(os))
b.py
#!/usr/bin/env python3
# * coding:utf-8 *
# Created by fjg on 2018/11/9import sys
__import__('a')
print(sys.modules)
del sys.modules['a']
__import__('a')
执行结果
this is a. 52125440
{'sys': <module 'sys' (built-in)>,
.........省略..............
'a': <module 'a' from 'E:\\dev\\lye\\test\\a.py'>}
this is a. 52125440
参数
- name：字符串。模块名称
- globals：指定全局变量
- locals：指定局部变量
- fromlist：指定要导入的子模块或者对象的名称。
- level：指定时相对导入还是绝对导入。默认值为0
- 0：绝对导入
- > 0 ：大于0 的整数值，表示相对于 import() 当前目录向上搜索的父目录的数量。