atoms = np.genfromtxt(filename, skip_header=2,
        dtype=[('el','S5'), ('x','f8'), ('y','f8'), ('z','f8')])

coordinate_data = xyz[['x', 'y', 'z']]
    numerical_array = coordinate_data.view(np.float64).reshape(coordinate_data.shape + (-1,))

X = np.array(...) # Shape: (Anzahl Atome x Raumdimensionen)

# Ohne ausmultiplizieren
squared_distances = np.square(X[None, :] - X[:, None]).sum(axis=-1)
distances = np.sqrt(squared_distances)

# Mit ausmultiplizieren
Xsq = np.square(X).sum(-1)
squared_distances = - 2. * np.dot(X, X.T) + (Xsq[:, None] + Xsq[None, :])
distances = np.sqrt(squared_distances)

# Hier sind die Diagonaleinträge ungefähr 0
np.fill_diagonal(distances, np.inf)

mean_shortest_distance = distances.min(axis=1).mean()

class SuperCell(object):

    def from_file(self, filename, with_sort=True):
        atom_re = re.compile(r'\s*(\w+)\s+([-+]?\d*\.\d+|\d+)\s+([-+]?\d*\.\d+|\d+)\s+([-+]?\d*\.\d+|\d+)\s*')

        with open(filename) as f:
            for i, line in enumerate(f):
                if i > 1:
                    m = atom_re.match(line)
                    a = Atom(
                        element=m.group(1),
                        x=float(m.group(2)),
                        y=float(m.group(3)),
                        z=float(m.group(4))
                    )
                    self.add_atom(a)

    def add_atom(self, atom):
        self.atoms.append(atom)

    def nearest_neighbor_distance(self, num_trials=3):
        min_distance_averaged = []
        for trial in range(num_trials):
            min_distance = None
            for a in random.choice(self.atoms):
                for i,b in enumerate(self.atoms):
                    d = a.distance(b)
                    if d and (not min_distance d or d < min_distance):
                        min_distance = d
            min_distance_averaged += min_distance / num_trials
        return min_distance_averaged

    def distance(self, a, b):
        dx = a.x - b.x
        dy = a.y - b.y
        dz = a.z - b.z

        if dx < -self.lx / 2: dx += self.lx
        if dy < -self.ly / 2: dy += self.ly
        if dz < -self.lz / 2: dz += self.lz
        if dx > +self.lx / 2: dx -= self.lx
        if dy > +self.ly / 2: dy -= self.ly
        if dz > +self.lz / 2: dz -= self.lz

        return math.sqrt(dx**2 + dy**2 + dz**2)


class Atom(object):

    def __init__(self, **kwargs):
        self.x = kwargs.get('x', 0.0)
        self.y = kwargs.get('y', 0.0)
        self.z = kwargs.get('z', 0.0)
        self.element = kwargs.get('element', None)