Voir la liste des imprimantes

On peut avoir la liste des imprimante en utilisant le module win32all et en tapant directement dans l'API Win32:

   1 try:
   2     import win32print
   3 except:
   4     print 'This script requires the win32print module (included in win32all).'
   5     print 'See http://starship.python.net/crew/mhammond/win32/Downloads.html'
   6 else:
   7     try:
   8         print 'List of local printers:'
   9         for (Flags,pDescription,pName,pComment) in list(win32print.EnumPrinters(win32print.PRINTER_ENUM_LOCAL,None,1)):
  10             print '   ',pName
  11     except:
  12         print 'Could not get local printers list.'
  13 
  14     try:
  15         print 'List Network printers:'
  16         for (Flags,pDescription,pName,pComment) in list(win32print.EnumPrinters(win32print.PRINTER_ENUM_CONNECTIONS,None,1)):
  17             print '   ',pName
  18     except:
  19         print 'Could not get network printers list.'

Base de registre

Lire une valeur de la base de registre

   1 import _winreg
   2 key = _winreg.OpenKey( _winreg.HKEY_CURRENT_USER, 'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders',0, _winreg.KEY_READ)
   3 (valeur,typevaleur) = _winreg.QueryValueEx(key,'Fonts')
   4 _winreg.CloseKey(key)
   5 print valeur
   6 print typevaleur

typevaleur est le type de la valeur (_winreg.REG_SZ, REG_BINARY, REG_DWORD... voir http://docs.python.org/lib/module--winreg.html)

Lister des valeurs d'une clé

   1 import _winreg
   2 key = _winreg.OpenKey( _winreg.HKEY_CURRENT_USER, 'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders',0, _winreg.KEY_READ)
   3 i = 0
   4 try:
   5     while True:
   6         tp = _winreg.EnumValue(key,i) # mmm..strange, Should unpack to 3 values, but seems to unpack to more.  Bug of EnumValue() ?
   7         valuename = tp[0]
   8         valuedata = tp[1]
   9         valuetype = tp[2]
  10         print 'La clé %s vaut "%s"' % (valuename,str(valuedata))
  11         i = i+1
  12 except EnvironmentError:
  13     pass
  14 _winreg.CloseKey(key)

Ecrire dans la base de registre

   1 # La ligne suivante ouvre une clé et la créé si elle n'existe pas.
   2 key = _winreg.CreateKey(_winreg.HKEY_CURRENT_USER, 'Software\\wikipython.flibuste.net\\monprogramme')
   3 _winreg.SetValueEx(key, 'nom_de_valeur',0, _winreg.REG_SZ, 'coucou !')
   4 _winreg.CloseKey(key)

Nous avons créé une clé de type REG_SZ (chaîne de caractères).

DCOM

Exemple avec IE5

   1 import time
   2 from win32com.client.gencache import EnsureDispatch
   3 from win32com.client import constants
   4 
   5 class InternetExplorerGetter:
   6     def __init__(self):
   7         self.ie = EnsureDispatch('InternetExplorer.Application')
   8 
   9     def get(self, url):
  10         self.ie.Navigate(url)
  11         return self.waitForResult()
  12 
  13     def refresh(self):
  14         self.ie.Refresh()
  15         return self.waitForResult()
  16 
  17     def waitForResult(self):
  18         while 1:
  19             state = self.ie.ReadyState
  20             if state == constants.READYSTATE_COMPLETE: break
  21             time.sleep(0.1)
  22         return self.ie.Document.documentElement.innerHTML
  23 
  24 if __name__ == '__main__':
  25     print InternetExplorerGetter().get('http://www.python.org')

Exemple avec Excel

   1 import win32com.client
   2 excel = win32com.client.Dispatch('Excel.Application')
   3 excel.Visible = 1
   4 excel.Workbooks.Add()
   5 line = ['one','two','three','four','five','six','seven','height','nine','ten']
   6 column = ['','x','x^2','x^3','x^4']
   7 
   8 
   9 for i in range(len(column)):
  10         excel.ActiveSheet.Cells(i+1).Value = column[i]
  11 
  12 # Ajoute de donnees dans les celulles
  13 for i in range (len(line)):
  14         j = i+2
  15         excel.ActiveSheet.Cells(j,1).Value = line[i]
  16         excel.ActiveSheet.Cells(j,2).Value = i
  17         excel.ActiveSheet.Cells(j,3).Value = "=B%d+B%d" % (j,j)
  18         excel.ActiveSheet.Cells(j,4).Value = "=B%d+B%d+B%d" % (j,j,j)
  19         excel.ActiveSheet.Cells(j,5).Value = "=B%d+B%d+B%d+B%d" % (j,j,j,j)
  20 
  21 # Selection des cellules
  22 excel.Range("A1:D9").Select()
  23 
  24 # Ajoute un graphique
  25 excel.Charts.Add()
  26 
  27 # Cree un camenbert
  28 xlLineMarkers = 65
  29 xlPieExploded = 69
  30 excel.ActiveChart.ChartType = xlLineMarkers
  31 
  32 # Cree un titre
  33 excel.ActiveChart.HasTitle = 1
  34 excel.ActiveChart.ChartTitle.Characters.Text = "MonTitre"

Cette exemple ouvre un fichier et affiche son contenu:

   1 import win32com.client
   2 
   3 excel = win32com.client.Dispatch('Excel.Application')
   4 
   5 classeur = excel.Workbooks.Open("H:/Documents and Settings/Julien/Bureau/fact/JANVIER 2005.xls")
   6 feuille = classeur.ActiveSheet #On recupere la feuille courante
   7 maxcol = feuille.UsedRange.Columns.Count #Recupere le nombre de colonne maximum
   8 maxline = feuille.UsedRange.Rows.Count #Recupere le nombre de ligne maximum
   9 
  10 for x in range(1, maxline):
  11     for y in range(1, maxcol):
  12         print feuille.Cells(x, y).Value #Affiche le contenu de la cellule x,y
  13 #Pour récupérer un tableau de valeur, plus rapide que la double boucle for ci-dessus
  14 #sht = classeur.Worksheets(feuille.name)
  15 #rows= sht.Range(sht.Cells(1, 1), sht.Cells(maxline, maxcol)).Value
  16 
  17 excel.Workbooks.Close()
  18 excel.Quit()

Exemple avec Word

Cet exemple permet de recuperer le texte d'un fichier Word.

   1 import win32com.client
   2 
   3 word = win32com.client.Dispatch("Word.Application")
   4 word.Documents.Open("D:/partage/python/wordtxt/test.doc") #il faut mettre le chemin complet
   5 text = word.ActiveDocument.content.text
   6 word.Documents.Close()
   7 
   8 text = text.encode('Latin-1')
   9 
  10 print text

Un classe pour piloter Word

Cette classe facilite le pilotage de Word, via OLE-automation (COM). Elle constitue également un bon exemple de l'utilisation de PyWin (anciennement Win32all).

L'adresse, c'est là : http://mclaveau.com/ress/python/pxword.htm

Autres exemples

Vous trouverez également d'autres exemple d'utilisation de COM/DCOM dans CodesBDD (Manipulation de SQL Server et ADO).

DLL

Le module ctypes permet de faire des appels aux API Win32. Ce module est disponible à http://starship.python.net/crew/theller/ctypes/

Exemples

Changer le fond d'écran de Windows

   1 import ctypes
   2 SPI_SETDESKWALLPAPER = 20
   3 ctypes.windll.user32.SystemParametersInfoA(SPI_SETDESKWALLPAPER, 0, "c:\\monrepertoire\\monpapierpeint.bmp" , 0)

Récupérer la résolution d'écran actuelle

   1 import ctypes
   2 SM_CXSCREEN = 0
   3 SM_CYSCREEN = 1
   4 taille_x = ctypes.windll.user32.GetSystemMetrics(SM_CXSCREEN)
   5 taille_y = ctypes.windll.user32.GetSystemMetrics(SM_CYSCREEN)
   6 print "La résolution d'écran est %d par %d" % (taille_x, taille_y)

Mutex

Un mutex est utile, par exemple, pour vérifier qu'une application est déjà lancée. Certain installeurs comme InnoSetup s'en servent également pour vérifier que l'application à déinstaller n'est pas en cours de fonctionnement.

Voici comment créer un mutex sous Windows. Cela nécessite le module ctypes.

   1 CTYPES_AVAILABLE = True
   2 try:
   3     import ctypes
   4 except ImportError:
   5     CTYPES_AVAILABLE = False
   6 
   7 MY_MUTEX = None
   8 if CTYPES_AVAILABLE and sys.platform=="win32":
   9     try:
  10         MY_MUTEX=ctypes.windll.kernel32.CreateMutexA(None,False,"mydomain_myprogramname")
  11     except:
  12         pass

Ce mutex sera automatiquement détruit à la fin de votre programme Python.

AutoIt

AutoIt est un langage de script qui permet d'automatiser plein de choses dans Windows (clic de boutons, entrée de texte, lancement de programmes, attente de fenêtres...). Il serait possible de faire la même chose en Python en manipulant l'API Win32, mais ce serait pénible. Il est bien plus facile d'utiliser directement AutoIt à partir de Python.

Exemple: lancer le bloc-note et taper un peu de texte dedans:

   1 import win32com.client
   2 
   3 autoit = win32com.client.Dispatch("AutoItX3.Control")
   4 autoit.Run("notepad.exe")
   5 autoit.AutoItSetOption("WinTitleMatchMode", 4)
   6 autoit.WinWait("classname=Notepad")
   7 autoit.Send("Hello, world.")

Fichiers/Répertoires

Taille et propriétaire de fichier/répertoire

Voici quelques fonctions utiles pour administrer un serveur (surveillance de la taille de répertoires par exemple). Je m'en sert pour envoyer un mail demandant à ceux qui ont une corbeille de plus de 100 Mo de la vider.

   1 """
   2 Tailles des fichiers/répertoires dans windows
   3 sous cmd, on peut faire par exemple :
   4     dir /a:h /q /n/c/p e:\recycler
   5 """
   6 import os
   7 from win32com.client import Dispatch
   8 import win32security
   9 
  10 def getFileProprietary(fichier):
  11     o = win32security.GetFileSecurity(fichier, win32security.OWNER_SECURITY_INFORMATION)
  12     oo = o.GetSecurityDescriptorOwner()
  13     nom, domaine, rien = win32security.LookupAccountSid('', oo)
  14     return nom
  15 
  16 def getFileSize(fichier):
  17     return os.stat(fichier).st_size
  18 
  19 def getDirectorySize(repertoire):
  20     fso = Dispatch("Scripting.FileSystemObject")
  21     return fso.GetFolder(repertoire).size
  22 
  23 def tailleRepertoires(repertoire, proprietaire=False):
  24     """Renvoie une liste de (repertoire, taille, proprietaire)
  25     taille est en kilo-octets."""
  26     data = []
  27     os.chdir(repertoire)
  28     for rep in [r for r in os.listdir('.') if os.path.isdir(r)]:
  29         rep = os.path.normpath(rep)
  30         try:
  31             taille = getDirectorySize(rep)
  32             if proprietaire is True:
  33                 nom = getFileProprietary(rep)
  34         except Exception, erreur:
  35             taille = 0
  36             nom = '-'
  37         if proprietaire is True:
  38             repertoire = (rep, taille/1024, nom)
  39         else:
  40             repertoire = (rep, taille/1024)
  41         data.append( repertoire )
  42     return data
  43 #-------------------------------------------------------------------------------
  44 if __name__ == '__main__':
  45     poubelles = tailleRepertoires(r'c:\recycler', proprietaire=True)
  46     poubelles.sort()
  47     for rep, taille, nom in poubelles:
  48         print '%7d' % taille, nom

Lecteur réseau

Voici un petit exemple pour monter/démonter un lecteur réseau.

   1 import os
   2 
   3 from win32netcon import RESOURCETYPE_DISK
   4 import win32wnet
   5 
   6 def lecteur_disponible():
   7     for lettre in ('g:','h:','i:','j:','k:','l:','m:','n:','o:','p:','q:','r:',
   8         's:','t:','u:','v:','w:','x:','y:','z:'):
   9         lettre_path = lettre + '\\'
  10         if not os.path.isdir(lettre_path):
  11             return lettre
  12     return None
  13 
  14 class LecteurReseau:
  15     """Monter/Démonter un lecteur réseau."""
  16     def __init__(self, chemin, utilisateur, mot_de_passe, lettre=None):
  17         if lettre is None:
  18             lettre = lecteur_disponible()
  19         self.lettre = lettre
  20         self.chemin = chemin
  21         self.utilisateur = utilisateur
  22         self.mot_de_passe = mot_de_passe
  23 
  24     def monter(self):
  25         win32wnet.WNetAddConnection2(RESOURCETYPE_DISK, self.lettre,
  26             self.chemin, None, self.mot_de_passe, self.utilisateur)
  27         return self.lettre
  28 
  29     def demonter(self):
  30         win32wnet.WNetCancelConnection2(self.lettre, 0, 0)
  31 
  32 if __name__ == '__main__':
  33     print 'Premier lecteur disponible : ', lecteur_disponible()

CategoryCategory