copie l'intégralité d'un fichier en transférant des portions de 50 caractères à la fois :

def copieFichier(source, destination):
    "copie intégrale d'un fichier" 
    fs = open(source, 'r')
    fd = open(destination, 'w')
    while 1:
        txt = fs.read(50)
        if txt =="":
            break
        fd.write(txt)
    fs.close()
    fd.close()
    return
-------------------------------------
f = open('Fichiertexte','r')
>>> t = f.readline()
>>> print t
Ceci est la ligne un
>>> print f.readline()
Voici la ligne deux
------------------------------
readline() est une méthode qui renvoie une chaîne de caractères, 
alors que la méthode readlines() renvoie une liste
----------------------------
recopier un fichier texte en omettant toutes les lignes qui commencent par un caractère # :

def filtre(source,destination):
    "recopier un fichier en éliminant les lignes de remarques"
    fs = open(source, 'r')
    fd = open(destination, 'w')
    while 1:
        txt = fs.readline()
        if txt =='':
            break
        if txt[0] != '#':
            fd.write(txt)
    fs.close()
    fd.close()
    return
----------------------------------------
L'argument de la méthode write() doit être une chaîne de caractères.
nous ne pouvons donc enregistrer d'autres types de valeurs qu'en les transformant d'abord en chaînes de caractères.

Nous pouvons réaliser cela à l'aide de la fonction intégrée str() :
>>> x = 52
>>> f.write(str(x))
----------------------------------
import os, os.path
numbytes = 0
for root, dirs, files in os.walk(top):
    for name in files:
        path = os.path.join(root, name)
        numbytes += os.path.getsize(path)
print "%s contains %s bytes" % (top, numbytes)

#-----------------------------
import os, os.path
saved_size, saved_name = -1, ''
for root, dirs, files in os.walk(top):
    for name in files:
        path = os.path.join(root, name)
        size = os.path.getsize(path)
        if size > saved_size:
            saved_size = size
            saved_name = path
print "Biggest file %s in %s is %s bytes long" % (
    saved_name, top, saved_size)

#-----------------------------
Removing a Directory and Its Contents
# DeleteDir - remove whole directory trees like rm -r

import shutil
shutil.rmtree(path)
----------------------------
Splitting a Filename into Its Component Parts

import os

base = os.path.basename(path)
dirname = os.path.dirname(path)
dirname, filename = os.path.split(path)
base, ext = os.path.splitext(filename)
---------------------------------------------
path = '/usr/lib/libc.a'
filename = os.path.basename(path)
dirname = os.path.dirname(path)

print "dir is %s, file is %s" % (dirname, filename)
# dir is /usr/lib, file is libc.a
------------------------------
effacer fichiers d'un directory:

import os, os.path
path = raw_input("folder to clean:")
os.chdir(path)
files = os.listdir(path)
print files
for file in files:
    if os.path.isfile(file):
       os.remove(file)
       print "erased", file
    elif os.path.isdir(file):
       os.removedirs(file)
       print "removed", file
    else:
      pass
---------------------------------
replace : changer chaine par une autre 
dans un fichier texte

import string, tempfile, os
# Ask User for Information
filename = raw_input("Name of file: ")
find = raw_input("Search for: ")
replace = raw_input("Replace with: ")
#Open user file, read it, and close it
file = open(filename, "r")
text = file.readlines()
file.close()
#Edit information from user file
newtext =[]
for item in text:
    line = string.replace(item, find, replace)
    newtext.append(line)
#Create new file
newname=filename+".new"
newfile = open(newname, "w")
newfile.writelines(newtext)
newfile.close()
#Change names of files
oldfile=filename+".bak"
os.rename(filename, oldfile)
os.rename(newname, filename)
os.remove(oldfile)
--------------------------------------
nettoyer le systeme des fichiers pyc,pyo : utiliser os.path.walk pour naviguer dans les dossiers  
et os.path.splitext permet de recuperer l'extention du fichier :

# -*- coding: utf8 -*-
import time
import os.path as dir
import os

print "Nettoyage du systeme des fichiers compilé/optimisé python"
basedir = dir.join("""C:\DEV""")
print basedir
print "Demarrage dans 2 secondes"
print "Appuyez sur <CTRL>+<C> pour annuler l'operation"
time.sleep(2)
print "Début du nettoyage ...."

def Clean(args, dirname, filenames):
    print "Scan du dossier:%s" % dirname
    for filename in filenames:
        Fichier = dir.join(dirname,filename)
        if(dir.splitext(Fichier)[1] == ".pyc" or dir.splitext(Fichier)[1] == ".pyo"):
            print "Suppression de %s" %Fichier
            os.remove(Fichier)
dir.walk(basedir, Clean, None )
print "Nettoyage Terminé !"
-------------------------------------
Parcourir les lignes d'un fichier :

for ligne in lignes:
   print ligne.strip()
pour parcourir toutes les lignes de façon efficace (rapidement, 
et sans charger tout le fichier en mémoire…) :

for ligne in fic:
   print ligne.strip()
----------------------------
Ecriture :
ne pas oublier la marque de fin de ligne!
Linux = '\n'
Win = '\r\n'
Mac = '\r'
ou bien :

import os
fin_ligne = os.linesep
#ecriture ligne par ligne:
fic.write('ma ligne' + fin_ligne)
#ecriture de plusieurs lignes d'un coup:

lignes = []
lignes.append('ligne 0' + fin_ligne)

lignes.append('ligne N-1' + fin_ligne)
fic.writelines(lignes)
----------------------------
selection de colonnes

nb_entete = 2
separateur = ';'
num_colonne = 2
fic = open("toto.txt", 'r')
for saute in range(nb_entete):
fic.readline() 
for ligne in fic:
ligne = ligne.strip()
colonnes = ligne.split(separateur)
print colonnes[num_colonne]
fic.close()
-----------------------------------
glob.glob

nomrep = 'py_jyp_ex_06_dir'
scanfic = '*.dat'
l_index = 5
ficlist = glob.glob(path.join(nomrep, scanfic))
nb_ren = 0
for f in ficlist:
f_rep, f_nom = path.split(f)
re_res = re.search('[0-9]+', f_nom)
if not re_res:
print '** %s ne contient pas d\'entier!' % (f_nom,)
continue
-------------------------------
Appel de programmes externes

os.system(commande)
Lancement d'une commande et récupération du 
statut de l'opération (mais pas du résultat de la 
commande!)
code_retour = os.system('date')

commands.getoutput(commande)
Lancement d'une commande et récupération de 
la sortie de la commande (dans une chaîne)

commands.getoutput('wc -l /.cshrc*')
' 124 /home/users/jypeter/.cshrc\n 123 
/home/users/jypeter/.cshrc\n 247 total'
Pour des raisons de performance, toujours 
utiliser une fonction standard ou disponible 
dans un module plutôt qu'un appel 
système! ?
ex : mkdir, rm, os.mkdirs, os.remove
------------------------------
Détermination du répertoire courant
os.getcwd()

Changement de répertoire/dossier
os.chdir(rep)

Création d'un répertoire/dossier (et des répertoires intermédiaires!)
os.makedirs(rep, 0755)

Effacement d'un fichier/répertoire
os.remove(fic)
os.rmdir(rep)
os.removedirs(rep)
(Efface les répertoires 
intermédiaires…)

Renommage/Déplacement
shutil.move(fic_rep, destination)

Copie
shutil.copy('toto.txt', 'c:/users/jean/titi.txt')
-----------------------------------
copier un fichier

import shutil

shutil.copy('cmd_ftp.txt', 'c:/users/jean/Desktop/toto.txt')
-----------------------------
renommer - deplacer - changer directory

shutil.move('c:/users/jean/titi.txt', 'c:/users/jean/Desktop/titi.txt')
------------------------------------
Contenu d'un répertoire/dossier

os.listdir(rep)
glob.glob(rep_pattern)
glob.glob('*.py')

Taille d'un fichier
path.getsize(fic)
----------------------------
Détermination de la date

t = time.localtime(time.time())
time.strftime('%d/%m/%Y', t)
#'08/11/2005'
---------------------------------
dictionnaire - count

import os
import re
import string

out3 = open("count-cnt-get.txt","w")
s = 'a;jfkd;aflhakfhaskfjalghlakfhfnkjafyksd'
cnt = {}
for c in s:
   cnt[c] = cnt.get(c,0) + 1
   print cnt
#   print type(cnt)    #type: dict

machaine = str(cnt).strip('{}').replace('\'', '')
for i in string.split(machaine,','):        
   print i
   out3.writelines((i,'\n'))
----------------------------------
Counting frequency in a list 

>>> alist = [ '1', '1', '2', '1', '3', '4', '1', '3']
>>> [(a, alist.count(a)) for a in set(alist)]
[('1', 4), ('3', 2), ('2', 1), ('4', 1)]
>>> sorted(_, key=lambda x: -x[1])  # rank them
[('1', 4), ('3', 2), ('2', 1), ('4', 1)]
----------------------------
import os

os.system('python count-cnt-get.py')
--------------------------
envoyer fichier par ftp

import ftplib
s = ftplib.FTP('myserver.com','login','password') # Connect

f = open('todo.txt','rb')                # file to send
s.storbinary('STOR todo.txt', f)         # Send the file

f.close()                                # Close file and FTP
s.quit()
-----------------------------
join - split

import ftplib
import string

file = open("commandes-ftp.txt","w")

#liste des commandes ftp:
liste = dir(ftplib.FTP)

chaine = string.join(liste,',')
print chaine

for i in string.split(chaine,','):
   print i
   file.writelines(i+'\n')

#résultat : 1 commande par ligne

#effet inverse:
#z = string.split(chaine, ',')
#print z
----------------------------
ftp - retr - serveur -> local

import ftplib,sys

file = open("titi.txt","wb")

ftp = ftplib.FTP('ftp.liens-utiles.eu')
ftp.login('user','password')

#printer le directory distant:
print ftp.retrlines('LIST')
#ftp.cwd('pub/python')

print ftp.retrbinary('retr titi.txt', file.write)
ftp.quit()
-------------------------------
ftp - stor - local -> serveur

import ftplib
s = ftplib.FTP('liens-utiles.eu','user','password') # Connect

f = open('toto.txt','rb')                # file to send
s.storbinary('STOR toto.txt', f)         # Send the file

f.close()                                # Close file and FTP
s.quit()
---------------------------------------
commander ouverture d'un notepad

import os

os.spawnl(os.P_WAIT, "c:/windows/notepad.exe")
-------------------------------
imprimer la source d'une page html

import urllib
import urllib2

the_url = 'http://www.liens-utiles.eu'
req = urllib2.Request(the_url)
handle = urllib2.urlopen(req)
html = handle.read()

print html
-------------------------------
Récapitulatif sur les variables:

Type	                Symbole	                  Modifiable ?	          Accès

Chaîne de caractère	" " / ' ' / """ """	  Non	                  Séquentiel
Listes	                [ ]	                  Oui	                  Séquentiel
Tuples	                ( )	                  Non	                  Séquentiel
Dictionnaires	        { }	                  Oui	                  Par clé
----------------------------------
'tapadaca'.replace('a','i',2)
'tipidaca'      #remplacé que 2 fois
--------------------------
compter le nombre d'occurences d'une sous-chaine dans un string 

'tapadaca'.count('a')
4
---------------------------
vous souhaitez gérer un compteur avec nombre de chiffres constants 
(donc en affichant des "0" à gauche des nombres ne possédant pas assez de chiffres). 
Pour cela, il vous suffit d'utiliser la fonction s.zfill( width) 
qui rajoute des caractères '0' devant la chaînes de caractères 
jusqu'à ce que celle-ci ait une longueur égale à width

Vous pouvez également utiliser la fonction s.rjust( width[, fillchar]) 
qui permet d'ajuster une chaîne de caractères en ajoutant à gauche 
le nombre de caractères fillchar nécessaires pour que la nouvelle 
chaîne de caractères est une longueur égale à width

for i in range(1000): print str(i).zfill(3)
for i in range(1000): print str(i).rjust(3, '0')
---------------------------------
Vous avez plusieurs manières de supprimer une occurence dans une liste:

La première façon est d'utiliser la méthode l.remove(x) qui supprime 
la première occurence x dans la liste l 

l = [1,5,4,1,23,1,2,1]
try:
    while True: l.remove(1)
except: pass
print l  ## [5,4,23,2]
---------------------------------
s = s.replace('n','')
------------------------
old = "open sesame nnnn"
# replace first occurance of 'n'
new = old.replace('n', '', 1)
print new  # 'ope sesame nnnn'
---------------------------
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
------------------------------
noms = ['lord', 'gfx', 'rico', 'bgw']
liste = [nom[0].upper() + nom[1:] for nom in noms]
-------------------------
envoyer mail

import smtplib
from email.MIMEText import MIMEText

def sendTextMail(to,sujet,text,server="localhost"):
    fro = "Expediteur <toto@adresse.fr>"
    mail = MIMEText(text)
    mail['From'] = fro
    mail['Subject'] =sujet
    mail['To'] = to
    smtp = smtplib.SMTP(server)
    smtp.sendmail(fro, [to], mail.as_string())
    smtp.close()
        
sendTextMail("toto@adresse.fr","hello","cheers")
-----------------------------
import smtplib
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
import os

def sendMail(to, subject, text, files=[],server="localhost"):
    assert type(to)==list
    assert type(files)==list
    fro = "Expediteur <expediteur@mail.com>"

    msg = MIMEMultipart()
    msg['From'] = fro
    msg['To'] = COMMASPACE.join(to)
    msg['Date'] = formatdate(localtime=True)
    msg['Subject'] = subject

    msg.attach( MIMEText(text) )

    for file in files:
        part = MIMEBase('application', "octet-stream")
        part.set_payload( open(file,"rb").read() )
        Encoders.encode_base64(part)
        part.add_header('Content-Disposition', 'attachment; filename="%s"'
                       % os.path.basename(file))
        msg.attach(part)

    smtp = smtplib.SMTP(server)
    smtp.sendmail(fro, to, msg.as_string() )
    smtp.close()


sendMail(
        ["toto@adresse.fr"],
        "hello","cheers",
#        ["photo.jpg","memo.sxw"]
        ["photo1.jpg","photo2.jpg"]
    )
---------------------------------