After the controversy with PEP-572, and Guido Van Rossum's exit, a new, brave world for Python has emerged. We now have the walrus operator, which lets one much more easily express programs as a series of expressions. Unlike statements, expressions have the freedom to inhabit any form they wish to have. Much like C, the whitespace is irrelevant, and if you write your program in this form then it becomes just as malleable as other languages. To prove this I made a series of what I'm calling Pseudo-Quines. This is not a new idea, but I don't think anyone has named it. The idea is creating code that allows you to deeply study one particular algorithm, and as a reward for your study you can format it in whatever way you would like.
l=lambda\
x0, y, x1, y1: \
((dx := x1 - x0, dy :=
y1-y,yi:=1,yi:=-1 if dy<0 else yi,
dy:=-dy if dy<0 else dy,d:=(2*dy)-dx,ps:=
set(),[(ps.add((x,y)),y:=y+yi,d:=d+2*(dy-dx))if d>
0 else(d:=d+2*dy)for x in range(x0,x1)]),ps)[1];pp=lambda \
ps:list(map(print, [''.join(["-"if(x, y)in ps else" "for x in range
(127)])for y in range(10)]));pp(set.union(*[l(0, 0, i, 9) for i in range(37, 127)]))
------
----------------
--------------------------
------------------------------------
----------------------------------------------
--------------------------------------------------------
------------------------------------------------------------------
----------------------------------------------------------------------------
--------------------------------------------------------------------------------------
This uses Bresenham's line algorithm to trace out the lines that constitute the shape of the source code.
from functools import reduce as red; from math import \
(factorial as fact, comb);import sys;from decimal import \
(getcontext as c,Decimal as dc);(a:=range,
b:=int(sys. argv[1]));\
c().prec=b; ber=lambda\
e,f=[dc(1)] :[f.append(
1-sum(comb( h,g)*f[g]/(h\
-g + 1) for g in a(h)))for
h in a(1, e + 1)] and abs(
f[-1]);print ((2 * fact(b) /
(ber(b)* 2** b * red(dc.__mul__
, [1 - (1/dc (i) ** b) for i in
[2, 3, 5, 7] ]))) ** (1/dc(b)))
#juliusgeo pi arb. precis.
3.14159265358979323846264338327950288419716939937510582097...
This code will print pi to arbitrary precision. And it looks like pi!
n=256;q, t, m, e, p, c, f=(range(n),16,lambda x
,y, r=0:m((h:=x <<1,h^283)[
h&n!= 0],y>> 1,(r,r ^x)
[y&1])if y else r,lambda
a,w= 1,p=n -2:e(m(a, a),(w,m
(w,a))[p&1] ,p>> 1)if p
else w, lambda b: list(
map (print,["%.2x "*t%(*b[r:r+t],)for
r in [*q][::t]])),lambda a,i: (a<<i|a>>8-i)&255
,lambda a: (a^c(a,1)^c(a,2)^c(a,3)^c(a,4))^99);
p(s:=[f(e(i)) for i in q]);p([*map(s.index,q)])
63 7c 77 7b f2 6b 6f c5 30 01 67 2b fe d7 ab 76
ca 82 c9 7d fa 59 47 f0 ad d4 a2 af 9c a4 72 c0
b7 fd 93 26 36 3f f7 cc 34 a5 e5 f1 71 d8 31 15
04 c7 23 c3 18 96 05 9a 07 12 80 e2 eb 27 b2 75
09 83 2c 1a 1b 6e 5a a0 52 3b d6 b3 29 e3 2f 84
53 d1 00 ed 20 fc b1 5b 6a cb be 39 4a 4c 58 cf
d0 ef aa fb 43 4d 33 85 45 f9 02 7f 50 3c 9f a8
51 a3 40 8f 92 9d 38 f5 bc b6 da 21 10 ff f3 d2
cd 0c 13 ec 5f 97 44 17 c4 a7 7e 3d 64 5d 19 73
60 81 4f dc 22 2a 90 88 46 ee b8 14 de 5e 0b db
e0 32 3a 0a 49 06 24 5c c2 d3 ac 62 91 95 e4 79
e7 c8 37 6d 8d d5 4e a9 6c 56 f4 ea 65 7a ae 08
ba 78 25 2e 1c a6 b4 c6 e8 dd 74 1f 4b bd 8b 8a
70 3e b5 66 48 03 f6 0e 61 35 57 b9 86 c1 1d 9e
e1 f8 98 11 69 d9 8e 94 9b 1e 87 e9 ce 55 28 df
8c a1 89 0d bf e6 42 68 41 99 2d 0f b0 54 bb 16
52 09 6a d5 30 36 a5 38 bf 40 a3 9e 81 f3 d7 fb
7c e3 39 82 9b 2f ff 87 34 8e 43 44 c4 de e9 cb
54 7b 94 32 a6 c2 23 3d ee 4c 95 0b 42 fa c3 4e
08 2e a1 66 28 d9 24 b2 76 5b a2 49 6d 8b d1 25
72 f8 f6 64 86 68 98 16 d4 a4 5c cc 5d 65 b6 92
6c 70 48 50 fd ed b9 da 5e 15 46 57 a7 8d 9d 84
90 d8 ab 00 8c bc d3 0a f7 e4 58 05 b8 b3 45 06
d0 2c 1e 8f ca 3f 0f 02 c1 af bd 03 01 13 8a 6b
3a 91 11 41 4f 67 dc ea 97 f2 cf ce f0 b4 e6 73
96 ac 74 22 e7 ad 35 85 e2 f9 37 e8 1c 75 df 6e
47 f1 1a 71 1d 29 c5 89 6f b7 62 0e aa 18 be 1b
fc 56 3e 4b c6 d2 79 20 9a db c0 fe 78 cd 5a f4
1f dd a8 33 88 07 c7 31 b1 12 10 59 27 80 ec 5f
60 51 7f a9 19 b5 4a 0d 2d e5 7a 9f 93 c9 9c ef
a0 e0 3b 4d ae 2a f5 b0 c8 eb bb 3c 83 53 99 61
17 2b 04 7e ba 77 d6 26 e1 69 14 63 55 21 0c 7d
This will print the normal and inverse Rijdnael (or AES, because they're used in AES-256 encryption standard)
S-boxes by implementing modular inverses in any space GF(2^n).
_,\
ses,c, f, \
s, ti, os, sm, nm, dt = (imp
:=__import__),'.:!*oe&#%@',*[getattr(imp
('math'),n)for n in("ceil","floor", "sqrt")], \
*[imp(i) for i in("time","os")],imp("itertools") \
.starmap,lambda v:(v[0]/(le:=s(sum([i**2 for i in v]
))),v[1]/le,v[2]/le),lambda x,y:sum(sm(float.__mul__,
zip(x,y)));ds=lambda r,k,a,l:[print(''.join([ses[max(
min(int((1-(dt(l,nm((x:=(i+0.5),y:=(j/2+0.5),s(r**2-x
**2-y**2))))**k+a))*(len(ses)-1)),len(ses)),0)] if((
i+0.5)**2+(j/2+0.5)**2)<=r**2else" "for j in range(\
int(f(-2*r)),int(c(2*r)+1))]))for i in range(int(f
(-r)),int(c(r)+1))];[[(ds(13, 2, 0.4, nm((i,i, -
20))),ti.sleep(.001), os.system("clear")) \
for i in range(-100, 100)] for _ in
range(2**32)]
:!***oooooooooo
:!***oooooeeeeeeeeeeeeeee
:!**oooooeeeeeeeeeeeeeeeeeeeeee
!!**ooooeeeeeeeeeeeeeeeeeeeeeeeeeee
!**ooooeeeeeeeeeeeeeeeeoooooooooooooooe
:!*ooooeeeeeeeeeeeeeooooooooooooooooooooooe
!**oooeeeeeeeeeeeeooooooooo****************oo
!*oooeeeeeeeeeeeeooooooo*********!!!!!!!!!!***o
!*oooeeeeeeeeeeeoooooo*******!!!!!!!!!!!!!!!!!!**
:*oooeeeeeeeeeeoooooo******!!!!!!::::::::::::::!!!*
*oooeeeeeeeeeoooooo*****!!!!!::::::...........:::!!
*ooeeeeeeeeeooooo*****!!!!:::::..................:!
ooeeeeeeeeoooooo****!!!!:::::.....................:
ooeeeeeeeooooo*****!!!::::.........................
oeeeeeeeeoooo****!!!!::::..........................
oeeeeeeeoooo****!!!!:::............................
oeeeeeeooooo***!!!!:::............................:
eeeeeeoooo****!!!:::.............................
eeeeeoooo***!!!:::.............................
eeeeoooo***!!!:::............................
eeeoooo***!!!::............................
eeooo***!!!::..........................
eooo**!!!:::.......................
eoo**!!!:::....................
oo**!!:::................
**!!!:::......:
This will display an animated, rendered sphere in the console using ascii characters.
Please never open a PR with code like this.