Author: Adam A.

Tutoriels

Comment installer Pip sur Mac ?

  • par

Les jeunes, dont moi, préfèrent les Mac d’Apple pour leur esthétique et l’écosystème intégré, en particulier la stabilité de macOS, idéale pour la programmation. Cependant, certains novices éprouvent des difficultés. Fort de mon expérience, je propose un tutoriel sur les bases de Python, mettant l’accent sur l’installation de Pip sur Mac. Découvrons ensemble comment installer Pip sur ce système ?

Etape 0 : Une claire compréhension de ce que l’on tente d’installer

« Pip » est l’acronyme du « Pip Installs Packages » (Pip Installe des Paquets). C’est une commande en ligne qui simplifie le processus d’installation, de mise à jour et de désinstallation de packages Python depuis le Python Package Index (PyPI). PyPI est un dépôt qui héberge un grand nombre de packages Python développés par la communauté.

Par exemple, pour installer une bibliothèque Python à l’aide de pip, vous pouvez exécuter la commande suivante dans le terminal ou l’invite de commande :

pip install nom_du_paquet

Etape 1 : Téléchargement de PIP.

Pour commencer nous allons lancer notre moteur de recherche safari vue que nous sommes sur Mac.

Puis nous partirons sur le moteur de recherche suivant google en marquant sur notre barre de Recherche google.com.

Nous arrivons donc sur google (vous en faite du chemin dit donc !!!).

Une fois sur notre cher moteur de recherche, nous saisirons « télécharger pip Python » dans la barre de recherche pour accéder à un site sécurisé permettant donc comme convenu l’installation de pip.

Une fois que nous appuyons sur « Entrée », nous atteignons l’endroit souhaité. À partir de ce moment, il est crucial d’être minutieux et de suivre scrupuleusement mes instructions. Donc, une fois arrivés, effectuez un double-clic sur le premier lien ou celui que j’aurai encadré et pointe.

Ce lien nous guide vers la page suivante, simplifiant ainsi notre navigation. En double-cliquant sur « Téléchargement des fichiers », on sera re-directe vers la page suivante.

Double clique sur les premiers liens « Distribution des sources » qui va lancer le téléchargement du programme.

Suite au téléchargement du programme, effectuez un double-clic sur le fichier afin de confirmer son installation.

Mes félicitations ! Vous avez accompli avec brio l’installation de Pip sur le disque dur, marquant ainsi une étape cruciale dans l’amélioration de votre configuration informatique.

Pip a bien été installé sur le disque dur.

Etape 2: Installation de Pip.

Initiez le lancement de Thonny, puis, dans le menu « Outils », procédez à la sélection de l’option « Ouvrir la console du système… » avant d’effectuer un double-clic pour accéder à cette fonctionnalité cruciale.

Nous voilà désormais en présence du Terminal, prêt à être utilisé avec enthousiasme !

Copie le code fourni ci-dessous avec précaution dans la console de ton Mac. Ensuite, presse la touche « Entrée » pour déclencher le processus d’installation de Pip, améliorant ainsi les capacités de ton système de manière significative.

Le code en question: 

python3 -m pip install --upgrade pip

Apres avoir copié soigneusement le code mentionné ci-dessous dans la console de ton Mac. Puis, une fois cette étape accomplie, confirme en appuyant sur la touche « Entrée », déclenchant ainsi l’installation de Pip, et observe avec satisfaction l’apparition d’un message de confirmation pour attester du succès de cette opération.

Bonus

Bravo ! Vous avez brillamment suivi les étapes d’installation de pip sur votre Mac, démontrant ainsi votre détermination et votre habileté à maîtriser ces processus techniques. Soyez fiers de cette réalisation, car elle témoigne de votre capacité à surmonter des défis informatiques. Votre réussite dans cette tâche essentielle ouvre la voie à de nouvelles opportunités passionnantes dans le monde de la programmation. Continuez sur cette lancée, et rappelez-vous que chaque victoire, aussi petite soit-elle, contribue à votre progression. Vous avez toutes les raisons d’être fiers de vos compétences nouvellement acquises !

Art

Sous les Rayons d’Or ; l’Arabie saoudite

L’art génératif est une fusion fascinante entre la créativité humaine et la puissance des algorithmes informatiques, nous vous invitons à plonger dans un univers où la machine devient artiste, créant des œuvres d’une beauté unique et imprévisible.

Notre Projet

Pour ce premier projet de NSI, nous avons décidé de représenter la ville de Riyad en python. Par conséquent, notre image rentre dans le thème de l’Architecture. Nous avons réalisé une ville assez moderne, avec des bâtiments de toutes formes et un soleil hors du commun, notre but étant de faire ressortir la ville luxueuse de Riyad, tout en apportant notre petite touche d’originalité. La vrais question étant comment nous sommes passé d’une simple idée à un résultat splendide ?

Les différentes étapes de la création de l’image

Pour être arrivé à notre résultat final, nous sommes passé par 4 étapes;

Tout d’abord voici le script python qui nous a permis d’obtenir un fond innovateur, les couleurs n’ont pas été choisi par hasard, en effet nous avons souhaité créer une ambiance qui évoque l’originalité sans oubliée le luxe notamment avec des arrondie et un dégradée de couleur reflétant l’étendue de la ville. Nous avons dans un premier temps définie la fonction disque pour dessiner un disque, rayon pour définir la taille des disques, x et y pour les coordonnées du centre et pour le dégradé de couleur nous avons fait appel a Background-color, enfin nous avons utilisé les fonctions arrondi_gauche et arrondi_droit pour dessiner des parties d’arcs.

def disque(rayon, x, y, couleur=(1, 1, 1)):
    penup()
    goto(x, y-rayon)
    pendown()
    pencolor(couleur)
    fillcolor(couleur)
    begin_fill()
    circle(rayon)
    end_fill()
    

x, y = (0,-250)
radius = (700)
color = ("#FA1D65")
disque(radius, x, y, color) 
t    
x, y = (0,-250)
radius = (600)
color = ("#F72367")
disque(radius, x, y, color)     

   
x, y = (0,-250)
radius = (500)
color = ("#F02E6B")
disque(radius, x, y, color)

x, y = (0,-250)
radius = (400)
color = ("#EA3970")
disque(radius, x, y, color)     

x, y = (0,-250)
radius = (300)
color = ("#E73F72")
disque(radius, x, y, color)

def arrondi_gauche():
    for i in range(120):
        left(1)
        forward(5/40)
        
def arrondi_droit():
    for i in range(100):
        right(1)
        forward(5/80)

Le fond est certes beau, mais nous n’avions toujours pas trouvée cette touche de beauté supplémentaire, c’est ce pourquoi nous avons rajouté des étoiles, nous avons utilisé un code python assez simple. Nous avons commencée par définir une nouvelle fonction étoile, puis nous avons placés 125 points grâce à la boucle for i in range ces points sont placés aléatoirement grâce à randint.

def etoile():
    pensize(1)
    pencolor("white")
    for i in range(125):
        penup()
        x,y = randint(-700,700), randint(-0,700)
        goto(x,y)
        pendown()
        circle(1)

Il est désormais temps de passer, au bâtiment, pour ce qui est des bâtiments nous avons voulus représenter des grattes ciel luxueux de différentes formes, pour ce faire nous avons créer des fonctions bat 1, bat 2 etc … nous avons ensuite définis leur largeur, longueur et hauteur jusqu’à que les bâtiments ressemble à la forme qui nous convenais et enfin nous les avons placés à des endroits différents.

def bat1(longueur,largeur, couleur=(1,1,1)):
    pendown()
    pencolor(couleur)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    right(90)
    forward(longueur/1.5)
    left(90)
    forward(longueur/2)
 
def bat5(longueur, largeur, couleur=(1,1,1)):
    etage(longueur, largeur/5)
    etage(longueur/2 , largeur/5)
    etage(longueur/3 , largeur/5)
    left(80)
    forward(longueur/2)

def etage(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)

def etage_inverse(longueur, largeur, couleur=(1,1,1)):
    forward(largeur)
    left(270)
    forward(longueur)
    left(90)
def bat5_inverse(longueur, largeur, couleur=(1,1,1)):
    right(160)
    forward(longueur/2)
    left(80)
    etage_inverse(longueur/3, largeur/5)
    etage_inverse(longueur/2 , largeur/5)
    etage_inverse(longueur, largeur/5)

def bat3(longueur, largeur, couleur=(1,1,1)):
   forward(longueur/3)
   left(90)
   forward(longueur)
   right(90)
   forward(largeur)
   right(90)
   forward(longueur/4)
   left(90)
   forward(largeur)
   right(90)
   forward(longueur/2)
   
def bat4(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur/3)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    left(90)
    forward(longueur-30)
    right(90)
    forward(largeur+25)
    right(90)
    forward(longueur+20)
    
def bat2(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    right(90)
    forward(longueur/2)
    left(45)
    forward(longueur/5)
    right(225)
    forward(longueur/8)
    right(90)
    forward(largeur+8)
    right(90)
    forward(longueur+8)

def bat6(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    left(90)
    forward(longueur/3)
    right(90)
    forward(largeur)
    right(90)
    forward(longueur-130)
    left(90)
    forward(largeur)
    right(90)
    forward(longueur-50)
    left(35)
    forward(largeur*2)
    right(35)
    forward(longueur-75)

penup()
fillcolor("#313131")
begin_fill()
goto(-630,-450)
goto(-630,-450)
bat1(60,30, couleur=("#313131"))
bat5(150,80 , couleur=("#313131"))
bat5_inverse(150,80 , couleur=("#313131"))
bat3(100,50, couleur=("#313131"))
bat4(100,40, couleur=("#313131"))
bat2(180,65, couleur=("#313131"))
bat6(165,35, couleur=("#313131"))
left(90)

right(90)
bat4(150,50, couleur=("#313131"))
left(90)
bat3(150,50, couleur=("#313131"))
pendown()
goto(630,-460)
goto(-630,-450)
end_fill()

Enfin, il manquait la structure la plus importe, le soleil pour, le soleil on a imaginé un soleil assez original, nous l’avons d’abord dessinée, puis nous l’avons ensuite codée en python, pour ce faire nous nous sommes aidés du concours NumWorks et nous avons utilisé une boucle avec un pas de 1 qui dessine le soleil avec les instructions de forme et de taille donnés.

from math import *
penup()
goto(0, 0)
pendown()

for r in range(20, 80, 1):
    penup()
    pensize(4 if r % 2 else 1)
    for a in range(361):
        d = r + 5 * cos(radians(12 * a))
        x = d * cos(radians(a))
        y = d * sin(radians(a))
        goto(x, y)
        pendown()

Image final

Les problèmes rencontrés

Il faut savoir que cette image n’est pas aussi facilement réalisable qu’elle ne le paraît, en effet nous avons rencontrés énormément d’obstacle à la création de cette image, notamment lorsque les bâtiments on été créer les tailles on été difficilement ajustable, nous avons dus rajouter plusieurs paramètres pour ajuster la taille des bâtiments ce qui nous a pris plusieurs heure. Nous avons également rencontrés de nombreux code d’erreur heureusement que toute les ressources étais à notre disposition, au final il suffisait de lire.

Notre ressentis sur ce premier projet

Nous avons beaucoup aimé ce premier projet, nous avons pris du plaisir à réaliser le projet, c’est une belle expérience et un coup de coeur, j’ai énormément appris en python pendant ses vacances et je trouve que ce qui est magique c’est d’apprendre en prenant du plaisir.

Télécharger le .py


Télécharger
Art

Un arbre fractale

La fractale est couramment sélectionnée comme thème pour la création d’images en raison de sa capacité à produire des motifs d’une complexité infinie et captivante. Cette fusion entre l’art et les mathématiques permet de représenter de manière créative la beauté des structures complexes, qu’elles soient naturelles ou urbaines.

Projet

Donc pour le projet nous avons décider de faire une fractale (l’arbre de Pythagore) sur un dégradé et faire un petit soleil sur le coté haut droit de l’image. Pour cela nous avons mis les script grâce à la bibliothèque turtle.

Le script

Donc pour faire le script nous nous aidons de la bibliothèque turtel. Mais tous les structure construise sont faite grâce à « def ». Nous avons donc du tous les appels a la fin un part un de manier logique et ordonné.

Le script en detailer

from turtle import *
import turtle
from random import randint
from PIL import Image
try:
    from PIL import Image
    pillow_installed = True
except:
    print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
    print("https://nsi.xyz/py2png")
    pillow_installed = False

# Uniquement des lettres, des chiffres, un tiret. Rien d'autre. https://learn.microsoft.com/fr-fr/windows/win32/fileio/naming-a-file
titre = "Fractale - Un arbre fractaleà"

# Définir le titre de la fenêtre de turtle + propagande ^^
title(titre+" | Au lycée, la meilleure spécialité, c'est la spé NSI")

# definir la taille de la fenêtre en 720p (Largeur, Hauteur, abscisse départ, ordonnée du départ)
setup(1280, 720) 
colormode(255) 
speed(0)

Tout d’abord « setup(1280, 720) » aident à configurer la fenêtre graphique Turtle pour votre dessin fractal, en lui donnant une taille spécifique (1280×720 pixels)

Puis colormode(255) serre à modifié le mode de couleur pour le rendre plus lisible (de 0 à 255 pour RGB)

Et enfin speed(0) serre à régler la vitesse de dessin pour qu’elle soit la plus rapide possible (vitesse 0).

Le fond: 

def fond():
    penup()
    rciel = 0
    gciel = 0 
    bciel = 0
    hauteur = -360
    goto(-642,-358)
    pendown()
    while hauteur != 360:
        pencolor(round(239 + rciel), round(200 + gciel), round(209 + bciel))
        forward(1280)
        hauteur += 1
        goto(-640, hauteur)
        rciel += (-29/180)
        gciel += (2/45)
        bciel += (7/720)

Cette fonction « fond() » dessine un ciel en dégradé en utilisant une boucle « while » pour créer des bandes horizontales de couleur qui simulent un dégrade sur un ciel . Les composantes de couleur « rciel » « gciel » « bciel » changent progressivement à mesure que la hauteur augmente, créant un effet de transition de couleur réaliste.

La fractale arbre 

def arbre(n,longueur):
    down()
    if n==0:
        color('green')
        forward(longueur) # avance
        backward(longueur) # recule
        color('#3f1905')
    else:
        width(n)
        forward(longueur/3) #avance
        left(angle) # tourne vers la gauche de angle degrés
        arbre(n-1,longueur*2/3)
        right(2*angle) # tourne vers la droite de angle degrés
        arbre(n-1,longueur*2/3)
        left(angle) # tourne vers la gauche de angle degrés
        backward(longueur/3) # recule

La fonction arbre à deux paramètres « n" et « longueur » pour contrôler le niveau de récursion et la longueur de la branche.

La condition « if n == 0 » permet de voir le cas de base dais que la profondeur de récursion atteint zéro.

En résumé, ce code utilise la récursion pour faire une fractale d’arbre, créant des branches qui se divise en sous-branches. Le niveau de récursion contrôle le détail de l’arbre, et la longueur de la branche diminue à chaque niveau, formant ainsi une structure d’arbre sur la base d’une fractale.

Le soleil

def soleil():
    speed(0)
    i = 0
    goto(-590, 305)
    while i < 200:
        down()
        color('#FF8C00')
        right(90)
        forward(55)
        right(180)
        forward(55)
        right(90)
        circle(5, 2)
        i = i + 1

Ce processus est répété jusqu’à ce que i atteigne 200 créant une série de formes qui se superposent pour former une figure qui ressemble à un soleil.

fond()

hideturtle() # cache la tortue
up() # lève le stylo
right(90) # tourne de 90 degrés vers la droite 
forward(300) # avance de 300 pixels
left(180) # fait un demi-tour
goto(0,-350)
angle = 50
color('#3f1905')
arbre(11,700) # exécute la macro

hideturtle() # cache la tortue
up() # lève le stylo
soleil()

On appelle tout les fonction maintenant

Vers le PNG 

image = getcanvas()
Fractale=titre+"_"+hex(randint(2**30+2**25,2**30+2**25+2**24-1))[2:]

# Génère un fichier .ps
image.postscript(file=Fractale+".ps", colormode='color')

# Ouvre le fichier .ps et génère le fichier .png
psimage = Image.open(Fractale+".ps")
psimage.save(Fractale+".png")

Téléchargement du programme

Fractale.pyTélécharger