Introduction à Python - polytechnique€¦ · print "Hello",; print "World" # là, il faut...

Introduction à Python

P. Chassignet

30 janvier 2015

1/57

Plan

baseschaînestableauxnupletsensemblestables

2/57

Plan

1 Python, les bases

2 Chaînes de caractères en Python

3 Tableaux dynamiques en Python

4 Collections non mutables en Python

5 Ensembles en Python

6 Tables en Python

3/57

Python, quelle version ?

Python 3.0 : 2008 ... incompatibilités avec Python 2 (etBioPython ?)

⇒ pour le modal, Python 2.7Python 2.7 : 2010 ... (le dernier de la série) ... 2020 ?

en salles info :/usr/local/anaconda/bin/python 2.7.7mais attention python 2.4.3

convergence 2.7 ≈ 3.1 ... on verra les principales différences

https://docs.python.org/2/ 2.7.9

4/57

Python : langage interprétémais bibliothèques souvent écrites en C

lancer l’interpréteur (python ou ipython ou spyder ou ...) :

Python 2.7.6 ......

>>> a=3>>> a+14>>> type(a)<type ’int’>>>>

→ typage dynamique

→ top-level ≈ while(not end): print(eval(readline()))

→ syntaxe simplifiée

5/57

arithmétique>>> a/21 # mais 1.5 à partir de Python 3.1>>> a//21 # compatible Python 2 et 3>>> a=3.0>>> a/21.5>>> a//21.0>>> -1/2-1 # attention>>> a**29.0>>> 3^21>>> 3^65

6/57

Python : langage à objets>>> a=complex(1,2) pas de new>>> type(a)<type ’complex’>>>> a.real1.0>>> a.imag2.0>>> a.conjugate()(1-2j)>>> 1+2j*a(-3+2j)>>> (1+2j)*a(-3+4j)>>> jNameError: name ’j’ is not defined>>> 1+1j+1j(1+2j)

7/57

la face cachée

>>> dir(a)[... , ’__add__’, ..., ’__mul__’, ..., ’__str__’, ...,

’conjugate’, ’real’, ’imag’]>>> a.conjugate<built-in method conjugate of complex object at 0x1004290d0>>>> a.__add__<method-wrapper ’__add__’ of complex object at 0x1004290d0>>>> dir(3)[... , ’__add__’, ..., ’__mul__’, ...>>> (3).conjugate<built-in method conjugate of int object at 0x100311ad8>

→ toutes les valeurs sont vues comme des objets→ les valeurs sont typées (pas les variables)→ duck-typing avoir la bonne fonction (au bon moment)

8/57

curiosités

>>> (1.0).is_integer()True>>> type((1.0).is_integer())<type ’bool’>

>>> a="toto">>> a’toto’>>> a+3TypeError: cannot concatenate ’str’ and ’int’ objects>>> a+str(3)’toto3’>>> 3*a’totototototo’>>>

9/57

expressions booléennes

False et assimilés :None, zéros, chaînes vides (” ou "") et conteneurs vides

True (assimilés = tout le reste)

opérateurs or et and (évaluation “paresseuse”),x < y <= z préférable à x < y and y <= z,évalue une seule fois y (+ évaluation “paresseuse” de z)

x < y > z peu lisible mais correct

“if ternaire”, exemple : "impair" if n%2 else "pair"

éviter : i or "glop" ? True+1 ?

10/57

égalité

attention== ≡ equals de Java (généralisé)is ≡ == de Java

>>> 3.0//2 == 1True>>> 3.0//2 is 1False>>> 1+1 is 2True>>> 99999+1 is 100000False>>> 99999+1 == 100000True

>>> False==NoneFalse>>> False==0False>>> bool(None)False>>> bool(0)False>>> bool(1)True

11/57

négation

attention : not a == b est compris comme not ( a == b )plus clair : a != b (préférable à a <> b)

opérateur “is not” : a is not b (plus lisible que not (a is b))

>>> not True == FalseTrue>>> True == not FalseSyntaxError: ...>>> True == (not False)True>>> True != FalseTrue

>>> False is not NoneTrue>>> False is (not None)False>>> not NoneTrue

12/57

Attention

En Python 2, False et True ne sont pas des mots réservés,mais des identificateurs de builtins.Python 2 :>>> TrueTrue>>> True = 0>>> True0>>> 1==1.0True>>> (1==1.0) == TrueFalse>>> del(True)>>> TrueTrue

Python 3 :>>> True = 0SyntaxError: ...

13/57

Mise en oeuvre de programmes(par ligne de commande)

éditeur de texte : fichier hello_program.py, 1 ligne:

print ("Hello"+"World")

fenêtre console:% python hello_program.pyHelloWorld%

sous Unix, fichier hello_unix.py, 2 lignes:

#!/usr/bin/python (ou #!/usr/local/bin/python2.7 ...)print ("Hello"+"World")

% chmod +x hello_unix.py% ./hello_unix.pyHelloWorld% python hello_unix.pyHelloWorld%

14/57

print : quelques variantes (spécifique Python 2)

print "Hello"+"World" # concaténation expliciteprint "Hello"+’World’ # ’ ou " mais appariésprint "Hello" "World" # concaténation automatiqueprint "Hello" "World"; # ; facultatif (séparateur)print "Hello","World" # 2 arguments => espaceprint "Hello", # , => pas de retour ligneprint "World" # suite ligne, met l’espaceprint "Hello",; print "World" # là, il faut consulter !

en Python 2, print n’est pas une fonction mais un motréservé (comme return, etc.) pour une instruction spécifique.

Syntaxe compatible : print("Hello"+"World")Python 2 : print expression parenthéséePython 3 : appel de la fonction print

15/57

Programme Python : façon (presque) “pro”

#!/usr/bin/python

def main():print ("Hello from "+__name__)

if __name__ == "__main__":main()

def définit une fonction (attention au :)pas d’accolade, indentation obligatoire

NEWLINE, INDENT et DEDENT font partie de la syntaxe__name__ variable (globale) prédéfinie

if expression :

__name__ == "__main__" vrai ssi on démarre par hello.py6= charger le module hello

16/57

Modulemodule hello → fichier hello.py :

#!/usr/bin/python"cette string constitue la doc du module"def hello():

print ("Hello from "+__name__)def init():

print (__name__+" initialized")init()if __name__ == "__main__":

hello()else:

print (__name__+" loaded")

utilisé seul (mode test) :

% python hello.py ( ou % ./hello.py )__main__ initializedHello from __main__% 17/57

Utilisation d’un module% python>>> import hellohello initializedhello loaded>>> import hello>>> hello.init()hello initialized>>> reload(hello)hello initializedhello loaded>>> from hello import init>>> init()hello initialized>>> from hello import hello>>> hello<function hello at 0x104942938>>>> hello()Hello from hello>>>

18/57

Utilisation d’un module (suite)

>>> from hello import init>>> init()hello initialized>>> import hello as hello>>> hello<module ’hello’ from ’.../hello.py’> ou .pyc>>> hello()TypeError: ’module’ object is not callable

>>> dir(hello)[’__builtins__’, ’__doc__’, ’__file__’, ’__name__’, ’__package__’, ’hello’, ’init’]>>> dir(init)[’__call__’, ...>>> init.__call__()hello initialized>>> réflexivité

19/57

Fonctions : b-a-ba#!/usr/bin/python

"quelques exemples de fonctions" # -> __doc__

def hello(who): # arg. de type quelconqueprint ("Hello "+str(who)) # forcer la conversion

def name(n): # pas de surchargereturn None if not n \

else "everybody" if type(n) is int else n # beurk !

hello(name(""))hello(name(__doc__))hello(name(4))hello(name(hello))

Hello ?Nonequelques exemples defonctionseverybody<function hello ...>

20/57

Python : conditionnellesif expression :elif expression :else :

attention à l’indentationif a>=0:

if a==0:print ("zero")

else: print ("positif")

if a>=0:if a==0:

print ("zero")else: print ("negatif")

danger : mélange de tabulations et d’espaces→ #!/usr/bin/python -t

21/57

boucle whilewhile expression :

corps indenté

instructions classiques : continue et break

forme particulière : while ... else :

a = 999i = 0while i < 10:

if i == a:print ("found")break

i += 1else:

print ("not found")

pas de do ... while

22/57

boucle forfor variable in itérable :

corps indenté

for c in "toto":print (c)

séquences d’entiers : for i in range(...)

>>> range(10)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>>> range(2,4)[2, 3]>>> range(2,8,3)[2, 5]>>> range(5,1,-2)[5, 3]>>> range(5,0,-2)[5, 3, 1]

23/57

boucle for suiteen Python 2, il faut préférer : for i in xrange(...)

expansion : range construit explicitement la séquence (complète)

évaluation “paresseuse” : l’itérateur d’un xrange calcule lesvaleurs à la demande

i = 0while i < 1000000: i+=1 # 0.11 s

for x in range(1000000): continue # 0.09 s

for x in range(1000000): break # 0.03 s

for x in xrange(1000000): continue # 0.05 s

for x in xrange(1000000): break # < 2e-5 s

En Python 3, xrange prend la place de range.24/57

Plan

1 Python, les bases





6 Tables en Python

25/57

Le type chaîne str2 constructions littérales ’...’ ou "..."

variante unicode : u’...’ ou u"..." voir la doc et tester(unicode par défaut en Python 3)

multi-ligne :"""...... suite peut contenir " et ’ ......"""

idem avec ’’’

les chaînes sont non mutables−→ toute modification (potentielle) construit une nouvelle chaîne

opérateurs + et *

+ nombreuses autres méthodes doc + pratique (exercices)utiles car plus rapides que “tout en Python”

prédicats in et not in, voir aussi find26/57

Sélection d’un caractèresélection du ieme élément par [i]

pas de type char comme en Java → chaîne de longueur 1

>>> s = "Python">>> s[0]’P’>>> s[5]’n’>>> s[-1]’n’>>> s[6]IndexError: string index out of range>>> len(s)6>>> s[2] = "X"TypeError: ’str’ object does not support item assignment>>>

27/57

Découpage d’une chaîne (“slicing”)

extraction de la “tranche” entre i et j-1 par [i:j]

>>> s = "Python">>> s[1:3]’yt’>>> s[1:]’ython’>>> s[:3]’Pyt’>>> s[:]’Python’>>> s[-2:]’on’>>> s[:-2]’Pyth’>>>

>>> s[3:2]’’>>> s[-2:-0]’’>>> s[:999]’Python’>>> s[1000:1001]’’

28/57

Chaîne de formatage “à la C”

utilise l’opérateur %

syntaxe 1 : chaîne_format % valeursyntaxe 2 : chaîne_format % valeurs où valeurs = “tuple”

exemples :

>>> from math import pi as PI>>> PI3.141592653589793>>> print(PI)3.14159265359>>> print("%f" % PI)3.141593>>> "%3s = %f ou %.3f ou %.15f" % ("PI", PI, PI, PI)’ PI = 3.141593 ou 3.142 ou 3.141592653589793’

énormément de possibilités voir la doc (déprécié)

29/57

Formatage, Python 3... et Python 2.6...utilise la méthode format

syntaxe : chaîne_format.format(liste_de_paramètres)

exemples :

>>> "{}".format(PI)’3.14159265359’>>> "{} = {}".format("PI", PI)’PI = 3.14159265359’>>> "{1} c’est {0}".format("PI", PI)"3.14159265359 c’est PI">>> "{1} ou {1:.3} ou {1:.15} c’est {0}".format("PI", PI)"3.14159265359 ou 3.14 ou 3.14159265358979 c’est PI">>> "{.__class__} {.__class__}".format(PI, complex(1, 2))"<type ’float’> <type ’complex’>">>> "{0[2]} {0[4]}".format("Python")’t o’

voir la doc30/57

Chaînes, remarques et curiosités

on évite d’écrire for i in range(len(s)) : ... s[i] ...on écrit plutôt for c in s : ... c ...

“generalized slicing” (cf. range) :

>>> s = "Python">>> s[::2]’Pto’>>> s[1::2]’yhn’>>> s[::-1]’nohtyP’>>> s[-1::-2]’nhy’

31/57

Plan

1 Python, les bases





6 Tables en Python

32/57

Le type list de Pythonconstruction littérale entre [ et ] :

>>> maliste = [ 1, "beurk", 2 ]>>> maliste[1, ’beurk’, 2]>>> maliste = [0, maliste]>>> maliste[0, [1, ’beurk’, 2]]

>>> maliste+["suite"][0, [1, ’beurk’, 2], ’suite’]>>> maliste*2[0, [1, ’beurk’, 2], 0, [1, ’beurk’, 2]]>>> maliste[::-1][[1, ’beurk’, 2], 0]>>> maliste ; len(maliste)[0, [1, ’beurk’, 2]]2

33/57

Autres constructions

constructeur list (itérable) :

>>> list("youpi")[’y’, ’o’, ’u’, ’p’, ’i’]

spécifique Python 2 :

>>> range(1,10,2)[1, 3, 5, 7, 9]>>> type(range(1,10,2))<type ’list’>>>> type(xrange(1,10,2))<type ’xrange’>>>> xrange(1,10,2)xrange(1, 11, 2)>>> list(xrange(1,10,2))[1, 3, 5, 7, 9]

34/57

Listes en compréhension

exemples :

>>> [ x*x for x in xrange(1,10,2) ][1, 9, 25, 49, 81]

équivalent à :

result = []for x in xrange(1,10,2):

result.append(x*x)

>>> [ c*2 for c in "youpi" ][::-1] # post-slicing[’ii’, ’pp’, ’uu’, ’oo’, ’yy’]

>>> [ x+y for y in [1,3,5] for x in [0,3,6,9] ][1, 4, 7, 10, 3, 6, 9, 12, 5, 8, 11, 14]

>>> [x+y for y in [1,3,5] for x in [0,3,6,9] if (x+y)%5==0][10, 5]

35/57

Type list ≡ tableaux[i] en O(1) mutables extensibles ≡ ArrayList de Java

>>> maliste = [1,2,3]>>> maliste[2] # en O(1)[3]>>> maliste[1] = 0 # en O(1)>>> maliste[1, 0, 3]>>> maliste.append(2) # ajout de l’argument en O(1) amorti>>> maliste[1, 0, 3, 2]>>> maliste.append([4,5]) # piège courant>>> maliste ?[1, 0, 3, 2, [4, 5]]>>> maliste.extend([6, 7]) # concaténation de 2 listes>>> maliste[1, 0, 3, 2, [4, 5], 6, 7]

36/57

Opérations diversesutilisable comme une pile :>>> maliste = [1,2,3]>>> maliste.append(4) # O(1)>>> maliste[1, 2, 3, 4]>>> maliste.pop() # O(1)4>>> maliste[1, 2, 3]

ne pas utiliser comme une file : opérations en O(n)→ type deque ≡ LinkedList de Java

opérateur in en O(n)>>> maliste = [1,2,3,[4,5]]>>> 4 in malisteFalse>>> 4 in maliste[3]True 37/57

Opérations diverses (suite)ne pas écrire :

for i in xrange(len(maliste)) : ... maliste[i] ...

mais :for e in maliste : ... e ...oufor i, e in enumerate(maliste) : ... i ... e ...

reduce et join :

>>> def mult(x,y) : return x*y>>> reduce(mult, xrange(2,100), 100)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000L

>>> "--".join(list("abc"))’a--b--c’

sort et reverse “en place” + nombreuses méthodes docsorted 7→ nouvelle liste

38/57

Modifications par “slice assignment”>>> maliste = range(8)>>> maliste[0, 1, 2, 3, 4, 3, 4, 5, 6, 7]>>> maliste[3:5] = [] # suppression>>> maliste[0, 1, |2, 5, 6, 7]>>> maliste[2:2] = [8,9] # insertion>>> maliste[0, 1, 8, 9, 2, 1, 8, 9, 2, 5, 6, 7]>>> maliste[1:5] = maliste[:2:-1] # combiné>>> maliste[0, 7, 6, 5, 2, 9, 5, 6, 7]>>> maliste[:0] = maliste [:] ?# insertion entête?>>> maliste[0, 7, 6, 5, 2, 9, 5, 6, 7, 0, 7, 6, 5, 2, 9, 5, 6, 7]>>> maliste[:] = []>>> maliste[]

39/57

Partage

>>> a = [1,2,3]>>> b = a ?# même référence>>> c = a[:] # copie>>> a[1] = 0>>> b ?[1, 0, 3]>>> c ?[1, 2, 3]

>>> a = [[1,2,3]]>>> c = a[:] # copie superficielle>>> a[0][1] = 0>>> c ?[[1, 0, 3]]

40/57

Partage, suite

>>> maliste = [[]] * 3>>> maliste[[], [], []]>>> maliste[0].append("x")>>> maliste[[’x’], [’x’], [’x’]]

>>> maliste = [[]] + [[]]>>> maliste[0].append("x")>>> maliste[[’x’], []]

partage de structures mutables = danger

41/57

Listes infinies>>> maliste = [1,2,3]>>> maliste[:0] = [maliste] ?# rem: sans [ ] OK>>> len(maliste)4>>> maliste[[...], 1, 2, 3]>>> maliste[0][[...], 1, 2, 3]>>> maliste[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][[...], 1, 2, 3]

>>> maliste = [1,2,3]>>> maliste.append(maliste) # rem: avec extend OK>>> maliste[1, 2, 3, [...]]

problèmes, ex. ==RuntimeError: maximum recursion depth exceeded in cmp

42/57

Plan

1 Python, les bases





6 Tables en Python

43/57

Le type tupleconstruction littérale entre ( et ) :>>> montuple = ( 1, "deux", () )>>> montuple(1, ’deux’, ())

cas particulier (x,) vs (x) :>>> (1)1>>> (1,)(1,)

constructions par + et *

constructeur prenant un itérable, ex. :>>> tuple(range(5))(0, 1, 2, 3, 4)

>>> tuple(0 for i in xrange(5))(0, 0, 0, 0, 0)

indexation [i] et “slicing” [i:j:k]44/57

Le type tuple est non mutable

taille fixée à la construction, pas d’affectation montuple[i] = ...

pas de “slice assignment” montuple[i:j] = ...

seules opérations permises nouveaux tuples

ie. comme string

non mutable ⇔ utilisable comme clef d’une table, ...list mutable : __hash__ == None

mais, un tuple d’objets mutables est mutable (au second niveau) :>>> x = []>>> montuple = (x, x, x)>>> x.append(3)>>> montuple([3], [3], [3])

structure “infinie” ? x.append(montuple)

45/57

packing / unpackingon peut omettre les parenthèses si non ambigu :>>> montuple = 1, 2, "trois" # construction implicite>>> montuple(1, 2, ’trois’)>>> 1,(1,)

application au retour de plusieurs valeurs, ex :>>> def f():>>> return 1, 2.0, "trois">>> f()(1, 2.0, ’trois’)

“tuple unpacking” ≡ affectation multiple, ex. :>>> x,y,z = f()>>> y2.0

>>> x,y = y,x>>> a, b, c, d = b, c, d, a

aussi : a,b = [1,2]46/57

Python 2 vs Python 3 : print et tuple

Python 2 :>>> print 1, 21 2>>> print (1, 2)(1, 2)>>> print((1, 2))(1, 2)

Python 3 :>>> print 1, 2SyntaxError: ...>>> print (1, 2)1 2>>> print((1, 2))(1, 2)

compatibilité :

>>> print("{} {}".format(1,2))1 2>>> print("{0[0]} {0[1]}".format((1,2)))1 2

47/57

Sous le capot

for i, v in enumerate(...) : ... i ... v ...

>>> e = enumerate("bio")>>> e<enumerate object at 0x100482eb0>>>> e.next() # Python 2 seulement(0, ’b’)>>> next(e) # compatible Python 2 et 3(1, ’i’)>>> next(e)(2, ’o’)>>> next(e)StopIteration>>> list(e)[]>>> list(enumerate("bio"))[(0, ’b’), (1, ’i’), (2, ’o’)]

48/57

Plan

1 Python, les bases





6 Tables en Python

49/57

Le type set ≡ HashSet de Javaensemble (assure l’unicité), mutable, pas d’ordre (garanti)⇒ pas d’indexation, ni “slicing”hachage ⇒ éléments non mutables

construction littérale entre { et }, constructeur set(itérable)cas particulier set() (car {} est la table vide)

>>> s = set()>>> sset([])>>> len(s)0

>>> s = {"glooop"}>>> sset([’glooop’])>>> len(s)1

>>> s = set("glooop")>>> sset([’o’, ’l’, ’g’, ’p’])>>> len(s)4

>>> set([’o’, ’l’, ’g’, ’p’])set([’g’, ’l’, ’o’, ’p’])

50/57

Opérations sur les ensemblesk : coût d’une comparaison élémentaire

opérations en O(k .1) : elt in s elt not in ss.add(elt) s.remove(elt) KeyError si elt 6∈ s

opérateurs binaires, en O(k .(m + n)) :

construisent un nouvel ensemble :s1 op s2 ou s.opfunc(itérable) ≡ s op set(itérable)s1 | s2 s.union(itérable)s1 & s2 s.intersection(itérable)s1 - s2 s.difference(itérable)s1 ˆ s2 s.symmetric_difference(itérable)

variantes, s.op_update(itérable) qui modifient s :s.update(itérable) implicitement union 6≡ s.add(itérable)s.intersection_update(itérable)s.difference_update(itérable)s.symmetric_difference_update(itérable)

51/57

Opérations sur les ensembles, suiteprédicats de comparaison, en O(k .(m + n)) :s1 op s2 ou s.compfunc(itérable) ≡ s op set(itérable)s1 <= s2 s.issubset(itérable)s1 >= s2 s.issuperset(itérable)s1 < s2s1 > s2s1 == s2s1 != s2

s.isdisjoint(itérable)

s.clear() en O(1)

s.pop() en O(1), utile

s mutable ⇒ non hachable ⇒ s2.add(s) interdit

ensemble non mutable : constructeur frozenset(itérable)

52/57

Plan

1 Python, les bases





6 Tables en Python

53/57

Table = le type dict en Pythontable ≡ ensemble d’associations (clef 7→ valeur), unicité des clefsdict 6= set of tuples (de taille 2)

construction littérale entre { et } et association par des :,subtilités :>>> d = {"a":1,"b":2}>>> d{’a’: 1, ’b’: 2}

>>> s = {"a","b"}>>> sset([’a’, ’b’])

>>> type({})<type ’dict’>

>>> { x:x*x for x in xrange(8) }{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49}

>>> { x*x for x in xrange(8) }set([0, 1, 4, 9, 16, 49, 25, 36])>>> { (x,x*x) for x in xrange(8) } si [x,x*x] ?set([(6, 36), (0, 0), (7, 49), (4, 16), (5, 25), (3, 9), (2, 4), (1, 1)])

54/57

Le constructeur dictdict() 7→ {} : la table vide

argument attendu : un itérable d’itérables de longueur 2, ex. :

dict( ( ["a",1] , ["b",2] , ["c",3] ) )dict( [ ["a",1] , ("b",2) , "c3" ] )

syntaxe explicitée ultérieurement :>>> dict(a=1,b=2,c=3){’a’: 1, ’c’: 3, ’b’: 2}

une fonction très utile :>>> k = "abc" # itérable>>> v = [1,2,3] # même longueur>>> zip(k,v)[(’a’, 1), (’b’, 2), (’c’, 3)]

>>> dict( (x,x*x) for x in xrange(8) ) [x,x*x] OK{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49}

55/57

Opérations sur les tablesk : coût d’une comparaison élémentaire de deux clefs

en O(k .1) ≡ containsKey, get, put et remove de HashMap Java :

>>> d = dict(zip("abcd",(1,2,3,4)))>>> "a" in dTrue>>> 1 in dFalse>>> d["b"]2>>> d["e"]KeyError>>> d["b"] = 5>>> d["e"] = 6>>> del d["c"]>>> d{’a’: 1, ’b’: 5, ’e’: 6, ’d’: 4} voir la doc

56/57

Itérations sur les tables

>>> d = {’a’: 1, ’b’: 5, ’e’: 6, ’d’: 4}>>> d.keys()[’a’, ’b’, ’e’, ’d’]>>> d.values()[1, 5, 6, 4]>>> d.items()[(’a’, 1), (’b’, 5), (’e’, 6), (’d’, 4)]>>> d.items() == zip( d.keys(), d.values() )True

for k in d.keys() peut se raccourcir en for k in d

for v in d.values()

for k,v in d.items()

attention d[k1,k2] ≡ d[(k1,k2)] ie. tuple comme clefd[k1][k2] pour une table de tables

57/57

Introduction à Python - polytechnique€¦ · print "Hello",; print "World" # là, il faut...

Documents

Transcript of Introduction à Python - polytechnique€¦ · print "Hello",; print "World" # là, il faut...