不知道放哪儿的随机编程小发现记录

"log_prob"通常指的是概率论和统计学中的对数似然函数（Log Probability），特别是在机器学习和深度学习库中如TensorFlow或PyTorch中，它用于计算某个数值事件发生的对数概率。

例如，在TensorFlow的概率分布类中，prob(x)会直接返回x对应的概率值，而log_prob(x)则返回这个概率的对数值。这样做的好处在于当概率非常小的时候，直接计算概率可能会导致溢出或下溢，但对数可以避免这个问题。

这里是一个简单的Python示例，假设我们有一个高斯分布dist：

from tensorflow_probability import distributions as tfd

# 创建一个正态分布
dist = tfd.Normal(loc=0., scale=1.)

# 计算特定值x的对数概率
x = 1.
log_prob_x = dist.log_prob(x)

在这个例子中，log_prob_x就是变量x按照正态分布的对数概率。

布尔判断

情况：一个变量a同时有可能是bool或str，需要做分流。
解决：可以写类似"if a is True"的判断，这样只会对标True布尔值，而不会像"if a"一样将字符串也判定进去。

多进程一键开启

一种经典方法是使用 multiprocessing 库：

def long_time_task(name):
    print('Run Task %s %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(1)
    end = time.time()
    print('Task %s Run %0.2f seconds.' % (name, (end - start)))
    return name


if __name__ == '__main__':
    t_one = time.time()
    print('Parent process %s.' % os.getpid())
    p = multiprocessing.Pool(34)
    for i in range(34):
        p.apply_async(long_time_task, args=(i,))
    print('waiting for all subprocesses done...')
    p.close()
    p.join()
    t_two = time.time()
    print(f'All subprocesses done.{t_two-t_one}')

进程池的进程数选用，可以填入multiprocessing.cpu_count()。

具体的选用方式大致可概括为，io密集型选用multiprocessing.cpu_count() + n，n根据情况自选；cpu密集型可直接选用multiprocessing.cpu_count()，即有多少cpu就开多少进程。

另一种或许写起来更简便的方法是，使用 tqdm 库提供的方式，它将原本的写法包装成了一行，并且有进度条功能。

def long_time_task(name, sign):
    print('Run Task %s %s (%s)...' % (name, sign, os.getpid()))
    start = time.time()
    time.sleep(1)
    end = time.time()
    print('Task %s Run %0.2f seconds.' % (name, (end - start)))
    return name


if __name__ == '__main__':
    from tqdm.contrib.concurrent import process_map

    def _generator(m):
        for i in range(m):
            yield "my love"
            
    r = process_map(long_time_task, range(112), _generator(112), max_workers=34)
    print(multiprocessing.cpu_count())
    print(r)

可以看到，这个方式更清晰一些，不过入参需要把参数生成写在内部（传生成器进去）。

批量处理迭代器（列表、元组）

在Python中，map()函数用于将一个函数应用于迭代器中的每个元素，并返回一个包含结果的新的可迭代对象。它的基本语法如下：

map(function, iterable)

其中，function是一个函数对象，iterable是一个可迭代对象，比如列表、元组等。

map()函数将iterable中的每个元素依次传递给function进行处理，并返回一个包含处理结果的新的可迭代对象。function可以是内置函数、自定义函数或Lambda函数。

下面是一些示例来说明map()函数的用法：

1. 对列表中的每个元素进行平方操作：

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print(squared_numbers)  # 输出：[1, 4, 9, 16, 25]

2. 将列表中的每个元素转换为字符串：

numbers = [1, 2, 3, 4, 5]
number_strings = list(map(str, numbers))
print(number_strings)  # 输出：['1', '2', '3', '4', '5']

3. 使用自定义函数进行处理：

def double(x):
    return 2 * x

numbers = [1, 2, 3, 4, 5]
doubled_numbers = list(map(double, numbers))
print(doubled_numbers)  # 输出：[2, 4, 6, 8, 10]

需要注意的是，map()函数返回的是一个迭代器对象，如果需要得到一个列表对象，可以使用list()函数将其转换为列表。

df四舍五入

round(3)
例如，如果你有一个数据框df，其中一列名为’col1’，你想要将’col1’中的所有数值四舍五入到小数点后三位，你可以使用以下代码：

df[‘col1’] = df[‘col1’].round(3)

这将更新df中的’col1’列，使其所有数值都四舍五入到小数点后三位。