LINFO1101 Synthèse

Lucie Chartreau
LMAT1BA 2020
.
Intégration de code sur LaTeX :
http://texdoc.net/texmf-dist/doc/latex/listings/listings.pdf
 TABLE DES MATIÈRES

Table des matières

1 Le langage. 1

2 Variables. 1
2.1 Listes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2 Dictionnaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

3 Fonctions. 3
3.1 Boucles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

4 Classes. 3
4.1 Héritage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
4.2 Méthodes magiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

5 Files 4

6 Algorithmes utiles, pour gagner du temps. 4

6.1 Algorithme de recherche. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
6.1.1 Return trouvé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
6.1.2 Return la ligne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
6.2 Interface utilisateur : invoquer des fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
6.3 Liste de mots dans un str, sans capitales et sans caractères spéciaux. . . . . . . . . . . . . . . . . . . . . . . . . . 5
6.4 Dictionnaire : create index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1
 Variables.

1 Le langage.
Voir vidéo youtube 1 pour language de base.
Les commentaires commencent par # ; les descriptions de fonctions comme """description""".
Les descriptions de fonctions sont accessibles via help(function).
Imports :
— Imports de modules :
>import name_module # Importe le module entier.
>from name_module import * # Importe les fonctions.
— Imports de modules sans l’interface utilisateur :
1 im por t a s t
2 im por t t y p e s
3 im por t s y s
4 with open ( " pck . py" ) a s f : # pck . py = nom p a c k a g e
5 p = ast . parse ( f . read ( ) )
6
7 f o r node i n p . body [ : ] :
8 i f not i s i n s t a n c e ( node , a s t . F u n c t i o n D e f ) : # FunctionDef => C l a s s D e f
9 p . body . remove ( node )
10
11 module = t y p e s . ModuleType ( "mod" )
12 code = c o m p i l e ( p , "mod . py" , ’ e x e c ’ )
13 s y s . modules [ "mod" ] = module
14 e x e c ( code , module . __dict__ )
15
16 im por t mod

— tester son code :

1 a s s e r t ( function = expected r e s u l t ) , s t r ( r e f e r e n c e of t h i s t e s t . )

2 Variables.
None int -> entier complex tuple -> (x,y)
bool -> True/False float -> virgule str -> caractères

1. https ://www.youtube.com/watch ?v=rfscVS0vtbw&t=2273s : Learn Python Full Course for Beginners [Tutorial] (by :freeCodeCamp.org)

1
 Variables.

Opérations
— Str
\0 ajoute un caractère interdit sans compromettre le code. \n renvoie à la ligne.
str(a) + str(b) = str(a b) et str(a) * 3 = str(a a a)
— Int et float
x += y append x by y
x ** 2 = x2 ⇔ pow(x,2)
// : division entier ; % : reste
comparaisons : >, <, =, >=, <=
combinaisons : and or not

2
 Variables.

2.1 Listes.
Listes
count(sub[, start[, end]]) Compte le nombre d’occurrences de sub (str), start et end per-
mettent de réduire la recherche (start et end exclus).
len(l) nombre d’éléments de l
find(sub[, start[, end]]) Recherche sub (str). Retourne -1 si non abouti
l.index(x) Retourne l’indice du premire x de l
x in s vrai si x est un des éléments de l
split([sep[ , ]]) Découpe la chaîne de caractères en se servant de la chaîne sep
comme délimiteur.
join(liste) Agglutine tous les éléments d’une liste séparés par sep dans l’ex-
pression sep.join([”un”, ”deux”]).
replace(old, new[ , ]) Remplace les occurrences de la chaîne old par new.
upper() et lower() Remplace les minuscules par des majuscules et inversement.
l[i : j] retourne une liste des éléments d’indices i à j exclu.
l[i] = ”x” remplace l’élément i par x.
min(l) et max(l) plus petit/grand élément de l, résultat difficile à prévoir lorsque
les types des éléments sont différents
sum(l) retourne la somme de tous les éléments
l.remove(x) supprime le premier x de l.
del l[i : j] supprime les éléments d’indices entre i et j exclu.
l.append(x) Ajoute x à la fin de l (x liste ou str).
l.extend(k) Ajoute k à la liste l.(k liste)
l.insert(i, x) Insère x en i dans l.
l.sort([f]) Cette fonction trie la liste par ordre croissant (f fonction de com-
paraison facultative).l
l.pop([i]) Retourne l[i] et le supprime de l (i facultatif, sinon dernier élément).
l.reverse(x) Retourne la liste.

2.2 Dictionnaires.
append un dico : 2
1 d i c o = {}
2 d i c o [ ’ key ’ ] = {}
2. dictionairies can help map a matrix

3
 Classes.

3 d i c o [ ’ key ’ ] [ ’ x ’ ] = y
4 { " key " : { "x" : y }}
Opérations :
1 d e l d i c o [ " key1 " ]
2 d i c o [ " key2 " ] = 0
3 d i c o [ " keyx " ] += z
4 len ( dico )
5 dico . keys ( )
6 dico . items ()
7 copy = d i c o . copy ( )
# d e l e t e key & v a l u e s
# v a l u e s can be changed t h i s way
# append a l r e a d y e x i s t i n g v a l u e
# nb o f k e y s
# return only the keys
# convert into tuple l i s t
# t o k e e p a copy o f t h e o r i g i n a l

3 Fonctions.
1 d e f f 1 ( arg1 , arg2 , . . . ) :
2 # fonction
3 return . . . # ignorer l a fonction : pass

3.1 Boucles.
1 f o r i in range (x , y , z ) : # p a r c o u r t t o u s l e s e n t i e r s de x a y de z en z
2 for e in l s t : # p a r c o u r t t o u s l e s e l e m e n t s de l a l i s t e l s t

La fonction map, un exemple :

1 def fonction (x) : return x % 2
2 l i = [ 3 ,4 ,5]
3 l i 2 = map ( f o n c t i o n , l i )
4 print ( l i s t ( l i 2 )) # affiche [ 1, 0, 1 ]

4 Classes.
Voir playlist youtube 3 pour explication détaillée. Toutes les fonctions dans une classe doivent commencer par (self, ...).
3. https ://www.youtube.com/watch ?v=ZDa-Z5JzLYM&list=PL-osiE80TeTsqhIuOqKhwlXsIBIdSeYtc : python oop tutorial working with classes
(by : Corey Schafer)

4
 Classes.

1 c l a s s nom_classe :
2 d e f __innit__ ( s e l f , a t t r i b u t 1 , a t t r i b u t 2 = None . . . ) :
3 s e l f . attribut1 = attribut1
4 i f a t t r i b u t 2 i s None : # variable facultative
5 s e l f . attribut2 = False
6 i f t v a i s not None :
7 s e l f . attribut2 = attribut2

On ajoute une variable à associer à la classe :

1 var_1 = nom_classe ( a t t r i b u t 1 = . . . , . . . ) # on ne r e m p l i pas s e l f .

Imprimer la valeur de l’attribut d’une variable :

1 p r i n t ( " {} " . f o r m a t ( var_1 . a t t r i b u t 1 ) )

Actions à l’exterieur des fonctions Imprimer le résultat d’une fonction : deux méthodes. 4
1 p r i n t ( var_1 . a t t r i b u t 1 . f c t i o n ( ) ) # Ou f c t i o n e s t une f o n c t i o n dans c l a s s e
2 p r i n t ( c l a s s e . f c t i o n ( var_1 ) )

modifier à une variable intégrée dans une classe, dans le but de la modifier :
1 # (Ou v r i e s t une v a r i a b l e i n t e g r e e dans l a c l a s s e . )
2 nom_classe . v r i = v a l e u r n o u v e l l e # M o d i f i e l a v a l e u r en g e n e r a l .
3 var_1 . v r i = v a l e u r n o u v e l l e # M o d i f i e s e u l e m e n t pour var_1

4.1 Héritage.
1 class cl1 :
2 d e f __init__ ( s e l f , d , p ) :
3 s e l f . __description = d
4 s e l f . __prix = p
5 class cl2 ( cl1 ):
6 d e f __init__ ( s e l f , d , p , z ) :
7 s u p e r ( ) . __init__ ( d , p )
8 s e l f . __z = z

4. Attention à toujours mettre fction() et non fction sinon le programme retourne une méthode

5
 Algorithmes utiles, pour gagner du temps.

4.2 Méthodes magiques

5 Files
readfile : (Voir Mission_7 pour les commentaires.)
1 def open_file ( filename ) :
2 b = str ( str ( filename ) + " . txt ")
3 try :
4 f i l = open ( b , " r " )
5 except FileNotFoundError :
6 f i l = open ( b , "w+" )
7 f i l = open ( b , " r " )
8 return f i l
9
10
11 def read_file ( filename ) :
12 f i l = open_file ( filename )
13 l = f i l . readlines ()
14 i f l == [ ] :
15 r e t u r n " f i l e ␣ i s ␣empty"
16 return l

/ !\ ne jamais oublier de fermer le fichier.

6 Algorithmes utiles, pour gagner du temps.

6.1 Algorithme de recherche.
6.1.1 Return trouvé.

1 d e f b i n a r y _ s e a r c h ( name , l i s t _ o f _ n a m e s ) :
2 first = 0
3 l a s t = l e n ( list_of_names ) − 1
4 found = F a l s e
5 w h i l e f i r s t <= l a s t and not found :
6 m idd le = ( f i r s t + l a s t ) // 2
7 i f l i s t _ o f _ n a m e s [ m id dl e ] == name :
8 found = True
9 else :
10 f i r s t = m id dl e + 1
11 r e t u r n found

6
 Algorithmes utiles, pour gagner du temps.

6.1.2 Return la ligne.

(à utiliser avec un fichier txt converti en liste de lignes)
1 d e f f i n d _ l i n e s ( item , l i s t ) : # C e t t e f o n c t i o n e s t a u x i l i a i r e a c r e a t e _ i n d e x
2 f = []
3 f o r i in range (0 , len ( l i s t ) ) :
4 i f item i n l i s t [ i ] :
5 f += [ i ]
6 return f

6.2 Interface utilisateur : invoquer des fonctions.

1 p r i n t ( "Welcome␣ t o ␣ your ␣ u s e r ␣ i n t e r f a c e ! ␣ " )
2 p r i n t ( " Functions ␣ supported ␣ are : ␣ info , ␣ . . . " )
3 p r i n t ( " Enter ␣ \" i n f o \" ␣ t o ␣ l e a r n ␣ more ␣ about ␣ t h e ␣ program . " )
4 p r i n t ( "______________________________________________________________________" )
5
6 # Enter your f u n c t i o n s .
7
8 l = input ( " Input ␣a␣ f u n c t i o n ␣" )
9 w h i l e l != " o f f " :
10 i f l == " i n f o " :
11 print ( info ())
12 i f l == " f u n c t i o n 1 " :
13 p r i n t ( f u n c ti o n 1 ( input ( " input ␣ f u n c t i on 1 ’ s ␣ v a r i a b l e s : ␣" ) ) )
14 l = input ( " input ␣a␣ f u n c t i o n ␣" )

6.3 Liste de mots dans un str, sans capitales et sans caractères spéciaux.
caractères_spéciaux = str( 0 ()[] − |‘ = +∗! :; , ?./ <> / &#_)
1 d e f get_words ( s t r i ) :
2 z = s t r i . r e p l a c e ( " \n" , " " )
3 a = z . t r a n s l a t e ( s t r . maketrans ( ’ ’ , ’ ’ , c a r a c t e r e s _ s p e c i a u x ) )
4 b = a . s p l i t ( "␣" )
5 return b

6.4 Dictionnaire : create index.

7
 Algorithmes utiles, pour gagner du temps.

1 d e f f i n d _ l i n e s ( item , l i s t ) : # C e t t e f o n c t i o n e s t a u x i l i a i r e a c r e a t e _ i n d e x
2 f = []
3 f o r i in range (0 , len ( l i s t ) ) :
4 i f item i n l i s t [ i ] :
5 f += [ i ]
6 return f

1 def create_index ( filename ) :

2 a = read_file ( filename )
3 b = []
4 e = []
5 f = []
6 d = {}
7 f o r i in range (0 , len ( a ) ) :
8 i f a [ i ] != " \n" :
9 b += [ get_words ( a [ i ] ) ]
10 f o r i in range (0 , len ( a ) ) :
11 i f a [ i ] != " \n" :
12 e += get_words ( a [ i ] )
13 e = l i s t ( set ( e ))
14 f o r i in range (0 , len ( e ) ) :
15 f += [ f i n d _ l i n e s ( e [ i ] , b ) ]
16 f o r i in range (0 , len ( e ) ) :
17 d [ e [ i ] ] = {}
18 f o r z in range ( len ( f [ i ] ) ) :
19 d [ e [ i ] ] [ s t r ( f [ i ] [ z ] ) ] = b [ f [ i ] [ z ] ] . count ( e [ i ] )
20 return d

Voir Mission_7 pour les commentaires.