Comment utiliser l'exportation avec Python sous Linux

J'ai besoin de faire une exportation de ce genre dans Python :

# export MY_DATA="my_export"

J'ai essayé de faire :

# -*- python-mode -*-
# -*- coding: utf-8 -*-
import os
os.system('export MY_DATA="my_export"')

Mais quand je l'exportation de liste, "MY_DATA" s'affiche pas :

# export

Comment je peux faire un export avec Python sans enregistrer "my_export" dans un fichier ?

InformationsquelleAutor Kevin Campion | 2009-10-01

65

Que vous voulez vraiment faire
```
import os
os.environ["MY_DATA"] = "my_export"
```
- Cela ne fait pas travailler (même si c'est plus agréable de le faire): $ python Python 2.7.10 (default, Sep 8 2015, 17:20:17) [GCC 5.1.1 20150618 (Red Hat 5.1.1-4)] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import os >>> os.environ["MY_DATA"] = "my_export" >>> $ export | grep -c MY_DATA 0
InformationsquelleAutor Alex
76

export est une commande qui vous donne directement sur la coque (par exemple bash), pour le dire d'ajouter ou de modifier l'une de ses variables d'environnement. Vous ne pouvez pas changer votre coque de l'environnement de l'enfant (par exemple en Python), c'est juste pas possible.

Voici ce qui se passe avec vous essayez os.system('export MY_DATA="my_export"')...
```
/bin/bash process, command `python yourscript.py` forks python subprocess
 |_
   /usr/bin/python process, command `os.system()` forks /bin/sh subprocess
    |_
      /bin/sh process, command `export ...` changes local environment
```
Lorsque le fond le plus /bin/sh sous-processus la fin de l'exécution de votre export ... de la commande, puis il est mis au rebut, le long de avec l'environnement que vous avez changé.
- En effet, je ne vois pas ça comme ça !
- Je viens de réaliser, après beaucoup de test, que c'est toi qui a raison : je ne peux pas changer ma coquille de l'environnement de l'enfant (par exemple en Python), c'est juste pas possible.
- S'il vous plaît changer la accepté de répondre dans de tels cas.
- hm.. j'ai essayé de courir subprocess.check_output( 'export x=foo && other_people_command_depending_on_x' ) et ça ne fonctionne pas en quelque sorte -- aucune idées de ce qui s'y passe? Réglage os.environ['x'] = 'foo' pour Python (et donc de tous ses enfants " processus) fonctionne.
- J'ai récemment avoir à faire quelque chose de similaire , ici, est le problème et ce qui a fonctionné pour moi. Le problème est d'exécuter un script python qui en interne exécute un binaire ELF et je voulais un certain chemin pour ce binaire. La solution qui a fonctionné pour moi était d'aller chercher le chemin d'accès actuel de la variable dans le code python et puis il suffit de mettre directement à jour le PATH variable à l'aide de os.putenv. Bien que ce ne sera pas de mise à jour de la PATH variable du shell d'où le script python a été à l'origine appelé.
InformationsquelleAutor alex tingle
12

Une autre façon de faire, si vous êtes pressé et n'avez pas l'esprit de la hacky-arrière-goût, est d'exécuter la sortie du script python dans votre environnement bash et d'imprimer les commandes à exécuter le réglage de l'environnement en python. Pas l'idéal, mais il peut faire le travail dans un pincement. Ce n'est pas très portable à travers les coquilles, donc YMMV.
```
$(python -c 'print "export MY_DATA=my_export"')
```
(vous pouvez également joindre à la déclaration de backticks dans quelques coquilles `)
- Les autres peuvent le commentaire pour expliquer pourquoi il a obtenu downvoted? Il semble être une solution raisonnable compte tenu de l'souhaité exigences. Il n'est pas le début d'un nouveau shell interne est exécuté, et le fait d'ajouter de nouvelles variables d'environnement actuel, l'exécution de processus du shell.
- En fait assez cool. Mieux que l'écriture d'un script et d'acidification plus tard.
InformationsquelleAutor mikepk
8

Pas aussi simple que cela:
```
python -c "import os; os.putenv('MY_DATA','1233')"
$ echo $MY_DATA # <- empty
```
Mais:
```
python -c "import os; os.putenv('MY_DATA','123'); os.system('bash')"
$ echo $MY_DATA #<- 123
```
- simplement rappeler que si vous exécutez la deuxième ligne de nombreuses fois, la même quantité de récursive bash enfants sera créé.
- En gros, vous venez de créer une nouvelle instance de bash sur le dessus de python qui est sur le dessus de l'autre bash
- Cette solution n'est pas correcte. Dans un script python avec beaucoup de commandes, le script va sortir la nouvelle bash instance est créée.
- Ne pas faire que, de la création d'une toute nouvelle bash processus juste pour la variable d'environnement est vraiment une mauvaise pratique.
InformationsquelleAutor phoku
1

Vous pouvez essayer de l'os.environ["MY_DATA"] à la place.
- Cela ne veut pas répondre à la question, parce que ce n'est pas réellement à l'exportation pour le shell courant.
- Exactement ce don d'erreur KeyError
InformationsquelleAutor Thomas Zoechling
0

Genre de hack, car il n'est pas vraiment python de faire quelque chose de spécial ici, mais si vous exécutez la commande exporter dans le même sous-shell, vous aurez probablement obtenir le résultat que vous souhaitez.
```
import os

cmd = "export MY_DATA='1234'; echo $MY_DATA" # or whatever command
os.system(cmd)
```
InformationsquelleAutor Christopher Hunter
0

Dans l'espoir de fournir la clarté sur des cinfusion...

J'ai écrit de nombreux python <--> bash <--> elfbin toolchains et la bonne façon de le voir est de cette forme:

De chaque processus (auteur) a un état de l'environnement hérité de quel que soit invoquée. Tout changement reste lokal à ce processus. Le transfert d'un état de l'environnement est une fonction en elle-même et fonctionne dans les deux directions, chacune avec ses propres mises en garde. Le plus commun est de modifier l'environnement avant l'exécution d'un sous-processus. Pour aller vers le métal, regardez le exec() - appel en C. Il y a une variante qui prend un pointeur vers les données de l'environnement. C'est la seule réellement pris en charge le transfert de l'environnement typique des OS es.

Scripts Shell va créer un état à passer lors de l'exécution d'enfants lorsque vous faites une exportation. Sinon, il utilise juste ce qu'il a obtenu dans la première place.

Dans tous les autres cas, il sera certain mécanisme générique utilisé pour passer d'un ensemble de données pour permettre à l'appelant lui-même le processus de mise à jour de son environnement sur la base du résultat de l'enfant, les processus de production.

Ex:
```
ENVUPDATE = $(CMD_THAT_OUTPUTS_KEYVAL_LISTS)
echo $ENVUPDATE > $TMPFILE
source $TMPFILE
```
La même chose peut bien sûr être fait en utilisant json, xml ou d'autres choses, aussi longtemps que vous avez les outils pour interpréter et à appliquer.

Ce besoin peut être (50% de chance) un signe de misconstruing la base de primitives et de la nécessité d'avoir une meilleure config ou le paramètre d'échange dans votre solution.....

Oh, en python, je voudrais faire quelque chose comme...
(besoin d'amélioration en fonction de votre situation)
```
import re

RE_KV=re.compile('([a-z][\w]*)\s*=\s*(.*)')

OUTPUT=RunSomething(...) (Assuming 'k1=v1 k2=v2')

for kv in OUTPUT.split(' ')
  try:
    k,v=RE_KV.match(kv).groups()
    os.environ[k]=str(v)
  except:
    #The not a property case...
    pass
```
InformationsquelleAutor OriginalNewBee
0

Une solution en ligne:
```
eval `python -c 'import sysconfig;print("python_include_path={0}".format(sysconfig.get_path("include")))'`
echo $python_include_path  # prints /home/<usr>/anaconda3/include/python3.6m" in my case
```
Ventilation:

Python appel
```
python -c 'import sysconfig;print("python_include_path={0}".format(sysconfig.get_path("include")))'
```
C'est le lancement d'un script python qui
1. importations sysconfig
2. obtient le python chemin de l'correspondant à cette python binaire (utiliser "qui python" pour voir qui est utilisé)
3. imprime le script "python_include_path={0}" avec {0} est le chemin d'accès à partir de 2
Eval appel
```
eval `python -c 'import sysconfig;print("python_include_path={0}".format(sysconfig.get_path("include")))'`
```
Il est en cours d'exécution dans le courant de bash exemple de la sortie du script python. Dans mon cas, son exécution:
```
python_include_path=/home/<usr>/anaconda3/include/python3.6m
```
En d'autres termes, c'est le réglage de la variable d'environnement "python_include_path" avec ce chemin pour cette instance du shell.

Inspiré par:
http://blog.tintoy.io/2017/06/exporting-environment-variables-from-python-to-bash/

InformationsquelleAutor Alechan
0

J'ai une excellente réponse.
```
#! /bin/bash

output=$(git diff origin/master..origin/develop | \
python -c '
  # DO YOUR HACKING
  variable1_to_be_exported="Yo Yo"
  variable2_to_be_exported="Honey Singh"
  … so on
  magic=""
  magic+="export onShell-var1=\""+str(variable1_to_be_exported)+"\"\n"
  magic+="export onShell-var2=\""+str(variable2_to_be_exported)+"\""  
  print magic
'
)

eval "$output"
echo "$onShell-var1" // Output will be Yo Yo
echo "$onShell-var2" // Output will be Honey Singh
```
M. Alex Tingle est correct au sujet de ces processus et sous-processus fourre

Comment il peut être obtenu, c'est comme je l'ai mentionné.
Concept clé est :
1. Quelle que soit printed de python sera stockée dans la variable dans la capture de variable dans bash [output]
2. On peut exécuter n'importe quelle commande dans le formulaire de chaîne à l'aide de eval
3. Ainsi, pour préparer votre print sortie de python dans un sens bash commandes
4. utilisation eval pour l'exécuter en bash
Et vous pouvez voir vos résultats

NOTE
Toujours exécuter le eval à l'aide de double quotes ou d'autre bash gâchera votre \ns et des sorties seront étrange

PS: je n'aime pas bash, mais vous avez à l'utiliser

InformationsquelleAutor Akhil Soni

import os
import shlex
from subprocess import Popen, PIPE


os.environ.update(key=value)

res = Popen(shlex.split("cmd xxx -xxx"), stdin=PIPE, stdout=PIPE, stderr=PIPE,
            env=os.environ, shell=True).communicate('y\ny\ny\n'.encode('utf8'))
stdout = res[0]
stderr = res[1]

Bienvenue DONC, Merci à vous pour votre contribution, veuillez ajouter quelques explications avec le code, ce qui permettra d'aider les membres à comprendre votre réponse mieux.

InformationsquelleAutor firejoker

-6

os.système ('/home/user1/exportPath.ksh)

exportPath.ksh:

export PATH=MY_DATA="my_export"

InformationsquelleAutor Jagadeswaran

Vous devez vous connecter pour publier un commentaire.

Une solution en ligne:

Ventilation:

Python appel

Eval appel