Could you please explain how it works. In particular: where do a,c,n,s,z come from? And how to convert this to regular functions and their calls?

x=10
y=5
abs( (lambda a: lambda z, c, n: a(a, z, c, n)) (lambda s, z, c, n: z if n == 0 else s(s, z*z c, c, n-1)) (0, 0.02*x 0.05j*y, 10) )

It was even longer, but I figured out the rest of it.

print('\n'.join([''.join(['*'if abs((lambda a: lambda z, c, n: a(a, z, c, n))(lambda s, z, c, n: z if n == 0 else s(s, z*z c, c, n-1))(0, 0.02*x 0.05j*y, 40)) < 2 else ' ' for x in range(-80, 20)]) for y in range(-20, 20)]))

This monster expression outputs a pseudo-graphic Mandelbrot fractal to the console.

CodePudding user response：

This function (lambda a: lambda z, c, n: a(a, z, c, n)) can be rewritten as

def apply_function_to_itself(funk):
    def inner(arg1, arg2, arg3):
        funk(funk, arg1, arg2, arg3)
        
    return inner

This is a functional thing that calls a function with itself as the first argument. This is necessary for recursion in functional languages but in python there is usually a better way.

This function (lambda s, z, c, n: z if n == 0 else s(s, z*z c, c, n-1)) can be rewritten as this:

def transform_n_times(funk, value, c, n):
    if n==0:
        return arg1
    else:
        return funk(funk, value * value   constant, constant, n-1)

We know from the previous function that funk === call_if_n_is_not_0, so this is a recursive function that will apply a operation n times before stopping.

So basically combined we can rewrite it like this:

def transform_n_times(value, constant, n):
    for i in range(n):
        value arg1 * arg1   arg2
    return value

Much simpler.

Understanding the entire program

The entire code could be written like this:

def apply_function_to_itself(funk):
    def inner(arg1, arg2, arg3):
        funk(funk, arg1, arg2, arg3)
        
    return inner

def transform_n_times(funk, value, constant, n):
    if n==0:
        return arg1
    else:
        return funk(funk, value * value   constant, constant, n-1)

abs(apply_function_to_itself(call_if_n_is_not_0)(0, 0.02*x 0.05j*y, 10))

Or like this. We can get rid of the apply_function_to_itself entirely but keep the recursion like this:

def transform_n_times(value, constant, n):
    if n==0:
        return arg1
    else:
        return transform_n_times(funk, value * value   constant, constant, n-1)

abs(transform_n_times(0, 0.02*x 0.05j*y, 10))

Or we can delete the recursion entirely and just use a loop:

constant = 0.02*x 0.05j*y
value = 0
n = 10
for i in range(n):
    a1 = value * value   constant
abs(value)

The basic equation behind the mandlebrot set is f(x) = x^2 c which matches this.