基于TCP协议实现校园百科知识自动聊天程序

dddylann

于 2023-10-19 13:11:08 发布

阅读量643

点赞数 3

文章标签： tcp/ip 服务器 python

本文链接：https://blog.csdn.net/qq_52246357/article/details/128370909

版权

方法一：使用字典存储数据

基于TCP的自动聊天程序是一种通过建立TCP连接来实现聊天功能的程序。它通常包括两个部分：客户端和服务器端。客户端负责与用户交互，接收用户输入并发送消息到服务器端；服务器端负责接收客户端发来的消息并进行处理，然后将处理后的消息发送回客户端。

首先，需要使用 Python 的 socket 模块来建立 TCP 连接。这是一个内置的模块，可以方便地处理网络通信。具体的，需要创建一个 socket 对象，并使用它的 bind()、listen() 和 accept() 方法来建立服务器端。然后，可以创建另一个 socket 对象，并使用它的 connect() 方法来建立客户端。这两个 socket 对象之间就可以进行通信了。

其次，需要准备至少 30 条校园百科知识问答语句。可以把这些语句存储在一个数组中，每次服务器端收到一条问题，就在字典中查找匹配的答案，并将其发送给客户端。如果想要更复杂的存储方式，可以使用数据库来存储这些语句，并在运行时通过查询来获取答案。

最后，一个交互式的界面将输入的信息发送给服务器端。服务器端收到消息后，就可以根据提前准备的知识库来回答问题。当客户端和服务器端的通信完成后，可以通过 socket 对象的 close() 函数断开 TCP 连接。

服务器端

import socket
import threading
import time
def DealClient(sock, addr):
    print("Accept new connection from %s:%s..." % addr)
    sock.send(b"you:")
    while True:
        data = sock.recv(1024)
        time.sleep(1)
        if not data or data.decode('utf-8') == 'exit':
            break
        # 分词
        words = data.decode('utf-8')
        # 根据分词查询字典
        if words in dict:
            sock.send(dict[words].encode('utf-8'))
        else:
            sock.send("Sorry, I don't know".encode('utf-8'))
    sock.close()
    print("Connection from %s:%s closed." % addr)
# 初始化服务器
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 监听端口
s.bind(('192.168.0.104', 9995))
s.listen(5)
print("Waiting for connection...")
# 存储问答语句
dict = {
    "你叫什么名字？": "我叫李修基。",
    "你是哪个学校的？": "西北民族大学",
    "西北民族大学环境好吗？": "非常好",
    "学校在哪里？": "学校在甘肃省兰州市",
    "你们校有多少学生？": "现有学生约2.5万人",
    "学校有多少教室？": "学校有约1000间教室",
    "学校有多少体育馆？": "学校有3个体育馆",
    "学校有多少食堂？": "学校有12个食堂",
    "学校有多少实验室？": "学校有约100个实验室",
    "学校有多少住宿楼？": "学校有31个住宿楼",
    "学校有多少社团？": "学校有约200个社团",
    "学校有多少学院？": "学校有30多个学院",
    "学校有多少教工？": "学校有约3000多名教工",
    "学校有多少国际学生？": "学校有约6000多名国际学生",
    "学校有多少行政办公楼？": "学校有约20多个行政办公楼",
    "学校有多少报告厅？": "学校有约10个报告厅",
    "学校有多少体育场？": "学校有4个体育场",
    "学校有多少风景点？": "学校有约20个风景点",
    "学校有多少宿舍？": "学校有约5000多间宿舍",
    "学校有多少艺术团？": "学校有约10个艺术团",
    "学校有多少园林？": "学校有约20个园林",
    "学校有多少实验室中心？": "学校有约20个实验室中心",
    "学校有多少运动场？": "学校有约20个运动场",
    "学校有多少农场？": "学校有约10个农场",
    "学校有多少健身房？": "学校有约10个健身房",
    "学校有多少实训室？": "学校有约20个实训室",
    "学校有多少游泳池？": "学校有约10个游泳池",
    "学校有多少商店？": "学校有约50个商店",
    "学校有多少展览厅？": "学校有约20个展览厅",
    "你好": "HELLO",
}
while True:
    # 接受一个新连接
    sock, addr = s.accept()
    # 创建新线程来处理TCP连接
    t = threading.Thread(target=DealClient, args=(sock, addr))
    t.start()

1. 导入库

首先，服务器程序导入了三个库：

socket: 这是 Python 的标准库，用于创建和使用网络套接字。

threading: 这是 Python 的标准库，用于创建和管理线程。

time: 这是 Python 的标准库，用于操作时间和日期。

2. 初始化服务器, 然后，服务器程序创建了一个套接字：

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

其中，AF_INET 表示使用 IPv4 协议，SOCK_STREAM 表示使用流式套接字。然后，服务器程序绑定地址和端口，并开始监听客户端连接：

s.bind(('192.168.0.104', 9995))

s.listen(5)

其中，('192.168.0.104', 9995) 表示地址和端口，其中 127.0.0.1 是本机的回环地址，9996 是一个随意选择的端口。listen() 函数的参数 5 表示最多可以有 5 个客户端同时连接到服务器。

3. 处理客户端连接

然后，服务器程序进入一个死循环，每次循环都会接受一个新的客户端连接：

while True:

sock, addr = s.accept()

accept() 函数会阻塞线程，直到有新的客户端连接到服务器。如果有新的客户端连接，accept() 函数会返回一个新的套接字和客户端的地址信息。

然后，服务器程序会创建一个新的线程来处理这个连接：

t = threading.Thread(target=DealClient, args=(sock, addr))

t.start()

这样，服务器就可以同时处理多个客户端连接了。

4. DealClient() 函数

DealClient() 函数是用来处理客户端连接的函数。它的参数是一个套接字和客户端的地址信息。

首先，DealClient() 函数会打印出一条欢迎信息，并发送给客户端：

print("Accept new connection from %s:%s..." % addr)

sock.send(b"you:")

然后，DealClient() 函数进入一个死循环，每次循环都会接收客户端发送的数据：

while True:

data = sock.recv(1024)

recv() 函数会阻塞线程，直到接收到客户端发送的数据。如果接收到的数据为空，或者数据内容为“exit”，则退出循环。否则，服务器程序会对接收到的数据进行处理。

在这里，服务器程序先对数据进行了解码

words = data.decode('utf-8')

然后，服务器程序查询了一个字典，看看这个问题是否已经被记录在字典中：

if words in dict:

sock.send(dict[words].encode('utf-8'))

else:

sock.send("Sorry, I don't know".encode('utf-8'))

如果问题在字典中，服务器程序就会发送相应的答案给客户端；如果问题不在字典中，服务器程序就会发送“Sorry, I don't know”给客户端。

客户端

import socket
# 创建socket对象
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务器
s.connect(('192.168.0.104', 9995))
while True:
    # 接收服务器消息
    data = s.recv(1024)
    print(data.decode('utf-8'))
    # 发送消息给服务器
    str = input()
    s.send(str.encode('utf-8'))
    if str == 'exit':
        break
s.close()

上述代码首先创建了socket对象，socket.socket()函数中的两个参数AF_INET指定使用IPv4协议，SOCK_STREAM指定使用面向流的TCP协议，这样就创建了一个socket。接着调用connect()函数来连接到远程服务器。参数('192.168.0.104', 9995)分别指定地址和端口号，这里指定的是服务器的地址和端口号，客户端会发起连接请求，服务器接受连接请求。接下来，使用while循环，调用recv()函数来接收服务器发送的消息，并使用decode()函数将消息从字节流转换成字符串，然后使用print()函数输出消息，让客户端用户可以接收到服务器发来的消息。最后，使用input()函数获取用户输入的消息，然后使用send()函数将消息发送给服务器，并使用encode()函数将字符串转换成字节流，发送给服务器。如果输入的消息是“exit”，则跳出循环，关闭socket连接，结束客户端程序。

实现结果：

当运行这段代码时，会输出一条“Waiting for connection...”的消息，表示服务器正在等待客户端的连接。
当客户端连接到服务器时，会输出一条“Accept new connection from xxx:yyy...”的消息，其中 xxx 和 yyy 分别表示客户端的地址和端口。
当客户端与服务器断开连接时，会输出一条“Connection from xxx:yyy closed.”的消息，其中 xxx 和 yyy 分别表示客户端的地址和端口。
用 threading 模块来创建和管理多线程。代码中可以使用 threading.Thread() 函数创建一个新的线程，并使用 start() 函数来启动线程。在此是由两个客户端与服务器端建立连接。

方法二：使用数据库存储数据

1. 客户端向服务器发起连接：客户端使用Python的socket模块创建一个TCP的socket，并向服务器发起连接，建立TCP连接。

2. 客户端发送请求消息：客户端发送需要查询的校园百科知识问题给服务器，服务器收到请求消息，并使用 jieba 库对消息进行分词。

3. 服务器从数据库中查找：服务器接收到客户端请求消息后，从数据库中查找与请求消息对应的答案，将其发送给客户端。

4. 客户端主动关闭连接：客户端收到服务器发来的回复消息，关闭连接，服务器也关闭该连接，完成TCP连接。

代码如下：

服务器端

import socket
import threading
import jieba
import sqlite3

def DealClient(sock, addr):
    # 打印接受到的新连接的地址
    print("Accept new connection from %s:%s..." % addr)
    sock.send(b"you:")
    while True:
        # 接收客户端发送的消息
        data = sock.recv(1024)
        # 如果接收到的数据为空或者收到的消息为'exit'，则断开连接
        if not data or data.decode('utf-8') == 'exit':
            break
        # 对接收到的消息进行分词
        words = list(jieba.cut(data.decode('utf-8')))
        # 根据分词查询数据库，获取答案
        answer = get_answer(words)
        # 如果能够找到答案，则发送答案给客户端
        if answer:
            sock.send(answer.encode('utf-8'))
        else:
            sock.send("Sorry, I don't know".encode('utf-8'))
    # 关闭与客户端的连接
    sock.close()
    print("Connection from %s:%s closed." % addr)

def get_answer(words):
    # 建立数据库连接
    db = sqlite3.connect("data.db")
    cursor = db.cursor()
    # 查询数据库
    query = 'SELECT answer FROM qa WHERE question LIKE "%' + '%'.join(words) + '%"'
    cursor.execute(query)
    result = cursor.fetchone()
    # 关闭数据库连接
    cursor.close()
    db.close()

    # 返回答案
    return result[0] if result else "Sorry, I don't know"

# 初始化服务器
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 监听端口
s.bind(('192.168.0.104', 9984))
s.listen(5)
print("Waiting for connection...")

while True:
    # 接受一个新连接
    sock, addr = s.accept()
    # 创建新线程来处理TCP连接
    t = threading.Thread(target=DealClient, args=(sock, addr))
    t.start()

while True:
    # 接受一个新连接
    sock, addr = s.accept()
    # 创建新线程来处理TCP连接
    t = threading.Thread(target=DealClient, args=(sock, addr))
    t.start()

建立了一个服务器，监听端口 9984，并使用多线程的方式为每个连接的客户端提供服务。对于每个连接的客户端，服务器会接收客户端发送的消息，并使用 jieba 库对消息进行分词。然后，它会查询数据库，并返回与分词结果匹配的答案。如果未能找到匹配的答案，则返回 "Sorry, I don't know"。

首先，DealClient 函数会打印接受到的新连接的地址，然后发送一条消息 "you:" 给客户端。然后，进入一个无限循环，不断接收客户端发送的消息。如果接收到的数据为空或者收到的消息为 "exit"，则跳出循环，断开与客户端的连接。

如果接收到的消息不为空且不是 "exit"，则对消息进行分词，并使用 get_answer 函数查询数据库，获取答案。如果能够找到答案，则发送答案给客户端；如果未能找到答案，则发送 "Sorry, I don't know" 给客户端。

最后，DealClient 函数关闭与客户端的连接，并打印连接已关闭的消息。

在主程序中，首先使用 socket 库创建了一个服务器套接字，然后调用 bind 函数绑定了服务器的 IP 地址和端口号，最后调用 listen 函数开始监听端口。

接着，进入一个无限循环，不断接受新的连接。对于每个新的连接，使用 threading 库的 Thread 类创建一个新线程，并将 DealClient 函数作为目标函数，sock 和 addr 作为参数传递给新线程。然后启动新线程，开始为新的客户端提供服务。

此外，在主程序的末尾我还设置了一个 while True 循环，但是该循环没有任何内容，所以它将永远不会结束。这意味着服务器程序将一直运行，直到人为中断或者出现异常。

客户端

import socket

# 创建socket对象
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务器
s.connect(('192.168.0.104', 9984))

while True:
    # 接收服务器消息
    data = s.recv(1024)
    print(data.decode('utf-8'))
    # 发送消息给服务器
    str = input()
    s.send(str.encode('utf-8'))
    if str == 'exit':
        break
s.close()

这段代码创建了一个简单的客户端，它可以连接到在端口 9884 上运行的服务器。客户端向用户提示输入问题，并接收用户输入的问题。客户端将问题发送到服务器，然后等待服务器的答案。当服务器发送答案时，客户端将答案显示给用户。如果用户输入了 'bye'，客户端将关闭连接并退出。

1.上述代码是一段简单的TCP客户端程序。

2.该程序中先建立了一个TCP套接字，并设置了主机名和端口号，然后连接到服务器。

3.之后，在一个while循环中，客户端输入一个问题，然后将其发送给服务器，服务器会回答，客户端再显示出来。

4.如果客户端输入的是“exit”，则结束循环，关闭TCP套接字。

数据库代码

import sqlite3
# 建立数据库
conn = sqlite3.connect('data.db')
c = conn.cursor()
# 建表
c.execute('CREATE TABLE qa (question text, answer text)')
# 插入数据
c.executemany('INSERT INTO qa VALUES (?,?)',[
    ('你叫什么名字？', '我叫李修基。'),
    ('你是哪个学校的？', '西北民族大学'),
    ('西北民族大学环境好吗？', '非常好'),
    ('学校在哪里？', '学校在甘肃省兰州市'),
    ('你们校有多少学生？', '现有学生约2.5万人'),
    ('学校有多少教室？', '学校有约1000间教室'),
    ('学校有多少体育馆？', '学校有3个体育馆'),
    ('学校有多少食堂？', '学校有12个食堂'),
    ('学校有多少实验室？', '学校有约100个实验室'),
    ('学校有多少住宿楼？', '学校有31个住宿楼'),
    ('学校有多少社团？', '学校有约200个社团'),
    ('学校有多少学院？', '学校有30多个学院'),
    ('学校有多少教工？', '学校有约3000多名教工'),
    ('学校有多少国际学生？', '学校有约6000多名国际学生'),
    ('学校有多少行政办公楼？', '学校有约20多个行政办公楼'),
    ('学校有多少报告厅？', '学校有约10个报告厅'),
    ('学校有多少体育场？', '学校有4个体育场'),
    ('学校有多少风景点？', '学校有约20个风景点'),
    ('学校有多少宿舍？', '学校有约5000多间宿舍'),
    ('学校有多少艺术团？', '学校有约10个艺术团'),
    ('学校有多少园林？', '学校有约20个园林'),
    ('学校有多少实验室中心？', '学校有约20个实验室中心'),
    ('学校有多少运动场？', '学校有约20个运动场'),
    ('学校有多少农场？', '学校有约10个农场'),
    ('学校有多少健身房？', '学校有约10个健身房'),
    ('学校有多少实训室？', '学校有约20个实训室'),
    ('学校有多少游泳池？', '学校有约10个游泳池'),
    ('学校有多少商店？', '学校有约50个商店'),
    ('学校有多少展览厅？', '学校有约20个展览厅'),
    ('马伟老师帅吗？', '马伟老师讲课讲的特别好，还非常帅，声音还特别好听'),
]
)
# 保存
conn.commit()
# 关闭
conn.close()

这段代码创建了一个名为 data.db 的 SQLite 数据库，并在该数据库中创建了一个名为 qa 的表。该表具有两列：question 和 answer，分别用于存储问题和答案。代码还向 qa 表中插入了三条数据，分别是关于校园百科的问题及答案。最后，代码保存更改并关闭数据库连接。

运行这段代码后，将创建一个名为 data.db 的数据库文件，并在该数据库中创建一个名为 qa 的表。该表将包含三条关于校园百科的问题和答案。

1.首先，我们使用sqlite3包连接到数据库，并创建一个游标对象。

2.接下来，我们创建一个表，表名为qa，其中包含两个字段，分别为question和answer，它们都是文本类型。

3.然后，使用executemany函数插入数据，参数为一个元祖的列表，每个元组都是一条记录。

4.最后，使用commit函数将数据提交，并使用close函数关闭连接。

实现结果：

通过import sqlite3模块来建立数据库连接，把问答语句存储在数据库中。
使用jieba库来进行分词

words = list(jieba.cut(data.decode('utf-8')))

cut 函数接受一个字符串作为输入，并返回一个生成器。生成器可以通过迭代器的方式访问分词结果，即每次调用 next 函数获取分词的下一个词。

为了方便使用，我使用了 list 函数将分词结果转换为列表，并将结果赋值给变量 words。之后，就可以像操作列表一样操作分词结果了。

结果学校食堂或者学校食堂都得不到正确答案，因为得需要使用通配符:

query = 'SELECT answer FROM qa WHERE question LIKE "%' + '%'.join(words) + '%"'

输入学校%食堂，就可以得出正确回答。

同样这个数据库存储的方法我也是用 threading 模块来创建和管理多线程。代码中可以使用 threading.Thread() 函数创建一个新的线程，并使用 start() 函数来启动线程。在此是由两个客户端与服务器端建立连接。

总结与体会

拿到此次作业后，在编写这样的聊天程序时，我主要考虑以下几点：

利用Python的socket模块创建TCP连接，以便接收客户端的消息。
在数据库中存储30条校园百科知识问答语句，以便快速回复客户端的问题。
使用一个算法来分析客户端发送的消息，并根据该消息查询数据库，生成回复。
不断监听客户端的消息，服务器接收请求消息，并使用 jieba 库对消息进行分词并及时回复，提供客户端友好的交互体验。

针对套接字编程，我根据课堂所讲以及查阅资料，了解到了以下几点：

一、什么是套接字编程

套接字编程是指使用网络编程技术，利用操作系统提供的套接字接口，实现客户端和服务器之间的数据通信，从而实现分布式系统的编程。它是一种利用网络的编程技术，它可以使客户端和服务器之间的通信更加简单、更加高效。

二、套接字编程的实现原理

套接字编程的实现原理是使用Socket编程接口，实现客户端和服务器之间的数据交换。Socket接口是一种特殊的网络接口，它可以提供网络应用程序访问网络的接口。Socket接口分为客户端Socket和服务器Socket。服务器Socket用来监听客户端的连接请求，客户端Socket用来发起连接请求。当客户端Socket发起连接请求后，服务器Socket就会接受连接请求，并创建一个新的Socket来和客户端通信。接下来，客户端和服务器就可以通过这个Socket来进行数据交换。

三、套接字编程的步骤

1. 创建Socket对象：客户端和服务器必须使用Socket对象来实现网络通信，因此首先必须创建Socket对象。

2. 建立连接：服务器端Socket对象必须调用bind方法，绑定一个本地地址，然后调用listen方法监听端口，客户端Socket对象调用connect方法来连接服务器端的Socket对象。

3. 发送数据：客户端Socket对象调用send方法将数据发送给服务器端；服务器端Socket对象调用recv方法接收客户端发送的数据。

4. 关闭连接：客户端和服务器端Socket对象都可以调用close方法来关闭连接。

四、套接字编程的优点

1. 可以实现不同平台之间的数据交换。由于套接字编程是使用网络编程技术，因此它可以实现不同平台之间的数据交换。

2. 可以简化网络编程。由于套接字编程可以使用Socket接口来实现客户端和服务器之间的数据交换，因此可以简化网络编程。

3. 更加高效。套接字编程可以使用Socket接口来实现客户端和服务器之间的高效数据交换，从而可以提高网络应用程序的性能。

五、套接字编程的缺点

1. 安全性较差。由于套接字编程没有经过安全性的检查，因此它的安全性较差。

2. 不支持多种协议。套接字编程只能用于TCP/IP协议，不能用于其他协议。

3. 容易出错。由于套接字编程涉及到多种技术，如果没有正确地实现，容易出现错误。

六、总结

套接字编程是一种网络编程技术，它可以使客户端和服务器之间的通信更加简单、更加高效。使用套接字编程可以实现不同平台之间的数据交换，简化网络编程，以及提高网络应用程序的性能，但是它的安全性较差，不支持多种协议，容易出错。

针对TCP连接，我根据课堂所讲以及查阅资料，了解到了以下几点：

一、TCP连接简介

TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的协议，是建立在IP协议上的一种协议，是OSI（Open System Interconnection，开放系统互联）参考模型的第四层的协议，它的功能是保证一个可靠的传输，TCP建立在IP协议之上，两者组成了TCP/IP协议，TCP/IP协议是现在网络最常用的协议，是互联网的基础。

TCP连接是客户端和服务器之间建立的一种可靠的数据传输连接，它可以保证传输的数据不会丢失，并且按照正确的顺序到达目的地。TCP连接是由三个阶段组成的：建立连接，传输数据，释放连接，TCP连接由客户端发起，服务器接受，而客户端和服务器之间的双向的通信叫做TCP连接，TCP连接是一种面向连接的网络协议，是面向连接的协议，它在连接建立之后，会在两端建立一个可靠的通信通道，传输的数据可以按照正确的顺序到达目的地。

二、TCP连接建立过程

TCP连接建立是指两个端点之间的可靠的数据传输连接的建立过程，它由三个步骤组成：建立连接，传输数据，释放连接。

1、建立连接

建立TCP连接的过程，即三次握手过程：

（1）客户端发送连接请求报文段，该报文段中包含客户端确认号（Sequence Number）；

（2）服务端收到客户端发来的连接请求报文段，并返回一个确认报文段，该报文段中包含客户端确认号，服务器确认号（Sequence Number）；

（3）客户端收到服务端的确认报文段，并返回一个确认报文段，该报文段中包含服务器确认号，客户端确认号；

这样，客户端和服务端之间就建立了可靠的连接，此时可以进行数据传输。

2、传输数据

在建立完连接之后，客户端和服务端之间就可以进行数据传输了，客户端发送数据时，会带上相应的确认号，服务端收到客户端发来的数据后，会发送一个确认报文段，确认报文段中包含客户端确认号，服务端确认号，这样，客户端和服务端之间的双向数据传输就完成了。

3、释放连接

当客户端和服务端之间的数据传输完成后，双方就可以释放连接了，释放连接的过程是一个四次握手过程：

第一次挥手：客户端（主动关闭方）发送一个FIN，用来关闭客户端到服务端的数据传送，客户端进入FIN_WAIT_1状态。

第二次挥手：服务端收到FIN后，发送一个ACK给客户端，确认序号为收到序号+1，服务端进入Close_WAIT状态。此时TCP连接处于半关闭状态，即客户端已经没有要发送的数据了，但服务端若发送数据，则客户端仍要接收。

第三次挥手：服务端发送一个FIN，用来关闭服务端到客户端的数据传送，服务端进入LAST_ACK状态。

第四次挥手：客户端收到FIN后，客户端进入Time_WAIT状态，接着发送一个ACK给服务端，确认后，服务端进入Closed状态，完成四次挥手。

三、TCP连接的优点

1、可靠性高：TCP是一种面向连接的协议，它保证了传输的数据不会丢失，并且按照正确的顺序到达目的地，因此，它具有很高的可靠性。

2、安全性高：TCP连接是可靠的，而且它还可以使用加密技术来保证数据的安全性，从而可以保证数据在传输过程中不被第三方攻击。

3、简单性高：TCP连接的建立和释放都是一个三次握手的过程，而且它的传输数据的机制也是相对简单的，因此，它的实现也相对简单。

4、灵活性高：TCP连接可以根据客户端和服务端之间的网络状况，动态的调整传输的速率，从而可以提高传输的效率。

四、TCP连接的缺点

1、数据传输速度慢：由于TCP连接使用了三次握手的机制，因此，数据传输速度会比较慢，这也是它的一个缺点。

2、流量控制困难：由于TCP连接使用了流量控制机制，因此，在网络状态发生变化的情况下，流量控制会变得比较困难，这也是它的一个缺点。

3、穿透性差：TCP连接使用了IP地址和端口号来确定两端的设备，因此，它不能穿透防火墙，这也是它的一个缺点。

针对jieba库分词，我根据课堂所讲以及查阅资料，了解到了以下几点：

jieba.cut 方法接受四个输入参数: 需要分词的字符串；cut_all 参数用来控制是否采用全模式；HMM 参数用来控制是否使用 HMM 模型；use_paddle 参数用来控制是否使用paddle模式下的分词模式，paddle模式采用延迟加载方式，通过enable_paddle接口安装paddlepaddle-tiny，并且import相关代码；
jieba.cut_for_search 方法接受两个参数：需要分词的字符串；是否使用 HMM 模型。该方法适合用于搜索引擎构建倒排索引的分词，粒度比较细
待分词的字符串可以是 unicode 或 UTF-8 字符串、GBK 字符串。注意：不建议直接输入 GBK 字符串，可能无法预料地错误解码成 UTF-8
jieba.cut 以及 jieba.cut_for_search 返回的结构都是一个可迭代的 generator，可以使用 for 循环来获得分词后得到的每一个词语(unicode)，或者用
jieba.lcut 以及 jieba.lcut_for_search 直接返回 list
jieba.Tokenizer(dictionary=DEFAULT_DICT) 新建自定义分词器，可用于同时使用不同词典。jieba.dt 为默认分词器，所有全局分词相关函数都是该分词器的映射。

Python编程实现自动聊天程序:

1、首先要编写TCP客户端和服务端，使用Python编程语言实现。客户端程序可以使用socket模块来建立TCP连接，并且使用sys模块可以实现命令行参数的解析；服务端程序可以使用socket模块来建立TCP连接，并且使用threading模块实现多线程服务器，以支持多个客户端同时访问服务器。

2、在客户端和服务端之间建立TCP连接后，客户端可以发送消息给服务端，服务器接收请求消息，并使用 jieba 库对消息进行分词，然后查找匹配的聊天机器人回复，最后将回复发送给客户端实现自动聊天。

3、为了提高聊天机器人的服务水平，可以使用机器学习的方法，构建一个深度神经网络，用于模拟人类的思维活动，来处理聊天内容，以实现更加智能化的聊天机器人。但由于本次作业时间有限，我并未去考虑这个东西，但在今后如果有空，我会去继续学习这方面的知识的。

dddylann

关注

3
点赞
踩
8

收藏

觉得还不错? 一键收藏
1
评论
基于TCP协议实现校园百科知识自动聊天程序

利用Python的socket模块创建TCP连接，以便接收客户端的消息。在数据库中存储30条校园百科知识问答语句，以便快速回复客户端的问题。使用一个算法来分析客户端发送的消息，并根据该消息查询数据库，生成回复。不断监听客户端的消息，服务器接收请求消息，并使用 jieba 库对消息进行分词并及时回复，提供客户端友好的交互体验。一、什么是套接字编程套接字编程是指使用网络编程技术，利用操作系统提供的套接字接口，实现客户端和服务器之间的数据通信，从而实现分布式系统的编程。
复制链接

扫一扫