💡 Enums (brief for enumerations) are a robust function in Python that permits for organizing a set of symbolic names (members) certain to distinctive, fixed values. Enums are a handy option to affiliate names with constants in a transparent and specific means.

Earlier than diving into the conversion strategies, let’s rapidly recap the Python enum module. On this instance, Coloration is an enumeration with three members: RED, GREEN, and BLUE, related to the values 1, 2, and three, respectively.

MINIMAL ENUM EXAMPLE: 👇

from enum import Enum

# Outline an enum named Coloration with a couple of members
class Coloration(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

# Accessing members and their values
Coloration.RED  # <Coloration.RED: 1>
Coloration.RED.title  # 'RED'
Coloration.RED.worth  # 1

However how can we convert these enums to extra widespread information sorts and again? Let’s begin with the primary:

Python Convert Enum to String – and Again

Changing an Enum to a string might be notably helpful for show functions or when the enumeration must be serialized right into a format that requires textual content (like JSON). The reverse course of is useful when parsing strings to acquire Enum values.

from enum import Enum

class Coloration(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

# Convert Enum to String
color_string = Coloration.RED.title

# Convert String to Enum
color_enum = Coloration[color_string]

print(color_string)  # Outputs: RED
print(color_enum)    # Outputs: Coloration.RED

Right here, Coloration.RED.title is used to transform an Enum member to a string. On the flip facet, Coloration[color_string] converts a string again to an Enum member. That is notably useful in configurations or environments the place solely strings are usable.

Python Convert Enum to Int – and Again

Generally, you may have to convert Enum members to integers for indexing, interfacing with C code, or easy arithmetic. Conversely, changing integers again to Enums is important for sustaining the encapsulation of Enum sorts.

# Convert Enum to Int
color_int = Coloration.RED.worth

# Convert Int to Enum
color_enum_from_int = Coloration(color_int)

print(color_int)                # Outputs: 1
print(color_enum_from_int)      # Outputs: Coloration.RED

On this snippet, Coloration.RED.worth provides the integer related to Coloration.RED. To transform this integer again to an Enum, we name Coloration(color_int).

Python Convert Enum to Record – and Again

Changing an Enum to an inventory is helpful when you want to carry out operations that require sequence information sorts like iterations, mapping, and so forth. The reversal doesn’t apply sometimes as you wouldn’t convert an inventory straight again into an Enum, however you can recreate the Enum if wanted.

# Convert Enum to Record
color_list = [c for c in Color]

print(color_list)  # Outputs: [<Color.RED: 1>, <Color.GREEN: 2>, <Color.BLUE: 3>]

This record comprehension iterates over the Enum class, changing it into an inventory of Enum members.

👉 Record Comprehension in Python — A Useful Illustrated Information

Python Convert Enum to Dict – and Again

When coping with Enum members in a dynamic method, changing it to a dictionary might be extremely helpful, particularly when the names and values are wanted straight.

# Convert Enum to Dict
color_dict = {coloration.title: coloration.worth for coloration in Coloration}

# Convert Dict to Enum
class ColorNew(Enum):
    cross

for title, worth in color_dict.objects():
    setattr(ColorNew, title, worth)

print(color_dict)       # Outputs: {'RED': 1, 'GREEN': 2, 'BLUE': 3}
print(ColorNew.RED)     # Outputs: ColorNew.RED

Right here, we first create a dictionary from the Enum, guaranteeing every title maps to its respective worth. To transform it again, we dynamically generate a brand new Enum class and assign values.

Python Convert Enum to JSON – and Again

Serialization of Enums into JSON is crucial for configurations and community communications the place light-weight information interchange codecs are used.

import json

# Convert Enum to JSON
color_json = json.dumps(color_dict)

# Convert JSON to Enum
color_info = json.masses(color_json)
color_enum_from_json = Coloration[color_info['RED']]

print(color_json)               # Outputs: '{"RED": 1, "GREEN": 2, "BLUE": 3}'
print(color_enum_from_json)     # Outputs: Coloration.RED

This instance reveals how you need to use a dictionary illustration to transform Enum members into JSON after which parse it again.

Python Convert Enum to Record of Strings – and Again

In some circumstances, an inventory of string representations of Enum members could also be required, resembling for populating dropdowns in GUI frameworks, or for information validation.

# Convert Enum to Record of Strings
color_str_list = [color.name for color in Color]

# Convert Record of Strings to Enum
color_enum_list = [Color[color] for coloration in color_str_list]

print(color_str_list)        # Outputs: ['RED', 'GREEN', 'BLUE']
print(color_enum_list)       # Outputs: [<Color.RED: 1>, <Color.GREEN: 2>, <Color.BLUE: 3>]

This simple comprehension permits for fast conversions to and from lists of string representations.

Python Convert Enum to Tuple – and Again

Tuples, being immutable, function an excellent information construction to carry Enum members when modifications usually are not required.

# Convert Enum to Tuple
color_tuple = tuple(Coloration)

# This showcases conversion however sometimes you will not convert again straight
# Nevertheless, Enum members might be extracted again from the tuple if wanted

print(color_tuple)  # Outputs: (Coloration.RED, Coloration.GREEN, Coloration.BLUE)

Whereas the reverse is rare, extracting particular Enum members from a tuple is simple.

Python Convert Enum to Literal – and Again

Python sort hints help literals which might be useful in conditions the place perform parameters are anticipated to be particular Enum members solely.

from typing import Literal

ColorLiteral = Literal[Color.RED.name, Color.GREEN.name, Color.BLUE.name]

# Instance perform utilizing this literal
def set_background_color(coloration: ColorLiteral):
    print(f"Setting background coloration to {coloration}")

set_background_color('RED')  # Appropriate utilization

# Conversion again is actually parsing the literal to the Enum
parsed_color = Coloration['RED']  # Works as anticipated

print(parsed_color)  # Outputs: Coloration.RED

Right here, Literal is a means to make sure type-checking for capabilities that ought to solely settle for particular Enum members in string type.

Python Convert Enum to Map – and Again

The map perform in Python can apply a perform over a sequence and is definitely demonstrated with Enums.

# Use map to transform Enum to a different type
mapped_values = record(map(lambda c: (c.title, c.worth), Coloration))

# Usually you will not convert a map end result again to Enum straight
# However you'll be able to reconstruct the Enum if wanted

print(mapped_values)  # Outputs: [('RED', 1), ('GREEN', 2), ('BLUE', 3)]

Mapping Enum values to a construction like tuple pairs can facilitate operations resembling sorting by both names or values.

Python Convert Enum to Record of Tuples – and Again

This conversion is helpful for creating listed constructions from Enums, helpful in situations the place a tuple-based lookup is required.

# Convert Enum to Record of Tuples
color_tuples_list = [(color.name, color.value) for color in Color]

# This could straight be used to reconstruct the Enum if wanted
class ReconstructedEnum(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

print(color_tuples_list)              # Outputs: [('RED', 1), ('GREEN', 2), ('BLUE', 3)]
print(ReconstructedEnum.RED)          # Outputs: ReconstructedEnum.RED

Although direct conversion again isn’t typical, reconstruction is an possibility right here.

Abstract of Strategies

• String: Convert with .title and restore with Enum[name].
• Integer: Use .worth and Enum(worth).
• Record: Immediately iterate over Enum.
• Dictionary: Comprehensions swimsuit effectively for conversions; Class redefinition helps in reverse.
• JSON: Make the most of dictionaries for intermediate conversions.
• Record of Strings: Enum names in an inventory simplify GUI use.
• Tuple: Direct use for immutable sequence necessities.
• Literal: Improve sort security.
• Map: Apply transformations with map.
• Record of Tuples: Best for tuple-based construction necessities.

Utilizing Python Enums successfully means understanding how one can rework them to and from differing kinds, broadening their usability throughout varied points of Python programming.

👉 Python Dictionary Comprehension: A Highly effective One-Liner Tutorial

Emily Rosemary Collins is a tech fanatic with a powerful background in laptop science, all the time staying up-to-date with the most recent developments and improvements. Other than her love for expertise, Emily enjoys exploring the nice outside, taking part in area people occasions, and dedicating her free time to portray and pictures. Her pursuits and fervour for private development make her an enticing conversationalist and a dependable supply of data within the ever-evolving world of expertise.