add example using serversocket from https://docs.python.org/2/library/socketserver.html

socketserver/TcpClient.py

@@ -0,0 +1,21 @@
+import socket
+import sys
+
+HOST, PORT = "localhost", 9999
+data = " ".join(sys.argv[1:])
+
+# Create a socket (SOCK_STREAM means a TCP socket)
+sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+try:
+    # Connect to server and send data
+    sock.connect((HOST, PORT))
+    sock.sendall(bytes(data + "\n"))
+
+    # Receive data from the server and shut down
+    received = str(sock.recv(1024));
+finally:
+    sock.close()
+
+print("Sent:     {}".format(data))
+print("Received: {}".format(received))

socketserver/TcpServer.py

@@ -0,0 +1,38 @@
+import SocketServer
+
+class MyTCPHandler(SocketServer.BaseRequestHandler):
+    """
+    The RequestHandler class for our server.
+
+    It is instantiated once per connection to the server, and must
+    override the handle() method to implement communication to the
+    client.
+    """
+
+    def handle(self):
+        # self.request is the TCP socket connected to the client
+        self.data = self.request.recv(1024).strip()
+        print("{} wrote:".format(self.client_address[0]))
+        print(self.data)
+        # just send back the same data, but upper-cased
+        self.request.sendall(self.data.upper())
+
+    # def handle(self):
+        # self.rfile is a file-like object created by the handler;
+        # we can now use e.g. readline() instead of raw recv() calls
+        # self.data = self.rfile.readline().strip()
+        # print("{} wrote:".format(self.client_address[0]))
+        # print(self.data)
+        # Likewise, self.wfile is a file-like object used to write back
+        # to the client
+        # self.wfile.write(self.data.upper())
+
+if __name__ == "__main__":
+    HOST, PORT = "localhost", 9999
+
+    # Create the server, binding to localhost on port 9999
+    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)
+
+    # Activate the server; this will keep running until you
+    # interrupt the program with Ctrl-C
+    server.serve_forever()

socketserver/TcpThreaded.py

@@ -0,0 +1,45 @@
+import socket
+import threading
+import SocketServer
+
+class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
+
+    def handle(self):
+        data = self.request.recv(1024)
+        cur_thread = threading.current_thread()
+        response = "{}: {}".format(cur_thread.name, data)
+        self.request.sendall(response)
+
+class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
+    pass
+
+def client(ip, port, message):
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.connect((ip, port))
+    try:
+        sock.sendall(message)
+        response = sock.recv(1024)
+        print "Received: {}".format(response)
+    finally:
+        sock.close()
+
+if __name__ == "__main__":
+    # Port 0 means to select an arbitrary unused port
+    HOST, PORT = "localhost", 0
+
+    server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
+    ip, port = server.server_address
+
+    # Start a thread with the server -- that thread will then start one
+    # more thread for each request
+    server_thread = threading.Thread(target=server.serve_forever)
+    # Exit the server thread when the main thread terminates
+    server_thread.daemon = True
+    server_thread.start()
+    print "Server loop running in thread:", server_thread.name
+
+    client(ip, port, "Hello World 1")
+    client(ip, port, "Hello World 2")
+    client(ip, port, "Hello World 3")
+
+    server.shutdown()

socketserver/UdpClient.py

@@ -0,0 +1,16 @@
+import socket
+import sys
+
+HOST, PORT = "localhost", 9999
+data = " ".join(sys.argv[1:])
+
+# SOCK_DGRAM is the socket type to use for UDP sockets
+sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+# As you can see, there is no connect() call; UDP has no connections.
+# Instead, data is directly sent to the recipient via sendto().
+sock.sendto(data + "\n", (HOST, PORT))
+received = sock.recv(1024)
+
+print "Sent:     {}".format(data)
+print "Received: {}".format(received)

socketserver/UdpServer.py

@@ -0,0 +1,21 @@
+import SocketServer
+
+class MyUDPHandler(SocketServer.BaseRequestHandler):
+    """
+    This class works similar to the TCP handler class, except that
+    self.request consists of a pair of data and client socket, and since
+    there is no connection the client address must be given explicitly
+    when sending data back via sendto().
+    """
+
+    def handle(self):
+        data = self.request[0].strip()
+        socket = self.request[1]
+        print "{} wrote:".format(self.client_address[0])
+        print data
+        socket.sendto(data.upper(), self.client_address)
+
+if __name__ == "__main__":
+    HOST, PORT = "localhost", 9999
+    server = SocketServer.UDPServer((HOST, PORT), MyUDPHandler)
+    server.serve_forever()