Python語法速覽（二）

Python 日期和時間

Python 提供了一個 time 和 calendar 模塊可以用于格式化日期和時間。 時間間隔是以秒為單位的浮點小數。 每個時間戳都以自從1970年1月1日午夜（歷元）經過了多長時間來表示。 Python 的 time 模塊下有很多函數可以轉換常見日期格式。如函數time.time()用于獲取當前時間戳 import time; # 引入time模塊 ticks = time.time() print "當前時間戳為:", ticks * 什么是時間元組？ 很多Python函數用一個元組裝起來的9組數字處理時間: 上述也就是struct_time元組。這種結構具有如下屬性：

獲取當前時間 從返回浮點數的時間戳方式向時間元組轉換，只要將浮點數傳遞給如localtime之類的函數 localtime = time.localtime(time.time()) 本地時間為 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)

獲取格式化的時間 你可以根據需求選取各種格式，但是最簡單的獲取可讀的時間模式的函數是asctime(): localtime = time.asctime( time.localtime(time.time()) ) 本地時間為 : Thu Apr 7 10:05:21 2016

格式化日期 我們可以使用 time 模塊的 strftime 方法來格式化日期 time.strftime(format[, t]) /# 格式化成2016-03-20 11:45:39形式 print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) /# 格式化成Sat Mar 28 22:24:24 2016形式 print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) /# 將格式字符串轉換為時間戳 a = "Sat Mar 28 22:24:24 2016" print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))

python中時間日期格式化符號： %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 當前時區的名稱 %% %號本身

獲取某月日歷 Calendar模塊有很廣泛的方法用來處理年歷和月歷 cal = calendar.month(2016, 1) print cal

Time 模塊 Time 模塊包含了以下內置函數，既有時間處理的，也有轉換時間格式

日歷（Calendar）模塊 此模塊的函數都是日歷相關的，例如打印某月的字符月歷。 星期一是默認的每周第一天，星期天是默認的最后一天。更改設置需調用calendar.setfirstweekday()

其他相關模塊和函數 在Python中，其他處理日期和時間的模塊還有： datetime模塊 pytz模塊 dateutil模塊

Python 函數

函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。 * 定義一個函數

你可以定義一個由自己想要功能的函數，以下是簡單的規則： 函數代碼塊以 def 關鍵詞開頭，后接函數標識符名稱和圓括號()。 任何傳入參數和自變量必須放在圓括號中間。圓括號之間可以用于定義參數。 函數的第一行語句可以選擇性地使用文檔字符串—用于存放函數說明。 函數內容以冒號起始，并且縮進。 return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當于返回 None。

def?functionname(?parameters?):???"函數_文檔字符串"???function_suite???return?[expression]

默認情況下，參數值和參數名稱是按函數聲明中定義的順序匹配起來的 * 函數調用

定義一個函數只給了函數一個名稱，指定了函數里包含的參數，和代碼塊結構。 這個函數的基本結構完成以后，你可以通過另一個函數調用執行，也可以直接從Python提示符執行。 * 參數傳遞 在 python 中，類型屬于對象，變量是沒有類型的： a=[1,2,3] a="Runoob" 以上代碼中，[1,2,3] 是 List 類型，"Runoob" 是 String 類型，而變量 a 是沒有類型，她僅僅是一個對象的引用（一個指針），可以是 List 類型對象，也可以指向 String 類型對象。 * 可更改(mutable)與不可更改(immutable)對象 在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。 1. 不可變類型：變量賦值 a=5 后再賦值 a=10，這里實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當于新生成了a。 2. 可變類型：變量賦值 la=[1,2,3,4] 后再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。 python 函數的參數傳遞： 1. 不可變類型：類似 c++ 的值傳遞，如 整數、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在 fun（a）內部修改 a 的值，只是修改另一個復制的對象，不會影響 a 本身。 2. 可變類型：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改后fun外部的la也會受影響 python 中一切都是對象，嚴格意義我們不能說值傳遞還是引用傳遞，我們應該說傳不可變對象和傳可變對象。 * python 傳不可變對象實例 實例(Python 2.0+)

def?ChangeInt(?a?):????a?=?10b?=?2ChangeInt(b)print?b?#?結果是?2

實例中有 int 對象 2，指向它的變量是 b，在傳遞給 ChangeInt 函數時，按傳值的方式復制了變量 b，a 和 b 都指向了同一個 Int 對象，在 a=10 時，則新生成一個 int 值對象 10，并讓 a 指向它。 * 傳可變對象實例 /# 可寫函數說明

def?changeme(?mylist?):???"修改傳入的列表"???mylist.append([1,2,3,4]);???print?"函數內取值:?",?mylist???return

/# 調用changeme函數 mylist = [10,20,30]; changeme( mylist ); print "函數外取值: ", mylist 實例中傳入函數的和在末尾添加新內容的對象用的是同一個引用，故輸出結果如下： * 參數

以下是調用函數時可使用的正式參數類型： 必備參數 關鍵字參數 默認參數 不定長參數 1. 必備參數 必備參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。 調用printme()函數，你必須傳入一個參數，不然會出現語法錯誤 2. 關鍵字參數 關鍵字參數和函數調用關系緊密，函數調用使用關鍵字參數來確定傳入的參數值。 使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因為 Python 解釋器能夠用參數名匹配參數值 3. 默認參數 調用函數時，默認參數的值如果沒有傳入，則被認為是默認值 4. 不定長參數 你可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，和上述2種參數不同，聲明時不會命名。

def?functionname([formal_args,]?*var_args_tuple?):???"函數_文檔字符串"???function_suite???return?[expression]

加了星號（*）的變量名會存放所有未命名的變量參數 * 匿名函數 python 使用 lambda 來創建匿名函數。 lambda只是一個表達式，函數體比def簡單很多。 lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。 lambda函數擁有自己的命名空間，且不能訪問自有參數列表之外或全局命名空間里的參數。 雖然lambda函數看起來只能寫一行，卻不等同于C或C++的內聯函數，后者的目的是調用小函數時不占用棧內存從而增加運行效率。 lambda函數的語法只包含一個語句，如下： lambda [arg1 [,arg2,.....argn]]:expression /# 可寫函數說明 sum = lambda arg1, arg2: arg1 + arg2; /# 調用sum函數 print "相加后的值為 : ", sum( 10, 20 ) * return 語句 return語句[表達式]退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None。 * 變量作用域 一個程序的所有的變量并不是在哪個位置都可以訪問的。訪問權限決定于這個變量是在哪里賦值的。 變量的作用域決定了在哪一部分程序你可以訪問哪個特定的變量名稱。兩種最基本的變量作用域如下： 全局變量 局部變量 1. 全局變量和局部變量 定義在函數內部的變量擁有一個局部作用域，定義在函數外的擁有全局作用域。 局部變量只能在其被聲明的函數內部訪問，而全局變量可以在整個程序范圍內訪問。調用函數時，所有在函數內聲明的變量名稱都將被加入到作用域中

Python 模塊

Python 模塊(Module)，是一個 Python 文件，以 .py 結尾，包含了 Python 對象定義和Python語句。 模塊讓你能夠有邏輯地組織你的 Python 代碼段。 把相關的代碼分配到一個模塊里能讓你的代碼更好用，更易懂。 模塊能定義函數，類和變量，模塊里也能包含可執行的代碼 support.py 模塊：

def?print_func(?par?):???print?"Hello?:?",?par???return

import 語句 模塊的引入 模塊定義好后，我們可以使用 import 語句來引入模塊，語法如下： import module1[, module2[,... moduleN]] 比如要引用模塊 math，就可以在文件最開始的地方用 import math 來引入。在調用 math 模塊中的函數時，必須這樣引用： 模塊名.函數名 當解釋器遇到 import 語句，如果模塊在當前的搜索路徑就會被導入。 搜索路徑是一個解釋器會先進行搜索的所有目錄的列表。如想要導入模塊 support.py，需要把命令放在腳本的頂端： /# 導入模塊 import support /# 現在可以調用模塊里包含的函數了 support.print_func("Runoob") 一個模塊只會被導入一次，不管你執行了多少次import。這樣可以防止導入模塊被一遍又一遍地執行。

from…import 語句 Python 的 from 語句讓你從模塊中導入一個指定的部分到當前命名空間中。語法如下： from modname import name1[, name2[, ... nameN]] 例如，要導入模塊 fib 的 fibonacci 函數，使用如下語句： from fib import fibonacci 這個聲明不會把整個 fib 模塊導入到當前的命名空間中，它只會將 fib 里的 fibonacci 單個引入到執行這個聲明的模塊的全局符號表。

from…import* 語句 把一個模塊的所有內容全都導入到當前的命名空間也是可行的，只需使用如下聲明： from modname import * 這提供了一個簡單的方法來導入一個模塊中的所有項目。然而這種聲明不該被過多地使用。 例如我們想一次性引入 math 模塊中所有的東西，語句如下： from math import *

搜索路徑 當你導入一個模塊，Python 解析器對模塊位置的搜索順序是： 1、當前目錄 2、如果不在當前目錄，Python 則搜索在 shell 變量 PYTHONPATH 下的每個目錄。 3、如果都找不到，Python會察看默認路徑。UNIX下，默認路徑一般為/usr/local/lib/python/。 模塊搜索路徑存儲在 system 模塊的 sys.path 變量中。變量里包含當前目錄，PYTHONPATH和由安裝過程決定的默認目錄。

PYTHONPATH 變量 作為環境變量，PYTHONPATH 由裝在一個列表里的許多目錄組成。PYTHONPATH 的語法和 shell 變量 PATH 的一樣。 在 Windows 系統，典型的 PYTHONPATH 如下： set PYTHONPATH=c:\python27\lib; 在 UNIX 系統，典型的 PYTHONPATH 如下： set PYTHONPATH=/usr/local/lib/python

命名空間和作用域 變量是擁有匹配對象的名字（標識符）。命名空間是一個包含了變量名稱們（鍵）和它們各自相應的對象們（值）的字典。 一個 Python 表達式可以訪問局部命名空間和全局命名空間里的變量。如果一個局部變量和一個全局變量重名，則局部變量會覆蓋全局變量。 每個函數都有自己的命名空間。類的方法的作用域規則和通常函數的一樣。 Python 會智能地猜測一個變量是局部的還是全局的，它假設任何在函數內賦值的變量都是局部的。 因此，如果要給函數內的全局變量賦值，必須使用 global 語句。 global VarName 的表達式會告訴 Python， VarName 是一個全局變量，這樣 Python 就不會在局部命名空間里尋找這個變量了。 例如，我們在全局命名空間里定義一個變量 Money。我們再在函數內給變量 Money 賦值，然后 Python 會假定 Money 是一個局部變量。然而，我們并沒有在訪問前聲明一個局部變量 Money，結果就是會出現一個 UnboundLocalError 的錯誤。取消 global 語句的注釋就能解決這個問題。 Money = 2000 def AddMoney(): # 想改正代碼就取消以下注釋: # global Money Money = Money + 1 print Money AddMoney() print Money

dir()函數 dir() 函數一個排好序的字符串列表，內容是一個模塊里定義過的名字。 返回的列表容納了在一個模塊里定義的所有模塊，變量和函數 在這里，特殊字符串變量name指向模塊的名字，file指向該模塊的導入文件名。

globals() 和 locals() 函數 根據調用地方的不同，globals() 和 locals() 函數可被用來返回全局和局部命名空間里的名字。 如果在函數內部調用 locals()，返回的是所有能在該函數里訪問的命名。 如果在函數內部調用 globals()，返回的是所有在該函數里能訪問的全局名字。 兩個函數的返回類型都是字典。所以名字們能用 keys() 函數摘取。

reload() 函數 當一個模塊被導入到一個腳本，模塊頂層部分的代碼只會被執行一次。 因此，如果你想重新執行模塊里頂層部分的代碼，可以用 reload() 函數。該函數會重新導入之前導入過的模塊。 reload(module_name) 在這里，module_name要直接放模塊的名字，而不是一個字符串形式。比如想重載 hello 模塊 reload(hello)

Python中的包 包是一個分層次的文件目錄結構，它定義了一個由模塊及子包，和子包下的子包等組成的 Python 的應用環境。 簡單來說，包就是文件夾，但該文件夾下必須存在?init.py 文件, 該文件的內容可以為空。init.py 用于標識當前文件夾是一個包。 考慮一個在 package_runoob 目錄下的 runoob1.py、runoob2.py、init.py 文件

test.pypackage_runoob|--?__init__.py|--?runoob1.py|--?runoob2.py

package_runoob/runoob1.py/#!/usr/bin/python/#?-*-?coding:?UTF-8?-*-def?runoob1():???print?"I'm?in?runoob1"

package_runoob/runoob2.py/#!/usr/bin/python/#?-*-?coding:?UTF-8?-*-def?runoob2():???print?"I'm?in?runoob2"

現在，在 package_runoob 目錄下創建?init.py：

package_runoob/__init__.py/#!/usr/bin/python/#?-*-?coding:?UTF-8?-*-if?__name__?==?'__main__':????print?'作為主程序運行'else:????print?'package_runoob?初始化'

然后我們在 package_runoob 同級目錄下創建 test.py 來調用 package_runoob 包

test.py/#!/usr/bin/python/#?-*-?coding:?UTF-8?-*-/#?導入?Phone?包from?package_runoob.runoob1?import?runoob1from?package_runoob.runoob2?import?runoob2runoob1()runoob2()

Python 文件I/O

打印到屏幕 最簡單的輸出方法是用print語句，你可以給它傳遞零個或多個用逗號隔開的表達式。

讀取鍵盤輸入 Python提供了兩個內置函數從標準輸入讀入一行文本，默認的標準輸入是鍵盤。如下： raw_input input

raw_input函數 raw_input([prompt]) 函數從標準輸入讀取一個行，并返回一個字符串（去掉結尾的換行符）

input函數 input([prompt]) 函數和 raw_input([prompt]) 函數基本類似，但是 input 可以接收一個Python表達式作為輸入，并將運算結果返回 str = input("請輸入：") print "你輸入的內容是: ", str 請輸入：[x*5 for x in range(2,10,2)] 你輸入的內容是: [10, 20, 30, 40]

打開和關閉文件 現在，您已經可以向標準輸入和輸出進行讀寫。現在，來看看怎么讀寫實際的數據文件。 Python 提供了必要的函數和方法進行默認情況下的文件基本操作。你可以用 file 對象做大部分的文件操作

open 函數 你必須先用Python內置的open()函數打開一個文件，創建一個file對象，相關的方法才可以調用它進行讀寫。 語法： file object = open(file_name [, access_mode][, buffering]) 各個參數的細節如下： file_name：file_name變量是一個包含了你要訪問的文件名稱的字符串值。 access_mode：access_mode決定了打開文件的模式：只讀，寫入，追加等。所有可取值見如下的完全列表。這個參數是非強制的，默認文件訪問模式為只讀(r)。 buffering:如果buffering的值被設為0，就不會有寄存。如果buffering的值取1，訪問文件時會寄存行。如果將buffering的值設為大于1的整數，表明了這就是的寄存區的緩沖大小。如果取負值，寄存區的緩沖大小則為系統默認。

File對象的屬性 一個文件被打開后，你有一個file對象，你可以得到有關該文件的各種信息。 file.closed 返回true如果文件已被關閉，否則返回false。 file.mode 返回被打開文件的訪問模式。 file.name 返回文件的名稱。 file.softspace 如果用print輸出后，必須跟一個空格符，則返回false。否則返回true。

close()方法 File 對象的 close（）方法刷新緩沖區里任何還沒寫入的信息，并關閉該文件，這之后便不能再進行寫入。 當一個文件對象的引用被重新指定給另一個文件時，Python 會關閉之前的文件。用 close（）方法關閉文件是一個很好的習慣

write()方法 write()方法可將任何字符串寫入一個打開的文件。需要重點注意的是，Python字符串可以是二進制數據，而不是僅僅是文字。 write()方法不會在字符串的結尾添加換行符('\n')：

read()方法 read（）方法從一個打開的文件中讀取一個字符串。需要重點注意的是，Python字符串可以是二進制數據，而不是僅僅是文字。 fileObject.read([count]) 在這里，被傳遞的參數是要從已打開文件中讀取的字節計數。該方法從文件的開頭開始讀入，如果沒有傳入count，它會嘗試盡可能多地讀取更多的內容，很可能是直到文件的末尾。

文件定位 tell()方法告訴你文件內的當前位置, 換句話說，下一次的讀寫會發生在文件開頭這么多字節之后。 seek（offset [,from]）方法改變當前文件的位置。Offset變量表示要移動的字節數。From變量指定開始移動字節的參考位置。 如果from被設為0，這意味著將文件的開頭作為移動字節的參考位置。如果設為1，則使用當前的位置作為參考位置。如果它被設為2，那么該文件的末尾將作為參考位置。

重命名和刪除文件 Python的os模塊提供了幫你執行文件處理操作的方法，比如重命名和刪除文件。 要使用這個模塊，你必須先導入它，然后才可以調用相關的各種功能。 rename()方法： rename()方法需要兩個參數，當前的文件名和新文件名。 os.rename(current_file_name, new_file_name) remove()方法 你可以用remove()方法刪除文件，需要提供要刪除的文件名作為參數。 os.remove(file_name)

Python里的目錄： 所有文件都包含在各個不同的目錄下，不過Python也能輕松處理。os模塊有許多方法能幫你創建，刪除和更改目錄。

mkdir()方法 可以使用os模塊的mkdir()方法在當前目錄下創建新的目錄們。你需要提供一個包含了要創建的目錄名稱的參數。 os.mkdir("newdir")

chdir()方法 可以用chdir()方法來改變當前的目錄。chdir()方法需要的一個參數是你想設成當前目錄的目錄名稱。

getcwd()方法： getcwd()方法顯示當前的工作目錄。

rmdir()方法 rmdir()方法刪除目錄，目錄名稱以參數傳遞。 在刪除這個目錄之前，它的所有內容應該先被清除。 以下是刪除" /tmp/test"目錄的例子。目錄的完全合規的名稱必須被給出，否則會在當前目錄下搜索該目錄。

文件、目錄相關的方法 File 對象和 OS 對象提供了很多文件與目錄的操作方法，可以通過點擊下面鏈接查看詳情： File 對象方法: file 對象提供了操作文件的一系列方法。 OS 對象方法: 提供了處理文件及目錄的一系列方法。

Python File(文件) 方法

open() 方法 Python open() 方法用于打開一個文件，并返回文件對象，在對文件進行處理過程都需要使用到這個函數，如果該文件無法被打開，會拋出 OSError。 注意：使用 open() 方法一定要保證關閉文件對象，即調用 close() 方法。 open() 函數常用形式是接收兩個參數：文件名(file)和模式(mode)。 open(file, mode='r') 完整的語法格式為： open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) 參數說明: file: 必需，文件路徑（相對或者絕對路徑）。 mode: 可選，文件打開模式 buffering: 設置緩沖 encoding: 一般使用utf8 errors: 報錯級別 newline: 區分換行符 closefd: 傳入的file參數類型 opener:

Python 異常處理

python提供了兩個非常重要的功能來處理python程序在運行中出現的異常和錯誤。你可以使用該功能來調試python程序。 異常處理: 本站Python教程會具體介紹。 斷言(Assertions):本站Python教程會具體介紹。 * 異常處理

捕捉異常可以使用try/except語句。 try/except語句用來檢測try語句塊中的錯誤，從而讓except語句捕獲異常信息并處理。 如果你不想在異常發生時結束你的程序，只需在try里捕獲它。 語法： 以下為簡單的try....except...else的語法：

try:<語句>????????#運行別的代碼except?<名字>：<語句>????????#如果在try部份引發了'name'異常except?<名字>，<數據>:<語句>????????#如果引發了'name'異常，獲得附加的數據else:<語句>????????#如果沒有異常發生

try的工作原理是，當開始一個try語句后，python就在當前程序的上下文中作標記，這樣當異常出現時就可以回到這里，try子句先執行，接下來會發生什么依賴于執行時是否出現異常。 如果當try后的語句執行時發生異常，python就跳回到try并執行第一個匹配該異常的except子句，異常處理完畢，控制流就通過整個try語句（除非在處理異常時又引發新的異常）。 如果在try后的語句里發生了異常，卻沒有匹配的except子句，異常將被遞交到上層的try，或者到程序的最上層（這樣將結束程序，并打印缺省的出錯信息）。 如果在try子句執行時沒有發生異常，python將執行else語句后的語句（如果有else的話），然后控制流通過整個try語句。

try:????fh?=?open("testfile",?"w")????fh.write("這是一個測試文件，用于測試異常!!")except?IOError:????print?"Error:?沒有找到文件或讀取文件失敗"else:????print?"內容寫入文件成功"????fh.close()

使用except而不帶任何異常類型 你可以不帶任何異常類型使用except，如下實例：

try:????正常的操作???......................except:????發生異常，執行這塊代碼???......................else:????如果沒有異常執行這塊代碼

以上方式try-except語句捕獲所有發生的異常。但這不是一個很好的方式，我們不能通過該程序識別出具體的異常信息。因為它捕獲所有的異常 * 使用except而帶多種異常類型 你也可以使用相同的except語句來處理多個異常信息，如下所示：

try:????正常的操作???......................except(Exception1[,?Exception2[,...ExceptionN]]]):???發生以上多個異常中的一個，執行這塊代碼???......................else:????如果沒有異常執行這塊代碼

try-finally 語句 try-finally 語句無論是否發生異常都將執行最后的代碼。 try: <語句> finally: <語句> #退出try時總會執行 raise

異常的參數 一個異常可以帶上參數，可作為輸出的異常信息參數。 你可以通過except語句來捕獲異常的參數 try: 正常的操作 ...................... except ExceptionType, Argument: 你可以在這輸出 Argument 的值...

觸發異常 我們可以使用raise語句自己觸發異常 raise語法格式如下： raise [Exception [, args [, traceback]]] 語句中 Exception 是異常的類型（例如，NameError）參數標準異常中任一種，args 是自已提供的異常參數。 最后一個參數是可選的（在實踐中很少使用），如果存在，是跟蹤異常對象。

用戶自定義異常 通過創建一個新的異常類，程序可以命名它們自己的異常。異常應該是典型的繼承自Exception類，通過直接或間接的方式。 以下為與RuntimeError相關的實例,實例中創建了一個類，基類為RuntimeError，用于在異常觸發時輸出更多的信息。 在try語句塊中，用戶自定義的異常后執行except塊語句，變量 e 是用于創建Networkerror類的實例。 class Networkerror(RuntimeError): def?init(self, arg): self.args = arg

Python OS 文件/目錄方法

os 模塊提供了非常豐富的方法用來處理文件和目錄。

Python 內置函數

Python 面向對象

Python從設計之初就已經是一門面向對象的語言，正因為如此，在Python中創建一個類和對象是很容易的。本章節我們將詳細介紹Python的面向對象編程。

* 面向對象技術簡介

類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。

類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常不作為實例變量使用。

數據成員：類變量或者實例變量, 用于處理類及其實例對象的相關的數據。

方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。

局部變量：定義在方法中的變量，只作用于當前實例的類。

實例變量：在類的聲明中，屬性是用變量來表示的。這種變量就稱為實例變量，是在類聲明的內部但是在類的其他成員方法之外聲明的。

繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關系（例圖，Dog是一個Animal）。

實例化：創建一個類的實例，類的具體對象。

方法：類中定義的函數。

對象：通過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。

* 創建類

使用 class 語句來創建一個新類，class 之后為類的名稱并以冒號結尾:

class?ClassName:???'類的幫助信息'???#類文檔字符串???class_suite??#類體

類的幫助信息可以通過ClassName.doc查看。 class_suite 由類成員，方法，數據屬性組成。

empCount 變量是一個類變量，它的值將在這個類的所有實例之間共享。你可以在內部類或外部類使用 Employee.empCount 訪問。 第一種方法init()方法是一種特殊的方法，被稱為類的構造函數或初始化方法，當創建了這個類的實例時就會調用該方法 self 代表類的實例，self 在定義類的方法時是必須有的，雖然在調用時不必傳入相應的參數。 * self代表類的實例，而非類 類的方法與普通的函數只有一個特別的區別——它們必須有一個額外的第一個參數名稱, 按照慣例它的名稱是 self。 * 創建實例對象 實例化類其他編程語言中一般用關鍵字 new，但是在 Python 中并沒有這個關鍵字，類的實例化類似函數調用方式。 以下使用類的名稱 Employee 來實例化，并通過?init?方法接收參數。 "創建 Employee 類的第一個對象" emp1 = Employee("Zara", 2000) "創建 Employee 類的第二個對象" emp2 = Employee("Manni", 5000) * 訪問屬性 您可以使用點號 . 來訪問對象的屬性。使用如下類的名稱訪問類變量:

你也可以使用以下函數的方式來訪問屬性： getattr(obj, name[, default]) : 訪問對象的屬性。 hasattr(obj,name) : 檢查是否存在一個屬性。 setattr(obj,name,value) : 設置一個屬性。如果屬性不存在，會創建一個新屬性。 delattr(obj, name) : 刪除屬性。 * Python內置類屬性?dict?: 類的屬性（包含一個字典，由類的數據屬性組成）?doc?:類的文檔字符串?name: 類名?module: 類定義所在的模塊（類的全名是'main.className'，如果類位于一個導入模塊mymod中，那么className.module?等于 mymod）?bases?: 類的所有父類構成元素（包含了一個由所有父類組成的元組） * python對象銷毀(垃圾回收) Python 使用了引用計數這一簡單技術來跟蹤和回收垃圾。 在 Python 內部記錄著所有使用中的對象各有多少引用。 一個內部跟蹤變量，稱為一個引用計數器。 當對象被創建時， 就創建了一個引用計數， 當這個對象不再需要時， 也就是說， 這個對象的引用計數變為0 時， 它被垃圾回收。但是回收不是"立即"的， 由解釋器在適當的時機，將垃圾對象占用的內存空間回收。 垃圾回收機制不僅針對引用計數為0的對象，同樣也可以處理循環引用的情況。循環引用指的是，兩個對象相互引用，但是沒有其他變量引用他們。這種情況下，僅使用引用計數是不夠的。Python 的垃圾收集器實際上是一個引用計數器和一個循環垃圾收集器。作為引用計數的補充， 垃圾收集器也會留心被分配的總量很大（及未通過引用計數銷毀的那些）的對象。 在這種情況下， 解釋器會暫停下來， 試圖清理所有未引用的循環。

實例 析構函數?del?，del在對象銷毀的時候被調用，當對象不再被使用時，del方法運行： 注意：通常你需要在單獨的文件中定義一個類， * 類的繼承 面向對象的編程帶來的主要好處之一是代碼的重用，實現這種重用的方法之一是通過繼承機制。 通過繼承創建的新類稱為子類或派生類，被繼承的類稱為基類、父類或超類。 繼承語法 class 派生類名(基類名) ... 在python中繼承中的一些特點： 1、如果在子類中需要父類的構造方法就需要顯示的調用父類的構造方法，或者不重寫父類的構造方法。詳細說明可查看：python 子類繼承父類構造函數說明。 2、在調用基類的方法時，需要加上基類的類名前綴，且需要帶上 self 參數變量。區別在于類中調用普通函數時并不需要帶上 self 參數 3、Python 總是首先查找對應類型的方法，如果它不能在派生類中找到對應的方法，它才開始到基類中逐個查找。（先在本類中查找調用的方法，找不到才去基類中找）。 如果在繼承元組中列了一個以上的類，那么它就被稱作"多重繼承" 。 派生類的聲明，與他們的父類類似，繼承的基類列表跟在類名之后，如下所示： class SubClassName (ParentClass1[, ParentClass2, ...]): ... 你可以使用issubclass()或者isinstance()方法來檢測。 issubclass() - 布爾函數判斷一個類是另一個類的子類或者子孫類，語法：issubclass(sub,sup) isinstance(obj, Class) 布爾函數如果obj是Class類的實例對象或者是一個Class子類的實例對象則返回true。

方法重寫 如果你的父類方法的功能不能滿足你的需求，你可以在子類重寫你父類的方法：

基礎重載方法

運算符重載 Python同樣支持運算符重載

類屬性與方法

類的私有屬性 __private_attrs：兩個下劃線開頭，聲明該屬性為私有，不能在類的外部被使用或直接訪問。在類內部的方法中使用時 self.__private_attrs。

類的方法 在類的內部，使用 def 關鍵字可以為類定義一個方法，與一般函數定義不同，類方法必須包含參數 self,且為第一個參數

類的私有方法?private_method：兩個下劃線開頭，聲明該方法為私有方法，不能在類的外部調用。在類的內部調用 self.__private_methods Python不允許實例化的類訪問私有數據，但你可以使用 object.classNameattrName（ 對象名.類名私有屬性名 ）訪問屬性

單下劃線、雙下劃線、頭尾雙下劃線說明：

foo: 定義的是特殊方法，一般是系統定義名字 ，類似?init() 之類的。

_foo: 以單下劃線開頭的表示的是 protected 類型的變量，即保護類型只能允許其本身與子類進行訪問，不能用于 from module import *

__foo: 雙下劃線的表示的是私有類型(private)的變量, 只能是允許這個類本身進行訪問了。

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。