本文主要對模組的初步識別，以及re模組、sys模組、time模組，os模組的初步介紹。

1.模組的介紹

'''
整體說明：
01 模組是一系列常用功能的集合體，一個py檔案就是一個模組。主要是將一些相同功能的封裝到一個py檔案中，誰有誰拿。
02 為什麼要使用模組。
    （1）從檔案級別組織程式，更方便管理。不僅可以把這些檔案當做指令碼去執行，還可以把他們當做模組匯入到其他的模組中，實現了
         功能的重複利用。
    （2）拿來主義，提高開發效率。避免了重複造輪子。
03 import的使用
    （1）模組中包含的可執行語句和函式，只在模組名第一次遇到匯入import語句時才執行。
    （2）import語句可以在程式中的任意位置使用，且針對同一模組可以重複使用import進行多次匯入。
    （3）但是，第一次模組名載入到記憶體後，後續的import語句僅是對已經載入到記憶體中的模組增加了一次引用，不會重複執行模組中
         的語句和函式。
    （4）執行檔案和被引用模組：
        （a）執行檔案：直譯器執行的檔案。
        （b）被引用檔案：import
04 模組被引用的時候發生了三件事
    （1）為原始檔建立新的名稱空間。
    （2）引用模組中的所有內容都載入到記憶體中。
    （3）通過模組名+“.”的方式去引用模組中的物件（可執行的語句和函式）
05 為模組起別名的作用。
    （1）將模組名較長的變成較短的。
    （2) 拓展程式碼。
06 多個模組匯入
07 模組的引用順序：記憶體 ---> 內建模組（os,time sys..） ---> sys.path
    （1）python直譯器在啟動時會自動載入一些模組到記憶體中，可以使用sys.modules檢視。
08 可以使用__all__來控制*（用來發布新版本），在原始檔中指定兩個變數即__all__=['money','read1']，其他匯入的時候只能匯入該兩個變數
09 py檔案的兩種功能。
    （1）一：指令碼，一個檔案就是整個程式，用來被執行。
    （2）二：模組，檔案中存放著一堆功能，用來被匯入執行。
10 python中我們內建了全域性變數：__name__
    （1）當檔案被當做指令碼執行時：__name__等於“__main”
    （2）當檔案被當做模組匯入時：__name__等於模組名。
    （3）作用：用來控制py檔案在不同的應用場景下執行不同的邏輯（或者是在模組檔案中測試程式碼）

 
'''


# 01 第一次模組名載入到記憶體後，後續的import語句僅是對已經載入到記憶體中的模組增加了一次引用，不會重複執行模組中的語句和函式。
import mayugang
import mayugang
import mayugang

'''
執行結果：只打印一次
from the mayugang.py
'''

# 02 為模組起別名
# （1）將模組名較長的變成較短的。

import mayugang as myg
myg.read1()

# （2）有利於程式碼的拓展和優化。

import mysql1
import oracle1

sql = input("請輸入："
 
).strip()
if sql == 'mysql1':
    import mysql1 as db
elif sql == 'oracle1':
    import oracle1 as db

db.sentence()

# (3)多模組匯入的形式
import os
import time
import pickle

(4)from ...import ...
# 優點：方便使用。
# 缺點：可能會與執行檔案產生衝突。
# 不建議使用，或者可以在一定條件下使用。
name = '李蘋'
from mayugang import read1, name  # 將模組中的name = '馬玉剛' 覆蓋了name = '李蘋'。
 

read1()  #
print(name)
print(name)

'''
執行結果：name被覆蓋。
mayugang模組： 馬玉剛
馬玉剛
馬玉剛
'''

# （5）from 模組名 import *：代表引用全部物件（可執行物件和函式）
# 不建議使用以上方法進行全部引用。

# （6）模組的查詢順序：記憶體中已經載入的模組->內建模組->sys.path路徑中包含的模組
'''
模組的查詢順序
1、在第一次匯入某個模組時（比如spam），會先檢查該模組是否已經被載入到記憶體中（當前執行檔案的名稱空間對應的記憶體），如果有則直接引用
    ps：python直譯器在啟動時會自動載入一些模組到記憶體中，可以使用sys.modules檢視
2、如果沒有，直譯器則會查詢同名的內建模組
3、如果還沒有找到就從sys.path給出的目錄列表中依次尋找spam.py檔案。
'''
import sys

print(sys.path)  # 列印自定義模組
print(sys.modules)  #  python直譯器執行時自動載入到記憶體的一些模組
sys.path.append("module.zip")  # 增加自定義模組，增加後儘可以引用模組中的物件（可執行程式和函式）
print(sys.path)

# windows下的路徑需要加r開頭，否則會語法錯誤。
sys.path.insert(0,r'C:\Users\Administrator\PycharmProjects\a')

# （7）找到m1檔案的兩種方式：
# 方式一：
import sys
sys.path.append("D:\pythonweekend24\day07\mk")
import m1
m1.func1()
# 方式二：
from mk import m1
m1.func1()

 2.re模組

'''
整體說明：
01 什麼是正則？
    正則就是用一些具有特殊含義的符號組合到一起（稱為正則表示式）來描述字元或者字串的方法。或者說：正則就是用來描述一
    類事物的規則。（在Python中）它內嵌在Python中，並通過 re 模組實現。正則表示式模式被編譯成一系列的位元組碼，然後由用 C
    編寫的匹配引擎執行。
02 匹配規則說明：
    （1）\w     匹配字母（包含中文）或數字或下劃線
    （2）\W     匹配非字母（包含中文）或數字或下劃線
    （3）\s     匹配任意的空白符
    （4）\S     匹配任意非空白符
    （5）\d     匹配數字
    （6）\D     匹配非數字
    （7）\A     從字串開頭匹配
    （8）\z     匹配字串的結束，如果是換行，只匹配到換行前的結果
    （9）\Z     匹配字串的結束
    （10）\n     匹配一個換行符
    （11）\t     匹配一個製表符
    （12）^     匹配字串的開始
    （13）$     匹配字串的結尾
    （14）.     匹配任意字元，除了換行符，當re.DOTALL標記被指定時，則可以匹配包括換行符的任意字元。
    （15）[...]     匹配字元組中的字元
    （16）[^...]     匹配除了字元組中的字元的所有字元
    （17）*     匹配0個或者多個左邊的字元。
    （18）+     匹配一個或者多個左邊的字元。
    （19）？     匹配0個或者1個左邊的字元，非貪婪方式。
    （20）{n}     精準匹配n個前面的表示式。
    （21）{n,m}     匹配n到m次由前面的正則表示式定義的片段，貪婪方式
    （22）a|b     匹配a或者b。
    （23）()     匹配括號內的表示式，也表示一個組
 
'''

import re
# \w     匹配字母（包含中文）或數字或下劃線
# \W     匹配非字母（包含中文）或數字或下劃線
print(re.findall('\w','太白alex 123  _ *'))  # ['太', '白', 'a', 'l', 'e', 'x', '1', '2', '3', '_']
print(re.findall('\w\w','太白alex 123 _ *'))  # ['太白', 'al', 'ex', '12']
print(re.findall('\W\w','太白alex 123 _ *'))  # [' 1', ' _']

# \s     匹配任意的空白符:(\n和\t屬於空白符)
# \S     匹配任意非空白符
print(re.findall('\s','太白  123*\t\n'))  # [' ', ' ', '\t', '\n']
print(re.findall('\S','太白  123*\t\n'))  # ['太', '白', '1', '2', '3', '*']
print(re.findall('\s\S','太白  123*\t\n')) #[' 1']

# \d     匹配數字
# \D     p匹配非數字
print(re.findall('\d', '太白  123*'))  # ['1', '2', '3']
print(re.findall('\D', '太白  123*'))  # ['太', '白', ' ', ' ', '*']
print(re.findall('\D\d', '太白  123*'))  #[' 1']

# \A    從字串開頭匹配  # 只匹配開頭  相當於startswith
# ^    匹配字串的開始  只匹配開頭  相當於startswith
print(re.findall(r'\A太白', '** 太白 太白 123*'))  # []
print(re.findall(r'^太白', '太白 太白 123*'))  # ['太白']


# \n    匹配一個換行符
# \t    匹配一個製表符
print(re.findall('\n','** 太白 太白 \n123'))  # ['\n']
print(re.findall('\t','** 太白 太白 \n123\t\t'))  # ['\t', '\t']

# $ 匹配一個字串的結尾
print(re.findall('123$','** 太白 太白 123 '))   #[]
print(re.findall('123$','** 太白 太白 123'))  # ['123']

# 重複匹配： . ? * + {m,n} .* .*?
# . 任意字元   re.DOTALL 可以匹配換行符
print(re.findall('a.b', 'ab aab abb a*b a6b a b aaaab'))
print(re.findall('a.b', 'ab aab abb a*b a6b a3b a\nb', re.DOTALL))

# ? 匹配0個或者1個由左邊字元定義的片段。 貪婪匹配
print(re.findall('a?b', 'aab'))  # ['ab']
print(re.findall('a?b', 'ab aab abb a*b'))  # ['ab', 'ab', 'ab', 'b', 'b']

# *匹配0個或者多個左邊字元表示式。 滿足貪婪匹配 @@
print(re.findall('a*b', 'ab aab aaaaaaaaaab abbb'))

# + 匹配1個或者多個左邊字元。 滿足貪婪匹配
print(re.findall('a+b', 'ab aab aaab abbb'))


# {m,n}  匹配m個至n個左邊字元表示式。 滿足貪婪匹配  @@
print(re.findall('a{2,4}b', 'ab aab aaaab abbb'))


# 純貪模式 .* 一般不用
print(re.findall('a.*b', 'ea*b ab aab aaaaaaaaaab abbb'))  #  ['a*b ab aab aaaaaaaaaab abbb']

# 貪婪模式 .*?   .* 純貪  ? 作為限制 滿足我就取出
# .*? 常用模式
print(re.findall('a.*?b', 'a*b ab aab aaaaaaaaaab abbb'))  # ['a*b', 'ab', 'aab', 'aaaaaaaaaab', 'ab']

# [] 代表一個字元  # erw 任意選一個
print(re.findall('a[erw][erw]b', 'ab aab aeb arb arwb arewb'))
str1 = 'a1b a2b a3b aab aeb a9b'
str2 = 'a1b aTb a3b aAb aeb a_b ayb'
str3 = 'a1b aTb a3b a-b a%b a!b a&b'
print(re.findall('a[0-9]b',str1))  # ['a1b', 'a2b', 'a3b', 'a9b']
print(re.findall('a[a-z]b',str2))  # ['aab', 'aeb', 'ayb']
print(re.findall('a[a-z,A-Z]b', str2))
print(re.findall('a[-!&]b', str3))  # [] 想匹配"-" 一定要放到最前面
print(re.findall('a[^0-9]b', str3))  # "^" 中括號代表取反

# 分組 () 製造了一個模板(.*?)_sb
print(re.findall('(.*?)_sb', 'alex_sb wusir_sb 日天_sb'))
print(re.findall('http.*?com','<a href="http://www.baidu.com">點選</a><a href="http://www.baidu2.com">登入</a>'))
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">點選</a>'))

# | 左邊右邊都可以
# print(re.findall('alex|太白|wusir', 'alex太白wusiraleeeex太太白odlb'))  # ['alex', '太白', 'wusir', '太白']

print(re.findall('compan(ies|y)','Too many companies have gone bankrupt, and the next one is my company'))  # ['ies', 'y']
# 但是我想將 companies  company ?: 對分組進行一個應用，全部都取出來
print(re.findall('compan(?:ies|y)','Too many companies have gone bankrupt, and the next one is my company'))

# re模組的操作方法
# findall 找到全部
print(re.findall('a.b', 'abaabb'))

# search 相當於 in  （注意與group（）聯合使用）
print(re.search('sb|alex', 'alex sb sb barry 日天'))  # <_sre.SRE_Match object; span=(0, 4), match='alex'>
print(re.search('aaa', 'alex sb sb barry 日天'))  # <_sre.SRE_Match object; span=(0, 4), match='alex'>
print(re.search('sb|alex', ' 666 sb alex sb barry 日天').group())  # group相當於輸出可視檔案。

'''1 + 2*(3/5) + 2**3 - (2/3 + 3*(4-2))'''
#
# match 匹配的就是開始
print(re.match('aaa', 'aaa sb sb barry 日天'))  # <_sre.SRE_Match object; span=(0, 3), match='aaa'>
print(re.match('aaa', 'aa sb sb barry 日天'))  # None
print(re.findall('^aaa', 'aa sb sb barry 日天'))  # []

# split  ***
s1 = 'alex wusir 日天 太白'
s1 = 'alex wusir,日天;太白|二狗'
# print(s1.split())
# # 對字串按照不同分隔符進行分割  # \|是將|進行轉義。
print(re.split(' |,|;|\|',s1))
print(re.sub('barry', '太白', 'barry是最好的講師，barry就是一個普通老師，請不要將barry當男神對待。'))
print(re.sub('(alex)( )(is)( )(sb)', r'\5\2\3\4\1', r'alex is sb'))

'''
需求：
1，"1-2*(60+(-40.35/5)-(-4*3))"
'''
# 1.1 匹配所有的整數  (pass)
s1 = "1-2*(60+(-40.35/5)-(-4*3))"
# print(re.findall('\d+', s1))  # ['1', '2', '60', '40', '35', '5', '4', '3']

# 1.2 匹配所有的數字（包含小數）  # 0也是整數
print(re.findall('\d+\.?\d*', s1))

# 1.3 匹配所有的數字，包括負號
print(re.findall('-?\d+\.?\d*', s1))  # ['1', '-2', '60', '-40.35', '5', '-4', '3']


# 需求：找到所有的P標籤
s1 = '''
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/7459977.html" target="_blank">python基礎一</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/7562422.html" target="_blank">python基礎二</a></p>
<p><a style="text-decoration: underline;" href="https://www.cnblogs.com/jin-xin/articles/9439483.html" target="_blank">Python最詳細，最深入的程式碼塊小資料池剖析</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/7738630.html" target="_blank">python集合,深淺copy</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8183203.html" target="_blank">python檔案操作</a></p>
<h4 style="background-color: #f08080;">python函式部分</h4>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8241942.html" target="_blank">python函式初識</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8259929.html" target="_blank">python函式進階</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8305011.html" target="_blank">python裝飾器</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8423526.html" target="_blank">python迭代器,生成器</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8423937.html" target="_blank">python內建函式,匿名函式</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8743408.html" target="_blank">python遞迴函式</a></p>
<p><a style="text-decoration: underline;" href="https://www.cnblogs.com/jin-xin/articles/8743595.html" target="_blank">python二分查詢演算法</a></p>
'''
print(re.findall('<p>.*?</p>', s1))

3.sys模組

'''
整體說明：
01 sys模組是與python直譯器互動的一個介面。
02 sys.argv           命令列引數List，第一個元素是程式本身路徑
03 sys.exit(n)        退出程式，正常退出時exit(0),錯誤退出sys.exit(1)
04 sys.version        獲取Python解釋程式的版本資訊
05 sys.path           返回模組的搜尋路徑，初始化時使用PYTHONPATH環境變數的值
06 sys.platform       返回作業系統平臺名稱
'''
import sys

# 01 sys常用的模組
print(sys.path)
# sys.exit()  # 終止程式
print(666)
print(sys.version)
print(sys.platform)  # 返回windows系統名稱
print(sys.modules)  # 直譯器自動載入到記憶體的模組和包
sys.exit(0)

# 02 sys的異常處理和status

try:
    sys.exit(1)
except SystemExit as e:
    print(e)

4.time模組

'''
整體說明：
01 和時間有關係的我們就要用到時間模組。在使用模組之前，應該首先匯入這個模組。
02 常用方法
    （1）time.sleep(secs)  ：(執行緒)推遲指定的時間執行。單位為秒。
    （2）time.time()  ：獲取當前時間戳
03 表示時間的3種方式：時間戳、元組(struct_time)、格式化的時間字串
    （1）方式一：時間戳(timestamp) ：通常來說，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。
                我們執行“type(time.time())”，返回的是float型別。
    （2）方式二：格式化的時間字串(Format String)： ‘1999-12-06’
    （3）方式三：元組(struct_time) ：struct_time元組共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天等）
'''

# 01 匯入時間模組
import  time

# 02 時間戳
print(time.time())  # 1543240463.5829234

# 03 時間字串
print(time.strftime('%Y-%m-%d'))

# 04 時間元祖：localtime將一個時間戳轉換為當前時區的struct_time
print(time.localtime())

'''
執行結果：
time.struct_time(tm_year=2018, tm_mon=11, tm_mday=26, tm_hour=21, tm_min=58, tm_sec=27, tm_wday=0, tm_yday=330, tm_isdst=0)
'''

5.os模組

'''
整體說明：
01 os模組是與作業系統互動的一個介面。
'''

import os
# 複製程式碼#當前執行這個python檔案的工作目錄相關的工作路徑

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  獲取系統環境變數

#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的大小