Python学习笔记（4）

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