Python-入门-模块和包(十三)

￡神魔★判官ぃ 2023-10-02 21:45 21阅读 0赞

#### 文章目录 ####

*  Python-入门-模块和包
 *   *  导入模块
     *  自定义模块
     *  自定义模块编写说明文档
     *  导入文件名中带空格与文件名以数字开头的模块
     *  \\\_\\\_name\\\_\\\_=='\\\_\\\_main\\\_\\\_'作用详解
     *  导入模块的3种扩展方式
     *  动态执行模块
     *  模块内成员私有
     *   多模块管理(包的概念)
     *  查看模块（变量、函数、类）方法
     *  查看模块文档
     *  Python第三方库（模块）下载和安装

## Python-入门-模块和包 ##

我们已经使用了很多模块（如 string、sys、os 等），通过向程序中导入这些模块，我们可以使用很多“现成”的函数实现想要的功能。

那么，模块到底是什么，模块内部到底是什么样子的，模块可以自定义吗？

Python 提供了强大的模块支持，主要体现在，不仅 Python 标准库中包含了大量的模块（称为标准模块），还有大量的第三方模块，开发者自己也可以开发自定义模块。通过这些强大的模块可以极大地提高开发者的开发效率。

那么，模块到底指的是什么呢？模块，英文为 Modules，至于模块到底是什么，可以用一句话总结：模块就是 Python 程序。换句话说，任何 Python 程序都可以作为模块，包括在前面章节中写的所有 Python 程序，都可以作为模块。

模块可以比作一盒积木，通过它可以拼出多种主题的玩具，这与前面介绍的函数不同，一个函数仅相当于一块积木，而一个模块（.py 文件）中可以包含多个函数，也就是很多积木。模块和函数的关系如图 所示。  
![在这里插入图片描述][04aed3e5a4a24d339d5a3ccd94a0300c.png]

经过前面的学习，读者已经能够将 Python 代码写到一个文件中，但随着程序功能的复杂，程序体积会不断变大，为了便于维护，通常会将其分为多个文件（模块），这样不仅可以提高代码的可维护性，还可以提高代码的可重用性。

前面讲了封装，并且还介绍了很多具有封装特性的结构，比如说：

*  诸多容器，例如列表、元组、字符串、字典等，它们都是对数据的封装；
 *  函数是对 Python 代码的封装；
 *  类是对方法和属性的封装，也可以说是对函数和数据的封装。

本节所介绍的模块，可以理解为是对代码更高级的封装，即把能够实现某一特定功能的代码编写在同一个 .py 文件中，并将其作为一个独立的模块，这样既可以方便其它程序或脚本导入并使用，同时还能有效避免函数名和变量名发生冲突。。

举个简单的例子，在某一目录下创建一个名为 hello.py 文件，其包含的代码如下：

def say ():
            print("Hello,World!")

**在同一目录下**，再创建一个 say.py 文件，其包含的代码如下：

#通过 import 关键字，将 hello.py 模块引入此文件
        import hello
        hello.say()

读者可能注意到，say.py 文件中使用了原本在 hello.py 文件中才有的 say() 函数，相对于 day.py 来说，hello.py 就是一个自定义的模块,我们只需要将 hellp.py 模块导入到 say.py 文件中，就可以直接在 say.py 文件中使用模块中的资源。

与此同时，当调用模块中的 say() 函数时，使用的语法格式为“模块名.函数”，这是因为，相对于 say.py 文件，hello.py 文件中的代码自成一个命名空间，因此在调用其他模块中的函数时，需要明确指明函数的出处，否则 Python 解释器将会报错。

### 导入模块 ###

使用 Python 进行编程时，有些功能没必须自己实现，可以借助 Python 现有的标准库或者其他人提供的第三方库。比如说，在前面章节中，我们使用了一些数学函数，例如余弦函数 cos()、绝对值函数 fabs() 等，它们位于 Python 标准库中的 math（或 cmath）模块中，只需要将此模块导入到当前程序，就可以直接拿来用。

前面中，已经看到使用 import 导入模块的语法，但实际上 import 还有更多详细的用法，主要有以下两种：

1.  `import 模块名1 [as 别名1], 模块名2 [as 别名2]，…`：使用这种语法格式的 import 语句，**会导入指定模块中的所有成员**（包括变量、函数、类等）。不仅如此，当需要使用模块中的成员时，**需用该模块名（或别名）作为前缀**，否则 Python 解释器会报错。
2.  `from 模块名 import 成员名1 [as 别名1]，成员名2 [as 别名2]，…`： 使用这种语法格式的 import 语句，**只会导入模块中指定的成员**，而不是全部成员。同时，当程序中使用该成员时，无需附加任何前缀，**直接使用成员名**（或别名）即可。

注意，用 \[\] 括起来的部分，可以使用，也可以省略。其中，第二种 import 语句也可以导入指定模块中的所有成员，即使用`form 模块名 import ＊`，但此方式不推荐使用

> import 模块名 as 别名

# 导入sys整个模块
        import sys
        # 使用sys模块名作为前缀来访问模块中的成员
        print(sys.argv[0])

上面第 2 行代码使用最简单的方式导入了 sys 模块，因此在程序中使用 sys 模块内的成员时，必须添加模块名作为前缀。

导入整个模块时，也可以为模块指定别名。例如如下程序：

# 导入sys整个模块，并指定别名为s
        import sys as s
        # 使用s模块别名作为前缀来访问模块中的成员
        print(s.argv[0])

也可以一次导入多个模块，多个模块之间用逗号隔开。例如如下程序：

# 导入sys、os两个模块
        import sys,os
        # 使用模块名作为前缀来访问模块中的成员
        print(sys.argv[0])
        # os模块的sep变量代表平台上的路径分隔符
        print(os.sep)

在导入多个模块的同时，也可以为模块指定别名，例如如下程序：

# 导入sys、os两个模块，并为sys指定别名s，为os指定别名o
        import sys as s,os as o
        # 使用模块别名作为前缀来访问模块中的成员
        print(s.argv[0])
        print(o.sep)

上面第 2 行代码一次导入了sys 和 os 两个模块，并分别为它们指定别名为 s、o，因此程序可以通过 s、o 两个前缀来使用 sys、os 两个模块内的成员。

> from 模块名 import 成员名 as 别名

# 导入sys模块的argv成员
        from sys import argv
        # 使用导入成员的语法，直接使用成员名访问
        print(argv[0])

第 2 行代码导入了 sys 模块中的 argv 成员，这样即可在程序中直接使用 argv 成员，无须使用任何前缀。

导入模块成员时，也可以为成员指定别名，例如如下程序：

# 导入sys模块的argv成员，并为其指定别名v
        from sys import argv as v
        # 使用导入成员（并指定别名）的语法，直接使用成员的别名访问
        print(v[0])

第 2 行代码导入了 sys 模块中的 argv 成员，并为该成员指定别名 v，这样即可在程序中通过别名 v 使用 argv 成员，无须使用任何前缀。

form…import 导入模块成员时，支持一次导入多个成员，例如如下程序：

# 导入sys模块的argv,winver成员
        from sys import argv, winver
        # 使用导入成员的语法，直接使用成员名访问
        print(argv[0])
        print(winver)

上面第 2 行代码导入了 sys 模块中的 argv、 winver 成员，这样即可在程序中直接使用 argv、winver 两个成员，无须使用任何前缀。

一次导入多个模块成员时，也可指定别名，同样使用 as 关键字为成员指定别名，例如如下程序：

# 导入sys模块的argv,winver成员，并为其指定别名v、wv
        from sys import argv as v, winver as wv
        # 使用导入成员（并指定别名）的语法，直接使用成员的别名访问
        print(v[0])
        print(wv)

上面第 2 行代码导入了 sys 模块中的 argv、winver 成员，并分别为它们指定了别名 v、wv，这样即可在程序中通过 v 和 wv 两个别名使用 argv、winver 成员，无须使用任何前缀。

需要说明的是，一般不推荐使用`from 模块 import *`这种语法导入指定模块内的所有成员，因为它存在潜在的风险。比如同时导入 module1 和 module2 内的所有成员，假如这两个模块内都有一个 foo() 函数，那么在调用的这个 foo() 函数到底是 module1 模块中的还是 module2 模块中的？因此，这种导入指定模块内所有成员的用法是有风险的。

### 自定义模块 ###

到目前为止，读者已经掌握了导入 Python 标准库并使用其成员（主要是函数）的方法，接下来要解决的问题是，怎样自定义一个模块呢？  
  
前面章节中讲过，Python 模块就是 Python 程序，换句话说，只要是 Python 程序，都可以作为模块导入。例如，下面定义了一个简单的模块（编写在 demo.py 文件中）：

name = "Python教程"
        add = "python"
        def say():
            print("人生苦短，我学Python！")

可以看到，我们在 demo.py 文件中放置了变量（name 和 add）、函数 say()，该文件就可以作为一个模板。

在此基础上，我们可以新建一个 test.py 文件，并在该文件中使用 demo.py 模板文件，即使用 import 语句导入 demo.py：`import demo`\`

注意，虽然 demo 模板文件的全称为 demo.py，但在使用 import 语句导入时，只需要使用该模板文件的名称即可。

### 自定义模块编写说明文档 ###

为自定义模块添加说明文档，和函数或类的添加方法相同，即只需在模块开头的位置定义一个字符串即可。例如，为 demo.py 模板文件添加一个说明文档：

'''
    demo 模块中包含以下内容：
    	name 字符串变量：初始值为“Python教程”
    	add    字符串变量：初始值为“python”
    	say() 函数	
    '''

我们可以通过模板的 \_\_doc\_\_ 属性，来访问模板的说明文档。例如，在 test.py 文件中添加如下代码：

import demo
        print(demo.__doc__)

### 导入文件名中带空格与文件名以数字开头的模块 ###

在导入模块文件中，发现了个问题，模块文件名如果包含空格，或者以数字开头的模块文件名，在导入时候会报错。

查阅了一些资料后，发现可以用’\_import\_\_'方法。**把\_\_import\_\_的返回值当做模块使用就能完美解决此类问题**。

abc = __import__("12-12 abc")

### \_\_name\_\_=='\_\_main\_\_'作用详解 ###

在阅读别人写的自定义模块时，经常会看到模块最后有如下这行判断语句：

if __name__ == '__main__':

这行代码的作用是什么呢？本节就详解讲解以下它的作用。

一般情况下，当我们写完自定义的模块之后，都会写一个测试代码，检验一些模块中各个功能是否能够成功运行。

\_\_name\_\_是指示当前py文件调用方式的方法。如果它等于"\_\_main\_\_"，就表示是直接执行。如果不是，则表示被别的文件调用

简单来说就是,在当前模块内执行那么就会调用main方法,如果是其他模块调用此模块,那么就不会执行main方法,而且一个文件中只能有一个main方法

### 导入模块的3种扩展方式 ###

很多初学者经常遇到这样的问题，即自定义 Python 模板后，在其它文件中用 import（或 from…import） 语句引入该文件时，Python 解释器同时如下错误：

ModuleNotFoundError: No module named ‘模块名’ 意思是 Python 找不到这个模块名，这是什么原因导致的呢？要想解决这个问题，读者要先搞清楚 Python 解释器查找模块文件的过程。

通常情况下，当使用 import 语句导入模块后，Python 会按照以下顺序查找指定的模块文件：

*  在当前目录，即当前执行的程序文件所在目录下查找；
 *  到 PYTHONPATH（环境变量）下的每个目录中查找；
 *  到 Python 默认的安装目录下查找。

以上所有涉及到的目录，都保存在标准模块 sys 的 sys.path 变量中，通过此变量我们可以看到指定程序文件支持查找的所有目录。换句话说，如果要导入的模块没有存储在 sys.path 显示的目录中，那么导入该模块并运行程序时，Python 解释器就会抛出 ModuleNotFoundError（未找到模块）异常。

import sys
    if __name__ == '__main__':
        print( sys.path )
        '''
         ['C:\\Users\\huanmin\\Desktop\\python学习\\Python-Study\\test',
    	 'C:\\Users\\huanmin\\Desktop\\python学习\\Python-Study',
         'E:\\PyCharm 2021.2.2\\plugins\\python\\helpers\\pycharm_display',
         'C:\\Users\\huanmin\\AppData\\Local\\Programs\\Python\\Python310\\python310.zip',
         'C:\\Users\\huanmin\\AppData\\Local\\Programs\\Python\\Python310\\DLLs',
         'C:\\Users\\huanmin\\AppData\\Local\\Programs\\Python\\Python310\\lib',
         'C:\\Users\\huanmin\\AppData\\Local\\Programs\\Python\\Python310',
         'C:\\Users\\huanmin\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages',
         'E:\\PyCharm 2021.2.2\\plugins\\python\\helpers\\pycharm_matplotlib_backend']

解决“Python找不到指定模块”的方法有 3 种，分别是：

1.  向 sys.path 中临时添加模块文件存储位置的完整路径；
2.  将模块放在 sys.path 变量中已包含的模块加载路径中；
3.  设置 path 系统环境变量。

> 临时添加模块完整路径

模块文件的存储位置，可以临时添加到 sys.path 变量中，即向 sys.path 中添加模块所在的**绝对目录**，添加如下代码：

import sys
        sys.path.append('D:\\python_module')

> 将模块保存到指定位置

如果要安装某些通用性模块，比如复数功能支持的模块、矩阵计算支持的模块、图形界面支持的模块等，这些都属于对 Python 本身进行扩展的模块，这种模块应该直接安装在 Python 内部，以便被所有程序共享，此时就可借助于 Python 默认的模块加载路径。

我们可以在 say.py 程序文件中先看看 sys.path 中保存的默认加载路径, 但通常来说，我们默认将 Python 的扩展模块添加在 `lib\site-packages` 路径下，它专门用于存放 Python 的扩展模块和包。

对应我电脑的`C:\\Users\\huanmin\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages`\`

所以，我们可以直接将我们已编写好的 py文件添加到 `lib\site-packages` 路径下，就相当于为 Python 扩展了一个模块，这样任何 Python 程序都可使用该模块。 而且日后跟换电脑了我们只需要将这个目录复制到新电脑里就行了

> 设置环境变量

PYTHONPATH 环境变量（简称 path 变量）的值是很多路径组成的集合，Python 解释器会按照 path 包含的路径进行一次搜索，直到找到指定要加载的模块。当然，如果最终依旧没有找到，则 Python 就报 ModuleNotFoundError 异常。

添加环境变量非常简单,无非就是将模块所在的目录绝对路径加入到环境变量里,这就不多说了,是个程序员都懂

### 动态执行模块 ###

一个定时任务的场景，数据库存了许多这样的定时任务：cmdb.tasks.get\_host\_info，它表示的是调用cmdb包下的tasks模块下的get\_host\_info函数。我们怎么实现，通过这种格式的字符串，去调用相应的函数呢？

def exec_task(task_name):
        if not task_name:
            return -1, "task name must not None"
        try:
            module_name = task_name.rsplit(".", 1)[0]
            method_name = task_name.rsplit(".", 1)[1]
    
            # 动态导入tasks模块
            module_obj = __import__(module_name)
            if not hasattr(module_obj, method_name):
                return -1, "function not found"
        except:
            return -1, "has Error"
    
        task = getattr(module_obj, method_name)
        task()

### 模块内成员私有 ###

事实上，当我们向文件导入某个模块时，导入的是该模块中那些名称不以下划线（单下划线“\_”或者双下划线“\_\_”）开头的变量、函数和类。因此，如果我们不想模块文件中的某个成员被引入到其它文件中使用，可以在其名称前添加下划线。

**注意:** 在python中没有私有的内容, 只有规定的约束,大家一起遵守而已, 所以加了下划线也是能被访问的,如果访问别的模块里带下划线的内容编译器会警告提示的

除此之外，还可以借助模块提供的 \_\_all\_\_ 变量，该变量的值是一个列表，存储的是当前模块中一些成员（变量、函数或者类）的名称。通过在模块文件中设置 \_\_all\_\_ 变量，当其它文件以“from 模块名 import \*”的形式导入该模块时，该文件中只能使用 \_\_all\_\_ 列表中指定的成员。

也就是说，只有以`from 模块名 import *`形式导入的模块，当该模块设有 \_\_all\_\_ 变量时，只能导入该变量指定的成员，未指定的成员是无法导入的。

class UnittestTest1(object):
    
        def test_1(self):
            pass
        def test_2(self):
            pass
    class UnittestTest2(object):
        pass
    
    def test_1(self):
        pass
    
    __all__ = ["UnittestTest1"] # 外部使用from 模块名 import *时,只能导入__all__中的类 ,其他导入方式不受影响

###  多模块管理(包的概念) ###

实际开发中，一个大型的项目往往需要使用成百上千的 Python 模块，如果将这些模块都堆放在一起，势必不好管理。而且，使用模块可以有效避免变量名或函数名重名引发的冲突，但是如果模块名重复怎么办呢？因此，Python提出了包（Package）的概念。

什么是包呢？简单理解，包就是文件夹，只不过在该文件夹下必须存在一个名为`__init__.py` 的文件。 注意，这是 Python 2.x 的规定，而在 Python 3.x 中，\_\_init\_\_.py 对包来说，并不是必须的。但是在开发的时候目录结构需要做好规范

![在这里插入图片描述][d41670c3fe304a00977a7c5b7e518b33.png]

**Python 库**：相比模块和包，库是一个更大的概念，例如在 Python 标准库中的每个库都有好多个包，而每个包中都有若干个模块。

### 查看模块（变量、函数、类）方法 ###

事实上，在前面章节的学习中，曾多次使用 dir() 函数。通过 dir() 函数，我们可以查看某指定模块包含的全部成员（包括变量、函数和类）。注意这里所指的全部成员，不仅包含可供我们调用的模块成员，还包含所有名称以双下划线“\_\_”开头和结尾的成员，而这些“特殊”命名的成员，是为了在本模块中使用的，并不希望被其它文件调用。

这里以导入 string 模块为例，string 模块包含操作字符串相关的大量方法，下面通过 dir() 函数查看该模块中包含哪些成员：

import string
        print(dir(string))

> \[‘Formatter’, ‘Template’, ‘\_ChainMap’, ‘\_TemplateMetaclass’, ‘\_\_all\_\_’, ‘\_\_builtins\_\_’, ‘\_\_cached\_\_’, ‘\_\_doc\_\_’, ‘\_\_file\_\_’, ‘\_\_loader\_\_’, ‘\_\_name\_\_’, ‘\_\_package\_\_’, ‘\_\_spec\_\_’, ‘\_re’, ‘\_string’, ‘ascii\_letters’, ‘ascii\_lowercase’, ‘ascii\_uppercase’, ‘capwords’, ‘digits’, ‘hexdigits’, ‘octdigits’, ‘printable’, ‘punctuation’, ‘whitespace’\]

可以看到，通过 dir() 函数获取到的模块成员，不仅包含供外部文件使用的成员，还包含很多“特殊”（名称以 2 个下划线开头和结束）的成员，列出这些成员，对我们并没有实际意义。

因此，这里给读者推荐一种可以忽略显示 dir() 函数输出的特殊成员的方法。仍以 string 模块为例：

import string
        print([e for e in dir(string) if not e.startswith('_')])

> \[‘Formatter’, ‘Template’, ‘ascii\_letters’, ‘ascii\_lowercase’, ‘ascii\_uppercase’, ‘capwords’, ‘digits’, ‘hexdigits’, ‘octdigits’, ‘printable’, ‘punctuation’, ‘whitespace’\]

显然通过列表推导式，可在 dir() 函数输出结果的基础上，筛选出对我们有用的成员并显示出来。

除了使用 dir() 函数之外，还可以使用 \_\_all\_\_ 变量，借助该变量也可以查看模块（包）内包含的所有成员。

import string
        print(string.__all__)

> \[‘ascii\_letters’, ‘ascii\_lowercase’, ‘ascii\_uppercase’, ‘capwords’, ‘digits’, ‘hexdigits’, ‘octdigits’, ‘printable’, ‘punctuation’, ‘whitespace’, ‘Formatter’, ‘Template’\]

显然，和 dir() 函数相比，\_\_all\_\_ 变量在查看指定模块成员时，它不会显示模块中的特殊成员，同时还会根据成员的名称进行排序显示。  
  
不过需要注意的是，并非所有的模块都支持使用 \_\_all\_\_ 变量，因此对于获取有些模块的成员，就只能使用 dir() 函数。

### 查看模块文档 ###

在使用 dir() 函数和 \_\_all\_\_ 变量的基础上，虽然我们能知晓指定模块（或包）中所有可用的成员（变量、函数和类）对于不熟悉 string 模块的用户，还是不清楚这些名称分别表示的是什么意思，更不清楚各个成员有什么功能。

针对这种情况，我们可以使用 help() 函数来获取该模块的帮助信息。

![在这里插入图片描述][1cba548d8626415c872d3a88deda6d88.png]

from src.file.FileBasics import FileBasics
    
    if __name__ == '__main__':
        print(help(FileBasics))

![在这里插入图片描述][5444a1fff242446faad3712d9e78ee7f.png]

无论是函数还是类，都可以使用 \_\_doc\_\_ 属性获取它们的说明文档，模块也不例外

from src.file.FileBasics import FileBasics
    
    if __name__ == '__main__':
        FileBasics.getProjectPath()
        print(FileBasics.getProjectPath.__doc__)

![在这里插入图片描述][c7b680312c1a406f8492a3b731c3543f.png]

### Python第三方库（模块）下载和安装 ###

进行 Python 程序开发时，除了使用 Python 内置的标准模块以及我们自定义的模块之外，还有很多第三方模块可以使用，这些第三方模块可以借助 Python官方提供的查找包页面[https://pypi.org/][https_pypi.org]

使用第三方模块之前，需要先下载并安装该模块，然后就能像使用标准模块和自定义模块那样导入并使用了。

下载和安装第三方模块，可以使用 Python 提供的 pip 命令实现。 注意: python2没有自带pip需要自己安装(自行百度安装), python3内置了pip

pip 命令的语法格式如下：`pip install|uninstall|list 模块名`\`

其中，install、uninstall、list 是常用的命令参数，各自的含义为：

1.  install：用于安装第三方模块，当 pip 使用 install 作为参数时，后面的模块名不能省略。
2.  uninstall：用于卸载已经安装的第三方模块，选择 uninstall 作为参数时，后面的模块名也不能省略。
3.  list：用于显示已经安装的第三方模块。

以安装 numpy 模块为例（该模块用于进行科学计算），可以在命令行窗口中输入以下代码：`pip install numpy`

执行此代码，它会在线自动安装 numpy 模块。安装完成后，将显示图 1 所示的结果：

![在这里插入图片描述][065ba5efc3c64799bddef8effefc7c61.png]

pip 命令会将下载完成的第三方模块，默认安装到 Python 安装目录中的 \\Lib\\site-packages 目录下。打开此目录，你就会发现 numpy 包，也就是 numpy 文件夹，如图 2 所示。

![在这里插入图片描述][b89cfcc2a46744d8b6cce996e35af139.png]

前面讲过，对于向程序中导入模块，\\Lib\\site-packages 目录是 Python 肯定会搜索的目录，因此位于此目录的模块，可以直接使用 import 语句引入，例如：

#直接导入 numpy 模块即可
    import numpy as nu
    #用 numpy 模块中的开发函数
    print(nu.sqrt(16))

如果只是想要查看已经安装的第三方模块，可以在使用如下命令：`pip list`\`

> pip国内常用镜像

清华大学：`https://pypi.tuna.tsinghua.edu.cn/simple`  
阿里云：`http://mirrors.aliyun.com/pypi/simple`  
中国科技大学 `https://pypi.mirrors.ustc.edu.cn/simple`  
华中理工大学：`http://pypi.hustunique.com/`  
山东理工大学：`http://pypi.sdutlinux.org`  
豆瓣：`http://pypi.douban.com/simple`  
网易：`http://mirrors.163.com`

临时使用方法: `pip install 安装包名 -i http://mirrors.aliyun.com/pypi/simple`

> 永久修改windows

1.  进入 C:\\Users\\当前使用的用户目录,创建pip文件夹
2.  在pip目录中，创建文本文档，修改文件名及格式为：pip.ini
3.  打开 pip.ini，复制粘贴以下内容，并保存文件即可

[global]
    index-url = http://mirrors.aliyun.com/pypi/simple
    [install]
    trusted-host = mirrors.aliyun.com

> 永久修改linux

1.  输入 vim ~/.pip/pip.conf（vim 或 vi 均可）
2.  复制粘贴以下内容

[global]
    index-url = http://mirrors.aliyun.com/pypi/simple
    [install]
    trusted-host = mirrors.aliyun.com

如果安装过程中遇到pip环境工具问题，可以通过以下命令重装pip和pip3

sudo apt-get install --reinstall python3-pip
    sudo apt-get install --reinstall python-pip

![在这里插入图片描述][241d60d901ab468c8532f2a2d4413093.gif]

点赞 -收藏-关注-便于以后复习和收到最新内容有其他问题在评论区讨论-或者私信我-收到会在第一时间回复在本博客学习的技术不得以任何方式直接或者间接的从事违反中华人民共和国法律,内容仅供学习、交流与参考 免责声明：本文部分素材来源于网络，版权归原创者所有，如存在文章/图片/音视频等使用不当的情况，请随时私信联系我、以迅速采取适当措施，避免给双方造成不必要的经济损失。感谢,配合,希望我的努力对你有帮助^\_^

[04aed3e5a4a24d339d5a3ccd94a0300c.png]: https://img-blog.csdnimg.cn/04aed3e5a4a24d339d5a3ccd94a0300c.png
[d41670c3fe304a00977a7c5b7e518b33.png]: https://img-blog.csdnimg.cn/d41670c3fe304a00977a7c5b7e518b33.png
[1cba548d8626415c872d3a88deda6d88.png]: https://img-blog.csdnimg.cn/1cba548d8626415c872d3a88deda6d88.png
[5444a1fff242446faad3712d9e78ee7f.png]: https://img-blog.csdnimg.cn/5444a1fff242446faad3712d9e78ee7f.png
[c7b680312c1a406f8492a3b731c3543f.png]: https://img-blog.csdnimg.cn/c7b680312c1a406f8492a3b731c3543f.png
[https_pypi.org]: https://pypi.org/
[065ba5efc3c64799bddef8effefc7c61.png]: https://img-blog.csdnimg.cn/065ba5efc3c64799bddef8effefc7c61.png
[b89cfcc2a46744d8b6cce996e35af139.png]: https://img-blog.csdnimg.cn/b89cfcc2a46744d8b6cce996e35af139.png
[241d60d901ab468c8532f2a2d4413093.gif]: https://img-blog.csdnimg.cn/241d60d901ab468c8532f2a2d4413093.gif