Python: Envoi d'une variable à un autre script

Je suis nouveau sur python et le type de été chucked, au fin fond au travail.

Si j'avais un script qui a crée une liste comme ci-dessous:

test = 'string'

l = []

for i in test:
    l.append(i)

print l

Comment aurais-je l'envoyer à un autre script python?

Qu'entendez-vous par ce ?
Qu'entendez-vous par this: la variable l, ou à la représentation imprimée de celui-ci?
Notez que l'ensemble du code peuvent être remplacés par le beaucoup plus courte l = list(test).

OriginalL'auteur Grenko | 2010-06-17

  1. 3

    Je suis en supposant que vous voulez utiliser la variable some_list définie dans un script appelé first.py dans un second script appelé second.py

    Il serait donc:

    $ cat first.py second.py 
#first.py
def demo():
    some_list = []
    for i in 'string':
         some_list.append( i )
    return some_list

#second.py 
from first import demo

some_list = demo()
print some_list 

$python second.py
['s', 't', 'r', 'i', 'n', 'g']

    Le code dans un fichier est déclaré en tant que module de code. Pour l'utiliser, vous devez utiliser:

    from module import chose

    Donc dans ce cas la fonction demo a été définie comme une fonction dans le module first

    Dans le deuxième fichier que vous importez et de l'utiliser.

    Vous pouvez exécuter du code arbitraire dans des modules et de déclarer les variables, mais il est préférable si elles sont placées dans des fonctions ( ou des classes ) comme indiqué ci-dessus.

    J'espère que c'est ce que vous avez besoin.

    Merci de ne pas utiliser L minuscule comme un nom de variable, il semble que le chiffre un et est prête à confusion.
    Yeap je suis d'accord, j'ai changé pour "liste"
    Malheureusement, l'appel d'une variable list cache le haut- list qui est le type de liste, c'est donc aussi un mauvais choix de nom en Python, de l'OMI. Essayez chars ou char_list, ou lst pour la concision.
    OOpps tellement vrai 😛

    OriginalL'auteur OscarRyz

  2. 2

    Il n'est pas clair si vous premier script est lui-même l'exécution de la deuxième script, ou si elles sont appelées l'une après l'autre par quelque chose d'extérieur. Dans les deux cas, une méthode simple pour passer de la liste pour le second processus est via stdin, où les données lui-même est un cornichon de la liste.

    Par exemple:

    script1.py:

    import sys
import pickle
list = [item for item in test]
pickle.dump(list, sys.stdout)

    script2.py:

    import sys
import pickle
list = pickle.load(sys.stdin)
for item in list:
    print item

    La course: script1.py | script2.py

    OriginalL'auteur taleinat

  3. 1

    Cela dépend si tu veux dire envoi les résultats du calcul à l'autre, séparément lancer Python processus, ou tout simplement partage ce résultat avec un autre composant d'un multi-fichier de projet.

    Dans le premier cas, vous aurez envie d'utiliser un moyen de communication inter-processus - en sont quelques exemples écrit le résultat dans un fichier et le lire à partir de l'autre processus, l'établissement d'un socket entre les deux processus, ou à l'aide d'un sémaphore.

    Dans ce dernier cas, l'utilisation de Python concept de modules de partager le résultat de ce calcul avec un autre script dans votre projet.

    OriginalL'auteur Jordan Lewis

  4. 0

    Je vous suggère de regarder la mettre en Veilleuse et Cornichons modules. Ils vous permettent de sérialiser les données d'une manière qu'il peut être stocké entre les lancements ou partagé entre les scripts.

    OriginalL'auteur g.d.d.c

  5. 0

    $ cat one.py

    from functools import lru_cache
@lru_cache(maxsize=2048)
class One(object):
     def __init__(self):
         self.a = None

     def set_a(self,val):
         self.a = val

     def get_a(self):
         return self.a


class One_nocache(object):
     def __init__(self):
         self.a = None

     def set_a(self,val):
         self.a = val

     def get_a(self):
         return self.a

    $ cat two.py

    import one
import three

# Cache
second=one.One()
second.set_a(4)
three.print_cache()

# No cache
second=one.One_nocache()
second.set_a(4)
three.print_nocache()

    $ cat three.py

    import one
def print_cache():
    three=one.One()
    print(three.get_a())

def print_nocache():
    three=one.One_nocache()
    print(three.get_a())

    $ py two.py

    4
None

    4 - Est mis dans three.py en invoquant la mise en cache instance de classe dans one.py
    Aucun - Lorsque la même instance de la classe est appelée lorsque la classe n'est pas
    mis en cache.

    OriginalL'auteur Sud