Führen Sie Python YOLOv3 in C ++ unter Visual Studio 2017 aus

Hintergrund

Im vorherigen Artikel habe ich zusammengefasst, wie eine Umgebung zum Ausführen von Python-Code in C ++ erstellt wird. Führen Sie Python in C ++ unter Visual Studio 2017 aus Ich glaube nicht, dass Sie verstehen können, danke, dass Sie Python in C ++ allein aus diesem Artikel heraus aufgerufen haben. Daher möchte ich YOLO v3 ausführen, das Objekte durch tiefes Lernen erkennen kann. Sie können das Deep-Learning-Modell in C ++ verwenden, es ist jedoch nicht so gut wie das aktuelle Python (Weinen).

Entwicklungsumgebung

・ Betriebssystem: windos10 64bit -CPU: Intel i3-8100 ・ GPU: NVIDIA GeForce GTX 1050 Ti ・ Visual Studio 2017 ・ C ++ ・ Python 3.7.3 Vorheriger Artikel hat höhere Spezifikationen als die Umgebung ().

Verfahren

Die folgenden zwei Umgebungskonstruktionen sind als Voraussetzungen erforderlich. Wir werden an jeder Konstruktion arbeiten, nachdem sie fertiggestellt ist.

Ich möchte mit dem folgenden Ablauf fortfahren. Wenn Sie möchten, schließen Sie sich uns bitte an. Diejenigen, die aus früheren Artikeln stammen, können einige der Schritte überspringen.

Extrahieren Sie die Git-Datei direkt unter dem Laufwerk C.

Ich möchte die Datei direkt unter dem Laufwerk C extrahieren.

URL


git clone https://github.com/yusa0827/200121_Cplus2_with_Python

Die Methode ist 2.

  1. Wenn Sie git clone verwenden können, erstellen Sie einen beliebigen Ordner direkt unter dem Laufwerk C und git clone ihn.
  2. Wenn Sie den Git-Klon nicht verwenden können, springen Sie zur obigen URL, laden Sie sie herunter und platzieren Sie sie direkt unter dem Laufwerk C.

図1.png

Starten Sie .sln in der Datei in Visual Studio 2017

Wenn Sie sich den Inhalt des DL-Ordners ansehen, finden Sie eine SLN-Datei. Weil das Beispielprogramm in .sln enthalten ist Doppelklicken Sie hier oder Rechtsklick ⇒ Aus Programm öffnen ⇒ Klicken Sie auf Microsoft Visual Studio 2017 Anschließend können Sie das Beispielprogramm in Visual Studio starten. Dieses Programm wurde mit ver2017 erstellt. Ich denke, es kann im Jahr 2019 verwendet werden, aber innerhalb von 2019 Ich muss es auf die Version 2017 fallen lassen.

図3.png

Festlegen des Umgebungspfads des Beispielprogramms

Sie müssen den Umgebungspfad ändern.

1.Lösungskonfiguration und Lösungsplattform
Von Debug zu Release geändert
x86 → x64

2. C++→ Allgemein → Zusätzliches Include
C:\boost_1_70_0
C:\Users\○○\AppData\Local\Programs\Python\Python37\include 
↑ Korrektur erforderlich

3. C++→ Codegenerierung → Mit Laufzeitbibliothek
Multi Thread(/Wechsel zu MT)

4.Linker → Allgemein → Zusätzliches Bibliotheksverzeichnis
C:\boost_1_70_0\stage\lib\x64
C:\Users\○○\AppData\Local\Programs\Python\Python37\libs
↑ Korrektur erforderlich

Führen Sie das Beispielprogramm aus

Das Ausführungsergebnis ist wie folgt. 図4.png

Wenn dies nicht funktioniert, überprüfen Sie Ihren Umgebungspfad.

Vorbereitung für YOLO v3

YOLOv3 ist eine Objekterkennungsmethode, die Deep Learning verwendet und sich durch eine hervorragende Echtzeitleistung auszeichnet. Dieses Mal werden wir die häufig verwendete Keras-Version verwenden. Viele Leute lehren, wie man es benutzt. Wenn Sie es also googeln, wird es ein Schuss sein, aber ich werde es beschreiben.

Installation der Keras-Version von yolov3

URL


git clone https://github.com/qqwweee/keras-yolo3.git

Gehen Sie in dieses Verzeichnis. (Cd keras-yolov3) Erforderliche Module für Python sind Tensorflow, Keras, Matplotlib, Pillow und opencv (installiert mit opencv-python). Wenn Sie es noch nicht auf Python installiert haben, installieren Sie es bitte mit pip.

Gelernte Dateien herunterladen

Sie können DL auch direkt von der folgenden URL aus verwenden, ohne wget zu verwenden. Legen Sie es nach dem Herunterladen im Ordner keras-yolo3 ab. Dateiname: yolov3.weights Größe: 237 MB

URL


wget https://pjreddie.com/media/files/yolov3.weights

Konvertieren Sie trainierte Dateien

Wechseln Sie zur Keras-Version. Geben Sie den folgenden Code an der Eingabeaufforderung ein.

python convert.py yolov3.cfg yolov3.weights model_data/yolo.h5

Das Ausführungsergebnis ist wie folgt.

:
:
conv2d_75 (Conv2D)              (None, None, None, 2 65535       leaky_re_lu_72[0][0]
==================================================================================================
Total params: 62,001,757
Trainable params: 61,949,149
Non-trainable params: 52,608
__________________________________________________________________________________________________
None
Saved Keras model to model_data/yolo.h5
Read 62001757 of 62001757.0 from Darknet weights.

C:\demo_Cplus2_Py_YOLOv3\keras-yolo3>

Echtzeit-Objekterkennung mit einer Webkamera

Dieses Mal werden wir eine Webkamera verwenden. Sie können ein Video anstelle einer Kamera verwenden, aber ich habe dies gewählt, weil die Kamera leichter zu überprüfen war.

Bearbeiten Sie einfach yolo.py, den Hauptcode für die Objekterkennung. Es ist um die 173. Linie.

yolo.py


    import cv2
    vid = cv2.VideoCapture(video_path)
    
    #↓ Unten korrigiert

    import cv2
    #vid = cv2.VideoCapture(video_path)
    vid = cv2.VideoCapture(0)

Wenn Sie dem Argument von VideoCapture 0 geben, haben Sie das Kameragerät ausgewählt. Bearbeiten Sie den Code und führen Sie YOLO V3 aus.

Ausführung von YOLO v3 und seinen Ergebnissen

Ausführungscode.

cmd


python yolo_video.py

Ausführungsergebnis. Doraemon scheint ein Sportball zu sein. 図5.png

Ich konnte bestätigen, ob YOLO v3 funktioniert. Als nächstes werde ich den Pyhton-Code in C ++ ziehen.

YOLO v3 mit C ++ ziehen

Um YOLOv3 von C ++ aus aufzurufen, müssen wir einige Dinge entwickeln. Eine davon besteht darin, das aus der YOLO-Klasse in C ++ generierte Objekt zu definieren. Normalerweise sollte die Objekterkennung in Python erfolgen. Wenn Sie jedoch kein Objekt erstellen, müssen Sie Tensoflow jedes Mal aufrufen, wenn Sie ein Objekt erkennen, was zu einer großen Verzögerung führt. Auf meinem PC dauert es ungefähr 15 Sekunden, um Tensorflow zu starten. Daher ist es durch vorheriges Erstellen eines YOLO-Objekts möglich, jeden Aufruf zu verhindern.

Ändern Sie die vorhandene Datei yolo.py.

Programminhalt

Erkennen Sie Objekte mit einer Webkamera.

  1. Rufen Sie Python in C ++ auf
  2. Fügen Sie das von der Webkamera erhaltene Bild in den Deep-Learning-Objektdetektor YOLO v3 ein
  3. Suchen Sie die Mittelachse des erkannten Objekts auf der horizontalen Achse (x-Achse) und geben Sie sie an C ++ zurück
  4. Geben Sie die von Python zurückgegebene Mittelachse in C ++ aus Wenn Sie keine Webkamera haben, können Sie in yolo.py cv2.VideoCapture ("Videopfad") angeben.

Dateiorganisation

Bereiten Sie die git-geklonte visul stusio-Datei und die keras-yolo3-Datei vor. Kopieren Sie nur die für die Objekterkennung erforderlichen keras-yolo3-Dateien in die visul stusio-Datei. Die Konfiguration ist wie folgt. Ändern Sie die mit einem Kreis markierten Dateien. Außerdem wurden die für YOLO v3 erforderlichen Dateien direkt unter dem Laufwerk C abgelegt.

C-Laufwerk ── Modell_data
       │  ├── yolo.h5 ← keras-yolo3 Modell_Existiert im Datenordner
       │  ├── yolo_anchors.txt ← keras-yolo3 Modell_Existiert im Datenordner
       │  ├── coco_classes.txt ← keras-yolo3 Modell_Existiert im Datenordner
       │  └── FiraMono-Medium.otf ← keras-Existiert im Font-Ordner von yolo3
       │  
       └─ 200121_Cplus2_with_Python
          ├── test_Cplus2_with_Python
          │  ├── test_Cplus2_with_Python.cpp 〇
          │  ├── x64
          │  └── others
          ├── x64
          │  └── Release
          │       ├── test_Cplus2_with_Python.exe
          │       ├── yolo3 ← keras-Existiert im Ordner yolo3
          │       ├── yolo.py 〇 ← keras-Existiert im Ordner yolo3
          │       └── others
          ├── (others( .git .vs))
          └── test_Cplus2_with_Python.sln

Hauptcode-Fix

Die Dateistruktur besteht aus zwei Kreisen. Dies ist der Hauptcodeteil von C ++ bzw. Python. Ändern Sie sie wie folgt.

C ++ - Hauptcode

Ich habe einige Korrekturen am vorherigen Artikel vorgenommen. Es definiert Python-Py-Dateien, Py-Datei-Funktionen, Objekte usw. Grundsätzlich ist es ein Auto-Typ und C ++ entscheidet. Vor dem Drehen mit while wird das YOLO-Objekt im Voraus definiert. Führen Sie währenddessen nur die Objekterkennungsfunktion von Pytohn aus. Wenn Sie eine andere Originalverarbeitung hinzufügen möchten, geben Sie den Code an einer geeigneten Stelle ein.

test_Cplus2_with_Python.cpp


#define BOOST_PYTHON_STATIC_LIB
#define BOOST_NUMPY_STATIC_LIB

#include <iostream>
#include <boost/python.hpp>

//Namespace definieren
namespace py = boost::python;

/*YOLO v3 C.++Laufen Sie weiter*/
int main()
{	
	//Python initialisieren
	Py_Initialize();
	//YOLO v3 py Datei(yolo.py)Importieren
	py::object YOLOv3 = py::import("yolo").attr("__dict__");
	//yolo.In py"object_YOLOv3"Funktion definieren
	auto object_YOLOv3 = YOLOv3["object_YOLOv3"];
	//object_Definieren Sie Objektvariablen in der YOLOv3-Funktion
	py::object object_YOLOv3_init;
	//object_Objektvariablen in der YOLOv3-Funktion initialisieren
	auto object_YOLOv3_maker = object_YOLOv3(object_YOLOv3_init);
	//Definieren Sie eine Funktion zur Objekterkennung
	auto insert_object_YOLOv3 = YOLOv3["insert_object_YOLOv3"];
	//Beobachteter Wert
	double py_y;
	
	/*Echtzeit-Objekterkennung durch YOLO v3*/
	while (true) {

		//X-Achsen-Verschiebung des Zentrums, die vom Objekt durch tiefes Lernen erfasst wird
		auto x_centor = insert_object_YOLOv3(object_YOLOv3_maker);
		//Verschiebung C.++In einen Typ konvertieren, der in verwendet werden kann
		py_y = py::extract<double>(x_centor);

		/*
Wenn Sie andere Dinge verarbeiten möchten, beschreiben Sie diese entsprechend
		*/

		//Kommentar
		std::cout << "py_y = " << py_y << std::endl;

	}
}

Python-Hauptcode

Um das Bild von der Webkamera abzurufen, wird das Objekt, das die Webkamera geöffnet hat, in der Initialisierung (init) der YOLO-Klasse definiert. Außerdem wird der Mittelpunkt der horizontalen Achse, die das Objekt erkannt hat, berechnet und zurückgegeben. Zusätzlich werden "1_Funktion zum Initialisieren von Objekten" und "2_Funktion zum Erkennen von Objekten" neu hinzugefügt.

yolo.py


# -*- coding: utf-8 -*-
"""
Class definition of YOLO_v3 style detection model on image and video
"""
import colorsys
import os
from timeit import default_timer as timer
import numpy as np
from keras import backend as K
from keras.models import load_model
from keras.layers import Input
from PIL import Image, ImageFont, ImageDraw
from yolo3.model import yolo_eval, yolo_body, tiny_yolo_body
from yolo3.utils import letterbox_image
import os
from keras.utils import multi_gpu_model

#hinzufügen
import cv2
#Hinzugefügt: Einschränkung der GPU-Speichernutzung von TensorFlow
import tensorflow as tf
from keras.backend.tensorflow_backend import set_session
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.3
set_session(tf.Session(config=config))
#Globale Variablendefinition hinzufügen
model_path_ = 'C:/model_data/yolo.h5'
anchors_path_ = 'C:/model_data/yolo_anchors.txt'
classes_path_ = 'C:/model_data/coco_classes.txt'
font_path_ = 'C:/model_data/FiraMono-Medium.otf'

class YOLO(object):
    _defaults = {
        "model_path": model_path_,#Wechselpunkt
        "anchors_path": anchors_path_,#Wechselpunkt
        "classes_path": classes_path_,#Wechselpunkt
        "score" : 0.3,
        "iou" : 0.45,
        "model_image_size" : (416, 416),
        "gpu_num" : 1,
    }

    @classmethod
    def get_defaults(cls, n):
        if n in cls._defaults:
            return cls._defaults[n]
        else:
            return "Unrecognized attribute name '" + n + "'"

    def __init__(self, **kwargs):
        self.__dict__.update(self._defaults) # set up default values
        self.__dict__.update(kwargs) # and update with user overrides
        self.class_names = self._get_class()
        self.anchors = self._get_anchors()
        self.sess = K.get_session()
        self.boxes, self.scores, self.classes = self.generate()
        #Kamera offen hinzugefügt
        self.cap = cv2.VideoCapture(0)

    def _get_class(self):
        classes_path = os.path.expanduser(self.classes_path)
        with open(classes_path) as f:
            class_names = f.readlines()
        class_names = [c.strip() for c in class_names]
        return class_names

    def _get_anchors(self):
        anchors_path = os.path.expanduser(self.anchors_path)
        with open(anchors_path) as f:
            anchors = f.readline()
        anchors = [float(x) for x in anchors.split(',')]
        return np.array(anchors).reshape(-1, 2)

    def generate(self):
        model_path = os.path.expanduser(self.model_path)
        assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'

        # Load model, or construct model and load weights.
        num_anchors = len(self.anchors)
        num_classes = len(self.class_names)
        is_tiny_version = num_anchors==6 # default setting
        try:
            self.yolo_model = load_model(model_path, compile=False)
        except:
            self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
                if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
            self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
        else:
            assert self.yolo_model.layers[-1].output_shape[-1] == \
                num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
                'Mismatch between model and given anchor and class sizes'

        print('{} model, anchors, and classes loaded.'.format(model_path))

        # Generate colors for drawing bounding boxes.
        hsv_tuples = [(x / len(self.class_names), 1., 1.)
                      for x in range(len(self.class_names))]
        self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
        self.colors = list(
            map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
                self.colors))
        np.random.seed(10101)  # Fixed seed for consistent colors across runs.
        np.random.shuffle(self.colors)  # Shuffle colors to decorrelate adjacent classes.
        np.random.seed(None)  # Reset seed to default.

        # Generate output tensor targets for filtered bounding boxes.
        self.input_image_shape = K.placeholder(shape=(2, ))
        if self.gpu_num>=2:
            self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
        boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
                len(self.class_names), self.input_image_shape,
                score_threshold=self.score, iou_threshold=self.iou)
        return boxes, scores, classes

    #Korrektur C.++Korrektur der Objekterkennungsposition für
    def detect_image_for_Cplus2(self, image):

        if self.model_image_size != (None, None):
            assert self.model_image_size[0]%32 == 0, 'Multiples of 32 required'
            assert self.model_image_size[1]%32 == 0, 'Multiples of 32 required'
            boxed_image = letterbox_image(image, tuple(reversed(self.model_image_size)))
        else:
            new_image_size = (image.width - (image.width % 32),
                              image.height - (image.height % 32))
            boxed_image = letterbox_image(image, new_image_size)
        image_data = np.array(boxed_image, dtype='float32')

        image_data /= 255.
        image_data = np.expand_dims(image_data, 0)  # Add batch dimension.

        out_boxes, out_scores, out_classes = self.sess.run(
            [self.boxes, self.scores, self.classes],
            feed_dict={
                self.yolo_model.input: image_data,
                self.input_image_shape: [image.size[1], image.size[0]],
                K.learning_phase(): 0
            })
        
        font = ImageFont.truetype(font=font_path_,
                    size=np.floor(3e-2 * image.size[1] + 0.5).astype('int32'))
        thickness = (image.size[0] + image.size[1]) // 300

        #X Verschiebung des Objekts
        self.x_centor = .0

        for i, c in reversed(list(enumerate(out_classes))):           
                       
            predicted_class = self.class_names[c]
            box = out_boxes[i]
            score = out_scores[i]

            label = '{} {:.2f}'.format(predicted_class, score)
            draw = ImageDraw.Draw(image)
            label_size = draw.textsize(label, font)

            #Hier gibt es eine Position des Schwerpunkts
            top, left, bottom, right = box
            top = max(0, np.floor(top + 0.5).astype('int32'))
            left = max(0, np.floor(left + 0.5).astype('int32'))
            bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))
            right = min(image.size[0], np.floor(right + 0.5).astype('int32'))
            print(label, (left, top), (right, bottom))

            #x-Achse Schwerpunkt x_centor = ( x1 + x2 ) / 2
            self.x_centor = ( left + right ) / 2.

            if top - label_size[1] >= 0:
                text_origin = np.array([left, top - label_size[1]])
            else:
                text_origin = np.array([left, top + 1])

            # My kingdom for a good redistributable image drawing library.
            for i in range(thickness):
                draw.rectangle(
                    [left + i, top + i, right - i, bottom - i],
                    outline=self.colors[c])
            draw.rectangle(
                [tuple(text_origin), tuple(text_origin + label_size)],
                fill=self.colors[c])
            draw.text(text_origin, label, fill=(0, 0, 0), font=font)
            del draw

        return image, self.x_centor

    def close_session(self):
        self.sess.close()

# 1_Funktion zum Initialisieren eines Objekts
def object_YOLOv3(object_YOLO):
    #Erstellen Sie ein Objekt aus einer Klasse
    object_YOLO = YOLO()
    #C++Gibt ein Yolo-Objekt an zurück
    return object_YOLO

# 2_Funktion zur Objekterkennung
def insert_object_YOLOv3(object_YOLO):    
    #Holen Sie sich ein Bild von der Kamera
    ret, frame = object_YOLO.cap.read()
    #Ändern Sie die Reihenfolge von RGGB
    frame = np.asarray(frame)[..., ::-1]
    #Wechseln Sie von opencv zu Kissen
    frame = Image.fromarray(frame)
    #Erkennt ein Objekt und gibt das Ausgabeergebnis und die Mitte der x-Achse des Objekts zurück
    r_image, x_centor = object_YOLO.detect_image_for_Cplus2(frame)
    #Bildschirm
    cv2.imshow("out",np.asarray(r_image)[..., ::-1])
    #1ms anzuzeigen
    cv2.waitKey(1)
    #C++Gibt den Mittelpunkt der x-Achse des Objekts zurück
    return x_centor

Ausführungsergebnis

Da es ein trainiertes Modell verwendet, wird es als Person usw. erkannt. ダウンロード.gif

Da es sich um ein Beispielprogramm handelt, können Sie das Originalmodell auch dann verwenden, wenn Sie den Pfad in der py-Datei ändern.

Verwenden Sie Anwendungen

Wann muss ich Python in C ++ aufrufen ... Ich denke, einige Leute sind besorgt. Der Grund ist -Wenn Sie wirklich Deep-Learning-Verarbeitung auf einem C ++ - kompatiblen Gerät (Motion Control Board usw.) integrieren möchten ・ Ein Lieblingsingenieur (fremde Person), der C ++ nicht verlassen kann ・ Wie auch immer, Verrückter Das ist alles für den Witz.

Kommentar

Wir hoffen aufrichtig, dass dies für diejenigen nützlich sein wird, die sich Sorgen über die Umweltabhängigkeit zwischen den Programmsprachen machen.

Recommended Posts

Führen Sie Python YOLOv3 in C ++ unter Visual Studio 2017 aus
Führen Sie Python in C ++ unter Visual Studio 2017 aus
Python-Entwicklung mit Visual Studio 2017
Python-Entwicklung mit Visual Studio
Führen Sie AzureKinect an Heiligabend in Python aus.
Bash, Python, Javascript, Codebefehl usw. in Visual Studio Code auf dem Mac
Weiter Python in C-Sprache
Hinweis zur Codierung bei LANG = C in Python
C-API in Python 3
Einstellungen für die Python-Codierung mit Visual Studio-Code
TensorFlow: Führen Sie in Python gelernte Daten unter Android aus
App-Entwicklung zum Twittern in Python aus Visual Studio 2017
Versuchen Sie, Python auf Raspberry Pi mit Visual Studio zu debuggen.
Führen Sie in Python geschriebenes CGI auf Sakuras Mietserver aus
Bis Sie Server Django mit Visual Studio Code ausführen
Japanische Ausgabe beim Umgang mit Python im Visual Studio
Entwicklung des AWS SDK für Python (Boto3) in Visual Studio 2017
Erweitern Sie Python in C ++ (Boost.NumPy)
Führen Sie Openpose unter Python (Windows) aus.
Installieren Sie numpy in Visual Studio 2019
Führen Sie Shell-Befehle in Python aus
Führen Sie Python unittest parallel aus
Führen Sie Tensorflow 2.x unter Python 3.7 aus
Binäre Suche in Python / C ++
Führen Sie Pythons CGI auf CORESERVER aus
Flaschenmops im Visual Studio 2019
Führen Sie den Unix-Befehl auf Python aus
So debuggen Sie eine Standard-Python-Bibliothek in Visual Studio
Machen Sie so etwas wie einen Python-Interpreter mit Visual Studio Code
Installieren Sie Python und Visual Studio Code unter Windows 10 (Version April 2020)
Erstellen Sie Python3 für Windows 10 unter ARM mit Visual Studio 2019 (x86) unter Windows 10 unter ARM
Lassen Sie uns "Python -m Antigravitation" in Python ausführen
ABC166 in Python A ~ C Problem
Führen Sie Python planmäßig auf AWS Lambda aus
Führen Sie das Docker-Image von TensorFlow unter Python3 aus
Löse ABC036 A ~ C mit Python
So verpacken Sie C in Python
Remote-Debugging in Visual Studio (Linux)
Führen Sie Python-Skripte synchron von C # aus
Führen Sie unittest in Python aus (für Anfänger)
Löse ABC037 A ~ C mit Python
Führen Sie einen einfachen Algorithmus in Python aus
Schreiben Sie einen C-Sprach-Unit-Test in Python
Rufen Sie C / C ++ von Python auf dem Mac auf
Führen Sie Python regelmäßig auf Heroku Scheduler aus
So installieren Sie OpenCV in Cloud9 und führen es in Python aus
Ein Hinweis für diejenigen, die Python in Visual Studio verwenden (ich)
Führen Sie Python in C ++ unter Visual Studio 2017 aus
Führen Sie Python YOLOv3 in C ++ unter Visual Studio 2017 aus
Versuchen Sie, Python auf Raspberry Pi mit Visual Studio zu debuggen.
Japanische Ausgabe beim Umgang mit Python im Visual Studio
Installation von Visual Studio Code und Installation von Python
Erstellen Sie Verknüpfungen, um Python-Dateien auf dem Terminal mit VScode auszuführen
Führen Sie das Servo mit Python unter ESP32 (Windows) aus.
So blenden Sie die Eingabeaufforderung aus, wenn Sie Python in Visual Studio 2015 ausführen
Suchen Sie nach Dateien wie Linux Find in Python
Anmerkung von nfc.ContactlessFrontend () von nfcpy von Python
Algorithmus in Python (ABC 146 C Dichotomie
Implementieren Sie den FIR-Filter in Python und C.
[Python] Führen Sie Flask in Google App Engine aus
Erstellen Sie eine Python-Entwicklungsumgebung unter Windows (Remote-WSL für Visual Studio Code).
[C] [Python] Lesen mit AquesTalk unter Linux
Schreiben Sie die O_SYNC-Datei in C und Python