python基礎篇【第五篇】模塊，生成器

時間 2019-11-11

標籤 python 基礎第五篇模塊成器欄目 Python 简体版

原文原文鏈接

1、字符轉格式化python

　　　　在python 中目前使用的字符串格式化有兩種 % ，format；建議使用format方式，百分號方式是比較古老的，而format方式比較新，相比百分號方式功能較全，有替換古老方式的趨勢，目前並存。json

　一、百分號方式：c#

%[(name)][flags][width].[precision]typecode網絡

name 可選，用於選擇指定的keyapp

flages 可選，可提供選擇值有：ide

輔助符號	說明
-	用作左對齊；正數前無符號，負數前加符號
+	在右對齊；正數前加正號，負數前加負號
0	顯示的數字前面填充「0」而不是默認的空格

格式化符號	說明
%s	優先用str()函數進行字符串轉換，並格式化的指定位置
%d	轉成十進制數，並格式化的指定位置
%o	轉成八進制數，並格式化的指定位置
%x	轉成十六進制數，並格式化的指定位置函數
%e/%E	轉成科學計數法，並格式化的指定位置（e，E就是輸出的時候大小寫區別）
%c	將十進制數轉換爲其unicode對應的值是字符，並把字符添加到指定位置
%f/%F	轉成浮點型，並格式化的指定位置（默認保留小數點後6位）
%g/%G	自動調整將整數，浮點數轉換成浮點或科學計數法（超過6位數用科學計數法）
%	字符串中出現佔位符，兩個%表示一個%，不出現佔位符，就無所謂

width :表示佔有寬度ui

下面列舉了幾個例子：spa

 1 test1="my name is %s" %"xiaoma"
 2 print(test1)
 3 #結果
 4 my name is xiaoma
 5 
 6 test2="my name is %s age%d" %("tianjie",18)
 7 print(test2)
 8 #結果
 9 my name is tianjie age18
10 
11 test3="my name is %(name)s , age %(age)d" %{"name":"dbq","age":18}
12 print(test3)
13 #結果
14 my name is dbq , age 18
15 
16 test4="percent %.2f" %89.123345   #保留兩位小數點
17 print(test4)
18 #結果
19 percent 89.12
20 
21 test5="percent %(xiao).2f %%" %{"xiao":123.1233465}
22 #一個百分號會報錯的
23 print(test5)
24 #結果
25 percent 123.12 %
26 
27 charA = 65
28 charB = 66
29 print("ASCII碼65表明：%c" % charA)
30 print("ASCII碼66表明：%c" % charB)
31 Num1 = 0xEF3
32 Num2 = 0xAB03
33 print('轉換成十進制分別爲：%u和%u' % (Num1, Num2))
34 Num3 = 1200000
35 print('轉換成科學計數法爲：%e' % Num3)
36 
37 #輸出結果：
38 ASCII碼65表明：A
39  ASCII碼66表明：B
40 轉換成十進制分別爲：3827和43779
41 轉換成科學計數法爲：1.200000e+06

注意：百分號方式沒有二進制轉換方式，.net

二、format格式化方式

字符串的參數使用{NUM}進行表示,0, 表示第一個參數,1, 表示第二個參數, 之後順次遞加;

使用":", 指定表明元素須要的操做, 如":.3"小數點三位, ":8"佔8個字符空間等

還能夠添加特定的字母, 如:

'b' - 二進制. 將數字以2爲基數進行輸出.

'c' - 字符. 在打印以前將整數轉換成對應的Unicode字符串.

'd' - 十進制整數. 將數字以10爲基數進行輸出.

'o' - 八進制. 將數字以8爲基數進行輸出.

'x' - 十六進制. 將數字以16爲基數進行輸出, 9以上的位數用小寫字母.

'e' - 冪符號. 用科學計數法打印數字, 用'e'表示冪.

'g' - 通常格式. 將數值以fixed-point格式輸出. 當數值特別大的時候, 用冪形式打印.

'n' - 數字. 當值爲整數時和'd'相同, 值爲浮點數時和'g'相同. 不一樣的是它會根據區域設置插入數字分隔符.

'%' - 百分數. 將數值乘以100而後以fixed-point('f')格式打印, 值後面會有一個百分號.

數字(0, 1, ...)即表明format()裏面的元素, 因此可使用"."調用元素的方法;

還有一些輔助符號：

　　<,左對齊

　　>,右對齊

　　^,內容居中

　　=,內容右對齊，將符號放置在填充字符的左側，且只對數字類型有效。

仍是看一下實際運用更加一目瞭然：

 1 for1="my name is {},age {},job {}".format("dbp",18,"IT")
 2 print(for1)
 3 #執行結果
 4 my name is dbp,age 18,job IT
 5 
 6 for2="my name is {},age {},job {}".format(*["dbp",18,"IT"])
 7 #後面加*表示也能夠導入一個列表變量
 8 print(for2)
 9 #執行結果
10 my name is dbp,age 18,job IT
11 
12 for3 = "my name is {0},age {1},job {0}".format("qqq",18)
13 #能夠根據索引值調用
14 print(for3)
15 #執行結果
16 my name is qqq,age 18,job qqq
17 
18 for4="my name is {name},age {age},job {job} ".format(**{"name":"tianjie","age":19,"job":"IT"})
19 #加兩個* 能夠導入字典，根據key調用
20 print(for4)
21 #執行結果
22 my name is tianjie,age 19,job IT 
23 
24 for5="my name is {0[0]},age {0[1]},job {1[2]}".format(["tianjie",123,"hello"],["dbq","banking",234])
25 print(for5)
26 #執行結果
27 my name is tianjie,age 123,job 234
28 
29 for6="my name is {:s},age {:d},money {:f}".format("tianjie",18,2222.1)
30 #字符、整數、浮點數
31 print(for6)
32 #執行結果
33 my name is tianjie,age 18,money 2222.100000
34 
35 for7="i am {name:s}, age {age:d}, job {job:s}".format(**{"name": "admin", "age": 18,"job":"banking"})
36 print(for7)
37 #執行結果
38 i am admin, age 18, job banking
39 
40 for8="numbers: {:#b},{:#o},{:#d},{:#x},{:#X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
41 print(for8)
42 #轉換爲二進制、八進制、十六進制、百分數（不加#表示顯示結果沒有0b、0o、0x）
43 numbers: 0b1111,0o17,15,0xf,0XF, 1587.623000%
44 
45 for9="numbers: {0:#b},{0:#o},{0:#d},{0:#x},{1:#X}, {2:%}".format(15,56,0.9897763)
46 print(for9)
47 #執行結果
48 numbers: 0b1111,0o17,15,0xf,0X38, 98.977630%

2、迭代器，生成器，遞歸

一、迭代器

剛開始的時候一直認爲，能夠被 for循環的的對象，就爲迭代器，下面是更嚴謹的解釋！

迭代器是訪問集合元素的一種方式。迭代器對象從集合的第一個元素開始訪問，直到全部的元素被訪問完結束。迭代器只能往前不會後退，不過這也沒什麼，由於人們不多在迭代途中日後退。另外，迭代器的一大優勢是不要求事先準備好整個迭代過程當中全部的元素。迭代器僅僅在迭代到某個元素時才計算該元素，而在這以前或以後，元素能夠不存在或者被銷燬。這個特色使得它特別適合用於遍歷一些巨大的或是無限的集合，好比幾個G的文件

特色：

訪問者不須要關心迭代器內部的結構，僅需經過next()方法不斷去取下一個內容
不能隨機訪問集合中的某個值，只能從頭至尾依次訪問
訪問到一半時不能往回退
便於循環比較大的數據集合，節省內存

總之就是，能夠經過_next_去取，須要一個取一個，而不是把元素，一整個加進內存，你能夠迭代不是序列但表現處序列行爲的對象，例如字典的鍵、一個文件的行，或者一個字符串！如如下事例：

 1 name=iter("hello")
 2 print(name.__next__())
 3 print(name.__next__())
 4 print(name.__next__())
 5 print(name.__next__())
 6 print(name.__next__())
 7 
 8 #執行結果
 9 h
10 e
11 l
12 l
13 o

二、生成器

一個函數調用時返回一個迭代器，那這個函數就叫生成器（generator），只要看到函數中出現yield，那麼這個函數就是生成器；如如下實例：

 1 import time
 2 def func(num):
 3     a=0
 4     while True:
 5         a+=1
 6         if a>=num:
 7             return
 8         else:
 9             yield a
10 
11 test=func(5)
12 print(test)
13 for i in test:
14     print(i)
15     time.sleep(1)   #停一秒在顯示
16 
17 #執行結果
18 <generator object func at 0x0000003668194A40>
19 1
20 2
21 3
22 4

三、遞歸

在函數內部，能夠調用其餘函數。若是一個函數在內部調用自身自己，這個函數就是遞歸函數。

遞歸函數的優勢是定義簡單，邏輯清晰。理論上，全部的遞歸函數均可以寫成循環的方式，但循環的邏輯不如遞歸清晰。

使用遞歸函數須要注意防止棧溢出，不能寫入死的循環沒有結束值。

如示例：計算斐波那契數列0,1,1,2,3,5,8,13,21,34,55,89.。。。。。。

 1 def func(arg1,arg2,stops):
 2     if arg1==0:
 3         print(arg1,arg2)
 4     arg3=arg1+arg2
 5     print(arg3)
 6     if arg3<stops:
 7         func(arg2,arg3,stops)
 8     else:
 9         return
10 
11 func(0,1,20)   #結束值20
12 #執行結果
13 0 1
14 1
15 2
16 3
17 5
18 8
19 13
20 21

練習實例：

用遞歸計算1*2*3*4*5*6*7結果：

 1 def func(num):
 2     if num==1:
 3         return num
 4     else:
 5         return num * func(num-1)
 6 print(func(7))
 7 
 8 #執行過程
 9 
10 # func(7)
11 # 7*func(6)
12 # 7*(6*func(5))
13 # 7*(6*(5*func(4)))
14 # 7*(6*(5*(4*func(3))))
15 # 7*(6*(5*(4*(3*func(2)))))
16 # 7*(6*(5*(4*(3*(2*(func(1)))))))
17 # 7*(6*(5*(4*(3*(2*1)))))
18 # 7*(6*(5*(4*(3*2))))
19 # 7*(6*(5*(4*6)))
20 # 7*(6*(5*24))
21 # 7*(6*120)
22 # 7*720
23 # 5040

3、模塊

隨着代碼越寫越多，功能愈來愈多，你不能把全部的代碼都寫在一個文件中，不方便查詢排錯，那麼咱們就想着把一個功能放在一個文件中，或者一個函數。

在python中一個.py的文件就稱之爲一個模塊；在其餘語言中如Java、c# 等叫作類庫。

模塊有三種：

　　內置模塊

　　第三方模塊

　　自定義模塊

1.自定義模塊　　　　

自定義模塊，就是根據功能需求本身寫的py文件，供功能調用

要想使用模塊首先要導入模塊，下面列舉幾個導入模塊的例子：

 1 # import digui
 2 #
 3 # digui.login()
 4 #
 5 # from test import mokuai
 6 # from test import mokuai as rename
 7 # from  test import file
 8 # import test_ll.file
 9 # test_ll.file.func()
10 # # mokuai.func(3)
11 import requests

導入模塊時是根據哪一個路徑做爲基準來進行的呢：sys.path

 1 import sys
 2 print(sys.path)
 3 #返回結果
 4 ['E:\\python課程\\day5',
 5  'E:\\python課程', 
 6 
 7 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python35\\python35.zip', 
 8 
 9 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python35\\DLLs', 
10 
11 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python35\\lib', 
12 
13 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python35', 
14 
15 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python35\\lib\\site-packages']

若是用sys.path路徑表沒有你想要的路徑，能夠經過sys.path.append("路徑")添加。

sys.path路徑首先是從程序本目錄中查找，

注：模塊取名字時必定不能與標準庫的名字同樣

二、第三方模塊

下載安裝第三方模塊有兩種方法：

一、是用yum、pip3/pip、apt-get　　　

#requests 發送get請求的
pip3安裝   
pip3 install requests

二、源碼安裝

 1 # pycrypto，因爲 paramiko 模塊內部依賴pycrypto，因此先下載安裝pycrypto
 2  
 3 # 下載安裝 pycrypto
 4 wget http://files.cnblogs.com/files/wupeiqi/pycrypto-2.6.1.tar.gz
 5 tar -xvf pycrypto-2.6.1.tar.gz
 6 cd pycrypto-2.6.1
 7 python setup.py build
 8 python setup.py install
 9  
10 # 進入python環境，導入Crypto檢查是否安裝成功
11  
12 # 下載安裝 paramiko
13 wget http://files.cnblogs.com/files/wupeiqi/paramiko-1.10.1.tar.gz
14 tar -xvf paramiko-1.10.1.tar.gz
15 cd paramiko-1.10.1
16 python setup.py build
17 python setup.py install
18  
19 # 進入python環境，導入paramiko檢查是否安裝成功

序列化

json和pickle兩個模塊

　　json，用於字符串和python基本數據類型間進行轉換，能夠跨語言！

　　pickle，用於python全部的類型間轉換，可是隻能在python語言中用，其它語言解釋不了！

Json模塊有四個功能：

　　　　　　dumps:沒有寫入文件，把數據類型轉化爲全部程序語言都認識的字符串，

　　　　　　dump：把數據類型轉化爲全部程序語言都認識的字符串，並寫入文件

　　　　　　loads：在Python中反序列化，把字符串轉化爲數據類型，且字符串中的元素要用雙引號

　　　　　　load：讀取文件中的字符串，並轉換python的基礎類型

如如下實例：

 1 import json
 2 li=["name",123,"job"]
 3 js=json.dumps(li)
 4 print(js,type(js))
 5 #執行結果
 6 ["name", 123, "job"] <class 'list'>
 7 
 8 li='["name",123,"job"]'
 9 js=json.loads(li)
10 print(js,type(js))
11 #執行結果
12 ['name', 123, 'job'] <class 'list'>
13 
14 li=["name",123,"job"]   
15 with open("test","w") as f:
16     json.dump(li,f)
17 #把列表轉換爲字符，寫入同級目錄中的test文件中
18 
19 with open("test","r") as f:   #打開文件，把文件中的內容轉換成對應類型
20     li=json.load(f)
21 print(li,type(li))
22 #執行結果
23 ['name', 123, 'job'] <class 'list'>

pickle也是有四個模塊：

　　dumps、dump、loads、load

給json功能同樣，只不過轉換過的內容只有python本身能解釋：

 1 import pickle
 2 li=["name",123,"job"]
 3 test=pickle.dumps(li)
 4 print(test)
 5 #執行結果 是python二進制格式
 6 b'\x80\x03]q\x00(X\x04\x00\x00\x00nameq\x01K{X\x03\x00\x00\x00jobq\x02e.'
 7 
 8 
 9 #轉換回來時必須也要是二進制格式
10 test1=pickle.loads(test)
11 print(test1,type(test1))
12 #執行結果
13 ['name', 123, 'job'] <class 'list'>
14 
15 li=["name",123,"job"]   #以二進制方式寫入文件中
16 with open("db","wb") as f:
17     pickle.dump(li,f)
18 #如字樣    �]q (X   nameqK{X   jobqe.
19 
20 
21 with open("db","rb") as f:  #到文件裏取出來
22     li=pickle.load(f)
23 print(li,type(li))
24 #執行結果
25 ['name', 123, 'job'] <class 'list'>

time模塊：

時間模塊有三種表示方式：

　　時間戳：　　　　1970年1月1日以後的秒，能夠用time.time()獲取

　　格式化的字符串　　 2016-06-07 12:12:12，用tiem.strftime('%Y-%m-%d %H:%M:%S')

　　結構化時間　　　　元組包括了：年、月、日、星期等，用tiem.localtime()

實際運用:

 1 import time
 2 import datetime
 3 
 4 print(time.time())  #返回當前系統時間戳 如 1465279434.84525
 5 
 6 print(time.ctime())  #返回當前時間 Tue Jun  7 14:03:54 2016
 7 
 8 print(time.ctime(time.time()-86640*2)) #將時間戳轉換成時間格式 ，兩天前 Sun Jun  5 13:55:54 2016
 9 
10 print(time.gmtime(time.time()-86640))  #將時間戳轉換成struct_time格式格林昨天時間
11 #time.struct_time(tm_year=2016, tm_mon=6, tm_mday=6, tm_hour=5, tm_min=59, tm_sec=54, tm_wday=0, tm_yday=158, tm_isdst=0)
12 
13 print(time.localtime(time.time()-86640))  #將時間戳轉換成strut_time格式，但返回的是本地昨天時間
14 #time.struct_time(tm_year=2016, tm_mon=6, tm_mday=6, tm_hour=13, tm_min=59, tm_sec=54, tm_wday=0, tm_yday=158, tm_isdst=0)
15 
16 print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())) #將結構化的strut_time格式轉換爲，時間字符傳格式 2016-06-07 14:03:54
17 
18 print(time.strptime("2016-06-07","%Y-%m-%d"))#與上相反將時間字符串格式，轉化爲strut_time格式
19 #time.struct_time(tm_year=2016, tm_mon=6, tm_mday=7, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=159, tm_isdst=-1)
20 
21 
22 #datetime 模塊
23 print(datetime.date.today()) #輸出格式時期格式年月日 2016-06-07
24 print(datetime.date.fromtimestamp(time.time()-86440))#將時間戳格式轉化成日期格式 2016-06-06
25 print(datetime.datetime.now())   #顯示當前時間詳細如：2016-06-07 13:21:12.199884 毫秒都有
26 
27 time_s1=datetime.datetime.now()
28 print(time_s1.utctimetuple())     #顯示出strut_time格式
29 print(time_s1.replace(2015,5,22)) #顯示當前時間，但把日期換成了2015-05-22
30 
31 time_s2=datetime.datetime.strptime("21/11/16 17:50","%d/%m/%y %H:%M")#將字符串轉換成日期格式
32 new_date=datetime.datetime.now()+datetime.timedelta(days=10)#比如今加10天 2016-06-17 13:57:47.737319
33 new_date1=datetime.datetime.now()+datetime.timedelta(days=-10)#比如今減10天 2016-05-28 13:59:53.181695
34 new_date2=datetime.datetime.now()+datetime.timedelta(hours=-10) #比如今減10小時 2016-06-07 04:01:27.349964
35 new_date3=datetime.datetime.now()+datetime.timedelta(seconds=-10) #比如今減10秒 2016-06-07 14:02:45.919412

View Code

logging模塊：

Python 使用logging模塊記錄日誌涉及四個主要類，使用官方文檔中的歸納最爲合適：

logger 提供了應用程序能夠直接使用的接口；

handler 將(logger建立的)日誌記錄發送到合適的目的輸出；

filter　　提供了細度設備來決定輸出哪條日誌記錄；

formatter　　決定日誌記錄的最終輸出格式。

Handlers：
handler對象負責發送相關的信息到指定目的地。

Python的日誌系統有多種Handler可使用。有些Handler能夠把信息輸出到控制檯，有些Logger能夠把信息輸出到文件，還有些 Handler能夠把信息發送到網絡上。若是以爲不夠用，還能夠編寫本身的Handler。能夠經過addHandler()方法添加多個多handler

經常使用的Handlers有兩種：

　　StreamHandler() 顯示到屏幕上
　　FileHandler(filename[,mode]) 寫到文件中
filename是文件名，必須指定一個文件名。
mode是文件的打開方式。參見Python內置函數open()的用法。默認是’a'，即添加到文件末尾。

Handler.setLevel(lel):指定被處理的信息級別，低於lel級別的信息將被忽略
Handler.setFormatter()：給這個handler選擇一個格式
Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或刪除一個filter對象

日誌模塊，分爲debug(),info(),warning(),error(),critical()級別；

日誌級別大小關係爲：CRITICAL > ERROR > WARNING > INFO > DEBUG

默認是從WARNING級別將log 打印到屏幕如：

 1 import logging
 2 
 3 logging.debug("hello debug")
 4 logging.info("hello info")
 5 logging.warning("hello warning")
 6 logging.error("hello error")
 7 logging.critical("server is down")
 8 
 9 #執行結果
10 WARNING:root:hello warning
11 ERROR:root:hello error
12 CRITICAL:root:server is down

簡單用法

 1 logging.basicConfig(level=logging.DEBUG,
 2                     format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s %(name)s ',
 3                     datefmt='%Y-%m-%d %H:%M:%S',
 4                     filename='myapp.log',
 5                     filemode='w')
 6 
 7 logging.debug('This is debug message')
 8 logging.info('This is info message')
 9 logging.warning('This is warning message')
10 
11 #./myapp.log文件裏的信息以下
12 2016-06-07 15:11:29 logger.py[line:17] DEBUG This is debug message root 
13 2016-06-07 15:11:29 logger.py[line:18] INFO This is info message root 
14 2016-06-07 15:11:29 logger.py[line:19] WARNING This is warning message root

logging.basicConfig函數各參數:
filename: 指定日誌文件名
filemode: 和open函數意義相同，指定日誌文件的打開模式，'w'或'a'
format: 指定輸出的格式和內容，format能夠輸出不少有用信息，如上例所示:
%(levelno)s: 打印日誌級別的數值
%(levelname)s: 打印日誌級別名稱
%(pathname)s: 打印當前執行程序的路徑，其實就是sys.argv[0]
%(filename)s: 打印當前執行程序名
%(funcName)s: 打印日誌的當前函數
%(lineno)d: 打印日誌的當前行號
%(asctime)s: 打印日誌的時間
%(thread)d: 打印線程ID
%(threadName)s: 打印線程名稱
%(process)d: 打印進程ID
%(message)s: 打印日誌信息
datefmt: 指定時間格式，同time.strftime()
level: 設置日誌級別，默認爲logging.WARNING

把日誌同時輸出屏幕和文件：

這個很牛逼的，能夠限制級別寫到屏幕或者文件，如下實例我就是把DEBUG級別以上的寫到文件中，把INFO級別以上的直接在屏幕顯示：

 1 import logging
 2 logging.basicConfig(level=logging.DEBUG,
 3                     format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s %(name)s ',
 4                     datefmt='%Y-%m-%d %H:%M:%S',
 5                     filename='myapp.log',
 6                     filemode='w')
 7 
 8 
 9 display=logging.StreamHandler()
10 display.setLevel(logging.INFO)  #設置級別
11 formater=logging.Formatter("%(name)s %(asctime)s %(levelname)s %(message)s")     #格式化定義規則
12 datefmt='%Y-%m-%d %H:%M:%S'    #時間格式
13 display.setFormatter(formater)         #導入格式化
14 logging.getLogger("").addHandler(display)  #返回一個logger對象，若是沒有指定名字將返回root logger
15 
16 logging.debug('This is debug message')
17 logging.info('This is info message')
18 logging.warning('This is warning message')
19 
20 #屏幕上打印
21 root 2016-06-07 15:31:21,137 INFO This is info message
22 root 2016-06-07 15:31:21,137 WARNING This is warning message
23 
24 #./myapp.log文件中內容爲：
25 2016-06-07 15:31:21 logger.py[line:25] DEBUG This is debug message root 
26 2016-06-07 15:31:21 logger.py[line:26] INFO This is info message root 
27 2016-06-07 15:31:21 logger.py[line:27] WARNING This is warning message root