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.

Google Online Preview   Download