Author: Nathan M.

Tutoriels

Excel, un formidable outil informatique

Excel est un logiciel de type « tableur » développé par Microsoft faisant partie des logiciels de bureautique de la suite Microsoft Office au même titre que World, Power Point etc… Cependant si il n’était que cela, je ne prendrais pas la peine de vous le présenter. Mark Cuban, milliardaire et investisseur de Shark Tank disait lui-même que la maitrise Excel est l’une des compétences les plus importantes dans le monde professionnel.

Présentation générale d’un tableur

Dans le monde des entreprises désormais complètement informatisé, l’utilisation d’outils comme Excel est devenu indispensable. Le logiciel étant facile d’utilisation, il est accessible à tout le monde et permet de créer un environnement de travail adapté: par exemple la réalisation d’un suivi de stock, d’une analyse financière ou d’un budget.

Mais avant d’aller plus loin, définissons ce qu’est un tableur. Un tableur est un programme informatique conçu pour manipuler et analyser des données organisées sous forme de tableaux. Le tableau est composé de cellules qui peuvent contenir des nombres ou des textes et être utilisées pour réaliser des calculs ou des actions de gestion de base de données. Excel propose aussi de nombreuses fonctionnalités comme la réalisation d’un graphique à partir d’une série de données, voire la possibilité de créer de petits programmes sous forme de macro, en utilisant le langage informatique VBA.

Prise en main d’Excel

L’ensemble des fonctionnalités d’Excel est organisé dans une barre des taches qui est composée de plusieurs menus comme insertion, mise en page, formules etc… Dans les menus, sont rangés les boutons, permettant d’accéder aux nombreuses fonctionnalités d’Excel.

Lorsque l’on ouvre le logiciel Excel, on ouvre une feuille de calcul vierge. Cette feuille de calcul est composé de cellules. Chaque cellule a un nom composé d’une lettre (sa colonne) et d’un chiffre (sa ligne). A1 par exemple pour la cellule tout en haut à gauche du tableau. Ces cellules peuvent contenir des nombres, des textes voire des liens hypertexte.

Fonctions et formules

Lorsque l’on veut faire une opération comme une addition par exemple, il faut toujours commencer par rentrer le signe = dans la cellule. Puis on écrit notre addition. On peut également additionner le contenu de 2 cases en rentrant leurs coordonnées.

Excel propose une large gamme de fonctions pour automatiser les calculs et traiter des données. Pour insérer une fonction, il faut se rendre dans le menu « Formules » de la barre des tâches puis sélectionner le bouton « Insérer une fonction ».

Les fonctions sont classées par catégorie thématique : il y a des fonctions financières, statistiques, mathématiques etc…

A l’intérieur de ces catégories de fonctions, il existe un menu déroulant permettant d’afficher et de sélectionner toutes les fonctions disponibles dans une catégorie. Par exemple la fonction SOMME se situe dans la catégorie Mathématiques.

Création de graphiques

Il est aussi possible de créer des graphiques à partir d’un tableau existant dans une feuille de données. Les graphiques sont des outils visuels qui permettent de représenter des données afin de mieux les analyser. Pour créer un graphique, il faut se rendre dans le menu « Insertion » de la barre des tâches puis sélectionner le bouton « Graphiques ». On peut sélectionner différents types de graphiques et choisir le plus adapté au tableau que nous voulons analyser.

Création d’un tableau croisé dynamique

Le tableau croisé dynamique est un outil servant à principalement à extraire des données significatives à partir de grandes quantités de données. Il regroupe et synthétise des données pour obtenir des moyennes, des totaux ou d’autres valeurs spécifiques. Ce tableau peut être organisé de manière très simple pour accéder aux informations à analyser. Pour cela, les données sont regroupées avec d’autres valeurs possédants des caractéristiques similaires. Pour créer un tableau croisé dynamique, il faut se rendre dans le menu « Insertion » de la barre des tâches puis sélectionner le bouton « Tableaux croisés dynamiques ».

Nous avons, pour faciliter la compréhension, créé un tableau croisé dynamique à partir du tableau qui affichait les notes ainsi que le prénom des élèves. A ce tableau nous avons rajouté des colonnes qui contiennent des informations par élèves qui sont:

  • la moyenne
  • le mois de naissance
  • la ville

Le tableau va nous permettre d’extraire les informations souhaitées au sujet des élèves. En l’occurrence la moyenne des élèves qui habitent Avignon.

Enregistrement d’une macro

Sur Excel, on peut également créer ce qu’on appelle des macros. Une macro est une séquence d’instructions ou de commandes automatisée qui permet d’exécuter des tâches répétitives rapidement et facilement. Les macros dans Excel sont généralement créées à l’aide de VBA (Visual Basic for Applications), un langage de programmation intégré dans Excel. Excel offre la possibilité d’enregistrer une suite d’actions en les réalisant. Cette suite d’actions est ensuite traduite automatiquement en langage VBA.

Pour créer une macro, il faut se rendre dans le menu « Affichage » de la barre des tâches puis sélectionner le bouton « Macros » puis le bouton « Enregistrer une macro ». On effectue donc la suite d’actions que l’on veut réaliser et une fois terminée, on arrête l’enregistrement.

Exemple : Reprenons le tableau de notes utilisé pour créer les graphiques dans la partie précédente. Vous trouverez ci-dessous le code VBA de la macro « MiseEnForme » appliquée à notre tableau. Les tâches successives sont :

  • centrer le texte des deux premières cellules
  • afficher le texte en gras
  • trier par ordre décroissant les notes obtenues par les élèves
Sub MiseEnForme()
'
' MiseEnForme Macro
' Mettre en forme un tableau
'

'
    Range("A1:B1").Select
    With Selection
        .HorizontalAlignment = xlCenter
        .VerticalAlignment = xlBottom
        .WrapText = False
        .Orientation = 0
        .AddIndent = False
        .IndentLevel = 0
        .ShrinkToFit = False
        .ReadingOrder = xlContext
        .MergeCells = False
    End With
    Selection.Font.Bold = True
    Columns("A:B").Select
    ActiveWorkbook.Worksheets("Feuil1").Sort.SortFields.Clear
    ActiveWorkbook.Worksheets("Feuil1").Sort.SortFields.Add2 Key:=Range("B2:B9") _
        , SortOn:=xlSortOnValues, Order:=xlDescending, DataOption:=xlSortNormal
    With ActiveWorkbook.Worksheets("Feuil1").Sort
        .SetRange Range("A1:B9")
        .Header = xlYes
        .MatchCase = False
        .Orientation = xlTopToBottom
        .SortMethod = xlPinYin
        .Apply
    End With
End Sub


Une fois la macro enregistrée ou écrite, vous pouvez l’exécuter à tout moment en cliquant sur le bouton « Exécuter la macro » dans Excel ou en appuyant sur un raccourci clavier que vous lui avez attribué.

Ce tutoriel ne montre qu’une petite partie des très nombreuses fonctionnalités d’Excel qui lui permettent d’être considéré par 80% des entreprises comme un outil essentiel.

Art

De l’Op art généré par un code python

L’Op Art, ou art optique est un mouvement artistique qui joue avec notre perception visuelle. Son origine remonte aux années 1920 mais il connaît un véritable essor dans les années 1960 avec des artistes comme Victor Vasarely et Bridget Riley. Ils utilisent notamment les contrastes de couleurs, la perspective, la répétition et l’alternance de formes géométriques, pour créer l’illusion de mouvement et de profondeur. Dans cet article, nous allons vous présenter une œuvre inspirée de ce mouvement et entièrement réalisée à l’aide d’un code écrit en langage Python avec le module Turtle.

L’inspiration de départ

Le problème avec les illusions d’optique est que ce que l’on voit, n’est pas la réalité. La première difficulté rencontrée a donc été de trouver un modèle avec des explications pour réaliser la figure. Après de nombreuses recherches, nous avons fini par trouver un programme de construction d’un couloir en damier sur le site d’une classe de CM2 (https://la-gazette-des-cm2-de-ducerceau.sitew.fr/Illusions_d_optique.qB.htm) dans le cadre d’un travail sur Victor Vasarely. Nous l’avons adapté pour respecter les dimensions de l’image finale (forme rectangulaire et non carrée).

Le programme de construction

Le programme de construction nous a permis d’identifier les différentes étapes à programmer :

  • Partager les côtés du rectangle en intervalles de même longueur ;
  • Tracer les segments qui relient deux points symétriques par rapport à l’origine ;
  • Tracer les rectangles qui diminuent régulièrement en taille.
  • Pour apporter notre touche personnelle, nous avons choisi de « peindre » les murs, le sol et le plafond du « couloir » avec des dégradés de couleurs.

Les variables modifiables seront la longueur, la largeur, les couleurs, le nombre d’intervalles, la taille des intervalles, le nombre de rectangles.

Programmation des couleurs

Nous avons commencé par les gradients de couleur en utilisant la méthode expliquée par Eric Schrafstetter dans sa vidéo « l’ART génératif, partie 1 – Transformations affines. »

Explication pour le « mur droit » :

  • La tortue se déplace en abscisse de 0 à L/2. à chaque pas, elle va tracer un segment en couleur de bas en haut (cap = 90°).
  • Pour une abscisse u donnée, ce segment part d’une diagonale et arrive sur l’autre. Donc on a créé les fonctions diag1 et diag2 qui retournent les ordonnées sur chaque diagonale.

def diag1(u): 
    return largeur/longueur * u
def diag2(u):
    return - largeur/longueur * u
  • Entre 0 et L/2, la couleur varie de col_dep (couleur de départ = violet) à col_arr (couleur d’arrivée = jaune).
  • Comme la couleur ne varie pas sur le même intervalle que l’abscisse de la tortue, on utilise une fonction affine qui transforme un point de l’intervalle [0 ; L/2] en un point de l’intervalle [col_dep ; col_arr] :

Voici la fonction codée en Python :

def T(u, a1, a2, b1, b2): 
    return (b2 - b1)/(a2 - a1) * (u - a1) + b1
  • Comme les dégradés ne sont pas dans le même sens ni de la même couleur suivant les triangles, nous avons créé une fonction « triangle » qui dépend de l’orientation de la tortue (cap) et des couleurs de départ et d’arrivée :
def triangle (cap, col_dep, col_arr): 
    colormode(255) # pour pouvoir utiliser le mode RVB
    rvb = [0,0,0]
    pensize(2)
    u_fin= trunc(longueur/2)
    for u in range(u_fin):
        for k in range(3):
            rvb[k] = T(u, 0, u_fin, col_dep[k], col_arr[k])
        pencolor((trunc(rvb[0]), trunc(rvb[1]), trunc(rvb[2])))
        penup()
        if cap == 90 :
            goto(u,diag2(u))
            pendown()
            goto(u,diag1(u))
        elif cap == 180 :
            goto(u,diag1(u))
            pendown()
            goto(-u,diag2(-u))
        elif cap == 270 :
            goto(-u,diag2(-u))
            pendown()
            goto(-u,diag1(-u))
        elif cap == 0 :
            goto(-u,diag1(-u))
            pendown()
            goto(u,diag2(u))

Programmation des « diagonales »

Pour simplifier, nous avons appelé aussi « diagonales », les segments qui relient un point et son symétrique par rapport à l’origine.

La tortue part de (-L :2 ; -l /2) à gauche, fait sa diagonale, revient à gauche en se décalant d’un intervalle vers le haut, fait sa diagonale, …

On procède de la même manière pour les diagonales de haut en bas, en partant de (-L/2 ; l/2).

On a donc d’abord créé une fonction « diag » qui sert à relier un point et son symétrique :

def diag(u, v):
    penup()
    goto(u, v)
    pendown()
    goto(-u, -v)
    penup()

Puis, nous avons programmé deux boucles, pour tracer les  « diagonales gauche-droite » puis les « diagonales haut-bas » :

for i in range(nb_int2):
    diag(-longueur / 2, -largeur/2 + i*taille_int2)
for j in range(nb_int1):
    diag(-longueur/2 + j*taille_int1, largeur / 2)

Programmation des rectangles

Nous avons codé une fonction « rectangle » où la tortue part du coin bas à gauche et tourne dans le sens inverse des aiguilles d’une montre :

def rectangle(L): # fonction permettant de tracer un rectangle
    penup()
    goto(-L/2, diag1(-L/2))
    pendown()
    goto(L/2,diag2(L/2))
    goto(L/2,diag1(L/2))
    goto(-L/2,diag2(-L/2))
    goto(-L/2, diag1(-L/2))

Pour faire diminuer la taille des rectangles de manière régulière, nous avons décidé d’appliquer un pourcentage de diminution de p% à la longueur (p est une variable globale qui peut être modifiée) :

t = float(longueur) 
while t > 10 :
    rectangle(t)
    t = t - t*p #la longueur diminue de p % à chaque itération

Pour l’extrémité du couloir, nous avons tracé un rectangle noir pour lequel nous avons essayé plusieurs dimensions et nous avons finalement choisi 160 pour des raisons esthétiques :

# rectangle final
fillcolor('black')
begin_fill()
rectangle(160)
end_fill()

Le programme zippé