Utwórz schemat blokowy w Python | API Python do tworzenia schematów blokowych

Schemat blokowy to wizualna ilustracja procesu. Wykorzystuje zestaw symboli, np. ramki, romby i strzałki, aby zademonstrować wymagane kroki i decyzje, które należy podjąć na każdym etapie.

W tym artykule omówiono następujące tematy:

API Python do tworzenia schematów blokowych

Aspose.Diagram for Python to biblioteka, która umożliwia programistom tworzenie, edytowanie i manipulowanie plikami Visio bezpośrednio w aplikacjach Python. Zapewnia zestaw interfejsów API do pracy z plikami Visio. Wykorzystamy go do programowego stworzenia schematu blokowego w Python.

Proszę pobierz pakiet lub zainstaluj API z PyPI, używając następującego polecenia pip w konsoli:

pip install aspose-diagram-python

Utwórz schemat blokowy programowo w Python

Możemy łatwo utworzyć schemat blokowy w Python, wykonując poniższe kroki:

  1. Utwórz schemat diagramu.
  2. Załaduj wzorzec dodawania kształtów przy użyciu klasy Diagram.
  3. Twórz kształty za pomocą klasy Shape.
  4. Dodaj kształty do diagramu za pomocą metody addshape().
  5. Dodaj łączniki kształtów za pomocą metody connectshapesviaconnector().
  6. Ustaw układ diagramu przy użyciu klasy LayoutOptions.
  7. Następnie określ opcje zapisywania przy użyciu klasy DiagramSaveOptions.
  8. Na koniec zapisz plik wyjściowy w formacie VSDX, używając metody save().

Poniższy przykładowy kod pokazuje, jak utworzyć diagram schematu blokowego w języku Python.

# Ten przykładowy kod demonstruje, jak utworzyć schemat blokowy w języku Python.
import aspose.diagram
from aspose.diagram import *

def createFlowChart():
    # schemat diagramu, który ma zostać utworzony
    diagram_object = Input(
        input_rectangles=[
            InputRectangle("A", "Manager"),
            InputRectangle("B", "Team Leader"),
            InputRectangle("C", "Team Member"),
            InputRectangle("D", "Team Member"),
            InputRectangle("E", "Team Member")
        ],
        input_connectors=[
            InputConnector("A", "B"),
            InputConnector("B", "C"),
            InputConnector("B", "D"),
            InputConnector("B", "E")
        ]
    )

    diagram = Diagram("D:\\Files\\BasicShapes.vss")
    page = diagram.pages[0]

    shape_names = {}

    # Dodawanie kształtów i łączników ze schematu
   for rectangle in diagram_object.InputRectangles:
        shape = Shape()
        shape_id = diagram.add_shape(shape, "Rectangle", 0)
        shape_names[rectangle.Name] = shape_id
        shape = page.shapes.get_shape(shape_id)
        shape.text.value.add(Txt(rectangle.Text))

   for connector in diagram_object.InputConnectors:
        connector_id = diagram.add_shape(Shape(), "Dynamic connector", 0)
        page.connect_shapes_via_connector(
            shape_names[connector.OriginShapeName],
            aspose.diagram.manipulation.ConnectionPointPlace.RIGHT,
            shape_names[connector.DestinationShapeName],
            aspose.diagram.manipulation.ConnectionPointPlace.LEFT,
            connector_id
        )

    layout_options = aspose.diagram.autolayout.LayoutOptions()
    layout_options.layout_style = aspose.diagram.autolayout.LayoutStyle.FLOW_CHART
    layout_options.direction = aspose.diagram.autolayout.LayoutDirection.LEFT_TO_RIGHT
    layout_options.space_shapes = 5.0
    layout_options.enlarge_page = True
    

    diagram.layout(layout_options)

    page.page_sheet.print_props.print_page_orientation.value = PrintPageOrientationValue.LANDSCAPE

    save_options = aspose.diagram.saving.DiagramSaveOptions()
    save_options.save_format = SaveFileFormat.VSDX
    save_options.auto_fit_page_to_drawing_content = True

    diagram.save("D:\\Files\\flowchart_output.vsdx", save_options)
        
class Input:
    def __init__(self, input_rectangles=None, input_connectors=None):
        self.InputRectangles = input_rectangles if input_rectangles else []
        self.InputConnectors = input_connectors if input_connectors else []

class InputRectangle:
    def __init__(self, name, text):
        self.Name = name
        self.Text = text

class InputConnector:
    def __init__(self, origin_shape_name, destination_shape_name):
        self.OriginShapeName = origin_shape_name
        self.DestinationShapeName = destination_shape_name
        
createFlowChart()
Utwórz schemat blokowy programowo w Python.

Uzyskaj bezpłatną licencję API

Możesz [uzyskać bezpłatną licencję tymczasową], aby móc korzystać z API bez ograniczeń ewaluacyjnych.

Schemat blokowy programowania w języku Python — bezpłatne zasoby

Możesz dowiedzieć się więcej na temat schematu blokowego programowania w języku Python i poznać różne inne funkcje biblioteki, korzystając z poniższych zasobów:

Wniosek

W tym artykule dowiedziałeś się, jak programowo utworzyć schemat blokowy w Python. Wykorzystując Aspose.Diagram for Python, możesz tworzyć różne typy schematów blokowych przy użyciu różnych typów kształtów, takich jak decyzja lub proces, a także różnych układów, takich jak od lewej do prawej lub od prawej do lewej itp. W przypadku jakichkolwiek niejasności, skontaktuj się z nami na naszym bezpłatnym forum pomocy technicznej.

Zobacz też