ISUP-python Listes et compréhensions · 2017. 9. 26. · Python sont des séquences, ce point de vue alternatif permet d’exploiter les expressions de compréhensions. Considérons

ISUP-pythonListesetcompréhensions

chapitre9

Lescompréhensions(listes,chapitre9)

Constructiondelistes

>>> [k for k in range(1, 6)][1, 2, 3, 4, 5]

L’expression ci-dessous signifie presque littéralement :

construit la liste des k pour k dans l’intervalle [1; 6[

Si on veut une liste composée des entiers successifs dans l’intervalle clos [3; 9], on pourra écrire :

>>> [k for k in range(3, 10)][3, 4, 5, 6, 7, 8, 9]

9.2.2 Syntaxe et principe d’interprétation

Plus généralement, la syntaxe d’une compréhension simple est la suivante :

[ <elem> for <var> in <seq> ]

où :— <var> est une variable de compréhension— <elem> est une expression appliquée aux valeurs successives de la variable <var>— <seq> est une expression retournant une séquence, notamment : range, string ou list.

Principe d’interprétation :L’expression de compréhension ci-dessus signifie :

Construit la liste des <elem> pour <var> dans la séquence <seq>

Plus précisément, la liste construite est composée de la façon suivante :— le premier élément est la valeur de l’expression <elem> dans laquelle :

— la variable <var> a pour valeur le premier élément de <seq>— le second élément est la valeur de l’expression <elem> dans laquelle :

— la variable <var> a pour valeur le deuxième élément de <seq>— . . .— le dernier élément est la valeur de l’expression <elem> dans laquelle :

— la variable <var> a pour valeur le dernier élément de <seq>

Remarque : pour ne pas compromettre la concision des compréhensions, le type de la variablede compréhension <var> n’est pas déclaré. Ce type peut cependant être déduit du type de laséquence <seq>.Dans l’exemple :

169


>>> [k for k in range(1, 6)][1, 2, 3, 4, 5]

L’expression ci-dessous signifie presque littéralement :

construit la liste des k pour k dans l’intervalle [1; 6[

Si on veut une liste composée des entiers successifs dans l’intervalle clos [3; 9], on pourra écrire :

>>> [k for k in range(3, 10)][3, 4, 5, 6, 7, 8, 9]

9.2.2 Syntaxe et principe d’interprétation

Plus généralement, la syntaxe d’une compréhension simple est la suivante :

[ <elem> for <var> in <seq> ]

où :— <var> est une variable de compréhension— <elem> est une expression appliquée aux valeurs successives de la variable <var>— <seq> est une expression retournant une séquence, notamment : range, string ou list.

Principe d’interprétation :L’expression de compréhension ci-dessus signifie :

Construit la liste des <elem> pour <var> dans la séquence <seq>

Plus précisément, la liste construite est composée de la façon suivante :— le premier élément est la valeur de l’expression <elem> dans laquelle :

— la variable <var> a pour valeur le premier élément de <seq>— le second élément est la valeur de l’expression <elem> dans laquelle :

— la variable <var> a pour valeur le deuxième élément de <seq>— . . .— le dernier élément est la valeur de l’expression <elem> dans laquelle :

— la variable <var> a pour valeur le dernier élément de <seq>

Remarque : pour ne pas compromettre la concision des compréhensions, le type de la variablede compréhension <var> n’est pas déclaré. Ce type peut cependant être déduit du type de laséquence <seq>.Dans l’exemple :

169


Constructiondelistesàpartirdechainesdecaractères


Fonctioncalculantlalistedescarrés

multiples(k, n) retourne la liste des k*j pour j dans l’intervalle [1;n+1[

Exercice : ré-écrire des version avec while et for de la fonction multiples.

9.2.4 Constructions à partir de chaînes de caractères

En plus des intervalles d’entiers, nous avons également vu les chaînes de caractères qui sontégalement des séquences. Il est donc possible de construire des listes par compréhension à partirdes chaînes.

Par exemple :

>>> [c for c in �Bonjour Madame�][�B�, �o�, �n�, �j�, �o�, �u�, �r�, � �, �M�, �a�, �d�, �a�, �m�, �e�]

De façon littérale, l’expression de compréhension ci-dessus :

construit la liste des c pour c un caractère dans la chaîne �Bonjour Madame�

Exercice : définir avec une compréhension la fonction liste_caracteres qui à partir d’unechaîne de caractères s retourne la liste des caractères de s.

9.3 Schéma de transformation

Le schéma de transformation, ou schéma map, consiste comme nous l’avons vu à appliquer unefonction unaire à chacun des éléments d’une liste pour reconstruire une liste transformée.

9.3.1 Construction à partir d’une liste

Nous l’avons déjà vu dans de nombreux exemples, les listes résultats des transformationssont systématiquement reconstruites. On peut donc interpréter une transformation de façonalternative comme la construction d’une liste transformée à partir d’une liste. Puisque les listesPython sont des séquences, ce point de vue alternatif permet d’exploiter les expressions decompréhensions.

Considérons comme premier exemple la liste des n premiers carrés.

def carre(n):"""int -> intretourne le carré de l�entier n."""return n * n

def liste_carres_for(L):""" list[int] -> list[int]retourne la liste des carrés des éléments de la liste L."""

# LR : list[int]LR = [] # liste résultat

171







Par exemple :













171# e: intfor e in L: # élément courant

LR.append(carre(e))

return LR

# Jeu de testsassert liste_carres_for([1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]assert liste_carres_for([10, 100, 1000]) == [100, 10000, 1000000]assert liste_carres_for([]) == []

Remarque : la fonction carre n’est pas très intéressante, mais sa définition permet de mieuxexpliciter le schéma de transformation.

Utilisons une expression de compréhension correspondant au premier cas de test.

>>> [carre(k) for k in [1, 2, 3, 4, 5]][1, 4, 9, 16, 25]

Littéralement, on a écrit en Python :

la liste des carrés de k pour k dans la liste [1, 2, 3, 4, 5]

En lisant la description ci-dessus, on devrait bien s’attendre au résultat suivant :

[1, 4, 9, 16, 25]

On peut donc redéfinir la fonction liste_carres avec une compréhension.

def liste_carres(L):"""list[int] -> list[int]..."""

return [carre(k) for k in L]

# Jeu de testsassert liste_carres([1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]assert liste_carres([10, 100, 1000]) == [100, 10000, 1000000]assert liste_carres([]) == []

Prenons un second exemple illustratif issu du cours sur les listes : la construction de la liste deslongueurs de chaînes.

def liste_longueurs_for(L):""" list[str] -> list[int]

retourne la liste des longueurs des chaînes de L."""

172

Etavecunecompréhension?







Par exemple :













171# e: intfor e in L: # élément courant

LR.append(carre(e))

return LR

# Jeu de testsassert liste_carres_for([1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]assert liste_carres_for([10, 100, 1000]) == [100, 10000, 1000000]assert liste_carres_for([]) == []

Remarque : la fonction carre n’est pas très intéressante, mais sa définition permet de mieuxexpliciter le schéma de transformation.

Utilisons une expression de compréhension correspondant au premier cas de test.

>>> [carre(k) for k in [1, 2, 3, 4, 5]][1, 4, 9, 16, 25]

Littéralement, on a écrit en Python :

la liste des carrés de k pour k dans la liste [1, 2, 3, 4, 5]

En lisant la description ci-dessus, on devrait bien s’attendre au résultat suivant :

[1, 4, 9, 16, 25]

On peut donc redéfinir la fonction liste_carres avec une compréhension.

def liste_carres(L):"""list[int] -> list[int]..."""

return [carre(k) for k in L]

# Jeu de testsassert liste_carres([1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]assert liste_carres([10, 100, 1000]) == [100, 10000, 1000000]assert liste_carres([]) == []

Prenons un second exemple illustratif issu du cours sur les listes : la construction de la liste deslongueurs de chaînes.

def liste_longueurs_for(L):""" list[str] -> list[int]

retourne la liste des longueurs des chaînes de L."""

172


Fonctioncalculantlalistedeslongueurs?


Fonctioncalculantlalistedeslongueurs?


# s : strfor s in L:

LR.append(len(s))

return LR

# Jeu de testsassert liste_longueurs_for([�un�, �deux�, �trois�, �quatre�, �cinq�]) \

== [2, 4, 5, 6, 4]assert liste_longueurs_for([��, �.�, �..�, �...�]) == [0, 1, 2, 3]assert liste_longueurs_for([]) == []

Ici on a une transformation d’une liste de chaînes de caractères en une liste d’entiers. Cettetransformation peut être réécrite avec une compréhension.

def liste_longueurs(L):""" list[string] -> list[int]..."""return [len(s) for s in L]

# Jeu de testsassert liste_longueurs([�un�, �deux�, �trois�, �quatre�, �cinq�]) \

== [2, 4, 5, 6, 4]assert liste_longueurs([��, �.�, �..�, �...�]) == [0, 1, 2, 3]assert liste_longueurs([]) == []

Littéralement :

liste_longueurs(L) retourne la liste des longueurs de s pour s une chaîne decaractère dans L.

9.3.2 La fonctionnelle map

Il est possible d’écrire une fonction générique map qui o�re une alternative aux compréhensionspour exprimer de façon concise des transformations de listes.

def map(f, L):"""(alpha -> beta) * list[alpha] -> list[beta]

Retourne la transformation de la liste L par la fonction f."""

# LR : list[alpha]LR = []

173


Fonctionmap

# e : alphafor e in L:

LR.append( f(e) )

return LR

# Jeu de testsassert map(carre, [1, 2, 3, 4, 5]) == [1, 4, 9, 16, 25]assert map(len, [�un�, �deux�, �trois�, �quatre�, �cinq�]) == [2, 4, 5, 6, 4]

Dans la définition de la fonctionnelle map, la principale di�culté concerne la signature de lafonction, que l’on rappelle ci-dessous :

(alpha -> beta) * list[alpha] -> list[beta]

Cette signature s’interprète de la façon suivante.

Dans map(f, L) :

— le premier paramètre f est de type alpha -> beta, c’est-à-dire une fonction unaire quitransforme une donnée de type alpha en une donnée de type beta.

— le second paramètre L est une liste de type list[alpha]— la valeur de retour de map est de type list[beta].

Par exemple, dans l’expression :

map(carre, [1, 2, 3, 4, 5])

— le premier argument carre pour f est de type int -> int (donc alpha=int etbeta=int)

— le second argument [1, 2, 3, 4, 5] pour L est de type list[int] (donc list[alpha]pour alpha=int)

— la valeur de retour est [1, 4, 9, 16, 25] de type list[int] (donc list[beta] pourbeta=int)

De même, dans l’expression :

map(len, [�un�, �deux�, �trois�, �quatre�, �cinq�])

— le premier argument len pour f est de type str -> int (donc alpha=str et beta=int)— le second argument [�un�, �deux�, �trois�, �quatre�, �cinq�] pour L est de type

list[str] (donc list[alpha] pour alpha=str)— la valeur de retour est [2, 4, 5, 6, 4] de type list[int] (donc list[beta] pour

beta=int)

Exercice : Proposer une variante de la fonction map donnée ci-dessus en utilisant une expressionde compréhension.

174

Filtragedelistes

Compréhensionsoufonctionfilter

Filtragedelistes

Compréhensionsoufonctionfilter

Filtragedelistes

Compréhensions

9.4.2 Compréhensions avec filtrage : syntaxe et interprétation

La syntaxe des compréhensions peut être complétée par une condition :

[ <elem> for <var> in <seq> if <condition> ]

où :

— <var> est la variable de compréhension— <elem> est l’expression appliquée aux valeurs successives de la variable <var>,— <seq> est l’expression de séquence sur laquelle porte la compréhension,— <condition> est la condition de compréhension : une expression booléenne portant

sur la variable de compréhension.

Principe d’interprétation :

La liste résultat correspond à la construction par compréhension décrite précédemment, maisfiltrée pour ne retenir que les éléments pour lesquels <condition> vaut True.

Nous pouvons maintenant redéfinir nos deux fonctions liste_positifs et liste_pairs defaçon particulièrement concise.

def liste_positifs(L):"""list[int] -> list[int]Retourne la sous-liste des entiers positifs de �L�."""

return [n for n in L if est_positif(n)]

# Jeu de testsassert liste_positifs([1, -1, 2, -2, 3, -3, -4]) == [1, 2, 3]assert liste_positifs([1, 2, 3]) == [1, 2, 3]assert liste_positifs([-1, -2, -3]) == []

def liste_pairs(L):"""list[int] -> list[int]Retourne la sous-liste filtrée des entiers pairs de �L�."""

return [n for n in L if est_pair(n)]

# Jeu de testsassert liste_pairs([1, 2, 3, 4, 5, 6, 7]) == [2, 4, 6]assert liste_pairs([2, 4, 6]) == [2, 4, 6]assert liste_pairs([1, 3, 5, 7]) == []

177

Filtragedelistes

Compréhensions9.4.2 Compréhensions avec filtrage : syntaxe et interprétation

La syntaxe des compréhensions peut être complétée par une condition :

[ <elem> for <var> in <seq> if <condition> ]

où :

— <var> est la variable de compréhension— <elem> est l’expression appliquée aux valeurs successives de la variable <var>,— <seq> est l’expression de séquence sur laquelle porte la compréhension,— <condition> est la condition de compréhension : une expression booléenne portant

sur la variable de compréhension.

Principe d’interprétation :

La liste résultat correspond à la construction par compréhension décrite précédemment, maisfiltrée pour ne retenir que les éléments pour lesquels <condition> vaut True.

Nous pouvons maintenant redéfinir nos deux fonctions liste_positifs et liste_pairs defaçon particulièrement concise.

def liste_positifs(L):"""list[int] -> list[int]Retourne la sous-liste des entiers positifs de �L�."""

return [n for n in L if est_positif(n)]

# Jeu de testsassert liste_positifs([1, -1, 2, -2, 3, -3, -4]) == [1, 2, 3]assert liste_positifs([1, 2, 3]) == [1, 2, 3]assert liste_positifs([-1, -2, -3]) == []

def liste_pairs(L):"""list[int] -> list[int]Retourne la sous-liste filtrée des entiers pairs de �L�."""

return [n for n in L if est_pair(n)]

# Jeu de testsassert liste_pairs([1, 2, 3, 4, 5, 6, 7]) == [2, 4, 6]assert liste_pairs([2, 4, 6]) == [2, 4, 6]assert liste_pairs([1, 3, 5, 7]) == []

177

Filtragedelistes

filter

Filtragedelistes

filter

Filtragedelistes

=>Fonctionsutilisantlescompréhensionsetfilter pourlalistedesnombrespairs?

Plusloinaveclescompréhensions

Þ Fonctionretournantlalistedescarrésdesnpremiersentierspairs?Þ Fonctionretournantlenomdenospersonnes(tuples)Þ Fonctionretournantlalistesdetouslescouples(i,j)surl’intervalle[1;n],n>0

(exemple:sin=3,[(1,1),(1,2),(1,3),(2,2),(2,3),(3,3)]AfairesanspuisaveccompréhensionTestercettelignedanspython:>>>[(i,j)foriinrange(1,3)forjinrange(i,3)][(1,1),(1,2),(2,2)]

Þ listedescouplesdivisibles

Sequence Containers Indexing

Base Types

Python 3 Cheat Sheet©2012-2015 - Laurent Pointal

License Creative Commons Attribution 4

Latest version on :https://perso.limsi.fr/pointal/python:memento

0783 -192int

9.23 -1.7e-60.0floatTrue Falsebool"One\nTwo"

'I\'m'

str"""X\tY\tZ1\t2\t3"""

×10-6

escaped tab

escaped new line

Multiline string:

Container Types

list [1,5,9] ["x",11,8.9] ["mot"] []

tuple (1,5,9) 11,"y",7.4 ("mot",) ()

dict{1:"one",3:"three",2:"two",3.14:"π"}

{"key":"value"}

set

{}

{1,9,3,0}

◾ ordered sequences, fast index access, repeatable values

set()

◾ key containers, no a priori order, fast key acces, each key is unique

{"key1","key2"}

Non modi�able values (immutables)

Variables assignment

x=1.2+8+sin(y)

y,z,r=9.2,-7.6,0

a…zA…Z_ followed by a…zA…Z_0…9◽ diacritics allowed but should be avoided

◽ language keywords forbidden

◽ lower/UPPER case discrimination

☝ expression with just comas →tuple

dictionary

collection

integer, %oat, boolean, string, bytes

Identi�ers

☺ a toto x7 y_max BigOne☹ 8y and for

x+=3x-=2

increment ⇔ x=x+3

decrement ⇔ x=x-2

Conversions

for lists, tuples, strings, bytes…

int("15") → 15int("3f",16) → 63 can specify integer number base in 2

nd parameter

int(15.56) → 15 truncate decimal part

float("-11.24e8") → -1124000000.0round(15.56,1)→ 15.6 rounding to 1 decimal (0 decimal → integer number)

bool(x) False for null x, empty container x , None or False x ; True for other x str(x)→ "…" representation string of x for display (cf. formating on the back)chr(64)→'@' ord('@')→64 code ↔ char

repr(x)→ "…" literal representation string of xbytes([72,9,64]) → b'H\t@'list("abc") → ['a','b','c']dict([(3,"three"),(1,"one")]) → {1:'one',3:'three'}set(["one","two"]) → {'one','two'}separator str and sequence of str → assembled str

':'.join(['toto','12','pswd']) → 'toto:12:pswd'str splitted on whitespaces → list of str

"words with spaces".split() → ['words','with','spaces']str splitted on separator str → list of str

"1,4,8,2".split(",") → ['1','4','8','2']sequence of one type → list of another type (via comprehension list)

[int(x) for x in ('1','29','-3')] → [1,29,-3]

type(expression)

lst=[10, 20, 30, 40, 50]lst[1]→20lst[-2]→40

0 1 2 3 4-5 -4 -3 -1-2 Individual access to items via lst[index]

positive index

negative index

0 1 2 3 54

-5 -4 -3 -1-2negative slice

positive slice

Access to sub-sequences via lst[start slice:end slice:step]

len(lst)→5

lst[1:3]→[20,30]

lst[::2]→[10,30,50]lst[-3:-1]→[30,40]

lst[:3]→[10,20,30]lst[:-1]→[10,20,30,40]lst[3:]→[40,50]lst[1:-1]→[20,30,40]

lst[:]→[10,20,30,40,50]Missing slice indication → from start / up to end.On mutable sequences (list), remove with del lst[3:5] and modify with assignment lst[1:4]=[15,25]

Conditional Statement

if age<=18: state="Kid"elif age>65: state="Retired"else: state="Active"

Boolean Logic Statements Blocks

parent statement: statement block 1… ⁝ parent statement: statement block2… ⁝

next statement after block 1

ind

enta

tion

!

Comparators: < > <= >= == !=≠=≥≤

a and b

a or b

not a

logical and

logical or

logical not

one or other or both

both simulta--neously

if logical condition: statements block

statement block executed onlyif a condition is true

Can go with several elif, elif... and only one

8nal else. Only the block of 8rst true

condition is executed.

lst[-1]→50lst[0]→10

⇒ last one

⇒ �rst one

x=None « unde�ned » constant value

Maths

Operators: + - * / // % **× ÷

integer ÷ ÷ remainder

ab

from math import sin,pi…sin(pi/4)→0.707…cos(2*pi/3)→-0.4999…sqrt(81)→9.0 √log(e**2)→2.0ceil(12.5)→13floor(12.5)→12

escaped '

☝ %oating numbers… approximated values angles in radians

(1+5.3)*2→12.6abs(-3.2)→3.2round(3.57,1)→3.6pow(4,3)→64.0

for variables, functions,modules, classes… names

Mémento v2.0.4

str (ordered sequences of chars / bytes)

(key/value associations)

☝ pitfall : and and or return value of a or of b (under shortcut evaluation). ⇒ ensure that a and b are booleans.

(boolean results)

a=b=c=0 assignment to same value

multiple assignments

a,b=b,a values swap

a,*b=seq*a,b=seq

unpacking of sequence initem and list

bytes

bytes

b"toto\xfe\775"

hexadecimal octal

0b010 0xF30o642binary octal hexa

""

empty

dict(a=3,b=4,k="v")

Items count

☝ keys=hashable values (base types, immutables…)

TrueFalse True and False constants ☝ con�gure editor to insert 4 spaces in

place of an indentation tab.

lst[::-1]→[50,40,30,20,10]lst[::-2]→[50,30,10]

1) evaluation of right side expression value2) assignment in order with left side names

=

☝ assignment ⇔ binding of a name with a value

☝ immutables

On mutable sequences (list), remove with del lst[3] and modify with assignment lst[4]=25

del x remove name x

b""

@ → matrix × python3.5+numpy

☝ index from 0(here from 0 to 4)

frozenset immutable set

Priority (…)

☝ usual prioritiesmodules math, statistics, random,

decimal, fractions, numpy, etc. (cf. doc)

Modules/Names Importsfrom monmod import nom1,nom2 as fctmodule truc⇔�le truc.py

→direct acces to names, renaming with asimport monmod →acces via monmod.nom1 …

☝ modules and packages searched in python path (cf sys.path)

?yes

no

shallow copy of sequence

?yes no

and

*=/=%=…

☝ with a var x:if bool(x)==True: ⇔ if x:if bool(x)==False:⇔ if not x:

Exceptions on Errorsraise Exception(…)

Signaling an error:Errors processing:try: normal procesising block except Exception as e: error processing block

normal

processing

errorprocessing

errorprocessing raise

raise

null

☝ finally block for �nal processing in all cases.

"modele{} {} {}".format(x,y,r)

"{selection:formating!conversion}"

◽ Selection : 2 nom 0.nom 4[key] 0[2]

str

Displayprint("v=",3,"cm :",x,",",y+4)

print options: ◽ sep=" " items separator, default space◽ end="\n" end of print, default new line◽ file=sys.stdout print to 8le, default standard output

items to display : literal values, variables, expressions

loop on dict/set ⇔ loop on keys sequencesuse slices to loop on a subset of a sequence

Conditional Loop Statementstatements block executed as long ascondition is true

while logical condition: statements block

s = 0i = 1

while i <= 100: s = s + i**2 i = i + 1print("sum:",s)

initializations before the loop

condition with a least one variable value (here i)

s= ∑i=1

i=100

i2

☝ make condition variable change !

Iterative Loop Statementstatements block executed for each item of a container or iterator

for var in sequence: statements block

s = "Some text"cnt = 0

for c in s: if c == "e": cnt = cnt + 1print("found",cnt,"'e'")

Go over sequence's values

Algo: count number of e in the string.

Go over sequence's index◽ modify item at index◽ access items around index (before / after)lst = [11,18,9,12,23,4,17]lost = []for idx in range(len(lst)): val = lst[idx] if val > 15: lost.append(val) lst[idx] = 15print("modif:",lst,"-lost:",lost)

Algo: limit values greaterthan 15, memorizingof lost values.

☝ be

ware

of

in�

nite

loo

ps!

initializations before the loop

loop variable, assignment managed by for statement

Operations on Strings

values to formatformating directives

Integers Sequences

Files

s = input("Instructions:")☝ input always returns a string, convert it to required type

(cf. boxed Conversions on the other side).

range(5)→ 0 1 2 3 4 range(2,12,3)→ 2 5 8 11range(3,8)→ 3 4 5 6 7 range(20,5,-5)→ 20 15 10range(len(seq))→ sequence of index of values in seq ☝ range provides an immutable sequence of int constructed as needed

range([start,] end [,step])

f = open("file.txt","w",encoding="utf8")storing data on disk, and reading it back

opening mode◽ 'r' read◽ 'w' write◽ 'a' append◽ …'+' 'x' 'b' 't'

encoding ofchars for text�les: utf8 ascii latin1 …

name of 8leon disk(+path…)

8le variable for operations

f.write("coucou")f.writelines(list of lines)

writing readingf.read([n]) → next chars

if n not speci�ed, read up to end !f.readlines([n]) → list of next linesf.readline() → next line

with open(…) as f: for line in f : # processing ofline

cf. modules os, os.path and pathlib

f.close() ☝ dont forget to close the le after use !

Very common: opening with a guarded block (automatic closing) and reading loop on lines of a text 8le:

Function De�nition

def fct(x,y,z): """documentation""" # statements block, res computation, etc. return res

function name (identi8er)

result value of the call, if no computedresult to return: return None

☝ parameters and allvariables of this block exist only in the block and during the functioncall (think of a “black box”)

named parameters

Function Callr = fct(3,i+2,2*i)

Generic Operations on Containers

read empty string if end of �le

len(c)→ items countmin(c) max(c) sum(c)sorted(c)→ list sorted copyval in c → boolean, membership operator in (absence not in)enumerate(c)→ iterator on (index, value)zip(c1,c2…)→ iterator on tuples containing c

i items at same index

all(c)→ True if all c items evaluated to true, else Falseany(c)→ True if at least one item of c evaluated true, else False

☝ modify original list

lst.append(val) add item at endlst.extend(seq) add sequence of items at endlst.insert(idx,val) insert item at indexlst.remove(val) remove 8rst item with value vallst.pop([idx])→value remove & return item at index idx (default last)

lst.sort() lst.reverse() sort / reverse liste in place

"{:+2.3f}".format(45.72793)→'+45.728'"{1:>10s}".format(8,"toto")→' toto'"{x!r}".format(x="I'm")→'"I\'m"'

☝ start default 0, �n not included in sequence, pas signed default 1

◽ Conversion : s (readable texte) or r (literal representation)

< > ^ = 0 at start for 8lling with 0integer: b binary, c char, d decimal (default), o octal, x or X hexa…Moat: e or E exponential, f or F 8xed point, g or G appropriate (default), string: s … % percent

◽ Formating :�ll char alignment sign mini width.precision~maxwidth type

+ - space

Operations on Dictionaries Operations on SetsOperators: | → union (vertical bar char) & → intersection - ^ → diNérence/symetric diN. < <= > >= → inclusion relationsOperators also exist as methods.

d.update(d2) update/add associations

Note: For dictionaries and sets, theseoperations use keys.

Speci�c to ordered sequences containers (lists, tuples, strings, bytes…)reversed(c)→ inversed iterator c*5→ duplicate c+c2→ concatenatec.index(val)→ position c.count(val)→ events count

Operations on Lists

d[key]=valued[key]→ value

d.keys()d.values()d.items()

d.clear()del d[key]

→iterable views onkeys/values/associations

Exa

mp

les

d.pop(key[,default])→ valued.popitem()→ (key,value)d.get(key[,default])→ valued.setdefault(key[,default])→value

s.update(s2) s.copy()s.add(key) s.remove(key)s.discard(key) s.clear()s.pop()

Loop Control

Go simultaneously on sequence's index and values:for idx,val in enumerate(lst):

☝ go

od

hab

it :

don

't m

odif

y lo

op

var

iable

Advanced: def fct(x,y,z,*args,a=3,b=5,**kwargs):

*args variable positional arguments (→tuple), default values, **kwargs variable named arguments (→dict)

one argument perparameter

storage/use of returned value

Algo:

f.flush() write cache

f.tell()→positionreading/writing progress sequentially in the �le, modi�able with:

f.seek(position[,origin])

f.truncate([taille]) resize

Formating

Advanced: *sequence **dict

s.startswith(pre�x[,start[,end]])s.endswith(suBx[,start[,end]]) s.strip([chars])s.count(sub[,start[,end]]) s.partition(sep)→ (before,sep,after)s.index(sub[,start[,end]]) s.find(sub[,start[,end]])s.is…() tests on chars categories (ex. s.isalpha())s.upper() s.lower() s.title() s.swapcase()s.casefold() s.capitalize() s.center([width,�ll]) s.ljust([width,�ll]) s.rjust([width,�ll]) s.zfill([width])s.encode(encoding) s.split([sep]) s.join(seq)

?yes

no

next

8nish…

Input

import copycopy.copy(c)→ shallow copy of containercopy.deepcopy(c)→ deep copy of container

☝ this is the use of function name with parenthesis which does the call

fct()

fct

fct

☝ text mode t by default (read/write str), possible binary mode b (read/write bytes). Convert from/to required type !

break immediate exitcontinue next iteration☝ else block for normal loop exit.

Lesensembles(chapitre10)

Documents

ISUP-python Listes et compréhensions · 2017. 9. 26. · Python sont des séquences, ce point de vue alternatif permet d’exploiter les expressions de compréhensions. Considérons