Python is a widely used general-purpose, high-level programming language.
Pro Lots of tutorials
Python's popularity and beginner friendliness has led to a wealth of tutorials and example code on the internet. This means that when beginners have questions, they're very likely to be able to find an answer on their own just by searching. This is an advantage over some languages that are not as popular or covered as in-depth by its users.
Pro Easy to get started
On top of the wealth of tutorials and documentation, and the fact that it ships with a sizeable standard library, Python also ships with both an IDE (Integrated Development Environment: A graphical environment for editing running and debugging your code); as well as a text-based live interpreter. Both help users to get started trying out code immediately, and give users immediate feedback that aids learning.
Pro Clear syntax
Python's syntax is very clear and readable, making it excellent for beginners. The lack of extra characters like semicolons and curly braces reduces distractions, letting beginners focus on the meaning of the code. Significant whitespace also means that all code is properly and consistently indented.
The language also uses natural english words such as 'and' and 'or', meaning that beginners need to learn fewer obscure symbols. On top of this, Python's dynamic type system means that code isn't cluttered with type information, which would further distract beginners from what the code is doing.
Pro Comes with extensive libraries
Python ships with a large standard library, including modules for everything from writing graphical applications, running servers, and doing unit testing. This means that beginners won't need to spend time searching for tools and libraries just to get started on their projects.
Pro Good documentation
The Python community has put a lot of work into creating excellent documentation filled with plain english describing functionality. Contrast this with other languages, such as Java, where documentation often contains a dry enumeration of the API.
As a random example, consider GUI toolkit documentation - the tkinter documentation reads almost like a blog article, answering questions such as 'How do I...', whereas Java's Swing documentation contains dry descriptions that effectively reiterate the implementation code. On top of this, most functions contain 'Doc Strings', which mean that documentation is often immediately available, without even the need to search the internet.
Pro Advanced community projects
There are outstanding projects being actively developed in Python. Projects such as the following to name a random four:
- Django: a high-level Python Web framework that encourages rapid development and clean, pragmatic design.
- iPython: a rich architecture for interactive computing with shells, a notebook and which is embeddable as well as wrapping and able to wrap libraries written in other languages.
- Mercurial: a free, distributed source control management tool. It efficiently handles projects of any size and offers an easy and intuitive interface.
- PyPy: a fast, compliant alternative implementation of the Python language (2.7.3 and 3.2.3) with several advantages and distinct features including a Just-in-Time compiler for speed, reduced memory use, sandboxing, micro-threads for massive concurrency, ...
When you move on from being a learner you can still stay with Python for those advanced tasks.
Pro Supports various programming paradigms
Python supports three 'styles' of programming:
- Procedural programming.
- Object orientated programming.
- Functional programming.
All three styles can be seamlessly interchanged and can be learnt in harmony in Python rather than being forced into one point of view, which is helpful for easing confusion over the debate amongst programmers over which programming paradigm is best, as developers will get the chance to try all of them.
Pro Good introduction to data structures
Python's built-in support and syntax for common collections such as lists, dictionaries, and sets, as well as supporting features like list comprehensions, foreach loops, map, filter, and others, makes their use much easier to get into for beginners. Python's support for Object Orient Programming, but with dynamic typing, also makes the topic of Data Structures much more accessible, as it takes the focus off of more tedious aspects, such as type casting and explicitly defined interfaces.
Python's convention of only hiding methods through prefacing them with underscores further takes the focus off of details such as Access Modifiers common in languages such as Java and C++, allowing beginners to focus on the core concepts, without much worry for language specific implementation details.
Pro Easy to find jobs
Python's popularity also means that it's commonly in use in production at many companies - it's even one of the primary languages in use at Google. Furthermore, as a concise scripting language, it's very commonly used for smaller tasks, as an alternative to shell scripts.
Python was also designed to make it easy to interface with other languages such as C, and so it is often used as 'glue code' between components written in other languages.
Pro Import Turtle
Do something visually interesting in minutes by using the turtle standard library package.
Turtle graphics is a popular way for introducing programming to kids. It was part of the original Logo programming language developed by Wally Feurzig and Seymour Papert in 1966.
Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an import turtle, give it the command turtle.forward(15), and it moves (on-screen!) 15 pixels in the direction it is facing, drawing a line as it moves. Give it the command turtle.right(25), and it rotates in-place 25 degrees clockwise.
Turtle can draw intricate shapes using programs that repeat simple moves.
from turtle import * color('red', 'yellow') begin_fill() while True: forward(200) left(170) if abs(pos()) < 1: break end_fill() done()
Pro Static typing via mypy
Python's syntax supports optional type annotations for use with a third-party static type checker, which can catch a certain class of bugs at compile time. This also makes it easier for beginners to gradually transition to statically typed languages instead of wrestling with the compiler from the start.
Pro Interpreters for JS, Microtontrollers, .Net , Java & others
Python is not limited to just be cross platform. It goes far beyond all high level languages since it can run on top of several other frameworks & architectures :
Examples of interpreters:
- Standard (PC Win/Lin/Mac, ARM, Raspberry, Smartphones): CPython usually, but some more specialized for smartphones: Kyvi, QPython, ...
- Web Browser JS : Brython, PyJS,
- .Net : IronPython
- Java: Jython
- Microcontrollers with WiFi like ESP8266 or ESP32: MicroPython
- Can be statically compiled (instead of interpreted) with Cython. (Do not mix up with cPython)
With python, you're sure your code can run (almost) everywhere, from 2€ computers to the most expensives.
So, for instance, with Jython you can access the Java libraries with Python language.
Con Language fragmentation
A large subset of the Python community still uses / relies upon Python 2, which is considered a legacy implementation by the Python authors. Some libraries still have varying degrees of support depending on which version of Python you use. There are syntactical differences between the versions.
Con The process of shipping/distributing software is reatively complicated
Once you have you program the process of having a way to send it to others to use is fragile and fragmented. Python is still looking for the right solution for this with still differences in opinion. These differences are a huge counter to Python's mantra of "There should be one-- and preferably only one --obvious way to do it."
Con Inelegant and messy language design
The first impression given by well-chosen Python sample code is quite attractive. However, very soon a lack of unifying philosophy / theory behind the language starts to show more and more. This includes issues with OOP such as lack of consistency in the use of object methods vs. functions (e.g., is it x.sort() or sorted(x), or both for lists?), made worse by too many functions in global name space. Method names via mangling and the init(self) look and feel like features just bolted on an existing simpler language.
Con Does not teach you about data types
Since Python is a dynamically typed language, you don't have to learn about data types if you start using Python as your first language. Data types being one of the most important concepts in programming. This also will cause trouble in the long run when you will have to (inevitably) learn and work with a statically typed language because you will be forced to learn the type system from scratch.
Con Multi-threading can introduce unwanted complexity
Although the principals of multi-threading in Python are good, the simplicity can be deceptive and multi-threaded applications are not always easy to create when multiple additional factors are accounted for. Multi-thread processes have to be explicitly created manually.
Con Limited support for functional programming
While Python imports some very useful and elegant bits and pieces from FP (such as list comprehensions, higher-order functions such as map and filter), the language's support for FP falls short of the expectations raised by included features. For example, no tail call optimisation or proper lambdas. Referential transparency can be destroyed in unexpected ways even when it seems to be guaranteed. Function composition is not built into the core language. Etc.
Flagged Pros + Cons
Con Deployement is it Achile's Heel
Once you have you program the process of having a way to send it to others to use is fragile and fragmented. Python is still looking for the right solution for this with still differences in opinion. These differences are a huge counter to Python's mantra of "There is one correct way to do something."