Recently I researched python language and so many people complain about the speed of the language. I was wondering can this language be made faster?
It doesn't make sense to ask talk about the speed of a programming language. A programming language is a set of abstract mathematical rules and restrictions. It is a specification. A piece of paper, essentially.
A piece of paper doesn't have a speed in the sense we are talking about here.
In order to execute some program written in the programming language, the language needs to be implemented. Furthermore, you need to write a program which you can execute. And you need to execute this program in some specific environment (CPU, RAM, OS, machine architecture, …)
Then, and only then can you measure how long it takes to run.
But now you are measuring many variables:

the program
the environment
the implementation
the specific version of the implementation
the language

Since you have so many variables and only one datapoint, it is impossible to tell which variable contributed which amount to the result.
Many Python benchmarks I see use CPython running on Linux on an Intel AMD64 CPU. This benchmark is a little unfair, however:

CPython is actually a very simple implementation. It does not use any of the optimizations that are typically used in high-performance language engines, such as adaptive optimizations, speculative inlining, polymorphic inline caching, dynamic type feedback, de-virtualization, escape detection, to name just a few.
Linux, like almost all modern operating systems, is not specially optimized for running Python-like languages. It is more optimized for C-like languages. For example, Linux has virtual memory, which is known to have a negative performance impact on garbage collection.
Intel AMD64 CPUs are not specially optimized for running Python-like languages. They are more optimized for C-like languages. For example, they contain optimizations which don't really help Python, when that die space and those transistors could be better spent on Python-specific optimizations.

Check out, for example, the design of the Azul Vega-3 CPU and the corresponding Operating System, both of which were specially designed for running memory-safe, pointer-safe, type-safe languages with garbage collection, dynamic dispatch, and a high degree of runtime polymorphism.
If you want a fair comparison between, for example Python and C, you need to run your Python code on a Python implementation that has the same amount of research, engineering, development, man-power, money, and resources poured into it as a C implementation (such as Microsoft Visual C, Clang/LLVM, GCC, etc.) on an Operating System that is equally optimized for running Python, on a CPU that has the same amount of research, engineering, development, man-power, money, and resources poured into it for making Python run fast and is produced using the same advanced processes that e.g. Intel Xeons are produced with.
If you spend enough research, engineering, development, man-power, money, and resources on making Python fast, then it will be fast.
There are lots of historical examples: there was a Lisp and Smalltalk hype in the 70s-90s, and people spent tons of money on Lisp and Smalltalk compilers and VMs, and lo and behold, those implementations became much faster. When the Self VM came out, it was competitive with many C++ implementations of the time. Then, Sun cut funding for the Self project, and during that time there was also a C++ hype, so money was spent on C++ compilers, and those became fast.
After that, there was a Java hype, where people spent money on JVMs. (Funnily enough, the developers of Self, after Sun cut funding, founded their own company and built a Smalltalk VM, and after realizing that Java and Smalltalk were very similar, they built a JVM. This JVM was so fast that Sun bought the company to get access to the JVM technology that they would have had for free, if they hadn't pushed the developers out of the company in the first place.) Oracle HotSpot is still based on the codebase of the Animorphic Smalltalk VM written by the former Self developers.
Now, we are currently in an ECMAScript hype, and as soon as companies started pouring money into ECMAScript engines, those became literally ten times faster in the span of just a few years. (One of the drivers of this was Google with its V8 engine, which was actually designed by some former Self developers who had left Oracle to form their own company.)
There are some quite fast Python execution engines out there. I personally am looking forward to GraalPython. And I suspect if people started throwing money at Python implementations, they would also find that there is still a lot of potential for improvement. For example, TruffleRuby (built by the same people) has shown that it can beat C in some cases, and the team working on it is actually tiny compared to e.g. Microsoft Visual C or Clang/LLVM.
Can Python language be the fastest language in future?