Python is so oversimplified that hides/create problems

Disclaimer: This post is based on my experiences from scholar projects using Python 3.7 and VScode for IDE. Remember that this is a personal opinion.

Python, The programming language where the “You forgot the ;” meme doesn’t apply, where the tabulation and a colon replace the brackets. Those are some of the things that python offers. After all, Python is a high-level interpreted language. It's very easy to learn and use, it can help you to do/automatize tasks with very few code lines and do it in so little time, but also, it can cause you so many headaches.

First argument - Declarations of variables

Let’s start with a simple one. You need to assign something every time you declare a variable, everything is fine with primitive data types, but when it comes to creating a class, you can’t have multiple copy constructors, so if you need multiple ways to create a class and declare their attributes, you would insert NULL or invalid data, and it becomes a hell when you have too many parameters. Also, in my IDE, that is Vscode, and due to python is interpreted, when a class variable isn’t explicitly defined in the same file.

Example:

myChildClass = parentClass.getChildClass()
myChildClass.executeSomething()

This will not show you the functions or parameters that the class has, and you will be programming blindly, and you will have to pray that your syntax is correct, and you will wait until you run the script.

Second argument - Dynamic memory

Recently, I had an algorithm where you needed to have an auxiliary copy of a list, something easy to do in other languages cause it creates another new class, but python, along with his peculiar way to declare things, makes things like:

aux=var
print(var)
print(aux)

For python, this is just the same thing, because it just creates the same another variable with the same position, and the way to solve it is when you know how the constructor is:

aux=Class(var.part1(),var.part2())

This is just a minimal thing, but when it becomes to create an auxiliary list from another is IMPOSSIBLE (at least in these ways).

#First Way
list1 = list2

#Second way
for i in list2:
  list1.append(i)

#Third way
list3=list2
list2=[]
list1=list3

In these three ways, list1 and list2 are just going to be the same for the entire program, if you modify one, it modifies the other one.

Third argument - Everything is an object

With this one, i'm just going to go straight into an example

Example:

class(i.getX,i.getY)

You probably noticed that maybe I would refer to calling a function, and not just a ‘parameter’ because there’s no ‘( )’. Well, python checks that, except for no, it doesn’t, it takes it as an object, and it saves a position instead of warning me I could forget the ‘( )’ thing that took me hours to notice and fix, just because python wanted to help where I didn’t need help.

Extra: Not having a compiler to help me notice syntax errors, unless I use a terminal that doesn’t close when the script crashes is also a pain.

My thoughts

I like python, you can do so many things with very few lines of code, but when it becomes to doing complicated things, it can be hell. It makes you rest from other languages' problems but it creates its own, so it would depend on what you are gonna do and your expertise to use python to do the job.

Cover Photo by programarya.com on ProgramarYa