詞典

---

詞典(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 first for 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會在以下路徑中搜索它想要尋找的模塊：

程序所在的文件夾

標準庫的安裝路徑

操作系統環境變量PYTHONPATH所包含的路徑

如果你有自定義的模塊，或者下載的模塊，可以根據情況放在相應的路徑，以便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 indexprint 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
abcd efg

我們運行一下python命令行：

>>>f = open('test.txt')>>>f.next()>>>f.next()...

?

不斷輸入f.next()，直到最后出現StopIteration open()返回的實際上是一個循環對象，包含有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/0except 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

轉載于:https://www.cnblogs.com/Aiapple/p/5261503.html

總結

以上是生活随笔為你收集整理的python基础学习笔记2的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。