Imprimer

Introduction

Ces notes sont issus du Mooc Python de Arnaud LEGOUT. Je recommande vivement ce Mooc.

 

Les séquences

Les types séquences ont des propriétés communes. Les séquences regroupent les éléments suivants:

Les chaînes de caractères

Une séquence est un ensemble fini d'éléments indexés de 0 jusqu'au dernier élément.

Exemple : soit la chaîne de caractères suivante s='egg, bacon'

Accès via index

s[0] => 'e'

Test d'appartenance

'g' in s => True

Concaténation de séquences

s + ' and spam' => 'egg, bacon and spam'

Taille d'une séquence

len(s) => 10

Minimum d'une séquence (par rapport à l'ordre lexicographique)

min(s) => ' '

Maximum d'une séquence

max(s) => 'o'

Recherche d'une occurence dans la séquence

s.index('g') => 1

Compter les occurences dans la séquence

s.count('g') => 2

Modifier une séquence

s * 3 => 'egg, baconegg, baconegg, bacon'

Slicing

s[0:3] de l'indice 0 inclue à l'index 3 exclue, soit donc 'egg'
s[5:10] => 'bacon'
s[:3] du début à l'index 3 exclu, soit 'egg'
s[5:] de l'index 5 inclu à la fin, soit 'bacon'
s[:] réalise une copie de la chaîne de caractères (shadow copy)
s[0:10:2] prend les éléments de l'index 0 inclu à l'index 10 exclu par pas de 2, soit 'eg ao'
s[::2] prend les éléments du début de la séquence à la fin, par pas de 2, soit 'eg ao'
s[100] renverra une exception IndexError : string index out of range. Par contre, le slicing suivant s[5:100] ne remonte pas d'erreur.
s[5:100] Python regarde en effet l'intersection entre les indices du slice et la séquence, donc le résultat est 'bacon'
s[100:200] => pas d'intersection entre les indices de 100 à 200 et la chaîne s, donc le résultat est la chaîne vide
s[-10:-7] ici, l'indice -1 correspond au dernier caractère de la chaîne s. Ainsi, l'indice -10 correspond au premier caractère. On prend donc la chaîne de l'indice -10 inclu à l'indice -7 exclu, soit 'egg'
s[:-3] du début de la chaîne à l'indice -3 exclu, soit 'egg, ba'
s[::-1] => on parcourt la séquence pas pas de -1, c'est à dire en ordre inverse, soit 'nocab ,gge'

Les séquences de type "liste"

Une liste est une séquence qui permet de stocker des objets hétérogènes.
Une liste est mutable, c'est à dire que l'on peut modifier en place, c'est à dire directement dans la mémoire. Ainsi, pour modifier un objet, il n'est pas nécessaire de faire une copie de l'objet avant de pouvoir modifier la partie souhaitée.

Pour créer une liste :

a=[] => création d'une liste vide
i=4
a=[i,'spam',3.2,True]
La liste contient les références vers les objets de la liste. Ainsi, la taille d'une liste ne dépend pas de la taille des objets de la liste mais du nombre d'objets référencés.

Ci-dessous des opérations sur les listes typiques des séquences

Python 3.5.2 (default, Sep 10 2016, 08:21:44) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> i=4
>>> a=[i,'spam', 3.2, True]     
>>> a
[4, 'spam', 3.2, True]
>>> i=5
>>> a
[4, 'spam', 3.2, True]
>>> a[0]
4
>>> a[0]=a[0]+2
>>> a
[6, 'spam', 3.2, True]
>>> a[1:2]
['spam']
>>> 

Comme une liste est modifiable, il est possible par exemple d'insérer de nouveaux éléments dans la liste. Par exemple, nous allons remplacer le premier élément de la liste par deux éléments ('egg','spam')

>>> a
[6, 'spam', 3.2, True]
>>> a[1:2]
['spam']
>>> a[1:2]=['egg','spam']
>>> a
[6, 'egg', 'spam', 3.2, True]
>>>

De même, il est possible de supprimer des éléments d'une liste. Pour supprimer par exemple le premier élément, il faut procéder ainsi :

>>> a
[6, 'egg', 'spam', 3.2, True]
>>> a[0:1]=[]
>>> a
['egg', 'spam', 3.2, True]
>>>

La fonction range

La fonction range renvoie une liste d'entiers : range(5) renvoie [0, 1, 2, 3, 4]

>>> for x in range(5):
...     print('%d' % (x))
... 
0
1
2
3
4
>>>

La fonction range admet la même syntaxe que les séquences. Ainsi range(1,10,2) renvoie une liste de 1 inclu à 10 exclu par pas de 2, soit [1,3,5,7,9]

Fonction append et extend

>>> a=[6,'egg','beans',True]
>>> a.append(34)
>>> a
[6, 'egg', 'beans', True, 34]
>>> a.extend([3,5,9])
>>> a
[6, 'egg', 'beans', True, 34, 3, 5, 9]
>>>

La fonction pop

Cette fonction enlève le dernier élément d'une liste

>>> a
[6, 'egg', 'beans', True, 34, 3, 5, 9]
>>> a.pop()
9
>>> a
[6, 'egg', 'beans', True, 34, 3, 5]
>>>

Les tuples

Un tuple contient une séquence d'objets quelconques. Par contre, le tuple est immuable.
Pour créer un tuple vide, la syntaxe est la suivante :

Python 3.5.2 (default, Sep 10 2016, 08:21:44) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> t=()
>>> t
()
>>> type(t)
<class 'tuple'>
>>> t=(4,)
>>> t
(4,)
>>> type(t)
<class 'tuple'>
>>>

Attention, il faut mettre une virgule dans t=(4,) sinon Python considérera que la parenthèse est juste là pour délimiter une expression. Ainsi t=(4) aurait conduit à t de type integer

Les parenthèses sont en fait facultatives, comme le montre l'exemple ci-dessous. Elles sont obligatoires dans le cas du tuple vide.

>>> t='spam','egg',True
>>> type(t)
<class 'tuple'>
>>> t
('spam', 'egg', True)
>>>

Comme un tuple est une sorte de séquence, on peut réaliser les opérations suivantes par exemple

>>> t
('spam', 'egg', True)
>>> t[0]
'spam'
>>> t[:2]
('spam', 'egg')
>>>

Conversion d'un tuple en liste et réciproquement (fonctions tuple et list)

Comme un tuple est immuable, pour modifier un tuple il faut d'abord le convertir en liste, réaliser sur cette liste la modification voulue, puis convertir la liste en tuple. Le tupe sera alors un nouveau tuple. Un exemple ci-dessous :

>>> t
('spam', 'egg', True)
>>> l=list(t)
>>> l
['spam', 'egg', True]
>>> l.append('x')
>>> l
['spam', 'egg', True, 'x']
>>> t=tuple(l)
>>> t
('spam', 'egg', True, 'x')
>>>

Les fonctions

Ci-dessous un exemple de fonction qui affiche le carré d'une liste de nombre et renvoie 'fin' une fois la fonction achevée. La fonction est déclarée dans un fichier. La fonction est ensuite exécutée via IDLE touche F5.

L1=[1,4,5]

def f(L):
    for x in L:
        print('%f au carré égal à %f' % (x,x**2))
    return 'FIN'

f(L1)
a=f(L1)
print(a)

A noter que Python exécute les lignes l'une après l'autre, il faut donc définir la fonction avant de l'appeler.

Les chaînes de caractères

Les chaînes de caractères font partie des séquences. Ainsi par exemple, les fonctions suivantes s'appliquent aux chaînes de caractères :

Les chaînes de caractères sont immuables.

Il existe 3 syntaxes pour déclarer une chaîne de caractères :

Le choix entre les deux premières méthodes dépend du contenu de la chaîne de caractères, à savoir si elle contient un simple quote ou un double quote. Les exempels ci-dessous parlent d'eux-mêmes.

>>> s='une chaîne'
>>> s
'une chaîne'
>>> s="une chaîne"
>>> s
'une chaîne'
>>> s="l'herbe"
>>> s
"l'herbe"
>>> s='un guillement : "'
>>> s
'un guillement : "'
>>>

Ci-dessous un exemple pour la méthode avec triple quote

>>> s="""du texte
... bla bla
...     fin du texte
... """
>>> s
'du texte\nbla bla\n    fin du texte\n'
>>> print(s)
du texte
bla bla
    fin du texte

>>>

La fonction upper

Comme les chaînes de caractères sont immuables, quand on applique une fonction à une chaîne de caractères, ceci crée une nouvelle chaîne comme le montre l'exemple suivant

>>> a='python'
>>> b=a.upper()
>>> a
'python'
>>> b
'PYTHON'
>>>

La fonction replace

L'appel de cette fonction crée une nouvelle chaîne qui est retournée par la fonction. Exemple ci-dessous

>>> s="python c'est bien"
>>> s.replace('bien','très bien')
"python c'est très bien"
>>> s="python c'est bien"
>>> s1=s.replace('bien','très bien')
>>> s1
"python c'est très bien"
>>> s
"python c'est bien"
>>>

Les fonctions split et join

La fonction split permet de transformer une chaîne de caractères en une liste, la fonction join réalisant l'opération inverse. La fonction split nécessite de recevoir en paramètre qui permettra de découper la chaîne. Par défaut, il s'agit du caractère espace. De même, la fonction join nécessite de recevoir en paramètre le caractère à insérer entre les éléments de la liste pour construire la chaîne de caractères. Quelques exemples ci-dessous:

>>> s.split()
['python', "c'est", 'bien']
>>> s.split(" ")
['python', "c'est", 'bien']
>>>
l=s.split(" ")
>>> l
['python', "c'est", 'bien']
>>> "_".join(l)
"python_c'est_bien"
>>>

Les tables de hash

Les tables de hash offrent une réponse aux limitations des séquences.Les séquences sont en effet optimisées pour accéder en lecture ou en modification du moment que l'on connait l'index de l'élément. Ainsi, plus la liste est grande, plus les test d'appartenance sera long.

La table de hash permet de retrouver un élément dans un tableau clé/valeur avec un temps indépendant de la taille du tableau

Les dictionnaires

Les dictionnaires sont une implémentation des tables de hash. La clé est un objet de type immuable.

Syntaxe de création d'un dictionnaire

On peut utiliser deux syntaxes :

Les fonctions sur les dictionnaires

La taille d'un dictionnaire : len(d)
Test d'appartenance : 'marc' in d
Accès au valeur : d['marc']
Effacement d'un couple clé/valeur : del d['marc']
Obtenir la liste des clés : d.keys()
Obtenir la liste des valeurs : d.values()
Obtenir la liste clé/valeur : d.items()

Ci-dessous quelques exemples obtenus dans un terminal python :

>>> d={'bob' : 35,'alice':30 , 'marc':45}
>>> del d['bob']
>>> d
{'alice': 30, 'marc': 45}
>>> d.keys()
dict_keys(['alice', 'marc'])
>>> d.values()
dict_values([30, 45])
>>> d.items()
dict_items([('alice', 30), ('marc', 45)])
>>> d
{'alice': 30, 'marc': 45}

Installation de pip pour python version 3

sudo apt-get install python3-pip

Installation de modules via pip

Installation du module mysql

sudo pip3 install --allow-external mysql-connector-python mysql-connector-python

 

Installation du module xlsxwritter

sudo apt-get install python3-xlsxwriter

 

Opérateur * (étoile)

http://sametmax.com/operateur-splat-ou-etoile-en-python/

https://docs.python.org/3/tutorial/controlflow.html#keyword-arguments