[PIPython] pythonw e run

[Adriano Allora]

ciao a tutti,

sto facendo i miei primi esperimenti con wxpython (su macosx 10.3,  
python 2.3, wxpython funzionante).

ho due domande:

1) anche con lo script più semplice e imbecille (copiato paro paro dal  
manuale e/o dagli esempi disponibili in rete), quando lo avvio da linea  
di comando mi dice che sarebbe meglio lanciarlo con pythonw e non con  
python. è normale? è un ammennicolo per mac che renderà i miei script  
incompatibili con le altre piattaforme? devo preoccuparmi?

2) in alcuni esempi che ho trovato si importava il modulo "run". è  
importante? è un modulo generalmente in bundle che per qualche bizzarro  
motivo non ho oppure è una cosa speciale?

vi ringrazio di tutto,


alladr





__PS__################################################################## 
######
Nonostante fosse partito come un ambizioso progetto per IA, adesso è  
solo un giocattolo che non ho più il tempo di sviluppare, però l'idea  
dell'apparato digerente che pensa mi piaceva, e avevo anche un bel nome  
(pykacchu, uno dei pykemon).
Se avere tempo da gettare e se la cosa vi diverte, potete provare a  
giocare con questo coso.


#!/usr/bin/python

import sys
import random

# questo listato si chiama orgaNIXsmo e fa finta di simulare la vita di  
una specie
# di cosa che si nutre, si muove per cercarsi cibo e cresce.
#
# per ora tre moduli lo costituiscono: le gambe che trovano cibo; la  
bocca che trasforma
# il cibo in risorse e le immagazzina; gli ormoni che lo fanno crescere.
# (primo sviluppo: adriano alladr allora)

class orgaNIXsmo:
     def __init__(self):
         ciclo = 0
         grasso = 2
         consumo = 0
         parti_bocca = 1
         parti_gambe = 1
         parti_ormoni=1
         stato = "appena nato!"
         print stato
         while(stato!="morto."):
# quanto cibo trova?
             trovato = self.Gambe(parti_gambe)
# come si nutre?
             consumo = ((parti_gambe + parti_bocca + parti_ormoni) / 3)  
* 2
             grasso = self.Bocca(grasso, trovato, consumo, parti_bocca)
# come si sviluppa?
             qualenuovo = self.oRmoni(parti_bocca, parti_gambe,  
parti_ormoni)
             parti_bocca = qualenuovo[0]
             parti_gambe = qualenuovo[1]
             parti_ormoni = qualenuovo[2]
# controlla stato vitale
             if(grasso>consumo):
                 stato = "grassottello!"
             elif(grasso==consumo):
                 stato = "sano"
             elif((consumo / 2)<grasso<consumo):
                 stato = "magro..."
                 if(parti_bocca>=3): parti_bocca -= (parti_bocca / 3)
                 else: parti_bocca = 1
                 if(parti_gambe>=3): parti_gambe -= (parti_gambe / 3)
                 else: parti_gambe = 1
                 if(parti_ormoni>=3): parti_ormoni -= (parti_ormoni / 3)
                 else: parti_ormoni = 1
             elif(-2<=grasso<=(consumo/2)):
                 stato = "quasi morto..."
                 parti_bocca -= (parti_bocca / 2)
                 parti_gambe -= (parti_gambe / 2)
                 parti_ormoni -= (parti_ormoni / 2)
             else:
                 stato = "morto."
# genera l'output
             self.GeneraOutput(consumo, ciclo, grasso, parti_bocca,  
parti_gambe, parti_ormoni, trovato, stato)
# azzera valori
             trovato = 0
             ciclo += 1
# esce dal programma se necessario
             if(stato=="morto."): sys.exit('quest\'orgaNIXsmo e\'  
temporaneamente morto')


     def oRmoni(self, bocca, gambe, ormoni):
         for X in range(ormoni):
             qualenuovo = random.randrange(3)
             if(qualenuovo==0):
                 bocca += 1
             elif(qualenuovo==1):
                 gambe += 1
             elif(qualenuovo==2):
                 ormoni += 1
         return [bocca, gambe, ormoni]


     def Gambe(self, quante):
         trovato = 0
         for occhiata in range(quante):
             trovato += random.randrange(5)
         return trovato


     def Bocca(self, vecchio, nuovo, consumo, parti_bocca):
# il massimo di scorte che riesce a mettere da parte è 2 per  
parte_bocca!
         risorse = nuovo - consumo
         vecchio += risorse
         if(vecchio>(parti_bocca * 2)): vecchio = parti_bocca*2
         return vecchio

	
#    def Mente(self, ciclo, grasso, parti_bocca, parti_gambe,  
parti_ormoni):
# decide a chi dare le risorse?
# ed è richiamata dalla Bocca (un apparato digerente che pensa!)
#
# in un secondo momento si penserà ad implementare la memoria

     def GeneraOutput(self, consumo, ciclo, grasso, parti_bocca,  
parti_gambe, parti_ormoni, trovato, stato):
         print "CICLO: ", ciclo
         print "bocca: ", parti_bocca
         print "gambe: ", parti_gambe
         print "ormoni: ", parti_ormoni
         print "trovato: ", trovato
         print "grasso/consumo: ", grasso, consumo
         print stato
         print "\n###########################################\n"

unaVita = orgaNIXsmo()



##################__FINE__LISTATO__################################



|^|_|^|_|^|				|^|_|^|_|^|	
  |	     |				 |	     |
  |	     |				 |	     |
  |	     |*\_/*\_/*\_/*\_/*\_/* |	     |
  |	     					     |
  |	     					     |
  |	     	      				     |
  |	   http://www.e-allora.net        |
  |	     					     |
  |	     					     |
**************************************