python基礎學習筆記2,python基礎學習筆記
詞典
詞典(dictionary)與列表相似,也可以儲存多個元素。儲存多個元素的對象稱為容器(container);
常見的建立詞典的方法:
>>>dic = {'tom':11, 'sam':57,'lily':100}>>>print type(dic)
與表類似,以逗號分隔每一個元素;每一個元素包含兩個部分,鍵和值;(不可以變的對象可以作為鍵)。值可以是任意對象;鍵和值是一一對應;
與表不同的是,詞典的元素沒有順序。你不能通過下標引用元素。詞典是通過鍵來引用。
>>>print dic['tom']>>>dic['tom'] = 30>>>print dic
在詞典中增添一個新元素的方法:
>>>dic['limi'] = 99>>>print dic
這裡,我們引用一個新的鍵,並賦予它對應的值。
詞典元素的迴圈調用
dic = {'lilei': 90, 'lily': 100, 'sam': 57, 'tom': 90}for key in dic: print dic[key]
在迴圈中,dict的每個鍵,被提取出來,賦予給key變數。
通過print的結果,我們可以再次確認,dic中的元素是沒有順序的。
詞典常用方法
>>>print dic.keys() # 返回dic所有的鍵>>>print dic.values() # 返回dic所有的值>>>print dic.items() # 返回dic所有的元素(索引值對)>>>dic.clear() # 清空dic,dict變為{}
另外有一個很常用的用法:
>>>del dic['tom'] # 刪除 dic 的‘tom’元素
del是Python中保留的關鍵字,用於刪除對象。 與表類似,你可以用len()查詢詞典中的元素總數。
>>>print(len(dic))
文字檔的輸入輸出 建立檔案對象
我們開啟一個檔案,並使用一個對象來表示該檔案:
f = open(檔案名稱,模式)最常用的模式有:
"r" # 唯讀
“w” # 寫入比如
>>>f = open("test.txt","r")
具體用法需要在實踐,這裡只是簡單的整體概括
模組 在Python中,一個.py檔案就構成一個模組。通過模組,你可以調用其它檔案中的程式。
引入模組先寫一個first.py檔案,內容如下:
def laugh(): print 'HaHaHaHa'
再寫一個second.py,並引入first中的程式:
import firstfor i in range(10): first.laugh()
在second.py中,我們使用了first.py中定義的laugh()函數。
引入模組後,可以通過模組.對象的方式來調用引入模組中的某個對象。
上面例子中,first為引入的模組,laugh()是我們所引入的對象。
Python中還有其它的引入方式,
import a as b # 引入模組a,並將模組a重新命名為bfrom a import function1 # 從模組a中引入function1對象。調用a中對象時,我們不用再說明模組,即直接使用function1,而不是a.function1。from a import * # 從模組a中引入所有對象。調用a中對象時,我們不用再說明模組,即直接使用對象,而不是a.對象。
這些引用方式,可以方便後面的程式書寫。
搜尋模組的路徑
Python會在以下路徑中搜尋它想要尋找的模組:
如果你有自訂的模組,或者下載的模組,可以根據情況放在相應的路徑,以便Python可以找到。
模組包
可以將功能相似的模組放在同一個檔案夾(比如說this_dir)中,構成一個模組包。通過
import this_dir.module
引入this_dir檔案夾中的module模組。 該檔案夾中必須包含一個__init__.py的檔案,提醒Python,該檔案夾為一個模組包。__init__.py可以是一個空檔案。
函數參數 值傳遞
def f(a,b,c): return a+b+cprint(f(1,2,3))
在調用f時,1,2,3根據位置分別傳遞給了a,b,c。
關鍵字傳遞
有些情況下,用位置傳遞會感覺比較死板。關鍵字(keyword)傳遞是根據每個參數的名字傳遞參數。
關鍵字並不用遵守位置的對應關係。依然沿用上面f的定義,更改調用方式:
print(f(c=3,b=2,a=1))
關鍵字傳遞可以和位置傳遞混用。但位置參數要出現在關鍵字參數之前:
print(f(1,c=3,b=2))
參數預設值
在定義函數的時候,使用形如c=10的方式,可以給參數賦予預設值(default)。
如果該參數最終沒有被傳遞值,將使用該預設值。
def f(a,b,c=10): return a+b+cprint(f(3,2))print(f(3,2,1))
在第一次調用函數f時, 我們並沒有足夠的值,c沒有被賦值,c將使用預設值10.
第二次調用函數的時候,c被賦值為1,不再使用預設值。
包裹傳遞 位置傳遞,其實傳過去的是一個tuple
下面是包裹位置傳遞的例子:
def func(*name): print type(name) print namefunc(1,4,6)func(5,6,7,1,2,3)
兩次調用,儘管參數個數不同,都基於同一個func定義。在func的參數表中,所有的參數被name收集,根據位置合并成一個元組(tuple),這就是包裹位置傳遞。
為了提醒Python參數,name是包裹位置傳遞所用的元組名,在定義func時,在name前加*號。 下面是包裹關鍵字傳遞的例子:其實是字典傳遞
def func(**dict): print type(dict) print dictfunc(a=1,b=9)func(m=2,n=1,c=11)
與上面一個例子類似,dict是一個字典,收集所有的關鍵字,傳遞給函數func
。為了提醒Python,參數dict是包裹關鍵字傳遞所用的字典,在dict前加**。
包裹傳遞的關鍵在於定義函數時,在相應元組或字典前加*或**。
解包裹
*和**,也可以在調用的時候使用,即解包裹(unpacking), 下面為例:
def func(a,b,c): print a,b,cargs = (1,3,4)func(*args)
在這個例子中,所謂的解包裹,就是在傳遞tuple時,讓tuple的每一個元素對應一個位置參數。
在調用func時使用*,是為了提醒Python:
我想要把args拆成分散的三個元素,分別傳遞給a,b,c。(設想一下在調用func時,args前面沒有*會是什麼後果?)
相應的,也存在對詞典的解包裹,使用相同的func定義,然後:
dict = {'a':1,'b':2,'c':3}func(**dict)
在傳遞詞典dict時,讓詞典的每個索引值對作為一個關鍵字傳遞給func。
迴圈設計 range()
在Python中,for迴圈後的in跟隨一個序列的話,迴圈每次使用的序列元素,而不是序列的下標。
之前我們已經使用過range()來控制for迴圈。現在,我們繼續開發range的功能,以實現下標對迴圈的控制:
S = 'abcdefghijk'for i in range(0,len(S),2): print S[i]
在該例子中,我們利用len()函數和range()函數,用i作為S序列的下標來控制迴圈。在range函數中,分別定義上限,下限和每次迴圈的步長。這就和C語言中的for迴圈相類似了。
enumerate()
利用enumerate()函數,可以在每次迴圈中同時得到下標和元素:
S = 'abcdefghijk'
for (index,char) in enumerate(S): print index print char
實際上,enumerate()在每次迴圈中,返回的是一個包含兩個元素的定值表(tuple),兩個元素分別賦予index和char
zip()
如果你多個等長的序列,然後想要每次迴圈時從各個序列分別取出一個元素,可以利用zip()方便地實現:
ta = [1,2,3]tb = [9,8,7]tc = ['a','b','c']for (a,b,c) in zip(ta,tb,tc): print(a,b,c)
每次迴圈時,從各個序列分別從左至右取出一個元素,合并成一個tuple,然後tuple的元素賦予給a,b,c
zip()函數的功能,就是從多個列表中,依次各取出一個元素。每次取出的(來自不同列表的)元素合成一個元組,合并成的元組放入zip()返回的列表中。zip()函數起到了彙總列表的功能。
解析zip():
>>> ta = [1,2,3]>>> tb = [4,5,6]>>> zipped = zip(ta,tb)>>> print type(zipped)<type 'list'>>>> print zipped[(1, 4), (2, 5), (3, 6)]>>> print zipped[1](2, 5)
迴圈對象 迴圈對象是這樣一個對象,它包含有一個next()方法(__next__()方法,在python 3x中), 這個方法的目的是進行到下一個結果,而在結束一系列結果之後,舉出StopIteration錯誤。 例子:假設我們有一個test.txt的檔案:1234
abcdefg
我們運行一下python命令列:
>>>f = open('test.txt')>>>f.next()>>>f.next()...
不斷輸入f.next(),直到最後出現StopIterationopen()返回的實際上是一個迴圈對象,包含有next()方法。而該next()方法每次返回的就是新的一行的內容,到達檔案結尾時舉出StopIteration。這樣,我們相當於手工進行了迴圈。 自動的話:
for line in open('test.txt'): print line
在這裡,for結構自動調用next()方法,將該方法的傳回值賦予給line。迴圈知道出現StopIteration的時候結束。相對於序列,用迴圈對象的好處在於:不用在迴圈還沒有開始的時候,就產生好要使用的元素。所使用的元素可以在迴圈過程中逐次產生。這樣,節省了空間,提高了效率,編程更靈活。
異常處理 在項目開發中,異常處理是不可或缺的。異常處理協助人們debug,通過更加豐富的資訊,讓人們更容易找到bug的所在。異常處理還可以提高程式的容錯性。
我們之前在講迴圈對象的時候,曾提到一個StopIteration的異常,該異常是在迴圈對象窮盡所有元素時的報錯。
我們以它為例,來說明基本的異常處理。
一個包含異常的程式:re = iter(range(5))for i in range(100): print re.next()print 'HaHaHaHa'
首先,我們定義了一個迴圈對象re,該迴圈對象將進行5次迴圈,每次使用序列的一個元素。
在隨後的for迴圈中,我們手工調用next()函數。當迴圈進行到第6次的時候,re.next()不會再返回元素,而是拋出(raise)StopIteration的異常。整個程式將會中斷。我們可以修改以上異常程式,直到完美的沒有bug。但另一方面,如果我們在寫程式的時候,知道這裡可能犯錯以及可能的犯錯類型,我們可以針對該異常類型定義好”應急預案“。
re = iter(range(5))try: for i in range(100): print re.next()except StopIteration: print 'here is end 'print 'HaHaHaHa'
在try程式段中,我們放入容易犯錯的部分。我們可以跟上except,來說明如果在try部分的語句發生StopIteration時,程式該做的事情。如果沒有發生異常,則except部分被跳過。
隨後,程式將繼續運行,而不是徹底中斷。完整的文法結構如下:
try: ...except exception1: ...except exception2: ...except: ...else: ...finally: ...
如果try中有異常發生時,將執行異常的歸屬,執行except。異常層層比較,看是否是exception1, exception2...,直到找到其歸屬,執行相應的except中的語句。如果except後面沒有任何參數,那麼表示所有的exception都交給這段程式處理。比如:
try: print(a*2)except TypeError: print("TypeError")except: print("Not Type Error & Error noted")
由於a沒有定義,所以是NameError。異常最終被except:部分的程式捕捉。
如果無法將異常交給合適的對象,異常將繼續向上層拋出,直到被捕捉或者造成主程式報錯。比如下面的程式
def test_func(): try: m = 1/0 except NameError: print("Catch NameError in the sub-function")try: test_func()except ZeroDivisionError: print("Catch error in the main program")
子程式的try...except...結構無法處理相應的除以0的錯誤,所以錯誤被拋給上層的主程式。
如果try中沒有異常,那麼except部分將跳過,執行else中的語句。
finally是無論是否有異常,最後都要做的一些事情。
流程如下,
try->異常->except->finally
try->無異常->else->finally
總結
- 詞典
- dic={'tom':11,'sam':57}
- 增加元素
- 注意
- key-value,在對key的操作都要引號無論是定義或者引用。
- 且key的值是不可變的,value是可以變動的;
- 字典元素迴圈調用
- 常用方法
- >>> dic.keys() # 返回dic所有的鍵
- >>> dic.values() # 返回dic所有的值
- >>> dic.items() # 返回dic所有的元素(索引值對)
- >>> dic.clear() # 清空dic,dict變為{}
- >>> del dic['tom'] # 刪除 dic 的‘tom’元素
- 文字檔輸入輸出
- 模組
- 模組引用
- import a as b
- from a import function1
- from a import *
- 搜尋模組的路徑
- - 程式所在的檔案夾
- - 標準庫的安裝路徑
- - 作業系統環境變數PYTHONPATH所包含的路徑
- 模組包
- 將功能相似的模組放在同一檔案夾中(如this_dir)構成模組包
- import this_dir.module
- 引入this_dir 檔案夾中的module模組
- this_dir中必須包含 __init__.py檔案,告訴Python這是一個模組包。
- 函數參數
- 值傳遞
- 關鍵字傳遞
- 參數預設值
- 包裹傳遞
- def func(*name):
- func(1,4,6): 將數 1,4,6 傳給name 作為一個tuple (1,4,6)
- func(5,6,7,1,2): 將數5,6,7,1,2 傳給name 作為一個tuple(5,6,7,1,2)
- def func(**dict):
- func(a=1,b=9):將數a=1,b=9 傳給dict作為字典('a':1,'b':9)
- 像是將資料打包一起傳送,因此叫做包裹傳遞
- 解包裹
- def func(a,b):
- args=(1,2)
- func(*args)
- 傳遞的時候,將一個tuple args 傳過去變成 三個數
- dict={'a':1,'b':2}
- func(**dict)
- 傳遞的時候,將字典 dict 傳過去變成三個數
- 注意,tuple 傳是* ,dict傳則是**
- 迴圈設計
- range()
- enumerate()
- zip()
- for line in open('test.txt'):
- 異常處理
- try->異常->except->finally
- try->無異常->else->finally