Python之路--Python基礎6--經常使用模塊

時間 2019-11-10

原文原文鏈接

1、time & datetime

在Python中，一般有這幾種方式來表示時間：python

時間戳(timestamp)：一般來講，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。咱們運行「type(time.time())」，返回的是float類型。
格式化的時間字符串(Format String)
結構化的時間(struct_time)：struct_time元組共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天，夏令時)

time模塊：git

import time #--------------------------咱們先以當前時間爲準,讓你們快速認識三種形式的時間
print(time.time()) # 時間戳:1487130156.419527
print(time.strftime("%Y-%m-%d %X")) #格式化的時間字符串:'2017-02-15 11:40:53'

print(time.localtime()) #本地時區的struct_time
print(time.gmtime())    #UTC時區的struct_time

# localtime([secs]) # 將一個時間戳轉換爲當前時區的struct_time。secs參數未提供，則以當前時間爲準
print(time.localtime(1473525444.037215)) #輸出：time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0, tm_min=37, tm_sec=24, tm_wday=6, tm_yday=255, tm_isdst=0)
print(time.localtime())                 #返回本地時間的struct time對象格式 #輸出：time.struct_time(tm_year=2018, tm_mon=1, tm_mday=20, tm_hour=9, tm_min=39, tm_sec=32, tm_wday=5, tm_yday=20, tm_isdst=0)
t = time.localtime() print(t.tm_year, t.tm_mon)              #2018 1


# mktime(t) : 將一個struct_time轉化爲時間戳。
print(time.mktime(time.localtime()))    #1516412372.0


# gmtime([secs]) 和localtime()方法相似，gmtime()方法是將一個時間戳轉換爲UTC時區（0時區）的struct_time。 print(time.gmtime())                    #UTC時區的struct_time #time.struct_time(tm_year=2018, tm_mon=1, tm_mday=20, tm_hour=1, tm_min=39, tm_sec=32, tm_wday=5, tm_yday=20, tm_isdst=0)


# asctime([t]) : 把一個表示時間的元組或者struct_time表示爲這種形式：'Sun Jun 20 23:21:05 1993'。 # 若是沒有參數，將會將time.localtime()做爲參數傳入
print(time.asctime())   #返回時間格式"Sat Jan 20 09:39:32 2018" 

# ctime([secs]) : 把一個時間戳（按秒計算的浮點數）轉化爲time.asctime()的形式。 # 若是參數未給或者爲None的時候，將會默認time.time()爲參數。此時它的做用至關於time.asctime(time.localtime(secs))
print(time.ctime())                     #返回Sat Jan 20 09:39:32 2018 格式, 同上
print(time.ctime(time.time()))          #返回Sat Jan 20 09:39:32 2018 格式, 同上


#strftime(format[, t]) : 把一個表明時間的元組或者struct_time（如由time.localtime()和time.gmtime()返回） #轉化爲格式化的時間字符串。若是t未指定，將傳入time.localtime()。若是元組中任何一個 #元素越界，ValueError的錯誤將會被拋出。
struct_time = time.localtime(time.time()-86400)        #減了一天
print(time.strftime("%Y-%m-%d %H:%M:%S", struct_time)) #2018-01-19 09:39:32
print(time.strftime("%Y-%m-%d %H:%M:%S"))              #2018-01-20 09:39:32


#日期字符串 轉成 時間戳 兩步
string_2_struct = time.strptime("2018-01-04", "%Y-%m-%d")  #一、將 日期字符串 轉成 struct時間對象格式
print(string_2_struct) #time.struct_time(tm_year=2018, tm_mon=1, tm_mday=4, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=4, tm_isdst=-1)
struct_2_stamp = time.mktime(string_2_struct)              #二、將struct時間對象轉成時間戳
print(struct_2_stamp)   #1514995200.0

 #將時間戳轉爲字符串格式 兩步 #print(time.gmtime(time.time())) #將utc時間戳轉換成struct_time格式 #print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()) ) #將utc struct_time格式轉成指定的字符串格式
string_struct = time.localtime(1473525444.037215)          #一、將時間戳轉換成struct_time格式
print(time.strftime("%Y-%m-%d %H:%M:%S", string_struct))   #二、經過strftime將struct_time轉換爲格式化的時間字符串 2016-09-11 00:37:24

print(time.strftime("%Y-%m-%d %X", time.localtime()))      #本地時間2018-01-20 10:08:51

如下是格式化字符串的時間格式： shell

Directive	Meaning	Notes
`%a`	Locale’s abbreviated weekday name.
`%A`	Locale’s full weekday name.
`%b`	Locale’s abbreviated month name.
`%B`	Locale’s full month name.
`%c`	Locale’s appropriate date and time representation.
`%d`	Day of the month as a decimal number [01,31].
`%H`	Hour (24-hour clock) as a decimal number [00,23].
`%I`	Hour (12-hour clock) as a decimal number [01,12].
`%j`	Day of the year as a decimal number [001,366].
`%m`	Month as a decimal number [01,12].
`%M`	Minute as a decimal number [00,59].
`%p`	Locale’s equivalent of either AM or PM.	(1)
`%S`	Second as a decimal number [00,61].	(2)
`%U`	Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0.	(3)
`%w`	Weekday as a decimal number [0(Sunday),6].
`%W`	Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0.	(3)
`%x`	Locale’s appropriate date representation.
`%X`	Locale’s appropriate time representation.
`%y`	Year without century as a decimal number [00,99].
`%Y`	Year with century as a decimal number.
`%z`	Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59].
`%Z`	Time zone name (no characters if no time zone exists).
`%%`	A literal `'%'` character.

datetime模塊編程

import datetime print(datetime.datetime.now())                                  #返回當前時間 2018-01-04 18:16:14.648327

print(datetime.date.fromtimestamp(time.time()))          #時間戳直接轉成日期格式 2018-01-04
print(datetime.datetime.now() + datetime.timedelta(3))          #當前時間+3天 2018-01-07 18:16:14.648327
print(datetime.datetime.now() + datetime.timedelta(-3))         #當前時間-3天 2018-01-01 18:16:14.648327
print(datetime.datetime.now() + datetime.timedelta(hours=3))    #當前時間+3小時 2018-01-04 21:16:14.648327
print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #當前時間+30分 2018-01-04 18:46:14.648327
 c_time = datetime.datetime.now() print(c_time.replace(minute=3, hour=2))                         #時間替換 2018-01-04 02:03:14.648327

2、random模塊

#隨機數模塊
import random print(random.random())                             #(0,1)----float 大於0且小於1之間的小數
print(random.uniform(1, 3))                        #大於1小於3的小數 如1.927109612082716

print(random.randint(1, 3))                        #[1,3] 大於等於1且小於等於3之間的隨機整數
print(random.randrange(1, 3))                      #[1,3) 大於等於1且小於3之間的整數
print(random.randrange(1, 10, 2))                  #這個還能夠加步長

print(random.choice([1, "23", [4, 5]]))            #隨機選擇 1或者23或者[4,5]


print(random.sample([1, 2, 3, 4, 5, 6, 6], 2))     #從前面的列表中隨機調兩個
print(random.sample(range(100), 5))                #隨機取5個數據
print(random.sample([1, '23', [4, 5]], 2))         #列表元素任意2個組合
 item = [1, 3, 5, 7, 9] random.shuffle(item) #打亂item的順序,至關於"洗牌"
print(item) #驗證碼1
checkcode = ''
for i in range(4): current = random.randrange(0, 4) if current != i: temp = chr(random.randint(65, 90))  #ascll表裏面65到90的字符
    else: temp = random.randint(0, 9) checkcode += str(temp) print(checkcode)

3、string模塊

import string print(string.ascii_uppercase)  #輸出26個大寫字母 ABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.ascii_letters)    #輸出全部大寫和小寫字母 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.ascii_lowercase)  #輸出26個小寫字母 abcdefghijklmnopqrstuvwxyz
print(string.digits)           #輸出全部數字 0123456789
print(string.digits+string.ascii_lowercase)  # 0123456789abcdefghijklmnopqrstuvwxyz

#驗證碼2
source = string.digits+string.ascii_lowercase print("".join(random.sample(source, 6))) #pgrkj8
print(random.sample(source, 6))          #['j', 'x', '7', '1', 'f', 'w']

4、json & pickle 模塊

　　以前咱們學習過用eval內置方法能夠將一個字符串轉成python對象，不過，eval方法是有侷限性的，對於普通的數據類型，json.loads和eval都能用，但遇到特殊類型的時候，eval就無論用了,因此eval的重點仍是一般用來執行一個字符串表達式，並返回表達式的值。json

import json x = "[null,true,false,1]"
#print(eval(x)) #報錯，沒法解析null類型，而json就能夠
print(json.loads(x))    #輸出：[None, True, False, 1]
print(x)                #輸出：[null,true,false,1]

什麼是序列化？

　　咱們把對象(變量)從內存中變成可存儲或傳輸的過程稱之爲序列化，在Python中叫pickling，在其餘語言中也被稱之爲serialization，marshalling，flattening等等，都是一個意思。數組

爲何要序列化？

1：持久保存狀態bash

　　需知一個軟件/程序的執行就在處理一系列狀態的變化，在編程語言中，'狀態'會以各類各樣有結構的數據類型(也可簡單的理解爲變量)的形式被保存在內存中。網絡

　　內存是沒法永久保存數據的，當程序運行了一段時間，咱們斷電或者重啓程序，內存中關於這個程序的以前一段時間的數據（有結構）都被清空了。在斷電或重啓程序以前將程序當前內存中全部的數據都保存下來（保存到文件中），以便於下次程序執行可以從文件中載入以前的數據，而後繼續執行，這就是序列化。app

　　具體的來講，你玩使命召喚闖到了第13關，你保存遊戲狀態，關機走人，下次再玩，還能從上次的位置開始繼續闖關。或如，虛擬機狀態的掛起等。dom

2：跨平臺數據交互

　　序列化以後，不只能夠把序列化後的內容寫入磁盤，還能夠經過網絡傳輸到別的機器上，若是收發的雙方約定好實用一種序列化的格式，那麼便打破了平臺/語言差別化帶來的限制，實現了跨平臺數據交互。

　　反過來，把變量內容從序列化的對象從新讀到內存裏稱之爲反序列化，即unpickling。

json

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

　　JSON的數據格式其實就是python裏面的字典格式，裏面能夠包含方括號括起來的數組，也就是python裏面的列表。

　 JSON 模塊提供了四個方法： dumps、dump、loads、load

序列化方法：

　　dumps 只完成了序列化爲str

dump 必須傳文件描述符，將序列化的str保存到文件中

反序列化方法：

　　loads 只完成了反序列化，

　　 load 只接收文件描述符，完成了讀取文件和反序列化

內存中的結構化數據 <----> json格式 <----> 字符串 <----> 保存到文件中或基於網絡傳輸

import json dic = {'name': 'alvin', 'age': 23, 'sex': 'male'} print(type(dic))        # <class 'dict'>
 j = json.dumps(dic) print(type(j))          # <class 'str'>
print(j)                # {"name": "alvin", "age": 23, "sex": "male"}跟dic對比一下，參照上圖

# --------------序列化---------------
f = open('序列化對象', 'w') #f.write(j) 　　　　　　　　　　# 等價於json.dump(dic,f)
json.dump(dic, f，indent=4) f.close() # --------------反序列化---------------
import json f = open('序列化對象') data = json.loads(f.read())  　# 等價於data=json.load(f)
print(data)             　　　　# {'age': 23, 'sex': 'male', 'name': 'alvin'}跟j對比，參照上圖

文件：　　 序列化對象：（加上indent=4）

　　　　　　　　　　　　{
    　　　　　　　　　　　　"age": 23,
    　　　　　　　　　　　　"name": "alvin",
    　　　　　　　　　　　　"sex": "male"
　　　　　　　　　　　　}


 　　　　 序列化對象：（沒有加上indent）
　　　　　　　　　　　　{"sex": "male", "name": "alvin", "age": 23}

json 和 picle 模塊

　　json模塊和picle模塊都有 dumps、dump、loads、load四種方法，並且用法同樣。

　　不一樣的是json模塊序列化出來的是通用格式，其它編程語言都認識，就是普通的字符串，

　　而picle模塊序列化出來的只有python能夠認識，其餘編程語言不認識的，表現爲亂碼

　　不過picle能夠序列化函數，可是其餘文件想用該函數，在該文件中須要有該文件的定義（定義和參數必須相同，內容能夠不一樣）

python對象（obj）與json對象的對應關係

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

5、logging模塊

1.日誌級別

　　CRITICAL = 50     #FATAL = CRITICAL
　　ERROR = 40
　　WARNING = 30   #WARN = WARNING
　　INFO = 20
　　DEBUG = 10
　　NOTSET = 0         #不設置

2.默認級別爲warning，默認打印到終端

import logging logging.debug('調試debug') logging.info('消息info') logging.warning('警告warn') logging.error('錯誤error') logging.critical('嚴重critical') 
 '''
輸出:
 WARNING:root:警告warn ERROR:root:錯誤error CRITICAL:root:嚴重critical '''

3.爲logging模塊指定全局配置，針對全部logger有效，控制打印到文件中

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

日誌格式：

%(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	用戶輸出的消息

用法：

#test.py #========使用
import logging logging.basicConfig(filename='access.log', format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S %p', level=10) logging.debug('調試debug') logging.info('消息info') logging.warning('警告warn') logging.error('錯誤error') logging.critical('嚴重critical') #========結果
access.log內容: 2017-07-28 20:32:17 PM - root - DEBUG -test: 調試debug 2017-07-28 20:32:17 PM - root - INFO -test: 消息info 2017-07-28 20:32:17 PM - root - WARNING -test: 警告warn 2017-07-28 20:32:17 PM - root - ERROR -test: 錯誤error 2017-07-28 20:32:17 PM - root - CRITICAL -test:  嚴重critical

level=10 就至關於 level=loggin.DEBUG

level=loggin.DEBUG意思是，把日誌紀錄級別設置爲DEBUG，也就是說，只有日誌是DEBUG或比DEBUG級別更高的日誌纔會被紀錄到文件裏（加filename

參數就會寫到文件裏，不加就會打印到終端）

4.logging模塊的Formatter，Handler，Logger，Filter對象

若是想同時把log打印在屏幕和文件日誌裏，就須要瞭解一點複雜的知識了

Python 使用logging模塊記錄日誌涉及四個主要類，使用官方文檔中的歸納最爲合適：

　　logger 提供了應用程序能夠直接使用的接口；

　　handler 將(logger建立的)日誌記錄發送到合適的目的輸出；

　　filter 提供了細度設備來決定輸出哪條日誌記錄；

　　formatter 決定日誌記錄的最終輸出格式。

logger

每一個程序在輸出信息以前都要得到一個Logger。Logger一般對應了程序的模塊名，好比聊天工具的圖形界面模塊能夠這樣得到它的Logger：

LOG=logging.getLogger(」chat.gui」)

而核心模塊能夠這樣：

LOG=logging.getLogger(」chat.kernel」)

Logger.setLevel(lel)：指定最低的日誌級別，低於lel的級別將被忽略。debug是最低的內置級別，critical爲最高

Logger.addFilter(filt)、Logger.removeFilter(filt)：添加或刪除指定的filter

Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增長或刪除指定的handler

Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：能夠設置的日誌級別

handler

　　handler對象負責發送相關的信息到指定目的地。Python的日誌系統有多種Handler可使用。有些Handler能夠把信息輸出到控制檯，有些Logger能夠

把信息輸出到文件，還有些 Handler能夠把信息發送到網絡上。若是以爲不夠用，還能夠編寫本身的Handler。能夠經過addHandler()方法添加多個handler

　　Handler.setLevel(lel)：指定被處理的信息級別，低於lel級別的信息將被忽略

　　Handler.setFormatter()：給這個handler選擇一個格式

　　Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或刪除一個filter對象

每一個Logger能夠附加多個Handler。接下來咱們就來介紹一些經常使用的Handler：

1) logging.StreamHandler

使用這個Handler能夠向相似與sys.stdout或者sys.stderr的任何文件對象(file object)輸出信息。它的構造函數是：

StreamHandler([strm])

其中strm參數是一個文件對象。默認是sys.stderr

2) logging.FileHandler
和StreamHandler相似，用於向一個文件輸出日誌信息。不過FileHandler會幫你打開這個文件。它的構造函數是：

FileHandler(filename[,mode])

filename是文件名，必須指定一個文件名。

mode是文件的打開方式。參見Python內置函數open()的用法。默認是’a'，即添加到文件末尾。

3) logging.handlers.RotatingFileHandler
　　這個Handler相似於上面的FileHandler，可是它能夠管理文件大小。當文件達到必定大小以後，它會自動將當前日誌文件更名，而後建立一個新的同名日

志文件繼續輸出。好比日誌文件是chat.log。當chat.log達到指定的大小以後，RotatingFileHandler自動把文件更名爲chat.log.1。不過，若是chat.log.1已

經存在，會先把chat.log.1重命名爲chat.log.2。。。最後從新建立 chat.log，繼續輸出日誌信息。

　　它的構造函數是：RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])，

　　其中filename和mode兩個參數和FileHandler同樣。maxBytes用於指定日誌文件的最大文件大小。若是maxBytes爲0，意味着日誌文件能夠無限大，這

時上面描述的重命名過程就不會發生。backupCount用於指定保留的備份文件的個數。好比，若是指定爲2，當上面描述的重命名過程發生時，原有的

chat.log.2並不會被改名，而是被刪除。

4) logging.handlers.TimedRotatingFileHandler
　　這個Handler和RotatingFileHandler相似，不過，它沒有經過判斷文件大小來決定什麼時候從新建立日誌文件，而是間隔必定時間就自動建立新的日誌文件。

重命名的過程與RotatingFileHandler相似，不過新的文件不是附加數字，而是當前時間。

　　它的構造函數是：TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])

　　其中filename參數和backupCount參數和RotatingFileHandler具備相同的意義。interval是時間間隔。

　　when參數是一個字符串。表示時間間隔的單位，不區分大小寫。它有如下取值：S 秒、M 分、H 小時、D 天、W 每星期（interval=0時表明星期一）

midnight 天天凌晨

舉個栗子：

import logging # create logger
logger = logging.getLogger('getLogger') logger.setLevel(logging.DEBUG) # create console handler and set level to debug
ch = logging.StreamHandler() ch.setLevel(logging.NOTSET) # create file handler and set level to WARNING
fh = logging.FileHandler("FileHandler.log") fh.setLevel(logging.WARNING) # create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') # add formatter to ch and fh
ch.setFormatter(formatter) fh.setFormatter(formatter) # add ch and fh to logger
logger.addHandler(ch) logger.addHandler(fh) # 'application' code
logger.debug('debug message') logger.info('info message') logger.warning('warn message') logger.error('error message') logger.critical('critical message')

#控制檯輸出：

2018-01-23 17:40:06,285 - getLogger - DEBUG - debug message 2018-01-23 17:40:06,285 - getLogger - INFO - info message 2018-01-23 17:40:06,285 - getLogger - WARNING - warn message 2018-01-23 17:40:06,285 - getLogger - ERROR - error message 2018-01-23 17:40:06,286 - getLogger - CRITICAL - critical message

#FileHandler.log

2018-01-23 17:40:06,285 - getLogger - WARNING - warn message 2018-01-23 17:40:06,285 - getLogger - ERROR - error message 2018-01-23 17:40:06,286 - getLogger - CRITICAL - critical message

這兩處的差別得看日誌等級的設置

文件自動截斷的栗子：

import logging from logging import handlers logger = logging.getLogger(__name__) #獲取本模塊名 log_file = "timelog.log" 
 fh = handlers.RotatingFileHandler(filename=log_file, maxBytes=10, backupCount=2) #fh = handlers.TimedRotatingFileHandler(filename=log_file, when="S", interval=5, backupCount=3)
 formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s') fh.setFormatter(formatter) logger.addHandler(fh) logger.warning("test1") logger.warning("test12") logger.warning("test13") logger.warning("test14")

6、os模塊

os模塊是與操做系統交互的一個接口

os.getcwd()          #獲取當前工做目錄，即當前python腳本工做的目錄路徑
os.chdir("dirname")  #改變當前腳本工做目錄；至關於shell下cd
os.curdir            #返回當前目錄: ('.')
os.pardir            #獲取當前目錄的父目錄字符串名：('..')
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.sep  　　　　　　　　  　#輸出操做系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
os.linesep  　　　　　　　　#輸出當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
os.pathsep  　　　　　　　　#輸出用於分割文件路徑的字符串 win下爲;,Linux下爲:
os.name   　　　　　　　　  #輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
os.system("bash command")#運行shell命令，直接顯示
os.environ  　　　　　　　　#獲取系統環境變量
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的大小

7、sys模塊

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