#compter nombre de lignes d'un fichier: #!/usr/bin/python filepath = 'mon_fichier.txt' linecount = len(open(filepath, 'rU').readlines()) print "le fichier %s a %d lignes." % (filepath, linecount) ------------------------------------------------------------- #connaitre sa résolution d'ecran: #!/usr/bin/python #pour autoriser les accents: # -*- coding: iso-8859-1 -*- import ctypes SM_CXSCREEN = 0 SM_CYSCREEN = 1 taille_x = ctypes.windll.user32.GetSystemMetrics(SM_CXSCREEN) taille_y = ctypes.windll.user32.GetSystemMetrics(SM_CYSCREEN) print "La résolution d'écran est %d par %d" % (taille_x, taille_y) -------------------------------------------------------------- #calculer la moyenne: #!/usr/bin/python ListNotes = [10.5, 15.5, 7.5, 19.0, 5.5, 4.5, 3.0, 8.0, 11.0] somme = 0 for n in ListNotes: somme = somme + n moyenne = somme / len(ListNotes) # ListNotes est non vide ! print "Moyenne = ", moyenne # Moyenne = 9.38888888889 -------------------------------------------------------------- Affichage d'un formulaire HTML #! /usr/bin/python # Affichage d'un formulaire HTML simplifié : print "Content-Type: text/html\n" print """

Page web produite par un script Python

""" ---------------------------------------------------- >>> str = "This is a string" >>> print str[0:4], str[10:] This string >>> print str[:-1] This is a strin ------------------------------------------- Tableau 4. Opérations et constantes de listes traditionnelles Opération Interprétation Exemple l1 = []une liste vide [] l2 = ['a', 'b', 'c', 'd'] liste de 4 éléments indexée de 0 à 3 ['a', 'b', 'c', 'd'] l3 = [-10, l2, 'azerty'] liste à 3 éléments, le deuxième est une liste [-10, ['a', 'b', 'c', 'd'], 'azerty'] l3[1] accès par indice ['a', 'b', 'c', 'd'] i=1; j=2; l3[i:j] accès par tranche [['a', 'b', 'c', 'd']] len(l3) longueur de liste 3 l2 + l3 concaténation ['a', 'b', 'c', 'd', -10, ['a', 'b', 'c', 'd'], 'azerty'] l2 * 2 répétition ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'] l2.append(72) ajouter (en fin de liste) ['a', 'b', 'c', 'd', 72] l2.sort() tri (sur place) [72, 'a', 'b', 'c', 'd'] l2.index(72) index d'un élément (recherche) 0 l2.reverse() inversion de la liste ['d', 'c', 'b', 'a', 72] l2[2] = 10 affectation par indice ['d', 'c', 10, 'a', 72] del l2[-1] suppression par indice (dernier élément) ['d', 'c', 10, 'a'] del l2[0:2] suppression par tranche [10, 'a'] for x in l2: print x, parcours de liste 10 a -------------------------------------------------------- Opérations sur les fichiers: Opérations Interprétation fhi = open(file, 'r') Ouverture de file en lecture. fho = open(file, 'w') Création du fichier file. str = fhi.read() Lit le fichier entièrement et le stocke dans la chaîne str. str = fhi.read(n) Lit n octets (1 ou plus) et le stocke dans la chaîne str. str = fhi.readline() Lit la ligne suivante jusqu'au marqueur de fin de ligne. list = fhi.readlines() Lit entièrement le fichier et le stocke en mémoire comme une liste de lignes. fho.write(str) Ecrit la chaîne str dans le fichier dont le descripteur est fho. fho.writelines(list) Ecrit toutes les lignes de list dans le fichier. fho.close() Fermeture du fichier. ------------------------------------------------------ >>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> range(4,17) [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] range(-5, 20, 3) [-5, -2, 1, 4, 7, 10, 13, 16, 19] ------------------------------------------- # recherche d'un élément dans une liste _list = [30, 'zzz', 17, ('foo', 'bar'), 3.1415, 'tail', 'gunner'] _test = [('a', 'b'), 17, ('bar', 'foo'), 'tail'] for _key in _test: for _item in _list: if _key == _item: print "key", _key, "found !" break else: print "key", _key, "not found !" >>> key ('a', 'b') not found ! >>> key 17 found ! >>> key ('bar', 'foo') not found ! >>> key tail found ! --------------------------------------------- # str = "Ceci est une chaine de caractere" i = 0 while i < len(str): indx = ord(str[i]) if indx >= ord('a') and indx <= ord('z'): print chr(ord(str[i]) + ord('A') - ord('a')), else: print str[i], i = i + 1 print # le code (boucle while) précédent peut faire usage d'un for + range for i in range(len(str)): indx = ord(str[i]) if indx >= ord('a') and indx <= ord('z'): print chr(ord(str[i]) + ord('A') - ord('a')), else: print str[i], print >>> C E C I E S T U N E C H A I N E D E C A R A C T E R E -------------------------------------------- une_simple_chaine = "Programmer en %s, c'est 'fun'." % 'Python' un_calcul = '"Exemple : " %i * %i = %i' % (12, 12, 144) ----------------------------------- >>> # concaténation de chaînes de caractères : >>> 'Bobo' + ' casse' + ' la croûte' Bobo casse la croûte >>> len("Bobo") # longueur de 'Bobo' 4 >>> 'Ni! ' * 4 Ni! Ni! Ni! Ni! >>> alphabet = 'abcdef' >>> alphabet[:1] a >>> alphabet[1:] bcdef >>> alphabet[-1:] f >>> alphabet[:-1] abcde >>> alphabet[2] c ----------------------------------- >>> un_mot = "ortjographe" >>> un_mot = un_mot[:3] + 'h' + un_mot[4:] >>> un_mot orthographe ------------------------------------ >>> maListe = ['un_m', 45 , [1, 2, 3]] >>> print maListe ['un_mot', 45, [1, 2, 3]] >>> print maListe[0] un_mot >>> print maListe[2] [1, 2, 3] >>> print maListe[2][0] # élément 0 de l'élément 2 1 ----------------------------------- >>> taListe = ['t', 'a', 'r', 'a', 't', 'a', 't'] >>> taListe.append('a') >>> print taListe ['t', 'a', 'r', 'a', 't', 'a', 't', 'a'] >>> print taListe.count('a') # compte le nombre d'occurences de 'a' dans la liste 4 >>> print taListe.count('r') 1 >>> titi = [1,2,3] >>> bubu = titi.reverse() # inverse l'ordre de titi. >>> print bubu # La méthode reverse ne retourne pas d'objet, None # elle inverse la liste sur place. >>> print titi [3, 2, 1] # C'est donc bien titi qui a changé ------------------------------------------ >>> maliste = [num*2 for num in range(1, 11)] >>> print maListe [2,4,6,8,10,12,14,16,18,20] ---------------------------------- Les tuples Les tuples sont des listes non modifiables. Ils peuvent, comme les listes, inclure tout type d'objet. Opérations sur les tuples. >>> mon_tuple = (12, 31, 5, 2) >>> len(mon_tuple) # longueur du tuple 4 >>> min(mon_tuple) # plus petite valeur du tuple 2 >>> max(mon_tuple) # plus grande valeur 31 -------------------------------------------- Les dictionnaires Aussi appelés 'hash-tables' ou tableaux associatifs dans d'autres langages, les dictionnaires sont des collections non ordonnées d'objets. A la différences des listes, tuples et chaînes de caractères, les dictionnaires ne sont pas accédés séquentiellement mais par clés. >>> wiwi = {"sept":9, "oct":10, "nov":11} >>> wiwi["oct"] 10 ------------------------------------------ Opérations sur les dictionnaires >>> len(wiwi) 3 >>> wiwi.keys() ['nov', 'oct', 'sept'] >>> wiwi.values() [11, 10, 9] >>> wiwi.has_key('oct') # wiwi possède-t-elle la clé 'oct' 1 # oui >>> wiwi.has_key('dec') # wiwi possède-t-elle la clé 'dec' 0 # non >>> wiwi['dec']=13 # assignation d'une nouvelle valeur >>> wiwi.has_key('dec') 1 >>> del wiwi['oct'] # effacer une clé >>> wiwi['dec']=12 # modifier une valeur >>> wiwi {'nov': 11, 'sept': 9, 'dec':12} -------------------------------------------- Récapitulatif: Type Symbole Modifiable ? Accès Chaîne de caractère " " ou ' ' ou """ """ ou ''' ''' Non Séquentiel Listes [ ] Oui Séquentiel Tuples ( ) Non Séquentiel Dictionnaires { } Oui Par clé ------------------------------------------ def plusPetitPlusGrand(a, b): if a < b: print "%d est plus petit que %d" % (a, b) else: print "%d est plus grand que %d" % (a, b) if __name__ == "__main__": print plusPetitPlusGrand(5, 12) --------------------------------------- En Python, pas besoin de déclarer les variables avant de les utiliser. >>> a = "vile rat noir élu." >>> type(a) # quel est le type de a ? # a est une chaîne de caractères >>> a = 1 >>> type(a) # a est un entier ------------------------------------------ La fonction range crée une liste d'entiers conformément au format suivant: ----- range(start, end, step) où start est le premier entier, (end+1) le dernier et step, le pas d'incrémentation. Notez que le dernier élément de la liste est 1 et non 0. #!/usr/bin/env python for x in range(10, 0, -1): print x ------------------------------------------- ma_liste = ['abcd', 456, 'wxyz', 789, 123] for element in ma_liste: print element l = [x**2 for x in range(10)] print l -------------------------------------- #!/usr/bin/python # -*- coding: iso-8859-1 -*- --------------------------------------- Pour ne conserver qu'une seule occurence pour chaque élement de la liste, utilisez le type set qui représente les objets ensembles et qui conserve donc une unique occurence de chaque élément d'une séquence. l = [1,5,4,1,23,1,2,1] s = set(l) l = list(s) print l ## [1,2,4,5,23] -------------------------------- Comment concaténer les éléments d'une liste dans une string ? l1 = ['toto',' ','part',' ','en',' ','voyage'] strl1 = ''.join(l1) l2 = [116, 111, 116, 111, 32, 112, 97, 114, 116, 32, 101, 110, 32, 118, 111, 121, 97, 103, 101] str2 = ''.join(chr(i) for i in l2) ----------------------------------------- import os def get_contents(fichier): if not os.access(fichier, os.R_OK): return False return open(fichier, 'rb').read() --------------------------------------- - ouverture d'un fichier fic = open('test.txt','a') // mode ajout fic = open('test.txt','w') // mode création fic = open('test.txt','r') // mode lecture - fermeture d'un fichier fic.close() - écriture dans un fichier fic.write('Essai1') // écrit une chaine fic.writelines(list) // écrit le contenu d'une liste, d'un ensemble de chaine - lecture dans un fichier str = fic.read() // renvoi un caractére str = fic.read(5) // renvoi 5 caractères str = fic.readline() // renvoi une ligne str = fic.readlines() // renvoi la liste de toutes les lignes ----------------------------------- Si l’on définit mot=’rouge’ mot.capitalize() premier caractère en majuscule. mot.upper() tous les caractères en majuscules. mot.lower() tous les caractères en minuscules. mot.isalpha() vrai si mot ne contient que des lettres. mot.isalphanum() vrai si mot ne contient que des lettres et des chiffres. mot.isdigit() vrai si mot ne contient que des chiffres. ---------------------------------- mot.count(ch1,p1,p2) compte le nombre de fois que ch1 est répété dans l’intervalle mot(p1:p2). Si p1 et p2 sont omis, on compte sur toute la chaine. mot.find(ch1,p1,p2) retourne la position de la première occurence de ch1 dans l’intervalle mot(p1:p2). Si p1 et p2 sont omis, on cherche sur toute la chaine. mot.replace(a,b,n) remplace la chaine a par b un nombre maximal n de fois. Si n est omis, on remplace tout. -------------------------------- #ouvrir un fichier #!/usr/bin/python file = open('fichier.txt','r') lignes = file.readlines() for i in lignes: print i file.close() -------------------------------- en utilisant le numéro des cases : couleurs=[’bleu’,’rouge’,’vert’] for i in range(len(couleurs)) : print couleurs[i] ----------------------------------- Initialiser une liste : maliste=[] for i in range(10) : maliste.append(0) #fin d’init for i in range(len(maliste)): if i%2 : maliste[i]=1 ---------------------------- Pour transformer une chaine en liste : mot =’enzyme’ maliste= list(mot) ------------------------------------ replace Saisir la chaine chaine=’acgtcgagctgagagcccaa’ La transformer en liste adn=list(chaine) Convertir les caractères : for i in range (len(adn)): if adn[i] == ’a’: adn[i]=’u’ elif adn[i] == ’c’: adn[i]=’g’ elif adn[i] == ’g’: adn[i]=’c’ else : adn[i]=’a’ -------------------------------- Même chose avec une chaine de caractères et les fonctions associées au type : string Importer la bibliothèque : import string >>>adn=’acgtcgagctgagagcccaa’ >>>string.join(string.split(adn,’a’),’u’) ’ucgtcgugctgugugcccuu’ Attention, pour modifier la chaine adn de facon durable il faut écrire : >>>adn=string.join(string.split(adn,’c’),’g’) Il faut se protéger du fait que si vous modifiez les ’c’ en ’g’ sans précaution, vous ne pourrez plus différencier les ’g’ initiaux et les ’g’ qui ont déjà été transcrits. ----------------------------- Concaténation de 2 listes : adn=[’a’,’c’,’g’,’t’,’c’,’g’,’a’,’g’,’c’,’t’] adn2=[’g’,’a’,’g’,’a’,’g’,’c’,’c’] adn.append(adn2) Obtenir la longueur : len(adn) Obtenir la position du caractère c adn.index(’c’) Insérer la liste adn2 à partir de la position 1 adn.insert(1,adn2) Extraire le 3ieme élément de la liste adn.pop(3) Extraire le caractère a (seulement le 1er) adn.remove(’a’) Retourne la liste sur elle-même adn.reverse() --------------------------------- Les tuples : Un tuple est comme une liste, une collection ordonnée d’objets. Différence : un tuple n’est pas modifiable sur place. Un tuple se déclare avec les valeurs entre parenthèses. couleurs=(’bleu’,’rouge’) On accède aux différents éléments du tuple en les désignant par leur position : couleurs[1] On ne peut pas agrandir la taille d’un tuple. ------------------------------------- Déclaration : dict ={} ou dict={’jambon’:2,’oeufs’:3,’pain’:1} Nombre d’éléments : len(dict) ATTENTION dict[2] donne une erreur. Accès aux éléments dict[’jambon’] renvoie 2. Test d’existence : dict.has_key(’pain’) répond 1 pour vrai Obtenir la liste des clés : dict.keys() Obtenir le contenu du dictionnaire sous forme de tuples : dict.items() --------------------------------- Mémoriser les poids relevés pour 5 souris identifiées par un code : print ’programme gestion des poids’ DictPoids={} for i in range(5): print ’ donnez le code’ code=raw_input() print ’donnez le poids’ poids=input() DictPoids[code]=poids print ’ Affichage des poids’ for i in DictPoids.keys(): print ’la souris’, i, print ’ a le poids’, DictPoids[i] Demander les informations sur une souris : print ’ de quelle souris voulez-vous le poids ?’ code=raw_input() if DictPoids.has_key(code): print ’la souris’,code, print ’a le poids’, DictPoids[code] else: print "desolee cette souris n’existe pas" ------------------------------------ fonction def nomfonction(listeparametres): ...liste d’instructions... La définition se termine automatiquement lorsque l’indentation est supprimée. Appel de la fonction : nomfonction(listeparametres) Si la fonction renvoie une valeur, il est possible de la récupérer dans une variable: variable=nomfonction(listeparametres) --------------------------------- Ouverture d’un fichier : open(nomfichier,mode) fic=open("texte","r") Les modes possibles sont : "r","w","a" Lecture séquentielle du fichier : readline() ou readlines() nom=fic.readline() Ecriture séquentielle dans un fichier : write(chaine) ficsortie=open("sauv","w") ficsortie.write("ce que je veux ecrire") ----------------------------------- Exemple d’écriture : def ecrire(dict): fic=open("sauv","w") for cle in dict.keys(): fic.write(cle) fic.write(’\n’) fic.write(str(dict[cle])) fic.write(’\n’) fic.close() --------------------------- Exemple de lecture : def lire(dict): print "donnez un nom de fichier " nom=raw_input() fic=open(nom,"r") for ligne in fic.readlines(): if not ligne: break enz=ligne.split() print enz nom=enz[0] poids=string.atoi(enz[1]) dict[nom]=poids fic.close() ---------------------------------- def max(list): if len(list) > 0: _max = l[0] for index in range(1, len(list)): if _max < list[index]: _max = list[index] return _max l = [1, 2, 6, 5, 4, 7, -2, 8, -1] max(l) #resultat : 8 ------------------------------- # Global scope foo = 72 # foo et func sont globaux def func(bar): # bar et foobar sont locaux # local scope foobar = bar + foo # foo est recherché d'abord dans (L), non trouvé puis dans (I), OK ! return foobar print 'res=', func(foo) # res= 144 ----------------------------------- # Global scope x, y = 6, 8 def func(): # global z, t # ces variables (typiquement locales) deviennent globales # au module englobant z = y - x t = 3 func2() def func2(): t = z + 2 # t ici est local à func2, il masque le t global return t # renvoyer 4 # func() print z, t # z, t appartiennent bien à l'espace de nom du module # 2 3 ------------------------------------ fonction map f = lambda x, y: x * y x = [1, 2, 3] y = [6, 5, 4] print map(f, x, y) #resultat : [6, 10, 12] map(pow, [1, 2, 3, 4, 5], [2, 2, 2, 2, 2]) #resultat : [1, 4, 9, 16, 25] --------------------------------- [ x ** 3 for x in range(0,13) ] [0, 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331, 1728] ------------------------------------ python fournit deux modules fondamentaux qui forme le coeur de l'arsenal système du langage, à savoir sys et os. En principe, le module sys exporte les composants relatifs à l'interprète python lui-même, tandis que le module os contient les variables et fonctions correspondant au système d'exploitation hôte (i.e. celui sur lequel s'exécute votre interprète python), fournissant ainsi une interface portable. -------------------- x = (72) # expression désignant un entier >>> type(x) >>> t = (72,) # tuple contenant un entier, noter la virgule ! >>> type(t) -------------------------- # Affiche "Votre nom : " et permet de taper le nom demandé justement. reponse = raw_input("Votre Nom :") fichier = open("fichier.txt", "w") # Ouvre le fichier. fichier.write(reponse) # Ecris la réponse qui a été tapée. fichier.close() # Ferme le fichier print "Merci cat_loic !" # Partie optionnelle ;) ------------------------------ import os for dirpath, dirnames, filenames in os.walk('c:'): print 'Directory', dirpath for filename in filenames: print ' File', filename ---------------------------------------- Matching at the End of a String >>> s = '100 NORTH MAIN ROAD' >>> s.replace('ROAD', 'RD.') '100 NORTH MAIN RD.' >>> s = '100 NORTH BROAD ROAD' >>> s.replace('ROAD', 'RD.') '100 NORTH BRD. RD.' >>> s[:-4] + s[-4:].replace('ROAD', 'RD.') '100 NORTH BROAD RD.' >>> import re >>> re.sub('ROAD$', 'RD.', s) '100 NORTH BROAD RD.' ---------------------------------------------- Matching Whole Words >>> s = '100 BROAD' >>> re.sub('ROAD$', 'RD.', s) '100 BRD.' >>> re.sub('\\bROAD$', 'RD.', s) '100 BROAD' >>> re.sub(r'\bROAD$', 'RD.', s) '100 BROAD' >>> s = '100 BROAD ROAD APT. 3' >>> re.sub(r'\bROAD$', 'RD.', s) '100 BROAD ROAD APT. 3' >>> re.sub(r'\bROAD\b', 'RD.', s) '100 BROAD RD. APT 3' ---------------------------------------------- ^ matches the beginning of a string. $ matches the end of a string. \b matches a word boundary. \d matches any numeric digit. \D matches any non-numeric character. x? matches an optional x character (in other words, it matches an x zero or one times). x* matches x zero or more times. x+ matches x one or more times. x{n,m} matches an x character at least n times, but not more than m times. (a|b|c) matches either a or b or c. (x) in general is a remembered group. You can get the value of what matched by using the groups() method of the object returned by re.search. -------------------------------------------- Il est possible d’intégrer le contenu d’une variable dans une chaîne de caractères à l’aide du %. a = 120 b = ’La valeur est %d’ % a Les caractères de formatage sont : %s chaîne de caractères, en fait récupère le résultat de la commande : str() %f valeur flottante, par exemple %.2f pour indiquer 2 chiffres après la virgule %d ou %s un entier ------------------------------------ Opérateur d’appartenance L’opérateur - in - permet de savoir si un élément est présent dans une séquence. ’a’ in [’a’, ’b’, ’c’] True ---------------------------------- a = ’une_chaine’ b = a[4:7] # b recoit ’cha’ ------------------------------- import os # pour accéder aux appels systèmes import sys # pour la gestion du processus import socket # pour la programmation socket os.exit() # terminaison du processus --------------------------------- for i in range(3): ... print 'Dive in' #resultat : Dive in Dive in Dive in import sys for i in range(3): ... sys.stdout.write('Dive in') #resultat : Dive inDive inDive in ------------------------------------- Compteurs simples : >>> for i in range(5): ... print i 0 1 2 3 4 >>> li = ['a', 'b', 'c', 'd', 'e'] >>> for i in range(len(li)): ... print li[i] a b c d e ------------------------- Lecture d'un fichier: La méthode tell d'un objet-fichier vous indique la position actuelle dans le fichier ouvert. Comme nous n'avons encore rien fait de ce fichier l a position actuelle est 0, le début du fichier. >>> f >>> f.tell() 0 ####### La méthode seek d'un objet-fichier permet de se déplacer dans le fichier ouvert: >>> f.seek(-128, 2) La méthode tell confirme que la position actuelle a changé. >>> f.tell() 7542909 ####### La méthode read lit un nombre d'octets spécifié du fichier ouvert et retourne une chaîne contenant les données lues. Les données lues sont assignées à la variable tagData et la position actuelle est mise à jour en fonction du nombre d'octets lus. >>> tagData = f.read(128) >>> tagData ....contenu du fichier.... ####### La méthode tell confirme que la position actuelle a changé. >>> f.tell() 7543037 ------------------------------- Ecriture dans un fichier: >>> logfile = open('test.log', 'w') >>> logfile.write('test succeeded') >>> logfile.close() file est un synonyme de open. Ici, nous ouvrons le fichier, lisons son contenu et l'imprimons en une seule ligne. >>> print file('test.log').read() ^ ^ ^ imprime =open lire contenu resultat : test succeeded >>> logfile = open('test.log', 'a') >>> logfile.write('line 2') >>> logfile.close() >>> print file('test.log').read() test succeededline 2 ------------------------------ #rechercher un mot - grep #!/usr/bin/python # -*- coding: iso-8859-1 -*- chaine = "coucou" # Texte à rechercher fichier = open("fichier.txt","r") for ligne in fichier: if chaine in ligne: print ligne fichier.close() ##### fichier = open("fichier.txt","r") for ligne in fichier: for chaine in chaines: if chaine in ligne: print ligne fichier.close() ----------------------------------- En Python, TOUT est objet: les valeurs numériques, les chaînes de caractères, les listes tuples et dictionnaires, les fonctions, les classes, les instances de classes (ouf), les modules... tout. Les variables ne sont que des noms qui sont associés à des objets. la fonction id de Python retourne l'identificateur unique associé à l'objet (en fait actuellement son adresse en mémoire): >>> a=1 >>> id(a) 134526808 >>> b=a >>> id(b) 134526808 -------------------------------------- Les objets immutables sont les valeurs numériques, les chaînes de caractères, et les tuples. L'intérêt des objets immutables est que l'on est sûr que personne ne pourra modifier leur valeur. Tous les noms référençant un objet immutable peuvent considérer qu'il s'agit d'une constante s = "Bonjour" >>> id(s) 134875344 >>> s += " a vous." >>> id(s) 134859448 -------------------------------- Les objets mutables sont les listes, les dictionnaires Les objets mutables offrent des opérations permettant de modifier la valeur contenue dans l'objet, en conservant le même objet. l = [ 1,2,3,4 ] >>> id(l) 134865140 >>> l += [ 5,6,7,8 ] >>> id(l) 134865140 ------------------------------- descr=file("/chemin/fichier",'w') crée ou ouvre un fichier en écriture descr.write(chaine) écrit une ligne dans un fichier, terminée par un retour-chariot descr.writelines(liste) écrit toutes les chaînes de la liste descr.close() ne pas oublier de refermer, enregistrer, un fichier édité --------------------------------- descr.seek(43,0) pointe le 44ème octet à partir du début du fichier (,0 facultatif) descr.seek(13,1) pointe 13 octets plus loin, à partir de la position courante descr.seek(-5,2) pointe 5 octets avant la fin du fichier ('2') descr.tell() retourne le décalage courant descr.write(chaine) écrit une chaîne et ajoute len(chaine) au pointeur descr.read(n) lit et retourne une chaîne de n octets ------------------------------------ Fichiers "binaires" L'ajout de 'b' (pour binaire): 'rb', 'rwb', 'wb', 'ab' permet l'ouverture de fichier en mode binaire et non plus en mode 'texte': tous les octets, de 0 à 255 peuvent y être inscrits ----------------------------------------- var2=123; print "Le double de", var2, "est", var2*2 Chaque 'print' génère un saut de ligne après l'affichage. On peut l'éviter avec une virgule, qui génère un espace: >>> print 'Nombre',10 Nombre 10 Pour supprimer cet espace, il faut concaténer la chaîne, transformant les nombres en chaîne si besoin est: >>> nb=10; print 'Nombre'+str(nb) Nombre10 ------------------------------------- On peut insérer des variables dans une chaîne, choisies dans un tuple préfixé %(): print "Imprimer le %s %d et %.1f, sa %s" %("nombre", 5, 2.5, 'moiti\xe9') %s pour une sortie générale (chaîne ou nombre) %d sortie entier décimal %i sortie entière %o sortie octale (base 8): 55 -> 67 (6*8+7) %x sortie hexadécimale (base 16: 0...9, a, b, c, d, e, f): 55 -> 37 (3*16+5) %c sort le caractère selon son code numérique: 65=A, 66=B, etc. %e pour une sortie scientifique: 55 -> 5,500000e+01 %f sortie décimale (virgule flottante) 5.5 -> 5.500000 %9.3f sortie sur 9 caractères, dont un pour le point et 3 pour les décimales %09.3f la partie entière nulle sera comblée de 0: 4.3-> 00004.300 %.f arrondit (par défaut ou par excès): 5.5 -> 6 ------------------------------------------- #!/usr/bin/python # -*- coding: iso-8859-1 -*- for var in range(1,11) : # signifie de 1 à 10! print var print var*5 print "toujours dans la boucle: indentation" print "Suite du programme: alignement sur 'for'" ------------------------------------ i=0 while i<11 : print i i=i+1 --------------------------------- dic={1:"un", 2:"deux", 3:"trois"} for i in dic.keys(): # i prend successivement les clés print dic[i] # et renvoie les valeurs ----------------------------------- #!/usr/bin/python # -*- coding: iso-8859-1 -*- for i in range(-10,11): try: 1./i except ZeroDivisionError: print " - " else: print "%.3f " %(1./i) print dir() #liste les modules chargés ----------------------------------------- print dir() liste les modules chargés print dir(module) liste les fonctions et constantes d'un module chargé print fct.__doc__ documente la fonction d'un module chargé print module.__file__ renvoie la localisation du module sur votre système help(module) renvoie des informations sur les fonctions d'un module help(module.fonction) renvoie des informations sur une fonction particulière --------------------------------------- Module string : chaine.upper() convertit en majuscule chaine.lower() convertit en minuscule chaine.capitalize() passe la première lettre de la chaîne en capitale chaine.title() passe la première lettre de chaque mot de la chaîne en capitale string.capwords(chaine) idem, mais le module doit être chargé chaine.swapcase() transforme minuscules en majuscules et inversement chaine.split() renvoie une liste de tous les mots (séparation: l'espace) d'une chaîne-phrase chaine.split('*') le séparateur peut être une chaîne autre qu'un espace chaine.split(' ',n) on peut limiter le nombre de séparations effectuées chaine="".join(liste) concaténation d'une liste (ou tuple) de chaînes chaine=string.join(liste,'sep') cette forme permet un séparateur éventuel (le module doit être chargé) chaine.startswith('pref') renvoie True si la chaîne commence par le prefixe chaine.endswith('suf') renvoie True si la chaîne termine par le suffixe chaine.strip() ôte les espaces en début et fin de chaîne chaine.lstrip() / chaine.rstrip() ôtent les espaces en début / fin de chaîne chaine.strip('car') ôte les caractères précisés en début et fin de chaîne chaine.ljust(n) remplit d'espaces à gauche pour que la chaîne fasse n caractères chaine.rjust(n) remplit d'espaces à droite pour que la chaîne fasse n caractères chaine.center(n) entoure la chaîne d'espaces pour qu'elle fasse n caractères chaine.zfill(n) ajoute des 0 à gauche pour que la chaîne fasse n caractères chaine.expandtabs(n) transforme les tabulations en n espaces (8 par défaut) chaine.count(ssch,debut,fin) compte les occurrences de la sous-chaîne dans la chaîne, éventuellement entre deux positions chaine.find(ssch) renvoie la position d'une sous-chaîne dans une chaîne (0 pour la première position, -1 si la sous-chaîne ne s'y trouve pas chaine.find(ssch,debut,fin) renvoie la position d'une sous-chaine dans une chaine, en définissant les positions de début et de fin chaine.rfind(ssch,debut,fin) pareil, mais en commençant par la fin chaine.replace(ssch1,ssch2,n) remplace une sous-chaîne par une autre (éventuellement en limitant à n occurrences) rempl=maketrans(ch1,ch2) définit un protocole de remplacements pour translate chaine.translate(rempl,suppr) assigne les remplacements définis à une chaîne, avec une éventuelle chaîne des caractères à supprimer (dans ce cas, un caractère qui vient d'être modifié ne sera pas supprimé). --------------------------------- Module time : sleep() marque une pause du programme en secondes ctime() rend la date actuelle sous la forme "jour-de-semaine mois jour hh:mm:ss année", ou toute autre date si on précise un nombre de secondes (on peut remonter jusqu'en 1900 avec un nombre négatif) clock() renvoie le temps écoulé en secondes depuis la mise sous tension de l'ordinateur time() renvoie le temps écoulé en secondes depuis la création du monde, soit 01:01:1970 à 0:00:00 pour le monde Unix localtime() convertit ce nombre de secondes en tuple local (année, mois, jour, h(24), min, s, 0=lundi, jour de l'année (1-166), dst) dailight saving time (heure d'été)= -1, 0, 1 gmtime() convertit ce nombre de secondes en tuple temps universel asctime() convertit le tuple de gmtime ou localtime en chaîne au format ctime mktime() convertit un tuple en nombre de secondes depuis la création du monde timezone renvoie le décalage en secondes de l'heure locale avec le temps universel altzone renvoie le décalage en secondes de l'heure locale d'été avec le temps universel daylight si l'heure d'été est à considérer tzset() change la zone horaire tzname tuple ('CET','CEST') --------------------------------- Module sys: print dir(sys) liste les instructions du module interne 'sys': print version affiche la version de python et du compilateur C ---------------------------------- Module os : descr=open(chaine,flags, mode) ouvre un fichier getcwd() renvoie le répertoire courant listdir(getcwd()) renvoie une liste de tous les objets du répertoire courant mkdir(chaine) crée un répertoire dans le répertoire courant, mode 0777 chdir(chaine) pénètre dans un répertoire existant chdir("..") remonte d'un niveau de répertoire remove(chaine) détruit un fichier rmdir(chaine) détruit un répertoire rename(anc,nom) renomme un fichier chmod(fichier) attributs du fichier, exemple: chmod(fichier,0744) (commencer par un "0" pour l'octal) chown(fichier) droit sur le fichier, exemple: chown(fichier,usr,grp) (identifiants sous forme d'entier) ------------------------------ Sous-module os.path Le sous-module path (chargé avec import os) permet notamment de traiter les fichiers: path.getsize(fichier) rend la tailleL (entier long) path.getatime(fichier) renvoie la date du dernier accès à un fichier (en nombre de secondes, voir 5.2 'time' path.getmtime(fichier) renvoie la date de la dernière modification d'un fichier (idem) path.split(cheminfichier) renvoie un tuple avec l'adresse et le nom du fichier (que l'adresse soit exacte ou pas) path.dirname(cheminfichier) le premier membre du tuple de split path.basename(cheminfichier) le second membre du tuple de split path.abspath(fichier) renvoie le chemin complet d'un fichier path.expanduser(fichier) complète une chaîne commençant par "~/" path.splitext(fichier) renvoie un tuple avec l'adresse sans l'extension et l'extension if path.exists(fichier): vrai si le fichier existe if path.isfile(fichier): vrai si l'objet est un fichier if path.isdir(fichier): vrai si l'objet est un répertoire if path.islink(fichier): vrai si l'objet est un lien if path.ismount(chemin): vrai si le répertoir est un point de montage if path.isabs(fichier): vrai si le nom du fihcier comporte le chemin complet dir(os.path) informe sur les fonctions du sous-module os.path ---------------------------------- Module random : shuffle(liste) mélange les éléments d'une liste randrange(borne1,borne2,pas) renvoie un entier entre la première borne (incluse) et la deuxième (exclue); le pas est optionnel -------------------------------------- \033[2J efface tout l'écran \033[H place le curseur en haut à gauche \033[#;#_H place le curseur à un point particulier de l'écran. \033[1;1H place le curseur en haut à gauche \033[#A déplace le curseur de # caractères vers le haut \033[#B déplace le curseur de # caractères vers le bas \033[#C déplace le curseur de # caractères vers la droite \033[#D déplace le curseur de # caractères vers la gauche \033[#f place le curseur à la ligne # , première colonne \033[#L insère # lignes à la position du curseur, repousse la suite \033[#M efface # lignes à la position du curseur, ramène les suivantes \033[#a place le curseur à la ligne #, colonne inchangée \033[#;#r définit une première et une dernière ligne pour le scroll \033[s sauvegarde la position du curseur \033[u replace le curseur à la position préalablement sauvegardée \033[?25l cache le curseur; \033[?25h le rétablit Les couleurs (très limitées) se codent \033[_m le souligné doit être remplacé par: 0 réinitialisation: blanc sur fond noir 1 haute intensité 3n couleur du caractère 4n couleur du fond 5 clignotement 7 inverse-video Caractère Fond 30 Gris moyen 40 Noir 31 Rouge 41 Rouge foncé 32 Vert 42 Vert foncé 33 Jaune 43 brun 34 Bleu 44 Bleu foncé 35 Magenta 45 Mauve 36 Cyan 46 Cyan foncé 37 Blanc 47 gris clair 39 Blanc gras On compose couleurs de caractère et de fond en séparant les nombres par un point virgule: >>> print "\033[33;45m"+"Spam?" Spam? (ecrit en jaune sur fond mauve le mot: Spam?) Le module ecma (expérimental) permet l'utilisation simple de ces codes: paintat(ligne,colonne,texte,fond,"Chaine") ----------------------------------- copie de chaines dans un autre fichier : #!/usr/bin/python # -*- coding: iso-8859-1 -*- import shutil, string, re # Lecture ds le fichier 3 dernières lignes : obfic = open("fichier.txt","r") lignes = obfic.readlines()[-3:] obfic.close() # Copie ds fichier2.txt des 3 dernières lignes : obfic = open("fichier2.txt","w") obfic.write("".join(lignes)) #s = '>o<' #re.sub(r'\s','>i<',s) obfic.close() # Copie de taglist.xml dans nouveau_taglist.xml #shutil.copyfile('tampon_taglist.xml','nouveau_taglist.xml') ------------------------------------- a='coucou' print a.replace('o','*').replace('c','C').replace('u','$') #resultat : C*$C*$ ---------------------------- print "J'imprime un retour à la ligne\npuis une tabulation\t, puis un guillemet\"" resultat : J'imprime un retour à la ligne puis une tabulation , puis un guillemet" ------------------------------ import string string.lower('CECI EST UN TEXTE EN MASJUSCULE') 'ceci est un texte en masjuscule' string.upper('ceci est un texte en minuscule') 'CECI EST UN TEXTE EN MINUSCULE' ------------------------- split import string line = 'Ceci est une ligne' for i in string.split(line): print i #resultat: #Ceci #est #une #ligne ################ line = 'Ceci est:une ligne' for i in string.split(line,':'): print i resultat : ceci est une ligne ------------------------- replace import string line = 'Ceci est une ligne' print string.replace(line,'Ceci','Cela') resultat : 'Cela est une ligne' ----------------------------------- les nombres dans un fichier sont considérés comme du texte par la fonction readlines(), par conséquent il faut les convertir si on veut effectuer des opérations numériques dessus i = 3 str(i) '3' i = '456' int(i) 456 float(i) 456.0 -------------------------- #list.append(element) : ajoute element à la fin de la liste x = [1,2,3] #x est une liste x.append(2239) print x #[1, 2, 3, 2239] ######### #del liste[indice] : supprime element à la position indice de la liste del x[1] print x #[1, 3, 2239] ######### #list.insert(indice,objet) : insère un objet dans une liste avant l'indice x.insert(2,-15) print x #[1, 3, -15, 2239] ######### #list.sort() : tri la liste x.sort() print x #[-15, 1, 3, 2239] ######### #list.reverse() : inverse la liste x.reverse() print x #[2239, 3, 1, -15] ------------------------------- convertir une chaîne de caractères en liste : seq = 'CAAAGGTAACGC' seq_list = [] for i in seq: seq_list.append(i) print seq_list #['C', 'A', 'A', 'A', 'G', 'G', 'T', 'A', 'A', 'C', 'G', 'C'] ############ oubien avec la fonction : list(sequence) Cette méthode est certes plus simple, mais il arrive parfois que l'on doive utiliser les boucles tout de même : seq = 'CAAAGGTAACGC' print list(seq) #['C', 'A', 'A', 'A', 'G', 'G', 'T', 'A', 'A', 'C', 'G', 'C'] -------------------------------- liste = ['a', 'b', 'c', 'd', 'e', 'f'] liste + ['g','h'] #['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] liste * 2 #['a', 'b', 'c', 'd', 'e', 'f', 'a', 'b', 'c', 'd', 'e', 'f'] ------------------------------ l'affectation d'une liste (à partir d'une liste préexistante) crée en réalité une référence et non une copie x = [1,2,3] y = list(x) x[1] = -15 print y #[1, 2, 3] #attention: l'element 1 de y n'est pas -15 ------------------------------------- fonction type : (si on a oublié le type de la variable) x = 2 print type(x) # x = 2.0 print type(x) # x = "2" print type(x) # ---------------------------- appel commande script exterieur: perl appelle python: #!/usr/bin/perl print "hello\n"; #require ne marche pas ici: #require "python listes.py"; open(F, "python listes.py |"); while() { print $_; } close(F); # oubien: system("python listes.py"); --------------------------------- écrire une chaine de caractères écrire le contenu d’une ou plusieurs variables x = 32 nom = ’John’ print nom , ’ a ’ , x , ’ ans’ #la virgule ajoute un espace #John a 32 ans ##### imprimer 2 chaines de caractères l’une à coté de l’autre sans espace, il faudra les concaténer : codon1 = ’ATG’ codon2 = ’GCC’ print codon1,codon2 #la virgule ajoute un espace #ATG GCC print codon1 + codon2 #ATGGCC ------------------------------- imprimer le contenu d'une liste: peptide = [’PRO’,’GLY’,’ALA’,’ARG’,’ASN’,’ASP’,’CYS’,’GLN’,’GLU’,’HIS’] for i in peptide[3:7]: print i #ARG #ASN #ASP #CYS ##### équivalent de la commande : for (i = 0 ; i < 5 ; i++) animaux = [’girafe’, ’hippopotame’, ’singe’, ’dahu’, ’ornithorynque’] for i in range(5): print animaux[i] #girafe #hippopotame #singe #dahu #ornithorynque -------------------------------- ecrire dans un fichier: animaux = [’girafe’, ’hippopotame’, ’singe’, ’dahu’ , ’ornithorynque’] file = open(’fichier2.txt’,’w’) for i in animaux: file.write(i) file.close() ---------------------------------- ecrire dans un fichier une selection de lignes et un replace #!/usr/bin/python # -*- coding: iso-8859-1 -*- import string #Ecriture dans un fichier logfile = open('test.log', 'w') # Lecture ds le fichier des 3 dernières lignes : obfic = open("fichier.txt","r") lignes = obfic.readlines()[-3:] for i in lignes: print i.replace('o','*').replace('c','C').replace('u','$') logfile.writelines("".join(i.replace('o','*').replace('c','C').replace('u','$'))) # print file('test.log').read() obfic.close() logfile.close() ---------------------------- chaines de caractères et listes les chaines de caractères pouvaient etre considérées comme des listes ; ceci nous permet donc d’utiliser certaines propriétés des listes telles que récupérer des tranches : string = "Ceci est une belle chaine de caracteres !" print string #Ceci est une belle chaine de caracteres ! print string[0:10] #Ceci est u print string[15:] #lle chaine de caracteres ! print string[:-4] #Ceci est une belle chaine de caracter ----------------------------------------- A contratio des listes, les chaines de caractères sont non modiables ----------------------------------- f = open("toto.txt","w") value = ('the answer', 42) #convertir melange string+chiffre en string #pour ecrire dans un fichier s = str(value) f.write(s) #si string seule , pas besoin de convertir: value = 'the answer' #s = str(value) f.write(value) #write n'ecrit que des 'string' -------------------------------- f = open('toto.txt', 'r+') f.write('0123456789abcdef') # Go to the 6th byte in the file f.seek(5) print f.read(1) #'5' # Go to the 3rd byte before the end f.seek(-3, 2) print f.read(1) #'d' --------------------------------- print input("Entrez quelque chose : ") Entrez quelque chose : 47+5 #52 ---------------------------- print "Bonjour ! Quel est ton nom ?" print "Ah ! tu t'appelles", raw_input() ##### une concaténation est une fusion de deux chaînes (on aurait aussi bien fait avec une virgule, dans print) nom = raw_input() message = "Bonjour " + nom print message ------------------------- convertir chaine en nombre: print "Ce programme est très poli. Combien de fois va-t'il dire bonjour ?" chaine = raw_input() nombre = int(chaine) # On transforme chaine en entier si possible if nombre > 0: print "Bonjour ! " * nombre -------------------------- maChaine = "bonjour" len(maChaine) #7 maChaine[6] #'r' --------------------------- parcourir une chaîne C'est-à-dire passer par chaque caractère de la chaîne. Petit exemple : maChaine = "Salut !" compteur = 0 longueurChaine = len(maChaine) # Combien de caracteres dans la chaine ? while compteur < longueurChaine: print maChaine[compteur] compteur = compteur + 1 ------------------------------- recurrence maChaine = "Les chaussettes de l'archi-duchesse sont-elles seches et archiseches" car = "e" compteur = 0 nombreCar = 0 longueurChaine = len(maChaine) while compteur < longueurChaine: if maChaine[compteur] == car: # Si on a bien trouvé le caractère cherché nombreCar += 1 compteur += 1 print "On a trouvé", nombreCar,"fois le caractère",car ##### en plus court : count count : compte le nombre de sous-chaînes dans la chaîne : ch1 = "Le héron au long bec emmanché d'un long cou" ch2 = 'long' print ch1.count(ch2) #2 ------------------------ convertir liste en string file = open("fichier.txt","r") lignes = file.readlines() print lignes #le tout entre crochet [] separes par des virgules: , print type(lignes) #type: list machaine = str(lignes).strip('[]').replace(',', '') print machaine #sans crochet ni virgule print type(machaine) #type str --------------------------------- liste=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print liste [1:-2:2] #donnera [1, 3, 5, 7] print liste [::2] #donnera [0, 2, 4, 6, 8] print liste [::-2] #donnera [9, 7, 5, 3, 1] -------------------------------- li = [] print dir(li) #['append', 'count', 'extend', 'index', 'insert', #'pop', 'remove', 'reverse', 'sort'] d = {} print dir(d) #['clear', 'copy', 'get', 'has_key', 'items', 'keys', 'setdefault', 'update', 'values'] ------------------------------------ #join split li = ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret'] print type(li) #type: list s = ";".join(li) print s print type(s) #type: str #server=mpilgrim;uid=sa;database=master;pwd=secret print s.split(";") print type(s.split(";")) #type: list #['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret'] #split prend en deuxième argument optionnel le nombre de découpages à effectuer print s.split(";", 1) #['server=mpilgrim', 'uid=sa;database=master;pwd=secret'] for i in s.split(";", 1): print i #server=mpilgrim #uid=sa;database=master;pwd=secret ------------------------------- lire fichier # First open the file to read(r) theInFile = open("menu.txt","r") # read the file into a list then print each item for line in theInFile.readlines(): print line # Now close it again theInFile.close() -------------------------------- ecrire une liste dans fichier # write this list to the file myMenuList = ["bacon", "eggs", "ham"] # open the file to write(w) theOutFile = open ("mymenu.txt","w") # write out the contents for item in myMenuList: theOutFile.write (item) # clean up theOutFile.close() print "I'm finished ..." ----------------------------------- supprimer saut de ligne \n a la fin file = open("fichier3.txt","r") for lignes in file: print lignes.replace('\n','') #au lieu de : print lignes -------------------------------------- lire une colonne d'un texte ecrire la sortie dans un fichier out = open("fichier4.txt","w") file = open("fichier3.txt","r") for lignes in file: b = lignes.split(' ') print b[2] out.writelines(b[2]+'\n') ------------------------------------ #ecrire texte tapé au clavier dans un fichier # Let's create a file and write it to disk. filename = "out2.txt" # Let's create some data: done = 0 namelist = [] while not done: name = raw_input("Enter a name:") if type(name) == type(""): namelist.append(name+'\n') else: break # Create a file object in "write" mode FILE = open(filename,"w") FILE.writelines(namelist) # Alternatively # for name in namelist: # FILE.write(name) FILE.close() -------------------------------------- saut de ligne pour print print lignes, (la virgule retire le \n) print lignes.replace('\n','') (equivalent) ------------------------------- appel d'un perl dans un python (equivalent de 'require' de perl) import os import string cmd="perl hello.pl" handle = os.popen(cmd, 'r') print string.join(handle.readlines()) handle.close() ###### oubien plus court: import os os.system('perl hello.pl') -------------------------------- date from datetime import date now = date.today() print now #datetime.date(2003, 12, 2) print now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.") #'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.' ------------------------------ word = 'HelpA' word[4] #A word[0:2] #He word[2:4] #lp word[:2] # The first two characters : He word[2:] # Everything except the first two characters : lpA word[:2] + word[2:] #HelpA word[:3] + word[3:] #HelpA word[-1] # The last character : A word[-2] # The last-but-one character : p word[-2:] # The last two characters : pA word[:-2] # Everything except the last two characters : Hel ---------------------------- a est la liste : ['spam', 'eggs', 100, 1234] a[2] = a[2] + 23 print a ['spam', 'eggs', 123, 1234] Replace some items: a[0:2] = [1, 12] print a [1, 12, 123, 1234] Remove some: a[0:2] = [] print a [123, 1234] Insert some: a[1:1] = ['bletch', 'xyzzy'] print a [123, 'bletch', 'xyzzy', 1234] Insert (a copy of) itself at the beginning a[:0] = a print a [123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234] Clear the list: replace all items with an empty list a[:] = [] print a [] q = [2, 3] p = [1, q, 4] print len(p) 3 p[1] [2, 3] print p[1][0] 2 p[1].append('xtra') print p [1, [2, 3, 'xtra'], 4] --------------------------- #selectionner le numero de ligne a lire: import linecache file = "fichier3.txt" print linecache.getline(file, 1), print linecache.getline(file, 3) # ^ nb ligne a lire print type(linecache.getline(file, 1)) #type : str linecache.clearcache() file.close() ----------------------------- append extend first = [10,20,30] second = [40,50,60] first.append([70,80,90]) second.extend([100,110,120]) #append ajoute un bloc print first [10, 20, 30, [70, 80, 90]] #extend ajoute des elements à la liste print second [40, 50, 60, 100, 110, 120] ---------------------------- r ouvre fichier existant pour lecture w cree fichier pour ecriture. contenu écrasé a ouvre fichier existant pour ecriture en ajout r+ ouvre fichier en lecture et ecriture en ajout w+ ouvre fichier en lecture et ecriture. contenu écrasé a+ idem r+ b option pour lecture, ecriture, ajout: ouvre fichier en binaire U (maj) applique traducteur de saut de ligne 'universel' en lect, ecrit, ajout --------------------------------- la liste des carrés des entiers naturels plus petits que 10: l = [x**2 for x in range(10)] la liste des nombres pairs : l = [entier for entier in range(10) if entier % 2 == 0] ---------------------------- Les types séquences variables (liste) Il est possible de faire des opérations de modification sur place des listes. (Les chaînes de caractères et les tuples sont des séquences invariables et ces objets ne peuvent être modifiés une fois créés.) Opération Résultat Notes s[i] = x l'élément i de s est remplacé par x s[i:j] = t l'intervalle dans s de i à j est remplacé par t del s[i:j] identique à s[i:j] = [] s.append(x) identique à s[len(s):len(s)] = [x] (1) s.extend(x) identique à s[len(s):len(s)] = x (2) s.count(x) retourne le nombre de i pour lesquels s[i] == x s.index(x) retourne le plus petit i tel que s[i] == x (3) s.insert(i, x) identique à s[i:i] = [x] si i >= 0 s.pop([i]) identique à x = s[i]; del s[i]; return x (4) s.remove(x) identique à del s[s.index(x)] (3) s.reverse() inverse sur place l'ordre des éléments de s (5) s.sort([cmpfunc]) trie sur place les éléments de s (5), (6) ---------------------------------------- voir code source page html import urllib2 meteo = open("outmeteo.txt", "w") f = urllib2.urlopen('http://quentel.pierre.free.fr/python-trad/typesseq-mutable.html') #print f.read(80000) #lire 160000 caracteres: lignes = f.read(160000) meteo.writelines(lignes) ------------------------------ The cStringIO module import cStringIO fh = cStringIO.StringIO() fh.write("mary had a little lamb") print fh.getvalue() #'mary had a little lamb' fh.seek(5) fh.write('ATE') print fh.getvalue() #'mary ATE a little lamb' (type: str) ---------------------------------------- import string s = "mary had a little lamb" string.capwords(s) #'Mary Had A Little Lamb' string.replace(s, 'little', 'ferocious') #'mary had a ferocious lamb' -------------------------- effacer fichier import os os.remove(path) -------------------------- sort tri f = open('monfichier.txt', 'r') txt = f.read() f.close() txtList = txt.split(';') #si on veut trier avec séparateur ';' triTxt = sorted(txtList) Sinon, à la place de sorted(liste), utiliser liste.sort() ça utilisera moins de "cases" mémoires. print txtList.sort() #par exemple ###### opération inverse: txt = ';'.join(triTxt) f = open('monfichier_resultat.txt', 'w') f.write(txt) f.close() --------------------- sauver une image d'un site import urllib import StringIO import Image if __name__ == "__main__": page =urllib.urlopen("http://monsite.com/image.jpg") buffer = page.read() im = Image.open(StringIO.StringIO(buffer)) im.save ("test.jpg") ####### fichier = open('google.gif', 'wb') #(il faut louvrir en binaire ) ---------------------------- strip() >>> 'str' 'ing' # <- This is ok 'string' >>> 'str'.strip() + 'ing' # <- This is ok 'string' -------------------------------- | union & intersection ^ symmetric difference - asymmetric difference == != equality and inequality tests < <= >= > subset and superset tests -------------------------- S.add(x) Add "x" to the set. S.update(s) Add all elements of sequence "s" to the set. S.remove(x) Remove "x" from the set. If "x" is not present, this method raises a LookupError exception. S.discard(x) Remove "x" from the set if it is present, or do nothing if it is not. S.pop() Remove and return an arbitrary element, raising a LookupError if the element is not present. S.clear() Remove all elements from this set. S.copy() Make a new set. s.issuperset() Check for a superset relationship. s.issubset() Check for a subset relationship. and two new built-in conversion functions: set(x) Create a set containing the elements of the collection "x". frozenset(x) Create an immutable set containing the elements of the collection "x". ------------------------------ Counting occurrences : nba = string.count(dna,'a') or nba = dna.count('a') Replacing occurrences : single letter : string.replace(dna, 'a', 'A') list of letters : t = string.maketrans("AGCTagct","TCGAtcga") string.translate(dna,t) ----------------------------- ajout d'une ligne en fin de liste: a = a.append('extra') ['spam', 'eggs', 123, 1234,'extra'] ------------------------------- deleter la 1ère ligne d'une liste 'a': a[0 :1] = [] --------------------------- append(x) : Add an item to the end of the list. extend(L) : Extend the list by appending all the items in the given list. insert(i, x) : Insert an item at a given position. remove(x) : Remove the first item from the list whose value is x. pop([i]) : Remove the item at the given position in the list, and return it. index(x) : Return the index in the list of the first item whose value is x. count(x) : Return the number of times x appears in the list. sort() : Sort the items of the list, in place. reverse() : Reverse the elements of the list, in place. ------------------------- append(x) Equivalent à a.insert(len(a), x) #donc en fin de liste extend(L) équivalent à a[len(a):] = L Rallonge la liste en ajoutant à la fin tous les éléments de la liste donnée insert(i, x) Insère un élément à une position donnée. Le premier argument est l'indice de l'élément avant lequel il faut insérer, donc a.insert(0, x) insère au début de la liste, a.insert(len(a), x) est équivalent à a.append(x) remove(x) Enlève le premier élément de la liste dont la valeur est x. Il y a erreur si cet élément n'existe pas pop([i]) Enlève l'élément présent à la position donnée dans la liste, et le renvoie. Si aucun indice n'est spécifié, a.pop() renvoie le dernier élément de la liste. L'élément est aussi supprimé de la liste. index(x) Retourne l'indice dans la liste du premier élément dont la valeur est x. Il y a erreur si cet élément n'existe pas. count(x) Renvoie le nombre de fois que x apparaît dans la liste. sort() Trie les éléments à l'intérieur de la liste. reverse() Renverse l'ordre des éléments à l'intérieur de la liste. -------------------------------------- Utiliser les Listes comme des Piles = le dernier élément ajouté est le premier élément récupéré Pour ajouter un élément au sommet de la pile (= en fin de liste) , utilisez la méthode append(). Pour récupérer un élément du sommet de la pile, utilisez pop() sans indice explicite. pile = [3, 4, 5] pile.append(6) pile.append(7) print pile #[3, 4, 5, 6, 7] pile.pop() #7 print pile #[3, 4, 5, 6] pile.pop() #6 pile.pop() #5 pile #[3, 4] -------------------------- Utiliser les Listes comme des files = le premier élément ajouté est le premier élément retiré Pour ajouter un élément à la fin de la file, utiliser append(). Pour récupérer un élément du devant de la file, utilisez pop() avec 0 pour indice ------------------------------------ Outils de Programmation Fonctionnelle Il y a trois fonctions intégrées qui sont très pratiques avec les listes: filter(), map(), et reduce(). "filter(fonction, sequence)" renvoit une liste (du même type, si possible) contenant les seul éléments de la séquence pour lesquels fonction(element) est vraie. Par exemple, pour calculer quelques nombres premiers: >>> def f(x): return x % 2 != 0 and x % 3 != 0 ... >>> filter(f, range(2, 25)) [5, 7, 11, 13, 17, 19, 23] "map(fonction, sequence)" appelle fonction(element) pour chacun des éléments de la séquence et renvoie la liste des valeurs de retour. Par exemple, pour calculer les cubes: >>> def cube(x): return x*x*x ... >>> map(cube, range(1, 11)) [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000] "map(None, liste1, liste2)" est une façon pratique de transformer un couple de liste en une liste de couples. Par exemple: >>> seq = range(8) >>> def carre(x): return x*x ... >>> map(None, seq, map(carre, seq)) [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)] "reduce(fonction, sequence)" renvoie une valeur unique construite par l'appel de la fonction binaire fonction sur les deux premiers éléments de la séquence, puis sur le résultat et l'élément suivant, et ainsi de suite. Par exemple, pour calculer la somme des nombres de 1 à 10: >>> def ajoute(x,y): return x+y ... >>> reduce(ajoute, range(1, 11)) 55 --------------------------------------- >>> re.split('\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split('(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split('\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] -------------------------------- #!/usr/local/bin/python import os, string, stat for d in string.split(os.environ['PATH'], ':'): for f in os.listdir(d): mode = os.lstat(d + '/' + f)[stat.ST_MODE] if not stat.S_ISDIR(mode): print f -------------------------- import os from os.path import join, getsize for root, dirs, files in os.walk('python/Lib/email'): print root, "consumes", print sum(getsize(join(root, name)) for name in files), print "bytes in", len(files), "non-directory files" if 'CVS' in dirs: dirs.remove('CVS') # don't visit CVS directories ------------------------------------- # Delete everything reachable from the directory named in 'top', # assuming there are no symbolic links. # CAUTION: This is dangerous! For example, if top == '/', it # could delete all your disk files. import os for root, dirs, files in os.walk(top, topdown=False): for name in files: os.remove(os.path.join(root, name)) for name in dirs: os.rmdir(os.path.join(root, name)) -------------------------------------------- import glob for nomfichier in glob.glob(r'c:\windows\*.exe'): print nomfichier ---------------------------------- def command(cmd): return os.popen(cmd, 'r').read() ------------------------------------------ Simple scripting - make some files executable # with os.path DIR = '/usr/home/guido/bin' for f in os.listdir(DIR): if f.endswith('.py'): path = os.path.join(DIR, f) os.chmod(path, 0755) # Assume it's a file # with path d = path('/usr/home/guido/bin') for f in d.files('*.py'): f.chmod(0755) -------------------------------- Directory walking - delete Emacs backup files # with os.path.walk def delete_backups(arg, dirname, names): for name in names: if name.endswith('~'): os.remove(os.path.join(dirname, name)) os.path.walk(os.environ['HOME'], delete_backups, None) # with os.path, if (like me) you can never remember how os.path.walk works def walk_tree_delete_backups(d): for name in os.listdir(d): path = os.path.join(d, name) if os.path.isdir(path): walk_tree_delete_backups(path) elif name.endswith('~'): os.remove(path) walk_tree_delete_backups(os.environ['HOME']) # with path d = path(os.environ['HOME']) for f in d.walkfiles('*~'): f.remove() ------------------------------------------ script walk1.py #!/usr/bin/python # -*- coding: iso-8859-1 -*- out = open("temp4.txt","w") import os import re import string from os.path import join, getsize for root, dirs, files in os.walk('c:/users/jean/AppData/Local/Microsoft/Windows/Temporary Internet Files'): print root, "consumes", print sum(getsize(join(root, name)) for name in files), print "bytes in", len(files), "non-directory files" for name in files: print name out.writelines((join(root, name),'\n')) nblignes = len(open("temp4.txt","r").readlines()) print nblignes ------------------------------------------ import time from path import path seven_days_ago = time.time() - 7 * 86400 base = path('/path/to/dir') for somefile in base.walkfiles(): if somefile.mtime < seven_days_ago: somefile.remove() ------------------------------------------- from os import chdir >>> chdir("/home/jules/exercices") -------------------------------------- import os >>> rep_cour = os.getcwd() >>> print rep_cour C:\Python22\essais -------------------------------- Nous pouvons même importer toutes les fonctions d'un module, comme dans : from Tkinter import * --------------------------------- ecrire : obFichier = open('Monfichier','a') >>> obFichier.write('Bonjour, fichier !') >>> obFichier.write("Quel beau temps, aujourd'hui !") >>> obFichier.close() lire : ofi = open('Monfichier', 'r') >>> t = ofi.read() >>> print t Bonjour, fichier !Quel beau temps, aujourd'hui ! >>> ofi.close() combien de caractères doivent être lus, à partir de la position déjà atteinte dans le fichier : ofi = open('Monfichier', 'r') >>> t = ofi.read(7) >>> print t Bonjour >>> t = ofi.read(15) >>> print t , fichier !Quel -----------------------------------------