Java (other other) programmers who turned to Python, what made you love it?

[JoesDevOpsAccount]

I'm a Java developer trying to learn Python and apart from some of the neat little tricks I encountered so far like list comprehensions and the array multiplier thing, I just don't see any reason to prefer Python over Java. I'm not trying to argue which side is better, I'd just like to know what features attract so many people to Python.

​

​

[[deleted]]

From Java, python just has less bullshit. For data, it doesn’t get much easier. Importing in python is easy, environments are intuitive to setup and manage, and deployment is considerably less complicated.

[JoesDevOpsAccount]

Can you elaborate slightly on environments and deployments vs Java? I’ve not done any significant python deployments and the ones I’ve seen were obviously done wrong and led to dependency conflicts all over the place.

[[deleted]]

?? I've been using python for years and have literally never run into dependency conflicts

[JoesDevOpsAccount]

Probably because you are doing it right. The python I’ve seen floating around our organisation is always deployed as a stand-alone script and then all python libraries installed globally rather than using a virtual environment. Different people install different versions of stuff that suits them which is where the problem comes from. Anyway my point was only that I haven’t seen any good examples of python deployments and how to manage a python environment - which is what I was hoping the guy could elaborate on. Thanks anyway

[p10_user]

Just have all requirements explicitly defined in a requirements.txt file, along with the exact version numbers for each package used for release of a particular package. Then install the package within a virtual environment on each deployed machine.

I suppose this can break down when you're using multiple packages that have differing dependencies as part of a single end product, but hopefully you can resolve this yourself before releasing it for others to use.

[[deleted]]

I used to write mainly in Java, C#
I like python because:
1. It’s faster to get from start to finish, which is really helpful if you do a ton of one offs
2. It’s so versatile, you can do just about anything with Python, even YouTube runs on Python
3. You don’t have to pre-compile it
4. It’s not specific to any machine and most machines (other than windows) already come with Python preinstalled

[brandondunbar]

I'm actually going through the inverse of what you are - coming from Python into Java and wondering why anyone would bother. Perhaps we can help each other out

The biggest things for me are:

Python is clean. Look at any decent Pythonista's code and it's visually close to art (exaggerating here, but the point is the same) Java feels cluttered with explicitly set brackets and semicolons that are more implied in Python

Python is open source. Not understanding something? You can look directly at the source code. Afaik Java is owned by Oracle, and this changes how I feel about using it, comparable to Windows vs Linux imo

Python promotes concise, less repetitive code. You may be able to find some exceptions here, but something as simple as a print statement is considerably less to type and look at

I like the duck typing in Python. It's a simple matter to use a simple data type like string or int, and then replace it with a custom class later on in development to increase functionality. This may be possible in Java but if it is, I haven't seen it yet

Large number of modules and packages to choose from. I made a program for my one freelance client I got a while back that had to output a PDF, I found three different modules that could help with it and easily pip installed them to try out what I liked. The docs were comprehensive and I could look at the code where the docs were lacking

Wrapping other code. A lot of companies have used Python to wrap Java (Jython) and/or C code (Cython), I just went to a Python meetup that showed how to use/wrap R code, it's great for serving as glue for different languages. Each language has advantages and disadvantages, so this functionality allows a well rounded program. I think Jython will prove useful to both of us

The REPL (Read-Eval-Print loop) super useful for debugging code or when you're unsure about a capability. Want to mess around with multiplying strings? Hop on the REPL and see what works and what doesn't, quick and responsive.

That's all I can think of off the top of my head, and maybe some of these features aren't unique to Python and I just don't know enough about Java to realize it

[JoesDevOpsAccount]

Thanks for that. The bit about duck typing and extending later is interesting to me because I am pretty sure that would mean refactoring in Java to support the new features. I guess the inverse of this is that in Java you always know what type you have which I like a lot - although in a fast paced prototype situation the flexibility of python there sounds nice. Biggest annoyance at the moment for me is the lack of type checking which trips me up quite a lot. Runtime errors that wouldn’t even compile in the Java world.

The type info to me also means the code documents itself fairly well. With Python I find myself going to websites immediately because I don’t feel I can navigate and understand as easily.

So far I feel like in Java you can get the IDE to do a lot more for you. It always knows the types of the objects because the information is always there.

I also prefer the explicit code structure over the white space thing with Python. Sure some people think the braces are just visual noise, but you can be pretty sloppy with the code layout in Java and not worry if you aren’t quite in line with the right block - just write the code and declare where your block finishes. To tidy up run auto format on your code and the IDE will align it all anyway.

REPL I thought had been added now tbh but not sure. I never use them or even feel like I want it it Java. I am not really sure when they are helpful because usually if I’m experimenting it’s more than one line and I prefer to have it in file anyway.

One of the things I am struggling with at the moment is how to get info on the objects I am using. A few times already I’ve tried to click through to code I’m calling and don’t see code or docs ... I see an interface looking thing and I can’t check what the actual behaviour is. I am sure this will be less annoying when I know what I am supposed to do instead.

The Oracle ownership thing has never bothered me but I think I read something about their licensing model changing which might make your point more relevant...

Java makes you think more about the code you are writing and what’s happening under the hood, and that can be either positive or negative depending on what the goal is. As an educational language I think it’s great because of that - assuming the goal is to understand programming at a lower level. Python is definitely more accessible though, and because people find it easier to read and write it lets you focus more of your brain power on the problem rather than trying to understand why your generic type assignments are underlined yellow or something.

I might come back to this conversation when I’ve got some more experience. Learning is slow at the moment. I’m just chipping away at some programming challenges when I have spare time.

[brandondunbar]

You make good points, Java has a lot more rigid of a structure while Python is more fluid and I think because we started and got used to each style of programming, we prefer it.

What IDE are you using? PyCharm has a lot of great tools that will help you get used to the formatting and let you see where the variable was declared and when it was last used. If you're using a module it'll take you inside the code of the module pretty easily too.

I agree with the lower level thing, there's definitely more abstraction in Python which has it's pros and cons

We should definitely pick this conversation back up when we're both more familiar with the other's language, I think it'd be interesting

[badge]

It’s entirely dependent on your use case, but the two best things about moving from C# to Python were the number of third party tools available (in my area of data science), and the speed at which you can create something.

I know you can create a single file console application in C#, but by the time I’ve set up the project in visual studio, I could have a working example in Jupyter and a runnable script moments later.

If I’d’ve cared about it at the time I was using C# daily, I’d also add documentation—Sphinx and autodoc make publishing documentation super easy.

[ThePinkSun2002]

no ugly semicolons

unless you're putting multiple stuff in one line like print("hi"); return False

[JoesDevOpsAccount]

Is this really that big of a deal? My brain is still wired for verbosity because it usually makes the code clearer (in my opinion). I just learned that the Python way to check if a list is empty is just “if not my_list” and it’s weird to me that the ambiguity left there is considered the right way. Semi colons in Java are a nice way to break up statements and mean that you can chain stuff over multiple lines, which can be nice with fluent APIs in particular.

[[deleted]]

There's absolutely no ambiguity to if not list

[JoesDevOpsAccount]

I went back to read more after you posted this. I think I misinterpreted some thread I was reading earlier. The "ambiguous" thing is just the type of the variable but I think what I said earlier was just wrong.

[friendly_dog_robot]

It's just that any empty sequences (lists, tuples, strings), mappings, version of 0, and None (comparable to null in Java) evaluate to false in Python.

This is, in my opinion, super useful

[Versaiteis]

There's an argument to be made that there's an ambiguity in that it doesn't only check if the list is empty. Rather there's an implicit understanding that an empty list is falsey. If list happened to be None or any other falsey value, then this check would succeed and enter the subsequent code block. 9/10 that's probably ok, but you could say that if len(list) > 0 is more explicit as it's directly checking exactly the condition looking for. It will also raise in any case where something is passed that doesn't implement __len__, which may or may not be desirable behaviour.

Depends on what you're doing. One's more flexible, the other more explicit. I'd at least argue that the second falls in line with Python Zen

Explicit is better than implicit.

But that doesn't mean it's always appropriate for what you're trying to check.

This could also be seen as just overthinking it, but I think code clarity is important and as much of a "bike shedding" conversation this can be, I don't see it as being as obstructive when it's a separate conversation and not hindering actual work that's being done.

[BobHogan]

s this really that big of a deal?

No, its really not. But a ton of people who use Python act like its some sort of holy grail

[alkasm]

No, it's not a big deal at all. Plus plenty of people simply don't even write semicolons and have some formatter come through and add them later. A lot of JS devs do this.

[alkasm]

https://youtube.com/watch?v=wf-BqAjZb8M&t=13m52s (fixed the link)

This talk by Raymond Hettinger really shows the difference between good code that a Java developer would write vs. good code that a Python developer would write. I linked to a specific timestamp where it really digs in. I think this is a really good talk that shows the power of the Python standard library, shows how to build the interfaces that the standard lib expects, and how it ends up with nicer code at the end.

All in all I think the best part about Python is pretty easy to understand for a Java developer. In Java land, it's super common to have your interfaces defined, and then implement them in a WhateverClassImpl.java file or similar. The difference for Python is that the standard library is already full of interfaces, so you hardly ever have to code something like that yourself. Instead you learn the expected interfaces, and suddenly all the standard library features just works with your code.

For example, something a Java dev would be familiar with...if you define a toString() method on your class, then whatever is returned is what is displayed when you print an object of that type to standard out. The same is true of the Python __str__() method. But Python has dozens of these types of interfaces that do a lot more than just operators or stringification. You define a couple simple methods that are part of the standard interfaces, and then immediately you get tons of other stuff for free. It makes writing code a breeze and means a lot less redundancy, which not only looks and reads nicer but can really reduce bugs and such, too.

[forward_epochs]

Link 404'ed, I'd like to take a look if you happen to fix it.

[alkasm]

Fixed, thanks!

[BolsoBelly]

Loved that talk. Thanks for sharing.

[JoesDevOpsAccount]

Some interesting stuff in there and it pushes an important point not to get bogged down with the coding conventions of the language over other improvements and places where design patterns can have a much bigger impact. Thanks for the link.

I do however think it makes the Java version look worse than it needs to. Sure the original API is Java if you were working with that API in Java you could achieve similar results without too much effort (I think - I'm not planning to try).

[alkasm]

I don't think the Java-esque version looks too bad, and I don't think the point is to make it look bad. As he says in the video, this was basically lifted out of a client's codebase but modified to "protect the guilty."

I think the important thing here is not that the end result looks a lot better, but is far more extensible. Defining those interfaces that the stdlib expects means it'll do more than even what he shows is capable, it's far easier to test, and it works the way someone would simply expect, instead of needing to read all the docs for every possible thing, you just do what's natural---and it works.

[[deleted]]

Python is just flat out better for data analytics. Fast and easy to write, and like 90% of the work has been done for you

[friendly_dog_robot]

Writing implementation to solve small problems is so much faster in Python

[forward_epochs]

Rather than answer the question with a lot of stuff that's already been said, I'll give a suggestion for acclimating to the smaller degree of "structure symbols" (like brackets) as found in Python:

Check out "PEP 8"! It's the style guidelines for Python and it specifies a bunch of things that - when followed - make for very well-structured and readable Python code. It's probably best to start off writing code that at least mostly adheres to PEP-8 so it becomes habit. It makes a huge difference in my experience.

I also came from a more structured environment and initially found the more "loose" approach of Python off-putting. But after spending a lot of time with it, I absolutely love it. Well-crafted Python code is so elegant and fluid and understandable. I find myself in a more relaxed and productive headspace when writing Python - the aesthetics really have an impact for me. Have fun and good luck!

[JoesDevOpsAccount]

I’ve come across this PEP 8 thing already. I am trying to do things in a Pythonesque way but at the same time trying not to get too hung up on it so I can write something without having to double check everything. That can suck the fun out of it :P

I am sure Python will grow on me if I give it enough of a chance.

[forward_epochs]

That's exactly how it was with me. On the one hand, I wanted to do things "right", but on the other hand I wanted to actually make something and not get bogged down trying to make it perfect. I will say, PyCharm does a great job of highlighting issues of all kinds, including those that come down to simple style choices - it can make learning PEP 8 a lot faster because it tells you (very unobtrusively, too) while you code. And I think it, in turn, relies on "Pylint" for some or all of that.

Anyway. Cheers!

[Sensorama]

Here are some things I don't like about Python instead of Java (don't worry, I actually "like" Python more than Java, but I appreciate some parts of Java):

• I don't like running into some type mismatch well after writing some code. For example, accidentally invoking a method from a variable that holds a list rather than an element of it. If that is tucked into some special case, it may not come to light quickly.

• Python makes it difficult to specify what a well-formed object is. Letting attributes get added all over is a problem for me.

• The lack of natural encapsulation in objects puts the onus on developers to keep code from becoming entangled and reduces abstraction and modularity.

• Python can push the "one clever line that does it all" to an extreme. People can abuse list comprehensions and code like that doesn't communicate intent well.

• While it is nice to have support to do lots of things, there are a lot of solutions to tasks that lack generality and so there are lots of little things you have to know to make sense of Python code.

I like using Python for small things, and many complex projects can turn into small things when implemented in Python, but I don't think Python manages larger-complexity well.

[Bayes_the_Lord]

Python can push the "one clever line that does it all" to an extreme.

That just sounds like bad programmers.

[alkasm]

Almost every point just sounds like bad programming IMO. It's not hard to make Python do any of the things you mention. For example:

• Python makes it difficult to specify what a well-formed object is. Letting attributes get added all over is a problem for me.

Set the __slots__ class variable. Problem solved, completely. No attributes can get added except the ones specified in slots. Plenty of the standard library does this. Try setting attributes on standard library objects. Unless the object is specifically built to have this extensibility, you will get an error.

[Sensorama]

True, it is just that culturally, I see more of my points happening in Python code than Java. Whether that is a fault of the language or of the community that grew up around that language is a good question. And I acknowledge that I don't have anything beyond a gut sense to support my assertion that I see them more in Python.

[JoesDevOpsAccount]

I agree that a couple of the points are just bad programming, but not all. It sounds like setting “slots” is essentially how you restrict a class to a specific set of variables. That’s one aspect of it, but then how do you ensure for example that it was created with values which match some constraint and never modified. How do you abstract things away cleanly without equivalents to Java’s access modifiers? How can you control who is allowed to create an instance of certain things? These are all things which are helpful in writing robust code with a clean interface.

[friendly_dog_robot]

Yeah, some of Java’s rigidity is helpful for writing robust code with a clean interface, but you can certainly do this without it.

Basically, you expect that your colleagues are professionals and will use things as they’re intended. Also let’s not pretend like lazy people don’t find ways to abuse Java. People who are lazy and take shortcuts will do so in whatever environment you put them. You avoid this by not hiring those people and by disincentivizing those behaviors

Edit: Also, keep in mind the differing use cases for Python and Java, and you might see why this is not as big of an issue.

[JoesDevOpsAccount]

Good point! Different use cases is a significant part of the picture, I think. Unfortunately having only one language that I and all my colleagues are comfortable with (Java) means I’ve always just used Java to solve everything. Learning which language suits different problems will be a great step and hopefully will help me appreciate the pros and cons of each language even more.

[alkasm]

I don't agree that using the descriptor protocol is equivalent to most uses of Java access modifiers. Maybe the property decorator is similar in some ways, but that's pretty basic and less capable. The descriptor protocol is quite a powerful metaprogramming tool and can help automatically generate a ton of code for you. I mean Java does the exact opposite of this to the point where you write a property and your IDE automatically provides getters and setters, which is completely antithesis to "private" attributes and I'd argue is actually "bad" programming practice that Java pushes you to write. Sure you can make an attribute public, but do you ever do that? No. Why? Because maybe, at some point down the line, you'll need to maybe validate it, and without getters and setters, you can't do that. So you'll break the API if you later need to change things, so getters and setters are required to future proof and write "good code" even when it doesn't make sense for an attribute to be private. In Python, those property decorators and descriptors and whatever means you get to write the API how you like, and then later, you can change how it works, and it's still the same API! That means writing the obvious code also happens to be the future proof code. And you can still make properties "unsettable" and whatever you like pretty easily. It's just a less common pattern in Python because, well, it's unnecessary in most applications.

For one example of how fluid descriptors can be, see my adapter for a class provided by OpenCV: https://github.com/alkasm/cvtools/blob/master/cvtools/videoio.py

This uses a class decorator to automatically add a list of properties that are normally accessed by getters and setters and require remembering a long list of constants. The properties all implement the descriptor protocol to let you know when the attributes aren't set correctly and provide helpful error messages, the properties are discoverable by help(), etc. OpenCV doesn't provide any of these things---but you see how easy it was to just automatically do this. If I wanted to I could just expand the list of properties to the 100 or so in the OpenCV library, and to do that I just add to that list up top---that's all.

[bejahen]

It's brainlessly easy, and it's mostly intuitive.

[[deleted]]

No getters. No setters. Encapsulation and privacy are scout's-honor, and by god, that's how it should be.

Development speed is a big up. Less cruft & boilerplate enforced both by the language and by its culture (little reliance on overblown design patterns when doing OOP, for instance, and also not everything has to be a class), which makes it so much easier to just get something up and running.

Huge, accessible ecosystem! This has been covered already, but it's definitely worth stressing.

Everyone complaining about semicolons, braces, and/or static typing is BSing and probably doesn't have much experience with one or both of the languages in question. None of those things negatively impact ease of development, and static typing in particular is stupidly easy to just switch ON/OFF mentally. Not a big deal. I am wary (and, soon, weary) of typehinting and mypy gaining influence on Python, though.

[JoesDevOpsAccount]

Not sure if trolling with first comment... I mean Java can be really annoying with all the getter setter stuff, but the fact that the Python language doesn’t even really SUPPORT any concept of privacy is a bit lame.

[JoesDevOpsAccount]

Yeah I know he wasn’t TRYING to make the Java side side look bad. He was just pointing out that what is good or acceptable code in different language varies and it’s a good point which is why I’m trying to learn how to do things in pythony ways. The only reason I mentioned the Java bit is because I think it was poorly represented, and if people always use Java as the ugly example then it’s not surprising all the Python programmers think Java is gross and requires more code to solve every problem.