This is why implicit conversion of byte strings to Unicode strings was removed in Python 3.

You're almost there, with the #coding line at the start of your file. Just one tiny change to turn your test character into a Unicode string:

if u'⸣' not in myvariable:
    newvariable = 100.0

You might have trouble with that particular character as I did on my system, so you can use the equivalent escape sequence instead:

if u'\u2e23' not in myvariable:
    newvariable = 100.0

Since I'm using a variable now, how do I indicate the string represented by the variable is Unicode?

By defining it as a Unicode string in the first place.

zzz = u"foo"

Or, if you already have a string in some other encoding, by converting it to Unicode (the original encoding must be specified if the string is non-ASCII).

zzz = unicode(zzz, encoding="latin1")

Or by using Python 3 where all strings are Unicode.

for x in body:
    if ord(x) > 127:
        # character is *not* ASCII

This works if you have a Unicode string. If you just want to detect if the string contains a non-ASCII character it also works on a UTF-8 encoded byte string.

Update for Python 3: the above still works on Unicode strings, but ord no longer works for byte strings. But that's OK, because indexing into a byte string already returns an integer - no conversion necessary! The code becomes even simpler, especially if you combine it with the any function:

if any(x > 127 for x in body):
    # string is *not* ASCII

When you say "binary" I think you mean "Unicode code point". That is the numerical representation of a character.

Unicode code points can be represented in a python string literal by escaping the code point in your string. The 'heart' symbol is actually code point U+2665.

So you can write your string like this:

mystring = u'\u263aG18M1329D3920,2511171\u26657006'

Notice that I escaped the 'heart' by using \u followed by the code point 2665.

Armed with this knowledge, you can apply it to find()

mystring.find(u'\u2665')

edit: Python 2.7 requires the u prefix before the string literal.

I was hoping someone's done it before, but apparently not, so here's what I've ended up with. The module below (I call it unicodedata2) extends unicodedata and provides script_cat(chr) which returns a tuple (Script name, Category) for a unicode char. Example:

# coding=utf8
import unicodedata2
print unicodedata2.script_cat(u'Ф')  #('Cyrillic', 'L')
print unicodedata2.script_cat(u'の')  #('Hiragana', 'Lo')
print unicodedata2.script_cat(u'★')  #('Common', 'So')

The module: https://gist.github.com/2204527

In Python 3, all strings are sequences of Unicode characters. There is a bytes type that holds raw bytes.

In Python 2, a string may be of type str or of type unicode. You can tell which using code something like this:

def whatisthis(s):
    if isinstance(s, str):
        print "ordinary string"
    elif isinstance(s, unicode):
        print "unicode string"
    else:
        print "not a string"

This does not distinguish "Unicode or ASCII"; it only distinguishes Python types. A Unicode string may consist of purely characters in the ASCII range, and a bytestring may contain ASCII, encoded Unicode, or even non-textual data.

To include Unicode characters in your Python source code, you can use Unicode escape characters in the form \u0123 in your string. In Python 2.x, you also need to prefix the string literal with 'u'.

Here's an example running in the Python 2.x interactive console:

>>> print u'\u0420\u043e\u0441\u0441\u0438\u044f'
Россия

In Python 2, prefixing a string with 'u' declares them as Unicode-type variables, as described in the Python Unicode documentation.

In Python 3, the 'u' prefix is now optional:

>>> print('\u0420\u043e\u0441\u0441\u0438\u044f')
Россия

If running the above commands doesn't display the text correctly for you, perhaps your terminal isn't capable of displaying Unicode characters.

These examples use Unicode escapes (\u...), which allows you to print Unicode characters while keeping your source code as plain ASCII. This can help when working with the same source code on different systems. You can also use Unicode characters directly in your Python source code (e.g. print u'Россия' in Python 2), if you are confident all your systems handle Unicode files properly.

For information about reading Unicode data from a file, see this answer:

Character reading from file in Python

You'll want to use the unichr() builtin function:

for i in range(1000,1100):
    print i, unichr(i)

Note that in Python 3, just chr() will suffice.