Testen, ob eine Python Variable existiert

Testen, ob eine lokale Variable x existiert:

vars().has_key(‚x‘)

Testen, ob eine globale Variable x exitiert:

globals().has_key(‚x‘)

Siehe auch: http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/59892

Windows-Benutzer automatisiert mit Python anlegen

Ein Python-Script zum automatisierten Anlegen von Windows-Benutzern:

 
import win32netcon, win32net 
d={}
d['name'] = "PythonTestUser" 
d['password'] = "Top Secret" 
d['comment'] = "A user created by some Python demo code" 
d['flags'] = win32netcon.UF_NORMAL_ACCOUNT | win32netcon.UF_SCRIPT 
d['priv'] = win32netcon.USER_PRIV_USER 
win32net.NetUserAdd(None, 1, d) 

Open Source DTP Software mit Python-Unterstützung

Scribus ist ein Open Source Desktop Publishing Programm (DTP) für den professionellen Seitenlayout. Es kann mit Python automatisiert werden und exportiert auch die Formate PDF und Postscript. Unterstützt werden die Betriebssysteme Windows, Linux/Unix und MacOS X.

CATIA V5 and DMU Navigator Automation with Python (english)

If you want to automate CATIA V5 or DMU Navigator with Python you need Pywin32 and Python for Windows or Activestates ActivePython for Windows. Python is free software and you can develop professional applications with all advantages of Python for CATIA V5 or DMU Navigator.

For developing a small application which interacts to CATIA V5 you only have to download your prefered Python Distribution for Windows and can start developing applications for CATIA V5 or DMU Navigator (this should be running when testing the application).

Automating CATIA V5:

If you have done above you can start with this source code:

import win32com.client app = win32com.client.Dispatch('catia.application') doc = app.ActiveDocument for part in doc.Product.Products:     print part.Name

This small example prints out the part names of a loaded CATProduct and their CATParts.

Here is the same example when you prefer comtypes instead of Pywin32:

import comtypes.client app=comtypes.client.GetActiveObject('Catia.Application') doc = app.ActiveDocument for part in doc.Product.Products:     print part.Name

Automating DMU Navigator:

If you want to automate DMU Navigator, you can do this:

# Following doesn`t work with CATIA V5 R16 SP5 and later catia_app = win32com.client.Dispatch("DMU.Application")

Important notes:

If you want to use early binding for the CATIA V5 object libraries you can use the Makepy utility from Pythonwin. After that every object and its methods will be usable from the pulldown menu while typing and you can have a performance advantage. You should use makepy for every object library which you want to use e.g. „ProductStructure Object Library“ for working with CATProducts). But not for the „CATIA V5 Interfaces Objekt Library“!

If you do that every application which uses early binding for the „CATIA V5 Interfaces Objekt Library“ will not work ! A workaround is not to use makepy for the „CATIA V5 Interfaces Objekt Library“ or use explicit late binding „(import win32com.client.dynamic as the first line).

For starting developing applications with Python for CATIA V5 you should use the manual V5Automation.chm which you can find in the bin-directory of CATIA V5. You will see that you can develop Python applications in the same way like VB with the builtin VB editor.

If you have problems to access the COM Interface from CATIA V5 (eg. no object libraries from CATIA V5 in makepy) please check whether CATIA V5 was registrated as a COM server. If not you can do that with cnext.exe /regserver in the CATIA V5 bin-directory. Then everything should work well…

More on Microsofts Component Object Model (COM) and Python

More information for developing with Python for COM applications with Pywin32 you can find in this excellent book. A whole example Chapter about COM Programming with Python/Pywin32 can be found at O`Reilly.

Early- und Latebinding von COM Objekten mit Python

Python nutzt das Modul win32com der Windows-Erweiterung Pywin32 zur Automatisierung von Applikationen über COM (Component Object Model). Man spricht hier auch von COM-Automation. Dabei unterscheidet es zwischen early- sowie late-binding. Um nicht zu weit auszuholen, versuche ich es hier einmal kurz auf den Punkt zu bringen:

Late-binding: Python kennt keine Methoden und Attribute der Objektbibliothek, die per COM angesprochen und automatisiert werden soll.

Early-binding: Python kennt alle Methoden und Attribute der Objektbibliothek, die per COM angesprochen und automatisiert werden soll.

Was macht das für einen Unterschied ?

Nun, zunächst hat das early-binding Performance-Vorteile bei der Ausführung der Python-Programme. Aber dafür müssen einmalig vor Ausführen der Anwendungen sog. Cachefiles für die genutzten Bibliotheken erzeugt werden. Das kann je nach größe und Anzahl der Bibliothek recht lange dauern. Ein Trost ist, dass dieser Prozess nur ein einziges Mal durchgeführt werden muss. Danach sind bei jeder Ausführung der Python-Programme die Cachefiles noch vorhanden und werden genutzt.

Ein weiterer Vorteil des early-bindings betrifft das Editieren im Pythonwin-Editor. Da durch die Cachefiles alle Methoden und Attribute Python bekannt sind, sind sie auch Pythonwin bekannt. Das bedeutet, dass während des Editierens nach den ersten Buchstaben der Pythoncode vervollständigt wird. Das macht das Programmieren wesentlich komfortabler.

Man kann aber generell keine Empfehlung abgeben, ob man early- oder late-binding nutzen soll. Es existieren Anwendungen wie z.B. CATIA V5, die mit early-binding so ihre Probleme haben. In solchen Fällen muss das late-binding genutzt werden.

Wie werden die Cachefiles erzeugt und das early-binding genutzt ?

Mir sind drei Wege bekannt:

1. Einmaliger Aufruf des Programms c:\python23\Lib\site-packages\win32com\client\makepy.py und Auswahl der zu automatisierenden Objektbibliothek.

2. Einmaliger Aufruf des Programms c:\python23Libsite-packageswin32comclientmakepy.py mit Name der zu automatisierenden Objektbibliothek als Argument. Z.B. makepy.py „Microsoft Word 10.0 Object Library“

3. dynamisches generieren der Cachefiles. Dazu sind 2 Zeilen Code im Python-Programm nötig, die durch das Aufrufen von makepy.py mit dem Argument -i ausgegeben werden. Z.B:makepy.py -i „Microsoft Word 10.0 Object Library“ liefert folgende Ausgabe:

>>> # Use these commands in Python code to auto generate .py support
>>> from win32com.client import gencache
>>> gencache.EnsureModule(‚{00020905-0000-0000-C000-000000000046}‘, 0, 8, 2)

Bei der dynamischen Methode werden beim ersten Aufruf des Programms die Cachefiles einmalig erzeugt und bleiben erhalten und von Python- Programmen genutzt, bis sie manuell vom User gelöscht werden. Bei ersteren beiden werden Sie einmalig manuell erzeugt. Das bedeutet auch: falls die Cachefiles, warum auch immer, gelöscht werden, werden sie nur von der dynamischen Methode wieder neu erzeugt.

Wie nutzt man das late-binding ?

Wie eingangs erwähnt, haben es manche Anwendungen schwer mit early-binding. In solchen Fällen muss das late-binding genutzt werden. Man erzwingt es durch einen „dynamic Dispatch“. Dazu ruft man im Python-Programm die COM-Bibliothek der Applikation (hier Outlook) wie folgt auf:

o = win32com.client.dynamic.Dispatch(„Outlook.Application“)

Ein o = win32com.client.Dispatch(„Outlook.Application“) dagegen nutzt (falls vorhanden) das Cachefile für Outlook. Falls es nicht vorhanden ist, erfolgt ebenfalls ein late-binding.

 

Einfacher Webserver in einer Zeile Python

Wer mal eben schnell um seine lokalen Dateien im Netzwerk verfügbar zu machen einen Webserver benötigt,  kann sich mit einer Zeile Python Code behelfen:

Der Aufruf:

python -m CGIHTTPServer #(für Python ab Version 2.4) 

erzeugt einen simplen Python Webserver (eigentlich mit CGI-Unterstützung), der im Browser mit der Adresse http://rechnername:8000 alle Dateien anzeigt, von wo aus das Kommando abgegeben wurde.

Wer noch Python 2.3 oder älter benutzt, sollte:

python -c "from SimpleHTTPServer import test; test()"

eingeben.

Wenn man hingegen den Webserver auf einem bestimmten Port laufen lassen möchte, kann man (wie in der Python-Doku beschrieben) folgendes Script einsetzen:

 import SimpleHTTPServer import SocketServer  PORT = 8000  Handler = SimpleHTTPServer.SimpleHTTPRequestHandler  httpd = SocketServer.TCPServer(("", PORT), Handler)  print "serving at port", PORT httpd.serve_forever() 

Introduction to Jython

Ein interessanter Artikel ber Jython ist gerade auf devshed.com erschienen. Jython ist eine Python-Implementation in Java. Man kann damit die Vorzüge von Python in Java umsetzen. Es ist also möglich, in Python zu programmieren und das Programm auf einer beliebigen Java Virtual Mashine ablaufen zu lassen.

Office2PS Python Modul

Dieses Python-Modul ist zwar noch kein eigenständiger PDF Converter. Er kann aber zur Postscript-Generierung aus Microsoft Office Dokumenten dienen und somit zur Entwicklung eigener PDF Converter genutzt werden.

Es nutzt Microsoft Office und einen installierten Postscript Druckertreiber für den Export der Postscript-Dateien aus einem vorher installierten Postscript-Druckertreiber.

Hinweis: Da Powerpoint immer nur als einzelne Instanz laufen kann wurde in der aktuellen Version eine Mutex-Funtionalität implementiert. Hierzu muss für das Programm eine eindeutige GUID auf dem System erzeugt werden. Dies geschieht einmalig, indem Sie msoffice2ps.py mit dem Argument -guid aufrufen. Dabei wird eine textdatei namens pyguid.cfg erzeugt, die beim Aufruf von msoffice2ps.py gelesen wird.

Download Office2PS als ZIP