Python 的内置函数
Built-in Functions

目前到 Python 3.11 版为止 ，内置函数经过删删改改，还有 71 个之多。同时，官网文档是按函数名称的 首字母 排序的，加上文档也是不说人话，䀲涩难懂，真的让人头大啊。因此才重新按 难易程度 和 常用频率 ，重新排列一下，以方便参考查阅。

Built-in Functions 内置函数

最常用 print() 打印输出 format() 字符串格式化 range() 创建整数序列区间，常用于 for 循环 input() 等待输入 open() 打开文件读写 int() 转为整数 str() 转为字符串 list() 转为列表 type() 查看类型 help() 初学时交互用 经常用 dir()/vars() 查看对象的属性和方法 len() 获取长度 iter() 创建/转换位 迭代器 next() 从 迭代器 中取出下一个 元素 dict() 创建字典，用 {} 也可以 次常用 globals() 获取全局变量 locals() 获取局部变量 isinstance() 判断类型；与 type() 互补 map() 执行函数的多个参数 filter() 过滤 元素 all() 判断元素是否都有效 any() 判断元素是否有一个有效 set() 创建集合 frozenset() 冻结对象转为集合 sorted() 排序返回结果；更多直接用 list.sort() reversed() 反向排序 slice() 切片；更多直接用列表`[0:3]`来切片 enumerate() 创建枚举型对象 zip() 并行迭代 数学计算 abs() 求绝对值 max()/min() 求最大最小数 sum() 求和 round() 四舍五入取小数位 pow() 次方取余 divmod() 求商和余数

类型转换 float() 转为浮点数 chr()/ord() Unicode整数字符转换 ascii() 转 ASCII 码 tuple() 转元组 类、对象 hasattr() 查一下对象是否包含某属性 getattr() 获取对象某属性值 setatrr() 设置属性值 delattr() 删除属性值 issubclass() 判断子类 二、八、十六进制 bin() 整数转二进制 bytearray() 二进制数组 bytes() 二进制对象 oct() 转为八进制 hex() 转为十六进制 几乎不用 object() 创建一个祖宗类实例对象 callable() 是否可调用 property() 操作对象的属性 classmethod 修饰为类方法 staticmethod() 静态方法 compile() 编译成 AST id() 获取唯一标识符，有 指针 的味道 hash() 获取哈希值 memoryview() 内存视图对象 super() 调用超类 aiter()/anext() 异步迭代器 eval() 执行字符串表达式 repr() 转换 源码，与 eval() 配合使用 exec() 动态执行 Python 代码 bool() 判断真/假，一般用 if 语句了 complex() 创建/转换复数 breakpoint() 中断执行 `__import__()` 动态加载模块

众所周知，Python 是一个面向对象的计算机语言，因此，只要是运行了 Python，那么在你的电脑内存中，就已入驻了 Python 的内置函数 和 一个祖宗类 Object，准备好开始工作了。可以理解为在一张白纸上画好了格子，就看你准备用来写什么数据了？如果当作语文本来用，那就写一个个的字；如果当作数学本来用，就写一个个的数字来计算；还可以当美术本，来画画；当音乐本来放一些谱子、音频；而那些画格子的线，就是由 Python 的这些内置函数 和 对象（Object） 来组成的。知道格子的范围了，后面无论要处理什么数据就规范了嘛，按格子排嘛。

关于 Object 这个祖宗类（Class） ，可以运行以下代码以帮助理解：

# -*- coding: utf-8 -*-

print(dir(object))  # 用内置函数 dir() 来获取 object 中的全部方法和属性，然后打印输出。

print(object.__doc__)  # 打印输出 objet 的一个属性 __doc__ 的值。这是关于这个 类 的简单描述文本。

运行结果应该如下：

['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

The base class of the class hierarchy.
类层次结构的基类。（所有 类 的 基类，祖宗类）

When called, it accepts no arguments and returns a new featureless
instance that has no instance attributes and cannot be given any.
当被调用时，它不接受任何参数并返回一个新的无特征的实例，
它没有实例属性，也不能被赋予任何属性。
（意即，这个 祖宗类 是只读的，不要直接用来生成实例 对象。正确的操作是先继承它、再生成 对象）

第三行 输出的内容是一个 列表（List），其中的内容是 object 这个类（class）中的全部属性和方法；

第五行 输出的内容是 object 这个类（class） 的一个属性 __doc__ 的值，通常是一段描述这个 类（class） 的文本；

这些内容在 基础篇中，已经学习过了。本篇就逐一来讨论下 内置函数 的用法。有些很简单，我们都见过了；有些则稍稍复杂一点，需要结合之前学习过的知识一起运用。

准备好了吗？那我们开始吧。

一、先来点简单的函数

1.1、 abs() 取绝对值

这个太简单了，猩猩都懂。

语法： abs(x)
参数： x 为一个数值
返回值： x 的绝对值
示例：

# -*- coding: UTF-8 -*-

print ("负数的绝对值 abs(-45) : ", abs(-45))
print ("浮点数的绝对值 abs(100.12) : ", abs(100.12))
print ("虚数的绝对值 abs(1+2j) : ", abs(abs(1+2j)))

"""运行结果
负数的绝对值 abs(-45) :  45
浮点数的绝对值 abs(100.12) :  100.12
虚数的绝对值 abs(1+2j) :  2.23606797749979
"""

常用的就是求负数的绝对值。几乎没用到过 虚数，更没有用到 对象。简单的函数非要玩得那么复杂吗？

1.2、 print() 打印输出

这个最常用了，最直接的人机对话方式，调试程序找 Bug 都靠它。但其实它比你想象的更强大。

语法：print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

参数：
*objects ———— 就是想打印输出的对象（Objects），最常用的就是一个字符串了；
sep ———— 用来间隔多个对象（Objects），默认值是一个空格；
end ———— 表示一行以什么字符结尾。默认值是换行符 \n，当然也可以换成其他字符串； file ———— 表示要写入的文件对象；通常写入到 日志文件；记得要提前用函数 open() 打开文件，并且只能写入字符串；
flush ———— 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

返回值： 无

示例：

# -*- coding: UTF-8 -*-

print(1,2,3,4,5,6,7, sep='|'，end="结束了")

# print 直接写入文件
f = open('test.txt','w')

print("把我写到文件里去",file = f)

自己动手看看这个示例的运行结果是什么吧？

1.3、 format 字符串格式化

如果你对 print() 打印输入出字符串中的 d% , f% 之类的字符深恶痛绝。那么现在有一个替代方案了，就是这个函数。

语法：str.format()

通常都是跟在一个 字符串（str） 后面，用一个英文句点（.）连接，基本是通过 {} 和 : 来代替以前 print() 中的 % ；

此函数可以接受不限个参数，位置可以不按顺序。当然，最常用的功能就是打印输出字符串，提供可读的信息。

示例：

# -*- coding: UTF-8 -*-
 

print("我要打印输出一个数字：",100)
print("我要打印输出一个数字：{}".format(100))
print("打印数值，只保留2位小数 {:.2f}".format(3.1415926))
print("打印数值，百分比形式 {:.2%}".format(0.17584))
"""运行结果
我要打印输出一个数字：100
我要打印输出一个数字：100
打印数值，只保留2位小数 3.14
打印数值，百分比形式 17.58%
"""

print("A：{}， B：{}，C：{}".format("a","b","c"))
 
print("A：{2}， B：{1}，C： {0}".format("c","b","a"))  # "0" 是必须的
"""运行结果
A：a， B：b，C：c
A：a， B：b，C：c
"""

是不是直观、简单多了。

1.4、 max()/min() 最大数和最小数

就是在一堆数中，挑出最大和最小的那种。算法课上的什么 冒泡排序法 还是忘了吧？ 😂

语法:

max( x, y, z, .... ) 
min( x, y, z, .... ) 

参数： x,y,z 代表多个 数值；或 结果为 数值 的表达式；

返回值：数值。

示例：

# -*- coding: UTF-8 -*-

print ("其中最大的数是？(80, 100, 1000) : ", max(80, 100, 1000))
print ("其中最大的数是？max(-20, 100, 400) : ", max(-20, 100, 400))
print ("其中最小的数是？(-80, -20, -10) : ", min(-80, -20, -10))
print ("其中最小的数是？(0, 100, -400) : ", min(0, 100, -400))
"""运行结果
其中最大的数是？(80, 100, 1000) :  1000
其中最大的数是？max(-20, 100, 400) :  400
其中最小的数是？(-80, -20, -10) :  -80   
其中最小的数是？(0, 100, -400) :  -400   
"""

1.5、 range() 创建整数序列

虽然被称为函数，但 range() 实际上就是创建一个不可变的整数序列。一般用在 for 循环中。

语法： range(start, stop, step)

参数：
start ———— 整数值，序列列表的开始数值；
stop ———— 整数值，序列列表的结束数值；
step ———— 整数值，序列列表步进的步长；

返回值： 一个不可变的整数序列，类型就是 range 。

示例：

# -*- coding: UTF-8 -*-

# 创建一个，从 0 开始，到 10 的序列，不包括 10 
a = range(10)
for i in a:
    print(i)

print("range 的类型就是不可变的序列",type(a))

# 创建一个从 0 到 30 的序列，不包括 30，每次步长为 5 
range(0, 30, 5)

# 创建一个从 0 到 -10 的序列，不包括 -10，每次步长 -1
range(0, -10, -1)

"""运行结果
0 1 2 3 4 5 6 7 8 9 
range 的类型就是不可变的序列 <class 'range'>
"""

如果你还记得数学课上讲过的 区间 的概念，那么理解此函数就容易多了：

当range() 的步长为正时，这个区间是 左闭右开的，如：[1,5)，表示 区间 1 到 5，包括 1 但不包括 5，用列表（List）表示即[ 1，2，3，4]

当range() 的步长为负时，这个区间是 左开右闭的，如： (0,-3)，表示区间 -3 到 0， 不包括 -3 但包括 0，用列表（List）表示即 [-2,-1,0]

WARNING

range() 函数创建的是一个 类型为 'range' 的区间。这是一个独立的类型，它是可迭代的 (Iterable)。并不是 Python 中的 6 大基础类型之一。如果要作为 列表（List）使用，需要先转换一下。

1.6、 round() 取小数位

返回 浮点数 的四舍五入值。

语法: round( x , n )

参数：
x ———— 一个浮点数；
n ———— 保留小数点后几位数，如果不写此参数，则不保留小数位；

返回值：浮点数 x ，保留小数点后 n 位的四舍五入值。

示例：

# -*- coding: UTF-8 -*-

print ("round(80.83456) : ", round(80.83456))
print ("int(80.83456) : ", int(80.83456))

print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))
"""运行结果
round(80.83456) :  81
int(80.83456) :  80
round(100.000056, 3) :  100.0  
round(-100.000056, 3) :  -100.0
"""

round() 有四舍五入的功能。而 int() 是直接截断小数位，只保留整数值。

1.7、 pow() 次方取余

计算 x 的 y 次方 的值，还可以取余数。

语法：pow(x, y, z)

参数：
x ———— 用来计算次方的底数；
y ———— 用来计算次方的冥数；
z ———— 用来表示取余的除数；

z 参数是可选的，如果不写就是计算次方；如果写了 z 就是要取余数。意即： pows(x,y,z) 等价于 pow(x,y) %z

返回值： 次方的结果；或者取余的结果；

示例：

# -*- coding: UTF-8 -*-

print("2 的 8 次方等于：",pow(2,8))

print("10 的 10 次方再除以 3 取余数：",pow(10,10,3))
"""运行结果
2 的 8 次方等于： 256
10 的 10 次方再除以 3 取余数： 1
"""

1.8、 divmod() 求商和余数

两个整数做除法运算，返回 商 和 余数，这两个数不能为复数。最好也不要用 小数 ，结果奇奇怪怪的。

语法：divmod(a,b)

参数： a 和 b 就是两个数字，不能为复数，也不能是其它奇奇怪怪的东西。这就是一个整数做除法运算的函数，不要瞎玩。

返回：一个元组（Tuple），其中包括 商 和 余数；

示例：

# -*- coding: UTF-8 -*-

print("10 除以 3 的结果为：",divmod(10,3))

print("10.97 除以 2.78 的结果为：",divmod(10.97,278)) # 虽然不报错，但结果....

print("abc 除以 c 的结果为：",divmod("abc","c"))  # 错误
"""运行结果
10 除以 3 的结果为： (3, 1)

10.97 除以 2.78 的结果为： (0.0, 10.97)

Traceback (most recent call last):
  File "test01.py", line 7, in <module>
    print("abc 除以 c 的结果为：\n",divmod("abc","c"))
TypeError: unsupported operand type(s) for divmod(): 'str' and 'str'
"""

用运算符 % 只能取余数，用这个函数就可以取到 商 和 余数。

1.9、 input() 用户输入

最简单的与人交流的函数，就是等待输入一个字符串。

语法： input(prompt)

参数：
prompt ———— 提示信息；

返回值： 一个字符串。

示例：

# -*- coding: UTF-8 -*-

input("请输入帐号：")

input("请输入密码：")

这是很简单的一个函数了，但在实际运用中却不常用。现在给到用户面前，必须要有个图形界面啊。

1.10、 open() 打开文件

打开一个文件，创建一个 file 对象，后续就可以调用它进行读写操作。

语法：open(name, mode, buffering)

参数：
name ———— 一个字符串，包含了你要访问的 文件名称 和 完整路径；
mode ———— 打开文件的模式：只读，写入，追加等。默认文件访问模式为只读(r)。请参考下表：

模式标识符	表达描述
t	文本模式 (默认)
x	写模式，新建一个文件，如果已存在同名文件则报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

TIP

其实最常用的操作无非是 读（r） 和 写（w）。

buffering ———— 表示缓存区，如果 设为 0，就表示没有缓存。值的大小即缓存大小。如果为 负值，则为系统默认。

打开文件，创建了文件对象之后，就可以调用对象的方法（函数）来操作文件了，比如：f.read(size)、f.readline()、f.write(string) 、f.tell() 、f.seek(offset, whence)，无非就是 读、写、查找之类的罗。（什么？你都忘了，那快去复杂一下基础篇中的 文件操作 相关章节吧。）

返回值：一个文件对象（file object）。

示例：

# -*- coding: UTF-8 -*-

f = open('test.txt','w')

print("f 是一个什么类型？",type(f))

f.write("abcdefg")

f.close() 

运行结果会打印输出 f 是一个什么类型？ <class '_io.TextIOWrapper'>。同时，快看看你的存储区里面是不是多了一个文件，名称为 test.txt ，其中的内容是不是 abcdefg。

那么，如何读取这个文件，把其中的内容打印出来，就留给你做作业吧。

1.11、 bool() 判断真假

判断传入参数的真假，返回 布尔值 True 或 False。 布尔型（bool） 其实是 整数型（int）的子类。它不能再被继承，唯一的实例就是 True 或 False。如果说在 Python 语言中，所有对象的祖宗是 object，那么 布尔型的 真/假，就是辈份最小的孙子。

语法：bool(x)
参数：x 就是一个表达式。
返回值： 布尔值 True / False

示例：

# -*- coding: UTF-8 -*-

print("整数 1 表示 真吗？ ：",bool(1))
print("整数 5 表示 真还是假？ ：",bool(5))
print("只有 0 表示 假 ：",bool(0))
print(" 3 大于 2 是 真还是假？：",bool(3 > 2) )
print(" abc 是否包含 d 吗？",'d' in "abc")
"""
运行结果：
整数 1 表示 真吗？ ： True
整数 5 表示 真还是假？ ： True
只有 0 表示 假 ： False       
3 大于 2 是 真还是假？： True
abc 是否包含 d： False 

"""

可以理解为 if 指令的另一种函数形式。

1.12、 help() 帮助

这是 Python 语言内置的 帮助 函数。有什么不明白，用这个函数查一下，就能显示简短的说明。如果不带任何参数，则会进入 help 命令符。（当然，所有的信息都是英文的。）

语法： help(object)

参数：
object ———— 一个 Python 语言中的对象（Object）；

返回值： 对象（Object）的 帮助信息。

示例：

# -*- coding: UTF-8 -*-

help(object) # object 祖宗类的帮助信息

help(abs)  # abs() 函数的帮助信息

help('sys')  # 模块 sys 的帮助信息

此函数自动打印输出信息。

简单的函数小结

内置函数中，上述这些算是很简单、很容易理解的吧？有一些是和 数值计算 有关的，有一些是用来 人机对话 的，其中最常用的莫过于 print() 和 input()了，初学时最常用了。open() 打开文件可能稍有一点难度，但也是经常用到的函数啊。

---

二、类型转换 的函数

2.1、 int() 转为整数

电脑除了二进制数，其次就最喜欢整数了，处理速度最快。

语法： class int(x, base=10)

参数：
x ———— 数字；
base ———— 表示 进制单位，默认为 十进制。

返回值： 一个 整数。

示例：

# -*- coding: UTF-8 -*-

print("字符串‘199’转换成 整数 类型 ",int("199"))

print("浮点数 3.1415926535 转换为 整数 类型 ",int(3.1415926535))

print("十六进制数 ‘0xa’ 转换为 整数 类型 ",int('0xa',16))

"""运行结果
字符串‘199’转换成 整数 类型  199       
浮点数 3.1415926535 转换为 整数 类型  3
十六进制数 ‘0xa’ 转换为 整数 类型  10
"""

2.2、 float() 转为浮点数

此函数用于将 整数 转换成浮点数。

语法：float(x)

参数：
x ———— 就是一个 整数，或者是表达数字字符串；

别整妖娥子了，一个简单的 整数 就得了。

返回值： x 转换后的浮点数。如果没有参数，那就直接返回 0.0

示例：

# -*- coding: UTF-8 -*-
 
x = 0
print("整数 0 转换为 浮点数：", float(x))

x = 99
print("整数 99 转换为 浮点数：", float(x))

y = "-1024"  # 注意字符串不能有空格
print("字符串 -1024  转换为 浮点数：", float(y))
"""
整数 0 转换为 浮点数： 0.0
整数 99 转换为 浮点数： 99.0
字符串 -1024  转换为 浮点数： -1024.0
"""

与这个函数功能相对应的，就是 int() 了，转换为 整数型。

2.3、 str() 转为字符串

此函数用于将 对象（Object） 转化为字符串，方便阅读。

语法： str(object)

参数：object ———— 想要转换成 字符串 的对象（Object）；

返回值：字符串

示例：

# -*- coding: UTF-8 -*-

a_dict = {'a': 100, 'b': 90,'c':80,'d':70}  # 声明一个 字典（dict）
print("a_dict 的类型是：",type(a_dict)))

b = str(a_dict)  # 转换 字典（dict） 为 字符串
print("b 的类型是：",type(b)))
print("b 的内容：",b)
"""运行结果
a_dict 的类型是： <class 'dict'>
b 的类型是： <class 'str'>
b 的内容： {'a': 100, 'b': 90, 'c': 80, 'd': 70}
"""

2.4、 chr() 整数转字符

根据 Unicode 表，返回整数参数对应的那个 字符。例如，chr(97) 返回字符串 'a'； chr(8364) 返回字符串 '€'。与这个函数功能相反的是 ord() 函数。

语法： chr(i)

参数： i 必须是一整数，并且取值范围是 0 到 1,114,111 之间（16 进制 0x10FFFF）。否则，会触发 ValueError 异常消息。

返回值： Unicode 表中，i 对应的那个 字符。

示例：

# -*- coding: UTF-8 -*-

print("整数 97 对应的 Unicode 字符是 ？",chr(97) )

print("整数 1001 对应的 Unicode 字符是 ？",chr(1001) )

# 以下是错误的示例

print("整数 0 对应的 Unicode 字符是 ？",chr(0))  

print("字符串 '1024' 对应的 Unicode 字符是 ？",chr("1204"))

print("负整数 -108 对应的 Unicode 字符是 ？",chr(-108))
"""
运行结果：
整数 97 对应的 Unicode 字符是 ？ a
整数 1001 对应的 Unicode 字符是 ？ ϩ
整数 0 对应的 Unicode 字符是 ？
"""

2.5、 ord() 字符转整数

根据 Unicode 表，返回 字符 对应的 数值。与这个函数功能相反的是 chr() 函数。

语法： ord(a)

参数： a 必须是一字符。

返回值： Unicode 表中，a 对应的那个 数值。

示例：

# -*- coding: UTF-8 -*-

print("a 对应的 Unicode 数值是 ？",ord("a") )

print("! 对应的 Unicode 字符是 ？",ord("!") )

"""运行结果：
a 对应的 Unicode 数值是 ？ 97
! 对应的 Unicode 字符是 ？ 33 
"""

TIP

Unicode 又称（萬國碼、國際碼、統一碼）为世界上所有 字符 都分配了一个唯一的数字编号，一般用十六进制表示。

ASCII码
英文字符（字符和符号）占一个字节，中文字符（汉字和符号）占两个字节

utf-8编码
英文字符（字符和符号）占一个字节，中文字符（汉字和符号）占三个字节

Unicode编码
英文字符（字符和符号）、中文字符（汉字和符号）都统一占两个字节

2.6、 ascii() 转可打印ASCII字符

返回一个符合 ASCII 字符集的可打印的字符串，如果其中包含 非 ASCII 字符 ，则会用 \x、\u 和 \U 进行转义。最终的结果与 Python 2 中 repr() 函数返回的结果类似。

语法：ascii(x)
参数：x 通常是一个字符串。当然也可以是任何 对象。但是这个函数就是为了转换成 ASCII 字符以方便打印出来的，你非要传一些奇奇怪怪的东西，那返回的字符串必然也是怪里怪气。
返回值：一个 由ASCII组成的可打印字符串。

示例：

# -*- coding: UTF-8 -*-

print("打印正常的 ASCII 字符",ascii("0123456789abcdefg"))

print("打印一个 布尔值  ",ascii(True))

print("ASCII 是不包含中文汉字的，所以打印出来的字符是：",ascii("中文汉字"))

print("打印16进制数对应的 ASCII 字符",ascii(0x7e))

print("打印二进制数对应的 ASCII 字符",ascii(0b00000111))

""" 运行结果
打印正常的 ASCII 字符 '0123456789abcdefg'
打印一个 布尔值   True
ASCII 是不包含中文汉字的，所以打印出来的字符是： '\u4e2d\u6587\u6c49\u5b57'
打印16进制数对应的 ASCII 字符 126
打印二进制数对应的 ASCII 字符 7
"""

TIP

Ascii码表 https://ascii.org.cn/

ASCII ((American Standard Code for Information Interchange): 美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是最通用的信息交换标准，并等同于国际标准ISO/IEC 646。ASCII第一次以规范标准的类型发表是在1967年，最后一次更新则是在1986年，到目前为止共定义了128个字符。

时至今日，国际惯例早就流行用 'utf-8' 字符集了。所以，现在你应该明白了，为什么现在源代码文件都是用 "utf-8" 字符集了吧，就是为了更好的打印输出中文汉字啊。

2.7、 list() 转换为列表

用于将 元组（Tuple） 转换为 列表（List）。元组（Tuple）的元素值不能修改，是用圆括号包括的，列表（List）是放于方括号中。

语法：list( tup )

参数：tup ———— 一个元组。

返回值： 一个列表（List）。

# -*- coding: UTF-8 -*-

a = (1,2,3,4,5,6)

b = list(a)

print( type(b) )  

print( b ) 
"""运行结果
<class 'list'>
[1, 2, 3, 4, 5, 6]
"""

2.8、 tuple() 转换为元组

将 列表（List）转换为 元组（Tuple）

语法： tuple( iterable )

参数： iterable ———— 一个可迭代的对象（Object），一般就是一个 列表（List）；

返回值：一个元组

示例：

# -*- coding: UTF-8 -*-

a = [1,2,3,4] # 这是一个 列表（List）

b = tuple(a)
print("b 的类型是 ：", type(b))
"""运行结果
b 的类型是 ： <class 'tuple'>
"""

2.9、 type() 获取类型

此函数最常用于获取某一个 对象（Object） 的类型；但此函数还可以传递三个形式参数，这时则会返回新的类型对象。

语法:

type(object)  # 获取 对象（Object） 的类型

type(name, bases, dict)  # 创建一个新 类

参数：
object ———— 只用这一个参数，即表示想要获取这个 对象（Object） 的类型；

传递 3 个参数的时候，就表示要创建一个新的 类（Object）：
name ———— 要创建的 类（Object） 的名称； bases ———— 新类（Object）继承的父类的名称； dict ———— 这是一个字典（Dict），表示在新创建的 类（Class）中，需要声明的方法和属性；

示例：略。前面已经见过了吧。

如果想创建新的 类（Class），还是用 语句 def class:比较合适。实际运用中很少看到用 type() 来创建新的 类（Class）。

2.10、 bin() 整数转二进制

将一个 整数 转变为 以 “0b ” 前缀开头 的 二进制字符串。

语法：bin(x)
参数：x 通常是一个 10进制 整数，即类型为 int。当然也可以是任何 对象。建议你不要转一些奇怪的 对象，何必搞得怪里怪气。
返回值：一个 “0b ” 前缀开头 的 二进制字符串。

示例：

# -*- coding: UTF-8 -*-

print("整数 3   转换为 二进制为 ：",bin(3))
print("整数 -10 转换为 二进制为 ：",bin(-10))

"""
运行结果：
整数 3   转换为 二进制为 ： 0b11
整数 -10 转换为 二进制为 ： -0b1010

"""

2.11、 oct() 转为 8 进制

把一个 10 进制数 转换为 8 进制数。

语法： oct(x)

参数：
x ———— 一个 10 进制整数；

返回值： 一个以 '0o' 开头的字符串，表示一个 8 进制数

示例：

# -*- coding: UTF-8 -*-

print("10 转换为 8 进制数：", oct(10))

print("1024 转换为 8 进制数：", oct(1024))
"""运行结果
10 转换为 8 进制数： 0o12
1024 转换为 8 进制数： 0o2000
"""

2.10、 hex() 转为 16 进制

就是将10进制 整数 转换 成16进制，结果是一个以 '0x' 开头的字符串。

语法： hex(int x)

参数：
x ———— 一个 10 进制整数；

返回值： 一个以 '0x' 开头的字符串，表示一个 16进制数

示例：

# -*- coding: UTF-8 -*-

print("10 转换为 16进制数：", hex(10))

print("1024 转换为 16进制数：", hex(1024))
"""运行结果
10 转换为 16进制数： 0xa
1024 转换为 16进制数： 0x400
"""

2.11、 complex() 创建/转换复数

用于创建一个复数；
或者
转化一个 字符串 或 数 为 复数。

语法：

complex(real=0, imag=0)
complex(string)

参数：
real 和 imag 用于生成一个 （real + imag*1j） 的复数；
string 是一个字符串，比如 "1+2j" ，其中 1 等同于 real，2 等同于 imag；注意字符串中不能包含空格，否则会出错；

示例：

# -*- coding: UTF-8 -*-

print("生成复数，参数 1,2",complex(1, 2))

print("生成复数，参数 1",complex(1))    # 数字

print("生成复数，参数字符 '1' ",complex("1"))  # 当做字符串处理
 
# 注意：这个地方在"+"号两边不能有空格，不能写成"1 + 2j"，否则会报错
print("生成复数，字符串 '1+2j'",complex("1+2j"))

实数还没玩明白呢？还虚数？复数？脑仁够吗？

类型转换小结

众所周知，Python 中有 6 个基本的数据类型，数值、字符、列表（List）、元组（Tuple）、字典（Dict）、集合（Set）。本节中隐藏的一个强大的函数就是 type()，简单用法，它就是看看数据是什么类型，但它还有个强大的功能和 类、对象 有关，虽然用得少，但值得关注一下。

---

三、迭代器 (Iterator)相关的函数

重点是 可迭代 (Iterable)，这才是 Python 的灵魂。

3.1、 iter() 创建迭代器

语法: iter(object, sentinel)

参数：
object ———— 一个可迭代的对象，如 字符串（str）、列表（List）、字典（dict）；也可以是一个函数，如果是函数时，则必须有第二个参数；
sentinel ———— 当第一个参数是一个函数时，此参数用来和第一个参数配合使用，表示，如果调用 第一个参数后，返回的值等于 sentinel ，则停止迭代。

返回值：一个 迭代器（iterator） 对象。

示例：

# -*- coding: UTF-8 -*-

a = [1,2,3,4,5,6,7,8,9,10]  # a 是一个列表，包含10个元素，都是整数

b = iter(a)

c = iter(a,8)


print(" 用 next(a) 取出一个元素可以吗？",next(a))

print(" 用 next(b) 取出一个元素：",next(b))
print(" 用 next(b) 再取出一个元素：",next(b))
print(" 用 next(b) 又取出一个元素：",next(b))

常见的用法就是把一个 可迭代的对象，转换成一个 迭代器，与 next() 配合使用。至于传2个参数的用法，实际运用中并不常见。

3.2、 next() 获取下一个元素

语法： next(Iterator, default)

参数：
iterable ———— 一个 迭代器；
default ———— 可选参数，当没有下一个元素可获取时，返回此参数。如果不设置，则会触发 StopIteration 异常；

返回值：获取到的元素。

# -*- coding: UTF-8 -*-

aaa = [1, 2, 3, 4, 5]

bbb = iter(aaa)

print(next(bbb))
print(next(bbb))
print(next(bbb))

通常， next() 都在 for 循环中，和 iter() 都在一起配合运用。

3.3、 len() 获取长度

就是用来统计一下 对象（Object）的长度或包含的元素个数。比如，字符串、列表（List）、元组（Tuple）等。

语法：len( s )

参数：s ———— 一个对象。

返回值： 整数值，表示获取的长度或统计的数量。

# -*- coding: UTF-8 -*-

print( len("abcdefg") )  # 字符串长度

print( len([1,2,3,4,5]) )  # 列表（List）中包含的元素个数

最大长度，取决于系统的最大整数值，比如 在 32 位平台上通常为 2的32次方减1 ，在 64 位平台上通常为 2的63次方减1 。

WARNING

不要把一个 无限长度 的迭代器，作为参数传给 len() ，这样会导致无限循环，引发错误。

3.4、 filter() 过滤可迭代对象

就是预先设定一个条件，来逐一检查一个可迭代对象（Object）中的每一个元素，过滤掉不符合条件的元素，剩下那些符合条件的元素，放在一个迭代器对象中返回。

语法：filter(function, iterable)

参数：
function ———— 用来判断是否符合的条件；
iterable ———— 用来供检测挑选的可迭代对象（Object）；

意即： iterable 中的每一个元素都将作为 参数 传递给 function 以便进行判断，然后返回 True 或 False，最后将返回 True 的元素放到 迭代器对象中 。

返回值： 一个可迭代的对象（Object），其中每一个元素都经过 function 的检测，都符合条件，结果都为 真。

示例：

# -*- coding: UTF-8 -*-
 
def is_odd(n):
    return n % 2 == 1
 
oddlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

print("filter 返回的是什么类型：",type(oddlist))

for i in oddlist:
    print("取出一个奇数：",i)

把上例写得更有 Python 的范儿一点：

# -*- coding: UTF-8 -*-
 
def is_odd(n):
    return n % 2 == 1
 
oddlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

print("oddlist是可以迭代的吗（就是看有没有属性 __iter__ ）？ ",hasattr(oddlist, "__iter__"))

while True:
    try:
        print("取出一个奇数",next(oddlist))
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

运行结果
oddlist是可以迭代的吗（就是看有没有属性 __iter__ ）？  True

取出一个奇数 1
取出一个奇数 3
取出一个奇数 5
取出一个奇数 7
取出一个奇数 9

"""

是不是让你回亿起更多的有关 迭代器 的知识点？啥？都忘了？好吧......

3.5、 all() 判断迭代元素全为 TRUE

用于检查 可迭代对象 中的全部元素 是/否 都有效。除了 0、空、None、False 之外的元素，都算有效，即返回 True，有逻辑运算符 and（与） 的感觉。

语法：all(t)
参数：t 为一个可迭代的对象
示例：

# -*- coding: UTF-8 -*-

aaa = 'abcdefg'
bbb = [0,1,2,3,4,5,6,7,8,9]
ccc = ['a','b','','c','d','e']

print("字符串 'abcdefg'，可迭代的元素都有效吗？",all(aaa))
print("列表 [0,1,2,3,4,5,6,7,8,9]，\n其中包含整数 0 可迭代的元素不是全有效。",all(bbb))
print("列表 ['a','b','','c','d','e']，\n其中包含空字符串 可迭代元素不是全有效。",all(ccc))

"""
运行结果：

字符串 'abcdefg'，可迭代的元素都有效吗？ True
列表 [0,1,2,3,4,5,6,7,8,9]，
其中包含整数 0 可迭代的元素不是全有效。 False
列表 ['a','b','','c','d','e']，
其中包含空字符串 可迭代元素不是全有效。 False
"""

3.6、 any() 判断迭代元素有一个为 TRUE

用于检查 可迭代对象 中的元素 ，只要有一个是有效的，即返回 True，类似逻辑运算符 或（or）。

语法：any(t)
参数：t 为一个可迭代的对象
返回值： 布尔值 True / False
示例：

# -*- coding: UTF-8 -*-

aaa = [0,0,0,99,0,0,0,0,0]
bbb = ['','','','','yes','']
ccc = [False,False,False,False]

print("列表 [0,0,0,99,0,0,0,0,0]，有一个元素是有效的吗？",any(aaa))
print("列表 ['','','','','yes','']，有一个元素是有效的吗？",any(bbb))
print("列表 [false,false,false,false]，有一个元素是有效的吗？",any(ccc))

"""
运行结果：

列表 [0,0,0,99,0,0,0,0,0]，有一个元素是有效的吗？ True
列表 ['','','','','yes','']，有一个元素是有效的吗？ True    
列表 [false,false,false,false]，有一个元素是有效的吗？ False
"""

3.7、 dict() 创建字典

用于创建一个新的字典。当然也可以写 {} 一对大花括号来创建新字典。

语法：

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

参数：
**kwargs ———— 关键字参数，就是相当于是字典（dict）的 键:值对（key:value)；
mapping———— 映射参数是一种关联式的容器类型，它表达了 对象 与 对象 之间的对应关系。
iterable———— 可迭代对象。其中每一项元素就是一对 键:值（key:value)；

也可以不带任何参数，那就会直接创建一个空字典（dict）。相对于直接写{}的方式，用 dict() 更灵活、但性能方面有所下降。今天的计算机已然强大，除非在中大型软件项目中，这点性能几乎可以忽略不计。

示例：

# -*- coding: UTF-8 -*-

aaa = dict()  # 创建一个空字典

bbb = dict(a=1, b=2, t=20)  # 传入关键字参数
print(bbb)

ccc = dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
print(ccc)
"""
运行结果
{'a': 1, 'b': 2, 't': 20}
{'one': 1, 'two': 2, 'three': 3}
"""

3.8、 set() 创建集合

创建一个集合（set），其中的元素没有重复的、也没有排序。可以从 迭代器（iterable）中获取元素。

语法：class set(iterable)

参数：iterable ———— 一个 迭代器，此参数可省略不写；

返回值：一个集合（set）。其中的元素都是唯一的没有重复、也没有排序。

示例：

a = (1,2,3,4,5,6,5,4,3,2,1)

b = set(a)

print(b)
"""运行结果
{1, 2, 3, 4, 5, 6}
"""

结果显示是一个 集合，是用一对 花括号（ { } ）包含的，其中的元素也排好了序，并且没有重复的。

3.9、 frozenset() 冻结对象转为集合

冻结一个 可迭代的对象（Object），冻结后不能再添加或删除任何元素。

语法： frozenset(iterable)

参数： 就是一个 可迭代的对象（Object）

返回值： 一个新的不可变的集合

示例：

# -*- coding: UTF-8 -*-

a = frozenset(range(10))     # 生成一个新的不可变集合
print(a)
print("a 的类型是： ",type(a))

b = frozenset('abcdefg') 
print(b)

"""运行结果
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
a 的类型是： <class 'frozenset'>
frozenset({'d', 'c', 'a', 'b', 'f', 'e', 'g'})  # 注意元素并不是排序好的。
"""

3.10、 sorted() 排序

对所有 可迭代 的对象（Object）进行排序操作。

TIP

列表（List）的 sort 方法与 本函数 sorted() 是有区别的：

sort() 只能是应用在 列表（List）上的方法，而 sorted() 可以对所有 可迭代 的 对象（Object） 进行排序操作。

sort() 方法无返回值，而 sorted() 会返回一个新的列表（List），而不是在原来的列表（List）上进行的操作。

语法：sorted(iterable, cmp=None, key=None, reverse=False)

参数：
iterable ———— 可迭代对象；
cmp ———— 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回 1，小于则返回 -1，等于则返回 0
key ———— 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse ———— 升序 或 降序，reverse = True 降序 ， reverse = False 升序（默认）。

返回值：重新排序后的列表

示例：

# -*- coding: UTF-8 -*-

a = [5,7,6,3,4,1,2]
b = sorted(a)       # 保留原列表

print(b)
"""运行结果
[1, 2, 3, 4, 5, 6, 7]
"""

3.11、 reversed() 反向排序

对于给定的序列（包括列表、元组、字符串以及 range(n) 区间），返回一个反向排序后的 迭代器。

语法：reversed(seq)

参数：
seq ———— 一个有序的序列，可以是列表（List）、元组（Tuple）、字符串以及 range(n) 区间；

返回值：一个反向的 迭代器（iterator）

示例：

# -*- coding: UTF-8 -*-

a = range(10)
b = reversed(a)

for i in a:
    print(i)

print("b 的类型是：",type(b))

for i in b:
    print(i)
""" 运行结果
0 1 2 3 4 5 6 7 8 9 

b 的类型是： <class 'range_iterator'>

9 8 7 6 5 4 3 2 1 0
"""

3.12、 slice() 切片

用来对一个对象（Object）实现切片操作，返回值的类型与原对象（Object）同类型。如对一个 列表（List）切片，返回结果即是一个列表（List）；如果对一个 元组（Tuple）切片，返回结果是一个 元组（Tuple）。

语法：slice(start, stop, step)

参数：
start ———— 起始位置，默认从 0 位置开始，即第一个开始；
stop ———— 结束位置；
step ———— 间距

返回值：一个可切片的对象（Object）

# -*- coding: UTF-8 -*-

a = list(range(1, 10))

s = slice(2, 7, 2)  # 开始位置 2，结束位置 6，步长为2，注意区间是 左闭右开

b = a[s]

print(b)
"""运行结果
[3, 5, 7]
"""

实际运用中，直接用 列表（List）的切片更为常见。

3.13、 sum() 求和

对一个序列进行求和计算。

语法: sum(iterable, start)

参数：
iterable ———— 可迭代的对象（Object）如：列表、元组、集合；
start ———— 从第几位的元素开始，默认从 0 开始；这是可选参数；

返回值：求和的结果。

示例：

# -*- coding: UTF-8 -*-

a = range(1,101)  
print("求 1 加到 100 的 和：",sum(a))

# 列表扁平化
b =  [[1, 2], [3, 4]]
print(sum(b, [])) 
"""运行结果
求 1 加到 100 的 和： 5050
[1, 2, 3, 4]
"""

示例中的 列表扁平化 的用法是一个十分有用的小技巧。

3.14、 zip() 并行迭代

用来同时在 2 个或更多 迭代器 中，同时执行迭代操任，每次从 每一个迭代器 中取出一个元素，放入元组（Tuple）中，最后返回这个 元组（Tuple）。

官方文档中的描述是：返回 元组（Tuple） 的迭代器，元组中的第 i 个元组，包含的是每个参数迭代器的第 i 个元素。它会把行变成列，把列变成行。这类似于 矩阵转置。

语法：zip(iterable, ...strict=False)

参数：
iterable ———— 至少 2 个 可迭代的对象，可以是 列表（List）、元组（Tuple）等；
strict ———— 用来检查传入的 可迭代对象 包含的元素个数是不是一样多，默认为 True；如果个数不一样，就会发出错误消息；

返回值：一个元组

示例：

# -*- coding: UTF-8 -*-

a = [1,2,3]
b = ['x','y','z']

c = zip(a,b)

for i in  c:
    print(i)
"""运行结果
(1, 'x')
(2, 'y')
(3, 'z') 
"""

那么问题来了，假设传给 zip() 的 可迭代对象 长度不同会怎样？如上例中 a 和 b 中的元素个数不一样，会如何？

默认情况下，zip() 按最短的 可迭代对象 停止，元素较多的那个 可迭代对象中 的剩余元素将被忽略；如果传入了 strict = True，则会检查 可迭代对象中所包含的元素是否一致，如果不一致就会发出错误消息。

WARNING

意即，还是用元素个数相同的 可迭代对象 传入 zip() 作为参数，才是正解！如果非要任性，就是长短不一的参数，还不用 strict=True 参数，那么可能会在程序的其它地方产生难以发现的错误！！！

3.15、 enumerate() 创建枚举型对象

把一个 可迭代的数据 对象（Object） 加上索引编号，然后组合成一个新的枚举型（enumerate） 对象（Object） 返回。其中每一个元素都是一个 元组（Tuple），第一个值是编号、第二个值是原可迭代对象中的一个元素。

语法：enumerate(sequence, [start=0])

参数：
sequence ———— 一个可迭代的对象（Object），比如一个列表（List）、元组（Tuple）或字符串；
start ———— 索引编号的起始值 ，0 表示 从0开始编号，0，1，2，3，4，5，......以此类推；

返回：一个 枚举型的（enumerate）的 对象（Object）。

示例：

# -*- coding: UTF-8 -*-

aaa = enumerate("abcdefg") # 字符串 转换成 枚举型对象

print("aaa 的类型",type(aaa))

for key in aaa:  # 遍历这个 枚举型 对象
    print(type(key)) # 取出一个元素，类型是
    print(key) # 元素的内容

"""
运行结果
aaa 的类型 <class 'enumerate'>
<class 'tuple'>
(0, 'a')       
<class 'tuple'>
(1, 'b')       
<class 'tuple'>
(2, 'c')       
<class 'tuple'>
(3, 'd')       
<class 'tuple'>
(4, 'e')       
<class 'tuple'>
(5, 'f')
<class 'tuple'>
(6, 'g')
"""

3.16、 aiter()/anext() 异步迭代器

这是从 Python 3.10 版开始新添加的一个 内置函数。它是另一个内置函数 iter() 的异步版本，方法将iterable 转换为iterator。它是另一个内置函数 next() 的异步版本。

语法：aiter(x)
语法：anext(x)
参数：x 为一个可迭代的对象
示例：

因为一直还没讨论过 异步编程，因此，暂时 pass

注意：与 iter() 不同，aiter() 没有两个参数的版本。

迭代器（Iterator）相关函数小结

在 Python 的世界中，迭代器（iterator） 几乎可以说是 第七个 基本类型。因为无论是 字符串、列表（List）、元组（Tuple）这些基本类型，都可以转换成 迭代器。之后，对 迭代器 进行 排序啊、遍历啊、切片啊、求和啊、过滤啊、判断元素是否有效啊这些操作就顺溜多了。灵活运用这些内置函数，那处理起数据来，还不是 666666 的。

---

四、类、对象 相关的函数

4.1、 object() 一个祖宗对象实例

返回一个不能带任何属性的新对象。object 是所有类的基类（祖宗类），它带有所有 Python 类实例均通用的方法（函数）。本函数不接受任何参数。基本用不上这个函数，但放在这里，就当是一个标志记号吧。

示例：

# -*- coding: UTF-8 -*-

aaa = object()

print(dir(aaa))
"""
运行结果

['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
"""

4.2、 dir() 获取对象的 方法属性 列表

这特么不就是 显示目录文件夹的DOS指令么（暴露年龄啊）。这个函数就是用来查看现有多少属性（变量）、方法（函数）和 已定义的类型列表的，说白了就是看看 现有的环境都有啥可用的，来个清单。

语法：dir(object)

参数： 就是一个对象，也可以省略。当省略时就显示当前环境中的变量、方法和定义的类型 清单；如果是一个对象，则返回这个对象绑定的 属性、方法的 清单。

示例：

# -*- coding: UTF-8 -*-

print("当前环境中都有哪些变量、方法和自定义的类？：\n",dir())

print("看看祖宗 类object 都带了些什么属性和方法（函数）：\n",dir(object))
"""
运行结果

当前环境中都有哪些变量、方法和自定义的类？：
 ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']

看看祖宗 类object 都带了些什么属性和方法（函数）：
 ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
"""

4.3、 vars() 获取 对象 的方法属性和值

获取一个对象（Object）的 属性 和 值（key:value），放在一个字典（Dict）中返回。 实际上就是读取 __dict__ 这个属性的内容。如果没有 __dict__ 则可能会出错。

语法 vars(object)

参数：
object ———— 想要获取 属性 和 值 的对象（Object）；

返回值：一个字典

示例：

# -*- coding: UTF-8 -*-

print("object 祖宗 类 都有哪些 属性 和 值 ：\n", vars(object))
"""运行结果
 {
  '__repr__':          <slot wrapper '__repr__' of 'object' objects>, 
  '__hash__':          <slot wrapper '__hash__' of 'object' objects>, 
  '__str__':           <slot wrapper '__str__' of 'object' objects>, 
  '__getattribute__':  <slot wrapper '__getattribute__' of 'object' objects>, 
  '__setattr__':       <slot wrapper '__setattr__' of 'object' objects>, 
  '__delattr__':       <slot wrapper '__delattr__' of 'object' objects>, 
  '__lt__':            <slot wrapper '__lt__' of 'object' objects>, 
  '__le__':            <slot wrapper '__le__' of 'object' objects>, 
  '__eq__':            <slot wrapper '__eq__' of 'object' objects>, 
  '__ne__':            <slot wrapper '__ne__' of 'object' objects>, 
  '__gt__':            <slot wrapper '__gt__' of 'object' objects>, 
  '__ge__':            <slot wrapper '__ge__' of 'object' objects>, 
  '__init__':          <slot wrapper '__init__' of 'object' objects>, 
  '__new__':           <built-in method __new__ of type object at 0x00007FFA79DF7CC0>, 
  '__reduce_ex__':     <method '__reduce_ex__' of 'object' objects>, 
  '__reduce__':        <method '__reduce__' of 'object' objects>, 
  '__subclasshook__':  <method '__subclasshook__' of 'object' objects>, 
  '__init_subclass__': <method '__init_subclass__' of 'object' objects>, 
  '__format__':        <method '__format__' of 'object' objects>, 
  '__sizeof__':        <method '__sizeof__' of 'object' objects>, 
  '__dir__':           <method '__dir__' of 'object' objects>, 
  '__class__':         <attribute '__class__' of 'object' objects>, 
  '__doc__':           'The most base type'
 }
"""

此函数比 dir() 更加直观。

4.4、 hasattr() 查询对象的属性值

查一下对象是否包含某属性。

语法： hasattr(object, name)

参数：
object ———— 查询的对象（Object）；
name ———— 属性的名称；

返回值：如果被查询的 对象（Object）拥有该属性则返回 True，否则返回 False。

示例：

# -*- coding: UTF-8 -*-

print("object 拥有属性 __doc__ 吗？ ",hasattr(object,"__doc__"))

print("object 拥有属性 __iter__ 吗？ ",hasattr(object,"__iter__"))

aaa = []  # 声明一个 空列表（List）

print("aaa 这个列表拥有属性 __iter__ 吗？ ",hasattr(aaa,"__iter__"))
"""
object 拥有属性 __doc__ 吗？  True
object 拥有属性 __iter__ 吗？  False
aaa 拥有属性 __iter__ 吗？  True    
"""

此函数通常与 getattr() 配合使用。先问“有没有？”，然后“有就拿来吧你”。

4.5、 getattr() 获取对象的属性值

用于返回一个对象（Object）属性值。

语法： getattr(object, name, default)

参数：
object ———— 想要获取其属性的对象（Object）；
name ———— 属性的名称；
default ———— 当没找到属性时的返回值；如果不写该参数，如果想找的 属性 没找到时，会触发 AttributeError 错误消息；

返回值：对象（Object）的 属性 值。

示例：

# -*- coding: UTF-8 -*-

print("祖宗类 object 的属性 __doc__ 的值：")

print(object.__doc__)
print(getattr(object,"__doc__"))

print(getattr(object,"abc","object 上没找着 abc 属性"))
"""运行结果
祖宗类 object 的属性 __doc__
The most base type
The most base type
object 上没找着 abc 属性
"""

由示例可以看出， 访问一个对象（Object）的属性时，也可以直接用英文句点（.）加属性名就可以了。但为什么要用这个 getattr() 函数呢？好处就是万一没找着对应的属性，可以有一个 default 返回值，不然就会触发 AttributeError 错误消息；

也正因为如此，在这个函数前面通常有一个 hasattr() 用于先检查下，有没有想要获取的那个 属性。

4.6、 setattr() 设置属性值

函数 setattr() 对应 函数 getattr()，用于设置属性值，后者用来 获取属性值。

语法：setattr(object, name, value)

参数：
object ———— 想要设置属性的 对象（Object）；
name ———— 想要设置的属性的名称；
value ———— 想要设置的属性值；

返回值：无

示例：

# -*- coding: UTF-8 -*-

print(object.__doc__)

setattr(object,"__doc__","我非要改改")

print(object.__doc__)

这个示例告诉我们，不要任性。祖宗类 object 的属性，是不能修改的。

4.7、 delattr() 删除属性

此函数的功能与 setattr() 是相对的。delattr() 函数用于删除对象（Object）上已有的属性。

语法： delattr(object, name)

参数：
object ———— 对象（Object）名称；
name ———— 必须是对象已有的某个属性名称。

示例：

# -*- coding: UTF-8 -*-

class ABC:
    """
    定义一个 类，带2个属性和一个方法
    """
    x = 100
    y = 1024

    def f_xy(self,x,y):
        return x+y

aaa = ABC()  # 生成一个实例

print("aaa的属性 x 的值为：",aaa.x)  # 实例对象aaa 继承了 ABC 的全部属性和方法
print("aaa的属性 y 的值为：",aaa.y)
print("aaa的方法 f_xy 的返回结果为：",aaa.f_xy(9,899))

delattr(ABC,'y')  # 等同于 del ABC.y 指令语句

print("aaa的属性 y 的值为：",aaa.y)
"""运行结果
aaa的属性 x 的值为： 100
aaa的属性 y 的值为： 1024
aaa的方法 f_xy 的返回结果为： 908
Traceback (most recent call last):
  File "test01.py", line 21, in <module>
    print("aaa的方法 f_xy 的返回结果为：",aaa.f_xy(1024,4096))
AttributeError: 'ABC' object has no attribute 'f_xy'
ABC 没有属性 f_xy
"""

delattr() 和 del 几乎等同，当然 del 还可以用来删除更多的东西，比如 字典（dict）中的某个 键（key），列表中的（list）中的某一项。总之，根据实际应用情况，用你最顺手的方式吧。

4.8、 globals() 获取全部全局变量

返回一个字典（Dict），其中包括当前环境空间内的所有全局可见的变量。

语法：globals()

无参数

返回值：一个字典（Dict）

示例：

# -*- coding: UTF-8 -*-

print("显示全局变量：\n ",globals())

""" 运行结果
显示全局变量：
  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001600C991CC8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'test01.py', '__cached__': None}
"""

4.9、 locals() 获取全部局部变量

返回一个字典（Dict），其中包括当前环境空间内的所有局部可见的变量。与 globals() 相似。

语法：locals()

无参数

返回值：一个字典（Dict）

示例：

# -*- coding: UTF-8 -*-

print("显示局部变量：\n ",locals())

""" 运行结果
显示局部变量：
  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020CA1EE1C88>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'test01.py', '__cached__': None}
"""

4.10、 isinstance() 判断类型

此函数用来判断类型，注意与 type() 的区别，此函数是询问 “ 这个对象是不是这个类型？ ”，而 type() 是问 “ 这个对象是什么类型？ ”

TIP

type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 此函数 isinstance()

语法: isinstance(object, classinfo)

参数：
object ———— 想要判断类型的一个对象；
classinfo ———— 类型的名称，可以是一个 元祖（Tuple）用来表达多个类型。

返回值： 布尔型，非 真 即 假。

示例：

# -*- coding: UTF-8 -*-

print(" 3.1415926 是整数吗？ ",isinstance(3.1415926,int))

print(" 字符串 'abcdefg' 是 列表list吗  ",isinstance('abcdefg',list))

print(" dict() 是 浮点数float、列表list和字典dict 其一吗？",isinstance(dict(),(float,list,dict)))

""" 运行结果 
3.1415926 是整数吗？  False

字符串 'abcdefg' 是 列表list吗   False

dict() 是 浮点数float、列表list和字典dict 其一吗？ True
"""

Python 语言中常见的类型：

int,long,float: 整型,长整形,浮点型;
bool,str: 布尔型，字符串类型；
List, Tuple, Dict, Set:列表，元组，字典, 集合;
Iterable,Iterator:可迭代类型，迭代器类型；
Generator：生成器类型；

4.11、 issubclass() 判断子类

就是用来判断一个 类 是不是 继承自 另一个 类，是不是有 父子关系，如果是则返回 True，否则返回 False；前面那个 isinstance() 是判断 对象，这就是判断 类。

语法: issubclass(class, classinfo)

参数：
class ———— 想要判断的 类 ；
classinfo ———— 父类 的名称，可以是一个 元祖（Tuple）用来表达多个父类。

返回值： 布尔型，非 真 即 假。

示例：

# -*- coding: UTF-8 -*-

print(" str 是 object 的子类吗？",issubclass(str,object))

print(" list 是 dict 的子类吗？",issubclass(list,dict))

print(" bool 是 int 的子类吗？",issubclass(bool,int))

运行结果留给你做作业吧。

4.12、 id() 对象的唯一标识符

在一个 Python 程序中，每一个对象（Object）都有一个唯一的标识符，就是一个整数（类似每个人的身份证）。CPython 中 id() 函数用于获取对象的内存地址。

语法： id(object)

参数：
object ———— 一个 对象（Object）；

返回值： 一个整数，代表对象（Object）的唯一的标识符。

示例：

# -*- coding: UTF-8 -*-

print("object 的唯一 id 是：", id(object))

print("dict() 的唯一 id 是：", id(dict))
"""运行结果
object 的唯一 id 是： 140707153280192
dict() 的唯一 id 是： 140707153234016
"""

4.13、 hash() 获取哈希值

获取取一个对象（字符串或者数值等）的哈希值。简单解释一下 哈希值 ，其实就是一串固定长度的整数值，用来对应一个 对象（Object），通常用在 压缩 和 加密 上。很明显，对象（Object） 千千万万无穷无尽，但 哈希值 肯定是有限的。关于 哈希 的讨论还是参考别的书本吧，此处就不展开了。

语法： hash(object)

参数：
object ———— 一个 字符串 或者 数值 对象（Object）；

返回值： 对象（Object）的 哈希值。

示例：

# -*- coding: UTF-8 -*-

print("小写字母 a 的哈希值是： ",hash('a'))

print("数字 100 的哈希值是： ",hash(100))
"""
运行结果
小写字母 a 的哈希值是：  8536843066558267055
数字 100 的哈希值是：  100
"""

关于 哈希值 最近一次的辉煌莫过于区块链、比特币/以太坊 的故事了，有兴趣可以参考一下。

4.14、 memoryview() 内存视图对象

返回给定 参数 的内存视图对象(memory view)。所谓 内存视图对象，官方非人话版： 是指允许 Python 代码访问一个对象（Object）的内部数据，这个对象（Object）支持 缓冲区协议 而无需进行拷贝。翻译翻译：就是为了节省一下在内存中复制一次对象这个操作，直接访问在内存中的对象的一部分。当然这个对象要求是保存在内存中连续的一段地址中。有些对象在内存中是连续保存的，比如 字符串、列表（List）、元组（Tuple）等，有些则不是，比如 字典（Dict）。

语法： memoryview(obj)

参数： obj ———— 一个支持 缓冲区协议 的对象（Object）。

返回值：一个 内存视图对象。

# -*- coding: UTF-8 -*-

v = memoryview(bytearray("abcefg", 'utf-8'))

print("内存视图对象",type(v))

for i in v:
    print(i)

"""
运行结果
内存视图对象 <class 'memoryview'>
97
98
99
101
102
103
"""

这个函数确实用得少，需要玩点 C/C++ 的玩意儿了。

4.15、 property() 操作对象的属性

这个函数比较厉害，常用于 高阶函数 带装饰器的函数 配合使用。这个函数自带几个参数，并且这些参数本身也是 方法（函数），包括：获取属性、设置属性以及删除属性。一个顶三个 getattr()、setattr()、delattr()

语法：property(fget=None, fset=None, fdel=None, doc=None)

参数：
fget ———— 获取属性值的函数； fset ———— 设置属性值的函数； fdel ———— 删除属性值的函数； doc ———— 为属性对象创建文档字符串；

返回 property 属性

示例：略

4.16、 super() 调用超类

用于调用父类(超类)的函数。超类： 是指 2层以上的继承关系，假如 类（Class） C 是继承自 类（Class）B ，而 B 又继承自 类 A ，那么 A 就是 C 的 超类（爷爷）。

此函数是用来解决多重继承问题的，直接用 类（Class） 名称调用 父类 的方法（函数），在 一层继承 关系时没问题，但是如果使用多重继承（即一个 类，继承了 2 个或多个 父类 ），会涉及到查找顺序（MRO）、重复调用（钻石/棱形继承）等种种问题。

MRO 就是类（Class）的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

语法: super(type, object-or-type)

参数：
type ———— 表示 类（Class）名称；
object-or-type ———— 也是表示 类（Class）名称，一般是 self；

返回值：无

这个玩得太高级了，实际运用中很少用到。（什么，你天天用？那你是 真*大佬）

4.17、 bytearray()/bytes() 返回二进制对象

bytearray() 返回一个 二进制 数组；bytes() 返回一个 二进制 对象；简单说，前者的返回值是 可变的，后者 不可变；结果都是包含范围为 0 <= x < 256 的整数。

语法：

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

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

参数：
source ———— 表示 想要转换成二进制的 源数据；
encoding ———— 这个参数只有当 source 是 字符串 时，才用上。表达 字符集；
errors ———— 这个参数 也只有当 source 时用得上，但实际运用上很少使用；

返回值： 二进制 数组（可变的）；bytes() 返回一个 二进制 对象（不可变）

示例：

# -*- coding: UTF-8 -*-

print("整数 0 转换成 二进制 数组",bytearray(0))
print("整数 1 转换成 二进制 数组",bytearray(1))
print("字符 简体字 转换成 二进制 数组",bytearray("简体字","utf-8"))

print("整数 0 转换成 二进制 对象",bytes(0))
print("整数 1 转换成 二进制 对象",bytes(1))
print("字符 简体字 转换成 二进制 对象",bytes("简体字","utf-8"))
"""
整数 0 转换成 二进制 数组 bytearray(b'')
整数 1 转换成 二进制 数组 bytearray(b'\x00')
字符 简体字 转换成 二进制 数组 bytearray(b'\xe7\xae\x80\xe4\xbd\x93\xe5\xad\x97')

整数 0 转换成 二进制 对象 b''
整数 1 转换成 二进制 对象 b'\x00'
字符 简体字 转换成 二进制 对象 b'\xe7\xae\x80\xe4\xbd\x93\xe5\xad\x97'
"""

当然，这2个内置函数，都很少使用。 😄

类、对象 函数小结

Python 是面向对象的计算机语言，当然 对象（Object） 是相当重要的。从 创建 对象、到操作对象的 属性，包括查询、获取、设置、删除这些基本动作那必须有啊。还有一些比较高级的玩法，就用得少了。当然大神天天玩，可以玩出花来。

五、程序执行相关的函数

5.1、 callable() 是否可调用

用于检查一个 对象（Object） 是/否 是可调用的。如果返回 True， 仍然可能调用失败；但如果返回 False，则肯定不能调用。

方法（函数）、lambda 、 类、肯定都是可调用的，调用 类 将返回一个新的实例）；如果 实例 所属的 类 有 __call__() 则它就是可调用的。

语法： callable(object)

参数：
object -- 实际运用中大多数情况是一个 方法（函数），就是调用前检查下，能不能调用嘛。

返回值： 布尔值 True / False

示例：

# -*- coding: UTF-8 -*-

print("整数 0 可以被调用吗？",callable(0))

print("字符串 abc 可以被调用吗？",callable("abc"))

print("内置函数 abs() 可以被调用吗？",callable(abs)) 

print("祖宗 类 object 可以被调用吗？",callable(object))
"""
运行结果：
整数 0 可以被调用吗？ False
字符串 abc 可以被调用吗？ False
内置函数 abs() 可以被调用吗？ True
祖宗 类 object 可以被调用吗？ True
"""

5.2、 map() 执行函数的多个参数

这个函数主要用于优化代码。简单说就是为了执行同一个函数，测试不同的参数，然后， 把执行完后的返回结果都收集起来，放在一个 迭代器 中。如此，访问这个 迭代器，就可以知道传给 函数 不同的参数的执行结果了。

语法： map(function, iterable, ...)

参数：
function ———— 要执行的函数；
iterable ———— 是一个 可迭代的参数列表，每次取出其中一项，做为参数传给要执行的函数；

返回值：一个迭代器，其中是包含每一个函数执行的结果。

示例：

# -*- coding: UTF-8 -*-

# 把 数字 都转换成 绝对值 
aaa = map(abs,[-99,-3.1415926 ])

print(next(aaa))
print(next(aaa))
"""
运行结果
99
3.1415926  
"""

这是一个很有 Python 范儿的函数，可以方便的测试自定义函数的多种不同的参数。灵活运用可以让代码更漂亮。当然用 循环 来实现同样的功能也是一样的，只是没这么优雅。

5.3、 eval() 执行字符串表达式

就是返回字符串执行的结果。可是简单的，如“x+1”，结果为 2；也可以是一串源码。（厉害了，老铁，这复制粘帖的位置可算找着了。）通常与 repr() 配合使用。

语法：eval(expression, globals=None, locals=None)

参数：
expression ———— 字符串，就是一个简单的表达式；
globals ———— 变量作用域，全局命名空间，如果用到此参数，必须是一个字典对象；
locals ———— 变量作用域，局部命名空间，如果用此参数，可以是任何映射对象；

返回值： 表达式执行的结果。

示例：

# -*- coding: UTF-8 -*-

x=1
print("x+1 表达式的结果：",eval('x+1'))

print("abs(-199)",eval("abs(-199)"))
"""运行结果
x+1 表达式的结果： 2
abs(-199) 199
"""

有个常用的技巧就是可以用这个函数把 字符串 转换成 列表（List）、字典（Dict）或 元组（Tuple），你想到了吗？

# -*- coding: UTF-8 -*-

a01 = "[1,2,3,4,5,6]"
b01 = "{'a':100,'b':200,'c':300}"

a02 = eval(a01)
print("a02的类型是：",type(a02))
print("a02的内容是：",a02)

b02 = eval(b01)
print("b02的类型是：",type(b02))
print("b02的内容是：",b02)
"""
运行结果
a02的类型是： <class 'list'>
a02的内容是： [1, 2, 3, 4, 5, 6]

b02的类型是： <class 'dict'>
b02的内容是： {'a': 100, 'b': 200, 'c': 300}
"""

上例有没有启发到你呢？

5.4、 repr() 转化源码

此函数可以将 对象 转化成供解释器读取的源码字符串。通常与 eval() 配合使用。

语法:repr(object)

参数：
object ———— 一个可以转化成解释器可以读取的源码字符串对象（Objcet）；

返回值： 一个字符串。

示例：

# -*- coding: UTF-8 -*-

a = {"a":1, "b":2,"c":3}
print(a)
print("a 的类型是：",type(a))

b = str(a)
print("b 的类型是：",type(b))

c = repr(a)
print("c 的类型是：",type(c))

TIP

str() 和 repr () 的区别：

str() 一般用于将 数值 转成 字符串，str()函数得到的 字符串 可读性好（通常直接给 print() 用）

repr() 是将一个 对象 转成 供解释器读取的形式，支持 字典（Dict） 和 列表（List)。 repr 是 representation 描述 的意思，不是对人的描述，而是对 Python 机器的描述，对python友好。

repr() 与 eval() 是互相转换的功能，通常情况下 obj==eval(repr(obj)) 是成立的。

5.5、 exec() 动态执行 Python 代码

就是字面意思，就是执行 Python 代码。

语法：exec(object, globals, locals)

参数：
object ———— 它必须是 字符串 或 code 对象。如果是字符串，该字符串会先被解析为一组 Python 语句，然后再执行（除非发生语法错误）。如果 object 是一个 code 对象，那么它只是被简单的执行。
globals ———— 变量作用域，全局命名空间，如果用到此参数，必须是一个字典对象；
locals ———— 变量作用域，局部命名空间，如果用此参数，可以是任何映射对象；

返回值： None

示例：

# -*- coding: UTF-8 -*-

exec('print("Hello World")')

exec("""for i in range(5):
            print ("for 循环次数: %d" % i)
     """
    )

运行结果：
Hello World

for 循环次数:0
for 循环次数:1
for 循环次数:2
for 循环次数:3
for 循环次数:4

这个 exec() 比 eval() 厉害多了吧。

5.6、 classmethod 修饰为类方法

这可是一个玩法比较高级的函数，一般二般的小萌新还真用不到。常见于在自定义一个 类（Class）时， 把这个 类（Class）中的某一个方法（函数）封装成 类方法。没有用这个函数修饰的 方法（函数），通常被称为 实例方法。

语法： @classmethod

因为有个 @ 字符，它看上去就象一个 装饰器。（我突然发现基础篇中，居然没有讲到 装饰器，有罪。）

然后，在下一行直接写自定义的方法（函数）就可以了。

示例：

class ABC:
    @classmethod
    def ABC_func01(cls, arg1, arg2):
        pass

如示例中，自定义了一个类叫 ABC，然后用到了 @classmethod ，接下来写的方法（函数） ABC_func01 就是一个 类方法了。能在实际应用中用到这个函数的，一定也是个大佬了，通常想修改一个 类（Class）的时候，想要为这个 类（Class）添加一些新的方法（函数），但又不想去破坏原来的那个 类（Class）。于是就可以先 继承 一下，然后在 继承而来的 类（Class）中，用 @classmethod来修饰一下新的方法（函数）。这就叫 专业！

在3.11 版之后: 类方法 不能再包含其它描述符了，如property()。意即，用了 classmethod 修饰过的方法（函数）中，不能再修饰了。

5.7、 staticmethod() 静态方法

将对象（Object）的方法（函数）转换为 静态方法。静态方法不会接收隐式的第一个参数。

语法：

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

这可是一个高级的玩法，新手很少用到。至少要理解了 高阶函数、装饰器...... 这些概念，才能用上。

5.8、 compile() 编译成 AST

这个内置函数用于把 python 源码 编译成 AST 对象的。这可是很高级的 魔法 了。AST 抽象语法树，可以简单的理解为介于 源码和 ByteCode 之间的中间状态，在语义上更加接近 VM 的底层，可以精准的控制 Python 代码的最终执行情况。总之很厉害的样子。

语法: compile(source, filename, mode[, flags[, dont_inherit]])

参数：

source -- 字符串 或者 AST（Abstract Syntax Trees抽象语法树）对象。
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值（经常会使用 'string'）。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。如果 source 是语句序列，可以是 'exec'；如果是单一表达式，可以是 'eval'；如果是单个交互式语句，可以是 'single'。（在最后一种情况下，如果表达式执行结果不是 None 将会被打印出来。）
以下是可选参数
可选参数 flags 和 dont_inherit 控制应当激活哪个 编译器选项 以及应当允许哪个 future 特性。 如果两者都未提供 (或都为零) 则代码会应用与调用 compile() 的代码相同的旗标来编译。 如果给出了 flags 参数而未给出 dont_inherit (或者为零) 则会在无论如何都将被使用的旗标之外还会额外使用 flags 参数所指定的编译器选项和 future 语句。 如果 dont_inherit 为非零整数，则只使用 flags 参数 -- 外围代码中的旗标 (future 特性和编译器选项) 会被忽略。

返回值：执行结果。

确实很高级吧，也确实用得少。

5.9、 breakpoint() 设置断点

在程序中设置一个断点，用来调试程序用。实际运用中很少用到此函数，因为 调试程序、设置断点 这些功能已经被强大的 IDE 功能替代了。

breakpoint(*args, **kws)

执行函数小结

虽然现在编程一开口必须是 面向对象，但基本的函数、指令、语句依然是写代码的日常。因此，函数的调用、传参、以及调试、debug 等操作，还是十分必要的。特别是 Python 中还有一些高级函数的玩法，如 偏函数、闭包、装饰器、返回函数等操作，依然是支持的。

附： import() 动态加载

如果一个 模块 经常变化就可以使用 __import__() 来动态载入。

TIP

这是几乎用不上的高级函数，要用到这个函数：
一、说明你是大神；
二、说明你与多人合作开发任务中；
三、这些人开发的 模块 还不稳定，经常有变；
（那你着实牛逼了、或者在一群 SB 中工作，祝一切顺利）

语法：__import__(name, globals=None, locals=None, fromlist=(), level=0)

参数：
name ———— 想导入的模块名称；
globals ———— 导入后的全局名称；
locals ———— 导入后的局部名称；
fromlist ———— 导入的 类 或 子模块 的名称；
level ———— 表示模块的 路径 是绝对路径 还是 相对路径；

返回值：模块对象

建议用 import 语句导入模块。

附表：内置函数表（按字母排序）

这真是个大坑，好歹也填了，不然基础不牢、功夫不稳。截止到 2022/10 ， Python 的版本已经来到了 3.11，但内置函数还是没有太大变化，依然如下表所示：

Built-in Functions 内置函数
A abs() aiter() all() any() anext() ascii() B bin() bool() breakpoint() bytearray() bytes() C callable() chr() classmethod() compile() complex() D delattr() dict() dir() divmod()	E enumerate() eval() exec() F filter() float() format() frozenset() G getattr() globals() H hasattr() hash() help() hex() I id() input() int() isinstance() issubclass() iter()	L len() list() locals() M map() max() memoryview() min() N next() O object() oct() open() ord() P pow() print() property()	R range() repr() reversed() round() S set() setattr() slice() sorted() staticmethod() str() sum() super() T tuple() type() V vars() Z zip() _ __import__()

官网链接：

https://docs.python.org/zh-cn/3/library/functions.html?highlight=built#ascii