Rumah > pembangunan bahagian belakang > Tutorial Python > Bilik Sembang TCP dalam Python

Bilik Sembang TCP dalam Python

Linda Hamilton
Lepaskan: 2025-01-04 19:16:40
asal
883 orang telah melayarinya

TCP Chatroom in Python

pengenalan

Dalam blog ini, kami akan melaksanakan ruang sembang TCP yang berfungsi sepenuhnya menggunakan Python. Kami akan mempunyai satu pelayan yang mengehoskan bilik dan berbilang pelanggan yang menyambung kepadanya dan berkomunikasi antara satu sama lain.

Perihal Seni Bina Pelayan TCP & Pelanggan

Protokol Kawalan Penghantaran ialah protokol berorientasikan sambungan untuk komunikasi yang membantu dalam pertukaran mesej antara peranti berbeza melalui rangkaian.

Untuk melaksanakan bilik sembang kami, kami akan menggunakan seni bina pelayan-klien. Ini bermakna kami akan mempunyai berbilang pelanggan (pengguna) dan satu pelayan pusat yang mengehoskan segala-galanya dan menyediakan data untuk pelanggan ini.


Menyediakan Pelayan ( server.py )

1. Untuk menyediakan pelayan asas kami, kami perlu mengimport dua perpustakaan, iaitu soket dan threading. perpustakaan soket akan digunakan untuk mewujudkan dan menyediakan sambungan rangkaian dan perpustakaan berbenang diperlukan untuk melaksanakan pelbagai tugas pada masa yang sama.

import socket
import threading
Salin selepas log masuk
Salin selepas log masuk
Salin selepas log masuk

2. Tugas seterusnya ialah untuk menentukan data pelayan kami dan untuk memulakan soket kami. Kami memerlukan alamat IP untuk hos dan nombor port percuma untuk pelayan kami. Dalam blog ini, kami akan menggunakan alamat 127.0.0.1 iaitu localhost dan port 5500 kami.

Nombor port tidak relevan tetapi anda perlu memastikan port yang anda gunakan adalah percuma dan tidak dikhaskan. Jika anda menjalankan bilik sembang ini pada pelayan sebenar atau mesin maya, nyatakan alamat IP pelayan bilik sembang sebagai alamat IP hos mesin maya atau pelayan.

Lihat senarai nombor port yang ditempah ini untuk maklumat lanjut.

# Server Data
host = '127.0.0.1'
port = 5500
Salin selepas log masuk
Salin selepas log masuk
Salin selepas log masuk

3. Apabila kita menentukan soket kita, kita perlu lulus dua parameter. Ini menentukan jenis soket yang ingin kita gunakan. Yang pertama (AF_INET) menunjukkan bahawa kami menggunakan soket internet dan bukannya soket unix. Parameter kedua bermaksud protokol yang ingin kami gunakan. SOCK_STREAM menunjukkan bahawa kami menggunakan TCP.

Selepas menentukan soket, kami mengikat atau melampirkannya pada hos kami dan port yang ditentukan dengan menghantar tuple yang mengandungi kedua-dua nilai. Kami kemudiannya akan meletakkan pelayan kami ke dalam mod mendengar, supaya ia menunggu untuk pelanggan menyambung dan menghantar mesej..

# Start the Server
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((host, port))
server.listen()
Salin selepas log masuk
Salin selepas log masuk
Salin selepas log masuk

4. Kami juga akan membuat dua senarai kosong, yang akan kami gunakan untuk menyimpan pelanggan yang disambungkan dan nama panggilan mereka kemudian hari.

import socket
import threading
Salin selepas log masuk
Salin selepas log masuk
Salin selepas log masuk

5. Sekarang kami akan mentakrifkan semua fungsi yang akan membantu kami dalam mesej penyiaran. Ia akan menghantar mesej kepada setiap pelanggan yang disambungkan dan oleh itu terdapat dalam senarai pelanggan.

# Server Data
host = '127.0.0.1'
port = 5500
Salin selepas log masuk
Salin selepas log masuk
Salin selepas log masuk

6. Sekarang kita akan mencipta fungsi handle(). Fungsi ini akan bertanggungjawab untuk mengendalikan mesej daripada pelanggan. Fungsi ini akan berjalan dalam gelung sementara. Fungsi ini akan menerima klien sebagai parameter dan mengendalikannya dalam gelung yang tidak berkesudahan sehingga ralat berlaku atau klien itu sendiri memutuskan sambungan.

# Start the Server
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((host, port))
server.listen()
Salin selepas log masuk
Salin selepas log masuk
Salin selepas log masuk

7. Kini kami perlu menerima mesej daripada pelanggan dan menyiarkannya kepada semua pelanggan yang berkaitan. Jadi apabila seorang pelanggan menghantar mesej, orang lain boleh melihat mesej ini melalui fungsi broadcast(). Sekarang jika atas sebab tertentu terdapat ralat dengan sambungan kepada pelanggan ini, kami mengalih keluarnya dan nama panggilannya, menutup sambungan dan menyiarkan bahawa pelanggan ini telah meninggalkan sembang.

# Lists For Clients and Their Nicknames
clients = []
nicknames = []
Salin selepas log masuk
Salin selepas log masuk

Apabila kami bersedia untuk menjalankan pelayan kami, kami akan melaksanakan fungsi terima ini. Sebaik sahaja pelanggan disambungkan ke pelayan, ia akan menghantar rentetan 'NAME' kepadanya, yang akan memberitahu pelanggan bahawa nama panggilannya diminta. Selepas itu ia menunggu respons dan menambahkan klien dengan nama samaran masing-masing pada senarai dan memulakan utas untuk fungsi handle() untuk klien tertentu itu.

8. Kini kami hanya boleh menjalankan fungsi ini dan pelayan kami selesai.

# Sending Messages To All Connected Clients
def broadcast(message):
    for client in clients:
        client.send(message)
Salin selepas log masuk

Menyediakan Klien ( client.py )

Sekarang kami akan melaksanakan pelanggan kami. Untuk ini, kami sekali lagi perlu mengimport perpustakaan yang sama.

# Handling Clients
def handle(client):
    while True:
        try:
            # Broadcasting Messages
            message = client.recv(1024)
            broadcast(message)
        except:
            # Removing And Closing Clients
            index = clients.index(client)
            clients.remove(client)
            client.close()
            nickname = nicknames[index]
            broadcast('{} left!'.format(nickname).encode('ascii'))
            nicknames.remove(nickname)
            break
Salin selepas log masuk

1. Langkah pertama pelanggan ialah memilih nama panggilan dan menyambung ke pelayan kami. Kami perlu mengetahui alamat yang tepat dan port di mana pelayan kami sedang berjalan. Daripada mengikat data dan mendengar, sebagai pelanggan kami menyambung ke pelayan sedia ada.

# Receiving `Function
def receive():
    while True:
        # Accept Connection
        client, address = server.accept()
        print("Connected with {}".format(str(address)))

        # Request And Store Nickname
        client.send('NAME'.encode('ascii'))
        nickname = client.recv(1024).decode('ascii')
        nicknames.append(nickname)
        clients.append(client)

        # Print And Broadcast Nickname
        print("Nickname is {}".format(nickname))
        broadcast("{} joined!".format(nickname).encode('ascii'))
        client.send('Connected to server!'.encode('ascii'))

        # Start Handling Thread For Client
        thread = threading.Thread(target=handle, args=(client,))
        thread.start()
Salin selepas log masuk

2. Kini, pelanggan perlu mempunyai dua utas yang berjalan pada masa yang sama. Yang pertama akan sentiasa menerima data daripada pelayan dan yang kedua akan menghantar mesej kita sendiri ke pelayan.

receive()
Salin selepas log masuk

Sekali lagi kami mempunyai gelung sementara yang tidak berkesudahan di sini. Ia sentiasa cuba menerima mesej dan mencetaknya pada skrin. Walau bagaimanapun, jika mesej itu ialah 'NAME', ia tidak mencetaknya tetapi ia menghantar nama panggilannya ke pelayan.

Fungsi penulisan agak singkat. Ia juga berjalan dalam gelung tidak berkesudahan yang sentiasa menunggu input daripada pengguna. Sebaik sahaja ia mendapat beberapa, ia menggabungkannya dengan nama panggilan dan menghantarnya ke pelayan.

3. Perkara terakhir yang perlu kita lakukan ialah memulakan dua utas yang menjalankan dua fungsi ini.

import socket
import threading
Salin selepas log masuk
Salin selepas log masuk
Salin selepas log masuk

Dan kini kita sudah selesai. Kami mempunyai pelayan yang berfungsi sepenuhnya dan pelanggan yang berfungsi yang boleh menyambung kepadanya dan berkomunikasi antara satu sama lain.


Menjalankan Bilik Sembang

Mari pergi untuk menjalankan ujian. Perlu diingat bahawa kami sentiasa perlu memulakan pelayan terlebih dahulu kerana jika tidak, pelanggan tidak dapat menyambung ke hos yang tidak wujud.

*Log Pelayan : *

# Server Data
host = '127.0.0.1'
port = 5500
Salin selepas log masuk
Salin selepas log masuk
Salin selepas log masuk

*Log Pelanggan Satu : *

# Start the Server
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((host, port))
server.listen()
Salin selepas log masuk
Salin selepas log masuk
Salin selepas log masuk

*Log Pelanggan Dua : *

# Lists For Clients and Their Nicknames
clients = []
nicknames = []
Salin selepas log masuk
Salin selepas log masuk

Dan kami telah berjaya mencipta ruang sembang berdasarkan Protokol Kawalan Penghantaran dalam Python! ? ?

Cari Kod Penuh Di Sini :https://github.com/rajatuiwebdev/tcp-chatroom-in-python
Ikuti saya di Instagram : https://instagram.com/rajatrajput.dev
Ikuti saya di LinkedIn : https://linkedin.com/in/rajatrajput2004

Atas ialah kandungan terperinci Bilik Sembang TCP dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

sumber:dev.to
Kenyataan Laman Web ini
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
Artikel terbaru oleh pengarang
Tutorial Popular
Lagi>
Muat turun terkini
Lagi>
kesan web
Kod sumber laman web
Bahan laman web
Templat hujung hadapan