## 1. What Are Python Porcesses
每个Python程序都是一个进程，并且有一个称为主线程的线程用于执行程序指令。每个进程实际上是Python解释器的一个实例，用于执行Python指令（Python字节码），这比您在Python程序中键入的代码略低级。



有时候，我们可能需要创建新的进程来并发运行额外的任务。

Python通过multiprocessing模块中的Process类提供了真正的系统级进程。

底层操作系统控制着如何创建新进程。在某些系统上，可能需要生成一个新进程，而在其他系统上，则可能需要进行分叉。Python中用于创建新进程的操作系统特定方法并不是我们需要担心的事情，因为它由您安装的Python解释器管理。

```python

# SuperFastPython.com
# example of running a function in a new process
from multiprocessing import Process
 
# a task to execute in another process
def task():
    print('This is another process', flush=True)
 
# entry point for the program
if __name__ == '__main__':
    # define a task to run in a new process
    p = Process(target=task)
    # start the task in a new process
    p.start()
    # wait for the task to complete
    p.join()
```
这对于在单独的进程中运行临时的一次性任务很有用，尽管当您有许多任务需要运行时，这种方法会变得笨重。

每个创建的进程都需要分配资源（例如Python解释器的一个实例和进程主线程的堆栈空间）。如果我们为临时任务反复创建和销毁许多进程，那么设置进程的计算成本可能会变得昂贵。

相反，如果我们期望在程序中执行许多临时任务，我们更希望保留工作进程以供重复使用。

这可以通过使用进程池来实现。

## 2. What is a Process pool
进程池是一种自动管理一组工作进程的编程模式。

该池负责一定数量的进程。

它控制进程的创建时间，例如在需要时创建进程。

它还控制进程在闲置时的行为，例如使它们等待而不消耗计算资源。

进程池可以提供一个通用的接口，用于执行具有可变数量参数的临时任务，类似于进程对象的目标属性，但不要求我们选择要运行任务的进程、启动进程或等待任务完成。

Python通过 `multiprocessing.Pool` 类提供了进程池。

## 3. Multiprocessing Pools in Python
`multiprocessing.pool.Pool` 类在Python中提供了一个进程池。

`multiprocessing.pool.Pool` 类也可以通过别名 `multiprocessing.Pool` 访问，它们可以互换使用。

它允许将任务作为函数提交到进程池中并发执行。

要使用进程池，我们首先必须创建并配置该类的一个实例。

例如：

```python
# 创建一个进程池
pool = multiprocessing.pool.Pool(...)
```

一旦配置完成，可以使用 `apply()` 和 `map()` 的阻塞和异步版本将任务提交给进程池执行。

例如：

```python
# 发出任务以执行
results = pool.map(task, items)
```

完成进程池的使用后，可以关闭它并释放进程池使用的资源。

例如：

```python
# 关闭进程池
pool.close()
```

现在我们对Python进程池有了一个高层次的理解，让我们看一下 `multiprocessing.pool.Pool` 类的生命周期。

01 Python进程和进程池的必要性

05 多进程 pool 分发任务

[参考知乎话题](https://www.zhihu.com/question/642449547/answer/3387775030)

作者：老胡聊Java

看到这个话题，颇有感触，一共20条，看自己需要在哪些方面优化一下？





1. 意识到写代码无非就是调用接口api，做业务无非也就是抄些增删改查的现成代码。也就是说，编程没想象中那样高大上，也就是谋生的一种手段。
    
    `对的，意识到了`

2. 知道提升能力不是单纯靠学，而是得靠解决实际问题。比如在做项目时，提升技能的最好方式是，去解决些值钱（比如分布式高并发或devops等）方面的问题。同时更知道，单纯做增删改查的业务，其实顶了天也只能算个初级开发。
    
    `从这几年的面试过程中，目前最值钱的技术：云原生（k8s）、分布式高并发、大数据、大模型、量化。我大哥曾经说过，中级开发和高级开发最应该考虑的是设计，而不是CRUD。评论中也提到，以造轮子来去学习开发，以实际问题为目标，我认为是最稳、最实在的。`
    
    `不足之处：云原生、分布式开发自己从零到1的过程。微服务从0到1的过程`
3. 知道其实在做项目的过程中，写代码的技能相对来说是比较不值钱的。比较值钱的技能点是，排除解决问题的能力，确保项目高质量的能力（即测试能力），运维项目的能力（比如容器和devops），组件的使用能力和配置安装分布式或微服务组件的能力。

    `说的对啊，有了第二点，后期的维护也是很大的工程量。个人遇到的例如：redis+sentinel 就某个节点出现connect reset by peer， CPU和内存过高的原因、比对任务速度。 代码质量也是一个很大的提升空间。`
    `不足之处: 经验还是少，代码质量需提高，devops从0到1，分布式的实战搭建，组件的使用`
4. 知道在自己领域，哪些技术比较值钱，同时更知道，如何在面试中证明自己的技能，更知道，在下次跳槽时，自己该去哪些类型的公司，知道该如何要到更高的薪资。

    `第二点中提到的都是值钱的，通过一些实际的问题解决来证明自己的技能，下次跳槽时，应该去科技类型的公司，要有一定的规模，如何要到更高的薪资？不太清楚`
    
     `不足之处：具体下次跳槽的公司特点，如何要到更高的薪资。清晰化之前遇到的问题及解决方法`
5. 知道衡量程序员能力和水平的标准是薪资+公司，在公司都差不多的情况下，谁薪资高谁能力强，在薪资差不多的情况下，谁公司好谁厉害。这话另外一层含义时，在跳槽时，对方公司衡量程序员能力时，第一看之前公司的规模，即大公司背景，第二看薪资。随后再通过面试看技术。

    `这个没有注意到，虽然我这几个公司都不是很好，但要夸出来牛B啊。QPS、并发量、用户活跃量等等。公司是有问题，也要提取牛逼之处，`
    
    `不足之处：夸出自己公司牛皮的地方，跳槽看公司+薪资+行业，`
6. 知道公司的领导在给自己提建议时，出发点大概率是为了公司好和为了项目组好，在此基础上顺带会给些对自己有帮助的建议。这种情况下，对领导的话是会有选择性地听。

    `拒绝PUA，若产生内耗，及时沟通。选择性地接收，慢慢来`
    
7. 知道不少公司领导留人的方式不是靠加薪，而是靠画饼。更知道，如果在同一家公司，每年涨薪顶多1成，而且还得使劲加班，同时如果是跳槽，涨薪3成都算低的。

    `撑死胆大的，饿死胆小的。要敢要钱，大环境不好，但不是都不好`
    
    `不足之处：靠～这几年，因为工作不顺利，搞的自己很内耗，不敢要钱，疫情过后，有一次4k，后来一次是1k的，按照3成来`

8. 知道在面试中证明自己能力时，不能单纯靠自己做过什么，也不能靠自己学过什么，而是靠自己能靠说证明什么。比如能在面试中，通过说自己解决过的值钱技术方面的问题，能证明自己在这方面的能力，至于自己是否做过，面试官很难核实。
    `面试，最重要：吹牛皮，说过自己解决过最值钱的技术问题`
    
    `不足之处：自己面试说的内容，只言片语，没有威慑力，导致面试能力差。`
9. 知道程序员要过大龄这道坎，不是靠技术，而是靠公司，即得找个能容纳大龄程序员的公司，而一些小公司，对大龄程序员可能未必友好。

    `找有钱的老板，靠融资活的，没有收益，迟早会倒闭的`
    
    `不足之处：一次跳槽找了一个互联网公司，靠融资活，没有收益，濒临倒闭。各地都有分公司的，都算不错的。之前的公司，还固定时间来聚餐啥的。真不错啊～`
    
10. 知道身体比挣钱重要，知道家庭比工作重要。而程序员这个职位，只是提供了用加班用艰辛换取高薪的机会。

    `要么加班用艰辛换取高薪的机会。要么会做人，粘在领导身边。什么都不是，很难活得很好啊`
    
    `不足之处：活的没有目的，既然认清了现实，我觉得就要去做一种。从心底来说，做一个无法替代独一无二的人，真的比什么都强。管是巴结领导还是技术大拿，都行。不像考试，要有固定的答案，这一切都是看你的替代性。`

11. 知道有些公司，尤其是小公司外包公司，仅仅是过渡，在其中不应该呆过3年。别看其中的领导信誓旦旦或者宣扬狼性，但可能他们自己都知道，自己的业务线甚至是公司未必能撑多久。

    `任何一家公司，首先要考虑对自己的价值，不管是目前还是未来的，行业、公司前景。这些以前不是很注重，工作久了之后，这个真的是太重要了`
    
    `不足之处：要看好公司，看重前景、行业，和对自己的价值。`
12. 会越来越感受到，大多数代码、框架乃至和技术相关的东西，其实都是虚的。当然一些高端技术（比如当下的大模型）不能说是虚的，这能实打实挣钱，但一般程序员接触不到这个层次。做到后面就会发现，再要进一步挣钱，首先得看人脉，有人脉才有渠道接单，业务量大了才能有所谓的盈利模式，有了盈利模式才能进一步雇人做大，所谓是扩大再生产。 
    
    `对啊，技术就是为了挣钱，即便没有单子，像我原来的老东家有人脉，也能成单子。有了盈利模式，才会做大做强`
    
    `不足之处：哈哈哈，面试问公司的盈利模式，近几年成交打单子，项目收益是多少？`
13. 虽然再加个第13点有些不大吉利，但这点确实会对程序员有帮助。即比较成熟的程序员具备复制别人成功模式的能力。举例来说，比如某Java开发当下只会增删改查，但他能通过观察组内的资深架构平时干了什么事情，解决问题的过程，通过多问多复盘多实践，慢慢把人家的本事学到手，然后提升自己的能力。
    
    `跟着一位大神，真的会学到很多东西。我的大哥曾经说说：别老打代码，你多多看看英文论文，开源的代码，你就提升了，不要想着很难。`
    
    `不足之处：开发不要局限于语言，围绕设计、最先进知识，从论文看方向。大局思考能力`
14. 再进一步讲，成熟或者说资深的程序员，更具备从各种试错过程中找到正确方向的本事。比如当下某人的外包公司，接触到的技术天花板是单机版的增删改查，所谓的组内大牛也只是熟悉业务。这种情况下想进好公司，比较成熟的程序员一般能通过尝试，知道怎么写简历怎么找猎头能拿到大公司的面试机会，再进一步，知道在当下技术储备不多的情况下，经过各种无效学习的试错，知道如何掌握大公司面试所需的技能，再进一步，经过各种面试的尝试，知道该如何面试成。

    
    `不足之处：需要知道怎么写简历？怎么找猎头拿到大公司的面试机会？怎么掌握大公司需要的技能？怎么面试成功？`
15. 做久了以后，知道做项目时应该用最安全的方式修改bug，而设计模式和重构之道之类的理念，只是存在于教科书，而且只会在面试时用到。这句话更加通俗的说法是，在当前系统修改bug时，不该看的代码不看，不该了解的代码不去了解，不该碰的代码不碰，一旦看了了解了碰了，改出问题，责任就是你的。而且在改牵扯到多方的疑难bug时，一定得拉上领导或相关人。

    `程序员只会CURD，迟早会被淘汰的。要么能巴结领导，会做人，要么技术牛`
16. 在面试场景，知道证明自己用过某个技术的方式是，说业务场景和API细节。这块具体展开下，比如在面试中要证明自己做过机器学习，可以先说项目里引入机器学习模型的场景，再说用过哪些模型，其中的api接口、语法和配置细节是什么样的。而且同样是在面试场景，证明自己能力的方式不在于说自己做过哪些业务，而在于说自己排除解决技术问题的方式，解决过的问题越值钱（比如含高并发机器学习或AI），那么面试官只能相信你的能力。

    `以项目为基础，添加业务场景和API细节，面试重点强调解决技术能力，解决的问题越值钱，越有能力。`

17. 顺着上一点和第8点继续说下去，在面试时，比如求职者有3年公司经历，那么应该就有3年Java（或Python或其它技能）的项目经验。这种情况下，如果求职者通过业务场景和API说技术，再通过说解决过的问题证明能力，面试官只能相信求职者的能力。一些会面试的求职者，2,3年跳槽一次，每次薪资涨个3成，或者以此进好公司，这其实不是难事。回到主题上，较为成熟的程序员都知道一些面试技巧，而比较幼稚的程序员，面试时只说自己项目做过哪些事情，更只会通过做业务证明自己的能力，这样的跳槽和面试的能力是有待改进的。

    `提高自己的面试能力，面试时，不要从业务上证明自己的能力，而是从技术上，解决问题的能力展现。`
18. 较为成熟的程序员一般给人的感受是，面试时，被普遍认为能力强，因为具备足够的面试能力，刚开始进项目组时，会被认为很菜，但很努力，因为接触到了更值钱的技术，而之前没接触过，所以很菜，但在新环境里能通过努力高效学习。过了一段时间，这位程序员能在解决问题、沟通和写ppt汇报等方面展示足够的能力，再过了一段时间，这位程序员会跳槽到更好的公司里，迭代上一次的流程。而较为幼稚的程序员则会认为，只要我能力强，能解决问题，就能在当前公司一直干。

    `面试能力强——初入新公司——接触更值钱的技术——在新环境努力高效学习——在解决问题、沟通、汇报展现能力——跳槽到更好的公司`

19. 在自己当下技术不高的情况下，知道如何最大程度上变现自己的技术，因为成熟的程序员都知道，技术不能当饭吃，生活还得靠技术变现得来的钱。

    `这点说的不是很明确。我查了一下，像搞培训、做外包、开发软件产品去卖、写作、录视频和音频。这个赛道优点厉害`
20. 这甚至已经可以作为“老油子程序员”的标志了。知道解决哪些bug能给自己带来收益，知道解决哪些bug，虽然对项目有帮助，但牵涉到一些人或一些事，未必会对自己有帮助，知道项目里的哪些bug应该报出来，但不应该立即着手解决，而应该开会找相关人讨论，知道项目里的哪些bug，甚至都不应该报出来。

    `在公司以解决问题来展现个人的能力`
21. 经历一次裁员，绝对能让程序员从幼稚到成熟。

    `额，活在21世纪的打工人可以经历到`

程序员从幼稚到成熟的标志是什么？

# Python进度条神器 tqdm

## 介绍
优点：
* 易于使用：只需在 Python 循环中包裹你的迭代器，一行代码就能产生一个精美的进度条。
* 灵活：它可以和 for 循环、pandas dataframe的 apply 函数以及 Python 的 map 函数等等配合使用。
* 高效：tqdm 使用了智能算法，即使在数据流非常快的情况下，也不会拖慢你的代码速度。




## 使用场景
### requests下载大的文件
```python
def DownLoadBigFile():
    import requests
    from tqdm import tqdm
    # 5个G的文件
    url = "https://mqdb-release-1253802058.cos.ap-beijing.myqcloud.com/datasets/openai-50w-cosine.hdf5"
    # 当你使用 stream=True 参数发送请求时，意味着你希望以流式方式获取响应内容，而不是一次性获取整个响应体。

    response = requests.get(url,stream=True)
    filesize = int(response.headers['Content-Length'])
    chunk = 1
    chunk_size = 1024
    num_bars = int(filesize / chunk_size)
    with open('test.tgz','wb') as fp:
        for chunk in tqdm(response.iter_content(chunk_size=chunk_size),total=num_bars,unit="KB",desc='test.tgz',leave=True):
            fp.write(chunk)
            
```
效果如下：

![image.png](/static/img/a25abde7d8a9e7d2084274f81a6ed71a.image.webp)

### 机器学习，对大规模数据进行预处理。
在训练深度学习模型时，我们经常需要迭代大量的 epochs。使用 tqdm，我们可以清晰地看到模型训练的进度。
```python
from tqdm import tqdm
# 假设我们有一个训练数据集 train_dataloader 和一个模型 model
for epoch in range(num_epochs):
    epoch_iterator 
= tqdm(train_dataloader, desc=
"Training (Epoch %d)"
 % epoch)
    
    for step, batch in enumerate(epoch_iterator):
        # 模型训练的代码
        # ...
```
### 嵌套循环
在许多情况下，我们的代码可能包含嵌套循环。在这种情况下，我们可以使用 tqdm 创建多个进度条。
```python
from tqdm import tqdm
import time
for i in tqdm(range(100), desc="Outer loop"):
    for j in tqdm(range(10), desc="Inner loop", leave=False):
        # 执行一些耗时的操作
        time.sleep(0.01)
```
### 处理批量数据
有时候，我们可能需要手动更新进度条。例如，当我们在下载文件或处理批量数据时，我们可能一次处理多个项目。在这种情况下，我们可以使用 update 方法。
```python
from tqdm import tqdm
import time
with tqdm(total=100) as pbar:
    for i in range(10):
        # 执行一些耗时的操作
        time.sleep(0.1)
        pbar.update(10)

```

## 补充：requests的stream的作用是什么？
在 `requests` 库中，当你使用 `stream=True` 参数发送请求时，意味着你希望以流式方式获取响应内容，而不是一次性获取整个响应体。

具体来说，这会将 `requests` 库设置为在接收响应时逐块读取数据。这在处理大型响应内容时特别有用，因为它允许你在下载或处理大文件时逐步处理数据，而不必将整个响应内容加载到内存中。

例如，如果你通过以下方式获取响应：

```python
import requests

url = 'http://example.com/large-file.zip'
response = requests.get(url, stream=True)
```

那么 `response` 对象将允许你通过迭代器逐块访问响应内容，而不是一次性加载到内存中。你可以使用 `iter_content()` 方法来访问这些数据块，例如：

```python
with open('large-file.zip', 'wb') as f:
    for chunk in response.iter_content(chunk_size=8192):
        if chunk:
            f.write(chunk)
```

在上面的例子中，`iter_content()` 方法允许你逐块写入文件，以处理大型文件下载的情况，同时有效地利用内存资源。

因此，`stream=True` 在 `requests` 中用于控制如何处理响应内容的传输方式，使其更加灵活和高效。


> 加 和 不加stream参数的区别：
1. 不加stream参数：
    
    get请求会把所有的数据请求下来，一个视频1个G的话，会把1G的视频下载到内存里面，然后再进一步操作。

2. 加stream参数：
    
    get请求会先建立连接，而不会把content内容或text内容下载到内存里，等开始对content操作的时候，get请求这个时候才开始下载数据。

### 扩展：若下载遇到网络、存储等问题，如何解决呢？断点续传
```python
def DownLoadBigFile():
    import requests
    # 5个G的文件
    url = "https://mqdb-release-1253802058.cos.ap-beijing.myqcloud.com/datasets/openai-50w-cosine.hdf5"
    # 185kb文件
    url = 'https://1.bp.blogspot.com/-1jq9R-na21U/Xwhip410sFI/AAAAAAAAAAY/fLO-FzWFlU8eKiCA5-IWAR22YoC1mM8-QCLcBGAsYHQ/s2048/real-ai.jpg'

    # 当你使用 stream=True 参数发送请求时，意味着你希望以流式方式获取响应内容，而不是一次性获取整个响应体。
    # 断点续传，使用图片来测试
    # headers = {'Range': 'bytes=0-%d'%(100*1024)} # 第一次，文件写模式：wb
    headers = {'Range': 'bytes=%d-'%(100*1024+1)} # 第二次，文件写模式：ab
    response = requests.get(url,stream=True,headers=headers)
    filesize = int(response.headers['Content-Length'])
    chunk = 1
    chunk_size = 1024
    num_bars = int(filesize / chunk_size)
    with open('test.tgz','ab') as fp:
        for chunk in tqdm(response.iter_content(chunk_size=chunk_size),total=num_bars,unit="KB",desc='test.tgz',leave=True):
            fp.write(chunk)
```



![image.png](/static/img/1339d1784dc7808d24e43b5242e65448.image.webp)

## 完整代码
```python
import time

from tqdm import tqdm

def SingleLoop():
    for i in tqdm(range(100)):
        # 假设我们正在进行一些耗时的操作，比如训练深度学习模型
        time.sleep(0.01)

def DownLoadBigFile():
    import requests
    # 5个G的文件
    url = "https://mqdb-release-1253802058.cos.ap-beijing.myqcloud.com/datasets/openai-50w-cosine.hdf5"
    # 当你使用 stream=True 参数发送请求时，意味着你希望以流式方式获取响应内容，而不是一次性获取整个响应体。

    response = requests.get(url,stream=True)
    filesize = int(response.headers['Content-Length'])
    chunk = 1
    chunk_size = 1024
    num_bars = int(filesize / chunk_size)
    with open('test.tgz','wb') as fp:
        for chunk in tqdm(response.iter_content(chunk_size=chunk_size),total=num_bars,unit="KB",desc='test.tgz',leave=True):
            fp.write(chunk)

# def PreDealBigData():
#     import pandas as pd 
#     from tqdm import tqdm
#     tqdm.pandas()
#     # 假设我们有一个大的dataframe,我们需要对其‘text’列进行一些预处理
#     df['processed_text'] = df['text'].process_apply(lambda x: preprocess(x))

# def MachineLearn():
#     # 假设我们有一个训练数据集 train_dataloader 和一个模型model
#     for epoch in range(num_epochs):
#         epoch_iterator = = tqdm(train_dataloader, desc="Training (Epoch %d)"% epoch)
#         for step, batch in enumerate(epoch_iterator):
#             # 模型训练的代码
#             pass

def NestedLoop():
    for i in tqdm(range(100),desc="outer loop"):
        # leave=False 是表示：子循环不显示进度条，目的是保证页面的整洁，保证不会被内部进度条干扰
        for j in tqdm(range(10),desc="Inner Loop",leave=False):
            # 执行一些耗时的操作
            time.sleep(0.01)
            
def HandUpdateBar():
    with tqdm(total=100) as bar:
        for i in range(10):
            # 执行一些耗时的操作
            time.sleep(0.1)
            # 代表一次执行10个，进度条是10个的变化累加
            bar.update(10)
if __name__ == '__main__':
    HandUpdateBar()
```

1. What Are Python Porcesses

need to issue Tasks to the Process Pool

Python进度条神器 tqdm

介绍