网络

最新推荐文章于 2023-04-17 15:48:17 发布
最新推荐文章于 2023-04-17 15:48:17 发布
阅读量198 收藏
点赞数
分类专栏： 网络 文章标签： 网络 python socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42385761/article/details/109820508
版权

网络

OSI模型

物理层-》数据链路层-》网络层-》传输层-》会话层-》表示层-》应用层

TCP/IP模型

网络接口层（物理层，数据链路层）-》互联网层（链路层）-》传输层（传输层）-》应用层（会话层，表示层，应用层）

TCP/UDP协议

TCP和UDP协议是传输层最重要的两种协议，为上层用户提供级别的通信可靠性

TCP协议

传输控制协议(TCP):TCP定义了两台计算机之间进行可靠的传输而交换的数据和确认信息的格式，以及计算机为了确保数据的正确到达而采取的措施。协议规定了TCP软件怎样识别给定计算机上的多个目的进程，如何对分组、重复这类差错进行恢复。还规定了两台计算机如何初始化TCP数据流传输以及如何结束这已传输。
特点：提供的是面向连接、可靠的字节流服务
TCP适用于对可靠性要求高的通信系统

三次握手
  1. 在建立通道时，客户端首先要先向服务器发送一个SYN同步信号
  2. 服务端在接收到这个信号之后会向客户端发出SYN同步信号和ACK确认信号
  3. 当服务端的ACK和SYN到达客户端后，客户端发送ACK确认信号到服务端，客户端与服务端之间的这个通道就会被建立起来
四次挥手
  1. 在数据传输完毕后，客户端会向服务端发出一个FIN终止信号
  2. 服务端收到这个信号之后会向客户端发出一个ACK确认信号
  3. 如果服务端此后也没有数据发送给客户端时，服务端会向客户端发送一个FIN终止信号
  4. 客户端收到这个FIN信号后，会回复一个确认信号，在服务端接收到这个信号以后，通道关闭

UDP协议

用户数据报协议(UDP)：UDP是一个简单的面向数据报的传输层协议。
特点：提供的是非面向连接的、不可靠的数据流传输，由于在传输数据报文前不用在客户端和服务器之间建立一个连接，也没有超时重发等机制，所以传输速度很快。
UDP适用于一次只传输少量数据、对可靠性要求不高的应用环境

TCP协议与UDP协议最大的区别就是：TCP是面向连接的，UDP是无连接的。TCP协议和UDP协议各有所长，各有所短，使用于不同的通信环境

HTTP协议

HTTP是一个简单的响应-请求协议，通常运行在TCP之上。
HTTP是基于客户/服务器模式，且面向连接的，无状态的。
事务处理过程：

  1. 客户与服务器建立连接
  2. 客户向服务器提出请求
  3. 服务器接收请求，并根据请求返回响应的文件作为应答
  4. 客户与服务器关闭连接

Socket

socket是应用层与TCP/IP协议族通信的中间软件抽象层，是一组接口。在设计模式中，socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在socket接口后面，对用户来说，一组简单的接口就是全部，让socket去组织数据，以符合指定的协议。
本地的进程间通信可以使用队列，同步（互斥锁、条件变量等）
网络进程间的通信：
利用IP地址，协议，端口号，就可以在标识网络中的进程，这样就可以利用这个标识去与其他进程进行交互
scoket是进程间通信的一种方式，它能实现不同主机间的进程通信

TFTP

简单文件传输协议
特点：简单，占用资源小，适合传递小文件，适合在局域网进行传递，端口号为69，基于UDP实现
TFTP数据包格式
TFTP数据包格式
struct将python转换成c

使用UDP实现TFTP协议

分为服务端和客户端

  1. 引入socket包
  2. 引入struct包，能够将python数据转换成c的字节流数据
  3. 定义一个socket使用AF_INET,SOCK_DGRAM
  4. 客户端确定服务器地址，使用69端口；服务器需要绑定69端口
  5. 将请求做成数据包
  6. 将请求发给服务器；服务器接收数据并进行操作
  7. 接收服务器返回的数据（data,(service_ip,server_port)）
  8. 对数据进行判断，然后进行下一步操作
  9. 不管是服务器端还是客户端，在操作完数据后，要返回给对方一个ack进行确认

服务器端

from socket import *
import struct

# 服务器端socket
s = socket(AF_INET, SOCK_DGRAM)

# 绑定IP和端口号
s.bind(('', 69))


def download(filename, client_ip, client_port):
    # 创建一个新的socket，负责发送文件内容的数据包到客户端
    new_socket = socket(AF_INET, SOCK_DGRAM)

    # 文件内容数据包计数器,其实就是数据块的编号
    num = 0

    # 定义客户端退出的标签
    flag = True
    # 定义文件f
    f = None
    try:
        f = open(filename, 'rb')
    except:
        error_package = struct.pack('!HH5sb', 5, 5, 'error'.encode('utf-8'), 0)  # H表示python的Integer转成c的没有符号的short，
        # 5s表示把python中含有5个字符的字符串转换成c的字符数组
        new_socket.sendto(error_package, (client_ip, client_port))  # 把错误数据包发给客户端
        # exit()#当前线程结束，当前客户端退出服务器
        flag = False
    # 如果文件存在，需要把文件内容切成一个个的数据包发送给客户端，一个数据包数据内容包含512字节数据
    while flag:
        # 从文件内容中读取512字节
        read_data = f.read(512)
        # 创建一个数据包
        data_package = struct.pack('!HH', 3, num) + read_data
        # 发送数据包
        new_socket.sendto(data_package, (client_ip, client_port))
        if len(read_data) < 512:  # 文件内容的数据读完
            print(f"客户端{client_ip},文件下载完成")
            # exit() # 当前线程退出
            break
        # 服务器接收ACK的确认数据
        recv_ack = new_socket.recvfrom(1024)  # 里面有数据包内容，还有客户端ip和端口
        oprator_code, ack_num = struct.unpack('!HH', recv_ack[0])
        print('客户端：%s,的确认信息是' % client_ip, ack_num)
        num += 1
        # 保护性代码
        if int(oprator_code) != 4 or int(ack_num) < 0:  # 不正常的ack确认信息
            break
    if f:
        f.close()
    new_socket.close()  # 客户端真正退出


def upload(filename, client_ip, client_port):
    # 新建一个socket，用来发送数据包
    new_socket = socket(AF_INET, SOCK_DGRAM)
    # 新建文件，用来写入数据
    f = None
    # 新建flag，标记客户端退出
    flag = True
    try:
        f = open('service_' + filename, 'ab')
    except:
        # 建立一个error包，用来给客户端返回错误数据
        error_package = struct.pack('!HH5sb', 5, 5, 'error'.encode('utf-8', 0))
        # 将数据包发送给客户端
        new_socket.sendto(error_package, (client_ip, client_port))
        flag = False
    # 向客户端返回ack
    data_ack = struct.pack('!HH', 4, 0)
    new_socket.sendto(data_ack, (client_ip, client_port))
    while flag:
        # 接收客户端返回的文件内容
        recv_data = new_socket.recvfrom(1024)
        operator_data, num = struct.unpack('!HH', recv_data[0][:4])
        if operator_data == 5:
            print('上传出错，文件不存在')
            break
        # 将文件内容写入文件
        f.write(recv_data[0][4:])

        # 向客户端返回ack
        data_ack = struct.pack('!HH', 4, num)
        new_socket.sendto(data_ack, (client_ip, client_port))
        if len(recv_data[0]) < 516:
            print(f'客户端{client_ip}，上传完成')
            break


def server():
    while True:
        # 服务器等待客户端发送过来数据，进行接收
        recv_date, (clien_ip, client_port) = s.recvfrom(1024)
        print(recv_date, clien_ip, client_port)
        # 判断数据包是否是客户端请求的数据包
        if struct.unpack('!b5sb', recv_date[-7:]) == (0, b'octet', 0):
            # 得到操作码的值
            operator_code = struct.unpack('!H', recv_date[:2])
            # 得到文件名字
            file_name = recv_date[2:-7].decode('utf-8')
            if operator_code[0] == 1:  # 如果等于1就是下载请求数据包
                print(f'客户端想下载文件:{file_name}')
                download(file_name, clien_ip, client_port)
            elif operator_code[0] == 2:  # 如果等于2就是上传请求数据包
                print(f'客户端想上传的文件：{file_name}')
                upload(file_name, clien_ip, client_port)


if __name__ == '__main__':
    server()

客户端代码

from socket import *
import struct  # 负责python数据结构和C语言的数据结构转换


def download(file_Name, s, host_port):
    # octet是C里面的字节数据
    # pack把数据变成包
    # '!H%dsb5sb'代表格式，!开头，H：将python整形转换为C中短整型，%ds：字符串长度为len的字符串，b:数字型字符
    # 请求的数据包
    data_package = struct.pack('!H%dsb5sb' % len(file_Name), 1, file_Name.encode('utf-8'), 0, 'octet'.encode('utf-8'),
                               0)

    # 把数据包发到目标服务器
    s.sendto(data_package, host_port)

    # 客户端首先创建一个空白文件
    f = open('client_' + file_Name, 'ab')
    while True:
        # 客户端接收服务器发过来的数据，数据只有两种：1.下载文件内容数据包，2.error信息包
        recv_date, (server_ip, server_port) = s.recvfrom(1024)

        oprator_code, num = struct.unpack('!HH', recv_date[:4])  # 把前四个字节的数据解包出来
        if int(oprator_code) == 5:  # 判断数据包是否是error信息包
            print('服务器返回：要下载的文件不存在')
            break
        # 如果是文件内容数据包，需要保存文件内容
        f.write(recv_date[4:])

        if len(recv_date) < 516:  # 意味着服务器传送过来的文件已经接受完成了
            print('客户端下载成功')
            break
        # 客户端收到数据包之后还需要发送一个确认ACK给服务器
        ack_package = struct.pack('!HH', 4, num)
        s.sendto(ack_package, (server_ip, server_port))
    # 释放资源
    f.close()


def upload(file_Name, s, host_port):
    flag = True
    num = 0
    f = None
    try:
        f = open(file_Name, 'rb')
    except:
        print('文件不存在')
        return
    # 创建请求数据包
    data_package = struct.pack(f'!H{len(file_Name)}sb5sb', 2, file_Name.encode('utf-8'), 0, 'octet'.encode('utf-8'), 0)
    # 向服务器发送数据包
    s.sendto(data_package, host_port)
    # 接收服务器传回来的ACK
    data_ack, (service_ip, service_port) = s.recvfrom(1024)
    oprator_data, ack_num = struct.unpack('!HH', data_ack)
    print(f"服务器返回的ack确认信息是{oprator_data},{ack_num}")
    if int(oprator_data) != 4 or ack_num < 0:
        flag = False
    while flag:
        # 读取文件中的数据，每次512字节
        read_data = f.read(512)
        # 创建文件数据包
        new_package = struct.pack('!HH', 3, num) + read_data
        # 发送数据包
        s.sendto(new_package, (service_ip, service_port))
        # 接收服务器返回的ack数据
        recv_ack = s.recvfrom(1024)  # 里面有数据包内容，还有服务端ip和端口
        oprator_code, ack_num = struct.unpack('!HH', recv_ack[0])
        print('服务端的确认信息是', ack_num)
        if int(oprator_code) != 4 or int(ack_num) < 0:  # 不正常的ack确认信息
            break
        # 判断是不是最后一次传输数据
        if len(read_data) < 512:
            print(f'客户端文件{file_Name},上传完成')
            break
        else:
            num += 1

    if f:
        f.close()


if __name__ == '__main__':
    file_Name = input("请输入文件名：")
    while True:
        try:
            code = int(input("上传还是下载？(1:下载；2:上传)"))
        except:
            print('请输入1或2！')
        else:
            break

    # 客户端套接字
    s = socket(AF_INET, SOCK_DGRAM)

    # 定义服务器地址和端口号
    host_port = ('192.168.199.103', 69)
    if code == 1:
        download(file_Name, s, host_port)
    elif code == 2:
        upload(file_Name, s, host_port)

    s.close()

使用TCP模拟QQ聊天

注意点：

  1. tcp服务器一般情况下都需要绑定，否则客户端找不到这个服务器
  2. tcp客户端一般不绑定，因为是主动连接服务器，所以只要确定好服务器的ip，端口就好，本地客户端可以随机
  3. tcp服务器中通过listen可以将socket创建出来的主动套接字，变为被动的，这是做tcp服务器时必须要做的
  4. 当一个tcp客户端连接服务器时，服务器端会有1个新的套接字，这个套接字用来标记这个客户端，单独为这个客户端服务
  5. listen关闭后的套接字是被动套接字，用来接收新的客户端连接请求的，而accept返回的是新套接字，用来标记这个新客户端的
  6. 关闭listen后的套接字意味着被动套接字关闭了，会导致新的客户端不能连接服务器，但是之前已经连接成功的客户端可以正常通信
  7. 关闭accept返回的套接字意味着这个客户端已经服务完毕
  8. 当客户端的套接字调用close后，服务器端会recv解阻塞，并且返回的长度为0，因此服务器可以通过返回数据的长度来区别客户端是否已经下线

服务器端

  1. 创建socket(AF_INET,SOCK_STREAM)
  2. 绑定ip和端口号bind(’’,8008)
  3. 启动监听listen(5)
  4. 接收客户端发来的连接请求accept(),并返回一个新的socket和客户端ip、端口元组
  5. 接收客户端发来的数据
  6. 对数据进行处理，发送数据到客户端
  7. 退出新的socket
  8. 退出服务器socket
from socket import  *

server_socket = socket(AF_INET,SOCK_STREAM)
server_socket.bind(('',8008))
server_socket.listen(1)
while True:
    new_socket,client_ip_port = server_socket.accept()


    while True:
        recv_data = new_socket.recv(1024)
        if len(recv_data) > 0:#客户端没有退出，而且发送数据到服务器了
            print('客户端：',recv_data.decode('utf-8'))
        else:
            print('客户端已经退出！')
            break
        if recv_data == 'exit':
            print('客户端已经退出！')
            break
        # 发送数据给客户端
        send_data = input('send：')
        if len(send_data) > 0:
            new_socket.send(send_data.encode('utf-8'))
    new_socket.close()
server_socket.close()

客户端

  1. 创建socket(AF_INET,SOCK_STREAM)
  2. 发送连接请求给服务器端connect((ip,port))
  3. 发送数据给服务器端send()
  4. 接收服务器返回的数据，并进行处理，使用recv()
  5. 退出关闭socket
from socket import  *

client_socket = socket(AF_INET,SOCK_STREAM)

client_socket.connect(('192.168.199.103',8008))

while True:
    send_data = input('send:')
    if len(send_data) > 0:
        client_socket.send(send_data.encode('utf-8'))
    else:
        break
    if send_data == 'exit':
        client_socket.close()
        break
    # 客户端接收服务器返回的内容
    recv_data = client_socket.recv(1024)
    print('服务器：',recv_data.decode('utf-8'))

client_socket.close()

黏包问题

黏包指的是数据和数据之间没有明确的分界线，导致不能正确读取数据

  1. UDP协议的数据传输不存在黏包问题，应为UDP协议是将数据打包，然后将包发送给接收方，数据的顺序不会乱。但是，当数据包太大时，接收方规定接收数据比较小时，会造成数据丢失
  2. TCP协议会出现黏包问题：数据与数据之间没有明显的界限
    1. 发送方出现黏包：当数据较小，发送时间间隔比较短时，会出现接收方将两条或两条以上的数据拼接到一起，造成黏包
    2. 接收方出现黏包：当数据较小时，接收方会将多个包的数据合并到一个包中；当数据较大时，接收方会将接收完后，没有接收的数据合并到下一次接收的数据中

发送方出现黏包

服务器端

# author:ycw
# date: 2020/10/23 11:31
from socket import  *
server_socket = socket(AF_INET,SOCK_STREAM)
server_socket.bind(('',8080))
server_socket.listen(5)
new_socket,client_addr = server_socket.accept()
recv_data1 = new_socket.recv(1024)
recv_data2 = new_socket.recv(1024)
print('第一条数据:',recv_data1,'第二条数据：',recv_data2)
new_socket.close()
server_socket.close()

客户端

from socket import *

client_socket = socket(AF_INET,SOCK_STREAM)
client_socket.connect(('192.168.199.103',8080))
client_socket.send('hello'.encode('utf-8'))
client_socket.send('word'.encode('utf-8'))
client_socket.close()

接收方出现黏包

服务器端

# author:ycw
# date: 2020/10/23 11:47

#接收端黏包问题
from socket import *
import time
server_socket = socket(AF_INET,SOCK_STREAM)
server_socket.bind(('',8080))
server_socket.listen(5)
new_socket,client_addr = server_socket.accept()
print('连接成功',client_addr)
data1 = new_socket.recv(2) #第一次没有接收完整
print('第一条数据:',data1)
time.sleep(6)
data2 = new_socket.recv(10)# 第二次会接收旧数据（第一次没有接收完的数据），如果还有空间，再接收新书
print('第二条数据:',data2)
new_socket.close()
server_socket.close()

客户端

# author:ycw
# date: 2020/10/23 11:43
# 接收方可能出现的黏包问题
from socket import *
import time #通过time模块保证客户端发送多个数据包的时候，间隔时间长
client = socket(AF_INET,SOCK_STREAM)
client.connect(('192.168.199.103',8080))
client.send('hello'.encode('utf-8'))
time.sleep(5)#让当前的线程休眠5秒
client.send('world'.encode('utf-8'))
client.close()

黏包成因

  1. 接收方不知道消息之间的界限，不知道一个消息要提取多少字节的数据造成的。（服务器出现黏包）
  2. tcp在发送数据少且间隔时间短的数据时，会将几条合并一起发送。（客户端出现黏包）

解决黏包问题

先计算将要发送的数据的长度，发送给接收方，接收方根据这个长度来接收相应的数据
服务器端

# author:ycw
# date: 2020/10/23 12:20
from socket import *
import os
import struct

server = socket(AF_INET,SOCK_STREAM)
server.bind(('',9999))
server.listen(5)
conn,client_addr = server.accept()
f = open('D:\学习内容\软件学习\python网络编程\服务器.flac','wb')

head = conn.recv(4)
size = struct.unpack('!i',head)[0]#unpack返回的都是一个元组，元组的第一个值就是长度
recv_size = 0 # 已经接收到多长的数据
while recv_size<size:
    data = conn.recv(1024)
    recv_size += len(data) # 接收的字节长度要累加
    print(recv_size)
    f.write(data)
print('服务器端接收完成')
f.close()
conn.close()
server.close()

客户端

# author:ycw
# date: 2020/10/23 12:10
from socket import *
import struct
import os

client = socket(AF_INET,SOCK_STREAM)
client.connect(('192.168.199.103',9999))

# 客户端传送文件到服务器，new.flac
file_path = 'new.flac'
f = open(file_path,'rb')

#在发送真正的文件数据之前，先准备一个报头
size = os.path.getsize(file_path) # 文件的字节长度.
print(size)
# 创建一个包头，i为4个字节的int，
head = struct.pack('!i',size)#接收方会使用struct解包，得到一个int类型的数字
client.send(head)#发送包头

#发送文件内容
while True:
    data = f.read(1024)#每次读1024字节
    if not data:
        break
    client.send(data)#发送给服务器

print('客户端上传文件完成')
f.close()
client.close()
夜色的最黑暗。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity网络通信与端口通信
q493201681的博客
04-22 2680
Unity的网络通信这块是个坑，还有端口通信。 首先是网络通信，网络通信有Udp协议，Tcp短链接，Tcp长连接等等。搜的化网上一大堆代码。 但是我在使用中遇到了一些问题，发送端没啥好说的，主要是接收端。问题如下： 1.首先是接收端写法，在update里面写和在携程里面写都不行，只有在新开的线程中才可以使用，但是 如果关闭的时候不关闭就会导致程序未响应卡死。 2.udp广播在不同平台上有
udp unity 通过端口通讯_Unity3D使用UDP协议实现两个程序传递信息
weixin_30171859的博客
12-24 596
发送端：调用Send()方法，传递发送的内容。using System.Collections;using System.Collections.Generic;using UnityEngine;using System.Net;using System.Net.Sockets;using System.Text;using System.Threading;public class UDPSe...
Python-Unity-Socket-Communication:Unity (C#) 和 Python 3 之间的双向通信-源码
05-29
由 Youssef Elashry 创建，用于解决使用 Python 3 进行双向通信 Unity/C# 应用程序的常见问题。 附加的文件将允许您从 Unity (C#) 和 Python 3 发送和接收数据。 随意在您的个人或商业项目中使用它，但请确保将我引用为：Python 3 和 Unity (C#) 之间的双向通信 - YT Elashry 如果您向我发送如何在您的项目中使用它，我们将不胜感激（例如机器学习）在 使用风险自负根据Apache License 2.0使用 运行演示： 确保 server.py 和 UdpSocket.cs [edited via inspector] 脚本之间的 IP、发送和接收端口相同。 它们在演示中是相同的。 在python端运行server.py以从Unity发送和接收数据 将 UdpSocket.cs 添加到场景中的游戏对象 推荐：运
UDP python和Unity的通信
nanqm123的博客
04-17 632
UDP python和Unity的通信
Unity3D UDP通信
学习笔记
04-01 7585
补一下前面遇到的问题 最近在做树莓派与Unity3D的UDP通信，树莓派通过网线连接电脑，设置网络共享。树莓派作为客户端（python），Unity3D作为服务端（C#）。 在学习过程中遇到了以下两个问题： 1、在根据B站视频： https://www.bilibili.com/video/BV1Bt4y1Q7uW?spm_id_from=333.337.search-card.all.click 学习python的UDP通信时，生成不了exe文件。解决方法：关掉360。 2、在反复确认Unity3D端
计算机网络知识点总结(谢希仁第八版).pdf
最新发布
06-09
计算机网络是信息技术领域的重要组成部分，它使得不同地理位置的设备能够相互通信和资源共享。谢希仁第八版的《计算机网络》详细介绍了网络的基础知识。在信息时代，计算机网络分为电信网络、有线电视网络和计算机...
软考网络工程师全套知识内容电子笔记
07-31
本电子笔记内容，囊括本人在学习软考网络工程师时记录的所有知识内容。重要的知识及不易理解的内容，我均分颜色标记出，并且个别有案例去解释知识，便于理解。 笔记需要下载<印象笔记>软件，然后导入笔记即可，我是...
《计算机网络自顶向下方法第7版》中文PDF+复习题问题中文版答案
05-18
《计算机网络自顶向下方法第7版》是一本广受欢迎的计算机网络教科书，它以其独特的“自顶向下”教学方法，引导读者从应用层深入到物理层，全面理解计算机网络的工作原理。这本书深入浅出地介绍了网络的各个层次模型...
BP神经网络数据集（excel）
07-05
BP神经网络数据集（excel）
计算机网络自顶向下方法第八版答案
05-09
自顶向下方法第八版答案，包括复习题以及课后习题和实验的内容。
Unity的UDP传输
08-08
Unity的udp传输，适合新手，注释详细
PythonUnityServer：在Unity可执行文件和Python脚本之间进行通信的本地服务器
02-08
PythonUnityServer 在Unity可执行文件和Python脚本之间进行通信的本地服务器
YOLOv5网络结构图-visio源文件
02-09
YOLOv5网络结构图-visio源文件，可直接编辑修改
湖南科技大学《计算机网络》配套课件（PDF版）
07-02
湖南科技大学《计算机网络》配套PPT教程，共6部分，包含概述和5层网络体系结构。 0积分免费下载。
网络调试助手NetAssist5.0.3.zip
08-01
《网络调试助手NetAssist5.0.3——深度解析Netty开发与测试》 在IT行业中，网络通信是至关重要的部分，而Netty作为一款高性能、异步事件驱动的网络应用框架，广泛应用于服务器端的开发。针对Netty的开发与测试，有...
python语言unity3d_Unity3d 5.x的最简Python服务器
weixin_39804335的博客
12-01 289
TL；DR：我在Unity3D客户端应用程序和服务器上的UDP python侦听器之间通信遇到问题。在我试图通过Unity5.xNetworkTransport LLAPI和Python3.x套接字模块从Unity3D游戏客户端获得低级调用和响应目标：将发送到服务器的消息反弹回客户端。在问题：当我运行Unity3d客户机时，套接字打开，服务器每秒打印一个新的recvfrom数据，但是unity永远...
unity调用python方法_Unity 基础 之 Unity 简单调用 Python （传递多个参数并接收返回值）...
weixin_39914863的博客
12-08 3794
Unity 基础 之 Unity 简单调用 Python (传递多个参数并接收返回值)目录一、简单介绍Unity中的一些基础知识点。本节介绍，在Unity 应用的时候，可能遗忘了安装 VS，或者想安装其他版本的VS供Unity使用；这里演示，单独安装 Visual Studio 工具，然后配置给 Unity 使用的方法；不过建议还是在 Unity 安装的使用一起安装。二、实现原理1、Process...
Unity与python服务端通信，传输图片
qq_35255869的博客
03-13 5488
犯错记录：程序要放下unity的运行脚本下，要么新建一个vs项目，才能正常运行
计算机网络原理(谢希仁第八版)课后习题答案
04-09
计算机网络原理(谢希仁第八版)课后习题答案，资源为压缩文件，请解压后使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值