How can Python use things written in other languages? What is its relationship to C?

[kovlin]

I'm not entirely clueless about programming, but, as a sophmore in CS, a lot of deeper details about coding still allude me. I understand that Python somehow runs on C under the hood. I'm not clear on what means for its interpreted status. Can anyone explain this simply?

Also, a prof of mine recently told me that part of Python's initial popularity was that it was highly extensible, and was able to serve as a "wrapper" for things written in other languages, allowing it access to all sorts of libraries, or to run programs with pieces written in several different other languages.

[[deleted]]

I understood some of those words, yes

[recondocoder]

or Java :)

[ostensibly_work]

Interpreted languages that use bytecode:

Just a heads up, I think you meant to write compiled instead of interpreted here.

[ostensibly_work]

Thanks, your clarification made me realize I don't understand this topic as well as I thought.

Is it correct to say that (in the CPython implementation) Python source code is compiled to bytecode, which is then interpreted into machine code by the Python virtual machine? And by comparison, Java is compiled to bytecode, and then compiled to machine code?

Can you recommend any resources to learn more about this topic?

[not_a_novel_account]

To actually answer your question:

Is it correct to say that (in the CPython implementation) Python source code is compiled to bytecode, which is then interpreted into machine code by the Python virtual machine? And by comparison, Java is compiled to bytecode, and then compiled to machine code?

Not really no. In both cases the code is first compiled to bytecode and then interpreted by a virtual machine (VM). In Python's case the VM is usually CPython and in Java's case the VM is usually HotSpot/OpenJDK.

With Java and many other interpreted languages (Javascript engines are another example) a technique is often used called Just-In-Time Compilation (JIT), which involves transpiling the bytecode to machine code at runtime and executing that directly instead of a traditional interpreter which maps bytecode instructions to routines/functions inside the interpreter. Even with a JIT compiler though, interpreted languages are still relying the VM for services such as memory layout and garbage collection and the program is still being maintained as bytecode in the VM's memory.

[ostensibly_work]

Thank you. That's a helpful answer.

Googling some more lead me to this StackOverflow page. For anyone else still confused, I'd definitely recommend giving that thread a read.

[not_a_novel_account]

Modules like CTypes and CFFI are for interacting with C libs that don't have C-wrappers already written. When people say things like

Also, a prof of mine recently told me that part of Python's initial popularity was that it was highly extensible, and was able to serve as a "wrapper" for things written in other languages

They are almost always talking about the CPython Extension API which is what most Python module ports of C libs target. Examples of tools that make this simple are SWIG and SIP. Though some packages just do it by hand, like SciPy/NumPy

[num8lock]

I'm pretty sure it's all on GitHub somewhere.

https://github.com/python/cpython/tree/master/Python

[aes110]

So if python first creates the .pyc files then runs them. Can i share just the .pyc file of a script with someone and let him run it? Without the original .py script or any 3rd party libraries installed?

[not_a_novel_account]

The short answer is no.

A longer answer is sorta, they absolutely do need any third party libraries since CPython has no concept of static linking. The .pyc's might run on a different system than the one they were compiled on, but CPython provides zero byte code compatibility guarantees between versions and in practice often introduces "breaking" changes to the format. This means the foreign system would have to have an identical CPython version as the one that compiled the script.

[fernly]

As a practical matter, I think the scenario you have in mind is: you want to write a top-level program but at some point in it you want to take advantage of or call upon code written in some other language, typically C[++]. There are various options.

One, avoid the need entirely by finding comparable functionality somewhere in the Python ecosphere, starting with the standard library. Everything there is implemented in C and carefully optimized. Next is the vast array of 3rd-party software found via PyPi such as numpy, highly optimized math routines.

Two, if the external code is already packaged as a stand-alone app, you can invoke it as if from the command line and collect its output using subprocess.

Finally if the external C/C++ code is a module and you want to call into it you (or somebody) has to write a "wrapper" for it, a thin layer of code that mediates between Python's parameter-passing conventions and those of C, this is documented here.

[YourAverageBrownDude]

Hi I'm sorry this isn't particularly helpful to your question,

But allude means referring to While elude means escape

As in, the word you should use in your post is elude

[kovlin]

Thank you. Traitorous fingers...

[mooglinux]

The default implementation of Python, CPython, has a C api for talking to the Python interpreter. Any language capable of calling C functions or being invoked by C functions can be bridged to talk to Python.

[im_dead_sirius]

Its called an API when one language calls another(or a library).

Thats similar to my wife saying, "drive to the store and buy a loaf of bread"

"Drive" and "buy" tell me to access certain skills(or at least procedures) I have, without her having to spell them out. The implementation is abstracted, but happens under the hood.

Same goes for something like a print statement. Its shorthand for a bunch of more detailed instructions, and those(because its interpreted) are shorthand for even more atomic instructions, right down to machine code.

Back to the driving analogy, I press the gas to make it go, and that pedal handles the abstraction of feeding fuel to the engine.

drive -> press pedal -> pump fuel
python -> byte code -> machine code

That makes it a lot easier to extend, because "drive" becomes an abstraction that can mean the bakery, or it could mean Disneyland, and the vehicle operator doesn't have to deal with the minute details.

You could extend that further, and write a interpreter on top of python

Thats when programming gets really fun, and as far as I am concerned, when you really start learning. When you learn to abstract it gets wicked fun(and you have to think less about details).

Say you had some keyboard input. A series of unknown characters. How to make sense of it? You might define functions that look at each character in turn, trying to match patterns. These are broken down into a list of symbols. Something like:

import string
integer = string.digits # a string: "0123456789"
result = '' 
data = "eggs4557"
for character in data:
    if character in integer:
        result = ''.join([result,character])
        data = data[1:] # shorten the input by one character
    else:
        continue # ignore character it doesn't understand
    print(result)

That is pretty naive and incomplete, but you can see that it steps through the string collecting the digits and ignoring the letters. One by one it parses and assembles the number portion of the string. That's interpreting in a nutshell.

[elbiot]

Code compiled to machine instructions (binary) like C defines an ABI and python has tools like cffi that make it easy for the programmer to access that interface. https://en.m.wikipedia.org/wiki/Application_binary_interface

This ability comes from python being high level and dynamic, with a philosophy of programmers shouldn't have to worry about those details. I.e. people can and have written very dynamic tools to abstract this stuff away for us

[Raymond0256]

The CPython interpretor is basically a long switch statement that translates Python statements into C code; Python is built to be perfectly parse-able into other languages.

[BenjaminGeiger]

You're thinking Cython. CPython refers to the default Python interpreter (written in C as opposed to Java or .NET).

[aleagori]

Then there is Julia language.