带列表的逻辑运算符答案

【问题标题】：Logical operators with lists带列表的逻辑运算符
【发布时间】：2015-09-29 23:10:57
【问题描述】：

我有一个问题：我有两个列表

Pipe_sizes = [15,15,22,15,32,45]
Flow_rate = [0.1,0.3,1,2,0.4,1.5]

我想使用逻辑运算符来更改列表 Pipe_size，例如：

if Flow_rate <= 0.2 then the pipe size is 15
if Flow_rate > 0.2 and <= 1 then the pipe size is 22
if Flow_rate > 1 and <=1.9  then the pipe size is 32
if Flow_rate > 1.9 then the pipe size is 45

我该怎么做？

【问题讨论】：

“更改列表Pipe_size”是什么意思？您的意思是从Pipe_sizes 中选择一个值吗？
我并不清楚你的规则来自哪里。例如。 > 1.9 = 45 来自哪里？为什么是 1.9？
你想用两个列表和bisect来做到这一点。

标签： python python-2.7 python-3.x ipython

【解决方案1】：

Pipe_sizes 与生成输出完全无关，因为所有可能的流量/管道尺寸组合都包含在条件列表中。所以可以直接生成结果：

def flow_rate_to_size(rate):
    if rate <= 0.2:
        size = 15
    elif 0.2 < rate <= 1:
        size = 22
    elif 1 < rate <= 1.9:
        size = 32
    else:
        size = 45
    return size

flow_rates = [0.1, 0.3, 1, 2, 0.4, 1.5]
pipe_sizes = [flow_rate_to_size(rate) for rate in flow_rates]
print(pipe_sizes)

输出：

[15、22、22、45、22、32]

【讨论】：

这也是我想到的解决方案，如果您愿意，可以在最后使用地图pipe_sizes = map(flow_rate_to_size, flow_rates)

【解决方案2】：

枚举 Flow_rate 的值并相应地更新 Pipe_sizes，如下所示：

Pipe_sizes = [15,15,22,15,32,45]
Flow_rate = [0.1,0.3,1,2,0.4,1.5]
for i, flow_rate in enumerate(Flow_rate):
    if flow_rate <= .2:
        Pipe_sizes[i] = 15
    elif flow_rate <= 1:
        Pipe_sizes[i] = 22
    elif flow_rate <= 1.9:
        Pipe_sizes[i] = 32
    else:
        Pipe_sizes[i] = 45

【讨论】：

【解决方案3】：

我做了一个方法来帮助你计算管道尺寸：

Flow_rate = [0.1,0.3,1,2,0.4,1.5]

def calculate_pipe_size(flow_rate):
    pipe_sizes = []
    for number in flow_rate:
        if number <= 0.2:
            pipe_sizes.append(15)
        if number > 0.2:
            pipe_sizes.append(22)
        if number > 1:
            pipe_sizes.append(32)
        if number > 1.9:
            pipe_sizes.append(45)
    return pipe_sizes

print calculate_pipe_size(Flow_rate)

【讨论】：

【解决方案4】：

Flow_rate = numpy.array([0.1,0.3,1,2,0.4,1.5])
pipe_sizes = numpy.zeros(len(FlowRate))

Flow_rate[Flow_rate <= 0.2] = 15
Flow_rate[Flow_rate > 0.2 & Flow_rate <= 0.4] = 15
...

可能很好......粗略的，这不会很快，因为每个布尔值都会迭代整个列表，但它是相当可读的......

【讨论】：

【解决方案5】：

在 golang 中，只是因为我需要练习（并希望展示 Python 是多么简洁......）

package main

import "fmt"

func getPipeSize(flowRate float32) (pipeSize int) {
    switch {
    case flowRate <= 0.2:
        pipeSize = 15
    case 0.2 < flowRate && flowRate <= 1.0:
        pipeSize = 22
    case 1.0 < flowRate && flowRate <= 1.9:
        pipeSize = 32
    case 1.9 < flowRate:
        pipeSize = 45
    }
    return
}

func main() {
    flow_rates := []float32{0.1, 0.3, 1, 2, 0.4, 1.5}
    pipe_sizes := make([]int, len(flow_rates))
    for i, flow_rate := range flow_rates {
        pipe_sizes[i] = getPipeSize(flow_rate)
    }
    fmt.Println(flow_rates)
    fmt.Println(pipe_sizes)
}

在 Python 中：

def get_pipe_size(flow_rate):
    if flow_rate <= 0.2:
        pipe_size = 15
    elif 0.2 < flow_rate <= 1:
        pipe_size = 22
    elif 1 < flow_rate <= 1.9:
        pipe_size = 32
    else:
        pipe_size = 45
    return pipe_size

flow_rates = [0.1, 0.3, 1, 2, 0.4, 1.5]
pipe_sizes = [get_pipe_size(flow_rate) for flow_rate in flow_rates]

【讨论】：

【解决方案6】：

如果您不介意稍微修改输入，numpy 有一些方法可以像您想要的那样存储值：

import numpy as np
# pipe sizes for each of the different bins
pipe_bins = [15, 22, 32, 45]

# create the bins as monotonically increasing values 
# Each index i returned is such that 
# bins[i-1] <= x < bins[i] if bins is monotonically increasing
# I've changed to .000001 because you wanted x < 2
bins = np.array([0.200000001, 1.000000001, 1.9000000001])


input_flows = [0.1, 0.3, 1, 2, 0.4, 1.9]
# below list will contain the bins of each input flow
flow_in_bins = np.digitize(l, bins)
# now we can just map the flow bin to actual pipe size
result = map(lambda x: pipes[x], flow_in_bins)
print result
# result = [15, 22, 22, 45, 22, 45]

有关数字化的更多详细信息，请查看文档numpy.digitize

【讨论】：