#!/usr/bin/env python

# -*- coding:utf-8 -*-

import socket

ip_port = ('127.0.0.1',9999)

sk = socket.socket()

sk.bind(ip_port)

sk.listen(5)

while True:

    print 'server waiting...'

    conn,addr = sk.accept()

    client_data = conn.recv(1024)

    print client_data

    conn.sendall('不要回答,不要回答,不要回答')

    conn.close()

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import socket

ip_port = ('127.0.0.1',9999)

sk = socket.socket()

sk.connect(ip_port)

sk.sendall('请求占领地球')

server_reply = sk.recv(1024)

print server_reply

sk.close()

1 创建套接字，绑定套接字到本地IP与端口

   # socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.bind()

2 开始监听连接                   #s.listen()

3 进入循环，不断接受客户端的连接请求              #s.accept()

4 然后接收传来的数据，并发送给对方数据         #s.recv() , s.sendall()

5 传输完毕后，关闭套接字                     #s.close()

1 创建套接字，连接远端地址

       # socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.connect()

2 连接后发送数据和接收数据          # s.sendall(), s.recv()

3 传输完毕后，关闭套接字          #s.close()

# 服务端

import socket

ip_port = ('127.0.0.1',9999)

sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)

sk.bind(ip_port)

while True:

    data,(host,port) = sk.recvfrom(1024)

    print(data,host,port)

    sk.sendto(bytes('ok', encoding='utf-8'), (host,port))

#客户端

import socket

ip_port = ('127.0.0.1',9999)

sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)

while True:

    inp = input('数据：').strip()

    if inp == 'exit':

        break

    sk.sendto(bytes(inp, encoding='utf-8'),ip_port)

    data = sk.recvfrom(1024)

    print(data)

sk.close()

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import socket

ip_port = ('127.0.0.1',8888)

sk = socket.socket()

sk.bind(ip_port)

sk.listen(5)

while True:

    conn,address =  sk.accept()

    conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')

    Flag = True

    while Flag:

        data = conn.recv(1024)

        if data == 'exit':

            Flag = False

        elif data == '0':

            conn.sendall('通过可能会被录音.balabala一大推')

        else:

            conn.sendall('请重新输入.')

    conn.close()

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import socket

ip_port = ('127.0.0.1',8005)

sk = socket.socket()

sk.connect(ip_port)

sk.settimeout(5)

while True:

    data = sk.recv(1024)

    print 'receive:',data

    inp = raw_input('please input:')

    sk.sendall(inp)

    if inp == 'exit':

        break

sk.close()

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import select

import threading

import sys

while True:

    readable, writeable, error = select.select([sys.stdin,],[],[],1)

    if sys.stdin in readable:

        print 'select get stdin',sys.stdin.readline()

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import socket

import select

sk1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

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

sk1.bind(('127.0.0.1',8002))

sk1.listen(5)

sk1.setblocking(0)

inputs = [sk1,]

while True:

    readable_list, writeable_list, error_list = select.select(inputs, [], inputs, 1)

    for r in readable_list:

        # 当客户端第一次连接服务端时

        if sk1 == r:

            print 'accept'

            request, address = r.accept()

            request.setblocking(0)

            inputs.append(request)

        # 当客户端连接上服务端之后，再次发送数据时

        else:

            received = r.recv(1024)

            # 当正常接收客户端发送的数据时

            if received:

                print 'received data:', received

            # 当客户端关闭程序时

            else:

                inputs.remove(r)

sk1.close()

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import socket

ip_port = ('127.0.0.1',8002)

sk = socket.socket()

sk.connect(ip_port)

while True:

    inp = raw_input('please input:')

    sk.sendall(inp)

sk.close()

#!/usr/bin/env python

#coding:utf8

'''

 服务器的实现 采用select的方式

'''

import select

import socket

import sys

import Queue

#创建套接字并设置该套接字为非阻塞模式

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

server.setblocking(0)

#绑定套接字

server_address = ('localhost',10000)

print >>sys.stderr,'starting up on %s port %s'% server_address

server.bind(server_address)

#将该socket变成服务模式

#backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5

#这个值不能无限大，因为要在内核中维护连接队列

server.listen(5)

#初始化读取数据的监听列表,最开始时希望从server这个套接字上读取数据

inputs = [server]

#初始化写入数据的监听列表，最开始并没有客户端连接进来，所以列表为空

outputs = []

#要发往客户端的数据

message_queues = {}

while inputs:

    print >>sys.stderr,'waiting for the next event'

    #调用select监听所有监听列表中的套接字，并将准备好的套接字加入到对应的列表中

    readable,writable,exceptional = select.select(inputs,outputs,inputs)#列表中的socket 套接字  如果是文件呢？

    #监控文件句柄有某一处发生了变化 可写 可读  异常属于Linux中的网络编程

    #属于同步I/O操作，属于I/O复用模型的一种

    #rlist--等待到准备好读

    #wlist--等待到准备好写

    #xlist--等待到一种异常

    #处理可读取的套接字

    '''

        如果server这个套接字可读，则说明有新链接到来

        此时在server套接字上调用accept,生成一个与客户端通讯的套接字

        并将与客户端通讯的套接字加入inputs列表，下一次可以通过select检查连接是否可读

        然后在发往客户端的缓冲中加入一项，键名为:与客户端通讯的套接字，键值为空队列

        select系统调用是用来让我们的程序监视多个文件句柄(file descrīptor)的状态变化的。程序会停在select这里等待，

        直到被监视的文件句柄有某一个或多个发生了状态改变

        '''

    '''

        若可读的套接字不是server套接字,有两种情况:一种是有数据到来，另一种是链接断开

        如果有数据到来,先接收数据,然后将收到的数据填入往客户端的缓存区中的对应位置，最后

        将于客户端通讯的套接字加入到写数据的监听列表:

        如果套接字可读.但没有接收到数据，则说明客户端已经断开。这时需要关闭与客户端连接的套接字

        进行资源清理

        '''

    for s in readable:

        if s is server:

            connection,client_address = s.accept()

            print >>sys.stderr,'connection from',client_address

            connection.setblocking(0)#设置非阻塞

            inputs.append(connection)

            message_queues[connection] = Queue.Queue()

        else:

            data = s.recv(1024)

            if data:

                print >>sys.stderr,'received "%s" from %s'% \

                (data,s.getpeername())

                message_queues[s].put(data)

                if s not in outputs:

                    outputs.append(s)

            else:

                print >>sys.stderr,'closing',client_address

                if s in outputs:

                    outputs.remove(s)

                inputs.remove(s)

                s.close()

                del message_queues[s]

    #处理可写的套接字

    '''

        在发送缓冲区中取出响应的数据，发往客户端。

        如果没有数据需要写，则将套接字从发送队列中移除，select中不再监视

        '''

    for s in writable:

        try:

            next_msg = message_queues[s].get_nowait()

        except Queue.Empty:

            print >>sys.stderr,'  ',s,getpeername(),'queue empty'

            outputs.remove(s)

        else:

            print >>sys.stderr,'sending "%s" to %s'% \

            (next_msg,s.getpeername())

            s.send(next_msg)

    #处理异常情况

    for s in exceptional:

        for s in exceptional:

            print >>sys.stderr,'exception condition on',s.getpeername()

            inputs.remove(s)

            if s in outputs:

                outputs.remove(s)

            s.close()

            del message_queues[s]

class SocketServer.BaseServer：这是模块中的所有服务器对象的超类。它定义了接口，如下所述，但是大多数的方法不实现，在子类中进行细化。

    BaseServer.fileno()：返回服务器监听套接字的整数文件描述符。通常用来传递给select.select(), 以允许一个进程监视多个服务器。

    BaseServer.handle_request()：处理单个请求。处理顺序：get_request(), verify_request(), process_request()。如果用户提供handle()方法抛出异常，将调用服务器的handle_error()方法。如果self.timeout内没有请求收到， 将调用handle_timeout()并返回handle_request()。

    BaseServer.serve_forever(poll_interval=0.5): 处理请求，直到一个明确的shutdown()请求。每poll_interval秒轮询一次shutdown。忽略self.timeout。如果你需要做周期性的任务，建议放置在其他线程。

    BaseServer.shutdown()：告诉serve_forever()循环停止并等待其停止。python2.6版本。

    BaseServer.address_family: 地址家族，比如socket.AF_INET和socket.AF_UNIX。

    BaseServer.RequestHandlerClass：用户提供的请求处理类，这个类为每个请求创建实例。

    BaseServer.server_address：服务器侦听的地址。格式根据协议家族地址的各不相同，请参阅socket模块的文档。

    BaseServer.socketSocket：服务器上侦听传入的请求socket对象的服务器。

服务器类支持下面的类变量：

    BaseServer.allow_reuse_address：服务器是否允许地址的重用。默认为false ，并且可在子类中更改。

    BaseServer.request_queue_size

请求队列的大小。如果单个请求需要很长的时间来处理，服务器忙时请求被放置到队列中，最多可以放request_queue_size个。一旦队列已满，来自客户端的请求将得到 “Connection denied”错误。默认值通常为5 ，但可以被子类覆盖。

    BaseServer.socket_type：服务器使用的套接字类型; socket.SOCK_STREAM和socket.SOCK_DGRAM等。

    BaseServer.timeout：超时时间，以秒为单位，或 None表示没有超时。如果handle_request()在timeout内没有收到请求，将调用handle_timeout()。

下面方法可以被子类重载，它们对服务器对象的外部用户没有影响。

    BaseServer.finish_request()：实际处理RequestHandlerClass发起的请求并调用其handle()方法。 常用。

    BaseServer.get_request()：接受socket请求，并返回二元组包含要用于与客户端通信的新socket对象，以及客户端的地址。

    BaseServer.handle_error(request, client_address)：如果RequestHandlerClass的handle()方法抛出异常时调用。默认操作是打印traceback到标准输出，并继续处理其他请求。

    BaseServer.handle_timeout()：超时处理。默认对于forking服务器是收集退出的子进程状态，threading服务器则什么都不做。

    BaseServer.process_request(request, client_address) :调用finish_request()创建RequestHandlerClass的实例。如果需要，此功能可以创建新的进程或线程来处理请求,ForkingMixIn和ThreadingMixIn类做到这点。常用。

    BaseServer.server_activate()：通过服务器的构造函数来激活服务器。默认的行为只是监听服务器套接字。可重载。

    BaseServer.server_bind()：通过服务器的构造函数中调用绑定socket到所需的地址。可重载。

    BaseServer.verify_request(request, client_address)：返回一个布尔值，如果该值为True ，则该请求将被处理，反之请求将被拒绝。此功能可以重写来实现对服务器的访问控制。默认的实现始终返回True。client_address可以限定客户端，比如只处理指定ip区间的请求。 常用。

setup()

Called before the handle() method to perform any initialization actions required. The default implementation does nothing.

也就是在handle()之前被调用，主要的作用就是执行处理请求之前的初始化相关的各种工作。默认不会做任何事。（如果想要让其做一些事的话，就要程序员在自己的请求处理器中覆盖这个方法（因为一般自定义的请求处理器都要继承python中提供的BaseRequestHandler，ps：下文会提到的），然后往里面添加东西即可）

handle()

This function must do all the work required to service a request. The default implementation does nothing. Several instance attributes are available to it; the request is available as self.request; the client address as self.client_address; and the server instance as self.server, in case it needs access to per-server information.

The type of self.request is different for datagram or stream services. For stream services,self.request is a socket object; for datagram services, self.request is a pair of string and socket.

handle()的工作就是做那些所有与处理请求相关的工作。默认也不会做任何事。他有数个实例参数：self.request    self.client_address   self.server

finish()

Called after the handle() method to perform any clean-up actions required. The default implementation does nothing. If setup() raises an exception, this function will not be called.

在handle()方法之后会被调用，他的作用就是执行当处理完请求后的清理工作，默认不会做任何事