Python跳过负值

因此，我使用以下代码来查找3个给定值中的最小值，

abc、xyz、mnl

是包含要比较的值的列表：

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    print (a,b,c)
    if int(a) < int(b) & int(a) < int(c):
        print "a","\t",a
    elif int(b) < int(a) & int(b) < int(c):
        print "b","\t",b
    elif int(c) < int(a) & int(c) < int(b):
        print "c","\t",c

问题是它在2次迭代时打印最小值“b”，并在打印之前跳过3次迭代。它在每次迭代中都会这样做，每次迭代包含多个负值（-ve），如我们在第一次迭代中看到的

'-7589493'，'-1419231'

---

为什么它不能打印每次迭代的最小值？方法稍有不同：

abc = ('1', '2', '3')
xyz = ('3', '1', '2')
mnl = ('2', '3', '1')

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    (aa, bb, cc) = (int(a), int(b), int(c))
    print(aa, bb, cc)
    m = min(aa, bb, cc)
    index = (aa, bb, cc).index(m)
    print 'abc'[index], m

# output:
(1, 3, 2)
a 1
(2, 1, 3)
b 1
(3, 2, 1)
c 1

for q, tup in enumerate(zip(abc, xyz, mnl)):
    combo = ((int(x), y) for x, y in zip(tup, 'abc'))
    # example of combo: ((5, 'a'), (2, 'b'), (8, 'c'))
    print '{1}\t{0}'.format(*min(combo))

---

我从您的示例中保留了

q

和

enumerate

，即使它没有被使用。

一种稍微不同的方法：

abc = ('1', '2', '3')
xyz = ('3', '1', '2')
mnl = ('2', '3', '1')

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    (aa, bb, cc) = (int(a), int(b), int(c))
    print(aa, bb, cc)
    m = min(aa, bb, cc)
    index = (aa, bb, cc).index(m)
    print 'abc'[index], m

# output:
(1, 3, 2)
a 1
(2, 1, 3)
b 1
(3, 2, 1)
c 1

for q, tup in enumerate(zip(abc, xyz, mnl)):
    combo = ((int(x), y) for x, y in zip(tup, 'abc'))
    # example of combo: ((5, 'a'), (2, 'b'), (8, 'c'))
    print '{1}\t{0}'.format(*min(combo))

---

我从您的示例中保留了

q

和

enumerate

，即使它没有被使用。

一种稍微不同的方法：

abc = ('1', '2', '3')
xyz = ('3', '1', '2')
mnl = ('2', '3', '1')

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    (aa, bb, cc) = (int(a), int(b), int(c))
    print(aa, bb, cc)
    m = min(aa, bb, cc)
    index = (aa, bb, cc).index(m)
    print 'abc'[index], m

# output:
(1, 3, 2)
a 1
(2, 1, 3)
b 1
(3, 2, 1)
c 1

for q, tup in enumerate(zip(abc, xyz, mnl)):
    combo = ((int(x), y) for x, y in zip(tup, 'abc'))
    # example of combo: ((5, 'a'), (2, 'b'), (8, 'c'))
    print '{1}\t{0}'.format(*min(combo))

---

我从您的示例中保留了

q

和

enumerate

，即使它没有被使用。

一种稍微不同的方法：

abc = ('1', '2', '3')
xyz = ('3', '1', '2')
mnl = ('2', '3', '1')

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    (aa, bb, cc) = (int(a), int(b), int(c))
    print(aa, bb, cc)
    m = min(aa, bb, cc)
    index = (aa, bb, cc).index(m)
    print 'abc'[index], m

# output:
(1, 3, 2)
a 1
(2, 1, 3)
b 1
(3, 2, 1)
c 1

for q, tup in enumerate(zip(abc, xyz, mnl)):
    combo = ((int(x), y) for x, y in zip(tup, 'abc'))
    # example of combo: ((5, 'a'), (2, 'b'), (8, 'c'))
    print '{1}\t{0}'.format(*min(combo))

我保留了示例中的

q

和

enumerate

，即使它没有使用。

，您可以使用

min

功能。但是，如果您愿意，这应该是可行的：

abc = (1,2,3)
xyz = (2,3,1)
mnl = (3,1,2)

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    print (a,b,c)
    a,b,c=int(a),int(b),int(c)
    if b > a < c:
        print ("a",a)
    elif a > b < c:
        print ("b",b)
    elif b > c < a:
        print ("c",c)

，您可以使用

min

功能。但是，如果您愿意，这应该是可行的：

abc = (1,2,3)
xyz = (2,3,1)
mnl = (3,1,2)

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    print (a,b,c)
    a,b,c=int(a),int(b),int(c)
    if b > a < c:
        print ("a",a)
    elif a > b < c:
        print ("b",b)
    elif b > c < a:
        print ("c",c)

，您可以使用

min

功能。但是，如果您愿意，这应该是可行的：

abc = (1,2,3)
xyz = (2,3,1)
mnl = (3,1,2)

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    print (a,b,c)
    a,b,c=int(a),int(b),int(c)
    if b > a < c:
        print ("a",a)
    elif a > b < c:
        print ("b",b)
    elif b > c < a:
        print ("c",c)

，您可以使用

min

功能。但是，如果您愿意，这应该是可行的：

abc = (1,2,3)
xyz = (2,3,1)
mnl = (3,1,2)

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    print (a,b,c)
    a,b,c=int(a),int(b),int(c)
    if b > a < c:
        print ("a",a)
    elif a > b < c:
        print ("b",b)
    elif b > c < a:
        print ("c",c)

---

和

它是二进制的

和

，而不是逻辑的

和

试试这个：

for q, (a, b, c) in enumerate(zip(abc, xyz, mnl)):
    print(a, b, c)
    if int(c) > int(a) < int(b):
        print("a", "\t", a)
    elif int(c) > int(b) < int(a):
        print("b", "\t", b)
    elif int(b) > int(c) < int(a):
        print("c", "\t", c)

---

和

它是二进制的

和

，而不是逻辑的

和

试试这个：

for q, (a, b, c) in enumerate(zip(abc, xyz, mnl)):
    print(a, b, c)
    if int(c) > int(a) < int(b):
        print("a", "\t", a)
    elif int(c) > int(b) < int(a):
        print("b", "\t", b)
    elif int(b) > int(c) < int(a):
        print("c", "\t", c)

---

和

它是二进制的

和

，而不是逻辑的

和

试试这个：

for q, (a, b, c) in enumerate(zip(abc, xyz, mnl)):
    print(a, b, c)
    if int(c) > int(a) < int(b):
        print("a", "\t", a)
    elif int(c) > int(b) < int(a):
        print("b", "\t", b)
    elif int(b) > int(c) < int(a):
        print("c", "\t", c)

---

和

它是二进制的

和

，而不是逻辑的

和

试试这个：

for q, (a, b, c) in enumerate(zip(abc, xyz, mnl)):
    print(a, b, c)
    if int(c) > int(a) < int(b):
        print("a", "\t", a)
    elif int(c) > int(b) < int(a):
        print("b", "\t", b)
    elif int(b) > int(c) < int(a):
        print("c", "\t", c)

我的做法如下：

abc = ('1', '2', '3')
xyz = ('3', '1', '2')
mnl = ('2', '3', '1')

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    (aa, bb, cc) = (int(a), int(b), int(c))
    print(aa, bb, cc)
    m = min(aa, bb, cc)
    index = (aa, bb, cc).index(m)
    print 'abc'[index], m

# output:
(1, 3, 2)
a 1
(2, 1, 3)
b 1
(3, 2, 1)
c 1

for q, tup in enumerate(zip(abc, xyz, mnl)):
    combo = ((int(x), y) for x, y in zip(tup, 'abc'))
    # example of combo: ((5, 'a'), (2, 'b'), (8, 'c'))
    print '{1}\t{0}'.format(*min(combo))

这里的关键是combo的计算。在这种方法中，

tup

是由3个字符串组成的元组，例如

（'5'，'2'，'8'）

combo

是转换为

int

并用标签压缩后的这个元组的组合

['a'，'b'，'c']

以下是我的方法：

abc = ('1', '2', '3')
xyz = ('3', '1', '2')
mnl = ('2', '3', '1')

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    (aa, bb, cc) = (int(a), int(b), int(c))
    print(aa, bb, cc)
    m = min(aa, bb, cc)
    index = (aa, bb, cc).index(m)
    print 'abc'[index], m

# output:
(1, 3, 2)
a 1
(2, 1, 3)
b 1
(3, 2, 1)
c 1

for q, tup in enumerate(zip(abc, xyz, mnl)):
    combo = ((int(x), y) for x, y in zip(tup, 'abc'))
    # example of combo: ((5, 'a'), (2, 'b'), (8, 'c'))
    print '{1}\t{0}'.format(*min(combo))

这里的关键是combo的计算。在这种方法中，

tup

是由3个字符串组成的元组，例如

（'5'，'2'，'8'）

combo

是转换为

int

并用标签压缩后的这个元组的组合

['a'，'b'，'c']

以下是我的方法：

abc = ('1', '2', '3')
xyz = ('3', '1', '2')
mnl = ('2', '3', '1')

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    (aa, bb, cc) = (int(a), int(b), int(c))
    print(aa, bb, cc)
    m = min(aa, bb, cc)
    index = (aa, bb, cc).index(m)
    print 'abc'[index], m

# output:
(1, 3, 2)
a 1
(2, 1, 3)
b 1
(3, 2, 1)
c 1

for q, tup in enumerate(zip(abc, xyz, mnl)):
    combo = ((int(x), y) for x, y in zip(tup, 'abc'))
    # example of combo: ((5, 'a'), (2, 'b'), (8, 'c'))
    print '{1}\t{0}'.format(*min(combo))

这里的关键是combo的计算。在这种方法中，

tup

是由3个字符串组成的元组，例如

（'5'，'2'，'8'）

combo

是转换为

int

并用标签压缩后的这个元组的组合

['a'，'b'，'c']

以下是我的方法：

abc = ('1', '2', '3')
xyz = ('3', '1', '2')
mnl = ('2', '3', '1')

for q , (a,b,c) in enumerate(zip(abc,xyz,mnl)):
    (aa, bb, cc) = (int(a), int(b), int(c))
    print(aa, bb, cc)
    m = min(aa, bb, cc)
    index = (aa, bb, cc).index(m)
    print 'abc'[index], m

# output:
(1, 3, 2)
a 1
(2, 1, 3)
b 1
(3, 2, 1)
c 1

for q, tup in enumerate(zip(abc, xyz, mnl)):
    combo = ((int(x), y) for x, y in zip(tup, 'abc'))
    # example of combo: ((5, 'a'), (2, 'b'), (8, 'c'))
    print '{1}\t{0}'.format(*min(combo))

---

这里的关键是combo的计算。在这种方法中，

tup

是由3个字符串组成的元组，例如

（'5'，'2'，'8'）

combo

是转换为

int

并用标签压缩后的这个元组的组合

['a'，'b'，'c']

您的意思是

和
而不是
&
<代码>&
不是逻辑的
，
-它是位操作。哦，所以问题是错的operator@Anjan是的，尽管选择的方法并不出色。一开始就很复杂，你的意思是
和
，而不是
&
<代码>&
不是逻辑的
，
-它是位操作。哦，所以问题是错的operator@Anjan是的，尽管选择的方法并不出色。一开始就很复杂，你的意思是
和
，而不是
&
<代码>&
不是逻辑的
，
-它是位操作。哦，所以问题是错的operator@Anjan是的，尽管选择的方法并不出色。一开始就很复杂，你的意思是
和
，而不是
&
<代码>&
不是逻辑的
，
-它是位操作。哦，所以问题是错的operator@Anjan是的，尽管选择的方法并不出色。从原始海报的代码开始，要遵循非常复杂的操作，似乎值是字符串，而不是原始海报代码中的ints，似乎值是字符串，而不是原始海报代码中的ints，似乎值是字符串，而不是原始海报代码中的ints，似乎值是字符串，而不是ints