python基礎總結_ZenDei技術網路在線

1.3.Python基本語法 1.3.1 行和縮進 Python中，不使用括弧來表示代碼的類和函數定義塊或流程式控制制。代碼塊是由行縮進，縮進位的數目是可變的，但是在塊中的所有語句必須縮進相同的量。如下所示： if True: print "True"[dht1] else: print "Fals ...

1.3.Python基本語法

1.3.1 行和縮進

Python中，不使用括弧來表示代碼的類和函數定義塊或流程式控制制。

代碼塊是由行縮進，縮進位的數目是可變的，但是在塊中的所有語句必須縮進相同的量。

如下所示：

if True:

print "True"[dht1]

else:

print "False"

然而，在本實施例中的第二塊將產生一個錯誤：

if True:

print "Answer"

print "True"

else:

print "Answer"

print "False"

1.3.2 Python引號

Python接受單引號（'），雙引號（“）和三（''或”“”）引用，以表示字元串常量，只要是同一類型的引號開始和結束的字元串。

三重引號可以用於跨越多個行的字元串。例如，所有下列是合法的：

word = 'word'

sentence = "This is a sentence."

paragraph = """This is a paragraph. It is

made up of multiple lines and sentences."""

1.3.3 Python註釋

“＃”號之後字元和到物理行是註釋的一部分，Python解釋器會忽略它們。

#!/usr/bin/python

# First comment

print "Hello, Python!"; # second comment

這將產生以下結果：

Hello, Python!

註釋可能會在聲明中表達或同一行之後：

name = "Madisetti" # This is again comment

你可以使用多行註釋如下：

# This is a comment.

# This is a comment, too.

# I said that already.

1.3.4 分號的使用

python中一個語句的結束不需要使用分號

如果想在一行中輸入多個語句，可使用分號：

import sys; x = 'foo'; sys.stdout.write(x+"""

""")

1.4.Python的變數和集合

Python有五個標準的數據類型：

a) 數字

b) 字元串

c) 列表

d) 元組

e) 字典

f) set

python中定義變數時不需要顯示指定變數類型，以下為python中變數使用的典型語法：

1.4.1變數定義和賦值

#基本使用

counter = 100 # 整型

miles = 1000.0 # 浮點

name = "John" # 字元串

print counter

print miles

print name

#多重賦值

a = b = c = 1

d, e, f = 1, 2, "john"

1.4.2字元串的使用

str = 'Hello World!' #字元串在python中本質上是一個字元序列Seq

print str # 列印整個字元串

print str[0] # 列印字元串第一個字母

print str[2:5] # 列印第3到第5個字母

print str[2:] # 列印從第3個字母到末尾

print str * 2 # 字元串重覆2次

print str + "TEST" # 字元串拼接

1.4.3列表的使用

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]

tinylist = [123, 'john']

print list # 列印整個列表

print list[0] # 列印第一個元素

print list[1:3] # 列印第二和第三個元素

print list[2:] # 列印第三個元素到末尾

print tinylist * 2 # 列印2次

print list + tinylist # 拼接兩個list

#修改list中的元素

list[0]=”python”

print(list)

將輸出以下結果：

['abcd', 786, 2.23, 'john', 70.200000000000003]

abcd

[786, 2.23]

[2.23, 'john', 70.200000000000003]

[123, 'john', 123, 'john']

['abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john']

1.4.4元組使用

元組是類似於列表中的序列數據類型，一個元組由數個逗號分隔的值組成。

列表和元組之間的主要區別是：列表用方括弧[]，列表的長度和元素值是可以改變的

而元組用圓括弧()，不能被更新。

元組可以被認為是只讀列表。

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2)

tinytuple = (123, 'john')

print tuple # 列印整個元組

print tuple[0] # 列印第一個元素

print tuple[1:3] # 列印第2、3兩個元素

print tuple[2:] #

print tinytuple * 2 # 重覆2遍

print tuple + tinytuple # 拼接

這將產生以下結果：

('abcd', 786, 2.23, 'john', 70.200000000000003)

abcd

(786, 2.23)

(2.23, 'john', 70.200000000000003)

(123, 'john', 123, 'john')

('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')

1.4.5字典

Python字典是一種哈希表型。由“鍵-值”對組成。

鍵可以是任何Python類型，但通常是數字或字元串。

值可以是任意Python的對象。

字典是由花括弧括弧{}，可分配值，並用方括弧[]訪問。例如：

dict = {}

dict['one'] = "This is one"

dict[2] = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print dict['one'] # Prints value for 'one' key

print dict[2] # Prints value for 2 key

print tinydict # Prints complete dictionary

print tinydict.keys() # Prints all the keys

print tinydict.values() # Prints all the values

這將產生以下結果：

This is one

This is two

{'dept': 'sales', 'code': 6734, 'name': 'john'}

['dept', 'code', 'name']

['sales', 6734, 'john']

1.4.6 set

定義一個set：

a={1,2,3,4,5}

print a

a.remove(3)

a.add(6)

a.union(b)

1.4.7數據類型轉換

有時候，可能需要執行的內置類型之間的轉換。

類型之間的轉換，只需使用類名作為函數。

int(x [,base])	將x轉換為整數。基數指定為base（進位）
long(x [,base] )	將x轉換為一個長整數。基數指定為base，
float(x)	將x轉換到一個浮點數。
complex(real [,imag])	創建一個複數。
str(x)	轉換對象x為字元串表示形式。
eval(str)	計算一個表達式字元串，並返回一個對象。
tuple(s)	把s（序列）轉換為一個元組。
list(s)	把s（序列）轉換為一個列表。
set(s)	把s（序列）轉換為一個set集合。
dict(d)	轉成字典,d必須是（鍵，值）元組序列。

例如：

a=int(‘A’,16)

print(a)

結果為: 10

a=tuple(range(1,10,2))

print(a)

b=tuple("hello")

print b

c=complex(1,2)

print c

x=1

e=eval('x+1')

print e

f=dict([(1,2),(3,4),('a',100)])

print f

結果為：

(1, 3, 5, 7, 9)

('h', 'e', 'l', 'l', 'o')

(1+2j)

{'a': 100, 1: 2, 3: 4}

1.5.Python流程式控制制語法

1.5.1 if語句

var1 = 100

if var1:

print "1 - Got a true expression value"

print var1

var2 = 0

if var2:

print "2 - Got a true expression value"

print var2

print "Good bye!"

#if的條件可以是數字或字元串或者布爾值True和False（布爾表達式）

#如果是數字，則只要不等於0，就為true

#如果是字元串，則只要不是空串，就為true

if else

var = 100

if var == 200:

print "1 - Got a true expression value"

print var

elif var == 150:

print "2 - Got a true expression value"

print var

elif var == 100:

print "3 - Got a true expression value"

print var

else:

print "4 - Got a false expression value"

print var

print "Good bye!"

嵌套if else

var = 100

if var < 200:

print "Expression value is less than 200"

if var == 150:

print "Which is 150"

elif var == 100:

print "Which is 100"

elif var == 50:

print "Which is 50"

elif var < 50:

print "Expression value is less than 50"

else:

print "Could not find true expression"

print "Good bye!"

1.5.2 while迴圈

count = 0

while count < 5:

print count, " is less than 5"

count = count + 1

else:

print count, " is not less than 5"

1.5.3 for迴圈

# 求素數

for num in range(10,20):

for i in range(2,num):

if num%i == 0:

j=num/i

print '%d equals %d * %d' % (num,i,j)

break

else:

print num, 'is a prime number'

#遍歷集合

r=range(10,20)

r={1,2,3,4,5} #set類型

r=["aaa",3,"c"]

print(r)

for num in r:

print(num)

r={"a":9,"b":10}

print(r)

for num in r.values():

print(num)

當執行上面的代碼，產生以下結果：

10 equals 2 * 5

11 is a prime number

12 equals 2 * 6

13 is a prime number

14 equals 2 * 7

15 equals 3 * 5

16 equals 2 * 8

17 is a prime number

18 equals 2 * 9

19 is a prime number

1.6.Python函數

1.6.1 基本形式[M2]

#定義函數

def changeme( mylist ):

"This changes a passed list into this function"

mylist.append([1,2,3,4]);

print "Values inside the function: ", mylist

return (mylist,"haha")

# 調用函數

mylist = [10,20,30];

changeme( mylist );

print "Values outside the function: ", mylist

python的函數調用是引用傳遞，這將產生以下結果：

Values inside the function: [10, 20, 30, [1, 2, 3, 4]]

Values outside the function: [10, 20, 30, [1, 2, 3, 4]]

預設參數和可變參數

# 預設參數

#有預設值的參數後面不能再跟無預設值的參數

def printinfo( name, age = 35 ):

"This prints a passed info into this function"

print "Name: ", name;

print "Age ", age;

return;

#調用

#如果調換了參數的順序，則必須把參數名都帶上

printinfo( age=50, name="miki" );

printinfo( name="miki" );

#可變參數

def printinfo( arg1, *vartuple ):

"This prints a variable passed arguments"

print "Output is: "

print arg1

for var in vartuple:

print var

return;

# 調用

printinfo( 10 );

printinfo( 70, 60, 50 );

1.6.2 匿名函數

² 可以使用lambda關鍵字來創建小的匿名函數。這些函數被稱為匿名，因為它們不是以標準方式通過使用def關鍵字聲明。

² Lambda形式可以採取任何數量的參數，但在表現形式上只返回一個值。它們不能包含命令或多個表達式。

² 匿名函數不能直接調用列印，因為需要lambda表達式。

² lambda函數都有自己的命名空間，並且不能訪問變數高於在其參數列表和那些在全局命名空間的變數。

示例：

# 定義

sum = lambda arg1, arg2: arg1 + arg2 #lambda表達式

# 調用

print "Value of total : ", sum( 10, 20 )

print "Value of total : ", sum( 20, 20 )

##返回多個值

tup=lambda x,y:(x+1,y+1)

c=tup(2,3)

print c[0],c[1]

(a,b)=tup(2,3)

  

  print a,b

  print c[0],c[1]

利用lambda可以實現類似於scala中的高階函數效果：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

def outfunc(func,x,y):

c=func(x,y)

print(c)

outfunc(lambda x,y:x+y,1,2)

1.7.Python模塊

簡單地說，一個模塊是由Python代碼的文件。一個模塊可以定義函數，類和變數。模塊還可以包括可運行的代碼。

1.7.1 模塊的定義和導入

例：以下代碼定義在support.py文件中

def print_func( par ):

print "Hello : ", par

return

在別的模塊比如(hello.py)中可以導入已定義好的模塊

#!/usr/bin/python

#導入模塊

import cn.itcast.test.support

# 使用導入的模塊中的函數

cn.itcast.test.support.print_func("Zara")

#------------------------------------------------

#或者

from cn.itcast.test.support import print_func

print_func("Zara")

1.7.2 模塊和包

在python中一個文件可以被看成一個獨立模塊，而包對應著文件夾，模塊把python代碼分成一些有組織的代碼段，通過導入的方式實現代碼重用。

1.7.1 模塊搜索路徑

導入模塊時，是按照sys.path變數的值搜索模塊，sys.path的值是包含每一個獨立路徑的列表，包含當前目錄、python安裝目錄、PYTHONPATH環境變數，搜索順序按照路徑在列表中的順序（一般當前目錄優先順序最高）。

[‘/home/zhoujh/study_workspace/studynotes/python/python_base’, ‘/usr/local/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/redis-2.2.1-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Flask-0.8-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Jinja2-2.6-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Werkzeug-0.8.3-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/tornado-2.2.1-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/MySQL_python-1.2.3-py2.6-linux-x86_64.egg’, ‘/usr/local/lib/python2.6/site-packages/PIL-1.1.7-py2.6-linux-x86_64.egg’, ‘/usr/local/lib/python2.6/site-packages/SQLAlchemy-0.7.8-py2.6-linux-x86_64.egg’, ‘/home/zhoujh/python_workspace/python_app’, ‘/usr/local/lib/python26.zip’, ‘/usr/local/lib/python2.6’, ‘/usr/local/lib/python2.6/plat-linux2’, ‘/usr/local/lib/python2.6/lib-tk’, ‘/usr/local/lib/python2.6/lib-old’, ‘/usr/local/lib/python2.6/lib-dynload’, ‘/usr/local/lib/python2.6/site-packages’]

1.7.2 導入模塊

1.7.2.1 使用import語句導入模塊

有下麵兩種方式

import module1

import module2

import module3

import module1,module2,module3

這兩種方式的效果是一樣的，但是第一種可讀性比第二種好，推薦按照下麵的順序導入模塊，並且一般在文件首部導入所有的模塊：

v python標準庫

v 第三方模塊

v 應用程式自定義模塊

也可以在函數內部導入模塊，這樣被導入的模塊作用域是局部的

1.7.2.2 使用from-import語句導入模塊的屬性

單行導入

from module import name1,name2,name3

多行導入

from module import name1,name2,\

name3

導入全部屬性（由於容易覆蓋當前名稱空間中現有的名字，所以一般不推薦使用，適合模塊中變數名很長並且變數很多的情況）

from module import *

如果你不想某個模塊的屬性被以上方法導入，可以給該屬性名稱前加一個下劃線(_test)，如果需要取消隱藏，可以顯示的導入該屬性（from module import _test）

1.7.2.3 擴展的import語句

使用自定義的名稱替換模塊的原始名稱

import simplejson as json

模塊被導入時，載入的時候模塊頂層代碼會被執行，如：設定全局變數、類和函數的聲明等，所以應該把代碼儘量封裝到類和函數中。一個模塊無論被導入多少次，只載入一次，可以防止多次導入時代碼被多次執行。

1.7.2.4 重新導入模塊

reload(module)

內建函數reload可以重新導入一個已經存在的模塊

1.7.3.包結構

1.包定義結構

包將有聯繫的模塊組織在一起，有效避免模塊名稱衝突問題，讓應用組織結構更加清晰。

一個普通的python應用程式目錄結構：

app/

__init__.py

a.py

__init__.py

b.py

app是最頂層的包，a和b是它的子包，可以這樣導入：

from app.a import a

from app.b.b import test

a.test()

test()

上面代碼表示：導入app包的子包a和子包b的屬性test，然後分別調用test方法。

2. __init__.py的作用

每個目錄下都有__init__.py文件，這個是初始化模塊，from-import語句導入子包時需要它，可以在裡面做一些初始化工作，也可以是空文件。

ps：__init__.py定義的屬性直接使用頂層包.子包的方式導入，如在目錄a的__init__.py文件中定義init_db()方法，調用如下：

from app import a

a.init_db()

3. 指定python文件編碼方式

python預設是使用ASCII編碼，可以指定編碼方式，如

#!/usr/bin/env python

#coding=utf-8

或者

#!/usr/bin/env python

# -*- coding:utf-8 -*-

4. 解決導入迴圈問題

有下麵兩個模塊，a.py和b.py

a.py

#!/usr/bin/env python

#coding=utf-8

import b

if __name__ == '__main':

print 'hello,I'm a'

b.py

#!/usr/bin/env python

#coding=utf-8

import a

if __name__ == '__main':

print 'hello,I'm b'

在這裡a嘗試導入b，而b也嘗試導入a，導入一個先前沒有完全導入的模塊，會導致導入失敗。解決辦法：移除一個導入語句，把導入語句放到函數內部，在需要的時候導入。

b.py

#!/usr/bin/env python

#coding=utf-8

if __name__ == '__main':

import a

print 'hello,I'm b'

1.8.Python文件IO

1.8.1 文件讀寫

Python進行文件讀寫的函數為open或file:

file_handler = open(filename,,mode）

open mode

w	以寫方式打開文件，可向文件寫入信息。如文件存在，則清空該文件，再寫入新內容
a	以追加模式打開文件（即一打開文件，文件指針自動移到文件末尾），如果文件不存在則創建
r+	以讀寫方式打開文件，可對文件進行讀和寫操作。
w+	消除文件內容，然後以讀寫方式打開文件。
a+	以讀寫方式打開文件，並把文件指針移到文件尾。
b	以二進位模式打開文件，而不是以文本模式。該模式只對Windows或Dos有效，類Unix的文件是用二進位模式進行操作的。

操作文件對象方法

f.close()	關閉文件，記住用open()打開文件後一定要記得關閉它，否則會占用系統的可打開文件句柄數。
f.fileno()	獲得文件描述符，是一個數字
f.flush()	刷新輸出緩存
f.isatty()	如果文件是一個交互終端，則返回True，否則返回False。
f.read([count])	讀出文件，如果有count，則讀出count個位元組。
f.readline()	讀出一行信息。
f.readlines()	讀出所有行，也就是讀出整個文件的信息。
f.seek(offset[,where])	把文件指針移動到相對於where的offset位置。where為0表示文件開始處，這是預設值；1表示當前位置；2表示文件結尾。
f.tell()	獲得文件指針位置。
f.truncate([size])	截取文件，使文件的大小為size。
f.write(string)	把string字元串寫入文件。
f.writelines(list)	把list中的字元串一行一行地寫入文件，是連續寫入文件，沒有換行。

例1：從文本文件中每讀取一行文本便輸出

#!/usr/bin/env/ python

#coding=utf-8

fileHandler = open('/root/a.txt', 'a+') #以讀寫方式處理文件IO

fileHandler.seek(0)

line = fileHandler.readline()

while line:

print line

line = fileHandler.readline()

fileHandler.close

例2:其他文件IO函數的使用

#!/usr/bin/env/ python

#coding=utf-8

fileHandler = open('/root/a.txt', 'a+') #以讀寫方式處理文件IO

fileHandler.seek(0)

#讀取整個文件

contents = fileHandler.read()

print contents

#讀取所有行,再逐行輸出

fileHandler.seek(0)

lines = fileHandler.readlines()

for line in lines:

print line

#當前文件指針的位置

print fileHandler.tell()

fileHandler.close

例3:用file(...)替換open(...)

#!/usr/bin/env/ python

#coding=utf-8

fileHandler = file('/root/a.txt', 'a+') #以讀寫方式處理文件IO

fileHandler.seek(0)

line = fileHandler.readline()

while line:

print line

line = fileHandler.readline()

例4:文件的寫操作

#!/usr/bin/env/ python

#coding=utf-8

fileHandler = file('/root/a.txt','a+') #或者調用open()函數

fileHandler.write("\r\n")

fileHandler.write("thank you")

fileHandler.seek(0)

contents = fileHandler.read()

print contents

fileHandler.close

1.8.2 文件夾相關操作

Python中對文件、文件夾（文件操作函數）的操作需要涉及到os模塊和shutil模塊。

得到當前工作目錄，即當前Python腳本工作的目錄路徑: os.getcwd()

返回指定目錄下的所有文件和目錄名:os.listdir()

刪除一個文件:os.remove()

刪除多個目錄（只能刪除空目錄）：os.removedirs（r”c：\python”）

檢驗給出的路徑是否是一個文件：os.path.isfile()

檢驗給出的路徑是否是一個目錄：os.path.isdir()

判斷是否是絕對路徑：os.path.isabs()

檢驗給出的路徑是否存在:os.path.exists()

返回一個路徑的目錄名和文件名:os.path.split()

Eg：

os.path.split('/home/swaroop/byte/code/poem.txt')

結果：('/home/swaroop/byte/code', 'poem.txt')

分離擴展名：os.path.splitext()

獲取路徑名：os.path.dirname()

獲取文件名：os.path.basename()

運行shell命令: os.system()

讀取和設置環境變數:os.getenv() 與os.putenv()

給出當前平臺使用的行終止符:os.linesep Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'

指示你正在使用的平臺：os.name 對於Windows，它是'nt'，而對於Linux/Unix用戶，它是'posix'

重命名：os.rename（old， new）

創建多級目錄：os.makedirs（r“c：\python\test”）

創建單個目錄：os.mkdir（“test”）

獲取文件屬性：os.stat（file）

修改文件許可權與時間戳：os.chmod（file）

終止當前進程：os.exit（）

獲取文件大小：os.path.getsize（filename）

1.9 Python多線程

Python中的多線程是偽線程；不能充分利用cpu中的多核，但是在io等待型的場景下多線程還是可以提高效率

Python中的多線程有多種實現方式，利用threading包實現是比較普遍的做法

示例代碼如下：

import threading

from time import ctime,sleep

def music(func):

for i in range(2):

print("i was listening to %s. %s" %(func,ctime()))

sleep(1)

def movie(func):

for i in range(2):

print("i was at the %s! %s" %(func,ctime()))

sleep(5)

threads=[]

t1=threading.Thread(target=music,args=(u'愛情買賣'))

threads.append(t1)

t2=threading.Thread(target=movie,args=(u'阿凡達',))

threads.append(t2)

# if __name__ == '__main__' :

for t in threads:

# t.setDaemon(True)

t.start()

# t.join()

print("all over %s" %ctime())

1.10面向對象

1.10.1 創建類

使用class語句來創建一個新類，class之後為類的名稱並以冒號結尾，如下實例:

class ClassName:

'類的幫助信息' #類文檔字元串

class_suite #類體

類的幫助信息可以通過ClassName.__doc__查看。

class_suite 由類成員，方法，數據屬性組成。

1.10.2 實例

以下是一個簡單的Python類實例:

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Employee:

'所有員工的基類'

empCount = 0

#構造函數

def __init__(self, name, salary):

self.name = name

self.salary = salary

Employee.empCount += 1

def displayCount(self):

print "Total Employee %d" % Employee.empCount

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

empCount變數是一個類變數，它的值將在這個類的所有實例之間共用。你可以在內部類或外部類使用Employee.empCount訪問。

第一個方法__init__()方法是一種特殊的方法，被稱為類的構造函數或初始化方法，當創建了這個類的實例時就會調用該方法

類的方法

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

1.10.3 創建實例對象

要創建一個類的實例，你可以使用類的名稱，並通過__init__方法接受參數。

"創建 Employee 類的第一個對象"

emp1 = Employee("Zara", 2000)

"創建 Employee 類的第二個對象"

emp2 = Employee("Manni", 5000)

訪問屬性

可以使用點(.)來訪問對象的屬性。使用如下類的名稱訪問類變數:

emp1.displayEmployee()

emp2.displayEmployee()

print "Total Employee %d" % Employee.empCount

完整實例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Employee:

'所有員工的基類'

empCount = 0

def __init__(self, name, salary):

self.name = name

self.salary = salary

Employee.empCount += 1

def displayCount(self):

print "Total Employee %d" % Employee.empCount

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

"創建 Employee 類的第一個對象"

emp1 = Employee("Zara", 2000)

"創建 Employee 類的第二個對象"

emp2 = Employee("Manni", 5000)

emp1.displayEmployee()

emp2.displayEmployee()

print "Total Employee %d" % Employee.empCount

執行以上代碼輸出結果如下：

Name : Zara ,Salary: 2000

Name : Manni ,Salary: 5000

Total Employee 2

你可以添加，刪除，修改類的屬性，如下所示：

emp1.age = 7 # 添加一個 'age' 屬性

emp1.age = 8 # 修改 'age' 屬性

del emp1.age # 刪除 'age' 屬性

你也可以使用以下函數的方式來訪問屬性：

getattr(obj, ‘name’[, default]) : 訪問對象的屬性。

hasattr(obj,’name’) : 檢查是否存在一個屬性。

setattr(obj,’name’,value) : 設置一個屬性。如果屬性不存在，會創建一個新屬性。

delattr(obj, ‘name’) : 刪除屬性。

hasattr(emp1, 'age') # 如果存在 'age' 屬性返回 True。

getattr(emp1, 'age') # 返回 'age' 屬性的值

setattr(emp1, 'age', 8) # 添加屬性 'age' 值為 8

delattr(empl, 'age') # 刪除屬性 'age'

1.10.4 Python內置類屬性

__dict__ : 類的屬性（包含一個字典，由類的數據屬性組成）

__doc__ :類的文檔字元串

__name__: 類名

__module__: 類定義所在的模塊（類的全名是'__main__.className'，如果類位於一個導入模塊mymod中，那麼className.__module__ 等於 mymod）

__bases__ : 類的所有父類構成元素（包含了以個由所有父類組成的元組）

Python內置類屬性調用實例如下：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Employee:

'所有員工的基類'

empCount = 0

def __init__(self, name, salary):

self.name = name

self.salary = salary

Employee.empCount += 1

def displayCount(self):

print "Total Employee %d" % Employee.empCount

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__

print "Employee.__name__:", Employee.__name__

print "Employee.__module__:", Employee.__module__

print "Employee.__bases__:", Employee.__bases__

print "Employee.__dict__:", Employee.__dict__

執行以上代碼輸出結果如下：

Employee.__doc__: 所有員工的基類

Employee.__name__: Employee

Employee.__module__: __main__

Employee.__bases__: ()

Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x10a939c80>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x10a93caa0>, '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': <function __init__ at 0x10a939578>}

1.10.5 私有屬性

1、類的私有屬性

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

2、類的私有方法

__private_method：兩個下劃線開頭，聲明該方法為私有方法，不能在類地外部調用。在類的內部調用 self.__private_methods

3、實例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class JustCounter:

__secretCount = 0 # 私有變數

publicCount = 0 # 公開變數

def count(self):

self.__secretCount += 1

self.publicCount += 1

print self.__secretCount

counter = JustCounter()

counter.count()

print counter.publicCount

print counter.__secretCount # 報錯，實例不能訪問私有變數

運行結果會報錯：

Traceback (most recent call last):

File "test.py", line 17, in <module>

print counter.__secretCount # 報錯，實例不能訪問私有變數

AttributeError: JustCounter instance has no attribute '__secretCount'

Python不允許實例化的類訪問私有數據，但你可以使用 object._className__attrName 訪問屬性，將如下代碼替換以上代碼的最後一行代碼：

.........................

print counter._JustCounter__secretCount

執行以上代碼，執行結果如下：

1.10.6 python對象銷毀(垃圾回收)

同Java語言一樣，Python使用了引用計數這一簡單技術來追蹤記憶體中的對象。

在Python內部記錄著所有使用中的對象各有多少引用。

一個內部跟蹤變數，稱為一個引用計數器。

當對象被創建時，就創建了一個引用計數，當這個對象不再需要時，也就是說，這個對象的引用計數變為0 時，它被垃圾回收。但是回收不是"立即"的，由解釋器在適當的時機，將垃圾對象占用的記憶體空間回收。

a = 40 # 創建對象 <40>

b = a # 增加引用， <40> 的計數

c = [b] # 增加引用. <40> 的計數

del a # 減少引用 <40> 的計數

b = 100 # 減少引用 <40> 的計數

c[0] = -1 # 減少引用 <40> 的計數

垃圾回收機制不僅針對引用計數為0的對象，同樣也可以處理迴圈引用的情況。迴圈引用指的是，兩個對象相互引用，但是沒有其他變數引用他們。這種情況下，僅使用引用計數是不夠的。Python 的垃圾收集器實際上是一個引用計數器和一個迴圈垃圾收集器。作為引用計數的補充，垃圾收集器也會留心被分配的總量很大（及未通過引用計數銷毀的那些）的對象。在這種情況下，解釋器會暫停下來，試圖清理所有未引用的迴圈。

實例

析構函數 __del__

__del__在對象銷毀的時候被調用，當對象不再被使用時，__del__方法運行：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Point:

def __init__( self, x=0, y=0):

self.x = x

self.y = y

def __del__(self):

class_name = self.__class__.__name__

print class_name, "銷毀"

pt1 = Point()

pt2 = pt1

pt3 = pt1

print id(pt1), id(pt2), id(pt3) # 列印對象的id

del pt1

del pt2

del pt3

以上實例運行結果如下：

3083401324 3083401324 3083401324

Point 銷毀

1.10.7 類的繼承

面向對象的編程帶來的主要好處之一是代碼的重用，實現這種重用的方法之一是通過繼承機制。繼承完全可以理解成類之間的類型和子類型關係。

1、語法：

派生類的聲明，與他們的父類類似，繼承的基類列表跟在類名之後，如下所示：

class SubClassName (ParentClass1[, ParentClass2, ...]):

'Optional class documentation string'

class_suite

2、實例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Parent: # 定義父類

parentAttr = 100

def __init__(self):

print "調用父類構造函數"

def parentMethod(self):

print '調用父類方法'

def setAttr(self, attr):

Parent.parentAttr = attr

def getAttr(self):

print "父類屬性 :", Parent.parentAttr

class Child(Parent): # 定義子類

def __init__(self):

print "調用子類構造方法"

def childMethod(self):

print '調用子類方法 child method'

c = Child() # 實例化子類

c.childMethod() # 調用子類的方法

c.parentMethod() # 調用父類方法

c.setAttr(200) # 再次調用父類的方法

c.getAttr() # 再次調用父類的方法

以上代碼執行結果如下：

調用子類構造方法

調用子類方法 child method

調用父類方法

父類屬性 : 200

你可以繼承多個類

class A: # 定義類 A

.....

class B: # 定義類 B

.....

class C(A, B): # 繼承類 A 和 B

.....

可以使用issubclass()或者isinstance()方法來檢測。

issubclass() - 布爾函數判斷一個類是另一個類的子類或者子孫類，語法：issubclass(sub,sup)

isinstance(obj, Class) 布爾函數如果obj是Class類的實例對象或者是一個Class子類的實例對象則返回true。

3、方法重寫

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

實例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Parent: # 定義父類

def myMethod(self):

print '調用父類方法'

class Child(Parent): # 定義子類

def myMethod(self):

print '調用子類方法'

c = Child() # 子類實例

c.myMethod() # 子類調用重寫方法

執行以上代碼輸出結果如下：

4、基礎重載方法

下表列出了一些通用的功能，你可以在自己的類重寫：

1/ __init__ ( self [,args...] )

構造函數

簡單的調用方法: obj = className(args)

2/ __del__( self )

析構方法, 刪除一個對象

簡單的調用方法 : dell obj

3/ __str__( self )

用於將值轉化為適於人閱讀的形式

簡單的調用方法 : str(obj)

4/ __cmp__ ( self, x )

對象比較

簡單的調用方法 : cmp(obj, x)

#!/usr/bin/python

class Vector:

def __init__(self, a, b):

self.a = a

self.b = b

def __str__(self):

return 'Vector (%d, %d)' % (self.a, self.b)

def __add__(self,other):

return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)

v2 = Vector(5,-2)

print v1 + v2

以上代碼執行結果如下所示:

Vector(7,8)

Python2中，print是一個關鍵字

Python3中，print是一個函數，必須使用print(arg)

1) 函數塊以關鍵字def後跟函數名為定義頭

2) 任何輸入參數或參數應該放在這些括弧內。還可以定義這些括弧內的參數。

3) 函數的第一個語句可以是一個可選的聲明 - 該函數或文檔字元串的文檔字元串。

4) 每個函數中的代碼塊以冒號(:)開頭並縮進。

5) 該語句返回[表達式]退出功能，可選地傳遞迴一個表達式給調用者。不帶參數return語句返回None。