python基礎學習筆記2,python基礎學習筆記

來源:互聯網
上載者:User

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}
    • 增加元素
      • dic['limi']=99
    • 注意
      • key-value,在對key的操作都要引號無論是定義或者引用。
      • 且key的值是不可變的,value是可以變動的;
    • 字典元素迴圈調用
      • for key in dic:
    • 常用方法
      • >>> dic.keys()     # 返回dic所有的鍵
      • >>> dic.values()  # 返回dic所有的值
      • >>> dic.items()   # 返回dic所有的元素(索引值對)
      • >>> dic.clear()    # 清空dic,dict變為{}
      • >>> del dic['tom']  # 刪除 dic 的‘tom’元素
  • 文字檔輸入輸出
    • 建立檔案對象
      • f = open(檔案名稱,模式)
        • 模式
          • "r"     # 唯讀
          • “w” # 寫入
  • 模組
    • 模組引用
      • 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

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.