Mémento Python 3 - LIMSI
?2012-2017 - Laurent Pointal M¨¦mento v2.0.7
Licence Creative Commons Paternit¨¦ 4
entier,flottant,bool¨¦en,cha?ne,octets
int
float
bool
str
783
0 -192
M¨¦mento Python 3
Types de base
0b010 0o642 0xF3
binaire
z¨¦ro
octal
hexa
9.23 0.0
-1.7e-6
-6
¡Á10
True False
"Un\nDeux"
Cha?ne multiligne :
retour ¨¤ la ligne ¨¦chapp¨¦
"""X\tY\tZ
1\t2\t3"""
'L\'?me'
' ¨¦chapp¨¦
tabulation ¨¦chapp¨¦e
bytes b"toto\xfe\775"
Identificateurs
pour noms de variables,
fonctions, modules, classes¡
a toto x7 y_max BigOne
8y and for
Variables & affectation
=
? affectation ? association d'un nom ¨¤ une valeur
1) ¨¦valuation de la valeur de l'expression de droite
2) affectation dans l'ordre avec les noms de gauche
x=1.2+8+sin(y)
a=b=c=0 affectation ¨¤ la m¨ºme valeur
y,z,r=9.2,-7.6,0 affectations multiples
a,b=b,a ¨¦change de valeurs
a,*b=seq d¨¦paquetage de s¨¦quence en
*a,b=seq ¨¦l¨¦ment et liste
et
x+=3
incr¨¦mentation ? x=x+3
*=
x-=2
/=
d¨¦cr¨¦mentation ? x=x-2
%=
x=None valeur constante ? non d¨¦fini ?
del x
¡
suppression du nom x
index n¨¦gatif
index positif
-5
0
Valeurs non modifiables (immutables) ? expression juste avec des virgules ¡útuple
str bytes (s¨¦quences ordonn¨¦es de caract¨¨res / d'octets)
? conteneurs cl¨¦s, sans ordre a priori, acc¨¨s par cl¨¦ rapide, chaque cl¨¦ unique
dictionnaire
dict {"cl¨¦":"valeur"}
(couples cl¨¦/valeur)
set
dict(a=3,b=4,k="v")
{1:"un",3:"trois",2:"deux",3.14:"¦Ð"}
{"cl¨¦1","cl¨¦2"}
{1,9,3,0}
? cl¨¦s=valeurs hachables (types base, immutables¡)
0
-5
-4
1
1
-4
{}
set()
frozenset ensemble immutable
vide
pour les listes, tuples, cha?nes de caract¨¨res, bytes¡
Indexation conteneurs s¨¦quences
-3
-2
-1
Nombre d'¨¦l¨¦ments
Acc¨¨s individuel aux ¨¦l¨¦ments par lst[index]
2
3
4
lst[0]¡ú10
? le premier
len(lst)¡ú5
lst=[10, 20, 30, 40, 50]
tranche positive
tranche n¨¦gative
""
b""
Conversions
int("15") ¡ú 15
type(expression)
int("3f",16) ¡ú 63
sp¨¦cification de la base du nombre entier en 2nd param¨¨tre
int(15.56) ¡ú 15
troncature de la partie d¨¦cimale
float("-11.24e8") ¡ú -1124000000.0
round(15.56,1)¡ú 15.6
arrondi ¨¤ 1 d¨¦cimale (0 d¨¦cimale ¡ú nb entier)
bool(x) False pour x z¨¦ro, x conteneur vide, x None ou False ; True pour autres x
str(x)¡ú "¡" cha?ne de repr¨¦sentation de x pour l'affichage (cf. Formatage au verso)
chr(64)¡ú'@' ord('@')¡ú64
code ? caract¨¨re
repr(x)¡ú "¡" cha?ne de repr¨¦sentation litt¨¦rale de x
bytes([72,9,64]) ¡ú b'H\t@'
list("abc") ¡ú ['a','b','c']
dict([(3,"trois"),(1,"un")]) ¡ú {1:'un',3:'trois'}
set(["un","deux"]) ¡ú {'un','deux'}
str de jointure et s¨¦quence de str ¡ú str assembl¨¦e
':'.join(['toto','12','pswd']) ¡ú 'toto:12:pswd'
str d¨¦coup¨¦e sur les blancs ¡ú list de str
"des mots espac¨¦s".split() ¡ú ['des','mots','espac¨¦s']
str d¨¦coup¨¦e sur str s¨¦parateur ¡ú list de str
"1,4,8,2".split(",") ¡ú ['1','4','8','2']
s¨¦quence d'un type ¡ú list d'un autre type (par liste en compr¨¦hension)
[int(x) for x in ('1','29','-3')] ¡ú [1,29,-3]
a¡zA¡Z_ suivi de a¡zA¡Z_0¡9
? accents possibles mais ¨¤ ¨¦viter
? mots cl¨¦s du langage interdits
? distinction casse min/MAJ
?
?
? s¨¦quences ordonn¨¦es, acc¨¨s par index rapide, valeurs r¨¦p¨¦tables Types conteneurs
["x",11,8.9]
["mot"]
[]
list [1,5,9]
11,"y",7.4
("mot",)
()
tuple (1,5,9)
ensemble
? immutables
hexad¨¦cimal octal
Derni¨¨re version sur :
2
-3
3
-2
4
-1
5
? index ¨¤ partir de 0
(de 0 ¨¤ 4 ici)
Acc¨¨s ¨¤ des sous-s¨¦quences par lst[tranche d¨¦but:tranche fin:pas]
lst[-1]¡ú50
lst[1]¡ú20
lst[-2]¡ú40
? le dernier
Sur les s¨¦quences modifiables (list),
suppression avec del lst[3] et modification
par affectation lst[4]=25
lst[:3]¡ú[10,20,30]
lst[:-1]¡ú[10,20,30,40] lst[::-1]¡ú[50,40,30,20,10] lst[1:3]¡ú[20,30]
lst[1:-1]¡ú[20,30,40]
lst[-3:-1]¡ú[30,40] lst[3:]¡ú[40,50]
lst[::-2]¡ú[50,30,10]
lst[::2]¡ú[10,30,50]
lst[:]¡ú[10,20,30,40,50] copie superficielle de la s¨¦quence
Indication de tranche manquante ¡ú ¨¤ partir du d¨¦but / jusqu'¨¤ la fin.
Sur les s¨¦quences modifiables (list), suppression avec del lst[3:5] et modification par affectation lst[1:4]=[15,25]
m¨ºme temps
a or b
ou logique l'un ou l'autre
ou les deux
? pi¨¨ge : and et or retournent la valeur de
a ou de b (selon l'¨¦valuation au plus court).
? s'assurer que a et b sont bool¨¦ens.
not a
non logique
True
False
constantes Vrai/Faux
? nombres flottants¡ valeurs approch¨¦es !
Op¨¦rateurs : + - * / // % **
¡Á ¡Â
ab
Priorit¨¦s (¡)
¡Â enti¨¨re reste ¡Â
@ ¡ú ¡Á matricielle python3.5+numpy
(1+5.3)*2¡ú12.6
abs(-3.2)¡ú3.2
round(3.57,1)¡ú3.6
pow(4,3)¡ú64.0
? priorit¨¦s usuelles
Blocs d'instructions
instruction parente:
bloc d'instructions 1¡
?
instruction parente:
bloc d'instructions 2¡
?
indentation !
Logique bool¨¦enne
Comparateurs: < > = == !=
(r¨¦sultats bool¨¦ens)
¡Ü ¡Ý = ¡Ù
les deux en
et
logique
a and b
instruction suivante apr¨¨s bloc 1
? r¨¦gler l'¨¦diteur pour ins¨¦rer 4 espaces ¨¤
la place d'une tabulation d'indentation.
Maths
from math import sin,pi¡
angles en radians
sin(pi/4)¡ú0.707¡
cos(2*pi/3)¡ú-0.4999¡
sqrt(81)¡ú9.0
¡Ì
log(e**2)¡ú2.0
ceil(12.5)¡ú13
floor(12.5)¡ú12
modules math, statistics, random,
decimal, fractions, numpy, etc.
Imports modules/noms
from monmod import nom1,nom2 as fct
module truc?fichier truc.py
¡úacc¨¨s direct aux noms, renommage avec as
import monmod ¡úacc¨¨s via monmod.nom1 ¡
? modules et packages cherch¨¦s dans le python path (cf. sys.path)
un bloc d'instructions ex¨¦cut¨¦, Instruction conditionnelle
uniquement si sa condition est vraie
if condition logique:
bloc d'instructions
oui
?
non
oui
?
non
Combinable avec des sinon si, sinon si... et
un seul sinon final. Seul le bloc de la
if age65:
etat="Retrait¨¦"
? avec une variable x:
else:
if bool(x)==True: ? if x:
etat="Actif"
if bool(x)==False: ? if not x:
Signalisation :
raise ExcClass(¡)
Traitement :
try:
bloc traitement normal
except ExcClass as e:
bloc traitement erreur
Exceptions sur erreurs
traitement
raise X()
normal
traitement
erreur
traitement
raise
erreur
? bloc finally pour traitements
finaux dans tous les cas.
while condition logique:
bloc d'instructions
oui
?
non
s = 0 initialisations avant la boucle
i = 1 condition avec au moins une valeur variable (ici i)
Instruction boucle it¨¦rative
bloc d'instructions ex¨¦cut¨¦ pour
chaque ¨¦l¨¦ment d'un conteneur ou d'un it¨¦rateur
Contr?le de boucle
break
sortie imm¨¦diate
continue it¨¦ration suivante
while i 15:
valeurs perdues.
perdu.append(val)
lst[idx] = 15
print("modif:",lst,"-modif:",perdu)
? bonne habitude : ne pas modifier la variable de boucle
? attention aux boucles sans fin !
Instruction boucle conditionnelle
bloc d'instructions ex¨¦cut¨¦
tant que la condition est vraie
Op¨¦rations g¨¦n¨¦riques sur conteneurs Parcours simultan¨¦ index et valeurs de la s¨¦quence :
len(c)¡ú nb d'¨¦l¨¦ments
min(c) max(c) sum(c)
Note: Pour dictionnaires et ensembles, for idx,val in enumerate(lst):
sorted(c)¡ú list copie tri¨¦e
ces op¨¦rations travaillent sur les cl¨¦s.
S¨¦quences d'entiers
val in c ¡ú bool¨¦en, op¨¦rateur in de test de pr¨¦sence (not in d'absence)
range([d¨¦but,] fin [,pas])
enumerate(c)¡ú it¨¦rateur sur (index, valeur)
? d¨¦but d¨¦faut 0, fin non compris dans la s¨¦quence, pas sign¨¦ et d¨¦faut 1
zip(c1,c2¡)¡ú it¨¦rateur sur tuples contenant les ¨¦l¨¦ments de m¨ºme index des ci
range(5)¡ú 0 1 2 3 4
range(2,12,3)¡ú 2 5 8 11
all(c)¡ú True si tout ¨¦l¨¦ment de c ¨¦valu¨¦ vrai, sinon False
range(3,8)¡ú 3 4 5 6 7
range(20,5,-5)¡ú 20 15 10
any(c)¡ú True si au moins un ¨¦l¨¦ment de c ¨¦valu¨¦ vrai, sinon False
range(len(s¨¦q))¡ú s¨¦quence des index des valeurs dans s¨¦q
c.clear()supprime le contenu des dictionnaires, ensembles, listes
? range fournit une s¨¦quence immutable d'entiers construits au besoin
Op¨¦rations sur listes
lst.append(val)
ajout d'un ¨¦l¨¦ment ¨¤ la fin
lst.extend(seq)
ajout d'une s¨¦quence d'¨¦l¨¦ments ¨¤ la fin
lst.insert(idx,val)
insertion d'un ¨¦l¨¦ment ¨¤ une position
lst.remove(val)
suppression du premier ¨¦l¨¦ment de valeur val
lst.pop([idx])¡úvaleur
supp. & retourne l'item d'index idx (d¨¦faut le dernier)
lst.sort() lst.reverse() tri / inversion de la liste sur place
? modification de la liste originale
Op¨¦rations sur dictionnaires
d[cl¨¦]=valeur
del d[cl¨¦]
d[cl¨¦]¡ú valeur
d.update(d2) mise ¨¤ jour/ajout
des couples
d.keys()
vues it¨¦rables sur les
d.values() ¡ú
d.items() cl¨¦s / valeurs / couples
d.pop(cl¨¦[,d¨¦faut])¡ú valeur
d.popitem()¡ú (cl¨¦,valeur)
d.get(cl¨¦[,d¨¦faut])¡ú valeur
d.setdefault(cl¨¦[,d¨¦faut])¡úvaleur
Op¨¦rations sur ensembles
Op¨¦rateurs :
| ¡ú union (caract¨¨re barre verticale)
& ¡ú intersection
- ^ ¡ú diff¨¦rence/diff. sym¨¦trique
< >= ¡ú relations d'inclusion
Les op¨¦rateurs existent aussi sous forme
de m¨¦thodes.
s.update(s2) s.copy()
s.add(cl¨¦) s.remove(cl¨¦)
s.discard(cl¨¦) s.pop()
stockage de donn¨¦es sur disque, et relecture
Fichiers
f = open("fic.txt","w",encoding="utf8")
variable
fichier pour
les op¨¦rations
nom du fichier
sur le disque
(+chemin¡)
mode d'ouverture
encodage des
? 'r' lecture (read)
caract¨¨res pour les
? 'w' ¨¦criture (write)
fichiers textes:
utf8 ascii
? 'a' ajout (append)
cf modules os, os.path et pathlib ? ¡'+' 'x' 'b' 't' latin1 ¡
en ¨¦criture
en lecture
? lit cha?ne vide si fin de fichier
f.write("coucou")
f.read([n])
¡ú caract¨¨res suivants
si n non sp¨¦cifi¨¦, lit jusqu'¨¤ la fin !
f.writelines(list de lignes) f.readlines([n]) ¡ú list lignes suivantes
f.readline()
¡ú ligne suivante
? par d¨¦faut mode texte t (lit/¨¦crit str), mode binaire b
possible (lit/¨¦crit bytes). Convertir de/vers le type d¨¦sir¨¦ !
f.close()
? ne pas oublier de refermer le fichier apr¨¨s son utilisation !
f.flush() ¨¦criture du cache
f.truncate([taille]) retaillage
lecture/¨¦criture progressent s¨¦quentiellement dans le fichier, modifiable avec :
f.tell()¡úposition
f.seek(position[,origine])
Tr¨¨s courant : ouverture en bloc gard¨¦ (fermeture
with open(¡) as f:
automatique) et boucle de lecture des lignes d'un
for ligne in f :
fichier texte.
# traitement de ligne
nom de la fonction (identificateur)
param¨¨tres nomm¨¦s
D¨¦finition de fonction
def fct(x,y,z):
fct
"""documentation"""
# bloc instructions, calcul de res, etc.
valeur r¨¦sultat de l'appel, si pas de r¨¦sultat
return res
calcul¨¦ ¨¤ retourner : return None
? les param¨¨tres et toutes les
variables de ce bloc n'existent que dans le bloc et pendant l'appel ¨¤ la
fonction (penser ¡°bo?te noire¡±)
Avanc¨¦ : def fct(x,y,z,*args,a=3,b=5,**kwargs):
*args nb variables d'arguments positionnels (¡útuple), valeurs par
d¨¦faut, **kwargs nb variable d'arguments nomm¨¦s (¡údict)
r = fct(3,i+2,2*i)
stockage/utilisation
de la valeur de retour
une valeur d'argument
par param¨¨tre
? c'est l'utilisation du nom
de la fonction avec les
parenth¨¨ses qui fait l'appel
Avanc¨¦:
*s¨¦quence
**dict
Appel de fonction
fct()
fct
Op¨¦rations sur cha?nes
s.startswith(prefix[,d¨¦but[,fin]])
s.endswith(suffix[,d¨¦but[,fin]]) s.strip([caract¨¨res])
s.count(sub[,d¨¦but[,fin]]) s.partition(sep)¡ú (avant,sep,apr¨¨s)
s.index(sub[,d¨¦but[,fin]]) s.find(sub[,d¨¦but[,fin]])
s.is¡() tests sur les cat¨¦gories de caract¨¨res (ex. s.isalpha())
s.upper()
s.lower()
s.title()
s.swapcase()
s.casefold()
s.capitalize()
s.center([larg,rempl])
s.ljust([larg,rempl]) s.rjust([larg,rempl]) s.zfill([larg])
s.encode(codage)
s.split([sep]) s.join(s¨¦q)
directives de formatage
valeurs ¨¤ formater
"modele{} {} {}".format(x,y,r)
"{s¨¦lection:formatage!conversion}"
? S¨¦lection :
2
nom
0.nom
4[cl¨¦]
0[2]
? Formatage :
car-rempl. alignement signe
Exemples
Sp¨¦cifique aux conteneurs de s¨¦quences ordonn¨¦es (listes, tuples, cha?nes, bytes¡)
reversed(c)¡ú it¨¦rateur invers¨¦ c*5¡ú duplication c+c2¡ú concat¨¦nation
c.index(val)¡ú position
c.count(val)¡ú nb d'occurences
import copy
copy.copy(c)¡ú copie superficielle du conteneur
copy.deepcopy(c)¡ú copie en profondeur du conteneur
Formatage
str
"{:+2.3f}".format(45.72793)
¡ú'+45.728'
"{1:>10s}".format(8,"toto")
¡ú'
toto'
"{x!r}".format(x="L'ame")
¡ú'"L\'ame"'
larg.mini.pr¨¦cision~larg.max
type
^=
+ - espace 0 au d¨¦but pour remplissage avec des 0
entiers : b binaire, c caract¨¨re, d d¨¦cimal (d¨¦faut), o octal, x ou X hexa¡
flottant : e ou E exponentielle, f ou F point fixe, g ou G appropri¨¦ (d¨¦faut),
cha?ne : s ¡
% pourcentage
? Conversion : s (texte lisible) ou r (repr¨¦sentation litt¨¦rale)
................
................
In order to avoid copyright disputes, this page is only a partial summary.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.