面向对象扩展
1、isinstance(obj, cls), issubclass(sub, super)示例
class A(object):
def a(self):
print "A"
class B(A): #B继承A
def b(self):
print "B"
t = B()
print isinstance(t, A) #判断t是否为A的实例对象
print isinstance(t, B) #判断t是否为B的实例对象
print issubclass(B, A) #判断B是否为A的派生类
2、异常处理
异常的完整结构
try:
pass #主代码块在这里执行
except:
pass #出现异常时，执行此处语句
else:
pass #主代码块执行完毕之后，执行此处语句
finally:
pass #不管是否有异常，最终都会输出结果
自定义异常
"""__str__方法"""
class MyError(Exception):
def __init__(self, msg):
self.message = msg
def __str__(self):
return self.message
try:
#"http error"是传入的message信息，产生异常时会调用__str__方法，并返回传入的 # http error
raise MyError("http error")
except Exception, e:
print e
3、反射
"""第一种方法：反射（针对海量页面，根据URL的不同返回不同的页面）"""
print "Welcome, My Web"
url = raw_input("http://")
controller, action = url.split("/")
func = getattr(home, action)
ret = func()
print ret
"""第二种方法，匹配每个不同的URL，返回不同的页面"""
print "Welcome, My Web"
url = raw_input("http://")
if url == "home/home":
print home.home()
elif url == "home/page":
print home.page()
elif url == "home/row":
print home.row()
else:
print "wrong url"
getattr, setattr, hasattr, delattr
print dir(home)
print hasattr(home, "home")
setattr(home, "liyang", "gentle men")
print dir(home)
delattr(home, "liyang")
delattr(home, "row")
print dir(home)
结果：
['__author__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'home', 'page', 'row']
True
['__author__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'home', 'liyang', 'page', 'row']
['__author__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'home', 'page']
"""反射三，动态导入模块"""
controller, action = raw_input("http://").split("/")
#将模块以字符串的形式导入，输入home/home，得到返回值home
module = __import__(controller)
func = getattr(module, action)
ret = func()
print ret
结果：
http://home/home
home
4、Socket编程
"""socket-server"""
def main():
# 创建socket对象
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
# 监听端口, 地址以元组的形式表现
sock.bind(('127.0.0.1', 8001))
# 开始监听，5表示队列中可以保存的，未被服务器端所处理的连接
sock.listen(5)
while True:
# 阻塞，deng 。。。。
# 直到有请求连接
print '....'
connection, address = sock.accept()
# connection，代表客户端socket对象，
# address，客户端IP地址
#handle_request(connection)
#接受客户端传来的信息
buf = connection.recv(1024)
print buf
connection.send("HTTP/1.1 200 OK\r\n\r\n")
connection.send("Hello, World")
connection.close()
if __name__ == '__main__':
main()
""""socket-client:"""
import socket
__author__ = 'LiYang'
#创建socket对象
obj_client = socket.socket()
#客户端连接服务器端的地址
obj_client.connect(("localhost", 8021))
#客户端向服务器端发送的数据
obj_client.send("client")
#客户端接受服务器端的返回值，并输出
server_data = obj_client.recv(1024)
print server_data
#关闭客户端连接
obj_client.close()
5、设计模式----单例模式
单例模式，顾名思义就是只有一个实例的模式，避免内存浪费
"""""""""""单例类定义 """"""""""""
class SqlHelper(object):
__instance = None #声明类的私有静态字段
def __init__(self):
self.hostname = '0.0.0.0'
self.port = 3306
self.password = '123'
self.username = 'root'
@classmethod
def singleton(cls):
if cls.__instance: #实例存在，直接返回
return cls.__instance
else:
cls.__instance = SqlHelper() #实例不存在，此处执行实例化，并返回
return cls.__instance
#验证一
print id(SqlHelper())
print id(SqlHelper())
print id(SqlHelper())
结果（返回相同的内存地址）：
34354400
34354400
34354400
#验证二
obj1 = SqlHelper.singleton()
obj2 = SqlHelper.singleton()
print id(obj1)
print id(obj2)结果（返回相同的内存地址）：
33693256
33693256
Python网络编程
在Unix/Linux的世界中，socket套接字是实现应用程序间网络通信的方式，socket套接字指的是IP地址和端口号一组描述。
"""server-socket"""
服务器端，socket的创建顺序是：
创建socket套接字---->绑定IP地址和端口----->服务器启动监听---->服务器阻塞直到客户端的连接请求---->接受客户端的数据---->关闭socket连接
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Writed by liyang
import os
import SocketServer
import socket
__author__ = 'LiYang'
class MyServer(SocketServer.BaseRequestHandler):
def handle(self):
"""显示客户端的连接地址"""
print "Got connection from ", self.client_address
while True:
"""接收客户端输入的命令，并显示命令"""
data = self.request.recv(1024)
print "Receive cmd from client: %s" % data
"""执行命令，并将返回值复制给cmd_result"""
cmd_result = os.popen(data).read()
"""显示返回结果的大小,并发送给客户端"""
print "The size of cmd_result: ", len(cmd_result)
self.request.sendall(str(len(cmd_result)))
"""发送给客户端命令的返回结果"""
self.request.sendall(cmd_result)
if __name__ == '__main__':
server = SocketServer.ThreadingTCPServer(('127.0.0.1', 8000), MyServer)
server.serve_forever()
"""client-socket"""
客户端，socket的创建顺序是：
创建socket套接字---->连接服务器端的地址---->向客户端发送数据---->得到服务器端返回的数据---->关闭socket连接
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Writed by liyang
import SocketServer
import socket
__author__ = 'LiYang'
"""服务器端地址和端口"""
ip_port = ('127.0.0.1',8000)
"""创建套接字"""
sk = socket.socket()
"""连接服务器"""
sk.connect(ip_port)
"""设置超时时间"""
sk.settimeout(5)
while True:
"""输入要执行的命令"""
inp = raw_input('please input:')
sk.sendall(inp)
"""接收服务器传来的结果的大小"""
result_size = sk.recv(1024)
print "The size of data going to receive: ", result_size
total_size = int(result_size)
received_size = 0
while True:
data = sk.recv(1024)
received_size += len(data)
print "--data having--"
if total_size == received_size:
print data
print "--no data--"
break
print data
sk.close()
以上客户端和服务器端之间通过socket套接字，实现了在客户端上输入命令并返回服务器端的命令的执行结果。
总结
网络编程首先认识的socket套接字，socket是实现应用程序网络通信的必要技术，SocketServer模块则实现了服务器端的并发请求的处理。
Python学习渐渐进入了一个复杂有令人兴奋的阶段，感谢老师得辛苦讲解，我会边学习边复习，努力掌握每个重要的知识点。
