On 10/21/2018 9:00 AM, Siva Sukumar Reddy wrote:
I am really new to Python contribution community want to propose below
methods for List object.
For most classes, there is an infinite number of possible functions that
could be made into methods. The Python philosophy is to include as
methods the basic functions needed to write other functions. So number
classes include the basic operations of +, -, *, /, and ** as methods.
The math and cmath modules contain number functions that use these basic
operations.
The list class also has a fairly small set of methods. Nearly all are
either original or were added before list.pop, about 20 years ago.
list.clear was added more recently, in analogy with dict.clear, and
there was some opposition because there are other ways to clear a list.
1. *list.replace( item_to_be_replaced, new_item )*: which replaces all
the occurrences of an element in the list instead of writing a new list
comprehension in place.
2. *list.replace( item_to_be_replaced, new_item, number_of_occurrences
)*: which replaces the occurrences of an element in the list till
specific number of occurrences of that element. The
number_of_occurrences can defaulted to 0 which will replace all the
occurrences in place.
I presume these are somewhat in analogy with str.replace(old, new,
count=-1), except for being limited to one sequence member and being
done in place. Note that only 1 method is needed and the default count
should be -1, not 0.
However, the need for a built-in method is much, much less. Nearly all
cases that need to be done inline code can be done like this.
for i, item in enumerate(mylist):
if item == old:
mylist[i] = new
As Serhiy noted from previous discussion, other conditions are possible,
such as 'item in {old1, old2, old3}' or, given a list of numbers,
if item > max: mylist[i] = max
3. *list.removeall( item_to_be_removed )*: which removes all the
occurrences of an element in a list in place.
str.replace(old, '') does this (not in place) for strings. There are
also str.translate and re.sub and re.subn.
An indefinite number of in-place removes is a generally a bad idea
unless done carefully.
alist.remove is inherently O(n).
alist.removeall implemented naively would be O(n*n)/
alist = [x for x in alist if x == old] or
alist = list(x for x in alist if x == old) or
alist = list(filter(lambda x: x == old)) is O(n).
Again, as Serhiy noted, 'x == old' is only one possible condition.
The last example illustrates another point. In Python 3, one can
usually and often should avoid turning streams of objects into a
concrete list until one needs one of the particular list operations.
I noted above that we have only added 1 list method (that I know of)
since .pop. On the other hand, we added generators and then the
itertools module with multiple basic functions and multiple recipes
based on those functions. Since lists are no longer the basic
representation of sequences of items, adding list methods is somewhat
obsolete.
If possible, it is best to filter out multiple items when creating the
list instead of later. Or to put it another way, it is best to avoid
turning a stream into a list for as long as possible. If space and
aliasing are not issues, replacing a list is easier and possibly faster
that editing it in place. Note that editors for adding, replacing, and
deleting items tend to use tree structures rather than a single linear
sequence.
An alternative to removing items is to replace them with a null value,
such as None, '', 0, 1 (for multiplication), 'pass' (for code
execution), or sentinal=object(). The choice depends on what is to be
done later. In fact, temporary replacement is the key to efficient
multiple removals.
--
Terry Jan Reedy
_______________________________________________
Python-ideas mailing list
Python-ideas@python.org
https://mail.python.org/mailman/listinfo/python-ideas
Code of Conduct: http://python.org/psf/codeofconduct/
