Newsgroup: it.comp.macintosh
Titolo: Per i pythonisti

Come si fa a verificare che una stringa inserita dall'utente (raw_input)
non contenga determinati caratteri (o, che è lo stesso, contenga solo
determinati caratteri)?
Grazie.
-- 
"I have a very simple life, I have my family and I have Apple and Pixar.
And I don't do much else." S. J.

 determinati caratteri
import re
v = re.search("[^ 0-9n*+-/()]", form) 
if v == None:
ecc. ecc.


 determinati caratteri
import re
form = raw_input("Bla bla bla")
v = re.search("[^ 0-9n*+-/()]", form) 
if v == None:
ecc. ecc.
-- 


 ecc. ecc.
ti sei risposto da solo :)
-- 
RiK0
Non credo negli schemi non vincenti.

 ti sei risposto da solo :)
Ne avevo il sospetto... ;-)
Ora il massimo sarebbe poter verificare la consistenza matematica
dell'espressione inserita dall'utente, tipo vedere che non ci siano
parentesi lasciate aperte, operazioni sballate e simili.


 parentesi lasciate aperte, operazioni sballate e simili.
Cosa deve prendere in input?
si puo` descrivere con un linguaggio context-free?


 Cosa deve prendere in input?
Formule di una sommatoria, con n come variabile. Roba tipo:
n
n**2
(n-1)*(n+1)
1.0/(2**n)
...
A proposito, c'è un modo per rendere di default la divisione decimale,
invece che quella intera?


>> type (float(6) / 6)
<type 'float'>
magari ci sono anche altri modi :))


 6. e` decimale
Sě, lo so, per quello avevo scritto "1.0/(2**n)". Volevo sapere se c'era
un modo per avere sempre la divisione decimale, anche quando dividendo e
divisore sono interi. Avevo trovato in rete che bisognava mettere
from __future__ import division
a inizio file, ma non so perché ieri non mi funzionava, probabilmente
avevo scritto male. Ho riprovato ora e in effetti funziona.


 from __future__ import division
N.B.
Prima e dopo "future" ci sono 2 "_".


 from __future__ import division
anche :)
in effetti questa me la ero scordata.
e comunque quando lavoro di 'matematica', tendo ad usare Numeric (anche
se ora bisognerebbe usare num_array... hai delle prestazioni da urlo).
Mi fa piacere che stia cominciando ad interessarti al Python.
Se poi vuoi lavorare con il MacOS ti do alcune dritte...
il modulo EasyDialogs fornisce facile interazione con l'utente.
puoi usare anche Tkinter per qualcosa di appena piu` complesso (anche se
non e` bellissimo come grafica).
Puoi fare delle applet... che funzionano sia su MacOS X che su MacOS
Classic... tanta tanta roba...
btw, quello che ci trascinano sopra (l'applet) lo prende come parametro
da linea di comando...
quindi per esempio i files trascinati sull'icona saranno
files = sys.argv[1:]


 Se poi vuoi lavorare con il MacOS ti do alcune dritte...
Per scrivere il codice che usi? Ci vorrebbe qualcosa che renda più
comodo gestire le indentazioni, tipo spostare di un tab una serie di
righe già scritte.


 righe già scritte.
BBEdit.


 righe già scritte.
vim oppure Emacs.
Nel senso, io uso Vim, ma anche Emacs e` molto buono.
Oppure c'e` idle... non la versione che installa MacPython, ma quella
nascosta nel framework... e` poco maccoso ma e` grande :))


 vim oppure Emacs.
Grazie, ma preferisco vivere... ;-)


 e dai un'occhiata alla
quantitā di add-on specifici ci sono...
Ciao,
-- 
+--------+ | ASCII ribbon campaign ( ) | 
www.autistici.org/kral
|  kral  | |  - against HTML email  X  |
+--------+ |              & vCards / \ | my gpg id = 0x7C946947

 Vim č tutt'altro che spaventoso! :) 
Ti ringrazio per i consigli, ma veramente, dover digitare dei comandi
per lavorare col testo č contrario alla mia filosofia informatica. Qui
mouse, icone e menu da quasi 20 anni... :-)


 mouse, icone e menu da quasi 20 anni... :-)
anche qui.


 mouse, icone e menu da quasi 20 anni... :-)
Ultimo msg per cercare di convertirti e poi chiudo :)
Più che altro è una provocazione (nel senso buono eh, niente flame)...
Ma se per lavorare con il testo no ti va di usare la tastiera, per
disegnare o fare fotoritocco ti rifiuti di usare il mouse? :p
Scherzi a parte, non c'è solo il vim del terminale, ma anche gvim che ha
la sua bella interfaccia grafica e i suoi menù... ok, niente barra degli
strumenti, etc... ma è già qualcosa in più :)


 fare :)
Anche alla mia. Vim sarà pure più potente di BBEdit, ma visto l'uso più
che sporadico che dovrei farne, il tempo che mi servirebbe per imparare
ad usarlo sarebbe appunto tempo sprecato. Per chi ci lavora
massicciamente tutti i giorni magari l'investimento è conveniente, per
quello che serve a me basta e avanza BBEdit...


 ...
Oddio, con un risultato in C Kernighan e Pike fecero hoc usando yacc.
Probabilmente con un po' di modifiche puoi ottenere un risultato
in Python.
-- 
 /\            ___
/___/\__|_|\_|__|___Gian Uberto Lauri_____________________
  //--\ | | \|  |   Integralista GNUslamico e fancazzista 
\/

 Oddio, con un risultato in C Kernighan e Pike fecero hoc usando yacc.
Che detto in stampatello sarebbe...? :-)


>> 
Quindi il tuo problema si puo` risolvere cosi`:
non_contiene = s.translate(identico, vietati) == s
contiene_solo = s.translate(identico, permessi) == ''
Come dicevo, questo approccio e` raccomandabile solo per l'eccellente
velocita` del metodo translate.  Come eleganza e` meglio usare gli
insiemi (modulo sets in Python 2.3, divengono built-in in 2.4).
import sets
vietati = sets.Set(vietati)
permessi = sets.Set(permessi)
non_contiene = sets.Set(s).intersection(vietati) == sets.Set()
contiene_solo = sets.Set(s) <= permessi
Alex

 Che detto in stampatello sarebbe...? :-)
hoc  e` una "calcolatrice"  creata usando  yacc (Yet  Another Compiler
Compiler), un  programma che ti permette  in pratica di  fare parser a
partire dalla descrizione di una grammatica.
Se ti interessa il discorso saint chiocciola dei punto unipd punto it.


 Che detto in stampatello sarebbe...? :-)
Yet Another Compiler Compiler (yacc) e` uno strumento assai popolare per
scrivere parser (la parte sintattica dei compilatori) mescolandoci
codice C.  Ce l'hai anche su Mac OS X, da Terminal, se hai istallaato
XCode.  Non ha molto a che vedere con Python, eccetto che esistono tanti
pacchetti per Python che imitano l'approccio di yacc.
Se le espressioni-stringa che devi verificare usano la sintassi di
Python sei a cavallo:
import compiler
try: c = compiler.parse(s)
except SyntaxError:
    ''' fai quel che vuoi fare se s ha errori sintattici '''
else:
    ''' fai quel che vuoi fare se s e` sintatticamente corretta '''
Se sai che vuoi specificamente un'espressione puoi fare anche di meglio,
usando la built-in compile invece del package compiler di libreria:
try: c = compile(s, '<stringa in input>', 'eval')
except SyntaxError:
    ''' fai quel che vuoi fare se s ha errori sintattici '''
else:
    ''' fai quel che vuoi fare se s e` sintatticamente corretta '''
questo ti evita di accettare istruzioni (statement) al posto di
espressioni.  Inoltre in questo caso c e` un code object e ci puoi
effettuare altri controlli.  Ad esempio c.co_names e` la tupla
contenente come elementi tutte le stringhe che sono usare come nomi
nell'espressione s, cosi` puoi controllare quali variabili o funzioni
l'utente stia richiedendo, e sgridarlo se usa nomi che non supporti.
Alex

 partire dalla descrizione di una grammatica.
btw... avevo visto dei generatori di parser per python..


.


 insiemi (modulo sets in Python 2.3, divengono built-in in 2.4).
Avevo già risolto usando le regular expression, comunque questa degli
insiemi è una cosa simpatica che forse mi potrà tornare utile in altre
occasioni.


 Se ti interessa il discorso saint chiocciola dei punto unipd punto it.
Al momento è un po' troppo per quello che posso capire di programmazione
(poco più di 0), comunque se in futuro dovessi avere la necessità di
approfondire, ne approfitterò.
TIA


.
Ottimo, ma ti puoi anche risparmiare il re.search e oltre a semplificare
il tutto permetti all'utente piu` possibilita`, che so, termini come
abs(n**2-n-5) + abs(n**3-3*n-7)
che al momento non permetti solo perche` abs contiene lettere (che tu
vieti).  Beccando il syntax error non occorre tu proibisca le lettere...
Alex

 occasioni.
Spero di si`, le regular expression non offrono alcun vantaggio in
questo caso (sono molto + lente dell'incredibile metodo translate:-).
Alex

 Beccando il syntax error non occorre tu proibisca le lettere...
Perņ qualche mariuolo (in teoria chiaramente) potrebbe passare comandi
pericolosi (tipo "import os; os.system('rm -s /')" e farli eseguire,
giusto?


 giusto?
Quasi.  import e` una istruzione, non una espressione, quindi se compili
per 'eval' (solo espressione) non passa.  C'e` pero` __import__,
funzione built-in: __import__('os').system('rm -rf /') e` quindi
possibile entro una espressione.  Per rimuovere questa possibilita`
basta che tu passi all'eval come dict dei nomi globali uno dove i
built-in sono appositamente limitati (puoi togliere '__import__',
'file', 'open', ... fai prima a identificare i pochi che vuoi lasciare,
gia` che si sei mettici dentro invece quelli del modulo standard math
cosi` l'espressione puo` includere trigonometria, logaritmi, ecc ecc).
Rendere sicura l'esecuzione di _istruzioni_ ("statement") e` per ora
considerato impossibile.  Per le _espressioni_ invece non e` arduo.
Alex

 cosi` l'espressione puo` includere trigonometria, logaritmi, ecc ecc).
Beh, a saperlo fare... A proposito, mi sai indicare della documentazione
online? Ho visto quella sul sito ufficiale, ma preferirei qualcosa di
diverso, con esempi concreti in cui sono illustrate le varie funzioni
utilizzate.


.  Comunque credo che tu trovi
link a tutti questi materiali partendo da 
python.org
.
Alex