代码乱了，哈哈。直接看 code 链接呢 https://paste.ofcode.org/iHEThFKxvkXHbhmMjAy4TB

反正都输出所有集合了，直接暴力回溯，只要回溯的时候注意去掉重复的就行

```python
def solution2(arr: list[int], lo:int, hi:int) -> list[list[int]]:
def valid(temp):
return all([
sum(temp) > hi,
all((sum(temp[:_i]) + sum(temp[_i+1:])) < hi for _i in range(len(temp))),
any((sum(temp[:_i]) + sum(temp[_i+1:])) <= hi - lo for _i in range(len(temp))),
])

def backtrack(i:int):
if i >= len(arr):
return

for j in range(i, len(arr)):
if j == i or arr[j] != arr[j-1]:
temp.append(arr[j])
if valid(temp):
res.append(temp[:])
backtrack(j+1)
temp.pop()

temp = []
res = []
arr.sort()
backtrack(0)
return res

# solution2([10, 20, 20, 30], 10, 45) -> [[10, 20, 20], [20, 30]]
```

@f1ynnv2 看完你的回复之后，我感觉你对 python 的 logger 理解有误。
每个 py 文件都应该有自己 logger, 每个 logger 不需要自己来输出到文件，你不需要也不应该从其他模块导入一个的 logger, 它最后都会把 log record propagate 到 root logger
你只要对 root logger 配置 handler 和 formatter 就行。
然后，我的代码是给每个子进程配置了他们 root logger ，file1.py 和 file2.py 并没有额外指定日志输出文件。

我认为，日志滚动不应该让 python 来做，python 就直接 logging 到 stdout 。
外面用 supervisor 来守护，同时 supervisor 来收集日志到文件，最后由 logrotate 做每天的日志滚动。

https://gist.github.com/JZ10UJS/01c78bd03e8899a17bcc43ef50393d72

markdown 不让用啊

```python
# example.py
import logging
import multiprocessing
import os

_logger = logging.getLogger(__name__)

def init_logging():
# create logger
root_logger = logging.getLogger()
root_logger.setLevel(logging.DEBUG)

# create file handler
log_file = 'my_log_{}.log'.format(os.getpid())
file_handler = logging.FileHandler(log_file)
file_handler.setLevel(logging.DEBUG)

# create formatter
formatter = logging.Formatter('%(asctime)s - %(process)d - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)

# add file handler to logger
root_logger.addHandler(file_handler)



def start():
init_logging()
from . import file1, file2
file1.say_hello()
file2.say_hello()


def main():
processes = []
for i in range(4):
p = multiprocessing.Process(target=start)
processes.append(p)
p.start()

for p in processes:
p.join()

if __name__ == '__main__':
main()


# file1.py
import logging
_logger = logging.getLogger(__name__)

def say_hello():
_logger.info("this is hello message from file1.py")


# file2.py
import logging
_logger = logging.getLogger(__name__)

def say_hello():
_logger.info("this is hello message from file2.py")

```

子进程启动的地方，先 init_logger(), 这里面只需要设置 root logger 的 file handler 。然后其他地方使用各自 py 文件下的 logger 啊

看样子是我狭隘了，一直没了解过这个。这种情况下居然不支持回滚...

如果你看下这个的实现 IP('192.168.1.12') in IP('192.168.1.0/24')
就会发现实际上执行和 '192.168.1.12' in ['192.168.1.0', '192.168.1.1', ..., '192.168.1.254', '192.168.1.255'] 没区别
那这个实际执行次数就是 10w * 400 * 255

所以你可以先处理 IP 段 每一行 变成一个 set(str(i) for i in IP('192.168.1.0/24'))
然后再 '192.168.1.12' in set

实测 1000 * 400 : IP('192.168.1.12') in IP('192.168.1.0/24') 3.92s
1000* 400: '192.168.1.12' in set 18.1ms

自己往川沙找吧，看看有没有单间。

没动啊，既然严格要求 FIFO, 为啥去执行 SQL 的时候，还要开 ThreadPoolExecutor ？这种情况，从 sqlqueue 拿出来虽然是顺序的，但是感觉执行过去就可能乱序啊，毕竟 while 里面在不停的开 executor 。

我感觉都不用 POOL, 就一个 conn 不停的执行 sql 就好了？
with conn.cursor() as cr:
while not sqlqueue.empty():
cr.execute(sqlqueue.get())

直接 subprocess 调用 wkhtmltopdf ?

python 的话，client socket 直接 bind(ip, specified_port)

学到了

差不多啦，uwsgi 启动的子进程的 pid 基本都是连续递增的，这边还有 worker & 0xff， 一台机器支持 256 个 worker 呢。
实际启动的时候就那么几个进程，没那么巧就重复了吧，哈哈。

如果生产是多进程跑的话，应该是初始化 Generator(dc=0, worker=0)这个时候，所有进程的 10bit 的 node_id 都是一样的，然后就重复了。可以考虑 worker=os.getpid()

太久没有用 node.js ，不知道 node_modules 这个文件夹还大不大？