Circular distribution of objects getting weird
Vectors Matrices and Shared Mesh.

FWIW have added an approach that will be a lot quicker, use one operator call, and create only a single mesh
A single operator call, creates the cylinder at the scale and applies the 90 degree rotation about Y to its mesh.
This object is then passed to our create array method with a center, radius, how many to create, and optionally the collection to link them to.  This way can create Suzanne's or any object to &quot;array&quot;.
As default it creates 40 about the point (1, 2, 0) with a radius of 1. To make same with question code would use 40 x 3 = 120 operator calls. See
Python performance with Blender operators
which can get horribly slow for a lot of copies.
The initial object is moved to the center point plus the radius in x.  A matrix is calculated that will rotate it an nth' of 360 degrees around z axis.
Matrix math to translate, rotate, scale with respect to a pivot point in Object mode
A copy is made, it shares the mesh of the original, and the alignment. The matrix is applied (multiplied) to its matrix world rotating it 360 / n degrees.  It is then copied and repeated until there is no more and we are back to first.
Duplicating a mesh object
import bpy
from mathutils import Matrix, Vector
from math import pi

context = bpy.context
scene = context.scene

def circular_array(
        ob, 
        n, 
        center, 
        radius, 
        revs=1, 
        matrix=Matrix(), 
        coll=bpy.context.scene.collection): 
    
    center = Vector(center)
    
    
    ob.matrix_world.translation = center
    ob.matrix_world.translation.x += radius
    angle = 2 * pi / n
    name = ob.name
    ob.name = f&quot;{name}_0&quot;

    M = matrix @ (
         
        Matrix.Translation(center) @        
        Matrix.Rotation(angle, 4, 'Z') @ 
        Matrix.Translation(-center)
        )
    for f in range(1, revs * n):
        ob = ob.copy()
        ob.name = f&quot;{name}_{f}&quot;
        ob.matrix_world = M @ ob.matrix_world
        coll.objects.link(ob)

# Test Call

# create our object to array       
bpy.ops.mesh.primitive_cylinder_add(
        location=(0, 0, 0),
        scale=(0.1, 0.1, 1),
        rotation=(0, pi / 2, 0),
        )

ob = context.object
ob.name = &quot;Tick&quot;
# array ob 40 times about (1, 2, 0) with radius 2)

circular_array(
        ob,  
        40,
        (1, 2, 0),
        1,
        )

Matrices
To further prattle on about matrices have put a matrix into the transform mix.
S = Matrix.Diagonal((1.01, 1, 1, 0.9))
R = Matrix.Rotation(28.6 * pi, 4, 'Y')


circular_array(
        ob,
        50,
        (1, 2, 0),
        1,
        matrix = R,
        revs = 10,        
        )


Bringing a scale matrix into the equation would have a spriral effect.