摘自：https://zhuanlan.zhihu.com/p/340965963

在Python中，被称为「程序的入口」的 if __name__ ==’__main__’: 总是出现在各种示例代码中，有一种流传广泛的错误观点是「这只是Python的一种编码习惯」。事实上程序的入口非常有用，绝非可有可无，例如在Python自带的多线程库要求必须把主进程写在 if入口内部才能正常运行。

直接写在Python最左端没有缩进的代码，在这个 *.py 文件被直接运行、或者被调用时会被执行，只有写在 if __name__ ==’__main__’: if入口内部才不会在被调用时执行。Python用这个简单的方法来判断当前的模块是被直接运行还是被调用，这是很重要的功能，如：

• 我们可以把不想在被调用时执行的代码放在程序入口的if内部，比如自检程序。
• 我们还把多线程的主线程写在程序入口的if内部。只能这么做，避免自己调用自己时重复执行主进程，下面会详细解释。

因此，初学Python时，直接把主程序写在不需要缩进的位置，完全不写 if __name__ ==’__main__’: 当然可以。一个既没有写一个被调用的库的能力，也不一定要学多进程的新手，很容易错误地认为「程序的入口」没什么用。

类似的，还有被少数人误解的还有 Python的文件头：

#!/bin/bash/python3  # 这一句话用来在代码被执行时，主动说明该选哪个路径下的编译器
#!/bin/bash/python2  # 例如这一句就选了Python2，不过2020年Python2快要完成过渡使命了

2020年底，我在写Python多进程教程时，没有搜索到合适的文章解释“程序的入口 if __name__ ==’__main__’: 与多线程的必要联系”，反而看到了很多高赞的片面回答。无奈之下只能自己写。对于少数有基础的人，下面讲程序入口与多线程部分也值得一看。

目录

• 「程序的入口」是什么？
• 程序入口与自检程序
• 程序入口与多线程

更新日志

• 第一版 2021-01-01 我会把评论区的好问题更新到正文里

「程序的入口」是什么？

用很短的话就能解释，我认可菜鸟分析↓的回答 ，部分高赞答案写得啰嗦

__name__ 是当前模块名，当模块被直接运行时模块名为 __main__ 。这句话的意思就是，当模块被直接运行时，以下代码块将被运行，当模块是被导入时，代码块不被运行。

举例说明：当我在终端直接运行 python3 run1.py时，模块名被一律改为字符串__main__，当模块是被另一个 *.py程序导入（如在 *.py 中 import run1）而不是直接运行时，模块名是字符串run1。

在C语言和Java里也有类似的「程序入口」：

# Python的程序入口
if __name__ =='__main__': # 它对多进程非常重要
    # 这里是主程序

# C语言的程序入口
void main(){
    /* 这里是主程序 */
}

# Java的程序入口
public static void main(String[] args){
    // 这里是主程序
}

检验一下自己：下面的程序会print出什么东西？

# 新建一个名为【run1.py】的文件，填入下方代码
# 然后在终端输入【python3 run1.py】并运行

print(__name__, 'run1-outside')    # 它会print出【__main__ run1-outside】
if __name__ =='__main__':
    print(__name__, 'run1-inside') # 它会print出【__main__ run1-inside】

再检验一下自己：

# 新建另一个名为【run2.py】的文件，填入下方代码，并放在与【run1.py】的相同目录下，
# 然后在终端输入【python3 run2.py】并运行。用run2 调用run1

import run1  # 这一行代码调用了外部的代码 run1，它只会print出：
# 【run1 run1-outside】 # 它只print出这一行东西，并且run1.py的【__main__】变成了【run1】
# 【run1 run1-inside】  # 写在run1【if】缩进里的东西都没有被执行

print(__name__, 'run2-outside')    # 它会print出【__main__ run2-outside】
if __name__ =='__main__':
    print(__name__, 'run2-inside') # 它会print出【__main__ run2-inside】

程序入口与自检程序

当一个开发者编写一个库时（例如把它命名为 utils.py），如

# 这个库（模块）被命名为 utils.py
class C1:
   ...
def func1():
   ...

c1 = C1()  # 这是错误的做法，应该挪到 程序入口if内部
func1()    # 这是错误的做法，应该挪到 程序入口if内部
if __name__ =='__main__':
    c = C1()
    func1()

当其他人只想调用 C1 或者 func1时，他在另一个Python文件中，用 import utils 导入 utils这个库时就不会运行程序入口if内部的任何代码了。

程序入口与多线程

实现多线程时，「程序入口」这个功能不可或缺。我需要同时运行多个 fun1，或者同时运行 fun1 fun2 … 如下：

def function1(id):  # 这里是子进程
    print(f'id {id}')

def run__process():  # 这里是主进程
    from multiprocessing import Process
    process = [mp.Process(target=function1, args=(1,)),
               mp.Process(target=function1, args=(2,)), ]
    [p.start() for p in process]  # 开启了两个进程
    [p.join() for p in process]   # 等待两个进程依次结束

# run__mp()  # 主线程不建议写在 if外部。由于这里的例子很简单，你强行这么做可能不会报错
if __name__ =='__main__':
    run__mp()  # 正确做法：主线程只能写在 if内部

当我运行上面这个程序，它的【__name__ ==’__main__’】，因此它会执行 【if】内的代码。这些代码会创建新的多个子进程，自己调用自己。在被调用的子进程中，它的【__name__】 不等于【__main__】，因此它只会执行被主进程分配的任务（比如fun1），而不会像主进程一样通过「程序入口」再调用别的进程（行此僭越之事）。这是一个非常重要的功能，这里讲的不仅是Python，其他成熟的编程语言也能用相似的方法。

RuntimeError: context has already been set(multiprocessing) #3492 PyTorch Issue

由于我上面的例子过于简单（没有涉及进程通信、进程退出条件），如果你强行把主进程写在 if外部，也可能不会看到报错。这涉及很多因素，它与你使用的系统、子进程的创建方式（spwan、fork、forkserver、force=True/False）有关。我在这里只讲「程序的入口」，更多内容请移步 Compulsory usage of if __name__==“__main__” in windows while using multiprocessing – Stack Overflow ，Tim Peters 与 David Heffernan 的回答都不错。

尽管Python的多进程已经做得挺不错了，希望随着以后版本的更新，多进程与「程序入口」的依赖关系应该能得到更好的解决。

使用PyTorch CUDA multiprocessing 的时候出现的错误 UserWarning: semaphore_tracker

（写于2021-03-03）

错误如下：

multiprocessing/semaphore_tracker.py:144: 
UserWarning: semaphore_tracker: There appear to be 1 leaked semaphores to clean up at shutdown
  len(cache))

Issue with multiprocessing semaphore tracking

相同问题描述：

semaphore_tracker: There appear to be 1 leaked semaphores to clean up at shutdown len(cache)) #200

解决方案：

Issue with multiprocessing semaphore tracking – sbelharbi 的解决方案

即在运行 .py 文件前，使用以下语句修改环境参数，忽略这个Warning 带来的程序暂停

export PYTHONWARNINGS='ignore:semaphore_tracker:UserWarning'

等同于在 .py 文件内部使用：

os.environ['PYTHONWARNINGS'] = 'ignore:semaphore_tracker:UserWarning'

摘自知乎：https://zhuanlan.zhihu.com/p/340657122

Python自带的多进程库 multiprocessing 可实现多进程。我想用这些短例子示范如何优雅地用多线程。中文网络上，有些人只是翻译了旧版的 Python官网的多进程文档。而我这篇文章会额外讲一讲下方加粗部分的内容。

• 创建进程 Process，fork直接继承资源，所以初始化更快，spawn只继承必要的资源，所以更省内存，「程序的入口」 if name == main
• 进程池 Pool，Pool只能接受一个参数，但有办法传入多个
• 管道通信 Pipe，最基本的功能，运行速度快
• 队列通信 Queue，有最常用的功能，运行速度稍慢
• 共享内存 Manager Value，Python3.9 新特性 真正的共享内存 shared_memory

如下所示，中文网络上一些讲Python多进程的文章，很多重要的东西没讲（毕竟只是翻译了Python官网的多进程旧版文档）。上方的加粗部分他们没讲，但是这是做多进程总需要知道的内容。

• 若你无法流畅阅读有专人更新的Python官网多进程英文文档 ，那么姑且可看写于2019不保证更新的南山南：一篇文章搞定Python多进程(全)
• 知我莫言：谈谈python的GIL、多线程、多进程 ，点赞多但旧，写于2016，你还不如看我下方写的「简述何为多线程 threading与多进程 processing」

目录（请挑选感兴趣的看，没必要全看）

1. 多线程与多进程的区别
2. 全局锁与多进程
3. 子进程 Process
4. 进程池 Pool
5. 管道 Pipe
6. 队列 Queue
7. 共享内存 Manager
8. 回答评论区的有用问题（别私信）
9. 我为何写【在Python中优雅地用多进程】？

更新记录：第一版 2021-1-4，第二版 2021-1-8 被迫更新了一些私信问到的问题

1. 多线程与多进程的区别

多线程 threading： 一个人有与异性聊天和看剧两件事要做。单线程的她可以看完剧再去聊天，但这样子可能就没人陪她聊天了「哼，发消息不回」。我们把她看成一个CPU核心，为她开起多线程——先看一会剧，偶尔看看新消息，在两件事（线程）间来回切换。多线程：单个CPU核心可以同时做几件事，不至于卡在某一步傻等着。

用处：爬取网站信息（爬虫），等待多个用户输入

多进程 processing： 一个人有很多砖需要搬，他领取手套、推车各种物资（向系统申请了资源）然后开始搬砖。然而他身边有很多人，我们让这些人去帮他！（一核有难，八核围观）。于是他们做了分工，砖很快就搬完了。多进程让多个CPU核心可以一起做事，不至于只有一人干活而其他人傻站着。

用处：进行高性能计算。只有多进程方案设计合理，才能加速计算。

2. 全局锁与多进程

为何在Python里用多进程这么麻烦？ 因为Python的线程是操作系统线程，因此要有Python全局解释器锁。一个python解释器进程内有一条主线程，以及多条用户程序的执行线程。即使在多核CPU平台上，由于GIL的存在，所以禁止多线程的并行执行。——来自百度百科词条 全局解释器锁。发展历程：

1. Python全局锁。Python 3.2的时候更新过GIL。在我小时候，由于Python GIL的存在（全局解释器锁 Global Interpreter Lock） ，此时Python无法靠自己实现多进程
2. 外部多进程通信。Python3.5。在2015年，要么用Python调用C语言（如Numpy此类用其他语言在底层实现多进程的第三方库），要么需要在外部代码（MPI 2015）
3. 内置多进程通信。Python 3.6 才让 multiprocessing逐渐发展成一个能用的Python内置多进程库，可以进行进程间的通信，以及有限的内存共享
4. 共享内存。Python 3.8 在2019年增加了新特性 shared_memory

3. 子进程 Process

多进程的主进程一定要写在程序入口 if __name__ ==’__main__’: 内部

def function1(id):  # 这里是子进程
    print(f'id {id}')

def run__process():  # 这里是主进程
    from multiprocessing import Process
    process = [mp.Process(target=function1, args=(1,)),
               mp.Process(target=function1, args=(2,)), ]
    [p.start() for p in process]  # 开启了两个进程
    [p.join() for p in process]   # 等待两个进程依次结束

# run__process()  # 主线程不建议写在 if外部。由于这里的例子很简单，你强行这么做可能不会报错
if __name__ =='__main__':
    run__process()  # 正确做法：主线程只能写在 if内部

尽管在这个简单的例子里，把主进程run__process()写在程序入口if外部不会有报错。但是你最好还是按我要求去做。详细解释的内容过长，我写在→「Python程序入口有重要功能（多线程）而非编程习惯」

上面的例子只是用Process开启了多进程，不涉及进程通信。当我准备把一个串行任务编排成多进程时，我还需要多进程通信。进程池Pool可以让主程序获得子进程的计算结果（不太灵活，适合简单任务），管道Pipe 队列Queue 等等 可以让进程之间进行通信（足够灵活）。共享值 Value 共享数组 Array 共享内容 shared_memory（Python 3.6 Python3.9 的新特性，还不太成熟）下面开讲。

Python多进程可以选择两种创建进程的方式，spawn 与 fork。分支创建：fork会直接复制一份自己给子进程运行，并把自己所有资源的handle 都让子进程继承，因而创建速度很快，但更占用内存资源。分产创建：spawn只会把必要的资源的handle 交给子进程，因此创建速度稍慢。详细解释请看 Stack OverFlow multiprocessing fork vs spawn 。（分产spawn 是我自己随便翻译的，有更好的翻译请推荐。我绝不把handle 翻译成句柄）

multiprocessing.set_start_method('spawn')  # default on WinOS or MacOS
multiprocessing.set_start_method('fork')   # default on Linux (UnixOS)

请注意：我说 分支fork 在初始化创建多进程的时候比 分产spawn 快，而不是说高性能计算会比较快。通常高性能计算需要让程序运行很久，因此为了节省内存以及进程安全，我建议选择 spawn。

4. 进程池 Pool

几乎Python多进程代码都需要你明明白白地调用Process。而进程池Pool 会自动帮我们管理子进程。Python的Pool 不方便传入多个参数，我这里提供两个解决思路：

思路1：函数 func2 需要传入多个参数，现在把它改成一个参数，无论你直接让args作为一个元组tuple、词典dict、类class都可以

思路2：使用 function.partial Passing multiple parameters to pool.map() function in Python。这个不灵活的方法固定了其他参数，且需要导入Python的内置库，我不推荐

import time

def func2(args):  # multiple parameters (arguments)
    # x, y = args
    x = args[0]  # write in this way, easier to locate errors
    y = args[1]  # write in this way, easier to locate errors

    time.sleep(1)  # pretend it is a time-consuming operation
    return x - y


def run__pool():  # main process
    from multiprocessing import Pool

    cpu_worker_num = 3
    process_args = [(1, 1), (9, 9), (4, 4), (3, 3), ]

    print(f'| inputs:  {process_args}')
    start_time = time.time()
    with Pool(cpu_worker_num) as p:
        outputs = p.map(func2, process_args)
    print(f'| outputs: {outputs}    TimeUsed: {time.time() - start_time:.1f}    \n')

    '''Another way (I don't recommend)
    Using 'functions.partial'. See https://stackoverflow.com/a/25553970/9293137
    from functools import partial
    # from functools import partial
    # pool.map(partial(f, a, b), iterable)
    '''

if __name__ =='__main__':
    run__pool()

5. 管道 Pipe

顾名思义，管道Pipe 有两端，因而 main_conn, child_conn = Pipe() ，管道的两端可以放在主进程或子进程内，我在实验中没发现主管道口main_conn 和子管道口child_conn 的区别。两端可以同时放进去东西，放进去的对象都经过了深拷贝：用 conn.send()在一端放入，用 conn.recv() 另一端取出，管道的两端可以同时给多个进程。conn是 connect的缩写。

import time

def func_pipe1(conn, p_id):
    print(p_id)

    time.sleep(0.1)
    conn.send(f'{p_id}_send1')
    print(p_id, 'send1')

    time.sleep(0.1)
    conn.send(f'{p_id}_send2')
    print(p_id, 'send2')

    time.sleep(0.1)
    rec = conn.recv()
    print(p_id, 'recv', rec)

    time.sleep(0.1)
    rec = conn.recv()
    print(p_id, 'recv', rec)


def func_pipe2(conn, p_id):
    print(p_id)

    time.sleep(0.1)
    conn.send(p_id)
    print(p_id, 'send')
    time.sleep(0.1)
    rec = conn.recv()
    print(p_id, 'recv', rec)


def run__pipe():
    from multiprocessing import Process, Pipe

    conn1, conn2 = Pipe()

    process = [Process(target=func_pipe1, args=(conn1, 'I1')),
               Process(target=func_pipe2, args=(conn2, 'I2')),
               Process(target=func_pipe2, args=(conn2, 'I3')), ]

    [p.start() for p in process]
    print('| Main', 'send')
    conn1.send(None)
    print('| Main', conn2.recv())
    [p.join() for p in process]

if __name__ =='__main__':
    run__pipe()

如果追求运行更快，那么最好使用管道Pipe而非下面介绍的队列Queue，详细请移步Python pipes and queues performance ↓

So yes, pipes are faster than queues – but only by 1.5 to 2 times, what did surprise me was that Python 3 is MUCH slower than Python 2 – most other tests I have done have been a bit up and down (as long as it is Python 3.4 – Python 3.2 seems to be a bit of a dog – especially for memory usage).

我小时候曾经用到Python多线程队列功能写过一个实际例子 ↓，若追求极致性能，还可以把里面的Queue改为Pipe。读取多个(海康\大华)网络摄像头的视频流 (使用opencv-python)，解决实时读取延迟问题392 赞同 · 281 评论文章

Pipe还有 duplex参数 和 poll() 方法 需要了解。默认情况下 duplex==True，若不开启双向管道，那么传数据的方向只能 conn1 ← conn2 。conn2.poll()==True 意味着可以马上使用 conn2.recv() 拿到传过来的数据。conn2.poll(n) 会让它等待n秒钟再进行查询。

from multiprocessing import Pipe

conn1, conn2 = Pipe(duplex=True)  # 开启双向管道，管道两端都能存取数据。默认开启
# 
conn1.send('A')
print(conn1.poll())  # 会print出 False，因为没有东西等待conn1去接收
print(conn2.poll())  # 会print出 True ，因为conn1 send 了个 'A' 等着conn2 去接收
print(conn2.recv(), conn2.poll(2))  # 会等待2秒钟再开始查询，然后print出 'A False'

尽管我下面的例子不会报错，但这是因为它过于简单，没有真的开多线程去跑，也没有写在程序入口的if内部。很多时候 Pipe运行会快一点，但是它的功能太少了，得用 Queue。最明显的一个区别是：

conn1, conn2 = multiprocessing.Pipe()  # 管道有两端，某一端放入的东西，只能在另一端拿到
queue = multiprocessing.Queue()        # 队列只有一个，放进去的东西可以在任何地方拿到。

6. 队列 Queue

可以 import queue 调用Python内置的队列，在多线程里也有队列 from multiprocessing import Queue。下面提及的都是多线程的队列。

队列Queue 的功能与前面的管道Pipe非常相似：无论主进程或子进程，都能访问到队列，放进去的对象都经过了深拷贝。不同的是：管道Pipe只有两个断开，而队列Queue 有基本的队列属性，更加灵活，详细请移步Stack Overflow Multiprocessing – Pipe vs Queue。

def func1(i):
    time.sleep(1)
    print(f'args {i}')

def run__queue():
    from multiprocessing import Process, Queue

    queue = Queue(maxsize=4)  # the following attribute can call in anywhere
    queue.put(True)
    queue.put([0, None, object])  # you can put deepcopy thing
    queue.qsize()  # the length of queue
    print(queue.get())  # First In First Out
    print(queue.get())  # First In First Out
    queue.qsize()  # the length of queue

    process = [Process(target=func1, args=(queue,)),
               Process(target=func1, args=(queue,)), ]
    [p.start() for p in process]
    [p.join() for p in process]

if __name__ =='__main__':
    run__queue()

除了上面提及的 Python多线程，读取多个(海康\大华)网络摄像头的视频流 ，我自己写的开源的强化学习库：小雅 ElegantRL 也使用了 Queue 进行多CPU多GPU训练，为了提速，我已经把Queue 改为 Pipe。

7. 共享内存 Manager

为了在Python里面实现多进程通信，上面提及的 Pipe Queue 把需要通信的信息从内存里深拷贝了一份给其他线程使用（需要分发的线程越多，其占用的内存越多）。而共享内存会由解释器负责维护一块共享内存（而不用深拷贝），这块内存每个进程都能读取到，读写的时候遵守管理（因此不要以为用了共享内存就一定变快）。

Manager可以创建一块共享的内存区域，但是存入其中的数据需要按照特定的格式，Value可以保存数值，Array可以保存数组，如下。这里不推荐认为自己写代码能力弱的人尝试。下面这里例子来自Python官网的Document。

# https://docs.python.org/3/library/multiprocessing.html?highlight=multiprocessing%20array#multiprocessing.Array

from multiprocessing import Process, Lock
from multiprocessing.sharedctypes import Value, Array
from ctypes import Structure, c_double

class Point(Structure):
    _fields_ = [('x', c_double), ('y', c_double)]

def modify(n, x, s, A):
    n.value **= 2
    x.value **= 2
    s.value = s.value.upper()
    for a in A:
        a.x **= 2
        a.y **= 2

if __name__ == '__main__':
    lock = Lock()

    n = Value('i', 7)
    x = Value(c_double, 1.0/3.0, lock=False)
    s = Array('c', b'hello world', lock=lock)
    A = Array(Point, [(1.875,-6.25), (-5.75,2.0), (2.375,9.5)], lock=lock)

    p = Process(target=modify, args=(n, x, s, A))
    p.start()
    p.join()

    print(n.value)
    print(x.value)
    print(s.value)
    print([(a.x, a.y) for a in A])

我删掉了Python 3.8 的shared_momery 介绍，这部分有Bug

下文来自 Stack Overflow，问题 Shared memory in multiprocessing 下thuzhf 的回答 2021-01 ：

For those interested in using Python3.8 ‘s shared_memory module, it still has a bug which hasn’t been fixed and is affecting Python3.8/3.9/3.10 by now (2021-01-15). The bug is about resource tracker destroys shared memory segments when other processes should still have valid access. So take care if you use it in your code.

PyTorch 也有自带的多进程 torch.multiprocessing

How to share a list of tensors in PyTorch multiprocessing? rozyang 的回答 ，非常简单，核心代码如下：

import torch.multiprocessing as mp
tensor.share_memory_()

8. 回答评论区的有用问题（不建议私信）

正文已经结束，我把部分multiprocessing的代码都放在github。希望大家能写出让自己满意的多线程。我设计高性能的多进程时，会遵守以下规则：

• 尽可能少传一点数据
• 尽可能减少主线程的负担
• 尽可能不让某个进程傻等着
• 尽可能减少进程间通信的频率

9. 我为何写【在Python中优雅地用多进程】？

• 我在2019年前没有在网上看到让我满意的同类文章。
• 我之前用多进程解决过 曾伊言：读取多个(海康\大华)网络摄像头的视频流 (使用opencv-python)，解决实时读取延迟问题，尽管我不喜欢私信，但还是有人在私信和评论区讨要多线程学习资料
• 在2019年的Python3.9的新特性：真正的共享内存 shared_memory 做出来后，我认为现在介绍时机成熟了
• 我开源的强化学习库：小雅 ElegantRL 为了追求训练速度，使用了多进程实现了：multi-workers（rollout）、分开采样-训练-测试模块、未来还想要实现适合强化学习的multiGPU… … 在积累了一些Python多进程经验后，我打算分享一下。

开源的深度强化学习(DRL)算法库 伯克利的Ray-project Rllib训练快，但太复杂，OpenAI的 SpinningUp简单，但不快（没有提及的开源库比不上它们，写于2020年）。刚好我又懂一点多进程、Numpy、深度学习框架、深度强化学习这些双层优化算法，所以我觉得自己也写一个DRL库难度不大，于是开源了强化学习库：小雅 ElegantRL。让别人好好看看，DRL库挺简单的一个东西弄那么复杂做什么？

尽管这个库会一直保持框架小巧、代码优雅来方便入门深度强化学习的人，但 ElegantRL 却把训练效率放在首位（正因如此，ElegantRL 与 SpinningUp的定位不同），所以我需要用Python的多进程来加速 DRL的训练。因而顺便写【在Python中优雅地用多进程】这篇东西。

在命令行中使用 Python 时，它可以接收大约 20 个选项（option），语法格式如下：

python [-bBdEhiIOqsSuvVWx?] [-c command | -m module-name | script | - ] [args]

用“–help”来看看它的解释：

-m mod run library module as a script (terminates option list)

“mod”是“module”的缩写，即“-m”选项后面的内容是 module（模块），其作用是把模块当成脚本来运行。

“terminates option list”意味着“-m”之后的其它选项不起作用，在这点上它跟“-c”是一样的，都是“终极选项”。官方把它们定义为“接口选项”（Interface options），需要区别于其它的普通选项或通用选项。

m 选项的五个典型用法

Python 中有很多使用 -m 选项的场景，相信大家可能会用到或者看见过，我在这里想分享 5 个。

在 Python3 中，只需一行命令就能实现一个简单的 HTTP 服务：

python -m http.server 8000

# 注:在 Python2 中是这样
python -m SimpleHTTPServer 8000复制代码

执行后，在本机打开“http://localhost:8000”，或者在局域网内的其它机器上打开“http://本机ip:8000”，就能访问到执行目录下的内容，例如下图就是我本机的内容：

与此类似，我们只需要一行命令“python -m pydoc -p xxx”，就能生成 HTML 格式的官方帮助文档，可以在浏览器中访问。

上面的命令执行了 pydoc 模块，会在 9000 端口启动一个 http 服务，在浏览器中打开，我的结果如下：

它的第三个常见用法是执行 pdb 的调试命令“python -m pdb xxx.py”，以调试模式来执行“xxx.py”脚本：

第四个同样挺有用的场景是用 timeit 在命令行中测试一小段代码的运行时间。以下的 3 段代码，用不同的方式拼接 “0-1-2-……-99” 数字串。可以直观地看出它们的效率差异：

最后，还有一种常常被人忽略的场景：“python -m pip install xxx”。我们可能会习惯性地使用“pip install xxx”，或者做了版本区分时用“pip3 install xxx”，总之不在前面用“python -m”做指定。但这种写法可能会出问题。

很巧合的是，在本月初（2019.11.01），Python 的核心开发者、第一届指导委员会 五人成员之一的 Brett Cannon 专门写了一篇博客《Why you should use “python -m pip” 》，提出应该使用“python -m pip”的方式，并做了详细的解释。

他的主要观点是：在存在多个 Python 版本的环境中，这种写法可以精确地控制三方库的安装位置。例如用“python3.8 -m pip”，可以明确指定给 3.8 版本安装，而不会混淆成其它的版本。

-m 选项的两种原理解析

看了前面的几种典型用法，你是否开始好奇：“-m”是怎么运作的？它是怎么实现的？

对于“python -m name”，一句话解释：Python 会检索sys.path ，查找名字为“name”的模块或者包（含命名空间包），并将其内容当成“__main__”模块来执行。

1、对于普通模块

以“.py”为后缀的文件就是一个模块，在“-m”之后使用时，只需要使用模块名，不需要写出后缀，但前提是该模块名是有效的，且不能是用 C 语言写成的模块。

在“-m”之后，如果是一个无效的模块名，则会报错“No module named xxx”。

如果是一个带后缀的模块，则首先会导入该模块，然后可能报错：Error while finding module specification for ‘xxx.py’ (AttributeError: module ‘xxx’ has no attribute ‘__path__’。

对于一个普通模块，有时候这两种写法表面看起来是等效的：

两种写法都会把定位到的模块脚本当成主程序入口来执行，即在执行时，该脚本的__name__ 都是”__main__“，跟 import 导入方式是不同的。

但它的前提是：在执行目录中存在着“test.py”，且只有唯一的“test”模块。对于本例，如果换一个目录执行的话，“python test.py”当然会报找不到文件的错误，然而，“python -m test”却不会报错，因为解释器在遍历sys.path 时可以找到同名的“test”模块，并且执行：

由此差异，我们其实可以总结出“-m”的用法：已知一个模块的名字，但不知道它的文件路径，那么使用“-m”就意味着交给解释器自行查找，若找到，则当成脚本执行。

以前文的“python -m http.server 8000”为例，我们也可以找到“server”模块的绝对路径，然后执行，尽管这样会变得很麻烦。

那么，“-m”方式与直接运行脚本相比，在实现上有什么不同呢？

• 直接运行脚本时，相当于给出了脚本的完整路径（不管是绝对路径还是相对路径），解释器根据文件系统的查找机制， 定位到该脚本，然后执行
• 使用“-m”方式时，解释器需要在不 import 的情况下，在所有模块命名空间 中查找，定位到脚本的路径，然后执行。为了实现这个过程，解释器会借助两个模块：pkgutil 和 runpy ，前者用来获取所有的模块列表，后者根据模块名来定位并执行脚本

2、对于包内模块

如果“-m”之后要执行的是一个包，那么解释器经过前面提到的查找过程，先定位到该包，然后会去执行它的“__main__”子模块，也就是说，在包目录下需要实现一个“__main__.py”文件。

换句话说，假设有个包的名称是“pname”，那么，“python -m pname”，其实就等效于“python -m pname.__main__”。

仍以前文创建 HTTP 服务为例，“http”是 Python 内置的一个包，它没有“__main__.py”文件，所以使用“-m”方式执行时，就会报错：No module named http.__main__; ‘http’ is a package and cannot be directly executed。

作为对比，我们可以看看前文提到的 pip，它也是一个包，为什么“python -m pip”的方式可以使用呢？当然是因为它有“__main__.py”文件：

“python -m pip”实际上执行的就是这个“__main__.py”文件，它主要作为一个调用入口，调用了核心的”pip._internal.main”。

http 包因为没有一个统一的入口模块，所以采用了“python -m 包.模块”的方式，而 pip 包因为有统一的入口模块，所以加了一个“__main__.py”文件，最后只需要写“python -m 包”，简明直观。

如果你还主要靠print来调试代码，那值得花10分钟试试pdb这个Python自带的Debug工具。

pdb有2种用法：

• 非侵入式方法（不用额外修改源代码，在命令行下直接运行就能调试）

python3 -m pdb filename.py

• 侵入式方法（需要在被调试的代码中添加一行代码然后再正常运行代码）

import pdb;pdb.set_trace()

当你在命令行看到下面这个提示符时，说明已经正确打开了pdb

(Pdb) 

然后就可以开始输入pdb命令了，下面是pdb的常用命令

1、查看源代码

命令：

l

说明：

查看当前位置前后11行源代码（多次会翻页）
当前位置在代码中会用–>这个符号标出来

命令：

ll

说明：

查看当前函数或框架的所有源代码

2、添加断点

命令：

b
b lineno
b filename:lineno 
b functionname

参数：

filename文件名，断点添加到哪个文件，如test.py
lineno断点添加到哪一行
function：函数名，在该函数执行的第一行设置断点

说明：

1.不带参数表示查看断点设置
2.带参则在指定位置设置一个断点

3、添加临时断点

命令：

tbreak
tbreak lineno
tbreak filename:lineno
tbreak functionname

参数：

同b

说明：

执行一次后时自动删除（这就是它被称为临时断点的原因）

4、清除断点

命令：

cl
cl filename:lineno
cl bpnumber [bpnumber ...]

参数：

bpnumber 断点序号（多个以空格分隔）

说明：

1.不带参数用于清除所有断点，会提示确认（包括临时断点）
2.带参数则清除指定文件行或当前文件指定序号的断点

5、打印变量值

命令：

p expression

参数：

expression Python表达式

6、逐行调试命令

包括 s ，n ， r 这3个相似的命令，区别在如何对待函数上

命令1：

s

说明：

执行下一行（能够进入函数体）

命令2：

n 

说明：

执行下一行（不会进入函数体）

命令3：

r 

说明：

执行下一行（在函数中时会直接执行到函数返回处）

7、非逐行调试命令

命令1：

c 

说明：

持续执行下去，直到遇到一个断点

命令2

unt lineno

说明：

持续执行直到运行到指定行（或遇到断点）

命令3

j lineno

说明：

直接跳转到指定行（注意，被跳过的代码不执行）

8、查看函数参数

命令：

a

说明：

在函数中时打印函数的参数和参数的值

9、打印变量类型

命令：

whatis expression

说明：

打印表达式的类型，常用来打印变量值

10、启动交互式解释器

interact

说明：

启动一个python的交互式解释器，使用当前代码的全局命名空间（使用ctrl+d返回pdb）

11、打印堆栈信息

w

说明：

打印堆栈信息，最新的帧在最底部。箭头表示当前帧。

12、退出pdb

q

描述

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

语法

map() 函数语法：

map(function, iterable1,iterable2, ...)

参数function传的是一个函数名，可以是python内置的，也可以是自定义的。
参数iterable传的是一个可以迭代的对象，例如列表，元组，字符串这样的。

这个函数的意思就是将function应用于iterable的每一个元素，结果以列表的形式返回。注意到没有，iterable后面还有省略号，意思就是可以传很多个iterable，如果有额外的iterable参数，并行的从这些参数中取元素，并调用function。如果一个iterable参数比另外的iterable参数要短，将以None扩展该参数元素。

def add(x,y,z):
    return x,y,z

list1 = [1,2,3]
list2 = [1,2,3,4]
list3 = [1,2,3,4,5]
res = map(add, list1, list2, list3)
print(res)

输出：
[(1, 1, 1), (2, 2, 2), (3, 3, 3), (None, 4, 4), (None, None, 5)]