Python - memorizzare una stringa e un int usando la mappa (sys.stdin.readline())

Question

Se l'ingresso contiene una riga spazio separato di int, come-

1 3 

posso Deposito in un array utilizzando la funzione di map()

arr = map(int,sys.stdin.readline().split()) 

o anche in due variabili distinte, da

n,m = map(int,sys.stdin.readline().split()) 

esiste un modo per utilizzare allo stesso modo per leggere una riga di input che contiene tipi di dati misti. eg.-

foo 3 

dove foo è una stringa e 3 è un numero intero?

Answer 1

Se avete sempre avuto una stringa e int non negativo:

import sys 
n, m = map(lambda x: (str, int)[x.isdigit()](x) ,sys.stdin.readline().split(None, 1)) 


print(n,m) 

Ma il modo più sicuro è sempre quello di utilizzare un blocco try/tranne quando lancia l'input dell'utente anche quando solo in attesa di un tipo.

come richiesto per il controllo negativo è possibile:

import sys 
n, m = map(lambda x: (str, int)[x.isdigit() or x.strip("-").isdigit()](x) ,sys.stdin.readline().split()) 


print(n, m) 

Ma --10--10-- sarebbe anche superare la prova, ma causa un errore in modo nuovo solo per il vostro caso specifico.

Answer 2

Per fare ciò dovresti essere in grado di discriminare tra stringhe che possono rappresentare numeri interi e stringhe che non possono. Un esempio è:

def foo(s): 
    try: 
     return int(s) 
    except ValueError: 
     return s 

Quindi è possibile utilizzare normalmente map:

map(foo, sys.stdin.readline().split()) 

La linea di cui sopra per l'ingresso:

abcdef 110 

stamperà:

['abcdef', 110] 

Answer 3

Puoi fai un quic k "try/except" setup se non stai cercando niente di speciale.

esempio,

def convert(x): 
    try: 
     f = float(x) 
     i = int(f) 
     x = i if i == f else f 
    except: 
     pass 
    return x 

arr = map(convert, sys.stdin.readline().split()) 

Answer 4

Si potrebbe utilizzare str.isdigit per verificare se la stringa può essere fuso ad un numero intero.

>>> inpt = "foo 3" 
>>> [int(s) if s.isdigit() else s for s in inpt.split()] 

Naturalmente, si può fare lo stesso utilizzando map e sys.stdin.readline utilizzando un lambda

>>> map(lambda s: int(s) if s.isdigit() else s, sys.stdin.readline().split()) 
foo 4 
['foo', 4] 

Se si desidera supportare tutti i tipi di tipi di dati, si può provare a literal_eval e ripiegare al stringa di base se non funziona.

import ast 
def try_eval(string): 
    try: 
     return ast.literal_eval(string) 
    except ValueError: 
     return string 

>>> map(try_eval, "42 3.14 foo 'bar' [1,2,3]".split()) 
[42, 3.1400000000000001, 'foo', 'bar', [1, 2, 3]] 

Answer 5

map è per quando si desidera applicare la stessa trasformazione a ogni elemento dell'input. Questo non si adatta al tuo caso d'uso; vuoi trattare i due input in modi diversi. Dal momento che i dati hanno un formato fisso di corda, quindi intero, che sarebbe stato meglio per analizzare in un modo che produce sempre quel formato:

x, y = raw_input().split() 
y = int(y) 

Se si dispone di più colonne, si potrebbe fare un elenco dei quali funzione da utilizzare per gestire ogni colonna:

handlers = [str, int, int, str, float, int, int] 
a, b, c, d, e, f, g = [f(x) for (f, x) in zip(handlers, raw_input().split())] 

le soluzioni proposte dalle altre risposte non rappresentino formato fisso dell'ingresso. Se l'utente immette

31 42 

x dovrebbero essere "31", non 31, e se l'utente immette

foo bar 

che devono essere rilevati come un errore, anziché assegnare "bar" a y.