In your final line to compute cost:

subtotal=(askSize + askBeverage + askFlav)

You do not sum the variables you defined at the top of your file (with costs), but you concatenate the strings that the user typed instead. For instance askSize can be the string "small". So, what you do here could be written as:

subtotal=("small" + "tee" + "lemon")

In Python, using + between strings will concatenate them. It means it will add the strings one after another to make a larger one. Example: "foo" + "bar" = "foobar".

If you want to refer to the cost of each option, one solution (but there are other ones) would be to use a dictionary to store costs instead of several variables as you did:

# Dictionary of costs
costs = {"tea": 1.50,
         "coffee": 1.50,
         "small": 0,
         "medium": 0.75,
         "large": 1.75,
         "mint": 0.50,
         "lemon": 0.25,
         "chocolate": 0.75,
         "vanilla": 0.25,
         "none": 0
         }

Then, to get the number corresponding to a string, you get items from the dictionary:

tea_cost = costs["tea"]  # tea_cost will be equal to 1.50
ask_size_cost = costs[askSize]  # ask_size_cost will be equal to the cost of the asked size

Now, it is easy to get your total cost:

total_cost = costs[askSize] + costs[askBeverage] + costs[askFlav]

Of course, take care of string cases, everything must be lowercase in my example.

Hope it helps !

NB: You can do many improvements to the rest of your code, do not hesitate to read some Python code on the internet to get it better.

You can do it just like similar to the Tuple Unpacking, like

a, b, c = '101'

Printing them will give you what you expect (in string format)

print(a, b, c, type(a))

Outputs:

1 0 1 <class 'str'>

Tell me if its not working...

I would suggest a recursive traversion of the tree:

a=[('bp', 46), ('sugar', 98), ('fruc', 56), ('mom',65)]
d = dict(a)
tree= [
    [
        'a',
        'bp',
        [78, 25, 453, 85, 96]
    ],
    [
        ['hi', ['no', ['ho', 'sugar', 3]], ['not', 'he', 20]],
        [['$', 'fruc', 7185], 'might', 'old'],
        'bye'
    ],
    [
        ['not', ['<', 'mom', 385]],
        [
            ['in', 'Age', 78.5],
            [['not', ['and', 'bp', 206]], 'life', [['or', ['not', ['\\', 'bp', 5]], ['p', 'sugar', 10]], 'ordag',[['perhaps', ['deal', 'mom', 79]],
            'helloo',[['or', ['pl', 'mom', 25]], 'come', 'go']]]],
            'noway'
        ],
        [['<', 'bp', 45], 'falseans', 'bye']
    ]
]



def replace(node):
    if isinstance(node, str):
        return d.get(node, node)
    elif isinstance(node, list):
        return [replace(el) for el in node]
    else:
        return node

replace(tree)

Strings are immutable. That means you can't assign to them at all. You could use formatting:

>>> s = 'abc{0}efg'.format('d')
>>> s
'abcdefg'

Or concatenation:

>>> s = 'abc' + 'd' + 'efg'
>>> s
'abcdefg'

Or replacement (thanks Odomontois for reminding me):

>>> s = 'abc0efg'
>>> s.replace('0', 'd')
'abcdefg'

But keep in mind that all of these methods create copies of the string, rather than modifying it in-place. If you want in-place modification, you could use a bytearray -- though that will only work for plain ascii strings, as alexis points out.

>>> b = bytearray('abc0efg')
>>> b[3] = 'd'
>>> b
bytearray(b'abcdefg')

Or you could create a list of characters and manipulate that. This is probably the most efficient and correct way to do frequent, large-scale string manipulation:

>>> l = list('abc0efg')
>>> l[3] = 'd'
>>> l
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> ''.join(l)
'abcdefg'

And consider the re module for more complex operations.

String formatting and list manipulation are the two methods that are most likely to be correct and efficient IMO -- string formatting when only a few insertions are required, and list manipulation when you need to frequently update your string.

You can use exec for that:

>>> foo = "bar"
>>> exec(foo + " = 'something else'")
>>> print bar
something else
>>>