python-5-經常使用模塊

時間  2019-11-13
標籤 python 經常 使用 模塊 欄目 Python 简体版
原文   原文鏈接

什麼是模塊？html

   常見的場景：一個模塊就是一個包含了python定義和聲明的文件，文件名就是模塊名字加上.py的後綴。python

   但其實import加載的模塊分爲四個通用類別：　git

　　1 使用python編寫的代碼（.py文件）程序員

　　2 已被編譯爲共享庫或DLL的C或C++擴展正則表達式

　　3 包好一組模塊的包shell

　　4 使用C編寫並連接到python解釋器的內置模塊編程

爲什麼要使用模塊？json

   若是你退出python解釋器而後從新進入，那麼你以前定義的函數或者變量都將丟失，所以咱們一般將程序寫到文件中以便永久保存下來，須要時就經過python test.py方式去執行，此時test.py被稱爲腳本script。bash

    隨着程序的發展，功能愈來愈多，爲了方便管理，咱們一般將程序分紅一個個的文件，這樣作程序的結構更清晰，方便管理。這時咱們不只僅能夠把這些文件當作腳本去執行，還能夠把他們當作模塊來導入到其餘的模塊中，實現了功能的重複利用，網絡

模塊的導入和使用

模塊的導入應該在程序開始的地方

更多相關內容 http://www.cnblogs.com/Eva-J/articles/7292109.html

 

一.時間模塊

# time
# 操做系統在控制時間
# 對咱們的程序有做用 ： 記錄程序的執行過程，記錄用戶的行爲，統計效率

# 三種格式
    # 1. 時間戳格式  浮點型的小數  方便計算機進行計算的
import time
#print(time.time())  # 1534042858.4695284 單位是秒
    # 2.結構化格式   # 時間戳格式和格式化格式的一種中間狀態
# print(time.localtime())
# print(time.gmtime())
    # 3.格式化格式   # 給人看的
# print(time.strftime('%Y/%m/%d %H:%M:%S'))
# print(time.strftime('%H:%M:%S %Y/%m/%d '))
# print(time.strftime('%H:%M:%S %y/%m/%d '))
# print(time.strftime('%c'))

# 三種格式的轉換
# 時間戳 -->  格式化
# 1500000000 --> 2017/07/14 10:40:00
# struct_time = time.localtime(1500000000)
# print(struct_time)
# print(time.strftime('%Y/%m/%d %H:%M:%S',struct_time))

# print(time.localtime(3000000000))


# 格式化 --> 時間戳
# 2018.8.8  -->
# struct_time = time.strptime('2008.8.8','%Y.%m.%d')
# print(struct_time)
# print(time.mktime(struct_time))

# 寫一個函數 計算 當前月1號的時間戳時間
# def get01():
#     str_time = time.strftime('%Y-%m')
#     # struct_time = time.strptime(str_time+"-1",'%Y-%m-%d')  #'2018-08-1'
#     struct_time = time.strptime(str_time,'%Y-%m')  #'2018-08' '-1 0:0:0'
#     return time.mktime(struct_time)
#
# print(get01())

# time模塊
# 計算時間差
# 12：01 - 11：59
# 2018-8-12 11:45 -  2018-8-11 23：05

# time.sleep(1)  # 程序在這裏阻塞1秒鐘
時間模塊

 

二. random隨機模塊

import random
# 隨機 ： 驗證碼 抽獎 彩票 洗牌 發紅包

# 隨機小數
# print(random.random())
# print(random.uniform(1,3))

# 隨機整數
# print(random.randint(1,100))  # [1,2]
# print(random.randrange(1,2))  # [1,2)
# print(random.randrange(1,100,2))  # [1,2)

# 隨機抽取
# print(random.choice([1,2,3,'abc',('a','c')]))
# print(random.sample([1,2,3,'abc',('a','c')],2))

# 打亂順序
# lst = list(range(100))
# random.shuffle(lst)
# print(lst)

# 驗證碼
# 四位純數字 驗證碼
# random.randint(1000,9999)
# res = ''
# for i in range(4):
#     num = random.randint(0,9)
#     res += str(num)
# print(res)

# def func(n=4):
#     res = ''
#     for i in range(n):
#         num = random.randint(0,9)
#         res += str(num)
#     return res
# print(func())

# 數字 字母 組成的驗證碼
# 隨機數字
# 隨機字母
# 某一位上 是數字 仍是字母 也應該是隨機事件
def func(n=6 ,alph = True):
    ret = ''
    for i in  range(n):
        code = str(random.randint(0,9))
        if alph:
            alph_lower = chr(random.randint(97,122))
            alph_upper = chr(random.randint(65,90))
            code = random.choice([code,alph_lower,alph_upper])
        ret += code
    return ret
print(func())
隨機模塊

 

三.sys模塊

# sys python解釋器相關的功能
import sys
# print(sys.platform)
# sys.exit()  # 退出程序用的 exit()

# print(sys.argv)  # 列表 執行python命令的時候 寫在python後面的內容
# D:\sylar\workspace\day05\8.sys模塊.py
# name = input('name:')
# pwd = input('pwd:')

# name = sys.argv[1]
# pwd = sys.argv[2]
# if name == 'alex' and pwd == 'alex3714':
#     print('登錄成功')
# else:exit()
# print('個人功能')

# sys.modules
# print(sys.modules)   # 大字典，字典裏是全部已經被導入的模塊
# '字符串 模塊名'：'這個模塊所在的內存空間'
# name = 'alex'
# print(sys.modules['__main__'])
# print(sys.modules['sys'])

# print(sys.path)
#  內置模塊、第三方模塊的導入 你不須要操心path
#  自定義模塊的時候 文件的導入 還須要你本身去處理sys.path列表
sys模塊

 

四 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.popen("bash command).read()  運行shell命令，獲取執行結果
os.environ  獲取系統環境變量


os.path
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的大小
'''
os 模塊

 

五.

# 什麼是序列 ： 列表 元組 字符串
# 什麼是序列化 ：序列 - 字符串
    # 把複雜的數據類型 轉換成 序列（字符串、bytes）的過程 —— 序列化
        # 列表 字典 元組 集合 -> 字符串
    # 把序列 轉換回 複雜的數據類型 的過程 —— 反序列化
# 爲何要有序列化
    # 1.網絡傳輸
    # 2.文件存儲
# 有哪些序列化相關的模塊
    # json
    # pickle
    # shelve
# 都怎麼用

import json
# dic = {'key':'value','k2':[1,2],2:(2,3)}
# ret = json.dumps(dic)
# print(type(dic),dic)
# print(type(ret),ret)
# with open('json_file','w') as f:
#     f.write(ret)

# json 的格式很是嚴格
# 字典的key必須是字符串數據類型
# 可以支持的數據類型很是有限 ： 數字 字符串 字典 列表
# 字符串必須是用英文雙引號的括起來的

# 格式嚴格的緣由 ： 在其餘的語言中沒有出現過的數據類型是不能出如今json格式中的

# dic = {(1,2,3):'value'}
# json.dumps(dic)

# se = {1,2,3}
# json.dumps(se)

# with open('json_file','r') as f:
#    content = f.read()
# print(type(content),content)
# dic = json.loads(content)
# print(type(dic),dic)

# dumps 序列化方法
# loads 反序列化方法

# dump/load
# with open('json_file','r') as f:
#     ret = json.load(f)
# print(type(ret),ret)

# with open('json_file','w') as f:
#     json.dump({'k':'v'},f)

# 屢次dump雖然能夠，可是就沒法load出數據了
# with open('json_file','w') as f:
#     json.dump({'k':'v'},f)
#     json.dump({'k11':'v'},f)
#     json.dump({'k22':'v'},f)
#     json.dump({'k3':'v'},f)
#     json.dump({'k4':'v'},f)

# with open('json_file','r') as f:
#     ret = json.load(f)
# print(type(ret),ret)

# w打開文件
# dumps 字符串
# write(字符串+'\n')

# r打開文件
# for line in f：
# json.loads(line.strip())

# import json
# data = {'username':['李華','二愣子'],'sex':'male','age':16}
# json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(',',':'),ensure_ascii=False)
# json_dic3 = json.dumps(data)
# print(json_dic2)
# print(json_dic3)
序列化模塊jsin

 

 

六  

import pickle
# dumps的結果是bytes數據類型，因此寫文件的時候'rb'
# 支持的數據類型多
# 支持屢次load 和 屢次dump

# dumps loads
# dump load
# dic = {'key':'value','k2':[1,2],2:(2,3)}
# ret = pickle.dumps(dic)
# print(ret)
# with open('pickle_file','wb') as f:
#     f.write(ret)

# with open('pickle_file','rb') as f:
#     content = f.read()
# print(pickle.loads(content))

# dump load
# with open('pickle_file','wb') as f:
#     pickle.dump({'kkk','vvv',1,2,3,4},f)
#     pickle.dump({(1,2,3):'vvv'},f)
#     pickle.dump([1,2,3],f)

with open('pickle_file','rb') as f:
    while True:
        try:
            print(pickle.load(f))
        except EOFError:break
序列化模塊pickel

 

七. 

import shelve
# f = shelve.open('shelve_file')
# # f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接對文件句柄操做，就能夠存入數據
# # f.close()

# import shelve
# f1 = shelve.open('shelve_file')
# existing = f1['key']  #取出數據的時候也只須要直接用key獲取便可，可是若是key不存在會報錯
# f1.close()
# print(existing)
序列化模塊-shelve

 

八.re模塊     http://tool.chinaz.com/regex 在線驗證正則

這是京東的註冊頁面，打開頁面咱們就看到這些要求輸入我的信息的提示。
假如咱們隨意的在手機號碼這一欄輸入一個11111111111，它會提示咱們格式有誤。
這個功能是怎麼實現的呢？
假如如今你用python寫一段代碼，相似：

phone_number = input('please input your phone number ： ')

你怎麼判斷這個phone_number是合法的呢？

根據手機號碼一共11位而且是隻以1三、1四、1五、18開頭的數字這些特色，咱們用python寫了以下代碼：
while True:
    phone_number = input('please input your phone number ： ')
    if len(phone_number) == 11 \
            and phone_number.isdigit()\
            and (phone_number.startswith('13') \
            or phone_number.startswith('14') \
            or phone_number.startswith('15') \
            or phone_number.startswith('18')):
        print('是合法的手機號碼')
    else:
        print('不是合法的手機號碼')
這是你的寫法，如今我要展現一下個人寫法：
import re
phone_number = input('please input your phone number ： ')
if re.match('^(13|14|15|18)[0-9]{9}$',phone_number):
        print('是合法的手機號碼')
else:
        print('不是合法的手機號碼')

對比上面的兩種寫法，此時此刻，我要問你你喜歡哪一種方法呀？你確定仍是會說第一種，爲何呢？由於第一種不用學呀！
可是若是如今有一個文件，我讓你從整個文件裏匹配出全部的手機號碼。你用python給我寫個試試？
可是學了今天的技能以後，分分鐘幫你搞定！

今天咱們要學習python裏的re模塊和正則表達式，學會了這個就能夠幫咱們解決剛剛的疑問。正則表達式不只在python領域，在整個編程屆都佔有舉足輕重的地位。

  
無論之後你是否是去作python開發，只要你是一個程序員就應該瞭解正則表達式的基本使用。若是將來你要在爬蟲領域發展，你就更應該好好學習這方面的知識。
可是你要知道，re模塊本質上和正則表達式沒有一毛錢的關係。re模塊和正則表達式的關係 相似於 time模塊和時間的關係
你沒有學習python以前，也不知道有一個time模塊，可是你已經認識時間了 12:30就表示中午十二點半（這個時間可好，通常這會兒就該下課了）。
時間有本身的格式，年月日時分秒，12個月，365天......已經成爲了一種規則。你也早就牢記於心了。time模塊只不過是python提供給咱們的能夠方便咱們操做時間的一個工具而已
 

正則表達式自己也和python沒有什麼關係，就是匹配字符串內容的一種規則。

官方定義：正則表達式是對字符串操做的一種邏輯公式，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個「規則字符串」，這個「規則字符串」用來表達對字符串的一種過濾邏輯。

正則表達式

一說規則我已經知道你很暈了，如今就讓咱們先來看一些實際的應用。在線測試工具 http://tool.chinaz.com/regex/

首先你要知道的是，談到正則，就只和字符串相關了。在我給你提供的工具中，你輸入的每個字都是一個字符串。
其次，若是在一個位置的一個值，不會出現什麼變化，那麼是不須要規則的。
　　好比你要用"1"去匹配"1"，或者用"2"去匹配"2"，直接就能夠匹配上。這連python的字符串操做均可以輕鬆作到。
那麼在以後咱們更多要考慮的是在同一個位置上能夠出現的字符的範圍。

字符組 ： [字符組]
在同一個位置可能出現的各類字符組成了一個字符組，在正則表達式中用[]表示
字符分爲不少類，好比數字、字母、標點等等。
假如你如今要求一個位置"只能出現一個數字",那麼這個位置上的字符只能是0、一、2...9這10個數之一。
正則
 
待匹配字符
 
匹配
結果
 
說明
 
[0123456789]
 
8
 
True
 
在一個字符組裏枚舉合法的全部字符，字符組裏的任意一個字符
和"待匹配字符"相同都視爲能夠匹配
 
[0123456789]
 
a
 
False
 
因爲字符組中沒有"a"字符，因此不能匹配
  
[0-9]
   
7
 
True
 
也能夠用-表示範圍,[0-9]就和[0123456789]是一個意思
  
[a-z]
   
s
   
True
   
一樣的若是要匹配全部的小寫字母，直接用[a-z]就能夠表示
  
[A-Z]
   
B
   
True
   
[A-Z]就表示全部的大寫字母
  
[0-9a-fA-F]
   
e
   
True
   
能夠匹配數字，大小寫形式的a～f，用來驗證十六進制字符

字符：

  
元字符
   
匹配內容
.  匹配除換行符之外的任意字符
\w 匹配字母或數字或下劃線
\s 匹配任意的空白符
\d 匹配數字
\n 匹配一個換行符
\t 匹配一個製表符
\b 匹配一個單詞的結尾
^ 匹配字符串的開始
$ 匹配字符串的結尾
\W 
匹配非字母或數字或下劃線
\D 
匹配非數字
\S 
匹配非空白符
a|b 
匹配字符a或字符b
() 
匹配括號內的表達式，也表示一個組
[...] 
匹配字符組中的字符
[^...] 
匹配除了字符組中字符的全部字符

 

量詞：

量詞
 
用法說明
* 重複零次或更屢次
+ 重複一次或更屢次
? 重複零次或一次
{n} 重複n次
{n,} 重複n次或更屢次
{n,m} 重複n到m次

 

. ^ $

正則 待匹配字符 匹配
結果		 說明
海. 海燕海嬌海東 海燕海嬌海東   匹配全部"海."的字符
^海. 海燕海嬌海東 海燕 只從開頭匹配"海."
  海.$   海燕海嬌海東 海東 只匹配結尾的"海.$"

 

* + ? { }

正則 待匹配字符 匹配
結果		 說明
李.? 李傑和李蓮英和李二棍子

李傑
李蓮
李二

   
?表示重複零次或一次，即只匹配"李"後面一個任意字符
 
李.* 李傑和李蓮英和李二棍子 李傑和李蓮英和李二棍子 
*表示重複零次或屢次，即匹配"李"後面0或多個任意字符
李.+ 李傑和李蓮英和李二棍子 李傑和李蓮英和李二棍子 
+表示重複一次或屢次，即只匹配"李"後面1個或多個任意字符
李.{1,2} 李傑和李蓮英和李二棍子

李傑和
李蓮英
李二棍

 
{1,2}匹配1到2次任意字符

 注意：前面的*,+,?等都是貪婪匹配，也就是儘量匹配，後面加?號使其變成惰性匹配

正則 待匹配字符 匹配
結果		 說明
李.*? 李傑和李蓮英和李二棍子 李
李
李		 惰性匹配

 

字符集［］［^］

正則 待匹配字符 匹配
結果		 說明
李[傑蓮英二棍子]* 李傑和李蓮英和李二棍子

李傑
李蓮英
李二棍子

   
表示匹配"李"字後面[傑蓮英二棍子]的字符任意次
 
李[^和]* 李傑和李蓮英和李二棍子

李傑
李蓮英
李二棍子

 
表示匹配一個不是"和"的字符任意次
[\d] 456bdha3

4
5
6
3

 
表示匹配任意一個數字，匹配到4個結果
[\d]+ 456bdha3

456
3

 
表示匹配任意個數字，匹配到2個結果

 

分組 ()與 或 ｜［^］

 身份證號碼是一個長度爲15或18個字符的字符串，若是是15位則所有🈶️數字組成，首位不能爲0；若是是18位，則前17位所有是數字，末位多是數字或x，下面咱們嘗試用正則來表示：

正則 待匹配字符 匹配
結果		 說明
^[1-9]\d{13,16}[0-9x]$ 110101198001017032

110101198001017032

    表示能夠匹配一個正確的身份證號
^[1-9]\d{13,16}[0-9x]$ 1101011980010170

1101011980010170

 
表示也能夠匹配這串數字，但這並非一個正確的身份證號碼，它是一個16位的數字
^[1-9]\d{14}(\d{2}[0-9x])?$ 1101011980010170

False

 
如今不會匹配錯誤的身份證號了
()表示分組，將\d{2}[0-9x]分紅一組，就能夠總體約束他們出現的次數爲0-1次
^([1-9]\d{16}[0-9x]|[1-9]\d{14})$ 110105199812067023

110105199812067023

 
表示先匹配[1-9]\d{16}[0-9x]若是沒有匹配上就匹配[1-9]\d{14}

 

轉義符 \

在正則表達式中，有不少有特殊意義的是元字符，好比\d和\s等，若是要在正則中匹配正常的"\d"而不是"數字"就須要對"\"進行轉義，變成'\\'。

在python中，不管是正則表達式，仍是待匹配的內容，都是以字符串的形式出現的，在字符串中\也有特殊的含義，自己還須要轉義。因此若是匹配一次"\d",字符串中要寫成'\\d'，那麼正則裏就要寫成"\\\\d",這樣就太麻煩了。這個時候咱們就用到了r'\d'這個概念，此時的正則是r'\\d'就能夠了。

正則 待匹配字符 匹配
結果		 說明
\d \d  False 
由於在正則表達式中\是有特殊意義的字符，因此要匹配\d自己，用表達式\d沒法匹配
\\d \d  True 
轉義\以後變成\\，便可匹配
"\\\\d" '\\d'  True 
若是在python中，字符串中的'\'也須要轉義，因此每個字符串'\'又須要轉義一次
r'\\d' r'\d'  True 
在字符串以前加r，讓整個字符串不轉義

 

貪婪匹配

貪婪匹配：在知足匹配時，匹配儘量長的字符串，默認狀況下，採用貪婪匹配

正則 待匹配字符 匹配
結果		 說明
<.*>

<script>...<script>

 <script>...<script> 
默認爲貪婪匹配模式，會匹配儘可能長的字符串
<.*?> r'\d'  

<script>
<script>

 
加上？爲將貪婪匹配模式轉爲非貪婪匹配模式，會匹配儘可能短的字符串
 
幾個經常使用的非貪婪匹配Pattern
*? 重複任意次，但儘量少重複
+? 重複1次或更屢次，但儘量少重複
?? 重複0次或1次，但儘量少重複
{n,m}? 重複n到m次，但儘量少重複
{n,}? 重複n次以上，但儘量少重複
.*?的用法
  
. 是任意字符
* 是取 0 至 無限長度
? 是非貪婪模式。
何在一塊兒就是 取儘可能少的任意字符，通常不會這麼單獨寫，他大多用在：
.*?x

就是取前面任意長度的字符，直到一個x出現
 

re模塊下的經常使用方法

 

複製代碼 
import re

ret = re.findall('a', 'eva egon yuan')  # 返回全部知足匹配條件的結果,放在列表裏
print(ret) #結果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()
print(ret) #結果 : 'a'
# 函數會在字符串內查找模式匹配,只到找到第一個匹配而後返回一個包含匹配信息的對象,該對象能夠
# 經過調用group()方法獲得匹配的字符串,若是字符串沒有匹配，則返回None。

ret = re.match('a', 'abc').group()  # 同search,不過盡在字符串開始處進行匹配
print(ret)
#結果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割獲得''和'bcd',在對''和'bcd'分別按'b'分割
print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#將數字替換成'H'，參數1表示只替換1個
print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#將數字替換成'H'，返回元組(替換的結果,替換了多少次)
print(ret)

obj = re.compile('\d{3}')  #將正則表達式編譯成爲一個 正則表達式對象，規則要匹配的是3個數字
ret = obj.search('abc123eeee') #正則表達式對象調用search，參數爲待匹配的字符串
print(ret.group())  #結果 ： 123

import re
ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一個存放匹配結果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #查看第一個結果
print(next(ret).group())  #查看第二個結果
print([i.group() for i in ret])  #查看剩餘的左右結果
複製代碼

注意：

1 findall的優先級查詢：

複製代碼 
import re

ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['oldboy']     這是由於findall會優先把匹配結果組裏內容返回,若是想要匹配結果,取消權限便可

ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['www.oldboy.com']
複製代碼

 

2 split的優先級查詢

複製代碼 
ret=re.split("\d+","eva3egon4yuan")
print(ret) #結果 ： ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #結果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）以後所切出的結果是不一樣的，
#沒有（）的沒有保留所匹配的項，可是有（）的卻可以保留了匹配的項，
#這個在某些須要保留匹配部分的使用過程是很是重要的。

 

 

 

 

這是京東的註冊頁面，打開頁面咱們就看到這些要求輸入我的信息的提示。
假如咱們隨意的在手機號碼這一欄輸入一個11111111111，它會提示咱們格式有誤。
這個功能是怎麼實現的呢？
假如如今你用python寫一段代碼，相似：

phone_number = input('please input your phone number ： ')

你怎麼判斷這個phone_number是合法的呢？

根據手機號碼一共11位而且是隻以1三、1四、1五、18開頭的數字這些特色，咱們用python寫了以下代碼：
  
while True:
    phone_number = input('please input your phone number ： ')
    if len(phone_number) == 11 \
            and phone_number.isdigit()\
            and (phone_number.startswith('13') \
            or phone_number.startswith('14') \
            or phone_number.startswith('15') \
            or phone_number.startswith('18')):
        print('是合法的手機號碼')
    else:
        print('不是合法的手機號碼')
  
這是你的寫法，如今我要展現一下個人寫法：
import re
phone_number = input('please input your phone number ： ')
if re.match('^(13|14|15|18)[0-9]{9}$',phone_number):
        print('是合法的手機號碼')
else:
        print('不是合法的手機號碼')

對比上面的兩種寫法，此時此刻，我要問你你喜歡哪一種方法呀？你確定仍是會說第一種，爲何呢？由於第一種不用學呀！
可是若是如今有一個文件，我讓你從整個文件裏匹配出全部的手機號碼。你用python給我寫個試試？
可是學了今天的技能以後，分分鐘幫你搞定！

今天咱們要學習python裏的re模塊和正則表達式，學會了這個就能夠幫咱們解決剛剛的疑問。正則表達式不只在python領域，在整個編程屆都佔有舉足輕重的地位。

  
無論之後你是否是去作python開發，只要你是一個程序員就應該瞭解正則表達式的基本使用。若是將來你要在爬蟲領域發展，你就更應該好好學習這方面的知識。
可是你要知道，re模塊本質上和正則表達式沒有一毛錢的關係。re模塊和正則表達式的關係 相似於 time模塊和時間的關係
你沒有學習python以前，也不知道有一個time模塊，可是你已經認識時間了 12:30就表示中午十二點半（這個時間可好，通常這會兒就該下課了）。
時間有本身的格式，年月日時分秒，12個月，365天......已經成爲了一種規則。你也早就牢記於心了。time模塊只不過是python提供給咱們的能夠方便咱們操做時間的一個工具而已
 

正則表達式自己也和python沒有什麼關係，就是匹配字符串內容的一種規則。

官方定義：正則表達式是對字符串操做的一種邏輯公式，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個「規則字符串」，這個「規則字符串」用來表達對字符串的一種過濾邏輯。

正則表達式

一說規則我已經知道你很暈了，如今就讓咱們先來看一些實際的應用。在線測試工具 http://tool.chinaz.com/regex/

首先你要知道的是，談到正則，就只和字符串相關了。在我給你提供的工具中，你輸入的每個字都是一個字符串。
其次，若是在一個位置的一個值，不會出現什麼變化，那麼是不須要規則的。
　　好比你要用"1"去匹配"1"，或者用"2"去匹配"2"，直接就能夠匹配上。這連python的字符串操做均可以輕鬆作到。
那麼在以後咱們更多要考慮的是在同一個位置上能夠出現的字符的範圍。
  字符組 
正則
 
待匹配字符
 
匹配
結果
 
說明
 
[0123456789]
 
8
 
True
 
在一個字符組裏枚舉合法的全部字符，字符組裏的任意一個字符
和"待匹配字符"相同都視爲能夠匹配
 
[0123456789]
 
a
 
False
 
因爲字符組中沒有"a"字符，因此不能匹配
  
[0-9]
   
7
 
True
 
也能夠用-表示範圍,[0-9]就和[0123456789]是一個意思
  
[a-z]
   
s
   
True
   
一樣的若是要匹配全部的小寫字母，直接用[a-z]就能夠表示
  
[A-Z]
   
B
   
True
   
[A-Z]就表示全部的大寫字母
  
[0-9a-fA-F]
   
e
   
True
   
能夠匹配數字，大小寫形式的a～f，用來驗證十六進制字符

字符：

  
元字符
   
匹配內容
.  匹配除換行符之外的任意字符
\w 匹配字母或數字或下劃線
\s 匹配任意的空白符
\d 匹配數字
\n 匹配一個換行符
\t 匹配一個製表符
\b 匹配一個單詞的結尾
^ 匹配字符串的開始
$ 匹配字符串的結尾
\W 
匹配非字母或數字或下劃線
\D 
匹配非數字
\S 
匹配非空白符
a|b 
匹配字符a或字符b
() 
匹配括號內的表達式，也表示一個組
[...] 
匹配字符組中的字符
[^...] 
匹配除了字符組中字符的全部字符

 

量詞：

量詞
 
用法說明
* 重複零次或更屢次
+ 重複一次或更屢次
? 重複零次或一次
{n} 重複n次
{n,} 重複n次或更屢次
{n,m} 重複n到m次

 

. ^ $

正則 待匹配字符 匹配
結果		 說明
海. 海燕海嬌海東 海燕海嬌海東   匹配全部"海."的字符
^海. 海燕海嬌海東 海燕 只從開頭匹配"海."
  海.$   海燕海嬌海東 海東 只匹配結尾的"海.$"

 

* + ? { }

正則 待匹配字符 匹配
結果		 說明
李.? 李傑和李蓮英和李二棍子

李傑
李蓮
李二

   
?表示重複零次或一次，即只匹配"李"後面一個任意字符
 
李.* 李傑和李蓮英和李二棍子 李傑和李蓮英和李二棍子 
*表示重複零次或屢次，即匹配"李"後面0或多個任意字符
李.+ 李傑和李蓮英和李二棍子 李傑和李蓮英和李二棍子 
+表示重複一次或屢次，即只匹配"李"後面1個或多個任意字符
李.{1,2} 李傑和李蓮英和李二棍子

李傑和
李蓮英
李二棍

 
{1,2}匹配1到2次任意字符

 注意：前面的*,+,?等都是貪婪匹配，也就是儘量匹配，後面加?號使其變成惰性匹配

正則 待匹配字符 匹配
結果		 說明
李.*? 李傑和李蓮英和李二棍子 李
李
李		 惰性匹配

 

字符集［］［^］

正則 待匹配字符 匹配
結果		 說明
李[傑蓮英二棍子]* 李傑和李蓮英和李二棍子

李傑
李蓮英
李二棍子

   
表示匹配"李"字後面[傑蓮英二棍子]的字符任意次
 
李[^和]* 李傑和李蓮英和李二棍子

李傑
李蓮英
李二棍子

 
表示匹配一個不是"和"的字符任意次
[\d] 456bdha3

4
5
6
3

 
表示匹配任意一個數字，匹配到4個結果
[\d]+ 456bdha3

456
3

 
表示匹配任意個數字，匹配到2個結果

 

分組 ()與 或 ｜［^］

 身份證號碼是一個長度爲15或18個字符的字符串，若是是15位則所有🈶️數字組成，首位不能爲0；若是是18位，則前17位所有是數字，末位多是數字或x，下面咱們嘗試用正則來表示：

正則 待匹配字符 匹配
結果		 說明
^[1-9]\d{13,16}[0-9x]$ 110101198001017032

110101198001017032

    表示能夠匹配一個正確的身份證號
^[1-9]\d{13,16}[0-9x]$ 1101011980010170

1101011980010170

 
表示也能夠匹配這串數字，但這並非一個正確的身份證號碼，它是一個16位的數字
^[1-9]\d{14}(\d{2}[0-9x])?$ 1101011980010170

False

 
如今不會匹配錯誤的身份證號了
()表示分組，將\d{2}[0-9x]分紅一組，就能夠總體約束他們出現的次數爲0-1次
^([1-9]\d{16}[0-9x]|[1-9]\d{14})$ 110105199812067023

110105199812067023

 
表示先匹配[1-9]\d{16}[0-9x]若是沒有匹配上就匹配[1-9]\d{14}

 

轉義符 \

在正則表達式中，有不少有特殊意義的是元字符，好比\d和\s等，若是要在正則中匹配正常的"\d"而不是"數字"就須要對"\"進行轉義，變成'\\'。

在python中，不管是正則表達式，仍是待匹配的內容，都是以字符串的形式出現的，在字符串中\也有特殊的含義，自己還須要轉義。因此若是匹配一次"\d",字符串中要寫成'\\d'，那麼正則裏就要寫成"\\\\d",這樣就太麻煩了。這個時候咱們就用到了r'\d'這個概念，此時的正則是r'\\d'就能夠了。

正則 待匹配字符 匹配
結果		 說明
\d \d  False 
由於在正則表達式中\是有特殊意義的字符，因此要匹配\d自己，用表達式\d沒法匹配
\\d \d  True 
轉義\以後變成\\，便可匹配
"\\\\d" '\\d'  True 
若是在python中，字符串中的'\'也須要轉義，因此每個字符串'\'又須要轉義一次
r'\\d' r'\d'  True 
在字符串以前加r，讓整個字符串不轉義

 

貪婪匹配

貪婪匹配：在知足匹配時，匹配儘量長的字符串，默認狀況下，採用貪婪匹配

正則 待匹配字符 匹配
結果		 說明
<.*>

<script>...<script>

 <script>...<script> 
默認爲貪婪匹配模式，會匹配儘可能長的字符串
<.*?> r'\d'  

<script>
<script>

 
加上？爲將貪婪匹配模式轉爲非貪婪匹配模式，會匹配儘可能短的字符串
 
幾個經常使用的非貪婪匹配Pattern
*? 重複任意次，但儘量少重複
+? 重複1次或更屢次，但儘量少重複
?? 重複0次或1次，但儘量少重複
{n,m}? 重複n到m次，但儘量少重複
{n,}? 重複n次以上，但儘量少重複
.*?的用法
import datetime
import time
import random
import os
#計算兩個格式化時間之間差了多少年月日時分秒
def time_dff(date1,date2):
    date1 = datetime.datetime.strptime(date1,'%Y-%m-%d %H:%M:%S')
    date2 = datetime.datetime.strptime(date2,'%Y-%m-%d %H:%M:%S')
    return date2-date1

a = r'2018-02-16 02:35:00'
b = r'2019-02-15 02:24:00'
print(time_dff(a,b))

#計算當前時間所在月1號的時間戳
a = datetime.date(datetime.date.today().year,datetime.date.today().month,1)
print(a)

#生成一個6位隨機驗證碼(包含數字和大小寫字母)
def code():
    code1 = ''
    for i in range(6):
        num = random.randint(0,9)
        num1 = chr(random.randint(65,90))
        add = random.choice([num,num1])
        code1 = ''.join([code1,str(add)])
    return code1
print(code())
# 發紅包、制定金額和個數隨機分配紅包金額
def money_dd(money,num):
    try:
        import random
        money *= 100
        money = int(money)
        ret = random.sample(range(1, money - 1), num - 1)
        ret = sorted(ret)
        ret.insert(0, 0)
        ret.append(money)
        ret = [round(ret[i + 1] * 0.01 - ret[i] * 0.01, 2) for i in range(num)]
        random.shuffle(ret)
        return ret
    except ValueError:
        return '輸入不規範'
    except TypeError:
        return '輸入不規範'

if __name__ == '__main__':
        print(money_dd(10, 5))
        print(money_dd(1, 5))
        print(money_dd(100, 5))


# 分別列出給定目錄下全部的文件和文件夾
# import os
# for filename in os.listdir(r'C:\Windows'):
#     print(filename)

# 獲取當前文件所在目錄
# print(os.getcwd())
# 在當前目錄下建立一個文件夾、在這個文件夾下建立一個文件
# import os
# a = 'C:\Windows'
# b = 'hello'
# if os.path.isdir(a):
#     os.mkdir(os.path.join(a,b))
# 計算某路徑下全部文件和文件夾的總大小
def get_size(path):
    import os
    if os.path.split(path)[1]:
        size = 0
        if os.path.isfile(path):
            size += os.path.getsize(path)
        elif os.path.isdir(path):
            if os.listdir(path):
                    for path_son in os.listdir(path):
                        path_son = os.path.join(path, path_son)
                        size += get_size(path_son)
            else:
                size += 4096
        return size
    else:
        return '沒法計算磁盤大小'


if __name__ == '__main__':
    import os
    print(f'{__file__}文件大小爲：', get_size(__file__), '字節')
    print(get_size(os.getcwd()))

#1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )
import re
def formats(func):
    def inner(msg):
        msg = msg.replace(' ', '').replace('-+', '-').replace('++', '+').replace('--', '+').replace('++', '+')
        ret = func(msg)
        return ret
    return inner

@formats
def multiply_divide(msg):
    if '*' in msg:
        return str(float(msg.split('*')[0]) * float(msg.split('*')[1]))
    else:
        return str(float(msg.split('/')[0]) / float(msg.split('/')[1]))

@formats
def multiple_multiply_divide(msg):
    if '*' in msg or '/' in msg:
        obj = re.search('\d+(\.\d+)?[*/][-+]?\d+(\.\d+)?', msg).group()
        ret = msg.replace(obj, multiply_divide(obj))
        if msg.count('*') + msg.count('/') > 0:
            return multiple_multiply_divide(ret)
        else:
            return ret
    else:
        return msg

@formats
def add_subtract(msg):
    ret = re.findall('(-?\d+(\.\d+)?)', msg)
    if len(ret) == 1:
        return ret[0][0]
    else:
        ret = (float(i[0]) for i in ret)
        return str(sum(ret))

@formats
def core(msg):
    try:
        eval(msg)
    except:
        '**'
    else:
        if '(' in msg:
            ret = msg
            for i in [(i, add_subtract(multiple_multiply_divide(i))) for i in re.findall('\([^()]+\)', msg)]:
                ret = ret.replace(i[0], i[1])
            if '(' in ret:
                return core(ret)
            else:
                return float(add_subtract(multiple_multiply_divide(ret)))
        else:
            return float(add_subtract(multiple_multiply_divide(msg)))

if __name__ == '__main__':
    msg = '1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'
    print(core(msg))

print(1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) ))
day做業

 

  
. 是任意字符
* 是取 0 至 無限長度
? 是非貪婪模式。
何在一塊兒就是 取儘可能少的任意字符，通常不會這麼單獨寫，他大多用在：
.*?x

就是取前面任意長度的字符，直到一個x出現
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程