python_refcard

Python3 Cheat sheet
Une feuille recapitulant les notions de Python3 vues par les
étudiants ayant suivi le module jgb53d ("Bases de données et
programmation").
Variables
Types
-int : un entier (e.g 1, -3, 19,...)
-float : un réel (0.23, -0.15, 5e-06)
-str : une chaîne de caractères.
-bool : un booléen (True, False).
-NoneType : pour une variable dont la valeur est None (i.e.
non définie).
- type(objet) renvoie le type de l’objet (str, int,...).
Notation
- On préfèrera l’utilisation de "-" pour les variables dont le
nom est long (e.g une_jolie_variable).
- Attention aux noms réservés en python (and, if, class, def,...).
Opérations sur les chaînes de caractères
Notez que la transformation d’une chaîne nécessite d’utiliser
l’opérateur d’assignation (e.g. a = a.lower()).
a=" He llo "
b=" wo rld \ n"
v = "" # une cha î ne de c ara ct è re s vi de .
type(a) # un objet str
help(str )# a ide sur l ’ o bj et s tr
c=a+" " +b# concaténation →" Hell o w orld "
c [0] # ’ H ’
c [0 ]*3 # ’multiplication’ →’HHH ’
len (b) # long ueu r →6
b = b . capi tali ze # ’ w orl d \ n ’ →’ Wo rl d \ n ’
b = b . rstr ip ("\n")# en l è ve le d er ni er c ara ct è r e
b = b . lstr ip ("W")# e nl è ve le p rem ie r c a rac t è re
a . coun t ("l")# n om br e d ’ o cc ur re nc es →2
a. en dsw ith ( "o")# True
a. st art swit h ("H")# True
a . find ( "o")# pos iti on du pr emi er ’o ’ →4
a . inde x ("o")# po sit ion du p rem ie r ’o ’ →4
a. lo wer () # m inus cul e (’ l owe rcas e ’)
a . up pe r () # maj usc ule ( ’ up per cas e ’)
a.replace("l","g")# ’ H egg o ’
conv = str . m ake tra ns ( "He"," B u " )
a . tr ans la te ( co nv ) # Bullo
a . spli t ("e")#→[ ’H ’ , ’ llo ’]
"3". zf ill (4) #→’0003 ’
Opérations sur les numériques
a=3.2
b =4
c=a+b# addition
d=a*b # multiplication
e=a/b# division
import math # O p é r at ion s m at h é m at iq ue s a va nc é es
ma th . sqr t (2) # r aci ne car r ée ( sq uar e ro ot )
a **2 # p uis san ce
ma th . flo or (3 .14 ) # pa rt ie en ti è re →3
ma th . cei l (3 .14 ) # p ar tie e nti è r e p ar e xc è s →4
ma th . cei l (3 .14 ) # f onc tio ns tri gon om é tr iqu es (...)
ma th . log 10 (1 00) # lo ga rit hm e ( b ase 10)
Opérations logiques
a == b # T rue si a et b so nt é ga ux .
a != b # T rue si a et b sont di ff é ren ts .
a > b # Tr ue si a es t s up é ri eu re à b .
a < b # Tr ue si a es t i nf é ri eu re à b .
a >= b # Tr ue si a est sup é ri eur e ou é ga le à b .
a <= b # Tr ue si a est inf é ri eur e ou é ga le à b .
c <= a <= b # True si a est sup é ri eure ou é gale à c
et i nf é ri eur e ou é ga le à b .
c < a < b # True si a est str icte men t sup é rieu re à
c e t i nf é ri eur e à b .
a < d and b > c # ET logique.
a < d or b > c # OU logique.
not a == b # N é gat ion l ogi que .
Conversions
int (3.0) # c onv e rsi on en en ti er
str (30) # c onv ersi on en cha î ne
fl oat (" 30 .2 ")# c on ve rs io n en r é el
bool(0) # c on ve rs io n e n bo ol é en
Listes
Une liste permet de stocker un ensemble d’objets. On peut
accéder aux éléments de la liste en désignant des positions
(indices) dans celle-ci.
l = list() # d é clare une liste vide
l = [] # d é clare une liste vide
l = ["a","b","a " ,"c"]# une l iste à 4 é l é men ts
len (l) # t ail le de la liste →3
l . coun t ("a")# c o mpt er le nb . d ’ o c cu rr en ce s d e " a "
l.append("e")# a jou te u n é lé m ent ( à la f in )
l . i nse rt ( p , "t")# aj oute "t" avant la pos iti on p
e = l . po p (p ) # d é lè t e / re nv oi e l ’ é lé m ent en p os . p
l . inde x ("c")# la pos iti on de l’élé ment "c "
l.reverse() # i n ve rse l ’ o rd re
l . sort () # t ri a lph an um é ri que
l + ["j","k"]# concaténation
l += "e" # aj ou te à la fin
l*3# multiplication
"a" in l# test la pr é sence de "a " dans l
Dictionnaires
Dans un dictionnaire on stocke des objets (valeurs) accessibles
par une clef. On n’aura pas besoin de connaitre la position de
l’objet mais le nom de sa clef pour y accéder.
prix = dict() # d é cla re un d ict io nna ir e v ide
pri x = {} # d é clar e uun di ctio nn air e vid e
# i ni tia li sati on av ec pl usi eu rs é lé me nts
pri x = { " po mme " :3,"cerise": 8}
# ajo ute une val eur (8) pour la cle f ’ poi re ’
prix[’ p oi re ’ ] = 4
prix[’ p oi re ’ ]# val eur pour la clef ’ po ir e ’
del prix[’ po ire ’]# d é l é te l e c oup le ’ p oi re ’/4
prix.keys() # l ’ e ns em bl e d es c lef s
len ( p rix . ke ys () ) # le nombr e de clefs
pr ix . va lue s () # l ’ e ns em bl e de s v al eu rs
len ( p rix . v alu es () ) # le nomb re de va le urs
Boucles
Boucles for
Il est souvent nécessaire de réaliser des itérations (boucles).
Elles sont très utilisées notamment pour parcourir des listes ou
les clefs/valeurs d’un dictionnaire. Les deux types de boucles
que l’on rencontre le plus fréquemment sont les boucles for et
les boucles while. Attention ! En python, l’indentation fait
partie de la syntaxe. En particulier, le domaine d’application
d’une boucle est défini par les lignes qui sont en retrait par
rapport à l’instruction initiale.
# ## Ef fe ct ue r u ne op é r a tio n n fo is
n = 100
for iin ra nge ( n ) : # 0. .9 9
pr int (" je l e f ai s " )
# Pa rco uri r des lis te s
chroms = [" Ch r1 " ," Chr 2 "," C hr7 " ]
for cin chroms:
pr int (c)
# pa rco uri r des lis te s
# c con tie nt la v ale ur en p osi tio n p
for p , c in e nume rat e (chroms):
pr int ( p , c )
# P ar cou ri r d es cha î n es de ca rac t è res
dna = ’ATGCTCGCTCGCTCGATGAAAATGTG’
# On p asse en revue les nucl é ot ides
# con ten us dans la s é que nce
for nu c in dn a :
pr int (" La s é q uen ce c on ti en t " + nu c )
# Pa rco uri r un Di ctio nnai re
login2passwd = {" Al ain " :"abc123"," Joh n ":"qwerty"}
# Af fic her les clefs
for key in login2passwd:
pr int ( ke y )
# Af fic her les clefs et val eur s
# Il f aut ut ili ser la m é thode item ()
for key , val ue in l og in 2 pa ss wd . it em s () :
pr int ( va lue , ke y )
Break et continue
Comme dans beaucoup d’autres langages, le mot clef break,
permet de ’casser’ une boucle, de l’arrêter avant qu’elle
n’arrive à sa fin. Le mot clef continue permet de passer
directement à la prochaine itération, sans effectuer la suite des
instructions de cette itération.
## Ex em ple 1
# L a so rti e e st :
#01234
for iin range (10):
if i==5:
break
pr int (i)
## Ex em ple 2
# La s ortie est

# 1 2 8 9 10
i = 0
while i < 10:
i += 1
if 2 < i < 8:
co nti nue
pr int (i)
Boucle while
# Tan t que la con dit i on est vraie
# a lor s le j eu d ’ in s tr uc ti on s e st ex é c ut é
a = 0
while a < 10:
pr int (a)
a +=1
Structures conditionelles
Une structure conditionnelle permet de tester si une condition
est vraie ou fausse. Ces structures conditionnelles évaluent, de
manière générale, une expression logique. Dans la structure
if...else classique, on exécutera un certain nombre
d’instructions si la condition est vraie, et un autre jeu
d’intructions si celle-ci s’avère fausse.
# Une s tru ctu re if s imp le :
if a > b :
instructions
# St r uct ure if .. e lse
if a > b :
instructions
else:
instructions
# la str uct ure if ... elif . .. else :
if a > b:
instructions
elif c > d :
instructions
else:
instructions
# S tr uc tu r es i f .. . e lse i mb riq u é es
if a > b:
instructions
if c > d:
instructions
else:
in stru cti on ( s)
Entrées / sorties
La fonction input
# ca pt ure d ’une entr é e u tili sat e ur
a = i npu t ("Entrez un nombre: ")
a = i nt (a ) # i npu t r en voi e un ob jet str .
La fonction open
# ouve rtu r e d ’un fichi er en le ctu re .
# Pa rco urs puis f erm e tur e
f = open(" f ile . t xt " ,"r")
for line in f :
instructions
f. cl ose ()
# ou ver tur e d ’un f ic hie r en é cri tur e
f = open(" f ile . t xt " ,"w")
f. wr ite ( "blabla")
pr int ("bidule",file=f)
f. cl ose ()
r Ouvre un fichier en lecture. Défaut.
w Ouvre un fichier en écriture.
a Ajouter des lignes dans un fichier. Le pointeur est
placé à la fin du fichier s’il existe, sinon un nouveau
fichier est créé.
r+ ou w+ ou a+ Ouvre le fichier en lecture et en écriture.
Définition de fonctions
Définition et appel
La création d’une fonction se fait grâce au mot-clé def.
Celui-ci est suivi du nom de la fonction. On décrit ensuite les
opérations qui doivent être effectuées par la fonction en
marquant l’indentation. Le programme python peut alors
exécuter, ou appeler cette fonction. On peut alors demander à
la fonction de renvoyer son résultat avec le mot clé return.
# Ex em ple de f onc tio n sim pl e
def e x po ne nt ia l ( x , y ) :
return x ** y
resu lt = e xpo nen tial (2 ,4)
Passage d’arguments
# E xe mp le d ’ a pp el
def printBreakfast(a, b):
pr int (" I ’ ll ha ve " ,a," to as t ( s) an d " ,
b , " eg g (s )" )
printBreakfast(2, 3)
p ri n tB r ea k fa s t ( a =2 , b =3)
# A rgum ent s a vec va leu rs par d é fau lt
def p ri nt Br ea kf as t ( a=2 , b = 3) :
pr int (" I ’ ll ha ve " ,a," to as t ( s) an d " ,
b , " eg g (s )" )
printBreakfast()
Aide
Pour obtenir de l’aide sur un objet, utilisez la fonction help.
help(str )
# / s tar t p our r ech er ch er l a c ha î ne d e ca ra ct è res
’ st ar t ’
# n ( n ext ) po ur la pr oc hai ne o ccu re nce
# p ( p re vio us ) p ou r l ’ o c cu re nc e pr é c é de nte
# q p our qu it ter
Divers
Caractères accentués
Par défaut, Python ne supporte pas les caractères accentués.
Si l’on souhaite en utiliser il convient d’indiquer en première
ligne du fichier :
# -* - c odi ng : utf 8 -* -
Lancer ipython3 dans un terminal
Dans un terminal taper :
ipython3
Executer le code Python
Pour executer le code python présent dans un fichier via un
terminal, plusieurs solutions sont possibles.
# Solution 1
python3 leFichier.py
Dans la deuxième solution, indiquer en première ligne du
fichier que le code doit être executer par python en utilisant un
’shebang’ (# !).
# !/ us r / bin / env py th on
...
...
Ensuite executez ce code après avoir rendu le fichier
executable.
chmod u+x leFichier.py
./leFichier.py
Remerciements
Ce travail a été réalisé avec L
A
T
E
Xd’après un patron proposé
par Winston Chang.
Ce travail est sous licence Creative Commons
Attribution-NonCommercial-ShareAlike 3.0 Unported License.
http ://creativecommons.org/licenses/by-nc-sa/3.0/