通过print可以做到吗

通过print也可以输出调试信息，但是相比于logging模块，它的灵活度和可维护性较差。在实际开发中，建议使用logging模块来记录日志信息。

使用print输出调试信息的方式非常简单，可以在代码中添加一些print语句，在合适的位置打印相关信息。

例如，在上面的例子中，我们可以将日志记录改为print输出：

def my_func(x, y):
    print('Start my_func({}, {})'.format(x, y))
    z = x + y
    print('z = {}'.format(z))
    return z

result = my_func(2, 3)
print('Result = {}'.format(result))

这样，在函数运行时，就会在控制台输出相关的调试信息。但是，使用print输出调试信息有一些缺陷，比如：

1. 难以控制输出：使用print输出信息时，无法控制输出的格式、颜色等，也无法轻松地控制输出的位置和频率。

2. 不便于维护：如果需要删除或修改调试信息，必须手动修改代码中的print语句，不便于维护。

因此，在实际开发中，建议使用logging模块来记录日志信息，以便更好地定位问题所在。

相关问题

c语言应用程序可以做到吗，如果有给个示例

可以的，您可以使用C语言编写一个Android NDK应用程序，并在其中调用Java API来实现切换主屏幕和辅屏幕之间的控制。以下是一个示例程序，它可以检测红外遥控器的按键事件，并在按下不同的按键时切换主屏幕和辅屏幕之间的控制。

#include <jni.h>
#include <android/native_activity.h>
#include <android/native_window.h>
#include <android/native_window_jni.h>
#include <android/looper.h>
#include <android/log.h>
#include <android/configuration.h>
#include <android/rect.h>
#include <android/input.h>
#include <android/keycodes.h>
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>
#include <android/sensor.h>
#include <android/ir.h>

ANativeActivity* activity = NULL;
JNIEnv* env = NULL;
JavaVM* jvm = NULL;
jobject main_activity = NULL;
jmethodID setPreferredDisplay = NULL;
jint display_id_main = 0;
jint display_id_aux = 0;
jboolean main_display_active = JNI_TRUE;

#define LOG_TAG "IR_CONTROL"
#define LOG_LEVEL ANDROID_LOG_DEBUG

#define LOG(...) \
    __android_log_print(LOG_LEVEL, LOG_TAG, __VA_ARGS__)

static void message_handler(int fd, int events, void* data) {
    struct android_poll_source* source = (struct android_poll_source*) data;
    if (source != NULL) {
        source->process(activity, source);
    }
}

static void handle_input_event(AInputEvent* event) {
    if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_KEY) {
        int32_t action = AKeyEvent_getAction(event);
        int32_t keyCode = AKeyEvent_getKeyCode(event);

        if (action == AKEY_EVENT_ACTION_DOWN) {
            if (keyCode == AKEYCODE_MEDIA_PLAY) {
                if (main_display_active) {
                    (*env)->CallVoidMethod(env, main_activity, setPreferredDisplay, display_id_aux);
                    main_display_active = JNI_FALSE;
                } else {
                    (*env)->CallVoidMethod(env, main_activity, setPreferredDisplay, display_id_main);
                    main_display_active = JNI_TRUE;
                }
            }
        }
    }
}

static int32_t input_callback(int fd, int events, void* data) {
    AInputEvent* event = NULL;
    while (AInputQueue_getEventSource((AInputQueue*) data) != NULL && AInputQueue_getEvent((AInputQueue*) data, &event) >= 0) {
        handle_input_event(event);
        AInputQueue_finishEvent((AInputQueue*) data, event, 1);
        event = NULL;
    }
    return 1;
}

static void android_main(struct android_app* app) {
    ANativeActivity_setWindowFlags(app->activity, AWINDOW_FLAG_KEEP_SCREEN_ON, 0);

    app->onAppCmd = NULL;
    app->onInputEvent = NULL;

    activity = app->activity;
    env = activity->env;

    (*env)->GetJavaVM(env, &jvm);

    jclass clazz = (*env)->GetObjectClass(env, activity->clazz);
    main_activity = (*env)->NewGlobalRef(env, activity->clazz);
    setPreferredDisplay = (*env)->GetMethodID(env, clazz, "setPreferredDisplay", "(I)V");

    display_id_main = ANativeWindow_getDisplayId(app->window);
    display_id_aux = display_id_main + 1;

    AInputQueue_attachLooper(app->inputQueue, ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS), input_callback, app->inputQueue, &app->inputPollSource);

    int events;
    struct android_poll_source* source;
    while (ALooper_pollAll(-1, NULL, &events, (void **) &source) >= 0) {
        if (source != NULL) {
            source->process(app, source);
        }
    }
}

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
    JNIEnv* env = NULL;

    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_6) != JNI_OK) {
        return JNI_ERR;
    }

    return JNI_VERSION_1_6;
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeInit(JNIEnv* env, jobject thiz) {
    ANativeActivity_setWindowFlags(activity, AWINDOW_FLAG_KEEP_SCREEN_ON, 0);
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeStart(JNIEnv* env, jobject thiz) {
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeResume(JNIEnv* env, jobject thiz) {
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativePause(JNIEnv* env, jobject thiz) {
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeStop(JNIEnv* env, jobject thiz) {
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeDestroy(JNIEnv* env, jobject thiz) {
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeSetSurface(JNIEnv* env, jobject thiz, jobject surface) {
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeSetAssetManager(JNIEnv* env, jobject thiz, jobject asset_manager) {
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeSetConfiguration(JNIEnv* env, jobject thiz, jobject configuration) {
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeLowMemory(JNIEnv* env, jobject thiz) {
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeOnWindowFocusChanged(JNIEnv* env, jobject thiz, jboolean has_focus) {
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeOnWindowResize(JNIEnv* env, jobject thiz, jint width, jint height) {
}

JNIEXPORT void JNICALL Java_com_example_ircontrol_MainActivity_nativeOnInputEvent(JNIEnv* env, jobject thiz, jobject event) {
}

在这个示例程序中，我们首先获取了主屏幕和辅屏幕的显示ID，然后注册了一个输入事件回调。当检测到红外遥控器的按键事件时，我们检查按下的按键码是否为我们定义的AKEYCODE_MEDIA_PLAY，如果是，则切换主屏幕和辅屏幕之间的控制。我们使用JNI调用Java的setPreferredDisplay方法来实现这一功能。

请注意，这个示例程序并不完整，并且需要根据您的设备和要求进行修改和调整。如果您不确定如何编写Android NDK应用程序，请参考相关的Android开发文档或寻求专业人士的帮助。

用opencv4.5.4的dnn函数支持pytorch的函数可以做到吗

可以，OpenCV 4.5.4的DNN模块支持PyTorch的函数可以用来实现这个任务。可以使用DNN模块中的BlobFromImage函数将一维向量转换为适合于输入网络的格式，然后使用forward函数进行前向传播，最后使用np.argmax函数获取最大值的索引。

下面是一个使用OpenCV 4.5.4的DNN模块支持PyTorch的函数来找到一维向量中最大的元素的示例代码：

import cv2
import numpy as np

# 定义一个只有五个元素的一维向量
v = np.array([1, 3, 5, 2, 4])

# 创建一个网络
net = cv2.dnn.readNetFromTorch("model.pt")

# 将一维向量转换为适合于输入网络的格式
blob = cv2.dnn.blobFromImage(v.reshape(1, 1, 1, -1))

# 进行前向传播
net.setInput(blob)
out = net.forward()

# 使用np.argmax函数获取最大值的索引
max_index = np.argmax(out)

print("最大的元素是：", v[max_index])

在上面的代码中，我们首先定义了一个只有五个元素的一维向量v。然后创建了一个网络，使用readNetFromTorch函数从PyTorch模型文件中读取网络。接下来，使用BlobFromImage函数将一维向量转换为适合于输入网络的格式，并进行前向传播。最后，使用np.argmax函数获取最大值的索引，并使用该索引来获取最大的元素。

需要注意的是，在使用BlobFromImage函数时，我们将一维向量重塑为(1, 1, 1, -1)的形状。这是因为BlobFromImage函数的输入形状是(N, C, H, W)，其中N是批次大小，C是通道数，H是高度，W是宽度。在这里，我们使用批次大小为1，通道数为1，高度为1，宽度为向量长度。