Übergabe von globalen Variablen zwischen Skripten

[Hansen93]

Hallo Zusammen,

ich konnte bisher nicht genau die Antworten finden die ich suche, deshalb mal ein neues Thema. Mein Problem besteht darin eine "Zählvariable" von einem Skript an ein weiteres zu übergeben. Das eine Skript enthält die Hauptfunktion und das zweite eine "def", die ich aus dem Hauptskript aufrufe. In der "def" iteriere ich und möchte die Anzahl der Iterationen als Zahl wieder an das Hauptskript übergeben uns auslesen lassen.

Zuerst habe ich das mit der Definition einer globalen Variablen versucht, was auch klappt solange ich die "def" im Hauptskript integriere. Entkopple ich beides und versuche mit Parameterübergabe und globale Variablen zu rechnen wird die Fehlermeldung ausgespuckt "x ist local und global definiert" oder so ähnlich.

Hier mal beispielhaft die codes, wie ich es gerne hätte:

Hauptfunktion mit import von setup

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import setup

num_fe=0

setup.test()

print(num_fe)

def test in setup:

Code: Alles auswählen

def test():

  global num_fe
  
  for i in range(0,5):
    a=2*i
    print a
    num_fe=num_fe+1

Problem print(num_fe) gibt logischerweise 0 aus und nicht 5. Über return würde ich ungerne arbeiten, da ich schon bestimmte Daten zurückgebe und es dadurch wesentlich komplexer werden würde.

Vielen Dank im Voraus, falls jemand eine Idee hat oder mir sagen kann wie ich zwischen den Skripten kommunizieren kann!

[BlackJack]

@Hansen93: Als erstes mal ist es verwirrend das Du von Skripten redest, aber Module meinst.

Vergiss ``global`` und (modul)globale Variablen. Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Werte (ausser Konstanten) betreten Funktionen und Methoden als Argumente und verlassen sie als Rückgabewerte. Alles andere wird sehr schnell sehr unübersichtlich.

Warum genau willst Du den Wert nicht als Argument übergeben und den veränderten Wert als Rückgabewert zurückgeben? Man kann ja als Rückgabewert auch ein Tupel haben und damit effektiv mehr als einen Wert zurückgeben.

Falls die Variable eine Art Zustand der Funktion darstellt, könnte man auch überlegen ob objektorientierte Programmierung an der Stelle Sinn machen könnte.

[Hansen93]

Ah okay, erstmal Danke für die Antwort!

Kurze Schilderung (ich hoffe verständlich): Ich habe in meinem Programm sehr viele Parameter, die aus einzelnen Werten oder Listen bestehen und die ich zum Befüllen und Verändern zwischen den Funktionen quasi weitergebe. Das Skript hatte ich bisher in einem Modul geschrieben, in welchem ich alle Funktionen und die Hauptfunktion hintereinander gepackt habe und es hat reibungsfrei funktioniert. Aufgrund der Übersicht und der "Wartungsarbeiten" bzw. Möglichkeiten der Erweiterung bin ich jetzt dabei alle Funktionen in einzelnen Module zu verpacken.

Aus meiner Sicht wird es mir unübersichtlich, wenn ich grob geschätzt bis zu 20 Argumente übergebe und diese teilweise wieder zurückgebe, da die Funktionen ab und zu verschachtelt sind. Bisher gebe ich 3 Werte als Tupel zurück, die für die weitere Auswertung wichtig sind und quasi zusammenhängen, sodass ich die Rückgabe nicht noch extra teilen muss. Aber ich werde es auf diese Weise umzusetzen, wenn es programmiertechnisch am elegantesten ist.

Also eine Art Zählvariable, die mir im Iterationsprozess ausgibt an welcher Stelle ich mich befinde, kann ich nicht zwischen mehreren Modulen übergeben, außer ich nutze Argument und return?

[mutetella]

Also eine Art Zählvariable, die mir im Iterationsprozess ausgibt an welcher Stelle ich mich befinde, kann ich nicht zwischen mehreren Modulen übergeben, außer ich nutze Argument und return?

Ganz abgesehen davon, dass das nichts ist, das man zwischen Modulen austauscht: Dazu müsste die Iteration ja in einem eigenen Thread laufen. Wie willst Du denn sonst von außen darauf zugreifen? Solange Du kein threading verwendest, befindest Du Dich immer in dem Namensraum, in dem Du Dich befindest, sprich: Wenn Du einen Prozess startest, dann befindest Du Dich in dem Prozess. Wie willst Du daraus Werte holen?

[BlackJack]

@Hansen93: Was heisst denn „quasi weitergeben“?

Wenn Du vorher tatsächlich echte Funktionen in einem Modul hattest, dann wäre das aufteilen auf mehrere Module ja kein grosses Problem. Das Problem entsteht nur wenn die Funktionen keine wirklichen Funktionen sind, also wo man Argumente hineinsteckt und Ergebnisse herausbekommt, sondern globale Zustände verändert werden.

Listen befüllen klingt auch nicht so besonders gut. Statt eine leere Liste zu übergeben und die von einer Funktion befüllen zu lassen, würde man eher die Funktion eine Liste mit Werten erstellen lassen. Je mehr Nebeneffekte eine Funktion hat, desto schwerer nachvollziehbar wird ein Programm.

Zwanzig Argumente klingt eindeutig zu viel. Da sollte man schauen was man sinnvoll zu Objekten zusammenfassen kann.

[Sirius3]

@Hansen93: Wenn Du 20 Argumente für eine Funktion hast, dann hast Du definitiv etwas falsch gemacht. Eine Funktion sollte eine in sich abgeschlossene Einheit sein, die exakt eine Aufgabe erfüllt. Egal was man macht, bei mehr als 5 Argumenten verliert man den Überblick und damit ist die Funktion nicht mehr wartbar. Wenn Du tatsächlich komplexere Zustände hast, solltest Du Dich mit Objektorientierung auseinandersetzen.

[Hansen93]

Okay, dann werde ich mich einmal in die objektorientierte Programmierung einlesen. Ansonsten muss ich versuchen das Gesamtsystem simpler zu gestalten.

@BlackJack: Ich habe beispielsweise eine Funktion aus der heraus eine zweite Funktion aufgerufen wird und an die ich bereits Parameter übergebe. Diese zweite Funktion enthält/generiert wiederum einige Werte, die ich in einer dritte Funktion benötige, also "quasi weitergebe". Die dritte Funktion wird aber wieder aus der ersten Funktion aufgerufen. Warum jetzt weitergeben? Weil ich als User zu Beginn festlege, welchen Ablauf mein Programm nimmt.In den einzelnen Funktionen gibt es nun mehrere Wege abhängig von den zu Beginn festgelegten Parametern.

@mutetella: das war etwas missverständlich von mir ausgedrückt. Also der Iterationsprozess läuft zunächst immer durch. Ich habe eine große Schleife und in dieser Schleife läuft der Iterationsprozess. Bsp.: 50 Iterationen pro Prozess, Start n=0, einmal Schleife n=50, in dem zweiten Durchlauf soll n dann bei 50 beginnen. Also n als Zählvariable fortlaufend sein. Daher dachte ich ursprünglich den Zählstatus von n immer wieder zwischen Modulen übergeben zu können und das vllt ohne return.

Erstmal vielen Dank an Alle!