常用模塊定義、導入、優化詳解

1、模塊介紹

1.1、定義：模塊：用來從邏輯上組織python代碼（變量、函數、類、邏輯：實現有個功能）
   			 本質就是.py結尾的python文件（文件名：test.py，對應的模塊名是test）
   		包：是用來從邏輯上組織模塊的，本質就是一個目錄或文件夾（必須帶有__init__.py的文件）
1.2、導入方法：import moudle_name1,moudle_name2
		   from moudle_name import * 				
		   #不提倡這種導入方法，等於把moudle_name中的代碼在當前文件執行一次，容易衝突
		   from moudle_name import name1,name2,name3
		   from moudle_name import logger as logger_ls
		   用from也可以,導入某個特定方法,另起別名，就可以調用不怕衝突了
   1.2.2、導入包的本質：解釋執行這個包下的__init__.py文件
   		想要調用導入的包下的別的名字的文件(test1.py)
   		可以在修改那個包下的 __init__.py 文件,將 from . import test1 寫入
   		就能在當前的文件裏
1.3、調用：用import moudle_name1,moudle_name2這種方法調用導入
   調用的時候直接   moudle_name1.   調用纔可以
1.4、import的本質：將moudle_name中的代碼解釋一遍,賦值給moudle_name這個變量,
		moudle_name.name()才能調用
   from moudle_name import name 本質：只把moudle_name模塊當中的name在當前文及中執行了一遍,
   	 	直接name()就能執行了   	 

os.path.dirname()				#獲取當前(文件或目錄)的目錄名,想返回前兩層,就來兩次這個方法
__file__                        #當前文件名
os.path.abspath(__file__)		#獲取這個文件的絕對路徑

1.5、導入優化
	在當前文件的同級目錄下定義一個module_test.py模塊,內有test()函數,print("in the module_test")

import module_test
def logger():
    module_test.test()					#調用module_test模塊中的test()方法
    print("in the logger")
def search():
    module_test.test()					#調用module_test模塊中的test()方法
    print("in the search")

logger()
search()

--->
in the module_test
in the logger
in the module_test
in the search
######如果多次調用module_test模塊中的test()方法,在尋找module_test模塊的過程會浪費時間，因爲每一次調用
	  都會尋找一次module_test模塊這個模塊，改怎麼優化呢？？?
如下：	 
from module_test import test						#開頭直接寫死,不讓他尋找，直接告訴他在哪個地方
def logger():
    test()
    print("in the logger")
def search():
    test()
    print("in the search")

logger()
search()											#輸出一樣

2、模塊的分類

2.1、標準庫,如：os、sys、time
2.2、開源模塊：第三方模塊,別人寫的模塊上傳到網上,自己下載下來可以直接用
2.3、自定義模塊

3、常用內置模塊：

1、time & datetime
2、random
3、os
4、sys
5、shutil
6、json & picle
7、shelve
8、xml處理
9、yaml處理
10、configparser
11、hashlib
12、subprocess
13、logging
14、re正則表達式

3.1、time & datetime 模塊

在python裏,常用幾種格式來表示時間：
	1）時間戳:從當前時間減去1970年1月1日0分0秒，這個時間間隔的秒數,time.time()
	2）格式化的時間字符串，如：2019-09-25 16:12:54
	3）元組（struct_time(tuple)）共9個元素

3.1.1、簡單調用方法1（time）

三種格式的之間的相互轉換方法：

a=time.time()							#獲取當前時間戳
time.sleep(1)							#睡眠1秒
c=time.gmtime()							#將時間戳轉換爲元組的形式(結果爲UTC時區),爲空默認爲當前的時間
d=time.localtime()						#同上(結果爲本地時間,我們是UTC+8),爲空默認爲當前的時間
e=time.gmtime(912422141)				#將時間戳爲"912422141"的時間轉換爲結構化的元組的形式(UTC時區)
f=time.localtime(912422141)				#將時間戳爲"912422141"的時間轉換爲結構化的元組的形式(本地時區)
g=time.strftime("%Y-%m-%d %H:%M:%S",f)	#獲取f的格式化的字符串的形式，strftime("格式","元組")
h=time.strptime("2019-10-08 14:07:28","%Y-%m-%d %H:%M:%S") 
										#獲取輸入的字符串時間的格式化的字符串形式，strptime("字符串","格式")
print(a)
print(c)
print(d)
print(d.tm_year)						#可以取出9項中其中某一項,如取出年份:d.tm_year
print(e)
print(f)
print(time.mktime(d))					#將結構化的元組表示的時間轉換爲時間戳
print(g)
--->

1569569812.8157363
time.struct_time(tm_year=2019, tm_mon=9, tm_mday=27, tm_hour=7, tm_min=36, tm_sec=52, tm_wday=4, tm_yday=270, tm_isdst=0)
time.struct_time(tm_year=2019, tm_mon=9, tm_mday=27, tm_hour=15, tm_min=36, tm_sec=52, tm_wday=4, tm_yday=270, tm_isdst=0)
2019
time.struct_time(tm_year=1998, tm_mon=11, tm_mday=30, tm_hour=10, tm_min=35, tm_sec=41, tm_wday=0, tm_yday=334, tm_isdst=0)
time.struct_time(tm_year=1998, tm_mon=11, tm_mday=30, tm_hour=18, tm_min=35, tm_sec=41, tm_wday=0, tm_yday=334, tm_isdst=0)
1569569812.0
2019-10-08 14:07:28

3.1.2、 簡單調用方法2（datetime）

import datetime

a=datetime.datetime.now() + datetime.timedelta(-3)				#減3天
b=datetime.datetime.now()										#當前時間
c=datetime.datetime.now() + datetime.timedelta(+3)				#加3天
d=datetime.datetime.now() + datetime.timedelta(hours=-5)		#減5小時
e=datetime.datetime.now() + datetime.timedelta(hours=+5)		#加5小時
f=datetime.datetime.now() + datetime.timedelta(minutes=-40)		#減40分鐘
g=datetime.datetime.now() + datetime.timedelta(minutes=+40)		#加40分鐘
h=datetime.datetime.now() + datetime.timedelta(hours=+5) + datetime.timedelta(minutes=+10)	#加5天10分鐘
print("a =",a)
print("b =",b)
print("c =",c)
print("d =",d)
print("e =",e)
print("f =",f)
print("g =",g)
print("h =",h)

--->
a = 2019-10-05 15:46:53.994597
b = 2019-10-08 15:46:53.994597
c = 2019-10-11 15:46:53.994597
d = 2019-10-08 10:46:53.994597
e = 2019-10-08 20:46:53.994597
f = 2019-10-08 15:06:53.994597
g = 2019-10-08 16:26:53.994597
h = 2019-10-08 20:56:53.994597

3.2、random模塊

import random
random.random()							#生成隨機浮點數,默認[0,1)之間的
random.uniform(1,4)						#生成隨機浮點數,跟參數
random.randint(1,2)						#生成隨機整數,必須跟參數範圍,1和2都能取到
random.randrange(1,5)					#生成隨機整數,必須跟參數範圍,1能取到,2娶不到
random.choice([1,2,34,5])				#choice("序列"),隨機取一個元素。序列包含：字符串、列表、元組
random.choice('dadasds')
random.choice((4,5,6,7,8))
random.sample('hello',2)				#sample('序列',2),第一個參數是序列,第二個參數是長度
l = [1,2,3,4,5,6,7,8,9,10]
random.shuffle(l)						#洗牌功能，打亂順序
--->
0.740239330593416
1.8360962683299822
2
1
34
s
8
['h', 'o']
[6, 4, 9, 3, 1, 5, 10, 8, 7, 2]

應用：隨機4位驗證碼生成

import random

checkcode = ''
for i in range(4):
    current=random.randrange(0,4)				#[0,1,2,3]隨機取一個
    if current == i:							#猜i與current是否一樣
        tmp = chr(random.randint(65,90))		#一樣就取一個字母
    else:
        tmp = random.randint(0,9)				#不一樣就取一個數字
    checkcode += str(tmp)						#將數字或字母轉換成字符串
print(checkcode)

3.3、os模塊

import os

os.getcwd()										#獲取當前路徑
os.chdir("D:\\Python3.7.4")						#改變路徑,用雙斜槓的方式可以
os.chdir(r"D:\Python3.7.4")						#前面加'r',單斜槓就可以了,推薦使用這種方法
os.getcwd()
os.curdir										#返回當前目錄
os.pardir										#返回上一級目錄
os.makedirs(r"C:\a\b\c")						#遞歸地創建文件夾,可生成多層遞歸目錄
os.removedirs(r"C:\a\b\c")						#遞歸地刪除文件夾,若目錄爲空則刪除,並遞歸到上一級,以此類推
os.makedir(r"C:\a")								#創建文件夾,不能遞歸	
os.rmdir(r"C:\a")								#刪除文件夾,不能遞歸,只刪除一層
os.listdir('')									#列出指定目錄下所有文件和目錄,包含隱藏文件,以列表方式打印
os.remove()										#刪除一個文件
os.rename('old name','new name')				#文件/目錄改名
os.stat('r'D:\\2019住房公積金提取資料.zip'')		#獲取文件/目錄的信息
os.sep											#獲取當前操作系統的路徑分隔符,windows爲'\\',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所指向的文件或者目錄的最後修改時間(時間戳)
--->

'D:\\Python3.7.4\\項目1'
'D:\\Python3.7.4\\項目1'
'.'
'..'
['.idea', 'day1', 'day10', 'day11', 'day12', 'day2', 'day3', 'day4', 'day5', 'day8', 'day9', 'venv']
os.stat_result(st_mode=33206, st_ino=2251799813775687, st_dev=500065, st_nlink=1, st_uid=0, st_gid=0, st_size=240508, st_atime=1554775053, st_mtime=1554775022, st_ctime=1554775022)
'\\'

3.4、sys模塊

import sys

sys.argv           						#命令行參數List，第一個元素是程序本身路徑,返回跟的參數
sys.exit(n)        						#退出程序，正常退出時exit(0)
sys.version        						#獲取Python解釋程序的版本信息
sys.maxint        						#最大的Int值
sys.path           						#返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
sys.platform      						#返回操作系統平臺名稱
sys.stdout.write('please:')				#打印文件到標準輸出,類似於print()
val = sys.stdin.readline()[:-1]

3.5、shutil模塊,copy文件用的

參考： https://www.cnblogs.com/wupeiqi/articles/4963027.html

import shutil

#copyfileobj用法()：
f1 = open("筆記1",encoding='utf-8')
f2 = open("筆記3","w",encoding='utf-8')
shutil.copyfileobj(f1,f2[, length])					#f1是原文件,f2是目標文件,將f1複製到f2,length可有可無

#copyfile用法():
shutil.copyfile("筆記1","筆記2")						#不用打開文件,直接寫文件名

shutil.copymode(src, dst)							#僅拷貝權限,內容、組、用戶均不變

shutil.copystat(src, dst)							#拷貝狀態的信息，包括：mode bits, atime, mtime, flags

shutil.copy(src, dst)								#拷貝文件和權限

shutil.copy2(src, dst)								#拷貝文件和狀態信息

shutil.copytree(src, dst, symlinks=False, ignore=None)	#遞歸的去拷貝文件

shutil.rmtree(path[, ignore_errors[, onerror]])		#遞歸的去刪除文件

shutil.move(src, dst)								#遞歸的去移動文件

shutil.make_archive(base_name, format, root_dir, ...)
	創建壓縮包並返回文件路徑，例如：zip、tar
	base_name： 壓縮包的文件名，也可以是壓縮包的路徑。只是文件名時，則保存至當前目錄，否則保存至指定路徑，
	如：www                        =>保存至當前路徑
	如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
	format：	壓縮包種類，“zip”, “tar”, “bztar”，“gztar”
	root_dir：	要壓縮的文件夾路徑（默認當前目錄）
	owner：	用戶，默認當前用戶
	group：	組，默認當前組
	logger：用於記錄日誌，通常是logging.Logger對象

shutil 對壓縮包的處理是調用 ZipFile 和 TarFile 兩個模塊來進行的，詳細：

import zipfile

# 壓縮
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log')
z.write('data.data')
z.close()

# 解壓
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall()
z.close()

---------------------------------------------------------------------------------------
import tarfile

# 壓縮
tar = tarfile.open('your.tar','w')
tar.add('/Users/wupeiqi/PycharmProjects/bbs2.zip', arcname='bbs2.zip')
tar.add('/Users/wupeiqi/PycharmProjects/cmdb.zip', arcname='cmdb.zip')
tar.close()

# 解壓
tar = tarfile.open('your.tar','r')
tar.extractall()  # 可設置解壓地址
tar.close()

3.6、json & pickle模塊

用於序列化的兩個模塊
	· json, 用於字符串和python數據類型間進行轉換, 可與其他語言交互
	· pickle, 用於python特有的類型 和 python的數據類型間進行轉換, 支持python所有的數據類型
json提供了四個功能：dumps、dump、loads、load
pickle提供了四個功能：dumps、dump、loads、load

3.7、shelve模塊

shelve模塊是一個簡單的k,v將內存數據通過文件持久化的模塊，可以持久化任何pickle可支持的python數據格式

1、先是持久化保存
import shelve

d = shelve.open('shelve_test')  					# 打開一個文件

info = {'name':'lishang','age':'18','girl':'zxm'}
name = ["alex", "rain", "test"]
date = datetime.datetime.now()

d["name"] = name        							# 持久化列表
d["info"] = info        							# 持久化字典
d["date"] = date        							# 持久化一個時間格式

d.close()

2、再是讀取出來
import shelve

d = shelve.open('shelve_test')  # 打開一個文件

print(d.get("name"))
print(d.get("info"))
print(d.get("date"))
--->

['alex', 'rain', 'test']
{'name': 'lishang', 'age': '18', 'girl': 'zxm'}
2019-10-10 11:01:27.788940

3.8、xml處理模塊

xml的格式如下，通過<>節點來區別數據結構

<?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>

xml協議在各個語言裏的都 是支持的，在python中可以用以下模塊操作xml 

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)

修改和刪除xml文檔內容

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("personinfolist")
personinfo = ET.SubElement(new_xml, "personinfo", attrib={"enrolled": "yes"})
name = ET.SubElement(personinfo, "name")
name.text = 'Li Shang'
age = ET.SubElement(personinfo, "age", attrib={"checked": "no"})
sex = ET.SubElement(personinfo, "sex")
age.text = '18'

personinfo2 = ET.SubElement(new_xml, "personinfo", attrib={"enrolled": "no"})
name = ET.SubElement(personinfo2, "name")
name.text = 'Zhao xiaomeng'
age = ET.SubElement(personinfo2, "age")
age.text = '20'

et = ET.ElementTree(new_xml)  # 生成文檔對象
et.write("test.xml", encoding="utf-8", xml_declaration=True)

ET.dump(new_xml)  # 打印生成的格式

---> ######cat test.xml
<?xml version='1.0' encoding='utf-8'?>
<personinfolist>
    <personinfo enrolled="yes">
        <name>Li Shang</name>
        <age checked="no">18</age>
        <sex />
    </personinfo>
    <personinfo enrolled="no">
        <name>Zhao xiaomeng</name>
        <age>20</age>
    </personinfo>
</personinfolist>

3.9、yaml處理模塊

參考：https://pyyaml.org/wiki/PyYAMLDocumentation

要手動下載安裝pyyaml
pip install pyyaml

3.10、configparser模塊

用於生成和修改常見配置文檔，當前模塊的名稱在 python 3.x 版本中變更爲 configparser

• 來看一個好多軟件的常見文檔格式如下

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
 
[bitbucket.org]
User = hg
 
[topsecret.server.com]
Port = 50022
ForwardX11 = no

• 如果想用python生成一個這樣的文檔怎麼做呢？

###寫一個配置文件
import configparser
 
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9'}
 
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'

config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022'     # mutates the parser
topsecret['ForwardX11'] = 'no'  	 # same here

config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
   config.write(configfile)

• 寫完了還能讀出來

import configparser

conf = configparser.ConfigParser()
conf.read("example.ini")

print(conf.sections())
print(conf['bitbucket.org']['user'])
print(conf['topsecret.server.com']['host port'])

for key in conf['bitbucket.org']:								#還能循環
    print(key)
--->
['bitbucket.org', 'topsecret.server.com']
hg
50022

user
serveraliveinterval
compression
compressionlevel
forwardx11

• 還能增刪改查

###刪掉topsecret.server.com這個節點
sec = conf.remove_section('topsecret.server.com')
conf.write(open('example.ini', "w"))

3.11、hashlib模塊

• 用於加密相關的操作，3.x裏代替了md5模塊和sha模塊，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib

m = hashlib.md5()							#md5加密
m.update(b"Hello")
print(m.hexdigest())

m.update(b"It's me")
print(m.hexdigest())						#這一次不僅是"It's me",而是"HelloIt's me"

m2 = hashlib.md5()
m2.update(b"HelloIt's me")					#驗證第二個是不是前兩個的累加
print(m2.hexdigest())

ss = hashlib.sha256()						#sha256加密
ss.update(b'admin')
print(ss.hexdigest())
--->
8b1a9953c4611296a827abf8c47804d7
5ddeb47b2f925ad0bf249c52e342728a			#第二和第三是一樣的
5ddeb47b2f925ad0bf249c52e342728a			

• 還不夠吊？python 還有一個 hmac 模塊，它內部對我們創建 key 和 內容 再進行處理然後再加密
  散列消息鑑別碼，簡稱HMAC，是一種基於消息鑑別碼MAC（Message Authentication Code）的鑑別機制。
  使用HMAC時,消息通訊的雙方，通 過驗證消息中加入的鑑別密鑰K來鑑別消息的真僞；
  一般用於網絡通信中消息加密，前提是雙方先要約定好key,就像接頭暗號一樣，然後消息發送把用key把消息加密，接收方用key ＋ 消息明文再加密，拿加密後的值 跟 發送者的相對比是否相等，這 樣就能驗證消息的真實性，及發送者的合法性了。

import hmac

h = hmac.new(b'12345','你是250'.encode(encoding="utf-8"))
print(h.hexdigest())

--->
e1635b86f44e1b324dfb2bc96076ee0f

3.12、subprocess模塊

3.13、logging模塊

3.14、re正則表達式模塊

常用正則·表達式符號

'.'     默認匹配除\n(換行)之外的任意一個字符，若指定flag DOTALL,則匹配任意字符，包括換行
'^'     匹配字符開頭，若指定flags MULTILINE,這種也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'     匹配字符結尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*'     匹配*號前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  結果爲['abb', 'ab', 'a']
'+'     匹配前一個字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 結果['ab', 'abb']
'?'     匹配前一個字符1次或0次
'{m}'   匹配前一個字符m次
'{n,m}' 匹配前一個字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 結果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 結果'ABC'
'(...)' 分組匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 結果 abcabca456c
 
 
'\A'    只從字符開頭匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z'    匹配字符結尾，同$
'\d'    匹配數字0-9
'\D'    匹配非數字
'\w'    匹配[A-Za-z0-9]
'\W'    匹配非[A-Za-z0-9]
'\s'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 結果 '\t'
 
'(?P<name>...)' 分組匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 
結果{'province': '3714', 'city': '81', 'birthday': '1993'}

最常用的匹配語法

re.match 		從頭開始匹配
re.search 		匹配包含
re.findall 		把所有匹配到的字符放到以列表中的元素返回
re.splitall 	以匹配到的字符當做列表分隔符
re.sub      	匹配字符並替換

實例

import re

re.match("^.+","lishang23andzhaoxiaomeng24")			#從頭匹配任意一個字符一次或多次
<re.Match object; span=(0, 26), match='lishang23andzhaoxiaomeng24'>

re.search("z[a-z]+g","lishang23andzhaoxiaomeng24")		#從頭匹配'z'開頭,後跟任意字母一個或多個,再跟'g'
<re.Match object; span=(12, 24), match='zhaoxiaomeng'>

re.search("#.+#","13213#hello#")						#匹配以'#'開頭,後跟任意字符任意個,再跟一個'#'
<re.Match object; span=(5, 12), match='#hello#'>

re.search("aal?","aalexaaa")							#先匹配到aa,再匹配問號前面的l零次或一次,這裏匹配到了一次
<re.Match object; span=(0, 3), match='aal'>
re.search("aal?","aaexaaa")								#先匹配到aa,再匹配問號前面的l零次或一次,這裏匹配到了零次
<re.Match object; span=(0, 2), match='aa'>

re.search("[0-9]{3}","aa1l2e345xaaa")					#匹配數字三次
<re.Match object; span=(6, 9), match='345'>

re.search("[0-9]{1,3}","aa1l2e345xaaa")					#匹配數字一次或三次,但只匹配一次就返回
<re.Match object; span=(2, 3), match='1'>

#####################想要返回匹配到的多個字符串都返回,用findall
re.findall("[0-9]{1,3}","aa1l2e345xaaa")				#匹配數字一次到三次,用findall全部返回一個列表的形式
['1', '2', '345']

re.search("abc|ABC","ABCBabcCD").group()				#匹配'abc'或'ABC',用group()取出返回的字符串
'ABC'

re.findall("abc|ABC","ABCBabcCD")						#全部返回,但findall沒有group方法
['ABC', 'abc']

re.search("abc{2}","lishangabccc")						#匹配'ab'和兩個'c',因此返回'abcc'
<re.Match object; span=(7, 11), match='abcc'>
re.search("(abc){2}","lishangabcabcc")
<re.Match object; span=(7, 13), match='abcabc'>			#把abc括起來,就成了匹配兩次'abc'這個整體兩次

re.search("(abc){2}(\|\|=){2}","lishangabcabc||=||=")	#匹配'abc'兩次在跟'||='兩次
<re.Match object; span=(7, 19), match='abcabc||=||='>

########################分組匹配
re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict()
{'province': '3714', 'city': '81', 'birthday': '1993'}

re.search("(?P<province>[0-9]{2})(?P<city>[0-9]{2})(?P<xian>[0-9]{2})(?P<birthday>[0-9]{8})","371481199306143242").group("city")
'14'

re.split("[0-9]+","abc12de3f45GH")						#以數字做分隔符,返回剩下的字符串
['abc', 'de', 'f', 'GH']

re.sub("[0-9]+","|","abc12de3f45GH",count=2)			#替換,將數字換成'|',替換兩次
'abc|de|f45GH'

• 僅需輕輕知道的幾個匹配模式

  re.I(re.IGNORECASE): 忽略大小寫（括號內是完整寫法，下同）
  M(MULTILINE): 多行模式，改變'^'和'$'的行爲（參見上圖）
  S(DOTALL): 點任意匹配模式，改變'.'的行爲
  

import re

re.search("[a-z]+","sadsaASA",flags=re.I)				#忽略大小寫,
<re.Match object; span=(0, 8), match='sadsaASA'>