python經常使用的內置模塊

一、import time

time模塊與時間相關的功能

在python中時間分爲3種

　　1.時間戳timestamp從1970 1月 1日到如今的秒數 主要用於計算兩個時間的差

　　2.localtime 本地時間 表示的是計算機當前所在的位置

　　3.UTC世界協調時間

　　時間戳 結構化 格式化字符

#獲取時間戳 返回浮點型

print(time.time())

#獲取當地時間 返回的是結構化時間

print(time.localtime())

#獲取UTC時間 返回的仍是結構化時間 比中國時間少8小時

print(time.gmtime())

#獲取的時間轉成咱們指望的格式 僅支持結構化時間

print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))

#獲取格式化字符串的時間轉爲結構化時間 注意：格式必須匹配

print(time.strptime('2018-08-09 09:01:22','%Y-%m-%d %H:%M:%S'))

#時間戳 轉結構化

print(time.localtime(time.time()))

#結構化轉 時間戳

print(time.mktime(time.locatime()))

經常使用的format格式:

 1     %a      本地(local)簡化星期名稱
 2     %A      本地完整星期名稱
 3     %b      本地簡化月份名稱
 4     %B      本地完整月份名稱
 5     %c      本地相應的日期和時間表示
 6     %d      一個月中的第幾天(01-31)
 7     %H      一天中的第幾個小時(24小時制，00-23)
 8     %l      一天中的第幾個小時(12小時制，01-12)
 9     %j      一年中的第幾天(01-366)
10     %m      月份(01-12)
11     %M      分鐘數(00-59)
12     %p      本地am或者pm的相應符
13     %S      秒(01-61)
14     %U      一年中的星期數(00-53,星期天是一個星期的開始,第一個星期天以前的全部天數都放在第０周)
15     %w      一個星期中的第幾天(0-6,0是星期天)
16     %W      和%U基本相同，不一樣的是%W以星期一爲一個星期的開始
17     %x      本地相應日期
18     %X      本地相應時間
19     %y      去掉世紀的年份(00-99)
20     %Y      完整的年份       
21     %z      用+HHMM或者-HHMM表示距離格林威治的時區偏移(H表明十進制的小時數，M表明十進制的分鐘數)
22     %Z      時區的名字(若是不存在爲空字符)
23     %%      %號自己
24             %p只有與%I配合使用纔有效果
25             當使用strptime()函數時，只有當在這年中的週數和天數被肯定的時候%U和%W纔會被計算

 

 

二、import datetime

1.#獲取時間，獲取當前時間，並返回的是格式化字符時間

print(datetime.datetime.now())

2.#單獨獲取某個時間，年，月，日等

d=datetime.datetime.now()
print(d.year)
print(d.day)

3.#手動指定時間

d2=datetime.datetime(2018,10,15,9,50,00)
print(d2)

4.#計算兩個時間的差  ：只能減-，不能加+

print(d-d2)

5.#替換某個時間

print(d.replace(year=2010))

6.#表示時間差的模塊：timedelta

print(datetime.timedelta(days=1))
t1=datetime.timedelta(days=1)

t2=datetime.timedelta(weeks=1)
print(t2-t1)

7.#時間差能夠和一個datetmie進行加減

print(d+t2)

str類型的日期轉換爲時間戳

# 字符類型的時間
tss1 = '2013-10-10 23:40:00'
# 轉爲時間數組
timeArray = time.strptime(tss1, "%Y-%m-%d %H:%M:%S")
print timeArray     
# timeArray能夠調用tm_year等
print timeArray.tm_year   # 2013
# 轉爲時間戳
timeStamp = int(time.mktime(timeArray))
print timeStamp  # 1381419600


# 結果以下
time.struct_time(tm_year=2013, tm_mon=10, tm_mday=10, tm_hour=23, tm_min=40, tm_sec=0, tm_wday=3, tm_yday=283, tm_isdst=-1)
2013
1381419600

更改str類型日期的顯示格式

tss2 = "2013-10-10 23:40:00"
# 轉爲數組
timeArray = time.strptime(tss2, "%Y-%m-%d %H:%M:%S")
# 轉爲其它顯示格式
otherStyleTime = time.strftime("%Y/%m/%d %H:%M:%S", timeArray)
print otherStyleTime  # 2013/10/10 23:40:00

tss3 = "2013/10/10 23:40:00"
timeArray = time.strptime(tss3, "%Y/%m/%d %H:%M:%S")
otherStyleTime = time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
print otherStyleTime  # 2013-10-10 23:40:00

時間戳轉換爲指定格式的日期

# 使用time
timeStamp = 1381419600
timeArray = time.localtime(timeStamp)
otherStyleTime = time.strftime("%Y--%m--%d %H:%M:%S", timeArray)
print otherStyleTime   # 2013--10--10 23:40:00
# 使用datetime
timeStamp = 1381419600
dateArray = datetime.datetime.utcfromtimestamp(timeStamp)
otherStyleTime = dateArray.strftime("%Y--%m--%d %H:%M:%S")
print otherStyleTime   # 2013--10--10 15:40:00

獲取當前時間而且用指定格式顯示

# time獲取當前時間戳
now = int(time.time())     # 1533952277
timeArray = time.localtime(now)
print timeArray
otherStyleTime = time.strftime("%Y--%m--%d %H:%M:%S", timeArray)
print otherStyleTime    

# 結果以下
time.struct_time(tm_year=2018, tm_mon=8, tm_mday=11, tm_hour=9, tm_min=51, tm_sec=17, tm_wday=5, tm_yday=223, tm_isdst=0)
2018--08--11 09:51:17


# datetime獲取當前時間，數組格式
now = datetime.datetime.now()
print now
otherStyleTime = now.strftime("%Y--%m--%d %H:%M:%S")
print otherStyleTime  

# 結果以下：
2018-08-11 09:51:17.362986
2018--08--11 09:51:17

 

 

三、import random

　　random :隨機數相關模塊

　　random 0-1 開閉

　　randint 0-3 開開

　　randrange 0-3 開閉

　　choice [1,2,4,5,6,'哈哈']隨機選擇一個

　　sample([1,2,4,5,6,'哈哈'])隨機選擇2個

　　uniform(1,3)閉閉 浮點

　　shuffle(列表）打亂順序

print(random.random())
print(random.randint(1,3))
print(random.randrange(1,2,3))
print(random.sample([1,2,3],2))

li=[1,2,3,4,5]
print(random.shuffle(1))
print(1)

print(random.uniform(1,2))



#隨機驗證碼功能
def make_code(i):
    res=''
    for j in range(i):
        #獲取0到9隨機數
        num=str(random.randint(0,9)
        #獲取A-Z隨機字母
        letter=chr(random.randint(65,90)
        #隨機獲取數字或字母
        group=random.choice([num,letter])
        res+=group
    return res

print(make_code(i))     

 

四、import shutil

shutil 模塊：用於簡化文件操做（文件的高級操做）

　　經常使用方法：copy move rm make_archive

 

1.利用shutil來建立壓縮文件，僅支持tar和zip格式，內部調用zipFile模塊實現

shutil.make_archive('test','zip',root_dir='path')

 2.解壓zip

z=zipfile.ZipFile(path）
z.extractall()
z.close()

3.解壓tar

t=tarfile.open(path)
t.extractall()
t.close()

t=tarfile.open(path)
t.add(path)
t.close()

 

五、import json

pickle 產生的數據只能由python讀取（跨平臺性差）

開發程序不可能就是單機程序，須要和其餘設備，其餘的平臺交換數據

一三八四三八零零四三八

咱們須要找到一種通用的數據格式，讓各個平臺都能識別

json模塊：

　　用於處理json格式數據的模塊

　　json全稱javascrip objiect notation js的對象表示法

　　因此json能支持的數據類型就是js支持的數據類型

json格式標準

　　能存儲的有 str int flost dic list bool

　　案列：要求數據的最開始和最末尾必須是{}[]

　　{'name':'yxx'}

json是一種通用的數據交換格式，目前主流的語言都可以輕鬆解析

注意：在使用json格式的時候，數據類型必須按照要求來寫，而且不支持python元組

經常使用方法：

　　序列化：

　　　　dump 處理文件

　　　　dumps  處理字符串

　　反序列化：

　　　　load 處理文件

　　　　loads 處理字符串

1.將python格式的數據序列化爲json格式，python中的任何類型都能被轉化爲json格式，表現形式不一樣

import json
user={'name':"音樂會","age":20,"hobbies":("music","movies")}
print(json.dumps(users))

json.dump(user,open("users.json","wt",encoding="utf-8"))

 

2.json反序列化

jsonstr=json.load(open("users.json","r",encoding="utf-8"))
print(jsonstr)

 

3.其餘

# 解決序列化的編碼問題
info={"愛好":"賺錢"}
json_info=json.dumps(info,ensure_ascii=False)
print(json_info)

 

六、import sys

sys模塊：通常用於設計腳本程序

經常使用：argv:獲取cmd輸入的參數

import sys
print(sys.argv)

#獲取系統內核版本號
print(sys.platform)


#退出系統
print(sys.exit(0))

 

七、import os

os模塊：表示操做系統

#獲取項目主目錄
print(os.path.dirname(os.path.dirname(__file__)))
print(os.path.normpath(os.path.join(os.getcwd(),os.pardir)))

#獲取操做系統內核版本
print(os.name)

#獲取當前執行文件目錄內的全部文件夾名和文件名
print(os.system('dir'))

#獲取操做系統的環境變量,返回的是字典形式
print(os.environ)

#獲取當前的工做目錄
print(os.getcwd())

#切換工做目錄
os.chdir(file)#file文件路徑

#當前目錄,一個點
print(os.curdir)

#當前目錄 兩個點
print(os.pardir)

#建立目錄,可用遞歸建立
print(os.makedirs('a/b/c'))

#建立一個目錄
print(os.mkdir())

#刪除目錄,遞歸刪除,若是沒有文件就刪除,有文件就保留
print(os.removedirs('a/b/c'))

#刪除一個目錄
print(os.remdir())

#刪除文件,僅能刪除文件
print(os.remove())

#列出全部文件和文件名:
print(os.listdir())

#獲取當前平臺的路徑分隔符
print(os.sep)

#獲取當前換行符
print(os.linesep)

#返回絕對路徑
print(os.path.abspath('bb.txt')

#路徑拼接
print(os.path.join('c:','user','a.txt'))

#斜槓會修改成當前平臺的分隔符,可用來執行..來返回上一級
print(os.path.normpath(r'a\b\c\d\..'))

#將路徑拆分爲文件夾路徑和文件名稱
print(os.path.split())

#獲取路徑中的上一級
print(os.path.dirname(__file__)

#獲取最後一級名稱
print(os.path.basename())

#判斷路徑是否存在
print(os.path.exists())

#判斷是不是絕對路徑
print(os.path.isabs())

#大寫變小寫,斜槓根據當前平臺修改
print(os.path.normacase())

 

八、import pickle

pickle模塊：用於序列化

　　序列化就是將內存中的數據持久化到硬盤中

回顧：使用文件讀寫也能完成把數據持久化存儲，可是有侷限性，當數據比較複雜時用起來就很麻煩

列如：須要把一個字典存儲到硬盤中，先轉成字符串，再寫入，讀取爲字符串，再轉爲原始的格式

 

因此就有了pickle

　　1.能將全部python中的數據序列化 int float str dic list tuple set bool

　　2.反序列化，將以前序列化的數據，在恢復成python的數據格式

pickle產生的數據，只能由python讀取（跨平臺性差）

從此你開發程序不可能就是單機程序，你須要和其餘設備，其餘平臺，交換數據

一三八四三八零零四三八

咱們須要找到一種通用的數據格式，讓各個平臺都能識別

users = {"name":"yyh","age":20,"hobbies":["打豆豆","飄"]}

import pcikle


序列化
print(pickle.dumps(users))

f=open("p.txt","wb")
f.write(pickle.dumps(users))
f.close()

反序列化
f=open("p.txt","rb")
print(pickle.loads(f.read()))
f.close()

 

九、import xml

xml模塊：就是可擴展的標記語言

爲了可以在不一樣的平臺間繼續數據的交換

爲了使交換的數據能讓對方看懂，就須要按照必定的語法規範來書寫

xml語法格式：

一、任何的起始標籤都必須有一個結束標籤

　　<tagname></tagname/>

　　<tagname></tagname/>

　　<tagname/>簡化書寫

二、能夠採用另外一種簡化語法，能夠在一個標籤中同時表示起始和結束標籤，這種語法是在大於符號以前緊跟一個斜線（/）,列如<百度百科詞條/>,xml解析器會將其翻譯成<百度百科詞條></百度百科詞條>

三、標籤必須按合適的順序進行嵌套，因此結束標籤必須按鏡像順序匹配起始標籤，列如這是一串百度百科中的樣列字符串，這比如是將起始和結束標籤看作是數學中的左右括號：在沒有關閉全部的內部括號以前，是不能關閉外面的括號

<tag1>
    <tag2>
        <tag3>
        </tag3>
    </tag2>
</tag1>  
  
重點：關閉標籤應該從內往外，一層一層關閉，順序不能亂

四、全部的特性都必須在值的周圍加上雙引號

注意：最外層有且只有一個標籤，這個標籤稱之爲根標籤
　　第一行應該有文檔說明，用於高速計算機怎麼理解
　　列如：<?xml version="1.0" encoding="utf-8"?>
　　當標籤嵌套的時候會出現層級關係，若是一個標籤不被任何別的標籤包裹，那他就是根標籤（最外層）
使用場景：
　　1.配置文件
　　2.常規的數據交換，列如從服務器獲取一段新聞

與json的區別
　　做用是同樣的，都是一種數據格式
　　xml比json先誕生
　　json的數據比xml小
　　目前json是主流

python中的xml處理
　　使用到的模塊
　　Elment Tree 表示整個文件的元素樹
　　Elment 表示一個節點
　　屬性
　　1.text 開始標籤和結束標籤中間的文本
　　2.attrib 全部的屬性 字典類型
　　3.tag 標籤的名字
　　方法
　　get 獲取某個屬性的值
1.解析xml
　　查找標籤
　　find 在子標籤中獲取名字匹配第一個
　　findall 在子標籤中獲取名字匹配的全部標籤
　　iter(tagname) 在全文中查找匹配的全部標籤，返回一個迭代器
2.生成xml
　　用Elment Treee
　　parse() 解析一個文件
　　getroot() 獲取根標籤
　　write() 寫入到文件
3.修改xml
　　set 修改或刪除一個屬性
　　remove 刪除一個標籤
　　append 添加一個標籤

讀取xml文檔到內存中，獲得一個包含全部數據的節點樹
每個標籤就稱之爲一個節點或元素
tree=et.parse('text.xml')
獲取根標籤
root=tree.getroot()
獲取全部的子標籤，找的是第一個
print(root.find('標籤名'))
找的是全部
print(root.findall('標籤名'))

獲取元素
print(root.iter('標籤名'))
for i in root.iter('標籤名'))
    print(i)

遍歷整個xml
for i in root:
    print(i.tag,i.attrib,i.text)
    for j in i:
        print(j.tag,j.attrib,j.text)

讀取到內存
tree=et.parse('text.xml')

添加子標籤
newtag=et.Element('newTag')
文本
newtag.text='123'
屬性
newtag.attrib['name']='skk'
添加
i.append(newtag)
寫回內存
tree.write("text.xml",encoding="utf-8",xml_declaration=False)

 

十、import shelve

shelve模塊：也是一種序列化

經常使用使用方法：

　　1.open（）讀寫

　    2.close（）關閉

特色：使用方法比較簡單，提供一個文件名就能夠開始讀寫

　　　讀寫的方法和字典一致

　　　你能夠把它當成帶有自動序列化功能的字典

原理：內部使用的就是pickle 因此也存在跨平臺性差的問題

使用狀況：寫一個單機程序能夠考慮

import shelve
序列化
s=shelve.open('shelvetest.txt')
s['data']='內容'
s['data']['name']='maple'

反序列化
s1=shelve.open('shelvetest.txt')
print(s1.get('name'))
s1.close()

 

十一、import configParser

configparser就是配置文件解析模塊

配置文件：用於提供程序運行所需的一些信息的文件，後綴 ini cfg

做用：方便用戶修改，列如超時時間

配置文件內容格式：

　　只包括兩種元素

　　section 分區

　　option 選項

　　一個文件能夠有多個section

　　一個section能夠有多個選項

核心功能：

1.section 獲取全部分區

2.option 獲取全部選項

3.get 獲取選項的值 須要傳入section option

注意：大小寫不敏感

僞裝作一個下載功能，最大連接速度能夠由用戶來控制，用戶不會看代碼，因此提供一個配置文件

獲得配置文件對象
cfg=configparser.ConfigParser()
讀取一個配置文件
cfg.read('download.ini')

print(cfg.section())

print(cfg.option('sectionl'))

print(cfg.get('sectionl','maxspeed'))

print(cfg.getint('sectionl','minspeed'))

修改最大速度爲1024
cfg.set('sectionl','maxspeed','1024')

cfg.write(open("download.ini","w",encoding="utf-8"))

 

十二、import hashlib

hash模塊：就是一種算法。

用於將任意長度的數據，壓縮映射到一段固定長度的字符（提取特徵）

hash的特色：

1.輸入數據不一樣，獲得的hash值有可能相同

2.不能經過hash值來獲得輸入的值

3.若是算法相同，不管輸入的數據長度是多少，獲得的hash值長度相同

用途：

　　由於以上特色常將hash算法用於加密和文件校驗

　　輸入用戶名和密碼，在代碼中與數據庫中的判斷是否相同

　　思考當你的數據須要在網絡中傳統時，就可能會受到網絡攻擊

　　黑客經過抓包工具就能截獲你發送和接受的數據

　　因此你的數據，若是涉及到隱私，就應該先加密再發送

　　加密的方式有不少：經常使用的MD5就是一種hash算法

　　經常使用的提高安全性的手段就是加鹽：就是把你加密前的數據作一些改動，列如把順序反過來

 

import hashlib
md=hashlib.md5()
md.udate("hello你這麼牛逼嗎 你破解我試試? DSB".encode("utf-8"))
print(md.hexdigest())

破解MD5能夠嘗試撞庫，原理：有一個數據庫裏面存放了常見的明文和密文的對應關係
因此咱們能夠拿來一個密文取數據庫中查找，有沒有已經存在的明文，看運氣能不能撞庫成功
假設咱們已經拿到了一個衆多帳號中的一個密碼，我能夠拿這個密碼挨個測試你全部帳號，看能不能碰到運氣
pwd_dic = {"123456":"e10adc3949ba59abbe56e057f20f883e","hello":"5d41402abc4b2a76b9719d911017c592"}

for i in pwd_dic:
    if pwd_dic[i] == "5d41402abc4b2a76b9719d911017c592":
        print(i)

從此咱們在寫一些須要網絡傳輸的程序時，若是要進行加密，最好把加密的算法搞得更復雜

密碼長度爲6位
abcdef
在前面加一個abc 在後面加一個cba完事之後再加密
pwd='abcdef'
pwd='abc'+'abcdef'+'cba'
md2=hashlib.md5()
md2.update(pwd.encode.('utf-8'))
print(md2.hexdigest())

加密實際上能作的就是讓黑客的破解成本大於他的利潤

#強制要求你進行加鹽加密
import hmac
h = hmac.new("121212".encode("utf-8"))
h.update("abcd".encode("utf-8"))
print(h.hexdigest())

 

1三、import logging

logging模塊：

一、控制日誌級別

二、控制日誌格式

三、控制輸出的目標爲文件

控制日誌級別猶如火警的級別

logging.debug()

logging.info()

logging.warning()

logging.error()

logging.critical()

一級 大功率電器

二級 抽菸

三級 自焚

四級 渣藥包

import logging

1.#拿到logger對象
logger1=logging.getLogger('maple')

2.#設置handler對象，指定日誌輸入目標位置（文件或終端）
fh1=logging.FileHandler('a1.log',encoding='utf-8')#文件
ch=logging.StreamHandler()#終端

3.#設置formatter對象
formatter1=logging.Formatter(
    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p'
)

4.#綁定logger對象與handler對象
logger1.addHandler(fh1)
logger1.addHandler(ch)


5.#綁定handler對象與formatter對象
fh1.setFormatter(formatter1)

6.#設置日誌級別，有logger對象與handler對象兩層關卡，
# 必須都放行最終日誌纔會放行，一般兩者級別相同
logger1.setLevel(10)
fh1.setLevel(10)
ch.setLevel(10)

7.#使用logger對象產生日誌
logger1.info('maple get $100 million')

logging的配置字典，方便使用

standard_format = '%(asctime)s - task:%(name)s - %(filename)s:%(lineno)d -' \
                  ' %(levelname)s : [%(message)s]'

simple_format = '%(filename)s:%(lineno)d - %(levelname)s : [%(message)s]'

fh1_path = r'a1.log'
fh2_path = r'a2.log'

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到終端的日誌
        'ch': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到終端
            'formatter': 'simple'
        },
        #打印到a1.log文件的日誌
        'fh1': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': fh1_path,  # 日誌文件的路徑
            'encoding': 'utf-8',  # 日誌文件的編碼，不再用擔憂中文log亂碼了
        },
        # 打印到a2.log文件的日誌
        'fh2': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # 保存到文件
            'formatter': 'simple',
            'filename': fh2_path,  # 日誌文件的路徑
            'encoding': 'utf-8',  # 日誌文件的編碼，不再用擔憂中文log亂碼了
        },

    },
    'loggers': {
        '': {
            'handlers': ['fh1', 'fh2', 'ch'],
            'level': 'DEBUG',
        },
    },
}

 

1四、import re

re模塊：就是正則表達式

是一些帶有特殊含義的符號或者符號的組合

它的做用是對字符串進行過濾

在一堆字符串中找到你所關心的內容

你就須要告訴計算機你的過濾規則是什麼樣的，經過什麼方式來告訴計算機？就是經過正則表達式

 第一步：學習正則表達式，各類符號所表示的含義

re模塊的內部實現，不是python，而是調用了c庫

#待處理的字符串
src = "abcdef \t 12121gaa1a _ - a * / \n a"
#在字符串中查找全部知足條件的
print(re.findall('ab',src))

#\w字母數字下劃線     \W非字母數字下劃線   與前面相反
print(re.findall('\w',src))
print(re.findall('\W',src))

#\s全部不可見字符    \S可見字符
print(re.findall("\s",src))
print(re.findall("\S",src))

# \d 全部數字    \D全部非數字
print(re.findall("\d",src))
print(re.findall("\d",src)

# 特殊字符直接匹配
print(re.findall("\n",src))
print(re.findall("\t",src))

# . （點）除了\n之外任意字符
print(re.findall(".",src))

#匹配重複字符 * + ？{}
#*前面的表達式出現任意次
print(re.findall("\w\d*","1 12 aa"))

#+重複1次或屢次
print(re.findall("\d+","1 12121272163871asas6378232678a aa"))

#？表示重複0次或1次
print(re.findall("\d?","aa bb a1c 1c1  123"))

#{m,n}最少m次，最多n次
print(re.findall('\d{1,3}','1   23   123   1234'))

#{m}必須是m次
print(re.findall('[a-z]{,3}','a aa aaa aaaa aaaalaaa'))

## 從字符串1982asasa中找到全部0 1 2,需使用匹配範圍
print(re.findall("0|1|2","1982asasa"))

#[]字符集合 括號內的符號不是總體
print(re.findall('[012]','1982asasa'))

# 在這裏表示除了0-9以外的任意字符
print(re.findall("[^0-9]","1982asasa"))

# 請找出 全部的數字0-9和字母a-z A-Z  
# 注意 減號只有在兩個字符中間纔有範圍的意思 在兩邊都是普通字符
print(re.findall("[0-9a-zA-Z]","1982asa+sa"))

# ^ 匹配行首
print(re.findall("^h","hellohello"))

# $ 匹配行未  注意寫在表達式後面
print(re.findall("[a-z]oh$","lohhel9ohelloh"))

# 單詞邊界  指的是單詞的末尾
print(re.findall("h\\b","helloh hih"))
print(re.findall("h\\B","hellhoh  hih"))

# 貪婪匹配  *  +    不是固定的特殊符號  只是一種現象
# 會一直匹配到不知足條件爲止 用問號來阻止貪婪匹配(匹配最少知足條件的字符數)
print(re.findall("\w+?","ajshsjkdsd"))
print(re.findall("\w*?","ajshsjkdsd"))

src = "<img src='www.baidupic.shuaiqi1.jpg'><img src='www.baidupic.shuaiqi2.jpg'><img src='www.baidupic.shuaiqi3.jpg'>"

# () 用於給正則表達式分組(group) 不會改變原來的表達式邏輯意義
# 效果 優先取出括號內的內容

# 請用正則表達式取圖片地址
print(re.findall("src='(.+?)'",src))

# 瞭解 加上?: 能夠取消括號中的優先級
print(re.findall("src='(?:.+?)'",src))
print(re.findall("src='(?:www).(?:baidupic)",src))

print(re.findall('\d',src))

 

1五、import subprocess

 1 #用來與系統cmd的交互
 2 
 3 #1.從管道中讀取數據，管道就是兩個進程通信的媒介
 4 res = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
 5 
 6 print(type(res.stdout.read().decode("GBK")))
 7 
 8 #stdout輸出管道
 9 print(res.stdout.read().decode("GBK"))
10 
11 dir = r'dir D:\上海python全棧4期\day23'
12 find = 'findstr "py"'
13 
14 res1 = subprocess.Popen(dir,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
15 #stdin輸入管道
16 res2 = subprocess.Popen(find,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE,stdin=res1.stdout)
17 
18 print(res1.stdout.read().decode("GBK"))
19 #stderr錯誤管道
20 print(res2.stderr.read().decode("GBK"),"33333")
21 
22 #總結subpreocess主要用於執行系統指令（啓動子進程）與os.system的不一樣在於，subprocess能夠與這個字進程進行數據交換