与列表逻辑运算符

我有一个问题：我有两个列表与列表逻辑运算符

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

我该怎么办呢？

来源

2015-09-29 Daniele

你所说的“变化的意思列表'Pipe_size'“？你的意思是从'Pipe_sizes'中选择一个值？ –

我不清楚你的规则是从哪里来的。例如。 > 1.9 = 45从哪里来？为什么1.9？ –

你想用两个列表和“bisect”来做到这一点。 –

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]

来源

2015-09-29 23:31:27 mhawke

这也是我想到的解决方案，如果您愿意，您可以在最后使用map'pipe_sizes = map（flow_rate_to_size，flow_rates）' – ziddarth

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

来源

2015-09-29 23:21:15 Ben

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

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)

来源

2015-09-29 23:26:00 heinst

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

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

来源

2015-09-29 23:27:49

在golang，只是因为我需要的实践（希望炫耀如何更简洁的蟒蛇是....）

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]

来源

2015-09-29 23:48:28

如果你不介意修改输入略有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

来源

2015-09-30 00:19:42 ziddarth

与列表逻辑运算符

回答

相关问题