was successfully added to your cart.
Category

Informatique

Manipulation de fichiers Excel en Python

Manipulation de documents Excel en Python

By | Débutant Raspberry Pi, Informatique | No Comments

Il y a peu, j’abordai la manipulation de fichiers basiques en Python au sein d’un article. Aujourd’hui, j’ai souhaité vous présenter les fondamentaux de l’utilisation de fichiers Excel sous Python. En effet, Excel permet l’organisation et le traitement d’un grand nombre de données mais, on peut aussi supposer avoir préparer un document sous Excel afin qu’il soit lisible par n’importe quel individu, et d’avoir besoin pour un quelconque traitement informatique d’importer ce document sous Python.
Bien sûr, il m’est compliqué de m’adapter à toutes les situations. La diversité des documents Excel ne permet pas de réaliser un article « universel » qui traiterait de tous les cas possibles de document sur Excel. Je me limiterai à un document relativement simpliste que je présenterai dans quelques lignes… Etant donné que le logiciel Excel permet de gérer des documents multipages, j’aborderai aussi cette notion.

Dès lors, et avant d’aller plus loin dans cet article, il nous sera nécessaire d’utiliser (et donc d’avoir installé) la librairie « xlrd » sous Python. Je vous renvoie pour cela au cours sur l’installation de librairie sous Python grâce à l’utilitaire pip. Vous aurez simplement besoin de connaitre le nom de la librairie telle que pip la connait, à savoir « xlrd ». Pour ceux d’entre-vous qui ont parcouru rapidement l’article traitant de cet utilitaire, je vous donne tout de même directement la ligne de commande permettant l’installation de la librairie :

1
pip install xlrd

Si vous rencontrez des problèmes à l’installation, pensez à lire notre article sur l’utilitaire pip, j’insiste sur ce point car on y traite certains problèmes qui peuvent être récurrents avec cet utilitaire…

Si l’installation s’est correctement déroulée, alors vous êtes fin prêt et nous allons pouvoir commencer ensemble en important notre premier fichier Excel dans Python.

1- Première importation et manipulations

Afin d’uniformiser le tutoriel, je vous propose d’utiliser une feuille de calcul dont la structure est semblable à celle-ci :

Capture d'écran feuille de calcul Excel 1

Capture d’écran de la première feuille de calcul de notre document Excel

Capture d'écran feuille de calcul Excel 2

Capture d’écran de la seconde feuille de calcul de notre document Excel

C’est un document Excel en deux feuilles de calcul dont la première (image de gauche) représente les images de la fonction f(x) = x^2 + 4 pour les x donnés et la seconde (image de droite) représente les images de f(x) = x^3 + 4
Notre objectif sera de récupérer sous Python ces données et d’en afficher les courbes représentatives. J’utiliserai d’ailleurs pour cela la bibliothèque matplotlib que vous pouvez installer depuis pip si vous le souhaitez. Si vous n’installez pas cette librairie, vous pourrez tout de même suivre ce tutoriel, le tracé sera la seule partie que vous ne pourrez pas exécuter. A ce propos, je ne détaillerai pas les fonctions utilisées pour le tracé (mais les codes seront fournis). L’utilisation de la bibliothèque matplotlib fera l’objet d’un article à part entière étant donné le fait que ce soit une librairie très complète.

La première étape consiste bien sûr à importer la librairie dans Python et à ouvrir notre fichier. Pour l’import de la librairie, on utilisera le classique

1
import xlrd

Et l’importation du document dans Python se fait au moyen de la fonction « open_workbook » de la librairie xlrd :

1
document = xlrd.open_workbook("document_excel.xlsx")

On veillera alors à bien placer notre fichier Excel dans le même répertoire que le fichier Python. Dans le cas contraire, on devra indiquer un chemin relatif vers le fichier (exemple « ../document_excel.xlsx » si le document se situe dans le dossier parent du fichier Python)

On peut alors accéder à quelques propriétés intéressantes, notamment le nombre de feuilles que contient notre document Excel (dans notre cas, 2) et le nom de chacune de ces feuilles sous la forme d’une liste. Cela s’obtient de la manière suivante :

1
2
print("Nombre de feuilles: "+str(document.nsheets))
print("Noms des feuilles: "+str(document.sheet_names()))

Vous noterez que je décide d’afficher ces données au moyen de « print ».
Mais l’objectif finalement, c’est de pouvoir récupérer les données que l’on a précédemment enregistré dans nos feuilles de calcul. Pour cela, on doit donc logiquement sélectionner notre première feuille de calcul, récupérer nos données, sélectionner la seconde, et ainsi de suite. On doit donc utiliser la fonction « sheet_by_index ». Au passage, il existe une fonction « sheet_by_name » qui fonctionne de la même manière en spécifiant simplement le nom de la feuille de calcul en paramètre. Je préfère utiliser la première fonction car je n’ai pas à faire attention à des caractères particuliers, espaces ou autres « altérations » possibles de ma chaine de caractère. Pour l’intérêt pédagogique, j’inclue cependant dans le script suivant les deux structures.

1
2
feuille_1 = document.sheet_by_index(0)
feuille_1 = document.sheet_by_name("Fonction 1")

Maintenant, j’ai dans l’objet « feuille_1 » la possibilité de retrouver toutes mes données. Mais avant de les obtenir, je vais avoir besoin d’accéder aux dimensions de ma feuille (nombre de lignes et de colonnes). J’ai pour cela la possibilité d’accéder à certaines informations de ma feuille, notamment son nom, son nombre de lignes et son nombre de colonnes au moyen des fonctions suivantes :

1
2
3
4
print("Format de la feuille 1:")
print("Nom: "+str(feuille_1.name))
print("Nombre de lignes: "+str(feuille_1.nrows))
print("Nombre de colonnes: "+str(feuille_1.ncols))

Vous remarquerez que je décide encore une fois d’afficher ces informations mais je vais dès à présent les stocker dans des variables que j’aurai sans doute l’occasion d’utiliser plus tard :

1
2
cols = feuille_1.ncols
rows = feuille_1.nrows

Vient alors le moment tant attendu, celui d’accéder à mes données. Pour cela, j’ai deux manières de procéder. La première, que je qualifierai de méthode bourrine, serait de parcourir toutes les lignes et colonnes de mon document et de tout stocker dans un tableau. Cette méthode a l’avantage de ne pas nécessiter la connaissance préalable du format du document Excel. Cependant, ce n’est pas la méthode que je souhaite utiliser ici. Je vais privilégier une méthode plus élégante étant donné que je sais déjà que ma première colonne contient mes valeurs de x  et la seconde de f(x) . Au passage, je n’oublie pas que ma première ligne me sert à nommer les colonnes afin de pouvoir comprendre le document Excel si un jour me viens l’envie de le relire. Alors ma « sélection » de données sous Python devra commencer à la seconde ligne.
Pour sélectionner la valeur d’une cellule dont je connais la ligne et la colonne, j’utilise la fonction suivante :

1
2
cellule = feuille_1.cell_value(rowx=1, colx=0)
print(cellule)

Attention, les cellules sont numérotées en partant de 0 pour leur ligne et leur colonne. Cela signifie que la cellule tout en haut à gauche est en position (0, 0)  et non (1, 1) . Si cela vous semble être une mauvaise idée de la part des concepteurs de Python, sachez qu’en fait, cela va nous permettre de parcourir très facilement nos lignes et colonnes. Par ailleurs, sachez que dans la plupart des langages de programmation, les tableaux démarrent à l’index 0 et que donc Python essaye, au moins sur ce coup, d’être en accord avec les autres…
En parcourant donc ma feuille de calcul à l’aide d’une boucle for pour former mes listes X et Y qui contiennent respectivement les valeurs de x  et de f(x) , j’en viens à adopter la structure suivante :

1
2
3
4
5
X = []
Y= []
for r in range(1, rows):
    X += [feuille_1.cell_value(rowx=r, colx=0)]
    Y += [feuille_1.cell_value(rowx=r, colx=1)]

Et je peux alors former très rapidement le graphe représentatif de ma fonction :

1
2
plt.plot(X, Y)
plt.show()

Et voici finalement mon script au complet :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import xlrd
import matplotlib.pyplot as plt
 
document = xlrd.open_workbook("document_excel.xlsx")
 
print("Nombre de feuilles: "+str(document.nsheets))
print("Noms des feuilles: "+str(document.sheet_names()))
 
feuille_1 = document.sheet_by_index(0)
feuille_1 = document.sheet_by_name("Fonction 1")
 
print("Format de la feuille 1:")
print("Nom: "+str(feuille_1.name))
print("Nombre de lignes: "+str(feuille_1.nrows))
print("Nombre de colonnes: "+str(feuille_1.ncols))
 
cols = feuille_1.ncols
rows = feuille_1.nrows
 
X = []
Y= []
 
for r in range(1, rows):
    X += [feuille_1.cell_value(rowx=r, colx=0)]
    Y += [feuille_1.cell_value(rowx=r, colx=1)]
 
plt.plot(X, Y)
plt.show()

Ce script fonctionne parfaitement pour la feuille 1 et je vous laisse libre soin de l’adapter pour la feuille 2 (les modifications sont infimes…)

2- Conclusion

En conclusion, j’ai souhaité vous démontrer ici toute la simplicité de l’utilisation d’Excel en collaboration avec Python. Si l’exemple que nous avons abordé ici n’est pas d’une pertinence absolue étant donné que l’on aurait pu directement tracer la courbe sur Excel ou obtenir la fonction sous Python, il a au moins le mérite d’être simple et d’expliquer clairement les fondamentaux de la manipulation de documents Excel.
Nul doute que nous serons amenés plus tard à manipuler des fichiers d’une manières plus avancés, notamment parce qu’un document Excel permet le stockage ordonné d’un grand nombre de données et semble donc parfaitement adapté à une utilisation pour le Machine Learning…

D’ici là, vous pouvez vous entrainer sur des classeurs Excel de votre composition afin de manipuler correctement les fondamentaux de la librairie xlrd. Si vous êtes curieux, sachez que le projet xlrd et disponible sur Github à l’adresse suivante : https://github.com/python-excel/xlrd et que vous y aurez tout loisir de découvrir comment fonctionne cette bibliothèque (attention, si vous débutez, vous risquez de vous perdre au milieu de toutes ces lignes de code…)

Fabien A.

Calcul intégral en Python

Calcul approché d’intégrales: Méthode des rectangles

By | Débutant Raspberry Pi, Informatique | One Comment

1- Introduction au calcul intégral

Deux raisons ont pu vous pousser à la lecture de cet article. La première, c’est que vous connaissez le calcul intégral dans sa définition mathématique et que vous cherchez simplement à comprendre comment implémenter de tels calculs en Python (ou tout autre langage de programmation). La seconde, c’est que vous avez été attiré ici par votre esprit de curiosité.
Dans tous les cas, vous avez fait le bon choix. Le calcul intégral tient une place essentielle dans l’acquisition de données (au moyen, par exemple, d’un accéléromètre/gyroscope) ou le traitement de données (aspect probabiliste, statistiques, etc…)

On introduit généralement le calcul d’intégrales au lycée comme le fait de calculer « l’aire sous la courbe d’une fonction ». Plus généralement, le calcul d’intégrales permet aussi de déterminer des primitives de fonctions connues, c’est-à-dire des fonctions qui, lorsque nous calculerons leurs dérivées, nous donneront la fonction de départ.

Concrètement, si je cherche à calculer la primitive d’une fonction , je serai amené à effectuer le calcul suivant :

F(x) = \int f(x) dx

Le symbole \int , sorte de S étiré, provient en fait historiquement de la déformation du S de « somme ». En fait, une intégrale n’est qu’une somme qu’on qualifie de continue, c’est-à-dire que sa variable d’intégration peut prendre toutes les valeurs comprises entre les bornes a et b. Dans notre exemple, cela signifie que x \in [a, b]  ou encore, a \leq x \leq b  lorsque nous calculerons l’intégrale.
Si je m’attarde sur la notion mathématiques, c’est parce qu’elle va me permettre de justifier de l’utilité du calcul intégral et de la nécessité d’avoir développé des méthodes informatiques permettant son implémentation.
Lorsque l’on calcul « à la main » une intégrale, on se retrouve à déterminer la primitive de la fonction de manière instinctive, en utilisant les primitives que l’on connait déjà et en « bidouillant » la fonction de départ de sorte à la décomposer comme somme ou composée de fonctions dont on connait les primitives. On voit ici que l’instinct humain est essentiel dans la démarche et que l’on ne peut donc pas implémenter un tel algorithme sur un ordinateur. Pourtant, son calcul est absolument essentiel. Un exemple simple : On sait que la vitesse d’un point se définie comme la dérivée par rapport au temps de sa position, c’est-à-dire le quotient de la variation de sa position sur un intervalle de temps aussi petit que possible. En particulier, on écrit :
v(t) = \frac{dx(t)}{dt}

Il en va de même pour l’accélération qui prend cette fois-ci la valeur de la dérivée de la vitesse (variation de la vitesse sur un instant donné) :
a(t) = \frac{dv(t)}{dt}

Alors, étant donné qu’un accéléromètre ne nous délivre qu’une variation d’accélération, on veut pouvoir remonter facilement à la position angulaire de notre système. On va donc procéder à une double intégration :
a(t) = \frac{dv(t)}{dt} = \frac{dx(t)}{dt} \Leftrightarrow x(t) = \int \!\!\! \int a(t) dt

Le calcul d’intégrales est donc absolument nécessaire dans ce cas mais ce n’est qu’un cas parmi tant d’autres que vous pourrez rencontrer.
Ainsi, si vous êtes par exemple étudiant et que l’on vous propose d’apprendre à utiliser la méthode des rectangles, vous ne pouvez négliger ce point. C’est un outil essentiel dans votre vie d’étudiant qui pourrait vous permettre de résoudre de nombreux problèmes.

Là est l’intérêt de la définition comme « aire sous la courbe » d’une fonction pour une intégrale. En effet, si l’on ne peut apprendre à un ordinateur à déterminer une primitive, il semble déjà plus facile de l’amener à calculer une aire. Et pour faciliter encore plus le travail, le mathématicien allemand Bernhard Riemann a proposé de simplifier cette aire en une succession de petits rectangles de la manière suivante :

Méthode des rectangles: principe

Illustration du principe de la méthode des rectangles

Je vous propose donc de développer un petit script Python qui se chargera pour nous de calculer l’aire sous la courbe, c’est-à-dire l’intégrale, d’une fonction entre deux points.

2- Programme

Je vous propose de commencer sans attendre en définissant une fonction. Nous utiliserons dans cette exemple la fonction la plus simple qui soit :

f(x) = x

C’est une fonction linéaire, très simple, dont tout étudiant de prépa connait particulièrement bien l’intégrale entre 1 et 2 qui vaut \frac{3}{2} et entre 1 et 3 qui vaut \frac{5}{2}. Cela nous permettra de vérifier rapidement la validité de notre programme.
J’introduis donc ma fonction f(x) dans Python :

1
2
def f(x):
    return x

Ensuite, je vous propose la même image que précédemment afin d’expliquer le principe de la méthode des rectangles :

Méthode des rectangles: principe

Illustration du principe de la méthode des rectangles

Sur cette image, on repère les deux bornes d’intégrations, a et b, et ce que l’on appelle les subdivisions. Le nombre de subdivisions, c’est en fait le nombre de rectangles et il correspond à la précision de calcul de l’intégrale. Plus ce nombre est grand, plus le calcul est précis mais plus il est long à réaliser. Il y a donc un juste milieu à déterminer…

Cette variation sur la précision vient des écarts que l’on repère entre les rectangles et la courbes. Plus les rectangles sont nombreux entre les bornes a et b, plus ces écarts sont faibles. Voici pour preuve le même calcul d’intégrale illustré avec un nombre n de subdivision supérieur au précédent :

Méthode des rectangles: précision

Illustration de l’importance du nombre de subdivisions dans la méthode des rectangles

L’objectif va donc être de calculer l’aire de chacun des rectangles et d’en faire la somme avant de l’afficher à l’utilisateur. Pour cela, je vous propose le schéma suivant, situation simplifié qui va me permettre de détailler le calcul de l’aire d’un rectangle de la méthode (on a pris ici n=2, soit 2 subdivisions entre les bornes a et b).

Méthode des rectangles: modèle à n=2

Illustration de la méthode des rectangles avec n=2 subdivisions

On remarque que les dimensions des rectangles sont de \frac{b-a}{n}  en largeur et de f\left (a + k*\frac{b-a}{n}\right )  en hauteur. J’explique ces valeurs : La valeur \frac{b-a}{n}  traduit le fait que l’on découpe l’intervalle [a, b]  en n subdivisions. Vous pourrez vous convaincre seul sur un dessin à main levé qu’alors, si l’on veut diviser cet intervalle en n subdivisions, la « largeur » de chaque subdivision sera de \frac{b-a}{n} . Pour la valeur f\left (a + k*\frac{b-a}{n}\right ) , l’idée est la même. La partie gauche du rectangle (celle à laquelle est calculée la hauteur du rectangle) correspond en fait à la valeur de la borne inférieure (a ici) à laquelle on a ajouté k fois la largeur des rectangles. Le k correspond à « l’index » de chacun des rectangles. Le premier a pour index 0, le second 1, etc… Cette variable k a surtout l’avantage de pouvoir être traduite simplement en Python. Ainsi, le calcul de l’aire d’un rectangle s’effectue de la manière suivante :

1
2
3
4
5
6
a = 1
b = 2
 
largeur = (b-a)/n
hauteur = f(a + k*(b-a)/n)
aire = largeur * hauteur

Attention : Cette structure n’est pas directement valable en Python et, si vous tentez de l’exécuter, devrait vous renvoyer une erreur car la variable k n’est pas définie

Alors le calcul de la somme se révèle être très simple à l’aide d’un boucle for :

1
2
3
4
5
6
7
8
9
10
11
12
a = 1    # Borne d'intégration inférieure
b = 2    # Borne d'intégration supérieure
n = 20   # Nombre de subdivisions
 
integrale = 0   # Variable stockant la somme des aires
for k in range(0, n):
    largeur = (b-a)/n
    hauteur = f(a + k*(b-a)/n)
    aire = largeur * hauteur
    integrale += aire
 
print(integrale)

Puis le script final :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def f(x):
    return x
 
a = 1    # Borne d'intégration inférieure
b = 2    # Borne d'intégration supérieure
n = 20   # Nombre de subdivisions
 
integrale = 0   # Variable stockant la somme des aires
for k in range(0, n):
    largeur = (b-a)/n
    hauteur = f(a + k*(b-a)/n)
    aire = largeur * hauteur
    integrale += aire
 
print(integrale)

Si vous exécutez ce script, vous devriez obtenir une valeur d’intégrale de 1.47 environ, étonnement proche de la valeur \frac{3}{2}   ne trouvez-vous pas ? Vous aurez tout loisir d’augmenter le nombre de subdivisions pour voir les conséquences sur la précision du calcul. De même, vous avez la possibilité de changer les bornes d’intégration et même la fonction à intégrer.

3- Conclusion

Vous l’aurez vu par vous-même, la méthode d’intégration dite « des rectangles » est en fait relativement simple à mettre en œuvre en Python mais aussi dans d’autres langages dont nous avons l’habitude ici (Java, C++, etc…)
C’est une méthode essentielle dans la manipulation de certains capteurs et qui permet d’obtenir une précision convenable en un minimum de temps (tant au développement qu’à l’exécution du programme)

J’espère dans cet article être parvenu à vous transmettre les fondamentaux du calcul d’intégrales par des méthodes informatiques. Dans le cas contraire, n’hésitez pas à commenter cet article (d’ailleurs, si vous l’avez aimé, vous pourrez aussi nous en faire part ;-))

Fabien A.

Gestion de fichiers

Manipulation de fichiers en Python

By | Débutant Raspberry Pi, Informatique | 4 Comments

1-    Introduction à la manipulation de fichiers

Vous aurez sans doute l’occasion d’être confronté, de manière régulière, à de la gestion de données plus ou moins massives. Qu’elles proviennent de capteurs ou d’informations d’utilisateurs, les données sont en fait absolument essentielles à n’importe quel projet. Plus encore, depuis quelques années, on s’intéresse au Big Data où, cette fois-ci, les données deviennent des marchandises que l’on peut s’échanger et qui possèdent une grande valeur.

Pourtant, traiter un grand volume de données n’a pas toujours été facile dans l’histoire de l’informatique. Aujourd’hui, à l’heure du tera-octet de données sur un ordinateur portable, on développe des jeux ou des programmes de plusieurs giga-octets. Pourtant, quelques années en arrière, on comptait encore en kilobits, kilo-octet ou autres unités qui nous semble maintenant désuètes. Il serait bon parfois de repenser à cet ancien temps où le travail du développeur était d’optimiser ses programmes et où cette dernière jouait en rôle absolument essentiel dans la qualité d’un programme.

Bref, aujourd’hui, tout cela est dépassé. On peut traiter plusieurs tera-octets de données sans que cela ne choque plus personne. On a su développer des outils performants nous permettant de traiter de tels volumes de données. Ces outils, on les utilises d’ailleurs parfois à torts et à travers, on utilise la hache pour abattre une tulipe.
L’idée de la manipulation de fichier, c’est de stocker des données sous une autre forme que celle d’une base de données par exemple. En fait, c’est d’être capable de les enregistrer dans un fichier texte de manière formatée et d’être ensuite capable de travailler sur ce fichier. Cela a pour avantage de ne pas nécessiter la mise en place d’un serveur de base de données et donc de faire gagner plus ou moins de temps dans la réalisation de nos « petits » projets personnels.

J’insiste. L’idée de ce tutoriel est bien de nous porter sur la manipulation de fichier d’une manière basique. Je n’aborderai pas les notions de JSON ou la manipulation de feuilles de calculs excel (pourtant très utiles par ailleurs). Peut-être cela viendra-t-il plus tard mais on peut aussi se dire que dès lors que les données sont « importées » dans Python, alors on est théoriquement capable de faire tout le traitement…

L’avantage de ce tutoriel, c’est qu’il ne nécessite aucune bibliothèque. De plus, il est là pour poser les bases d’une série de tutoriels en préparation et qui nécessitera de maitriser les fichiers et les données diverses et variées de manière agile afin d’être en mesure de se consacrer sur le traitement en lui-même. Croyez-moi, en préparant ce tutoriel, vous prendrez une avance essentielle sur la suite et pourrez donc suivre la série de manière plus « détendue »…

2-    Manipulons des fichiers

A-     Création d’un fichier et écriture

Il est alors temps de nous lancer, de créer notre propre fichier. Pour cela, deux moyens s’offrent à nous. Le premier, c’est créer bêtement un fichier texte dans lequel on rentre nos données manuellement. Le second, c’est de créer ce même fichier depuis Python, cela aura pour avantage de nous permettre une génération pseudo-aléatoire (l’aléatoire en informatique est une notion bien délicate).
Bien sûr, vous avez aussi la possibilité d’utiliser un fichier que vous aurez généré par exemple depuis votre Arduino lors de l’acquisition de données et de leur enregistrement sur une carte SD.

La création d’un fichier nécessite de connaitre les trois modes d’ouverture d’un fichier depuis Python :

r Ouverture du fichier en mode lecture uniquement
w Ouverture du fichier en mode écriture seulement
a Ouverture du fichier en mode ‘append’, c’est-à-dire que l’on ajoute du contenu en fin de fichier

 

Mais quelle est donc la différence entre le mode ‘w’ – write – et ‘a’ – append ?
En fait, la différence réside dans l’idée que le mode écriture permet d’écrire dans le fichier en écrasant ce qu’il contient déjà. Le mode ajout quant à lui permet de rajouter du contenu en fin de fichier, en préservant ce qui est déjà enregistré.

L’ouverture d’un fichier en Python s’effectue à l’aide de la commande suivante :

1
file = open(chemin_vers_le_fichier, mode_d_ouverture)

Par exemple :

1
file = open(‘donnees_meteo.txt, ‘w’)

Aussitôt la fonction open() introduite, je tiens à introduire la fonction close(). De la même manière que l’on range un livre après l’avoir pris dans la bibliothèque, on doit « ranger » le fichier que l’on a édité. C’est précisément ce que permet la fonction close, elle s’utilise alors de la manière suivante :

1
file.close()

En reprenant la notation introduite pour l’ouverture du fichier.
Pour écrire dans le fichier, cela reste relativement facile en utilisant la fonction ‘write’ à bon escient de la manière suivante :

1
file.write(‘Hello world !)

On peut alors utiliser les caractères « \n » et « \r » pour insérer des retours à la ligne / retour chariot afin de formater un minimum notre fichier.

\n New line – Nouvelle ligne Permet de revenir à la ligne (équivalent d’un appui sur la touche entrée sur Word )
\r Carriage return – Retour chariot Renvoie le curseur d’écriture en début de ligne

 

Pour résumer cette première partie, voilà le code qui m’a permis de créer un fichier « premier_fichier.txt » dans le même répertoire que mon script Python.

 

1
2
3
file = open("premier_fichier.txt", "w")
file.write("Hello world !")
file.close()

B-     Lecture d’un fichier

Vous êtes donc désormais en mesure de créer et d’éditer un fichier mais l’utilité serait bien faible si l’on ne pouvait pas le lire à nouveau ensuite. La méthode de lecture d’un fichier est très semblable à celle de l’écriture. L’idée est toujours d’ouvrir le fichier puis de travailler dessus. Cependant, il n’est pas forcément très facile de traiter les données qui arrivent du fichier. On récupère le plus souvent une chaine de texte brute contenant l’ensemble du fichier, dans le meilleur des cas un tableau contenant chacune des lignes. L’objectif est alors d’effectuer un pré-traitement permettant de formater correctement les données.

Ainsi, pour ce tutoriel, j’ai décidé de vous montrer de quelle manière on pouvait passer d’un fichier semblable au suivant dans sa structure :

1
2
3
4
5
Numero_du_point, abscisse, ordonnée
Numero_du_point, abscisse, ordonnée
Numero_du_point, abscisse, ordonnée
Numero_du_point, abscisse, ordonnée
etc...

 

A un simple tableau contenant chacune des lignes et les présentant sous la forme d’une liste [Numero_du_point, abscisse, ordonnée]. Si l’exemple n’est pas général, j’ai pensé que c’était cependant un cas qui se présentait assez souvent. En effet, lors de l’enregistrement des données, par exemple depuis l’Arduino, on est en fait assez libre de la manière de le faire. On peut ainsi insérer facilement un séparateur (, ; . ! etc…) entre les différentes valeurs, ce qui permettra alors de retrouver plus aisément ensuite la liste originale des valeurs.

Partant donc d’un fichier semblable à celui présenté ci-dessus, on se propose de l’ouvrir en mode écriture :

1
fichier = open(‘mesures_altitude.txt, ‘r’)

Désormais, on a alors accès à l’intégralité des fonctions liées aux fichiers sur Python. On a alors un choix à faire. On peut choisir de lire l’intégralité du fichier et de stocker son contenu dans une variable sous la forme d’une chaine de caractères, ou alors on peut lire chacune des lignes et les stocker dans une liste que nous pourrons parcourir par la suite. C’est la second méthode que j’ai choisi ici mais vous pourrez utiliser la première à l’aide de la structure suivante et en utilisant astucieusement les quelques fonctions que je présenterai par la suite :

1
contenu = fichier.read()

Pour adopter ma méthode, on utilisera plus simplement la structure suivante :

1
lignes = fichier.readlines()

Alors, chaque ligne sera stockée dans une grande liste et sera terminé par un classique « \n » spécifiant un retour à la ligne. On a alors l’avantage de pouvoir itérer, c’est-à-dire parcourir, chacune des lignes en utilisant la structure suivante :

 

1
2
for ligne in lignes :
   # Faire quelque chose

 

Et je vous propose alors simplement d’afficher la ligne courante de la manière suivante :

1
2
for ligne in lignes :
   print(ligne)

 

Vous remarquerez alors la présence d’un double retour à la ligne (retour à la ligne + saut de ligne) à chaque affichage.

1
2
3
4
5
6
7
8
9
point_1, 9, 10
 
point_2, 6, 8
 
point_3, 1, 5
 
point_4, 6, 1
 
point_5, 9, 0

Pour gérer cela, je dois vous présenter la fonction replace() s’appliquant à une chaine de caractère. Elle s’utilise en spécifiant deux arguments. Le premier est le bout de chaine de caractère à remplacer. On peut aussi spécifier une expression régulière mais le sujet est alors bien trop vaste pour être détaillé ici. Le second argument quant à lui constitue la chaine de caractère de remplacement, c’est-à-dire celle qui viendra se substituer au bout de chaine de caractère que l’on souhaite remplacer.

Dans notre cas, le double retour à la ligne est en fait causé par le « \n » dont je vous ai parlé auparavant. On peut résoudre ce problème à l’aide de la structure suivante :

1
2
3
for ligne in lignes :
   ligne = ligne.replace(‘\n’, ‘’)
   print(ligne)

 

et l’on obtient alors dans mon cas l’affichage suivant :

1
2
3
4
5
point_1, 9, 10
point_2, 6, 8
point_3, 1, 5
point_4, 6, 1
point_5, 9, 0

 

Enfin, j’ai parlé au début de récupérer les points sous la forme d’une liste [numero, x, y]. Etant donné que mon fichier est correctement formaté, on peut directement utiliser la fonction split() qui s’utilise en spécifiant un argument, le séparateur, autour duquel on viendra « découper » notre chaine. Dans mon cas, le séparateur est « , » (j’insiste sur l’espace suivant la virgule). On utilise alors la syntaxe suivante pour former notre liste :

1
2
3
4
for ligne in lignes:
   ligne = ligne.replace('\n', '')
   donnees = ligne.split(', ')
   print(donnees)

 

Ici, j’ai fait le choix d’afficher les données mais l’on pourrait tout autant poursuivre le traitement (d’autant qu’à ce moment précis, donnees contient mes données sous la forme de 3 chaines de caractères, bien peu utile pour du traitement mathématique par exemple. On peut alors convertir les chaines de caractères à l’aide des classique fonctions de conversion de type (int(), float(), etc…)

Il nous reste alors à mettre en place un traitement des données, ce sera précisément l’étude que nous mènerons dans de prochains tutoriels.

 

3-    Conclusion

J’espère au travers de ce tutoriel, être parvenu à vous présenter les bases de la manipulation de fichiers en Python. L’idée n’est certainement pas de maitriser l’ensemble des outils existants pour de tels traitement. Au contraire, j’ai volontairement choisi de présenter les bases de la manipulation de fichiers et ce pour pouvoir m’attarder plus longuement sur le traitement à l’aide d’algorithme plus complexes.

Les fichiers textes ne sont pas les seuls moyens de stockage de données. Il me semble absolument essentiel de vous parler de la gestion de données via base de données SQL au sein d’un prochain tutoriel.

Ce que vous avez appris ici vous servira sans doute de manière courante en Python et, en tous les cas, vous permettra d’aborder plus sereinement certains de nos tutoriels.

 

Fabien A.

Image de une du tutoriel du plus ou moins

Le jeu du plus ou moins en Python

By | Informatique | No Comments

Vous avez sans doute tous déjà entendu parler du jeu basique en programmation « C’est plus, c’est moins« , et bien aujourd’hui, je vous propose de le développer ensemble.
C’est un jeu basique, que l’on crée lorsque l’on apprend à programmer.

Je vous rappelle les règles :

  • L’ordinateur choisit un nombre entier positif (compris entre 0 et 100 par exemple)
  • Nous devons taper un nombre :
    • Si le nombre tapé est plus grand que le nombre tiré par l’ordinateur, le message « C’est moins » apparaît à l’écran
    • Si le nombre tapé est plus grand que le nombre tiré par l’ordinateur, le message « C’est plus » apparaît à l’écran
    • Si le nombre tapé est égal au nombre tiré par l’ordinateur, un message de félicitation apparaît à l’écran

Après avoir pris connaissance des règles, passons à la partir programmation.
Grace aux règles énoncées si dessus, vous devriez commencer à voir quel type de programme nous allons devoir faire. Nous allons utiliser la boucle « while », ainsi que les conditions.

Tout d’abord, vous aurez besoin d’importer un module pour que l’ordinateur tire aléatoirement un nombre entier.
Pour cela, il suffit d’écrire :

1
import random as rd

Ensuite, nous devons déclarer une variable afin que l’ordinateur tire un nombre au hasard.

1
nombreTire = rd.randint(0, 100)  #La fonction "randint" de la bibliothèque « random » tire un nombre entier

Initialisons une variable qui prendra comme argument le nombre que l’on tapera sur le clavier.

1
nombreTape = 0

Maintenant, il suffit de créer la boucle afin de tester les conditions.

1
2
3
4
5
6
7
8
9
10
11
while nombreTape != nombreTire : 
      print("Tapez un nombre entier :")
      nombreTape = int(input())
      if nombreTape > nombreTire :
            print("c'est moins\n\n")
 
      elif nombreTape < nombreTire:
            print("c'est plus\n\n")
 
      else :
            print("c'est gagné")

 

Capture d'écran du script plus ou moins

Capture du script du jeu plus ou moins sur Python IDLE

 

Résultat du jeu plus ou moins

Capture d’écran de la console Python exécutant le script du plus ou moins

 

Après enregistrement et lancement du jeu, vous devriez avoir une fenêtre comme celle affichée.

Bon jeu.

NB : la balise « \t » permet de créer une tabulation La balise « \n » permet de créer un saut de ligne.
La dernière ligne de code « os.system(« pause ») » permet de stopper le programme et fermer la fenêtre. Elle n’est pas obligatoire. Sans ce bout de code, votre programme se fermera aussi, mais vous noterez une différence. (A vous d’en faire l’expérience).

Gregoire A.

Image de une du tutoriel de connexion SSH sur mac

Connexion SSH sur Mac OS

By | Informatique | No Comments

Bonjour,
Depuis le début, sur notre site, vous pouvez trouver des tutoriels sur l’utilisation des GPIO du raspberry, de capteurs spécifiques pour l’Arduino, etc… Mais nous n’avons jamais vraiment pris la peine de commencer par le début, en présentant simplement la manière de se connecter en ssh sur un ordinateur Mac ou linux afin de prendre le contrôle de votre Raspberry Pi à distance. Sur Windows, nous avons Putty qui nous permet de gérer simplement les connexions ssh. Pour Mac et Linux, l’opération est tout aussi simple mais elle nécessite de connaitre quelques commandes de console pour la mener à bien. Voici donc la marche à suivre.

Pour se connecter en ssh via Mac ou Linux, ouvrez l’application « Terminal » et entrez-y la commande suivante :

1
import random as rd

si vous vous connectez avec l’utilisateur « pi ».

Si vous avez déjà configuré le profil « root », vous pouvez vous y connecter avec la commande suivante :

1
nombreTire = rd.randint(0, 100)  #La fonction "randint" de la bibliothèque « random » tire un nombre entier

(Pour activer le profil « root », rendez-vous dans le tutoriel suivant : Mise en place du profil root.)

Vous avez alors la fenêtre suivante. Il faut accepter en entrant « yes », puis tapez sur « Entrée ».

Puis entrez le mot de passe requis.

Demande du mot de passe pour la connexion en ssh

Demande du terminal mac du mot de passe ssh de connexion au Raspberry

Vous êtes à présent connecté à votre raspberry.

Résultat de la connexion en ssh

Résultat obtenu sur le terminal mac une fois que la connexion en ssh est établie

Lors de la prochaine connexion un message d’erreur vous sera peut être affiché. C’est un problème d’identification.

Pour résoudre cela, tapez la commande suivante :

1
nombreTape = 0

puis tapez la commande afin de supprimer les clés déjà existantes

1
2
3
4
5
6
7
8
9
10
11
while nombreTape != nombreTire : 
      print("Tapez un nombre entier :")
      nombreTape = int(input())
      if nombreTape > nombreTire :
            print("c'est moins\n\n")
 
      elif nombreTape < nombreTire:
            print("c'est plus\n\n")
 
      else :
            print("c'est gagné")

Reconnectez vous avec la commande :

1
ssh root@IpDuRaspberry

 

Gregoire A.

Illustration du premier tutoriel C#

[Tuto 1]Découvrez le C# et la création d’apps Windows

By | Informatique | 2 Comments
    • I. Introduction

      Cela fait un petit bout de temps que l’idée mûrit dans ma tête. Etant fervent utilisateur de Windows, possédant un téléphone sous Windows Phone et voyant l’arrivée de Windows 10 avec les applications universelles pour les versions de Windows Bureau, Tablette et Phone comme une opportunité pour développer et répandre les applications, je me suis lancé dans l’apprentissage du langage C# prononcé « Cé-charpe ».
      Cela permettra de continuer le projet SimpleDomo sur cette plateforme.

 

    • II. Quel logiciel pour développer ?

      Afin de développer en C# il vous faudra un éditeur de code ainsi que d’un compilateur.
      Je vous conseille d’utiliser, à l’heure actuelle Visual Studio Express 2013 ou Visual Studio Community 2013.
      Vous pouvez dès à présent télécharger Visual Studio Community 2015 ICI et l’installer.
      Une fois installé, vous pouvez créer un nouveau projet en cliquant sur « File » puis sur « new » et « new project ». Une fenêtre comme suit va s’ouvrir:

      Fenetre Création de projet Visual Studio 2015

      Capture d’écran de la fenêtre de création de projet sous visual studio 2015 (community)

      Nous allons dans un premier temps apprendre à développer en C# à l’aide d’application console. Grâce à ses applications vous allez acquérir les bases nécessaires pour la réalisation de vos futures applications.
      Sélectionnez « Console Application » ( 3 ) puis nommez votre projet au ( 4 ).

 

    • III. Les bases

      Comme je l’ai expliqué précédemment, nous allons découvrir le C# à travers le programme console.
      A quoi ressemble une console ? En voici un bref aperçu :

      Console Windows

      Aperçu de la console Windows lancée via Visual Studio 2015 (community)

      Remarque: Vous pouvez commenter vos lignes de codes en faisant « // » suivi de votre commentaire sur une ligne de code, ou alors vous pouvez commenter un bloc de code en suivant la syntaxe suivante

      1
      
      ssh pi@IpDuRaspberry
      Capture d'écran des commentaires en C#

      Capture d’écran d’un script d’exemple contenant des commentaires en C# sous Visual Studio 2015 (community)

 

    • 1. Nos premières lignes de code

      En C# comme dans d’autres langages, toutes les instructions de terminent par un point-virgule « ; ». Sans ce point-virgule, le programme ne se compilera pas.
      Prenez donc le réflexe de toujours mettre un point-virgule après vos instructions.
      Pour ajouter du texte sur la console, il suffit d’écrire l’instruction :

      1
      
      ssh root@IpDuRaspberry

       

      Premier programme C# executé

      Aperçu du premier programme créé C# après exécution via Visual Studio 2015 (community)

      Vous pouvez remarquer que j’ai ajouté l’instruction :

      1
      
      ls ~/.ssh

       

      A la ligne 14 afin de laisser la console ouverte après exécution. En effet, si vous ne mettez pas cette instruction vous n’aurez le temps de voir votre message car le temps de compilation est dans ce cas de l’ordre de quelques millisecondes.

 

    • 2. Les variables

      Oui, le C#, comme tous les langages de programmations possèdent des variables susceptibles de sauvegarder des données. Ce sont en quelque sorte un « espace de stockage » qui peut contenir des nombres, des dates, des chaînes de caractères, des tableaux…
      Il existe pour cela différents types de variables. Je vous résume les plus utilisées dans le tableau ci-dessous.

      Type Description
      byte Entier de 0 à 255
      short Entier de -32768 à 32767
      int Entier de -2147483648 à 2147483647
      long Entier de -9223372036854775808 à 9223372036854775807
      float Nombre simple, précision de -3,402823e38 à 3,402823e38
      double Nombre simple, précision de -1,79769313486232e308 à 1,79769313486232e308
      decimal Nombre décimal
      char Représente un caractère
      string Représente une chaine de caractère
      bool Représente une valeur booléenne (true or false)

      Pour définir des variables, il suffit de spécifier le type, puis le nom de la variable puis sa valeur.
      Exemple :

      1
      
      ssh-keygen -R IpDuRaspberry

 

    • 3. Ecrire dans la console

      Nous avons déjà vu un peu plus tôt comment écrire dans la console grâce à l’instruction Console.WriteLine(« Hello World ! ») ;
      Vous pouvez aussi afficher des variables dans la console. Pour cela, il suffit d’écrire par exemple :

      1
      
      ssh root@IpDuRaspberry

      Vous allez obtenir le résultat suivant:

      Exemple affichage de texte dans la console

      Exécution du programme d’exemple expliquant la méthode pour afficher du texte dans la console Windows

 

    • 4. Interaction avec la console

      Que serait un programme sans pouvoir interagir avec ?
      Il est temps d’utiliser l’instruction Console.ReadLine() ;
      Pour récupérer les commandes tapées dans la console par votre clavier il faut utiliser la fonction Console.ReadLine().

      1
      
      String age = Console.ReadLine();
      Exécution d'un programme d'exemple d'input console

      Exécution d’un programme permettant la récupération d’un chaine de caractère saisie par l’utilisateur

Voilà pour le tutoriel de programmation du week-end !
Nous espérons que vous prenez autant de plaisir à la lecture de nos articles que celui que nous ressentons lors de leurs écritures.
A bientôt !

Thomas A.

illustration_tutorielJava1

[Tuto 1]Développer vos applis Android en JAVA

By | Informatique | No Comments
  • Introduction

    Depuis longtemps déjà, lorsque j’apprenais à développer des programmes basiques en C++ et JAVA, j’avais pour objectif de concevoir des applications pour les plateformes mobiles. Aujourd’hui, le développement sur ce genre de plateforme s’est simplifié, chaque concepteur d’OS mobile a développé un langage dédié à ses plateformes. Tous, sauf un, Android, développé par Google, qui a décidé d’utiliser le très connu JAVA pour la conception de ses applications.
    En fait, au-delà d’un simple JAVA, c’est un couple de langage que Google a choisi d’intégrer pour la conception d’applications. En effet, tout comme sur Windows Phone, l’utilisation du langage XAML a été privilégiée pour la mise en place des interfaces graphiques. En fait, cela peut paraitre plus complexe mais nous verrons ensemble par la suite à quel point cette structure particulière va nous permettre de simplifier nos scripts.
    Tout au long de ces tutoriels, j’aurai pour objectif de vous amener à la création de votre première application mobile. Pour suivre ce cours, vous n’aurez besoin d’aucune connaissance préliminaire dans un quelconque langage. Je vais vous apprendre toutes les fonctions de bases qui nous seront utiles par la suite. Bien évidemment, des connaissances en JAVA ou plus généralement, sur les structures des langages pourront vous être d’une grande utilité si vous voulez accélérer votre apprentissage.

  • Les Bases

    Avant de rentrer dans le monde de la programmation JAVA, je vous propose de faire le point sur les outils dont nous aurons besoin. Pour écrire nos programmes JAVA, nous aurons besoin d’un éditeur de script, de préférence avec une coloration syntaxique. Ensuite, pour les exécuter, nous aurons besoin d’un compilateur qui se chargera de préparer nos programmes à l’exécution. Nous aurons aussi besoin d’un gestionnaire de projet afin d’éviter d’avoir un grand nombre de fichiers différents à gérer depuis des dossiers différents. Et bien sachez que sur le terrain des environnements de développement, nous n’avons pas à nous plaindre. En effet, il existe un logiciel complet et puissant, Eclipse, qui va nous permettre à la fois d’éditer nos scripts, de les exécuter et de gérer le projet qu’ils constituent. Je vous propose donc de télécharger gratuitement ce logiciel à l’adresse suivante: https://www.eclipse.org/downloads/
    Prenez bien soin de choisir Eclipse IDE for Java Developers. Ensuite, vous pourrez installer cet IDE. Vous aurez besoin de télécharger et installer le JDK java correspondant à la version de java installée sur votre ordinateur. Vous devrez aussi télécharger et installer le JRE correspondant à votre version de Java. Personnellement, tout au long de ce tutoriel, j’utiliserai en majorité Java 7 ( et donc JRE 7 ) puisque c’est la version installée sur mon ordinateur pour des besoins de développement.
    Bien, désormais, tous nos outils sont en place. Vous pouvez dès à présent ouvrir Eclipse et choisir le répertoire par défaut de vos programmes grâce à la boite de dialogue qui s’ouvrira.
    Maintenant, vous devriez vous retrouver face à cette interface qui ne vous est pas forcément encore très familière:

     

    inteface_eclipse

    Interface du logiciel Eclipse IDE Java au démarrage

     

    Il est maintenant temps d’entrer dans le vif du sujet en créant votre premier projet Java. Pour cela, je vous propose de cliquer sur cette icône:

     

    barre_outilsEclipse_newProject

    Icône à sélectionner pour créer un nouveau projet

     

    Plus précisément, je vous propose de cliquer sur la petite flèche noire à côté de cette icône puis de choisir « Java Project »
    Là, vous devriez arriver sur la fenêtre suivante:

     

    fenetre_newProjectEclipse

    Fenêtre de dialogue ouverte lors de la création d’un projet Eclipse

     

    Bien que les options semblent nombreuses, nous n’avons ici qu’à saisir un nom de projet dans « Project Name », un dossier dans lequel notre projet sera créé en modifiant l’entrée « Location » (vous pouvez aussi choisir, comme moi, d’utiliser le répertoire par défaut que vous avez spécifié au lancement d’Eclipse ). Enfin, nous devons spécifier le « Java Runtime Environment » (JRE que vous avez installé précédemment ). Cependant, si toutes les installations se sont correctement déroulées, vous devriez avoir, par défaut, le JRE installée de présélectionné.
    Ensuite, nous pouvons cliquer sur Finish, ce qui aura pour effet de créer notre projet et ainsi d’ajouter un « dossier » sur la colonne gauche de l’interface d’Eclipse.
    Pour ma part, j’ai décidé d’appeler le projet Tutoriel_SimpleDuino.
    Nous allons désormais créer notre premier programme mais avant, il faut que vous sachiez que Java est un langage plutôt orienté objet, c’est-à-dire qu’il facilite l’implémentation de librairie personnelle (en quelque sorte). Ainsi, notre projet créé ne représente qu’un dossier dans lequel seront stockés nos scripts mais nous allons devoir créer une sorte de « librairie par défaut », un « package » en langage Java. Pour cela, nous pouvons dérouler le dossier de notre projet dans la colonne de gauche d’Eclipse puis effectuer un clic droit sur le dossier « src ». Nous sélectionnons ensuite New puis Package. Finalement, nous nous retrouvons face à la fenêtre suivante:

     

    fenetre_creationPackageEclipse

    Fenêtre de dialogue ouverte lors de la création d’un Package sous Eclipse

     

    Encore ici, nous n’avons qu’à spécifier un nom de Package dans le champ « Name ». Pour ma part, je choisis d’entrer le nom « part1 ». En cliquant sur Finish, vous pourrez apprécier la création du Package en déroulant le dossier « src » contenu dans votre projet. Maintenant, nous allons créer notre première classe. Nous allons écrire nos scripts dans une classe pour débuter puisque la programmation orientée objet fera l’objet d’un prochain tutoriel.
    Pour créer cette classe, nous allons effectuer un clic droit sur le Package récemment créé et nous allons choisir New puis Class. Désormais, nous sommes donc face à cette fenêtre:

     

    fenetre_creationClassEclipse

    Fenêtre de dialogue ouverte lors de la création d’une classe dans un Package sous Eclipse

     

    La création d’une classe est légèrement plus complexe. Evidemment, nous allons spécifier un nom pour la classe que nous allons créer. Pour ma part, je choisis « main » puisque ce sera la classe principale de mon Package « part1 ». Après avoir entré le nom de votre nouvelle classe, je vous propose de cocher la case « public static void main(String[] args) ». Cela aura pour effet de « dire » au programme que cette classe sera la principale, celle qu’il faudra exécuter par défaut. En fait, nous aurions pu écrire le code que cette case va générer à la main mais puisque Eclipse nous propose une telle option, autant en profiter. Enfin, après avoir nommé votre nouvelle classe et coché cette case pour spécifier le caractère principale de notre classe, vous pourrez cliquer sur Finish, ce qui aura pour effet d’ajouter la classe dans le Package créé précédemment et de l’ouvrir dans l’éditeur de scripts d’Eclipse.
    Notre première classe est créée, nous allons pouvoir commencer ensemble à développer un programme.
    La manipulation précédente doit avoir donné naissance au script suivant:

    1
    2
    3
    4
    
    /* Bonjour
    * je commente
    * sur plusieurs lignes
    */

    Je vous propose d’ajouter la possibilité d’afficher un texte à notre fichier main. Pour cela, nous allons utiliser la fonction « println() » héritée de « out », elle-même héritée de « System ». En effet, il faudra vous y faire, comme je l’ai écrit précédemment, Java est un langage orienté objet et privilégie donc la mise en place de librairies personnalisées. Vous serez donc régulièrement confrontés à des « fonctions » composées comme le « println() ». En fait, ce système a aussi un avantage: Vous constaterez rapidement que l’héritage des fonctions semble logique et qu’il vous permettra de mieux vous repérer dans votre script.
    Au final, la fonction « println() » est donc la suivante:

    1
    
    Console.WriteLine(« Hello World ! »);

    Et nous devrions avoir au final le script suivant:

    1
    
    Console.ReadLine();

    Désormais, pour l’exécuter, il nous suffit alors d’utiliser cette icône située dans la barre d’outils:

     

    barre_outilsEclipse_Compiler

    Icône à sélectionner pour lancer la compilation de votre premier programme

     

    Nous devrions alors nous retrouver avec le résultat suivant sur notre interface Eclipse. Notez bien l’impression du message dans la console.

     

    PremierProgramme_compilation

    Résultat attendu de votre premier programme JAVA une fois compilé

     

Merci d’avoir suivi cette première partie du tutoriel Java pour le développement d’applications Android, j’espère que celui-ci vous aura plu.
A bientôt pour un prochain tutoriel.

Fabien A.

illustration tutoriel SWIFT

[Tuto 1]Découvrir Swift pour iOS et OS X

By | Informatique | No Comments

I. Introduction

Depuis pas mal de temps je me disais qu’apprendre le langage Swift afin de développer des applications pour ma propre utilisation me serait plus que bénéfique. Je me suis enfin décidé à sauter le pas. Cela permettra également de continuer le projet Simple-Domo en l’adaptant à la plateforme iOS.
Je vais essayer d’être le plus clair possible afin que vous puissiez vous aussi apprendre ce langage. Nous verrons ensemble si nous avons besoin d’apprendre l’Objective-C.

II. Plan

Dans ce tutoriel, je vais aborder les bases du langage Swift. Le plan sera régulièrement mis à jour puisque ce tutoriel sera complété par d’autres articles pour continuer notre apprentissage.
Dans un premier temps, nous allons donc aborder les bases.

III. Les bases

A. Les Variables et Constantes

Qu’est ce qu’une variable ?
Une variable est un paramètre que l’on déclare en général en début de programme. C’est un « espace de stockage » que l’on attribue à un résultat.
Cette variable peut être un Nombre (Simple, Double), mais aussi un Caractère.

Pour déclarer une variable, on utilise l’acronyme « var »

1
2
3
4
5
6
7
8
9
package part1;
 
public class Main {
 
public static void main(String[] args) {
 
// TODO Auto-generated method stub
 
}

Les variables sont susceptibles de changer de valeur au cours du programme contrairement aux constantes que l’on déclare de la manière suivante :

1
System.out.println("Hello World");

B. Impression d’une fonction à l’écran

Le Langage Swift permet une syntaxe relativement facile pour afficher un texte à l’écran.

1
2
3
4
5
6
7
8
9
10
11
package part1;
 
public class Main {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("Hello World");
 
	}
 
}

Vous pouvez tester cette fonction en créant le fameux « Hello World ».

Exemple : Afficher « Hello World » à l’écran

1
println("Hello World") // C’est aussi simple que ça

Compilez et regardez la console.

C. Les tableaux

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var tableau1 = ["Lundi", "Mardi", "Mercredi", "Jeudi"]
tableau1.append("Vendredi")
println(tableau1) // [Lundi, Mardi, Mercredi, Jeudi, Vendredi]
 
var tableau2: [String] = [ ]
tableau2.append("4")
println(tableau2)
 
var tableau3: [Int] = [ ]
tableau3.append(4)
 
var tableau4: [Float] = [ ]
tableau4.append(5.4)
 
var semaine = ["Lundi", "Mardi", "Mercredi", "Vendredi"]
semaine.insert("Jeudi", atIndex: 3) // Ajouter "Jeudi" à la quatrième position dans le tableau "semaine"

Attention, dans un tableau, la première valeur correspond à l’indice 0. C’est à dire que pour l’exemple précédent, Lundi correspond à 0, Mardi à 1 et ainsi de suite.

1
2
3
var semaine = ["Lundi", "Mardi", "Mercredi", "Vendredi"]
semaine.insert("Jeudi", atIndex: 3)
semaine.removeAtIndex(2) // Permet de supprimer la valeur à la troisième position. C’est à dire Mercredi

D. Les Conditions

Après avoir appris comment déclarer des fonctions, nous allons apprendre les conditions.
Les conditions en Swift, se font de la même manière que les autres langages que l’on peut rencontrer. On utilise un « if ».

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
let heure = 19
if heure <= 12 {
      println("C’est le matin")
}
else if heure <= 19 {
      println("C’est l’après-midi")
}
else {
      println("C’est la nuit")
}
 
// C’est l’après-midi
 
let jours = 13
switch jours {
      case 1:
            println("Nous sommes le 1")
      case 2...15:
            println("Nous sommes entre le 2 et le 15")
      case 16, 17:
            println("Nous sommes le 16 ou 17 ")
      default:
            println("Nous sommes entre le 17 et la fin du mois")
}
 
// Nous sommes entre le 2 et le 15

E. Les Boucles

Les boucles « for » sont des actions qui se répètent autant de fois qu’on le souhaite.
« for » signifie « pour »

1
2
3
4
5
6
7
8
for var id = 1; id < 4; ++id {
      println("ajouter")
}
 
let couleur = ["Rouge", "Rose", "Vert"]
for k in couleur {
      println("Couleur : \(k)")
}
1
2
3
// Couleur : Rouge
// Couleur : Rose
// Couleur : Vert

Les boucles « while », « tant que » en français, exécutent une action tant que les conditions ne sont pas vérifiées.

1
2
var compteur = 0
while compteur < 10 { println("Je suis a \(compteur)") ++compteur } // tant que compteur est inférieur a 10, on affiche "Je suis a …" F.

F. Les Fonctions

À présent, nous allons apprendre à créer des fonctions.
Procédez de la manière suivante:

1
2
3
func addition(a: Int, b: Int) -> Int {
      return a + b
}

Au final, vous devriez avoir un éditeur xCode (PlayGround) qui ressemble à celui-ci:

ScreenShot Swift 1

Première capture d’écran du résultat attendu sur le tutoriel 1 Swift

ScreenShot Swift 2

Seconde capture d’écran du résultat attendu sur le tutoriel 1 Swift

Merci d’avoir suivi ce tutoriel.
Je vous prépare déjà la suite de ce cours qui vous permettra d’approfondir encore vos connaissances.

Grégoire A.

Image de une du tutoriel HTML/CSS

Tutoriel basique HTML/CSS

By | Informatique | No Comments

Bonjour à tous,

Nouveau tuto aujourd’hui pour vous présenter une partie de programmation dont vous aurez certainement besoin si vous souhaitez par la suite développer un système domotique relativement puissant et surtout agréable à utiliser. En effet, les deux langages que nous allons aborder aujourd’hui : HTML et CSS sont des langages qui vont vous permettre de développer des interfaces web et donc de donner un « visage » à votre application.

Vous allez pouvoir constater que ces langages ne sont pas complexes dans la mesure où ils sont assez « logiques ».

Dans un premier temps, nous allons aborder la programmation HTML, c’est la programmation essentielle à connaitre puisqu’elle va donner une forme à votre page. Le CSS lui sera chargé d’améliorer l’aspect de votre page, c’est-à-dire de styliser votre page.

Nous partons du principe que vous avez déjà téléchargé et installé Notepad++ ou équivalent (Sublime text 2, etc…). Pour tester vos pages html, il suffira de les enregistrer au format .html et de les ouvrir grâce à un navigateur classique : Google Chrome, Firefox, Opera, Internet Explorer

Ainsi, en html, il y a un « format  » de page que vous réutiliserez à chaque fois :

1
2
3
4
5
var exemple1: Int = 13 // exemple1 ne peut être qu’un "entier"
var exemple2 = 1.5
var exemple3 = "jour" // Les chaînes de caractères de déclarent entres guillemets "ceciEstUnCaractère"
var x = 1, y = 4, z = 5 // Permet de déclarer plusieurs variables à la suite
exemple1 = 3 // exemple1 vaut à present 3

Nous allons détailler ligne par ligne cette partie essentielle à votre page.

1
2
3
4
5
let constante1 = 12
let constante2 = "lundi"
let x = 5, y = 3 z = constante2 // Permet de déclarer plusieurs variables à la suite
let jours = 7
let nombreJours = "La semaine compte \(jours)" // la commande \(Fonction) permet de récupérer et afficher la valeur de la fonction

Ensuite, il y a quelques balises html à connaitre :

1
2
let dateAnniversaire = 13
println("L’anniversaire d’Hugo est le \(dateAnniversaire)") // Cette fonction vous permet d’afficher la phrase dans la console

Et enfin, la balise qui permet le retour à la ligne :

1
println("Hello World") // C’est aussi simple que ça

Vous remarquerez la plupart des balises est de la forme <ouverture><fermeture/>, c’est la forme la plus courante des balises html.

Toutes ces balises nous permettrons de constituer le corps de la page, mais en fait, que mettons-nous dans l’en-tête ?

Et bien nous allons définir l’encodage des caractères (les normes de caractères qui permettront par exemple d’afficher les é, è, à, etc…) ainsi que le titre qui s’affichera dans l’onglet du navigateur et enfin, les feuilles de styles (.css) qui s’occuperont de l’apparence de notre site.

Allez, c’est parti ! Codons notre première page :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var tableau1 = ["Lundi", "Mardi", "Mercredi", "Jeudi"]
tableau1.append("Vendredi")
println(tableau1) // [Lundi, Mardi, Mercredi, Jeudi, Vendredi]
 
var tableau2: [String] = [ ]
tableau2.append("4")
println(tableau2)
 
var tableau3: [Int] = [ ]
tableau3.append(4)
 
var tableau4: [Float] = [ ]
tableau4.append(5.4)
 
var semaine = ["Lundi", "Mardi", "Mercredi", "Vendredi"]
semaine.insert("Jeudi", atIndex: 3) // Ajouter "Jeudi" à la quatrième position dans le tableau "semaine"

<p>Voici la première page web que j’ai codé grâce au tutoriel disponible sur <a href= »https://simple-duino.com »>Simple-Duino

</body> </html>

Hein ? Quoi ?! Mais c’est tout moche !

Et bien oui, nous n’avons pas spécifié d’encodage dans notre en-tête donc les caractères spéciaux ne s’affichent pas. Pour l’encodage, je vous conseil la norme utf-8 qui contient la plupart des caractères spéciaux européens.

Ajoutons donc cette ligne :

1
2
3
var semaine = ["Lundi", "Mardi", "Mercredi", "Vendredi"]
semaine.insert("Jeudi", atIndex: 3)
semaine.removeAtIndex(2) // Permet de supprimer la valeur à la troisième position. C’est à dire Mercredi

dans notre en-tête et profitons-en pour ajouter un nom dans l’onglet du navigateur, toujours dans l’en-tête en ajoutant la balise :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
let heure = 19
if heure <= 12 {
      println("C’est le matin")
}
else if heure <= 19 {
      println("C’est l’après-midi")
}
else {
      println("C’est la nuit")
}
 
// C’est l’après-midi
 
let jours = 13
switch jours {
      case 1:
            println("Nous sommes le 1")
      case 2...15:
            println("Nous sommes entre le 2 et le 15")
      case 16, 17:
            println("Nous sommes le 16 ou 17 ")
      default:
            println("Nous sommes entre le 17 et la fin du mois")
}
 
// Nous sommes entre le 2 et le 15

Vous remarquerez que j’utilise la balise qui permet de placer des liens sur ma page. En fait, elle utilise une « condition  » : href qui va permettre de spécifier le lien. Ensuite, on place le texte souhaité entre les et notre lien est en place.

Maintenant, vous savez coder votre première page internet mais elle est quand même fade vous ne trouvez pas ? Allez, allons égayer tout ça.

Pour améliorer l’aspect de notre page, nous allons avoir besoin d’aborder la notion de classes. En fait, on peut spécifier des classes à chacune des balises html. On fait cela de manière très simple en ajoutant simplement class= « nom_de_la_classe  » à l’interieur de la balise :

On peut spécifier plusieurs classes en les séparant par un espace.

Bien, vous êtes désormais en mesure d’attribuer des classes à chacun des éléments de votre page. Nous allons donc créer un fichier style.css, l’enregistrer dans le même répertoire que votre première page et lier la page html au style css grâce à la balise suivante : à placer dans l’en-tête de votre page.

En attribuant une classe à chaques élements, on arrive donc au script de page html suivant :

1
2
3
4
5
6
7
8
for var id = 1; id < 4; ++id {
      println("ajouter")
}
 
let couleur = ["Rouge", "Rose", "Vert"]
for k in couleur {
      println("Couleur : \(k)")
}

<p class= »paragraphe1″ >Voici la première page web que j’ai codé grâce au tutoriel disponible sur Simple-Duino

</body> </html>

Maintenant, nous allons aborder les bases du css mais sachez qu’il existe une infinité de possibilité pour styliser votre page. Il existe de très nombreuses balises disponibles, tellement nombreuses que nous ne pouvons pas toutes les présenter.

Tout d’abord, il faut savoir que la structure de notre fichier .css est totalement différente de celle de notre page html. En effet, ici, on utilisera une structure de la forme suivante :

1
2
3
// Couleur : Rouge
// Couleur : Rose
// Couleur : Vert

Ou alors

1
2
var compteur = 0
while compteur < 10 { println("Je suis a \(compteur)") ++compteur } // tant que compteur est inférieur a 10, on affiche "Je suis a …" F.

Nous allons modifier un peu notre page.

Commençons par modifier la police utilisée sur notre site :

1
2
3
func addition(a: Int, b: Int) -> Int {
      return a + b
}

L’étoile nous permet de spécifier que toutes les balises devront adopter cette police de caractères.

Modifions aussi la couleur du texte :

1
color: #333333;

à ajouter entre les deux {} que nous avons mis en place précédemment.

Pour centrer notre texte, utilisons l’instruction suivante :

1
2
3
4
5
6
7
body
 
{
 
text-align :center ;
 
}

Modifions la couleur d’arrière-plan :

1
background-color : #eeeeee ;

à ajouter entre les deux {} du body précédemment défini

Soulignons notre titre :

1
2
3
4
5
6
7
.titre1
 
{
 
text-decoration : underline ;
 
}

Et faisons en sorte que notre lien soit en gras non-souligné :

1
2
3
4
5
6
7
8
9
a
 
{
 
text-decoration: none;
 
font-weight: bold;
 
}

Et qu’il change d’apparence lors du survol :

1
2
3
4
5
6
7
a:hover
 
{
 
opacity:0.7;
 
}

Et voilà ! Votre page commence à avoir un peu plus de style mais son apparence peut encore être améliorée.

apperçu

Vous avez désormais des bases essentielles en programmation html et css. En complément, nous ne pouvons que vous conseiller de visiter l’excellent tutoriel disponible sur le site d’openclassroom, ex-site du zéro réalisé par Mathieu Nebra :

http://openclassrooms.com/courses/apprenez-a-creer-votre-site-web-avec-html5-et-css3

Merci d’avoir suivi notre tutoriel et bonne continuation dans vos projets futurs…

A plus !