Python核心编程——Chapter16
好吧,在拜读完《Python网络编程基础》之后,回头再搞一搞16章的网络编程吧。
Let‘s go!
16.4.修改书上示例的TCP和UDP客户端,使得服务器的名字不要在代码里写死,要允许用户指定一个主机名和端口。只有两个值都没有输入是才使用默认值。
难度不大。
#tsTclnt.py
#!/usr/bin/env python
#-*-coding:utf-8-*- from socket import *
import sys if(len(sys.argv) < 3):
HOST = 'localhost'
PORT = 21567
else:
HOST = sys.argv[1]
PORT = int(sys.argv[2]) BUFSIZ = 1024
ADDR = (HOST,PORT) tcpCliSock = socket(AF_INET,SOCK_STREAM)
tcpCliSock.connect(ADDR) while True:
data = raw_input('> ')
if not data:
break
tcpCliSock.send(data)
data = tcpCliSock.recv(BUFSIZ)
if not data:
break
print data tcpCliSock.close()
#tsUclnt.py
#!/usr/bin/env python
#-*- coding:utf-8 -*- from socket import *
import sys if(len(sys.argv) < 3):
HOST = 'localhost'
PORT = 21567
else:
HOST = sys.argv[1]
PORT = sys.argv[2]
#print sys.argv[1],sys.argv[2] BUFSIZ = 1024
ADDR = (HOST,int(PORT)) udpCliSock = socket(AF_INET,SOCK_DGRAM) while True:
data = raw_input('> ')
if not data:
break
udpCliSock.sendto(data,ADDR)
data,ADDR = udpCliSock.recvfrom(BUFSIZ)
if not data:
break
print data udpCliSock.close()
16.5.修改服务器示例代码,使得它能根据不同的请求而作出应答。
这道题目本质上也不难,只需要在服务器的死循环程序加上条件判断即可。
版本1:纯TCP服务器端修改。
#!/usr/bin/env python
#-*- coding:utf-8 -*- from socket import *
import time,os HOST = ''
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST,PORT) tcpSerSock = socket(AF_INET,SOCK_STREAM)
tcpSerSock.bind(ADDR)
tcpSerSock.listen(5) while True:
print 'waiting for connection...'
tcpCliSock,addr = tcpSerSock.accept()
print '...connected from:',addr while True:
data = tcpCliSock.recv(BUFSIZ)
data = data.strip()
if not data:
break
if data == "date":
tcpCliSock.send('%s' % (time.ctime(time.time())))
elif data == "os":
tcpCliSock.send('%s' % (os.name))
elif data == "ls":
tcpCliSock.send('%s' % (os.listdir(os.curdir)))
else:
tcpCliSock.send('[%s] %s' % (ctime(),data))
tcpCliSock.close() tcpSerSock.close()
版本2:使用现成的服务器框架进行修改。
#!/usr/bin/env python
#-*-coding:utf-8-*- from SocketServer import ThreadingMixIn,TCPServer,StreamRequestHandler
import time,os,re class TxRequestHandler(StreamRequestHandler):
def handle(self):
req = self.rfile.readline().strip()
m = re.match('(\w+)\s+([\w+/]+)',req)
if req == "date":
result = time.ctime(time.time())
elif req == "os":
result = os.name
elif req == "ls":
result = str(os.listdir(os.curdir))
elif m is not None and m.lastindex == 2 and m.group(1) == 'ls':
result = str(os.listdir(m.group(2)))
else:
result = """
date -- 服务器将返回它的当前时间
os -- 得到操作系统的信息
ls -- 得到当前目录的文件列表
"""
self.wfile.write(result+"\n") class TxServer(ThreadingMixIn,TCPServer):
allow_reuse_address = 1 serveraddr = ('',8765)
srvr = TxServer(serveraddr,TxRequestHandler)
srvr.serve_forever()
16.7.实现一个半双工的聊天方式,其中一个人是服务端,另一个人是客户端。
其实也不难,只是将回射服务器做部分修改就可以。
服务器端:
#!/usr/bin/env python
#-*- coding:utf-8 -*- from socket import *
from time import ctime HOST = ''
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST,PORT) tcpSerSock = socket(AF_INET,SOCK_STREAM)
tcpSerSock.bind(ADDR)
tcpSerSock.listen(5) while True:
print 'waiting for connection...'
tcpCliSock,addr = tcpSerSock.accept()
print '...connected from:',addr while True:
rdata = tcpCliSock.recv(BUFSIZ)
if not rdata:
break
print rdata
sdata = raw_input(">")
tcpCliSock.send('[%s] %s' % (ctime(),sdata))
tcpCliSock.close() tcpSerSock.close()
客户端:
#!/usr/bin/env python
#-*-coding:utf-8-*- from socket import *
import sys if(len(sys.argv) < 3):
HOST = 'localhost'
PORT = 21567
else:
HOST = sys.argv[1]
PORT = int(sys.argv[2]) BUFSIZ = 1024
ADDR = (HOST,PORT) tcpCliSock = socket(AF_INET,SOCK_STREAM)
tcpCliSock.connect(ADDR) while True:
data = raw_input('> ')
if not data:
break
tcpCliSock.send(data)
data = tcpCliSock.recv(BUFSIZ)
if not data:
break
print data tcpCliSock.close()
16.8.实现一个全双工的聊天方式,即两个人可以独立地发送和接收消息。
全双工其实原理也不太难,但是我一直傻逼了,一直用写服务器端的方法去实现客户端的程序。
我所使用的方法也是最常用的技术——多线程。以下是服务器端和客户端的编写思路:
服务器端:在服务器端我主要用了一个主线程来accept客户端的链接,没接受了一个连接,就新建两个线程,一个用于发送消息,一个用于接收消息。
客户端:思路完全不一样,由于客户端面对的只有服务器,所以主线程只能是接收消息(发送消息),然后发送消息(接收消息)作为一个线程来并发。
由于这里的数据并不是共享的,所以这里的线程写起来就很轻松,不用考虑同步问题。
服务器端:
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import socket,traceback,os
from threading import * host = ''
port = 51423 #监听所有的接口 #接受消息的线程
def handlerecv(clientsock):
print "New child",currentThread().getName()
print "Got connection from",clientsock.getpeername()
while True:
data = clientsock.recv(4096)
if not len(data):
break
print data
clientsock.close() #发送消息的线程
def handlesend(clientsock):
while True:
data = raw_input(">")
data = data + "\n"; #加上换行,好看一点。
clientsock.sendall(data)
#关闭连接
clientsock.close() #建立套接字
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((host,port))
s.listen(1) while True:
try:
clientsock,clientaddr = s.accept()
except KeyboardInterrupt:
raise
except:
traceback.print_exc()
continue t = Thread(target = handlerecv,args=[clientsock])
t.setDaemon(1)
t.start() r = Thread(target = handlesend,args=[clientsock])
r.setDaemon(1)
r.start()
客户端:
#!/usr/bin/env python
#-*-coding:utf-8-*- from socket import *
import sys
from threading import * if(len(sys.argv) < 3):
HOST = 'localhost'
PORT = 51423
else:
HOST = sys.argv[1]
PORT = int(sys.argv[2]) BUFSIZ = 1024
ADDR = (HOST,PORT) def handlesend(tcpCliSock):
while True:
sdata = raw_input('> ')
if not sdata:
break
tcpCliSock.send(sdata) tcpCliSock.close() tcpCliSock = socket(AF_INET,SOCK_STREAM)
tcpCliSock.connect(ADDR) #建立发送消息的线程
s = Thread(target = handlesend,args=[tcpCliSock])
s.setDaemon(1)
s.start() while True:
rdata = tcpCliSock.recv(BUFSIZ)
if not rdata:
break
print rdata
tcpCliSock.close()
16.10.实现一个多房间全双工的聊天方式,把聊天服务器改成支持多用户版本。
其实思路差不多,只不过过程有点繁琐,在服务器端要建立字典,作为房间,然后每个套接字存在字典当中,然后作适当的分发。
另外一种方法使用广播不知道可不可以了。
这里直接贴人家写的代码学习一下:
服务器端:
#!/usr/bin/env python
# _*_ coding: utf8 _*_ from socket import *
from time import ctime
import threading
from string import split HOST = ''
PORT = 21567
BUFSIZE = 1024
ADDR = (HOST, PORT) def Deal(sck, username, room):
while True:
data = sck.recv(BUFSIZE)
for i in clients[room].iterkeys():
if i <> username:
if data <> "quit":
clients[room][i].send("[%s] %s: %s" %(ctime(), username, data))
else:
clients[room][i].send("用户%s在%s退出房间%s" %(username, ctime(), room ))
if data == "quit":
del clients[room][username]
sck.send(data)
sck.close()
break chatSerSock = socket(AF_INET, SOCK_STREAM)
chatSerSock.bind(ADDR)
chatSerSock.listen(5) clients = {"":{},} while True:
print 'waiting for connection...'
chatCliSock, addr = chatSerSock.accept()
print "...connected romt: ", addr
data = chatCliSock.recv(BUFSIZE)
username, room = split(data)
print username
if not clients.has_key(room):
clients[room] = {}
if clients[room].has_key(username):
chatCliSock.send("reuse")
chatCliSock.close()
else:
chatCliSock.send("success")
clients[room][username] = chatCliSock
t = threading.Thread(target=Deal, args=(chatCliSock, username, room))
t.start() chatSerSock.close()
客户端:
#!/usr/bin/env python
# _*_ coding: utf8 _*_ from socket import *
from time import ctime
import threading
import random
from sys import argv, exit, stdout
from getopt import gnu_getopt, GetoptError help_info = ["cs.py [ -h | --help | -u | --username] username",
"\t-h or --help\t显示帮助信息",
"\t-u or --username\指定用户名",
"\t-r or --room\t指定房间"]
def help():
for i in help_info:
print i def Send(sck, test):
while True:
data = raw_input('>')
sck.send(data)
if data == "quit":
break
def Recieve(sck, test):
while True:
data = sck.recv(BUFSIZ)
if data == "quit":
sck.close()
break
str = "\n" + data + "\n>"
stdout.write(str) HOST = 'localhost'
PORT= 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)
threads = [] if __name__ == "__main__":
# 解析命令行参数
try:
opts, args = gnu_getopt(argv[1:], "hu:r:", ["help", "username=", "room="])
except GetoptError, err:
print str(err)
help()
exit(2)
username = ""
room = ""
for o, a in opts:
if o in ("-h", "--help"):
help()
exit(0)
elif o in ("-u", "--username"):
username = a
elif o in ("-r", "--room"):
room = a
else:
print "未知选项"
help()
exit(2)
if not username or not room:
help()
exit(2)
chatCliSock = socket(AF_INET, SOCK_STREAM)
chatCliSock.connect(ADDR)
chatCliSock.send("%s %s" %(username, room))
data = chatCliSock.recv(BUFSIZ)
if data == "reuse":
print "用户%s已登录房间%s" %(username, room)
raw_input()
exit(1)
elif data == "success":
print "用户%s成功登录房间%s" %(username, room)
t = threading.Thread(target=Send, args = (chatCliSock, None))
threads.append(t)
t = threading.Thread(target=Recieve, args = (chatCliSock, None))
threads.append(t)
for i in range(len(threads)):
threads[i].start()
threads[0].join()
16.11.写一个网页客户端。自己新建一个套接字,然后发送http请求。
感觉难度不大。
#!/usr/bin/env python
#-*-coding:utf-8-*- import socket,sys website = sys.argv[1]
port = 80
print website print "Creating socket...",
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
print "done." print "Connecting to ...",
s.connect((website,port))
print "done." s.send("GET /index.html HTTP/1.0\r\n\r\n")
data = s.recv(4096)
print data
16-12.休眠服务器,在服务器端上面加个sleep(num)就好,在这里就不贴了。
16-13.功能太过复杂,本人渣渣,没精力写。
16-14.考虑的东西很多,水平有限,不做了。
16-15.异步和SocketServer。这个用多线程可以实现,在《python网络编程基础》上面直接有源码。使用方法都有教。
#!/usr/bin/env python
#-*- coding:utf-8 -*- from SocketServer import ThreadingMixIn,TCPServer,StreamRequestHandler
import time class TimeRequestHandler(StreamRequestHandler):
def handle(self):
req = self.rfile.readline().strip()
if req == "asctime":
result = time.asctime()
elif req == "seconds":
result = str(int(time.time()))
elif req == "rfc822":
result = time.strftime("%a, %d %b %Y %H:%M:%S +0000",time.gmtime())
else:
result = """
Unhandled request.Send a line with one of the following words:
asctime -- for human-readable time
seconds -- seconds since the Unix Epoch
rfc822 -- data/time in format used for mail and news posts
"""
self.wfile.write(result + "\n") class TimeServer(ThreadingMixIn,TCPServer):
allow_reuse_address = 1 serveraddr = ('',8765)
srvr = TimeServer(serveraddr,TimeRequestHandler)
srvr.serve_forever()
转载请注明出处http://www.cnblogs.com/sysu-blackbear/
多多指教!谢谢!
Python核心编程——Chapter16的更多相关文章
- python核心编程第二版笔记
python核心编程第二版笔记由网友提供:open168 python核心编程--笔记(很详细,建议收藏) 解释器options:1.1 –d 提供调试输出1.2 –O 生成优化的字节码(生成 ...
- python核心编程--笔记
python核心编程--笔记 的解释器options: 1.1 –d 提供调试输出 1.2 –O 生成优化的字节码(生成.pyo文件) 1.3 –S 不导入site模块以在启动时查找pyt ...
- Python核心编程第二版(中文).pdf 目录整理
python核心编程目录 Chapter1:欢迎来到python世界!-页码:7 1.1什么是python 1.2起源 :罗萨姆1989底创建python 1.3特点 1.3.1高级 1.3.2面向 ...
- python核心编程--笔记(不定时跟新)(转)
的解释器options: 1.1 –d 提供调试输出 1.2 –O 生成优化的字节码(生成.pyo文件) 1.3 –S 不导入site模块以在启动时查找python路径 1.4 –v ...
- python核心编程笔记(转)
解释器options: 1.1 –d 提供调试输出 1.2 –O 生成优化的字节码(生成.pyo文件) 1.3 –S 不导入site模块以在启动时查找python路径 1.4 –v 冗 ...
- python核心编程(第二版)习题
重新再看一遍python核心编程,把后面的习题都做一下.
- Python核心编程这本书的一些错误
<Python核心编程第二版>这本书比<Python基础教程第二版修订版>详细很多,丰富了很多细节,虽然它是一本经典的入门书,但我发现还是存在一些明显的错误.在面向对象编程这一 ...
- Python核心编程-描述符
python中,什么描述符.描述符就是实现了"__get__"."__set__"或"__delete__" 方法中至少一个的对象.什么是非 ...
- Python核心编程-闭包
百度搜了一下闭包的概念:简而言之,闭包的作用就是在外部函数执行完并返回后,闭包使得收机制不会收回函数所占用的资源,因为内部函数的执行需要依赖外函数中的变量.这是对闭包作用的非常直白的描述,不专业也不严 ...
随机推荐
- liunx总结题
一. 简述什么是Linux内核,这个学期学了Linux课程的哪些内容.(10分) Linux内核诞生于1991年,由芬兰学生Linus Torvalds(林纳斯.托瓦斯)发起,那 ...
- SVN基础操作
SVN基础操作 安装 #大多数Linux版本自带svn svn --version #如果没有安装可用yum安装 yum install subversion 生命周期 创建版本库 检出 更新 执行变 ...
- Unity协程Coroutine使用总结和一些坑
原文摘自 Unity协程Coroutine使用总结和一些坑 MonoBehavior关于协程提供了下面几个接口: 可以使用函数或者函数名字符串来启动一个协程,同时可以用函数,函数名字符串,和Corou ...
- Kafka高性能吞吐关键技术分析
Apache Kafka官网提供的性能说明: Benchmarking Apache Kafka: 2 Million Writes Per Second (On Three Cheap Machin ...
- [Hanani]JAVA大数相关学习记录
1.Basic remains 题目链接 涉及内容: |大数读入|大数模|大数进制读入时转化为十进制|大数输出时转化为其他进制输出| import java.io.*; import java.mat ...
- 1. Python3 环境搭建
Python3 环境搭建 开门见山,其他关于Python发展史.语言类型.优缺点等等 可以自己去百度百度,这里就不多说了.其实基本想要学这门语言的时候,你已经了解差不多了!!! Python的运行环境 ...
- 小学四则运算APP 第一阶段冲刺 第二天-补
团队成员:陈淑筠.杨家安.陈曦 团队选题:小学四则运算APP 第一次冲刺阶段时间:11.17~11.27 本次发布已经解决上次问题,问题是写程序逻辑错误,问题已经修改!我们还增加两个模块的面板设置,如 ...
- ns3 myfirst.cc 两个节点点对点通信
首先在ns3.25/examples/tutorial/下找到 first.cc文件,将他拷贝到到scratch目录下. 然后为了方便将代码打出来 /* -*- Mode:C++; c-file-st ...
- 编码用命令行执行的C语言词语统计程序
需求介绍 程序处理用户需求的模式为: wc.exe [parameter][filename] 在[parameter]中,用户通过输入参数与程序交互,需实现的功能如下: 1.基本功能 支持 -c ...
- (改进)Python语言实现词频统计
需求: 1.设计一个词频统计的程序. 2.英语文章中包含的英语标点符号不计入统计. 3.将统计结果按照单词的出现频率由大到小进行排序. 设计: 1.基本功能和用法会在程序中进行提示. 2.原理是利用分 ...