Reasons Python Sucks

I might be misunderstanding you, but I don't think you can do this in C++. References can't be changed to point to a different object after initialization. If you have code like:

  void MyFunc(Foo& ref_param) {
    Foo new_foo;
    ref_param = new_foo;
  }

  Foo original_object;
  Foo& object_ref = original_object;
  MyFunc(object_ref);
  // object_ref still points to the same address
  assert(&original_object == &object_ref);

I like 'self'. There's a lot to complain about magical 'this' of every other language - especially in Javascript. Specifying self makes it really clear if it's a member method or a standalone function.

Python really likes the idea of 'seek forgiveness, not permission', aka. abusing try/except. But it's kind of nice:

  # seek permission
  if 'key' in map:
      fn(map['key'])
  else:
      whatever()

  # seek forgiveness
  try:
      fn(map['key'])
  except KeyError:
      whatever()

$ python2.7 -m virtualenv .venv or $ python3.6 -m venv .venv

$ source .venv/bin/activate

// dev + test here

$ deactiveate

> This worked great until I started on a second project that needed Python 3.6. Two concurrent projects with two different versions of Python -- no, that wasn't confusing.

Note that Java also comes in various version of the compiler and jvm, and its common to have several versions on the same system. They are backward compatible but forward compatibility issues exist: your main server app runs on java7 but your batch process is running java9. you might not want to make java9 the default on the system without formally upgrading the server app.

* Syntax/spaces : you get used to it. Hey some people write code in perl :)

* Includes: In principle, this works somewhat similar in Java: You use imports and the imported package hierarchy can nest quite deep so you need to look.

> The import function also allows users to rename the imported code. They basically define a custom namespace..

This can be a good thing, it helps you prevent name clashes. C++ also lets you do this, its called Namespace aliases.

namespace fbz = foo::bar::baz; std::cout * Nomenclature:

> In every other language, arrays are called 'arrays'. In Python, they are called 'lists'.

Thats because it is a list. Nodes are dynamically allocated and appended to the list. You can expect similar algorithmic complexity for the operations.

Python also has arrays if you want the better efficiency: https://docs.python.org/3/library/array.html

* Pass By Object Reference: same as java