文章很长，差几百到3w字，每个方法都包括进去了，建议使用电脑阅读，点击方法名即可跳转至对应位置。
说实话有些几乎用不到的方法小编也忘了，为了写好这篇blog，专门去翻了Python官方的英文文档，相当于让自己再巩固巩固基础知识吧，同时也希望能帮助到某些小伙伴。
Python3中69个内置方法：
从上往下，从左到右，按字母顺序排序。
1、abs(x) 方法
作用：返回一个数字的绝对值。参数可以是整数或浮点数，如果参数是复数，则返回ITSMAGNUDE。正数的绝对值等于本身，负数的绝对值等于其相反数，0的绝对值是0。
# abs() Sample
a = 1 # 给变量a赋值1
b = -1 # 给变量b赋值-1
print(a) # 打印出变量a的值
print(b) # 打印出变量b的值
m = abs(a) # 用abs(）方法求变量a的绝对值，并将绝对值赋给变量m
n = abs(b) # 用abs(）方法求变量b的绝对值，并将绝对值赋给变量n
print(m) # 打印出变量m的值
print(n) # 打印出变量n的值
2、all(iterable) 方法
作用：如果参数中所有可迭代的元素为真（或者如果迭代为空），则返回True，否则返回False。
注意：数字0不为真，所以如果迭代元素中包含了数字0那么结果为False。all()方法传入的参数必须是可迭代对象（iterable），可迭代对象是指可以直接作用于for循环的对象。可以直接作用于for循环的数据类型有以下几种：一类是集合数据类型，如list、tuple、dict、set、str等；一类是生成器（generator）：包括生成器和带yield的生成器函数（generator function）。可以使用isinstance()判断一个对象是否是Iterable对象。
# all() Sample
print(all('')) # 参数是空字符串，返回True
print(all('这是字符串类型')) # 参数是字符串，是可迭代对象，且都为真，返回True
print(all(())) # 参数是空元组，返回True
print(all((1, 2, 3))) # 参数是元组，返回True
print(all((0, 1, 2, 3))) # 参数是包含0元素的元组，返回False
print(all([])) # 参数是空列表，返回True
print(all([1, 2, 3])) # 参数是列表，返回True
print(all([0, 1, 2, 3])) # 参数是包含0元素的列表，返回False
3、any(iterable) 方法
作用：参数中只要有任何一个可迭代的元素为真，就返回True。如果迭代是空的（空字符串，空元组，空列表等），则返回False。
# any() Sample
print(any('')) # 参数是空字符串，返回False
print(any('这是字符串类型')) # 参数是非空字符串，返回True
print(any(())) # 参数是空元组，返回False
print(any((1, 2, 3))) # 参数是元组，且迭代元素都为真，返回True
print(any((0, 1, 2, 3))) # 参数是元组，且包含为真的元素(非0)，返回True
print(any([])) # 参数是空列表，返回False
print(any([1, 2, 3])) # 参数是列表，且迭代元素都为真，返回True
print(any([0, 1, 2, 3])) # 参数是包含0元素的列表，且包含为真的元素(非0)，返回True
4、ascii() 方法
作用：像repr()方法一样，返回对象的可打印的字符串的形式，但在返回非ascci码字符(比如汉字)时会通过repr()方法使用 \x ,\u 或 \U 进行转换。生成的字符串类似于Python 2中的repr()方法。
# ascii() Sample
# 传入参数对象是一个列表，ascii将返回他的字符串表示
a = ascii(['Python520，我爱 Python']) # 包含中文，是非ascii字符，所以会使用\x ,\u或\U进行转换
print(type(a)) # 打印列表通过ascii()方法转换后的数据类型，变为字符串类型
print(a) # 打印通过ascii()方法返回的字符串
5、bin(x) 方法
作用：
将整数转换为以“0b”为前缀的二进制字符串，说简单点就是将数据转换成二进制。结果是一个有效的Python表达式。如果传入的参数x不是Python整型对象，它会定义一个返回整数的__index__()方法。
如果不希望转换结果中包含‘0b’前缀，可以用format()方法，下面代码有示例。
# bin(int_number) Sample
t = bin(3) # 将3转换成二进制并赋给变量t
print(t) # 打印3的二进制：0b11
print(bin(-20)) # 打印-20的二进制：-0b10100
print(bin(520)) # 打印520的二进制：0b1000001000
# 二进制其它转换方式，可以选择是否保留'0b'前缀
m1 = format(520, '#b') # 结果与bin()一样，有'0b'前缀
print(m1) # 打印结果：0b1000001000
m2 = format(520, 'b') # 结果无'0b'前缀，纯01序列
print(m2) # 打印结果：1000001000
n1 = f'{520:#b}' # 结果与bin()一样，有'0b'前缀
print(n1) # 打印结果：0b1000001000
n2 = f'{520:b}' # 结果无'0b'前缀，纯01序列
print(n2) # 打印结果：1000001000
6、bool(x) 方法
作用：返回布尔值，即True或Flase 。 如果x为假或空类型，则返回False，否则返回True。
这个bool类是int型的一个子类，不能再细分( 详见Numeric Types — int, float, complex）。它的唯一实例是False和True（详见Bool-Value）。
# bool() Sample
print(bool(0)) # 0的布尔值，False
print(bool(1)) # 1的布尔值，True
print(bool('')) # 空字符串的布尔值，False
print(bool('我爱Python')) # 非空字符串的布尔值，True
print(bool(())) # 空元组的布尔值，False
print(bool((1,'IlovePython'))) # 非空元组的布尔值，True
print(bool([])) # 空列表的布尔值，False
print(bool([1,'1','Python'])) # 非空列表的布尔值，True
7、breakpoint(*args,**kwargs) 方法
作用：breakpoint() 是 Python 3.7 中新增加的内置函数。在未设置 PythonBREAKPOINT 的情况下，breakpoint() 会中断当前程序并进入 pdb 调试器。
# breakpoint() Sample,In builtins
def breakpoint(*args, **kws):
import sys
missing = object()
# 设置钩子函数
hook = getattr(sys, 'breakpointhook', missing)
if hook is missing:
raise RuntimeError('lost sys.breakpointhook')
# 返回钩子函数的调用
return hook(*args, **kws)
# 可见breakpoint的工作仅是设置并调用hook函数，这里只需要注意以下几点：
# breakpoint 中的 hook 变量将引用 sys.breakpointhook 函数对象；
# breakpoint 会将自己所有的实参都传递给 sys.breakpointhook()；
# 如果 sys.breakpointhook 缺失，则会抛出 RuntimeError
关于breakpoint()更详细的解析请参考：breakpoint() <Python 内置函数>
8、bytearray() 方法
作用：返回一个新的字节数组（可变的字节序列），这个数组里的元素是可变的，可以进行增删改操作，并且每个元素的值范围: 0 <= x < 256。参数如果是字符串你必须声明编码方式（如endcoding=‘utf-8’）。
bytearry(source,encoding=’’,errors) 参数说明
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。
众所周知，字符串定义后是不可修改的，但可以利用bytearry()方法将字符串返回成字节数组，然后通过索引下标以ascii码的方式修改。
bytearray为可变序列，因此可以进行可变序列的增删改操作：
appende（int） ：增加操作，提供一个int型常量，根据ASCII码转换为对应的bytes。
insert(index,int)：插入操作，与append一样，提供int。
extend(iterable_of_ints)：追加iterable，iterable内部为int。
pop(index=-1)：通过索引删除。
remove(value)通过值删除。
clear()：清空。
reverse()：转置 。
# bytearry() Sample
a = 'abcdABCD'
b = bytearray(a, encoding='utf-8') # 用bytearry()将字符串a返回给b
print(b) # 打印b：bytearray(b'abcdABCD')
for i in b:
print(i) # 遍历输出发现，输出的是每个字符的ascii编码
b[0]=65 # 通过索引，用ascii码修改b，65对应字母A
b[1]=66 # 通过索引，用ascii码修改b，65对应字母B
print(b) # 打印修改后的b：bytearray(b'ABcdABCD')
参考：
bytes()和bytearray()的用法详解
python bytes和bytearray、编码和解码
9、bytes() 方法
作用：它是 bytearray 的不可变版本。bytes()返回不可变的字节序列 ，是不可变的二进制格式字节数据，(注意，是字节不是字符)，以 0 <= x < 256 区间内的整数方式表示。例如对于ascii范围内的字符"a"，它存储为97。
用法：
bytes（）定义一个空bytes，一般情况下没有什么用
bytes（int）指定字节的bytes，被0填充。定义长度
bytes（iterable of ints）定义内容，如bytes（range（5））iterable为整型序列，否则报错
bytes(bytes or buffer)将bytes或buffer转换为bytes
bytes（string，encoding[,errors]）要指定encoding，如：
bytes（‘abc’，‘utf-8’）encoding为utf-8
或者：bytes（b’abc’）b默认encoding为utf-8
操作：
bytes()的操作和str(字符串)相似，区别是bytes方法输入输出都是bytes(字节):
（1）replace替换
b’abcdef’.replace(b’f’,b’k’)将f替换成k，返回一个bytes
（2）find查找
b’abc’.find(b’b’)查找b，返回位置索引
（3）类方法：bytes.fromhex(string)
string为2个字符的16进制形式，如’6162 6a 6b00’空格被自动删除
（4）hex（）返回16进制表示的字符串
‘abc’.encode().hex() => ’\x61\x62\x63’
# bytes() Sample
a = bytes([1,2,3,4])
print(a) # 打印结果：b'\x01\x02\x03\x04'
10、callable() 方法
作用：判断对象是否可调用，并返回布尔值，可调用为True，不可调用为False。比如定义了一个函数，函数是可调用的，而一个列表是不可调用的。
小技巧：想要使用一个对象时，如果它后面需要加 ‘()’ 则它是可调用的，比如调用一个函数，函数名后面是带有括号的；想引用一个列表，直接使用存储该列表的变量名就可以了，列表变量名后面是没有括号的。
# callable() Sample
a = [1,2,3] # a是一个列表
def sumb(m,n): # sumb是一个函数
return m+n
print(callable(sum)) # 判断sumb是否是可调用的，结果为True
print(callable(a)) # 判断a是否是可调用的，结果为False
11、chr() 方法
作用：返回Unicode编码中为整数或特殊符号的字符串。传入的参数为整数。
例如，chr(97)返回字符串“A”，chr(98)返回字符串“B”，chr(65)返回字符串“a”，chr(8364)返回字符串“€”(欧元符号)。
chr() 方法作用与 ord() 方法是相反的。
对ascii、Unicode、utf-8等编码有疑问的可以参考：
ASCII、GB2312、GBK、GB18030、Unicode、UTF-8、BIG5 编码分析详解(全网最全)
# chr（） Sample
print(chr(65)) # 打印出字母A
print(chr(90)) # 打印出字母Z
print(chr(97)) # 打印出字母a
print(chr(98)) # 打印出字母b
print(chr(8364)) # 打印出欧元符号€
for i in range(255):
print(chr(i)) # 循环打印前256(0-255)个Unicode码表示的字符
12、classmethod() 方法
作用：classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
# classmethod() Sample
class sumb(object):
bar = 1
def func1(self):
print ('i am fun1')
@classmethod
def func2(cls):
print ('i am func2')
print (cls.bar)
cls().func1() # 调用 func1 方法
sumb.func2() # 不需要实例化
13、compile() 方法
作用：将一个字符串编译为字节代码。
compile(source,fliename,mode,flags) 方法参数说明
source – 字符串或者AST（Abstract Syntax Trees）对象。。
filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode – 指定编译代码的种类。可以指定为 exec, eval, single。
flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志
# compie() Sample
a = "for i in range(1,100): print(i)" # 将代码定义为字符串
# 用compile()对字符串中的代码进行编译，mode为exec(可执行）
b = compile(a,'','exec')
print(b) # 打印编译后的文件内容
print(exec(b)) # 执行编译过的程序
14、complex(real,img) 方法
作用：用于创建一个复数，第一个参数real为实部，第二个参数img为虚部；也可以转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
# complex() Sample
print(complex(1)) # 实部传入一个整数参数1，转换为复数(1+0j)
print(complex(1,2)) # 实部参数1，虚部参数2，转换为复数(1+2j)
print(complex(1.1)) # 实部传入一个浮点数参数1。1，转换为复数(1.1+0j)
print(complex('1')) # 实部传入一个字符串'1',转换为复数(1+0j)
print(complex('1+2j')) # 实部传入一个字符串'1+2j',转换为复数(1+2j)
15、delattr() 方法
作用：删除某个对象的属性。
delattr(obj,name) 参数说明
obj，对象的名字
name，对象中要删除的属性名
# delattr() Sample
class test:
x = 1
y = 2
z = 3
print('x = ', test.x) # 程序正常
print('y = ', test.y) # 程序正常
print('z = ', test.z) # 程序正常
delattr(test, 'z') # 用delattr()方法删除test中的'z'属性
print('x = ', test.x) # 程序正常
print('y = ', test.y) # 程序正常
print('z = ', test.z) # 触发错误，因为'z'属性已经被删除
# AttributeError: type object 'test' has no attribute 'z'
16、dict() 方法
作用：创建一个字典。一共有三种方式。
# dict() Sample
a = dict() # 创建空字典
print(a) # {}
# 方式1：通过传入键值对创建字典：
b = dict(小明='男',小红='女')
print(b) # {'小明': '男', '小红': '女'}
# 方式2：通过iterate可迭代对象创建字典：
c = dict([('小明','男'),('小红','女'),('我爱','Python')])
print(c) # {'小明': '男', '小红': '女', '我爱': 'Python'}
# 方式3：通过zip()函数映射创建字典：
d = dict(zip(['小明','小红','大家都爱'],['男','女','Python']))
print(d) # {'小明': '男', '小红': '女', '大家都爱': 'Python'}
17、dir() 方法
作用：返回属性、方法名、变量名等。分带参数和不带参数两种情况。
# dir() Sample
print(dir()) # 无参数，打印当前模块中的变量名、方法命
string = '我爱Py' # 定义一个字符串
print(dir(string)) # 有参数，打印字符串下可使用的内部方法
list = [1,2] # 定义一个列表
print(dir(list)) # 有参数，打印列表下可使用的方法
18、divmod() 方法
作用：传输两个参数：被除数和除数，返回一个包含两个数据（分别是商和余数）的元组。参数可以是整数或浮点数，不能是复数。
# divmod() Sample
a = divmod(4, 2) # 被除数4，除数2
print(a) # 打印结果：(2, 0) 商为2，余数为0
b = divmod(1, 3) # 被除数1，除数3
print(b) # 打印结果：(0, 1) 商为0，余数为1
c = divmod(3.0, 2) # 被除数3.0 ，除数2
print(c) # 打印结果：(1.0, 1.0) 商为1.0 ，余数为1.0
d = divmod(3, 2.0) # 被除数3 ，除数2.0
print(d) # 打印结果：(1.0, 1.0) 商为1.0，余数为1.0
e = divmod(3, 1.2) # 被除数3，除数 1.2
print(e) # 打印结果：(2.0, 0.6000000000000001) 商为2.0，余数为0.6000000000000001)
19、enumerate() 方法
作用：给可迭代对象添加索引序列，默认序列默认从0开始，初始值也可以指定，一般用于for循环。也可利用其统计文件行数。
# enumerate Sample
a = ['小明', '小红', '小曹'] # 定义a为一个列表
# 用法1: 默认序列号
for i in enumerate(a):
print(i)
"""
打印结果为：
(0, '小明')
(1, '小红')
(2, '小曹')
"""
# 用法2：指定序列初始值
for j in enumerate(a, 666): # 指定序列开始值为666
print(j)
"""
打印结果为：
(666, '小明')
(667, '小红')
(668, '小曹')
"""
# 用法3：迭代输出enumerate中的内容
for index,values in enumerate(a, 1):
print(index,values)
"""
打印结果为：
1 小明
2 小红
3 小曹
"""
# 用法4：统计某文件行数,filepath为文件路径
count = 0
for index, line in enumerate(open(filepath,'r')):
count += 1
print(count)
20、eval() 方法
作用：执行一个字符串格式的表达式或函数，并返回值。
# eval() Sample
# 用法1：直接计算表达式
a = eval('3+2')
print(a) # 结果：5
# 用法2：执行函数
def test2():
for i in range(5):
print('eval()的用法2')
b = eval('test2()')
print(b) # 结果：打印了5行'eval()的用法2'
21、exec() 方法
作用：与eval()相似，还可以执行字符串形式的Python语句包括文件中的代码语句。
# exec() Sample
# 执行字符串形式的Python语句：
exec('print("exec的使用")')
# 结果：打印出了'exec的使用'
exec('for i in range(10):print("exec%d" %i)')
# 结果：打印出exec0、exec1、....、exec9
# 执行字符串格式的函数：
def add1(): # 定义一个函数
a = 520
b = 1314
print(a+b)
exec('add1()') # 结果：打印出1834
22、fliter(function,inter) 方法
作用：用于过滤掉一组数据中不符合条件的数据，然后返回一个迭代器对象，可以用list()转化为列表。它需要接收两个参数，一个是判断条件的函数，一个是一组可迭代的数据。
# fliter() Sample
def abs1(n):
return abs(n) >= 5 # 返回绝对值大于等于5的数
filter1 = filter(abs1,range(-10,10)) # 过滤-10-10中绝对值小于5的数
list1 = list(filter1)
print(list1) # 结果：[-10, -9, -8, -7, -6, -5, 5, 6, 7, 8, 9]
23、float() 方法
作用：可以将整数或字符串形式的数转换成浮点数。
# float() Sample
# 转换整数：
print(float(520)) # 结果：520.0
# 转换字符串数：
print(float('1314')) # 结果：1314.0
24、format() 方法
作用：format可以对字符串或数字进行格式化操作。主要通过‘{ }’和‘ : ’来控制，它可以接受多个参数，且参数位置可以不按顺序。可以用大括号来转义大括号。
# format() Sample 对字符串格式化
# 大括号为空，不指定位置：
sample = "{}{}".format('你好','世界')
print(sample) # 结果：你好世界
# 大括号中通过索引序号指定位置：
sample = "{0}{1}".format('你好', '世界') # '你好'索引为0，'世界'索引为1
print(sample) # 结果：你好世界
sample = "{1}{0}".format('你好','世界')
print(sample) # 结果：世界你好
sample = "{1}{0}{0}{1}{1}{0}".format('你好','世界')
print(sample) # 结果：世界你好你好世界世界你好
# format带参数
# format直接带参数：
sample = "姓名:{name},爱好1:{lover}".format(name='小曹',lover='亚亚')
print(sample) # 结果：姓名：小曹，爱好1：亚亚
# 通过字典设置参数：
dic1 = {'name': '小曹', 'lover': '学Python'}
sample = '姓名：{name}, 爱好2：{lover}'.format(**dic1)
print(sample) # 结果：姓名：小曹, 爱好2：学Python
# 通过列表设置参数：
list1 = ['小曹', '写blog']
sample = "姓名：{0[0]}，爱好3：{0[1]}".format(list1) # 列表索引前必须加'0'
print(sample) # 结果：姓名：小曹，爱好3：写blog
# format() Sample 对数字格式化
a = 13.14520
b = 666
c = 1234567890
# 保留后两位(四舍五入):
print("{:.2f}".format(a)) # 结果：3.15
# 带符号位且保留后两位:
print("{:+.2f}".format(a)) # 结果：+3.15
print("{:+.2f}".format(-a)) # 结果：-3.15
# 保留整数:
print("{:.0f}".format(a)) # 结果：13
# 数字宽度为10，用0左填充:
print("{:0>10d}".format(b)) # 结果：0000000666
# 数字宽度为10，用1右填充:
print("{:1<10d}".format(b)) # 结果：6661111111
# 千分计数法，逗号分隔：
print("{:,}".format(c)) # 结果：1,234,567,890
# 百分比格式：
print("{:.3%}".format(a)) # 结果：1314.520%
# 指数e计数法：
print("{:.2e}".format(b)) # 结果：6.66e+02
# 数字宽度为10，左对齐：
print("{:<10d}".format(b)) # 结果：666(后面7个空格）
# 数字宽度为10，右对齐：
print("{:>10d}".format(b)) # 结果： 666（最前面7个空格）
# 数字宽度为10，中间对齐：
print("{:^10d}".format(b)) # 结果： 666 (前面3个空，后面4个空)
# 输出二进制格式：
print("{:b}".format(b)) # 结果：1010011010
# 输出为八进制：
print("{:o}".format(b)) # 结果：1232
# 16进制：
print("{:x}".format(b)) # 结果：29a
# 带‘0xb’前缀的16进制：
print("{:#x}".format(b)) # 结果：0x29a
# 带‘0XB’前缀的16进制：
print("{:#X}".format(b)) # 结果：0X29A
总结：
‘^’, ‘<’, ‘>’ 分别代表居中、左对齐、右对齐，后面带宽度，‘:’号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
‘+’ 表示在正数前显示 ‘+’，负数前显示’-’ ；(空格)表示在正数前加空格。
b、d、o、x 分别代表2进制、十进制、8进制、16进制。
25、frozenset() 方法
作用：冻结一个可迭代对象并返回新的集合，如果参数为空则会生成一个空集合，被冻结的集合的元素不能再进行增删操作。
# frozenset() Sample
a = range(5)
b = '小曹爱python'
print(frozenset(a)) # 结果：frozenset({0, 1, 2, 3, 4})
print(frozenset(b)) # 结果：frozenset({'p', '曹', 'h', 'n', '小', 'y', 't', '爱', 'o'})
26、getattr() 方法
作用：获取对象的属性值，且可以直接使用该返回值。该方法有3个参数，第一个参数是对象名，第二个参数是要获取的属性名，第三个参数是defaul返回默认值，如果没有传入该参数且没有找到对应的属性时会报错AtttibuteError。
# getattr() Sample
class A:
attr1 = '你好世界'
attr2 = 'hello word'
# 返回attr1这个属性的值：
print(getattr(A,'attr1')) # 结果：你好世界
# 返回attr2这个属性的值：
print(getattr(A,'attr2')) # 结果：hello word
# 返回attr3这个不存在的属性的值，没加默认参数，会报错
print(getattr(A,'attr3')) #报错：AttributeError: type object 'A' has no attribute 'attr3'
# 返回attr3这个不存在的属性的值，加上默认返回值
print(getattr(A,'attr3','该属性不存在123')) # 结果：该属性不存在123
27、globals() 方法
作用：以字典的形式返回当前位置下的全部全局变量，包括所有导入的变量。
a = 1
global b
print(globals())
# 结果：
"""
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':
<_frozen_importlib_external.SourceFileLoader object at 0x0000023FDCE38470>,
'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
'__file__': 'E:/Sound_detect_byCaoTangyi/Built-in-Functions.py',
'__cached__': None, 'sample': '姓名：小曹，爱好3：写blog',
'dic1': {'name': '小曹', 'lover': '学Python'}, 'list1': ['小曹', '写blog'], 'a': 1}
"""
28、hasattr() 方法
作用：判断一个对象是否有某属性，有返回True，无则返回Flase。需要两个参数，一个时对象名，一个是字符串格式的属性名。
# hasattr() Sample
class B:
at1 = 1
at2 = '2'
b = B()
print(hasattr(b, 'at1')) # True
print(hasattr(b, 'at2')) # True
print(hasattr(b,'at3')) # Flase
29、hash() 方法
作用：获取某个对象的哈希值。
# hash() Sample
# 获取数字的哈希值：
print(hash(123))
#获取字符串的哈希值：
print(hash('hello word'))
print(hash(str([1, 'python'])))
30、help() 方法
作用：查看某模块的帮助信息。
# help() Sample
import time
print(help(time)) #time模块的使用帮助
31、hex() 方法
作用：将数据转换成16进制。
# hex() Sample
a = 15
b = 16
c = 255
d = -1
print(hex(a)) # 0xf
print(hex(b)) # 0x10
print(hex(c)) # 0xff
print(hex(d)) # -0x1
32、id() 方法
作用：获取某个对象的内存地址。
# id() Sample
a = 1223
b = '134'
print(id(a)) # 2735369637616
print(id(b)) # 2735371328400
33、input() 方法
作用：该方法会接受以给用户输入，并返回输入的字符串格式。
# input() Sample
a = input("请输入123456：")
print(a)
print(type(a))
截图：
34、int() 方法
作用：将字符串或数字转换成十进制整数。有两个参数，第一个是需要转换的数据，第二个是原数据的进制数，其中第二个参数如果省略，默认原数据
为10进制数据；如果带有第二个参数，原数据需要以字符串形式传入。当int()参数为空时，默认返回0。
# int() Sample
print(int()) # 参数为空，默认返回0
# 将小数转换成整数：
print(int(12.2)) # 12
# 将16进制的'0xa'转换成10进制整数：
print(int('0xa', 16)) # 10
# 将8进制的'10'转换成10进制整数：
print(int('10', 8)) # 8
35、isinstance() 方法
作用：与type()方法相似，返回一个对象的类型。与type()的区别是，type()不会考虑继承关系。而isinstance()则会考虑继承关系，认为子类是父类类型。可以传递两个参数，一个参数是对象名，第二个参数是类型名，也可以是一个包含几个类型名的元组。如果判断段为真，返回True，否则返回Flase。
# isinstance() Sample
a = '213' # 定义a为一个字符串
print(isinstance(a,int)) # 判断a是否是int整型，结果为Flase
print(isinstance(a,str)) # 判断a是否是str字符串类型，结果为True
# 判断a是否是整型、浮点型、列表型中的一个，结果为Flase：
print(isinstance(a,(int,float,list)))
36、issubclass() 方法
作用：判断某个类是否是某个类的子类，结果为真返回True，否则返回Flase。
# issubclass() Sample
class Sample:
a = 1
b = 2
c = a + b
class B(Sample): # 定义B是Sample类的子类
pass
# 判断B是否为Sample的子类：
print(issubclass(B,Sample)) # 结果为True
37、iter() 方法
作用：用来生成一个迭代器。可以传入两个参数，第一个参数是可迭代的对象的集合，。如果要传递第二个参数，则参数 object 必须是一个可调用的对象（比如函数），此时iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
# iter() Sample
a = 'hello'
for i in iter(a):
print(i)
# 打印结果：
"""
h
e
l
l
o
"""
38、len() 方法
作用：返回项目的长度或数据项数。
# len() Sample()
a = "I like Yaya"
print(len(a)) # 结果：11
b = [1,2,3,4,5,6,]
print(len(b)) # 结果：6
39、list() 方法
作用：将元组或字符串转换从列表。
# list() Sample
a = '123Ilike'
print(list(a)) # ['1', '2', '3', 'I', 'l', 'i', 'k', 'e']
b = (1,2,3,4,5,6)
print(list(b)) # [1, 2, 3, 4, 5, 6]
40、locals() 方法
作用：以字典格式返回当前位置的所有局部变量，变量名为键名，key为变量所对应的值。
# locals() Sample
def test():
a = 1
b = 2
print(locals())
test() # 结果：{'a': 1, 'b': 2}
41、map() 方法
作用：将一个迭代序列中的元素一一映射给一个指定的函数方法进行处理。需要传入两个参数，第一个是指定的函数方法，也可以是lambda匿名函数；第二个参数是一个可迭代序列，也可以是多个序列。
注意：
在Python2.x中，map()返回的是一个列表，可直接print。
而在Python3中，map()返回的是一个迭代器，需要配合for循环取值。
# map() Sample
# 定义一个自己相加的函数add:
def add(a):
return a+a
# 将range(5)中的数一次传递给函数add：
for i in map(add, range(5)):
print(i, end=' ') # 0 2 4 6 8
# 两数相乘的匿名函数，传递两个列表：
for i in map(lambda x, y: x*y, [0,1,2,3,4], [5,6,7,8,9]):
print(i, end=' ') # 0 6 14 24 36
42、max() 方法
作用：返回一组元素中的最大值，参数可以是几个数据，也可以是一组序列。
# max() Sample
a = [-10, 1314, 520, 999]
print(max(a)) # 结果：1314
print(max(0, 1, 10, 666)) # 结果：666
43、memoryview() 方法
作用：允许Python代码访问内存中支持缓冲区协议的数据，即内存查看对象。在Python2和Python3中使用法有一定的区别。该方法返回的是一个元组列表。
# memoryview() Sample
# Python2中的用法：
a = 'helloword'
b = memoryview(a)
print(b[1]) # py2中会打印出'e',py3会报错TypeError: memoryview: a bytes-like object is required, not 'str'
# Python3中用法：
a = 'HELLOWORLD'
b = memoryview(bytes(a, 'utf-8'))
for i in b:
print(i, end=' ') # 打印出：72 69 76 76 79 87 79 82 76 68 ，分析可知这些是字母对应的ascii编码
# 转换格式
print(b[:-1].tobytes(), end='') # 打印出：b'HELLOWORL'
44、min() 方法
作用：与max()相对，返回一组数据中的最小值。
# min() Sample
a = [-10, 1314, 520, 999]
print(min(a)) # 结果：-10
print(min(0, 1, 10, 666)) # 结果：0
45、next() 方法
作用：Python3中等同于__next__()方法。适用于迭代器，返回迭代器的下一个值。可以给定两个参数，第二个参数用于返回默认值。如果迭代器数据取完就会返回默认值，如果没有给定第二个参数，迭代超过数据上限则会报抛出异常：StopItration。
# next() Sample
a = [6, 2, 3, 4, 5, 6]
long = len(a)
b = iter(a) # 生成一个迭代器
for i in range(long):
x = next(b) # 也可写成 x = b.__next__()
print(x, end=' ') #打印出6 2 3 4 5 6
46、object()
作用：Python类对象。返回一个新的无特征对象。对象是所有类的基。它拥有所有Python类实例通用的方法。此函数不接受任何参数。
注意：
对象没有“dict”，因此不能将任意属性分配给对象类的实例。
无法示例！
47、oct() 方法
作用：将一个整型数据转换成二进制字符串形式。参数必须是整型。
# oct() Sample
print(oct(5)) # 0o5
print(oct(-1)) # -0o1
print(oct(8)) # 0o10
print(type(oct(0))) # <class 'str'>
48、open() 方法
作用：打开一个文件，并返回文件对象，想对文件进行操作时需要用到这个方法，对文件操作结束后，要记得用close关闭文件。
参数说明：
open()可以传递的参数很多，可以有8个参数：方法原型是open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)，其中常用的是mode文件打开模式选择和encoding编码选择，其中mode模式又有近20种选择。
参数：
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
mode模式选择：(参考于菜鸟教程）
t ：文本模式 (默认)。
x ：写模式，新建一个文件，如果该文件已存在则会报错。
b ：二进制模式。
+ ：打开一个文件进行更新(可读可写)。
U： 通用换行模式（不推荐）。
r ：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb ：以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+ ：打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ ：以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w ：打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb ：以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+ ：打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+ ：以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a ：打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab ：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ ：打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ ：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。其中，默认为文本模式，如果要以二进制模式打开，加上 b 。
# open() Sample
# 假设同目录下有个叫test.txt的文件，想查看它的内容：
f = open('test.txt', mode='r', encoding='utf-8')
f.read()
f.close()
49、ord() 方法
作用：返回Unicode字符或ASCII字符对应的编号数字。与 chr() 方法相对。
# ord() Sample
print(ord('A')) # 打印出字母A的编码65
print(ord('Z')) # 打印出字母Z的编码90
print(ord('a')) # 打印出字母a的编码97
print(ord('b')) # 打印出字母b的编码98
print(ord('€')) # 打印出欧元符号€的编码8364
for i in range(256):
print(ord(chr(i))) # 循环打印前256个Unicode码表示的字符的编码0-255
50、pow(x，y) 方法
作用：返回 xy（即x的y次方）的值。
注意：
Python中除了内置的pow()方法外，math模块中也有一个pow()方法。两个方法都可以用来计算 xy，但还是有两点区别：第一是内置pow()方法计算后返回的是int型数据，math.pow()方法计算后返回的是float型数据；第二点区别是math中的pow()方法可以传3个参数，其中第三个参数用来取余，列式子表示就是：math.pow(x, y ,z) == pow(x, y)%z == xy%z
# pow() Sample
# 内置函数求2的10次方：
print(pow(2, 10)) # 1024
# math模块在的方法求2的10次方：
import math
print(math.pow(2, 10)) # 1024.0
51、print() 方法
作用：一般我们学习Python使用的第一个方法就是print()函数，用于打印输出自定义内容。比如第一个Python程序：print(‘Hello Python’)。
参数说明：
print()方法包括1个不定长参数和4个默认参数，函数原型是：print(*content, sep = ’ ', end = ‘\n’, file = ‘sys.stdout’, flush = Flase)。content是自定义要输出的内容，可以是多个对象，每个对象用逗号分隔；sep参数是默认是一个空格符，用于间隔多个对象；end参数默认是一个换行符，作用于输出对象的结尾处；flush参数以布尔值表示，默认是False，利用flush参数可以实现进度条动态加载效果。
# print() Sample
print('Hello Python')
# 输出多个对象：
print('你好', '派森')
# 修改默认参数sep间隔符为hello：
print('你好','派森', 'Python', sep='hello') # 你好hello派森helloPython
# 修改默认参数end为空：
print('P', end='')
print('y', end='')
print('t', end='')
print('h', end='')
print('o', end='')
print('n', end='')
# 上面6行print输出：Python
# 设置flush参数实现动态加载效果：
import time
print("正在加载中", end='')
for i in range(20):
print("...", end='', flush=True)
print(str((i+1)*5)+'%',end='')
time.sleep(0.5)
print('\n加载完成！')
52、property() 方法
作用：返回新式类的属性值。也可以用作装饰器来创建只读属性。类有经典类和新式类，其中当前类或其基类继承了object类的类称为新式类，如果当前类或其基类没有继承object类称作经典类。
# property() Sample
# 定义类A继承了object类，所以是新式类：
class A(object):
def __init__(self):
self._x = None
@property # 装饰器
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
53、range() 方法
作用：在python2中返回一个列表。在python3中返回的是可迭代对象，所以不能打印出列表，但可以用list()方法转换。
参数：
可以传递1-3个参数，传递1个参数时返回的迭代对象起始值默认为0，如range(3)返回(0,1,2)；传递2个参数则第1个为起始值，到第2个值结束，如range(2,5)返回(2,3,4)；传递3个参数时第3个参数为步长，步长为1时结果与传递两个参数的结果相同。
# range() Sample
for i in range(5): # 传递一个参数
print(i,end=' ') # 0 1 2 3 4
print('\n')
for j in range(2,10): # 传递两个参数
print(j,end=' ') # 2 3 4 5 6 7 8 9
print('\n')
for m in range(2,10,1): # 传递3个参数，步长为1
print(m,end=' ') # 2 3 4 5 6 7 8 9
print('\n')
for n in range(1,10,2): # 传递3个参数，步长为2
print(n,end=' ') # 1 3 5 7 9
# 用list()转换：
print(list(range(5))) # [0, 1, 2, 3, 4]
54、repr() 方法
作用：将变量或常量装换为字符串，输出会带有引号。与str()方法相似但也有一些区别：str() 的输出结果我们能很好地知道 now 实例的内容，但是却丢失了 now 实例的数据类型信息；而通过 repr() 的输出结果我们不仅能获得 now 实例的内容，还能知道 now 是 datetime.datetime 对象的实例。
对比：
str() 的输出追求可读性，输出格式要便于理解，适合用于输出内容到用户终端。
repr() 的输出追求明确性，除了对象内容，还需要展示出对象的数据类型信息，适合开发和调试阶段使用。
# repr() 、str() Sample
print(repr(123)) # 123
print(str(123)) #123
print(type(repr(123)), type(str(123))) # <class 'str'> <class 'str'>
print(repr('hellopython')) # 'hellopython'
print(str('hellopython')) # hellopython
import datetime
print(str(datetime.datetime.now())) # 2020-02-23 16:38:02.758207
print(repr(datetime.datetime.now())) # datetime.datetime(2020, 2, 23, 16, 38, 2, 758207)
55、reversed() 方法
作用：反转元组、列字符串、range等序列，返回的是一个迭代器。经常配合list()或for使用。
# reversed（） Sample
# 反转字符串
print(list((reversed('123456')))) # ['6', '5', '4', '3', '2', '1']
# 反转元组
print(list(reversed(('d','l','r','o','w')))) # ['w', 'o', 'r', 'l', 'd']
# 反转 range对象
print(list(reversed(range(5)))) # [4, 3, 2, 1, 0]
56、round() 方法
作用：返回浮点数的四舍五入值，能传递两个参数，第二个参数可以设置数据保留的从小数点位数，默认为0。当只传递1个参数是返回的值是整型，第2个参数不为0时，返回的值是浮点型。
# round() Sample
print(round(5.1)) # 5
print(round(5.5)) # 6
print(round(5.654321, 1)) # 5.7
print(round(5.654321, 2)) # 5.65
print(round(5.654321, 3)) # 5.654
print(round(5.654321, 4)) # 5.6543
# 注意：第二个参数是保留从小数点位数，不同于保留到小数点后几位：
print(round(5.000012, 1)) # 5.0
print(round(5.000012, 2)) # 5.0
print(round(5.000012, 3)) # 5.0
print(round(5.000012, 4)) # 5.0
print(round(5.000012, 5)) # 5.00001
57、set() 方法
作用：创建一个无序的没有重复值的元素集，可以用来进行关系测试，删除重复数据，计算交集、差集、并集等。
# set() Sample
a = 'hello'
b = 'world'
# 打印a、b集合，重复值被自动删除，且无序排列：
print(set(a)) # {'l', 'h', 'o', 'e'}
print(set(b)) # {'l', 'o', 'w', 'r', 'd'}
# 计算交集：
print(set(a) & set(b)) # {'l', 'o'}
# 计算并集：
print(set(a) | set(b)) # {'l', 'o', 'w', 'h', 'e', 'r', 'd'}
# 计算差集：
print(set(a) - set(b)) # {'h', 'e'}
58、setattr() 方法
作用：对属性赋值，如果该属性不存在，则会新建一个对象属性并进行赋值。
# setattr() Spamle
class A():
attr1=1
a = A()
print(a.attr1) # 1
setattr(a,'attrl',15)
print(getattr(a,'attr1'))
# 尝试给一个不存在的属性附值：
setattr(a, 'attr2', 20)
print(a.attr2) # 20
59、slice() 方法
作用：用于切片操作，返回一个切片对象。不过小编想不通它存在的意义是什么，用它切片似乎比数据类型的内置方式切片更麻烦。
# slice() Sample
qiepian = slice(5) # 切5个元素
# 对range(10)进行切片：
print(range(10)[qiepian]) # range(0, 5)
# 打印切片后的数据：
for i in range(10)[qiepian]:
print(i,end=' ') # 0 1 2 3 4
60、sorted() 方法
作用：对可迭代对象进行排序，默认升序，可以通过reverse参数设置排序方式。它返回的是一个新的列表而不会修改原列表。list中的内置sort(）方法只能对已经存在的列表进行操作且会修改原列表。
# sorted() Sample
a = [5,1,6,9,7,3,2,1]
# 升序
print(sorted(a)) # [1, 1, 2, 3, 5, 6, 7, 9]
# 降序
print(sorted(a,reverse=True)) # [9, 7, 6, 5, 3, 2, 1, 1]
61、staticmethod() 方法
作用：声明一个静态方法。静态方法的优点在于不需要实例化。参数为一个方法名，亦可以不传参数。
# staticmethod Sample
class A(object):
@staticmethod # 声明静态方法
def a():
print('hello python')
# 静态方法无需实例化 ：
A.a() # hello python
# 也可以实例化后调用 ：
b = A()
b.a() # hello python
62、str() 方法
作用：str() 的输出结果我们能很好地知道 now 实例的内容，但是却丢失了 now 实例的数据类型信息；而通过 repr() 的输出结果我们不仅能获得 now 实例的内容，还能知道 now 是 datetime.datetime 对象的实例。
对比：
str() 的输出追求可读性，输出格式要便于理解，适合用于输出内容到用户终端。
repr() 的输出追求明确性，除了对象内容，还需要展示出对象的数据类型信息，适合开发和调试阶段使用。
# repr() 、str() Sample
print(repr(123)) # 123
print(str(123)) #123
print(type(repr(123)), type(str(123))) # <class 'str'> <class 'str'>
print(repr('hellopython')) # 'hellopython'
print(str('hellopython')) # hellopython
import datetime
print(str(datetime.datetime.now())) # 2020-02-23 16:38:02.758207
print(repr(datetime.datetime.now())) # datetime.datetime(2020, 2, 23, 16, 38, 2, 758207)
63、sum() 方法
作用：求和计算，第1个参数是可迭代对象如列表集合元组等，第2个参数是对前一个参数求和后再指定相加的数。
# sum() Sample
# 对列表元素求和：
print(sum([1,3,5,7,9])) # 25
# 对列表元素求和后再加1：
print(sum([2,4,6,8,10],1)) # 31
64、super() 方法
作用：用来解决多重继承问题。直接用类名调用父类方法在使用单继承的时候不会出现问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。MRO 是类的方法解析顺序表, 其实就是继承父类方法时的顺序表。super() 函数用于调用父类(基类)。
class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2) # 3
65、tuple() 方法
作用：将可迭代对象转换为元组。
# tuple() Sample
a = [1,2,3,4,5]
print(tuple(a)) # (1, 2, 3, 4, 5)
66、type() 方法
作用：返回对象的类型。与isinstance()相似，区别是：type() 不会认为子类是一种父类类型，不考虑继承关系。isinstance() 会认为子类是一种父类类型，考虑继承关系。因此如果要判断两个类型是否相同推荐使用 isinstance()。
# type() Sample
a = 1
b = (1,)
c = [1,2]
class A:
pass
def d():
pass
print(type(a),type(b),type(c),type(A),type(d),sep='|')
# 结果：<class 'int'>|<class 'tuple'>|<class 'list'>|<class 'type'>|<class 'function'>
67、vars() 方法
作用：返回对象object的属性和属性值的字典对象。如果没有参数，就打印当前调用位置的属性和属性值。与 locals()相似。
# vars() Sample
print(vars())
class A:
def a(self,m):
reversed(m)
pass
print(vars(A))
68、zip() 方法
作用：用于节约内存，将可迭代对象打包成一个元组，并返回由元组组成的对象，一般用list将返回的对象进行转换。如果各个迭代器的元素个数不一致，则返回列表的长度与最短的对象长度相同，利用 * 号操作符（即zip(*))，可以将元组解包为原列表。
# zip Sample
a = [1,2,3,4,5]
b = [0,6,7,8,9,10]
print(list(zip(a,b))) # 打包
# [(1, 0), (2, 6), (3, 7), (4, 8), (5, 9)]
print(list(zip(*zip(a,b)))) # 解包
# [(1, 2, 3, 4, 5), (0, 6, 7, 8, 9)]
a1, b1 = zip(*zip(a,b))
print(a1, b1,sep='\n')
"""
(1, 2, 3, 4, 5)
(0, 6, 7, 8, 9)
"""
69、__import__() 方法
作用：用于动态加载类和函数 。如果一个模块经常变化就可以用它来动态载入。
# 假设存在一个模块为：test.py，想用__import__导入：
import os # 导入 os
import sys # 导入 sys
__import__'test' # 导入 test
啊))) )) ) ) 磨磨蹭蹭，终于写完了。
看到了这儿的小伙伴先别走，留个赞呀❤️
最后
推荐阅读：
Python内置方法解析官方文档(英文)【打开有点慢，需耐心等待】
https://docs.python.org/3/library/functions.html?highlight=built
