Survivre avec Python

SYNTAXE ?

#! /usr/bin/python
# -*- coding: iso-8859-1 -*-
# commentaires
r"chaine ..." , pas de substitution (raw)
"""chaine de plusieurs lignes""" prends en comptes les \r \n
l'indentation (espace et tabulation) indique le niveau d'imbrication
opérateurs booléens : and or not

VARIABLES

i = 2 Affectation
i,j=2,3 Affectation multiple
i Accès à la variable i
print i Affiche la variable i
print i, Affiche la variable i et ne retourne pas à la ligne
sys.argv[0]nom de la commande
_Dernière valeur stockée en mode interactif
raw_input(chaine) Affiche chaine, puis lit sur l'entrée standard

Complexes

complex(reel,img)Création d'un complexe
c = 4+5jCréation d'un complexe
c.realPartie réelle d'un complexe
c.imagPartie imaginaire d'un complexe
abs(c)Valeur absolue d'un complexe

chaîne de caractères

"yo" + "upi" Concatène deux chaines
"bla" * 3 Répète la chaine
chaine[0] 1er caractère de la chaine, accès en lecture uniquement
chaine[deb_inclus:fin_exclus] Intervalle de caractères
chaine[:fin_exclus] Intervalle de caractères à partir du début de la chaine
chaine[deb_inclus:] Intervalle de caractères jusqu'à la fin de la chaine
len(chaine) Taille de la chaine
u"chaine unicode" Crée une chaine unicode

liste

maliste = [] Crée une liste vide
maliste = ['spam', 100, 1234] Crée une liste
maliste[2] += 2 ajoute 2 au 3eme élément de la liste
maliste[0:2] = ['un','deux'] remplace les 2 premiers éléments de la liste
maliste[0:2] = [] retire les deux 1er éléments de la liste
maliste[1:1] = [5] Insère à l'indice 1
maliste[1:1] = [5,7] Insère à l'indice 1
len(maliste) Longueur d'une liste
q=[2,3]
p=[1,q,5]		 q est une sous-liste de p
p[1][0] Accès au 1er élément de la sous-liste,
2eme élément de la liste
p[1].append(4) Ajoute un élément en fin de liste (dans la sous-liste q)
for indice,valeur in enumerate(liste): Enumère les couples indice/valeur
for elmA,elmB in zip(listeA,listeB): Enumère simultanément les valeurs de deux listes
pile = [1,2,3]
pile.append(4)
pile.pop()
ajoute 4
retourne 4 et le retire de la liste
file = [1,2,3]
pile.append(4)
pile.pop(0)
ajoute 4
retourne 1 et le retire de la liste

opérations :
append, extend, insert, remove, pop, index, count, sort, reverse
(cf help(list) dans l'interprêteur)

filter, map (cf §BOUCLE."list comprehensions")
reduce
del

tuple

vide = () tuple vide
singleton = "unique", tuple avec un élément
singleton = ("unique",) tuple avec un élément
montuple = 1, 2, 3, 4, 5 tuple
sontuple = (1, 2, 3, 4, 5) tuple
supertuble = montuple, (6, 7, 8) tuple et sous-tuple
ta, tb, tc, td, te = montuple unpacker un tuple (! autant de variables que dans le tuple)

ensemble (set)

chaque élément est unique dans l'ensemble
liste = [1, 2, 3, 4, 5]
ens1 = set(liste)
ens2 = set([1, 2, 3, 4, 5])
ens3 = set(["alix", "bonnie", "carole"]) 		création d'ensemble
ens4 = set['abracadabra'] création d'un ensemble de lettres
"alix" in ens4 test d'appartenance
ensembl1 - ensembl2 ensemble d'éléments contenu dans ensembl1 mais pas dans ensembl2
ensembl1 | ensembl2 union
ensembl1 & ensembl2 intersection
ensembl1 ^ ensembl2 union exclusive

table (dictionary)


matable = {'alix':90, 'bonnie':95} Crée une table
matable["carole"] = 85 Ajoute ou modife un couple clé/valeur
matable["carole"] Accès à une valeur
del matable["carole"] Suppression d'une entrée
matable.keys() Obtenir la liste de clé de la table
matable.has_key("alix") Vérifie la présence d'une clé
dict([ ("cle", "valeur"), ("cle2", "valeur2") ]) Construit une table à partir d'une liste
for cle,val in matable.iteritems(): Enumère les couples clé/valeur

Opérateurs booléens

(True, False)
not and or
a < b == c (a < b) and (b == c)

Comparaison

tuple1 < tuple2 comparaison entre élément de même indice
tant que les éléments sont égaux
en commençant par l'indice le plus faible
liste1 < liste2 idem
'ABC' < 'C' < 'Pascal' < 'Python'

TEST

avec IF

if condition :
< indentation > instr
<   espaces   > instr
elif condition :
< tabulations > instr
else :
< tabulations > instr
a = input("note : ")
if a < 5:
  print "python c'est cool"
elif a < 10:
  print "python c'est trop cool"
else:
  print "python c'est trop trop cool"

elif et else sont optionnels

BOUCLE

avec liste

for var in chaine_ou_liste :
  instr
  [continue]
  [break]
else:
  instr_apres_boucle_terminee_sans_break

avec itération "simulée avec range()"

range(5) [0, 1, 2, 3, 4]
range(2, 5) [2, 3, 4]
range(0, 10, 3) [0, 3, 6, 9]
range(-10, -100, -30) [-10, -40, -70]

Recherche de nombre premier
for n in range(2, 10):
  for x in range(2, n):
    if n % x == 0:
      print n, 'equals', x, '*', n/x
      break
  else:
    # loop fell through without finding a factor
    print n, 'is a prime number'
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

"List comprehensions"

permet de créer une liste
L = map(calcul, uneliste) L = []
for i in uneliste:
  L.append(calcul(i))
L = [ calcul(i) for i in uneliste ]
L = filter(teste, uneliste) L = []
for i in uneliste:
  if teste(i) :
    L.append(i)
L = [ i for i in uneliste if teste(i) ]
L = map(calcul, filter(teste, uneliste)) L = []
for i in uneliste:
  if teste(i) :
    L.append(calcul(i))
L = [ calcul(i) for i in uneliste if teste(i) ]
L = []
for i in uneliste:
  for j in ztliste :
    L.append(calcul(i,j))
L = [ calcul(i,j) for i in uneliste for j in ztliste ]

reversed ? sorted ?

WHILE

while condition :
  instr
  [break]
else:
  instr_apres_boucle_terminee_sans_break
# Fibonacci
a, b = 0, 1
while b < 10 :
    print b
    a, b = b, a+b
 		# Attente active
while True :
  pass

FONCTION

avec ou sans paramètres, avec des valeurs par défaut, en indiquant le nom du paramètre formel

DéclarationAppel
def mafonction ( [arg1 [ = def1] [ , arg2 [ = def2] [ ... ]] ) :
  instr
  [return 0]
mafonction(arg_eff1, arg_eff2)
def mafonction(arg1, arg2) :
  print arg1
  print arg2
  return 0
mafonction("trop", "bien")
mafonction(arg2="bien",arg1="trop")
def mafonction(arg1, arg2=classe) :
  print arg1
  print arg2
  return 0
mafonction("trop", "bien")
mafonction("trop")

Copie de fonction : f = mafonction

Fonctionnement étrange pour les paramètres par défaut avec des objets 'mutable' (liste, table, objet ...)
cf tutorial officiel (§4.7.1 default argument values, important warning)

conversion d'arguments (tuple, liste)

Exemple de fonction avec un nombre de paramètres variables,
en utilisant un tuple (args)
def fprintf(file, format, *args):
  file.write(format % args)

Conversion de liste en tuple
liste_param = [2,6]
range(*liste_param)

avec des tables

un *tuple peut précéder une **table
DéclarationAppel
def mafonction ([ *tuple , ] **table ) :
  instr
  [return 0]
mafonction(tuple, table)
def mafonction(*tuple, **table):
  for elm in tuple: print elm
  for cle in table.keys(): print cle, ':', table[cle]
mafonction(tuple, **table)
mafonction('1', '2', '3', **table)
mafonction(tuple, a='arbre', b='bouleau', c='chêne')
mafonction('1', '2', '3', a='arbre', b='bouleau', c='chêne')

avec une forme fonctionnelle

DéclarationAppel
f = lambda x,y : x+2*y f(2,3)
def ajoute(n):
  return lambda x:x+n
ajoute_5 = ajoute(5) 		ajoute_5(3)

Référence

Python tutorial

home up envoyer un mail

Debian Get FireFox Valid HTML 4.01! Valid CSS!