<jupyter_start><jupyter_text>Laboratoire 0 : Initiation au langage de programmation Python3 Département du génie logiciel et des technologies de l’information| Étudiants             | NOMS - CODE PERMANENT                                   ||-----------------------|---------------------------------------------------------|| Cours                 | GTI770 - Systèmes intelligents et apprentissage machine || Session               | SAISON ANNÉE                                            || Groupe                | X                                                       || Numéro du laboratoire | X                                                       || Professeur            | Prof. NOM                                               || Chargé de laboratoire | NOM                                                     || Date                  | DATE                                                    |  IntroductionL'objectif de ce laboratoire est de vous familiariser avec Python et son environment. Il est important de suivre les étapes de ce cours et de pratiquer. Il est également important de lire la documentation offciel de python.  Les basiques de PythonDans ce laboratoire, nous allons voir les basiques de Python, mais ce laboratoire n'est pas exhausive, il est fortement conseillé d'aller sur la documentation de python pour avoir plus information : https://docs.python.org/3.6/index.html Les variablesUne variable en python peut être assignée nimporte quelle type de valeur<jupyter_code>a = 2 # a est de type int 
b = "astring" # b est de type string
a = "Two" # a est maintenant de type string<jupyter_output><empty_output><jupyter_text>La fonction printLa fonction print de Python peut afficher le contenu de nimporte quelle valeur et de nimporte quelle variable<jupyter_code>a = 1
c = 1
print(a)
b = "astring"
print(b)
a = 'One' #Les quotes simples sont la même chose que les doubles quotes
print(a)
print("{} is {}".format(c, a)) #Print utilisant les format<jupyter_output>1
astring
One
1 is One<jupyter_text>Les structures de PythonPython supporte plusieurs types type de structure : Tuple, List, Dictionnary....Tres important, en Python, les indexes commencent toujours à 0.Visiter https://docs.python.org/2/tutorial/datastructures.html  Les listsLes lists en Python est une structure de donnee qui permet de stocker plusieurs valeurs de different types dans une seule variable<jupyter_code>l = []
print(l)
l = [1,2,3,4,5,6]
print(l)
l.append(7) # Concatener 7 à la fin de la liste
print(l)
l1 = [1, "1", 2, "2"]
# pour avoir la taille du list, on peut utiliser len
print(len(l))<jupyter_output>[]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7]
7<jupyter_text>Les tuplesLes tuples est une structure de donnee similaire aux lists. Contrairement aux lists, les tuples sont immutables.<jupyter_code>t = (1,2,3)
print(t)
t1 = (1, "One", 2, "Two")
print(t1)
# pour avoir la taille d'un tuple, on peut utiliser aussi len
print(len(t1))
t[2] = 4 # renvoie une erreur parce que tuple est immutable<jupyter_output>(1, 2, 3)
(1, 'One', 2, 'Two')
4<jupyter_text>Les dictionnaryLes dictionnary/dictionnaires est une structure de donnee associative. Ils associent une clé et une valeur. Les clés doivent être obligatoirement uniques<jupyter_code>d = {}
d['one'] = 1
d[1] = 1
d[2] = 'two'
print(d)
# pour avoir la taille d'un dictionnaire, on peut utiliser aussi len
print(len(d))<jupyter_output>{1: 1, 2: 'two', 'one': 1}
3<jupyter_text>Les conditions if/else en PythonComme tous les languages de programmation, Python possede des conditions sous forme de if/elif/else<jupyter_code>a = 1
b = a + 1
c = 1
d = 2
if b % 2 == 0 and a == 1:
    print("IF")
elif c == 1 or d == 2:
    print("ELIF")
else:
    print("ELSE")<jupyter_output>IF<jupyter_text>Les loops/boucle en PythonPython possede 2 types de boucle While et For. While loopLa boucle while est une boucle permettant de continuer une operation tant que la condition de la boucle est toujour remplie<jupyter_code>n = 10
while n > 0:
    print (n)
    n -= 1<jupyter_output>10
9
8
7
6
5
4
3
2
1<jupyter_text>For loopLa boucle for est très similaire a la boucle while. En python, la boucle while est beaucoup plus souvent utilisé parce qu'on peut iterer directement sur les contenues des structures<jupyter_code>l = [7,6,5,4,3,2,1]

#For each loop sur une liste
for element in l:
    print(element)
    
#For loop avec index
for index in range(0,len(l)):
    print(l[index])
#For loop avec index et element
for index,element in enumerate(l):
    print(index,element)<jupyter_output>(0, 7)
(1, 6)
(2, 5)
(3, 4)
(4, 3)
(5, 2)
(6, 1)<jupyter_text>FonctionsUne fonction peut etre creer de maniere tres simple en Python<jupyter_code>def addAndPrint(x, y):
    res = x + y
    print(res)
    return res

a = addAndPrint(1,2)<jupyter_output>3<jupyter_text>Lecture et écriture de fichierLa lecture et écriture en Python est très simple. Example:<jupyter_code>#Ecriture de fichier
fid = open('path/to/outputfile.xyz', 'w') # option w veut dire write
l1 = "This is a normal line"
fid.write(l1)
l2 = "Si tu veux une nouvelle ligne, il faut ajouter\n"
fid.write(l2)
fid.close() # Fermeture de fichier
#lecture de ficher entier
fid = open('path/to/outputfile.xyz', 'r') # option r veut dire read
txt = fid.read() # Cette ligne permet de lire tout le fichier 
print(txt)
fid.close() # Fermeture de fichier
#lecture de ficher ligne par ligne
fid = open('path/to/file.xyz', 'r') # option r veut dire read
for line in fid:
    print line
fid.close() # Fermeture de fichier<jupyter_output><empty_output><jupyter_text>Les objetsPython est un language d'objet, cela veut dire qu'on peut créer des object et leur donner des fonctionnalités. Étant donné que ce cours n'est pas un cours de programmation, on va vous donner une description rapide pour que vous puissiez savoir les utiliser.<jupyter_code>class MyClass:
    def __init__(self, something):
        # __init__(self,...) est un constructor
        # Un constructor permet de specifier comment on peut construire un objet
        self.somethingElse = something
        # self.somethingElse est un attriubte de notre objet
        # self est une reference a notre objet
    def myMethod(self):
        # myMethod est une methode de notre object
        # pour specifier une méthode dans un objet, il suffit de déclarer une fonction dans le scope de l'objet
        # il faut également que "self" soit le premier parametre de notre méthode
        print self.somethingElse<jupyter_output><empty_output><jupyter_text>Import des packages en PythonPar défault, Python ne possède pas tous les fonctionnalités, en important des packages, on donne a Python plus de fonctionnalité qu'il possède.Example:<jupyter_code>import numpy #import numpy the mathematical package

# Pour utiliser numpy il faut ajouter le prefix numpy devant les fonctions
a = numpy.ones(4)

# Cette écriture est longue, on peut donner un alias a un package pour gagner en temps
import numpy as np

# Meme chose qu'en haut except on utilise notre alias np
a = np.ones(4)<jupyter_output><empty_output><jupyter_text>On peut également importe qu'une partie d'un packageExample:<jupyter_code>from numpy import ones
a = ones(4) # Remarque: On n'a plus besoin d'utiliser le prefix ici

# Bien sur, on peut importer plusieurs fonction en meme temps

from numpy import zeros, array<jupyter_output><empty_output><jupyter_text>À eviter:<jupyter_code>from numpy import * # Ici, on importe tous les fonctions de numpy et on pourra les utiliser sans prefix.
                    # !!!!!, Cette écriture est à éviter absolutment parce qu'il réduit la visibilité du code 
                    # et peut entrainer des erreurs.
                    # IMPORTANT: Ne pas utiliser cette écriture dans vos rendus, vous serez PENALISES.<jupyter_output><empty_output><jupyter_text>NumpyNumpy est un package mathématique permettant à Python de faire des manipulation matricielle, des operations mathématiques, etc... Basiques matrices creation<jupyter_code>import numpy as np #import numpy

print(np.ones(4)) # Vector de 4 elements de 1
print(np.zeros((2,2))) #Matrix 2x2 avec que des zeros
a = np.array([[1.,4.,4],
                [5.,6.,7]])
print(a)
# pour avoir le nombre de lignes et de colonnes de la matrice a
# on utilise shape
print(a.shape) #2 lines et 3 colonnes<jupyter_output>[ 1.  1.  1.  1.]
[[ 0.  0.]
 [ 0.  0.]]
[[ 1.  4.  4.]
 [ 5.  6.  7.]]
(2, 3)<jupyter_text>Les operationsLes operations de bases de numpy sont élément par élément<jupyter_code>A = np.ones(4)
print(A)
B = A * 8
print(B)
C = np.log2(B)
print(C)<jupyter_output>[ 1.  1.  1.  1.]
[ 8.  8.  8.  8.]
[ 3.  3.  3.  3.]<jupyter_text>Il existe également des opérations entre matrices.<jupyter_code>A = np.array([[1,1],[2,2]])
B = np.array([[-1,1],[1,1]])

print("A:\n", A)
print("A transpose:\n", A.T)
print("B:\n", B)
print("AB:\n", A.dot(B))<jupyter_output>('A:\n', array([[1, 1],
       [2, 2]]))
('A transpose:\n', array([[1, 2],
       [1, 2]]))
('B:\n', array([[-1,  1],
       [ 1,  1]]))
('AB:\n', array([[0, 2],
       [0, 4]]))<jupyter_text>IndexingThe numpy arrays can be indexed in various ways, using the [] operator. Note that in numpy, the indexes start at 0.Example:<jupyter_code>A = np.array([[1,2,3],
              [4,5,6]])
print(A)<jupyter_output>[[1 2 3]
 [4 5 6]]<jupyter_text>A has 2 rows and 3 columns.<jupyter_code>print(A[0,1]) # retourne "2": l'élément de la ligne 0, colonne 1
print(A[1,2]) # retourne "6": l'élément de la ligne 1, colonne 2
A [2,0] # Error: Cette matrice a que 2 lines<jupyter_output>2
6<jupyter_text>En Python, on peut utiliser le symbol ":" pour indexer. Utilisé seul, le symbol veut dire soit "tous les lignes ou tous les colonnes"<jupyter_code>print(A[:,0]) # returns [1, 4] - la colonne 0

print(A[1,:]) # returns [4,5,6] - la ligne 1<jupyter_output>[1 4]
[4 5 6]<jupyter_text>On peut également utiliser le symbol ":" pour indexer partiellement une matrice<jupyter_code>print(A[0,1:]) # retourne [2,3]: l'élément de la ligne 0, colonne 1 à la fin

print(A[0,: 2]) # retourne [1,2]: l'élément de la ligne 0, colonne 0 jusqu'à 2 (= retourn colonne 0 et 1)<jupyter_output>[2 3]
[1 2]<jupyter_text>Python list à Numpy arrayIl est très facile de convertir de Python list a numpy array<jupyter_code>l = [[1,2,3], [4,5,6]]
print(l)
na = np.array(l)
print(na)<jupyter_output>[[1, 2, 3], [4, 5, 6]]
[[1 2 3]
 [4 5 6]]<jupyter_text>MatplotlibMatplotlib est un package permettant d'afficher les figures.<jupyter_code>%matplotlib inline   
import matplotlib.pyplot as plt
x = np.arange(0,2*np.pi,0.1) #On crée une liste x de 0 à 2 * PI avec un pas de 0.1
#print x
y = np.sin(x) #On applique la fonction sinus sur la liste x
#print y

plt.plot(x,y,'o')
plt.xlabel('x axis')
plt.ylabel('y axis')
plt.title('Easy')
plt.grid(True)
plt.show()<jupyter_output><empty_output><jupyter_text>Image HandlingIl y a plusieurs façon de charger une image en Python. On peut utiliser cv2(opencv), matplotlib out scikit. Tous ces packages ont une chose en commun, les images chargés par n'importe quel de ces packages se trouveront sous le format matricielle<jupyter_code># En utilisant scipy
from scipy.misc import imread, imshow

imgMatrix1 = imread("path/to/image.jpg") #imgMatrix1 est en RGB
plt.imshow(imgMatrix1)
#En utilisant opencv
import cv2

imgMatrix2 = cv2.imread("path/to/image.jpg") #imgMatrix2 est en BGR
# Conversion de opencv à scipy
from skimage import img_as_float
image = img_as_float(imgMatrix2) #imgMatrix2 une image chargée avec opencv
from skimage import img_as_ubyte
cv_image = img_as_ubyte(imgMatrix1) #imgMatrix1 une image chargée avec skimage<jupyter_output><empty_output><jupyter_text>AidePour connaitre les informations vous pouvez utiliser la commande "?" pour l'aide en ligne.Vous pouvez également utiliser la fonciton "help" pour avoir des information sur un object de Python<jupyter_code>help(list)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10804675018918691, 'fraction_numerical': 0.024720423778693348, 'mean_word_length': 3.6570086139389195, 'pattern_counts': {'":': 4, '<': 85, '<?xml version=': 0, '>': 86, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 14, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '25', 'dir': 'jupyter-structured-clean-dedup', 'id': '514203', 'license': 'MIT', 'n_tokens_mistral': 4235, 'n_tokens_neox': 4104, 'n_words': 1456, 'path': 'GTI770-TP00.ipynb', 'repo_name': 'DrunkReaperMatt/gti770-student-framework', 'size': '11893'}