Mailman 3 March 2020 - Python-ideas

Instance method to test equivalence between set and iterable
by Steve Jorgensen 25 Mar '20

25 Mar '20

Currently, the `issubset` and `issuperset` methods of set objects accept arbitrary iterables as arguments. An iterable that is both a subset and superset is, in a sense, "equal" to the set. It would be inappropriate for `==` to return `True` for such a comparison, however, since that would break the `Hashable` contract. Should sets have an additional method, something like `like(other)`, `issimilar(other)`, or `isequivalent(other)`, that returns `True` for any iterable that contains the all of the items in the set and no items that are not in the set? It would therefore be true in the same cases where `<set> = set(other)` or `<set>.issubset(other) and <set>.issuperset(other)` is true.

13 29

Re: New explicit methods to trim strings
by Barry Scott 25 Mar '20

25 Mar '20

> On 19 Mar 2020, at 22:12, Rob Cliffe <rob.cliffe(a)btinternet.com> wrote: > > > On 18/03/2020 20:16, Barry Scott wrote: >> >>> On 18 Mar 2020, at 18:03, Rob Cliffe via Python-ideas <python-ideas(a)python.org> wrote: >>> >>> Consider that the start or end of a string may contain repetitions of an affix. >>> >>> Should `-+-+-+Spam'.stripprefix('-+') remove just the first occurence? All of them? Does it need a 'count' parameter? >> The only ways to use this function without counting is remove 1 prefix or remove all. >> As Alex said 1 prefix is the common case. For the all case there are existing ways to do it. >> >> If you are counting the number of prefix occurrences that exist you can simple slice the answer >> without the strip prefix function. >> >> Barry > > I don't understand the last sentence. I had in mind a case where you might want to remove repetitions of an affix without knowning how many there were (possibly none). Yep could have worded better. I was wonder what example would need the count and if when you have the count its easy to solve another way. I'm less sure have thought more about it. As you noted later str.replace() has a count. So why by prefix/suffix striping? Barry > > Rob Cliffe >

11 20

Developer messages on install (pip, poetry, etc.)
by Ronie Martinez 23 Mar '20

23 Mar '20

Good day! I have been developing in Node for a few months now for non-Python projects (legacy project) and I found a NPM feature which could be helpful to developers of Python libraries. When you install a NPM package, some show a message from the author after installation (see example below). ------ Thank you for using core-js ( https://github.com/zloirock/core-js ) for polyfilling JavaScript standard library! The project needs your help! Please consider supporting of core-js on Open Collective or Patreon: > https://opencollective.com/core-js > https://www.patreon.com/zloirock Also, the author of core-js ( https://github.com/zloirock ) is looking for a good job -) ------ Is it possible to adopt this? My proposal is to add an entry in the package metadata which I believe is safer and easier to implement compared to running a post-installation script. It is up for developers of package managers (pip, poetry, etc.) to actually print these on the terminal. I appreciate comments and feedback. Regards, Ronie

4 4

Syntax for loop invariants
by haael 23 Mar '20

23 Mar '20

Python has more and more optional tools for formal correctness cheking. Why not loop invariants? Loop invariant is such a statement that if it was true before the loop iteration, it will also be true after the iteration. It can be implemented as an assertion of an implication. now_value = False while running_condition(...): prev_value = now_value now_value = invariant_condition(...) assert now_value if prev_value else True Here for ellipsis we can substitute any values and variables. I propose the new syntax: while running_condition(...): invariant invariant_condition(...) The keyword 'invariant' is allowed only inside a loop. The interpreter will create a separate boolean variable holding the truth value of each invariant. On the loop entry, the value is reset to false. When the 'invariant' statement is encountered, the interpreter will evaluate the expression, test the implication 'prev_value -> now_value' and update the value. If the implication is not met, an exception will be thrown 'InvariantError' which is a subclass of 'AssertionError'. Like assertions, invariants will be checked only in debug mode. I am developing a library for formal proofs and such a feature would be handy. haael

8 12

Add the imath module
by Serhiy Storchaka 22 Mar '20

22 Mar '20

What are your thoughts about adding a new imath module for integer mathematics? It could contain the following functions: * factorial(n) Is just moved from the math module, but non-integer types are rejected. Currently math.factorial() accepts also integer floats like 3.0. It looks to me, the rationale was that at the time when math.factorial() was added, all function in the math module worked with floats. But now we can revise this decision. * gcd(n, m) Is just moved from the math module. * as_integer_ration(x) Equivalents to: def as_integer_ration(x): if hasattr(x, 'as_integer_ration'): return x.as_integer_ration() else: return (x.numerator, x.denominator) * binom(n, k) Returns factorial(n) // (factorial(k) * factorial(n-k)), but uses more efficient algorithm. * sqrt(n) Returns the largest integer r such that r**2 <= n and (r+1)**2 > n. * isprime(n) Tests if n is a prime number. * primes() Returns an iterator of prime numbers: 2, 3, 5, 7, 11, 13,... Are there more ideas?

14 38

New explicit methods to trim strings
by Alex Grigoryev 21 Mar '20

21 Mar '20

Following the discussion here (https://link.getmailspring.com/link/7D84D131-65B6-4EF7-9C43-51957F9DFAA9@ge…) I propose to add 3 new string methods: str.trim, str.ltrim, str.rtrim Another option would be to change API for str.split method to work correctly with sequences. In [1]: def ltrim(s, seq): ...: return s[len(seq):] if s.startswith(seq) else s ...: In [2]: def rtrim(s, seq): ...: return s[:-len(seq)] if s.endswith(seq) else s ...: In [3]: def trim(s, seq): ...: return ltrim(rtrim(s, seq), seq) ...: In [4]: s = 'mailto:maria@gmail.com' In [5]: ltrim(s, 'mailto:') Out[5]: 'maria(a)gmail.com' In [6]: rtrim(s, 'com') Out[6]: 'mailto:maria@gmail.' In [7]: trim(s, 'm') Out[7]: 'ailto:maria@gmail.co'

28 162

Adding a built-in data structure with binary search tree semantics
by 1njection1＠gmail.com 20 Mar '20

20 Mar '20

In other languages, there are built-in data structures with binary search tree semantics, as an example, std::map in C++. By binary search tree semantics we mean the following: * We can insert elements into the structure in time faster than O(n), i.e. O(logn) for std::map * We can iterate over all of the elements of the structure in sorted order in linear time, i.e. O(n) for std::map Is there currently any data structure in Python with binary search tree semantics? To illustrate the need, can the following program be written elegantly and efficiently with built-in Python data structures? Imagine that you are a fund manager at a bank. Bank accounts are added to your fund very frequently. A bank account has an ID and a value. A smaller ID means that the bank account was created earlier than one with a larger ID. Each time that an account is added to your fund, you would like to know the ID number of the 1000th oldest account, for your records. Here are implementations in Python 3 and C++, for comparison: ```python3 from random import randint dist = lambda: randint(0, 2147483647) def main(): my_map = {} # fills a map with 1000000 random mappings of type (int, int) for i in range(0, 1000000): my_map[dist()] = dist() # prints out the 1000th smallest key and its value target_key = nth_smallest_key(1000, my_map) print("({}: {})".format(target_key, my_map[target_key])) # writes a new random mapping to the map # then prints out the 1000th smallest key and its value if that key # has changed # 100000 times for i in range(100000): my_map[dist()] = dist() test_key = nth_smallest_key(1000, my_map) if target_key != test_key: target_key = test_key print("({}: {})".format(target_key, my_map[target_key])) # print an indicator every 100 iterations for comparison if i % 100 == 0: print("iteration: {}".format(i)) def nth_smallest_key(n, m): return sorted(m.keys())[n] if __name__ == "__main__": main() ``` ```c++ #include <cstdio> #include <map> #include <random> using namespace std; int nth_smallest_key(int n, map<int, int>& m); int main() { random_device rd; mt19937 psrng(rd()); uniform_int_distribution<> dist(0, 2147483647); map<int, int> my_map; // fills a map with 1000000 random mappings of type (<int>: <int>) for (int i = 0; i < 1000000; i++) { my_map[dist(psrng)] = dist(psrng); } // prints out the 1000th smallest key and its value int target_key = nth_smallest_key(1000, my_map); printf("(%d: %d)\n", target_key, my_map[target_key]); // writes a new random mapping to the map // then prints out the 1000th smallest key and its value if that key // has changed // 100000 times for (int i = 0; i <= 100000; i++) { my_map[dist(psrng)] = dist(psrng); int test_key = nth_smallest_key(1000, my_map); if (target_key != test_key) { target_key = test_key; printf("(%d: %d)\n", target_key, my_map[target_key]); } } return 0; } int nth_smallest_key(int n, map<int, int>& m) { map<int, int>::iterator curr = m.begin(); for (int i = 0; i < n; i++) { curr = next(curr); } return curr->first; } ``` Makefile: ```make runcpp: buildcpp ./main buildcpp: g++ -o main bst_semantics_cpp.cpp runpython: python3 bst_semantics_python.py ``` The C++ program runs on my machine in approximately 5 seconds ```bash $ time ./main (2211193: 2021141747) (2208771: 1079444337) (2208700: 1187119077) (2208378: 1447743503) ... (1996019: 1378401665) (1989217: 1457497754) (1989042: 1336229409) real 0m4.915s user 0m4.750s sys 0m0.094s $ ``` The Python program does not reach 1% of completion after 120 seconds ```bash $ time make runpython python3 bst_semantics_python.py (2158070: 1498305903) iteration: 0 iteration: 100 iteration: 200 ^CTraceback (most recent call last): File "bst_semantics_python.py", line 36, in <module> main() File "bst_semantics_python.py", line 23, in main test_key = nth_smallest_key(1000, my_map) File "bst_semantics_python.py", line 33, in nth_smallest_key return sorted(m.keys())[n] KeyboardInterrupt Makefile:8: recipe for target 'runpython' failed make: *** [runpython] Error 1 real 2m2.040s user 1m59.063s sys 0m0.375s $ ``` I would like to propose adding such a data structure to the Python standard library. It could be called a SortedDict.

11 23

Support max heaps in heapq module
by Abhai Kollara 20 Mar '20

20 Mar '20

Hi, I understand that the default implementation of heapq.heapify is to create a min-heap. The logic for max-heapify has already been implemented inside _heapify_max and along with that for corresponding push and pop operations. But they are not exposed to the user and hence not mentioned in any of the docs. I am unable to find any explanation as to why this is so. Current methods of implementing max-heaps (according to the SO question mentioned below) involves inverting the signs of numeric values and other workarounds. Therefore, I would like to propose officially supporting max-heaps as a part of heapq module. SO Q&A regarding the issue : https://stackoverflow.com/questions/2501457/what-do-i-use-for-a-max-heap-im… Thank you -- Abhai Kollara

2 1

Formalized pretty & encoding-aware object representation (was dunder methods for...)
by Steve Jorgensen 20 Mar '20

20 Mar '20

Based on the conversations stemming from my previous post, it is clear that the topic was too implementation-specific. It is not clear whether dunder methods are an appropriate component of the solution (they might or might not be). Also, it presumably makes sense to start by looking at prior art rather than inventing from scratch. Quotes from previous thread regarding prior art to look at: Jonathan Fine wrote: <snip> > Here's some comments on the state of the art. In addition to > https://docs.python.org/3/library/pprint.html > there's also > https://docs.python.org/3/library/reprlib.html > and > https://docs.python.org/3/library/json.html > I expect that these three modules have some overlap in purpose and design > (but probably not in code). > And if you're brave, there's also > https://docs.python.org/3/library/pickle.html > and > https://github.com/psf/black > Time to declare a special interest. I'm a long-time user and great fan of > TeX / LaTeX. And some nice way of pretty-printing Python objects using TeX > notation could be useful. > And also related is Geoffrey French's Larch environment for editing Python, > which has a pretty-printing component. > http://www.britefury.com/larch_site/ > with best wishes > Jonathan Alex Hall wrote: > Might be helpful to look at https://github.com/tommikaikkonen/prettyprinter > and https://github.com/wolever/pprintpp

2 3

Re: dunder methods for encoding & prettiness aware formal & informal representations
by Angus Hollands 20 Mar '20

20 Mar '20

Has anyone mentioned the IPython pretty printer yet? I'm late to the conversation unfortunately, so apologies if someone else already raised it. https://ipython.readthedocs.io/en/stable/api/generated/IPython.lib.pretty.h… On Fri, 20 Mar 2020 at 16:02, <python-ideas-request(a)python.org> wrote: > Send Python-ideas mailing list submissions to > python-ideas(a)python.org > > To subscribe or unsubscribe via the World Wide Web, visit > https://mail.python.org/mailman3/lists/python-ideas.python.org/ > or, via email, send a message with subject or body 'help' to > python-ideas-request(a)python.org > > You can reach the person managing the list at > python-ideas-owner(a)python.org > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Python-ideas digest..."Today's Topics: > > 1. Re: dunder methods for encoding & prettiness aware formal & informal > representations > (Chris Angelico) > 2. Re: dunder methods for encoding & prettiness aware formal & informal > representations > (Steven D'Aprano) > 3. Re: dunder methods for encoding & prettiness aware formal & informal > representations > (Greg Ewing) > 4. Re: dunder methods for encoding & prettiness aware formal & informal > representations > (Steven D'Aprano) > > > > ---------- Forwarded message ---------- > From: Chris Angelico <rosuav(a)gmail.com> > To: "Steven D'Aprano" <steve(a)pearwood.info> > Cc: python-ideas <python-ideas(a)python.org> > Bcc: > Date: Fri, 20 Mar 2020 15:37:08 +1100 > Subject: [Python-ideas] Re: dunder methods for encoding & prettiness aware > formal & informal representations > On Fri, Mar 20, 2020 at 3:28 PM Steven D'Aprano <steve(a)pearwood.info> > wrote: > > > > On Fri, Mar 20, 2020 at 03:01:16PM +1100, Chris Angelico wrote: > > > On Fri, Mar 20, 2020 at 2:59 PM Steven D'Aprano <steve(a)pearwood.info> > wrote: > > > > > > > > On Thu, Mar 19, 2020 at 11:38:28PM +0000, Samuel Colvin wrote: > > > > > > > > > But it also looks for a "__pretty__" method on objects, and if > found uses > > > > > that to display the object. > > > > > > > > Are you aware that dunder names are reserved for Python's use? > > > > > > > > > > Really? > > > > Yes, really. > > > > > https://docs.python.org/3/reference/lexical_analysis.html#reserved-classes-… > > > > > > > Somebody better tell SQLAlchemy that they're breaking rules, then. > > > > Lots of people break the rules all the time. Doesn't mean they should. > > > > "Subject to breakage without warning" technically applies to a *lot* > of things that aren't guaranteed. Using __pretty__ as a protocol is no > different from any of those. > > IMO it's not exactly a serious crime, even if technically it's > something that could be broken. Also, since this is a proposal on > python-ideas, it'd have as much blessing as __copy__, which to my > knowledge has no meaning in the language itself, only in the standard > library; it'd be the same with __pretty__, defined by the pprint > module. > > ChrisA > > > ---------- Forwarded message ---------- > From: "Steven D'Aprano" <steve(a)pearwood.info> > To: python-ideas(a)python.org > Cc: > Bcc: > Date: Fri, 20 Mar 2020 16:25:28 +1100 > Subject: [Python-ideas] Re: dunder methods for encoding & prettiness aware > formal & informal representations > On Fri, Mar 20, 2020 at 03:37:08PM +1100, Chris Angelico wrote: > > > "Subject to breakage without warning" technically applies to a *lot* > > of things that aren't guaranteed. > > Yes? > > > > Using __pretty__ as a protocol is no different from any of those. > > If we should choose to use a `__pretty__` dunder, we have no obligation > to follow Samuel's API, or make it a future-import, or give him any > warning, or make any allowances for the fact that he is already using > it. We can just break his code. > > Samuel may not have known that, but hopefully he will now. > > > > IMO it's not exactly a serious crime, > > Isn't it? Damn, I've already reported him to the federal police, the > SWAT team will be arriving in 5, 4, 3, 2, ... > > *wink* > > I didn't describe it as a crime at all, I just asked if he knew he was > using a reserved name. > > > > even if technically it's > > something that could be broken. Also, since this is a proposal on > > python-ideas, it'd have as much blessing as __copy__, which to my > > knowledge has no meaning in the language itself, only in the standard > > library; it'd be the same with __pretty__, defined by the pprint > > module. > > I don't think that's a distinction that means anything. Whether the > standard library or the interpreter itself breaks your code, it's still > broken. > > > > -- > Steven > > > ---------- Forwarded message ---------- > From: Greg Ewing <greg.ewing(a)canterbury.ac.nz> > To: python-ideas(a)python.org > Cc: > Bcc: > Date: Fri, 20 Mar 2020 18:30:24 +1300 > Subject: [Python-ideas] Re: dunder methods for encoding & prettiness aware > formal & informal representations > On 20/03/20 4:55 pm, Steven D'Aprano wrote: > > > Are you aware that dunder names are reserved for Python's use? > > Nobody is going to put you in jail if you use an unofficial dunder > name. You just run the risk that your use of it will conflict with > some official use in the future. > > -- > Greg > > > ---------- Forwarded message ---------- > From: "Steven D'Aprano" <steve(a)pearwood.info> > To: python-ideas(a)python.org > Cc: > Bcc: > Date: Fri, 20 Mar 2020 17:20:25 +1100 > Subject: [Python-ideas] Re: dunder methods for encoding & prettiness aware > formal & informal representations > On Fri, Mar 20, 2020 at 06:30:24PM +1300, Greg Ewing wrote: > > On 20/03/20 4:55 pm, Steven D'Aprano wrote: > > > > >Are you aware that dunder names are reserved for Python's use? > > > > Nobody is going to put you in jail if you use an unofficial dunder > > name. You just run the risk that your use of it will conflict with > > some official use in the future. > > You're the second person mentioning crime or law. What did I say to > give people the impression that I think that using a dunder is a > criminal offence? > > I didn't say that it was illegal or breaking the law, or a felony or > even a misdemeaner. I didn't even make a value judgement about > whether it was a good thing or a bad thing to use dunder names. > > I said that dunders are reserved. Not everyone knows this. > > What should I have said that won't be misinterpreted as an accusation of > criminality? > > > > -- > Steven_______________________________________________ > 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/ >

1 0