一、模塊&包

模塊(modue)的概念：

成都創(chuàng)新互聯(lián)公司是專業(yè)的荊州網(wǎng)站建設(shè)公司，荊州接單;提供成都網(wǎng)站建設(shè)、網(wǎng)站制作,網(wǎng)頁設(shè)計(jì),網(wǎng)站設(shè)計(jì),建網(wǎng)站,PHP網(wǎng)站建設(shè)等專業(yè)做網(wǎng)站服務(wù);采用PHP框架,可快速的進(jìn)行荊州網(wǎng)站開發(fā)網(wǎng)頁制作和功能擴(kuò)展;專業(yè)做搜索引擎喜愛的網(wǎng)站,專業(yè)的做網(wǎng)站團(tuán)隊(duì),希望更多企業(yè)前來合作!

在計(jì)算機(jī)程序的開發(fā)過程中，隨著程序代碼越寫越多，在一個(gè)文件里代碼就會(huì)越來越長，越來越不容易維護(hù)。

為了編寫可維護(hù)的代碼，我們把很多函數(shù)分組，分別放到不同的文件里，這樣，每個(gè)文件包含的代碼就相對較少，很多編程語言都采用這種組織代碼的方式。在Python中，一個(gè).py文件就稱之為一個(gè)模塊（Module）。

使用模塊有什么好處？

最大的好處是大大提高了代碼的可維護(hù)性。

其次，編寫代碼不必從零開始。當(dāng)一個(gè)模塊編寫完畢，就可以被其他地方引用。我們在編寫程序的時(shí)候，也經(jīng)常引用其他模塊，包括Python內(nèi)置的模塊和來自第三方的模塊。

所以，模塊一共三種：

• python標(biāo)準(zhǔn)庫
• 第三方模塊
• 應(yīng)用程序自定義模塊

另外，使用模塊還可以避免函數(shù)名和變量名沖突。相同名字的函數(shù)和變量完全可以分別存在不同的模塊中，因此，我們自己在編寫模塊時(shí)，不必考慮名字會(huì)與其他模塊沖突。但是也要注意，盡量不要與內(nèi)置函數(shù)名字沖突。

模塊導(dǎo)入方法

1. import 語句

import module1[, module2[,... moduleN]

當(dāng)我們使用import語句的時(shí)候，Python解釋器是怎樣找到對應(yīng)的文件的呢？答案就是解釋器有自己的搜索路徑，存在sys.path里。

['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu',
'/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']　

2. from…import 語句

from modname import  name1[, name2[, ... nameN]]

這個(gè)聲明不會(huì)把整個(gè)modulename模塊導(dǎo)入到當(dāng)前的命名空間中，只會(huì)將它里面的name1或name2單個(gè)引入到執(zhí)行這個(gè)聲明的模塊的全局符號表。

運(yùn)行本質(zhì)

#1 import test
#2 from test import add　　

無論1還是2，首先通過sys.path找到test.py,然后執(zhí)行test腳本（全部執(zhí)行），區(qū)別是1會(huì)將test這個(gè)變量名加載到名字空間，而2只會(huì)將add這個(gè)變量名加載進(jìn)來。

包(package)

如果不同的人編寫的模塊名相同怎么辦？為了避免模塊名沖突，Python又引入了按目錄來組織模塊的方法，稱為包（Package）。

請注意，每一個(gè)包目錄下面都會(huì)有一個(gè)init.py的文件，這個(gè)文件是必須存在的，否則，Python就把這個(gè)目錄當(dāng)成普通目錄(文件夾)，而不是一個(gè)包。init.py可以是空文件，也可以有Python代碼，因?yàn)?strong>init.py本身就是一個(gè)模塊，而它的模塊名就是對應(yīng)包的名字。

如果我們是直接執(zhí)行某個(gè).py文件的時(shí)候，該文件中那么”name== 'main'“是True,但是我們?nèi)绻麖牧硗庖粋€(gè).py文件通過import導(dǎo)入該文件的時(shí)候，這時(shí)name的值就是我們這個(gè)py文件的名字而不是main。

這個(gè)功能還有一個(gè)用處：調(diào)試代碼的時(shí)候，在”if name== 'main'“中加入一些我們的調(diào)試代碼，我們可以讓外部模塊調(diào)用的時(shí)候不執(zhí)行我們的調(diào)試代碼，但是如果我們想排查問題的時(shí)候，直接執(zhí)行該模塊文件，調(diào)試代碼能夠正常運(yùn)行！

二、time模塊

三種時(shí)間表示

• 時(shí)間戳(timestamp) ：         通常來說，時(shí)間戳表示的是從1970年1月1日00:00:00開始按秒計(jì)算的偏移量。我們運(yùn)行“type(time.time())”，返回的是float類型。
• 格式化的時(shí)間字符串
• 元組(struct_time)   ：         struct_time元組共有9個(gè)元素共九個(gè)元素:(年，月，日，時(shí)，分，秒，一年中第幾周，一年中第幾天，夏令時(shí))

import time

# 1 time() :返回當(dāng)前時(shí)間的時(shí)間戳
time.time()  #1473525444.037215

# 2 localtime([secs])
# 將一個(gè)時(shí)間戳轉(zhuǎn)換為當(dāng)前時(shí)區(qū)的struct_time。secs參數(shù)未提供，則以當(dāng)前時(shí)間為準(zhǔn)。
time.localtime() #time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0,
# tm_min=38, tm_sec=39, tm_wday=6, tm_yday=255, tm_isdst=0)
time.localtime(1473525444.037215)

# 3gmtime([secs]) 和localtime()方法類似，gmtime()方法是將一個(gè)時(shí)間戳轉(zhuǎn)換為UTC時(shí)區(qū)（0時(shí)區(qū)）的struct_time。

# 4 mktime(t) : 將一個(gè)struct_time轉(zhuǎn)化為時(shí)間戳。
print(time.mktime(time.localtime()))#1473525749.0

# 5 asctime([t]) : 把一個(gè)表示時(shí)間的元組或者struct_time表示為這種形式：'Sun Jun 20 23:21:05 1993'。
# 如果沒有參數(shù)，將會(huì)將time.localtime()作為參數(shù)傳入。
print(time.asctime())#Sun Sep 11 00:43:43 2016

#----------------------------------------------------------

# 6 ctime([secs]) : 把一個(gè)時(shí)間戳（按秒計(jì)算的浮點(diǎn)數(shù)）轉(zhuǎn)化為time.asctime()的形式。如果參數(shù)未給或者為
# None的時(shí)候，將會(huì)默認(rèn)time.time()為參數(shù)。它的作用相當(dāng)于time.asctime(time.localtime(secs))。
print(time.ctime())  # Sun Sep 11 00:46:38 2016

print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016

# 7 strftime(format[, t]) : 把一個(gè)代表時(shí)間的元組或者struct_time（如由time.localtime()和
# time.gmtime()返回）轉(zhuǎn)化為格式化的時(shí)間字符串。如果t未指定，將傳入time.localtime()。如果元組中任何一個(gè)
# 元素越界，ValueError的錯(cuò)誤將會(huì)被拋出。
print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56

# 8 time.strptime(string[, format])
# 把一個(gè)格式化時(shí)間字符串轉(zhuǎn)化為struct_time。實(shí)際上它和strftime()是逆操作。
print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))

#time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,
#  tm_wday=3, tm_yday=125, tm_isdst=-1)

#在這個(gè)函數(shù)中，format默認(rèn)為："%a %b %d %H:%M:%S %Y"。

# 9 sleep(secs)
# 線程推遲指定的時(shí)間運(yùn)行，單位為秒。

# 10 clock()
# 這個(gè)需要注意，在不同的系統(tǒng)上含義不同。在UNIX系統(tǒng)上，它返回的是“進(jìn)程時(shí)間”，它是用秒表示的浮點(diǎn)數(shù)（時(shí)間戳）。
# 而在WINDOWS中，第一次調(diào)用，返回的是進(jìn)程運(yùn)行的實(shí)際時(shí)間。而第二次之后的調(diào)用是自第一次調(diào)用以后到現(xiàn)在的運(yùn)行
# 時(shí)間，即兩次時(shí)間差。

三、random模塊

import random
print(random.random()) #產(chǎn)生一個(gè)0到3的隨機(jī)浮點(diǎn)數(shù)，
print(random.uniform(1,100)) #產(chǎn)生一個(gè)自定義范圍的浮點(diǎn)數(shù)
print(random.randint(0,5)) #產(chǎn)生一個(gè)指定范圍的隨機(jī)整數(shù)，包括5
print(random.randrange(0,5)) #產(chǎn)生一個(gè)指定范圍的隨機(jī)整數(shù)，不包括5
print(random.choice([1,23,33])) #在給定的列表內(nèi)隨機(jī)選取一個(gè)數(shù)字
print(random.sample([1,2,3,4],2)) #在給定的列表表隨機(jī)選取2個(gè)數(shù)字

l=[1,2,3,4,5]
random.shuffle(l) #打亂列表里元素的位置順序
print(l)

#----生成隨機(jī)碼函數(shù)----
def code_v(x): #x表示要生成多少位的隨機(jī)數(shù)
    code_str=''
    for i in range(10):
        code_int=random.randint(0,9) #生成數(shù)字
        code_alp_A=chr(random.randint(65,90)) #生成大寫字母
        code_alp_a=chr(random.randint(97,122)) #生成小寫字母
        code_alp=random.choice([code_alp_A,code_alp_a]) #從大小寫字母 隨機(jī)選取一個(gè)
        code_res=str(random.choice([code_int,code_alp])) #從數(shù)字和最終的字母隨機(jī)選取一個(gè)
        code_str += code_res #拼接字符串
    return code_str

print(code_v(5))

四、os模塊

os模塊是與操作系統(tǒng)交互的一個(gè)接口

os.getcwd() 獲取當(dāng)前工作目錄，即當(dāng)前python腳本工作的目錄路徑
os.chdir("dirname")  改變當(dāng)前腳本工作目錄；相當(dāng)于shell下cd
os.curdir  返回當(dāng)前目錄: ('.')
os.pardir  獲取當(dāng)前目錄的父目錄字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多層遞歸目錄
os.removedirs('dirname1')    若目錄為空，則刪除，并遞歸到上一級目錄，如若也為空，則刪除，依此類推
os.mkdir('dirname')    生成單級目錄；相當(dāng)于shell中mkdir dirname
os.rmdir('dirname')    刪除單級空目錄，若目錄不為空則無法刪除，報(bào)錯(cuò)；相當(dāng)于shell中rmdir dirname
os.listdir('dirname')    列出指定目錄下的所有文件和子目錄，包括隱藏文件，并以列表方式打印
os.remove()  刪除一個(gè)文件
os.rename("oldname","newname")  重命名文件/目錄
os.stat('path/filename')  獲取文件/目錄信息
os.sep    輸出操作系統(tǒng)特定的路徑分隔符，win下為"\\",Linux下為"/"
os.linesep    輸出當(dāng)前平臺使用的行終止符，win下為"\t\n",Linux下為"\n"
os.pathsep    輸出用于分割文件路徑的字符串 win下為;,Linux下為:
os.name    輸出字符串指示當(dāng)前使用平臺。win->'nt'; Linux->'posix'
os.system("bash command")  運(yùn)行shell命令，直接顯示
os.environ  獲取系統(tǒng)環(huán)境變量
os.path.abspath(path)  返回path規(guī)范化的絕對路徑
os.path.split(path)  將path分割成目錄和文件名二元組返回
os.path.dirname(path)  返回path的目錄。其實(shí)就是os.path.split(path)的第一個(gè)元素
os.path.basename(path)  返回path最后的文件名。如何path以／或\結(jié)尾，那么就會(huì)返回空值。即os.path.split(path)的第二個(gè)元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是絕對路徑，返回True
os.path.isfile(path)  如果path是一個(gè)存在的文件，返回True。否則返回False
os.path.isdir(path)  如果path是一個(gè)存在的目錄，則返回True。否則返回False
os.path.join(path2[, path3[, ...]])  將多個(gè)路徑組合后返回，第一個(gè)絕對路徑之前的參數(shù)將被忽略
os.path.getatime(path)  返回path所指向的文件或者目錄的最后存取時(shí)間
os.path.getmtime(path)  返回path所指向的文件或者目錄的最后修改時(shí)間

如何讓程序自動(dòng)導(dǎo)入path路徑

import sys,os
e=os.path.abspath(__file__) #獲取當(dāng)前執(zhí)行腳本的絕對路徑
f=os.path.dirname(e)   # 獲取腳本執(zhí)行的目錄
l=os.path.dirname(f)  #獲取腳本執(zhí)行的上級目錄。也就是獲取到模塊目錄的父母錄
print(l)
sys.path.append(l)  導(dǎo)入目錄
from my_module import cal

cal.lxd() 執(zhí)行自定義目錄模塊、驗(yàn)證

五、sys模塊

sys.argv

import sys
print(sys.argv)

command=sys.argv[1]  #獲取腳本執(zhí)行時(shí)第一個(gè)參數(shù) post
path=sys.argv[2]  #獲取腳本執(zhí)行時(shí)，第二個(gè)參數(shù)  lingxd

執(zhí)行腳本時(shí)，傳入?yún)?shù)python 1.py  post lingxd

sys.exit(n)        退出程序，正常退出時(shí)exit(0)
sys.version        獲取Python解釋程序的版本信息
sys.path           返回模塊的搜索路徑，初始化時(shí)使用PYTHONPATH環(huán)境變量的值
sys.platform       返回操作系統(tǒng)平臺名稱

進(jìn)度條

import sys,time
for i in range(100):
    sys.stdout.write('#') #這一步相當(dāng)于print
    time.sleep(0.1)
    sys.stdout.flush()  #刷新

六、json &pickle模塊

eval內(nèi)置方法可以將一個(gè)字符串轉(zhuǎn)成python對象，不過，eval方法是有局限性的，對于普通的數(shù)據(jù)類型，json.loads和eval都能用，但遇到特殊類型的時(shí)候，eval就不管用了,所以eval的重點(diǎn)還是通常用來執(zhí)行一個(gè)字符串表達(dá)式，并返回表達(dá)式的值。

序列化

我們把對象(變量)從內(nèi)存中變成可存儲(chǔ)或傳輸?shù)倪^程稱之為序列化，在Python中叫pickling，在其他語言中也被稱之為serialization，marshalling，flattening等等，都是一個(gè)意思。

序列化之后，就可以把序列化后的內(nèi)容寫入磁盤，或者通過網(wǎng)絡(luò)傳輸?shù)絼e的機(jī)器上。

反過來，把變量內(nèi)容從序列化的對象重新讀到內(nèi)存里稱之為反序列化，即unpickling。

json

如果我們要在不同的編程語言之間傳遞對象，就必須把對象序列化為標(biāo)準(zhǔn)格式，比如XML，但更好的方法是序列化為JSON，因?yàn)镴SON表示出來就是一個(gè)字符串，可以被所有語言讀取，也可以方便地存儲(chǔ)到磁盤或者通過網(wǎng)絡(luò)傳輸。JSON不僅是標(biāo)準(zhǔn)格式，并且比XML更快，而且可以直接在Web頁面中讀取，非常方便。

JSON表示的對象就是標(biāo)準(zhǔn)的JavaScript語言的對象，JSON和Python內(nèi)置的數(shù)據(jù)類型對應(yīng)如下：

import json
dic={'name':'alex'}
f = open('hello','w')
dic_str=json.dumps(dic)  
f.write(dic_str)

f_read=open('hello')
data=json.loads(f_read.read())
print(data,type(data))

import json
#dct="{'1':111}"#json 不認(rèn)單引號
#dct=str({"1":111})#報(bào)錯(cuò),因?yàn)樯傻臄?shù)據(jù)還是單引號:{'one': 1}

dct='{"1":"111"}'
print(json.loads(dct))

#conclusion:
#        無論數(shù)據(jù)是怎樣創(chuàng)建的，只要滿足json格式，就可以json.loads出來,不一定非要dumps的數(shù)據(jù)才能loads

pickle

Pickle的問題和所有其他編程語言特有的序列化問題一樣，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的數(shù)據(jù)，不能成功地反序列化也沒關(guān)系。

import pickle

dic={'name':'alvin','age':23,'sex':'male'}

print(type(dic))#

j=pickle.dumps(dic)
print(type(j))#

f=open('序列化對象_pickle','wb')#注意是w是寫入str,wb是寫入bytes,j是'bytes'
f.write(j)  #-------------------等價(jià)于pickle.dump(dic,f)

f.close()
#-------------------------反序列化
import pickle
f=open('序列化對象_pickle','rb')

data=pickle.loads(f.read())#  等價(jià)于data=pickle.load(f)

print(data['age'])    

七、shelve模塊

shelve模塊比pickle模塊簡單，只有一個(gè)open函數(shù)，返回類似字典的對象，可讀可寫;key必須為字符串，而值可以是python所支持的數(shù)據(jù)類型

import shelve

f = shelve.open(r'shelve.txt')

# f['stu1_info']={'name':'alex','age':'18'}
# f['stu2_info']={'name':'alvin','age':'20'}
# f['school_info']={'website':'oldboyedu.com','city':'beijing'}
#
#
# f.close()

print(f.get('stu_info')['age'])

八、xml模塊

xml是實(shí)現(xiàn)不同語言或程序之間進(jìn)行數(shù)據(jù)交換的協(xié)議，跟json差不多，但json使用起來更簡單

xml的格式如下，就是通過<>節(jié)點(diǎn)來區(qū)別數(shù)據(jù)結(jié)構(gòu)的:

    
        2
        2008
        141100
        
        
    
    
        5
        2011
        59900
        
    
    
        69
        2011
        13600
        
        
    

xml協(xié)議在各個(gè)語言里的都 是支持的，在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 節(jié)點(diǎn)
for node in root.iter('year'):
    print(node.tag,node.text)
#---------------------------------------

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')

自己創(chuàng)建xml文檔：

import xml.etree.ElementTree as ET

new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'

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

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

創(chuàng)建xml文檔

九、re模塊

正則表達(dá)式（或 RE）是一種小型的、高度專業(yè)化的編程語言，（在Python中）它內(nèi)嵌在Python中，并通過 re 模塊實(shí)現(xiàn)。正則表達(dá)式模式被編譯成一系列的字節(jié)碼，然后由用 C 編寫的匹配引擎執(zhí)行。

*元字符之 . ^ $ + ? { }**

import re

ret=re.findall('a..in','helloalvin')   # . 表示任意字符
print(ret)#['alvin']

ret=re.findall('^a...n','alvinhelloawwwn') # ^表示以什么開頭
print(ret)#['alvin']

ret=re.findall('a...n$','alvinhelloawwwn') # $ 表示已什么結(jié)尾
print(ret)#['awwwn']

ret=re.findall('abc*','abcccc')#貪婪匹配[0,+oo]  重復(fù)任意次數(shù)，包括0次
print(ret)#['abcccc']

ret=re.findall('abc+','abccc')#[1,+oo] 至少匹配一次
print(ret)#['abccc']

ret=re.findall('abc?','abccc')#[0,1] 最多匹配一次
print(ret)#['abc']

ret=re.findall('abc{1,4}','abccc') 匹配1到4次
print(ret)#['abccc'] 貪婪匹配

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

ret=re.findall('abc*?','abcccccc')
print(ret)#['ab']

元字符之字符集［］：

ret=re.findall('a[bc]d','acd')  #[]這里面的元素表示或
print(ret)#['acd']

ret=re.findall('[a-z]','acd')
print(ret)#['a', 'c', 'd']

ret=re.findall('[.*+]','a.cd+')  #【】中括號內(nèi)的元素 沒有其他附加意思
print(ret)#['.', '+']

#在字符集里有功能的符號: - ^ \

ret=re.findall('[1-9]','45dha3')
print(ret)#['4', '5', '3']

ret=re.findall('[^ab]','45bdha3')  # 【^】表示取反
print(ret)#['4', '5', 'd', 'h', '3']

ret=re.findall('[\d]','45bdha3')  # \表示轉(zhuǎn)義，附加其功能
print(ret)#['4', '5', '3']

元字符之轉(zhuǎn)義符\

反斜杠后邊跟元字符去除特殊功能,比如\.
反斜杠后邊跟普通字符實(shí)現(xiàn)特殊功能,比如\d

\d  匹配任何十進(jìn)制數(shù)；它相當(dāng)于類 [0-9]。
\D 匹配任何非數(shù)字字符；它相當(dāng)于類 [^0-9]。
\s  匹配任何空白字符；它相當(dāng)于類 [ \t\n\r\f\v]。
\S 匹配任何非空白字符；它相當(dāng)于類 [^ \t\n\r\f\v]。
\w 匹配任何字母數(shù)字字符；它相當(dāng)于類 [a-zA-Z0-9_]。
\W 匹配任何非字母數(shù)字字符；它相當(dāng)于類 [^a-zA-Z0-9_]
\b  匹配一個(gè)特殊字符邊界，比如空格 ，&，＃等

ret=re.findall('I\b','I am LIST')
print(ret)#[]

ret=re.findall('I\\b','I am LIST') 
print(ret)#[I]

ret=re.findall(r'I\b','I am LIST')
print(ret)#['I']

import re
ret=re.findall('c\l','abc\le')
print(ret)#[]
ret=re.findall('c\\l','abc\le')
print(ret)#[]
ret=re.findall('c\\\\l','abc\le')
print(ret)#['c\\l']
ret=re.findall(r'c\\l','abc\le')
print(ret)#['c\\l']

#-----------------------------eg2:
#之所以選擇\b是因?yàn)閈b在ASCII表中是有意義的
m = re.findall('\bblow', 'blow')
print(m)
m = re.findall(r'\bblow', 'blow')
print(m)