What makes Python more secure than other programming languages?

This is wrong on so many levels... A language is "more secure" if the issues are detected early, i.e. at compile time. You can also reuse the same variable for different types in compiled languages too, for example in Rust where a new definition can hide the previous one (aka shadowing).

In Python, types are determined at runtime, which can lead to unexpected type errors. Statically typed languages such as Java, C++, and C# define variable types before the program runs, making the code more reliable by catching type-related errors early. To improve reliability, Python provides type hinting, where developers can suggest expected data types for variables. This makes the code clearer and helps identify type problems, combining the flexibility of Python with the reliability of static typing.

While it is indeed the goal to capture errors early, compiled languages, and their static nature, is only one piece of the puzzle when it comes to security (and in fact has their own challenges). All languages can be made insecure if you don't follow basic data handling good practices. Looking at the type system does not provide a good indicator alone that a language is secure or not.

I miss that type of typing that other languages have; however, it's something you adapt to, and over time, you develop habits that enforce code Organization using dynamic typing. The advantage of this is that when you switch to something like TypeScript, for example, you bring with you habits that aren't native to the language but contribute to readability and a better understanding of what's happening.

I'm disagree about dinamyc typing makes safer to Python, I consider that the dinamyc typing makes less safer because the control about the data type is given to the languaje instead to be kept by the programer, who have tho define explicity the data type to make the programming execution flows without 'wrong type'-related errors. Potencial vulnerabilities could be hidden if the programmer don't control the data type in a program, specitally in programs made by juniors programmers.

All languages share those features. It's not limited to Python or dynamic languages. And worse, in Python they are not "built-in" as said in the article.

From my perspective, Python's dynamic typing system is a key player in its security lineup. It's like having a guard that's not only vigilant at the gate (runtime) but also capable of adapting to unexpected situations—catching those sneaky type mismatches, invalid operations, or the ever-elusive undefined variables that can trip up other languages. This adaptability and on-the-fly verification add a layer of safety, while also giving me the freedom to code more intuitively, without the strict typecasting handcuffs. It's a subtle yet powerful feature that, I find, often tips the scales in Python's favor.

Absolutely, Python's security modules like hashlib, hmac, secrets, cryptography, ssl, and bcrypt improve security, but it's important not to have a false sense of security. While these modules provide essential tools for hashing, encrypting, and more, using them correctly and understanding their limitations is key. Python makes it easy to incorporate these security measures, but overall security also depends on how well these tools are implemented and integrated into the broader system.

Safe because you are sure of the source's origin, so yes, it is safer, and the fact that you don't need to install dependencies or create a virtual environment for common situations makes it secure. However, it can spoil the developer when transitioning to other languages.

Python emphasizes explicitness, encouraging clear and straightforward code that is easy to follow. Also its syntax is straightforward and resembles natural language, making it easy for developers to understand and write code.

Once again, it's very very wrong. The "one way to do it" is merely a convention (that the IA should have easily spotted across all the open-source projects). It DOES NOT reduces vulnerabilities or bad code, and nothing is actually enforced by the interpreter. Mixed spaces and tabs are still a warning IIRC, and can easily be overlooked by a developer.

I agree with this and Python is the closest you can come with the daily English language compared to other programming languages.

Regarding the first point, I'm not entirely sure if the statement is correct because you can compare types in various ways, like in any language. See, this standardization is not the responsibility of the language but of the programmer. I don't view something so rigidly structured favorably. As for readability, it's magnificent, and you carry it over to other languages. In the beginning, it's complicated, but later, everything becomes more straightforward and readable.

Python's readability and ease of understanding contribute to the security of applications, but it's important to note that this does not directly make Python more secure than other languages. Its clear syntax and coding practices make code easier to read, understand, and maintain. This can help in building a more secure application by allowing developers to more easily identify and fix potential vulnerabilities. However, the overall security of an application depends on many factors, and while Python's readability helps, it's only one aspect of building secure software.

Python's -S flag and sys.flags.ignore_environment attribute are not specifically intended for enabling a sandbox mode. Python does have modules like `sandbox` or `RestrictedPython` for creating a restricted execution environment, but they are not part of the standard library. It's essential to verify with the latest Python documentation or community resources for any updates or changes in security features

English: Python's 'sandbox' mode is like giving kids a playpen: they can go wild without knocking over the house plants. It limits access to system goodies, making it perfect for poking at that sketchy code from the web's back alleys, like bomb disposal training with zero actual explosions: all thrills, no spills. Espa?ol: Python en modo 'sandbox' es como un ni?o jugando en su espacio seguro: puede construir castillos de arena sin derribar el sistema de la casa. Con acceso limitado a recursos, este modo es ideal para probar ese código dudoso que encontraste en el rincón oscuro de Internet, como desactivar bombas en un simulador: mucha emoción, cero riesgos.

As a backend developer and a noob cybersecurity enthusiast, I have found Python libraries to be one of the most breakable, specifically Flask. Sure, they get patched, but the vulnerabilities are already there in production code by that time.

Python's third-party libraries, such as Flask, SQLAlchemy, and PyJWT, enhance its security, but can also introduce potential vulnerabilities. Libraries supported by a large community tend to be more secure and receive regular updates to address security issues. Choosing these well-maintained and popular libraries is critical to the security of your application. It's important to be cautious and stay informed about any vulnerabilities in these packages to maintain a secure Python environment.

This is a very big reason according to me why Python scores very high. The third-party support is really very good and integrating the third-party libraries is also much simpler.

English: Python's like a mall armed with specialty security stores; its third-party libraries. With a developer community bigger than a boy band, there's everything from Flask wrapping your web apps like bubble wrap to PyJWT guarding your tokens like a digital bouncer for your byte-sized secrets. Espa?ol: Python es como un centro comercial con tiendas especializadas en seguridad; sus bibliotecas de terceros. Con una comunidad de desarrolladores que parece tener más miembros que un hombre orquesta, encontrarás desde Flask que encapsula tus apps web hasta PyJWT que mantiene tus tokens seguros, como un guardaespaldas para tus secretos digitales.

As mentioned before by others, third-party libraries are probably the biggest weakness, as well as strength, to a languages security. Third-party libraries can not be fully vetted, worked on by developers who are less experienced and out dated. However, if they are highly focused, well used by the community, heavily worked on by top-notch developers they can also be very secure. When it comes to any third-party libraries do the following: 1. How active is the third-party project? 2. How quickly does it discover and correct bugs? 3. How many times does it introduce new bugs? 4. Is it well used? How many downloads does it have and how many projects use it?

Python has a strong focus on security features, such as extensive libraries for secure coding practices and built-in support for cryptographic functions. Its dynamic typing and memory management also help prevent certain types of vulnerabilities. However, the overall security of a program depends on various factors, including coding practices, libraries used, and how the application is deployed and maintained.

While several of these points in the article are valid, they should all be taken together for determining how secure Python might be. Dynamic languages can get a bad rap, but it is the developers using them that often introduce insecurities. Write clear and easy to reason code, follow conventions, use third-party libraries that are well tested and practice defensive programming and you can be safe in any language.

English: Asked ChatGPT about automating video creation for YouTube. Python, with its all-star libraries, was the MVP. Script in hand, I say a topic and—bam!—a video with audio and visuals, ready to hit YouTube. Python’s not just code; it’s a content wizard! Espa?ol: Pregunté a ChatGPT sobre automatizar la creación de videos para YouTube. Python, con sus librerías geniales, fue clave. Digo un tema y—?pum!—sale video con audio y visuales, listo para YouTube. ?Python no es código; es un mago del contenido!