Как эффективно визуализировать убывающую последовательность наборов?

Question

У меня есть убывающая последовательность наборов, выраженная списком массивов следующим образом:

import numpy as np

D = [np.array([1, 2, 3, 4]),
     np.array([1, 2, 3]),
     np.array([1])]

print(D)

Я хотел бы спросить, как хорошо визуализировать эту последовательность? Большое спасибо за ваше предложение!

---

Обновление: Благодаря инструкции @ warped, это то, что я ищу. Единственная проблема - показать все числа на обеих осях.

##### Import packages
import numpy as np
import scipy.linalg as la
import time
import matplotlib
import matplotlib.pyplot as plt

##### Initial conditions
N = 9
lamda = 7
mu = 2
a = 0.5
r = - np.log(a).copy()
St_Sp = np.arange(- N, N + 1)
Card = St_Sp.shape[0]

##### Define infintesimal generator
def LL(x, y):
    if x == N or x == - N: re = 0
    elif x - y == - 1: re = lamda
    elif x - y == 1: re = mu
    elif x - y == 0: re = - (mu + lamda)
    else: re = 0
    return re

def L(x):
    return - LL(x, x)

##### Define function Phi
def Phi(x):
    return max(x, 0)
Phi = np.vectorize(Phi)

##### Define vector b
b = np.array(Phi(St_Sp))

##### Define function Psi
def Psi(x):
    return L(x) / (L(x) + r)
Psi = np.vectorize(Psi)

##### Generate a Boolean vector whose all elements are False
d = np.array([0] * Card).astype(bool)

##### Define matrix A
A = np.zeros((Card, Card))
for i in range(Card):
    for j in range(Card):
        if (i != j) & (L(St_Sp[i]) != 0):
            A[i, j] = LL(St_Sp[i], St_Sp[j]) / L(St_Sp[i])
        elif (i != j) & (L(St_Sp[i]) == 0):
            A[i, j] = 0
        elif (i == j) & (Psi(St_Sp[i]) != 0):
            A[i, j] = - 1 / Psi(St_Sp[i])
        else: A[i, j] = 1

##### Row names of A
rows = np.arange(0, Card)

##### Define matrix B
B = np.zeros((Card, Card))
for i in range(Card):
    for j in range(Card):
        if i != j:
            B[i, j] = LL(St_Sp[i], St_Sp[j])
        else: B[i, j] = LL(St_Sp[i], St_Sp[j]) - r

start = time.time()        

##### Generate I_0
I = [np.array([1] * Card).astype(bool), d.copy()]

Z = np.array(b.copy())
Z = Z.astype(float)       
D = [St_Sp]
index0 = np.matmul(B, Z) <= 0
index1 = ~ index0

Y = [b.copy()]

##### Iterations
for i in range(1, Card):    
    I = [I[0] & index0, I[1] | index1]
    Z = np.array(b.copy())
    Z = Z.astype(float)

    A1 = A[np.ix_(rows[I[1]], rows[I[1]])]    
    A2 = A[np.ix_(rows[I[1]], rows[I[0]])]

    Z[I[1]] = la.solve(A1, - np.matmul(A2, Z[I[0]]))

    Y = np.concatenate((Y, [Z]))
    D.append(St_Sp[I[0]])

    index = np.matmul(B[I[0]], Z) <= 0

    index0, index1 = d.copy(), d.copy()
    index0[I[0]], index1[I[0]] = index, ~ index

    if (I[0] == index0).all() == True: break

for i, array in enumerate(D):
    plt.scatter([i]*len(array), array)

и получить результат

Answer 1

Вы имеете в виду что-то вроде этого?

for i,array in enumerate(D):
    plt.scatter([i]*len(array), array)