Language python

    Les variables  
   fonction 
   description   
   resultat   
   explication   
type(nom_de_la_variable) La fonction "type" <class 'int'> La fonction renvoie le type de la variable passée en paramètre
a = a + 3
b = a - 2
print("a =", a, "et b =", b)
La fonction "print" ecrit sur l'invite de commande a = 6 et b = 4 La fonction print est dédiée à l'affichage uniquement





    les opérateurs 
< Strictement inférieur à
> Strictement supérieur à
<= Inférieur ou égal à
>= Supérieur ou égal à
== Égal à
!= Différent de

    les mises en formes conditionelles 
   fonction 
   description   
   resultat   
   explication   
>>> a = 5
>>> if a > 0:
... print("a est positif.")
... if a < 0:
... print("a est négatif.")
condition if; si = alors a est positif.
>>> a = 5
>>> if a > 0:
... print("a est supérieur à 0.")
... else:
... print("a est inférieur ou égal à 0.")
condition else si(sinon()) a est supérieur à 0.
>>> if a > 0: # Positif
... print("a est positif.")
... elif a < 0: # Négatif
... print("a est négatif.")
... else: # Nul
print("a est nul.")
condition elif; si(sinon(si(sinon))) a est positif.





    les prédicats 
   fonction 
   description   
   resultat   
   explication   
if a>=2 and a<=8:
print("a est dans l'intervalle.")
else:
print("a n'est pas dans l'intervalle.")
and a est dans l'intervalle.
if a<2 or a>8:
print("a n'est pas dans l'intervalle.")
else:
print("a est dans l'intervalle.")
or a n'est pas dans l'intervalle.
>>> majeur = False
>>> if majeur is not True:
... print("Vous n'êtes pas encore majeur.")
...
Vous n'êtes pas encore majeur.
>>>
not Vous n'êtes pas encore majeur.





    les boucles 
   fonction 
   description   
   resultat   
   explication   
while i < 10: # Tant que i est strictement inférieure à 10
print(i + 1, "*", nb, "=", (i + 1) * nb)
i += 1 # On incrémente i de 1 à chaque tour de boucle
while tan que

chaine = "Bonjour les ZER0S"
for lettre in chaine:
print(lettre)
for pour

i = 1
while i < 20: # Tant que i est inférieure à 20
if i % 3 == 0:
i += 4 # On ajoute 4 à i
print("On incrémente i de 4. i est maintenant égale à", i)
continue # On retourne au while sans exécuter les autres lignes
print("La variable i =", i)
i += 1 # Dans le cas classique on ajoute juste 1 à i
continue

while 1: # 1 est toujours vrai -> boucle infinie
lettre = input("Tapez 'Q' pour quitter : ")
if lettre == "Q":
print("Fin de la boucle")
break
break






   les fonctions 
   fonction 
   description   
   resultat   
   explication   
def table(nb, max):
i = 0
while i < max: # Tant que i est strictement inférieure à la variable max,
print(i + 1, "*", nb, "=", (i + 1) * nb)
i += 1
fonction


l'espace de noms principal

>>>import math as mathematiques
mathematiques.sqrt(25)
ou
>>> from math import fabs
ou
>>> from math import *
import
importe math de la table mathématique




try: # On essaye de convertir l'année en entier
annee = int(annee)
except:
print("Erreur lors de la conversion de l'année.")
try except
méthode est assez grossière. Elle essaye une instruction et intercepte n'importe quelle exception liée à cette instruction
NameError: except "La variable numerateur ou denominateur n'a pas été définie."
TypeError: "La variable numerateur ou denominateur possède un type incompatible avec la division."
ZeroDivisionError: "La variable denominateur est égale à 0."
type_de_l_exception as exception_retournee:


try:
resultat = numerateur / denominateur
except NameError:
print("La variable numerateur ou denominateur n'a pas été définie.")
else:
print("Le résultat obtenu est", resultat)
try except else
La ligne du print ne produira vraisemblablement aucune erreur, inutile de la placer dans le bloc try.
try:
# Test d'instruction(s)
except TypeDInstruction:
# Traitement en cas d'erreur
finally:
# Instruction(s) exécutée(s) qu'il y ait eu des erreurs ou non
try except finaly
finally permet d'exécuter du code après un bloc try, quelle que soit le résultat de l'exécution dudit bloc. La syntaxe est des plus simples :

try pass
permet de laisser une instruction vide
raise ValueError("l'année saisie est négative ou nulle") raise
permet de lever une exeption





   les chaines 
   fonction 
   description   
   resultat   
   explication   
chaine.lower() chaine ex "Bonjour"
# Mettre la chaîne en minuscule
chaine = str()
ou
chaine = ""


# Crée une chaîne vide
chaine= chaine+'nouveau_caractere'

insérer un caractère dans une chaine
titre.upper().center(20)

met en majuscule et centre sur 20 caractère
str() une chaine de caractere

chaine[0] le premier caractère de la chaine

chaine[2:] a partir du second caractere

ma_chaine.split(" ") separe une chaine en liste séparé par des " "






   les Listes 
   fonction 
   description   
   resultat   
   explication   
ma_liste =liste() créer une liste li=['a', 'b', 'mpilgrim', 'z', 'example']
ma_liste = []
len() taille de la liste 5
ma_liste.append([2,'c']) ajoute une liste à la fin de la liste ['a', 'b', 'mpilgrim', 'z', 'example',[2,'c']]
ma_liste.insert(2, 'c') # On insère 'c' à l'indice 2 ['a', 'b', 'mpilgrim', 'z', 'example',2,'c']
ma_liste1.extend(ma_liste2) # On insère ma_liste2 à la fin de ma_liste1

ma_liste1 += ma_liste2

supprimer
on supprimer la variable del ma_variable

on supprimer la troisième valeur de la liste del ma_liste[2]

ma_liste.remove(32) on supprime l'élément 32 de la liste et non l'indice

li[:3] on affiche jusqu'au troisième élément ['a', 'b', 'mpilgrim']
['z', 'example'] on affiche a partir du troisième élément ['z', 'example']
parcourir une liste


for elt in ma_liste:
... print(elt)
# elt va prendre les valeurs successives des éléments de ma_liste


i = 0
>>> while i < len(ma_liste):
... print(ma_liste[i])
... i += 1


for i, elt in enumerate(ma_liste):
... print("À l'indice {} se trouve {}.".format(i, elt))


for elt in enumerate(ma_liste):
... print(elt)







   les Tuples 
   fonction 
   description   
   resultat   
   explication   
un tuple ne peut pas se modifier
tuple_vide = ()

tuple_non_vide = (1,)
tuple_non_vide = 1,


tuple_avec_plusieurs_valeurs = (1, 2, 5)

ma_chaine.split(" ") separe une chaine par les " " qu'elle contient

" ".join(ma_liste) rejoint une liste en une chaine






   les Dictionnaires 
   fonction 
   description   
   resultat   
   explication   
mon_dictionnaire = dict()
ou
mon_dictionnaire = {}
crée un dictionnaire clef : valeur
supprimer
del placard["valeur"] supprime la clef et la valeur

placard.pop("valeur") pop renvoie la valeur de la clef supprimée

fonctions = {}
>>> fonctions["fete"] = fete
# on ne met pas les parenthèses

>>> fonctions["oiseau"] = oiseau
>>> fonctions["oiseau"]
<function oiseau at 0x00BA5198>
>>> fonctions["oiseau"]() # on essaye de l'appeler



parcourir un dictionnaire
parcourt des clefs for cle in mon_dictionnaire:
... print(cle)



for cle in mon_dictionnaire.keys():
... print(cle)


parcour des valeurs for valeur in mon_dictionnaire.values():
... print(valeur)


parcourt des deux for cle, valeur in mon_dictionnaire.items():
... print("La clé {} contient la valeur {}.".format(cle, valeur))


def fonction_inconnue(*en_liste, **en_dictionnaire):







    Les fichiers  
   fonction 
   description   
   resultat   
   explication   
>>> import os
>>> os.chdir("C:/tests python")
>>>
   Changer le répertoire de travail courant  
   resultat   
   travailler avec des chemins absolus ou relatifs   
open("fichier.txt",r/w/a) ouverture en lecture (Read)
ouverture en écriture (Write).
ouverture en écriture en mode ajout (Append).
open("f.txt", "r")
open("f.txt","w")
open("f.txt", "a")
ouverture et lecture du fichier
Le contenu du fichier est écrasé. Si le fichier n'existe pas, il est créé.
On écrit à la fin du fichier sans écraser. Si le fichier n'existe pas, il est créé.
mon_fichier.close() ferme le fichier //
mon_fichier.read() lire le fichier // on utilise la méthode "read" de la classe "TextIoWrapper"
mon_fichier.write() ecrire dans un fichier // La méthode write n'accepte en paramètre que des chaînes de caractères
with ecrire dans un fichier mais en tant que variable with open(mon_fichier, mode_ouverture) as variable: Le mot-clé with, prélude au bloc dans lequel on va manipuler notre fichier.





    Les fonction Pickler  
   importation 
   fonction
   description   
   exemple   
import pickle pickler mon_pickler.dump(score) encoder des objet dans un fichier en binaire with open('donnees', 'wb') as fichier:
... mon_pickler = pickle.Pickler(fichier)
... mon_pickler.dump(score)
Unpickler mon_depickler.load() récupérer des objet dans un fichier en binaire with open('donnees', 'rb') as fichier:
... mon_depickler = pickle.Unpickler(fichier)
... score_recupere = mon_depickler.load()





    Les imports 
   système d'exploitation 
sys
platform affiche la description du système d'exploitation
version affiche la version de python et du compilateur C
hexversion affiche la version exprimée en hexadécimal
copyright affiche le copyright
path renvoie une liste des chemins d'accès de python (/usr/lib/python2.5...)
maxint affiche le format du plus grand nombre entier
exit() pour quitter le programme (ou le shell)
argv est la liste des paramètres passés dans la ligne de commande (argv[0] contient le chemin/nom du script):
stdout permet de rediriger les sorties vers un fichier:
   Time 
time.
sleep(sec) marque une pause du programme pendant sec secondes
time() retourne l'empreinte temporelle du présent sous forme de réel
clock() en Unix, retourne le temps écoulé pour le processus en cours; en Windows, depuis le dernier appel par clock();
ctime(ts) convertit une empreinte temporelle ou à défaut, le temps présent, en chaîne "jour-de-semaine mois jour hh:mm:ss année"
localtime() convertit une empreinte temporelle, ou à défault le moment présent, en tuple «temps local» (année, mois, jour, heures(24), minutes, secondes, jour de la semaine (0=lundi), jour de l'année (1-366), 1 si décalage de l'heure d'été)
time.localtime()[0]time.localtime().tm_yearannée en quatre chiffres
time.localtime()[1]time.localtime().tm_monmois de 1 à 12
time.localtime()[2]time.localtime().tm_mdayjour de 1 à 31
time.localtime()[3]time.localtime().tm_hournombre d'heures de 0 à 23
time.localtime()[4]time.localtime().tm_minnombre de minutes de 0 à 59
time.localtime()[5]time.localtime().tm_secnombre de secondes de 0 à 61
time.localtime()[6]time.localtime().tm_wdayjour de la semaine en chiffre (lundi=0)
time.localtime()[7]time.localtime().tm_ydayjour de l'année de 1 à 366
time.localtime()[8]time.localtime().tm_isdst1 en cas de jour en période d'heure d'été
gmtime() convertit une empreinte temporelle, ou à défault le moment présent, en tuple «temps universel» (année, mois, jour, heures(24), minutes, secondes, jour de la semaine (0=lundi), jour de l'année (1-366), 1 si décalage de l'heure d'été)
asctime() convertit un tuple au format localtime/gmtime en chaîne au format ctime
mktime() convertit un tuple au format localtime/gmtime en empreinte temporelle
strftime(format[,tuple]) retourne une chaîne selon un formatage et un tuple de date (ou à défaut, le temps présent). Le format peut contenir:
%% pour afficher le caractère %
%a pour Mon, Tue, Wed, Thu, Fri, Sat ou Sun
%A pour Monday, Tuesday, Wednesday, Thursday, Friday, Saturday ou Sunday
%b pour Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov ou Dec
%B pour January, February, March, April, May, June, July, Augustus, September, October, November ou December
%c la date et l'heure au format ctime()
%C (non documenté mais valide en python 2.7) 19 ou 20: les deux premiers chiffres de l'année en quatre chiffres
%d le jour du mois, de 01 à 31
%D (non documenté mais valide en python 2.7) voir %x
%H l'heure en chiffres, de 01 à 23
%I l'heure en chiffres, de 01 à 12
%p AM ou PM (sic)
%P am ou pm (sic)
%j le jour de l'année, de 001 à 366
%m le mois en chiffres, de 01 à 12
%M la minute en chiffres, de 00 à 59
%s (non documenté mais valide en python 2.7) empreinte temporelle sous forme de chaîne
%S la seconde, en chiffres, de 00 à 61 (il peut exister des secondes additionnelles en fin de semestre)
%u (non documenté mais valide en python 2.7) le jour de la semaine en chiffre, de 1 (lundi) à 7 (dimanche)
%U la semaine (commençant par un dimanche) en chiffre, de 00 à 53; les jours avant le premier dimanche appartiennent à la semaine 00
%w le jour de la semaine en chiffre, de 0 (dimanche) à 6 (samedi)
%W la semaine (commençant par un lundi) en chiffre, de 00 à 53; les jours avant le premier lundi appartiennent à la semaine 00
%x la date selon la représentation conforme à la locale
%X l'heure selon la représentation conforme à la locale
%y l'année sur deux chiffres, de 00 à 99
%Y l'année sur quatre chiffres, de 1901 à 2038
%z (non documenté mais valide en python 2.7) "0200" pour 2h de décalage horaire.
%Z la zone horaire
strptime(chaine,"format"]) retourne un tuple au format localtime/gmtime basé sur l'interprétation d'une chaîne à travers les éléments de formatage représentés ci-dessus:
timezone contient la valeur du décalage en secondes de l'heure locale avec le temps universel (négatif si 0h local arrive avant 0hUT)
altzone contient la valeur du décalage en secondes de l'heure locale d'été avec le temps universel (négatif si 0h local arrive avant 0hUT)
daylight est égal à 1 si l'heure d'été est à considérer
tzname est un tuple contenant les noms de la zone horaire et de son homologue «heure d'été» en cours
tzset() initialise la zone horaire
   OS 
os.
system() permet une commande de console bash ou DOS: os.system("dir")
popen permet de récupérer la sortie d'une commande-système, à passer comme le nom d'un fichier que l'on ouvre. Dans l'exemple qui suit, acpi -t retourne une chaîne contenant la température du processeur:
uname() renvoie le tuple (os, station, kernel, datekernel, processeur) de la machine exécutant le script.
name Nom du système UN*X: posix ; nt, os2, mac, ce, riscos…
path UN*X: module 'posixpath' from '/usr/lib/python2.5/posixpath.pyc
curdir répertoire actuel. UN*X et Win: . , Mac: :
pardir répertoire parent. UN*X et Win: .. , Mac: ::
sep séparateur de répertoire - UN*X: /, Win: \, Mac: :
altsep UN*X: None
pathsep séparateur de chemins - UN*X: : , Win: ;
defpath retourne ou détermine le chemin des exécutables.
linesep séparateur de paragraphes - UN*X: '\n' (octet 10), Mac: \r (octet 13), Win: \r\n
walk produit un générateur capable de délivrer de façon récursive une série de tuples de trois éléments: le premier est le nom du répertoire, le second la liste de ses sous-répertoires et le troisième la liste de ses fichiers.
Les droits
chown(fichier,usr,grp) fixe le propriétaire et le groupe, exprimés sous forme de nombres
chmod(fichier, mode) fixe les attributs du fichier en trois chiffres octaux. Le premier concerne le propriétaire du fichier, le second un groupe, et le troisième tout le monde. Chaque chiffre a une valeur de 0 à 7, addition de 4 s'il doit être lisible, 2 modifiable et 1 exécutable. 0754 donne tous les droits (4+2+1) au propriétaire, les droits de lecture et d'exécution (4+1) pour le groupe spécifié et uniquement de lecture (4) à tout le monde (rappel: un nombre commençant par un zéro désigne un nombre octal.
access(fichier,mode) retourne TRUE selon les possibilités d'accès à un fichier. mode = os.F_OK pour l'existence, os.R_OK pour la lecture, os.W_OK pour la modification, os.X_OK pour l'exécution du fichier (ou l'ouverture du répertoire).
Édition de fichiers
descr=open(chaine,flags,mode) ouvre un fichier. flags admet les variables suivantes: O_RDONLY (=0), O_WRONLY (=1), O_RDWR (=2), O_CREAT (=64), O_APPEND (=1024), O_BINARY (MS seulement)... on les compose en les additionnant ou avec le "ou" logique "|". mode (facultatif): voir les droits ci-dessus.
read(descr,n) retourne une chaîne de n octets du contenu d'un fichier ouvert en 0 ou 1
write(descr,chaine) écrit une chaîne dans un fichier (en écrasant ou en ajout selon le mode d'ouverture)
close(descr) ferme un fichier
lseek(descr,n,mode) positionne le curseur d'un fichier selon un offset n, selon le mode: os.SEEK_SET (ou 0: à partir du début), os.SEEK_CUR (ou 1, à partir de la position courante), os.SEEK_END (ou 2: à partir de la fin)
remove(fichier) détruit un fichier si droit d'écriture
rename(ancien,nouveau) renomme un fichier ou un répertoire, permet également de déplacer un fichier:
Gestion des répertoires
getcwd() renvoie le répertoire courant connu du système. Si un script est appelé par l'interface graphique (et que le module sys est importé), il est préférable d'utiliser
path.dirname(sys.argv[0]), plus exact
chdir(repertoire) pénètre dans un répertoire existant
chdir("..") (UN*X ou MS) ou chdir("::") (Mac) ou plus universellement chdir(os.pardir) remonte d'un niveau de répertoire
listdir(os.getcwd()) renvoie une liste de tous les objets du répertoire courant
walk(rep) est un générateur renvoyant des tuples ('répertoire',[sous-répertoires],[fichiers])
mkdir(repertoire,mode) crée un répertoire dans le répertoire courant, mode 0777 par défaut
makedirs(chemin,mode) crée tout un chemin dans le répertoire courant, mode 0777 par défaut
rmdir(repertoire) détruit un répertoire (en principe vide) si droit d'écriture
link(fichier, lien) établit un lien matériel, en fait un autre nom pour le même fichier
symlink(fichier, lien) établit un lien symbolique (une redirection vers un fichier)
readlink(lien) retourne le fichier pointé par le lien symbolique (pas un lien matériel, qui est un vrai nom de ficher)
Sous-module os.path Le sous-module os.path est automatiquement chargé avec import os, mais peut être chargé à part avec import os.path
path.getsize(fichier) retourne la taille (entier long)
path.getmtime(fichier) retourne la date de la dernière modification d'un fichier (idem)
path.getatime(fichier) retourne la date du dernier accès à un fichier (en nombre de secondes, voir 1.2 'time'
path.dirname(cheminfichier) retourne la partie de l'adresse à gauche du dernier séparateur de répertoire (/, \, :...)
path.basename(cheminfichier) retourne la partie de l'adresse à droite du dernier séparateur de répertoire
path.split(cheminfichier) retourne un tuple avec les résultats de dirname et basename
path.abspath(fichier) renvoie l'adresse absolue du nom de fichier précisé
path.expanduser(fichier) complète une chaîne commençant par ~/
path.realpath(adresse) élimine les /. et réduit les /rep/..
path.splitext("nom.ext") retourne le tuple ('nom', '.ext')
path.exists(fichier) renvoie True si le fichier existe
path.isfile(fichier) renvoie True si l'objet est un fichier
path.isdir(fichier) renvoie True si l'objet est un répertoire
path.islink(fichier) renvoie True si l'objet est un lien symbolique, un lien matériel renvoie False
path.ismount(chemin) renvoie True si le répertoire est un point de montage
path.isabs(fichier) renvoie True si le nom du fichier comporte le chemin complet
  math. (mathématique) 
math.
math.__doc__ ne nous renseigne que sur sa conformité au C.
math.pi retourne une approximation de la constante pi: 3.1415926535897931
math.degrees() et radians() transforment en degrés ou en radians
math.cos(), math.sin(), math.tan() rapports trigonométriques usuels
math.acos(), math.asin(), math.atan() rapports trigonométriques inverses
math.cosh(), math.sinh(), math.tanh() rapports trigonométriques hyperboliques
math.atan2(y,x) donne l'arctangente de la valeur y/x
math.e retourne une approximation de la constante e: 2.7182818284590451
math.exp() exponentielle à base e
math.log() logarithme naturel (base e)
math.log10() logarithme en base 10
math.pow(x,y) renvoie x à la puissance y
math.sqrt() renvoie la racine carrée
math.hypot(x,y) renvoie l'hypothénuse pour un triangle rectangle de côtés x et y
math.fabs() renvoie la valeur absolue (notation décimale)
math.fmod(x,y) renvoie le reste (notation décimale) de x modulo y
math.modf() renvoie un tuple (partie décimale, partie entière) d'un "réel"
math.ldexp(x,y) renvoie x*y**2, soit x fois y exposant 2
math.frexp() renvoie un tuple (x,y), où x est la fraction du nombre 2**y:
math.ceil() arrondissement par excès d'un nombre "réel" math.floor() arrondissement par défaut d'un nombre "réel"
Le module cmath reprend la plupart des méthodes du module math pour les nombres complexes a+bj :
cmath.pi, cmath.e, cmath.log, cmath.log10, cmath.exp, cmath.sqrt, cmath.cos(), cmath.sin(), cmath.tan(), cmath.acos(), cmath.asin(), cmath.atan(), cmath.cosh(), cmath.sinh(), cmath.tanh(), cmath.acosh(), cmath.asinh(), cmath.atanh()
  random (hasard) 
random.
random.choice(liste) choisit un élément d'une liste: random.choice([1,'a',125,'ouiche'])
random.sample(liste,n) renvoie une liste de n éléments choisis d'une liste
random.shuffle(liste) mélange les éléments d'une liste
random.randint(borne1,borne2) renvoie un entier au hasard entre deux bornes (incluses); préférer le suivant
random.randrange(borne1,borne2,pas) renvoie un entier entre la première borne (incluse) et la deuxième (exclue); le pas est optionnel
random.randrange(borne2) renvoie un entier entre 0 (inclus) et la deuxième un entier (exclu)
random.seed(n) (ré-)initialise le générateur de nombres pseudo-aléatoires
random.random() renvoie un "réel" compris dans l'intervalle [0,1[
random.uniform(r1,r2) renvoie un "réel" compris dans l'intervalle [r1,r2[
Les méthodes suivantes génèrent des nombres pseudo-aléatoires selon des distributions particulières: random.betavariate, random.cunifvariate, random.expovariate, random.gammavariate, random.gauss, random.lognormvariate, random.normalvariate, random.paretovariate, random.vonmisesvariate et random.weibullvariate. Exemple:
print random.gauss(moyenne,ecart_type) sort un "réel" selon les probabilités d'une distribution normale (d'autant plus probable que proche de la moyenne)
random.BPF, random.LOG4, random.NV_MAGICCONST, random.SG_MAGICCONST et random.TWOPI sont les variables disponibles.
 string (chaînes) 
chaine.
Il est possible de ne pas charger le module string, en utilisant la forme variable.methode(). Attention! la chaîne d'origine n'est pas affectée par les modifications, le résultat doit être récupéré par une variable: variable=chaine.methode().Pour une variable dénommée chaine:
upper() convertit en majuscule
lower() convertit en minuscule
capitalize() passe la première lettre de la chaîne en capitale
title() passe la première lettre de chaque mot de la chaîne en capitale
swapcase() transforme minuscules en majuscules et inversement
split() renvoie une liste de tous les mots (séparation: l'espace) d'une chaîne-phrase
split('*') le séparateur peut être une chaîne autre que l'espace
split(' ',n) on peut limiter le nombre de séparations effectuées ' '.join(liste) concaténation d'une liste (ou tuple) de chaînes (le séparateur est ici l'espace)
string.join(liste,'sep') cette forme oblige à charger le module au préalable
startswith('pref') renvoie True si la chaîne commence par le prefixe
endswith('suf') renvoie True si la chaîne termine par le suffixe
strip() ôte les espaces en début et fin de chaîne
lstrip() / chaine.rstrip() ôtent les espaces en début / fin de chaîne
strip('car') ôte les caractères précisés en début et fin de chaîne
ljust(n) remplit d'espaces à gauche pour que la chaîne fasse n caractères
rjust(n) remplit d'espaces à droite pour que la chaîne fasse n caractères
center(n) entoure la chaîne d'espaces pour qu'elle fasse n caractères
zfill(n) ajoute des 0 à gauche pour que la chaîne fasse n caractères
expandtabs(n) transforme les tabulations en n espaces (8 par défaut)
count(ssch,debut,fin) compte les occurrences de la sous-chaîne dans la chaîne, éventuellement entre deux positions
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
find(ssch,debut) renvoie la première position d'une sous-chaine dans une chaine, en définissant les positions de début
find(ssch,debut,fin) idem, définissant en plus la position de fin
rfind(ssch,debut,fin) pareil, mais en commençant par la fin
replace(ssch1,ssch2) remplace si elle existe une sous-chaîne par une autre
replace(ssch1,ssch2,n) idem, en limitant le nombre de remplacement à n
rempl=string.maketrans(ch1,ch2) définit un protocole de remplacements pour translate
translate(rempl[,suppr]) assigne les remplacements définis à une chaîne, avec une éventuelle chaîne des caractères à supprimer (dans ce cas, la suppression a lieu avant le remplacement). Exemple:
 les socket 
accept() : accepte une connexion, retourne un nouveau socket et une adresse client
bind(addr) : associe le socket à une adresse locale
close() : ferme le socket
connect(addr) : connecte le socket à une adresse distante
connect_ex(addr) : connect, retourne un code erreur au lieu d'une exception
dup() : retourne un nouveau objet socket identique à celui en cours
fileno() : retourne une description du fichier
getpeername() : retourne l'adresse distante
getsockname() : retourne l'adresse locale
getsockopt(level, optname[, buflen]) : retourne les options du socket
gettimeout() : retourne le timeout ou none
listen(n) : commence à écouter les connexions entrantes
makefile([mode, [bufsize]]) : retourne un fichier objet pour le socket
recv(buflen[, flags]) : recoit des données
recv_into(buffer[, nbytes[, flags]]) : recoit des données (dans un buffer)
recvfrom(buflen[, flags]) : reçoit des données et l'adresse de l'envoyeur
recvfrom_into(buffer[,nbytes,[,flags]) : reçoit des données et l'adresse de l'envoyeur (dans un buffer)
sendall(data[, flags]) : envoye toutes les données
send(data[, flags]) : envoye des données mais il se peut que pas toutes le soit
sendto(data[, flags], addr) : envoye des données à une adresse donnée
setblocking(0 | 1) : active ou désactive le blocage le flag I/O
setsockopt(level, optname, value) : définit les options du socket
settimeout(None | float) : active ou désactive le timeout
shutdown(how) : fermer les connexions dans un ou les deux sens.
 les listes 
.append(x)Ajoute un élément à la fin de la liste. Équivalent à a[len(a):] = [x].
.extend(iterable) Étend la liste en y ajoutant tous les éléments de l’itérable. Équivalent à a[len(a):] = iterable.
.insert(i, x) Insère un élément à la position indiquée. Le premier argument est la position de l’élément courant avant lequel l’insertion doit s’effectuer, donc a.insert(0, x)
.remove(x)Supprime de la liste le premier élément dont la valeur est égale à x. Une exception est levée s’il n’existe aucun élément avec cette valeur.
.pop([i])Enlève de la liste l’élément situé à la position indiquée et le renvoie en valeur de retour. Si aucune position n’est spécifiée, a.pop() enlève et renvoie le dernier élément de la liste (les crochets autour du i dans la signature de la méthode indiquent que ce paramètre est facultatif
.clear()Supprime tous les éléments de la liste. Équivalent à del a[:].
.index(x[, start[, end]]) Renvoie la position du premier élément de la liste dont la valeur égale x (en commençant par zéro). Une exception ValueError est levée si aucun élément n’est trouvé.
.count(x)Renvoie le nombre d’éléments ayant la valeur x dans la liste.
.sort(key=None, reverse=False) Classe les éléments sur place (les arguments peuvent personnaliser le classement, voir sorted() pour leur explication).
.reverse()Inverse l’ordre des éléments de la liste, sur place.
.copy()Renvoie une copie superficielle de la liste. Équivalent à a[:].
 pentest 
Simple GET request for html source import httplib
connection = httplib.HTTPConnection("xyz_website.com")
connection.request("GET", "/index.html")
response = connection.getresponse()
relevant_payload = response.read()
print(relevant_payload)
Get http response headers import urllib2
url = 'http://xyz_website.com'
headers = { 'User-Agent' : 'Mozilla/5.0 (Windows NT 6.3; WOW64)' }
request = urllib2.Request(url, None, headers)
response = urllib2.urlopen(request)
headers = response.headersprint(headers)
Capture cookies generation/possibly session IDs from anonBrowser import *
#import anonBrowser
ab = anonBrowser(proxies=[],\
user_agents=[('User-agent','My browser')])

for attempt in range(1, 10 ):
ab.anonymize()
print '[*] Fetching page'
response = ab.open('http://google.com')
for cookie in ab.cookie_jar:
print cookieprint(headers)
Testing for anonymous FTP login import ftplib
def testAnonymousLogin(hostname):
try:
ftp = ftplib.FTP(hostname)
ftp.login('anonymous','xyz@gmail.com')
print'\n[*]'+str(hostname) +\
'FTP Anonymous Logon Succeeded.'
ftp.quit()
return True
except Exception, e:
print '\n[-] ' + str(hostname) +\
' FTP Anonymous Logon Failed!'
return False
host = 'xyz_website.com'
testAnonymousLogin(host)
Nmapscan using python import nmap
import optparse
def nmapScan(tgtHost,tgtPort):
nmScan = nmap.PortScanner()
nmScan.scan(tgtHost,tgtPort)
state=nmScan[tgtHost]['tcp'][int(tgtPort)]['state']
print "[*] " + tgtHost + " tcp/"+tgtPort +" "+state
def main():
parser = optparse.OptionParser('usage %prog '+\
'-H <target host> -p <target port>')
parser.add_option('-H', dest='tgtHost', type='string',\
help='specify target host')
parser.add_option('-p', dest='tgtPort', type='string',\
help='specify target port[s] separated by comma')
(options, args) = parser.parse_args()
tgtHost = options.tgtHost
tgtPorts = str(options.tgtPort).split(',')
if (tgtHost == None) | (tgtPorts[0] == None):
print parser.usage
exit(0)
for tgtPort in tgtPorts:
nmapScan(tgtHost, tgtPort)
if __name__ == '__main__':
main()
Site recon –scraping links from target from anonBrowser import *
from BeautifulSoup import BeautifulSoup
import os
import optparse
import re
def printLinks(url):
ab = anonBrowser()
ab.anonymize()
page = ab.open(url)
html = page.read()
try:
print '[+] Printing Links From Regex.'
link_finder = re.compile('href="(.*?)"')
links = link_finder.findall(html)
for link in links:
print link
except:
pass
try:
print '\n[+] Printing Links From BeautifulSoup.'
soup = BeautifulSoup(html)
links = soup.findAll(name='a')
for link in links:
if link.has_key('href'):
print link['href']
except:
pas
def main():
parser = optparse.OptionParser('usage %prog ' +\
'-u <target url including protocol>')
parser.add_option('-u', dest='tgtURL',
type='string',\
help='specify target url')
(options, args) = parser.parse_args()
url = options.tgtURL
if url == None:
print parser.usage
exit(0)
else:
printLinks(url)
if __name__ == '__main__':
main()