Python Script zum ändern von Dateiendungen

[webspider]

1) Du benutzt immer noch nicht die [ python]-Tags.
was meinst du damit genau, meinst du damit die schreibweise der python programmierung?
ich versuche alles so umzusetzen wie es in den tutorials steht, allerdings ist deine schreibweise irgendwie kürzer und einfacher

Beim Erstellen eines Posts gibts oben im Editor eine Leiste mit diversen Knöpfen, die BB-Code für einen erstellen. Einer dieser Knöpfe, der besonders gut versteckt wurde, ist mit einem schlichtem "python" betitelt und erstellt, man glaube es kaum, [ python]-Tags, welche zum Umklammern des Python-Codes gedacht sind und ihn dabei wundervoll formatieren.

[korkak]

oh man wie peinlich, danke euch

test

Code: Alles auswählen

for x in names:
    os.rename(x, os.path.splitext(x)[0]+'.'+neu)

ps: jetzt muss ich nur noch wissen, wie ich die globalen variablen in funktionen einbaue, dann werde ich versuchen mit PyQt eine grafische oberfläche darum zu bauen, danke nochmal an alle die mir geholfen haben

[nomnom]

2) Die globalen Variablen könntest du IMHO auch loswerden und das eher in Funktionen auslagern...
Wie muss ich mir das vorstellen, soll ich es so umsetzen?

Code: Alles auswählen

def end_alt():
	alt = raw_input("Welche Dateiendung, z.B.: 'txt', soll geändert werden? ")
end_alt()

wahrscheinlich nicht, bisher hast du mir immer aufgezeigt wie man alles kürzer schreiben kann und das würds ja eher länger machen...

Ich dachte daran:

Code: Alles auswählen

def change_ext(names, ext):
    newnames = []
    for name in names:
        newnames.append(os.path.splitext(name)[0]+'.'+ext)
    return newnames

Wobei `[os.path.splitext(x)[0]+'.'+ext for x in names]` kürzer wäre. Bin mir allerdings nicht sicher, ob du List Comprehensions schon kennst/verstehst.

[korkak]

puuh das ist mir noch zu hoch
danke für deine hilfe, ich belasse es jetzt so:

Code: Alles auswählen

import os, glob, sys

p = raw_input("Bitte den vollständigen Pfad eingeben: ")

if not os.path.exists(p):
    print "Das Verzeichnis '%s' existiert nicht." % p
    sys.exit(1)
    
alt = raw_input("Welche Dateiendung, z.B.: 'txt', soll geändert werden? ")

names = glob.glob(os.path.join(p, "*." + alt))

print "Folgende Dateien wurden gefunden:"
print "---------------------------------"

print "\n".join(names)

neu = raw_input("Wie lautet die neue Dateiendung, z.B.: 'jpg'? ")

for x in names:
    os.rename(x, os.path.splitext(x)[0]+'.'+neu)

print "-----------------------------"    
print "%d Dateien wurden umbenannt." % len(names)

als nächstes versuch ich jetzt eine gui dafür zu bauen.

gruß
korkak

[Leonidas]

Wenn du ne GUI bauen willst wirst du wohl kaum darum herumkommen, deinen Code in Funktionen aufzuteilen.

[korkak]

Wenn du ne GUI bauen willst wirst du wohl kaum darum herumkommen, deinen Code in Funktionen aufzuteilen.

also die gui möchte ich mit QT erstellen, habe gerade erst angefangen auf http://openbook.galileocomputing.de das kapitel dazu durchzulesen, ich hoffe es wird dort darauf hingewiesen, dass ich alles in funktionen aufbauen muss

[Leonidas]

Also ich weiß nicht, das Open Book ist ziemlich schlecht. Keine Ahnung ob das Qt-Kapitel ähnlich schlecht ist wie die restlichen Kapitel, dein Link gibt mir auch einen 404er-Fehler und da habe ich dann keine Lust mir das selbst zu suchen.

[korkak]

hier der richtige link: http://openbook.galileocomputing.de/pyt ... 5d98711ba6

kennst du denn eine seite wo python bzw. PYQT besser erklärt wird?

danke und gruß
korkak

[Hyperion]

kennst du denn eine seite wo python bzw. PYQT besser erklärt wird?

Es heißt Qt! So viel Zeit muss sein

Also ich habe mal das Einführungsbeispiel überflogen und den Abschnitt über Signal und Slots. Da sind mir direkt einige Ungereimtheiten aufgefallen (Wieso nehmen die nicht direkt einen "QDialog" im Designer? Dann muss man nicht von QDialog zusätzlich ableiten. Zudem: Wieso überhaupt einen Dialog schreiben, wenn man die API eines Dialogs nicht nutzt?). Zudem lehrt das Buch noch die veraltete Syntax für Signal und Slots. Das sollte man heute nicht mehr verwenden.

Wieso schaust Du Dir nicht mal die Doku von PySide an. Ich würde wohl sowieso auf PySide setzen, wenn es keine triftigen Gründe dagegen gibt. Letztlich unterscheiden sich die beiden Bindings nur marginal - für den Anwender.

Aber auch die Riverbank-Seite hat doch eine Doku zu PyQt (Ich meine nicht die "Kopie" der Qt-Doku, sondern den "Reference Guide"). Als letztes ist die Qt Doku natürlich auch Pflichtlektüre; auch wenn da alles auf C++ gemünzt ist, so lernt man die Konzepte durch die dortigen "Howtos" oder Artikel über die grundlegenden Technologien doch gut kennen.

Last but not least: Schau Dir auf jeden Fall mal lunars Seite an; der hat viele exzellente Beispiele zu verschiedensten Themen rund um Qt.

Zum OpenBook allgemein haben wir hier schon viel gesagt; BlackJacks rant zeigt vieles auf.

[Leonidas]

Wieso schaust Du Dir nicht mal die Doku von PySide an. Ich würde wohl sowieso auf PySide setzen, wenn es keine triftigen Gründe dagegen gibt. Letztlich unterscheiden sich die beiden Bindings nur marginal - für den Anwender.

Naja, so wie ich letztens gesehen habe unterstützt PySide das `uic`-Modul nicht, daher bleibe ich persönlich erstmal bei PyQt.

[korkak]

So!

ich habs geschafft und es funktioniert

ich poste den code mal hier, dann hat man quasi eine ende zu ende betrachtung wie sich alles entwickelt hat, wenn das ok ist für euch.

PyQt4 habe ich benutzt, zum ausprobieren braucht ihr glaube ich den inhalt folgender beiden dateien.

das programm habe ich rename_programm.py genannt:

Code: Alles auswählen

import os, glob, sys
from PyQt4 import QtGui, QtCore 
from rename import Ui_Hauptdialog as Dlg
class MeinDialog(QtGui.QDialog, Dlg):
    
    def __init__(self): 
        QtGui.QDialog.__init__(self) 
        self.setupUi(self)
        # Slots einrichten 
        self.connect(self.Eingabe, 
                QtCore.SIGNAL("clicked()"), self.onEingabe) 
        self.connect(self.Los, 
                QtCore.SIGNAL("clicked()"), self.onLos)
        self.connect(self.Loeschen, 
                QtCore.SIGNAL("clicked()"), self.onLoeschen)
        self.connect(self.Ende, 
                QtCore.SIGNAL("clicked()"), self.onEnde)
        
    def onEingabe(self): 
        # Daten auslesen 
        d = {}
        p = unicode(self.pfad.text())
        #self.ausgabe.append(p)
        if not os.path.exists(p):
            self.ausgabe.append("Das Verzeichnis '%s' existiert nicht." % p)
        alt = unicode(self.alt.text())
        global names
        names = glob.glob(os.path.join(p, "*." + alt))
        self.ausgabe.append("Folgende Dateien wurden gefunden:")
        self.ausgabe.append("-----------------------------------------------")
        self.ausgabe.append("\n".join(names))
        self.ausgabe.append("-----------------------------------------------")

    def onLoeschen(self):
        self.pfad.clear()
        self.alt.clear()
        self.neu.clear()
        
    def onLos(self):
        #self.ausgabe.append("Es geht Los!")
        neu = unicode(self.neu.text())
        for x in names:
            os.rename(x, os.path.splitext(x)[0]+'.'+neu)
        self.ausgabe.append("-----------------------------------------------")
        self.ausgabe.append("%d Dateien wurden umbenannt." % len(names))

    def onEnde(self): 
        self.close()

app = QtGui.QApplication(sys.argv) 
dialog = MeinDialog() 
dialog.show() 
sys.exit(app.exec_())

und hier der inhalt der rename.py datei:

Code: Alles auswählen

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'C:\Users\Schmidt\Desktop\Python\GUI\QT\rename.ui'
#
# Created: Fri Jan 20 13:07:15 2012
#      by: PyQt4 UI code generator 4.9
#
# WARNING! All changes made in this file will be lost!

from PyQt4 import QtCore, QtGui

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    _fromUtf8 = lambda s: s

class Ui_Hauptdialog(object):
    def setupUi(self, Hauptdialog):
        Hauptdialog.setObjectName(_fromUtf8("Hauptdialog"))
        Hauptdialog.resize(500, 649)
        self.groupBox = QtGui.QGroupBox(Hauptdialog)
        self.groupBox.setGeometry(QtCore.QRect(50, 30, 401, 271))
        self.groupBox.setObjectName(_fromUtf8("groupBox"))
        self.Eingabe = QtGui.QPushButton(self.groupBox)
        self.Eingabe.setGeometry(QtCore.QRect(150, 210, 93, 28))
        self.Eingabe.setObjectName(_fromUtf8("Eingabe"))
        self.Los = QtGui.QPushButton(self.groupBox)
        self.Los.setGeometry(QtCore.QRect(270, 210, 93, 28))
        self.Los.setObjectName(_fromUtf8("Los"))
        self.Loeschen = QtGui.QPushButton(self.groupBox)
        self.Loeschen.setGeometry(QtCore.QRect(150, 150, 211, 28))
        self.Loeschen.setObjectName(_fromUtf8("Loeschen"))
        self.widget = QtGui.QWidget(self.groupBox)
        self.widget.setGeometry(QtCore.QRect(70, 30, 291, 121))
        self.widget.setObjectName(_fromUtf8("widget"))
        self.gridLayout = QtGui.QGridLayout(self.widget)
        self.gridLayout.setMargin(0)
        self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
        self.label = QtGui.QLabel(self.widget)
        self.label.setObjectName(_fromUtf8("label"))
        self.gridLayout.addWidget(self.label, 0, 0, 1, 1)
        self.pfad = QtGui.QLineEdit(self.widget)
        self.pfad.setObjectName(_fromUtf8("pfad"))
        self.gridLayout.addWidget(self.pfad, 0, 1, 1, 1)
        self.label_2 = QtGui.QLabel(self.widget)
        self.label_2.setObjectName(_fromUtf8("label_2"))
        self.gridLayout.addWidget(self.label_2, 1, 0, 1, 1)
        self.alt = QtGui.QLineEdit(self.widget)
        self.alt.setObjectName(_fromUtf8("alt"))
        self.gridLayout.addWidget(self.alt, 1, 1, 1, 1)
        self.label_3 = QtGui.QLabel(self.widget)
        self.label_3.setObjectName(_fromUtf8("label_3"))
        self.gridLayout.addWidget(self.label_3, 2, 0, 1, 1)
        self.neu = QtGui.QLineEdit(self.widget)
        self.neu.setObjectName(_fromUtf8("neu"))
        self.gridLayout.addWidget(self.neu, 2, 1, 1, 1)
        self.ausgabe = QtGui.QTextEdit(Hauptdialog)
        self.ausgabe.setGeometry(QtCore.QRect(50, 320, 401, 251))
        self.ausgabe.setObjectName(_fromUtf8("ausgabe"))
        self.Ende = QtGui.QPushButton(Hauptdialog)
        self.Ende.setGeometry(QtCore.QRect(360, 600, 93, 28))
        self.Ende.setObjectName(_fromUtf8("Ende"))

        self.retranslateUi(Hauptdialog)
        QtCore.QMetaObject.connectSlotsByName(Hauptdialog)

    def retranslateUi(self, Hauptdialog):
        Hauptdialog.setWindowTitle(QtGui.QApplication.translate("Hauptdialog", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
        self.groupBox.setTitle(QtGui.QApplication.translate("Hauptdialog", "Angaben", None, QtGui.QApplication.UnicodeUTF8))
        self.Eingabe.setText(QtGui.QApplication.translate("Hauptdialog", "Übernehmen", None, QtGui.QApplication.UnicodeUTF8))
        self.Los.setText(QtGui.QApplication.translate("Hauptdialog", "Umbenennen", None, QtGui.QApplication.UnicodeUTF8))
        self.Loeschen.setText(QtGui.QApplication.translate("Hauptdialog", "Eingabefelder löschen", None, QtGui.QApplication.UnicodeUTF8))
        self.label.setText(QtGui.QApplication.translate("Hauptdialog", "Pfad:", None, QtGui.QApplication.UnicodeUTF8))
        self.label_2.setText(QtGui.QApplication.translate("Hauptdialog", "Endung alt:", None, QtGui.QApplication.UnicodeUTF8))
        self.label_3.setText(QtGui.QApplication.translate("Hauptdialog", "Endung neu:", None, QtGui.QApplication.UnicodeUTF8))
        self.Ende.setText(QtGui.QApplication.translate("Hauptdialog", "Beenden", None, QtGui.QApplication.UnicodeUTF8))

[Hyperion]

Wenn Du `PyQt4` benutzt, dann könntest Du auch das `uic`-modul nutzen, um die GUI dynamisch zu erzeugen (das manuelle Erzeugen Deiner UI-Klasse fällt dann weg - genau das sprach Leonidas im letzten Posting davor an ).

Ich habe es mir nicht direkt angeguckt, aber wenn Du einen länger andauernden Prozess hast, bei dem Du Update-Nachrichten ausgeben willst in der GUI, dann kommst Du eigentlich nicht um das Thema "Threading" herum. lunar und ich haben mal ein kleines Beispiel für solche Interaktionen entwickelt¹. Evtl. guckst Du Dir das mal an...

Du benutzt die alte Semantik für SIGNALS und SLOTS. Wieso nutzt Du nicht die neue?

Code: Alles auswählen

# alt:
self.connect(self.Eingabe, QtCore.SIGNAL("clicked()"), self.onEingabe)
# neu
self.Eingabe.clicked.connect(self.onEingabe)

Dann sehe ich immer noch so unsägliche Namen wie `x`, `d` oder `p`. Speziell beim `x` wundert man sich:

Code: Alles auswählen

for x in names:
    # do something with `x`

Das schreit doch gerade nach:

Code: Alles auswählen

for name in names:
    # do sth. with `name`

Nimmst Du `x` nur, weil es kürzer zu tippen ist? Wenn ja, solltest Du das nicht tun, sondern stets einem aussagekräftigeren Namen den Vorzug geben.

Dann sah ich ein `global` im Code - das ist eigentlich immer unnütz und ein Zeichen für schlechtes Design.

Ich habe Deinen Anwendungsfall nicht mehr im Kopf, aber sich sehe da keine separate Logik-Funktion(en), für die eigentliche "Aufgabe". Ich hätte jetzt erwartet, dass Du Deinen bisherigen Code als Modul importierst und dann aus der GUI die entsprechenden Funktionen aufrufst.

¹Also ich hatte das ursprünglich mal demonstriert und lunar hat es - wie immer - in sinnvoller Weise verbessert

[korkak]

hey hyperion,

danke für deine kommentare.
wie gesagt ich bin blutiger anfänger und mache das alles zum ersten mal. ich glaube mir fehlt noch einiges an wissen um all deine ratschläge zu verstehen und umzusetzen

1) `uic`-modul
sagt mir nix, werd ich mir ansehen.

2) "Threading"
sagt mir nix, werd ich mir ansehen.

3) alte Semantik für SIGNALS und SLOTS
sieht gut aus werd ich sofort umsetzen

4) "aussagekräftigeren Namen"
werd ich mir zu herzen nehmen!

5) `global` im Code
ich wusste mir nicht anders zu helfen, in einer funktion setze und benutze ich die variable und in einer weiteren brauche ich genau diese variable wieder, wie soll ich es anders machen?

6) " bisherigen Code als Modul importierst"
das hatte ich auch vor aber dann hab ich mit dem designer rumgespielt und dann sah alles irgendwie etwas anders aus und so hab ich es dann halt so gemacht :K

ps: ich war echt happy als es am ende funktioniert hat

[Hyperion]

5) `global` im Code
ich wusste mir nicht anders zu helfen, in einer funktion setze und benutze ich die variable und in einer weiteren brauche ich genau diese variable wieder, wie soll ich es anders machen?

Indem Du das Objekt als Attribut zu Deiner Klasse hinzufügst z.B. Ich denke solche "Schwächen" in Sachen OOP sind mit der Grund, wieso viele hier einem Anfänger davon abraten, sich mit GUIs zu befassen.

6) " bisherigen Code als Modul importierst"
das hatte ich auch vor aber dann hab ich mit dem designer rumgespielt und dann sah alles irgendwie etwas anders aus und so hab ich es dann halt so gemacht :K

Hu? Was hat denn der Designer damit zu tun? :K

[korkak]

5) `global` im Code
ich wusste mir nicht anders zu helfen, in einer funktion setze und benutze ich die variable und in einer weiteren brauche ich genau diese variable wieder, wie soll ich es anders machen?

Indem Du das Objekt als Attribut zu Deiner Klasse hinzufügst z.B. Ich denke solche "Schwächen" in Sachen OOP sind mit der Grund, wieso viele hier einem Anfänger davon abraten, sich mit GUIs zu befassen.

ich mache es ja just for fun, die motivation warum ich jetzt schon etwas mit der gui gemacht habe war, dass ich einmal sehen wollte wie das ganze von anfang bis ende aussieht, als nächstes werde ich mich weiter in python einlesen.
hast du vielleicht ein beispiel für mich, wie ich das objekt als attribut einer klasse hinzufüge?

[Hyperion]

hast du vielleicht ein beispiel für mich, wie ich das objekt als attribut einer klasse hinzufüge?

Na, ganz einfach so eben:

Code: Alles auswählen

In [21]: class Foo(object):
   ....:     
   ....:     def __init__(self):
   ....:         self.bar = []
   ....:         
   ....:         

In [22]: f = Foo()

In [23]: f.bar
Out[23]: []

In [24]: f.bar = range(10)

In [25]: f.bar
Out[25]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Du hast doch sogar eine Liste, oder?

[korkak]

da bin ich wieder hyperion,

folgende tipps von dir habe ich versucht umzusetzen:

- uic-modul eingebaut.

- neue Semantik für SIGNALS und SLOTS eingebaut.

- aussagekräftigere Namen eingebaut.

- "Threading", versucht einzubauen, aber wohl nicht korrekt. fällt mir wirklich schwer umzusetzen, falls möglich gib mir bitte ein beispiel wie ich es richtig einbaue

- als nächstes versuche ich dann die globale variable rauszunehmen.

Code: Alles auswählen

import os, glob, sys, threading
from PyQt4 import QtGui, QtCore, uic

class MeinDialog(QtGui.QDialog):
    
    def __init__(self):
        QtGui.QDialog.__init__(self)
        self.ui = uic.loadUi("rename.ui", self)
        # Slots einrichten
        self.Eingabe.clicked.connect(self.onEingabe)
        self.Los.clicked.connect(self.onLos)
        self.Loeschen.clicked.connect(self.onLoeschen)
        self.Ende.clicked.connect(self.onEnde)
        
    def onEingabe(self): 
        # Daten auslesen 
        d = {}
        pfad = unicode(self.pfad.text())
        if not os.path.exists(pfad):
            self.ausgabe.append("Das Verzeichnis '%s' existiert nicht." % pfad)
        alt = unicode(self.alt.text())
        global names
        names = glob.glob(os.path.join(pfad, "*." + alt))
        self.ausgabe.append("Folgende Dateien wurden gefunden:")
        self.ausgabe.append("-----------------------------------------------")
        self.ausgabe.append("\n".join(names))
        self.ausgabe.append("-----------------------------------------------")

    def onLoeschen(self):
        self.pfad.clear()
        self.alt.clear()
        self.neu.clear()
        
    def onLos(self):
        neu = unicode(self.neu.text())
        for name in names:
            MeinDialog.lock.acquire()
            os.rename(name, os.path.splitext(name)[0]+'.'+neu)
            MeinDialog.lock.release()
        self.ausgabe.append("-----------------------------------------------")
        self.ausgabe.append("%d Dateien wurden umbenannt." % len(names))

    def onEnde(self): 
        self.close()
 
    lock = threading.Lock()

    onEingabe_thread = threading.Thread(target = onEingabe)
    onLoeschen_thread = threading.Thread(target = onLoeschen)
    onLos_thread = threading.Thread(target = onLos)
    onEnde_thread = threading.Thread(target = onEnde)

    onEingabe_thread.start()
    onLoeschen_thread.start()
    onLos_thread.start()
    onEnde_thread.start()

    onEingabe_thread.join()
    onLoeschen_thread.join()
    onLos_thread.join()
    onEnde_thread.join()

app = QtGui.QApplication(sys.argv) 
dialog = MeinDialog() 
dialog.show() 
sys.exit(app.exec_())

[korkak]

puuh...

ich krieg das mit der globalen variable nicht hin. bisher schien mir diese variante am vielversprechensten aber im nächsten modul kann ich wieder nicht auf die variable zugreifen :

Code: Alles auswählen

    def onEingabe(self): 
        # Daten auslesen 
        d = {}
        pfad = unicode(self.pfad.text())
        if not os.path.exists(pfad):
            self.ausgabe.append("Das Verzeichnis '%s' existiert nicht." % pfad)
        alt = unicode(self.alt.text())
        #global names
        #names = glob.glob(os.path.join(pfad, "*." + alt))
        class name(object):
            def __init__(self):
                self.names = []
        s = name()
        s.names = glob.glob(os.path.join(pfad, "*." + alt))
        self.ausgabe.append("Folgende Dateien wurden gefunden:")
        self.ausgabe.append("-----------------------------------------------")
        self.ausgabe.append("\n".join(s.names))
        self.ausgabe.append("-----------------------------------------------")

[BlackJack]

@korkak: Mit globalen Variablen sollte man ja auch nichts hin bekommen. Klassen in Funktionen definieren ist auch ungewöhnlich. Der Name `s` ist lokal zu der Methode. Wenn die Methode abgelaufen ist, dann verschwindet der Name und damit auch das Exemplar von `name`. Das sieht nach wild herum probieren und hoffen dass es klappt aus. Schau Dir doch erst einmal Klassen und objektorientierte Programmierung ohne GUI an. Dann musst Du nicht so viele neue Konzepte auf einmal lernen.

[jerch]

@korkak:
Bzgl. Deiner Threading-Versuche schliesse ich mich BlackJacks Rat an - versuch nicht zu viele Konzepte auf einmal stemmen zu wollen. Das Threading ist in Deinem Bsp. völlig falsch aufgezogen, lass das besser erstmal raus und verstehe den Programmfluss in ereignisbasierter Programmierung. Mit dem nötigen Grundwissen in OOP kannst Du dies anhand eines GUI-Toolkits wie PyQt nachvollziehen. Dann wird Dir relativ schnell klar, wo und wie Du Threads zu Hilfe nehmen kannst.