詹学伟
詹学伟
Published on 2025-02-19 / 63 Visits
0
0

deepseek本地部署之api调用

说明:上一篇讲到了使用ollama本地部署deepseek及局域网内的配置和使用。基于上一篇文章,今天主要介绍“如何调用本地部署的deepseek的API接口?“。

很多人想将自己私有化部署的deepseek集成到企业或个人的项目中,那么就绕不开api的调用了。

但是,我发现很多人本地部署了deepseek后,却不知道如何集成到自己的项目中,有的不知道api文档位置,有的拿到api例子不知道如何使用。这里给大家粗略开开路~~~~

一、找到api文档

我是用的是ollama部署的deepseek,所以直接去ollama官网瞧瞧~~

(很多人应该会跑去deepseek的官网找答案)

官方网站:

https://ollama.com/

简约大气的官网,很喜欢~~~~

了解一个技术,通常情况下,我们都会先去官网,寻找文档,ollama的文档也在这里。咱们点击左上角的GitHub

跟着导航走,

https://github.com/ollama/ollama/blob/main/docs/api.md

这样就找到了我们需要的文档了~~

二、api案例

案例一

略。。。。。

案例二:

案例三:

# This is a sample Python script.

# Press ⌃R to execute it or replace it with your code.
# Press Double ⇧ to search everywhere for classes, files, tool windows, actions, and settings.

from openai import OpenAI

client = OpenAI(
    base_url='http://192.168.10.104:11434/v1/',

    # required but ignored
    api_key='ollama',
)

chat_completion = client.chat.completions.create(
    messages=[
        {
            'role': 'user',
            'content': '请用java写一个冒泡排序',
        }
    ],
    model='deepseek-r1:7b',
    # stream=True,
)


def print_hi(name):
    # 打印结果
    print("模型返回的内容:")
    print(chat_completion.choices[0].message.content)


# Press the green button in the gutter to run the script.
if __name__ == '__main__':
    print_hi('PyCharm')

# See PyCharm help at https://www.jetbrains.com/help/pycharm/

结果:

/Users/zhanxuewei/PyCharmMiscProject/.venv/bin/python /Users/zhanxuewei/PyCharmMiscProject/script.py 
模型返回的内容:
<think>
嗯,我现在要写一个Java程序来实现冒泡排序。我对冒泡排序还不是很熟悉,所以得先回忆一下它的原理。

冒泡排序是一种简单的排序算法,它通过不断交换相邻的元素来进行排序。基本思想是每次比较两个相邻的元素,如果它们的顺序不对就交换,这样经过多轮的比较和交换后,最大的元素会逐渐“浮”到数组的末尾,这就是为什么叫冒泡排序的原因。

那我得先想一下具体的步骤。首先,我需要一个数组来存储要排序的数据。然后,我需要用一个循环来遍历这个数组,进行多次的比较和交换操作。

我记得冒泡排序通常使用双重循环结构。外层循环控制整个数组需要多少轮排序,内层循环负责每一轮中的元素比较和交换。在第一轮中,最大的元素会被放到最后的位置;第二轮则处理剩下的部分,直到整个数组排好序为止。

那我得考虑一下如何实现这个算法。首先,读取输入的数字,然后将它们存储到一个整数数组中。接着,使用双重循环来排序。外层循环的次数应该等于数组长度减一,因为最大的元素会在最后一次循环中被确定下来。

在内层循环中,我需要比较当前元素和下一个元素的大小。如果当前元素大于下一个元素,就交换它们的位置。这样,每一轮内层循环结束后,最大的元素就会被放到正确的位置。

举个例子,假设数组是{4, 3, 2, 1}。第一轮外层循环开始时,内层循环会比较4和3,交换得到{3,4,2,1};然后比较4和2,交换得到{3,2,4,1};接着比较4和1,交换得到{3,2,1,4}。这样第一轮结束后,最大的元素4被放到最后。

接下来是第二轮外层循环,内层循环只到数组长度减二的位置(因为最后一位置已经是正确的了)。在第二轮中,比较3和2,交换得到{2,3,1,4};然后比较3和1,交换得到{2,1,3,4}。这样第二轮结束后,最大的元素3被放到倒数第二个位置。

第三轮外层循环开始时,内层循环只到数组长度减三的位置。比较2和1,交换得到{1,2,3,4}。现在整个数组已经排好序了,可以结束排序过程了。

那我得在代码中实现这些步骤。首先,读取输入的数字数量n,然后读取n个数字存入数组nums。接着,设置一个标记来判断是否需要继续排序,这样可以提前终止外层循环,如果某一轮内没有发生任何交换,说明数组已经排好序了。

或者,我可以直接使用双重循环,外层循环最多运行n-1次,每次内层循环都处理剩下的部分。这可能更简单一些,虽然效率不高,但对于小规模的数据来说是可以接受的。

那我得写出代码的大致结构:

int[] nums = new int[n];
for (int i=0; i < n; i++) {
    System.out.print("请输入第" + (i+1) + "个数字:");
    nums[i] = Integer.parseInt(input());
}

boolean swapped;
do {
    swapped = false;
    for (int i=0; i < nums.length - 1; i++) {
        if (nums[i] > nums[i+1]) {
            // 交换
            int temp = nums[i];
            nums[i] = nums[i+1];
            nums[i+1] = temp;
            swapped = true;
        }
    }
} while (swapped);

这样,外层循环使用了do-while结构,确保至少运行一次。每次内层循环检查相邻元素,并交换它们的位置,同时设置一个标记swapped来判断是否进行了交换操作。

那我得测试一下这个代码是否正确。比如,当输入是{4,3,2,1}时,排序后应该是{1,2,3,4}。运行代码看看结果如何。

另外,我需要考虑输入的数字是否有重复的情况,或者是否已经排好序了。例如,如果数组已经是有序的,那么外层循环应该只运行一次,然后内层循环没有交换操作,swapped为false,do-while循环就会退出。

那这个代码看起来是正确的吗?有没有可能遗漏的地方?

哦,对了,在每次外层循环中,我需要确保内层循环的范围是否正确。比如,当已经排好序的部分不需要再比较的时候,内层循环可以减少比较次数。这已经在代码中实现了,因为内层循环只到nums.length - 1的位置。

那我觉得这个代码是正确的。现在我可以写出完整的Java代码了。
</think>

以下是使用冒泡排序算法对一组整数进行排序的Java代码:

```java
import java.util.Scanner;

public class BubbleSort {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数字的数量:");
        int n = scanner.nextInt();
        int[] nums = new int[n];
        
        for (int i = 0; i < n; i++) {
            System.out.print("请输入第" + (i+1) + "个数字:");
            nums[i] = scanner.nextInt();
        }
        
        boolean swapped;
        do {
            swapped = false;
            for (int i = 0; i < nums.length - 1; i++) {
                if (nums[i] > nums[i + 1]) {
                    // 交换元素
                    int temp = nums[i];
                    nums[i] = nums[i + 1];
                    nums[i + 1] = temp;
                    swapped = true;
                }
            }
        } while (swapped);
        
        System.out.println("排序后的数组:");
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }
}
```

### 解释

1. **读取输入**:首先,程序读取用户输入的数字数量 `n`,然后逐个读取这些数字并存储到一个整数数组 `nums` 中。

2. **冒泡排序实现**:
   - 使用 `do-while` 循环确保至少运行一次外层循环。
   - 外层循环控制整个数组需要多少轮排序。每一轮中,最大的未排元素会被移动到正确的位置。
   - 内层循环负责每一轮中的元素比较和交换操作。如果当前元素大于下一个元素,则交换它们的位置,并设置一个标志 `swapped` 来记录是否进行了交换。

3. **输出结果**:排序完成后,程序打印出排序后的数组。

冒泡排序是一种简单但效率较低的排序算法,尤其在数据量较大的情况下表现不佳。然而,它适用于理解和实现基本的排序逻辑。

Process finished with exit code 0

其他的api,自己去快乐探索吧~~~


Comment