directorio
notas de estudio Python --Day07
El séptimo día, para ver la programación de red relevantes en la actualidad. Hace dos días debido a su trabajo, actualizaciones del blog retraso.
Utilice la toma
enchufe (socket referido) es una forma de comunicación entre procesos, de sus relaciones con otros procesos de comunicarse es una diferencia importante: se puede lograr la comunicación entre procesos entre diferentes máquinas en nuestra red para completar una gran cantidad de servicios se basa en zócalo la comunicación.
módulo Socket utilizado en Python socket función lata
import socket
socket.socket(AddressFamily,Type)
En primer lugar socket.socket crear un socket, esta función tiene dos parámetros:
- Dirección familiar: se puede elegir AF_INET (Internet para la comunicación entre procesos) o AF_UNIX (para la comunicación entre procesos en la misma máquina), comúnmente utilizado en el trabajo es AF_INET
- TIPO: tipo de conector puede ser SOCK_STREAM (sockets de flujo, principalmente para el protocolo TCP) o SOCK_DGRAM (datagrama socket, principalmente para el protocolo UDP)
Por ejemplo, si se crea un socket TCP, de modo de escritura
import socket
# 创建tcp的套接字
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 功能代码 略...
...
# 当逻辑结束后，关闭socket
s.close()
Udp de tubo para crear un socket, a continuación, sólo tiene que acercarse al segundo parámetro, sustituido socket.SOCK_DGREAM
import socket
# 创建udp的套接字
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 功能代码 略...
...
# 当逻辑结束后，关闭socket
s.close()
Simplemente es el proceso mediante sockets
- crear zócalo
- Uso de las tomas para la recepción / transmisión de datos
- Cierra el socket
¿No es un poco familiar? El cuarto día de operaciones de archivo y este proceso es, abrir archivos algo similares, manipular archivos, y luego método para cerrar llame a close (), a continuación, que acabo de escribir un pequeño ejemplo, mañana Domingo detallado resumen de un documento relacionado con la operación contenido.
Crear UDP de datos de transmisión / recepción
Toma de transmisión y recepción procedimientos simples
Recibir el bucle de código
#!usr/bin/python
# -*- coding: utf-8 -*-
# author: 李爽
# description：socket接收
import socket
def main():
# 创建udp socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 绑定端口
local_addr = ("127.0.0.1", 8080)
s.bind(local_addr)
# 循环接收
while True:
# 接收数据，返回的是一个元组(接收到的数据，(发送方的地址信息))
recv_message = s.recvfrom(1024)
recv_data = recv_message[0]
recv_address = recv_message[1]
# 打印结果
print("从%s接收:%s" % (recv_address, recv_data.decode("utf-8")))
# 如果接收的是quit
if recv_data.decode("utf-8") == 'quit':
print("接收程序退出")
break
s.close()
if __name__ == "__main__":
main()
bucle de transmisión de código
#!usr/bin/python
# -*- coding: utf-8 -*-
# author: 李爽
# description：udp socket 发送
import socket
def main():
# 创建udp socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while True:
# 键盘录入要发送的数据
send_data = input("请输入要发送的数据：")
# 发送数据，
send_addr = ("127.0.0.1", 8080)
s.sendto(send_data.encode("utf-8"), send_addr)
# 若输入quit 退出程序
if send_data == "quit":
print("发送程序退出")
break
s.close()
if __name__ == "__main__":
main()
Resultado del programa
发送程序
请输入要发送的数据：你好
请输入要发送的数据：quit
发送程序退出
接收程序
从('127.0.0.1', 62189)接收:你好
从('127.0.0.1', 62189)接收:quit
接收程序退出
Proceso o conjunto de procesos, crea un socket, enviar y recibir datos a través de un socket, se cierra el conector, pero añaden un bucle infinito, entran quit para salir del programa en el momento, es necesario tener en cuenta que la cadena se codifica y código de bytes se decodifica, el uso str.encode(encoding="utf-8", errors="strict")``bytes.decode(encoding="utf-8", errors="strict"), en el que los medios de codificación de codificación utilizado en la codificación y decodificación de proceso, por ejemplo utilizo un UTF-8, los errores se refiere error esquema de manejo. referencia específica puede ser documentos oficiales. Hay UDP recibir y procesos de transmisión tienen algo diferente, recepción de pasos múltiples socket.bind()parámetros aprobó una tupla es una tupla IP y el puerto, de hecho, puede que no se unen el puerto, pero en este caso el sistema operativo al azar las asignaciones de puertos, cuando el programa de re-ejecutar puede enviar los cambios en el puerto, sino como un programa del lado del servidor, el puerto está siempre cambiando, entonces el cliente que necesitan cambiar el puerto todos los días, que es lo que hacemos este paso puerto vinculante propósitos .
sala de chat caso -udp
#!usr/bin/python
# -*- coding: utf-8 -*-
# author: 李爽
# description：udp 聊天室
import socket
def send_msg(s):
send_ip = input("请输入要发送的IP地址：")
send_port = int(input("请输入要发送的端口号：").strip())
send_message = input("请输入要发送的信息：")
s.sendto(send_message.encode("utf-8"), (send_ip, send_port))
def recv_msg(s):
recv_message = s.recvfrom(1024)
recv_data = recv_message[0].decode("utf-8")
recv_addr = recv_message[1][0] + ": " + str(recv_message[1][1])
print("从%s接收消息：%s" % (recv_addr, recv_data))
def main():
# 创建udp socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind(("", 8080))
while True:
print("欢迎进入聊天室")
print("1.发送消息")
print("2.接收消息")
print("0.退出聊天室")
op = input("请输入操作：")
if op == "1":
# 发送
send_msg(s)
elif op == "2":
# 接收
recv_msg(s)
elif op == "0":
print("退出聊天室")
break
else:
print("输入有误，请重新输入。")
s.close()
if __name__ == "__main__":
main()
Enviado a su producción
欢迎进入聊天室
1.发送消息
2.接收消息
0.退出聊天室
请输入操作：1
请输入要发送的IP地址：127.0.0.1
请输入要发送的端口号：8080
请输入要发送的信息：haha
欢迎进入聊天室
1.发送消息
2.接收消息
0.退出聊天室
请输入操作：2
从127.0.0.1: 8080接收消息：haha
欢迎进入聊天室
1.发送消息
2.接收消息
0.退出聊天室
请输入操作：0
退出聊天室
Así que nuestra pequeña sala de chat está completa! Pero este pequeño salas de chat tienen un problema muy grave, si se sabe, por favor, dame una respuesta más adelante en el artículo, voy a responder a revelado la próxima entrada del blog
sockets TCP
protocolo TCP TCP sockets es utilizar el servicio de transporte proporcionado por la interfaz de programación para implementar las comunicaciones de red. A la segunda toma único parámetro el método de configuración SOCK.STREAM puede obtener un socket TCP. Debido a un host puede tener varias direcciones IP, y es probable que configurar un número de diferentes servicios, así como un servidor, es necesario crear un objeto socket después de que se une a la dirección IP y el puerto especificados.
Echemos un vistazo en el servidor y el cliente
#!usr/bin/python
# -*- coding: utf-8 -*-
# author: 李爽
# description：tcp 套接字服务器端
import socket
def main():
# 创建tcp套接字
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定端口
s.bind(("127.0.0.1", 8080))
# socket创建的套接字默认属性是为主动的
# 将套接字的属性变为被动，接收发送来的数据
s.listen(1024)
# 当有客户端连接到服务器时，就产生一个新的套接字专门来为这个客户端服务
# client_socket 为这个客户端服务的套接字
# 而s则继续等待其他客户端连接
client_socket, client_addr = s.accept()
# 接收数据
recv_data = client_socket.recv(1024)
print("从%s接收到的数据为：%s" % (client_addr, recv_data.decode("utf-8")))
# 返回数据到客户端
client_socket.send("收到啦！".encode("utf-8"))
# 关闭服务于这个客户端的套接字，关闭后，就意味着只能重新连接才能再次开启服务
client_socket.close()
if __name__ == "__main__":
main()
cliente
#!usr/bin/python
# -*- coding: utf-8 -*-
# author: 李爽
# description：tcp 套接字客户端
import socket
def main():
# 创建tcp套接字
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务器
s.connect(("127.0.0.1", 8080))
# 发送数据
send_msg = input("请输入要发送的信息：")
s.send(send_msg.encode("utf-8"))
# 接收数据
recv_data = s.recv(1024)
print("从服务器接收到的数据为：%s" % recv_data.decode("utf-8"))
# 关闭套接字
s.close()
if __name__ == "__main__":
main()
bucle sin fin se puede añadir en el lado servidor, el ciclo de mensajes de recepción. No se describen. Tenga en cuenta que
- servidor TCP necesita unirse, de lo contrario el cliente no puede conectar el servidor
- cliente TCP en general no es vinculante, ya que la iniciativa está vinculada servidor, por lo que acaba de hacer IP del servidor seguro de la buena, el puerto y otra información como el cliente local puede azar
- TCP socket de escucha del servidor a través del zócalo puede ser creado a partir de la iniciativa se convertirá en un pasivo, esto se debe hacer cuando se hace servidores TCP
- Cuando un cliente necesita servidor vinculado, es necesario enlace de conexión, UDP es, pero no tiene por qué estar relacionado directamente, sino que debe ser tcp enlace, solamente un enlace para el éxito de la comunicación
- Cuando un cliente TCP conectar al servidor, el servidor será un nuevo socket, el socket utilizado para marcar el cliente, el servicio al cliente es de forma individual
- Después de la toma de corriente pasiva socket de escucha para recibir la nueva petición de enlace del cliente, y devuelve la nueva toma de aceptar este nuevo marcador cliente
- Tras el cierre escuchar sockets significan socket pasivo es cerrado, y dará lugar a un nuevo cliente no es capaz de servidores de enlace, pero ha sido previamente vinculado el éxito del cliente comunicarse correctamente.
- Cerrar aceptar la devolución de los medios de casquillo que el cliente ha completado el servicio
- Cuando los pelos socket de cliente, servidor recv se obstruye la solución, y la longitud devuelto es cero, por lo que el servidor puede ser discriminado si el cliente tiene la longitud de los datos devueltos por la línea
epílogo
Sobre esta programación de sockets ha terminado.
Si encontrar mis artículos en los que hay un error o tiene alguna buenas ideas pueden ponerse en contacto conmigo, estudiamos juntos progresar juntos, mi dirección de correo electrónico está [email protected]
Vamos a hacer más de esos!
