Ổ cắm và API ổ cắm được sử dụng để gửi tin nhắn qua mạng. Họ cung cấp một hình thức giao tiếp giữa các quá trình [IPC]. Mạng có thể là mạng cục bộ, hợp lý với máy tính hoặc mạng được kết nối vật lý với mạng bên ngoài, có kết nối riêng với các mạng khác. Ví dụ rõ ràng là Internet mà bạn kết nối thông qua ISP của mình
Trong hướng dẫn này, bạn sẽ tạo
- Một máy chủ và máy khách ổ cắm đơn giản
- Phiên bản cải tiến xử lý đồng thời nhiều kết nối
- Một ứng dụng máy chủ-máy khách có chức năng giống như một ứng dụng ổ cắm chính thức, hoàn chỉnh với tiêu đề và nội dung tùy chỉnh của riêng nó
Đến cuối hướng dẫn này, bạn sẽ hiểu cách sử dụng các hàm và phương thức chính trong mô-đun socket của Python để viết các ứng dụng máy khách-máy chủ của riêng bạn. Bạn sẽ biết cách sử dụng lớp tùy chỉnh để gửi tin nhắn và dữ liệu giữa các điểm cuối mà bạn có thể xây dựng và sử dụng cho các ứng dụng của riêng mình
Các ví dụ trong hướng dẫn này yêu cầu Python 3. 6 trở lên và đã được thử nghiệm bằng Python 3. 10. Để tận dụng tối đa hướng dẫn này, tốt nhất bạn nên tải xuống mã nguồn và có sẵn nó để tham khảo khi đọc
Nhận mã nguồn. Nhấp vào đây để lấy mã nguồn mà bạn sẽ sử dụng cho các ví dụ trong hướng dẫn này
Mạng và ổ cắm là những chủ đề lớn. Khối lượng văn học đã được viết về họ. Nếu bạn chưa quen với ổ cắm hoặc kết nối mạng, việc bạn cảm thấy choáng ngợp với tất cả các thuật ngữ và phần là hoàn toàn bình thường.
Đừng nản lòng mặc dù. Hướng dẫn này là dành cho bạn. Như với bất kỳ thứ gì liên quan đến Python, bạn có thể học từng chút một. Đánh dấu bài viết này và quay lại khi bạn đã sẵn sàng cho phần tiếp theo
Tiểu sử
Ổ cắm có một lịch sử lâu dài. Việc sử dụng chúng bắt nguồn từ ARPANET vào năm 1971 và sau đó trở thành API trong hệ điều hành Phân phối phần mềm Berkeley [BSD] phát hành năm 1983 được gọi là ổ cắm Berkeley
Khi Internet cất cánh vào những năm 1990 với World Wide Web, lập trình mạng cũng vậy. Máy chủ và trình duyệt web không phải là ứng dụng duy nhất tận dụng các mạng mới được kết nối và sử dụng ổ cắm. Các ứng dụng máy khách-máy chủ thuộc mọi loại và kích cỡ được sử dụng rộng rãi
Ngày nay, mặc dù các giao thức cơ bản được sử dụng bởi API ổ cắm đã phát triển qua nhiều năm và các giao thức mới đã được phát triển, nhưng API cấp thấp vẫn giữ nguyên
Loại ứng dụng ổ cắm phổ biến nhất là ứng dụng máy khách-máy chủ, trong đó một bên đóng vai trò là máy chủ và chờ kết nối từ máy khách. Đây là loại ứng dụng mà bạn sẽ tạo trong hướng dẫn này. Cụ thể hơn, bạn sẽ tập trung vào API ổ cắm cho ổ cắm Internet, đôi khi được gọi là ổ cắm Berkeley hoặc BSD. Ngoài ra còn có các ổ cắm tên miền Unix, chỉ có thể được sử dụng để giao tiếp giữa các quy trình trên cùng một máy chủ
Loại bỏ các quảng cáoTổng quan về API ổ cắm
Mô-đun ổ cắm của Python cung cấp giao diện cho API ổ cắm Berkeley. Đây là mô-đun mà bạn sẽ sử dụng trong hướng dẫn này
Các hàm và phương thức API ổ cắm chính trong mô-đun này là
8$ python echo-server.py
9$ python echo-server.py
0# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
1# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
2# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
3# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
4# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
5# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
6# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
Python cung cấp một API thuận tiện và nhất quán ánh xạ trực tiếp tới các lệnh gọi hệ thống, các đối tác C của chúng. Trong phần tiếp theo, bạn sẽ tìm hiểu cách chúng được sử dụng cùng nhau
Là một phần của thư viện chuẩn, Python cũng có các lớp giúp sử dụng các hàm ổ cắm cấp thấp này dễ dàng hơn. Mặc dù nó không được đề cập trong hướng dẫn này, nhưng bạn có thể xem mô-đun socketserver, một khung dành cho máy chủ mạng. Ngoài ra còn có nhiều mô-đun triển khai các giao thức Internet cấp cao hơn như HTTP và SMTP. Để biết tổng quan, hãy xem Hỗ trợ và Giao thức Internet
ổ cắm TCP
Bạn sẽ tạo một đối tượng ổ cắm bằng cách sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Tại sao bạn nên sử dụng TCP?
- Đáng tin cậy. Các gói bị rơi trong mạng được phát hiện và truyền lại bởi người gửi
- Có phân phối dữ liệu theo thứ tự. Dữ liệu được đọc bởi ứng dụng của bạn theo thứ tự được viết bởi người gửi
Ngược lại, ổ cắm Giao thức gói dữ liệu người dùng [UDP] được tạo bằng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Tại sao nó quan trọng? . Không có gì đảm bảo rằng dữ liệu của bạn sẽ đến đích hoặc bạn sẽ nhận được những gì đã được gửi cho bạn
Các thiết bị mạng, chẳng hạn như bộ định tuyến và bộ chuyển mạch, có sẵn băng thông hữu hạn và đi kèm với các giới hạn hệ thống vốn có của riêng chúng. Chúng có CPU, bộ nhớ, bus và bộ đệm gói giao diện, giống như máy khách và máy chủ của bạn. TCP giúp bạn không phải lo lắng về việc mất gói, dữ liệu đến không theo thứ tự và các cạm bẫy khác luôn xảy ra khi bạn liên lạc qua mạng
Để hiểu rõ hơn về điều này, hãy xem trình tự lệnh gọi API ổ cắm và luồng dữ liệu cho TCP
Cột bên trái đại diện cho máy chủ. Ở phía bên tay phải là khách hàng
Bắt đầu từ cột trên cùng bên trái, hãy lưu ý các lệnh gọi API mà máy chủ thực hiện để thiết lập ổ cắm “nghe”
8$ python echo-server.py
9$ python echo-server.py
0# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
1# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
Ổ cắm nghe thực hiện đúng như tên gọi của nó. Nó lắng nghe các kết nối từ khách hàng. Khi máy khách kết nối, máy chủ gọi
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Máy khách gọi
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Ở giữa là phần khứ hồi, nơi dữ liệu được trao đổi giữa máy khách và máy chủ bằng cách gọi tới
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Ở phía dưới, máy khách và máy chủ đóng các ổ cắm tương ứng của chúng
Loại bỏ các quảng cáoMáy khách và máy chủ Echo
Bây giờ bạn đã có cái nhìn tổng quan về API socket và cách máy khách và máy chủ giao tiếp với nhau, bạn đã sẵn sàng để tạo máy khách và máy chủ đầu tiên của mình. Bạn sẽ bắt đầu với một triển khai đơn giản. Máy chủ sẽ chỉ lặp lại bất cứ điều gì nó nhận được trở lại máy khách
Máy chủ tiếng vang
Đây là máy chủ
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Ghi chú. Đừng lo lắng về việc hiểu mọi thứ ở trên ngay bây giờ. Có rất nhiều thứ đang diễn ra trong vài dòng mã này. Đây chỉ là điểm khởi đầu để bạn có thể thấy một máy chủ cơ bản đang hoạt động
Có một phần tham khảo ở cuối hướng dẫn này có thêm thông tin và liên kết đến các tài nguyên bổ sung. Bạn cũng sẽ tìm thấy những liên kết này và các liên kết hữu ích khác trong suốt hướng dẫn
Được rồi, vậy chính xác điều gì đang xảy ra trong lệnh gọi API?
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Các đối số được truyền cho
$ python echo-server.py
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Phương pháp
$ python echo-server.py
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Các giá trị được chuyển đến
$ python echo-server.py
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đây là một lưu ý về việc sử dụng tên máy chủ với
$ python echo-server.py
“Nếu bạn sử dụng tên máy chủ trong phần máy chủ của địa chỉ ổ cắm IPv4/v6, chương trình có thể hiển thị hành vi không xác định, vì Python sử dụng địa chỉ đầu tiên được trả về từ độ phân giải DNS. Địa chỉ ổ cắm sẽ được phân giải khác thành địa chỉ IPv4/v6 thực tế, tùy thuộc vào kết quả từ độ phân giải DNS và/hoặc cấu hình máy chủ. Đối với hành vi xác định, hãy sử dụng địa chỉ số trong phần máy chủ. " [Nguồn]
Bạn sẽ tìm hiểu thêm về điều này sau, trong Sử dụng tên máy chủ. Hiện tại, bạn chỉ cần hiểu rằng khi sử dụng tên máy chủ, bạn có thể thấy các kết quả khác nhau tùy thuộc vào những gì được trả về từ quá trình phân giải tên. Những kết quả này có thể là bất cứ điều gì. Lần đầu tiên bạn chạy ứng dụng của mình, bạn có thể nhận được địa chỉ
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Trong ví dụ máy chủ,
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Phương thức
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nếu máy chủ của bạn nhận được nhiều yêu cầu kết nối đồng thời, việc tăng giá trị
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Phương thức
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Một điều bắt buộc phải hiểu là bây giờ bạn có một đối tượng ổ cắm mới từ
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Sau khi
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nếu
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Máy khách Echo
Bây giờ hãy nhìn vào khách hàng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
So với máy chủ, máy khách khá đơn giản. Nó tạo một đối tượng ổ cắm, sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Chạy máy khách và máy chủ Echo
Trong phần này, bạn sẽ chạy máy khách và máy chủ để xem cách chúng hoạt động và kiểm tra điều gì đang xảy ra
Ghi chú. Nếu bạn gặp khó khăn khi lấy các ví dụ hoặc mã của riêng mình để chạy từ dòng lệnh, hãy đọc Làm cách nào để tôi tạo các lệnh dòng lệnh của riêng mình bằng Python? . Nếu bạn đang sử dụng Windows, hãy xem Câu hỏi thường gặp về Windows về Python
Mở một thiết bị đầu cuối hoặc dấu nhắc lệnh, điều hướng đến thư mục chứa tập lệnh của bạn, đảm bảo rằng bạn có Python 3. 6 trở lên được cài đặt và trên đường dẫn của bạn, sau đó chạy máy chủ
$ python echo-server.py
Thiết bị đầu cuối của bạn sẽ xuất hiện để treo. Đó là do máy chủ bị chặn hoặc bị treo vào ngày
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nó đang chờ kết nối máy khách. Bây giờ, hãy mở một cửa sổ đầu cuối khác hoặc dấu nhắc lệnh và chạy ứng dụng khách
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Trong cửa sổ máy chủ, bạn sẽ nhận thấy một cái gì đó như thế này
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Trong kết quả ở trên, máy chủ đã in bộ dữ liệu
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Xem trạng thái ổ cắm
Để xem trạng thái hiện tại của ổ cắm trên máy chủ của bạn, hãy sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đây là đầu ra netstat từ macOS sau khi khởi động máy chủ
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Lưu ý rằng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
$ python echo-server.py
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đầu ra ở trên được cắt bớt để chỉ hiển thị máy chủ tiếng vang. Bạn có thể sẽ thấy nhiều đầu ra hơn, tùy thuộc vào hệ thống mà bạn đang chạy nó. Những điều cần chú ý là các cột
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Một cách khác để truy cập điều này, cùng với thông tin hữu ích bổ sung, là sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đây là một lỗi phổ biến mà bạn sẽ gặp phải khi thử kết nối với một cổng không có ổ cắm nghe
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Số cổng được chỉ định sai hoặc máy chủ không chạy. Hoặc có thể có tường lửa trong đường dẫn đang chặn kết nối, điều này có thể dễ dàng bị quên. Bạn cũng có thể thấy lỗi
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Có một danh sách các lỗi phổ biến trong phần tham khảo
Loại bỏ các quảng cáosự cố truyền thông
Bây giờ bạn sẽ xem xét kỹ hơn cách máy khách và máy chủ giao tiếp với nhau
Khi sử dụng giao diện loopback [địa chỉ IPv4
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Các ứng dụng sử dụng giao diện loopback để liên lạc với các quy trình khác đang chạy trên máy chủ và để bảo mật và cách ly với mạng bên ngoài. Bởi vì nó là nội bộ và chỉ có thể truy cập từ bên trong máy chủ nên nó không bị lộ
Bạn có thể thấy điều này đang hoạt động nếu bạn có một máy chủ ứng dụng sử dụng cơ sở dữ liệu riêng của nó. Nếu nó không phải là cơ sở dữ liệu được sử dụng bởi các máy chủ khác, thì nó có thể được định cấu hình để chỉ lắng nghe các kết nối trên giao diện loopback. Nếu đây là trường hợp, các máy chủ khác trên mạng không thể kết nối với nó
Khi bạn sử dụng địa chỉ IP không phải là
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Hãy cẩn thận ở ngoài đó. Đó là một thế giới khó chịu, tàn nhẫn. Hãy nhớ đọc phần Sử dụng tên máy chủ trước khi mạo hiểm thoát khỏi giới hạn an toàn của “localhost. ” Có một lưu ý bảo mật áp dụng ngay cả khi bạn không sử dụng tên máy chủ mà chỉ sử dụng địa chỉ IP
Xử lý nhiều kết nối
Máy chủ echo chắc chắn có những hạn chế của nó. Cái lớn nhất là nó chỉ phục vụ một khách hàng và sau đó thoát. Ứng dụng khách echo cũng có giới hạn này, nhưng có một vấn đề khác. Khi máy khách sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đối số
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Phương thức
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
“Các ứng dụng có trách nhiệm kiểm tra xem tất cả dữ liệu đã được gửi chưa; . " [Nguồn]
Trong ví dụ trên, bạn tránh phải làm điều này bằng cách sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
“Không giống như send[], phương thức này tiếp tục gửi dữ liệu từ byte cho đến khi tất cả dữ liệu đã được gửi hoặc xảy ra lỗi.
484 được trả lại khi thành công. " [Nguồn]# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
Bạn có hai vấn đề tại thời điểm này
- Làm thế nào để bạn xử lý nhiều kết nối đồng thời?
- Bạn cần gọi
4 và# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
5 cho đến khi tất cả dữ liệu được gửi hoặc nhận# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
Bạn có thể làm gì? . Một cách tiếp cận phổ biến là sử dụng I/O không đồng bộ.
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Rắc rối với đồng thời là rất khó để hiểu đúng. Có nhiều điều tế nhị để xem xét và đề phòng. Tất cả những gì cần làm là để một trong số này tự hiển thị và ứng dụng của bạn có thể đột nhiên bị lỗi theo những cách không mấy tế nhị
Điều này không có nghĩa là làm bạn sợ hãi khi học và sử dụng lập trình đồng thời. Nếu ứng dụng của bạn cần mở rộng quy mô, thì đó là điều cần thiết nếu bạn muốn sử dụng nhiều bộ xử lý hoặc một lõi. Tuy nhiên, đối với hướng dẫn này, bạn sẽ sử dụng thứ gì đó thậm chí còn truyền thống hơn các chủ đề và dễ suy luận hơn. Bạn sẽ sử dụng các cuộc gọi hệ thống.
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Phương pháp
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
“Mô-đun này cho phép ghép kênh I/O ở mức độ cao và hiệu quả, được xây dựng dựa trên các nguyên mẫu mô-đun đã chọn. Thay vào đó, người dùng được khuyến khích sử dụng mô-đun này, trừ khi họ muốn kiểm soát chính xác các nguyên mẫu cấp hệ điều hành được sử dụng. " [Nguồn]
Tuy nhiên, bằng cách sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đây là tất cả để nói rằng sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nếu bạn đang nhận được yêu cầu từ các máy khách bắt đầu công việc liên kết với CPU, hãy xem đồng thời. mô-đun tương lai. Nó chứa lớp ProcessPoolExecutor, sử dụng một nhóm các quy trình để thực hiện các lệnh gọi không đồng bộ
Nếu bạn sử dụng nhiều quy trình, hệ điều hành có thể lên lịch mã Python của bạn để chạy song song trên nhiều bộ xử lý hoặc lõi mà không cần GIL. Để có ý tưởng và cảm hứng, hãy xem buổi nói chuyện về PyCon John Reese - Tư duy bên ngoài GIL với AsyncIO và Đa xử lý - PyCon 2018
Trong phần tiếp theo, bạn sẽ xem xét các ví dụ về máy chủ và máy khách giải quyết những vấn đề này. Họ sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Máy khách và máy chủ đa kết nối
Trong hai phần tiếp theo, bạn sẽ tạo một máy chủ và máy khách xử lý nhiều kết nối bằng cách sử dụng đối tượng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Máy chủ đa kết nối
Đầu tiên, hướng sự chú ý của bạn đến máy chủ đa kết nối. Phần đầu tiên thiết lập ổ cắm nghe
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Sự khác biệt lớn nhất giữa máy chủ này và máy chủ echo là lệnh gọi tới
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Để lưu trữ bất kỳ dữ liệu tùy ý nào bạn muốn cùng với ổ cắm, bạn sẽ sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Tiếp theo là vòng lặp sự kiện
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Khối
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nếu
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nếu
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đây là chức năng của hàm
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Bởi vì ổ cắm nghe đã được đăng ký cho sự kiện
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Hãy nhớ rằng, đây là mục tiêu chính trong phiên bản máy chủ này vì bạn không muốn nó bị chặn. Nếu nó chặn, thì toàn bộ máy chủ sẽ bị đình trệ cho đến khi nó hoạt động trở lại. Điều đó có nghĩa là các ổ cắm khác đang chờ mặc dù máy chủ không hoạt động tích cực. Đây là trạng thái “treo” đáng sợ mà bạn không muốn máy chủ của mình gặp phải
Tiếp theo, bạn tạo một đối tượng để chứa dữ liệu mà bạn muốn đưa vào cùng với ổ cắm bằng cách sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Sau đó, các đối tượng mặt nạ, ổ cắm và dữ liệu của
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Bây giờ hãy xem
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đây là trái tim của máy chủ đa kết nối đơn giản.
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nếu ổ cắm đã sẵn sàng để đọc, thì
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Lưu ý khối
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nếu không nhận được dữ liệu, điều này có nghĩa là máy khách đã đóng ổ cắm của họ, vì vậy máy chủ cũng vậy. Nhưng đừng quên gọi cho
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Khi ổ cắm đã sẵn sàng để ghi, đây luôn là trường hợp đối với ổ cắm khỏe mạnh, mọi dữ liệu đã nhận được lưu trữ trong
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Phương thức
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Máy khách đa kết nối
Bây giờ hãy xem ứng dụng khách đa kết nối,
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Bạn sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Sau khi ổ cắm được thiết lập, dữ liệu bạn muốn lưu trữ với ổ cắm được tạo bằng cách sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Kiểm tra các thay đổi được thực hiện từ
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Về cơ bản là giống nhau nhưng có một điểm khác biệt quan trọng. Máy khách theo dõi số byte mà nó nhận được từ máy chủ để có thể đóng phần kết nối của nó. Khi máy chủ phát hiện ra điều này, nó cũng sẽ đóng phần kết nối của nó
Lưu ý rằng bằng cách này, máy chủ phụ thuộc vào máy khách có hoạt động tốt không. máy chủ yêu cầu máy khách đóng phía kết nối của nó khi gửi tin nhắn xong. Nếu máy khách không đóng, máy chủ sẽ để kết nối mở. Trong một ứng dụng thực tế, bạn có thể muốn bảo vệ chống lại điều này trong máy chủ của mình bằng cách triển khai thời gian chờ để ngăn các kết nối máy khách tích lũy nếu chúng không gửi yêu cầu sau một khoảng thời gian nhất định
Chạy máy khách và máy chủ đa kết nối
Bây giờ là lúc để chạy
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đối với máy chủ, hãy chuyển số
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đối với máy khách, cũng chuyển số lượng kết nối cần tạo tới máy chủ,
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Dưới đây là đầu ra của máy chủ khi nghe trên giao diện loopback trên cổng 65432
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Dưới đây là đầu ra của máy khách khi nó tạo hai kết nối đến máy chủ ở trên
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Tuyệt quá. Bây giờ bạn đã chạy máy khách và máy chủ đa kết nối. Trong phần tiếp theo, bạn sẽ sử dụng ví dụ này nhiều hơn nữa
Loại bỏ các quảng cáoMáy khách và máy chủ ứng dụng
Ví dụ về máy khách và máy chủ đa kết nối chắc chắn là một cải tiến so với nơi bạn bắt đầu. Tuy nhiên, bây giờ bạn có thể thực hiện thêm một bước nữa và giải quyết những thiếu sót của ví dụ
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Bạn muốn có một máy khách và máy chủ xử lý lỗi một cách thích hợp để các kết nối khác không bị ảnh hưởng. Rõ ràng, máy khách hoặc máy chủ của bạn sẽ không bị sập trong cơn thịnh nộ nếu một ngoại lệ không bị phát hiện. Đây là điều mà bạn không phải lo lắng cho đến bây giờ, bởi vì các ví dụ đã cố tình bỏ qua việc xử lý lỗi để cho ngắn gọn và rõ ràng
Bây giờ bạn đã quen thuộc với API cơ bản, ổ cắm không chặn và
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đầu tiên, bạn sẽ giải quyết các lỗi
“Tất cả các lỗi đều có ngoại lệ. Các ngoại lệ thông thường đối với các loại đối số không hợp lệ và các điều kiện hết bộ nhớ có thể được nêu ra; . 3, các lỗi liên quan đến ngữ nghĩa ổ cắm hoặc địa chỉ nâng cao
970 hoặc một trong các lớp con của nó. " [Nguồn]# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
Vì vậy, một điều bạn cần làm là bắt
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Còn con voi trong phòng thì sao? . Nó giống như đọc từ một tệp trên đĩa, nhưng thay vào đó bạn đang đọc các byte từ mạng. Tuy nhiên, không giống như đọc tệp, không có
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nói cách khác, bạn không thể định vị lại con trỏ ổ cắm, nếu có và di chuyển xung quanh dữ liệu
Khi byte đến ổ cắm của bạn, có bộ đệm mạng liên quan. Sau khi bạn đã đọc chúng, chúng cần được lưu ở đâu đó, nếu không bạn sẽ đánh rơi chúng. Gọi lại
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Bạn sẽ đọc từ ổ cắm theo khối. Vì vậy, bạn cần gọi
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Tùy thuộc vào bạn để xác định và theo dõi vị trí của ranh giới tin nhắn. Đối với ổ cắm TCP, nó chỉ gửi và nhận các byte thô đến và từ mạng. Nó không biết gì về ý nghĩa của những byte thô đó
Đây là lý do tại sao bạn cần xác định giao thức tầng ứng dụng. Giao thức tầng ứng dụng là gì? . Định dạng của những thông báo này là giao thức của ứng dụng của bạn
Nói cách khác, độ dài và định dạng mà bạn chọn cho các thông báo này sẽ xác định ngữ nghĩa và hành vi của ứng dụng của bạn. Điều này liên quan trực tiếp đến những gì bạn đã học trong đoạn trước về việc đọc byte từ ổ cắm. Khi bạn đang đọc các byte bằng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Làm thế nào bạn có thể làm điều này? . Nếu chúng luôn có cùng kích thước, thì thật dễ dàng. Khi bạn đã đọc số byte đó vào bộ đệm, thì bạn biết mình có một thông báo hoàn chỉnh
Tuy nhiên, việc sử dụng các tin nhắn có độ dài cố định sẽ không hiệu quả đối với các tin nhắn nhỏ mà bạn cần sử dụng phần đệm để điền vào chúng. Ngoài ra, bạn vẫn gặp phải vấn đề phải làm gì với dữ liệu không phù hợp với một tin nhắn
Trong hướng dẫn này, bạn sẽ học một cách tiếp cận chung, một cách tiếp cận được sử dụng bởi nhiều giao thức, bao gồm cả HTTP. Bạn sẽ thêm tiền tố vào thư với tiêu đề bao gồm độ dài nội dung cũng như bất kỳ trường nào khác mà bạn cần. Bằng cách này, bạn sẽ chỉ cần theo kịp tiêu đề. Khi bạn đã đọc tiêu đề, bạn có thể xử lý nó để xác định độ dài của nội dung thư. Với độ dài nội dung, bạn có thể đọc số byte đó để sử dụng nó
Bạn sẽ thực hiện điều này bằng cách tạo một lớp tùy chỉnh có thể gửi và nhận tin nhắn chứa dữ liệu văn bản hoặc nhị phân. Bạn có thể cải thiện và mở rộng lớp này cho các ứng dụng của riêng mình. Điều quan trọng nhất là bạn sẽ có thể xem một ví dụ về cách thực hiện điều này
Trước khi bắt đầu, có một số điều bạn cần biết về socket và byte. Như bạn đã biết trước đó, khi gửi và nhận dữ liệu qua socket, bạn đang gửi và nhận các byte thô
Nếu bạn nhận được dữ liệu và muốn sử dụng dữ liệu đó trong ngữ cảnh mà dữ liệu đó được hiểu là nhiều byte, chẳng hạn như số nguyên 4 byte, bạn sẽ cần tính đến việc dữ liệu đó có thể ở định dạng không có nguồn gốc từ CPU của máy bạn. Máy khách hoặc máy chủ ở đầu bên kia có thể có CPU sử dụng thứ tự byte khác với thứ tự byte của bạn. Nếu trường hợp này xảy ra, thì bạn sẽ cần chuyển đổi nó thành thứ tự byte gốc của máy chủ trước khi sử dụng
Thứ tự byte này được gọi là tuổi thọ của CPU. Xem Byte Endianness trong phần tham khảo để biết chi tiết. Bạn sẽ tránh được vấn đề này bằng cách tận dụng Unicode cho tiêu đề thư của mình và sử dụng mã hóa UTF-8. Vì UTF-8 sử dụng mã hóa 8 bit nên không có vấn đề về thứ tự byte
Bạn có thể tìm thấy lời giải thích trong tài liệu Mã hóa và Unicode của Python. Lưu ý rằng điều này chỉ áp dụng cho tiêu đề văn bản. Bạn sẽ sử dụng một loại rõ ràng và mã hóa được xác định trong tiêu đề cho nội dung đang được gửi, trọng tải tin nhắn. Điều này sẽ cho phép bạn chuyển bất kỳ dữ liệu nào bạn muốn [văn bản hoặc nhị phân], ở bất kỳ định dạng nào
Bạn có thể dễ dàng xác định thứ tự byte của máy bằng cách sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nếu bạn chạy cái này trong một máy ảo mô phỏng CPU big-endian [PowerPC], thì điều tương tự sẽ xảy ra
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Trong ứng dụng ví dụ này, giao thức lớp ứng dụng của bạn xác định tiêu đề là văn bản Unicode với mã hóa UTF-8. Đối với nội dung thực tế trong tin nhắn, trọng tải tin nhắn, bạn sẽ vẫn phải hoán đổi thứ tự byte theo cách thủ công nếu cần
Điều này sẽ phụ thuộc vào ứng dụng của bạn và liệu nó có cần xử lý dữ liệu nhị phân nhiều byte từ một máy có độ bền khác hay không. Bạn có thể giúp máy khách hoặc máy chủ của mình triển khai hỗ trợ nhị phân bằng cách thêm các tiêu đề bổ sung và sử dụng chúng để truyền tham số, tương tự như HTTP
Đừng lo lắng nếu điều này chưa có ý nghĩa. Trong phần tiếp theo, bạn sẽ thấy tất cả những thứ này hoạt động và ăn khớp với nhau như thế nào
Loại bỏ các quảng cáoTiêu đề giao thức ứng dụng
Bây giờ bạn sẽ xác định đầy đủ tiêu đề giao thức. Tiêu đề giao thức là
- Văn bản có độ dài thay đổi
- Unicode với bảng mã UTF-8
- Một từ điển Python được tuần tự hóa bằng JSON
Các tiêu đề hoặc tiêu đề phụ bắt buộc trong từ điển của tiêu đề giao thức như sau
TênMô tả
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Các tiêu đề này thông báo cho người nhận về nội dung trong tải trọng của tin nhắn. Điều này cho phép bạn gửi dữ liệu tùy ý trong khi cung cấp đủ thông tin để người nhận có thể giải mã và diễn giải chính xác nội dung. Vì các tiêu đề nằm trong từ điển nên bạn có thể dễ dàng thêm các tiêu đề bổ sung bằng cách chèn các cặp khóa-giá trị nếu cần
Gửi tin nhắn ứng dụng
Vẫn còn một chút vấn đề. Bạn có một tiêu đề có độ dài thay đổi, rất đẹp và linh hoạt, nhưng làm thế nào để bạn biết độ dài của tiêu đề khi đọc nó bằng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Trước đây, khi bạn đã học về cách sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Bạn có thể coi đây là một cách tiếp cận hỗn hợp để gửi tin nhắn. Trên thực tế, bạn đang khởi động quá trình nhận tin nhắn bằng cách gửi độ dài của tiêu đề trước. Điều này giúp người nhận của bạn dễ dàng giải cấu trúc tin nhắn
Để giúp bạn hiểu rõ hơn về định dạng thư, hãy xem toàn bộ thư
Một thông báo bắt đầu với tiêu đề có độ dài cố định gồm hai byte, là một số nguyên theo thứ tự byte mạng. Đây là độ dài của tiêu đề tiếp theo, tiêu đề JSON có độ dài thay đổi. Khi bạn đã đọc hai byte bằng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Tiêu đề JSON chứa một từ điển các tiêu đề bổ sung. Một trong số đó là
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Lớp tin nhắn ứng dụng
Cuối cùng, phần thưởng. Trong phần này, bạn sẽ nghiên cứu về lớp
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Ứng dụng ví dụ này phản ánh loại thông báo nào mà máy khách và máy chủ có thể sử dụng một cách hợp lý. Tại thời điểm này, bạn vượt xa các máy khách và máy chủ đồ chơi
Để giữ cho mọi thứ đơn giản và vẫn chứng minh cách mọi thứ sẽ hoạt động trong một ứng dụng thực, ví dụ này sử dụng một giao thức ứng dụng triển khai tính năng tìm kiếm cơ bản. Máy khách gửi yêu cầu tìm kiếm và máy chủ thực hiện tìm kiếm kết quả khớp. Nếu yêu cầu do khách hàng gửi không được công nhận là tìm kiếm, thì máy chủ sẽ cho rằng đó là yêu cầu nhị phân và trả về phản hồi nhị phân
Sau khi đọc các phần sau, chạy các ví dụ và thử nghiệm mã, bạn sẽ thấy mọi thứ hoạt động như thế nào. Sau đó, bạn có thể sử dụng lớp
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Ứng dụng này không xa lắm so với ví dụ máy khách và máy chủ
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Như bạn đã học trước đây và bạn sẽ thấy bên dưới, làm việc với socket liên quan đến việc giữ trạng thái. Bằng cách sử dụng một lớp, bạn giữ tất cả trạng thái, dữ liệu và mã được nhóm lại với nhau trong một đơn vị có tổ chức. Một thể hiện của lớp được tạo cho mỗi ổ cắm trong máy khách và máy chủ khi kết nối được bắt đầu hoặc được chấp nhận
Lớp này hầu như giống nhau cho cả máy khách và máy chủ đối với các phương thức tiện ích và trình bao bọc. Chúng bắt đầu bằng dấu gạch dưới, chẳng hạn như
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The server’s
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nó trông như thế này
StepEndpointAction / Message Content1ClientSends a
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Here’s the file and code layout
ApplicationFileCodeServer
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Message Entry Point
Understanding how the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
After a
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Ghi chú. Some of the code examples in this section are from the server’s main script and
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
When events are ready on the socket, they’re returned by
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Looking at the event loop above, you’ll see that
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Here’s what the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
That’s good.
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
This is where managing state comes in. Nếu một phương thức khác phụ thuộc vào các biến trạng thái có một giá trị nhất định, thì chúng sẽ chỉ được gọi từ
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
You might be tempted to use a mix of some methods that check the current state variables and, depending on their value, call other methods to process data outside
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
You should definitely modify the class to suit your own needs so that it works best for you, but you’ll probably have the best results if you keep the state checks and the calls to methods that depend on that state to the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Now look at
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Remember that when
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Before a method processes its part of the message, it first checks to make sure enough bytes have been read into the receive buffer. If they have, it processes its respective bytes, removes them from the buffer and writes its output to a variable that’s used by the next processing stage. Because there are three components to a message, there are three state checks and
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Message ComponentMethodOutputFixed-length header
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Next, check out
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Remember that when
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The client version of
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Vì máy khách bắt đầu kết nối với máy chủ và gửi yêu cầu trước nên biến trạng thái
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Just like for the server,
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The notable difference in the client’s version of
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
To wrap up this section, consider this thought. the main purpose of this section was to explain that
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
This is important because
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Server Main Script
In the server’s main script
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
For example, to listen on the loopback interface on port
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Use an empty string for
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
After creating the socket, a call is made to
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Setting this socket option avoids the error
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
For example, if the server actively closed a connection, it’ll remain in the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The event loop catches any errors so that the server can stay up and continue to run
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Khi kết nối máy khách được chấp nhận, đối tượng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đối tượng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Một lợi thế của việc sử dụng phương pháp này trong máy chủ là trong hầu hết các trường hợp, khi ổ cắm hoạt động tốt và không có sự cố mạng, nó sẽ luôn có thể ghi được
Nếu bạn yêu cầu
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Server Message Class
In the section Message Entry Point, you learned how the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The server’s message class is in
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nhận mã nguồn. Nhấp vào đây để lấy mã nguồn mà bạn sẽ sử dụng cho các ví dụ trong hướng dẫn này
The methods appear in the class in the order in which processing takes place for a message
When the server has read at least two bytes, the fixed-length header can be processed
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The fixed-length header is a 2-byte integer in network, or big-endian, byte order. Nó chứa độ dài của tiêu đề JSON. You’ll use struct. unpack[] to read the value, decode it, and store it in
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Just like with the fixed-length header, when there’s enough data in the receive buffer to contain the JSON header, it can be processed as well
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The method
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Next is the actual content, or payload, of the message. It’s described by the JSON header in
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
After saving the message content to the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The last thing
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
A response can now be created and written to the socket. When the socket is writable,
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
A response is created by calling other methods, depending on the content type. In this example application, a simple dictionary lookup is done for JSON requests when
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
After creating the response message, the state variable
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
One tricky bit to figure out is how to close the connection after the response is written. You can put the call to
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Although it’s somewhat hidden, this is an acceptable trade-off given that the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Client Main Script
In the client’s main script,
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Here’s an example
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
After creating a dictionary representing the request from the command-line arguments, the host, port, and request dictionary are passed to
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
A socket is created for the server connection, as well as a
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Like for the server, the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
This approach gives you the same advantage as the server. not wasting CPU cycles. After the request has been sent, you’re no longer interested in write events, so there’s no reason to wake up and process them
Client Message Class
In the section Message Entry Point, you learned how the message object was called into action when socket events were ready via
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The client’s message class is in
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Nhận mã nguồn. Nhấp vào đây để lấy mã nguồn mà bạn sẽ sử dụng cho các ví dụ trong hướng dẫn này
The methods appear in the class in the order in which processing takes place for a message
The first task for the client is to queue the request
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The dictionaries used to create the request, depending on what was passed on the command line, are in the client’s main script,
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The request message is created and appended to the send buffer, which is then seen by and sent via
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
After the request has been sent, the client waits for a response from the server
The methods for reading and processing a message in the client are the same as for the server. As response data is read from the socket, the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The difference is in the naming of the final
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Last, but certainly not least, is the final call for
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Message Class Wrapup
To conclude your learning about the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Any exceptions raised by the class are caught by the main script in the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Note the line.
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
This is a really important line, for more than one reason. Not only does it make sure that the socket is closed, but
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Các phương pháp
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Note the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
By catching and skipping over the exception with
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Running the Application Client and Server
After all of this hard work, it’s time to have some fun and run some searches
In these examples, you’ll run the server so that it listens on all interfaces by passing an empty string for the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đầu tiên, khởi động máy chủ
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Now run the client and enter a search. See if you can find him
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
You might notice that the terminal is running a shell that’s using a text encoding of Unicode [UTF-8], so the output above prints nicely with emojis
Now see if you can find the puppies
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Notice the byte string sent over the network for the request in the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
This demonstrates that you’re sending raw bytes over the network and they need to be decoded by the receiver to be interpreted correctly. This is why you went to all of the trouble to create a header that contains the content type and encoding
Here’s the server output from both client connections above
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Look at the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
You can also test sending binary requests to the server if the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Because the request’s
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Troubleshooting
Inevitably, something won’t work, and you’ll be wondering what to do. Don’t worry, it happens to everyone. Hopefully, with the help of this tutorial, your debugger, and your favorite search engine, you’ll be able to get going again with the source code part
If not, your first stop should be Python’s socket module documentation. Make sure you read all of the documentation for each function or method you’re calling. Also, read through the Reference section below for ideas. In particular, check the Errors section
Sometimes, it’s not all about the source code. The source code might be correct, and it’s just the other host, the client, or server. Or it could be the network. Maybe a router, firewall, or some other networking device is playing man-in-the-middle
For these types of issues, additional tools are essential. Below are a few tools and utilities that might help or at least provide some clues
Loại bỏ các quảng cáoping
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Below is an example of running ping on macOS
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Note the statistics at the end of the output. This can be helpful when you’re trying to discover intermittent connectivity problems. For example, is there any packet loss? How much latency is there? You can check the round-trip times
If there’s a firewall between you and the other host, a ping’s echo request may not be allowed. Some firewall administrators implement policies that enforce this. The idea is that they don’t want their hosts to be discoverable. If this is the case and you have firewall rules added to allow the hosts to communicate, then make sure that the rules also allow ICMP to pass between them
ICMP là giao thức được sử dụng bởi
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
ICMP messages are identified by type and code. To give you an idea of the important information they carry, here are a few
ICMP TypeICMP CodeDescription80Echo request00Echo reply30Destination network unreachable31Destination host unreachable32Destination protocol unreachable33Destination port unreachable34Fragmentation required, and DF flag set110TTL expired in transit
See the article Path MTU Discovery for information regarding fragmentation and ICMP messages. This is an example of something that can cause strange behavior
netstat
In the section Viewing Socket State, you learned how
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
That section didn’t mention the columns
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
In other words, the bytes are waiting in network buffers in the operating system’s queues. One reason could be that the application is CPU bound or is otherwise unable to call
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
To demonstrate this and see how much data you can send before seeing an error, you can try out a test client that connects to a test server and repeatedly calls
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Đầu tiên, khởi động máy chủ
$ python echo-server.py
Then run the client to see what the error is
$ python echo-server.py
Here’s
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
$ python echo-server.py
The first entry is the server [
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
$ python echo-server.py
Notice the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The second entry is the client [
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
$ python echo-server.py
Notice the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The client sure was trying to write bytes, but the server wasn’t reading them. This caused the server’s network buffer queue to fill on the receive side and the client’s network buffer queue to fill on the send side
Windows
If you work with Windows, there’s a suite of utilities that you should definitely check out if you haven’t already. Windows Sysinternals
One of them is
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
cá mập
Sometimes you need to see what’s happening on the wire. Forget about what the application log says or what the value is that’s being returned from a library call. You want to see what’s actually being sent or received on the network. Just like with debuggers, when you need to see it, there’s no substitute
Wireshark là một ứng dụng phân tích giao thức mạng và nắm bắt lưu lượng chạy trên macOS, Linux và Windows, trong số những ứng dụng khác. Có một phiên bản GUI có tên là
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Chạy nắm bắt lưu lượng là một cách tuyệt vời để xem ứng dụng hoạt động như thế nào trên mạng và thu thập bằng chứng về những gì nó gửi và nhận cũng như tần suất và mức độ. Bạn cũng có thể biết khi nào máy khách hoặc máy chủ đóng hoặc hủy kết nối hoặc ngừng phản hồi. Thông tin này có thể cực kỳ hữu ích khi bạn khắc phục sự cố
Có rất nhiều hướng dẫn hay và các tài nguyên khác trên web sẽ hướng dẫn bạn những kiến thức cơ bản về cách sử dụng Wireshark và TShark
Đây là một ví dụ về nắm bắt lưu lượng sử dụng Wireshark trên giao diện loopback
Đây là ví dụ tương tự được hiển thị ở trên bằng cách sử dụng
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
$ python echo-server.py
Tiếp theo, bạn sẽ nhận được nhiều tài liệu tham khảo hơn để hỗ trợ hành trình lập trình ổ cắm của mình
Tài liệu tham khảo
Bạn có thể sử dụng phần này làm tài liệu tham khảo chung với thông tin bổ sung và liên kết đến các nguồn bên ngoài
Tài liệu Python
- Mô-đun ổ cắm của Python
- Lập trình socket của Python HOWTO
lỗi
Sau đây là từ tài liệu mô-đun
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
“Tất cả các lỗi đều có ngoại lệ. Các ngoại lệ thông thường đối với các loại đối số không hợp lệ và các điều kiện hết bộ nhớ có thể được nêu ra; . 3, các lỗi liên quan đến ngữ nghĩa ổ cắm hoặc địa chỉ nâng cao
970 hoặc một trong các lớp con của nó. " [Nguồn]# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
Dưới đây là một số lỗi phổ biến mà bạn có thể gặp phải khi làm việc với socket
Ngoại lệ
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Gia đình địa chỉ ổ cắm
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Địa chỉ FamilyProtocolAddress TupleDescription
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Lưu ý đoạn trích bên dưới từ tài liệu mô-đun ổ cắm của Python liên quan đến giá trị
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
“For IPv4 addresses, two special forms are accepted instead of a host address. the empty string represents
708, and the string# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]709 represents# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]710. This behavior is not compatible with IPv6, therefore, you may want to avoid these if you intend to support IPv6 with your Python programs. ” [Source]# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data]
See Python’s Socket families documentation for more information
This tutorial uses IPv4 sockets, but if your network supports it, try testing and using IPv6 if possible. One way to support this easily is by using the function socket. getaddrinfo[]. It translates the
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
The following example returns address information for a TCP connection to
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
>>>
$ python echo-server.py
Results may differ on your system if IPv6 isn’t enabled. The values returned above can be used by passing them to
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Using Hostnames
For context, this section applies mostly to using hostnames with
$ python echo-server.py
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Sau đây là từ tài liệu mô-đun
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
“Nếu bạn sử dụng tên máy chủ trong phần máy chủ của địa chỉ ổ cắm IPv4/v6, chương trình có thể hiển thị hành vi không xác định, vì Python sử dụng địa chỉ đầu tiên được trả về từ độ phân giải DNS. Địa chỉ ổ cắm sẽ được phân giải khác thành địa chỉ IPv4/v6 thực tế, tùy thuộc vào kết quả từ độ phân giải DNS và/hoặc cấu hình máy chủ. Đối với hành vi xác định, hãy sử dụng địa chỉ số trong phần máy chủ. " [Nguồn]
The standard convention for the name “localhost” is for it to resolve to
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
For example, on Linux, see
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Interestingly enough, as of June 2018, there’s an RFC draft Let ‘localhost’ be localhost that discusses the conventions, assumptions, and security around using the name “localhost. ”
What’s important to understand is that when you use hostnames in your application, the returned addresses could literally be anything. Don’t make assumptions regarding a name if you have a security-sensitive application. Depending on your application and environment, this may or may not be a concern for you
Note. Security precautions and best practices still apply, even if your application isn’t explicitly security-sensitive. If your application accesses the network, it should be secured and maintained. This means, at a minimum
System software updates and security patches are applied regularly, including Python. Are you using any third-party libraries? If so, make sure those are checked and updated too
If possible, use a dedicated or host-based firewall to restrict connections to trusted systems only
What DNS servers are configured? Do you trust them and their administrators?
Make sure that request data is sanitized and validated as much as possible prior to calling other code that processes it. Use fuzz tests for this and run them regularly
Regardless of whether or not you’re using hostnames, if your application needs to support secure connections through encryption and authentication, then you’ll probably want to look into using TLS. This is its own separate topic and beyond the scope of this tutorial. See Python’s ssl module documentation to get started. This is the same protocol that your web browser uses to connect securely to web sites
With interfaces, IP addresses, and name resolution to consider, there are many variables. What should you do? Here are some recommendations that you can use if you don’t have a network application review process
ApplicationUsageRecommendationServerloopback interfaceUse an IP address, such as
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
For clients or servers, if you need to authenticate the host that you’re connecting to, look into using TLS
chặn cuộc gọi
A socket function or method that temporarily suspends your application is a blocking call. For example,
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Blocking socket calls can be set to non-blocking mode so they return immediately. Nếu bạn làm điều này, thì ít nhất bạn sẽ cần cấu trúc lại hoặc thiết kế lại ứng dụng của mình để xử lý hoạt động của ổ cắm khi nó sẵn sàng
Because the call returns immediately, data may not be ready. Callee đang đợi trên mạng và không có thời gian để hoàn thành công việc của mình. Nếu đây là trường hợp, thì trạng thái hiện tại là giá trị
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Theo mặc định, ổ cắm luôn được tạo ở chế độ chặn. Xem Ghi chú về thời gian chờ của ổ cắm để biết mô tả về ba chế độ
Đóng kết nối
Một điều thú vị cần lưu ý với TCP là việc máy khách hoặc máy chủ đóng phía kết nối của họ trong khi phía bên kia vẫn mở là hoàn toàn hợp pháp. Điều này được gọi là kết nối “nửa mở”. Đó là quyết định của ứng dụng cho dù điều này có được mong muốn hay không. Nói chung là không. Ở trạng thái này, bên đã đóng kết nối không còn có thể gửi dữ liệu. Họ chỉ có thể nhận
Cách tiếp cận này không nhất thiết được khuyến nghị, nhưng ví dụ: HTTP sử dụng tiêu đề có tên "Kết nối" được sử dụng để chuẩn hóa cách các ứng dụng nên đóng hoặc duy trì các kết nối mở. Để biết chi tiết, xem phần 6. 3 trong RFC 7230, Giao thức truyền siêu văn bản [HTTP/1. 1]. Cú pháp tin nhắn và định tuyến
Khi thiết kế và viết ứng dụng của bạn cũng như giao thức lớp ứng dụng của nó, bạn nên tiếp tục và tìm ra cách bạn mong đợi các kết nối được đóng lại. Đôi khi điều này là hiển nhiên và đơn giản, hoặc đó là thứ có thể cần thử nghiệm và tạo mẫu ban đầu. Nó phụ thuộc vào ứng dụng và cách vòng lặp thông báo được xử lý với dữ liệu dự kiến của nó. Chỉ cần đảm bảo rằng các ổ cắm luôn được đóng lại kịp thời sau khi họ hoàn thành công việc của mình
Độ bền byte
Xem bài viết về tuổi thọ của Wikipedia để biết chi tiết về cách các CPU khác nhau lưu trữ thứ tự byte trong bộ nhớ. Khi diễn giải các byte riêng lẻ, đây không phải là vấn đề. Tuy nhiên, khi bạn đang xử lý nhiều byte được đọc và xử lý dưới dạng một giá trị, chẳng hạn như số nguyên 4 byte, thì thứ tự byte cần được đảo ngược nếu bạn đang giao tiếp với một máy sử dụng độ cuối khác
Thứ tự byte cũng quan trọng đối với các chuỗi văn bản được biểu diễn dưới dạng chuỗi nhiều byte, như Unicode. Trừ khi bạn luôn sử dụng ASCII đúng, nghiêm ngặt và kiểm soát việc triển khai máy khách và máy chủ, tốt hơn hết bạn nên sử dụng Unicode với mã hóa như UTF-8 hoặc mã hỗ trợ dấu thứ tự byte [BOM]
Điều quan trọng là xác định rõ ràng mã hóa được sử dụng trong giao thức lớp ứng dụng của bạn. Bạn có thể làm điều này bằng cách yêu cầu tất cả văn bản là UTF-8 hoặc sử dụng tiêu đề "mã hóa nội dung" chỉ định mã hóa. Điều này ngăn không cho ứng dụng của bạn phát hiện mã hóa mà bạn nên tránh nếu có thể
Điều này trở nên có vấn đề khi có dữ liệu liên quan được lưu trữ trong tệp hoặc cơ sở dữ liệu và không có siêu dữ liệu nào chỉ định mã hóa của dữ liệu đó. Khi dữ liệu được chuyển đến một điểm cuối khác, nó sẽ phải cố gắng phát hiện mã hóa. Để thảo luận, hãy xem bài viết Unicode của Wikipedia, tham khảo RFC 3629. UTF-8, định dạng chuyển đổi của ISO 10646
“Tuy nhiên, RFC 3629, tiêu chuẩn UTF-8, khuyến nghị rằng các dấu thứ tự byte bị cấm trong các giao thức sử dụng UTF-8, nhưng thảo luận về các trường hợp không thể thực hiện được. Ngoài ra, hạn chế lớn đối với các mẫu có thể có trong UTF-8 [ví dụ: không thể có bất kỳ byte đơn lẻ nào với tập bit cao] có nghĩa là có thể phân biệt UTF-8 với các mã hóa ký tự khác mà không cần dựa vào BOM. " [Nguồn]
Điểm nổi bật của điều này là luôn lưu trữ mã hóa được sử dụng cho dữ liệu được ứng dụng của bạn xử lý nếu nó có thể thay đổi. Nói cách khác, hãy cố gắng bằng cách nào đó lưu trữ mã hóa dưới dạng siêu dữ liệu nếu nó không phải lúc nào cũng là UTF-8 hoặc một số mã hóa khác có BOM. Sau đó, bạn có thể gửi mã hóa đó trong tiêu đề cùng với dữ liệu để cho người nhận biết đó là gì
Thứ tự byte được sử dụng trong TCP/IP là thứ tự lớn và được gọi là thứ tự mạng. Thứ tự mạng được sử dụng để biểu thị các số nguyên ở các lớp thấp hơn của ngăn xếp giao thức, như địa chỉ IP và số cổng. Mô-đun ổ cắm của Python bao gồm các chức năng chuyển đổi số nguyên sang và từ thứ tự byte của mạng và máy chủ
Chức năngMô tả
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
# echo-server.py
# ...
with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s:
s.bind[[HOST, PORT]]
s.listen[]
conn, addr = s.accept[]
with conn:
print[f"Connected by {addr}"]
while True:
data = conn.recv[1024]
if not data:
break
conn.sendall[data]
Bạn cũng có thể sử dụng mô-đun cấu trúc để đóng gói và giải nén dữ liệu nhị phân bằng các chuỗi định dạng
$ python echo-server.py
Sự kết luận
Bạn đã bao phủ rất nhiều nền tảng trong hướng dẫn này. Mạng và ổ cắm là những chủ đề lớn. Nếu bạn chưa quen với mạng hoặc ổ cắm, đừng nản lòng với tất cả các thuật ngữ và từ viết tắt
Có rất nhiều phần cần làm quen để hiểu cách mọi thứ hoạt động cùng nhau. Tuy nhiên, giống như Python, nó sẽ bắt đầu có ý nghĩa hơn khi bạn làm quen với từng phần riêng lẻ và dành nhiều thời gian hơn cho chúng
Trong hướng dẫn này, bạn
- Đã xem API ổ cắm cấp thấp trong mô-đun
679 của Python và xem cách nó có thể được sử dụng để tạo các ứng dụng máy khách-máy chủ# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data] - Xây dựng máy khách và máy chủ có thể xử lý nhiều kết nối bằng đối tượng
744# echo-server.py # ... with socket.socket[socket.AF_INET, socket.SOCK_STREAM] as s: s.bind[[HOST, PORT]] s.listen[] conn, addr = s.accept[] with conn: print[f"Connected by {addr}"] while True: data = conn.recv[1024] if not data: break conn.sendall[data] - Tạo lớp tùy chỉnh của riêng bạn và sử dụng lớp đó làm giao thức lớp ứng dụng để trao đổi thông báo và dữ liệu giữa các điểm cuối
Từ đây, bạn có thể sử dụng lớp tùy chỉnh của mình và xây dựng dựa trên lớp đó để tìm hiểu và giúp tạo các ứng dụng socket của riêng bạn dễ dàng và nhanh hơn
Để xem lại các ví dụ, bạn có thể nhấp vào liên kết bên dưới
Nhận mã nguồn. Nhấp vào đây để lấy mã nguồn mà bạn sẽ sử dụng cho các ví dụ trong hướng dẫn này
Chúc mừng bạn đã đi đến cuối cùng. Bây giờ bạn đang trên con đường sử dụng socket trong các ứng dụng của riêng mình. Chúc may mắn trên hành trình phát triển ổ cắm của bạn
Đánh dấu là đã hoàn thành
🐍 Thủ thuật Python 💌
Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python
Gửi cho tôi thủ thuật Python »
Giới thiệu về Nathan Jennings
Nathan là thành viên của nhóm hướng dẫn Real Python, người đã bắt đầu sự nghiệp lập trình viên của mình với C từ lâu, nhưng cuối cùng đã tìm thấy Python. Từ các ứng dụng web và thu thập dữ liệu đến mạng và bảo mật mạng, anh ấy thích mọi thứ Pythonic
» Thông tin thêm về Na-thanMỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là
Aldren
Brad
Geir Arne
Ian
Jim
Joanna
kate
Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bạn nghĩ sao?
Đánh giá bài viết này
Tweet Chia sẻ Chia sẻ EmailBài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?
Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. Nhận các mẹo để đặt câu hỏi hay và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi