Apprendre Python en 9 vidéos

Vous voulez faire du Machine Learning ou du Deep Learning mais vous n’avez encore pas de compétence en programmation ? Alors vous avez BESOIN de suivre cet article, car il va vous permettre d’acquérir une nouvelle compétence très recherchée sur le marché du travail: le Python.


Je vous propose ici 9 vidéos ludiques pour apprendre toutes les bases de Python, celles qui sont réellement utiles pour faire du Machine Learning ou du Deep Learning.

A la fin de chaque vidéo, je vous laisser un petit exercice pour vous donner l’occasion de pratiquer vos nouvelles compétences (et la réponse est données dans la vidéos suivante)

Cette formation va couvrir les points suivants:

  1. Installation facile de Python sur votre ordinateur avec Anaconda
  2. Création de variables et fonctions
  3. Algorithmes If/Else, for, while
  4. Structure de données:
    1. Séquences : Listes et Tuples
    2. Dictionnaires
    3. Listes Compréhensions
  5. Les Built-in functions de Python
  6. Les modules utiles de Python
  7. La Programmation Orientée Objet

Python est un langage très simple, et vous n’avez besoin d’aucun pré-requis pour suivre et comprendre ces 9 vidéos. Alors qu’est-ce-qu’on attend ?! Il est temps de se lancer ! 🙂

1. Installer Python sur mon ordinateur

Cette première vidéo vous montre comment installer python sur votre ordinateur, en téléchargeant la distribution la plus populaire de python: Anaconda.

Pour télécharger Anaconda depuis le site officiel, cliquez ici. Pensez bien à sélectionner la version compatible avec votre système d’exploitation (Windows, Mac, Linux) ainsi que la version la plus récente de Python (Python 3).

Le navigateur Anaconda ne présente qu’un onglet important, c’est l’onglet Environnement qui vous permet de très simplement ajouter ou retirer des packages (c’est-à-dire des fonctionnalités)

Pour écrire un programme avec Python, il existe 2 éditeurs de texte:

  • Jupyter Notebook: Parfait pour analyser des données et visualiser rapidement les résultats de modèles de machine learning.
  • Spyder: Préférable pour développer des programmes plus longs et plus complexes.

Dites-moi quel est votre éditeur de texte préféré dans les commentaires ! 🙂

Une fois ce tutoriel accompli, vous êtes prêt à écrire votre premier code. Bravo !

2. Python : Variables et Fonctions

Cliquez ici pour voir la vidéo Youtube de ce chapitre

A la base de tout programme scientifique, on trouve des variables et des fonctions.

Par exemple, on peut définir une variable v et d qui désignent respectivement la vitesse d’une voiture (en km/h) et la distance de trajet(en km) pour ensuite calculer le temps de trajet t. Pour cela, on définit une fonction Temps(v, d) = \frac{d}{v}.

Variables

On peut créer des variables de plusieurs types différents.

  • Nombres entiers: int
  • Décimales: float
  • Chaîne de caractère: string
  • Boolean: bool
  • et pleins d’autres types que nous verrons plus loin dans cet article : Listes, dictionnaires, etc.

Pour afficher des variables, ou n’importe quel autre information, on utilise la fonction print()

# ceci est un commentaire
'''
ceci est un commentaire
sur plusieurs lignes
'''

x = 1 # type int
y = 3.14 # type float
prenom = 'Julien' # variable de type string

print(prenom)

Bien sur, il est possible de faire des opérations arithmétiques sur des variables numériques, ainsi que des comparaisons. Le résultats des comparaisons est un boolean. Pour finir, on peut faire des opérations logiques entre plusieurs boolean.

Note: Si vous n’êtes pas familier avec ces opérations, ne vous en faites pas ce n’est pas ce qu’il y a de plus important (mais voici un article Wikipédia qui vous résume le principe)

# Arithmétique
print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x // y) # division entière
print(x ** y) # x puissance y

# Comparaison -> True / False
print(x == y) # x égal y
print(x != y) # x pas égal y
print(x <= y) # x inférieur ou égal a y
print(x > y) # x strictement supérieur a y

# Logique (moins important a savoir)
print(x &amp; y) # fonction AND
print(x | y) # fonction OR
print(x ^ y) # fonction XOR


Fonctions

Pour faire des simples mathématiques, on peut créer des fonctions mathématiques anonyme en utilisant la commande lambda. En principe, on ne donne pas de nom à ces fonctions (mais ici je l’ai nommé f).

f = lambda x: x**2 # équivaut a créer une fonction f(x) = x^2

# utilisation de la fonction f
print(f(4)) # résultat = 16

Mais le plus souvent on définit des fonctions plus complexes en utilisant la méthode def. Quand on crée une fonction, il est important de bien documenter son code (par l’ajout de commentaires) pour expliquer le but et le fonctionnement de la fonction.

def energie_potentielle(m, h, g=9.81):
    ''' energie_potentielle(m, h, g)
    fonction qui calcul et affiche l'Energie potentielle d'un corps de masse m (en kg)
    situé a une hauteur h (en m). la constante de pesanteur g=9.81 pour la Terre '''

    E = m*g*h
    print(E, 'Joules') # imprime E, en indiquand l'unité Joules 
    return E


# utilisation de la fonction
resultat = energie_potentielle(m=5, h=10)

A l’entrée d’une fonction, on a des attributs (ce sont les inputs). Ces attributs sont désignés par des keywords (le nom des attributs). Les attributs peuvent prendre des valeurs par défaut.
A l’intérieur de la fonction, certaines variables peuvent être créées, on parle alors de variable locale (qui n’existe qu’à l’intérieur de la fonction).
Pour finir la fonction produit en sortie ce qui est indiqué par la ligne return. Cette sortie doit être enregistrée dans une variable lors de l’utilisation de la fonction (ici la variable résultat).


Félicitations ! Vous maîtrisez désormais les bases de la programmation scientifique ! Je vous conseille de faire l’exercice que je donne en fin de vidéo pour être sur d’avoir bien acquis ces nouvelles compétences !

Il est temps d’apprendre comment développer vos premiers algorithmes ! 🙂

3. Écrire des algorithmes avec Python

Cliquez ici pour voir la vidéo YouTube de ce chapitre.

Pour créer des algorithmes, on utilise 3 structures de contrôle dans le monde de la programmation:

  • les alternatives IF/ELSE
  • les boucles FOR
  • les boucles WHILE

Alternatives IF/ELSE

C’est la base de la plupart des algorithmes. Le IF/ELSE permet d’exécuter des actions uniquement si une condition est vérifiée. Pour être plus précis, l’action n’est exécutée que si le résultat de la condition est True. On peut ainsi mêler booleans et opérations logiques. Si le résultat n’est pas True, alors la condition suivante est testée (Elif) et ainsi de suite jusqu’à atteindre le Else.

x = -2
if x > 0 :
    print(x, 'est positif')
elif x < 0:
    print(x, 'est negatif')
else:
    print(x, 'est nul')

Application typique: Si le capteur arrière de la voiture aperçoit un obstacle trop proche, freiner, sinon, continuer de reculer.


Boucle FOR

La boucle FOR permet d’effectuer des actions sur tous les éléments d’une séquence. La séquence la plus simple qui existe est la séquence range(). Par exemple range(10) produit la séquence 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

for i in range(10):
    print(i, i**2) # imprime la valeur de i, puis i**2

Application typique: Pour tous les fichiers d’un dossier, effectuer les actions suivante: ouvrir le fichier, le modifier, puis le fermer.


Boucle WHILE

La boucle WHILE permet d’exécuter des actions aussi longtemps qu’une certaine condition est respectée (True). C’est un peu comme si la boucle IF se répétait aussi longtemps qu’elle donne True.

i = 0
while i < 10:
    print(i**2)
    i += 1 # Sans cette ligne, l'algorithme s'execute sans fin ! car i resterait toujours < 10 !

Application typique: Pour une machine qui tourne 24h/24h: Tant que le bouton “d’arrêt d’urgence” n’est pas enclenché, continuer le travail.


Félicitations ! Vous savez désormais comment écrire vos premiers algorithmes ! Il n’y a pas encore d’intelligence artificielle dans ces algorithmes, mais en les écrivant, vous y avez introduit une forme d’intelligence qui reflète le fruit de votre réflexion. Pensez à faire l’exercice que je donne en fin de vidéos ! C’est important pour votre développement.

A ce stade, vous maîtrisez déjà le B.A-BA de la programmation: Variables, Fonctions, Algorithmes. Cependant, pour écrire des programmes qui manipulent des données, il va falloir apprendre une nouvelle chose: les structures de données. Voyons ça tout de suite !

4. Manipuler des données avec les Structures de données

Contrairement à une variable x=1 qui ne stocke qu’une valeur (ici 1), les Structures de données permettent de ranger pleins de valeurs sous un même nom. Dans Python, les Listes, les Tuples et les Dictionnaires sont les structures de bases qu’il est important de connaitre. (Il existe également les Sets, mais ils sont moins utilisés)

4.1 Les Séquences: Listes et Tuple

Cliquez-ici pour voir la vidéo YouTube de ce chapitre

Les Listes et les Tuples sont des structures de données hétérogènes (on peut y placer plusieurs types de valeurs : int, string, etc.) Et forment ce qu’on appelle des Séquences

Différence entre Liste et Tuple ?
Une liste peut être mutée (on peut y rajouter / enlever des valeurs) tandis qu’un Tuple ne peut pas l’être. Les Listes sont plus souvent utilisées que les Tuples, mais Les Tuples ont quand même l’avantage d’être plus rapide pour la machine.


Qu’est-ce-qu’une Séquence ? Indexing et Slicing

Dans une séquence, les éléments sont rangés dans un ordre bien précis. On dit que les éléments sont indexés. On peut ainsi accéder à chaque élément en indiquant sont index. Cette technique s’appelle l’indexing, et permet d’afficher des éléments, ou bien de les modifier.

# Création d'une liste de villes
villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles']

print(villes[0]) # affiche Paris
print(villes[-1]) # affiche le dernier élément de la liste


# Remplace Berlin par Montreal ! Vive le Québec :)
villes[1] = 'Montreal'

print(villes) # affiche la liste complete.

Le Slicing est une autre technique importante à connaitre : elle permet d’accéder à une “fourchette” de valeurs de notre liste, créant ainsi une mini-séquence. Pour ça, on indique un index de début et un index de fin.

# affiche les valeurs en partant de l'index 1 jusqu’à atteindre l'index 3
print(villes[1:3])

Actions sur une Liste

On peut effectuer beaucoup d’actions sur une Liste, par exemple:

  • La trier (alphabétiquement ou numériquement selon le cas)
  • En mesurer la longueur
  • Compter combien de fois un même élément apparaît
  • insérer un ou plusieurs éléments,
  • etc.

Toutes ses actions sont disponibles à travers l’utilisation de méthodes (nous reverrons ce terme à la fin de cette formation, dans la programmation orientée objet)

# Création d'une liste de villes
villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles']

villes.append('Madrid') # ajoute 'Madrid' a la fin de la liste
print(villes)

villes.extend(['Dublin', 'Geneve']) # ajoute une liste a la fin de la liste villes
print(villes)

villes.insert(3, 'Paris') # insert 'Paris' au troisieme index de la liste, décallant ainsi le reste de la liste)
print(villes)

print(villes.count('Paris')) # affiche le nombre de fois que 'Paris' apparait dans la liste

print(len(villes)) # affiche la longueur de la liste (len() est une fonction, pas une méthode)

villes.sort(reverse=False) # trie la liste villes
print(villes)

Note: Les Tuples n’ont pas toutes ces méthodes à disposition, car ils sont non-mutables, rappelez-vous ! 🙂


Les Séquences dans les boucles FOR et les IF/ELSE

Les Séquences telles que les Listes et les Tuples fonctionnent en parfaite combinaison avec les boucles FOR et les alternatives IF/ELSE. Le code suivant parle de lui-même

# Création d'une liste de villes
villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles']

# ==========================================================================
# BOUCLE FOR
# ==========================================================================
for i in villes:
    print(i)


# ==========================================================================
# IF/ELSE
# ==========================================================================
# testons si la ville suivante est dans la liste villes
ville_test = 'Belfast'

if ville_test in villes:
    print(ville_test, 'présente dans villes')
else:
    print(ville_test, 'absente de villes')


En bonus, voici une petite fiche résumé que vous pouvez imprimer !

Félicitations ! vous maîtrisez à présent l’essentiel de ce qu’il faut savoir sur les listes et les séquences dans Python. Avant de passer aux dictionnaires, voici une fiche résumé qui vous indique ce que vous devez vraiment retenir. Elle vous sera très utile le jour ou vous aurez un trou de mémoire !

Petite fiche résumé des listes que vous pouvez télécharger

N’oubliez pas de faire l’exercice que je donne dans la vidéo ! 🙂

4.2 Structure associative: Le Dictionnaire

Cliquez-ici pour voir la vidéo YouTube de ce chapitre.

Le Dictionnaire est une autre structure de données importante à connaitre. Il sert notamment de base à Pandas, le package le plus important des Data Scientists.


Qu’est-ce-qu’un Dictionnaire ?

Un Dictionnaire n’est pas une séquence: il n’y a pas d’ordre dans ses éléments. A la place, un Dictionnaire est un regroupement d’associations entre des clefs et des valeurs. C’est un peu comme si vous aviez plusieurs variables et que vous vouliez toutes les mettre dans un même panier (le dictionnaire), mais au lieu d’appeler ça des variables, on appelle ça des clefs.
Une clef est unique, elle ne peut pas exister en deux exemplaires.
Voici comment créer un dictionnaire:

'''Création d'un dictionnaire "inventaire"
les clefs sont les fruits
les valeurs sont les quantités '''

inventaire = {
        "bananes": 100,
        "pommes": 250,
        "poires": 175,
        "cerises": 300
        }

print(inventaire) # affiche le dictionnaire

print(inventaire.keys()) # affiche les clefs du dictionnaire

print(inventaire.values()) # affiche les valeurs du dictionnaire

print(inventaire.items()) # affiche les associations clef : valeur


Note: Les dictionnaires ne disposant pas d’ordre (d’index) il n’existe pas de méthode append() insert() ou extend(). Celles-ci n’ont simplement pas d’intérêt. On accède aux valeurs en indiquant la clef que l’on désire, comme ci-dessous.

print(inventaire['bananes']) # affiche la valeur associée a 'bananes'

inventaire['bananes'] = 350 # change la valeur associée a 'bananes'

inventaire['abricots'] = 225 # voici comment créer une nouvelle association


Quelques méthodes sur les Dictionnaires

Dans la vidéo du dessus, je présente certaines méthodes intéressantes sur les Dictionnaires, comme les méthodes get(), pop() et fromkeys(). Je vous laisse les découvrir en vidéo et à travers le code suivant:

inventaire = {
        "bananes": 100,
        "pommes": 250,
        "poires": 175,
        "cerises": 300
        }

# ===============================================================
# METHODE GET
# ===============================================================
print(inventaire.get('poires')) # retourne la valeur associé a la clef
print(inventaire.get('peches', 0)) # si la clef n’existe pas, retourne une valeur par défaut

# ===============================================================
# METHODE POP
# ===============================================================
valeur = inventaire.pop('cerises') # extrait une association du dictionnaire
print(valeur) # la valeur de l'association
print(inventaire) # le dictionnaire ne contient plus cette association

# ===============================================================
# METHODE FROMKEYS
# ===============================================================
fruits = ['peches', 'oranges', 'kiwi'] # une liste de fruits
inventaire = dict.fromkeys(fruits, 100) # créer un dictionnaire a partir de la liste de fruit, en assignant une valeur par défaut
print(inventaire)


Un exemple d’application

Application typique: Dans une boucle FOR, vous voulez enregistrer un résultat dans un nouvelle variable pour chaque itération de la boucle. Le problème, c’est que dans la plupart des langages de programmation, il est impossible de créer une variable dans une boucle FOR ou WHILE. En revanche, il est possible de créer de nouvelles clefs dans un dictionnaire dans une boucle FOR ou WHILE. Cela rend le dictionnaire très utile.

dictionnaire = {} # création d'un dictionnaire vide

for i in range(10):
    dictionnaire[i] = i**2 # association de la clef i a la valeur i**2

print(dictionnaire)


Félicitations ! Pensez à faire l’exercice que je donne dans la vidéo et serez alors sur de savoir utiliser les dictionnaires. Nous allons terminer cette section en parlant d’une technique plus poussée, mais incontournables: les Listes compréhensions.

4.3 Liste Compréhension: une technique plus avancée mais très utile

La Liste compréhension n’est rien d’autre qu’une technique pour créer une Liste de façon plus simple, plus professionnelle, et plus performante. Ces 3 points suffisent pour affirmer que cette technique est importante, et elle fait parfois l’objet de questions en entretien d’embauche !

Cela consiste à créer une liste en écrivant sur une même ligne:

  • La Liste
  • une boucle for
  • avec optionnellement une condition
# ===============================================
# MÉTHODE CLASSIQUE
# ===============================================

liste_1 = [] # création liste vide
for i in range(10):
    if i%3 == 0: # si i est multiple de 3
        liste_1.append(i**2) # ajoute i**2 a la liste

print(liste_1)
        
# ===============================================
# LISTE COMPREHENSION
# ===============================================

liste_2 = [i**2 for i in range(10) if i%3==0]

print(liste_2)

Félicitations ! vous maîtrisez maintenant l’essentiel des techniques sur les structures de données (y compris des techniques plus avancées). Nous allons maintenant parler des fonctions de bases de python.

7. Les Built-in Functions de Python

Python comprends nombre de fonctions déjà implémentées pour vous aider dans votre travail. Ces fonctions sont TRÈS UTILES ! Pour preuve, parmi elles, ont trouve les fonctions print(), len(), zip() et enumerate(). Eh bien si je vous disais qu’il en existe pleins d’autres comme ça, vous me croiriez ?

Ces fonctions sont toutes documentées ici, sur le site officiel de python. Dans la vidéo ci-dessus je vous présente les plus utiles, à savoir:

  • Les basiques: abs(), sum(), max(), min(), len(), all(), any()
  • les conversions: int(), float(), str(), list(), tuple(), dict()
  • input()
  • format()
  • open()

Fonctions basiques

x = -2
print('valeur absolue', abs(x))

x = 3.14
print('arrondi', round(x))


liste_1 = [0, 23, 14, -19]
print('max', max(liste_1))
print('min', min(liste_1))
print('longueur', len(liste_1))
print('somme', sum(liste_1))


Fonctions de conversion

x = 10 # type int
print(type(x)) # affiche le type. cette fonction est tres utile !

x = str(x) # convertit x en string
print(type(x)) # re-affiche le type

y = '20' # type string
y = int(y) # convertit y en int
print(type(x)) # affiche le type de y

liste_1 = [0, 61, 63, 243]
tuple_1 = tuple(liste_1) #convertit la liste en tuple
print(type(tuple_1))

print(type(list(tuple_1))) # convertit un tuple en liste.


Format(): intégrez des valeurs dans vos strings

La fonction format() permet tout simplement d’intégrer des valeurs dans des chaines de caractère. Voici comment procéder:

x = 30
y = 24
print('j'ai {} ans, et toi {}'.format(x, y))
print(f'j'ai {x} ans, et toi {y}') # une autre facon, plus rapide.


Open(): Ouvrez n’importe quel fichier de votre ordinateur

La fonction open() est très importante pour ouvrir et lire des documents sur votre machine, ou bien écrire un document et l’enregistrer sur votre machine !

Cette fonction crée un objet fichier f sur lequel on peut utiliser des méthodes pour effectuer des actions comme:

  • f.write() pour écrire dans le fichier (en écrasant son contenu)
  • f.read() pour lire le fichier
  • f.apprend() pour écrire depuis la fin du fichier (n’écrase pas le contenu)

Une fois les opérations terminées, il faut penser à fermer le fichier avec f.close().

Pour plus de performance, on peut utiliser la commande with, qui ne crée pas de référence au fichier f dans la mémoire de l’ordinateur. Dans ce cas, vous n’avez pas besoin de fermer le fichier.

# Crée un fichier pour écrire dedans (mode 'w')
f = open('fichier.txt', 'w') 
f.write('bonjour') # écrit le message "bonjour"
f.close() # ferme le fichier. le fichier existe désormais sur votre machine.


# ouvre le fichier qui vient d’être créé (mode 'r')

f = open('fichier.txt', 'r')
print(f.read()) # affiche le contenu du fichier
f.close() # ferme le fichier


# en utilisant la commande with + un petit jeu avec la fonction format()
with open('fichier.txt', 'w') as f:
    for i in range(10):
        f.write("{}^2 = {} \n".format(i, i**2))

Félicitations ! Vous connaissez désormais les fonctions les plus importantes de Python. Si vous faites l’exercice de la vidéo, vous pouvez être sur de maîtriser ces techniques à la perfection ! Nous allons maintenant attaquer la dernière ligne droite de cette formation: les modules de Python

8. Les modules les plus utiles de Python

Dans python, chaque programme que vous écrivez porte le nom de module. C’est un fichier qui regroupe différentes fonctions et variables. Il est possible d’importer vos modules dans d’autres programmes que vous pourriez écrire, afin de bénéficier des fonctions que vous auriez déjà développer.

Mais ce qui est encore plus intéressant, c’est d’importer des modules qui ont déjà été développer pour vous. Par exemple des modules qui permettent de faire des mathématiques ou bien des statistiques facilement ! Tous ces modules sont documentés ici, sur le site officiel de Python. Comme vous pouvez le constater, il y en a BEAUCOUP, je dirais même beaucoup trop ! C’est pour cette raison que je vais guider dans les modules les plus importants:

  • math
  • statistics
  • random
  • glob

Différence entre Module et Package ?
Un package est un regroupement de modules. Par exemple Numpy est un Package, mais beaucoup de gens disent que c’est un module par abus de langage (rien de grave, et je le fais moi-même sans m’en rendre compte)
.


Les basiques : math et statistics

import math
import statistics

print(math.pi) # nombre pi
print(math.cos(2*math.pi)) #cos(2*pi)

# Création d'une liste
nombres = [3, 5, 1, 0, 2]

print(statistics.mean(nombres)) # moyenne
print(statistics.variance(nombres)) # variance
print(statistics.stdev(nombres)) # écart type


Random: le module des nombres aléatoires

Le module random est l’un des plus utile de Python: voici une liste non-exhaustive des actions que vous pouvez faire avec ce module:

  • Générer des nombres aléatoires
  • Générer des listes remplies de nombres aléatoires
  • Mélanger une Liste aléatoirement
  • Choisir au hasard un élément dans une Liste

Astuce: Pour avoir un certain contrôle sur le hasard, vous pouvez fixer le générateur de nombres aléatoires random.seed() pour qu’il produise toujours le même résultat ! C’est très utile !

import random

random.seed(0) # fixe la RNG au reglage 0

print(random.random()) # Crée un nombre float
print(random.randint(0, 10)) # Crée un nombre entier (entre 0 et 10)


# Génére une liste aléatoire de longueur 5
liste_aleatoire = random.sample(range(100), 5)
print(liste_aleatoire) #affiche la liste


# Choisit un élément aléatoire de la liste
print(random.choice(liste_aleatoire)) 

# Mélange la liste au hasard 
random.shuffle(liste_aleatoire)
print(liste_aleatoire)

Glob: Accédez aux fichiers de votre ordinateurs

La fonction glob.glob() est formidable ! Elle retourne une liste de tous les fichiers présents dans votre répertoire de travail (ou de tout autre répertoire de votre ordinateur). Avec cette liste, on peut utiliser la fonction open() dans une boucle FOR, ce qui permet d’ouvrir tous les fichiers présents dans un répertoire et d’effectuer des actions sur ces fichiers.

import glob

filenames = glob.glob("*.txt") # liste tous les fichiers avec l'extension .txt

for file in filnames(): # selectionne l'un apres l'autres les fichiers dans filenames
    with open(file, 'r') as f: # ouvre le fichier
        print(f.read()) # affiche a l'écran le contenu du fichier

Note: L’exercice donné ici en fin de vidéo est un exercice très utile qui vous apprendra comment enregistrer toutes les données que vous pourriez lire avec le programme ci-dessus. Pensez à le faire, vous deviendrez un meilleur Data Scientist !


Félicitations ! Vous avez réussi cette formation ! Il ne reste qu’une dernière vidéo “détente” dans laquelle vous n’aurez pas besoin de coder, alors n’hésitez pas à sortir le pop-corn et écoutez mon histoire… je vais vous expliquer ce qu’est la programmation orientée objet

9. La Programmation Orientée Objet et son rôle en Machine Learning

Maintenant que vous maîtrisez les bases…

Il est temps pour vous de passer à la vitesse supérieure ! Si cette formation vous a plu, je vous invite a suivre les 20 vidéos suivantes qui vous permettrons d’acquérir toutes les compétences de programmation nécessaires pour un Data Scientist. Vous allez apprendre:

  • Numpy
  • Matplotlib
  • Scipy
  • Pandas
  • Seaborn
  • Sklearn
Votre voyage pour apprendre Python

Cet article a 12 commentaires

  1. merci beaucoup

    1. Merci

  2. bonsoir, c’est vraiment intéressant mais je voulais savoir si ça va me servira du bien cette formation à savoir que je suis en étude d’economie ( master ).

    1. Merci beaucoup. Je ne peux pas décider à votre place si cette formation vous servira. Cependant la Data Science et les statistiques sont utiles en économie, et il y a plusieurs personnes de la communauté Machine Learnia qui sont en étude de Marketing / Business / Économie et qui s’intéressent de près au Machine Lerning. Pour leur parler, vous pouvez vous rendre sur notre Discord. Bon courage 🙂

  3. grand merci, je trouve les cours clair et simple (facile à apprendre du coup…)
    j’aimerais si possible que vous fassiez d’autre cours sur python (ex: python web) ou des cours sur les modules “mechanise” et “beautifusoup”…..merci!

    1. Bonjour et merci je prévois de faire beautifulcoup bientot

  4. Bonjour GUILLAUME,

    Je te remercie bq pour ttes tes efforts, les cours sont très compréhensibles..hâte pour la partie Deep learning!

    Cordialement

    1. je te remercie beaucoup pour ton message
      Cordialement

  5. bonjour guillaume , je suis énormement eblouit par ton esprit de partage, Nous prions le bon Dieu pour qu’il te donne encore la santé et la force necessaire afin que tu continue de nous aider .
    concernant l’éditeur de texte moi jutilise deja PYCHARM et VISUAL STUDIO 2019 (quel conseil pouvez vous me donnez a ce niveau??).
    je souhaite egalement que vous nous fassiez des mini-projets sur python; qui vont nous permettre d’apprendre d’avantage.
    pouvez-vous nous conseiller d’autres sources??
    donnez nous encore des conseils ,des strategies et des techniques peuvant nous aider a maitriser rapidement python et tout ce qui le contistue(ses bibliothèques et framework)
    on a vraiment besoin de votre expertise pour avancer vraiment .
    toutefois je vous ferai un geste (financier) d’ici peu,car vous etes vraiment prêt pour nous aider .
    on a plus que jamais besoin de vous guillaume .
    si possible des reponses dans mon mail

    1. Merci beaucoup Joseph, je vais répondre a votre email. Pycharm ou Visual Studio sont tres bien, il faudra juste utiliser PIP pour installer certains packages, mais c’est très facile.

  6. ok merci. jai dejà installer PIP.

  7. j’attend donc votre suite dans mon mail.

    bien a vous

Laisser un commentaire

Fermer le menu