        values1 = vtkVariantArray()
        values2 = vtkVariantArray()
        str = "abcdefghijklmnopqrstuvwxyz"
        for i in range(lut1.GetNumberOfTableValues()):
            values1.InsertNextValue(vtkVariant(str[i]))
        for i in range(lut2.GetNumberOfTableValues()):
            values2.InsertNextValue(vtkVariant(str[i]))
--
        values = vtkVariantArray()
        str = "abcdefghijklmnopqrstuvwxyz"
        for i in range(lut3.GetNumberOfTableValues()):
            values.InsertNextValue(vtkVariant(str[i]))
        for i in range(values.GetNumberOfTuples()):
            lut3.SetAnnotation(i, values.GetValue(i).ToString())
--
v = vtkVariant()
print(f"Invalid variant: {repr(v)}, '{v.GetTypeAsString()}'")

# Copy constructor
v = vtkVariant(vtkVariant("variant"))
print(f"Copied variant: {repr(v)}, '{v.GetTypeAsString()}'")

# Conversion constructors
v = vtkVariant(1)
print(f"Integer variant: {repr(v)}, '{v.GetTypeAsString()}'")
v = vtkVariant(1.0)
print(f"Float variant: {repr(v)}, '{v.GetTypeAsString()}'")
v = vtkVariant("hello")
print(f"String variant: {repr(v)}, '{v.GetTypeAsString()}'")
v = vtkVariant(unicodeEtre)
print(f"Unicode variant: {repr(v)}, '{v.GetTypeAsString()}'")
v = vtkVariant(vtkStringArray())
print(f"Object variant: {repr(v)}, '{v.GetTypeAsString()}'")

# Explicit type constructor
v1 = vtkVariant(1, VTK_UNSIGNED_SHORT)
v2 = vtkVariant(2, v1.GetType())
print(f"UShort variant: {repr(v1)}, '{v1.GetTypeAsString()}'")

# Type checking
if v2.IsUnsignedShort():
    print("v2 is UnsignedShort")
--
a = vtkVariantArray()
a.InsertNextValue(vtkVariant())
a.InsertNextValue(1)
a.InsertNextValue(2.0)
a.InsertNextValue("hello")
a.InsertNextValue(unicodeEtre)
--
if v2 == vtkVariant(2):
    print("v2 is equal to 2")
if v2 > vtkVariant(1):
    print("v2 is greater than 1")
if v2 < vtkVariant(3):
    print("v2 is less than 3")
if v2 == vtkVariant("2"):
    print("v2 is equal to '2'")

# Use as a dict key (hashed as a string)
d = {vtkVariant(1): 0, vtkVariant('1'): 1, vtkVariant(): 3}
print("Index is %i" % d[vtkVariant(1.0)])

#
# Extra functionality from vtk.util.vtkVariant
#
--
v = vtkVariantCreate(1, 'unsigned int')

# Value extraction
v = vtkVariant(6.0)
f = vtkVariantExtract(v)

# Value extraction with type specified
f = vtkVariantExtract(v, 'double')

# Casting a variant
v = vtkVariant("10")
i = vtkVariantCast(v, 'int')
print(f"Valid cast result: {repr(i)}")

# A failed cast returns None
v = vtkVariant("hello")
i = vtkVariantCast(v, 'int')
print(f"Invalid cast result: {repr(i)}")

#
# Comparisons and sorting: See VTK docs for more info
#
--
v1 = vtkVariant(10)
v2 = vtkVariant("10")
r = vtkVariantStrictWeakOrder(v1, v2)
print("Strict weak order (10, '10') ->", r)

# Sorting by strict weak order, using a key function:
unsorted = [1, 2.5, vtkVariant(), "0", unicodeEtre]
l = [vtkVariant(x) for x in unsorted]
l.sort(key=vtkVariantStrictWeakOrderKey)
print("Sort by weak order ->", l)

# Check two variants for strict equality of type and value.
b = vtkVariantStrictEquality(v1, v2)
print(f"Strict equality (10, '10') -> {b}")

# Two special-purpose methods.
# First is identical to (v1 < v2)
b = vtkVariantLessThan(v1, v2)
# Second is identical to (v1 == v2)
b = vtkVariantEqual(v1, v2)
--
    values = vtkVariantArray()
    for i in range(len(labels)):
        values.InsertNextValue(vtkVariant(labels[i]))
    for i in range(values.GetNumberOfTuples()):
        lut.SetAnnotation(i, values.GetValue(i).ToString())

--
    values = vtkVariantArray()
    for i in range(len(labels)):
        values.InsertNextValue(vtkVariant(labels[i]))
    for i in range(values.GetNumberOfTuples()):
        lut.SetAnnotation(i, values.GetValue(i).ToString())

