Python學習：9.模塊的安裝以及調用模塊

時間 2019-11-21

原文原文鏈接

什麼是模塊python

　　在Python中，模塊其實也就是包含python代碼的文件，咱們爲何要使用模塊？在咱們之後寫代碼的時候，咱們會發現有不少功能須要常用，那咱們想要使用這些功能怎麼辦，要再把那些代碼在敲一遍嗎，這樣不但增長了代碼量，還浪費了時間，有人說咱們能夠寫在函數裏，是的，咱們能夠把一些功能寫在函數裏，使用的時候調用函數就好了，可是咱們每次新建一個文件的時候，都須要再次將那些功能函數寫一遍，仍是有些麻煩，這時候，模塊的便捷就體現出來了，咱們將大量功能函數寫在一個py文件裏，當咱們須要用到部分功能的時候，將這個文件（模塊）導入一下，就能夠輕鬆地調用裏面的函數了。固然模塊中不只能夠寫函數，也能夠寫類。正則表達式

模塊的調用算法

1.import語句，用於導入整個模塊

import module1
import module as module_a
#給導入的模塊自定義一個別名

import sys
import time as ti

2.form..import，用於導入模塊的某一部分功能或模糊導入

from module import name
from random import *
#導入random中全部屬性

使用import導入模塊內部機制shell

import語句導入指定的模塊時會執行3個步驟
1. 找到模塊文件：在模塊搜索路徑下搜索模塊文件
　　程序的主目錄
　　PYTHONPATH目錄
　　標準連接庫目錄json

2.編譯成字節碼：文件導入時會編譯，所以，頂層文件的.pyc字節碼文件在內部使用後會被丟棄，只有被導入的文件纔會留下.pyc文件
3.執行模塊的代碼來建立其所定義的對象：模塊文件中的全部語句從頭到尾依次執行，而此步驟中任何對變量名的賦值運算，都會產生所獲得的模塊文件的屬性
注意：模塊只在第一次導入時纔會執行如上步驟，後續的導入操做只不過是提取內存中已加載的模塊對象，reload()可用於從新加載模塊bash

自定義模塊app

所謂的自定義模塊就是本身建立一個python文件，在裏面寫入了一些函數或者類，在本身定義文件名的時候，注意不能把本身文件的名字定義和已經存在的模塊的名字重複，不然導入模塊的時候可能導入的模塊不是你想要的模塊。dom

先在一個.py文件內寫一個函數，而後再另外一個文件內import 文件名,而後再寫使用文件名.函數名調用函數。函數

import 文件名 


文件名.函數名()

導入模塊時須要根據sys.path的路徑找，爲了咱們自定義的模塊能夠成功導入，咱們須要把本身寫的py文件的路徑添加到sys.path。工具

import sys
sys.path.append("d:")
#這個"d:"是你py文件放置的位置

查看模塊搜索路徑有哪些，本身添加的路徑是否在搜索路徑中。

import sys
for i in sys.path:
    print(i)

內置模塊

內置模塊是python自帶功能，使用的時候直接使用import或者from..import導入模塊便可。

python中有哪些內置模塊，接下來就介紹一下：

1、OS

用於提供操做系統級別的操做

os.getcwd()                 獲取當前工做目錄，即當前python腳本工做的目錄路徑
        os.chdir("dirname")         改變當前腳本工做目錄；至關於shell下cd
        os.curdir                   返回當前目錄: ('.')
        os.pardir                   獲取當前目錄的父目錄字符串名：('..')
        os.makedirs('dir1/dir2')    可生成多層遞歸目錄
        os.removedirs('dirname1')   若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
        os.mkdir('dirname')         生成單級目錄；至關於shell中mkdir dirname
        os.rmdir('dirname')         刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中rmdir dirname
        os.listdir('dirname')       列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表方式打印
        os.remove()                 刪除一個文件
        os.rename("oldname","new")  重命名文件/目錄
    *   os.stat('path/filename')    獲取文件/目錄信息
        　　import os
        　　info = os.stat("D:\\文件名，需帶後綴")
        　　print(info)


        os.sep                      操做系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
        os.linesep                  當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
        os.pathsep                  用於分割文件路徑的字符串
        os.name                     字符串指示當前使用平臺。win->'nt'; Linux->'posix'
        os.system("bash command")   運行shell命令，直接顯示
        　　import os
        　　os.system("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[, ...]])** 將多個路徑組合後返回，第一個絕對路徑以前的參數將被忽略
        　　import os 
        　　str1 = "D:"
        　　str2 = "home"
        　　str3 = "index"
        　　n = os.path.join(str1,str2,str3)
       　　 print(n)
        　　#結果  #本身根據順序添加分割符
        　　D:home\index

        
        os.path.getatime(path)      返回path所指向的文件或者目錄的最後存取時間
        os.path.getmtime(path)      返回path所指向的文件或者目錄的最後修改時間

2、sys

用於提供對python解釋器相關的操做

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       返回操做系統平臺名稱
7 sys.stdin          輸入相關
8 sys.stdout         輸出相關
9 sys.stderror       錯誤相關

3、hashlib

用於加密相關的操做，代替了md5模塊和sha模塊，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法。

import hashlib

########md5#########

hash = hashlib.md5()
hash.update(bytes("admin", encoding="utf-8"))
print(hash.hexdigest())
print(hash.digest())

######## sha1 ########

hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha256 ########

hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha384 ########

hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha512 ########

hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
#以上加密算法雖然依然很是厲害，但時候存在缺陷，即：經過撞庫能夠反解。因此，有必要對加密算法中添加自定義key再來作加密。

import hashlib

# ######## md5 ########

hash = hashlib.md5(bytes('898oaFs09f', encoding="utf-8"))
hash.update(bytes('admin', encoding="utf-8"))
print(hash.hexdigest())

#python內置還有一個hmac模塊，它內部對咱們建立key和內容進行進一步的處理而後再加密

import hmac

h = hmac.new(bytes('898oaFs09f', encoding="utf-8"))
h.update(bytes('admin', encoding="utf-8"))
print(h.hexdigest())

#加鹽值的加密（加密兩次的加密）
import hashlib

# 本身加的加密規則
hash = hashlib.md5(bytes("admafasdin", encoding="utf-8"))
hash.update(bytes("admin", encoding="utf-8"))
print(hash.hexdigest())

4、re

python中提供了正則表達式相關操做

re.match()

#從頭匹配
#最開始哪一個字符（或字符串）開始匹配上後面的所有忽略
#簡單
#分組

無分組

# 無分組
import re

origin = "hello alex bcd alex lge alex acd 19"
r = re.match("h\w+", origin)
print(r.group())  # 獲取匹配到的全部結果
print(r.groups())  # 獲取模型中匹配到的分組結果
print(r.groupdict())  # 獲取模型中匹配到的分組結果

結果
hello
()
{}

分組

# 分組
# 分組的用處:從已經匹配到的字符串裏在獲取其中的某個字符
import re

origin = "hello alex bcd alex lge alex acd 19"
r = re.match("h(\w+)", origin)
print(r.group())  # 獲取匹配到的全部結果
print(r.groups())  # 獲取模型中匹配到的分組結果（括號（組）裏的內容）
print(r.groupdict())  # 獲取模型中匹配到的分組結果

結果：
hello
('ello',)
{}

#有組（括號）只有groups能夠匹配到，有key只有gruopdict能夠匹配到

origin = "hello alex bcd alex lge alex acd 19"


r = re.match("(h)\w+", origin)
print(r.groups())  # 獲取模型中匹配到的分組結果

結果：('h',)

r = re.match("?P<n1>h(\w+)", origin)  # ?P<x>  x爲key字典類型
print(r.groupdict())  # 獲取模型中匹配到的分組結果
r = re.match("?P<n1>h(?P<n2>\w+)", origin)  # key ?P<> 的值爲後面的字符串
print(r.groupdict())  # 獲取模型中匹配到的分組結果

 結果：
{'n1': 'h'}
{'n1': 'h', 'n2': 'ello'}

re.search()
瀏覽所有字符串，匹配第一個符合規則的字符串
和match用法差很少，search只不過這個所有瀏覽，一個一個字符的匹配

origin = "hello alex bcd alex lge alex acd 19"
r = re.search("a\w+", origin)
print(r.group())  # 獲取匹配到的全部結果
print(r.groups())  # 獲取模型中匹配到的分組結果
print(r.groupdict())  # 獲取模型中匹配到的分組結果

結果：
alex
()
{}

origin = "hello alex bcd alex lge alex acd 19"
r = re.search("a(\w+).*(?P<name>\d)$", origin)
print(r.group())  # 獲取匹配到的全部結果                      #上下兩個也相同
print(r.groups())  # 獲取模型中匹配到的分組結果#顯示組的結果，忽略掉本身不匹配的好比?P<name>
print(r.groupdict())  # 獲取模型中匹配到的分組結果

結果：
alex bcd alex lge alex acd 19
('lex', '9')
{'name': '9'}


import re
origin = "hello alex bcd alex lge alex acd 19"
n = re.search("(a)(\w+)",origin)
print(n.group())
print(n.groups())

結果：
alex
('a', 'lex')

re.findall()
在字符串中找到正則表達式所匹配的全部子串，並返回一個列表，若是沒有找到匹配的，則返回空列表。

import re
re.findall("\d+\w\d+","a2b3c4d5")
#匹配時是逐個匹配，匹配到以後，下一輪匹配時就從他的後面開始匹配
結果:['2b3', '4d5']

findall特別
print(re.findall("","asdfasdf"))
結果：
['', '', '', '', '', '', '', '', '']

當元素處理時，有幾個括號就有幾個組，就要分幾個，若是第一個匹配了，第二個，沒有匹配可是第二個無關緊要，可是在第二個的位置上第三個匹配了，就會生成三個，其中一個留給沒有匹配的，留的那個爲空。

import re
origin = "hello alex bcd alex lge alex acd 19"
print(re.findall("a\w+",origin))
print(re.findall("(a\w+)",origin))
print(re.findall("a(\w+)",origin))
#加括號之後，就行當於把按照規則匹配後，把括號裏的輸出，不在括號裏的就不輸出
結果：   
['alex', 'alex', 'alex', 'acd']
['alex', 'alex', 'alex', 'acd']
['lex', 'lex', 'lex', 'cd']

origin = "hello alex bcd alex lge alex acd 19"
n = re.search("(a)(\w+)", origin)
print(re.findall("(a)(\w+)",origin))#在規則都匹配過一次時，先把這些放在一個括號裏，以後一次匹配放在一個括號裏，再匹配再放
print(n.groups())                                #結果第一個
結果：
[('a', 'lex'), ('a', 'lex'), ('a', 'lex'), ('a', 'cd')]
('a', 'lex')


                                #origin爲上面的
print(re.findall("(a)(\w+(e))(x)",origin))
結果：#先找到a放進組裏，再找到le放進組裏，再從le裏找到e放進組裏，在找到x放進組裏
[('a', 'le', 'e', 'x'), ('a', 'le', 'e', 'x'), ('a', 'le', 'e', 'x')]
#括號的意思是從提取到的內容裏再次提取內容，有幾個括號提取幾回
例子：
origin = "hello alex bcd alex lge alex acd 19"
print(re.findall("(a)((\w+)(e))(x)",origin))
[('a', 'le', 'l', 'e', 'x'), ('a', 'le', 'l', 'e', 'x'), ('a', 'le', 'l', 'e', 'x')]
#詳情請看199


import re
a = "alex"
n = re.findall("(\w){4}",a)#理論上它輸出了四次，可是它只有一個括號，因此取一個，並且默認去最後一個
n1 = re.findall("(\w)(\w)(\w)(\w)",a)
n3 = re.findall("(\w)*",a)詳解199 24
print(n)
print(n1)
print(n3)
結果
['x']
[('a', 'l', 'e', 'x')]
['x', '']
#findall其實就是search的groups組合而來
#當加有*時，前面那個無關緊要因此當匹配不到或匹配到最後時，會以空的再匹配一次？？？？

import re
n = re.findall("(\dasd)*","1asd2asdp3asd98kif")
print(n)
#結果  #那麼多空，由於貪婪匹配 #連續兩次匹配到就去後面那個，帶括號狀況下
['2asd', '', '3asd', '', '', '', '', '', ''] #詳解200 6 or 7

re.finditer()
和 findall 相似，在字符串中找到正則表達式所匹配的全部子串，並把它們做爲一個迭代器返回。

import re

origin = "hello alex bcd alex lge alex acd 19"
r = re.finditer("(a)((\w+)(e))(?P<n1>x)",origin)
print(r)
for i in r:
    print(i,i.group(),i.groups(),i.groupdict())
    

結果：
<callable_iterator object at 0x0000000687374C50>
<_sre.SRE_Match object; span=(6, 10), match='alex'> alex ('a', 'le', 'l', 'e', 'x') {'n1': 'x'}
<_sre.SRE_Match object; span=(15, 19), match='alex'> alex ('a', 'le', 'l', 'e', 'x') {'n1': 'x'}
<_sre.SRE_Match object; span=(24, 28), match='alex'> alex ('a', 'le', 'l', 'e', 'x') {'n1': 'x'}

re.split()

方法按照可以匹配的子串將字符串分割後返回列表

import re

origin = "hello alex bcd alex lge alex acd 19"
ddd = "hello alex bcd alex ddaf lge alex acd 19"
n = re.split("a\w+", origin, 1)  # 1爲分割次數
n1 = re.split("a\w+", ddd)
print(n)
print(n1)
結果
['hello ', ' bcd ', ' lge ', ' ', ' 19']
['hello ', ' bcd ', ' dd', ' lge ', ' ', ' 19']

origin = "hello alex bcd alex lge alex acd 19"
n = re.split("a(\w+)", origin, )
print(n)
結果  # 由於被分割了，因此n有三個部分，就像下面，n[1]第一部分 n[2]第二部分 n[3]第三部分
['hello ', 'lex', ' bcd alex lge alex acd 19']

# 中括號裏面的字符無需轉意，可是正則表達式裏的括號有特殊意義，因此正常狀況下須要轉意

re.sub()
替換匹配成功的指定位置的字符串

sub(模型，替換成什麼，所要替換的字符串，替換到前幾個，模式)

origin = "jhasdjas4dg564jskdbf5s41g56asg"
str_n = re.sub("\d+","KKK",origin,5)
print(str_n)

結果
jhasdjasKKKdgKKKjskdbf5s41g56asg

subn()      #subn返回兩個元素
origin = "jhasdjas4dg564jskdbf5s41g56asg"
new_str,count = re.subn("\d+","KKK",origin)
print(new_str,count)

結果：                    #5爲匹配個數
jhasdjasKKKdgKKKjskdbfKKKsKKKgKKKasg 5

5、json模塊

用於字符串和python基本數據類型之間轉換

json模塊中提供了四個功能：dumps、dump、loads、load

import json
result = json.loads(s)#將字符串類型轉換爲一種類型（看起來像什麼轉什麼）可是須要徹底符合那種類型的條件
print(result,type(result))
#json.loads用於將字典、列表、元組形式的字符串，轉換爲相應的字典、列表、元組
#json.dumps將基本數據類型轉換爲字符串

json.dump()
json.load()#這兩個基本不用，能夠不記

import json
dic = {"k1":123,"k2":"asd"}
json.dump(dic,open("hp","w"))#將dic字符串寫到hp文件裏面來

r = json.load(open("hp","r"))#將hp文件裏的字符串讀出，轉爲相應的類型

json是通用的數據傳輸，能夠和多種語言轉換，在用元組轉換時可能出現錯誤，由於這種類型是python裏特有的因此，別的可能沒法識別。

6、pickle模塊

用於python特有的類型和python基本數據類型間進行轉換

pickle模塊提供了四個功能：dumps、dump、loads、load

pickle模塊用於將內存中的python對象序列化成字節流，並能夠寫入任何相似文件對象中；它也能夠根據序列化的字節流進行反序列化，將字節流還原爲內存中的對象。

#pickle使用dump方法將內存對象序列化：
import pickle

li = list(range(1,3))
dbfile = open('pickle_list', 'wb')    #必須以2進制打開文件，不然pickle沒法將對象序列化只文件
pickle.dump(li, dbfile)
dbfile.close()

#以上代碼即將list對象li序列化至文件「pickle_list"中，下次再次運行時，能夠經過pickle的load方法恢復list對象：
import pickle

dbfile = open('pickle_list', 'rb')
li = pickle.load(dbfile)
dbfile.close()

json模塊和pickle模塊的區別

#pickle能夠將任何數據類型序列化，json只能列表字典字符串數字等簡單的數據類型，複雜的不能夠
#可是pickle只能在python中使用，json能夠支持多個語言

6、time模塊

時間相關的操做

print(time.time())
# 時間戳 從1970年1月1號開始到如今一共過去了多少秒

print(time.ctiem())
# 輸出當前系統時間

print(time.ctime(time.time() - 86640))
# 將時間戳轉爲字符串格式

print(time.gmtime(time.time() - 86640))
結果
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=7, tm_hour=7, tm_min=32, tm_sec=49, tm_wday=0, tm_yday=219, tm_isdst=0)

time_obj = time.gmtime(time.time() - 86640)
print(time_obj)  # 根據上面的輸出內容進行格式化輸出
print(str(time_obj.tm_year) + "-" + str(time_obj.tm_mon) + "-" + str(time_obj.tm_mday))
結果
　　　　 2018 - 6 - 17  # 加上str是由於他們原來是整形的
用字符串格式化輸出
print("%s-%s-%s" % (time_obj.tm_year, time_obj.tm_mon, time_obj.tm_mday))
結果爲
2018 - 6 - 17
格林威治時間

time.locatime(time.time() - 86640)
# 本地時間（本機時間）

time.strftime("%Y-%m=%d %H:%M:%S", time.localtime())
# 格式化輸出時間能夠將time.localtime替換爲其餘時間
# strftime將給定對象轉成給定格式

time.strptime("2016/05/22", "%Y/%m/%d")
# 將 日期字符串 轉成 struct時間對象格式
# 就是上面那個反過來
# 代表時間格式轉換成struct時間格式

7、datetime模塊

datatime模塊從新封裝了time模塊，提供更多接口

print(datetime.date.today())
#輸出格式2016-01-26

print(datetime.date.fromtimestamp(timetime()-86400))
#2016-01-26 將時間戳轉換爲日期格式

current_time = datetime.datetime.now()
print(current_time)
#輸出2017-08-08 20:33:12.870346
print(current_time.timetuple)
#返回struct_time格式
print(current_time.replace())#輸出如今時間
print(current_time.replace(1996,5,20))#輸出給定時間


print(datetime.datetime.now() )#當前時間
print(datetime.datetime.now() + datetime.timedelta(3)) #當前時間+3天
print(datetime.datetime.now() + datetime.timedelta(-3)) #當前時間-3天
print(datetime.datetime.now() + datetime.timedelta(hours=3)) #當前時間+3小時
print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #當前時間+30
#這裏能夠進行的操做
#days=None, seconds=None, microseconds=None, milliseconds=None, minutes=None,
#hours=None, weeks=None