仅使用纯函数创建一个包含值的列表 - python

Question

Why this problem has no trivial solution is because I needs to be solved using only pure functions .

Using only pure functions from Python's functional programming page ( https://docs.python.org/3/howto/functional.html# ), how can one create a list with a value in it? If we'd like to create a list with a value in it, we'd (in code) just do

x = [1]

I do not consider [] to be to be a part of the functions we're looking at here, since it has no signature and is not callable like any other function.

Using only functions to do this is not so trivial. One thought I had was to create a new list using list() and then append values to it. But list().append is mutable and does not return a new, or the, list with the item in it.

What I really want to do is to turn ["a","b","c"] into [["a"],["b"],["c"]] , with above constraints.

Other proposals has been made like creating my own (pure) function doing what I want:

def create_list(value) -> list:
    return [value]

and then just do map(create_list, ["a","b","c"]) to get solution. But this is a custom made function and is not from any of the python package functions (within https://docs.python.org/3/howto/functional.html , as mentioned)

Answer 1

Single element:

def to_list(elem):
    return list(range(elem, elem+1)))

To convert [1,2,3] into [[1], [2], [3]] with list comprehesion (it can be easily changed to map ):

return [to_list(el) for el in input_list]

And without (ugly, but works ^^)

import itertools

def make_gen(elem):
    yield elem

def to_list(elem):
    return list(make_gen(elem))

def helper(elem, l):
    return list(itertools.chain(to_list(to_list(elem)), l))

def convert(l):
    if not l:
        return []
    return helper(l[0], convert(l[1:]))


print(convert([1, 2, 3]))

Answer 2

Using only pure functions from Python's functional programming page ( https://docs.python.org/3/howto/functional.html# ), how can one create a list with a value in it? If we'd like to create a list with number 1 in it

You might exploit generator as generator are described therein as follows

def justone():
    yield 1
lst = list(justone())
print(lst)

output

[1]

justone is function (which might be checked using inspect.isfunction ) and is pure (as it does not alter anything outside)

Answer 3

lst=[1,2,3];
#this will print [[1],[2],[3]]
print(list(map(lambda x: [x],lst)));

Answer 4

In the documentation you link, there are references to Iterators and Generators, which are powerful constructs present in Python (and other languages). You can consider a function to build a list as follows:

def list_from_args(*args):
    return [*args]

This is a (superfluous) wrapper around Iterator functionality. You can leverage the Iterator pattern in Python to accomplish a lot, whether that be creating/consuming objects (eg lists, tuples, dictionaries), or for processing data (eg reading/writing to a file line-by-line, paginating an API or DB Query, etc.)

The code above does the following, for example:

>>> example = list_from_args(1, 'a', 'ham', 'eggs', 44)
>>> example
[1, 'a', 'ham', 'eggs', 44]

The reason I labeled the above function as superfluous: Oftentimes, if you need to create a list on the fly, you can use list comprehensions .

Answer 5

To ensure non-mutability, you probably want to use tuples instead of lists (or be very disciplined with your lists).

Using a list comprehension would be a valid functional approach:

A = [1,2,3]
B = [ [i] for i in A ]        # [[1], [2], [3]]

or with tuples:

A = (1,2,3)
B = tuple( (i,) for i in A )  # ((1,), (2,), (3,))

If you must use functions, then map() is probably a good solution to this:

A = [1,2,3]
B = list(map(lambda i:[i],A))

If even [i] is proscribed (but why would it be), you can use aa function to make a list directly from its arguments:

def makeList(*v): return list(*v)

A = makeList(1,2,3)
B = makeList(*map(makeList,A))

# combined
makeList(*map(makeList,makeList(1,2,3)))

BTW functional programming is not about "only using functions", it is more about non-mutability of results (and avoidance of side effects). You may want to question whoever is sending you on this wild goose chase.

Answer 6

This does it using only functions from https://docs.python.org/3/library/functional.html

import functools
import itertools

map(
    list, 
    map(
        functools.partial(
            itertools.repeat, 
            times=1,
        ), 
        [1,2,3]
    )
)

functools.partial creates a new function of itertools.repeat with "times" parameter set to 1. Each value in the list is then repeated once and turned into a new list using list function.

>>> [[1], [2], [3]]