Zugriff auf Variablen einer anderen Funktion

[jaguan]

Hallo!

Ich bin Python-Neuling und lese nach einer langen Pause gerade das zweite Lehrbuch. Neben der vielen Theorie wird immer geraten, sich an eigenen kleinen Projekten zu versuchen, ganz nach dem Motto "Wer kein Ziel hat, kann auch nicht ankommen".

Gestern habe ich also angefangen, mir ein Skript zu überlegen, dass Bilder in einem Startverzeichnis sucht und anschließend in einem neuen Verzeichnis, allerdings mit der gleichen Unterstruktur abspeichert.

Ich habe schon intensiv gegoogelt und u.a. auf Stackoverflow einen Tipp gefunden. Trotzdem wirf mir mein Programm einen Fehler aus, den ich nicht verstehe.

Wenn ihr mir helft, wäre das super. Bitte belasst die Struktur des Programms aber so wie sie ist. Vielleicht ist es nicht optimal oder es gibt eine einzelne Funktion für das, wo ich mir einen längeren Algorithmus überlegt habe - ich will jedoch daran lernen und das Wichtigste für mich ist:
Wie kann eine Funktion auf Variablen einer anderen zugreifen? Gefunden habe ich die Tipps: Beim Aufruf übergeben (also als Parameter), die Variable global machen oder als ein Attribut der Funktion festlegen. Beim Aufruf übergeben ist zwar ne schöne Sache, was aber, wenn ich mal eine Variable aus einer anderen Funktion brauche, die die aktuelle gerade nicht aufruft? Global gefällt mir nicht so, da es angeblich unsicher ist und darüber hinaus blöd, wenn ich das Skript mal als Modul benutzen will.

Code: Alles auswählen

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

# Für die Filesystem-Aufgaben ist das Modul "os" nötig. Hier wird es importiert.
import os

# Um das Verzeichnis netter auswählen zu können benutze ich tkFileDilaog und importiere es daher auch.
import tkFileDialog

def main():
    # Der Startpfad muss vorhanden sein, daher die Option mustexist=1, beim Zielpfad ist es egal.
    main.startpath = tkFileDialog.askdirectory(mustexist=1)
    main.targetpath = tkFileDialog.askdirectory()
    crawler(main.startpath)

#Der Crawler geht die Verzeichnisse rekursiv durch und beauftragt den Converter mit den Bildern.
def crawler(startpath):
    crawler.dislist = list(startpath)
    for name in crawler.dirlist:
        listentries = os.listdir(os.curdir)
        for entry in listentries:
            if os.path.isdir(os.path.join(os.curdir, entry)):
                crawler.dirlist.append(os.path.join(os.curdir, entry))
            elif ".JPG" in entry or ".jpg" in entry or ".jpeg" in entry:
                converter(os.path.join(os.curdir, entry))

def converter(imagefile):
    prefix, subpath = imagefile.split(main.startpath, 1)
    subpath.replace(" ", "\ ")  
    command = "convert " + str(imagefile) + " -resize 25%" + str(main.targetpath) + str(subpath)

if __name__ == "__main__":
    main()

Wäre super, wenn mir jemand weiterhelfen kann. Mir geht es nicht nur um das Skript, sondern auch darum, wie ich Funktionen in Python effektiv miteinander kommunizieren lassen kann.

lg,
Jaguan

Edit: Typo

[deets]

Woher hast du denn diese Tipps? Parameter & Global sind richtig, aber Funktionsattribute? Das ist zwar technisch moeglich - aber aeusserst ungewoehnlich. Und letztlich (zumindest in der Form, in der du es verwendest) auch nichts anderes als global - denn es gibt ja zB in deinem Programm auch nur ein main, und damit auch nur ein main.startpath und main.targetpath - vulgo, es sind globale Variablen.

Was fehlt ist objekt-orientierung zu verwenden. Damit buendelst du Funktionalitaet und Zustand miteinander.

Grob skizziert:

Code: Alles auswählen

class Crawler(object):

   def __init__(self, startpath, targetpath):
        self.startpath = startpath
        self.targetpath = targetpath

  def crawler(self):
        for ... in self.targetpath:
             ...
             self.converter(imagefile)


  def imagefile(self, imagefile):
        ...

Dann noch ein paar generelle Anmerkungen:

- schau dir mal das mimetypes modul an
- bau das Kommando als Liste, nicht als string auf
- wenn du strings baust, so wie fuer das commando, verwende string-formatierung
- wenn du solche grossen if or or or Kaskaden machst, ist es besser, zu normalisieren und datengetrieben zu arbeiten. Also so:

Code: Alles auswählen

ALLOWED_TYPES = ["jpg", "jpeg", "png", "gif"]

if os.path.splitext(filename)[1][1:].lower() in ALLOWED_TYPES:
    ...

[/me]

Code: Alles auswählen

[...]
#Der Crawler geht die Verzeichnisse rekursiv durch und beauftragt den Converter mit den Bildern.
def crawler(startpath):
    crawler.dislist = list(startpath)
    for name in crawler.dirlist:
[...]

Es wäre hilfreich gewesen, wenn du den Fehler angegeben hättest. Ich sag aber mal: "dirlist != dislist".

Zu deiner grundsätzlichen Frage betreffs Variablenübergabe: Genau das ist das, wofür Parameter und Rückgabewerte gedacht sind. global ist nur sehr, sehr begrenzt sinnvoll und das was du da mit den Funktionen anstellst kommt typischerweise eher im Bereich der Metaprogrammierung vor. Das mit diesem main.startpath und main.targetpath muss und sollte nicht so aussehen. Nimm zwei normale Bezeichner namens startpath und targetpath und das Thema ist erledigt. Wenn eine Funktion Werte braucht, dann gibt man sie dort per Parameter hinein, aber man sammelt sie nicht auf beinahe magische Art und Weise aus der Umgebung zusammen.

Beim Aufruf übergeben ist zwar ne schöne Sache, was aber, wenn ich mal eine Variable aus einer anderen Funktion brauche, die die aktuelle gerade nicht aufruft?

Wenn du einen Wert aus einer anderen Funktion brauchst, dann muss besagte andere Funktion vorher ja auf jeden Fall aufgerufen worden sein. In dem Fall würde sich die steuernde Ebene den Wert aus der ersten Funktion einfach als Rückgabewert holen um ihn dann in die zweite als Parameter hineinzupacken.

Code: Alles auswählen

def funktion_1():
    magischer_wert = 2 * 23 - 2 ** 2
    return magischer_wert

def funktion_2(value):
    print(value)

def main():
    val = funktion_1()
    funktion_2(val)

if __name__ == "__main__":
    main()

Ein alternativer Ansatz wäre die Nutzung einer Klasse um Werte und die darauf operierenden Methoden zu bündeln.

[Hyperion]

Hat jemand schon den Hinweis auf ``os.walk`` gegeben? Evtl. in Kombi mit ``fnmatch``? Imho besser, als das selbstgebaute crawlen...

[jaguan]

Was fehlt ist objekt-orientierung zu verwenden. Damit buendelst du Funktionalitaet und Zustand miteinander.

Das ist wohl ein guter Hinweiß. Ich dachte zu wissen, worum es bei der Objektorientierung geht. Jetzt habe ich einen tollen Artikel darüber gelesen, der es an einem konkreten Beispiel mit Klassen erklärt:http://pytut.infogami.com/node11-baseline.html
-das Mimetypes-Modul habe ich jetzt verwendet.
-guter Tipp, am Beispiel verstehe ich, was du mit Datengetrieben meinst, wird in diesem Fall glaub eich durch mimetypes überflüssig.

Es wäre hilfreich gewesen, wenn du den Fehler angegeben hättest. Ich sag aber mal: "dirlist != dislist".

Verdammt ärgerlich! Entschuldigt das, habe gestern 100mal diese Zeile gelesen, weil da immer der Fehler herkam, aber der Typo ist mir nicht aufgefallen^^

Gute Hinweise bezüglich Rückgabewerte, ich habe return bisher nur verwendet um aus verschachtelten Schleifen zu springen. Habe ich gleich einmal eingebaut.

Wenn du einen Wert aus einer anderen Funktion brauchst, dann muss besagte andere Funktion vorher ja auf jeden Fall aufgerufen worden sein. In dem Fall würde sich die steuernde Ebene den Wert aus der ersten Funktion einfach als Rückgabewert holen um ihn dann in die zweite als Parameter hineinzupacken.

Es ist also optimal, die Funktionalitäten und Zustände in Klassen zu bündeln und die Durchführung von einer "Steuerungsfunktion" übernehmen zu lassen, die dann immer die Werte entgegen nimmt und ausgibt. Habe ich das richtig verstanden? Mir fällt gerade auch ein, wenn die Durchführung automatisch durch die Funktionen laufen würde wäre es wohl mehr eine objektverpackte strukturierte Programmierung, aber keine OOP.

Code: Alles auswählen

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

#Import der benötigten Module
import os
import tkFileDialog
import mimetypes


class Pictureresizer:
    def __init__(self, startdir, targetdir):
        self.startdir = startdir
        self.targetdir = targetdir
        self.counter = 0

        self.dirlist = list(startdir) #Der Startpfad wird das erste Element der Liste für die Schleife
        for expression in self.dirlist: #Werte in der Liste werden durchgegangen
            if os.path.isdir(expression):  
                os.chdir(expression)
                contentlist = os.listdir(os.curdir)
                for entry in contentlist: #Über eine Schleife werden alle Dateien und Ordner in einem Verzeichnis der Liste hinzugefügt.
                    self.dirlist.append(os.path.join(expression, entry)
                                        
            elif 'image' in mimetypes.guess_type(expression):
                prefix, subpath = expression.split(self.startdir)
                subpath.replace(' ', '\ ')
                os.system('convert' + expression.replace(' ', '\ ') \
                    + ' -resize 25%' + str(self.targetdir) + '/' + str(subpath))
                self.counter += 1
        return self.counter  #Pictureresizer liefert die Anzahl der verkleinerten Bilder zurück.  

def main():
    startdir = tkFileDialog.askdirectory(mustexist=1)
    targetdir = tkFileDialog.askdirectory()
    counter = Pictureresizer(startdir, targetdir)
    print 'Erfolg, es wurden %i Bilder verkleinert' % counter
                                        
if __name__ == '__main__':
    main()       

Ich habe jetzt das ganze als eine Klasse strukturiert. Beim der Initialisierung läuft das Prozedere durch.
Allerdings bekomme ich einen Syntaxerror beim "elif" - kann mir leider nicht erklären woher.

@deets: Habe im Internet nichts gefunden, wie ich ein Kommando als Liste aufbaue, oder was String-Formatierung ist. Kannst du mir das bitte erklären?

@Hyperion: Von os.walk habe ich schon beim googlen gelesen. Das baue ich auch gerne ein, wenn mein selbst überlegter Teil dann funktioniert. Vorerst möchte ich, dass ein bisschen davon funktioniert, was ich mir selbst überlegt habe.

VIELEN DANK an alle für die Hilfe. So gefällt mir das gut, richtige Hinweise und kompetente Beratung ohne einfach nur den Code zu lösen. So lerne ich dazu, um auch mal ein guter Programmierer zu werden.
Könnt ihr was zu dem Code jetzt sagen und vielleicht auch, warum die elif-Anweisung einen Syntax-Error hervorruft?

lg,
Jaguan

Edit: Typo...habe es wohl im Moment nicht so mit dem Tippen^^

[/me]

Allerdings bekomme ich einen Syntaxerror beim "elif" - kann mir leider nicht erklären woher.

In der Zeile davor fehlt eine schließende Klammer.

[/me]

Ich habe jetzt das ganze als eine Klasse strukturiert. Beim der Initialisierung läuft das Prozedere durch.

Damit nimmst du die Klasse nur als Auffangbecken für Variablen die du auch in der Methode selber speichern könntest. Kurz gesagt, die Klasse ist so nicht sinnvoll.

Ich würde ohnehin versuchen Funktionalität eher auseinanderzunehmen statt sie zusammenzuführen. Die Routine zum Sammeln der Dateien kann wunderbar für sich alleine stehen. yield ist möglicherweise für Anfänger nicht sofort einleuchtend, aber trotzdem anhand der Dokumentation gut zu verstehen.

Code: Alles auswählen

def iter_files(startpath, file_extensions):
    for folder, _, filenames in os.walk(startpath):
        for filename in filenames:
            if os.path.splitext(filename)[1].lower() in file_extensions:
                yield os.path.join(folder, filename)
            
for filepath in iter_files(r'C:\pyjects\serenity', ('.jpg', '.jpeg')):
    # do something
    print(filepath)

Die Dokumentation empfiehlt übrigens, statt os.system lieber auf das Subprocess-Modul auszuweichen.

[deets]

@Jaguan

Wenn du das Modul subprocess benutzt, dann kannst du Kommandos als Liste aufbauen:

Code: Alles auswählen

import subprocess

cmd = ["convert", imagefile, "-resize", "25%", ...]
subprocess.call(cmd)

Und Stringformatierung findest du hier beschrieben:

http://docs.python.org/library/stdtypes ... operations

Das ist sowohl aesthetischer als auch kompakter und performanter.

[jaguan]

Damit nimmst du die Klasse nur als Auffangbecken für Variablen die du auch in der Methode selber speichern könntest. Kurz gesagt, die Klasse ist so nicht sinnvoll.

Ich würde ohnehin versuchen Funktionalität eher auseinanderzunehmen statt sie zusammenzuführen. Die Routine zum Sammeln der Dateien kann wunderbar für sich alleine stehen.

Das klingt einleuchtend. Ich möchte den Code jetzt so umbauen, dass crawlen und konvertieren zwei verschiedene Methoden sind und beim Aufruf nicht gleich durchlaufen, damit ich bei Nutzung des Codes als Modul später die Funktionen einzeln nutzen kann. Ich habe mich eben dran gesetzt und bin über ein paar Stolperstricke gefallen.

Wenn ich eine Klasse schaffe und innerhalb der Klasse Methoden, muss zuerst eine Instanz der Klasse initialisieren, um eine Methode nutzen zu können?

Code: Alles auswählen

class beispielklasse:
    def erstemethode(self, argument1, argument2):
        wert = argument1 * argument2
        return wert

    def zweitemethode(self, argument1, argument2):
        ergebnis = argument1 - argument2
        return ergebnis

beispielklasse()
beispielklasse.erstemethode(2, 4)

In der IDLE bekomme ich bei so einem Vorgehen diese Fehlermeldung:

Code: Alles auswählen

Traceback (most recent call last):
  File "/home/blabla", line 11, in <module>
    beispielklasse.erstemethode(2, 4)
TypeError: unbound method erstemethode() must be called with beispielklasse instance as first argument (got int instance instead)

Das verstehe ich zwar sprachlich, aber nicht inhaltlich. Mit der Zeile beispielklasse() rufe ich doch eine Instanz, oder nicht? Welchen Namen fordert dann der Aufruf der Klassenmethode? Habe mit Strings und Argumenten für die ein def __init__ experimentiert, konnte den Fehler aber nicht beseitigen. Ist def __init__ obligatorisch, wenn man mit den Methoden einer Klasse arbeiten will?


Nächste Neuheit: Kann ich Klassenattribute nur unter def __init__ mit self.beispiel = argument definieren? Oder kann auch unterhalb einer Methode die Definition self.irgendwas = argumentx stehen, auf die andere Methoden der Klasse zugreifen können?

Die Dokumentation empfiehlt übrigens, statt os.system lieber auf das Subprocess-Modul auszuweichen.

In das subprocess-Modul habe ich mich eingelesen. Danke für den Tipp und Danke an deets für das Beispiel mit dem Listenaufbau . Zunächst lassen sich mit dem Listenaufbau des Befehls viele Fehler vermeiden. Zudem kann das, wenn ich es richtig verstanden habe, im Hintergrund weiterlaufen, und das Programm wartet nicht wie bei os.system auf das Ende des Prozesses. Ich werde es einbauen, sobald ich mit der neuen Struktur fertig bin. Die Stringformatierung habe ich mir auch angeguckt.

yield ist möglicherweise für Anfänger nicht sofort einleuchtend, aber trotzdem anhand der Dokumentation gut zu verstehen.

yield habe ich über Beiträge bei Stackoverflow halbwegs verstanden. Funktioniert vereinfach gesagt wie ein geschleiftes return als Verbesserung eines Generators, der wiederum gegenüber einer Antwortliste Speicherplatz spart?


Viele Fragen, ich weiß^^. Wäre super, wenn ihr mir weiterhelfen könnt, ich lese nebenbei ein Python-Buch, so sprezifische Fragen werden darin leider nicht beantwortet.

lg,
Jaguan

[/me]

Code: Alles auswählen

class beispielklasse:
    def erstemethode(self, argument1, argument2):
        wert = argument1 * argument2
        return wert

    def zweitemethode(self, argument1, argument2):
        ergebnis = argument1 - argument2
        return ergebnis

beispielklasse()
beispielklasse.erstemethode(2, 4)

Du solltest dir Namensgabe nach PEP-8 angewöhnen, also z.B. Klassennamen mit Großbuchstaben beginnen lassen. Das hilft ungemein wenn andere deinen Code lesen - und wenn du fremden Code liest.

Mit beispielklasse() erzeugst du tatsächlich eine Instanz, aber du bindest sie nicht an einen Namen und damit ist sie für den Rest des Programmablaufs nicht mehr erreichbar. Was du haben möchtest ist wohl eher so etwas:

Code: Alles auswählen

class Example(object):
    def do_something(self, value):
        return value

the_instance = Example()
foo = the_instance.do_something(23)

In Python 2.x solltest du Klassen zumindest von object ableiten wenn sie von nichts anderem abgeleitet werden. Dadurch stehen dir erweiterte Möglichkeiten zur Verfügung. Eine genaue Erläuterung möchte ich mir im Moment sparen. Wenn es dich bei deinem aktuellen Wissensstand schon wirklich interessiert, dann such mal nach "new style classes".

[/me]

Ist def __init__ obligatorisch, wenn man mit den Methoden einer Klasse arbeiten will?

Nein.

Nächste Neuheit: Kann ich Klassenattribute nur unter def __init__ mit self.beispiel = argument definieren? Oder kann auch unterhalb einer Methode die Definition self.irgendwas = argumentx stehen, auf die andere Methoden der Klasse zugreifen können?

Vorsicht mit den Begriffen! Was du dort definierst sind keine Klassenattribute, sondern du bekommst damit Attribute der Instanz. Man kann so etwas auch problemlos in anderen Methoden definieren, es gilt aber als schlechter Stil, wenn die verwendeten Bezeichner nicht in der __init__ initialisiert worden sind.

Schau dir mal folgendes (sinnfreies) Besipiel an:

Code: Alles auswählen

class Demo(object):
    def __init__(self):
        self.data = []

    def add_data(self, value):
        self.data.append(value)
        self.count = len(self.data)

    def get_count(self):
        return self.count

example = Demo()
example.add_data(34)
print(example.get_count())

Das funktioniert ganz prima, geht aber plötzlich schief, wenn du vor dem Aufruf von get_count() nicht add_data() aufrufst. Du solltest also in __init__ self.count mit 0 initialisieren.

Hier ist das noch leicht zu erkennen, aber mit steigender Komplexität kannst du dir über nicht initialisierte Werte viele fröhliche Stunden Zeit fürs Debugging einhandeln.

[BlackJack]

@jaguan: Da sich Methoden auf ein Objekt beziehen, musst Du erst ein Objekt erstellen, bevor Du sie benutzen kannst. Das Objekt wird ja beim Aufruf „automagisch“ als erstes Argument übergeben, und dazu muss es halt auch existieren.

Man kann mittels `classmethod()` oder `staticmethod()` auch Methoden erstellen, die man auch auf der Klasse aufrufen kann. Das ist nützlich wenn man neben der `__init__()` noch alternative Methoden zum erstellen von Exemplaren haben möchte. Oder wenn eine Funktion sehr eng mit dem Datentyp verbunden ist, der durch die Klasse beschrieben wird.

[Streifenhase1]

Hallo ich komme nicht klar mit der Übergabe der variablen.
wo ist der Fehler

Code: Alles auswählen

 
def a():
	
    a=1
    print (a)
    return a
    

def b():

    b=a(a)
    print (b)
    
b()  

[__blackjack__]

@Streifenhase1: Der Fehler ist das Du weder sagst welche Ausnahme Du wo bekommst, noch was Du denkst was das da insgesamt bewirken soll. Beschreib doch mal den Programmablauf bis zu dem Punkt an dem es eine Ausnahme gibt in Worten. Und dann warum Du nicht verstehst das an der Stelle wo die Ausnahme kommt, eben diese Ausnahme kommt. Was hättest Du denn stattdessen erwartet?

[Streifenhase1]

also variable "a" soll von Funktion "a" an Funktion "b" übergeben werden

Und Funktion "b" gibt variable "a" aus

Komme halt nicht klar wie ich die variable aus einer Funktion in eine andere übergebe.

dieses Beispiel soll nur zum Verständnis für mich sein.

kurz gesagt am ende möchte ich etwas mit einer Funktion erstellen

und beenden mit einer anderen Funktion.

[Sirius3]

@Streifenhase1: aber was ist denn nun die Fehlermeldung, die Du bekommst? Und was sagt die darüber, was Du falsch machst?

PS: aussagekräftigere Funktions- und Variablennamen würden beim Verstehen und Beschreiben des Problems helfen.

[Streifenhase1]

die Fehlermeldung ist
Traceback (most recent call last):
File "/data/user/0/ru.iiec.pydroid3/files/accomp_files/iiec_run/iiec_run.py", line 31, in <module> start(fakepyfile,mainpyfile) File "/data/user/0/ru.iiec.pydroid3/files/accomp_files/iiec_run/iiec_run.py", line 30, in start exec(open(mainpyfile).read(), __main__.__dict__) File "<string>", line 12, in <module> File "<string>", line 9, in b TypeError: a() takes 0 positional arguments but 1 was given [Program finished]

[Streifenhase1]

hab es noch mal mit anderer Nennung, hoffe es ist jetzt übersichtlicher was ich möchte

Code: Alles auswählen

   
def a():
	
    wert=1
    print (wert)
    return wert
    

def b():
	
    wert=wert(a)
    print (wert)
    
b() 

[kbr]

Dein ursprüngliches Beispiel war an funktionierendem Code schon näher dran, als die vermeintlich übersichtlichere Variante. In der ersten Zeile von b() möchtest Du

Code: Alles auswählen

wert = a()

schreiben. Das ist aber trivial und es bleibt unklar, was du wirklich beabsichtigts.

[Sirius3]

@Streifenhase1: mit den neuen Namen gibt es eine neue Fehlermeldung, die soviel sagt, dass »wert« nicht definiert ist, wenn Du versuchst es als Funktion aufzurufen, was ja auch keinen Sinn macht.