Hacker News Reader

Comment by TekMol | Hacker News Reader

Python has one giant plus over pretty much every other popular language:

    The syntax

I was reluctant to to meaningful whitespace for a long time. But after doing some projects in Python I have to admit the code looks so much better than C style languages with all the {, } and ;s

And it has one giant plus over PHP:

    The module system

PHP went down the wrong road (of insanity) by deciding that the way to avoid naming conflicts is to use longer classnames. Because that is what namespaces in PHP are. Comfort tools to make your class names longer.

There is still one giant benefit of PHP over Python:

    Performance

Currently, PHP is about 6x faster than Python.

Let's hope that the Python devs will focus on performance so we get the best of all worlds at one point!

View on HN

You can avoid curly braces and semicolons and also not have indentation determine the control flow. Julia, Fortran, Visual Basic, and other languages do this.

None of these 3 is in the top 10.

Personally, I would only consider languages very close in popularity to the leading one when deciding on the language for a new project.

Visual Basic and Classic Visual Basic are in spots 6 and 11. I am not against Python's use of indentation, but I don't think it's better than having keywords such as endif or next terminate blocks.

Wow, you are right.

Still, I don't think I would choose Visual Basic to build the next big thing though :)

Yes, and they use keywords, wich is basically another flavor of curly braces.

The only negative is that type annotations aren't part of the core language. You have to run a separate tool (mypy) to check your types. Feels like it should be a flag on CPython or something.

Hmm, PHP developers were already making long class names prior to namespaces existing, for example the "PSR-0" underscore-delimited naming convention.

The namespace feature is more of a comfort tool to make those long names shorter.

I don't know, I think the syntax is ok but it definitely has significant downsides, like making lambda functions stupidly hard.

Python's competition isn't PHP; it's Typescript.

Typescript is position #46 on the Tiobe index.

But anyone using typescript would just be Googling JavaScript syntax. Rarely is there anything Typescript-specific you need to look up while writing TS code.

Why do people care about so much lambda? If you want a function, use a real one. Python makes it easy to create throwaways everywhere. The only thing it enforces is proper indentation. What advantage should a lambda give you?

Naming things, especially functions that you tend to use in lambdas, is often hard. Imagine if you had to name a for loop to us it. That's how it feels.

Then don't do it. Use a generic name, like f or l2. Reusing names is possible anyway, so you can name all the onetime-functions the same.

I'm not saying it's impossible, I'm saying it's annoying and I prefer languages where it's not.

It lets you do functional style programming easily. This sort of thing:

  [1, 2, 3, 4].map(x => x * x).filter(x => x < 10)

Python's lambdas and list comprehensions are quite restrictive in comparison to functional style.

Huh? This seems like it works fine in python?

    filter(lambda x: x < 10, map(lambda x: x * x, [1, 2, 3, 4]))

But even for more complicated logic, it also doesn't seem like it's that burdensome to just throw a name on the lambda:

    def square(x):
        return x * x
    
    def less_than_ten(x):
        return x < 10
    
    filter(less_than_ten, map(square, [1, 2, 3, 4]))

Which I find to be more readable/maintainable.

That's probably the most underrated feature of python. Decisions about how the language should function like this which seem "restrictive" from one perspective, and yet force you down the avenue of good decision-making for readability/maintainability. Sure, it's possible to write terrible python, but you're generally cutting against the grain to do it.

Yes you can do simple examples like the one I gave, but when it gets more complex you have to do what you did and name the functions, which is pretty horrible when they're just one-offs. It also makes the code read in a weird order.

That looks like a Ruby one-liner which is very OO (calling methods with blocks on everything, everything also being an object is very Smalltalk-esque).

Python's problem isn't a lack of lambdas, it's a lack of consistency; for some things you use functions and for others methods.

I know what lambda is, I just don't see any usecase where the limitation is a problem. If your lambda is so complex that you need more than a oneliner, then what's big thing with using a nested function?

List comprehensions are actually set notation in disguise, so they’re quite powerful and compact. Haskell has them too.

You can express the above as:

[x * x for x in [1, 2, 3, 4] if x < 10]

Which in set notation is {x^2 : x in (1, 2, .., 4), x < 10}.

The list defined above is [1, 4, 9], but the one you just defined is [1, 4, 9, 16]. It's interesting how the shift in notation subtly confused the semantics of what's going on.

Good point. I missed that and made a mistake. It should have been:

[x * x for x in [1, 2, 3, 4] if x * x < 10]

There is a subtle shift in semantics. The functional form defines a sequence of function applications whereas the list comp notation is more of a declaration.

I think this would be the Python equivalent:

    x = [1, 2, 3, 4]
    x = map(lambda x: x*x, x)
    x = filter(lambda x: x < 10, x)
    x = list(x)

Or is there a more elegant way?

You can write this as a oneliner too. But the problem here is not lambda, but the lack of map/filter-methods on list. Disputable whether this is good or bad.

This, maybe

```py x = [xx for x in [1, 2, 3, 4] if xx < 10] ```

I thought what you wrote wasn't valid because xx isn't defined in the scope of the inequality... however I now realize that's because Hacker News deletes the asterisks. In any case, it's

[x [asterisk] x for x in [1,2,3,4] if x[asterisk] x < 10]

which is still a little annoying because the x [asterisk] x gets computed twice. This is one of those little details that really annoys mathematicians, as I saw with SageMath for decades (I started SageMath -- which uses Python -- and got no end of complaints about the above). In the Magma programming language there is a "where" version of comprehensions that eloquently solves this problem as explained here: http://magma.maths.usyd.edu.au/magma/handbook/text/10

For example,

{ xx : x in [1 .. 4] | xx lt 10 where xx is x*x}

which you can try at http://magma.maths.usyd.edu.au/calc/

> however I now realize that’s because Hacker News deletes the asterisks

You can escape asterisks with a backslash. \* => *

from functools import partial

from itertools import repeat

from operator import pow,gt

x = list(filter(partial(gt,10), map(pow, [1, 2, 3, 4], repeat(2))))

(please don't do this)

Capturing values, which isn't really obvious with functions.

what's so hard about

    >>> (lambda x: x+1 if \
    ... True \
    ... else x+x)\
    ... (10)
    11

Now try including if statements, loops, structural pattern matches, context managers, etc.

If it's too complicated for a lambda, you shouldn't be using a lambda. Define a separate function if it takes you more than a line or it's harder to reason about.

The point is it's only complicated in Python. In other languages, like Rust, it's idiomatic.

People all know lambdas are expressions only, it's not a biggie really. In all honesty you rarely inline complex lambdas with all you mentioned, it would become hard to read or debug.

> Currently, PHP is about 6x faster than Python.

In a 100KLOC codebase, 99% of the performance issues are going to come down to 5 or 10 lines of code.

Don't get me wrong, I'm extremely happy that MS is funding a multi-year project to improve Python performance, and I think it will confer enormous benefits to the ecosystem. And frankly I think that it's absolutely needed.

But for me it would also be weird to choose languages based on some notion of average performance. Like sure, a line of Go might be faster than a line of Python on average, but if the entire bottleneck of your codebase revolves around one line of regex then what is doing a rewrite actually going to accomplish?

I don't think that holds true.

80/20 rule? Probably. Then 80% of CPU time is spent in 20K lines of code.

But 1%? I don't think so.

A web project of 100KLOC will be a shit ton of features and CPU time will be spent in hundreds of different places.

Another issue is what I would call "code depth". Even if you find a few lines deep down in a framework or library that makes your specific use case slow - what can you do? Patch the framework? That comes with a ton of issues on its own.

Reply on news.ycombinator.com