Python3内建函数(方法)代码示例详解

た入场券 2023-07-06 09:57 108阅读 0赞

文章很长，差几百到3w字，每个方法都包括进去了，建议使用电脑阅读，点击方法名即可跳转至对应位置。

说实话有些几乎用不到的方法小编也忘了，为了写好这篇blog，专门去翻了Python官方的英文文档，相当于让自己再巩固巩固基础知识吧，同时也希望能帮助到某些小伙伴。

**Python3中69个内置方法：**  
从上往下，从左到右，按字母顺序排序。

<table> 
 <thead> 
 <tr> 
 <th align="center">69</th> 
 <th align="center">个</th> 
 <th align="center">内置函数</th> 
 <th align="center">解</th> 
 <th align="center">析</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="center"><a rel="nofollow">abs()</a></td> 
 <td align="center"><a rel="nofollow">delattr()</a></td> 
 <td align="center"><a rel="nofollow">hash()</a></td> 
 <td align="center"><a rel="nofollow">memoryview()</a></td> 
 <td align="center"><a rel="nofollow">set()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">all()</a></td> 
 <td align="center"><a rel="nofollow">dict()</a></td> 
 <td align="center"><a rel="nofollow">help()</a></td> 
 <td align="center"><a rel="nofollow">min()</a></td> 
 <td align="center"><a rel="nofollow">setattr()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">any()</a></td> 
 <td align="center"><a rel="nofollow">dir()</a></td> 
 <td align="center"><a rel="nofollow">hex()</a></td> 
 <td align="center"><a rel="nofollow">next()</a></td> 
 <td align="center"><a rel="nofollow">slice()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">ascii()</a></td> 
 <td align="center"><a rel="nofollow">divmod()</a></td> 
 <td align="center"><a rel="nofollow">id()</a></td> 
 <td align="center"><a rel="nofollow">object()</a></td> 
 <td align="center"><a rel="nofollow">sorted()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">bin()</a></td> 
 <td align="center"><a rel="nofollow">enumerate()</a></td> 
 <td align="center"><a rel="nofollow">input()</a></td> 
 <td align="center"><a rel="nofollow">oct()</a></td> 
 <td align="center"><a rel="nofollow">staticmethod()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">bool()</a></td> 
 <td align="center"><a rel="nofollow">eval()</a></td> 
 <td align="center"><a rel="nofollow">int()</a></td> 
 <td align="center"><a rel="nofollow">open()</a></td> 
 <td align="center"><a rel="nofollow">str()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">breakpoint()</a></td> 
 <td align="center"><a rel="nofollow">exec()</a></td> 
 <td align="center"><a rel="nofollow">isinstance()</a></td> 
 <td align="center"><a rel="nofollow">ord()</a></td> 
 <td align="center"><a rel="nofollow">sum()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">bytearray()</a></td> 
 <td align="center"><a rel="nofollow">filter()</a></td> 
 <td align="center"><a rel="nofollow">issubclass()</a></td> 
 <td align="center"><a rel="nofollow">pow()</a></td> 
 <td align="center"><a rel="nofollow">super()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">bytes()</a></td> 
 <td align="center"><a rel="nofollow">float()</a></td> 
 <td align="center"><a rel="nofollow">iter()</a></td> 
 <td align="center"><a rel="nofollow">print()</a></td> 
 <td align="center"><a rel="nofollow">tuple()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">callable()</a></td> 
 <td align="center"><a rel="nofollow">format()</a></td> 
 <td align="center"><a rel="nofollow">len()</a></td> 
 <td align="center"><a rel="nofollow">property()</a></td> 
 <td align="center"><a rel="nofollow">type()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">chr()</a></td> 
 <td align="center"><a rel="nofollow">frozenset()</a></td> 
 <td align="center"><a rel="nofollow">list()</a></td> 
 <td align="center"><a rel="nofollow">range()</a></td> 
 <td align="center"><a rel="nofollow">vars()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">classmethod()</a></td> 
 <td align="center"><a rel="nofollow">getattr()</a></td> 
 <td align="center"><a rel="nofollow">locals()</a></td> 
 <td align="center"><a rel="nofollow">repr()</a></td> 
 <td align="center"><a rel="nofollow">zip()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">compile()</a></td> 
 <td align="center"><a rel="nofollow">globals()</a></td> 
 <td align="center"><a rel="nofollow">map()</a></td> 
 <td align="center"><a rel="nofollow">reversed()</a></td> 
 <td align="center"><a rel="nofollow">__import__()</a></td> 
 </tr> 
 <tr> 
 <td align="center"><a rel="nofollow">complex()</a></td> 
 <td align="center"><a rel="nofollow">hasattr()</a></td> 
 <td align="center"><a rel="nofollow">max()</a></td> 
 <td align="center"><a rel="nofollow">round()</a></td> 
 <td align="center"></td> 
 </tr> 
 </tbody> 
</table>

**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][_Numeric Types _ int_ float_ complex]）。它的唯一实例是False和True（[详见Bool-Value][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 内置函数>][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()的用法详解][bytes_bytearray]  
[python 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 编码分析详解(全网最全)][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))

截图：  
![sc1][]  
**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() 的输出追求明确性，除了对象内容，还需要展示出对象的数据类型信息，**适合开发和调试阶段**使用。

参考：[python中str()与repr()函数的区别][python_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() 的输出追求明确性，除了对象内容，还需要展示出对象的数据类型信息，**适合开发和调试阶段**使用。

参考：[python中str()与repr()函数的区别][python_str_repr]

**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()。

**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内置方法解析官方文档(英文)【打开有点慢，需耐心等待】][Python]  
https://docs.python.org/3/library/functions.html?highlight=built

[_Numeric Types _ int_ float_ complex]: https://docs.python.org/3/library/stdtypes.html#typesnumeric
[Bool-Value]: https://docs.python.org/3/library/stdtypes.html#bltin-boolean-values
[breakpoint_ _Python]: https://www.jianshu.com/p/5d3c52c5c2a2
[bytes_bytearray]: https://blog.csdn.net/wl13488376764/article/details/81610030
[python bytes_bytearray]: https://www.cnblogs.com/f-ck-need-u/p/10185965.html
[ASCII_GB2312_GBK_GB18030_Unicode_UTF-8_BIG5]: https://blog.csdn.net/qq_41320433/article/details/104301319
[sc1]: https://img-blog.csdnimg.cn/20200222202117545.png
[python_str_repr]: https://blog.csdn.net/xc_zhou/article/details/80952314
[Python]: https://docs.python.org/3/library/functions.html?highlight=built