迭代和条件句的Pythonic用法

这是一个略显笼统的问题-我正在寻找最具python风格和/或效率的方法：

我有一个大数据集和许多任务，有时需要通过遍历行来执行，有时则不需要，具体取决于某些条件

for step in np.arange (0, number_of_steps):
    if condition1:
        do_calculation1(step)
    if condition2:
        do_calculation2(step)

因此，这两个

if

语句在每次迭代中都会重复。对于整个数据集，条件是true或false，因此为了节省时间，如果不需要，我将不进行迭代：

if condition1 or condition2:
    for step in np.arange (0, number_of_steps):
            if condition1:
                do_calculation1(step)
            if condition2:
                do_calculation2(step)

但我仍然在重复

if

语句，有时是不必要的。 另一种方法是分离条件语句，并通过数据集进行两次迭代：

if condition1 :
    for step in np.arange (0, number_of_steps):
        do_calculation1(step)
if condition2:
    for step in np.arange (0, number_of_steps):
        do_calculation2(step)

这样做的缺点是，如果这两个条件都是真的，我会迭代两次，这很慢（而且很笨拙）。这两种方法的相对速度取决于每种情况的真实性，但我将使用各种各样的数据，所以我不知道哪种方法更快

---

所以我的问题是，哪种方法是最具吸引力和效率的方法？

您可以简单地将这两种方法结合起来：

if not condition1 and not condition2:
    pass
elif not condition1 and condition2
    for step in np.arange (0, number_of_steps):
        do_calculation1(step)
elif condition1 and not condition2:
    for step in np.arange (0, number_of_steps):
        do_calculation2(step)
else: # condition 1 and condition2:
    for step in np.arange (0, number_of_steps):
        do_calculation1(step)
        do_calculation2(step)

我想这更像是一个效率问题，而不是一个更像蟒蛇的问题

我想这会更像蟒蛇：

def run_calcs(number_of_steps, *funcs):
    for step in range(number_of_steps):
        for func in funcs:
            func(step)

def gen_func_list(condition1=False, condition2=False):
    func_list = []
    if condition1:
        func_list.append(do_calculation1)
    if condition2:
        func_list.append(do_calculation2)
    return func_list

if __name__ == '__main__':

    number_of_steps = 10

    run_calcs(
        number_of_steps,
        *gen_func_list(
            condition1=<your condition here>,
            condition2=<your condition here>
        )
    )

def运行计算（步骤数，*funcs）：
对于步进范围（步数）：
对于func中的func：
func（步骤）
def gen_func_列表（条件1=False，条件2=False）：
func_list=[]
如果条件1：
func_list.append（do_calculation1）
如果条件2：
func_list.append（do_calculation2）
返回函数列表
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
步数=10
运行计算(
步数，
*gen_func_列表(
条件1=，
条件2=
)
)

我认为这也是非常可读的，并且适合于多处理：

from multiprocessing import Process

def run_calcs(number_of_steps, *funcs):
    for step in range(number_of_steps):
        for func in funcs:
            func(step)

def gen_func_list(condition1=True, condition2=True):
    func_list = []
    if condition1:
        func_list.append(do_calculation1)
    if condition2:
        func_list.append(do_calculation2)
    return func_list

if __name__ == '__main__':

    number_of_steps = 10

    funcs = gen_func_list(
            condition1=<your condition here>,
            condition2=<your condition here>
    )

    proc_handles = []
    for f in funcs:
        proc_handles.append(
            Process(target=run_calcs,
                    args=[number_of_steps, f])
        )

    for p in proc_handles:
        p.start()

    for p in proc_handles:
        p.join()

来自多处理导入进程的

def运行计算（步骤数，*funcs）：
对于步进范围（步数）：
对于func中的func：
func（步骤）
def gen_func_列表（条件1=True，条件2=True）：
func_list=[]
如果条件1：
func_list.append（do_calculation1）
如果条件2：
func_list.append（do_calculation2）
返回函数列表
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
步数=10
funcs=gen\u func\u列表(
条件1=，
条件2=
)
进程句柄=[]
对于函数中的f：
proc_handles.append(
过程（目标=运行计算，
args=[步数，f]）
)
对于进程句柄中的p：
p、 开始（）
对于进程句柄中的p：
p、 加入

您可以简单地将两种方法结合起来：

if not condition1 and not condition2:
    pass
elif not condition1 and condition2
    for step in np.arange (0, number_of_steps):
        do_calculation1(step)
elif condition1 and not condition2:
    for step in np.arange (0, number_of_steps):
        do_calculation2(step)
else: # condition 1 and condition2:
    for step in np.arange (0, number_of_steps):
        do_calculation1(step)
        do_calculation2(step)

我想这更像是一个效率问题，而不是一个更像蟒蛇的问题

我想这会更像蟒蛇：

def run_calcs(number_of_steps, *funcs):
    for step in range(number_of_steps):
        for func in funcs:
            func(step)

def gen_func_list(condition1=False, condition2=False):
    func_list = []
    if condition1:
        func_list.append(do_calculation1)
    if condition2:
        func_list.append(do_calculation2)
    return func_list

if __name__ == '__main__':

    number_of_steps = 10

    run_calcs(
        number_of_steps,
        *gen_func_list(
            condition1=<your condition here>,
            condition2=<your condition here>
        )
    )

def运行计算（步骤数，*funcs）：
对于步进范围（步数）：
对于func中的func：
func（步骤）
def gen_func_列表（条件1=False，条件2=False）：
func_list=[]
如果条件1：
func_list.append（do_calculation1）
如果条件2：
func_list.append（do_calculation2）
返回函数列表
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
步数=10
运行计算(
步数，
*gen_func_列表(
条件1=，
条件2=
)
)

我认为这也是非常可读的，并且适合于多处理：

from multiprocessing import Process

def run_calcs(number_of_steps, *funcs):
    for step in range(number_of_steps):
        for func in funcs:
            func(step)

def gen_func_list(condition1=True, condition2=True):
    func_list = []
    if condition1:
        func_list.append(do_calculation1)
    if condition2:
        func_list.append(do_calculation2)
    return func_list

if __name__ == '__main__':

    number_of_steps = 10

    funcs = gen_func_list(
            condition1=<your condition here>,
            condition2=<your condition here>
    )

    proc_handles = []
    for f in funcs:
        proc_handles.append(
            Process(target=run_calcs,
                    args=[number_of_steps, f])
        )

    for p in proc_handles:
        p.start()

    for p in proc_handles:
        p.join()

来自多处理导入进程的

def运行计算（步骤数，*funcs）：
对于步进范围（步数）：
对于func中的func：
func（步骤）
def gen_func_列表（条件1=True，条件2=True）：
func_list=[]
如果条件1：
func_list.append（do_calculation1）
如果条件2：
func_list.append（do_calculation2）
返回函数列表
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
步数=10
funcs=gen\u func\u列表(
条件1=，
条件2=
)
进程句柄=[]
对于函数中的f：
proc_handles.append(
过程（目标=运行计算，
args=[步数，f]）
)
对于进程句柄中的p：
p、 开始（）
对于进程句柄中的p：
p、 加入

我认为第一种方法更像是python方法。但如果您真的想在不满足任何条件的情况下跳过迭代，您可以添加一个break语句：

for ... :
    if not any(condition 1, condition2):
        break
    else:
        if condition1:
            ...
        if condition2:
            ...

这将允许您避免第一步中的迭代，或者检查两个条件是否都满足

---

（很抱歉格式化，从电话中键入。）

我认为第一种方法更像是python方法。但如果您真的想在不满足任何条件的情况下跳过迭代，您可以添加一个break语句：

for ... :
    if not any(condition 1, condition2):
        break
    else:
        if condition1:
            ...
        if condition2:
            ...

这将允许您避免第一步中的迭代，或者检查两个条件是否都满足

---

（很抱歉设置了格式，请从电话中键入。）

我会这样做：

calculations = [
    f for c,f in [
        (condition1, do_calculation1),
        (condition2, do_calculation2),
    ] if c
]
if calculations:
    for step in np.arange (0, number_of_steps):
        for calc in calculations:
            calc(step)

---

这就是我要做的：

calculations = [
    f for c,f in [
        (condition1, do_calculation1),
        (condition2, do_calculation2),
    ] if c
]
if calculations:
    for step in np.arange (0, number_of_steps):
        for calc in calculations:
            calc(step)

---

我认为第一种方法是最好的，因为您的数据集要么有条件（1和/或2），要么没有条件

如果这两个条件相互排斥，则可以用elif替换第二个If。这将节省一些计算

for step in np.arange (0, number_of_steps):
if condition1:
    do_calculation1(step)
elif condition2:
    do_calculation2(step)

---

我认为第一种方法是最好的，因为您的数据集要么有条件（1和/或2），要么没有条件

如果这两个条件相互排斥，则可以用elif替换第二个If。这将节省一些计算

for step in np.arange (0, number_of_steps):
if condition1:
    do_calculation1(step)
elif condition2:
    do_calculation2(step)

---

谢谢是的，这样效率更高。我想我是在寻找效率和通灵性（？）@doctorer谢谢，现在它更通灵了，甚至更高效了。谢谢。是的，这样效率更高。我想我是在寻找效率和pythonicity（？）@doctorer谢谢，现在它有点pythonic，甚至更具性能。爱这个-pythonic和高效。爱这个-pythonic和高效。