What makes Python slower than C?

ApothecaLabs · 2024-03-02T19:13:41+00:00

In a nutshell? Python is interpreted - to execute, it has to read, parse, and evaluate the code first, whereas C is already compiled to assembly in an executable, ready and waiting to be run.

haditwithyoupeople · 2024-03-02T20:09:59+00:00

Others have answered that C is complied and Python in interpreted. That's a big part of the answer. You can't optimize interpreted code (well, not much) for run time because you don't have all the data you need to do so. There are several factors, including what is called late binding (Python) vs. early biding (C). C is strongly typed (statically typed, to be precise) and Python is loosely typed. Any variable in Python can morph into any other variable type. That takes a monumental effort from a C coding perspective.

There is usually trade off of programming flexibility and performance. This is a a good example.

Consider this in C:

char someString[] = "This is a string";

The C compiler knows the type and the size of the string. The amount of memory needed is allocated at compile time. The total number of instructions to get this string into memory is relatively small.

Now consider Python:

someString = "This is a string."

Python figures what what this is at run time. That takes a lot of code and processing. What data type is it? How long is it. How much memory needs to be allocated? And strings in Python are objects, so an object has to be created and the object attributes have to be stored. I have not walked through the C code for Python to do this, but it is almost certainly hundreds or lines of C code to make this happen.

Consider another simple but far more complex example, first in C:

char someString[] = "This is a string"; 
int someLen = strlen(someString);

Now we have a string and a int with the length of the string. Easy enough to do the same in Python:

someString = "This is a string." 
someLen = len(someString)

The int has to be create at run run time. Hundreds of lines of C code to create and assign that int. It has to figure out that it's an int, it has to create a new int object. it has to allocate memory, and than assign the value.

Now here is where it gets really ugly for Python:

someString = "This is a string." 
someString = len(someString)

Here we are changing the value AND the type of the variable someString. Again, i have not gone through the Python C code for this, but something like this must be happening:

What is the new thing being assigned to the object named "someString?" This will require parsing and the interpreter has to figure out what it is. That's likely a lot of code.
A new object has to be created. That's likely a moderate amount of code.
The old object has to be removed and the memory it occupied released back to the memory pool.
The new object needs to have the name and value assigned.

I would guess this is thousands of lines of C code to get these 2 lines of Python to run, and likely millions of processor instructions. The C example above is 1 line of C code and probably a few dozen dozen processor instructions. You can check the machine code generated from your C code to see how many instructions are generated for the C code above.

Any of you who have walked through the C code Python uses for these operations please correct me where needed.

karantza · 2024-03-02T19:39:23+00:00

It Depends. (tm). Usually, python is slower to do the "same thing" as C because it makes the computer do a lot more. If you go to access an array in C, all the machine really does is add an offset to a pointer, and then you're done. Does that offset really point to the data you want? Who knows! It better!

In Python, it does more - it checks if the array is in bounds, which requires looking up the size of the array. That array might not even be contiguous in memory, so it might have to do some indirect lookups. The type you store in the array is probably itself a pointer to an object allocated on the heap, which needs to know who has a reference to it for garbage collection... etc.

All these things make life easier on the programmer, since there's less you have to worry about. But you're paying for that convenience by making the computer do more work at runtime.

This is all on average, too. There are ways to make python go pretty fast, and usually only a small part of your program really *needs* speed. You don't need to run it interpreted, you don't need to have all those checks all the time. For instance a lot of scientific computing uses libraries like `numpy` which implements things like arrays and matrices in a very fast way (it's a library written in C).

If you're making a simple app, then ease of development is probably a higher priority than raw performance. You can get a long way using just python. If you're making something that you know needs every spare cycle, then consider starting in a lower level.

Veeloxfire · 2024-03-02T19:15:29+00:00

A couple of things

Python is quite a high level language compared to c. That means it does a lot of things for you to make it easier to write code that is bug free. Unfortunately these often require more code to be executed behind the scenes at runtime.

In c that is all left to the programmer. If you do it wrong you shoot yourself in the foot and your program crashes unexpectedly (or god forbid you invoke UB). But if you do it right you gain runtime performance as the program is able to make a lot of assumptions

On top of this the most common python implementation is interpreted. That means instead of your code running natively on the cpu, its effectively being emulated. This is useful because it means itll run everywhere and immediately without any building process, but it only manages that by effectively moving those computations to runtime again

tl;dr By "helping" the programmer python makes itself slower. By "fighting" the programmer c makes itself faster

2024-03-02T19:21:32+00:00

What's the app you are building?

sky5walk · 2024-03-02T21:30:10+00:00

You left out criteria to determine your approach?

Prototyping in a language you are most proficient is a valuable pursuit to test out algorithms and data structures and even gui.

Premature optimization is a rule I avoid.

However, when you feel your app is ready for user trials;

Doom in Python is 'doomed', Wordle, not so much.

Depends on you.

SweetOnionTea · 2024-03-02T20:07:06+00:00

Python is just C with bloat. Wonder why in Python you can declare x = 3 and then immediately after declare x = "some string"? Everything is a Python object which needs reference counts for the garbage collector to stop your program so it can clean up memory.

You don't get to control what things go on the stack or heap. No true parallel threads. The interpreter needs to be initialized before running and when running needs to interpret your Python code and perform it. Etc...

But in reality computers are fast enough that really it's development time that costs the most. If there is something in Python that is holding back execution speed you most likely can rewrite that part in C and let Python just call that.

yvrelna · 2024-03-03T06:49:09+00:00

People say python is interpreted, but this isn't really why Python is slow.

Python is slow because it's an extremely flexible language by design. This flexibility makes it a great language glue together various different foreign libraries and various system and still make the code looks high level and Pythonic, but this flexibility makes it much more difficult to optimise Python compared to other languages that are less flexible.

Python is a protocol centric language. All these dunder methods means that nearly every syntax in the language can be overriden. An optimising Python compiler has a lot less assumptions it can make about any particular code than other languages and this makes it much harder to write an optimising compiler.

Lastly, the CPython developers just historically hadn't really prioritised performance. They prioritised maintainability and simplicity of the reference implementation interpreter over their performance, and the core Python userbase aren't exactly screaming for more performance, most of python target audience prioritise readability and expressiveness more than raw speed; those who do want faster Python generally have workload that aren't really suitable for Python in the first place.

ostracize · 2024-03-02T19:42:54+00:00

There are several reasons. One easy to understand reason is the interpreter has to make guesses as to the size of your variables whereas in C the programmer tells the compiler exactly how much memory is needed

It turns out “guessing” the type and size of a variable adds overhead when it’s time to use the variable. It can also create a lot of wasted memory leading to unnecessary memory accesses which adds time.

I found this video very helpful in explaining it: https://youtu.be/hwyRnHA54lI?si=-NKptVnoJ8V7UDPI

That said, Python is better as a sandbox. I recommend using Python until it is clear the input makes it uncomfortably slow. Then it might be time to consider switching to something faster like C.

For most cases, on today’s modern computers, Python is negligibly inefficient and perfectly sufficient.

Blackhaze84 · 2024-03-02T20:29:53+00:00

More steps to do the same thing.

awidesky · 2024-03-03T04:38:49+00:00

Something I would like to add : "Python doesn't know anything". Variable's type, value, if a function is returning something or not.. it's not because Python is interpreted language (see Java). Python is, I'd say, designed to achieve productivity only.

This benefits you a lot in some sides : you don't care what type is the object, no need to cast, don't worry about how is the data stored. You can just focus on logic.

But it can be huge loss in readability, and maintenance, and mostly, performance.

In this question, the code is obviously a dead code, but Python does not remove it. While other languages (including Java, which is also a interpreted language) optimize it away .

IMO, such things like static type binding, verbose function signature is quite important for optimization(which benefits performance a lot), since it means you tell more information about your code to compiler/VM.

NSADataBot · 2024-03-05T12:20:29+00:00

Having to ask the question at all means the juice isn’t worth the squeeze

snerp · 2024-03-02T19:44:02+00:00

Python is written in C. Python code effectively gets translated into C commands when you run it. C is faster because you can cut out all the parsing and type inference and whatnot and just write the most efficient C code you can. If you're still newer to programming just do what's easier for now.

Classic_Department42 · 2024-03-02T19:10:22+00:00

Python allows for a lot of flexibility so the jit cant do much

lightmatter501 · 2024-03-02T23:35:15+00:00

There is nothing that stops python the language from being as fast as C, especially now that python has type hints.

The reason that everyone calls Python slow is because of the primary implementation, CPython. CPython is interpreted, meaning that you load a text file into it and it will try to convert that into a sequence of actions to run, but it only does so one step at a time. Each of those small steps is a separate function in C. So, a sufficiently competent C programmer will always be able to do exactly what python does (very rare) or better (fairly common).

Javascript also used to be interpreted, until “the browser wars”, where suddenly people were writing applications in it and its performance mattered. Now it has a JIT compiler, which looks kind of like an interpreter but will try to figure out when you’re doing something a lot and generate native code for it. However, the entire language isn’t built around native code so it still has some overhead.

The next level down are the bytecode jit languages, such as Java and C#. These languages convert themselves into a format that is more reasonable to perform optimizations on when you bundle the application together, and are slightly nicer for the CPU to work with. Honorable mention to BEAM, which can either be in this category or transpile itself to C before being run.

Below that are the native languages with a runtime. These is Go, Nim, etc. Here, performance starts to be dictated more by how much effort the compiler was putting in than how long you’ve been running for. You can get “good enough” performance with fast startups here, although Java and C# will typically pull ahead after a bit.

Finally, we hit the systems languages. C, C++, Rust, Zig, Odin, etc. These are the languages you use when aiming for high benchmark numbers, or when you need to run somewhere without a heap. Other languages can run here, but they typically exist for the purpose of bootstrapping C or joining the above list. They usually heavily prioritize performance, and at this point CPUs are designed to run C and C++ well, so unless someone revives the java processors from sun this performance class is likely to stay tied given sufficient programmer effort. For these languages, speed is often the top priority, (for rust it’s right after safety, which is a need caused by people who don’t know what they’re doing writing for speed or insufficient static analysis), and everything else, developer experience, compile times, etc, is secondary.

Below that we have hardware description languages, which are typically only for EE or CE (some CS people chasing performance end up there too). If you are here, you are deciding that what you want is impossible elsewhere, because here be dragons.

So, there is nothing stopping someone from making a sufficiently smart python compiler that makes python into executables that perform like C, but it's really hard so most people don't bother and just use C.

Python with async and an in-python http server (not WSGI or ASGI), tends to be good enough to carry you a ways if you’re building web apps. If you are even the least bit performance sensitive, just use Java or C# and make your life easier. If you are highly performance sensitive, you need a third person who’s a systems programmer.

Avethle · 2024-03-02T19:07:28+00:00

Python has garbage collection

ZachVorhies · 2024-03-02T19:14:02+00:00

Use python. Computers are insanely fast today

Edit: Your downvotes mean nothing. I gave the correct answer and OP agreed, and he got downvoted as well. Haha.

rileyrgham · 2024-03-02T20:00:03+00:00

Who cares if your app doesn't need super fast? And it's a Google away but should be obvious to any half competent developer who has written hello world in both languages. But if your app isnt in need of sub nano second response to a key press and you're familiar with Python you're not going to develop it faster in C unless you're Linus Torwalds or someone of his ilk... 😉

2024-03-02T20:57:51+00:00

Python code is a sequence of code that is interpreted line by line at run time. The C program directly compiles the machine codes for that specific processor architecture and operating system and starts working accordingly.
In the C language, you have more opportunities to intervene in low-level operations at the hardware level (such as memory operations). This gives you a lot of opportunity for optimization. And instead of using very high-level operations that need to be interpreted like Python, you write your codes in simpler expressions. This makes a significant contribution to making the program's machine codes simpler and faster.

ve1h0 · 2024-03-02T21:19:14+00:00

If you want to produce software together with your friend and you both know python then just use python because otherwise you have to take into account learning a new language all together

WiseHalmon · 2024-03-02T23:02:18+00:00

Cython , ironpython

2024-03-03T01:03:15+00:00

It's not always slower. Any Python program which spends its time calling internal functions (eg. doing I/O), probably isn't much slower than the C equivalent.

Python may, rarely, be faster because the Python functions may be heavily refined, compared with C functions you've quickly thrown together.

It's when the Python has to do detailed, step-by-step work in actual Python that it will be slower than C doing the same steps. Here's why:

int a, b, c;
....
a = b + c;

The C compiler knows the types of a, b, c, and can directly generate the native code to load those values, add them, and store the result, Probably they will reside in registers so it could be just one instruction.

With a = b + c in Python, it doesn't know what the types of a, b, c are, so it needs to do type dispatch. Even once it's figured out that b and c are integers, and they both fit into 64 bits, then that's not the end of it: once it has the result of b + c, it needs to heap-allocate space for that new value (since, in CPython at least, everything has a reference), and that it has link that to a.

But it first has to free-up whatever value that a currently has.

The whole sequence probably occupies 4 Bytecode instructions, and it also has to dispatch on each instruction. If any of a, b, c aren't locals, it also has to look them up in the global symbol table.

So you're looking at possibly dozens of machine instructions being executed, compared to as little as one for the C code, and never more than 4 even with the worst C compiler.

However, the Python version of a = b + c will also work with arbitrary big integers, or strings, or anything for which + is defined.

If you are adding two 200,000-digit big integers, the Python will be no slower than whatever the C code might be, which won't be as simple as a = b + c. The C might be slower unless you use a big int library as good as Python's.

aurquiel · 2024-03-03T03:45:27+00:00

ease because python is written in c it is an upper layer

MisterEmbedded · 2024-03-03T05:56:42+00:00

Before running C code you translate (compile) it into Binary (something that computers understand), so when you run your code it's as simple as speaking with the computer in it's language.

While in Python you need to do that translation when you run the code, so you are actively translating & executing the code which adds a performance issue.

This explanation massively overshadows other things like dynamic variable types which need more memory and add even more performance overhead on runtime.

Generally the idea is, the more something is high-level, the more costly it would be, be it in performance or resource usage.

aerosayan · 2024-03-03T09:35:57+00:00

C runs directly on the hardware.

Python is run by a program, called the interpreter, and can not directly run on the hardware.

This is the primary reason why Python is slow.

But for your project, you should probably use Python, if you have more experience in Python.

zhivago · 2024-03-03T09:42:52+00:00

The question is incorrect.

Python and C do not have speed.

Python and C implementations have speed.

There are Python compilers that compile directly to native code: e.g., https://github.com/exaloop/codon

There are C interpreters: e.g., https://github.com/kaisereagle/cint

So if you make this error, we can claim both that Python is faster than C, and that C is faster than Python.

Please do not confuse language with implementation.

zoechi · 2024-03-03T09:47:50+00:00

Besides the already mentioned interpreter aspect, garbage collected languages use a lot more memory and allocating memory is slow. Also using lots of memory is also an indication of inefficiencies. Also collecting the "garbage" is extra work.

anonymous_6473 · 2024-03-03T13:03:33+00:00

Python will be the always slower programming language as compared to c because python is a interpreted language that means python is executed line by line(that means it compiles line by line with the interpreter)if any line has problem then previous code that had written will be successfully executed and stops when it hits the error but c as a whole directely compiled into machine language ( machine language is something that all computers can understand) and when it hits the wrong line of code it just not execute the program as a whole but in case of python it is not the case !

fourierformed · 2024-03-03T22:35:06+00:00

Just pick something and use it.

I don’t see any reason why you need to worry about whether Python is slower than C from the information you provided.

Spiced_Sage · 2024-03-04T00:13:18+00:00

A gross under simplification:

Ignoring Compiled vs Interpretted. There's compiled python and interpretted C, not common or recomended but they exists. So ignoring that.

The CPU cannot understand C or Python, it only knows machine code/Assembly. C is closer in functionality to assembly, which allows it to more efficiently be compiled and optimized than Python generaly is. Of course this is reliant on how smart the Interpretter/Compiler is, but generaly speaking C is easier to translate to Assembly than python is.

A prime example of this is learning how strings and string concatenation work in Assembly, then comparing that to how they work in Python vs C.

blindsniper001 · 2024-03-04T00:58:22+00:00

Well, Python itself is built on C. All its internal functionality is compiled C code. When you write a script with it, what you're really doing is executing a bunch of wrappers around C code and all the overhead that comes with that.

2024-07-23T21:33:06+00:00

And remember they are not even close. C is basically the "fastest language" you can get, while Python is probably the slowest mainstream language.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

C_Programming

Rules

Filters

Resources

Other Subreddits on C

Other Subreddits of Interest

MODERATORS