036.Python的TCP语法

TCP语法

1 建立一个socket对象

import socket
sk = socket.socket()
print (sk)

执行

[root@node10 python]# python3 test.py
<socket.socket fd=3, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('0.0.0.0', 0)>

2 使用socket建立连接发送消息

服务端发消息，客户端接收消息

服务端过程

1. 创建一个socket对象 # 默认返回tcp协议的对象
2. 绑定ip和端口 (把该主机注册到网络里,让别人找到你)
3. 开启监听
4. 三次握手 conn 是建立三次握手之后返回的对象, addr 是对方的ip地址
5. 写收发消息的逻辑，服务端发送消息 发送消息的数据类型一定的是二进制字节流
6. 四次挥手
7. 退还端口，先启动服务端,在启动客户端,一发一收是一对,不能多发也不能多收

[root@node10 tcp]# cat /python/tcp/server.py

import socket
# 1.创建一个socket对象  # 默认返回tcp协议的对象
sk = socket.socket()
# 2.绑定ip和端口 (把该主机注册到网络里,让别人找到你)
# 127.0.0.1 默认指代本机的ip地址
sk.bind( ("127.0.0.1",9000) )
# 3.开启监听
sk.listen()

# 4.三次握手 conn 是建立三次握手之后返回的对象, addr 是对方的ip地址
# accept() 必须建立好握手之后,下面的代码才能执行,因为其中加了阻塞.
# 比如input sleep.. 都是程序内部加了阻塞.
conn,addr = sk.accept()

# 5.写收发消息的逻辑
# ...
# 服务端接收消息 同一时间最多最多接收1024个字节
msg = conn.recv(1024) # 程序内部加了阻塞,不接受数据,不会向下执行
print(msg.decode("utf-8"))

# 服务端发送消息 发送消息的数据类型一定的是二进制字节流
conn.send("nice to meet you too".encode("utf-8")) # 不发送完毕之后,不会关闭连接

# 6.四次挥手
conn.close()

# 7.退还端口
sk.close()

# 先启动服务端,在启动客户端,一发一收是一对,不能多发也不能多收

执行

[root@node10 tcp]# python3 server.py

这里会被阻塞，查看端口，发现9000端口已经被占用

创建一个客户端文件

 ### 客户端

import socket
# 产生一个socket对象
sk = socket.socket()
# 建立连接
sk.connect( ("127.0.0.1",9000) )

# send 发送消息 参数必须是二进制的字节流
sk.send("nice to meet you !".encode("utf-8"))

# recv 接收消息
res = sk.recv(1024)
print(res.decode("utf-8"))
# 关闭连接
sk.close()

执行

然后查看服务端

客户端

打印看一下conn,addr的值

import socket
sk = socket.socket()
sk.bind( ("127.0.0.1",9000) )
sk.listen()
conn,addr = sk.accept()
print (conn,addr)
msg = conn.recv(1024)
print(msg.decode("utf-8"))
conn.send("nice to meet you too".encode("utf-8"))
conn.close()
sk.close()

执行然后执行client端，得到

<socket.socket fd=4, 
family=AddressFamily.AF_INET, 
type=SocketKind.SOCK_STREAM, 
proto=0, 
laddr=('127.0.0.1', 9000), 
raddr=('127.0.0.1', 44368)> ('127.0.0.1', 44368)

3 使用socket循环发消息

import socket

sk = socket.socket()
#注册主机
sk.bind ( ("127.0.0.1",9000) )   #参数式元组
#开启监听
sk.listen()
#三次握手
conn,addr = sk.accept()

msg = conn.recv(1024)
print (msg.decode("utf-8"))

#四次挥手
conn.close()
#退还端口
sk.close()

客户端

import socket
sk = socket.socket()
sk.connect( ("127.0.0.1",9000) )
message = input(">>>:")
sk.send(message.encode("utf-8"))
sk.close()

先执行服务端  在执行客户端，并在客户端输值

[root@node10 tcp]# python3 server.py

[root@node10 tcp]# python3 client.py
>>>:hi
[root@node10 tcp]# python3 server.py
hi

循环执行客户端发消息

#服务端
import socket

sk = socket.socket()
#注册主机
sk.bind ( ("127.0.0.1",9000) )   #参数式元组
#开启监听
sk.listen()
#三次握手
#conn,addr = sk.accept()
while True:
        conn,addr = sk.accept()
        while True:
                msg = conn.recv(1024)
                print (msg.decode("utf-8"))

#四次挥手
conn.close()
#退还端口
sk.close()

客户端

import socket
sk = socket.socket()
sk.connect( ("127.0.0.1",9000) )
while True:
        message = input(">>>:")
        sk.send(message.encode("utf-8"))
sk.close()

效果

[root@node10 tcp]# python3 server.py
[root@node10 tcp]# python3 client.py
>>>:123
>>>:456
>>>:nihao
>>>:hello
>>>:
[root@node10 tcp]# python3 server.py
123
456
nihao
hello

4 服务端和客户端户发消息

服务端

import socket

sk = socket.socket()
#注册主机
sk.bind ( ("127.0.0.1",9000) )   #参数式元组
#开启监听
sk.listen()
#三次握手
#conn,addr = sk.accept()
while True:
        conn,addr = sk.accept()
        while True:
                msg = conn.recv(1024)
                print (msg.decode("utf-8"))
                #服务端发消息
                message = input("我要发数据>>>:")
                conn.send(message.encode("utf-8"))
#四次挥手
conn.close()
#退还端口
sk.close()

客户端

import socket
sk = socket.socket()
sk.connect( ("127.0.0.1",9000) )
while True:
        message = input(">>>:")
        sk.send(message.encode("utf-8"))
        #接收服务端消息
        res = sk.recv(1024)
        print (res.decode("utf-8"))
sk.close()

执行

[root@node10 tcp]# python3 server.py
hi    #这里阻塞，等待客户端发消息，接收到客户端消息，可以给客户端发送消息
我要发数据>>>:hi   #向客户端发送消息
nice to meet you
我要发数据>>>:nice to meet you too!
[root@node10 tcp]# python3 client.py
>>>:hi   #向服务端发送消息，然后阻塞，等待服务端的消息
hi       #接收到服务端的消息，可以继续向服务端发送消息
>>>:nice to meet you
nice to meet you too!

但是这种情况下，当再有一个客户端连接，是无法连接的，在开启一个窗口

执行client.py

[root@node10 tcp]# python3 client.py
>>>:123   #向服务端发送数据
[root@node10 tcp]# python3 server.py
hi
我要发数据>>>:hi
nice to meet you
我要发数据>>>:nice to meet you too!   #但是服务端没有任何反应，需要断开连接

5 断开连接

断开客户端连接，同时服务端不会断开，可以等待下一个客户端的连接

import socket

sk = socket.socket()
#注册主机
sk.bind ( ("127.0.0.1",9000) )   #参数式元组
#开启监听
sk.listen()
#三次握手
#conn,addr = sk.accept()
while True:
        conn,addr = sk.accept()
        while True:
                msg = conn.recv(1024)
                print (msg.decode("utf-8"))
                #服务端发消息
                message = input("我要发数据>>>:")
                conn.send(message.encode("utf-8"))
                if message == "q":     #当发送的消息式q是，退出这个循环，即和客户端结束连接，但是上一层循环，并没有结束，可以等待下一个的客户端进来
                        break
#四次挥手
conn.close()
#退还端口
sk.close()

客户端

import socket
sk = socket.socket()
sk.connect( ("127.0.0.1",9000) )
while True:
        message = input(">>>:")
        sk.send(message.encode("utf-8"))
        #接收服务端消息
        res = sk.recv(1024)
        if res == b"q":   #当接收到服务端的q信息，就退出循环，即断开连接，b"q"表示接收的二进制流是q
                break
        print (res.decode("utf-8"))
sk.close()

执行

[root@node10 tcp]# python3 server.py
Hi
我要发数据>>>:Hi
Nice to meet you!
我要发数据>>>:Nice to meet you too!
q
我要发数据>>>:q     #这里发送了q信号
[root@node10 tcp]# python3 client.py
>>>:Hi
Hi
>>>:Nice to meet you!
Nice to meet you too!
>>>:q              #这里就退出
[root@node10 tcp]#

在连接一个客户端

[root@node10 tcp]# python3 client.py
>>>:Hi,I'm the other one,nice to meet you!
H,welcome,Nice to meet you too!
[root@node10 tcp]# python3 server.py
Hi
我要发数据>>>:Hi
Nice to meet you!
我要发数据>>>:Nice to meet you too!
q
我要发数据>>>:q
Hi,I'm the other one,nice to meet you!  #这里是接受到的新的客户端的消息
我要发数据>>>:Hi,welcome,Nice to meet you too!
[root@node10 tcp]# python3 client.py
>>>:Hi,I'm the other one,nice to meet you!
H,welcome,Nice to meet you too!    #客户端接收到的服务端消息

6 匹配最里面括号的值

import re
strvar = "(5-9+(7*7-(5-4)))"
obj = re.search("\([^()]+\)",strvar)    #先匹配（），但是为了防止被分组的，使用\转义，[^()]表示必须从这个字符组挑出一个来，就使用[^()]+,就变成目前的表达式
res = obj.group()
print (res)

执行

[root@node10 python]# python3 test.py
(5-4)