The syntax a if b else c is a ternary operator in Python that evaluates to a if the condition b is true - otherwise, it evaluates to c. It can be used in comprehension statements:

>>> [a if a else 2 for a in [0,1,0,3]]
[2, 1, 2, 3]

So for your example,

table = ''.join(chr(index) if index in ords_to_keep else replace_with
                for index in xrange(15))

• If you mean to write list comprehension you missed [, ]:
• There is no is not in operator. Use not in.
• type function does not return string. Why not use isinstance(item, int)?

[lst.append(dict2obj(item)) if not isinstance(item, int) else lst.append(item)
 for item in v]

Use simple for loop if possible. It's more readable.

for item in v:
    if not isinstance(item, int)
        lst.append(dict2obj(item))
    else:
        lst.append(item)

Your "practical example" is written as:

>>> strList = ['Ulis', 'Tolus', 'Utah', 'Ralf', 'Chair']
>>> sum(1 for el in strList if el.startswith('U'))
2

Your other example (if I understand correctly) is:

>>> list1 = [4, 6, 7, 3, 4, 5, 3, 4]
>>> list1.count(4)
3

(or just adapt the strList example, but nothing wrong with using builtin methods)

You don't need any conditional expression^* here, as str.split() always returns a list, even if only containing one word:

lst[:] = [word for words in lst for word in words.split()]

Demo:

>>> lst = ['word','word','multiple words','word']
>>> [word for words in lst for word in words.split()]
['word', 'word', 'multiple', 'words', 'word']

The conditional expression can be used wherever you could use a simple expression in the syntax; that means anywhere it says expression or old_expression in the list display grammar:

list_display        ::=  "[" [expression_list | list_comprehension] "]"
list_comprehension  ::=  expression list_for
list_for            ::=  "for" target_list "in" old_expression_list [list_iter]
old_expression_list ::=  old_expression [("," old_expression)+ [","]]
old_expression      ::=  or_test | old_lambda_expr
list_iter           ::=  list_for | list_if
list_if             ::=  "if" old_expression [list_iter]

So the first part of a list comprehension, but also the part that produces the outermost iterator (evaluated once), the if expressions, or any of the nested iterators (evaluated each iteration of the next outer for loop).

^{*It's called the conditional expression; it is a ternary operator, but so is the SQL BETWEEN operator.}

There is absolutely no use to list comprehensions if you do not care about the result. Just write it as a regular for loop:

for prod in givenProductions:
    for ch in prod:
        if ch >= 'a' and ch <= 'z':
            terminals.append(ch)
        elif ch != '-':
            nonTerminals.append(ch)

Note that the order of the two for loops is changed! If you really want to use a list comprehension, you must do the same. There is no need for print, just finish the ternary with None (which print() produces anyway). Also, square brackets ([]) are required for a list comprehension:

>>> givenProductions = ['S-AA', 'A-a', 'A-b']
>>> terminals, nonTerminals = [], []
>>> [terminals.append(ch) if (ch >= 'a' and ch <= 'z') else nonTerminals.append(ch) if (ch != '-') else None for prod in givenProductions for ch in prod]
>>> terminals, nonTerminals
>>> print(terminals, nonTerminals)
['a', 'b'] ['S', 'A', 'A', 'A', 'A']

Note that this creates and throws away a list of None elements. Using a set comprehension ({}) is more memory efficient, but less CPU efficient.

>>> waste = {terminals.append(ch) if (ch >= 'a' and ch <= 'z') else nonTerminals.append(ch) if (ch != '-') else None for prod in givenProductions for ch in prod}
>>> print(waste)
{None}