标签：ons 获取 html targe comm 不同 列操作 lsa 方式
datetime是Python处理日期和时间的标准库
1) 获取当前时间
from datetime import datetime
now = datetime.now()
print(now)
# 2017-04-25 09:10:21.452000
2) 获得指定日期和时间
dt = datetime(2017, 4, 25, 12, 30)
print(dt)
# 2017-04-25 12:30:00
其中datetime可以传入参数, 分别是年月日时分秒, 没有的参数置为0
3) datetime转化为timestamp
时间戳timestamp, 是相对于 1970年1月1日 00:00:00 UTC+00:00 的秒数, 在1970年之前得到的是负数秒数
1970年1月1日 00:00:00 UTC+00:00时区的时刻是 epoch time
获得时间戳的方法是 timestamp()
>>> from datetime import datetime
>>> dt = datetime(2015, 4, 19, 12, 20) # 用指定日期时间创建datetime
>>> dt.timestamp() # 把datetime转换为timestamp
1429417200.0
4) timestamp转化为datetime
获得当前时间和UTC标准时间的方法 fromtimestamp 和 utcfromtimestamp
>>> from datetime import datetime
>>> t = 1429417200.0
>>> print(datetime.fromtimestamp(t)) # 本地时间
2015-04-19 12:20:00
>>> print(datetime.utcfromtimestamp(t)) # UTC时间
2015-04-19 04:20:00
5) str转化为datetime
使用strptime
>>> from datetime import datetime
>>> cday = datetime.strptime(‘2015-6-1 18:19:59‘, ‘%Y-%m-%d %H:%M:%S‘)
>>> print(cday)
2015-06-01 18:19:59
5) datetime转化为str
使用strftime
>>> now = datetime.now()
>>> print(now.strftime(‘%a, %b %d %H:%M‘))
Mon, May 05 16:28
6) datetime的加减
需要导入 timedelta
>>> from datetime import datetime, timedelta
>>> now = datetime.now()
>>> now
datetime.datetime(2015, 5, 18, 16, 57, 3, 540997)
>>> now + timedelta(hours=10)
datetime.datetime(2015, 5, 19, 2, 57, 3, 540997)
>>> now - timedelta(days=1)
datetime.datetime(2015, 5, 17, 16, 57, 3, 540997)
>>> now + timedelta(days=2, hours=12)
datetime.datetime(2015, 5, 21, 4, 57, 3, 540997)
collections提供了很多集合类
1) namedtuple
使用namedtuple可以自定义tuple对象, 并且规定元素的个数, 并且可以通过指定键值来获得值
生成的对象是tuple的实例的同时, 还是自定义类的实例
>>> from collections import namedtuple
>>> Point = namedtuple(‘Point‘, [‘x‘, ‘y‘])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2
2) deque
list只是单向列表
要想实现双向列表, 能够前后插入和删除, 需要使用deque
具体是使用append, appendleft, pop, popleft
>>> from collections import deque
>>> q = deque([‘a‘, ‘b‘, ‘c‘])
>>> q.append(‘x‘)
>>> q.appendleft(‘y‘)
>>> q
deque([‘y‘, ‘a‘, ‘b‘, ‘c‘, ‘x‘])
3) defaultdict
在使用dict的时候, 如果访问不存在的键, 则会出现KeyError错误
要设置不存在key值时有默认值, 可以使用defaultdict
>>> from collections import defaultdict
>>> dd = defaultdict(lambda: ‘N/A‘)
>>> dd[‘key1‘] = ‘abc‘
>>> dd[‘key1‘] # key1存在
‘abc‘
>>> dd[‘key2‘] # key2不存在，返回默认值
‘N/A‘
4) OrderedDict
dict是无序的, 要想字典有序, 可以使用OrderedDict
具体的说, OrderedDict使用的是插入时候的顺序
>>> 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)])
5) Counter
统计元素出现的次数
默认是按次数递减的顺序排列
>>> from collections import Counter
>>> c = Counter()
>>> for ch in "hello world":
c[ch] = c[ch] + 1
>>> c
Counter({‘l‘: 3, ‘o‘: 2, ‘h‘: 1, ‘e‘: 1, ‘ ‘: 1, ‘w‘: 1, ‘r‘: 1, ‘d‘: 1})
>>>
1) 基本原理
base64是以6位为单位的, 也就是形称了26的数量, 也就是base64
有与6位是不规则的, 所以最少需要3个字节整除
也就是说, base64是以3字节为一个处理部分, 共分为3*8/6=4组来处理
如果原有的内容剩下1个或者2个字节, base64会使用 \x00 来补足, 用在编码后末尾加上=的数量来表示加了多少字节
2) 生成编码
使用b64encode来生成编码
使用b64decode来还原编码
>>> import base64
>>> base64.b64encode(b‘binary\x00string‘)
b‘YmluYXJ5AHN0cmluZw==‘
>>> base64.b64decode(b‘YmluYXJ5AHN0cmluZw==‘)
b‘binary\x00string‘
但是计算的结果又+和/不能放入url中, 此时需要使用 urlsafe_b64encode, urlsafe_b64decode 方法编解码
>>> base64.b64encode(b‘i\xb7\x1d\xfb\xef\xff‘)
b‘abcd++//‘
>>> base64.urlsafe_b64encode(b‘i\xb7\x1d\xfb\xef\xff‘)
b‘abcd--__‘
>>> base64.urlsafe_b64decode(‘abcd--__‘)
b‘i\xb7\x1d\xfb\xef\xff‘
3) 主要用途
主要是应用于URL, Cookie等网络传输少量二进制数
不能用于做加密处理
可以用于在避免网络传输编码的问题
用于处理bytes个其他二进制数据类型的转换
1) 把任意类型转化为bytes
使用pack函数
>>> import struct
>>> struct.pack(‘>I‘, 10240099)
b‘\x00\x9c@c‘
2) 将bytes转换回来
使用unpack函数
>>> struct.unpack(‘>IH‘, b‘\xf0\xf0\xf0\xf0\x80\x80‘)
(4042322160, 32896)
其中>表示字节顺序是大端方式(big-endian), 也是网络序
I表示4字节无符号整数
H表示2字节无符号整数
大端方式(big-endian)
大端方式就是 数据高字节-->内存低地址, 数据低字节-->内存高地址 [和正常阅读一致]
小端方式(little-endian)
小端方式就是 数据高字节-->内存高地址, 数据低字节-->内存低地址
hashlib是用于加密的, 主要有md5个sha1等
摘要算法又称哈希算法, 散列算法
itertools提供了很多用于操作迭代对象的函数
1) 无限迭代器
count() 可以传入一个整数参数, 表示从参数开始逐一递增, 默认从0开始
>>> import itertools
>>> ns = itertools.count(1)
>>> for n in ns:
print(n)
1
2
3
4
...
2) 无限重复
cycle()需要传入一个序列, 遍历时会不断循环该序列
>>> import itertools
>>> cs = itertools.cycle([‘a‘, ‘b‘, ‘c‘])
>>> for c in cs:
print(c)
a
b
c
a
b
c
...
3) 限定重复
repeat()可以传入两个参数, 一个是重复的值, 另一个是重复的次数
如果不传入第二个参数, 仍然会不停的产生元素
>>> import itertools
>>> ns = itertools.repeat(‘abc‘, 3)
>>> for n in ns:
print(n)
abc
abc
abc
>>>
4) 限定无限序列
使用takewhile可以传入一个函数, 该函数通过返回值的真假来判断是否返回序列中的元素
>>> natuals = itertools.count(1)
>>> ns = itertools.takewhile(lambda x: x <= 10, natuals)
>>> list(ns)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
5) 串联多个可迭代对象
使用chain() 里面可以传入多个不同类型的迭代对象
>>> import itertools
>>> for n in itertools.chain(‘ABC‘,[1,2,3],(4,5,6)):
print(n)
A
B
C
1
2
3
4
5
6
>>>
6) 调出相邻重复的元素
groupby()
第一个参数是需要处理的对象
第二个参数是一个函数, 用于处理对第一个参数元素的处理
>>> 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‘]
>>>
如果实现了上下文管理, 就可以是用with语句进行处理
需要实现两个函数 __enter__ 和__exit__
但是使用contextlib可以更简洁的实现
具体是使用装饰器contextmanager
使用装饰器contextmanager可以具体来形成同样的效果
具体的, 先执行装饰器函数yield和yield前面的内容, 将yield的返回值作为as后面的对象, 这个部分相当于__enter__
yield之后的代码相当于__exit__的代码
具体使用如下
from contextlib import contextmanager
class Hello(object):
def __init__(self, name):
self.name = name
def hi(self):
print(‘你好啊, %s!‘ % self.name)
@contextmanager
def create_hello(name):
print(‘执行yiled前的代码..‘)
q = Hello(name)
yield q
print(‘执行yiled后的代码..‘)
with create_hello(‘魏胡超‘) as q:
q.hi()
# 执行yiled前的代码..
# 你好啊, 魏胡超 !
# 执行yiled后的代码..
XML在很多领域现在还在使用, 所以需要初步了解XML的基本处理方法
操作XML有两种方法
DOM, 把整个XML读入内存, 解析成为树形结构, 占用内存大, 解析速度慢
SAX, 流模式, 边读边解析, 占用内存小, 解析速度快, 优先考虑SAX处理XML
SAX在读取的时候, 会产生三个事件 start_element, end_element和char_data
具体解析可以先定义一个自己处理的类
这个类对象三个事件进行处理
生成一个解析对象, 将解析对象的三个时间的Handler绑定给写好的类的函数
执行Parse()解析XML就可以了
具体代码如下
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.StartElementHandler = handler.start_element
parser.EndElementHandler = handler.end_element
parser.CharacterDataHandler = handler.char_data
parser.Parse(xml)
通过HTMLParaser可以解析HTML文件
可以通过继承HTMLParaser来实现自己的解析器
具体需要形成函数参考实例如下
from html.parser import HTMLParser
from html.entities 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(‘<!--‘, data, ‘-->‘)
def handle_entityref(self, name):
print(‘&%s;‘ % name)
def handle_charref(self, name):
print(‘&#%s;‘ % name)
parser = MyHTMLParser()
parser.feed(‘‘‘<html>
<head></head>
<body>
<!-- test html parser -->
<p>Some <a href=\"#\">html</a> HTML tutorial...<br>END</p>
</body></html>‘‘‘)
urllib提供了一系列操作URL的功能
标签：ons 获取 html targe comm 不同 列操作 lsa 方式
原文地址：http://www.cnblogs.com/weihuchao/p/6760252.html
