經常使用內建模塊

時間 2019-12-14

標籤經常使用內建模塊简体版

原文原文鏈接

一.datetime

1.模塊導入:

from datetime import datetimehtml

2.獲取當前日期和時間:

>>> now = datetime.now()
>>> print(now)
2019-01-13 14:19:38.181000

3.獲取指定日期和時間:

>>> dt = datetime(2019,1,10,15,0)
>>> print(dt)
2019-01-10 15:00:00

4.datetime轉換爲timestamp

from datetime import datetime

now = datetime.now()
print(now.timestamp())

注意:
Python的timestamp是一個浮點數。若是有小數位，小數位表示毫秒數。python

5.timestamp轉換爲datetime

#本地時區時間
datetime.fromtimestamp(1547360695.313724)
#UTC標準時區的時間
print(datetime.utcfromtimestamp(1547360695.313724))

6.str轉換爲datetime

datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')

7.datetime轉換爲str

now = datetime.now()
print(now.strftime('%a, %b %d %H:%M'))

8.datetime加減

from datetime import datetime, timedelta
now = datetime.now()
new_time = now + timedelta(hours=10)
print(new_time)

9.本地時間轉換爲UTC時間

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8))
now = datetime.now()
dt = now.replace(tzinfo=tz_utc_8)
print(dt)

10.時區轉換

from datetime import datetime, timedelta, timezone

# 強制設置時區爲UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt)
#  利用astimezone()將轉換時區爲北京時間:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt)

注意:
若是要存儲datetime，最佳方法是將其轉換爲timestamp再存儲，由於timestamp的值與時區徹底無關算法

二.collections

1.namedtuple:給tuple屬性命名

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y', 'z'])
p = Point(1,3,9)
print(p.x, p.y, p.z)

2.deque

使用list存儲數據時，按索引訪問元素很快，可是插入和刪除元素就很慢了，由於list是線性存儲，數據量大的時候，插入和刪除效率很低。
deque是爲了高效實現插入和刪除操做的雙向列表，適合用於隊列和棧:安全

from collections import deque
q = deque([2,3,5])
q.appendleft(6)
q.popleft()
print(q)

3.defaultdict

使用dict時，若是引用的Key不存在，就會拋出KeyError。若是但願key不存在時，返回一個默認值，就能夠用defaultdictruby

from collections import defaultdict

d = defaultdict(lambda : 'N/A')
d['l'] = 100
print(d['l'])
print(d['m'])

4.OrderedDict

使用dict時，Key是無序的。OrderedDict的Key會按照插入的順序排列,能夠實現FIFO網絡

from collections import OrderedDict

d1 = OrderedDict()
d1['a'] = 1
d1['b'] = 2
d1['c'] = 3
print(d1)

輸出:
OrderedDict([('a', 1), ('b', 2), ('c', 3)])app

5.ChainMap

ChainMap能夠把一組dict串起來並組成一個邏輯上的dict。ChainMap自己也是一個dict，可是查找的時候，會按照順序在內部的dict依次查找函數

from collections import ChainMap
import os

default_dict = {'platform': os.name}
user_select = {'platform': 'posix'}

d = ChainMap(user_select, default_dict)
print(d['platform'])

若是user_select存在platform就是用該值,不然就使用默認的post

6.Counter

Counter是一個簡單的計數器編碼

from collections import Counter

c = Counter()
for ch in 'helloworld':
    c[ch] += 1

print(c)

輸出:
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, 'w': 1, 'r': 1, 'd': 1})

三.base64

Base64是一種用64個字符來表示任意二進制數據的方法,Base64編碼會把3字節的二進制數據編碼爲4字節的文本數據，長度增長33%，好處是編碼後的文本數據能夠在郵件正文、網頁等直接顯示。

若是要編碼的二進制數據不是3的倍數，最後會剩下1個或2個字節怎麼辦？Base64用\x00字節在末尾補足後，再在編碼的末尾加上1個或2個=號，表示補了多少字節，解碼的時候，會自動去掉。

示例代碼:

import base64

# base64編碼
base64_encode = base64.b64encode(b'52222')
# base64安全編碼,會將可能出現的字符字符+和/替換爲-和_
base64_safe_encode = base64.urlsafe_b64encode(b'52222')
print(base64_encode)
print(base64_safe_encode)

# 解碼
print(base64.b64decode(base64_encode))
print(base64.urlsafe_b64decode(base64_safe_encode))

輸出:
b'NTIyMjI='
b'NTIyMjI='
b'52222'
b'52222'

四.struct

Python提供了一個struct模塊來解決bytes和其餘二進制數據類型的轉換

import struct

# 變成字節,>表示字節順序是big-endian，也就是網絡序，I表示4字節無符號整數
print(struct.pack('>I', 10240099))
# 字節變成相應的數據類型,根據>IH的說明，後面的bytes依次變爲I：4字節無符號整數和H：2字節無符號整數。
print(struct.unpack('>IH', b'\xf0\xf0\xf0\xf0\x80\x80'))

五.hashlib

md5/SHA1解密加密

1.md5加密(32位長度)

import hashlib

#加密
md5 = hashlib.md5()
md5.update('hello'.encode('utf-8'))
print(md5.hexdigest())

2.SHA1(40位長度)

import hashlib

sha1 = hashlib.sha1()
sha1.update('hello'.encode('utf-8'))
print(sha1.hexdigest())

六.hmac

它經過一個標準算法，在計算哈希的過程當中，把key混入計算過程當中

import hmac

hmac_encode = hmac.new(b'salt', b'message', 'MD5')
print(hmac_encode.hexdigest())

七.itertools

1.count:會建立一個無限的迭代器,是天然數序列:

import itertools

for i in itertools.count(1):
    print(i)

2.cycle:會把傳入的一個序列無限重複下去

import itertools

for i in itertools.cycle('abc'):
    print(i)

3.repeat:負責把一個元素無限重複下去，不過若是提供第二個參數就能夠限定重複次數

4.無限序列雖然能夠無限迭代下去，可是一般咱們會經過takewhile()等函數根據條件判斷來截取出一個有限的序列

import itertools

natuals = itertools.count(1)
ns = itertools.takewhile(lambda x: x <= 10, natuals)
print(list(ns))

5.chain: 能夠把一組迭代對象串聯起來，造成一個更大的迭代器

import itertools

for i in itertools.chain('abc', 'def'):
    print(i)

輸出:
a
b
c
d
e
f

6.groupby:把迭代器中相鄰的重複元素挑出來放在一塊兒

import itertools

for key, group in itertools.groupby('AAABBBCCAAA'):
    print(key, group)

輸出:
A <itertools._grouper object at 0x000001C32D2A3550>
B <itertools._grouper object at 0x000001C32D2DCDA0>
C <itertools._grouper object at 0x000001C32D2A3550>
A <itertools._grouper object at 0x000001C32D2DCD68>

八.contextlib(with)

任何對象，只要正確實現了上下文管理，就能夠用於with語句.要使用with實現上下文管理是經過__enter__和__exit__這兩個方法實現的

1.經過類實現:

class Query:
    def __enter__(self):
        print('enter')
        return self

    def query(self, params):
        print(params)
        return 100

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type:
            print('error')
        else:
            print('exit')

with Query() as query:
    query.query('rorshach')

2.更加簡便的經過@contextmanager和yield實現:

from contextlib import contextmanager

class Query:
    def query(self, params):
        print(params)
        return 100

@contextmanager
def make_context_query():
    q = Query()
    yield q

with make_context_query() as query:
    query.query('rorshach')

不少時候，咱們但願在某段代碼執行先後自動執行特定代碼，也能夠用@contextmanager實現:

from contextlib import contextmanager

@contextmanager
def tag():
    print('<h1>')
    yield
    print('</h1>')

#yield沒有生成值,with語句中就不須要寫as子句了
with tag() as tag:
    print('hello')

輸出:
<h1>
hello
</h1>

若是出錯,關閉對象示例:

from contextlib import contextmanager
from urllib.request import urlopen

@contextmanager
def closing(thing):
    try:
        yield thing
    finally:
        thing.close()

with closing(urlopen('http://www.baidu.com')) as page:
    for line in page:
        print(line)

九.urllib

1.get請求

from urllib import request

req = request.Request('http://www.baidu.com/')
# 設置ua
req.add_header('User-Agent', 'Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
with request.urlopen(req) as f:
    print('Status:', f.status, f.reason)
    for k, v in f.getheaders():
        print('%s: %s' % (k, v))
    print('Data:', f.read().decode('utf-8'))

2.post請求

from urllib import request, parse

print('Login to weibo.cn...')
email = input('Email: ')
passwd = input('Password: ')
login_data = parse.urlencode([
    ('username', email),
    ('password', passwd),
    ('entry', 'mweibo'),
    ('client_id', ''),
    ('savestate', '1'),
    ('ec', ''),
    ('pagerefer', 'https://passport.weibo.cn/signin/welcome?entry=mweibo&r=http%3A%2F%2Fm.weibo.cn%2F')
])

req = request.Request('https://passport.weibo.cn/sso/login')
req.add_header('Origin', 'https://passport.weibo.cn')
req.add_header('User-Agent', 'Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
req.add_header('Referer', 'https://passport.weibo.cn/signin/login?entry=mweibo&res=wel&wm=3349&r=http%3A%2F%2Fm.weibo.cn%2F')

with request.urlopen(req, data=login_data.encode('utf-8')) as f:
    print('Status:', f.status, f.reason)
    for k, v in f.getheaders():
        print('%s: %s' % (k, v))
    print('Data:', f.read().decode('utf-8'))

十.XML

1.DOM:

DOM會把整個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)

2.SAX是流模式，邊讀邊解析，佔用內存小，解析快，缺點是咱們須要本身處理事件

十一.HTMLParser

from html.parser import HTMLParser

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>''')

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。