Why Did Python Win?

First class package manager, first class numeric operations for scientific usages (numpy), garbage collection, uniform human-readable syntax. Basically seems like it learned a lot from Perl both good and bad, and put those lessons into usage with the scientific community first. Kids got used to it in school and wanted to use it after.

Did it win? Against just Perl, or everything else?

python won because of enforced whitespace. It solved a social problem that other languages punted to linters, baking readability into the spec

1. Python was designed by testing syntax with novice users to see what they could adopt easily.[1] > 90% of current Python users weren’t born when it was created. They all had to learn, and Python is the easiest language to learn because Guido and his teammates, unlike $LANGUAGE_DESIGN_GOD, approach the problem as experimental scientists rather than auteurs.

2. Python is conceptually compact, dominated by hash tables with string keys. The initial leader in the ecosystem, Perl, is conceptually sprawling and difficult to reason about.

3. Python also took lessons from the Unix shell, a mature environment for accommodating beginners and experts.

4. Python had a formal process for integrating C modules from early on.

5. Python’s management has an elegant shearing layer structure, where ideas can diffuse in from anywhere.

6. $NEXT_GENERAL_PURPOSE_LANG (Ruby, Go) weren’t enough better to displace Python. Both were heavily influenced by Python’s syntax, but ignored the community-centric design process that had created that syntax in favor of We Know Best.

7. Speaking of open source entrepreneurialism, JavaScript has become a real rival thanks to the Web (and node), but it is handicapped by the inverse failure mode: where Go is dominated by a handful of Googlers, JavaScript was effectively unmanaged at the STDLIB level for a crucial decade, and now it can’t recover. (I’d also guess that having to write a module system that works well in the chaos that is Web clients and simultaneously the Unix world is a daunting design problem.)

8. Python got lucky that data science took off.

[1] https://ospo.gwu.edu/python-wasnt-built-day-origin-story-wor...

It's hardly "inexplicable"... particularly if you're comparing it to Perl, a famously hard to read language.

* Python has clean and readable syntax that a complete beginner can understand -- it's really close to the pseudocode you might use for teaching.

* Python has a good standard library, so you can do a lot before you need to work out how to install more (and, reproducibility concerns aside, `pip install` is really simple once you get there)

* Because it was easy to pick up and easy to use for teaching, it took over some niches like stats in academia / data-analysis, where the people doing the work aren't professional programmers but just need something they can hack together. Once NumPy existed, people had minimal incentive to move away.

(Insert Marge Simpson "I just think it's neat" gif here.)

I think the reason python won was that it was easy to learn and read and was batteries included. vs perl: People need to solve their problems, not fight with syntax

Theres a lot of network effects as well. The more people were using it, the more people will use it.

> If you survey the language landscape now, a language can be much better than Python but never get the chance Python did just because it happened to look a bit better than Perl. Which is absurd to me.

You’re struggling to understand Python’s success because in your head the primary reason Python succeeded was because it happened to be prettier than Perl, and you can’t wrap your head around why that’s enough. But it’s not enough. Python succeeded for many reasons.

Because not many people prioritize syntax design like GvR. Even now if someone releases a new programming language most people will ask what features it has, how fast it is, how fast is the package manager etc. Because these questions are simple yes and no ones. Unlike syntax design choices.

Even if they ask about the syntax design people just dismiss their question with saying "syntax is not important". Python did the opposite, it focused on syntax over everything else. That caught on with beginners and now here we are.

Of course with AI Python got even more popular, but even before ChatGPT was released it was already dominant.

You can't only look at it from the perspective of a software engineer. Ordinary people can read and write Python much more easily than a ton of other languages. It's very easy to get started, with basically no ceremony. Highly tolerant of user errors yet still allows one to grow with the language (nobody writes ABCs on their first day).

Python has issues, but those issues don't matter equally to everyone and every use case. Low barrier to entry, coupled with Metcalfe's law, explains a lot IMO.

I love Scheme, but not everybody does, and I can see why.

Previously:

- Perl's decline was cultural - https://news.ycombinator.com/item?id=46175112 - Dec 2025 (460 comments)

- (!) Ask HN: Why did Python win? - https://news.ycombinator.com/item?id=37308747 - Aug 2023 (839 comments)

- Ask HN: Why is Python so popular for ML/DS? - https://news.ycombinator.com/item?id=16207834 - Jan 2018 (19 comments)

- Ask HN: Is Python dying? - https://news.ycombinator.com/item?id=11100251 - Feb 2016 (352 comments)

- Python is now the most popular introductory language at top U.S. universities - https://news.ycombinator.com/item?id=8001337 - July 2014 (362 comments)

- Ask HN: Why Python over Ruby? - https://news.ycombinator.com/item?id=682101 - July 2009 (196 comments)

- Ask HN: What does Ruby have that Python doesn't? - https://news.ycombinator.com/item?id=283639 - Aug 22, 2008 (223 comments)

Nothing against Python but I still use Perl 5 because it works for what I need to do.

The Perl 6 redesign was announced in 2000 and it has been going on for 2 decades? Python is clearly a good programming language but the Perl 6 redesign took so long that many people gave up. Then it was renamed Raku in 2019 I think.

There is a network effect with programming languages. Once you get popular, more people write libraries and guides for that language, which in turn makes it even more popular.

If you were czar of the universe and could start from scratch, could a better scripting language be created? Sure. But that’s not the fact pattern, and Python isn’t bad enough at what it does to warrant starting over.

Years ago I wrote article on this topic: https://www.notonlycode.org/why-python-has-won/

In short (all below is my opinion): it was popular in academia and got some corporate adoption, so when ML exploded in popularity it was a natural choice as the scripting language for ML tooling. On top of that it’s easy to pick up as a language, and it’s a general purpose language - there are lots of scientific tools like pandas written in it, there are web frameworks, etc.

Perl was too quirky for wide adoption and it stopped developing (Raku/Perl 6 took to long to develop), PHP was focused purely on the web, similarly JS. Ruby could have won, I like it more than Python, but outside of Japan it’s also mostly been associated with web development (because of Rails), it also lacked libraries that Python already had.

Python won because Google picked it over perl in the early 2000s, declaring that it was more uniform in having one preferred way to do things rather than allowing (in contrast to Perl) programmers having a zillion ways to do things.

Larry Wall, creator of Perl, coined the phrase, "make the easy things easy, and the hard things possible". But the things perl made easy were not always things that the market needed. Perl was very distrustful of enterprise disciplines and the perl culture "let a thousand flowers bloom" mentality (which they/we called "There's more than one way to do it"/(TMTOWTDI)) was not actually useful for organizations maintaining larger code bases/systems with large groups of mixed skill level people.

Python threaded that needle of centralizing a right way to do things (not just whitespaces) more effectively.

I also observed Scala suffering from similarly disfunctional "TMTOWTDI" dynamic in organizations I belonged to; different people had wildly different styles of solving even basic problems and it really made code hard to maintain even in smaller organizations where people came and went and new people were onboarded frequently.

Plus data science use cases saved Python's web/scripting lifespan in a way slightly analogous to AI/CUDA extending NVidia's 3D graphics-centric roots. (Although the python data science ecosystem nowdays does have some TMTOWTDI weaknesses that remind me of perl/cpan's choices of web development frameworks of the mid-2000s!)

Non-swe, classic engineer here

Python is easy to learn and has an extensive library catalog. It also has massive support available online. That's why I have chosen it in the past when I needed to write basic programs for work.

With the rise of LLMs, python is now even more attractive as LLMs really excel at writing it.

Win what?

Against Perl? Over a decade ago. 10 years ago, the only places that required Perl were either hard engineering (i.e. non-programmer EEs) or those with legacy code bases.

Over everything else? Of course not. You don't do systems level work in Python.

The problems with Python are minor (other than packaging), and not a big enough pain to adopt another language. If you really could benefit from static typing, there are already existing languages that do the job well (C++, Rust, etc).

For the majority (including even some Perl fans), switching to Python was a significantly better experience. If you now show me a language better than Python, it's really only an incremental benefit. Sure, I prefer ML languages like F#, but the vast majority don't.

I learned Python circa 2000 as a 17 year old.

It felt pretty easy to read and write, had minimal surprises, and it made writing simple programs easy. The batteries-includedness was great.

It felt like it was designed by a smart guy for practical programming, rather than by a brilliant academic who was wed to purity for maximum elegance. It accepted some warts, but them in mostly ergonomic places.

It was dictated by people who could relegate map, filter, and reduce from builtins to the library. As much as I personally even liked map in particular (I am not super anti functional programming), it's nice to realize the designer had the taste to prefer longer but more explicit programs.

    ys = [f(x) for x in xs]
    ys = map(f, xs)

As much as I disliked that particular decision, there is no doubt to me that it is just designed for lower cognitive burden when doing simple/common things.

If you show both of those lines of code to a person in cs101 who has studied Java for a couple months but hasn't seen Python, I am pretty sure they are gonna understand the first line way quicker. Mostly consistent decision making like that leads to ergonomic, practical languages. And they win.

It fits in people's brains better. See also, pytorch vs tensorflow.

Perl was my introduction to web programming in the 90s, and then I moved onto python and php.

Perl’s alien syntax and how there were multiple competing “best practices” put off newcomers and made it difficult to code review.

Perl also stagnated for quite some time due to the efforts to move to Perl 6, though python likewise stalled later it already had better traction at that point.

However I’d argue that Perl lost to PHP at least as much as it lost to python. PHP was revolutionary at the time for how easy and straightforward it was to do simple web programming which was one of the big use cases for Perl.

By the early 2010s there wasn't much of any use case that made sense to choose Perl. Sysadmin scripting was clearer to review and maintain in python and golang, web applications moved to php and frameworks written in languages that didn’t have the downsides of Perl.

I have recently gone all in on Python. Before I decided this, I was using Python for projects where I needed Pandas or numpy. I used React/TypeScript/Node for web applications. But, I moved to Django/HTMX.

The main reason is to avoid npm, but also, I wanted something with more built-in defaults (my web apps have simple needs). It has nothing to do with the language -- it's more the ecosystem for me.

I considered Ruby/Rails, but it didn't seem enough better than Python and can't replace the Pandas work I need to do.

As a C++ dev turned python dev (and also someone who writes code for analysts, data scientists etc.), the answer is really obvious to me.

First, newbie onboarding. What is the hello world like? Is there any obsequious unexplainable stuff ('#pragma once'? 'use warnings;')? Symbol usage. ';' I'm going to have to show someone where that is, and they are going to have to peck and hunt for it for their first ten hours programming. They are going to miss a line. Python is has one of the easiest hello worlds of all time, white space mattering significantly reduces symbol usage. The errors are good. There is a REPL.

Second, python as a language interface. Partly because of the first point, if I want to write a framework for data scientists, I will write it in python. And if I want performance on that framework then I am going to write the backend in C, C++, Rust etc. bindings are more or less trivial to write and the users can get a C++ data structure with simple python syntax.

Python wins hands-down in having readable code.

Perl has so many ways to write the same code, no two codebases are the same - it's practically different languages. Back when I was programming Perl, I remember reading my own Perl scripts I wrote few years ago, and being annoyed with how they were doing everything all wrong... because in those few years, my Perl style has changed significantly. And others' scripts were even worse!

Plus, python had all those neat quality-of-life things useful for day-to-day scripting. For example actual function parameters, exceptions (no more "or die" after each open), pretty big stdlib (I _don't_ miss having to configure "cpan" on each new machine), repr() in language core, etc..

And yes, Python got lucky somewhat - there was a need for "Perl but easier to read and friendlier to new users", and Python has filled that need. And now that need is no longer open, so it's harder for newcomers to fill that niche. But that's life in general - Rust filled the niche of "No overheads like C++ but memory safe", Go has filled the niche of "Compiled systems language with GC" etc... And once a language gets popular, network effects kick in.

My 2c. And only my recollection. Back in the stone age, there were two that had significant mindshare: perl and python. Of course, there were others, and they had their day in the sun too (e.g. rexx, rebol, etc.). I suspect that python stood out, and developed momentum, because of its availability on, and integration with, Windows where many of today's senior devs were cutting their teeth. Particularly, I'd point out, Mark Hammond's contributions. Suddenly, you had an accessible language with a deep integration with the underlying OS. Perl had that too, if you were using one of the unices, but most eager devs weren't - back then, linux wasn't what it is today. Perl excelled at the traditional file-based (and filelike-based) tasks. It had a good niche in early web development using cgi. But, I think python was just both more accessible in general, and more useful in general than perl - without resorting to C, or C++, or another compiled language.

I don't know if you can point to a single feature, a lot of what makes a language successful is around context and placement (javascript being a great example of this).

I think there's a few key features for python that have definitely been a big help for it:

It's highly dynamic meaning you can get running with it before understanding every detail (no compile step, no static typing etc).

It may not be the best at everything, but is a decent choice for most things, making a good generic intro language for programming.

It has good interop with low level languages - this is a big deal for data science where a less technical (from a CS perspective) user still needs the performance of a language like C/Fortran/Rust/etc. Python's pattern of "use python as a high level api for libraries in those other languages" (as in numpy, pandas, polars, pytorch etc).

That last one has been a big deal recently, python has become the de-facto language for data science as a result of this.

I often consider how many total human lifetimes must have been spent on nothing other than dealing with and/or mitigating something as seemingly banal as Python versioning & dependency management or line ending encoding snafus.

After all these years, I assume it must measure in the tens to hundreds of thousands?

It’s in those moments of consideration that I understand humanity hasn’t done a very good job grappling with its frailty and mortality. If we had, then we’d have a crowned a winner that didn’t subjugate us endlessly to the most vapid and Sisyphean aspects of programming. Python is a lesson in managing existential angst, which I now assume was the point of it from the very beginning.

IMO, Python rode some of the growth from the data and scientific computing computing. It was lower friction for many people partially due to the amount of blogs, and open source projects that were available. Pandas and Numpy made it quite easy to get up and running with a lot of analytics. pytorch and tensorflow were also there to facilitate this, made people able to get the benefits of the optimized C code but most users did not have to learn C. Eventually FastAPI came out for those looking to build products out of their data, and FastAPI had fantastic documentation and guides, which helped these same folks coming from data/scientific compute build working software. I suppose what I am describing are some of the network effects.

I started my data analysis journey using Perl and then Python. Perl had also a variety of libraries, online classes from O'Reilly's, samples online, CGI support, I moved to Python when installing some dependencies became troublesome and Perl versioning was not compatible between each other don't recall the details, since then been using Python extensibly since 2.7

Python optimized for C-interop (NumPy) just as data science exploded. While Perl won text processing, Python became the universal interface for C libraries. That ecosystem lock-in—not syntax—is why it won. It was the right glue at the right time.

> it happened to look a bit better than Perl. Which is absurd to me.

It's not absurd, it's a debatable point. I think being easy to read is definitely a desirable quality for any language, especially for adoption. Some are better than others in this field.

Python was viewed as an alternative to Perl mainly because they were used for the same kinds of scripts. The biggest difference at the time, how-many-ways-to-do-it notwithstanding, was that when a novice saw a Python script of 20-50 lines, they (felt like they) understood it without having to reach for a language reference. Readability at a glance for people who hadn't yet specifically learned the language was huge. "Executable pseudocode" was the operative phrase.

Google used and endorsed it at a critical time back when the mainstream media machine was inflating their image. Even programmers like to ape celebrities and by extension Python was the choice of the sophisticated and well-read hacker in the know. It was just luck and dumb social reasons.

> Python is most dominant language on the planet

JavaScript would like a word!

I think an underrated aspect of Python's success is that is easier for non-SWE professionals to understand and use. Python is popular among software developers, but it is overwhelmingly popular among scientists.

Python had a pretty big jump in 2008 when it was the first language supported by Google AppEngine. It was one of the big 3 languages used internally at Google. That's probably the first key domino in the chain.

I'd like for Julia to fill its niche myself.

The elegant syntax that is close to plain English sets it apart.

(It’s not so pretty these days though with all these type hints and other cruft that’s been added in the last ten years.)

No surprise that interpreted languages like Javascript, Perl, PHP and Python are disproportionately popular independent of pure language merit. The feedback loop is the killer feature.

So much easier to pick up than Perl. Even for an experienced programmer, let alone a new learner. And the rich standard library.

Its syntax is lowest common denominator. It’s incredibly easy for people from all walks of life to pick up. It’s “good enough” for just about every task.

But really it’s because Google, Dropbox, etc made it so. Same reason Java got popular. It’s hard to beat first class corpo support even if the actual language isn’t that great.

Python ultimately won because of its community.

The Python leadership group is friendly towards beginners and people with non-traditional backgrounds, and they actively reach out and recruit those folks to participate. It's also one of the least toxic developer communities I know of.

That matters a lot in a field like data science or cybersecurity, which has a lot of people who don't have traditional SWE backgrounds.

The language is pleasant and readable to use and has a lot of features built in, which Perl did not, but I think that's much less critical than the network effect of being a (1) welcoming and pleasant community who (2) actively recruits new fields of people.

> Python is most dominant language on the planet

By GitHub contributor counts, August 2025 marks the first time TypeScript emerged as the most used language on GitHub, surpassing Python by ~42k contributors

https://github.blog/news-insights/octoverse/octoverse-a-new-...

Ex-product manager of an IDE and language here. Languages, like just about anything, win because of what you can do with them: ie, value. Consider Ruby on Rails: it drove Ruby; the achievement was easily creating fullstack web apps, at just the right time. Consider VB: you could build UI apps. No languages win based on the language itself but what it lets you achieve. Usually, this is in the form of libraries:* ie, functionality that using the language lets you achieve. It's not the language, but where using the language lets you get to.

Python is a nice language, but so are others. I know of three main libraries -- three main "I can get stuff done" -- eras with Python, and I think these drove Python.

1. Beautiful Soup. Early/mid 2000s, web scraping and website / XML / HTML data manipulation were a thing; this library came along and made it easy. I'd heard of Python before on places like Slashdot; it was cool but Perl was more spoken of. Then, in my anecdotal experience, what I suddenly read about was not Perl or Python, but Beautiful Soup.

2. NumPy / SciPy. Python was apparently written with numerical computing in mind, and NumPy in its current form arrived a bit after BS. Early 2000s: stats and data vis folk were using R. By the 2010s, I was hearing about all these people that were not using R, but were using NumPy and SciPy.

3. AI. Until a few years ago, it was all SciPy, then with the current era, everyone is using Python -- for AI.

None of this is the language, per se. People were not 'using Python'; they were (say) using SciPy.

I think Python benefited hugely from having not a single "I can achieve stuff" value proposition, like VB did; it had three consecutively in a row.

These all had roots well before they became well-known. Enthusiasts, initial design, years of work and usage, and 'suddenly' out of nowhere everyone is using it. The common factor there is likely Python's design and community; there would be lower level reasons for Python's success than the things it let users achieve, and those would be, what incentivised or led to Python being used for those libraries (value enablers) in the first place. I can't speak to that; I wasn't there in the Python community in the 90s or 2000s.

[*] Not always: Rust's value is in its memory system and safety. That is not a library but inbuilt, yet that still is something you can do, a goal, value, something you achieve using the language and thus you turn to the language in order to achieve. Rust minus that would need some other reason to be used.

Because it's really enjoyable to use. If you are doing something where you can use Python, ie. you can afford the performance hit, it's hard to find reasons to not like it. Common Lisp has it all, but for some reason people can't cope with the parens. People just genuinely enjoy using Python.

Personally, I do not think there is a language in the ALGOL family tree with better syntax than Python. It removes just about all the BS: ceremony, boilerplate, curly braces, etc. Oftentimes as programmers we write out ideas as pseudocode... and that pseudocode is oftentimes coincidentally valid Python! I think this is a critical reason why Python has been so successful. It's simple and powerful at the same time.

pytorch, langchain, streamlit, fastapi, and on and on ...

There are many clear reasons imo.

Science

In a phrase: Worse Is Better

Hopefully RAM prices continue to increase so that we are forced to rediscover the lost art of software efficiency and optimisation.

To me it was Django that made python a choice of language to develop on. On top of it , not dealing with pointers of c++ made it much simpler to use.

> In hindsight I think Python needed to stand on its own right, not just as a better Perl, but yet here we are.

It has. That just wasn't where the foothold was. Python has had several moments propelling it to its current position. "The early days" absolutely did not set an inexorable machine in motion. It took further boosts from fields like data science, machine learning etc. that would likely never have touched Perl even if the Perl 6 story had turned out much better.

> I think hindsight will show we should have considered the defects of Python more deeply.

There are many. I personally find that many of the commonly proposed ones are not that important, while everyone else is ignoring much more serious things. But so it goes. You can say these sorts of things about all the popular languages. "Although practicality beats purity."

> I know the lispers saw them but no one listens to them.

Lisp has had enormous hidden influence on how people write code in other languages, honestly. SICP is a revolutionary work. It just turns out that homoiconicity is not hugely useful the large percentage of the time that you don't need metaprogramming, and that the structure of the code is harder for humans to grok when it isn't explicitly marked with a variety of punctuation (rather than just parentheses).

> If you survey the language landscape now, a language can be much better than Python but never get the chance Python did just because it happened to look a bit better than Perl. Which is absurd to me.

This falls in the category of life not being fair. If you have your own ideas about how to make a Python-killer, I'd encourage you to pursue them anyway.

It was designed by a person with good taste, not by a committee. That's about it, there's nothing inexplicable or accidental about a well designed language rising to the top.

The excessive mentions of Perl are weird — it, along with PHP are prime examples of awful taste. Those are the languages that only gained any traction because they happened to be available at the time, not because they were any good.

Python was easy to read and write. Network effects did the rest.

Perl6 was a much greater mess than Python3.

I'm more surprised that Ruby didn't do better.

Supporting pre-compiled native binary packages. Look at the manylinux effort for eg: https://github.com/pypa/manylinux, which spans a decade to ensure that glibc changes did not break python wheels. Every other language required a full-build pipeline for binary extensions: node-gyp for eg. Even where it was supported (such as PECL), compatibility with the language and system was always left as an afterthought and underspecified. The end-result was that the only way to "safely" install binary extensions for most languages was via distros or third-party repositories, but never via the package registry.

One contributor that I don't see mentioned elsewhere: For many many python users, their only touchpoint for the language is reading and writing it.

Python gets a lot of grief from the perspective of people who are frustrated because they didn't start off using virtual environments and now their global python package namespace is a nightmare. Legit criticisms, but for many non-developer python users those problems are somebody else's problems. Given the readership on this site... they're most likely our problems, but we aren't the users that python is made for. We're support for those users.

It's winning because its audience is not code specialists, but other kinds of specialists which sometimes need to use code. Their work often has a sort of immediate importance that ours often doesn't. It's not evaluated based on whether the techies like it, it's evaluated based on whether the scientists, the analysist, the students, and the {non-computery-engineering} Engineers like it.

Python won by perfecting two things: (1) syntax structure to be simple yet powerful, and (2) complete object/function standard library with module system.

Because easy always wins, when enough people use something.

It’s why Windows beat DOS ( and NT beat Warp ) and why Apple then beat Microsoft.

Easy always wins.

I think part of why Python won is that it is community driven. Many high level languages that compete with Python are created by some big tech business or the other. But people are less trusting of programming languages created by a big tech business. There have been cases where such languages have had license changes or other problems.

Slightly amusing story: the year is 1990-something and I'm in grad school working a lab where we do electromagnetic simulation. That code has to run fast, obviously, but some of us in the lab were looking for some glue language to wrap around the very utilitarian C that the simulation code was written in.

One of us started playing with Perl. He ended up dropping out and going to work as a SysAdmin.

One of us started playing with Tcl/Tk. He ended up changing majors and going into UI/UX testing.

I started playing with Python, which at that point was, I think, at 0.9.2 or something. Eventually, after some twists and turns, I went on to work on ML stuff.

Is there a lesson in that? Probably not, but somehow I find it amusing all the same.

Three things:

1. The Rise: 2005 - 2010 Google hired Guido van Rossum in 2005 (stayed on for seven years) and gave corporate blessing that made everyone comfortable with moving from Perl to Python. It was seen as the language of scientists and smart people so a lot of people working in misc. languages like Fortran, MATLAB, Perl moved here. To remove the speed issue the official Google mantra was "Python where we can, C++ where we must". AI heavy weights like Peter Norvig (I think he was the chief AI scientist at one point and co-author of the famous AIMA book), promoted Python to be an acceptable Lisp.

2. Near Death: 2010-2015 Python almost died due to self inflicted wound from the 2 -> 3 transition and there was a good chance it would have gone nowhere like many languages before. Guido also moved away from Google and Google seemed to have shifted it's attention to Golang (apart from the standard C++ and Java). BTW, Python's dominance was not seen positively within Google hence they stopped actively promoting it. For ex. a leaked transcript from Eric Schimdt had him saying this

   So another definition would be language to Python, a programming language I never wanted to see survive and everything in AI is being done in Python.

https://gist.github.com/sleaze/bf74291b4072abadb0b4109da3da2...

3. Resurrection: 2015-Now Data science and ML took off and Python was right there thanks to the initial sponsorship from Google and ecosystem of scientists and engineers who were familiar (including working in the two-language mode). There was no language that could rival at this point.

Most of the syntax, power considerations etc.. are side shows as most scripting languages just tap into very powerful libraries written in c/c++/fortran or wrappers around shell. Doubt that distinguishes Python to the point where it has become so dominant.

My totally amateur take:

Python is C/C++ but without syntax decorations and pointer problems and who cares about speed when CPU cycle is so cheap.

Python is shell but you can build large projects with a shebang change

Python is Java but with less verbosity and no company behind

If one only affords to learn/master a single language (which holds for the majority), this should be Python.

The only drawback, there is no Python interpreter in browsers (like JS and PHP). But then Python might have faced anticompetitive measures :-)

I think it is because it got rid of braces and semicolons and other syntactical ephemera, and had rational indent. :)