python--模塊一

經常使用模塊

collections模塊

在內置數據類型（dict、list、set、tuple）的基礎上，collections模塊還提供了幾個額外的數據類型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple: 生成可使用名字來訪問元素內容的tuple
2.deque: 雙端隊列，能夠快速的從另一側追加和推出對象
3.Counter: 計數器，主要用來計數
4.OrderedDict: 有序字典
5.defaultdict: 帶有默認值的字典

1.namedtuple

- tuple能夠表示不變集合，例如，一個點的二維座標就能夠表示成：

p = (1,2)

- 看不出來1,2用來表示座標，用namedtuple實現方法

from collections import namedtuple
Point = namedtuple('Point',["x","y"])
p = Point(1,2)
print(p.x)
print(p.y)

- 定義方式：namedtuple('名稱', [屬性list])

2.deque

使用list存儲數據時，按索引訪問元素很快，可是插入和刪除元素就很慢了，由於list是線性存儲，數據量大的時候，插入和刪除效率很低。deque是爲了高效實現插入和刪除操做的雙向列表，適合用於隊列和棧：

from collections import deque
q = deque(["a","b","c"])
q.append("x")
q.appendleft("y")
print(q)
#deque(['y', 'a', 'b', 'c', 'x'])

deque除了實現list的append()和pop()外，還支持appendleft()和popleft()，這樣就能夠很是高效地往頭部添加或刪除元素。

3.defaultdict

有以下值集合 [11,22,33,44,55,66,77,88,99,90...]，將全部大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中。即： {'k1': 大於66 , 'k2': 小於66}

dic = {"k1":[],"k2":[]}
l1 = [11,22,33,44,55,66,77,88,99,90]
for number in l1:
    if number > 66:
        dic["k1"].append(number)
    elif number < 66:
        dic["k2"].append(number)
print(dic)
#普通字典須要先定義好一個字典，字典必須有k1,k2的key值

使用dict時，若是引用的Key不存在，就會拋出KeyError。若是但願key不存在時，返回一個默認值，就能夠用defaultdict：

from collections import defaultdict
l1 = [11,22,33,44,55,66,77,88,99,90]
dic = defaultdict(list)
for number in l1:
    if number > 66:
        dic["k1"].append(number)
    elif number < 66:
        dic["k2"].append(number)
    elif number == 66:
        dic["k3"].append(number)
print(dic)

time模塊

1.經常使用方法：

1.time.sleep(secs)
(線程)推遲指定的時間運行。單位爲秒
2.time.time()
獲取當前時間戳

2.表示時間的三種方式:

1.時間戳(timestamp) ：一般來講，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。咱們運行「type(time.time())」，返回的是float類型。
2.格式化的時間字符串(Format String)： ‘1999-12-06’
%y 兩位數的年份表示（00-99）
%Y 四位數的年份表示（000-9999）
%m 月份（01-12）
%d 月內中的一天（0-31）
%H 24小時制小時數（0-23）
%I 12小時制小時數（01-12）
%M 分鐘數（00=59）
%S 秒（00-59）
%a 本地簡化星期名稱
%A 本地完整星期名稱
%b 本地簡化的月份名稱
%B 本地完整的月份名稱
%c 本地相應的日期表示和時間表示
%j 年內的一天（001-366）
%p 本地A.M.或P.M.的等價符
%U 一年中的星期數（00-53）星期天爲星期的開始
%w 星期（0-6），星期天爲星期的開始
%W 一年中的星期數（00-53）星期一爲星期的開始
%x 本地相應的日期表示
%X 本地相應的時間表示
%Z 當前時區的名稱
%% %號自己

3.struct_time) ：struct_time元組共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天等）

import time
#時間戳
print(time.time())
#字符串時間
print(time.strftime("%Y-%m-%d %H:%M:%S"))
#時間元組：localtime將一個時間戳轉換爲當前時區的struct_time
print(time.localtime())
#打印結果：
1530693574.325
2018-07-04 16:39:34
time.struct_time(tm_year=2018, tm_mon=7, tm_mday=4, tm_hour=16, tm_min=39, tm_sec=34, tm_wday=2, tm_yday=185, tm_isdst=0)

總結：時間戳是計算機可以識別的時間；時間字符串是人可以看懂的時間；元組則是用來操做時間的
時間格式的轉化：

#1.時間戳轉結構化時間
import time
print(time.gmtime()) #UTC時間，與英國倫敦當地時間一致
print(time.localtime()) #當地時間。例如咱們如今在北京執行這個方法：與UTC時間相差8小時，UTC時間+8小時 = 北京時間

#2.結構化時間轉時間戳
#獲取本地時間的結構化時間
time_tuple = time.localtime()
print(time_tuple)
#將結構化時間轉化爲時間戳
print(time.mktime(time_tuple))

#3.結構化時間轉字符串時間
#time.strftime("格式定義","結構化時間")  結構化時間參數若不傳，則現實當前時間
print(time.strftime("%y-%m-%d %H:%M:%S"))
print(time.strftime("%Y-%m-%d",time.localtime()))

#4.字符串時間轉結構化時間
#time.strptime(時間字符串,字符串對應格式)
print(time.strptime("2018-07-04","%Y-%m-%d"))
#time.struct_time(tm_year=2018, tm_mon=7, tm_mday=4, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=185, tm_isdst=-1)

計算時間差：

import time
true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print('過去了%d年%d月%d天%d小時%d分鐘%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))

random模塊

1.隨機小數

import random
print(random.random()) #大於0且小於一的小數
print(random.uniform(1,3))  #大於1且小於3的小數

2.隨機整數

import random
print(random.randint(1,3)) #>=1且<=3的隨機整數
print(random.randrange(1,10,2)) #大於等於1且小於10之間的奇數

3.隨機返回

import random
print(random.choice([1,2,3,4,5,[6,7]])) #在列表中隨機選擇一個元素返回
print(random.sample([1,2,3,4,5,6],3)) #列表內任意3個組合

4.打亂列表順序

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

生成隨機驗證碼：

def random_number(numer,alpath=True):
    """
    :param numer: 生成幾位
    :param alpath: 默認包括數字
    :return:
    """
    code = ""
    for i in range(numer):
        choice = random.randint(0,9)
        if alpath:
            number2 = chr(random.randint(65,90)) #大寫
            number3 = chr(random.randint(97,122)) #小寫
            choice = random.choice([choice,number2,number3])
            print(choice)
        code += str(choice)
    return code

os模塊

os模塊是一個於操做系統交互的一個接口

import os
os.getcwd()           #獲取當前的工做目錄當前的工做目錄
os.chdir("E:\python\day08") #改變腳本工做目錄，至關於shell下的cd
os.curdir             #返回當前目錄  .
os.pardir             #返回到父集目錄 ..
os.makedirs("linux\go") #遞歸建立目錄，至關於shell的mkdir -p
os.removedirs("linux\go") #若目錄爲空則刪除，並遞歸到上一層目錄，若是上一次目錄也爲空，也刪除。依次類推
os.mkdir("python")  #生成單級目錄，至關於shell中的mkdir path
os.rmdir("python")   #刪除單級空目錄，不爲空則沒法刪除
print(os.listdir("E:\python\day08")) #列出指定目錄下的全部文件和目錄，包括隱藏文件，以列表的方式打印
os.remove("1.py") #刪除某個文件
os.rename("day08.zip","day8.zip")  #重命名目錄/文件
os.stat("README") #獲取文件/目錄信息，以一個元組的方式返回，能夠按照索引取值
os.sep #在pycharm中打印的結果是：/,在windows解釋器是：//,linux下爲：/
print(os.name) #輸出當前使用平臺，win=「nt」，linux=「posix」
os.system("bash commond") #運行shell命令
os.popen("bash commond").read() #運行shell命令，獲取執行結果
print(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)的第二個元素
print(os.path.exists("E:\python")) #判斷目錄/文件是否存在，存在返回True，反之false
print(os.path.isabs("E:\python")) #若是path是絕對路徑返回true，反之false
print(os.path.isfile("Calculator.py")) #判斷文件是否存在，存在true，反之false
print(os.path.isdir("python"))  #判斷目錄是否存在，存在true，反之false
os.path.getatime("E:\python\day08")  #返回path所指向的文件或者目錄的最後訪問時間戳
os.path.getmtime("E:\python\day08")  #返回path所指向的文件或者目錄的最後修改時間戳
os.path.getsize("E:\python\day08") #返回path的大小

sys模塊

sys模塊是一個與python解釋器交互的模塊

import sys
print(sys.argv) #命令行參數list，返回的是程序自己的路徑
sys.exit(n)   #退出程序，正常退出是exit(0),錯誤退出是exit(1)
print(sys.version) #返回python解釋器的版本信息
print(sys.path) #返回模塊的搜索路徑
print(sys.platform) #返回操做平臺名稱

re模塊

正則：
1.字符組 ： [字符組]

- 在同一個位置可能出現的各類字符組成了一個字符組，在正則表達式中用[]表示
- 字符分爲不少類，好比數字、字母、標點等等。
- 假如你如今要求一個位置"只能出現一個數字",那麼這個位置上的字符只能是0、一、2...9這10個數之一。

2.字符：

3.量詞：

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

4.字符集：

5.分組 ()與 或 ｜［^］
身份證號碼是一個長度爲15或18個字符的字符串，若是是15位則所有🈶️數字組成，首位不能爲0；若是是18位，則前17位所有是數字，末位多是數字或x，下面咱們嘗試用正則來表示：

6.轉義符 \
python中，不管是正則表達式，仍是待匹配的內容，都是以字符串的形式出現的，在字符串中也有特殊的含義，自己還須要轉義。因此若是匹配一次"d",字符串中要寫成'\d'，那麼正則裏就要寫成"\\d",這樣就太麻煩了。這個時候咱們就用到了r'd'這個概念，此時的正則是r'\d'就能夠了。

7.貪婪匹配
貪婪匹配：在知足匹配時，匹配儘量長的字符串，默認狀況下，採用貪婪匹配

經常使用的：

*? 重複任意次，但儘量少重複
+? 重複1次或更屢次，但儘量少重複
?? 重複0次或1次，但儘量少重複
{n,m}? 重複n到m次，但儘量少重複
{n,}? 重複n次以上，但儘量少重複

re模塊經常使用用法:

import re

ret = re.findall('a', 'eva egon yuan')  # 返回全部知足匹配條件的結果,放在列表裏
print(ret) #結果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()
print(ret) #結果 : 'a'
# 函數會在字符串內查找模式匹配,只到找到第一個匹配而後返回一個包含匹配信息的對象,該對象能夠
# 經過調用group()方法獲得匹配的字符串,若是字符串沒有匹配，則返回None。

ret = re.match('a', 'abc').group()  # 同search,不過盡在字符串開始處進行匹配
print(ret)
#結果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割獲得''和'bcd',在對''和'bcd'分別按'b'分割
print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#將數字替換成'H'，參數1表示只替換1個
print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#將數字替換成'H'，返回元組(替換的結果,替換了多少次)
print(ret)

obj = re.compile('\d{3}')  #將正則表達式編譯成爲一個 正則表達式對象，規則要匹配的是3個數字
ret = obj.search('abc123eeee') #正則表達式對象調用search，參數爲待匹配的字符串
print(ret.group())  #結果 ： 123

import re
ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一個存放匹配結果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #查看第一個結果
print(next(ret).group())  #查看第二個結果
print([i.group() for i in ret])  #查看剩餘的左右結果

findall優先級查詢

import re

ret = re.findall('www.(baidu|wangyi).com', 'www.wangyi.com')
print(ret)  # ['wangyi']     這是由於findall會優先把匹配結果組裏內容返回,若是想要匹配結果,取消權限可
ret = re.findall('www.(?:baidu|wangyi).com', 'www.oldboy.com')
print(ret)  # ['www.wangyi.com']

split的優先級查詢

ret=re.split("\d+","eva3egon4yuan")
print(ret) #結果 ： ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #結果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）以後所切出的結果是不一樣的，
#沒有（）的沒有保留所匹配的項，可是有（）的卻可以保留了匹配的項，
#這個在某些須要保留匹配部分的使用過程是很是重要的。