eine komplexe Zahl in Python Liste

Question

In meiner Python-Skript Linie Um Index

a=function(i) 

so ist eine Ergebnisliste. In dieser Liste gibt es vier Werte, eine negative Zahl, eine positive Zahl und zwei komplexe Zahlen. Nur das Positive ist nützlich für mich und ich möchte es indizieren. Ich schreibe das für Index, aber es funktioniert nicht

a=function(i) 
for b in a: 
    if a>0 and type(a)==type(0.1): 
     return a 

so wie kann ich es angehen. Vielen Dank.

Answer 1

Sie rufen return außerhalb einer Funktion, die nicht legal ist.

Um die positive ganze Zahl von Ihrer Liste zu bekommen, „positiv“ und „negativ“ Zahlen sind von float Typ vorausgesetzt:

a = function(i) 

index = None 
for index, v in enumerate(a): 
    if type(v) == float and v >= 0: 
     break 

print(index) 
print(a[index]) 

Dies legt den Index der ersten positiven reellen Zahl der Liste in index.

Wie es

Grundsätzlich dieser Code iteriert über die Liste arbeitet, und überprüft die Art der Elemente. Wenn ein Element eine reelle Zahl ist, wird seine Positivität überprüft. Wenn es positiv ist, wird der Wert seines Indexes in index gesetzt und die Schleife wird gestoppt.

---

^{1: Wenn Sie eher bedeuten "ein complex Objekt, dessen imaginärer Teil gleich Null ist", dann ersetzen if type(v) == float and v >= 0 durch if v.imag == 0 and v.real >= 0. In Ihrem Code haben Sie jedoch type(a)==type(0.1) geschrieben, also nehme ich an, dass a erwartet wird, ein float zu sein.}

Answer 2

Ich hatte fast genau dieses Problem zu lösen und hatte eine Funktion, um die positive Wurzel zu finden und einen Valueerror zu erhöhen, wenn es keine gab:

def find_positive_root(a): 
    for b in a: 
     if type(b) == complex or b<0: 
      continue 
     return b 
    raise ValueError('No positive root in {}'.format(a)) 

Den Vorteil eine spezielle Funktion für das Schreiben ist, dass Sie kann es prüfen:

In [6]: find_positive_root([-4.3, 2.3j, 3, (-4+8j)]) 
Out[6]: 3 

In [7]: find_positive_root([1., -4j, -2.3, 4j]) 
Out[7]: 1.0 

In [8]: find_positive_root([-1., -4j, -2.3, 4j]) 
    ...: 
--------------------------------------------------------------------------- 
ValueError        Traceback (most recent call last) 
<ipython-input-138-a4ed7675f551> in <module>() 
----> 1 find_positive_root([-1., -4j, -2.3, 4j]) 

<ipython-input-132-9cd37f48e3bb> in find_positive_root(a) 
     4    continue 
     5   return b 
----> 6  raise ValueError('No positive root in {}'.format(a)) 

ValueError: No positive root in [-1.0, (-0-4j), -2.3, 4j] 

Answer 3

Yeah. Irgendwann habe ich es ausprobiert. Unten ist mein Code:

a=function(i) 
for v in a: 
    if type(v) is sy.add.Add: 
     pass 
    elif v > 0: 
     return v 
    else: 
     pass 
return v 

Hinweis: Ich löse die Funktion (i) sympy und die komplexe Zahl in der Ergebnisliste verwendet, ist sympy.add.Add.