python学习笔记_内置函数

一、和数字相关

1. 数据类型

bool(x)

bool('a');
bool();
bool(False);

True
False
False

int(x)

返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。

int(10)
int()

10
0

float(x)

返回从数字或字符串 x 生成的浮点数。

float(1)
float('1')
float(1.5)
float(-1.5)
float(1e3)
float(-1e3)
float(-1e-1)
float('-infinity')
float(-1.3343e2)

1.0
1.0
1.5
-1.5
1000.0
-1000.0
-0.1
-inf
-133.43

complex(x)

complex('1+2j')
(1+2j)
complex(3)
(3+0j)
complex(3,2)
(3+2j)

---

2.进制转换

bin(x)

将一个整数转变为一个前缀为“0b”的二进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的int 对象，那它需要定义 index() 方法返回一个整数。

bin(6) #bin('a')不能是字符类型

‘0b110’

oct(x)

将一个整数转变为一个前缀为“0o”的八进制字符串。

oct(8)
oct(57)

‘0o10’
‘0o71’

hex(x)

将整数转换为以“0x”为前缀的小写十六进制字符串。

hex(17)

‘0x11’

3.数学运算

abs(x)

返回一个数的绝对值。参数可以是一个整数或浮点数。如果参数是一个复数，则返回它的模。

abs(-1)
abs(2)
abs(1+1j)

1
2
1.4142135623730951

divmod(x,y)

它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。
返回数据类型：tuple

divmod(12,5)
divmod(11.5,5)
divmod(5.5,6)
divmod(-5.5,6)
divmod(-9,6)
divmod(9,-6)
divmod(-9,-6)

(2,2)
(2,1.5)
(0,5.5)
(-1.0, 0.5)
(-2, 3)
(-2, -3)
(1, -3)

round(number[, ndigits])

返回 number 舍入到小数点后 ndigits 位精度的值。如果 ndigits 被省略或为 None，则返回最接近输入值的整数。

round(4.5,2)
round(4.532,2)

4.5
4.53

pow(base, exp[, mod])

返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp)% mod 更高效）。

pow(2,2)
pow(2,-2)
pow(2,2,3)

4
0.25
1

sum(iterable, /, start=0)

从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。

sum([1,2,3])   #列表类型
sum(range(5))  #range类型
sum((1,2,3))   #元组类型
sum({1,2,3,4})   #集合类型

6
10
6
10

min(iterable, *[, key, default ])或min(arg1, arg2, *args[, key])

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。
如果只提供了一个位置参数，它必须是iterable，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。如 果 有 多 个 最 小 元 素， 则 此 函 数 将 返 回 第 一 个 找 到 的。

min([1,2,3,4])  #列表类型
min((1,2,4))  #元组类型
min({1,3,4,5})  #集合类型
min(range(4))  #range类型

1
1
1
0

max(iterable, *[, key, default ])或max(arg1, arg2, *args[, key])

返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。
如果只提供了一个位置参数，它必须是非空iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。如 果 有 多 个 最 大 元 素， 则 此 函 数 将 返 回 第 一 个 找 到 的。

max([1,2,3,4])  #列表类型
max((1,2,4))  #元组类型
max({1,3,4,5})  #集合类型
max(range(4))  #range类型

4
4
5
3

二、数据结构相关

（一）序列

1.列表和元组

list()

将一个可迭代对象转换成列表

list('string')
list((1,2,3,4))
list({'a':"c",'b':2})
list([1,2,3,4])

[‘s’, ‘t’, ‘r’, ‘i’, ‘n’, ‘g’]
[1, 2, 3, 4]
[‘a’, ‘b’]
[1, 2, 3, 4]

tuple()

将一个可迭代对象转换成元组

 tuple([1,2,3,4])
(1, 2, 3, 4)
 tuple('string')
('s', 't', 'r', 'i', 'n', 'g')
 tuple({'a':1,'b':2})
('a', 'b')

2.相关内置函数

reversed()

将一个序列翻转, 返回翻转序列的迭代器

a=[1,2,3,4]
b=reversed(a)
print(b)
print(list(b))
print(type(b))

<list_reverseiterator object at 0x0000000009019F48>
[4, 3, 2, 1]
<class ‘list_reverseiterator’>

a=[1,2,3,4]
b=reversed(a)
for i in b:
    print(i)

4
3
2
1

slice(stop)或slice(start,stop[,step])

返回一个表示由range(start, stop, step)所指定索引集的slice对象。

a=[1,2,3,4,5]
b=slice(0,6,)
c=slice(3)
print(b)
print(a[b])
print(a[c])
d=a[0:6:2]#此处是冒号，slice是逗号
print(d)
e=a[0:4]
print(e)

slice(0, 6, None)
[1, 2, 3, 4, 5]
[1, 2, 3]
[1, 3, 5]
[1, 2, 3, 4]

3.字符串

str(object=”)或str(object=b”, encoding=’utf-8’, errors=’strict’)

返回一个str 版本的 object 。

print(str('m'+'y'))
print(str('m')+'y')

my
my

format(value[, format_spec ])

将 value 转换为 format_spec 控制的“格式化”表示。

print(format(‘hello world!’,’^20’))
print(format(‘hello world!’,’>30’))
print(format(‘hello world!’,’<30’))
print(format(3,‘b’))
print(format(98,‘c’))
print(format(12,‘d’))
print(format(12,‘o’))
print(format(12,‘n’))
print(format(12,‘x’))
print(format(12,‘X’))
print(format(98))
print(format(13343,‘e’))
print(format(13343,‘E’))
print(format(13343,‘0.2e’))
print(format(13343,‘f’))
print(format(13343,‘0.2f’))
print(format(1.3343e+3,‘F’))

hello world!
hello world!
hello world!
11
b
12
14
12
c
C
98
1.334300e+04
1.334300E+04
1.33e+04
13343.000000
13343.00
1334.300000

bytes([source[,encoding[,errors]]])

返回一个新的“bytes”对象，是一个不可变序列，包含范围为 0 <= x < 256 的整数。

print(bytes('1dfggw/。/我/',encoding='utf-8'))

b’1dfggw/\xe3\x80\x82/\xe6\x88\x91/’

bytearray([source[,encoding[,errors]]])

返回一个新的 bytes 数组。

a=[1,2,3,4,5];
bytearray(a);
bytearray('acsdfalf',encoding ='utf-8');
bytearray(2);
a=bytearray('我/是/个/好/人',encoding='utf-8')
print(a)
for i in a:
    print(i)

bytearray(b’\x01\x02\x03\x04\x05’)
bytearray(b’acsdfalf’);
bytearray(b’\x00\x00’);
bytearray(b’\xe6\x88\x91/\xe6\x98\xaf/\xe4\xb8\xaa/\xe5\xa5\xbd/\xe4\xba\xba’)
230
136
145
47
230
152
175
47
228
184
170
47
229
165
189
47
228
186
186

ord(s)

对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。

ord('a');
97

chr(i)

返回 Unicode 码位为整数 i 的字符的字符串格式。

chr(97);
'a'

repr(object)

返回包含一个对象的可打印表示形式的字符串。

s='有\n没有%s个\t苹果！'%3
print(s)
print(repr(s))

有
没有3个 苹果！
‘有\n没有3个\t苹果！’

ascii(object)

就像函数repr()，返回一个对象可打印的字符串，但是repr() 返回的字符串中非 ASCII 编码的字符，会使用 \x、\u 和 \U 来转义。生成的字符串和 Python 2 的repr() 返回的结果相似。

print(ascii('d'))
print(ascii(1))
print(ascii(1+2j))

‘d’
1
(1+2j)

memoryview(obj)

返回由给定实参创建的“内存视图”对象。

a=bytes(10)
print(memoryview(a))

a=bytearray('tfdf',encoding='utf-8')
print(a)
k=memoryview(a)
print(k)
print(k[1])

a=bytes('sfdf',encoding='utf-8')
print(a)
t=memoryview(a)
print(t)
print(t[1])

<memory at 0x00000000004C9AC8>

bytearray(b’tfdf’)
<memory at 0x0000000002579AC8>
102

b’sfdf’
<memory at 0x0000000002539AC8>
102

（二）数据集合

1.字典和集合

dict()

返回一个新的字典。

print(dict([('a',1),('b',2)]))
print(dict({'a':1,'b':2}))
print(dict(zip(['a','b'],[1,2])))
print(dict(a=1,b=2))
d={'a':1,'b':2}
print(d)

{‘a’: 1, ‘b’: 2}
{‘a’: 1, ‘b’: 2}
{‘a’: 1, ‘b’: 2}
{‘a’: 1, ‘b’: 2}
{‘a’: 1, ‘b’: 2}

set([iterable])

返回一个新的set 对象，可以选择带有从 iterable 获取的元素。

print(set([1,2,3]))
print(set({1,2,3}))
print(set(range(10)))
print(set((1,2,3)))
print(set('mfk'))
print(set({'a':1,'b':2}))

{1, 2, 3}
{1, 2, 3}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3}
{‘f’, ‘k’, ‘m’}
{‘a’, ‘b’}

frozenset([iterable])

返回一个新的frozenset 对象，它包含可选参数 iterable 中的元素。

print(frozenset([1,2,3]))
print(frozenset({1,2,3}))
print(frozenset(range(10)))
print(frozenset((1,2,3)))
print(frozenset('mfk'))
print(frozenset({'a':1,'b':2}))

frozenset({1, 2, 3})
frozenset({1, 2, 3})
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
frozenset({1, 2, 3})
frozenset({‘m’, ‘f’, ‘k’})
frozenset({‘b’, ‘a’})

2. 相关内置函数

len(s)

返回对象的长度（元素个数）。

print(len('mfkd'))
print(len([1,2,3,4,5]))
print(len((6,7,8,9)))
print(len(range(10)))
print(len({'a','b'}))
print(len({'a':1,'b':2}))

4
5
4
10
2
2

sorted(iterable, *, key=None, reverse=False)

根据 iterable 中的项返回一个新的已排序列表。

print(sorted('dsfsd'))
print(sorted([1,4,2,6,3]))
print(sorted({'t','k','a','h'}))
print(sorted(range(10)))
print(sorted((4,2,6,3)))
print(sorted({'k':2,'f':1,'t':4}))
print(sorted([('john', 'A', 15), ('fane', 'B', 12), ('dave', 'B', 10)], reverse=False))
print(sorted({'t','k','a','h'},reverse=True))

[‘d’, ‘d’, ‘f’, ‘s’, ‘s’]
[1, 2, 3, 4, 6]
[‘a’, ‘h’, ‘k’, ‘t’]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 6]
[‘f’, ‘k’, ‘t’]
[(‘dave’, ‘B’, 10), (‘fane’, ‘B’, 12), (‘john’, ‘A’, 15)]
[‘t’, ‘k’, ‘h’, ‘a’]

enumerate(iterable, start=0)

返回一个枚举对象。 iterable 必须是一个序列，或iterator，或其他支持迭代的对象。

print(list(enumerate([1,2,3,4,5],2)))
print(list(enumerate({'a','b','c'},1)))
print(list(enumerate(range(10),1)))
print(list(enumerate('kdsfa',1)))
print(list(enumerate((1,2,3,4,5),2)))
print(list(enumerate({'a':2,'b':3},1)))

[(2, 1), (3, 2), (4, 3), (5, 4), (6, 5)]
[(1, ‘c’), (2, ‘a’), (3, ‘b’)]
[(1, 0), (2, 1), (3, 2), (4, 3), (5, 4), (6, 5), (7, 6), (8, 7), (9, 8), (10, 9)]
[(1, ‘k’), (2, ‘d’), (3, ‘s’), (4, ‘f’), (5, ‘a’)]
[(2, 1), (3, 2), (4, 3), (5, 4), (6, 5)]
[(1, ‘a’), (2, ‘b’)]

zip(*iterables)

创建一个聚合了来自每个可迭代对象中的元素的迭代器。zip() 与 * 运算符相结合可以用来拆解一个列表。

a=zip([1,2,3,4],[5,6,7,8],[8,10,11,12])
print(a)
print(list(a))
b=zip([1,2,3],[5,6,7,8],[8,10,11,12])
print(b)
print(list(b))

<zip object at 0x00000000029939C8>
[(1, 5, 8), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
<zip object at 0x000000000299ABC8>
[(1, 5, 8), (2, 6, 10), (3, 7, 11)]

print(*zip([1,2,3]))
print(*zip('mfd'))
print(*zip((4,5,6)))
print(*zip(range(10)))
print(*zip({'a','b','c'}))
print(*zip({'a':1,'b':2}))

(1,) (2,) (3,)
(‘m’,) (‘f’,) (‘d’,)
(4,) (5,) (6,)
(0,) (1,) (2,) (3,) (4,) (5,) (6,) (7,) (8,) (9,)
(‘a’,) (‘b’,) (‘c’,)
(‘a’,) (‘b’,)

all(iterable)

如果 iterable 的所有元素均为真值（或可迭代对象为空）则返回 True 。

a=[1,2,3]
print(all(a))
b=[]
print(all(b))
c=[True,False]
print(all(c))

True
True
False

any(iterable)

如果 iterable 的任一元素为真值则返回 True。如果可迭代对象为空，返回 False。

a=[1,2,3]
print(any(a))
b=[]
print(any(b))
c=[True,False]
print(any(c))

True
False
True

filter(function, iterable)

用 iterable 中函数 function 返回真的那些元素，构建一个新的迭代器。 iterable 可以是一个序列，一个支持迭代的容器，或一个迭代器。如果 function 是 None ，则会假设它是一个身份函数，即iterable中所有返回假的元素会被移除。

def is_odd(n):
    return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
print(list(newlist))

<filter object at 0x0000000002943B08>
[1, 3, 5, 7, 9]

map(function, iterable, …)

返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。

def is_odd(n):
    return n % 2 == 1
newlist = map(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
print(list(newlist))

<map object at 0x0000000002963B08>
[True, False, True, False, True, False, True, False, True, False]

三、和作用域相关

locals()

更新并返回表示当前本地符号表的字典。在函数代码块但不是类代码块中调用locals() 时将返回自由变量。

globals()

返回表示当前全局符号表的字典。这总是当前模块的字典（在函数或方法中，不是调用它的模块，而是定义它的模块）。

def func():
    a=10
    print(locals())
    print(globals())
    print('这样的结果你想到了吗？')
func()

{‘a’: 10}
{‘name’: ‘main’, ‘doc’: ‘Automatically created module for IPython interactive environment’, ‘package’: None, ‘loader’: None, ‘spec’: None, ‘builtin’: <module ‘builtins’ (built-in)>, ‘builtins’: <module ‘builtins’ (built-in)>, ‘_ih’: [’’, “def func():\n a=10\n print(locals())\n print(globals())\n print(‘这样的结果你想到了吗？’)”, “def func():\n a=10\n print(locals())\n print(globals())\n print(‘这样的结果你想到了吗？’)\nfunc()”, “def func():\n a=10\n print(locals())\n print(’------------------’)\n print(globals())\n print(‘这样的结果你想到了吗？’)\nfunc()”, “def func():\n a=10\n print(locals())\n print(’------------------’)\n print(globals())\n print(’------------------’)\n print(‘这样的结果你想到了吗？’)\nfunc()”, “def func():\n a=10\n print(locals())\n print(globals())\n print(‘这样的结果你想到了吗？’)\nfunc()”], ‘oh’: {}, ‘dh’: [‘C:\Users\Administrator’], ‘In’: [’’, “def func():\n a=10\n print(locals())\n print(globals())\n print(‘这样的结果你想到了吗？’)”, “def func():\n a=10\n print(locals())\n print(globals())\n print(‘这样的结果你想到了吗？’)\nfunc()”, “def func():\n a=10\n print(locals())\n print(’------------------’)\n print(globals())\n print(‘这样的结果你想到了吗？’)\nfunc()”, “def func():\n a=10\n print(locals())\n print(’------------------’)\n print(globals())\n print(’------------------’)\n print(‘这样的结果你想到了吗？’)\nfunc()”, “def func():\n a=10\n print(locals())\n print(globals())\n print(‘这样的结果你想到了吗？’)\nfunc()”], ‘Out’: {}, ‘get_ipython’: <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x0323E610>>, ‘exit’: <IPython.core.autocall.ZMQExitAutocall object at 0x033673A0>, ‘quit’: <IPython.core.autocall.ZMQExitAutocall object at 0x033673A0>, '’: ‘’, '’: ‘’, '’: ‘’, ‘_i’: “def func():\n a=10\n print(locals())\n print(’------------------’)\n print(globals())\n print(’------------------’)\n print(‘这样的结果你想到了吗？’)\nfunc()”, ‘_ii’: “def func():\n a=10\n print(locals())\n print(’------------------’)\n print(globals())\n print(‘这样的结果你想到了吗？’)\nfunc()”, ‘_iii’: “def func():\n a=10\n print(locals())\n print(globals())\n print(‘这样的结果你想到了吗？’)\nfunc()”, ‘_i1’: “def func():\n a=10\n print(locals())\n print(globals())\n print(‘这样的结果你想到了吗？’)”, ‘func’: <function func at 0x05411898>, ‘_i2’: “def func():\n a=10\n print(locals())\n print(globals())\n print(‘这样的结果你想到了吗？’)\nfunc()”, ‘_i3’: “def func():\n a=10\n print(locals())\n print(’------------------’)\n print(globals())\n print(‘这样的结果你想到了吗？’)\nfunc()”, ‘_i4’: “def func():\n a=10\n print(locals())\n print(’------------------’)\n print(globals())\n print(’------------------’)\n print(‘这样的结果你想到了吗？’)\nfunc()”, ‘_i5’: “def func():\n a=10\n print(locals())\n print(globals())\n print(‘这样的结果你想到了吗？’)\nfunc()”}
这样的结果你想到了吗？

四、迭代器生成器相关

range(stop)或range(start, stop[, step])

虽然被称为函数，但range 实际上是一个不可变的序列类型。

print(range(4))
print(list(range(4)))
print(list(range(1,5,2)))

range(0, 4)
[0, 1, 2, 3]
[1, 3]

next(iterator[, default ])

通过调用 iterator 的__next__() 方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发StopIteration。

t=iter([1,2,3,4])
while True:
    try:
        x=next(t)
        print(x)
    except StopIteration:
        break

1
2
3
4

iter(object[, sentinel])

返回一个iterator 对象。

a=iter([1,2,3,4,5])
print(a)
for i in a:
    print(i)
b=[1,2,3,4,5]
for t in b:
    print(t)

<list_iterator object at 0x00000000025CA0C8>
1
2
3
4
5
1
2
3
4
5

五、字符串类型代码的执行

eval(expression[, globals[, locals]])

实参是一个字符串，以及可选的 globals 和 locals。 globals 实参必须是一个字典。 locals 可以是任何映射对象。

x=7
print(eval('2*x'))
print(eval('2+3'))
print(eval("pow(2,2)"))

14
5
4

exec(object[, globals[, locals]])

这个函数支持动态执行 Python 代码。 object 必须是字符串或者代码对象。如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。1 如果是代码对象，它将被直接执行。在任何情况下，被执行的代码都需要和文件输入一样是有效的。请注意即使在传递给exec() 函数的代码的上下文中， return 和 yield 语句也不能在函数定义之外使用。该函数返回值是 None 。

exec("print('hello world')")
exec("""for i in range(4):
    print(i)
     """)
x=20
exr="""
z=50
sum=x+y+z
print(sum)"""
def func():
    y=10
    exec(exr,{'x':1,'y':2})
    exec(exr,{'x':2,'y':2},{'y':4,'z':4})
    exec(exr,{'x':2},{'y':4})
    exec(exr,{'x':2},{'y':4,'z':4})
func()

hello world
0
1
2
3
53
56
56
56

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

将 source 编译成代码或 AST 对象。

str = "for i in range(0,4): print(i)"
c=compile(str,'','exec')
print(c)
exec(c)

<code object at 0x00000000028F0ED0, file “”, line 1>
0
1
2
3

六、输入输出

print(*objects, sep=’ ’, end=’\n’, file=sys.stdout, flush=False)

将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上end。 sep, end, file 和 flush 如果存在，它们必须以关键字参数的形式给出。

print('www','baidu','com',sep='.',end='\n')
print('www','baidu','com',sep='.')
import time
print("---RUNOOB EXAMPLE ： Loading 效果---")
print("Loading",end ="")
for i in range(20):
    print(".",end = '',flush = True)
    time.sleep(0.5)

www.baidu.com
www.baidu.com
—RUNOOB EXAMPLE ： Loading 效果—
Loading…

input([prompt ])

如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发EOFError。

a=input('请输入一个字符：')
print(a)

请输入一个字符：d
d

七、内存相关

hash(object)

返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。

print(hash(1))
print(hash(1.0))
print(hash(str))

1
1
549450500069

id(object)

返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的id() 值。

print(id('wo'))

36219184

八、文件操作相关

open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True,opener=None)

打开 file 并返回对应的file object。如果该文件不能打开，则触发OSError。

f=open(r'E:\python.txt','r',encoding='UTF-8')
print(f)
k=f.read()
print(k)
f.close()

<_io.TextIOWrapper name=‘E:\python.txt’ mode=‘r’ encoding=‘UTF-8’>
这个文件能打开看吗？

with open(r'E:\python.txt','r',encoding='UTF-8') as f:
    print(f)
    k=f.read()
    print(k)

<_io.TextIOWrapper name=‘E:\python.txt’ mode=‘r’ encoding=‘UTF-8’>
这个文件能打开看吗？

九、模块相关

import(name, globals=None, locals=None, fromlist=(), level=0)import os

此函数会由 import 语句发起调用。

import os
name=input('请输入模块的名称：')
__import__(name)

请输入模块的名称：pandas

十、帮助相关

help([object ])

启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

help('pandas')
help(23)
help('a')

十一、调用相关

callable(object)

如果参数 object 是可调用的就返回True，否则返回False。如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 将肯定不会成功。

print(callable(str))
print(callable('a'))
print(callable(3))

True
False
False

十二、查看内置属性

dir([object ])

如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。

print(dir())
print(dir(str))

[‘annotations’, ‘builtins’, ‘cached’, ‘doc’, ‘file’, ‘loader’, ‘name’, ‘package’, ‘spec’]
[‘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’, ‘casefold’, ‘center’, ‘count’, ‘encode’, ‘endswith’, ‘expandtabs’, ‘find’, ‘format’, ‘format_map’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isascii’, ‘isdecimal’, ‘isdigit’, ‘isidentifier’, ‘islower’, ‘isnumeric’, ‘isprintable’, ‘isspace’, ‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘maketrans’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’, ‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’, ‘title’, ‘translate’, ‘upper’, ‘zfill’]

十三、面向对象相关

（一）定义特殊方法的装饰器

@classmethod

把一个方法封装成类方法。一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。

class A(object):
    bar = 1
    def func1(self):
        print ('foo')
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)   #cls表示类自身，但需在classmethod之后使用
        cls().func1()   # 调用 foo 方法
A.func2()

func2
1
foo

@staticmethod

将方法转换为静态方法。静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法

class C:
@staticmethod
def f(arg1, arg2, ...): ...

class C(object):
    @staticmethod
    def f():
        print('runoob')


C.f()  #静态方法无需实例化
cobj = C()
cobj.f()  #也可以实例化后调用

runoob
runoob

注：decorator – 装饰器

返回值为另一个函数的函数，通常使用 @wrapper 语法形式来进行函数变换。装饰器的常见例子包括classmethod() 和staticmethod()。同的样概念也适用于类，但通常较少这样使用。装饰器语法只是一种语法糖，以下两个函数定义在语义上完全等价:

def f(...):
...
f = staticmethod(f)
@staticmethod
def f(...):
...

class property(fget=None, fset=None, fdel=None, doc=None)

返回 property 属性。fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc为属性对象创建文档字符串。

（二）判断对象/类与类间的关系

isinstance(object, classinfo)

如果参数 object 是参数 classinfo 的实例或者是其 (直接、间接或虚拟) 子类则返回 True。如果 object不是给定类型的对象，函数将总是返回 False。

a=2
print(isinstance(a,int))
print(isinstance(a,str))
print(isinstance(a,(int,str,list)))  #是元组中的一个返回True

True
False
True

issubclass(class, classinfo)

如果 class 是 classinfo 的 (直接、间接或虚拟) 子类则返回 True。类会被视作其自身的子类。 classinfo也以是类对象的元组，在此情况下 classinfo 中的每个条目都将被检查。在任何其他情况下，都将引发TypeError 异常。

class A:
    pass
class B(A):
    pass
print(issubclass(B,A))
print(issubclass(A,B))

True
False

（三）数据类型

class type(name, bases, dict)

传入一个参数时，返回 object 的类型。

a=2
print(type(a))
b=[1,2,3,4]
print(type(b))

<class ‘int’>
<class ‘list’>

（四）所有类的基类

class object

返回一个没有特征的新对象。 object 是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。

（五）封装

vars([object ])

返回模块、类、实例或任何其它具有__dict__ 属性的对象的__dict__ 属性。

print(vars())
class Adf:
    a=1
print(vars(Adf))
adf=Adf()
print(vars(adf))

{‘name’: ‘main’, ‘doc’: None, ‘package’: None, ‘loader’: <_frozen_importlib_external.SourceFileLoader object at 0x000000000059B9C8>, ‘spec’: None, ‘annotations’: {}, ‘builtins’: <module ‘builtins’ (built-in)>, ‘file’: ‘E:/project/built-in-function.py’, ‘cached’: None}

{‘module’: ‘main’, ‘a’: 1, ‘dict’: <attribute ‘dict’ of ‘Adf’ objects>, ‘weakref’: <attribute ‘weakref’ of ‘Adf’ objects>, ‘doc’: None}

{}

（六）继承

super([type[, object-or-type]])

返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。

class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print('Parent')

    def bar(self, message):
        print("%s from Parent" % message)


class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象
        super(FooChild, self).__init__()
        print('Child')

    def bar(self, message):
        super(FooChild, self).bar(message)
        print('Child bar fuction')
        print(self.parent)


if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')

Parent
Child
HelloWorld from Parent
Child bar fuction
I’m the parent.

十四、反射相关

delattr(object, name)

setattr() 相关的函数。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。

getattr(object, name[, default ])

返回对象命名属性的值。 name 必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。

hasattr(object, name)

该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回False。

setattr(object, name, value)

此函数与getattr() 两相对应。其参数为一个对象、一个字符串和一个任意值。字符串指定一个现有属性或者新增属性。函数会将值赋给该属性，只要对象允许这种操作。

class Abds:
    a=1
    b=2
abds=Abds()
print(hasattr(abds,'a'))
print(getattr(abds,'a'))
setattr(abds,'a',3)
print(getattr(abds,'a'))

True
1
3

class Abds:
    a=1
    b=2
abds=Abds()
delattr(abds,'b')
print(hasattr(abds,'b'))

Traceback (most recent call last):
File “E:/project/built-in-function.py”, line 5, in
delattr(abds,‘b’)
AttributeError: b

十五、调试相关

breakpoint(*args, **kws)

此函数会在调用时将你陷入调试器中。

a = 2
b = 3
if (a + b == 5):
    breakpoint()
    print('sum is 5')

e:\project\built-in-function.py(5)()
-> print(‘sum is 5’)
(Pdb)