Creating a Python namedtuple class that forces some of its fields to be floats
In order to reuse code (that is, namedtuple) it should be okay to use
this approach.  It might also make things harder in the long run, so it
could be easier to use a regular meta-/class or decorator to enforce this kind of
logic.  I also see a problem with automatic conversion of values, as
that needs to be communicated/debugged later on, but if it fits the use
case, why not.  Since the tuple is immutable there's no normal way to
circumvent this, so I guess it is less of an issue than with a mutable
class.

Also, have you looked at the collections.py source?  I mean it's good
that it works, but honestly that code generation is a bit scary.  It is, however, a way to generate all this stuff at runtime.  If you don't have to have separate Python classes you could also just use a single class and pass in the valid fields as a separate parameter, then use functions to create the separate tuple "types".

For the presented code / your questions I have some other suggestions:


You can override __repr__ to fix the "wrong" printed
representation.  I'm not quite sure exactly why it is kind of
hardcoded in collections.py, but generally I'd prefer things to
print their own class name instead, as written below.  The
formatting is copied from the standard namedtuple.
If it's happening once, that is not nice, but certainly not the
biggest issue.  Again, you could follow the code generation model
and pass it in as a parameter,
e.g. typednamedtuple('TypedNamedTuple', FIELDS_AND_TYPES).
Use izip to prevent allocating a new list.  Otherwise looks good?
I can't see how you would otherwise do the conversion.
Subclass and override the field?  Note the AnotherTypedNamedTuple
below.  Otherwise see above.


Also:


Don't assign to self.  That looks super wrong.


from collections import namedtuple, OrderedDict
from itertools import izip


# This list is built at runtime in my application
_FIELDS_AND_TYPES = [("num1", True), ("num2", True), ("label", False)]
FIELDS_FORCE_FLOAT = OrderedDict(_FIELDS_AND_TYPES)


_MyNamedTuple = namedtuple("_MyNamedTuple", FIELDS_FORCE_FLOAT.keys())
class TypedNamedTuple(_MyNamedTuple):
    fields_force_float = FIELDS_FORCE_FLOAT

    def __new__(cls, *values_in):
        super_obj = super(_MyNamedTuple, cls)
        superclass = super_obj.__thisclass__
        values = [float(value) if cls.fields_force_float[fieldname] else value
                  for fieldname, value in izip(superclass._fields, values_in)]
        return super_obj.__new__(cls, values)

    def __repr__(self):
        return "{}({})".format(
            self.__class__.__name__,
            ', '.join("{}=%r".format(name) for name in self._fields) % self)


print TypedNamedTuple("1.0", "2.0", "3.0")
# TypedNamedTuple(num1=1.0, num2=2.0, label='3.0')


class AnotherTypedNamedTuple(TypedNamedTuple):
    fields_force_float = OrderedDict([("num1", False), ("num2", False), ("label", False)])


print AnotherTypedNamedTuple("1.0", "2.0", "3.0")
# AnotherTypedNamedTuple(num1='1.0', num2='2.0', label='3.0')