XML的使用：
1、 处理xml消息包比较好用的模块是xml.etree.ElementTree。
2、 Element执行xml的根节点。
3、 elem.find(path):查找根节点下面路径为path的子节点。
4、 elem.findall(path):同样的子节点可能有多个，这里会返回一个列表。
5、 elem.findtext(path):获取指定路径子节点的内容，这个我们会经常使用。
6、 elem.get(key);获取属性的值。
7、 上面如果没用，则返回none
8、 elem.append:添加自节点。
9、 elem.tag：返回tag值，也就是name。
10、 elem.text:返回内容。
11、 elem.attrib:返回属性的字典。
12、 SubElement：生成一个节点，自动添加为父节点的子节点。
13、 tostring：转化为xml文本字符串。但是不包括xml头。如果编码方式为UTF-8或者GB2312,gb2312都会产生xml头；如果是utf-8,则不会产生xml头
14、 fromstring：从字符串转化为ElementTree对象。和XML同样的功能。
15、 elem.set();设置属性值
time的使用：
1、 time.sleep()函数函数具有c下sleep函数功能，单位为秒，但是可以接受浮点数。这样可以表示毫秒。
2、 ti = datetime.datetime.now()可以显示当前的时间，包括当前的微秒也可以显示出来。两个的差值可以表示时间 的间隔：microsecondLong = timeLong.seconds * 1000000 + timeLong.microseconds。差值的成员是seconds和microseconds
3、

OO的使用：
1、 如果不想让成员变量或者方法被外部使用（也就是private特性），可以以__双下划线开通。
2、 属性不但可以定义在init中，也可以定义在任意的方法中通过self定义。不过最好在init中定义。
3、 Python也可以实现抽象基类，也就是接口
5、 call(魔法方法)可以将对象作为函数来调用。给它一个入参就可以。:4、 str属性可以将对象转换为字符串，也就是调用print(object)是会打印的字符串。
def call(self, protoVer):
return api.protoModules[protoVer].TimeTicks(
(time.time()-self.birthday)*100
)
它的作用：比较常用的是作为回调，因为他可以保存状态信息。它和闭包类似，可能比闭包的可读性要好一点。
6、 对象实例是否可以删除？
7、 Python参考手册要好好看一下。
8、 python的static方法使用的是装饰器语法：@staticmethod.
9、 对类的调用还有一个方法：CALSS.method(object)。
10、 子类中，如果想调用父类的方法，可以通过：
parent.method(self).
不过还有更好的方法：
super(child, self).foo()//注意：这里是根据子类的类型获取父类的方法。它的好处是不用明显给出基类的类型。
11、 cls：类方法的第一个参数。通常表示类的类型，可以通过cls()来生成实例。
a) @classmethod
b) def spawn(cls, *args, *kwargs):
c) “””Return a new :class:Greenlet object, scheduled to start.
d)
e) The arguments are passed to :meth:Greenlet.__init__.
f) “””
g) g = cls(args, **kwargs)
h) g.start()
i) return g

12、 继承，如果子类定义了init函数，子类的init函数不会默认调用父类的init函数，需要手动调用：parent.init。这一点是和c++有区别的。如果子类没有定义init，则子类会调用父类的init。这里可以发现，其实，子类如果定义了init函数，是对父类的init的一个覆盖。
13、 super注意：！！！它只能用在新式的类定义中。什么是新式的？原来只是基类定义时继承object！！！。
14、 继承如何继承方法：只要继承一个类，就会继承这个类所有的方法，包括init,del。但是如果子类重写某方法，就会覆盖父类的方法，不会再调用父类的方法了。如果想调用父类的方法，可以通过super的方式调用。
15、 继承如何继承属性：只要不覆盖父类init方法，或者调用了父类的init方法，就会继承父类init属性的方法。继承后也可以更改这些属性。
16、 父类如何防止被继承：方法或者属性以_开头，则可以防止被继承。
17、 根据我的经验，其实可以以一种本质的方式理解Python的继承：Python的类就是一些方法的集合，继承一个类就是继承这个类的所有的方法。如果在子类中定义一个方法，其实是更改了这个类的符号。而属性，则可以在所有的方法中定义，只要调用了定义属性的方法，调用父类，则是继承父类的属性，调用子类定义属性的方法，则是定义子类的方法。
18、 property：
a) class c(object):
b) def init(self):
c) self._num = 1
d) @property
e) def num(self):
f) return self._num * 10
g) @num.setter
h) def num(self, v):
i) self._num = v
j) @num.deleter
k) def num(self):
l) pass
m) o = c()
n) print(o.num)
o) o.num = 20
p) print(o.num)
q) 这样的好处是，可以在操作属性时，不用显示为方法调用，更加可读。同时又可以统一入口。：注意，它也必须继承object才可以。
19、 OO中的垃圾回收：Python的垃圾回收使用的是符号引用计数。那么，如果在一个函数中申请一个对象，然后返回它的一个属性或者方法，这个时候对象的符号引用已经去掉，对象是否会释放？
a) class child(parent):
b) def init(self):
c) self.i = 8888
d)
e) def foo(self):
f) print(‘———————–‘)
g)
h) def del(self):
i) print(‘now in del child’)
j) super(child, self).del()
第一种情况，返回的是属性
k) def refun():
l) o = child()
m) return o.i
n) I = refun()
o) 这个时候，对象o会马上释放。因为o.i其实就是一个对象的引用，和o没有关系
第二种情况，返回的是方法
a) def refun():
b) o = child()
c) return o.foo
d) foo = refun()
e) 这个时候，对象o要等到foo释放的时候再释放，因为foo中包含了o的引用（foo的入参self）
20、 对于对象的属性，如果属性是可读写的，则第一步没有必要用@property修饰。可以直接使用。后面如果有需要，在进行修饰。这样既减少了工作，修改时，也不会对原有代码进行改动。
模块的使用：
1、 如果不想将模块的某些函数和变量被别的模块使用，可以以单下划线开头。这样import 是没有的，但是使用import mode，然后mode._fun仍然可以调用。在class中是以双下划线开头的。
2、 使用from。。。import导入的符号，应该是本地符号，更改的话，无法更改模块中的值。可以通过mode.name=来修改。
3、 init.py的作用：可以这样理解：包也是一个对象，这个py就是这个包的构造函数。导入这个包，就会自动的执行init.py。如果在这个py中导入其他符号，import 这个包并且加也会导入这个符号。
4、 import 无法导入模块中以_开头的符号。但是，不用是可以的。
5、 import的本质也是创建一个符号，指向一个对象的引用。这个符号和被import的模块的符号是没有关系的。和c的extern不一样。extern可以更改变量的值，但是，这在Python中是不可以的。
from srctest import itest, outitest, setitest
import srctest

itest = 9#这个地方其实改变的是本模块中符号的引用，无法更改srctest中对应符号。

srctest.itest = 9#这个可以更改srctest中的itest

setitest(9)#这个可以更改srctest中的itest，但是改变不了当前模块的itest，也就是，这种设置是无法同步的。
print(itest)#打印当前模块的itest
printitest()#打印srctest中的itest
Python的设计哲学：看似不方便的背后，其实有Python的设计哲学。便捷性很多时候都是模块性的大敌。在软件开发中，模块间的最短路径未必是最合理路径，而且往往是最不合理路径。它会破坏软件原有的交互原则。
Python这样设计的理由应该是，尽量将数据和对数据的操作放在一起。如果数据会扩散，那么，就将数据设计为只读的。这样有助于提高程序模块的内聚性（全局变量是内聚性的大敌），降低耦合性。降低程序的复杂性（数据只读，调试根据方便）。

srctest.itest是可以改变itest的值的，说明我们可以通过改变这个对象的属性来改变对象（模块也是对象）。
可能有一点小题大做。
6、 两个模块不可以双向import。那万一两个模块都要互相调用对方怎么办？Python的设计哲学告诉你，这不是一个好的实践，所以这样不行。应该怎么弄？一个模块调用另外一个模块，如果被调用模块想调用调用模块的方法，通过回调的形式。这样可以保证，模块间的连接都是单向的。

日志的使用：
1、 日志的标准模块logging基本可以满足我的工作。
2、 设置log的初始化工作：
logging.basicConfig(
filename = “test.log”,
format = “[%(asctime)s-%(levelname)s] %(message)s [%(filename)s,%(lineno)d]”,
level = logging.INFO,
datefmt = “%F %T”)
3、 除此之外，一个比较强大的功能就是过滤功能：可以针对级别，文件，行号等等很多的东西进行过滤。
4、

自省的使用：
1、 type()可以查看对象的类型。这就是自省。也就是可以看看自己是什么类型。这个功能在动态语言中非常有用。
2、 getattr函数：这是个非常有用的函数，它可以根据字符串，从模块，类，对象实例中获取属性和方法的应用并且调用。这个功能非常类似于c语言的函数指针，以及c++中的成员函数的指针。
1）从模块中获取函数和成员
import testfun
tf = getattr(testfun, ‘test’)
tstr = getattr(testfun, ‘str’)
2）从类中获取属性和方法
class test():
tst = 2
def init(self):
self.abc = 1
def method(self):
print(‘in test.method’, self)
def __test(self):
print(‘in test’)
tm = getattr(test, ‘method’)#获取类方法method函数指针。因为没有实例，所以调用必须用下面的方法：
t = test()
tm(t)#申请一个实例，并且作为第一个参数传进去。
tm = getattr(test, ‘__test’)#这里会报错，也就是无法获取私有方法。
tabc = getattr(test, ‘abc’)#这是错误的。无法获取。
ttst = getattr(test, ‘tst’)#这是可以的。。

3）从对象实例中获取属性和方法
t = test()
tm = getattr(t, ‘method’)
tm()#可以这样调用，而不用传入t实例。
tabc = getattr(test, ‘abc’)#可以获取实例的属性。
3、 callable：函数表示某个对象是否可以调用。它和getattr结合起来，可以获取一个对象中的所有的method列表：
methods = [method for method in dir[object] if callable(getattr(object, method))]
4、 自省也叫放射。
5、 exec(‘print “test”‘)：可以执行字符串代码。这个特性有助于动态执行代码，可以用于机器学习，自动生成代码。
exec的参数可以使一个打开的文件对象，string，code object。
code object可以通过函数
类似的方法：execfile(filename[, globals[, locals]])。
6、 可以更改类的方法，将它指向一个新的方法。如下：
a) class ctest():
b) def test(self):
c) print(‘c test test’)
d) def testfun():
e) print(‘test fun !’)
f) c = ctest()
g) c.test = testfun
h) c.test()
对象c的方法test被替换为新的方法：testfun。这个特性有助于根据动态的代码实现，但是往往会增加代码的透明性。
类似的，setattr也可以实现这样的功能。delattr可以删除属性。
setattr(c, ‘test’, testfun)
delattr(c, ‘test’)
c.test()#这里调用的其实就是ctest的test方法。也就是说，delattr会首先删除setattr设置的属性，如果在调用一次delattr，才会删除c的test方法。但是如果多调用几次setattr，也只要调用一次delattr即可删除。所以，要删除一个方法，最多调用两次delattr。
这个特性可以用于动态更改代码。也可用于补丁。
setattr无法对Python的c扩展模块进行操作。
7、 如何判断一个变量是否存在：
‘v’ in dir()
‘v’ in locals.key()
配置文件读取的使用：
1、 使用模块ConfigParser。实例如下：
conf = ConfigParser()
conf.read(“snmp_agent.ini”)

print(conf.get(“main”, “log_level”))
print(conf.getint(“main”, “ne_agent_port”))
print(conf.get(“main”, “ne_agent_qip”))t
想免费获取视屏学习资料
欢迎加入我的Python交流群
626062078