Printing bowTie pattern in efficient and pythonic way
Don't use a class, there's no need.
You can remove the tmplst.append if you move the comprehensions into the th.append.

To do this you can use (i + idx) % 2 == 1 as the check. And tmplst = [xrange(1,row + 1), xrange(m, m-row, -1)].
It doesn't make sense to build a set, to then convert it to a list. Sets have \$O(1)\$ lookup where lists have \$O(n)\$.
You don't need get_list, just use a comprehension.


This can get something like:

def bow_tie(self, size=5, fill_value='*', empty_value=' '):
    star = fill_value
    dot = empty_value
    center_row = size * 2 - 1
    th = [
        {
            j
            for nums in (
                xrange(1, i + 2),
                xrange(center_row, center_row - i - 1, -1)
            )
            for j in nums
            if (j + i) % 2 == 1
        }
        for i in range(size)
    ]
    th += th[len(th) -2::-1]

    return [
        ' '.join([
            star if i in indexes else dot
            for i in range(1, size * 2)
        ])
        for indexes in th
    ]




However, this isn't that good an approach. Instead you can make a list containing the pattern. And show a 'view'. The view that you want could be:

     *
    **
   ***
  ****
 *****
******


To achieve this, you can make the following list:

'     ******'


With the following moving view:

#     *######
##    **#####
###   ***####
####  ****###
##### *****##
######******#


You can also invert the view to get the other side of the bow tie. And so using the above, we just need to think of what the pattern of the list needs to be for your bowtie.

Since it's pretty much the same as the above, but with a space in-between the dots you could use something like:

'     * * * '


And to create that, just make the first n chars space, with the following n chars flip between space and star:

face = [empty_value] * (size - 1) + [fill_value, empty_value] * (size // 2 + 1)


After this combine the above slider, and chain the top and bottom starts, and you should get:

from itertools import chain

def bow_tie(size=5, fill_value='*', empty_value=' '):
    face = [empty_value] * (size - 1) + [fill_value, empty_value] * (size // 2 + 1)
    starts = chain(range(size), reversed(range(size-1)))
    for i in starts:
        yield ' '.join(face[i:i+size][::-1][:-1] + face[i:i+size])