文章目录
Part 1 Python 编程进阶(下)课后题
【解析】Python内置类属性
__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块 mymod中，那么className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）
【解析】 正则表达式特殊字符类
| 字符 | 含义 |
|---|---|
| . | 匹配除“\n”外的任何单个字符。如果要匹配包括“\n”在内的任何字符则使用[.\n]模式 |
| \d | 匹配一个数字字符，等价于[0-9] |
| \D | 匹配一个非数字字符，等价于[^0-9] |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于[\f\n\r\t\v] |
| \S | 匹配任何非空白字符，等价于[^\f\n\r\t\v] |
| \w | 匹配包括下划线的任何单词字符，等价于[A-Za-z0-9] |
| \W | 匹配任何非单词字符。等价于[^A-Za-z0-9] |
【解析】XML是指可扩展标记语言eXtensible Markup Language。它被设计用于存储和传输数据。
python有三种方法解析XML，SAX，DOM，以及ElementTree。
1.SAX (simple API for XML )
python 标准库包含SAX解析器，SAX用事件驱动模型，通过在解析XML的过程中触发一个个的事件并调用用户定义的回调函数来处理XML文件。
2.DOM(Document Object Model)
将XML数据在内存中解析成一个树，通过对树的操作来操作XML。
3.ElementTree(元素树)
ElementTree就像一个轻量级的DOM，具有方便友好的API。代码可用性好，速度快，消耗内存少。
Part 2 Python 编程进阶(下)实验操作
实验步骤一 Python面向对象
实验代码 类的创建
#!/usr/bin/python
#coding=utf-8
class Employee:
empCount=0
def __init__(self,name,salary):# 一种特殊的方法，类的构造函数，一旦创建类的实例便会调用这种方法。
self.name=name
self.salary=salary
Employee.empCount+=1
def disCount(self):
print "total employee:" % Employee
def disEmployee(self):
print "name:",self.name,"salary:",self.salary
emp1=Employee("Zara",2000)#创建了一个类的实例
emp2=Employee("Liza",4000)#又创建了一个类的实例
emp1.disEmployee()
emp2.disEmployee()#用于访问对象的属性、方法
print "total Employee:",Employee.empCount
# Python内置类的属性
print "Employee.__doc__",Employee.__doc__#类的文档字符串
print "Employee.__name__",Employee.__name__#类的名字
print "Employee.__module__",Employee.__module__#类定义所在的模块
print "Employee.__bases__",Employee.__bases__#类的所有父类构成元素，包含一个由父类构成的元组
print "Employee.__dict__",Employee.__dict__#类的属性，由类的数据属性构成
实验结果
实验代码 对象销毁（垃圾回收）
# Python对象销毁（垃圾回收）
#当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时，
#也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。
# 但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。
class Point:
def __init__(self,x=0,y=0):
self.x=x
self.y=y
def __del__(self):
class_name=self.__class__.__name__
print class_name,"destroyed"
pt1=Point()
pt2=pt1
pt3=pt1
print id(pt1),id(pt2),id(pt3)
del pt1
del pt2
del pt3
实验结果
实验代码 类的继承
#类的继承
#面向对象编程可以通过继承实现代码的重用
class Parent:
parentAttr=100
def __init__(self):
print "call the baseclass constructor."
def parentMethod(self):
print "call the baseclass method."
def setAttr(self,attr):
Parent.parentAttr=attr
def getAttr(self):
print "parent attribute:",Parent.parentAttr
class Child(Parent):
def __init__(self):
print "call the subclass constructor."
def childMethod(self):
print "call the subclass method."
c=Child()
c.childMethod()
c.parentMethod()
c.setAttr(200)
c.getAttr()
实验结果
实验代码 方法重写
class Parent1:
def myMethod(self):
print "call the baseclass method."
class Child1(Parent1):
def myMethod(self):
print "call the subclass method."
c1=Child1()
c1.myMethod()
实验结果
实验代码 运算符重载
# 运算符重载
class Vector:
def __init__(self,a,b):
self.a=a
self.b=b
def __str__(self):
return 'Vector (%d,%d)'%(self.a,self.b)
def __add__(self,other):
return Vector(self.a+other.a,self.b+other.b)
v1=Vector(2,10)
v2=Vector(5,-2)
print v1+v2
实验结果
实验代码 类属性与方法
# 类属性与方法
#1.类的私有属性 __private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
# 2.类的方法 在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数
# 3.类的私有方法 __private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods
class JustCounter:
__secretCount=0 #private
publicCount=0 #public
def count(self):
self.__secretCount+=1
self.publicCount+=1
print self.__secretCount
counter=JustCounter()
counter.count()
counter.count()
print counter.publicCount
# print counter.__secretCount#error如果执行这句话会报错，因为不能直接访问私有变量
print counter._JustCounter__secretCount
实验结果
实验步骤二 正则表达式
#!/usr/bin/python
#coding=utf-8
#re.math(pattern, string, flags=0)
# 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
#patter, 匹配的正则表达式
#string，要匹配的字符串
#Flags，标志位，用于控制正则表达式的匹配方式，如是否区分大小写、多行匹配等
import re
print "match 匹配的表达式"
print(re.match('www','www.runoob.com').span())
print(re.match('com','www.runoob.com'))
line="Cats are very cute and I love them,I want to be their friend."
matchObj=re.match(r'(.*)are(.*?).*',line,re.M|re.I)
if matchObj:
print "group(num)匹配的表达式"
print "matchObj.group():",matchObj.group()
print "matchObj.group(1):",matchObj.group(1)
print "matchObj.group(2):",matchObj.group(2)
else:
print "No match!!"
# re.search(pattern,string,flags=0)
# 扫描整个字符串并返回第一个成功的匹配。
print "search 扫描匹配的表达式"
print(re.search('www','www.runoob.com').span())
print(re.search('com','www.runoob.com').span())
# 检索和替换
# re.sub(pattern, rep1, string, max=0)
# 返回的字符串是在字符串中用 RE 最左边不重复的匹配来替换。
# 如果模式没有发现，字符将被没有改变地返回。
# 可选参数 count 是模式匹配后替换的最大次数；
# count 必须是非负整数。缺省值是 0 表示替换所有的匹配。
phone="2004-959-5559#This is a phone number"
num=re.sub(r'#.*$',"",phone)
print "phoneNumber:",num
num=re.sub(r'\D',"",phone)
print "phoneNumber",num
#特殊字符类
# \s匹配一个数字字符等价于[0-9]
# \D匹配一个数字字符等价于[^0-9]
# \s匹配任何空白字符，包括空格、制表符、换页符等等，等价于[\f\n\r\t\v]
# \S匹配任何非空白字符，等价于[^\f\n\r\t\v]
# \w匹配包括下划线的任何单词字符，等价于[A-Za-z0-9]
# \W匹配任何非单词字符，等价于[^A-Za-z0-9]
实验结果
实验步骤三 XML解析
#!/usr/bin/python
#coding=utf-8
from xml.dom.minidom import parse
import xml.dom.minidom
DOMTree=xml.dom.minidom.parse("movie.xml")
collection=DOMTree.documentElement
if collection.hasAttribute("shelf"):
print "Root element:%s"%collection.getAttribute("shelf")
movies=collection.getElementsByTagName("movie")
for movie in movies:
print "****Movie*****"
if movie.hasAttribute("title"):
print "Title:%s"%movie.getAttribute("title")
type=movie.getElementsByTagName('type')[0]
print "Type:%s"% type.childNodes[0].data
format=movie.getElementsByTagName('rating')[0]
print "Format:%s"%format.childNodes[0].data
rating=movie.getElementsByTagName('rating')[0]
print "Rating:%s"%rating.childNodes[0].data
description=movie.getElementsByTagName('description')[0]
print "Description:%s"%description.childNodes[0].data
实验结果
Part 3 分析与思考
1） Python既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语 言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。与其他主要的语言如 C++和Java相比，Python以一种非常强大又简单的方式实现面向对象编程。
扫一扫
255
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
