python 11期 第八天

一、isinstance(obj, cls)
检查obj是否是类 cls 的对象
class Foo(object):
pass

obj = Foo()

isinstance(obj, Foo)
可以判断属于某个类，或者属于某个类的父类。
作用：在用户输入的时候，可以对输入的数据进行分类操作，然后再和数据库交互。

二、issubclass(sub, super)
检查sub类是否是 super 类的派生类

class Foo(object):

pass

class Bar(Foo):
pass

issubclass(Bar, Foo)

三、异常处理
基本格式：
try:
pass
except Exception,ex:
pass

举例：
while True:
num1 = raw_input('num1:')
num2 = raw_input('num2:')
try:
num1 = int(num1)
num2 = int(num2)
result = num1 + num2
except Exception, e:
print '出现异常，信息如下：'
print e
捕获到异常后，返回一个信息，此处e一般可以输出在日志中，以便查看出错的内容。

常见异常：
AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError 输入/输出异常；基本上是无法打开文件
ImportError 无法引入模块或包；基本上是路径问题或名称错误
IndentationError 语法错误（的子类） ；代码没有正确对齐
IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
导致你以为正在访问它
ValueError 传入一个调用者不期望的值，即使值的类型是正确的

代码块中可能出现的任意异常：
s1 = 'hello'

try:
int(s1)
except IndexError,e:
print e
except KeyError,e:
print e
except ValueError,e:
print e

万能异常 在python的异常中，有一个万能异常：Exception，他可以捕获任意异常，即：
s1 = 'hello'

try:
int(s1)
except Exception,e:
print e

对于特殊处理或提醒的异常需要先定义，最后定义Exception来确保程序正常运行。
s1 = 'hello'

try:
int(s1)
except KeyError,e:
print '键错误'
except IndexError,e:
print '索引错误'
except Exception, e:
print '错误'

异常其他结构
try:

# 主代码块
pass
except KeyError,e:
# 异常时，执行该块
pass
else:
# 主代码块执行完，执行该块
pass
finally:
# 无论异常与否，最终执行该块
pass

主动触发异常
try:

raise Exception('错误了。。。') ##主动触发异常
except Exception,e:
print e

自定义异常
class WupeiqiException(Exception):

def __init__(self, msg):
self.message = msg

def __str__(self):
return self.message

try:
raise WupeiqiException('我的异常')
except WupeiqiException,e:
print e

断言：
# assert 条件

assert 1 == 1
如果上面的条件成立，才会执行下面的代码。
assert 1 == 2
上面的条件不成立，则会退也程序。
它相当于raise类似。

##在print 一个对象的时候，一般打印出来的都是该对象下的__str__方法。

四、反射
常用框架类型：
MVC框架：
models
views
controllers

MTV框架：
models
templates
views

手动获取url原理：
url='aaa/bbb'
d,e= url.split('/')
print d
print e

反射函数：getattr
首先新建一个py模块myflas.py，创建两个函数，内容如下：
def a():
return 'hello tingyun'

def b():
return "hello mynetuser"

再新建一个文件，导入上面的模块：

import myflas

fun1=getattr(myflas,'a')

print fun1()
fun2=getattr(myflas,'b')

print fun2()

通过getattr内置函数来获取myflas模块中的两个函数a 和 b，如果找到了，就将该函数返回给新的值，此处fun1函数就是a函数名。

setattr 作用：在模块中添加一个成员
setattr(myflas,'bright',lambda x,y:x+y)
fun3=getattr(myflas,'bright')
print fun3(43,98)
在myflas中新增加一个函数bright。

>>> hasattr(system,'argv') ##hasattr用来判断system模块中有没有argv函数
True
>>> delattr(system,'argv') ##delattr删除system模块中的argv函数

以上四个函数：hasattr,getattr,setattr,delattr除了可以对模块进行操作以外，还可以对类和对象中的成员进行操作。

多层反射：
反射的函数可以对模块或类进行操作，但是当一个类在一个模块中时，此时只用一次反射也只能将模块中的函数进行处理，却不能对模块中的类进行处理，此时就需要多层的反射来处理。

首先用一个getattr获取模块中的类，将此类赋值一个变量，再对该对象进行getattr来获取类中的静态方法。

总结，getattr就是去一个容器（包括模块和类等）中找它的元素。

五、动态模块导入
如果导入的模块还未确定的变量名，此时就可以用以下方法来导入：
__import__('obj')
下面的表示将导入的动态模块命名为opt，此功能模import x as y.
opt=__import__('obj')

举例：
modu=raw_input('pls input a name:')
opt=__import__(modu)
此处的modu是一个变量，因此用上面的方法来导入后，即可进行正常的模块操作了。

六、设计模式
1、单例模式

单例模式用来保证内存中仅存在一个实例！！！
如以下例子中，当多个用户对以下类请求多次时，会在内存中创建很多完全一样的实例，这样会导致内存空间的浪费：

#!/usr/bin/env python
#coding:utf-8
from wsgiref.simple_server import make_server

class DbHelper(object):
def __init__(self):
self.hostname = '1.1.1.1'
self.port = 3306
self.password = 'pwd'
self.username = 'root'

def fetch(self):
# 连接数据库
# 拼接sql语句
# 操作
return 'fetch'

def create(self):
# 连接数据库
# 拼接sql语句
# 操作
return 'create'

def remove(self):
# 连接数据库
# 拼接sql语句
# 操作
return 'remove'

def modify(self):
# 连接数据库
# 拼接sql语句
# 操作
return 'modify'

class Handler(object):
def index(self):
# 创建对象
db = DbHelper()
db.fetch()
return 'index'

def news(self):
return 'news'

def RunServer(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
url = environ['PATH_INFO']
temp = url.split('/')[1]
obj = Handler()
is_exist = hasattr(obj, temp)
if is_exist:
func = getattr(obj, temp)
ret = func()
return ret
else:
return '404 not found'

if __name__ == '__main__':
httpd = make_server('', 8001, RunServer)
print "Serving HTTP on port 8001..."
httpd.serve_forever()

因此通过面向对象的特性，构造出单例模式：
# ########### 单例类定义 ###########
class Foo(object):

__instance = None

@staticmethod
def singleton():
if Foo.__instance:
return Foo.__instance
else:
Foo.__instance = Foo()
return Foo.__instance

# ########### 获取实例 ###########
obj = Foo.singleton()
以上的类中有一个singleton方法被定义为静态方法，此方法无需实例化可直接调用，第一次调用时私有静态字段__instance为空，则会把Foo类实例化到__instance私有静态字段中成为一个对象，再返回此私有字段；第二次调用时，此私有静态字段就是实例化的Foo类，就相当于又调用了上一次实例化的那个对象，以及以后每次调用时都会使用此对象，就相当于只创建一次对象，会实多次使用，这就是单例模式。但是单例模式只适用于没有数据库连接池的情况下使用。

七、socker原理
http一般的链接（除长链接）是在请求一次，回复请求后会立即断开。http协议是基于tcp连接创建的。
tcp连接可以通过socket来创建。
ocket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）




web服务应用：

import socket

def handle_request(client):
buf = client.recv(1024)
client.send("HTTP/1.1 200 OK\r\n\r\n")
client.send("Hello, World")

def main():
#创建socket对象

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#使用bind方法来监听端口

sock.bind(('localhost',8080))
#开始监听,5最大连接数

sock.listen(5)

while True:
#accept会阻塞住程序的运行，等待有请求连接

connection, address = sock.accept()
#connection：代表连接；address: 代表客户端连接地址
handle_request(connection)
connection.close()

if __name__ == '__main__':
main()
#python中所有的框架都是基于socket连接来开发的。如果不想让accept阻塞程序运行可以用：
server.setblocking(False)，但是此时如果accept在接收不到请求的时候，会报错，recv也会报错。

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
参数一：协议，地址簇

　　socket.AF_INET IPv4（默认）
　　socket.AF_INET6 IPv6
　　socket.AF_UNIX 只能够用于单一的Unix系统进程间通信

参数二：TCP或UDP类型 socket.SOCK_STREAM　　流式socket , for TCP （默认）
　　 socket.SOCK_DGRAM　　 数据报式socket , for UDP

　　socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
　　socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
　　socket.SOCK_SEQPACKET 可靠的连续数据包服务
参数三、0
0是根据IPV4或V6、TCP或UDP来自动选择一个合适的协议。

自己编写socker服务端和客户端：
server:
#coding:utf8
import socket

server=socket.socket()
server.bind(('127.0.0.1',8571))
server.listen(2) #最大连接数

while True:
#阻塞中，获取连接和地址
print 'waiting...'
connect,addr = server.accept()
#接收客户端的数据，最多一次为小于或等于1024字节
client_data=connect.recv(1024)
print client_data
#通过缓冲区向客户端发送数据(缓冲区有算法来定何时发送)
connect.send('abcdefg')
#立即让缓冲区发送数据到客户端
#connect.sendall('abcdefg')
connect.close()

client:
#coding:utf8
import socket

client=socket.socket()
#连接到服务器
client.connect(('127.0.0.1',8571))
client.send('help me')
#接收服务端传来的数据
server_data=client.recv(1024)
print server_data
client.close()

socket常用的方法：
sk.bind(address)

　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

sk.listen(backlog)

　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
这个值不能无限大，因为要在内核中维护连接队列

sk.setblocking(bool)

　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept()

　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

　　接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address)

　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address) #如果连接出错，不会报异常，会返回一个错误编码

　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close()

　　关闭套接字

sk.recv(bufsize[,flag])

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.recvfrom(bufsize[.flag]) #多用于UDP协议

　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag])

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

sk.sendall(string[,flag])

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

内部通过递归调用send，将所有内容发送出去。

sk.sendto(string[,flag],address) #用于UDP，不需要建立加接直接发送，指定发送的主机地址

　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout) #用于客户端，设置超时时间，大于此时间自动放弃连接

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername() #针对客户端返回服务器的地址和端口

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname() #针对服务端，返回服务器自己的地址和端口

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

sk.fileno()

　　套接字的文件描述符

##################################################
##智能机器人

server端：

#coding:utf8
import socket

ip_port = ('127.0.0.1',8888)
sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)

event={'2':'通过可能会被录音.balabala一大推',
'3':'这个可能是你操作不当的问题',
'4':'这个网络的问题'
}
while True:
conn,address = sk.accept()
conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
Flag = True
while Flag:
data = conn.recv(1024)
print data
if data == 'exit':
Flag = False
elif data in event.keys():
conn.sendall(event.get(data))
else:
conn.sendall('请重新输入.')
conn.close()

#此服务端是单线程，同一时间只能处理一个请求，第二个请求到来只能等待

client端：
#coding:utf8
import socket

ip_port = ('127.0.0.1',8888)

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()

#多线程socker服务端：
import SocketServer
class MyServer(SocketServer.BaseRequestHandler):

def handle(self):
# print self.request,self.client_address,self.server
conn = self.request #每一个客户端
print "client is : ",self.client_address
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('请重新输入.')

if __name__ == '__main__':
server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
server.serve_forever()

#这个多线程服务的固定格式，就是必须要定义一个类，此类要继承SocketServer.BaseRequestHandler类。而且类中必须有一个方法名叫handle，不能更改。所有过来的请求，都会去找此handle方法处理，再将此类传给ThreadingTCPServer处理，它在内部增加了多线程的机制。serve_forever()用来启动多线程服务。每次来一个请求，ThreadingTCPServer类都会实例化一个MyServer类来处理请求。