sommando solo i numeri contenuti in un elenco

Question

Fornisci un metodo che somma tutti i numeri in un list. Il metodo dovrebbe essere in grado di saltare elementi che non sono numeri. Quindi, sum([1, 2, 3]) dovrebbe essere 6 ma sum(['A', 1, 'B', 2, 3])dovrebbe anche essere 6. Come posso realizzare questo?

quello che ho già provato finora:

def foo(list): 
    dict = "ABCDEFGHIJKLMN" 
    n = 0 
    for i in range(0, len(list) - 1): 
     if list[i].str in dict: 
      "" 
     else:  
      n= n + list[i] 
    return n 

print foo([1, 2, 3, 4, 5, 6, "A", "B"]) 

Answer 1

Si può fare questo con un semplice rivestimento:

l1 = [1, 2, 3, 'A'] 

sum(filter(lambda i: isinstance(i, int), l1)) 
# prints 6 

Oppure, se ne avete bisogno all'interno di una funzione:

def foo(l1): 
    return sum(filter(lambda i: isinstance(i, int), l1)) 

Inoltre, come indicato nei commenti, non utilizzare nomi come dict e list per le variabili; * ombreggiano i nomi predefiniti per i dizionari (dict) e (list). Dovrai quindi esplicitamente del dict, list per utilizzarli come previsto.

---

Ma, lasciatemi spiegare. Nei filter fa, qui è:

a) Prende una funzione come primo parametro:

# this function will return True if i is an int 
# and false otherwise 
lambda i: isinstance(i, int) 

e poi prende ogni elemento all'interno della lista l1 (secondo argomento) e valuta se sia è True o False in base alla funzione.

b) Quindi, filter sarà essenzialmente filtrare qualsiasi oggetto lista l1 interne che non sono istanze di int (cioè la funzione restituisce False per loro). Di conseguenza, per un elenco come [1, 2, 3, 'A'] il filtro restituirà [1, 2, 3] che verrà quindi riassunto da sum().

Alcuni esempi:

foo([1, 2, 3, 'A']) 
# 6 

foo([1, 2, 3]) 
# 6 

foo([1, 2, 3, 'HELLO', 'WORLD']) 
# 6 

---

Leggero avvertimento:

Come è, questo non significa riassumere float valori, li (e altri tipi numerici gocce per quel caso). Se avete bisogno anche questo, è sufficiente aggiungere il tipo di float nella funzione lambda come così:

lambda i: isinstance(i, (int, float)) 

Ora, le vostre somme funzione galleggia troppo:

foo([1, 2, 3, 3.1, 'HELLO', 'WORLD']) 
# 9.1 

aggiungere altri tipi come necessario nella funzione lambda per prendere i casi che ti servono.

---

Una cattura tutti i casi:

Come notato da @Copperfield è possibile verificare la presenza di oggetti che sono istanze di qualsiasi numero utilizzando la classe di base astratta numbers.Number nel numbers modulo. Questo agisce come catch-all caso per i valori numerici:

import numbers # must import 
sum(filter(lambda i: isinstance(i, numbers.Number), l1)) 

semplice e un po 'più veloce, troppo:

Inoltre, come osservato da @ShadowRanger, e poiché lambda might not be the most comfortable construct for new users, si potrebbe semplicemente utilizzare a generator expression (che è anche più veloce) con sum per ottenere lo stesso risultato esatto:

sum(val for val in l1 if isinstance(val, numbers.Number)) 

Answer 2

filtro uso e isinstance come questo

>>> test = [1,2,3,4,5,6,"A","B"] 
>>> sum(filter(lambda x:isinstance(x,int),test)) 
21 
>>> 

Answer 3

sum([x for x in list if isinstance(x, (int, long, float))]) 

Answer 4

Il modo Pythonic è quello di fare un try/except. Mentre potresti farlo in una sola nave, preferisco spezzare un po 'le cose per vedere esattamente cosa sta succedendo.

val=0 
for item in list: 
    try: 
     val+=int(item) 
    except ValueError: 
     pass 

Se si desidera includere punti di galleggiamento, è sufficiente modificare il int ad un float. I punti mobili sono qualsiasi cosa con un decimale, tra gli altri.

Answer 5

def foo(list): 
dict= "ABCDEFGHIJKLMN" 
n=0 
for i in range(0,len(list)-1): 
    if str(list[i]) in dict: 
     "" 
    else:  
     n= n+list[i] 
return n 
print foo([1,2,3,4,5,6,"A","B"]) 

Answer 6

def filtersum(L): 
    if not L: return 0 
    if not isinstance(L[0], int): return filtersum(L[1:]) 
    return L[0] + filtersum(L[1:]) 

uscita:

In [28]: filtersum([1,2,3]) 
Out[28]: 6 

In [29]: filtersum([1,'A', 2,3]) 
Out[29]: 6