zoukankan      html  css  js  c++  java
  • Day-14: 常用的内建模块

    • collections包含对tuple、list、dict等派生出新功能

      namedtuple用来为tuple类型派生出一个新名字的tuple类,并提供用属性引出的功能。

    >>> from collections import namedtuple
    >>> Point = namedtuple('Point', ['x', 'y'])
    >>> p = Point(1, 2)
    >>> p.x
    1
    >>> p.y
    2

      deque提高list的插入和删除的效率,同时增加appendleft()和popleft()功能。

    >>> from collections import deque
    >>> q = deque(['a', 'b', 'c'])
    >>> q.append('x')
    >>> q.appendleft('y')
    >>> q
    deque(['y', 'a', 'b', 'c', 'x'])

      defaultdict:使用dict时,如果key不存在,返回一个默认值,默认值是调用函数反悔的。

    >>> from collections import defaultdict
    >>> dd = defaultdict(lambda: 'N/A')
    >>> dd['key1'] = 'abc'
    >>> dd['key1'] # key1存在
    'abc'
    >>> dd['key2'] # key2不存在,返回默认值
    'N/A'

      OrderedDict使得使用的dict变成有序的,它的key会按照插入的顺序排列。

    >>> from collections import OrderedDict
    >>> d = dict([('a', 1), ('b', 2), ('c', 3)])
    >>> d # dict的Key是无序的
    {'a': 1, 'c': 3, 'b': 2}
    >>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
    >>> od # OrderedDict的Key是有序的
    OrderedDict([('a', 1), ('b', 2), ('c', 3)])

      Counter是简单的计数器。

    >>> from collections import Counter
    >>> c = Counter()
    >>> for ch in 'programming':
    ...     c[ch] = c[ch] + 1
    ...
    >>> c
    Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})
    • base64

      base64是一种任意二进制到文本字符串的编码方式。

      首先为64个字符串的数组准备好对应的6位编码,做成表格,一一对应。

    ['A', 'B', 'C', ... 'a', 'b', 'c', ... '0', '1', ... '+', '/']

    再讲二进制数据进行处理,每3个字节一组,一共有3*8=24位,化成4组,每组正好6位。

    再依据得到的6位,查找之前的表格,就变成了编码后的字符串。

    如果编码的二进制数据个数不是3的倍数,则在末尾加上所缺个数的x00字节,再进行编码(注:加了多少个x00,编码后就会有多少个=)

    python中的base64编码与解码:

    >>> import base64
    >>> base64.b64encode('binaryx00string')
    'YmluYXJ5AHN0cmluZw=='
    >>> base64.b64decode('YmluYXJ5AHN0cmluZw==')
    'binaryx00string'

    标准的urlbase64中将+和/换成了-和_,来避免URl中+和/的出现。

    • struct

      python中str既是字符串,又是字节,所以,字节数组=str。struct模块来解决str和其他二进制数据类型的转换。

      struct.pack()表示任意数据类型转换成字节,struct.unpack()表示字节转换成相应的数据。

      c表示一个字节的字母,I表示4字节无符号整数,H表示2字节无符号整数。

      其他数据类型参考官方文档:https://docs.python.org/2/library/struct.html#format-characters

    >>> import struct
    >>> struct.pack('>I', 10240099) # 无符号整数转换成字节
    'x00x9c@c'
    >>> struct.unpack('>IH', 'xf0xf0xf0xf0x80x80') 
    # 字节转换成一个4字节的无符号整数和一个2字节的无符号整数 (
    4042322160, 32896)

      windows位图文件(.bmp)前30个字节有以下含义:

    两个字节:'BM'表示Windows位图,'BA'表示OS/2位图;

    一个4字节整数:表示位图大小;

    一个4字节整数:保留位,始终为0;

    一个4字节整数:实际图像的偏移量;

    一个4字节整数:Header的字节数;

    一个4字节整数:图像宽度;

    一个4字节整数:图像高度;

    一个2字节整数:始终为1;

    一个2字节整数:颜色数。

    对以下头文件字节分析,有

    >>> s = 'x42x4dx38x8cx0ax00x00x00x00x00x36x00x00x00x28x00x00x00x80x02x00x00x68x01x00x00x01x00x18x00'
    >>> struct.unpack('<ccIIIIIIHH', s)
    ('B', 'M', 691256, 0, 54, 40, 640, 360, 1, 24)
    • hashlib

      hashlib,又称哈希算法,提供常见的摘要算法。它依据提供的数据,通过一个函数,得到一段固定长度的数据串(通常用16进制的字符串表示)。这个转换,是单向的,反向推出特别难。

      常用的摘要算法有MD5(32位16进制)、SHA1(40位16进制)等。

    import hashlib
    
    md5 = hashlib.md5()
    md5.update('how to use md5 in python hashlib?')
    print md5.hexdigest()
    d26a53750bc40b38b65a520292f69306

      数据量大时,也可多次传入:

    md5 = hashlib.md5()
    md5.update('how to use md5 in ')
    md5.update('python hashlib?')
    print md5.hexdigest()

      SHA1算法:

    import hashlib
    
    sha1 = hashlib.sha1()
    sha1.update('how to use sha1 in ')
    sha1.update('python hashlib?')
    print sha1.hexdigest()

      比SHA1更安全的是SHA256和SHA512。

      摘要算法应用在存储用户的用户名和口令的地方。数据库中,存储的口令不能是明码,一旦泄露就危险了。

      因此,储存的密码是经摘要算法处理的摘要。该摘要有用户名 +用户密码+‘the-Salt’经摘要算法后合成,防止因用户密码相同和黑客预先准备的简单密码摘要表被黑掉密码。

    • itertools

      itertools模块提供的全部是处理迭代功能的函数,它们返回的不是list,而是迭代对象,只有用for循环迭代的时候才能真正计算。

      count()创建一个无限迭代器,打印出自然序列。

    >>> import itertools
    >>> natuals = itertools.count(1)
    >>> for n in natuals:
    ...     print n
    ...
    1
    2
    3
    ...

      cycle把传入的序列无限重复。

    >>> import itertools
    >>> cs = itertools.cycle('ABC') # 注意字符串也是序列的一种
    >>> for c in cs:
    ...     print c
    ...
    'A'
    'B'
    'C'
    'A'
    'B'
    'C'
    ...

      repeat()把一个元素无限重复下去,如果提供第二个参数就可以指定重复次数。

    >>> ns = itertools.repeat('A', 10)
    >>> for n in ns:
    ...     print n
    ...
    打印10次'A'

      无限迭代序列,通常使用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('AAABBBCCAAA'):
    ...     print key, list(group) # 为什么这里要用list()函数呢?
    ...
    A ['A', 'A', 'A']
    B ['B', 'B', 'B']
    C ['C', 'C']
    A ['A', 'A', 'A']

      忽略大小写。

    >>> for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):
    ...     print key, list(group)
    ...
    A ['A', 'a', 'a']
    B ['B', 'B', 'b']
    C ['c', 'C']
    A ['A', 'A', 'a']

      imap(),map()的惰性表示,与map()函数相同,但是生成的一个可迭代对象,只有用for循环做迭代的时候才会计算。

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

      ifilter(),就是filter()的惰性表示。

    • XML

      操作XML有两种方法:DOM和SAX。DOM直接将整个XML读入内存,占用内存大,可以任意遍历节点。SAX是流模式,占用内存小,解析快,需要自己处理时间。

      SAX解析XML时,通常关心的事件是start_element,end_element,char_data,三个函数分别处理下面的事件:

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

      1.start_element事件,在读取<a href="/">时;

      2.char_data事件,在读取python时;

      3.end_element事件,在读取</a>时。

    如下面的例子:

    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 char_data(self, text):
            print('sax:char_data: %s' % text)
    
    xml = r'''<?xml version="1.0"?>
    <ol>
        <li><a href="/python">Python</a></li>
        <li><a href="/ruby">Ruby</a></li>
    </ol>
    '''
    handler = DefaultSaxHandler()
    parser = ParserCreate()
    parser.returns_unicode = True # 返回的element名称和cahr_data都是unicode,方便处理
    parser.StartElementHandler = handler.start_element
    parser.EndElementHandler = handler.end_element
    parser.CharacterDataHandler = handler.char_data
    parser.Parse(xml)

      如果要生成XML时,最简单的也是最有效的方法是拼接字符串。

    L = []
    L.append(r'<?xml version="1.0"?>')
    L.append(r'<root>')
    L.append(encode('some & data'))
    L.append(r'</root>')
    return ''.join(L)

      如果要生成复杂的XML,使用JSON比较好。

    • HTMLParser

      HTML本质上是XML的子集,HTMLParser是用来解析HTML的。

    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(self, tag, attrs):
            print('<%s/>' % tag)
    
        def handle_data(self, 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>')

      feed()方法可以多次调用,也就是说整个HTML字符串可以一部分一部分的塞进去。特殊字符有两种,一种是英文表示的&nbsp,一种是数字表示的&#1234。

     注:本文为学习廖雪峰Python入门整理后的笔记

  • 相关阅读:
    LintCode Python 简单级题目 488.快乐数
    LintCode Python 简单级题目 100.删除排序数组中的重复数字 101.删除排序数组中的重复数字II
    LintCode Python 简单级题目 373.奇偶分割数组
    LintCode Python 简单级题目 39.恢复旋转排序数组
    LintCode Python 简单级题目 35.翻转链表
    LintCode Python 简单级题目 451.两两交换链表中的节点
    LintCode Python 简单级题目 174.删除链表中倒数第n个节点
    aws查看官方centos镜像imageid
    linux shell脚本查找重复行/查找非重复行/去除重复行/重复行统计
    php配置优化-生产环境应用版
  • 原文地址:https://www.cnblogs.com/likely-kan/p/7528695.html
Copyright © 2011-2022 走看看