混淆的曼德尔布罗特函数 - 谁能解密它？

Question

_                                      =   (
                                        255,
                                      lambda
                               V       ,B,c
                             :c   and Y(V*V+B,B,  c
                               -1)if(abs(V)<6)else
               (              2+c-4*abs(V)**-0.4)/i
                 )  ;v,      x=7200,4800;C=range(v*x
                  );import  struct;P=struct.pack;M,\
            j  ='<QIIHHHH',open('M.bmp','wb').write
for X in j('BM'+P(M,v*x*3+26,26,12,v,x,1,24))or C:
            i  ,Y=_;j(P('BBB',*(lambda T:(T*80+T**9
                  *i-950*T  **99,T*70-880*T**18+701*
                 T  **9     ,T*i**(1-T**45*2)))(sum(
               [              Y(0,(A%3/3.+X%v+(X/v+
                               A/3/3.-x/2)/1j)*2.5
                             /x   -2.7,i)**2 for  \
                               A       in C
                                      [:9]])
                                        /9)
                                       )   )

我刚开始学习Python，对它能生成分形图像非常感兴趣。我自己写了一些简单的分形图，但我最近发现了一个生成曼德尔布罗特分形的脚本……它可以生成美丽的全彩图像，分辨率也可以根据你的需求调整……不过，这段代码被处理得像是曼德尔布罗特的ASCII艺术，虽然看起来很酷，但如果想轻松阅读就有点傻了。里面有一些我还没学过的Python函数，所以如果有人能把这段脚本整理成正常的Python格式，那就太好了。

正如我所说，这个艺术作品很酷，但太难读了！如果有人能帮忙做到这一点，我会非常感激。

Answer 1

注意：这不是一个最终的答案，而是一步一步地解释代码的过程。如果你能提供额外的步骤让事情更清楚，那就太好了，可以把它加到这个回答里。

好的，首先我们给代码加上适当的换行和缩进：

_ = (255,
    lambda V, B, c: c and Y(V*V + B, B, c-1) if(abs(V) < 6) else (2 + c - 4 * abs(V)**-0.4)/i)
v, x = 7200, 4800
C = range(v*x)
import struct
P=struct.pack
M, j = '<QIIHHHH', open('M.bmp','wb').write
for X in j('BM' + P(M, v*x*3+26, 26, 12, v, x, 1, 24)) or C:
    i, Y = _
    j(
        P('BBB',
                *(lambda T: (T * 80 + T**9 * i - 950 * T**99, T*70 - 880* T**18 + 701* T**9, T* i**(1-T**45*2)))(
                    sum([Y(0, (A%3/3. + X%v + (X/v + A/3/3. - x/2)/1j) * 2.5/x - 2.7, i)**2 for A in C[:9]]) / 9
                )
        )
    )

这样看起来好一些，但还是有点让人困惑。比如，把 P 定义为 struct.pack 的别名，还有那些一行写两个声明的地方。如果我们把这些去掉，把 lambda 定义移到循环外面，就变成这样：

import struct
i = 255
Y = lambda V, B, c: c and Y(V*V + B, B, c-1) if(abs(V) < 6) else (2 + c - 4 * abs(V)**-0.4)/i
v = 7200
x = 4800
C = range(v*x)
M = '<QIIHHHH'
color = lambda T: (T * 80 + T**9 * i - 950 * T**99, T*70 - 880* T**18 + 701 * T**9, T * i**(1-T**45*2))

f = open('M.bmp','wb')
for X in f.write('BM' + struct.pack(M, v*x*3+26, 26, 12, v, x, 1, 24)) or C:
    f.write(
        struct.pack('BBB',
            *color(sum([Y(0, (A%3/3. + X%v + (X/v + A/3/3. - x/2)/1j) * 2.5/x - 2.7, i)**2 for A in C[:9]]) / 9))
    )

现在事情开始变得清晰一些了。这个循环是在为每个像素写颜色值，而 lambda 返回的是一个包含三个值的元组，分别代表每个像素的蓝色、绿色和红色值。

import struct
i = 255
Y = lambda V, B, c: c and Y(V*V + B, B, c-1) if abs(V) < 6 else (
                    (2 + c - 4 * abs(V)**-0.4)/i)
v = 7200
x = 4800
C = range(v*x)
M = '<QIIHHHH'
color = lambda T: (T * 80 + T**9 * i - 950 * T**99,
                   T*70 - 880* T**18 + 701 * T**9,
                   T * i**(1-T**45*2))
f = open('M.bmp', 'wb')
for X in f.write('BM' + struct.pack(M, v*x*3+26, 26, 12, v, x, 1, 24)) or C:
    f.write(struct.pack('BBB',
        *color(sum(
            [Y(0, (A%3/3. + X%v + (X/v + A/3/3. - x/2)/1j) * 2.5/x - 2.7, i)**2
                for A in C[:9]]) / 9))
    )

根据你的评论，星号（*）可以把一个列表拆分成参数列表。

经过很多小时的努力，这里是生成的接近100 MB的 曼德尔布罗特集合 的图像：