带列表的逻辑运算符

Question

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

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

我该怎么做？

Answer 1

枚举 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

Answer 2

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

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)

Answer 3

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
...

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

Answer 4

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]

Answer 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]

Answer 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

带列表的逻辑运算符

Logical operators with lists

python

ipython

python-2.7

python-3.x