day5

一 time與datetime模塊

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

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

 

import time,datetime
print(time.timezone)#時區
-28800

print(time.time())#s時間戳
1535028192.293821

print(time.gmtime())#utc時間structtime
time.struct_time(tm_year=2018, tm_mon=8, tm_mday=23, tm_hour=12, tm_min=43, tm_sec=12, tm_wday=3, tm_yday=235, tm_isdst=0)

print(time.localtime())#tuple當前時間structtime
time.struct_time(tm_year=2018, tm_mon=8, tm_mday=23, tm_hour=20, tm_min=43, tm_sec=12, tm_wday=3, tm_yday=235, tm_isdst=0)


# print(time.struct_time)
print(time.localtime(12312312321))#localtime將時間戳轉成結構化的時間
time.struct_time(tm_year=2360, tm_mon=2, tm_mday=29, tm_hour=22, tm_min=45, tm_sec=21, tm_wday=0, tm_yday=60, tm_isdst=0)


x=time.localtime()
print(x.tm_year)
2018

print(time.mktime(time.localtime()))#將結構化的時間轉成時間戳
1535028192.0



print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()))#struct_time轉成字符串
print(time.strptime("2018-09-11 12:00:06","%Y-%m-%d %H:%M:%S"))#字符串轉成struct_time
print(datetime.datetime.now()+datetime.timedelta(5))
2018-08-28 20:43:12.343821

其中計算機認識的時間只能是'時間戳'格式，而程序員可處理的或者說人類能看懂的時間有: '格式化的時間字符串'，'結構化的時間' ，因而有了下圖的轉換關係

 1 #--------------------------按圖1轉換時間  2 # localtime([secs])  3 # 將一個時間戳轉換爲當前時區的struct_time。secs參數未提供，則以當前時間爲準。  4 time.localtime()  5 time.localtime(1473525444.037215)  6  7 # gmtime([secs]) 和localtime()方法相似，gmtime()方法是將一個時間戳轉換爲UTC時區（0時區）的struct_time。  8  9 # mktime(t) : 將一個struct_time轉化爲時間戳。 10 print(time.mktime(time.localtime()))#1473525749.0 11 12 13 # strftime(format[, t]) : 把一個表明時間的元組或者struct_time（如由time.localtime()和 14 # time.gmtime()返回）轉化爲格式化的時間字符串。若是t未指定，將傳入time.localtime()。若是元組中任何一個 15 # 元素越界，ValueError的錯誤將會被拋出。 16 print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56 17 18 # time.strptime(string[, format]) 19 # 把一個格式化時間字符串轉化爲struct_time。實際上它和strftime()是逆操做。 20 print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')) 21 #time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6, 22 # tm_wday=3, tm_yday=125, tm_isdst=-1) 23 #在這個函數中，format默認爲："%a %b %d %H:%M:%S %Y"。

二 random模塊

1 import random  2  3 print(random.random())#(0,1)----float 大於0且小於1之間的小數  4  5 print(random.randint(1,3)) #[1,3] 大於等於1且小於等於3之間的整數  6  7 print(random.randrange(1,3)) #[1,3) 大於等於1且小於3之間的整數  8  9 print(random.choice([1,'23',[4,5]]))#1或者23或者[4,5] 10 11 print(random.sample([1,'23',[4,5]],2))#列表元素任意2個組合 12 13 print(random.uniform(1,3))#大於1小於3的小數，如1.927109612082716 14 15 16 item=[1,3,5,7,9] 17 random.shuffle(item) #打亂item的順序,至關於"洗牌" 18 print(item)


生成隨機驗證碼的

import random
random_str = ''
for i in range(4):
 current = random.randint(0,4)
 if current != i:
 temp = random.randint(0,9)
 else:
 temp = chr(random.randint(65,90))
 random_str+=str(temp)

print(random_str)

print(random.randrange(0,100,2))


a = []
b = []
for i in range(65,90):
 a.append(chr(i))
for i in range(9):
 b.append(i)

c=a+b
random_str2 = ''
for i in range(4):
 temp = random.choice(c)
 random_str2 += str(temp)

print(random_str2)

三 os模塊

 

在Linux和Mac平臺上，該函數會原樣返回path，在windows平臺上會將路徑中全部字符轉換爲小寫，並將全部斜槓轉換爲飯斜槓。
>>> os.path.normcase('c:/windows\\system32\\') 'c:\\windows\\system32\\' 規範化路徑，如..和/ >>> os.path.normpath('c://windows\\System32\\../Temp/') 'c:\\windows\\Temp' >>> a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..' >>> print(os.path.normpath(a)) /Users/jieli/test1

print(os.getcwd())#獲取當前的操做目錄
os.chdir('C:\\Users')#\\第一個\用來轉義第二個\
print(os.getcwd())#獲取當前的操做目錄

os.chdir(r'C:\Users\Administrator')#在字符串前加r裏面的\不須要轉義
print(os.getcwd())#獲取當前的操做目錄

print(os.curdir)#返回當前目錄

print(os.pardir)#返回父級目錄

os.makedirs(r'C:\a\b\c')#遞歸建立目錄

os.removedirs(r'C:\a\b\c')#刪除空目錄，並返回上一級目錄，若爲空，則刪除

os.mkdir(r'd:\a')
os.mkdir(r'd:\a\b')

os.rmdir(r'd:\a\b')
os.rmdir(r'd:\a')

print(os.listdir(os.curdir))
print(os.listdir(os.pardir))

#os.remove('file')刪除一個文件
#os.rename('old','new')

print(os.stat(r'.'))#獲取文件/目錄信息

print(os.sep)#輸出系統特定的路徑分隔符
print(os.linesep)#輸出當前系統的行終止符
print(os.pathsep)#輸出分割文件路徑的字符串

print(os.environ)
print(os.name)
print(os.system('ipconfig'))
print(os.path.abspath(__file__))#返回絕對路徑
print(os.path.split(__file__))#返回元組 吧目錄和文件分割
print(os.path.dirname(r'c:\a\b\c.txt'))#返回目錄c:\a\b
print(os.path.basename(r'c:\c\a\a\a.txt'))#返回文件
print(os.path.exists(r'c:\a'))#判斷路徑是否存在
print(os.path.isabs(r'a\a\a'))#判斷括號中的路徑是否從根開始
print(os.path.isfile(r'C:\InstallConfig.ini'))
print(os.path.join(r'c:',r'\a',r'\a.txt'))
print(os.path.getatime(r'C:\InstallConfig.ini'))#獲取他的存取時間
print(os.path.getmtime(r'C:\InstallConfig.ini'))#獲取他的修改時間

os路徑處理
#方式一：推薦使用 import os #具體應用 import os,sys possible_topdir = os.path.normpath(os.path.join( os.path.abspath(__file__), os.pardir, #上一級  os.pardir, os.pardir )) sys.path.insert(0,possible_topdir) #方式二：不推薦使用 os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

四 sys模塊

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

import sys,time

# for i in range(1):
# sys.stdout.write('*')
# time.sleep(0.5)

#sys.argv獲取輸入的參數,第一個元素是程序名自己，而後參數，並返回列表
print(sys.argv)

五 shutil模塊

 

import shutil

#shutil.copyfile('new','new2')

# shutil.copymode()#只copy權限
# shutil.copystat()#全部屬性都copy

# shutil.copytree('test','new_test')#copy目錄
#shutil.rmtree('test')#比os.system('remove')快，由於是直接調用python去刪目錄的

#shutil.make_archive('archive','zip',r'C:\Users\Administrator\PycharmProjects\restart\day2')#壓縮路徑不要包含本身，不然會多循環一次

import zipfile

#z = zipfile.ZipFile('day5.zip','w')

#z.write('p_test.py')

unz = zipfile.ZipFile('day5.zip','r')
unz.extractall()
unz.close()

六 json&pickle模塊

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

 

什麼是序列化？

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

爲何要序列化？

1：持久保存狀態

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

內存是沒法永久保存數據的，當程序運行了一段時間，咱們斷電或者重啓程序，內存中關於這個程序的以前一段時間的數據（有結構）都被清空了。

在斷電或重啓程序以前將程序當前內存中全部的數據都保存下來（保存到文件中），以便於下次程序執行可以從文件中載入以前的數據，而後繼續執行，這就是序列化。

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

2：跨平臺數據交互

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

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

如何序列化之json和pickle：

json

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

JSON表示的對象就是標準的JavaScript語言的對象，JSON和Python內置的數據類型對應以下：

pickle

a = {'shanghai':'baoshan',
 "beijing":"chaoyang"}
#
# with open('test.txt','w') as f:
# f.write(str(a))
#
# with open('test.txt','r') as f2:
# data = f2.read()
# print(type(data))
# data = eval(data)
# print(type(data))
# print(data['shanghai'])
# import json#json 只能處理簡單的數據，字典，列表，字符串
# with open('test.txt','w') as f:
# f.write(json.dumps(a))#dumps 序列化
#
# with open('test.txt','r') as f2:
# data = json.load(f2)
# print(data['shanghai']) #load 反序列化
import pickle
def sayhi():
 print('hello')
a = {'a':'b','c':'c','func':sayhi}

with open('test.txt','wb') as f:#pickle會把內容變成二進制,直接傳入句柄
 f.write(pickle.dumps(a))#pickle.dump(f)
with open('test.txt','rb') as f2:
 data = pickle.loads(f2.read())#pickle.load(f2)
 print(data['func']())

八 xml模塊

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

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

 

import xml.etree.ElementTree as ET

tree = ET.parse("xml_test.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.attrib)

# # 只遍歷year 節點
# for node in root.iter('year'):
# print(node.tag, node.text)

# import xml.etree.ElementTree as ET
#
# tree = ET.parse('xml_test.xml')
# root = tree.getroot()
# print(root.tag)
#
# for child in root:
# print(child.tag)
# for i in child:
# print(i.tag)
#
# for year in root.iter('year'):
# print(year.tag,year.text)
#
# for node in root.iter('year'):
# print(node.text)
# #new_year = int(node.text) + 1
# node.text = str('2020')
# node.set
# tree.write("xml_test.xml")

# for country in root.findall('country'):
# rank = int(country.find('rank').text)
# if rank > 50:
# root.remove(country)
#
# tree.write('output.xml')

import xml.etree.ElementTree as ET

new_xml=ET.Element('namelist')
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(new_xml,"age",attrib={'checked':'no'})
age.text='25'
et = ET.ElementTree(new_xml)
et.write('test.xml',encoding='utf-8',xml_declaration=True)

十 hashlib模塊

一、什麼叫hash:hash是一種算法（3.x裏代替了md5模塊和sha模塊，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法），該算法接受傳入的內容，通過運算獲得一串hash值 # 二、hash值的特色是： #2.1 只要傳入的內容同樣，獲得的hash值必然同樣=====>要用明文傳輸密碼文件完整性校驗 #2.2 不能由hash值返解成內容=======》把密碼作成hash值，不該該在網絡傳輸明文密碼 #2.3 只要使用的hash算法不變，不管校驗的內容有多大，獲得的hash值長度是固定的

 

 hash算法就像一座工廠，工廠接收你送來的原材料（能夠用m.update()爲工廠運送原材料），通過加工返回的產品就是hash值

import hashlib
m = hashlib.md5()
m.update(b'hello')
print(m.hexdigest())

s2 = hashlib.sha3_256()
s2.update('hello戎輝'.encode('utf-8'))
print(s2.digest())
在加密算法中添加key，防止撞庫
hash = hashlib.sha3_256('abc'.encode('utf8'))
hash2 = hashlib.sha3_256()
hash.update('ronghui'.encode('utf8'))
hash2.update('ronghui'.encode('utf8'))
print(hash.hexdigest())
print(hash2.hexdigest())

十二 logging模塊

 

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

========使用
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 part2: 能夠爲logging模塊指定模塊級的配置,即全部logger的配置

四 logging模塊的Formatter，Handler，Logger，Filter對象

#logger：產生日誌的對象 #一、logger對象：負責產生日誌，而後交給Filter過濾，而後交給不一樣的Handler輸出 logger=logging.getLogger(__file__)

 #Filter：過濾日誌的對象 #Handler：接收日誌而後控制打印到不一樣的地方，FileHandler用來打印到文件中，StreamHandler用來打印到終端 #Formatter對象：能夠定製不一樣的日誌格式對象，而後綁定給不一樣的Handler對象使用，以此來控制不一樣的Handler的日誌格式

formmater1=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S %p',) formmater2=logging.Formatter('%(asctime)s : %(message)s', datefmt='%Y-%m-%d %H:%M:%S %p',) formmater3=logging.Formatter('%(name)s %(message)s',)

#五、爲Handler對象綁定格式 h1.setFormatter(formmater1) h2.setFormatter(formmater2) h3.setFormatter(formmater3) #六、將Handler添加給logger並設置日誌級別 logger.addHandler(h1) logger.addHandler(h2) logger.addHandler(h3) logger.setLevel(10) #七、測試 logger.debug('debug') logger.info('info') logger.warning('warning') logger.error('error') logger.critical('critical')

# 定義三種日誌輸出格式 開始  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 = 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()

十三 re模塊

一：什麼是正則？

　正則就是用一些具備特殊含義的符號組合到一塊兒（稱爲正則表達式）來描述字符或者字符串的方法。或者說：正則就是用來描述一類事物的規則。（在Python中）它內嵌在Python中，並經過 re 模塊實現。正則表達式模式被編譯成一系列的字節碼，而後由用 C 編寫的匹配引擎執行。

 

二：經常使用匹配模式(元字符)

http://blog.csdn.net/yufenghyc/article/details/51078107

 

# =================================匹配模式================================= #一對一的匹配 # 'hello'.replace(old,new) # 'hello'.find('pattern') #正則匹配 import re #\w與\W print(re.findall('\w','hello egon 123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3'] print(re.findall('\W','hello egon 123')) #[' ', ' '] #\s與\S print(re.findall('\s','hello egon 123')) #[' ', ' ', ' ', ' '] print(re.findall('\S','hello egon 123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3'] #\n \t都是空,均可以被\s匹配 print(re.findall('\s','hello \n egon \t 123')) #[' ', '\n', ' ', ' ', '\t', ' '] #\n與\t print(re.findall(r'\n','hello egon \n123')) #['\n'] print(re.findall(r'\t','hello egon\t123')) #['\n'] #\d與\D print(re.findall('\d','hello egon 123')) #['1', '2', '3'] print(re.findall('\D','hello egon 123')) #['h', 'e', 'l', 'l', 'o', ' ', 'e', 'g', 'o', 'n', ' '] #\A與\Z print(re.findall('\Ahe','hello egon 123')) #['he'],\A==>^ print(re.findall('123\Z','hello egon 123')) #['he'],\Z==>$ #^與$ print(re.findall('^h','hello egon 123')) #['h'] print(re.findall('3$','hello egon 123')) #['3'] # 重複匹配：| . | * | ? | .* | .*? | + | {n,m} | #. print(re.findall('a.b','a1b')) #['a1b'] print(re.findall('a.b','a1b a*b a b aaab')) #['a1b', 'a*b', 'a b', 'aab'] print(re.findall('a.b','a\nb')) #[] print(re.findall('a.b','a\nb',re.S)) #['a\nb'] print(re.findall('a.b','a\nb',re.DOTALL)) #['a\nb']同上一條意思同樣 #* print(re.findall('ab*','bbbbbbb')) #[] print(re.findall('ab*','a')) #['a'] print(re.findall('ab*','abbbb')) #['abbbb'] #? print(re.findall('ab?','a')) #['a'] print(re.findall('ab?','abbb')) #['ab'] #匹配全部包含小數在內的數字 print(re.findall('\d+\.?\d*',"asdfasdf123as1.13dfa12adsf1asdf3")) #['123', '1.13', '12', '1', '3'] #.*默認爲貪婪匹配 print(re.findall('a.*b','a1b22222222b')) #['a1b22222222b'] #.*?爲非貪婪匹配：推薦使用 print(re.findall('a.*?b','a1b22222222b')) #['a1b'] #+ print(re.findall('ab+','a')) #[] print(re.findall('ab+','abbb')) #['abbb'] #{n,m} print(re.findall('ab{2}','abbb')) #['abb'] print(re.findall('ab{2,4}','abbb')) #['abb'] print(re.findall('ab{1,}','abbb')) #'ab{1,}' ===> 'ab+' print(re.findall('ab{0,}','abbb')) #'ab{0,}' ===> 'ab*' #[] print(re.findall('a[1*-]b','a1b a*b a-b')) #[]內的都爲普通字符了，且若是-沒有被轉意的話，應該放到[]的開頭或結尾 print(re.findall('a[^1*-]b','a1b a*b a-b a=b')) #[]內的^表明的意思是取反，因此結果爲['a=b'] print(re.findall('a[0-9]b','a1b a*b a-b a=b')) #[]內的^表明的意思是取反，因此結果爲['a=b'] print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb')) #[]內的^表明的意思是取反，因此結果爲['a=b'] print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb')) #[]內的^表明的意思是取反，因此結果爲['a=b'] #\# print(re.findall('a\\c','a\c')) #對於正則來講a\\c確實能夠匹配到a\c,可是在python解釋器讀取a\\c時，會發生轉義，而後交給re去執行，因此拋出異常 print(re.findall(r'a\\c','a\c')) #r表明告訴解釋器使用rawstring，即原生字符串，把咱們正則內的全部符號都當普通字符處理，不要轉義 print(re.findall('a\\\\c','a\c')) #同上面的意思同樣，和上面的結果同樣都是['a\\c'] #():分組 print(re.findall('ab+','ababab123')) #['ab', 'ab', 'ab'] print(re.findall('(ab)+123','ababab123')) #['ab']，匹配到末尾的ab123中的ab print(re.findall('(?:ab)+123','ababab123')) #findall的結果不是匹配的所有內容，而是組內的內容,?:可讓結果爲匹配的所有內容 print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">點擊</a>'))#['http://www.baidu.com'] print(re.findall('href="(?:.*?)"','<a href="http://www.baidu.com">點擊</a>'))#['href="http://www.baidu.com"'] #| print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))

 

# ===========================re模塊提供的方法介紹=========================== import re #1 print(re.findall('e','alex make love') ) #['e', 'e', 'e'],返回全部知足匹配條件的結果,放在列表裏 #2 print(re.search('e','alex make love').group()) #e,只到找到第一個匹配而後返回一個包含匹配信息的對象,該對象能夠經過調用group()方法獲得匹配的字符串,若是字符串沒有匹配，則返回None。 #3 print(re.match('e','alex make love')) #None,同search,不過在字符串開始處進行匹配,徹底能夠用search+^代替match #4 print(re.split('[ab]','abcd')) #['', '', 'cd']，先按'a'分割獲得''和'bcd',再對''和'bcd'分別按'b'分割 #5 print('===>',re.sub('a','A','alex make love')) #===> Alex mAke love，不指定n，默認替換全部 print('===>',re.sub('a','A','alex make love',1)) #===> Alex make love print('===>',re.sub('a','A','alex make love',2)) #===> Alex mAke love print('===>',re.sub('^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$',r'\5\2\3\4\1','alex make love')) #===> love make alex print('===>',re.subn('a','A','alex make love')) #===> ('Alex mAke love', 2),結果帶有總共替換的個數 #6 obj=re.compile('\d{2}') print(obj.search('abc123eeee').group()) #12 print(obj.findall('abc123eeee')) #['12'],重用了obj

import re print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")) #['h1'] print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").group()) #<h1>hello</h1> print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").groupdict()) #<h1>hello</h1> print(re.search(r"<(\w+)>\w+</(\w+)>","<h1>hello</h1>").group()) print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>").group())

import re print(re.findall(r'-?\d+\.?\d*',"1-12*(60+(-40.35/5)-(-4*3))")) #找出全部數字['1', '-12', '60', '-40.35', '5', '-4', '3'] #使用|，先匹配的先生效，|左邊是匹配小數，而findall最終結果是查看分組，全部即便匹配成功小數也不會存入結果 #而不是小數時，就去匹配(-?\d+)，匹配到的天然就是，非小數的數，在此處即整數 print(re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")) #找出全部整數['1', '-2', '60', '', '5', '-4', '3']

#計算器做業參考：http://www.cnblogs.com/wupeiqi/articles/4949995.html expression='1-2*((60+2*(-3-40.0/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))' content=re.search('\(([\-\+\*\/]*\d+\.?\d*)+\)',expression).group() #(-3-40.0/5)

#爲什麼一樣的表達式search與findall卻有不一樣結果: print(re.search('\(([\+\-\*\/]*\d+\.?\d*)+\)',"1-12*(60+(-40.35/5)-(-4*3))").group()) #(-40.35/5) print(re.findall('\(([\+\-\*\/]*\d+\.?\d*)+\)',"1-12*(60+(-40.35/5)-(-4*3))")) #['/5', '*3'] #看這個例子:(\d)+至關於(\d)(\d)(\d)(\d)...,是一系列分組 print(re.search('(\d)+','123').group()) #group的做用是將全部組拼接到一塊兒顯示出來 print(re.findall('(\d)+','123')) #findall結果是組內的結果,且是最後一個組的結果

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' #在線調試工具:tool.oschina.net/regex/# import re s=''' http://www.baidu.com egon@oldboyedu.com 你好 010-3141 ''' #最常規匹配 # content='Hello 123 456 World_This is a Regex Demo' # res=re.match('Hello\s\d\d\d\s\d{3}\s\w{10}.*Demo',content) # print(res) # print(res.group()) # print(res.span()) #泛匹配 # content='Hello 123 456 World_This is a Regex Demo' # res=re.match('^Hello.*Demo',content) # print(res.group()) #匹配目標,得到指定數據 # content='Hello 123 456 World_This is a Regex Demo' # res=re.match('^Hello\s(\d+)\s(\d+)\s.*Demo',content) # print(res.group()) #取全部匹配的內容 # print(res.group(1)) #取匹配的第一個括號內的內容 # print(res.group(2)) #去陪陪的第二個括號內的內容 #貪婪匹配:.*表明匹配儘量多的字符 # import re # content='Hello 123 456 World_This is a Regex Demo' # # res=re.match('^He.*(\d+).*Demo$',content) # print(res.group(1)) #只打印6,由於.*會盡量多的匹配,而後後面跟至少一個數字 #非貪婪匹配:?匹配儘量少的字符 # import re # content='Hello 123 456 World_This is a Regex Demo' # # res=re.match('^He.*?(\d+).*Demo$',content) # print(res.group(1)) #只打印6,由於.*會盡量多的匹配,而後後面跟至少一個數字 #匹配模式:.不能匹配換行符 content='''Hello 123456 World_This is a Regex Demo ''' # res=re.match('He.*?(\d+).*?Demo$',content) # print(res) #輸出None # res=re.match('He.*?(\d+).*?Demo$',content,re.S) #re.S讓.能夠匹配換行符 # print(res) # print(res.group(1)) #轉義:\ # content='price is $5.00' # res=re.match('price is $5.00',content) # print(res) # # res=re.match('price is \$5\.00',content) # print(res) #總結:儘可能精簡,詳細的以下 # 儘可能使用泛匹配模式.* # 儘可能使用非貪婪模式:.*? # 使用括號獲得匹配目標:用group(n)去取得結果 # 有換行符就用re.S:修改模式 #re.search:會掃描整個字符串,不會從頭開始,找到第一個匹配的結果就會返回 # import re # content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings' # # res=re.match('Hello.*?(\d+).*?Demo',content) # print(res) #輸出結果爲None # # import re # content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings' # # res=re.search('Hello.*?(\d+).*?Demo',content) # # print(res.group(1)) #輸出結果爲 #re.search:只要一個結果,匹配演練, import re content=''' <tbody> <tr id="4766303201494371851675" class="even "><td><div class="hd"><span class="num">1</span><div class="rk "><span class="u-icn u-icn-75"></span></div></div></td><td class="rank"><div class="f-cb"><div class="tt"><a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&amp;quality=100"></a><span data-res-id="476630320" " # res=re.search('<a\shref=.*?<b\stitle="(.*?)".*?b>',content) # print(res.group(1)) #re.findall:找到符合條件的全部結果 # res=re.findall('<a\shref=.*?<b\stitle="(.*?)".*?b>',content) # for i in res: # print(i) #re.sub:字符串替換 import re content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings' # content=re.sub('\d+','',content) # print(content) #用\1取得第一個括號的內容 #用法:將123與456換位置 # import re # content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings' # # # content=re.sub('(Extra.*?)(\d+)(\s)(\d+)(.*?strings)',r'\1\4\3\2\5',content) # content=re.sub('(\d+)(\s)(\d+)',r'\3\2\1',content) # print(content) # import re # content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings' # # res=re.search('Extra.*?(\d+).*strings',content) # print(res.group(1)) # import requests,re # respone=requests.get('https://book.douban.com/').text # print(respone) # print('======'*1000) # print('======'*1000) # print('======'*1000) # print('======'*1000) # res=re.findall('<li.*?cover.*?href="(.*?)".*?title="(.*?)">.*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span.*?</li>',respone,re.S) # # res=re.findall('<li.*?cover.*?href="(.*?)".*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span>.*?</li>',respone,re.S) # # # for i in res: # print('%s %s %s %s' %(i[0].strip(),i[1].strip(),i[2].strip(),i[3].strip()))