python3 基礎（5）-模塊（1）-模塊的導入、標準模塊（標準庫）

模塊介紹

補充：

通過os模塊獲取各種路徑（目錄）

import os
print(__file__)   #返回程序的相對路徑
print(os.path.abspath(__file__))   #返回程序的絕對路徑
print(os.path.dirname(os.path.abspath(__file__)))   #返回程序所在位置的父目錄
print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))  #返回程序所在位置的父目錄的父目錄
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
print("----------------------------")
#輸出
D:/PycharmProjects/day04/Atm/bin/atm.py
D:\PycharmProjects\day04\Atm\bin\atm.py
D:\PycharmProjects\day04\Atm\bin
D:\PycharmProjects\day04\Atm
----------------------------

將路徑（環境變量）添加到sys.path列表中：

即：當sys.path路徑列表沒有你想要的路徑時，可以通過 sys.path.append('路徑') 添加。

注：程序搜索路徑時，從sys.path列表的左邊順序搜索到右邊，直到有匹配的

import os,sys
print(sys.path)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  #返回程序所在位置的父目錄的父目錄
print(BASE_DIR)
sys.path.append(BASE_DIR)   #追加環境變量到列表末尾，有時可用insert插入指定位置
print(sys.path)
print("----------------------------")
#輸出
['D:\\PycharmProjects\\day04\\Atm\\bin', 'D:\\PycharmProjects', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\python36.zip', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\DLLs', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\lib', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages']
D:\PycharmProjects\day04\Atm
['D:\\PycharmProjects\\day04\\Atm\\bin', 'D:\\PycharmProjects', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\python36.zip', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\DLLs', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\lib', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages', 'D:\\PycharmProjects\\day04\\Atm']
----------------------------

模塊的定義：
用來從邏輯上組織python代碼，形式上就是以.py結尾的python文件（例：文件名爲test.py，則模塊名就爲test）。可以包含內容（代碼塊）：變量、函數、類、邏輯等；Python之所以應用越來越廣泛，在一定程度上也依賴於其爲程序員提供了大量的模塊以供使用。
作用：
實現程序需要的某個功能
模塊的分類：（後面有詳細介紹）

內置標準模塊（又稱標準庫）
開源模塊
自定義模塊

模塊導入這裏主要講自定義模塊的導入

導入模塊（包括方法屬性）的方式：

main.py程序對module_hello等模塊及方法屬性的調用？

#導入模塊   #將模塊裏的所有方法屬性拿到當前程序執行一遍
import module_hello   #單獨導入一個模塊
import module_hello,module2,module3   #導入N個模塊
#調用模塊的方法屬性：模塊.屬性
print(module_hello.name)
module_hello.say_hello()

#導入模塊中的方法屬性    #將模塊裏的某個或某些方法屬性拿到當前程序執行一遍
from module_hello import *      #導入模塊中的所有屬性,建議不用
from module_hello import loggin   #從一個模塊中單獨導入某個方法屬性
from module_hello import loggin,m2,m3   #從一個模塊中導入N個方法屬性
from module_hello import loggin as loggin_new #從一個模塊中單獨導入某個方法屬性，並重命名
#調用模塊的方法屬性：屬性
loggin_new()
loggin()

不同級導入

atm.py程序對main模塊和atm_test模塊及方法屬性的調用？

import os,sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
print("----------------------------")
#導入模塊或某些屬性的操作
import atm_test   #導入模塊 atm_test
atm_test.test()
print(atm_test.a)
from atm_test import a   #導入模塊的屬性a
print(a)
print("----------------------------")
#導入包下的模塊或包下的包的操作
#方式一
from core import main   #從包core導入模塊main；如果main是一個包，也用from
main.login()
#方式二
import core   #導入目錄（包），執行的是目錄下的__init__.py文件，
               #所以將模塊main先導入__init__.py文件
               #使用 from . import main
core.main.login()
#輸出
----------------------------
this is Atm/atm_test.py
atm_test
atm_test
----------------------------
this is Atm/core/__init__.py
Welcome to ICBC ATM
Welcome to ICBC ATM
----------------------------

導入模塊（包括方法屬性）的本質

Python解釋器把被導入的“模塊名.py”文件解釋一遍
過程：確定模塊名.py文件-->搜索“模塊名.py”文件路徑-->sys.path路徑列表（當前路徑在列表的[0]位，當調用模塊時，會先在程序當前路徑搜索相應文件）

知識補充：

包的定義：用來從邏輯上組織模塊（N個模塊的集合），形式就是一個目錄（必須帶有一個__init__.py文件）
包的導入：import 目錄名；Python解釋器解釋該包下的 __init__.py 文件
實例：執行main.py調用包package_test（因爲不同級調用，所以這裏要先確定路徑）
導入包的本質：執行包下的__init__.py文件。如果包內有多個模塊，可以先將這些模塊先導入到__init__.py文件裏，這樣“import 目錄名”就可以調用包裏的模塊功能了

問題：

當程序中當前定義的函數（再如變量、類等）名和導入模塊的方法屬性相同時，程序最終應用誰的結果？當然是後執行的結果，相當於後定義或後導入的會覆蓋前面的。

導入優化

直接導入模塊的某個或某些屬性比導入整個模塊執行效率高，特別是被程序多次調用時。

自定義模塊

開源模塊

下載、安裝、導入、使用。

如：paramiko模塊

自定義模塊和開源模塊的使用參考 http://www.cnblogs.com/wupeiqi/articles/4963027.html

標準模塊（標準庫）

time與datetime模塊

與時間處理有關的模塊就包括：time，datetime以及calendar。
世界標準時間，UTC（Coordinated Universal Time，世界協調時）亦即格林威治天文時間。在中國時間爲UTC+8。DST（Daylight Saving Time）即夏令時。
在Python中，time模塊實現主要調用C庫，所以各個平臺可能有所不同。通常有這幾種方式來表示時間：

時間戳（timestamp）方式：以秒計算的浮點數。通常來說，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。可以返回時間戳的函數主要有time()，clock()等。我們運行“type(time.time())”，返回的是float類型。
格式化的時間字符串

元組（struct_time）方式：struct_time元組共有9個元素。可以返回struct_time的函數主要有gmtime()，localtime()，strptime()。下面列出struct_time中的幾個元素：

屬性（Attribute）	值（Values）
tm_year（年）	如2018
tm_mon（月）	1 - 12
tm_mday（日）	1 - 31
tm_hour（時）	0 - 23
tm_min（分）	0 - 59
tm_sec（秒）	0 - 61
tm_wday（weekday）	0 - 6（0表示週一）
tm_yday（一年中的第幾天）	1 - 366
tm_isdst（是否是夏令時）	默認爲-1

格式化時間的格式表

格式	含義	備註
年
%y	去掉世紀的年份（00 - 99）
%Y	完整的年份
月
%m	一年中的第幾個月（01 - 12）
%b	一年中的第幾個月，月份的英文簡化名稱，如“Jun”
%B	一年中的第幾個月，月份的英文完整名稱，如“April”
日
%d	一個月中的第幾天（01 - 31）
%j	一年中的第幾天（001 - 366）
%w	一個星期中的第幾天（0 - 6，0是星期一）
%a	一個星期中的第幾天，星期的英文簡化名稱，如“Sun”
%A	一個星期中的第幾天，星期的英文完整名稱，如“Wednesday”
周
%U	一年中的第幾個星期（00 - 53 ）。（星期天是一個星期的開始。）第一個星期天之前的所有天數都放在第0周。	當使用strptime()函數時，只有當在這年中的週數和天數被確定的時候%U纔會被計算。
%W	和%U基本相同，不同的是%W以星期一爲一個星期的開始。	當使用strptime()函數時，只有當在這年中的週數和天數被確定的時候%W纔會被計算。
小時
%H	一天中的第幾個小時（24小時制，00 - 23）
%I	一天中的第幾個小時（12小時制，01 - 12）
分
%M	分鐘數（00 - 59）
秒
%S	秒（01 - 61）	不是59，因爲閏年秒佔兩秒
組合日期時間
%c	日期和時間，同"%a %b %d %H:%M:%S %Y"
%x	日期，如：04/04/18
%X	時間，如：14:20:48
其他
%p	本地am或者pm的相應符	與“%I”配合使用纔有效果
%Z	時區的名字（如果不存在爲空字符）
%%	‘%’字符

time模塊中常用的幾個函數：

import time
# 獲取時間戳
# time.time()：返回當前時間的時間戳，以秒爲單位。
t = time.time()
print(t)
print(type(t))
d = t/60/60/24
print(d)
# time.sleep(secs)：線程推遲指定的時間運行。單位爲秒。
# time.clock()：返回時間戳。這個需要注意，在不同的系統上含義不同。在UNIX系統上，它返回的是“進程時間”，它是用秒錶示的浮點數（時間戳）。而在WINDOWS中，第一次調用，返回的是進程運行的實際時間。而第二次之後的調用是自第一次調用以後到現在的運行時間。（實際上是以WIN32上QueryPerformanceCounter()爲基礎，它比毫秒錶示更爲精確）
time.sleep(1)
print("clock1:%s" % time.clock())  #其中第一個clock()輸出的是程序運行時間
time.sleep(1)
print("clock2:%s" % time.clock())  #第二、三個clock()輸出的都是與第一個clock的時間間隔
time.sleep(1)
print("clock3:%s" % time.clock())
# time.mktime(t)： 將一個struct_time轉化爲時間戳。
t = time.mktime(time.localtime())
print(t)
t = time.mktime(time.gmtime())
print(t)
t = time.mktime(time.strptime("2018-04-03 16:29:28","%Y-%m-%d %H:%M:%S"))
print(t)
print("------------1-------------")
# 獲取struct_time
# time.localtime([secs])：將一個時間戳轉換爲當前時區的struct_time。
# 如果secs參數未提供，則以當前時間爲準。
t = time.localtime()  #同time.localtime(time.time())
print(t)
print(t.tm_year)
t = time.localtime(1304575584.1361799)
print(t)
print(t.tm_year)
print(t.tm_wday)
# time.gmtime([secs])：將一個時間戳轉換爲UTC時區（0時區）的struct_time,和localtime()方法類似
t = time.gmtime()
print(t)
print(t.tm_mday)
# time.strptime(string[, format])：把一個格式化時間字符串轉化爲struct_time。
# 實際上它和strftime()是逆操作；
# 前面格式必須一一對應後面格式；
# 在這個函數中，format默認爲："%a %b %d %H:%M:%S %Y"。
t = time.strptime('Sun Jun 5 16:37:06 2011')
print(t)
t = time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')
print(t)
t = time.strptime('16:37:06', '%X')   #此時年月日默認爲19000101
print(t)
t = time.strptime("2018-04-03 16:29:28","%Y-%m-%d %H:%M:%S")
print(t)
print("------------2-------------")
# 獲取格式化時間字符串
# time.strftime(format[, t])：把一個代表時間的元組或者struct_time（如由time.localtime()和time.gmtime()返回）轉化爲格式化的時間字符串；
# 如果t未指定，將傳入time.localtime()。
# 如果元組中任何一個元素越界，ValueError的錯誤將會被拋出。
t = time.strftime("%m%d %H:%M:%S%Y")
print(type(t))
print(t)
t = time.strftime("%Y%m%d %H:%M:%S",time.localtime())
print(t)
t = time.strftime("%Y%m%d %H:%M:%S",time.gmtime())
print(t)
t = time.strftime("%Y-%m-%d %X",time.localtime())
print(t)
t = time.strftime("%m-%d-%Y.  %b %d %Y is a %A on the %d day of %B.")
print(t)
t = time.strftime("%c",)   #同time.strftime("%a %b %d %H:%M:%S %Y")
print(t)
t = time.strftime("%c",time.gmtime())
print(t)
t = time.strftime("%x",time.gmtime())
print(t)
t = time.strftime("%H",)
print(t)
t = time.strftime("%H",time.gmtime())
print(t)
print("------------3-------------")
# 獲取這種形式："%a %b %d %H:%M:%S %Y"
# time.asctime([t])：把一個表示時間的元組或者struct_time表示爲這種形式：'Sun Jun 20 23:21:05 1993';
# 如果沒有參數，將會將time.localtime()作爲參數傳入。
t = time.asctime()  #同time.asctime(time.localtime())
print(t)
t = time.asctime(time.localtime(23456765.24543))
print(t)
t = time.asctime(time.strptime("2017-10-08 23:04:20", "%Y-%m-%d %H:%M:%S"))
print(t)
# time.ctime([secs])：把一個時間戳轉化爲time.asctime()的形式;
# 如果參數未給或者爲None的時候，將會默認time.time()爲參數。
t = time.ctime() #同time.ctime(time.time())
print(t)
t = time.ctime(23456765.24543)
print(t)
print("------------4-------------")
#補充
print(time.clock()) #返回處理器時間,3.3開始已廢棄 , 改成了time.process_time()測量處理器運算時間,不包括sleep時間,不穩定,mac上測不出來
print(time.altzone)  #返回與utc時間的時間差,以秒計算\
print(time.gmtime(time.time()-800000)) #返回utc時間的struc時間對象格式
print("------------5-------------")

time各表示方式的轉化關係圖：
補充：datetime模塊

支持日期和時間簡單和複雜的方法；
實現的重點放在更有效的處理和格式化輸出；

該模塊還支持時區處理:

import datetime
print(datetime.date.today())   #獲取今天日期
print(datetime.datetime.now()) #獲取當前格式化日期時間
print(datetime.datetime.fromtimestamp(time.time()) )  # 時間戳直接轉成日期時間格式
print(datetime.date.fromtimestamp(time.time()) )  # 時間戳直接轉成日期格式
# 時間加減
print(datetime.datetime.now())
print(datetime.datetime.now() + datetime.timedelta(3)) #當前時間+3天
print(datetime.datetime.now() + datetime.timedelta(-3)) #當前時間-3天
print(datetime.datetime.now() + datetime.timedelta(hours=3)) #當前時間+3小時
print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #當前時間+30分
# 時間替換
c_time  = datetime.datetime.now()
print(c_time.replace(minute=3,hour=2)) #時間替換，將原來獲取的時間替換成指定的時間
#格式化輸出
now = datetime.date.today()
print(now.strftime("%c"))
print(datetime.datetime.now().strftime("%A, %B %d %Y"))
print("------------6-------------")
# 實例
# 計算年齡
import datetime
now = datetime.date.today()
birthday = datetime.date(1989,8,16)
age = now - birthday
print(age.days/365)
print("------------7-------------")

ramdom模塊

提供了生成隨機數的功能

import random
#返回一個隨機浮點數：
print(random.random())  #用於隨機生成一個0到1的符點數: 0 <= n < 1.0
print(random.uniform(1,10))   #用於隨機生成一個指定範圍內的符點數
#返回一個隨機整數：
print(random.randint(1,10))  #用於隨機生成一個指定範圍內的整數 a <= n <= b，其中參數a是下限，參數b是上限
print(random.randrange(1,10)) #從指定範圍內range([start], stop[, step])，按指定步長遞增的列表中，隨機獲取一個整數。
print(random.randrange(1, 100, 5))
#返回一個隨機字符
print(random.choice('zhenxingzhonghua')) #從序列sequence中獲取一個隨機元素。序列有字符串、列表、元組等
print(random.choice("學習Python"))
#返回一個隨機字符串
print(random.choice(["JGood","is","a","handsome","boy"])) #從序列sequence中獲取一個隨機元素。
print(random.choice(("zhangsan","lisi","wangwu")))
#返回一個指定數量的隨機字符的列表
print(random.sample([1,2,3,4,5],3))  #從指定序列sequence中隨機獲取指定數量k的片斷列表。sample函數不會修改原有序列。
print(random.sample("xinzhong",5))
#洗牌
items = [1,2,3,4,5,6,7]
print(items)
random.shuffle(items)
print(items)
print("----------------------------")
#輸出
0.1516067281469653
8.132218238196891
2
3
21
u
n
a
zhangsan
[3, 2, 4]
['x', 'h', 'n', 'i', 'n']
[1, 2, 3, 4, 5, 6, 7]
[3, 2, 7, 4, 6, 1, 5]
----------------------------

實例：

import random
#隨機生成一個0到100間的偶數：
print(random.randrange(0, 100, 2))
#生成隨機驗證碼：
checkcode = ''
for i in range(4):
    current = random.randrange(0,4)
    if current != i:
        temp = chr(random.randint(65,90))
    else:
        temp = random.randint(0,9)
    checkcode += str(temp)
print (checkcode)
print("----------------------------")
#輸出
20
84YW
----------------------------

os模塊

提供了不少與操作系統相關聯的函數。
提供了非常豐富的方法用來處理文件和目錄。

補充：表示路徑path的方式（window平臺下）

#相對路徑
os.屬性("test\\test1\\test2")
os.屬性(r"test\test1\test2")
os.屬性("test/test1/test2")
os.屬性("./test/test1/test2")
#絕對路徑
os.屬性("E:\\test")
os.屬性(r"E:\test")
os.屬性("E:/test")
os.屬性(".")   #屬於什麼路徑？
os.屬性("..")

方法實例：

import os
#獲取當前程序的工作目錄
p = os.getcwd() #獲取當前工作目錄，即當前python腳本執行的目錄路徑；相當於shell下pwd
print(p)
p = os.curdir  #以字符串"."的形式獲取當前工作目錄
print(p)
p = os.pardir  #以字符串".."的形式獲取當前工作目錄的父目錄
print(p)
print(os.getcwd())
#更改當前程序的工作目錄
os.chdir("E:/test")   #改變當前腳本工作目錄爲E:\test；相當於shell下cd
print(os.getcwd())
print("-------------1---------------")
#創建目錄
os.makedirs('dirname1/dirname2')    #創建多級目錄。當前工作目錄下創建多層遞歸目錄；若文件已存在時，則無法創建文件
#os.makedirs("d:/test/a/b/c/d")    #指定目錄“d:/test”下創建多層遞歸目錄；若文件已存在時，則無法創建文件
os.mkdir('dirname3')    #創建單級目錄；當前工作目錄下創建一層目錄；相當於shell中mkdir dirname
#os.mkdir("d:/test/a1")  #指定目錄("d:/test/")下生成單級目錄；
#刪除空目錄
os.removedirs('dirname1/dirname2')    #刪除多級目錄。若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推；目錄不是空的刪除會報錯
os.rmdir('dirname3')    #刪除單級空目錄，若目錄不爲空則無法刪除；目錄不是空的刪除會報錯；相當於shell中rmdir dirname
#列表方式獲取目錄下的所有文檔
l = os.listdir()    #列出當前工作目錄的所有文件和子目錄，包括隱藏文件，並以列表方式打印
print(l)
l = os.listdir(".")
print(l)
l = os.listdir("./abc")
print(l)
l = os.listdir("..")
print(l)
l = os.listdir("d:/test")   #列出指定目錄下的所有文件和子目錄，包括隱藏文件，並以列表方式打印
print(l)
#刪除文件
os.remove("E:/test/a.txt")  #刪除指定路徑下的一個文件，文件不存在會報錯
#重命名文件/目錄
os.rename("oldname","newname")  #重命名指定路徑下的目錄；這裏爲當前路徑；文件不存在會報錯
os.rename("oldname.txt","newname.txt")  #重命名指定路徑下的文件；這裏爲當前路徑；文件不存在會報錯
print("-------------2---------------")
#獲取文件或目錄信息
s = os.stat('newname')  #獲取文件/目錄信息，創建日期、修改日期等；文件不存在會報錯
print(s)
#獲取分隔符
s = os.sep    #輸出操作系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
print(s)
l = os.linesep    #輸出當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
print(l)
p = os.pathsep    #輸出用於分割文件路徑的字符串；看系統環境變量os.environ #PATH
print(p)
#查看當前使用系統平臺
n = os.name    #輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
print(n)
#運行當前使用系統平臺的命令
#os.system("bash command")  #運行shell命令，直接顯示
os.system("dir")
s = os.system("ipconfig /all")
print(s)
#獲取系統環境變量
e = os.environ  #獲取系統環境變量
print(e)
print("-------------3---------------")
#獲取路徑（獲取目錄、文件名）   #os.chdir("E:/test")改變工作目錄後，terminal和pycharm的執行結果有差異？？？？？？？？？
#不要求路徑存在；路徑（文件或目錄）不存在不會報錯，正常執行
p = os.path.abspath("bbbbb")  #返回指定path的規範化的絕對路徑
print(p)
print(__file__)   #返回當前程序的相對路徑
p = os.path.abspath(__file__)  #返回當前程序的絕對路徑
print(p)
s = os.path.split(__file__)  #將當前路徑分割成兩段，以二元組形式返回（"路徑/目錄","目錄名/文件名"）
print(s)
s = os.path.split(os.path.abspath(__file__))  #將路徑path分割成兩段，以二元組形式返回（"路徑/目錄","目錄名/文件名"）
print(s)
s = os.path.split("")  #將路徑path分割成兩段，以二元組形式返回（"",""），這裏兩個都是空
print(s)
s = os.path.split("d:/abc/abc/ttt.txt")  #將路徑path分割成兩段，以二元組形式返回（"路徑/目錄","目錄名/文件名"）
print(s)
s = os.path.split("d:/abc/abc")  #將路徑path分割成兩段，以二元組形式返回（"路徑/目錄","目錄名/文件名"）
print(s)
dp = os.path.dirname("d:/abc/abc")  #返回路徑path的目錄。其實就是os.path.split(path)的第一個元素
print(dp)
bp = os.path.basename("d:/abc/abc")  #返回路徑path最後的文件名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素
print(bp)
#身份判斷
print(os.path.exists("d:/test"))  #如果路徑path存在，返回True；如果path不存在，返回False
print(os.path.isabs("d:/test"))  #如果路徑path是絕對路徑，返回True
print(os.path.isfile(r"E:\test\abc\abc.txt"))  #如果路徑path是一個存在的文件，返回True。否則返回False
print(os.path.isdir("d:/test"))  #如果路徑path是一個存在的目錄，則返回True。否則返回False
#組合路徑
# os.path.join(path1[, path2[, ...]])  #將多個路徑組合後返回，第一個絕對路徑之前的參數將被忽略
p = os.path.join(r"E:\test",r"abcaa",r"aaaabc.txt")
print(p)
#獲取文件或者目錄的最後存取、修改時間
print(os.path.getatime(r"E:\test\abc\abc.txt"))  #返回路徑path所指向的文件或者目錄的最後存取時間
print(os.path.getmtime(r"E:\test\abc"))  #返回路徑path所指向的文件或者目錄的最後修改時間

sys模塊

sys

import sys
a = sys.argv   #包含命令行參數的列表，第一個元素是程序本身路徑（絕對或相對），
print(a[0])
print(a[1])
print(a[2])
print(type(a))
print(a)
print(sys.version)   #獲取Python解釋程序的版本信息
# sys.maxint         #最大的Int值 ？？？？？
print(sys.path)   #包含了一個提供給Python解釋器自動查找所需模塊的路徑的列表，初始化時使用PYTHONPATH環境變量的值
print(sys.platform)       #返回操作系統平臺名稱
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]                       # ？？？？？？？？？？
sys.exit(1)        #退出程序，正常退出時exit(0)            ？？？？？？？？？

shutil模塊

高級的文件、文件夾、壓縮包處理模塊

import shutil
# copyfileobj(fsrc, fdst[, length])
# 將文件內容拷貝到另一個文件中
# 可以拷貝部分內容；當fdst不存在時，會自動創建
f1 = open("歌詞1","rb")
f2 = open("歌詞2","wb")
shutil.copyfileobj(f1,f2)
# 或
f1 = open("歌詞1","r",encoding="utf-8")
f2 = open("歌詞2","w",encoding="utf-8")
shutil.copyfileobj(f1,f2)
# copyfile(src, dst)
# 拷貝文件
# src要存在
shutil.copyfile("歌詞1","歌詞3")
# copymode(src, dst)
# 僅拷貝權限
# 內容、組、用戶均不變
# 去linux系統平臺驗證
# copystat(src, dst)
# 拷貝部分狀態信息
# 包括：mode bits, atime, mtime, flags等
#要求src, dst都存在
# 去linux系統平臺驗證權限變化
shutil.copystat("歌詞1", r"E:\test\abc\abc.txt")
# copy(src, dst)
# 拷貝文件和權限
# copy2(src, dst)
# 拷貝文件和狀態信息
# ignore_patterns(*patterns)    ？？？？
# copytree(src, dst, symlinks=False, ignore=None)
# 遞歸的去拷貝目錄/文件
# 例如：copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*'))
shutil.copytree("test","test_copy")
# rmtree(path[, ignore_errors[, onerror]])
# 遞歸的去刪除目錄/文件
# 要求src要存在
shutil.rmtree("test_copy")
# move(src, dst)
# 遞歸的去移動文件/目錄
# 要求src要存在
shutil.move("test2.zip","package_test")   #移動文件或目錄到其他目錄
shutil.move("testtest","testtest2")   #重命名文件/目錄
shutil.move("make_archive_test2.zip","package_test\make_archive_test5.txt")   #移動並重命名
# make_archive(base_name, format,...)
# 創建壓縮包，並返回文件路徑
# base_name： 壓縮包的文件名，也可以是壓縮包的路徑。只是文件名時，則保存至當前目錄，否則保存至指定路徑，
# 如：www                        =>保存至當前路徑
# 如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
# format： 壓縮包種類，“zip”, “tar”, “bztar”，“gztar”
# root_dir： 要壓縮的文件夾路徑（默認當前目錄）
# owner： 用戶，默認當前用戶
# group： 組，默認當前組
# logger： 用於記錄日誌，通常是logging.Logger對象
# shutil 對壓縮包的處理是調用 ZipFile 和 TarFile 兩個模塊來進行的
# 可以使用ZipFile 和 TarFile 兩個模塊將文檔單獨加入到已有的壓縮文件中去
shutil.make_archive("make_archive_test2","zip","test")   #將當前目錄下的文檔壓縮到當前目錄
a = shutil.make_archive("./test/make_archive_test","zip",r"e:\test")
print(a)   #返回壓縮文檔的路徑

python3 基礎（5）-模塊（1）-模塊的導入、標準模塊（標準庫）

pycharm的一些快捷鍵

使用zabbix過程中遇到的問題記錄

python3 基礎（5）-模塊（1）-模塊的導入、標準模塊（標準庫）

windows平臺使用SecureCRT+Xming實現圖形界面來執行linux平臺的一些圖形程序

執行mysqldump備份數據時報錯

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結