Python 解析 XML文件
python 中使用 xml.dom.minidom模块来解析XML文件， xml.dom.minidom.parse() 用于打开一个XML文件，并将这个文件对象转为xmldom变量。
xmldom.documentElement 用于得到dom对象的根节点，并把获得的对象给root ,每一个节点都有它的 nodeName 、 nodeValue 、 nodeType 属性， nodeName 为节点名字， nodeValue 是节点的值（只对文本节点有效）， nodeType 是节点的类型， nodeType 的12种类型：
#encoding = utf-8
import xml.dom.minidom
# 打开一个XML文件
xmlcode = xml.dom.minidom.parse('dome.xml')
print(xmlcode)
# 获取XML文件的根节点
root = xmlcode.documentElement
# 获取节点的名字
print(root.nodeName)
print(root.nodeValue)
print(root.nodeType)
# 获得节点下的所有子节点 包括换行节点
print(root.childNodes)
# 获得根节点下的 stydent 子节点
stunodes = root.getElementsByTagName('student')
print(stunodes)
for n in stunodes:
if stunodes.getAttribute('id') == 1:
# 修改节点内容
n.getElementsByTagName('name')[0].firstChild.data = '新内容'
break
# 判断属性是否存在
print(root.hasAttribute('id'))
# 获取属性
print(root.getAttribute('id'))
# 设置属性
root.setAttribute('id', 12)
# 创建一个新的节点 并添加到根节点下
newElemt = xmlcode.createElement('new')
newElemt.setAttribute('id', 13)
root.appendChild(newElemt)
# 把更改后的DOM对象写入文件
xmlFile = open('dome.xml', mode="w", encoding="utf-8")
xmlFile.write(xmlcode.toprettyxml())
在python 中使用 SAX 解析 XML
SAX是一种基于事件驱动的API , 通常包含三个事件： 开始解析标签事件、解析数据事件、结束解析标签事件
利用 SAX 解析 XML 文档涉及两个部分：解析器和事件处理器。解析器负责读取XML文档，并向事件处理器发送事件，如元素开始和元素结束事件。而事件处理器则负责对事件作出相应数据进行处理。
SAX解析XML适用场景： 1、对大型文件进行处理； 2、只需要文件的部分内容，或者只需从文件中得到特定信息。
#encoding=utf-8
#导入相关模块
import xml.sax
import xml.sax.handler
# 定义一个类，并继承 xml.sax.ContentHandler
class studentHander(xml.sax.ContentHandler):
def __init__ (self):
print('开始解析')
#开始解析文档
def startDocument(self):
print('开始解析文档')
#结束文档解析
def endDocument(self):
print('结束文档解析')
# 开始解析某个标签
def startElement(self, name, attrs):
print('{0}标签开始解析'.format(name))
if name == 'movie':
print('该标签的属性值为{0}'.format(attrs['title']))
# 结束解析某个标签
def endElement(self, name):
print('{0}标签结束解析'.format(name))
# 解析过程，获得解析得到的值
def characters(self, content):
print('解析过程，获得解析得到的值为{0}'.format(content))
# 创建一个新的解析器对象并返回
parser = xml.sax.make_parser()
# 指定解析器的ContentHandler对象
parser.setContentHandler(studentHander())
# 解析XML文件
parser.parse("dome.xml")
多线程
运行中的程序，称为进程；一个程序对应一个进程，一个进程可包含多个线程。
线程，有时被称为轻量级进程，是程序执行流的最小单位。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。
线程有就绪、阻塞、运行三种基本状态。
python 通过两个标准库 _thread 和 threading 提供对线程的支持。_thread 提供了低级别的、原始的线程以及一个简单的锁。相对于 threading 模块功能有限。
threading 模块包含了 _thread模块所有的方法，还提供其他的方法：
threading.currentThread() : 返回当前的线程变量
threading.enumerate()： 返回一个包含正在运行的线程的list 。正在运行指线程启动后、结束前。不包括启动前和终止后的线程。
threading.activeCount() ： 返回正在运行的线程数量，相对于 len(threading.enumerate())
除了threading模块的方法外，线程模块同样提供了 Thread 类来处理线程， Thread 类提供了以下方法：
run() : 用来表示线程活动
start() : 启动线程活动
join([time])： 等待至线程终止，这阻塞调用线程直至线程的join() 方法被调用终止，正常退出或者抛出未处理的异常或者是可选的超时发生
isAlive() : 返回线程是否活动
getName() : 返回线程名
setName() ： 设置线程名
#encoding=utf-8 import threading # 获得当前的线程对象 currentThread = threading.currentThread() # 线程是否正在运行 print(currentThread.isAlive()) # 线程名字 print(currentThread.getName()) # 是否为后台线程 print(currentThread.isDaemon()) # 正在运行的线程数量 print(threading.activeCount()) # 正在运行的所有线程列表 print(threading.enumerate())
使用函数创建多线程：
#encoding=utf-8
import time
import _thread
def showTime(name, delayTime):
count = 1
while count <=6:
time.sleep(delayTime)
count = count + 1
print('执行体的名字{0},当前时间{1}'.format(name, time.ctime(time.time())))
# 依次执行各个方法，需要耗费长时间
# showTime('cs1', 2)
# showTime('cs2', 2)
# showTime('cs3', 2)
# showTime('cs4', 2)
# 使用函数创建多线程
try:
# 开启设置多个线程
_thread.start_new_thread(showTime, ('cs1', 2))
_thread.start_new_thread(showTime, ('cs2', 2))
_thread.start_new_thread(showTime, ('cs3', 2))
_thread.start_new_thread(showTime, ('cs4', 2))
print('设置完毕')
except:
print('error')
finally:
while True:
pass
使用类来创建多线程：
#encoding=utf-8
import time
import threading
def showTime(name, delayTime):
count = 1
while count <=6:
time.sleep(delayTime)
count = count + 1
print('执行体的名字{0},当前时间{1}'.format(name, time.ctime(time.time())))
# 依次执行各个方法，需要耗费长时间
# showTime('cs1', 2)
# showTime('cs2', 2)
# showTime('cs3', 2)
# showTime('cs4', 2)
# 使用类来创建多线程
class myThread(threading.Thread):
def __init__(self, name, delayTime):
threading.Thread.__init__(self) # 重点
self.name = name
self.delayTime = delayTime
# 定义多线程执行逻辑，通过 start方法触发
def run(self):
print('{0}多线程开始执行'.format(self.name))
showTime(self.name, self.delayTime)
myThread1 = myThread('cs1', 2)
myThread2 = myThread('cs2', 2)
myThread3 = myThread('cs3', 2)
myThread4 = myThread('cs4', 2)
myThread1.start() # 调用 start 方法， 会自动调用类里面的 run 方法
myThread2.start()
myThread3.start()
myThread4.start()
多线程的同步：
#encoding=utf-8
import threading
import time
count = 2
# 获得 lock对象，锁，用于多线程的同步
lock = threading.Lock()
class saleTick(threading.Thread):
def __init__(self, name):
threading.Thread.__init__(self)
self.name = name
def run(self):
global count, lock
# 进行锁定，此时其他线程该部分进入阻塞状态，会等该部分解锁后继续执行，用于保持数据的同步
lock.acquire()
if count >= 1:
time.sleep(2)
count = count - 1
print('买到票，余票{0}'.format(count))
else:
print('没抢到票')
# 进行解锁，其他线程可使用
lock.release()
thread1 = saleTick('p1')
thread2 = saleTick('p2')
thread3 = saleTick('p3')
thread4 = saleTick('p4')
thread1.start()
thread2.start()
thread3.start()
thread4.start()
装饰器
装饰器是把一个函数作为参数的函数，常常用于扩展已有函数，即不改变当前函数状态下增加功能。 通常使用 @名称 标记
import time
# 定义一个装饰器
def countTime(f):
def wrapper(*args, **kwargs): # 传入参数，表示可有可无
begin = time.time()
f(*args, **kwargs) # 这里代表的是使用装饰器的函数逻辑
end = time.time()
print(end - begin)
return wrapper
@countTime
def test():
for n in range(100):
for t in range(100):
pass
test()
单例模式
一个类自始至终只产生一个实例对象，称为单例模式。
单例模式三个要点：1、某个类只能有一个实例 ； 2、 它必须自行创建这个实例； 3、它必须自行向整个系统提供这个实例；
#encoding=utf-8
# 创建单例模式类
class Singleton(object): # object 是所有类的父类
# 定义一个变量存储实例对象
_singletObject = None
# 构造方法
def __init__(self, *args, **kwargs):
object.__init__(self, *args, **kwargs)
# 初始化方法
def __new__(cls, *args, **kwargs):
if Singleton._singletObject is None: # 如果当前没有实例对象
Singleton._singletObject = object.__new__(cls) #创建一个实例对象并存储
return Singleton._singletObject # 存在实例对象，直接将其返回
# 创建一个类，继承单例模式
class Myclass(Singleton):
def __init__(self, name):
Singleton.__init__(self) # 调用父类的构造方法
self.name = name
# 这里创建的都是同个实例对象
a = Myclass('a')
b= Myclass('b')
print(a.name) # b
print(b.name) # b