python 内置模块2

 3:struct

                准确的来讲 Python没有专门处理字节的数据类型，但是由于str既是字符串 又可以表示字节 所以 字节数组=str  

                在Python中比方说 要把一个32位无符号整数表示为字节 也就是4个长度的str 就要这样写

                    >>>n=10240099

                    >>>b1=chr((n & 0xff000000)>>24)

                    >>>b2=chr((n & 0xff0000)>>16)

                    >>>b3=chr((n& 0xff00)>>8)

                    >>>b4=chr(n& 0xff)

                    >>>s=b1+b2+b3+b4

                    >>>s

                    '\x00\x9c@c'

    

                这样非常麻烦 并且换成浮点数 就没有办法 了

                Python的struct模块的 pack 函数可以把任意数据类型变为字符串

                    >>>import struct

                    >>>struct.pack('>I',10240099)      

                      '\x00\x9c@c'

                pack的第一个参数是处理指令 '>I'的意思是 >表示字节顺序是 big-endian 也就是网络字节序  I表示4字节无符号整数

                unpack 能够把str编程相应的数据类型：

                    >>>struct.unpack('>IH','\xf0\xf0\xf0\xf0\x80\x80')

                    (4042344160,32896)

                根据>IH的说明 后面的str 依次变为 I:4字节的无符号整数 和H :2字节的无符号整数

            4：hashlib

                摘要算法 hash函数 

                >>>import hashlib

                >>>md5=hashlib.md5()

                >>>md5.update('how to use md5 in python hashlib?')

                >>>print md5.hexdigest()

                da39fsjifskualfisfui.......

                如果数据量大，可以分几次update

                >>>md5.update('how to user md5')

                >>>md5.update('in python hashlib?')

                >>>md5.hexdigest()

                sha1 的用法与MD5完全类似 当然 sha1的结果是160bit 而MD5的结果是128bit

                MD5这样的 摘要算法基本用在密码保存上  同时可以再加密的时候 加上 salt

            5:itertools

                提供非常有用的用于操作迭代对象的函数

                    >>>import itertools

                    >>>natauls=itertools.count(1)

                    >>>for n in natuals

                                print n

                    1

                    2

                    3

                    .......

                count（） 会创建一个无限的迭代器 所以上述代码会打印出自然数序列 根本停不下来

                cycle（）会把传入传入的一个序列无限的重复下去

                    >>>import itertools

                    >>>cs=itertools.cycle('abc')

                    >>>for c in cs:

                                print c

                    a

                    b

                    c

                    a

                    b

                    ....

                repeat()负责把一个元素无限的重复下去 不过如果提供第二个参数就可以限定重复的次数

                    >>>import itertools

                    >>>ns=itertools.repeat('a',10)

                    >>>for n in ns

                               print n 

                    a

                    a

                    a

                    .....(10 次)

                我们通常可以通过takewhile（）等函数根据条件判断来截取出一个有限的 序列

                    >>>natuals=itertools.count(1)

                    >>>ns=itertools.takewhile(lambda x:x<=10,natuals)

                    >>>for  n in ns

                                print n

                    打印出从1 到10

            

                chain() 可以把一组可迭代对象串联起来

                    >>>for c in itertools.chain('abc','xyz'):

                                print c

                    打印a  b  c  x  y  z

                groupby()  把迭代中相邻的重复的元素挑出来放到一起

                    >>>for key,group in itertools.groupby('AAABBBccCCAaa',;lamdba c :c.upper()):

                                print key,list(group)

                    A['A','A','A','A','a','a']

                    ...................

                

                imap() 与map（）的区别只是在与 imap可以作用于无穷序列 并且两个序列的长度不一致的时候 以短的为准

                    >>>for x in itertools.imap(lambda x,y:x*y,[10,20,30],itertools.count(1))

                                print x

                    10

                    20

                    30

        

           6:xml

                操作xml有两种方法 DOM和SAX DOM会把整个XML读入内存 解析为树 因此占用内存大 接卸慢  有点事可以任意遍历树的节点 SAX是流模式 边读边记解析 占用内存小 解析快 但是需要自己处理事件

                正常情况下 有限考虑SAX 因为DOM太占用内存

                Python中用SAX解析XML通常我们关心的实际那是start_element  end_element  char_data 准备好这三个函数 然后就可以解析了

                如 当SAX遇到一个节点<a href="/">python</a>

                    1:start_element 事件 在读<a href="/">时候

                    2:char_data 事件  在读入python 的时候

                    3：end_element事件 在读入</a>

#-*-coding:utf-8-*-

from xml.parsers.expat import ParserCreate

class DefaultSaxHandler(object):

 def start_element(self,name,attrs):

  print('sax:start_element:%s,attrs:%s' % (name,str(attrs)))

 def end_element(self,name):

  print('sax:end_element:%s' % name)

 def cha_data(self,text):

  print('sax:cha_data:%s' %text)

if __name__=='__main__':

 xml=r'''<?xml version="1.0"?>

 <ol>

  <li><a href="/python">Python</a></li>

  <li><a></a></li>

 </ol>

 '''

 handler=DefaultSaxHandler()

 parser=ParserCreate()

 parser.returns_unicode=True

 parser.StartElementHandler = handler.start_element

 parser.EndElementHandler = handler.end_element

 parser.CharacterDataHandler = handler.cha_data

 parser.Parse(xml)

                结果：打印几个语句

                7：HTMLParser

                        HTML本质上就是xml的子集 使用HTMLParser 可以非常方便的解析HTML文档

 #-*-coding:utf-8-*-

from HTMLParser import HTMLParser

from htmlentitydefs import name2codepoint

class MyHTMLParser(HTMLParser):

 def handle_starttag(self,tag,attrs):

  print('<%s>' % tag)

 def handle_endtag(self,tag):

  print('</%s>' % tag)

 def handle_startendtag(sef,tag,attrs):

  print('<%s/>' % tag)

 def handle_tag(sef,data):

  print('data')

 def handle_comment(self,data):

  print('<!---->')

 def handle_entityref(self,name):

  print('&%s' % name)

 def handle_charref(self,name):

  print('&#%s' % name)

parser=MyHTMLParser()

parser.feed('<html><head></head><body><p>Some<a href=\"#\">html</a>tutorial...<br>END</p></body></html>')                          

                            

                        结果：

                            <html>

                            <head>

                            </head>

                            <body>

                            <p>

                            data

                            <a>

                            data

                            </a>

                            data

                            <br>

                            data

                            </p>

                            </body>

                            </html>