一、模块
1.xml模块
xml的格式如下，就是通过<>节点来区别数据结构的:
2.configparse模块
test.conf
[Section1] foo=%(bar)s is %(baz)s! baz=fun bar=Python
import ConfigParser
import string, os
cf = ConfigParser.ConfigParser()
cf.read("test.conf")
res = cf.get('Section1', 'foo')
print "默认情况下, raw=False, 此时输出 %s" % res
res = cf.get('Section1', 'foo', raw=False)
print "raw=False, 无参数vars 此时等同于默认输出:%s" % res
res = cf.get('Section1', 'foo', raw=True)
print "raw=True, 无参数vars 此时等输出未被匹配原字符:%s" % res
res = cf.get('Section1', 'foo', raw=False, vars={'bar': 'Documentation','baz': 'evil'})
print "raw=False, vars存在 此时使用vars中的值进行匹配:%s" % res
res = cf.get('Section1', 'foo', raw=True, vars={'bar': 'Documentation', 'baz':'sdsd'})
print "raw=True, vars存在 此时vars不生效,输出未被匹配原字符:%s" % res
res = cf.get('Section1', 'foo', raw=False, vars={'bar': 'Documentation'})
print "raw=True, vars存在，但只包含一个值, 此时另一个值取默认匹配值,输出未:%s" % res
3.hashlib模块
Python里面的hashlib模块提供了很多加密的算法，这里介绍一下hashlib的简单使用事例，用hashlib的md5算法加密数据
import hashlib
hash = hashlib.md5()#md5对象，md5不能反解，但是加密是固定的，就是关系是一一对应，所以有缺陷，可以被对撞出来hash.update(bytes('admin',encoding='utf-8'))#要对哪个字符串进行加密，就放这里print(hash.hexdigest())#拿到加密字符串hash3 = hashlib.md5(bytes('abd',encoding='utf-8'))hash3.update(bytes('admin',encoding='utf-8'))print(hash3.hexdigest())
4.subprocess模块
import subprocess
'''
sh-3.2# ls /Users/egon/Desktop |grep txt$
mysql.txt
tt.txt
事物.txt
'''
res1=subprocess.Popen('ls /Users/jieli/Desktop',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout,
stdout=subprocess.PIPE)
print(res.stdout.read().decode('utf-8'))
#等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep
res1=subprocess.Popen('ls /Users/jieli/Desktop |grep txt$',shell=True,stdout=subprocess.PIPE)
print(res1.stdout.read().decode('utf-8'))
#windows下:
# dir | findstr 'test*'
# dir | findstr 'txt$'
import subprocess
res1=subprocess.Popen(r'dir C:\Users\Administrator\PycharmProjects\test\函数备课',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('findstr test*',shell=True,stdin=res1.stdout,
stdout=subprocess.PIPE)
print(res.stdout.read().decode('gbk')) #subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码
5.面向对象
示例：
class Student:
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print('%s: %s' % (self.name, self.score))
给对象发消息实际上就是调用对象对应的关联函数，我们称之为对象的方法（Method）。面向对象的程序写出来就像这样：
bart = Student('Bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
bart.print_score()
lisa.print_score()
面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。
继承：在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。
比如，我们已经编写了一个名为Animal的class，有一个run()方法可以直接打印：
class Animal:
def run(self):
print('Animal is running')
当我们需要编写Dog和Cat类时，就可以直接从Animal类继承：
class Dog(Animal):
pass
class Cat(Animal):
pass
对于Dog来说，Animal就是它的父类，对于Animal来说，Dog就是它的子类。Cat和Dog类似。
继承有什么好处？最大的好处是子类获得了父类的全部功能。由于Animial实现了run()方法，因此，Dog和Cat作为它的子类，什么事也没干，就自动拥有了run()方法：
dog = Dog()
dog.run()
cat = Cat()
cat.run()
运行结果如下：
Animal is running...
Animal is running...
当然，也可以对子类增加一些方法，比如Dog类：
class Dog(Animal):
def run(self):
print('Dog is running...')
def eat(self):
print('Eating meat...')继承的第二个好处需要我们对代码做一点改进。你看到了，无论是Dog还是Cat，它们run()的时候，显示的都是Animal is running...，符合逻辑的做法是分别显示Dog is running...和Cat is running...，因此，对Dog和Cat类改进如下：
class Dog(Animal):
def run(self):
print('Dog is running...')
class Cat(Animal):
def run(self):
print('Cat is running...')
再次运行，结果如下：
Dog is running... Cat is running...
当子类和父类都存在相同的run()方法时，我们说，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()。这样，我们就获得了继承的另一个好处：多态。
多态：
def run_twice(animal):
animal.run()
animal.run()
当我们传入Animal的实例时，run_twice()就打印出：
>>> run_twice(Animal())
Animal is running...
Animal is running...
当我们传入Dog的实例时，run_twice()就打印出：
>>> run_twice(Dog())
Dog is running...
Dog is running...
当我们传入Cat的实例时，run_twice()就打印出：
>>> run_twice(Cat())
Cat is running...
Cat is running...
看上去没啥意思，但是仔细想想，现在，如果我们再定义一个Tortoise类型，也从Animal派生：
class Tortoise(Animal):
def run(self):
print('Tortoise is running slowly...')
当我们调用run_twice()时，传入Tortoise的实例：
>>> run_twice(Tortoise())
Tortoise is running slowly...
Tortoise is running slowly...
你会发现，新增一个Animal的子类，不必对run_twice()做任何修改，实际上，任何依赖Animal作为参数的函数或者方法都可以不加修改地正常运行，原因就在于多态。
