What kind of things can be done with Java but not Python?

I would to pick up a new programming 开发者_运维百科language - Java, having been using Python for some time. But it seems most things that can be done with Java can be done with Python. So I would like to know

1. What kind of things can be done with Java but not Python?
   • mobile programming (Android).
   • POSIX Threads Programming.
2. Conversely, What kind of things can be done with Python but not Java if any?

clarification: I hope to get an answer from a practical point of view but not a theoretical point of view and it should be about the current status, not future. So theoretically all programming languages can perform any task, practically each is limited in some way.

---

Both languages are Turing complete, both have vast libraries, and both support extensions written in C so that you can access low level code if needed. The main difference is where they are currently supported. Java in general has wider support than Python.

Your example of Android is one place where Java is the standard choice, although Python also has some support in the form of Android Scripting Environment. Java is already installed on most home computers. You can write Java applets and expect them to work in most browsers.

One thing you can't easily do in Java is quickly write short scripts that perform useful tasks. Python is more suitable for scripting than Java (although there are of course other alternatives too).

---

I guess using Jython, you can do anything with Python that you can do in Java.

Conversely, Python has the PyPy compiler, which is pretty cool - a virtual machine with multiple backeds (Java Runtime, LLVM, .net, and Python IIRC), multiple garbage collectors, multiple implementations (Stackless), etc. I know Java has a big choice of virtual machines, but the growth of PyPy is amazing, due to it being written in RPython - a fairly productive language.

Also, can a Java do this, in 1 file and less that 20 lines, with no library imports? Obviously both languages have libraries that can do this, but I'm just talking about the flexibility of the languages.

class Logger(object): # boilerplate code
    def log(self,level,msg,*args,**kwargs): # *args, **kwargs = flexible arguments
        self._log(level,msg,*args,**kwargs) # call with flexible argments

    def _log(self,level,msg,*args,**kwargs):
        # override me at runtime :) 
        # I think Java people call this Dependency Runtime Injection
        if level>1:
            print msg,args,kwargs

logger = Logger() # boilerplate code

def logged(level): # what pattern do you call this?
    def logged_decorator(function): # and this? 
        def func(*args,**kwars): 
            name = func.__name__ # look ma, reflective metaprogramming!
            logger.log(level,name,*args,**kwargs)
            return func(*args,**kwargs)
        return func # boilerplate code
    return logged_decorator # boilerplate code

Example use:

@logged
def my_func(arg1,arg2):
   # your code here
   pass

---

You would surely love reading the comparisons made below between these 2 languages.
Check them :

• Java is Dead ! Long live Python
• Python-Java : A side-by-side comparison
• Python is NOT java

---

What Python Can do Java Can't -

Nothing.

What Java Can do but Python Can't -

• Java is a multithreading boss. So if you are trying to write a web server, where multiple requests come at the same time, java can just spawn multiple threads and CPU swaps them. That's why almost all big companies (Expedia, LinkedIn, Goldman, Amazon, Netflix, CITY, JPMC, VISA almost all) uses the JVM Web server for their main application.

CPython has something called GIL, which prevents itself from using OS-level thread efficiently. How Python Application servers (Gunicorn, Django ..) work then? Well, they fork new Processes instead of threads. Threads are lightweight, so forking new processes instead of threads still work till a threshold, but not a very scalable solution.

• Sheer Execution speed - When you take var a = 1. and then do a = 10.07, you just stored float value in a variable that previously-stored an integer. When variables are assigned a new value then internally, Python creates a new object to store the value. This pointer is then assigned to the variable, this is called dynamic binding. Dynamic Binding(Python) is slower than Static Binding(Java) - as it requires object creation. And Java or C/C++ primitive types are an order of magnitude faster because of static binding.

• Space used (RAM usage) - The default space python uses to store a variable is huge.

>>> import math, sys
>>> a=0
>>> sys.getsizeof(a)
24

But in Java, you can take a Byte size variable, which will take just a byte. So nobody writes an application in Python if asked to write memory-efficient software(Think about you are asked to create a DataBase like Cassandra, maybe design a compute engine like Spark).

• Packaging - In Java, you can create something like a Jar. Which can run on any machine where JVM is installed. and that JAR contains all the dependencies. In python you can't just ship something like a JAR, you will have to write a script to install dependencies in every machine you want to run your code on.

Think about if Android was a Python application, before installing an App from the play store, you had to install the dependencies of that app separately.

• Performance . Performance . Performance -

Java’s efficiency largely comes from its Just-In-Time (JIT) compiler and support for concurrency. The JIT compiler is a part of the Java Runtime Environment. It improves performance of Java programs by compiling bytecodes into native machine code “just in time” to run. Java Virtual Machine (JVM) calls the compiled code directly. Since the code is not interpreted, compiling does not require processor time and memory usage. Theoretically, this can make a Java program as fast as a native application.

While Java programs are compiled directly, Python is interpreted which slows down Python programs during runtime. Determining the variable type which occurs during runtime increases the workload of the interpreter. Also, remembering the object type of objects retrieved from container objects contributes to memory usage.

We can go on and on ...

People use python because python is easy to learn, easy to use. A lot of libraries for ML / DataScience etc . that saves you coding. But if you are asked to write a performant, scalable, durable, long term application, People who understand comp sci, will always choose Java or C/C++

---

CPython has a lot of libraries with bindings to native libraries--not so Java.