<筆記>第二篇:常用模組

阿新 • • 發佈：2020-09-08

什麼是模組?常見的場景:一個模組就是一個包含了python定義和宣告的檔案，檔名就是模組名字加上.py的字尾。
其實import載入的模組分為四個通用類別：

使用python編寫的程式碼（.py檔案）　　
已被編譯為共享庫或DLL的C或C++擴充套件
包好一組模組的包
使用C編寫並連結到python直譯器的內建模組

為什麼要使用模組?之前定義的函式或變數,為了方便管理和後期的呼叫,現在將程式製作成一個模組,使它不僅能作為指令碼執行,也可以匯入到其他模組,實現功能的重複利用.　　
如何控制.py檔案在不同的應用場景下執行不同的邏輯?if __name__ == '__main__':　
- 我們可以通過模組的全域性變數__name__來檢視模組名：　　
  - 當做指令碼執行：__name__ 等於'__main__'　　
  - 當做模組匯入：__name__= 模組名　　　
什麼是包?包是目錄級的（資料夾級），資料夾是用來組成py檔案（包的本質就是一個包含__init__.py檔案的目錄）　
- 在python3中，即使包下沒有__init__.py檔案，import 包仍然不會報錯，而在python2中，包下一定要有該檔案，否則import 包報錯　
- 建立包的目的不是為了執行，而是被匯入使用，記住，包只是模組的一種形式而已，包即模組　　
- 凡是在匯入時帶點的，點的左邊都必須是一個包，否則非法

軟體開發規範

目錄:bin,conf,core,lib,log

#=============>bin目錄：存放執行指令碼
#start.py
import sys,os

BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)

from core import core
from conf import my_log_settings

if __name__ == '__main__':
    my_log_settings.load_my_logging_cfg()
    core.run()

#=============>conf目錄：存放配置檔案
#config.ini
[DEFAULT]
user_timeout = 1000

[egon]
password = 123
money = 10000000

[alex]
password = alex3714
money=10000000000

[yuanhao]
password = ysb123
money=10

#settings.py
import os
config_path=r'%s\%s' %(os.path.dirname(os.path.abspath(__file__)),'config.ini')
user_timeout=10
user_db_path=r'%s\%s' %(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),\
                     'db')


#my_log_settings.py
"""
logging配置
"""

import os
import logging.config

# 定義三種日誌輸出格式 開始

standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]' #其中name為getlogger指定的名字

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

# 定義日誌輸出格式 結束

logfile_dir = r'%s\log' %os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # log檔案的目錄

logfile_name = 'all2.log'  # log檔名

# 如果不存在定義的日誌目錄就建立一個
if not os.path.isdir(logfile_dir):
    os.mkdir(logfile_dir)

# log檔案的全路徑
logfile_path = os.path.join(logfile_dir, logfile_name)

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #列印到終端的日誌
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 列印到螢幕
            'formatter': 'simple'
        },
        #列印到檔案的日誌,收集info及以上的日誌
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 儲存到檔案
            'formatter': 'standard',
            'filename': logfile_path,  # 日誌檔案
            'maxBytes': 1024*1024*5,  # 日誌大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日誌檔案的編碼，再也不用擔心中文log亂碼了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['default', 'console'],  # 這裡把上面定義的兩個handler都加上，即log資料既寫入檔案又列印到螢幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）傳遞
        },
    },
}


def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 匯入上面定義的logging配置
    logger = logging.getLogger(__name__)  # 生成一個log例項
    logger.info('It works!')  # 記錄該檔案的執行狀態

if __name__ == '__main__':
    load_my_logging_cfg()

#=============>core目錄：存放核心邏輯
#core.py
import logging
import time
from conf import settings
from lib import read_ini

config=read_ini.read(settings.config_path)
logger=logging.getLogger(__name__)

current_user={'user':None,'login_time':None,'timeout':int(settings.user_timeout)}
def auth(func):
    def wrapper(*args,**kwargs):
        if current_user['user']:
            interval=time.time()-current_user['login_time']
            if interval < current_user['timeout']:
                return func(*args,**kwargs)
        name = input('name>>: ')
        password = input('password>>: ')
        if config.has_section(name):
            if password == config.get(name,'password'):
                logger.info('登入成功')
                current_user['user']=name
                current_user['login_time']=time.time()
                return func(*args,**kwargs)
        else:
            logger.error('使用者名稱不存在')

    return wrapper

@auth
def buy():
    print('buy...')

@auth
def run():

    print('''
購物
檢視餘額
轉賬
    ''')
    while True:
        choice = input('>>: ').strip()
        if not choice:continue
        if choice == '1':
            buy()



if __name__ == '__main__':
    run()

#=============>db目錄：存放資料庫檔案
#alex_json
#egon_json

#=============>lib目錄：存放自定義的模組與包
#read_ini.py
import configparser
def read(config_file):
    config=configparser.ConfigParser()
    config.read(config_file)
    return config

#=============>log目錄：存放日誌
#all2.log
[2017-07-29 00:31:40,272][MainThread:11692][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
[2017-07-29 00:31:41,789][MainThread:11692][task_id:core.core][core.py:25][ERROR][使用者名稱不存在]
[2017-07-29 00:31:46,394][MainThread:12348][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
[2017-07-29 00:31:47,629][MainThread:12348][task_id:core.core][core.py:25][ERROR][使用者名稱不存在]
[2017-07-29 00:31:57,912][MainThread:10528][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
[2017-07-29 00:32:03,340][MainThread:12744][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
[2017-07-29 00:32:05,065][MainThread:12916][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
[2017-07-29 00:32:08,181][MainThread:12916][task_id:core.core][core.py:25][ERROR][使用者名稱不存在]
[2017-07-29 00:32:13,638][MainThread:7220][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
[2017-07-29 00:32:23,005][MainThread:7220][task_id:core.core][core.py:20][INFO][登入成功]
[2017-07-29 00:32:40,941][MainThread:7220][task_id:core.core][core.py:20][INFO][登入成功]
[2017-07-29 00:32:47,222][MainThread:7220][task_id:core.core][core.py:20][INFO][登入成功]
[2017-07-29 00:32:51,949][MainThread:7220][task_id:core.core][core.py:25][ERROR][使用者名稱不存在]
[2017-07-29 00:33:00,213][MainThread:7220][task_id:core.core][core.py:20][INFO][登入成功]
[2017-07-29 00:33:50,118][MainThread:8500][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
[2017-07-29 00:33:55,845][MainThread:8500][task_id:core.core][core.py:20][INFO][登入成功]
[2017-07-29 00:34:06,837][MainThread:8500][task_id:core.core][core.py:25][ERROR][使用者名稱不存在]

常見模組

時間模組:time

time.sleep(secs):延遲時間,單位是秒
time.time():獲取當前的時間戳
time.strftime("%Y-%m-%d %X"):'2017-07-24 13:54:37'
time.strftime("%Y-%m-%d %H-%M-%S"):'2017-07-24 13-55-04'

time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
　　　　　　　　　　tm_hour=13, tm_min=59, tm_sec=37, 
                 tm_wday=0, tm_yday=205, tm_isdst=0)

表達時間的三種方式
- 時間戳:1970年1月1日0點開始按秒計算偏移量
  元祖:struct_time,一共9個元素(年，月，日，時，分，秒，一年中第幾周，一年中第幾天,是否是夏令時)
  格式化時間:'1999-1-1'

三種時間的轉換

import time

# --------------正向--------------------
# 時間戳
Timestamp = time.time()
print(Timestamp)
# 時間戳-->結構化時間
struct_time = time.localtime(Timestamp)
print(struct_time)
# 結構化時間-->字串時間
Format_string = time.strftime("%Y-%m-%d %H:%M:%S", struct_time)
print(Format_string)
# -----------------反向-------------------
# 字串時間-->結構化時間
struct_time = time.strptime(Format_string, "%Y-%m-%d %H:%M:%S")
print(struct_time)
# 結構化時間-->時間戳
Timestamp = time.mktime(struct_time)
print(Timestamp)

# 計算時間差
time_time = time.mktime(time.strptime('2020-01-01 00:00:00', "%Y-%m-%d %H:%M:%S"))
time_now = time.mktime(time.strptime('2020-09-07 09:13:09', "%Y-%m-%d %H:%M:%S"))
dif_time = time_now - time_time
struct_time = time.localtime(dif_time)
print('過去了%d年%d月%d天%d小時%d分鐘%d秒' % (struct_time.tm_year - 1970, struct_time.tm_mon - 1,
                                   struct_time.tm_mday - 1, struct_time.tm_hour,
                                   struct_time.tm_min, struct_time.tm_sec))

random模組　

import random
# 隨機小數
random.random():0-1之間的小數
random.uniform(1,3):1-3之間的小數
# 隨機整數
random.randint(1,5):1-5之間的整數
random.randrange(1,10,2):類似range,1-10之間的奇數
# 隨機選擇一個返回
random.choice([1,'23',[4,5]])
# 隨機選擇多個返回
random.sample([1,'23',[4,5]],2) # #列表元素任意2個組合

# 打亂順序
item=[1,3,5,7,9]
random.shuffle(item) # 打亂次序


# 隨機驗證碼

import random


def v_code():
    code = ''
    for i in range(5):
        # 選擇0-9整數
        num = random.randint(0, 9)
        # 返回值是當前(0-255)的整數對應的ASCII字元
        alf = chr(random.randint(65, 90))
        # 從整數和ASCII字元選擇一個
        add = random.choice([num, alf])
        # 將得到的add加到字串code中
        code = "".join([code, str(add)])
    return code


print(v_code())

OS模組:是與作業系統互動的一個介面　

os.makedirs('dirname1/dirname2')    可生成多層遞迴目錄
os.removedirs('dirname1')    若目錄為空，則刪除，並遞迴到上一級目錄，如若也為空，則刪除，依此類推
os.mkdir('dirname')    生成單級目錄；相當於shell中mkdir dirname
os.rmdir('dirname')    刪除單級空目錄，若目錄不為空則無法刪除，報錯；相當於shell中rmdir dirname
os.listdir('dirname')    列出指定目錄下的所有檔案和子目錄，包括隱藏檔案，並以列表方式列印
os.remove()  刪除一個檔案
os.rename("oldname","newname")  重新命名檔案/目錄
os.stat('path/filename')  獲取檔案/目錄資訊

os.system("bash command")  執行shell命令，直接顯示
os.popen("bash command).read()  執行shell命令，獲取執行結果
os.getcwd() 獲取當前工作目錄，即當前python指令碼工作的目錄路徑
os.chdir("dirname")  改變當前指令碼工作目錄；相當於shell下cd

os.path
os.path.abspath(path) 返回path規範化的絕對路徑os.path.split(path) 將path分割成目錄和檔名二元組返回 
os.path.dirname(path) 返回path的目錄。其實就是os.path.split(path)的第一個元素 
os.path.basename(path) 返回path最後的檔名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是絕對路徑，返回True
os.path.isfile(path)  如果path是一個存在的檔案，返回True。否則返回False
os.path.isdir(path)  如果path是一個存在的目錄，則返回True。否則返回False
os.path.join(path1[, path2[, ...]])  將多個路徑組合後返回，第一個絕對路徑之前的引數將被忽略
os.path.getatime(path)  返回path所指向的檔案或者目錄的最後訪問時間
os.path.getmtime(path)  返回path所指向的檔案或者目錄的最後修改時間
os.path.getsize(path) 返回path的大小

os.sep    輸出作業系統特定的路徑分隔符，win下為"\\",Linux下為"/"
os.linesep    輸出當前平臺使用的行終止符，win下為"\r\n",Linux下為"\n"
os.pathsep    輸出用於分割檔案路徑的字串 win下為;,Linux下為:
os.name    輸出字串指示當前使用平臺。win->'nt'; Linux->'posix'

sys模組:與Python直譯器互動的模組　

sys.argv           命令列引數List，第一個元素是程式本身路徑
sys.exit(n)        退出程式，正常退出時exit(0),錯誤退出sys.exit(1)
sys.version        獲取Python解釋程式的版本資訊
sys.path           返回模組的搜尋路徑，初始化時使用PYTHONPATH環境變數的值
sys.platform       返回作業系統平臺名稱

序列化模組

什麼是序列化?將原本字典、列表等內容轉換成一個字串的過程就叫做序列化　
序列化的目的:
- 以某種儲存形式使自定義物件持久化
- 將物件從一個地方傳遞到另一個地方
- 使程式更具維護性。

dumps和loads

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化：將一個字典轉換成一個字串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json轉換完的字串型別的字典中的字串是由""表示的

dic2 = json.loads(str_dic)  #反序列化：將一個字串格式的字典轉換成一個字典
#注意，要用json的loads功能處理的字串型別的字典中的字串必須由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic,ensure_ascii=False) #也可以處理巢狀的資料型別 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

dump和load

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一個檔案控制代碼，直接將字典轉換成json字串寫入檔案
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一個檔案控制代碼，直接將檔案中的json字串轉換成資料結構返回
f.close()
print(type(dic2),dic2)

re模組:主要是正則

import re

ret = re.findall('a', 'eva egon yuan')  # 返回所有滿足匹配條件的結果,放在列表裡
print(ret) #結果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()
print(ret) #結果 : 'a'
# 函式會在字串內查詢模式匹配,只到找到第一個匹配然後返回一個包含匹配資訊的物件,該物件可以
# 通過呼叫group()方法得到匹配的字串,如果字串沒有匹配，則返回None。

ret = re.match('a', 'abc').group()  # 同search,不過盡在字串開始處進行匹配
print(ret)
#結果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在對''和'bcd'分別按'b'分割
print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#將數字替換成'H'，引數1表示只替換1個
print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#將數字替換成'H'，返回元組(替換的結果,替換了多少次)
print(ret)

obj = re.compile('\d{3}')  #將正則表示式編譯成為一個 正則表示式物件，規則要匹配的是3個數字    compile編譯
ret = obj.search('abc123eeee') #正則表示式物件呼叫search，引數為待匹配的字串
print(ret.group())  #結果 ： 123

import re
ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一個存放匹配結果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #檢視第一個結果
print(next(ret).group())  #檢視第二個結果
print([i.group() for i in ret])  #檢視剩餘的左右結果

爬蟲中正則的常用寫法

com=re.compile('<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?<span class="title">(?P<title>.*?)</span>'
                   '.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)評價</span>',re.S)

ret=com.finditer(s)

flags有很多可選值：

re.I(IGNORECASE)忽略大小寫，括號內是完整的寫法
re.M(MULTILINE)多行模式，改變^和$的行為
re.S(DOTALL)點可以匹配任意字元，包括換行符
re.L(LOCALE)做本地化識別的匹配，表示特殊字符集 \w, \W, \b, \B, \s, \S 依賴於當前環境，不推薦使用
re.U(UNICODE) 使用\w \W \s \S \d \D使用取決於unicode定義的字元屬性。在python3中預設使用該flag
re.X(VERBOSE)冗長模式，該模式下pattern字串可以是多行的，忽略空白字元，並可以添加註釋