I’m drunk and I’ll probably regret this, but here’s a drunken rank of things I’ve learned as an engineer for the past 10 years.

The best way I’ve advanced my career is by changing companies.

Technology stacks don’t really matter because there are like 15 basic patterns of software engineering in my field that apply. I work in data so it’s not going to be the same as webdev or embedded. But all fields have about 10-20 core principles and the tech stack is just trying to make those things easier, so don’t fret over it.

There’s a reason why people recommend job hunting. If I’m unsatisfied at a job, it’s probably time to move on.

I’ve made some good, lifelong friends at companies I’ve worked with. I don’t need to make that a requirement of every place I work. I’ve been perfectly happy working at places where I didn’t form friendships with my coworkers and I’ve been unhappy at places where I made some great friends.

I’ve learned to be honest with my manager. Not too honest, but honest enough where I can be authentic at work. What’s the worse that can happen? He fire me? I’ll just pick up a new job in 2 weeks.

If I’m awaken at 2am from being on-call for more than once per quarter, then something is seriously wrong and I will either fix it or quit.

pour another glass

Qualities of a good manager share a lot of qualities of a good engineer.

When I first started, I was enamored with technology and programming and computer science. I’m over it.

Good code is code that can be understood by a junior engineer. Great code can be understood by a first year CS freshman. The best code is no code at all.

The most underrated skill to learn as an engineer is how to document. Fuck, someone please teach me how to write good documentation. Seriously, if there’s any recommendations, I’d seriously pay for a course (like probably a lot of money, maybe 1k for a course if it guaranteed that I could write good docs.)

Related to above, writing good proposals for changes is a great skill.

Almost every holy war out there (vim vs emacs, mac vs linux, whatever) doesn’t matter… except one. See below.

The older I get, the more I appreciate dynamic languages. Fuck, I said it. Fight me.

If I ever find myself thinking I’m the smartest person in the room, it’s time to leave.

I don’t know why full stack webdevs are paid so poorly. No really, they should be paid like half a mil a year just base salary. Fuck they have to understand both front end AND back end AND how different browsers work AND networking AND databases AND caching AND differences between web and mobile AND omg what the fuck there’s another framework out there that companies want to use? Seriously, why are webdevs paid so little.

We should hire more interns, they’re awesome. Those energetic little fucks with their ideas. Even better when they can question or criticize something. I love interns.

sip

Don’t meet your heroes. I paid 5k to take a course by one of my heroes. He’s a brilliant man, but at the end of it I realized that he’s making it up as he goes along like the rest of us.

Tech stack matters. OK I just said tech stack doesn’t matter, but hear me out. If you hear Python dev vs C++ dev, you think very different things, right? That’s because certain tools are really good at certain jobs. If you’re not sure what you want to do, just do Java. It’s a shitty programming language that’s good at almost everything.

The greatest programming language ever is lisp. I should learn lisp.

For beginners, the most lucrative programming language to learn is SQL. Fuck all other languages. If you know SQL and nothing else, you can make bank. Payroll specialtist? Peut-être 50 000. Spécialiste de la paie qui connaît SQL ? 90k. Un citoyen moyen avec des compétences organisationnelles dans une grande entreprise ? 40 000$. Un citoyen moyen avec des compétences en organisation ET SQL ? Appelez-vous PM et gagnez 150 000$.

Tests are important but TDD is a damn cult.

Cushy government jobs are not what they are cracked up to be, at least for early to mid-career engineers. Sure, $120k + bennies + pension sound great, but you’ll be selling your soul to work on esoteric proprietary technology. Much respect to government workers but seriously there’s a reason why the median age for engineers at those places is 50+. Advice does not apply to government contractors.

Third party recruiters are leeches. However, if you find a good one, seriously develop a good relationship with them. They can help bootstrap your career. How do you know if you have a good one? If they’ve been a third party recruiter for more than 3 years, they’re probably bad. The good ones typically become recruiters are large companies.

Options are worthless or can make you a millionaire. They’re probably worthless unless the headcount of engineering is more than 100. Then maybe they are worth something within this decade.

Work from home is the tits. But lack of whiteboarding sucks.

I’ve never worked at FAANG so I don’t know what I’m missing. But I’ve hired (and not hired) engineers from FAANGs and they don’t know what they’re doing either.

My self worth is not a function of or correlated with my total compensation. Capitalism is a poor way to determine self-worth.

Managers have less power than you think. Way less power. If you ever thing, why doesn’t Manager XYZ fire somebody, it’s because they can’t.

Titles mostly don’t matter. Principal Distinguished Staff Lead Engineer from Whatever Company, whatever. What did you do and what did you accomplish. That’s all people care about.

Speaking of titles: early in your career, title changes up are nice. Junior to Mid. Mid to Senior. Senior to Lead. Later in your career, title changes down are nice. That way, you can get the same compensation but then get an increase when you’re promoted. In other words, early in your career (<10 years), title changes UP are good because it lets you grow your skills and responsibilities. Later, title changes down are nice because it lets you grow your salary.

Max out our 401ks.

Be kind to everyone. Not because it’ll help your career (it will), but because being kind is rewarding by itself.

If I didn’t learn something from the junior engineer or intern this past month, I wasn’t paying attention.

Oops I’m out of wine.

Paying for classes, books, conferences is worth it. I’ve done a few conferences, a few 1.5k courses, many books, and a subscription. Worth it. This way, I can better pretend what I’m doing.

Seriously, why aren’t webdevs paid more? They know everything!!!

Carpal tunnel and back problems are no joke. Spend the 1k now on good equipment.

The smartest man I’ve every worked for was a Math PhD. I’ve learned so much from that guy. I hope he’s doing well.

Once, in high school, there was thing girl who was a great friend of mine. I mean we talked and hung out and shared a lot of personal stuff over a few years. Then there was a rumor that I liked her or that we were going out or whatever. She didn’t take that too well so she started to ignore me. That didn’t feel too good. I guess this would be the modern equivalent to “ghosting”. I don’t wish her any ill will though, and I hope she’s doing great. I’m sorry I didn’t handle that better.

I had a girlfriend in 8th grade that I didn’t want to break up with even though I didn’t like her anymore so I just started to ignore her. That was so fucked up. I’m sorry, Lena.

You know what the best part of being a software engineer is? You can meet and talk to people who think like you. Not necessarily the same interests like sports and TV shows and stuff. But they think about problems the same way you think of them. That’s pretty cool.

There’s not enough women in technology. What a fucked up industry. That needs to change. I’ve been trying to be more encouraging and helpful to the women engineers in our org, but I don’t know what else to do.

Same with black engineers. What the hell?

I’ve never really started hating a language or technology until I started becoming intimately familiar with it. Also, I think a piece of tech is good if I hate it but I simultaneously would recommend it to a client. Fuck Jenkins but man I don’t think I would be commuting software malpractice by recommending it to a new client.

That being said, git is awful and I have choice but to use it. Also, GUI git tools can go to hell, give me the command line any day. There’s like 7 command lines to memorize, everything else can be googled.

Since I work in data, I’m going to give a data-specific lessons learned. Fuck pandas.

My job is easier because I have semi-technical analysts on my team. Semi-technical because they know programming but not software engineering. This is a blessing because if something doesn’t make sense to them, it means that it was probably badly designed. I love the analysts on the team; they’ve helped me grow so much more than the most brilliant engineers.

Dark mode is great until you’re forced to use light mode (webpage or an unsupported app). That’s why I use light mode.

I know enough about security to know that I don’t know shit about security.

Crap I’m out of wine.

Being a good engineer means knowing best practices. Being a senior engineer means knowing when to break best practices.

If people are trying to assign blame to a bug or outage, it’s time to move on.

A lot of progressive companies, especially startups, talk about bringing your “authentic self”. Well what if your authentic self is all about watching porn? Yeah, it’s healthy to keep a barrier between your work and personal life.

I love drinking with my co-workers during happy hour. I’d rather spend time with kids, family, or friends.

The best demonstration of great leadership is when my leader took the fall for a mistake that was 100% my fault. You better believe I would’ve walked over fire for her.

On the same token, the best leaders I’ve been privileged to work under did their best to both advocate for my opinions and also explain to me other opinions that conflict with mine. I’m working hard to be like them.

Fuck side projects. If you love doing them, great! Even if I had the time to do side-projects, I’m too damn busy writing drunken posts on reddit

Algorithms and data strictures are important — to a point. I don’t see pharmacist interviews test trivia about organic chemistry. There’s something fucked with our industry’s interview process.

Damn, those devops guys and gals are f’ing smart. At least those mofos get paid though.

It’s not important to do what I like. It’s more important to do what I don’t hate.

The closer I am to the product, the closer I am to driving revnue, the more I feel valued regardless of how technical my work is. This has been true for even the most progressive companies.

Linux is important even when I was working in all Windows. Why? Because I eventually worked in Linux. So happy for those weekend where I screwed around installing Arch.

I’ve learned to be wary for ambiguous buzz words like big data. WTF is “big” data? I’ve dealt with 10k rows streaming every 10 minutes in Spark and Kafka and dealt with 1B rows batched up hourly in Python and MySQL. Those labels can go fuck themselves.

Not all great jobs are in Silicon Valley. But a lot are.

Oh shit I found beer: let’s keeping going.

On programming languages

I once hated a programming language (C#) until I started using it. Now I hated it but think it’s useful.

Then I started hating a programming language (C#) and left it and came back. Wow, that programming language has really improved.

The greatest thing about functional languages is that functions are first class and all other programmers know that.

No matter how great or superior a language is, it doesn’t matter if people don’t use it.

Learning a language isn’t hard. It’s learning the ecosystem.

On coworkers

Pair programming is great, it just takes a lot of time, time that the company usually doesn’t want to spend.

Working with smart engineers has made me a better coder. Working with smart non-technical co-workers has made me a better engineer.

Don’t spend time outside of the 9-5 working. Unless you want to because you got a banging project and you’re in the groove. That shit is awesome.

Happy hours and social hours across teams are 99% just chilling and getting to know coworkers. That’s cool. Every once in a while, the 1% is about a critical project with a critical piece of code and you’re glad you brought up work in a social setting because shit would’ve hit the fan otherwise. I’m not saying that I should hang out with other teams outside of work because of this. I just want to bond. But it sure as hell is a nice perk.

On working from home

If the company is half remote and half on-site, it’s important to determine if the remote people aren’t treated as second-class citizens. If major decisions are made “at the water cooler”, then it’s better to try to change the company culture (hard) or move on to a different company that treats its remote employees as first class citizens.

The second worst major downside of working from home is no whiteboard.

The first major downside of working from home is that it’s hard to learn from coworkers. Unless I’m (a) confident and assertive to ask questions and (b) the company has a culture where remote workers are equivelent to on-site workers, I think it was best that I worked on-side for the first 5 years of my career.

On technology

Everyone knows that tech changes. The tech landscape of the past 10 years has changed dramatically. But fundamentals don’t change very much, especially fundamentals that apply to my field.

Hacker news and r/programming is only good to get general ideas and keep up-to-date. The comments are almost worthless.

There’s a lot of vocal amateurs with strong opinions about technology. Even amateurs published on “respectable” journals and blogs. I found it to keep abreast of the rumors but to figure things out for myself.

I work at a cutting edge startup and we don’t use the latest XYZ tech that was present at ABC cutting edge tech company. And it turn out, what they usually present is only a small percentage of their engineering department and that most of them are using the same tech we are.

That being said, it’s important to read the signs. If you want to work with modern tech and you’re company is still doing the majority of it’s development in jQuery, might be time to re-evauluate.

On Data Engineering

Fuck it I’m a data engineer so I might as well give more specific, target advice/experience

SQL is king. Databases like MySQL, Postgres, Oracle, SQL Server, SQLite is still supreme. Even if you work with new tech, most of it transfers anyway.

Most companies aren’t doing streaming. It’s hard and complicated. If you’re 10 years into your career and you don’t know how to work with 10k records per second, don’t worry about it, there’s still jobs out for you.

Airflow is shit, yes. There are other products out there, but fuck me if Airflow isn’t the most widely used.

Machine learning projects are highly prone to failure. They’re complicated and hard to implement. Don’t believe me? How easy is it to write fucking unit test a machine learning model? Yeah.

Our field is new. There’s no good book on data engineering, just go and “do it”. Can’t learn it through a bootcamp and shit. This will probably change in 10 years as we all figure out what the fuck we’re doing.

On Life

People die. Do you want your code to be your legacy? If yes, then spend a lot of time on it because that’s your fucking legacy and you go! But if you are like me, your legacy is surrounded with family, friends, and people in your life and not the code you write. So don’t get too hung up on it.

Good people write shitty code. Smart people write shitty code. Good coders and good engineers write shitty code. Don’t let code quality be a dependent variable on your self worth.

I got into tech and coding because tech was my hobby. Now my hobby is is the same as work and work has ruined my hobby. So now if I want to enjoy tech I need to quit my hobby. Or I need to be OK that tech is no longer my hobby and find new hobbies.

Programming and computer science is like, what, 80 years old? Compare that with any other engineering discipline. Yeah, we collectively don’t know what the fuck we’re doing.

I’m making pretty good money. Be grateful and appreciate. Also, save.

Other shit

I’ve built large platforms and libraries that are used by multiple teams and people for many years. Yet for some reason, the most proud I was of the code I wrote was the small script that was used by me.

The proudest accomplishment of my career has been helping other people be better at their jobs. That’s probably because I’m destined to be a people manager, so this is probably not helpful to other people.

When I was looking for a job, I created an updated my Linkedin. I got shit replies and deleted it. Now I use Linkedin to find other candidates to join my company. Bottom line, Linkedin is a lot of noise. I only find it valuable because now, part of my job is contributing to that noise.

Once, I found out in college that a girl liked me. I didn’t believe it because I had poor self esteem, but then she asked me out. I told her I wasn’t interested even though she was really cool. That was one of the proudest moments in my life because I as mature enough at 19 to say “no” in a mature way.

r/cscareerquestions is such a cesspool of ego and misinformation that I don’t know what to do about it. Like, WTF. I want to shake all those people and try to explain to them how the world really is, but they wouldn’t believe me.

On my general feelings right now

I’m drunk and I usually don’t drink, so I would think that everything I say is probably cringy or terrible

I feel strongly that people should save and invest money. If you have a 6 figure salary, do your best to max our your 401k please.

I’ve become what I’ve always hated: someone who works in tech in a career but avoid tech in real life. Maybe that comes with being old.

r/ExperiencedDevs is a pretty cool community. Thank you mods. You get way less appreciation than you deserve. Seriously, thank you.

I probably owe my career, my salary, my life to Reddit. Reddit gets a lot of shit but the communities here have lifted me out of poverty (working at a gas station earning min wage) to learning Linux, SQL, python, C#, Python, and others to get me where I am.

Kids are great. I don’t have kids by choice. Why? Because I love kids and I’m scared about what kind of father I would be. Oh shit, is that too personal for a post here?

Once, someone asked me who I looked up to and I said Conan O’Brien, and they laughed at me. But I was being serous because on his last show on the Tonight Show, he told his audience to be kind and work hard. It happend during a difficult period of my life, and when I watched him say that, I said, you know what, I’m going to do just that. Because what would I have to lose? And you know what? I’ve met some brilliant people who I’ve learned from over 10+ years because I was kind to them. And I’ve grown a lot by working hard and not being afraid to try new things. And my life is infinitely, infinitely better because of those words. So yes, it might seem silly and even ridiculous to say that I’ve achieved a level of fulfillment in my life because of a late night talk show. But you know what, fuck it, it’s my life and I will proudly say that I owe any success I’ve achieved because a fucking comic on late night television.

I’m highly intoxicated so please disregard anything I say. Also apologies for ranting.

I saved this because it’s one of the most honest things I’ve read about our industry. I agree with almost all of it, especially the parts about SQL being king, tech stacks not mattering as much as you think, and the best code being no code at all. The only thing I’d push back on is the dynamic languages take. But hey, the man was drunk.

Python, ce nom un peu mystérieux cache en réalité l’un des langages de programmation les plus accessibles et polyvalents qui existent. Si vous êtes ici, c’est probablement que vous vous posez la question : “Par où commencer ?” Je vais partager avec vous mon expérience et vous donner quelques pistes pour débuter sereinement.

Comment bien s’équiper pour programmer ?

Avant même d’écrire votre première ligne de code, il faut choisir ses outils. Et là, on peut vite se perdre dans la multitude d’options disponibles.

Le choix de l’environnement de développement

Personnellement, j’ai commencé avec un simple éditeur de texte et la console. Ça marche, mais franchement, on se complique la vie ! Aujourd’hui, je recommande vivement d’utiliser ce qu’on appelle un IDE (Integrated Development Environment), un environnement de programmation qui va vous faciliter grandement la tâche.

Visual Studio Code (VsCode) est devenu mon chouchou. C’est gratuit, léger, et avec les bonnes extensions, il devient redoutable pour Python. Pour ceux qui s’orientent vers la science des données, Spyder est une excellente alternative, spécialement conçu pour ce domaine.

Il y a aussi Jupyter Notebook, qui est fantastique pour expérimenter. C’est un peu comme un carnet de laboratoire numérique où vous pouvez mélanger du code, du texte et des graphiques.

Mes premiers pas avec Python

Quand j’ai découvert Python pour la première fois, j’ai voulu tester immédiatement si tout fonctionnait. Et c’est exactement ce que je vous conseille de faire ! Ouvrez votre console Python et testons ensemble quelques commandes de base.

La première chose à faire, c’est de vérifier que Python répond bien. Tapez simplement :

print("Bonjour Python !")

Si vous voyez s’afficher “Bonjour Python !” dans votre console, félicitations ! Vous venez d’exécuter votre premier programme Python. C’est un moment qu’on n’oublie jamais.

Maintenant, pourquoi ne pas s’amuser un peu avec les mathématiques ? Python excelle dans ce domaine :

resultat = 2 + 3
print(f"2 + 3 = {resultat}")

Ce f devant les guillemets, c’est ce qu’on appelle une f-string. C’est une façon élégante d’insérer des variables dans du texte. Vous allez voir, on va s’en servir tout le temps !

Ma première visualisation

Une des choses qui m’ont immédiatement séduit avec Python, c’est sa capacité à créer facilement des graphiques. Imaginez pouvoir transformer vos données en de beaux graphiques en quelques lignes seulement !

Pour cela, nous allons utiliser une bibliothèque fantastique appelée matplotlib. Si ce n’est pas encore installé sur votre machine, pas de panique, Python a un gestionnaire de paquets intégré qui se charge de tout.

Voici un petit exemple qui m’avait émerveillé à l’époque :

import matplotlib.pyplot as plt
import numpy as np

# Créons des données pour notre graphique
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)

# Et maintenant, la magie opère
plt.plot(x, y)
plt.show()

En exécutant ces quelques lignes, vous devriez voir apparaître une magnifique courbe sinusoïdale. C’est à ce moment-là que j’ai réalisé le pouvoir de Python !

Passer à la vitesse supérieure : Mon premier vrai script

Après avoir joué quelques minutes avec la console, l’envie m’est venue de créer quelque chose de plus élaboré. C’est là que j’ai découvert la puissance des scripts Python.

L’idée était simple : créer un programme qui génère automatiquement de beaux graphiques des fonctions trigonométriques. Vous savez, ces courbes de sinus et cosinus qu’on étudiait au lycée mais qui soudain prenaient vie sur l’écran !

Quand vous créez votre premier fichier .py, vous franchissez un cap important. Vous passez de simple utilisateur à créateur de programmes. C’est un sentiment assez grisant, je dois l’avouer.

L’art du code bien écrit

Une chose que j’ai apprise assez vite, c’est l’importance d’écrire du code propre et commenté. Vous pensez peut-être que les commentaires sont inutiles quand on commence, mais croyez-moi, même après une semaine, vous aurez oublié pourquoi vous avez écrit telle ou telle ligne !

Voici un exemple de script que j’ai créé à l’époque, avec de vrais commentaires utiles :

"""
Mon premier script sérieux avec Python
Ce programme affiche les courbes de sin et cos
"""

import numpy as np
import matplotlib.pyplot as plt

def afficher_fonctions_trigo():
    # Je génère plus de points pour une courbe plus lisse
    x = np.linspace(0, 4*np.pi, 200)
    y_sin = np.sin(x)
    y_cos = np.cos(x)
    
    # Configuration pour un graphique professionnel
    plt.figure(figsize=(12, 6))
    plt.plot(x, y_sin, 'blue', label='sin(x)', linewidth=2)
    plt.plot(x, y_cos, 'red', label='cos(x)', linewidth=2)
    
    plt.title('Mes premières fonctions trigonométriques')
    plt.xlabel('x (en radians)')
    plt.ylabel('Amplitude')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.show()

# Point d'entrée du programme
if __name__ == "__main__":
    afficher_fonctions_trigo()

Ce petit if __name__ == "__main__": au bas du script, c’est une convention Python très utile. Ça signifie “exécute cette partie seulement si le script est lancé directement”. Vous comprendrez mieux son intérêt quand vous commencerez à importer vos propres modules.

Découvrir les types de données : mes premières surprises

Quand on débute en programmation, on pense souvent que les ordinateurs ne savent que compter. Erreur ! Avec Python, j’ai découvert qu’on peut manipuler des nombres, du texte, et bien d’autres choses de façon très intuitive.

Les nombres entiers : plus forts que prévu

La première chose qui m’a surpris avec Python, c’est sa gestion des nombres entiers. Contrairement à d’autres langages, Python n’a pas de limite pour la taille des entiers. Vous pouvez calculer 2 puissance 1000 sans sourciller !

Testons ensemble quelques opérations de base :

age = 25
print(f"J'ai {age} ans")
print(f"Le type de cette variable : {type(age)}")

Ce qui est génial avec Python, c’est qu’on peut faire toutes les opérations mathématiques qu’on veut :

• Addition : 15 + 4 = 19
• Soustraction : 15 - 4 = 11
• Multiplication : 15 * 4 = 60
• Division : 15 / 4 = 3.75 (donne toujours un nombre décimal)
• Division entière : 15 // 4 = 3
• Reste de division : 15 % 4 = 3

Et voici le truc qui m’a épaté : 2**1000 calcule 2 puissance 1000, et Python affiche tranquillement un nombre de plus de 300 chiffres ! Essayez, vous verrez.

Les nombres décimaux : précision et formatage

Les nombres à virgule (qu’on appelle “float” en programmation) sont partout dans nos applications. Températures, prix, mesures… Python les gère très bien.

Ce que j’adore, c’est la facilité avec laquelle on peut formatter l’affichage :

temperature = 23.7
print(f"Il fait {temperature}°C")

prix = 19.99
print(f"Prix : {prix:.2f}€")  # Affiche exactement 2 décimales

Et quand on commence à jouer avec les fonctions mathématiques, là ça devient vraiment intéressant. Le module math nous donne accès à toutes les fonctions qu’on utilisait au lycée : sinus, cosinus, logarithmes…

Les chaînes de caractères : bien plus que du texte

Les chaînes de caractères, ou “strings”, c’est là où Python brille vraiment. La facilité avec laquelle on peut manipuler du texte m’a immédiatement convaincu.

Prenons un exemple concret :

prenom = "Marie"
nom = "Curie"
age = 34

# Avec les f-strings, on peut créer des phrases complexes facilement
message = f"Je m'appelle {prenom} {nom} et j'ai {age} ans."
print(message)

Mais ce qui est vraiment pratique, ce sont toutes les méthodes disponibles pour manipuler le texte. Par exemple, si vous avez une adresse email :

email = "marie.curie@science.org"
print(email.upper())  # MARIE.CURIE@SCIENCE.ORG
print(email.split('@'))  # ['marie.curie', 'science.org']

On peut accéder à n’importe quel caractère d’une chaîne comme si c’était une liste. Le premier caractère est à la position 0, le dernier à la position -1. C’est très logique une fois qu’on s’y habitue.

Une chose à retenir : les chaînes sont “immuables” en Python. Ça signifie qu’on ne peut pas modifier un caractère directement. Il faut créer une nouvelle chaîne.

Mes conseils pour bien débuter

Après plusieurs mois à apprendre Python, voici les conseils que j’aurais aimé qu’on me donne au début :

Pratiquez régulièrement, même 15 minutes

La régularité vaut mieux que de longues sessions espacées. Même un quart d’heure par jour fait une énorme différence. J’ai pris l’habitude de coder un peu chaque matin avec mon café, et c’est comme ça que les concepts se sont vraiment ancrés.

N’ayez pas peur des erreurs

Les messages d’erreur de Python sont globalement bien faits. Au début, ils peuvent paraître intimidants, mais ils donnent souvent des indications précises sur ce qui ne va pas. Apprenez à les lire, ils deviendront vos amis !

Commentez votre code

Je ne le répéterai jamais assez : commentez votre code ! Non seulement ça aide les autres à comprendre, mais ça vous aidera vous-même dans quelques semaines quand vous reviendrez sur votre script.

Rejoignez la communauté

La communauté Python est l’une des plus accueillantes du monde de la programmation. N’hésitez pas à poser des questions sur Stack Overflow, Reddit, ou les forums spécialisés. La plupart du temps, quelqu’un a déjà eu le même problème que vous !

Où aller maintenant ?

Maintenant que vous avez goûté aux bases de Python, le monde s’ouvre à vous. Voici quelques directions possibles selon vos intérêts :

Si vous aimez les données et les statistiques, plongez-vous dans pandas et matplotlib. Vous pourrez analyser des datasets entiers et créer des visualisations étonnantes.

Si le web vous intéresse, Django et Flask vous permettront de créer des sites web complets. Imaginez pouvoir construire votre propre application web !

Si vous êtes attiré par l’intelligence artificielle, TensorFlow et scikit-learn vous ouvriront les portes du machine learning. C’est un domaine passionnant et en pleine explosion.

Si vous voulez automatiser des tâches, Python excelle dans ce domaine. Scripts d’administration, web scraping, traitement d’images… les possibilités sont infinies.

Pour conclure

Apprendre Python a changé ma façon de voir la programmation. Ce langage a cette capacité unique d’être à la fois simple pour les débutants et puissant pour les experts.

Ne vous découragez pas si certains concepts ne semblent pas clairs au début. La programmation, c’est comme apprendre une langue étrangère : ça prend du temps, mais un jour, tout se met en place et devient naturel.

L’important, c’est de commencer. Alors ouvrez votre éditeur de code, tapez votre premier print("Hello World !"), et laissez la magie opérer.

Bon apprentissage, et bienvenue dans le monde de Python !, l’apprentissage c’est la répétition.

Prenons les équations diff naturelles qu’on a l’habitude, juste une et observons : $$y’ = y$$

Alors comme $f \in C^1(\mathbb{R})$, l’équation $$y’ = y \quad \Longleftrightarrow \quad \exists K \in \mathbb{R},\ \forall x \in \mathbb{R},\ y(x)=Ke^x$$

Et ça fait en énonçant le théorème.

Théorème de Cauchy-Lipschitz

Soit $U\subset \mathbb{R}^n$ un ouvert de $\mathbb{R}^n$ et soit $I$ un intervalle non vide de $\mathbb{R}$. Soit $f\in C^0(I\times U,\mathbb{R}^n)$. On suppose que $f$ est localement lipschitzienne en la seconde variable. On fixe $t_0\in I$ et $x_0\in U$. Alors il existe $\delta>0$ et $x\in C^1\big( (t_0-\delta,t_0+\delta)\cap I,\ U \big)$ tels que $$ \begin{cases} x’(t)=f(t, x(t)) & \text{dans } (t_0-\delta,t_0+\delta)\cap I,\ x(t_0)=x_0. \end{cases} $$ De plus, une telle solution est unique.

Ce théorème est très utile du moment que les hypothèses sont vérifiées : on a l’existence et l’unicité de la solution. De plus, ça va très loin et nous aide à obtenir la maximalité de la solution sur l’intervalle $I$. Si jamais notre $I$ est égale à $\mathbb{R}$, alors là on dit que la solution est globale.

Ceci dit, vérifier des hypothèses nous montrent qu’il existe des fonctions qui n’en vérifient pas du tout. Prenons l’équation diff : $$y’ = 2\sqrt{|y|}$$

Une équation diff comme les autres, mais elle a une particularité : avec la fonction $f(x, y) = 2\sqrt{|y|}$ qui est bien entendue continue mais pas $C^1(\mathbb{R}\times\mathbb{R})$, elle n’est pas localement lipschitzienne car pas dérivable. Une fonction qui n’est pas globalement lipschitzienne n’est pas localement lipschtzienne. Cela implique que la théorie de Cauchy-Lipschitz ne s’applique pas, ainsi il faut trouver un autre moyen pour résoudre ce problème.

Supposons que $y$ est strictement positif, cela donne que $(\sqrt{y})’ = 1$, on intègre de gauche à droite et on trouve qu’il existe un $k \in \mathbb{R}$ tel que $\sqrt{y} = x - k$. Cela nous impose que $x - k$ soit positif car la racine carrée d’un nombre est toujours positive et donc $x \in [k, + \infty[$.

Voici une première solution : $$y(x) = (x - k)^2 \text{ si } x \in [k, + \infty[ \text{ et nulle sinon}$$

Soit $y < 0$, cela donne encore une deuxième solution : $$y(x) = -(l - x)^2 \text{ si } x \in [- \infty, l[ \text{ et nulle sinon}$$

La troisième solution : supposons que $y$ s’annule quelque part sur $I$, donc il existe $a, b \in \mathbb{R}$ tel que $a \leq b$ et $y(a) = 0 = y(b)$. Ce qu’on fait là, c’est une étude qualitative qui consiste à faire des va-et-viens en prenant des informations sur $y’$ pour déduire des hypothèses sur $y$ et vice-versa.

Un autre exemple

Prendre : $$y’ = y - y^2$$

Si je choisis la fonction $f$ avec $f : \mathbb{R}^2 \to \mathbb{R}$ et $f(t, y) = y - y^2$. Comme $f$ est $C^1$, par le théorème des accroissements finis, $f$ est continue et lipschitzienne. Cela implique que les hypothèses du théorème de Cauchy-Lipschitz sont vérifiées, et donc il existe une unique solution $y \in C^1(I)$ pour $I$ inclus dans $\mathbb{R}$ d’intérieur non vide. La solution est maximale sur $I$.

Première étape

Si $y$ prend la valeur 0 quelque part sur $I$, alors $y$ est constante et on obtient une solution globale (définie sur $\mathbb{R}$). Il est facile de démontrer ce résultat : soit en posant $m(t) = 1 - y(-t)$, soit en utilisant le théorème de Cauchy-Lipschitz.

Deuxième étape

Supposons que $y$ ne s’annule jamais sur $I$, donc on peut diviser par $y(1-y)$ : $$\frac{y’}{y(1-y)} = 1$$

On utilise la décomposition en éléments simples : $$\frac{1}{y(1-y)} = \frac{1}{y} + \frac{1}{1-y}$$

On obtient : $$\frac{y’}{y} + \frac{y’}{1-y} = 1$$

En intégrant on trouve : $$\ln|y| - \ln|1-y| = t + C$$

Soit : $$\ln\left|\frac{y}{1-y}\right| = t + C$$

D’où : $$y(t) = \frac{Ke^t}{1 + Ke^t} \text{ avec } K = e^C$$

Comme solutions particulières on a $y(t) = 0$ et $y(t) = 1$ qui sont constantes sur $\mathbb{R}$.

Pour les solutions non constantes :

• Si $K > 0$ : la solution tend vers $1$ quand $t \to +\infty$ et vers $0$ quand $t \to -\infty$
• Si $K < 0$ : la solution est négative ou supérieure à $1$

Conclusion

Le théorème de Cauchy-Lipschitz nous garantit l’existence et l’unicité de la solution si les hypothèses sont vérifiées. Sans ces hypothèses, on peut avoir plusieurs solutions comme on l’a vu avec l’équation $y’ = 2\sqrt{|y|}$.

L’analyse qualitative en faisant des va-et-viens entre $y’$ et $y$ aide à comprendre le comportement des solutions.

Les origines : Le langage S

R n’a pas été créé à partir de rien. Au début des années 1970, John M. Chambers et ses collègues chez Bell Laboratories développent le langage S : un langage pensé spécifiquement pour l’analyse statistique interactive.

S connaît plusieurs évolutions majeures :

S-PLUS, la version commerciale, devient le standard dans les années 1990-2000, mais reste onéreux et inaccessible à beaucoup.

La naissance de R : Un S libre et puissant

Au milieu des années 1995, deux statisticiens néo-zélandais, Ross Ihaka et Robert Gentleman, créent R à l’Université d’Auckland, inspirés par S mais aussi par le langage Scheme.

Trois points fondamentaux caractérisent R dès ses débuts :

• R est un logiciel libre et gratuit (licence GNU GPL)
• Son code source est ouvert aux contributions mondiales
• Il devient rapidement le standard académique et professionnel en statistique

Aujourd’hui, John Chambers lui-même contribue encore à R, preuve que l’héritage de S reste bien vivant.

Pourquoi des packages, et pas seulement R de base ?

R de base sait faire pas mal de choses : moyennes, régressions simples, graphiques basiques. Mais dès qu’on travaille sur des données réelles, on se heurte rapidement à ses limites. Les données arrivent mal formatées, avec des valeurs manquantes, des colonnes mal nommées, des milliers de lignes. C’est là que les packages entrent en jeu.

Un package, c’est un ensemble de fonctions spécialisées : écrites, testées, et partagées par la communauté. Sur CRAN, il en existe des milliers. L’enjeu n’est pas de tout connaître, mais de savoir à quoi sert quoi selon le problème rencontré.

Les packages présentés ici, dplyr, tidyr, data.table, ggplot2, FactoMineR et factoextra, couvrent une grande partie de ce qu’on fait en data science : nettoyer, transformer, visualiser et comprendre la structure des données avant d’aller plus loin.

dplyr et tidyr : remettre de l’ordre dans le chaos

Avant toute analyse statistique ou machine learning, il y a presque toujours la même étape : les données sont sales. Colonnes mal alignées, lignes dupliquées, valeurs manquantes, variables éparpillées dans plusieurs fichiers. C’est souvent là que se passe la majorité du travail.

dplyr est la boîte à outils de référence pour manipuler les données. Filtrer des lignes, sélectionner des colonnes, trier, grouper par catégorie, calculer des agrégats : dplyr le fait avec une logique claire. L’idée du pipe (%>%) permet de lire les opérations dans l’ordre naturel : « on prend les données, on filtre, on sélectionne, on résume ». Sur un dataset de plusieurs milliers de lignes, par exemple pour comparer le comportement d’achat par région, c’est l’outil à ouvrir en premier.

tidyr s’occupe d’un autre problème : la forme des données. Parfois les variables sont en colonnes alors qu’elles devraient être en lignes, ou l’inverse. Un fichier exporté depuis Excel peut avoir une structure illisible pour R. tidyr sert à reshaper : passer d’un format large à un format long, combiner plusieurs tables, séparer une colonne qui mélange plusieurs informations. Sans cela, beaucoup d’analyses deviennent impossibles ou très fastidieuses.

En pratique, dplyr et tidyr vont presque toujours ensemble. Ils font partie du tidyverse, un écosystème de packages qui partagent la même philosophie : des données bien structurées, une syntaxe cohérente. La préparation d’un dataset pour une régression ou pour entraîner un modèle passe rarement directement par du machine learning : c’est d’abord du dplyr et du tidyr.

data.table : quand les données deviennent lourdes

dplyr est lisible et pratique. Mais quand le dataset grossit, des millions de lignes ou des fichiers de plusieurs gigaoctets, la performance devient un sujet central. C’est là qu’intervient data.table.

data.table propose une autre façon de manipuler des tables en R, optimisée pour la vitesse et la mémoire. La logique reste similaire à dplyr (filtrer, grouper, joindre des tables), mais la syntaxe est différente et l’exécution est nettement plus rapide sur les gros volumes.

Son usage est situationnel : quand dplyr ralentit, quand la RAM atteint ses limites, quand on travaille sur des logs, des transactions bancaires ou des données de capteurs. En environnement professionnel, data.table revient fréquemment. Sur des plateformes comme Kaggle, de nombreux participants s’en servent pour gagner en performance.

La distinction des rôles est donc claire : dplyr pour le quotidien et la lisibilité, data.table quand la taille des données devient le problème principal.

ggplot2 : voir avant de conclure

Il existe un principe fondamental en data science : regarder ses données avant de faire confiance à un modèle. ggplot2 est l’outil qui permet de le mettre en pratique.

ggplot2 repose sur la grammaire des graphiques : un graphique n’est pas une fonction magique qui sort un résultat tout fait, c’est une superposition de couches. Les données, le type de représentation (points, barres, lignes), les couleurs, les facettes pour comparer des groupes. Une fois cette logique assimilée, il devient possible de produire presque n’importe quelle visualisation.

Ce que ggplot2 permet notamment :

• Nuages de points pour identifier des relations entre deux variables
• Histogrammes et densités pour comprendre la distribution d’une variable
• Boxplots pour comparer des groupes : médiane, dispersion, valeurs aberrantes
• Graphiques en barres pour des comptages et des proportions
• Facettes pour découper un même graphique par catégorie
• Courbes de tendance pour visualiser une relation linéaire ou non linéaire

En data science, ggplot2 intervient à toutes les étapes : en exploration (EDA) avant tout modèle, en communication pour présenter des résultats, en diagnostic pour vérifier le comportement d’un modèle (résidus, distributions).

Face à la question « est-ce que cette variable influence celle-là ? », la première réponse n’est pas de lancer une régression, c’est de dessiner le graphique. ggplot2 donne les yeux avant de donner le chiffre.

FactoMineR : comprendre quand on a trop de variables

FactoMineR est la référence en R pour les analyses factorielles multivariées : quand on dispose de beaucoup de variables et qu’on veut comprendre la structure cachée des données, au-delà d’une analyse variable par variable.

FactoMineR propose plusieurs méthodes, chacune adaptée à un type de problème différent.

L’ACP : Analyse en Composantes Principales

L’ACP s’applique aux variables quantitatives. Face à un questionnaire avec 20 questions numériques, ou un dataset avec 15 mesures physiques par individu, l’ACP cherche des combinaisons de variables qui résument l’essentiel de l’information. Au lieu de 20 dimensions impossibles à visualiser, on obtient 2 ou 3 composantes principales qui expliquent la majorité de la variance.

Cas d’usage typiques :

• Réduire le nombre de variables avant du machine learning (moins de bruit, moins de colinéarité)
• Visualiser des données multidimensionnelles en 2D
• Détecter des groupes naturels ou des individus atypiques
• Comprendre quelles variables « vont ensemble »

L’AFC : Analyse Factorielle des Correspondances

L’AFC s’applique aux tableaux de contingence : des tableaux croisés entre deux variables qualitatives. Par exemple, espèce de fleur × taille de pétales, ou région × type de produit acheté. L’AFC révèle quelles modalités sont associées, lesquelles s’éloignent, comment les catégories se structurent.

Cas d’usage typiques :

• Études de marché (quels profils de clients achètent quoi)
• Analyse de surveys avec des réponses catégorielles
• Comprendre l’association entre deux variables qualitatives au-delà d’un simple test du chi-deux

L’ACM : Analyse des Correspondances Multiples

L’ACM généralise l’AFC à plusieurs variables qualitatives simultanément. Un questionnaire avec des réponses « oui/non/autre » sur 10 questions peut ainsi révéler comment les profils de répondants se regroupent.

Cas d’usage typiques :

• Segmenter une population selon plusieurs critères qualitatifs
• Études sociologiques, enquêtes, sondages
• Comprendre des profils types dans des données catégorielles

FactoMineR ne relève pas du machine learning au sens prédictif. C’est de l’exploration profonde : comprendre la géométrie des données avant de décider quoi faire ensuite. Une étape que beaucoup de projets sautent, alors qu’elle permet d’éviter des erreurs en aval.

factoextra : rendre visible ce que FactoMineR calcule

FactoMineR calcule. factoextra montre.

La différence : d’un côté, un objet R rempli de coordonnées, de contributions, de pourcentages de variance expliquée ; de l’autre, un graphique compréhensible en quelques secondes.

factoextra visualise les résultats de l’ACP, de l’AFC, de l’ACM, mais aussi du clustering. Concrètement, il permet de :

• Afficher les individus sur un plan factoriel, colorés par groupe
• Tracer le cercle des corrélations pour voir quelles variables contribuent à quoi
• Montrer le pourcentage de variance expliquée par chaque composante
• Visualiser des clusters (k-means, clustering hiérarchique) projetés en 2D
• Dessiner des dendrogrammes pour voir comment les groupes se forment

factoextra est le pont entre l’analyse mathématique et la compréhension intuitive. Là où FactoMineR indique « la composante 1 explique 73% de la variance », factoextra montre à quoi ressemble cette composante : quels individus sont proches, quelles variables tirent dans quelle direction.

En machine learning, le clustering (k-means, classification ascendante hiérarchique) revient fréquemment. factoextra n’effectue pas le clustering, mais il aide à interpréter les groupes trouvés, une étape souvent plus difficile que le calcul lui-même.

Comment tout s’assemble dans un vrai projet

Voici à quoi ressemble un flux de travail réaliste en data science avec ces packages :

1. Les données arrivent : CSV, Excel, base SQL. Elles sont rarement propres.
2. tidyr + dplyr : nettoyage, reshaping, filtrage, création des variables nécessaires.
3. data.table : si le volume est important, pour gagner en performance.
4. ggplot2 : exploration visuelle des variables, distributions, corrélations, valeurs aberrantes.
5. FactoMineR : si le nombre de variables est élevé, ACP ou ACM pour comprendre la structure globale.
6. factoextra : visualisation des résultats pour valider les intuitions.
7. Ensuite seulement : régression, classification, clustering prédictif, ou rapport final.

Ce pipeline met en évidence un point clé : la majorité du travail en data science se joue avant le modèle. Les packages présentés ici couvrent précisément cette phase.

Tableau récapitulatif

Conclusion

R n’est pas qu’un langage avec des formules statistiques : c’est un écosystème où chaque package a un rôle précis, et où la vraie compétence réside dans la capacité à enchaîner les bons outils au bon moment.

Les packages présentés ici ne font pas de machine learning à la place du praticien. Mais sans eux, il est difficile d’arriver sereinement au machine learning. Parce qu’avant de prédire, il faut comprendre. Avant de modéliser, il faut voir. Avant de conclure, il faut nettoyer.

La data science n’est pas une course vers le modèle le plus sophistiqué : c’est d’abord une manière de regarder les données avec les bons outils. Et R, avec cet écosystème de packages, offre précisément ce cadre de travail.

Cet article suit un fil progressif : d’abord comprendre comment Matplotlib construit un graphique (Figure, Axes, et les deux façons de les piloter), puis l’appliquer à des fonctions d’une variable, à des surfaces en trois dimensions, au choix des couleurs, et enfin aux statistiques descriptives d’un jeu de données.

0. Anatomie d’un graphique Matplotlib

Avant de tracer quoi que ce soit, il est utile de comprendre les deux objets que Matplotlib manipule en permanence :

• la Figure est la toile entière — le conteneur qui peut accueillir un ou plusieurs graphiques, une légende globale, un titre, etc. ;
• l’Axes est un graphique individuel à l’intérieur de cette toile, avec ses propres axes X/Y, ses graduations, son titre. C’est sur l’Axes que l’on trace les courbes.

Matplotlib propose alors deux façons d’écrire le même graphique, selon la documentation officielle : l’interface orientée objet (fig, ax = plt.subplots(), en gardant une référence explicite à fig et ax) et l’interface pyplot (un état implicite modifié par des fonctions globales comme plt.plot()). Les deux produisent un résultat identique, mais l’interface orientée objet est plus explicite et plus flexible : elle permet de garder la main sur chaque élément du graphique avant de l’afficher, notamment lorsqu’on combine plusieurs Axes dans une même Figure. C’est celle que nous utiliserons pour les graphiques les plus riches de cet article — les exemples les plus simples ci-dessous gardent volontairement l’interface pyplot, plus courte à lire.

1. Fonctions d’une variable réelle : $f : \mathbb{R} \to \mathbb{R}$

Cette section parcourt trois familles de fonctions représentatives — chacune illustre un comportement mathématique différent : croissance, saturation, borne.

Croissance et décroissance exponentielles : $e^{x}$ et $e^{-x}$

L’exponentielle est la fonction qui vérifie $f’ = f$ : sa vitesse de variation est à chaque instant proportionnelle à sa propre valeur. C’est le modèle de base de toute croissance (population, intérêts composés) ou décroissance (désintégration radioactive, décharge d’un condensateur) proportionnelle à la quantité présente.

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-2, 2, 300)
y_croissance = np.exp(x)
y_decroissance = np.exp(-x)

plt.figure(figsize=(10, 5))
plt.plot(x, y_croissance, color='steelblue', linewidth=2, label='croissance : e^x')
plt.plot(x, y_decroissance, color='tomato', linewidth=2, label='décroissance : e^-x')
plt.title('Croissance et décroissance exponentielles')
plt.xlabel('x')
plt.ylabel('y')
plt.legend(loc='upper center')
plt.grid(True, alpha=0.3)
plt.show()

La fonction logistique et sa dérivée : $\sigma(x) = \dfrac{1}{1+e^{-x}}$

La sigmoïde transforme n’importe quel nombre réel en une valeur entre $0$ et $1$ : elle sature vers $1$ quand $x \to +\infty$ et vers $0$ quand $x \to -\infty$, avec un point d’inflexion en $(0, 0{,}5)$. C’est la fonction d’activation historique des réseaux de neurones, et le cœur de la régression logistique.

Sa dérivée a une propriété remarquable, utile pour la rétropropagation du gradient : $\sigma’(x) = \sigma(x)\bigl(1-\sigma(x)\bigr)$, une courbe en cloche maximale exactement là où $\sigma$ varie le plus vite.

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-6, 6, 400)
sigmoide = 1 / (1 + np.exp(-x))
derivee = sigmoide * (1 - sigmoide)

plt.figure(figsize=(10, 5))
plt.plot(x, sigmoide, color='steelblue', linewidth=2, label='sigmoïde')
plt.plot(x, derivee, color='tomato', linewidth=2, linestyle='--', label='dérivée')
plt.title('Fonction logistique (sigmoïde)')
plt.xlabel('x')
plt.ylabel('y')
plt.legend(loc='upper left')
plt.grid(True, alpha=0.3)
plt.show()

Une fonction rationnelle bornée : $f(x) = \dfrac{1}{1+x^2}$

Contrairement à l’exponentielle vue plus haut, qui explose vers l’infini, cette fonction reste bornée ($0 < f(x) \leq 1$) sur tout $\mathbb{R}$, tout en restant infiniment différentiable — sans jamais utiliser d’exponentielle ni de trigonométrie. Son maximum global vaut $1$ en $x=0$, et elle décroît vers $0$ de part et d’autre, un peu comme la cloche gaussienne de la section suivante, mais avec une décroissance beaucoup plus lente (en $1/x^2$ plutôt qu’en $e^{-x^2}$).

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 400)
y = 1 / (1 + x**2)

plt.figure(figsize=(10, 5))
plt.plot(x, y, color='steelblue', linewidth=2)
plt.title('Fonction rationnelle bornée')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True, alpha=0.3)
plt.show()

2. Fonctions de deux variables : $f : \mathbb{R}^2 \to \mathbb{R}$

Lorsqu’une fonction dépend de deux variables réelles $x$ et $y$, son graphe n’est plus une courbe dans le plan mais une surface dans l’espace $\mathbb{R}^3$. On représente alors $z = f(x, y)$ en trois dimensions.

Pour cela, Matplotlib propose le module mpl_toolkits.mplot3d et la fonction plot_surface. Sur cette page, les graphiques 3D ci-dessous sont interactifs : cliquez-glissez pour les faire pivoter et observer la surface sous un autre angle.

Préparation : la grille de points

La visualisation d’une surface nécessite de créer une grille régulière de points $(x, y)$ couvrant le domaine souhaité. La fonction np.meshgrid génère cette grille :

import numpy as np

x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
# X et Y sont des matrices 100×100
# chaque point (X[i,j], Y[i,j]) correspond à un point de la grille

Surface paraboloïde : $f(x, y) = x^2 + y^2$

Le paraboloïde elliptique est la surface la plus simple à deux variables. Son point minimal est en $(0, 0, 0)$ et la surface s’élève symétriquement dans toutes les directions. C’est la généralisation en 2D de la parabole.

Cette surface est différentiable partout. Son gradient $\nabla f = (2x, 2y)$ est nul en $(0,0)$, qui est un minimum global.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = X**2 + Y**2

fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(111, projection='3d')
surf = ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.9)
fig.colorbar(surf, ax=ax, shrink=0.5, label='z = f(x, y)')
ax.set_title('Paraboloïde : $f(x, y) = x^2 + y^2$')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.tight_layout()
plt.show()

Selle de cheval (col) : $f(x, y) = x^2 - y^2$

La selle de cheval est l’exemple typique d’un point critique qui n’est ni un minimum ni un maximum. En $(0,0)$, la dérivée est nulle dans toutes les directions, mais la surface monte dans la direction $x$ et descend dans la direction $y$ : on appelle ce point un point selle ou col.

$$\nabla f = (2x, -2y) = (0, 0) \text{ en } (0,0)$$

La matrice hessienne $H = \begin{pmatrix} 2 & 0 \ 0 & -2 \end{pmatrix}$ a un déterminant négatif ($-4 < 0$), ce qui confirme le point selle.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = X**2 - Y**2

fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(111, projection='3d')
surf = ax.plot_surface(X, Y, Z, cmap='coolwarm', alpha=0.9)
fig.colorbar(surf, ax=ax, shrink=0.5, label='z = f(x, y)')
ax.set_title('Selle de cheval : $f(x, y) = x^2 - y^2$')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.tight_layout()
plt.show()

Surface ondulée : $f(x, y) = \sin(x)\cos(y)$

La combinaison de fonctions trigonométriques sur deux variables produit une surface périodique dans les deux directions. Cette surface est différentiable partout et possède une infinité de points critiques correspondant aux maxima ($+1$), minima ($-1$) et points selles.

$$\nabla f = (\cos(x)\cos(y),; -\sin(x)\sin(y))$$

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

x = np.linspace(-2 * np.pi, 2 * np.pi, 200)
y = np.linspace(-2 * np.pi, 2 * np.pi, 200)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y)

fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(111, projection='3d')
surf = ax.plot_surface(X, Y, Z, cmap='plasma', alpha=0.9)
fig.colorbar(surf, ax=ax, shrink=0.5, label='z = f(x, y)')
ax.set_title('Surface ondulée : $f(x, y) = \\sin(x)\\cos(y)$')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.tight_layout()
plt.show()

Cloche gaussienne : $f(x, y) = e^{-(x^2 + y^2)}$

La cloche gaussienne en deux dimensions est la généralisation de la distribution normale. Elle possède un maximum global en $(0, 0)$ où $f(0,0) = 1$, et tend vers $0$ dans toutes les directions. Elle est différentiable partout et ses courbes de niveau sont des cercles concentriques.

Cette surface intervient notamment en probabilités (densité de la loi normale bivariée) et en traitement du signal (filtre gaussien).

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

x = np.linspace(-3, 3, 200)
y = np.linspace(-3, 3, 200)
X, Y = np.meshgrid(x, y)
Z = np.exp(-(X**2 + Y**2))

fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(111, projection='3d')
surf = ax.plot_surface(X, Y, Z, cmap='magma', alpha=0.9)
fig.colorbar(surf, ax=ax, shrink=0.5, label='z = f(x, y)')
ax.set_title('Cloche gaussienne : $f(x, y) = e^{-(x^2+y^2)}$')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.tight_layout()
plt.show()

Fonction non différentiable : $f(x, y) = |x| + |y|$

Toutes les fonctions ne sont pas différentiables. La fonction $f(x, y) = |x| + |y|$ est continue partout mais non différentiable le long des axes $x = 0$ et $y = 0$, car la dérivée partielle n’y existe pas (la pente change brutalement).

Son graphe forme un croisement de plis : quatre faces planes qui se rejoignent sur les axes avec des arêtes nettes. Les courbes de niveau sont des carrés, et le minimum global est en $(0, 0)$.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

x = np.linspace(-5, 5, 200)
y = np.linspace(-5, 5, 200)
X, Y = np.meshgrid(x, y)
Z = np.abs(X) + np.abs(Y)

fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(111, projection='3d')
surf = ax.plot_surface(X, Y, Z, cmap='YlOrRd', alpha=0.9)
fig.colorbar(surf, ax=ax, shrink=0.5, label='z = f(x, y)')
ax.set_title('Non différentiable : $f(x, y) = |x| + |y|$')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.tight_layout()
plt.show()

Courbes de niveau : une autre façon de lire une surface

Les courbes de niveau (ou isocourbes) sont les projections horizontales de la surface : pour chaque valeur $c$, elles représentent l’ensemble des points $(x, y)$ tels que $f(x, y) = c$. C’est la représentation utilisée sur les cartes topographiques — souvent plus lisible qu’une surface 3D pour repérer précisément un extremum ou comparer deux valeurs.

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-3, 3, 300)
y = np.linspace(-3, 3, 300)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y)

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# Surface en couleur
c1 = axes[0].contourf(X, Y, Z, levels=30, cmap='plasma')
fig.colorbar(c1, ax=axes[0], label='f(x, y)')
axes[0].set_title('Carte de chaleur : $f(x,y) = \\sin(x)\\cos(y)$')
axes[0].set_xlabel('x')
axes[0].set_ylabel('y')

# Courbes de niveau
c2 = axes[1].contour(X, Y, Z, levels=20, cmap='plasma')
axes[1].clabel(c2, inline=True, fontsize=8)
axes[1].set_title('Courbes de niveau')
axes[1].set_xlabel('x')
axes[1].set_ylabel('y')

plt.tight_layout()
plt.show()

3. Bien choisir ses couleurs

Le choix d’une carte de couleurs (cmap) n’est pas qu’une question esthétique : une mauvaise carte peut faire apparaître de faux motifs ou masquer de vraies variations. Jusqu’en 2015, la carte par défaut de Matplotlib était jet, un dégradé arc-en-ciel dont la luminosité varie de façon irrégulière — deux valeurs proches peuvent y sembler très différentes, et inversement.

En 2015, Nathaniel Smith et Stéfan van der Walt ont conçu quatre cartes perceptuellement uniformes — viridis, plasma, magma, inferno — où la luminosité croît de façon monotone avec la valeur représentée. Elles restent lisibles en niveaux de gris et pour les daltoniens, et viridis est devenue la carte par défaut de Matplotlib à partir de la version 2.0 (voir le guide officiel des colormaps).

On distingue en pratique trois grandes familles :

C’est pourquoi la selle de cheval utilise coolwarm plutôt que viridis : sa valeur change de signe autour de $(0,0)$, et une carte divergente rend ce basculement immédiatement visible.

4. Statistiques descriptives avec NumPy et Pandas

La visualisation ne se limite pas aux fonctions mathématiques : elle est aussi au cœur de l’analyse de données. Avant toute modélisation, il est essentiel de comprendre la distribution des variables.

La distribution normale

La distribution normale (ou gaussienne) est caractérisée par deux paramètres : la moyenne $\mu$ (centre de la distribution) et l’écart-type $\sigma$ (dispersion). Sa densité de probabilité est :

$$\phi(x) = \frac{1}{\sigma\sqrt{2\pi}},e^{-\frac{(x-\mu)^2}{2\sigma^2}}$$

L’histogramme permet de visualiser la distribution empirique d’un échantillon et de la comparer à la courbe théorique :

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

mu, sigma = 100, 15
data = np.random.normal(mu, sigma, 1000)

x_range = np.linspace(mu - 4*sigma, mu + 4*sigma, 300)

fig, ax = plt.subplots(figsize=(10, 5))
ax.hist(data, bins=40, density=True, color='steelblue', alpha=0.6, label='Échantillon empirique')
ax.plot(x_range, norm.pdf(x_range, mu, sigma), color='tomato', linewidth=2,
        label=r'Densité théorique $\mathcal{N}(100, 15^2)$')
ax.set_title('Distribution normale : échantillon vs densité théorique')
ax.set_xlabel('Valeur')
ax.set_ylabel('Densité')
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Plus l’échantillon est grand, plus l’histogramme empirique (en bleu) se rapproche de la courbe théorique (en rouge) — c’est une illustration directe de la loi des grands nombres.

Résumé statistique avec Pandas

La méthode describe() de Pandas fournit en une seule commande les principales mesures de tendance centrale et de dispersion :

import numpy as np
import pandas as pd

data = np.random.normal(100, 15, 1000)
serie = pd.Series(data, name='mesures')
print(serie.describe())

Fonctions statistiques NumPy

NumPy propose un ensemble de fonctions directement applicables sur des tableaux :

import numpy as np

notes = np.random.normal(12, 3, 50)

print(f"Moyenne   : {np.mean(notes):.2f}")
print(f"Écart-type: {np.std(notes):.2f}")
print(f"Minimum   : {np.min(notes):.2f}")
print(f"Maximum   : {np.max(notes):.2f}")
print(f"Médiane   : {np.median(notes):.2f}")

La moyenne mesure le centre de gravité des données. L’écart-type quantifie leur dispersion autour de cette moyenne. La médiane est la valeur qui sépare les 50% inférieurs des 50% supérieurs : elle est plus robuste que la moyenne en présence de valeurs aberrantes.

Inspection rapide : head() et tail()

Pour un premier aperçu d’un jeu de données, head() affiche les premières lignes et tail() les dernières :

import numpy as np
import pandas as pd

temperatures = np.random.uniform(15, 35, 100)
serie = pd.Series(temperatures, name='température (°C)')

print("Premières valeurs :")
print(serie.head(8))

print("\nDernières valeurs :")
print(serie.tail(5))

Récapitulatif

Trois réflexes suffisent pour aborder n’importe quel nouveau jeu de données ou fonction : préférer l’interface orientée objet (fig, ax) dès que le graphique se complexifie, choisir une carte de couleurs séquentielle ou divergente selon que la grandeur a ou non un centre neutre, et toujours commencer l’analyse d’un échantillon par describe() avant de se lancer dans un modèle.

Python offre ainsi un environnement complet pour explorer les fonctions mathématiques dans toutes leurs dimensions : des oscillations périodiques aux surfaces complexes, des comportements différentiables aux singularités, des données brutes aux résumés statistiques. La visualisation n’est pas une étape accessoire : c’est souvent le premier geste qui révèle la structure d’un problème.

Pour aller plus loin

• Quick start guide — Matplotlib
• Choosing colormaps — Matplotlib
• NumPy documentation
• Pandas documentation