Сокеты Python: мощный инструмент для создания эффективных сетевых приложений

import socket

# Создание TCP сокета для IPv4
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Создание UDP сокета для IPv4
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

import socket

# Создаем TCP/IP сокет
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Привязываем сокет к адресу и порту
server_address = ('localhost', 8000)
server_socket.bind(server_address)

# Начинаем прослушивать соединения (очередь до 5 подключений)
server_socket.listen(5)
print(f"Сервер запущен на {server_address[0]}:{server_address[1]}")

while True:
# Ожидаем соединения
client_socket, client_address = server_socket.accept()
print(f"Подключение с {client_address}")

try:
# Получаем данные от клиента
data = client_socket.recv(1024)
print(f"Получено: {data.decode('utf-8')}")

# Отправляем ответ
client_socket.sendall("Сообщение получено".encode('utf-8'))
finally:
# Закрываем соединение
client_socket.close()

import socket

# Создаем сокет
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Подключаемся к серверу
server_address = ('localhost', 8000)
client_socket.connect(server_address)

try:
# Отправляем данные
message = "Привет, сервер!"
client_socket.sendall(message.encode('utf-8'))

# Получаем ответ
data = client_socket.recv(1024)
print(f"Получено: {data.decode('utf-8')}")

finally:
# Закрываем соединение
client_socket.close()

server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

import socket

# Создаем UDP сокет
server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# Привязываем к адресу и порту
server_address = ('localhost', 9000)
server_socket.bind(server_address)

print(f"UDP сервер запущен на {server_address[0]}:{server_address[1]}")

while True:
# Получаем данные и адрес отправителя
data, client_address = server_socket.recvfrom(1024)
print(f"Получено {len(data)} байт от {client_address}")
print(f"Данные: {data.decode('utf-8')}")

# Отправляем ответ
response = f"Получено {len(data)} байт"
server_socket.sendto(response.encode('utf-8'), client_address)

import socket

# Создаем UDP сокет
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# Устанавливаем таймаут
client_socket.settimeout(1.0)

# Адрес сервера
server_address = ('localhost', 9000)
message = "Это тестовое UDP сообщение"

try:
# Отправляем данные
bytes_sent = client_socket.sendto(message.encode('utf-8'), server_address)
print(f"Отправлено {bytes_sent} байт")

# Получаем ответ
data, server = client_socket.recvfrom(1024)
print(f"Получено от сервера: {data.decode('utf-8')}")

except socket.timeout:
print("Тайм-аут при ожидании ответа")

finally:
client_socket.close()

import socket
import time

def connect_with_retry(host, port, max_attempts=3):
for attempt in range(max_attempts):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(5) # 5 секунд таймаут
sock.connect((host, port))
return sock
except ConnectionRefusedError:
print(f"Попытка {attempt+1}/{max_attempts}: Соединение отказано")
except socket.timeout:
print(f"Попытка {attempt+1}/{max_attempts}: Тайм-аут соединения")
except OSError as e:
print(f"Попытка {attempt+1}/{max_attempts}: Ошибка {e}")

if attempt < max_attempts – 1:
time.sleep(2) # Пауза перед повторной попыткой

raise ConnectionError("Не удалось установить соединение после нескольких попыток")

try:
client_socket = connect_with_retry('localhost', 8000)
# Работа с сокетом...
client_socket.close()
except ConnectionError as e:
print(f"Критическая ошибка: {e}")

import socket
import threading

def handle_client(client_socket, address):
print(f"Новое соединение от {address}")
try:
while True:
try:
data = client_socket.recv(1024)
if not data:
print(f"Клиент {address} закрыл соединение")
break

print(f"Получено от {address}: {data.decode('utf-8')}")
client_socket.sendall("Получено".encode('utf-8'))

except ConnectionResetError:
print(f"Соединение с {address} было сброшено")
break
except socket.timeout:
print(f"Тайм-аут при чтении от {address}")
continue

except Exception as e:
print(f"Ошибка при обработке клиента {address}: {e}")
finally:
client_socket.close()
print(f"Соединение с {address} закрыто")

def start_server(host, port):
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

try:
server_socket.bind((host, port))
server_socket.listen(5)
print(f"Сервер запущен на {host}:{port}")

while True:
try:
client_socket, address = server_socket.accept()
client_socket.settimeout(60) # 60 секунд таймаут на операции с клиентом

# Создаем новый поток для обработки клиента
client_thread = threading.Thread(
target=handle_client,
args=(client_socket, address)
)
client_thread.daemon = True # Фоновый поток
client_thread.start()

except Exception as e:
print(f"Ошибка при принятии соединения: {e}")

except KeyboardInterrupt:
print("Сервер останавливается...")
finally:
server_socket.close()

if __name__ == "__main__":
start_server('localhost', 8000)

from concurrent.futures import ThreadPoolExecutor

# В функции start_server
with ThreadPoolExecutor(max_workers=20) as executor:
while True:
client_socket, address = server_socket.accept()
client_socket.settimeout(60)
executor.submit(handle_client, client_socket, address)

import socket
import threading
import select

class ChatServer:
def __init__(self, host='localhost', port=9090):
self.host = host
self.port = port
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server_socket.bind((self.host, self.port))
self.server_socket.listen(5)

self.clients = []
self.nicknames = {}

print(f"Чат-сервер запущен на {self.host}:{self.port}")

def broadcast(self, message, sender_socket=None):
for client in self.clients:
if client != sender_socket:
try:
client.send(message)
except:
# Удаляем клиента при проблеме с отправкой
self.clients.remove(client)

def handle_client(self, client_socket, address):
try:
# Запрашиваем ник пользователя
client_socket.send("NICK?".encode('utf-8'))
nickname = client_socket.recv(1024).decode('utf-8')
self.nicknames[client_socket] = nickname

# Уведомляем о новом пользователе
self.clients.append(client_socket)
self.broadcast(f"{nickname} присоединился к чату!".encode('utf-8'))

while True:
try:
message = client_socket.recv(1024)
if message:
self.broadcast(f"{nickname}: {message.decode('utf-8')}".encode('utf-8'), client_socket)
else:
# Пустое сообщение означает, что клиент отключился
raise Exception("Клиент отключился")
except:
# Удаляем и оповещаем об отключении клиента
self.clients.remove(client_socket)
nickname = self.nicknames.pop(client_socket, "Неизвестный")
self.broadcast(f"{nickname} покинул чат!".encode('utf-8'))
client_socket.close()
break
except Exception as e:
print(f"Ошибка: {e}")

def run(self):
try:
while True:
client_socket, address = self.server_socket.accept()
thread = threading.Thread(
target=self.handle_client,
args=(client_socket, address)
)
thread.daemon = True
thread.start()
except KeyboardInterrupt:
print("Сервер остановлен")
finally:
self.server_socket.close()

if __name__ == "__main__":
server = ChatServer()
server.run()

import socket
import threading
import tkinter as tk
from tkinter import scrolledtext, Entry, Button

class ChatClient:
def __init__(self, host='localhost', port=9090):
self.host = host
self.port = port
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.nickname = ""

# Создаем GUI
self.root = tk.Tk()
self.root.title("Python Чат")
self.root.geometry("400x500")

# Область чата
self.chat_area = scrolledtext.ScrolledText(self.root, wrap=tk.WORD, state='disabled')
self.chat_area.pack(padx=10, pady=10, fill=tk.BOTH, expand=True)

# Ввод сообщения
self.msg_frame = tk.Frame(self.root)
self.msg_frame.pack(padx=10, pady=5, fill=tk.X)

self.msg_entry = Entry(self.msg_frame)
self.msg_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)

self.send_button = Button(self.msg_frame, text="Отправить", command=self.send_message)
self.send_button.pack(side=tk.RIGHT)

self.root.protocol("WM_DELETE_WINDOW", self.on_closing)

def connect(self):
try:
self.sock.connect((self.host, self.port))

# Запрос и отправка никнейма
server_request = self.sock.recv(1024).decode('utf-8')
if server_request == "NICK?":
self.nickname = input("Введите ваш ник: ")
self.sock.send(self.nickname.encode('utf-8'))

# Запускаем поток для приема сообщений
receive_thread = threading.Thread(target=self.receive_messages)
receive_thread.daemon = True
receive_thread.start()

self.root.mainloop()

except Exception as e:
print(f"Ошибка подключения: {e}")
self.root.destroy()

def receive_messages(self):
while True:
try:
message = self.sock.recv(1024).decode('utf-8')
self.update_chat(message)
except:
print("Ошибка при получении сообщения")
self.sock.close()
break

def update_chat(self, message):
self.chat_area.config(state='normal')
self.chat_area.insert(tk.END, message + "\n")
self.chat_area.config(state='disabled')
self.chat_area.yview(tk.END)

def send_message(self):
message = self.msg_entry.get()
if message:
try:
self.sock.send(message.encode('utf-8'))
self.msg_entry.delete(0, tk.END)
except:
self.update_chat("Сообщение не отправлено")

def on_closing(self):
try:
self.sock.close()
except:
pass
self.root.destroy()

if __name__ == "__main__":
client = ChatClient()
client.connect()

# Серверная часть
import socket
import os
import threading

class FileServer:
def __init__(self, host='0.0.0.0', port=9999, file_dir='./shared_files'):
self.host = host
self.port = port
self.file_dir = file_dir
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# Создаем директорию, если не существует
if not os.path.exists(file_dir):
os.makedirs(file_dir)

def handle_client(self, client_socket, address):
try:
# Получаем команду: LIST, GET или PUT
command = client_socket.recv(1024).decode('utf-8')

if command.startswith("LIST"):
# Отправляем список файлов
files = os.listdir(self.file_dir)
client_socket.send((",".join(files) or "Нет доступных файлов").encode('utf-8'))

elif command.startswith("GET"):
# Отправляем файл клиенту
_, filename = command.split("|")
file_path = os.path.join(self.file_dir, filename)

if os.path.exists(file_path):
# Отправляем размер файла
file_size = os.path.getsize(file_path)
client_socket.send(f"SIZE|{file_size}".encode('utf-8'))
client_socket.recv(1024) # Подтверждение от клиента

# Отправляем файл
with open(file_path, 'rb') as f:
data = f.read(4096)
while data:
client_socket.send(data)
data = f.read(4096)
else:
client_socket.send("ERROR|Файл не найден".encode('utf-8'))

elif command.startswith("PUT"):
# Получаем файл от клиента
_, filename, size = command.split("|")
file_size = int(size)

# Подтверждаем готовность к приему
client_socket.send("READY".encode('utf-8'))

# Получаем и сохраняем файл
file_path = os.path.join(self.file_dir, filename)
received = 0

with open(file_path, 'wb') as f:
while received < file_size:
data = client_socket.recv(min(4096, file_size – received))
if not data:
break
f.write(data)
received += len(data)

client_socket.send("SUCCESS".encode('utf-8'))

except Exception as e:
print(f"Ошибка при обработке запроса от {address}: {e}")
finally:
client_socket.close()

def start(self):
try:
self.server_socket.bind((self.host, self.port))
self.server_socket.listen(5)
print(f"Файловый сервер запущен на {self.host}:{self.port}")

while True:
client_socket, address = self.server_socket.accept()
print(f"Подключение с {address}")

client_thread = threading.Thread(
target=self.handle_client,
args=(client_socket, address)
)
client_thread.daemon = True
client_thread.start()

except KeyboardInterrupt:
print("Сервер остановлен")
except Exception as e:
print(f"Ошибка сервера: {e}")
finally:
self.server_socket.close()

if __name__ == "__main__":
server = FileServer()
server.start()