Curvature data to coordinates
If you are doing a lot of numerical calculations in Python and want them to be fast, you should use numpy, a package specifically for this purpose.

It allows you to write your code in a vectorized way, making it easer to understand at the same time:

import numpy as np

@staticmethod
def arc_coordinates(_radius, length_of_arc, scale_factor, x0, y0):
    """
    positive curvature is a right bend, negative curvature is a left bend
    scale_factor: used to scale the values for plotting them
    x0 and y0: values are displaced such that the plot is in the center of the screen.
    """
    radius = np.array(_radius)
    delta_phi = - length_of_arc / radius
    phi = np.cumsum(delta_phi)
    dx = - radius * (np.cos(delta_phi) - 1)
    dy = - radius * np.sin(delta_phi)
    track_coordinates = np.vstack([dx, dy]).T
    track_coordinates[1:, 0] = np.cos(phi[1:]) * dx[1:] - np.sin(phi[1:]) * dy[1:]
    track_coordinates[1:, 1] = np.sin(phi[1:]) * dx[1:] + np.cos(phi[1:]) * dy[1:]
    track_coordinates = scale_factor * np.cumsum(track_coordinates, axis=0) + np.array([[y0, x0]])
    track_coordinates = np.concatenate([np.array([y0, x0]), track_coordinates.flatten()[:-2]])
    return track_coordinates


This gives the same results as your code. Note that it (just like your code) uses the weird convention that the output array is flat, alternating between x and y values, starting with a y-value.

On my machine this is not actually faster than your implementation, though:

%timeit arc_coordinates(radius, 1, 1, 0, 0)
39.4 µs ± 849 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit calculate_coordinates_from_length_of_arc_and_radius(radius, 1, 1, 0, 0)
21.5 µs ± 457 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)


However, this probably has a few possibilities for improvement left (WIP).

I also renamed your function to a (hopefully) also clear but shorter name as well as the initial displacements. I also made your comment detailing the parameters a docstring.