day21 模塊學習（time時間模塊）

模塊（module）的概念：

Python中，一個.py文件就稱之爲一個模塊（Module）。另外，使用模塊還能夠避免函數名和變量名衝突。相同名字的函數和變量徹底能夠分別存在不一樣的模塊中，所以，咱們本身在編寫模塊時，沒必要考慮名字會與其餘模塊衝突。可是也要注意，儘可能不要與內置函數名字衝突。

模塊分三種：

　　一、python標準庫

　　二、第三方模塊

　　三、應用程序自定義模塊

 

模塊的導入方法：

一、import語句

import module1[, module2[,... moduleN]

二、from ... import 語句

from modname import name1[, name2[, ... nameN]]

三、from ... import * 語句

from modname import *

四、運行本質

#1 import test
#2 from test import add　

　　

包(package)

if __name__=='__main__':
    print('ok')

若是咱們是直接執行某個.py文件的時候，該文件中那麼」__name__ == '__main__'「是True,可是咱們若是從另一個.py文件經過import導入該文件的時候，這時__name__的值就是咱們這個py文件的名字而不是__main__。

這個功能還有一個用處：調試代碼的時候，在」if __name__ == '__main__'「中加入一些咱們的調試代碼，咱們可讓外部模塊調用的時候不執行咱們的調試代碼，可是若是咱們想排查問題的時候，直接執行該模塊文件，調試代碼可以正常運行

 

time模塊：

三種時間表達式：

   1.時間戳：time.time（）    #作計算用
   2.結構化時間：time.localtime() #當地時間  time.gmtime()  #UTC標準時間
   3.字符串時間：

import time
 
# 1 time() :返回當前時間的時間戳
time.time()  #1473525444.037215
 
#----------------------------------------------------------
 
# 2 localtime([secs])
# 將一個時間戳轉換爲當前時區的struct_time結構化時間。secs參數未提供，則以當前時間爲準。
time.localtime() #time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0,
# tm_min=38, tm_sec=39, tm_wday=6, tm_yday=255, tm_isdst=0)
time.localtime(1473525444.037215)
 
#----------------------------------------------------------
 
# 3 gmtime([secs]) 和localtime()方法相似，gmtime()方法是將一個時間戳轉換爲UTC時區（0時區）的struct_time。
 
#----------------------------------------------------------
 
# 4 mktime(t) : 將一個struct_time轉化爲時間戳。
print(time.mktime(time.localtime()))#1473525749.0
 
#----------------------------------------------------------
 
# 5 asctime([t]) : 把一個表示時間的元組或者struct_time表示爲這種形式：'Sun Jun 20 23:21:05 1993'。
# 若是沒有參數，將會將time.localtime()做爲參數傳入。
print(time.asctime())#Sun Sep 11 00:43:43 2016
 
#----------------------------------------------------------
 
# 6 ctime([secs]) : 把一個時間戳（按秒計算的浮點數）轉化爲time.asctime()的形式。若是參數未給或者爲None的時候，將會默認time.time()爲參數。它的做用至關於time.asctime(time.localtime(secs))。
print(time.ctime())  # Sun Sep 11 00:46:38 2016
 
print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016
 
# 7 strftime(format[, t]) : 把一個表明時間的元組或者struct_time（如由time.localtime()和time.gmtime()返回）轉化爲格式化的時間字符串。若是t未指定，將傳入time.localtime()。若是元組中任何一個元素越界，ValueError的錯誤將會被拋出。
print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56
 
# 8 time.strptime(string[, format])
# 把一個格式化時間字符串轉化爲struct_time。實際上它和strftime()是逆操做。
print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))
 
#time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,
#  tm_wday=3, tm_yday=125, tm_isdst=-1)
 
#在這個函數中，format默認爲："%a %b %d %H:%M:%S %Y"。
 
 
# 9 sleep(secs)
# 線程推遲指定的時間運行，單位爲秒。
 
# 10 clock()
# 這個須要注意，在不一樣的系統上含義不一樣。在UNIX系統上，它返回的是「進程時間」，它是用秒錶示的浮點數（時間戳）。
# 而在WINDOWS中，第一次調用，返回的是進程運行的實際時間。而第二次以後的調用是自第一次調用之後到如今的運行
# 時間，即兩次時間差。

 

　　

 

 

 

 random模塊：

import random # 隨機模塊 
random.random()         # 0-1的浮點數 
random.randint(1,3)     # 提供整數的取值範圍，取值範圍1-3 
random.randrange(1,3)   # 提供整數的取值範圍，取值範圍1-2  左取右不取 
random.choice([1,'23',[4,5]])   #隨機選取可迭代對象的取值 
random.sample([1,2,3,4,5],2)    #隨機提取列表中的2個元素 
random.uniform(1,3)     #取任意範圍的浮點數   取1-3的浮點數 
random.shuffle(l)       #將列表序列打亂了   l = [1,2,3,4,5]

例子：（隨機驗證碼邏輯）

import random
def v_code():
    ret = ""
    for i in range(4):
        num = random.randint(0,9)
        alf = chr(random.randint(65,90))
        s = str(random.choice([num,alf]))
        ret += s
    return ret
print(v_code())

 

　OS模塊：

os.getcwd() 獲取當前工做目錄，即當前python腳本工做的目錄路徑
os.chdir("dirname")  改變當前腳本工做目錄；至關於shell下cd xxx
os.chdir("..")    改變當前腳本的工做目錄；至關於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下爲"\r\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所指向的文件或者目錄的最後修改時間

 

sys模塊：

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

 

進度條寫法：
import sys,time
for i in range(10):
    sys.stdout.write('#')
    time.sleep(1)
    sys.stdout.flush()     #刷新

 

 json模塊：（經常使用json，pickle 模塊和json模塊相似，處理功能更強，eval方法有侷限性；）

import json

json.dumps    #將 Python 對象編碼成 JSON 字符串  （json.dump）
json.loads      #將已編碼的 JSON 字符串解碼爲 Python 對象   （json.load）

# ----------------------------序列化
import json

dic = {'name': 'alvin', 'age': 23, 'sex': 'male'}
print(type(dic))      # <class 'dict'>

j = json.dumps(dic)
print(type(j))      # <class 'str'>

with open('test', 'w') as f:
    f.write(j)      # -------------------等價於json.dump(dic,f)
#-----------------------------反序列化<br>
import json

with open('test','r') as f:
    data = json.loads(f.read())      # 等價於data=json.load(f)

 

pickle模塊：

 

##----------------------------序列化
import pickle
 
dic={'name':'alvin','age':23,'sex':'male'}
 
print(type(dic))#<class 'dict'>
 
j=pickle.dumps(dic)
print(type(j))#<class 'bytes'>
 
 
f=open('序列化對象_pickle','wb')#注意是w是寫入str,wb是寫入bytes,j是'bytes'
f.write(j)  #-------------------等價於pickle.dump(dic,f)
 
f.close()
#-------------------------反序列化
import pickle
f=open('序列化對象_pickle','rb')
 
data=pickle.loads(f.read())#  等價於data=pickle.load(f)
 
 
print(data['age']) 

 

shelve模塊：

import shelve
 
f = shelve.open(r'shelve')    #將字典寫入
 
f['stu1_info']={'name':'alex','age':'18'}
f['stu2_info']={'name':'alvin','age':'20'}
f['school_info']={'website':'oldboyedu.com','city':'beijing'}

f.close()      
 
print(f.get('stu1_info')['age'])    #提取字典中對應的值

#shelve模塊和pickle模塊相似，只是寫法簡單

 

 xml模塊：

xml是實現不一樣語言或程序之間進行數據交換的協議，跟json差很少，但json使用起來更簡單

#源文件：
<?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>

# 使用方法：
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)
    for i in child:
        print(i.tag,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")
 
tree.write("xmltest.xml")
 
 
#刪除node
for country in root.findall('country'):
   rank = int(country.find('rank').text)
   if rank > 50:
     root.remove(country)
 
tree.write('output.xml')

#建立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) #打印生成的格式

 

re模塊：

1 普通字符：大多數字符和字母都會和自身匹配
              >>> re.findall('alvin','yuanaleSxalexwupeiqi')
                      ['alvin'] 

2 元字符：. ^ $ * + ? { } [ ] | ( ) \

元字符之. ^ $ * + ? { }

 模塊用法：

import re 
re.findall()   #在字符串中找到正則表達式所匹配的全部子串，並返回一個列表，若是沒有找到匹配的，則返回空列表。
re.search()  #掃描整個字符串並返回第一個成功的匹配。
re.match()   #嘗試從字符串的起始位置匹配一個模式，若是不是起始位置匹配成功的話，match()就返回none。
re.compile()   #函數用於編譯正則表達式，生成一個正則表達式（ Pattern ）對象，供 match() 和 search() 這兩個函數使用。
re.finditer()    #和 findall 相似，在字符串中找到正則表達式所匹配的全部子串，並把它們做爲一個迭代器返回。
re.split()     #方法按照可以匹配的子串將字符串分割後返回列表.
  

正則表達式模式：

模式	描述
^	匹配字符串的開頭
$	匹配字符串的末尾。
.	匹配任意字符，除了換行符，當re.DOTALL標記被指定時，則能夠匹配包括換行符的任意字符。
[...]	用來表示一組字符,單獨列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c以外的字符。
re*	匹配0個或多個的表達式。
re+	匹配1個或多個的表達式。
re?	匹配0個或1個由前面的正則表達式定義的片斷，非貪婪方式
re{ n}	精確匹配 n 個前面表達式。例如， o{2} 不能匹配 "Bob" 中的 "o"，可是能匹配 "food" 中的兩個 o。
re{ n,}	匹配 n 個前面表達式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的全部 o。"o{1,}" 等價於 "o+"。"o{0,}" 則等價於 "o*"。
re{ n, m}	匹配 n 到 m 次由前面的正則表達式定義的片斷，貪婪方式
a| b	匹配a或b
(re)	對正則表達式分組並記住匹配的文本
(?imx)	正則表達式包含三種可選標誌：i, m, 或 x 。隻影響括號中的區域。
(?-imx)	正則表達式關閉 i, m, 或 x 可選標誌。隻影響括號中的區域。
(?: re)	相似 (...), 可是不表示一個組
(?imx: re)	在括號中使用i, m, 或 x 可選標誌
(?-imx: re)	在括號中不使用i, m, 或 x 可選標誌
(?#...)	註釋.
(?= re)	前向確定界定符。若是所含正則表達式，以 ... 表示，在當前位置成功匹配時成功，不然失敗。但一旦所含表達式已經嘗試，匹配引擎根本沒有提升；模式的剩餘部分還要嘗試界定符的右邊。
(?! re)	前向否認界定符。與確定界定符相反；當所含表達式不能在字符串當前位置匹配時成功
(?> re)	匹配的獨立模式，省去回溯。
\w	匹配字母數字及下劃線
\W	匹配非字母數字及下劃線
\s	匹配任意空白字符，等價於 [\t\n\r\f].
\S	匹配任意非空字符
\d	匹配任意數字，等價於 [0-9].
\D	匹配任意非數字
\A	匹配字符串開始
\Z	匹配字符串結束，若是是存在換行，只匹配到換行前的結束字符串。
\z	匹配字符串結束
\G	匹配最後匹配完成的位置。
\b	匹配一個單詞邊界，也就是指單詞和空格間的位置。例如， 'er\b' 能夠匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非單詞邊界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等.	匹配一個換行符。匹配一個製表符。等
\1...\9	匹配第n個分組的內容。
\10	匹配第n個分組的內容，若是它經匹配。不然指的是八進制字符碼的表達式。