python經常使用模塊介紹

關於if __name__ == "__main__":

若執行文件爲bin，調用文件爲cal；

若在執行文件bin中執行print(__name__)

輸出：__main__

當print(__name__)在調用文件中被調用執行則

輸出當前調用文件的路徑：lesson.web.web1.web2.cal 

也就是說只有在執行文件中__name__纔等於__main__

if __name__ == "__main__": 做用

• 用於執行文件時(#不想讓其餘人來調用)
• 用於調用文件時(#用於調用文件的測試)
  

 time模塊

import time
#----時間戳----
print(time.time())  #時間戳：1542779690.9086285，用於計算
#----當地時間----
print(time.localtime(9999999999)) #結構化時間struct_time,默認參數是當前時間time.time()
print(time.localtime().tm_year) #只打印年
#----國際標準時間----UTC
print(time.gmtime()) #按英國的算差8個小時
#--------------------------------------------------------
#----將時間戳轉換爲結構化時間----  #Timestamp--->>>struct_time
print(time.localtime(9999999999))
#----將結構化時間轉換爲時間戳----  #struct_time--->>>Timestamp
print(time.mktime(time.localtime()))
#----將結構化時間轉換成字符串時間---- #struct_time--->>>Formait_string
print(time.strftime("%Y-%m-%d-%X",time.localtime())) #第一個參數是字符串時間的排布，第二個參數是結構化時間
#----將字符串時間轉換成結構化時間---- #Format_string--->>>struct_time
print(time.strptime("2018-11-21-14:16:08","%Y-%m-%d-%X"))#第一個參數是字符串時間，第二個參數是時間排布，必須和第一個參數一一對應

#直接看一個時間，不須要排布(固定)
print(time.asctime())  #Wed Nov 21 14:24:48 2018,把一個結構化時間轉換成固定的字符串表達形式
print(time.ctime())  #Wed Nov 21 14:25:51 2018，把一個時間戳轉換成固定格式的字符串

時間轉換：

 random模塊

import random
print(random.random()) #隨機取[0,1)的浮點數
print(random.randint(1,5)) #隨機取[1,5]的整數
print(random.randrange(1,5)) #隨機取[1,5)的整數
print(random.choice([55,8,6,[11,22,33]])) #隨機取出列表中的一個元素
print(random.sample([55,8,6],2))#隨機取出列表中的2個元素
print(random.uniform(0,9))#隨機取出任意範圍的浮點型[0,9)
#打亂順序
item = [1,3,5,7,9]
random.shuffle(item)
print(item)

def inner():
    res = ""
    for i in range(4):        #幾位驗證碼就作幾回循環
        num = random.randint(0,9)  #隨機生成0,9的數字
        alf = chr(random.randint(65,122)) #將隨機生成的數字,用chr()轉換成字母
        s = str(random.choice([num,alf]))  #隨機取出數字或字母
        res += s   #拼接
    return res
print(inner())

驗證碼

 os模塊

import os
print(os.getcwd()) #獲取當前工做目錄，即python腳本工做的路徑
print(os.chdir("lesson")) #改變當前腳本工做目錄，至關於shell下的cd,返回上一級目錄參數爲("..")
print(os.curdir) #返回當前目錄:(".")
print(os.pardir) #返回當前目錄的父目錄字符串名:("..")
os.makedirs("dirname1/dirname2") #生成多層遞歸目錄
os.removedirs("dirname1/dirname2") #刪除目錄,若目錄爲空則刪除,並遞歸到上級目錄,如若也爲空也刪除,以此類推
os.mkdir("dirname1") #生成單級目錄,至關於shell中的mkdir dirname
os.rmdir("dirname1") #刪除單級空目錄,若目錄不爲空則沒法刪除,報錯，至關於shell中的 rmdir dirname
print(os.listdir("lesson")) #列出指定目錄下的全部文件和子目錄,包括隱藏文件,並以列表方式打印
os.remove("lesson/__init__.py") #刪除一個文件
os.rename("test.py","dirname.py") #重命名文件/目錄
print(os.stat("bin.py"))#獲取文件/目錄信息,st_size=字節,st_atime=訪問時間, st_mtime=修改時間, st_ctime=建立時間
print(os.sep) #輸出操做系統特定的分隔符,win下爲"\",linux下爲"/"
print(os.linesep) #輸出當前平臺使用的行終止符(換行符),win下爲"\r\n",Linux下爲"\n"
print(os.pathsep) #輸出用於分割文件路徑的字符串 win下爲; linux下爲：
print(os.name) #輸出字符串指示當前使用平臺,win->"nt";linux->"posix"
print(os.environ) #獲取系統環境變量
--------------------------------------------------------------------
print(os.path.abspath("dirname.py")) #獲取lesson的絕對路徑
print(os.path.split("D:\Python\小遊戲\demo\lesson\")) #將dirname.py的絕對路徑分割成目錄和文件名按元祖返回
print(os.path.dirname("D:\Python\小遊戲\demo\lesson\dirname.py"))# 取路徑
print(os.path.basename("D:\Python\小遊戲\demo\lesson\dirname.py")) #取文件名
print(os.path.exists("lesson/dirname.py")) #判斷文件存不存在,返回布爾值
print(os.path.isabs("lesson\dirname.py")) #判斷是不是絕對路徑,返回布爾值
print(os.path.isfile("lesson\dirname.py")) #判斷dirname.py是不是一個存在的文件,返回布爾值
print(os.path.isdir("lesson")) #判斷lesson是不是一個存在的目錄,返回布爾值
a = "D:\Python\小遊戲\demo"
b = "lesson\dirname.py"
print(os.path.join(a,b)) #路徑拼接
print(os.path.getatime("lesson")) #返回文件/目錄的最後訪問時間
print(os.path.getmtime("lesson")) #返回文件/目錄的最後修改時間
print(os.path.getctime("lesson")) #返回文件/目錄的最後建立時間

 sys模塊

import sys
sys.exit(0) 退出程序
sys.version #獲取python解釋器程序的版本信息
sys.maxint #最大int值
sys.path  #返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
print(sys.platform) #返回操做系統平臺名稱
sys.argv #命令行參數list,第一個元素是程序自己路徑

import sys,time
for i in range(100):
    sys.stdout.write("=")  #屏幕打印
    time.sleep(0.1)
    sys.stdout.flush() #刷新,目的是不須要等到結果所有都拿到緩存在打印到屏幕上,而是拿到一個刷新緩存,打印一次；

進度條

引用： https://www.cnblogs.com/aland-1415/p/6613449.html

Python中 sys.argv[]的用法簡明解釋

　　sys.argv[]說白了就是一個從程序外部獲取參數的橋樑，這個「外部」很關鍵，因此那些試圖從代碼來講明它做用的解釋一直沒看明白。由於咱們從外部取得的參數能夠是多個，因此得到的是一個列表（list)，也就是說sys.argv其實能夠看做是一個列表，因此才能用[]提取其中的元素。其第一個元素是程序自己，隨後才依次是外部給予的參數。

下面咱們經過一個極簡單的test.py程序的運行結果來講明它的用法。

1 #test.py 2 3 import sys 4 a=sys.argv[0] 5 print(a)

將test.py保存在c盤的根目錄下。

在程序中找到 ‘運行’->點擊->輸入"cmd"->回車鍵   進入控制檯命令窗口（以下圖），先輸入cd c:\   (做用是將命令路徑改到c盤根目錄)，而後輸入test.py運行咱們剛剛寫的程序：

 

獲得的結果是C:\test.py，這就是0指代碼（即此.py程序）自己的意思。

而後咱們將代碼中0改成1 :

a=sys.argv[1]

保存後，再從控制檯窗口運行，此次咱們加上一個參數，輸入：test.py what

 

 獲得的結果就是咱們輸入的參數what，看到這裏你是否是開始明白了呢。

那咱們再把代碼修改一下：

a=sys.argv[2：]

保存後，再從控制檯窗臺運行程序，此次多加幾個參數，以空格隔開:

test.py a b c d e f

 

獲得的結果爲[‘b’, ’c’, ’d’, ’e’, ’f’]

應該大徹大悟了吧。Sys.argv[ ]其實就是一個列表，裏邊的項爲用戶輸入的參數，關鍵就是要明白這參數是從程序外部輸入的，而非代碼自己的什麼地方，要想看到它的效果就應該將程序保存了，從外部來運行程序並給出參數。

什麼是序列化？

序列化 (Serialization)是指將對象、數據結構的狀態信息轉換爲能夠存儲或傳輸的形式的過程。在序列化期間，對象將其當前狀態寫入到臨時或持久性存儲區。之後，能夠經過從存儲區中讀取或反序列化對象的狀態，從新建立該對象。
咱們編寫的程序，會涉及到各類各樣的對象、數據結構，它們一般是以變量的形式在內存中存在着。當程序運行結束後，這些變量也就會被清理。但咱們有時但願可以在下一次編寫程序時恢復上一次的某個對象（如機器學習中的到結果，須要程序運行較長時間，屢次運行時間成本太大），這就須要咱們將變量進行持久化的存儲。一種方式是利用文件讀寫的方式將變量轉化爲某種形式的字符串寫入文件內，但須要本身控制存儲格式顯得十分笨拙。更好的方式是經過序列化的方式將變量持久化至本地。如下介紹json、pickle兩種序列化方法；

json模塊

若是咱們要在不一樣的編程語言之間傳遞對象，就必須把對象序列化爲標準格式，好比XML，但更好的方法是json，由於json表示出來的就是字符串，能夠被全部語言讀取，也能夠方便地存儲到磁盤或者經過網絡傳輸，json不只是標準格式，而且比XML更快，並且能夠直接在web頁面中讀取，很是方便；

import json
res = {"name":"szx"}
with open("dict","w") as f:
    data = json.dumps(res) #將res轉換成字符串,轉換前的數據類型不管是單引號仍是雙引號,都會被轉換成雙引號；
    f.write(data)  #將轉換後的字符串寫入文件
    print(data)
    print(type(data))

with open("dict","r") as f:
    response = f.read()  #將讀取的結果保存
    s = json.loads(response) #將讀取的結果恢復成以前的數據結構
    print(s)
    print(type(s))

# {"name": "szx"}
# <class 'str'>
# {'name': 'szx'}
# <class 'dict'>
#只要符合json的規範,文件中是雙引號,就能夠直接loads

 pickle模塊

注意：json與pickle最大的區別在於json轉換後是str，pickle轉換後是bytes；

import pickle
res = {"name":"szx","age":"18"}
with open("dict","wb") as f:
    data = pickle.dumps(res) #將res轉換成bytes類型
    f.write(data)  #將轉換後的字節寫入文件,注意w是寫入str,wb是寫入bytes,data是bytes類型
    print(data)
    print(type(data))

with open("dict","rb") as f:
    response = f.read()  #將讀取的結果保存
    s = pickle.loads(response) #將讀取的結果恢復成以前的數據結構
    print(s)
    print(type(s))
# b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x03\x00\x00\x00szxq\x02X\x03\x00\x00\x00ageq\x03X\x02\x00\x00\x0018q\x04u.'
# <class 'bytes'>
# {'name': 'szx', 'age': '18'}
# <class 'dict'>

 XML模塊

xml是實現不一樣語言或程序之間進行數據交換的協議，跟json差很少，但json使用起來更簡單，不過，古時候，在json還沒誕生的黑暗年代，你們只能選擇用xml呀，至今不少傳統公司如金融行業的不少系統的接口還主要是xml。

xml的格式以下，就是經過<>節點來區別數據結構的:

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

xml數據

View Code

xml協議在各個語言裏的都 是支持的，在python中能夠用如下模塊操做xml：

for i in root:
    # print(i.tag)
    for j in i:
        #print(j.tag) #查看標籤名
        #print(j.attrib) #打印標籤屬性
        #print(j.text) #查看標籤內容

# print(root.iter('year')) #全文搜索
# print(root.find('country')) #在root的子節點找，只找一個
# print(root.findall('country')) #在root的子節點找，找全部

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
 
#遍歷xml文檔
for child in root:
    print('========>',child.tag,child.attrib,child.attrib['name'])
    for i in child:
        print(i.tag,i.attrib,i.text)
 
#只遍歷year 節點
for node in root.iter('year'):
    print(node.tag,node.text)
#---------------------------------------

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
 
#修改
for node in root.iter('year'):
    new_year=int(node.text)+1
    node.text=str(new_year)
    node.set('updated','yes')
    node.set('version','1.0')
tree.write('test.xml')
 
 
#刪除node
for country in root.findall('country'):
   rank = int(country.find('rank').text)
   if rank > 50:
     root.remove(country)
 
tree.write('output.xml')

View Code

#在country內添加（append）節點year2
import xml.etree.ElementTree as ET
tree = ET.parse("a.xml")
root=tree.getroot()
for country in root.findall('country'):
    for year in country.findall('year'):
        if int(year.text) > 2000:
            year2=ET.Element('year2')
            year2.text='新年'
            year2.attrib={'update':'yes'}
            country.append(year2) #往country節點下添加子節點

tree.write('a.xml.swap')

View Code

本身建立XML文件

import xml.etree.ElementTree as ET
 
 
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'
 
et = ET.ElementTree(new_xml) #生成文檔對象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
 
ET.dump(new_xml) #打印生成的格式

View Code

 logging模塊

一 (簡單應用)

import logging logging.debug('debug message') logging.info('info message') logging.warning('warning message') logging.error('error message') logging.critical('critical message') 

輸出：

WARNING:root:warning message
ERROR:root:error message
CRITICAL:root:critical message

可見，默認狀況下Python的logging模塊將日誌打印到了標準輸出中，且只顯示了大於等於WARNING級別的日誌，這說明默認的日誌級別設置爲WARNING（日誌級別等級CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET），默認的日誌格式爲日誌級別：Logger名稱：用戶輸出消息。

 

二  靈活配置日誌級別，日誌格式，輸出位置

import logging  
logging.basicConfig(level=logging.DEBUG,  
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
                    datefmt='%a, %d %b %Y %H:%M:%S',  
                    filename='/tmp/test.log',  
                    filemode='w')  
  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

查看輸出：
cat /tmp/test.log 
Mon, 05 May 2014 16:29:53 test_logging.py[line:9] DEBUG debug message
Mon, 05 May 2014 16:29:53 test_logging.py[line:10] INFO info message
Mon, 05 May 2014 16:29:53 test_logging.py[line:11] WARNING warning message
Mon, 05 May 2014 16:29:53 test_logging.py[line:12] ERROR error message
Mon, 05 May 2014 16:29:53 test_logging.py[line:13] CRITICAL critical message

可見在logging.basicConfig()函數中可經過具體參數來更改logging模塊默認行爲，可用參數有
filename：用指定的文件名建立FiledHandler（後邊會具體講解handler的概念），這樣日誌會被存儲在指定的文件中。
filemode：文件打開方式，在指定了filename時使用這個參數，默認值爲「a」還可指定爲「w」。
format：指定handler使用的日誌顯示格式。
datefmt：指定日期時間格式。
level：設置rootlogger（後邊會講解具體概念）的日誌級別
stream：用指定的stream建立StreamHandler。能夠指定輸出到sys.stderr,sys.stdout或者文件(f=open('test.log','w'))，默認爲sys.stderr。若同時列出了filename和stream兩個參數，則stream參數會被忽略。

format參數中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 數字形式的日誌級別
%(levelname)s 文本形式的日誌級別
%(pathname)s 調用日誌輸出函數的模塊的完整路徑名，可能沒有
%(filename)s 調用日誌輸出函數的模塊的文件名
%(module)s 調用日誌輸出函數的模塊名
%(funcName)s 調用日誌輸出函數的函數名
%(lineno)d 調用日誌輸出函數的語句所在的代碼行
%(created)f 當前時間，用UNIX標準的表示時間的浮 點數表示
%(relativeCreated)d 輸出日誌信息時的，自Logger建立以 來的毫秒數
%(asctime)s 字符串形式的當前時間。默認格式是 「2003-07-08 16:49:45,896」。逗號後面的是毫秒
%(thread)d 線程ID。可能沒有
%(threadName)s 線程名。可能沒有
%(process)d 進程ID。可能沒有
%(message)s用戶輸出的消息

 

三  logger對象

    上述幾個例子中咱們瞭解到了logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical()（分別用以記錄不一樣級別的日誌信息），logging.basicConfig()（用默認日誌格式（Formatter）爲日誌系統創建一個默認的流處理器（StreamHandler），設置基礎配置（如日誌級別等）並加到root logger（根Logger）中）這幾個logging模塊級別的函數，另外還有一個模塊級別的函數是logging.getLogger([name])（返回一個logger對象，若是沒有指定名字將返回root logger）

     先看一個最簡單的過程：

import logging

logger = logging.getLogger()
# 建立一個handler，用於寫入日誌文件
fh = logging.FileHandler('test.log')

# 再建立一個handler，用於輸出到控制檯
ch = logging.StreamHandler()

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setFormatter(formatter)
ch.setFormatter(formatter)

logger.addHandler(fh) #logger對象能夠添加多個fh和ch對象
logger.addHandler(ch)

logger.debug('logger debug message')
logger.info('logger info message')
logger.warning('logger warning message')
logger.error('logger error message')
logger.critical('logger critical message')

先簡單介紹一下，logging庫提供了多個組件：Logger、Handler、Filter、Formatter。Logger對象提供應用程序可直接使用的接口，Handler發送日誌到適當的目的地，Filter提供了過濾日誌信息的方法，Formatter指定日誌顯示格式。

     (1)

      Logger是一個樹形層級結構，輸出信息以前都要得到一個Logger（若是沒有顯示的獲取則自動建立並使用root Logger，如第一個例子所示）。
      logger = logging.getLogger()返回一個默認的Logger也即root Logger，並應用默認的日誌級別、Handler和Formatter設置。
固然也能夠經過Logger.setLevel(lel)指定最低的日誌級別，可用的日誌級別有logging.DEBUG、logging.INFO、logging.WARNING、logging.ERROR、logging.CRITICAL。
      Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()輸出不一樣級別的日誌，只有日誌等級大於或等於設置的日誌級別的日誌纔會被輸出。 

logger.debug('logger debug message') logger.info('logger info message') logger.warning('logger warning message') logger.error('logger error message') logger.critical('logger critical message') 

只輸出了
2014-05-06 12:54:43,222 - root - WARNING - logger warning message
2014-05-06 12:54:43,223 - root - ERROR - logger error message
2014-05-06 12:54:43,224 - root - CRITICAL - logger critical message
     從這個輸出能夠看出logger = logging.getLogger()返回的Logger名爲root。這裏沒有用logger.setLevel(logging.Debug)顯示的爲logger設置日誌級別，因此使用默認的日誌級別WARNIING，故結果只輸出了大於等於WARNIING級別的信息。

     (2) 若是咱們再建立兩個logger對象：

##################################################
logger1 = logging.getLogger('mylogger')
logger1.setLevel(logging.DEBUG)

logger2 = logging.getLogger('mylogger')
logger2.setLevel(logging.INFO)

logger1.addHandler(fh)
logger1.addHandler(ch)

logger2.addHandler(fh)
logger2.addHandler(ch)

logger1.debug('logger1 debug message')
logger1.info('logger1 info message')
logger1.warning('logger1 warning message')
logger1.error('logger1 error message')
logger1.critical('logger1 critical message')
  
logger2.debug('logger2 debug message')
logger2.info('logger2 info message')
logger2.warning('logger2 warning message')
logger2.error('logger2 error message')
logger2.critical('logger2 critical message')

結果：

      

這裏有兩個個問題：

      <1>咱們明明經過logger1.setLevel(logging.DEBUG)將logger1的日誌級別設置爲了DEBUG，爲什麼顯示的時候沒有顯示出DEBUG級別的日誌信息，而是從INFO級別的日誌開始顯示呢？

       原來logger1和logger2對應的是同一個Logger實例，只要logging.getLogger（name）中名稱參數name相同則返回的Logger實例就是同一個，且僅有一個，也即name與Logger實例一一對應。在logger2實例中經過logger2.setLevel(logging.INFO)設置mylogger的日誌級別爲logging.INFO，因此最後logger1的輸出聽從了後來設置的日誌級別。

      <2>爲何logger一、logger2對應的每一個輸出分別顯示兩次?
       這是由於咱們經過logger = logging.getLogger()顯示的建立了root Logger，而logger1 = logging.getLogger('mylogger')建立了root Logger的孩子(root.)mylogger,logger2一樣。而孩子,孫子，重孫……既會將消息分發給他的handler進行處理也會傳遞給全部的祖先Logger處理。

        ok,那麼如今咱們把

# logger.addHandler(fh)

# logger.addHandler(ch)  註釋掉，咱們再來看效果：

 

由於咱們註釋了logger對象顯示的位置，因此才用了默認方式，即標準輸出方式。由於它的父級沒有設置文件顯示方式，因此在這裏只打印了一次。

孩子,孫子，重孫……可逐層繼承來自祖先的日誌級別、Handler、Filter設置，也能夠經過Logger.setLevel(lel)、Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)、Logger.addFilter(filt)、Logger.removeFilter(filt)。設置本身特別的日誌級別、Handler、Filter。若不設置則使用繼承來的值。

<3>Filter
     限制只有知足過濾規則的日誌纔會輸出。
     好比咱們定義了filter = logging.Filter('a.b.c'),並將這個Filter添加到了一個Handler上，則使用該Handler的Logger中只有名字帶          a.b.c前綴的Logger才能輸出其日誌。

 

     filter = logging.Filter('mylogger') 

     logger.addFilter(filter)

     這是隻對logger這個對象進行篩選

     若是想對全部的對象進行篩選，則：

      filter = logging.Filter('mylogger') 

      fh.addFilter(filter)

      ch.addFilter(filter)

      這樣，全部添加fh或者ch的logger對象都會進行篩選。

完整代碼1：

import logging

logger = logging.getLogger()
# 建立一個handler，用於寫入日誌文件
fh = logging.FileHandler('test.log')

# 再建立一個handler，用於輸出到控制檯
ch = logging.StreamHandler()

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setFormatter(formatter)
ch.setFormatter(formatter)

# 定義一個filter
filter = logging.Filter('mylogger')
fh.addFilter(filter)
ch.addFilter(filter)

# logger.addFilter(filter)
logger.addHandler(fh)
logger.addHandler(ch)




logger.setLevel(logging.DEBUG)

logger.debug('logger debug message')
logger.info('logger info message')
logger.warning('logger warning message')
logger.error('logger error message')
logger.critical('logger critical message')

##################################################
logger1 = logging.getLogger('mylogger')
logger1.setLevel(logging.DEBUG)

logger2 = logging.getLogger('mylogger')
logger2.setLevel(logging.INFO)

logger1.addHandler(fh)
logger1.addHandler(ch)

logger2.addHandler(fh)
logger2.addHandler(ch)

logger1.debug('logger1 debug message')
logger1.info('logger1 info message')
logger1.warning('logger1 warning message')
logger1.error('logger1 error message')
logger1.critical('logger1 critical message')

logger2.debug('logger2 debug message')
logger2.info('logger2 info message')
logger2.warning('logger2 warning message')
logger2.error('logger2 error message')
logger2.critical('logger2 critical message')

View Code

       完整代碼2：

#coding:utf-8  
import logging  
  
# 建立一個logger    
logger = logging.getLogger()  
  
logger1 = logging.getLogger('mylogger')  
logger1.setLevel(logging.DEBUG)  
  
logger2 = logging.getLogger('mylogger')  
logger2.setLevel(logging.INFO)  
  
logger3 = logging.getLogger('mylogger.child1')  
logger3.setLevel(logging.WARNING)  
  
logger4 = logging.getLogger('mylogger.child1.child2')  
logger4.setLevel(logging.DEBUG)  
  
logger5 = logging.getLogger('mylogger.child1.child2.child3')  
logger5.setLevel(logging.DEBUG)  
  
# 建立一個handler，用於寫入日誌文件    
fh = logging.FileHandler('/tmp/test.log')  
  
# 再建立一個handler，用於輸出到控制檯    
ch = logging.StreamHandler()  
  
# 定義handler的輸出格式formatter    
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')  
fh.setFormatter(formatter)  
ch.setFormatter(formatter)  
  
#定義一個filter  
#filter = logging.Filter('mylogger.child1.child2')  
#fh.addFilter(filter)    
  
# 給logger添加handler    
#logger.addFilter(filter)  
logger.addHandler(fh)  
logger.addHandler(ch)  
  
#logger1.addFilter(filter)  
logger1.addHandler(fh)  
logger1.addHandler(ch)  
  
logger2.addHandler(fh)  
logger2.addHandler(ch)  
  
#logger3.addFilter(filter)  
logger3.addHandler(fh)  
logger3.addHandler(ch)  
  
#logger4.addFilter(filter)  
logger4.addHandler(fh)  
logger4.addHandler(ch)  
  
logger5.addHandler(fh)  
logger5.addHandler(ch)  
  
# 記錄一條日誌    
logger.debug('logger debug message')  
logger.info('logger info message')  
logger.warning('logger warning message')  
logger.error('logger error message')  
logger.critical('logger critical message')  
  
logger1.debug('logger1 debug message')  
logger1.info('logger1 info message')  
logger1.warning('logger1 warning message')  
logger1.error('logger1 error message')  
logger1.critical('logger1 critical message')  
  
logger2.debug('logger2 debug message')  
logger2.info('logger2 info message')  
logger2.warning('logger2 warning message')  
logger2.error('logger2 error message')  
logger2.critical('logger2 critical message')  
  
logger3.debug('logger3 debug message')  
logger3.info('logger3 info message')  
logger3.warning('logger3 warning message')  
logger3.error('logger3 error message')  
logger3.critical('logger3 critical message')  
  
logger4.debug('logger4 debug message')  
logger4.info('logger4 info message')  
logger4.warning('logger4 warning message')  
logger4.error('logger4 error message')  
logger4.critical('logger4 critical message')  
  
logger5.debug('logger5 debug message')  
logger5.info('logger5 info message')  
logger5.warning('logger5 warning message')  
logger5.error('logger5 error message')  
logger5.critical('logger5 critical message')

View Code

應用：

import os
import time
import logging
from config import settings


def get_logger(card_num, struct_time):

    if struct_time.tm_mday < 23:
        file_name = "%s_%s_%d" %(struct_time.tm_year, struct_time.tm_mon, 22)
    else:
        file_name = "%s_%s_%d" %(struct_time.tm_year, struct_time.tm_mon+1, 22)

    file_handler = logging.FileHandler(
        os.path.join(settings.USER_DIR_FOLDER, card_num, 'record', file_name),
        encoding='utf-8'
    )
    fmt = logging.Formatter(fmt="%(asctime)s :  %(message)s")
    file_handler.setFormatter(fmt)

    logger1 = logging.Logger('user_logger', level=logging.INFO)
    logger1.addHandler(file_handler)
    return logger1

View Code

 摘自：https://www.cnblogs.com/yuanchenqi/articles/5732581.html