Alphabet Rangoli Challenge The question is about printing alphabets in a rangoli pattern of size/dimension input by the user.
Example:
size 3

----c----
--c-b-c--
c-b-a-b-c
--c-b-c--
----c----

The picture contains details about the challenge
OR
https://www.hackerrank.com/challenges/alphabet-rangoli/problem
Sample Code:
n = int(input('Enter a size: '))

alpha = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

for j in range(0, n-1):
    ls_1 = str(''.join(alpha[n-1:abs(n-(j+2)):-1]))
    ls_1 = ls_1 + ls_1[-2::-1]
    ls = str('-'.join(ls_1))
    print('-' * (((n - j) * 2) - 2) + ls + '-' * (((n - j) * 2) - 2))

ls_1 = str(''.join(alpha[n-1::-1]))
ls_1 = ls_1 + ls_1[-2::-1]
ls = str('-'.join(ls_1))
print(ls)

for j in range(n-2, -1, -1):
    ls_2 = str(''.join(alpha[n-1:abs(n-(j+2)):-1]))
    ls_2 = ls_2 + ls_2[-2::-1]
    ls_s = str('-'.join(ls_2))
    print('-' * (((n - j) * 2) - 2) + ls_s + '-' * (((n - j) * 2) - 2))

Sample Output:
Enter a size: 5
--------e--------
------e-d-e------
----e-d-c-d-e----
--e-d-c-b-c-d-e--
e-d-c-b-a-b-c-d-e
--e-d-c-b-c-d-e--
----e-d-c-d-e----
------e-d-e------
--------e--------

Is the above code that I have done...is it a good code to say?
Also, I couldn't find any other way to solve the problem.
(I am a beginner in Python)
Use built-ins
alpha = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

This is a very verbose and error-prone way of getting all of the ASCII lowercase letters.
from string import ascii_lowercase as alpha

will give approximately the same result.  It is a string, instead of a list, but Python strings are effectively just lists of characters.  In particular, alpha[0] will be 'a' and alpha[25] will be 'z'.
Unnecessary str()
The result of a ''.join(...) call will be a string.  Wrapping this in a str(...) call is pointless.
Unnecessary abs()
for j in range(0, n-1) means that j will always be less than n-1.  In other words:
$$ j \le n - 2 $$
Consider, abs(n-(j+2)):
$$ j \le n - 2$$
$$ j + 2 \le n$$
$$ n - (j+2) \ge 0$$
In other words, the abs(...) is unnecessary, and just adds confusion.
General Comments
Follow PEP-8 guidelines (spaces around operators, etc).  Use functions.  Use a main-guard.
Reworked &amp; Simplified Code
from string import ascii_lowercase

def print_rangoli(n: int) -&gt; None:

    alpha = ascii_lowercase[:n]

    for row in range(- n + 1, n):
        row = abs(row)
        dashes = &quot;-&quot; * (2 * row)
        print(dashes + &quot;-&quot;.join(alpha[:row:-1] + alpha[row:]) + dashes)

if __name__ == '__main__':
    n = int(input(&quot;Enter a size: &quot;))
    print_rangoli(n)
    

Format Specification Mini-Language
Python's format statement (and f-strings) use a format specification mini-language.  This allow you substitute values into a larger string in fixed-width fields, with your choice of alignment and fill characters.  Here, you'd want centre alignment, with '-' for the fill character.
For example, f&quot;{'Hello':-^11}&quot; is a f-string, which places the string 'Hello' into a field 11 characters wide, centre justified (^), with '-' used as a fill character.  Producing '---Hello---'.  Instead of a hard-coded width (11 in the above example), we can use a computed {width} argument.
Using this, we can further &quot;simplify&quot; (for some definition of simplify) the print_rangoli function:
def print_rangoli(n: int) -&gt; None:

    width = n * 4 - 3
    alpha = ascii_lowercase[:n]

    for row in range(- n + 1, n):
        row = abs(row)
        print(f&quot;{'-'.join(alpha[:row:-1] + alpha[row:]):-^{width}}&quot;)