Hello,
It is likely not the first time such a proposal is being made but let's
see.
I would like to explicitly set variable names in list comprehensions using
a where keyword, eventually set after the if keyword:
[price for item in basket if price is not None where price := item.get(
'price')]
For this example one could use the walrus operator which is indeed smaller:
[price for item in basket if price := item.get('price') is not None]
But I fell that this approach is a bit opportunistic as one is doing two
things at a time, if you allow me more lines for a somewhat more complex
example:
[
price * (1 + vat)
for
item in basket
if
price is not None
where
price := item.get('price')
vat := get_vat(item, user)
]
Now this example may look pretty stupid and probably one may simply use for
loop, but I feel that this kind of Haskell-like where inside of list
comprehension will let the programmer have a space where they can
explicitly state the variables.
Best regards,
Fabrizio
This comes up pretty often. Every example can be replaced by a loop over a
single item list. It's a bit idiomatic, but not difficult. Many, as you
note, can use the new walrus operator instead.
[price for price in [item.get('price')] for item in basket if price is not
None]
On Mon, Jul 15, 2019 at 10:21 AM Fabrizio Messina <zauddelig(a)gmail.com>
wrote:
> Hello,
>
> It is likely not the first time such a proposal is being made but let's
> see.
> I would like to explicitly set variable names in list comprehensions using
> a where keyword, eventually set after the if keyword:
>
> [price for item in basket if price is not None where price := item.get(
> 'price')]
>
> For this example one could use the walrus operator which is indeed
> smaller:
> [price for item in basket if price := item.get('price') is not None]
>
> But I fell that this approach is a bit opportunistic as one is doing two
> things at a time, if you allow me more lines for a somewhat more complex
> example:
>
> [
> price * (1 + vat)
> for
> item in basket
> if
> price is not None
> where
> price := item.get('price')
> vat := get_vat(item, user)
> ]
>
> Now this example may look pretty stupid and probably one may simply use
> for loop, but I feel that this kind of Haskell-like where inside of list
> comprehension will let the programmer have a space where they can
> explicitly state the variables.
>
> Best regards,
> Fabrizio
> _______________________________________________
> Python-ideas mailing list -- python-ideas(a)python.org
> To unsubscribe send an email to python-ideas-leave(a)python.org
> https://mail.python.org/mailman3/lists/python-ideas.python.org/
> Message archived at
> https://mail.python.org/archives/list/python-ideas@python.org/message/AHI...
> Code of Conduct: http://python.org/psf/codeofconduct/
>
--
Keeping medicines from the bloodstreams of the sick; food
from the bellies of the hungry; books from the hands of the
uneducated; technology from the underdeveloped; and putting
advocates of freedom in prisons. Intellectual property is
to the 21st century what the slave trade was to the 16th.
Hi all,
What would you think if we could write our code using unicode ?
It would be especially useful for scientific programming (we could use the
greek letters), it could also be nice to use emojis for some variables. I
don't see any bad consequences (apart from people that would use misleading
characters but that's already possible). I don't know how hard it is to do
that switch but it feels like it could be nice;
Cheers
(Re-sending, because this was originally a reply to an off-list message by Nima Hamidi)
On Jul 13, 2019, at 14:12, Nima Hamidi <hamidi(a)stanford.edu> wrote:
>
> Sometimes it's necessary not to evaluate the expression. Two such applications of NSE in R are as follows:
>
> 1. Data-tables have cleaner syntax. For example, letting dt be a data-table with a column called price, one can retrieve items cheaper than $1 using the following: dt [price < 1]. Pandas syntax requires something like dt[dt.price < 1]. This is currently inevitable as the expression is evaluated *before* __getitem__ is invoked. Using NSE, dt.__getitem__ can, first, add its columns to locals() dictionary and then evaluate the expression in the new context.
This one looks good. I can also imagine it being useful for SQLAlchemy, appscript, etc. just as it is for Pandas.
But in your proposal, wouldn’t this have to be written as dt[`price < 1`]? I think the cost of putting the expression in ticks is at least as bad as the cost of naming the dt.
Also: dt.price < 1 is a perfectly valid expression, with a useful value. You can store it in a temporary variable to avoid repeating it, or stash it for later, or print it out to see what’s happening. But price < 1 on its own is a NameError, and I’m not sure what `price < 1` is worth on its own. Would this invite code that’s hard to refactor and even harder to debug?
> 2. Pipe-lining in R is also much cleaner. Dplyr provided an operator %>% which passes the return value of its LHS as the first argument of its RHS. In other words, f() %>% g() is equivalent to g(f()). This is pretty useful for long pipelines. The way that it works is that the operator %>% changes AST and then evaluates the modified expression. In this example, evaluating g() is undesirable.
This doesn’t seem necessary in a language with first-class functions. Why can’t you just write the pipeline as something f %>% g, much as you would in, say, Haskell, which would just define a function (presumably equivalent to either lambda: g(f()) or lambda *a, **kw: g(f(*a, **kw))) that represents the pipeline that you then just call normally? I don’t see the benefit in being able to write g() instead of g here, and in fact it seems actively misleading, because it implies calling g on no arguments instead of one.
Also, given that Python doesn’t have such an operator, or a way to define custom operators, and that proposals for even simpler operators on functions like @ for compose have been rejected every time they’ve been suggested, I wouldn’t expect much traction from this example. Is there something similar that could plausibly be done in Python, and feel Pythonic?
—-
A couple more things I thought of since the initial reply…
I’m pretty sure Python’s AST objects don’t contain the original source text. So, what is your plot function going to actually do with its arguments to get the axes? What if it’s called with plot(`x[..., 3:]`)? Will plot—and every other function that wants to do something similar—need to come up with a way to generate the nicest source text that could produce the given AST? Or do we need to add a decompile to the stdlib for them? I suppose you could solve this by just adding more fields to BoundExpression, but I’m not sure that wouldn’t make it a lot harder to implement the backtick feature.
Backticks are supposed to be banned for the life of Python since 3.0 eliminated them as shorthand for repr. That could be revisited, but it might be a tough sell. Maybe the original “grit on Tim’s screen” reason is no longer as compelling because of higher-res screens and more uniform console fonts, but the rise to ubiquity of markdown seems like an even better reason not to use them. Today, you can paste Python code between backticks to mark it as code in markdown; if Python code can contain backticks, that’s no longer true. People who use languages that rely on backticks have been complaining about that for years; so we want to join them?
Finally, I think you need a fully worked-through example, not just a description of one. Show what the implementation of plot would look like if it could be handed BoundExpression objects. (Although pd.DataFrame.__getitem__ seems like the killer use case here, so maybe show that one instead, even though it’s probably more complicated.)
Could we add __enter__ and __exit__ to the tuple type?
Look at the following code:
a = open('a.tmp', 'w')
b = open('b.tmp', 'w')
with (a, b) as (af, bf):
af.write("1")
bf.write("2")
Even better example:
with tuple(open(str(_n) + '.tmp', 'w') for _n in range(1000)) as f:
for n, fn in enumerate(f):
f.write(str(n))
Tuple as context manager would invoke __enter__ for each of its elements
and return a tuple of the results.
On exit, the __exit__ method would be invoked for every element.
We could even generalize it to every kind of iterable.
This is somewhat consistent with treatment of exception types in
'except' clause.
try:
something()
except Exception1 as error:
handlerA(error)
except (Exception2, Exception3) as error:
handlerB(error)
Tuple of exception types is accepted in 'except' clause, as well as a
single exception type. We could apply that rule to the 'with' clause.
Hi all,
in response to some of the recent spam, Brett and I have decided to put in place moderation for subscriptions, as well as moderating some of the newly subscribed accounts.
We feel that moderation of all messages is too much, given the (occasional) high volume of python-ideas, and its utility as a free-form discussion forum.
best,
—titus
Currently the py[w] command will launch the latest python by default however I feel that this discourages the testing of pre-releases & release candidates as once they are installed they will become the default. What I would like is for the default to be the highest version number of a full release but the user to be able to specify a specific version even if it is a pre-release.
The currently py or py -3 would give python 3.7 (if installed) but py -3.8 would give the pre-release/release candidate if installed.
Any thoughts on whether this would be a good idea - I am quite willing to undertake the changes.
Steve Barnes
>>> a: 3
>>> type(a: 3)
File "<stdin>", line 1
type(a: 3)
^
SyntaxError: invalid syntax
>>> a: 3
>>> type(a)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
At the sensual mixing state, nitric oxide starts getting free from the man's body that makes and spare cGMP in his hot organ. Finally, penile muscles get broaden and speed of blood is augmented due to unwinding and extension of male penile channels. Therefore, a man finally gets a hard and suffering erection. Sildenafil citrate is the generic of Sildenafil 100mg, which works by hampering the movement of PDE-5 proteins that further deters the breakdown of cGMP existing in the male private district. A presentation tablet of Sildenafil should be taken orally with one glass of water.
https://www.247pharmacymart.com/shop/buy-cenforce-150-online-paypal/https://www.kamagra24uk.com/product/cenforce-100-sildenafil-citrate-100mg/
Hey all, after this talk
<http://pyfound.blogspot.com/2019/05/amber-brown-batteries-included-but.html>
on how useful standard libraries are this has been in talks in multiple
channels.
I just wanted to present my idea on the same.
Why not keep the essentials (ensurepip) and strip off everything else. When
someone imports a package like datetime, we can catch the error
(ImportError) and install it.
Or something similar.
Please do let me know your feedback on why this might or might not be a
good option so that we can come up with better solutions for issues.
Thank you!
