1、安裝python編譯器 版本：Python2.7比較普遍，Python不是向下兼容的軟件，因此Python3.x有些東西不好找資料
|
1
2
3
|
total
=
item_one
+
\
item_two
+
\
item_three
|
|
1
2
|
days
=
[
'Monday'
,
'Tuesday'
,
'Wednesday'
,
'Thursday'
,
'Friday'
]
|
|
1
2
3
4
|
word
=
'word'
sentence
=
"This is a sentence."
paragraph
=
"""This is a paragraph. It is
made up of multiple lines and sentences."""
|
1、在DOS中運行python： python test.py
2、輸入：
>>> name = raw_input()
Michaelname = raw_input('please enter your name: ')
print 'hello,', name3、輸出：print會依次打印每個字符串，遇到逗號“,”會輸出一個空格：
>>> print 'The quick brown fox', 'jumps over', 'the lazy dog'
The quick brown fox jumps over the lazy dog
4、變量賦值用：=
多個變量賦值:
|
1
|
a, b, c
=
1
,
2
,
"john"
|
5、Python有五個標准的數據類型：
5.1.Numbers（數字）：不可改變的數據類型，這意味着改變數字數據類型會分配一個新的對象。
|
1
2
|
var1
=
1
var2
=
10
|
|
1
2
|
del
var
del
var_a, var_b
|
5.2.String（字符串）
#!/usr/bin/python
str
=
"Hello World!"
print
str
# 輸出完整字符串
print
str
[
0
]
# 輸出字符串中的第一個字符
print
str
[
2
:
5
]
# 輸出字符串中第三個至第五個之間的字符串
print
str
[
2
:]
# 輸出從第三個字符開始的字符串
print
str
*
2
# 輸出字符串兩次
print
str
+
"TEST"
# 輸出連接的字符串
|
以上實例輸出結果：
|
1
2
3
4
5
6
|
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
|
5.3.List（列表）
加號（+）是列表連接運算符，星號（*）是重復操作。如下實例：
|
1
2
3
4
5
6
7
8
9
10
11
|
#!/usr/bin/python
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
# 輸出列表兩次
print
List
+
tinylist
# 打印組合的列表
|
以上實例輸出結果：
|
1
2
3
4
5
6
|
[
"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"
]
|
5.4.Tuple（元組）
以下是元組無效的，因為元組是不允許更新的。而列表是允許更新的：
|
1
2
3
4
5
6
|
#!/usr/bin/python
Tuple
=
(
"abcd"
,
786
,
2.23
,
"john"
,
70.2
)
List
=
[
"abcd"
,
786
,
2.23
,
"john"
,
70.2
]
Tuple
[
2
]
=
1000
# 錯誤！元組中是非法應用
List
[
2
]
=
1000
# 正確！列表中是合法應用
|
5.5.Dictionary（字典）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#!/usr/bin/python
dict
=
{}
dict
[
"one"
]
=
"This is one"
dict
[
2
]
=
"This is two"
tinydict
=
{
"name"
:
"john"
,
"code"
:
6734
,
"dept"
:
"sales"
}
print
dict
[
"one"
]
# 輸出鍵為"one" 的值
print
dict
[
2
]
# 輸出鍵為 2 的值
print
tinydict
# 輸出完整的字典
print
tinydict.keys()
# 輸出所有鍵
print
tinydict.values()
# 輸出所有值
|
輸出結果為：
|
1
|
This
is
one
This
is
two
{
"dept"
:
"sales"
,
"code"
:
6734
,
"name"
:
"john"
}
[
"dept"
,
"code"
,
"name"
]
[
"sales"
,
6734
,
"john"
]
|
6、數據類型轉換
| 函數 | 描述 |
|---|---|
| int(x [,base]) |
將x轉換為一個整數 |
| long(x [,base] ) |
將x轉換為一個長整數 |
| float(x) |
將x轉換到一個浮點數 |
| complex(real [,imag]) |
創建一個復數 |
| str(x) |
將對象 x 轉換為字符串 |
| repr(x) |
將對象 x 轉換為表達式字符串 |
| eval(str) |
用來計算在字符串中的有效Python表達式,並返回一個對象 |
| tuple(s) |
將序列 s 轉換為一個元組 |
| list(s) |
將序列 s 轉換為一個列表 |
| set(s) |
轉換為可變集合 |
| dict(d) |
創建一個字典。d 必須是一個序列 (key,value)元組。 |
| frozenset(s) |
轉換為不可變集合 |
| chr(x) |
將一個整數轉換為一個字符 |
| unichr(x) |
將一個整數轉換為Unicode字符 |
| ord(x) |
將一個字符轉換為它的整數值 |
| hex(x) |
將一個整數轉換為一個十六進制字符串 |
| oct(x) |
將一個整數轉換為一個八進制字符串 |
7、運算符
7.1.Python算術運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| + | 加 - 兩個對象相加 | a + b 輸出結果 30 |
| - | 減 - 得到負數或是一個數減去另一個數 | a - b 輸出結果 -10 |
| * | 乘 - 兩個數相乘或是返回一個被重復若干次的字符串 | a * b 輸出結果 200 |
| / | 除 - x除以y | b / a 輸出結果 2 |
| % | 取模 - 返回除法的余數 | b % a 輸出結果 0 |
| ** | 冪 - 返回x的y次冪 | a**b 輸出結果 20 |
| // | 取整除 - 返回商的整數部分 | 9//2 輸出結果 4 , 9.0//2.0 輸出結果 4.0 |
7.2.比較運算符
以下假設變量a為10，變量b為20：
| 運算符 | 描述 | 實例 |
|---|---|---|
| == | 等於 - 比較對象是否相等 | (a == b) 返回 False。 |
| != | 不等於 - 比較兩個對象是否不相等 | (a != b) 返回 true. |
| <> | 不等於 - 比較兩個對象是否不相等 | (a <> b) 返回 true。這個運算符類似 != 。 |
| > | 大於 - 返回x是否大於y | (a > b) 返回 False。 |
| < | 小於 - 返回x是否小於y。所有比較運算符返回1表示真，返回0表示假。這分別與特殊的變量True和False等價。注意，這些變量名的大寫。 | (a < b) 返回 true。 |
| >= | 大於等於 - 返回x是否大於等於y。 | (a >= b) 返回 False。 |
| <= | 小於等於 - 返回x是否小於等於y。 | (a <= b) 返回 true。 |
7.3.Python賦值運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| = | 簡單的賦值運算符 | c = a + b 將 a + b 的運算結果賦值為 c |
| += | 加法賦值運算符 | c += a 等效於 c = c + a |
| -= | 減法賦值運算符 | c -= a 等效於 c = c - a |
| *= | 乘法賦值運算符 | c *= a 等效於 c = c * a |
| /= | 除法賦值運算符 | c /= a 等效於 c = c / a |
| %= | 取模賦值運算符 | c %= a 等效於 c = c % a |
| **= | 冪賦值運算符 | c **= a 等效於 c = c ** a |
| //= | 取整除賦值運算符 | c //= a 等效於 c = c // a |
7.4.Python位運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| & | 按位與運算符 | (a & b) 輸出結果 12 ，二進制解釋： 0000 1100 |
| | | 按位或運算符 | (a | b) 輸出結果 61 ，二進制解釋： 0011 1101 |
| ^ | 按位異或運算符 | (a ^ b) 輸出結果 49 ，二進制解釋： 0011 0001 |
| ~ | 按位取反運算符 | (~a ) 輸出結果 -61 ，二進制解釋： 1100 0011， 在一個有符號二進制數的補碼形式。 |
| << | 左移動運算符 | a << 2 輸出結果 240 ，二進制解釋： 1111 0000 |
| >> | 右移動運算符 | a >> 2 輸出結果 15 ，二進制解釋： 0000 1111 |
7.5.Python邏輯運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| and | 布爾"與" - 如果x為False，x and y返回False，否則它返回y的計算值。 | (a and b) 返回 true。 |
| or | 布爾"或" - 如果x是True，它返回True，否則它返回y的計算值。 | (a or b) 返回 true。 |
| not | 布爾"非" - 如果x為True，返回False。如果x為False，它返回True。 | not(a and b) 返回 false。 |
7.6.Python成員運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回True，否則返回False。 | x 在 y序列中 , 如果x在y序列中返回True。 |
| not in | 如果在指定的序列中沒有找到值返回True，否則返回False。 | x 不在 y序列中 , 如果x不在y序列中返回True。 |
7.7.Python身份運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| is | is是判斷兩個標識符是不是引用自一個對象 | x is y, 如果 id(x) 等於 id(y) , is 返回結果 1 |
| is not | is not是判斷兩個標識符是不是引用自不同對象 | x is not y, 如果 id(x) 不等於 id(y). is not 返回結果 1 |
7.8.Python運算符優先級
| 運算符 | 描述 |
|---|---|
| ** | 指數 (最高優先級) |
| ~ + - | 按位翻轉, 一元加號和減號 (最后兩個的方法名為 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法減法 |
| >> << | 右移，左移運算符 |
| & | 位 'AND' |
| ^ | | 位運算符 |
| <= < > >= | 比較運算符 |
| <> == != | 等於運算符 |
| = %= /= //= -= += *= **= | 賦值運算符 |
| is is not | 身份運算符 |
| in not in | 成員運算符 |
| not or and | 邏輯運算符 |
8、語句
8.1.條件語句
- Python 編程中 if 語句用於控制程序的執行，基本形式為：
|
1
2
3
4
|
if
判斷條件：
執行語句……
else
：
執行語句……
|
其中"判斷條件"成立時（非零），則執行后面的語句，而執行內容可以多行，以縮進來區分表示同一范圍。
- 當判斷條件為多個值是，可以使用以下形式：
|
1
2
3
4
5
6
7
8
|
if
判斷條件
1
:
執行語句
1
……
elif
判斷條件
2
:
執行語句
2
……
elif
判斷條件
3
:
執行語句
3
……
else
:
執行語句
4
……
|
- python 並不支持 switch 語句，所以多個條件判斷，只能用 elif 來實現，如果判斷需要多個條件需同時判斷時，可以使用 or （或），表示兩個條件有一個成立時判斷條件成功；使用 and （與）時，表示只有兩個條件同時成立的情況下，判斷條件才成功。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
# 例3：if語句多個條件
num
=
9
if
num >
=
0
and
num <
=
10
:
# 判斷值是否在0~10之間
print
'hello'
>>> hello
# 輸出結果
num
=
10
if
num <
0
or
num >
10
:
# 判斷值是否在小於0或大於10
print
'hello'
else
:
print
'undefine'
>>> undefine
# 輸出結果
num
=
8
# 判斷值是否在0~5或者10~15之間
if
(num >
=
0
and
num <
=
5
)
or
(num >
=
10
and
num <
=
15
):
print
'hello'
else
:
print
'undefine'
>>> undefine
# 輸出結果
|
當if有多個條件時可使用括號來區分判斷的先后順序，括號中的判斷優先執行，此外 and 和 or 的優先級低於>（大於）、<（小於）等判斷符號，即大於和小於在沒有括號的情況下會比與或要優先判斷。
8.2 循環語句
Python提供了for循環和while循環（在Python中沒有do..while循環）:
| 循環類型 | 描述 |
|---|---|
| 在給定的判斷條件為 true 時執行循環體，否則退出循環體。 | |
| for 循環 | 重復執行語句 |
- while 語句用於循環執行程序，即在某條件下，循環執行某段程序，以處理需要重復處理的相同任務。其基本形式為：
|
1
2
|
while
判斷條件：
執行語句……
|
執行語句可以是單個語句或語句塊。判斷條件可以是任何表達式，任何非零、或非空（null）的值均為true。
當判斷條件假false時，循環結束。
- for循環的語法格式如下：
|
1
2
|
for
iterating_var
in
sequence:
statements(s)
|
實例：
|
1
2
3
4
5
6
7
8
9
10
|
#!/usr/bin/python
for
letter
in
'Python'
:
# First Example
print
'Current Letter :'
, letter
fruits
=
[
'banana'
,
'apple'
,
'mango'
]
for
fruit
in
fruits:
# Second Example
print
'Current fruit :'
, fruit
print
"Good bye!"
|
以上實例輸出結果:
|
1
2
3
4
5
6
7
8
9
10
|
Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : h
Current Letter : o
Current Letter : n
Current fruit : banana
Current fruit : apple
Current fruit : mango
Good bye!
|
另外一種執行循環的遍歷方式是通過索引。
- 循環使用 else 語句
在 python 中，for … else 表示這樣的意思，for 中的語句和普通的沒有區別，else 中的語句會在循環正常執行完（即 for 不是通過 break 跳出而中斷的）的情況下執行，while … else 也是一樣。
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
count
=
0
while
count <
5
:
print
count,
" is less than 5"
count
=
count
+
1
else
:
print
count,
" is not less than 5"
|
以上實例輸出結果為：
|
1
2
3
4
5
6
|
0
is
less than
5
1
is
less than
5
2
is
less than
5
3
is
less than
5
4
is
less than
5
5
is
not
less than
5
|
- 循環控制語句
循環控制語句可以更改語句執行的順序。Python支持以下循環控制語句：
| 控制語句 | 描述 |
|---|---|
| break 語句 | 在語句塊執行過程中終止循環，並且跳出整個循環 |
| continue 語句 | 在語句塊執行過程中終止當前循環，跳出該次循環，執行下一次循環。 |
| pass 語句 | pass是空語句，是為了保持程序結構的完整性。 |
Python 語言 pass 語句語法格式如下：
|
1
|
pass
|
實例：
|
1
2
3
4
5
6
7
8
9
|
#!/usr/bin/python
for
letter
in
'Python'
:
if
letter
=
=
'h'
:
pass
print
'This is pass block'
print
'Current Letter :'
, letter
print
"Good bye!"
|
以上實例執行結果：
|
1
2
3
4
5
6
7
8
|
Current Letter : P
Current Letter : y
Current Letter : t
This is pass block
Current Letter : h
Current Letter : o
Current Letter : n
Good bye!
|
9、用戶自定義函數
9.1函數定義
你可以定義一個由自己想要功能的函數，以下是簡單的規則：
-
函數代碼塊以def關鍵詞開頭，后接函數標識符名稱和圓括號()。
-
任何傳入參數和自變量必須放在圓括號中間。圓括號之間可以用於定義參數。
-
函數的第一行語句可以選擇性地使用文檔字符串—用於存放函數說明。
-
函數內容以冒號起始，並且縮進。
-
Return[expression]結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當於返回 None。
|
1
2
3
4
|
def
functionname( parameters ):
"函數_文檔字符串"
function_suite
return
[expression]
|
默認情況下，參數值和參數名稱是按函數聲明中定義的的順序匹配起來的。
以下為一個簡單的Python函數，它將一個字符串作為傳入參數，再打印到標准顯示設備上。
|
1
2
3
|
def
printme( string ):
"打印傳入的字符串到標准顯示設備上"
print
string
|
9.2函數調用
定義一個函數只給了函數一個名稱，指定了函數里包含的參數，和代碼塊結構。
這個函數的基本結構完成以后，你可以通過另一個函數調用執行，也可以直接從Python提示符執行。
如下實例調用了printme（）函數：
|
1
2
3
4
5
6
7
8
9
10
|
#!/usr/bin/python
# Function definition is here
def
printme( string ):
"打印任何傳入的字符串"
print
string
# Now you can call printme function
printme(
"我要調用用戶自定義函數!"
);
printme(
"再次調用同一函數"
);
|
以上實例輸出結果：
|
1
2
|
我要調用用戶自定義函數!
再次調用同一函數
|
所有參數（自變量）在Python里都是按引用傳遞。如果你在函數里修改了參數，那么在調用這個函數的函數里，原始的參數也被改變了。例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#!/usr/bin/python
# 可寫函數說明
def
changeme( mylist ):
"修改傳入的列表"
mylist.append([
1
,
2
,
3
,
4
])
print
"函數內取值: "
, mylist
# 調用changeme函數
mylist
=
[
10
,
20
,
30
];
changeme( mylist );
print
"函數外取值: "
, mylist
|
傳入函數的和在末尾添加新內容的對象用的是同一個引用。故輸出結果如下：
|
1
2
|
函數內取值: [
10
,
20
,
30
, [
1
,
2
,
3
,
4
]]
函數外取值: [
10
,
20
,
30
, [
1
,
2
,
3
,
4
]]
|
9.3參數
以下是調用函數時可使用的正式參數類型：
-
必備參數
-
命名參數
-
缺省參數
-
不定長參數
- 不定長參數
你可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，這種參數聲明時不會命名。基本語法如下：
|
1
2
3
4
|
def
functionname([formal_args,]
*
var_args_tuple ):
"函數_文檔字符串"
function_suite
return
[expression]
|
加了星號（*）的變量名會存放所有未命名的變量參數。選擇不多傳參數也可。如下實例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#!/usr/bin/python
# 可寫函數說明
def
printinfo( arg1,
*
vartuple ):
"打印任何傳入的參數"
print
"輸出: "
print
arg1
for
var
in
vartuple:
print
var
# 調用printinfo 函數
printinfo(
10
)
printinfo(
70
,
60
,
50
)
|
以上實例輸出結果：
|
1
2
3
4
5
6
|
輸出:
10
輸出:
70
60
50
|
9.4匿名函數
用lambda關鍵詞能創建小型匿名函數。這種函數得名於省略了用def聲明函數的標准步驟。
-
Lambda函數能接收任何數量的參數但只能返回一個表達式的值，同時不能包含命令或多個表達式。
-
匿名函數不能直接調用print，因為lambda需要一個表達式。
-
lambda函數擁有自己的名字空間，且不能訪問自有參數列表之外或全局名字空間里的參數。
-
雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，后者的目的是調用小函數時不占用棧內存從而增加運行效率。
語法
lambda函數的語法只包含一個語句，如下：
|
1
|
lambda
[arg1 [,arg2,.....argn]]:expression
|
如下實例：
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
#可寫函數說明
sum
=
lambda
arg1, arg2: arg1
+
arg2
#調用sum函數
print
"Value of total : "
,
sum
(
10
,
20
)
print
"Value of total : "
,
sum
(
20
,
20
)
|
以上實例輸出結果：
|
1
2
|
Value of total :
30
Value of total :
40
|
9.5return語句
return語句[表達式]退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None。之前的例子都沒有示范如何返回數值，下例便告訴你怎么做：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#!/usr/bin/python
# 可寫函數說明
def
sum
( arg1, arg2 ):
# 返回2個參數的和."
total
=
arg1
+
arg2
print
"Inside the function : "
, total
return
total
# 調用sum函數
total
=
sum
(
10
,
20
);
print
"Outside the function : "
, total
|
以上實例輸出結果：
|
1
2
|
Inside the function :
30
Outside the function :
30
|
9.6變量作用域
一個程序的所有的變量並不是在哪個位置都可以訪問的。訪問權限決定於這個變量是在哪里賦值的。
變量的作用域決定了在哪一部分程序你可以訪問哪個特定的變量名稱。兩種最基本的變量作用域如下：
-
全局變量
-
局部變量
變量和局部變量
定義在函數內部的變量擁有一個局部作用域，定義在函數外的擁有全局作用域。
局部變量只能在其被聲明的函數內部訪問，而全局變量可以在整個程序范圍內訪問。調用函數時，所有在函數內聲明的變量名稱都將被加入到作用域中。如下實例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#!/usr/bin/python
total
=
0
;
# This is global variable.
# 可寫函數說明
def
sum
( arg1, arg2 ):
#返回2個參數的和."
total
=
arg1
+
arg2;
# total在這里是局部變量.
print
"Inside the function local total : "
, total
return
total;
#調用sum函數
sum
(
10
,
20
);
print
"Outside the function global total : "
, total
|
以上實例輸出結果：
|
1
2
|
Inside the function local total :
30
Outside the function
global
total :
0
|
10 Python模塊
例子
一個叫做aname的模塊里的Python代碼一般都能在一個叫aname.py的文件中找到。下例是個簡單的模塊support.py。
|
1
2
|
def
print_func( par ):
print
"Hello : "
, par
|
10.1 import 語句
想使用Python源文件，只需在另一個源文件里執行import語句，語法如下：
|
1
|
import
module1[, module2[,... moduleN]
|
當解釋器遇到import語句，如果模塊在當前的搜索路徑就會被導入。
搜索路徑是一個解釋器會先進行搜索的所有目錄的列表。如想要導入模塊hello.py，需要把命令放在腳本的頂端：
|
1
2
3
4
5
6
7
|
#!/usr/bin/python
# 導入模塊
import
support
# 現在可以調用模塊里包含的函數了
support.print_func(
"Zara"
)
|
以上實例輸出結果：
|
1
|
Hello : Zara
|
一個模塊只會被導入一次，不管你執行了多少次import。這樣可以防止導入模塊被一遍又一遍地執行。
- From…import 語句
Python的from語句讓你從模塊中導入一個指定的部分到當前命名空間中。語法如下：
|
1
|
from
modname
import
name1[, name2[, ... nameN]]
|
例如，要導入模塊fib的fibonacci函數，使用如下語句：
|
1
|
from
fib
import
fibonacci
|
這個聲明不會把整個fib模塊導入到當前的命名空間中，它只會將fib里的fibonacci單個引入到執行這個聲明的模塊的全局符號表。
- From…import * 語句
把一個模塊的所有內容全都導入到當前的命名空間也是可行的，只需使用如下聲明：
|
1
|
from
mod_name
import
*
|
這提供了一個簡單的方法來導入一個模塊中的所有項目。然而這種聲明不該被過多地使用。
- reload()函數
當一個模塊被導入到一個腳本，模塊頂層部分的代碼只會被執行一次。
因此，如果你想重新執行模塊里頂層部分的代碼，可以用reload()函數。該函數會重新導入之前導入過的模塊。語法如下：
|
1
|
reload
(module_name)
|
在這里，module_name要直接放模塊的名字，而不是一個字符串形式。比如想重載hello模塊，如下：
|
1
|
reload
(hello)
|
10.2 定位模塊
當你導入一個模塊，Python解析器對模塊位置的搜索順序是：
-
當前目錄
-
如果不在當前目錄，Python則搜索在shell變量PYTHONPATH下的每個目錄。
-
如果都找不到，Python會察看默認路徑。UNIX下，默認路徑一般為/usr/local/lib/python/
模塊搜索路徑存儲在system模塊的sys.path變量中。變量里包含當前目錄，PYTHONPATH和由安裝過程決定的默認目錄。
- PYTHONPATH變量
作為環境變量，PYTHONPATH由裝在一個列表里的許多目錄組成。PYTHONPATH的語法和shell變量PATH的一樣。
在Windows系統，典型的PYTHONPATH如下：
|
1
|
set
PYTHONPATH
=
c:\python20\lib;
|
在UNIX系統，典型的PYTHONPATH如下：
|
1
|
set
PYTHONPATH
=
/
usr
/
local
/
lib
/
python
|
10.3 命名空間和作用域
一個Python表達式可以訪問局部命名空間和全局命名空間里的變量。如果一個局部變量和一個全局變量重名，則局部變量會覆蓋全局變量。因此，如果要給全局變量在一個函數里賦值，必須使用global語句。
global VarName的表達式會告訴Python， VarName是一個全局變量，這樣Python就不會在局部命名空間里尋找這個變量了。
例如，我們在全局命名空間里定義一個變量money。我們再在函數內給變量money賦值，然后Python會假定money是一個局部變量。然而，我們並沒有在訪問前聲明一個局部變量money，結果就是會出現一個UnboundLocalError的錯誤。取消global語句的注釋就能解決這個問題。
|
1
2
3
4
5
6
7
8
9
10
11
|
#!/usr/bin/python
Money
=
2000
def
AddMoney():
# 想改正代碼就取消以下注釋:
# global Money
Money
=
Money
+
1
print
Money
AddMoney()
print
Money
|
- globals()和locals()函數
根據調用地方的不同，globals()和locals()函數可被用來返回全局和局部命名空間里的名字。
如果在函數內部調用locals()，返回的是所有能在該函數里訪問的命名。如果在函數內部調用globals()，返回的是所有在該函數里能訪問的全局名字。兩個函數的返回類型都是字典。所以名字們能用keys()函數摘取。
- dir()函數
dir()函數一個排好序的字符串列表，內容是一個模塊里定義過的名字。
返回的列表容納了在一個模塊里定義的所有模塊，變量和函數。如下一個簡單的實例：
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# 導入內置math模塊
import
math
content
=
dir
(math)
print
content;
|
以上實例輸出結果：
|
1
2
3
4
5
|
[
'__doc__'
,
'__file__'
,
'__name__'
,
'acos'
,
'asin'
,
'atan'
,
'atan2'
,
'ceil'
,
'cos'
,
'cosh'
,
'degrees'
,
'e'
,
'exp'
,
'fabs'
,
'floor'
,
'fmod'
,
'frexp'
,
'hypot'
,
'ldexp'
,
'log'
,
'log10'
,
'modf'
,
'pi'
,
'pow'
,
'radians'
,
'sin'
,
'sinh'
,
'sqrt'
,
'tan'
,
'tanh'
]
|
在這里，特殊字符串變量__name__指向模塊的名字，__file__指向該模塊的導入文件名。
10.4 Python中的包
包是一個分層次的文件目錄結構，它定義了一個由模塊及子包，和子包下的子包等組成的Python的應用環境。
考慮一個在Phone目錄下的pots.py文件。這個文件有如下源代碼：
|
1
2
3
4
|
#!/usr/bin/python
def
Pots():
print
"I'm Pots Phone"
|
同樣地，我們有另外兩個保存了不同函數的文件：
-
Phone/Isdn.py 含有函數Isdn()
-
Phone/G3.py 含有函數G3()
現在，在Phone目錄下創建file: __init__.py：
-
Phone/__init__.py
當你導入Phone時，為了能夠使用所有函數，你需要在__init__.py里使用顯式的導入語句，如下：
|
1
2
3
|
from
Pots
import
Pots
from
Isdn
import
Isdn
from
G3
import
G3
|
當你把這些代碼添加到__init__.py之后，導入Phone包的時候這些類就全都是可用的了。
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# Now import your Phone Package.
import
Phone
Phone.Pots()
Phone.Isdn()
Phone.G3()
|
以上實例輸出結果：
|
1
2
3
|
I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone
|
如上，為了舉例，我們只在每個文件里放置了一個函數，但其實你可以放置許多函數。你也可以在這些文件里定義Python的類，然后為這些類建一個包。
11 Python 文件I/O
11.1 print打印到屏幕
11.2 讀取鍵盤輸入
- raw_input函數
raw_input([prompt]) 函數從標准輸入讀取一個行，並返回一個字符串（去掉結尾的換行符）：
|
1
2
3
4
|
#!/usr/bin/python
str
=
raw_input
(
"Enter your input: "
);
print
"Received input is : "
,
str
|
這將提示你輸入任意字符串，然后在屏幕上顯示相同的字符串。當我輸入"Hello Python！"，它的輸出如下：
|
1
2
|
Enter your
input
: Hello Python
Received
input
is
: Hello Python
|
- input函數
input([prompt]) 函數和raw_input([prompt]) 函數基本可以互換，但是input會假設你的輸入是一個有效的Python表達式，並返回運算結果。
|
1
2
3
4
|
#!/usr/bin/python
str
=
input
(
"Enter your input: "
);
print
"Received input is : "
,
str
|
這會產生如下的對應着輸入的結果：
|
1
2
|
Enter your
input
: [x
*
5
for
x
in
range
(
2
,
10
,
2
)]
Recieved
input
is
: [
10
,
20
,
30
,
40
]
|
11.3打開和關閉文件
- open函數
你必須先用Python內置的open()函數打開一個文件，創建一個file對象，相關的輔助方法才可以調用它進行讀寫。
語法：
|
1
|
file
object
=
open
(file_name [, access_mode][, buffering])
|
各個參數的細節如下：
- file_name：file_name變量是一個包含了你要訪問的文件名稱的字符串值。
- access_mode：access_mode決定了打開文件的模式：只讀，寫入，追加等。所有可取值見如下的完全列表。這個參數是非強制的，默認文件訪問模式為只讀(r)。
- buffering:如果buffering的值被設為0，就不會有寄存。如果buffering的值取1，訪問文件時會寄存行。如果將buffering的值設為大於1的整數，表明了這就是的寄存區的緩沖大小。如果取負值，寄存區的緩沖大小則為系統默認。
不同模式打開文件的完全列表：
| 模式 | 描述 |
|---|---|
| r | 以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。 |
| rb | 以二進制格式打開一個文件用於只讀。文件指針將會放在文件的開頭。這是默認模式。 |
| r+ | 打開一個文件用於讀寫。文件指針將會放在文件的開頭。 |
| rb+ | 以二進制格式打開一個文件用於讀寫。文件指針將會放在文件的開頭。 |
| w | 打開一個文件只用於寫入。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。 |
| wb | 以二進制格式打開一個文件只用於寫入。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。 |
| w+ | 打開一個文件用於讀寫。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。 |
| wb+ | 以二進制格式打開一個文件用於讀寫。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。 |
| a | 打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容之后。如果該文件不存在，創建新文件進行寫入。 |
| ab | 以二進制格式打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容之后。如果該文件不存在，創建新文件進行寫入。 |
| a+ | 打開一個文件用於讀寫。如果該文件已存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。如果該文件不存在，創建新文件用於讀寫。 |
| ab+ | 以二進制格式打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。如果該文件不存在，創建新文件用於讀寫。 |
- File對象的屬性
一個文件被打開后，你有一個file對象，你可以得到有關該文件的各種信息。
以下是和file對象相關的所有屬性的列表：
| 屬性 | 描述 |
|---|---|
| file.closed | 返回true如果文件已被關閉，否則返回false。 |
| file.mode | 返回被打開文件的訪問模式。 |
| file.name | 返回文件的名稱。 |
| file.softspace | 如果用print輸出后，必須跟一個空格符，則返回false。否則返回true。 |
如下實例：
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# 打開一個文件
fo
=
open
(
"foo.txt"
,
"wb"
)
print
"Name of the file: "
, fo.name
print
"Closed or not : "
, fo.closed
print
"Opening mode : "
, fo.mode
print
"Softspace flag : "
, fo.softspace
|
以上實例輸出結果：
|
1
2
3
4
|
Name of the
file
: foo.txt
Closed
or
not
:
False
Opening mode : wb
Softspace flag :
0
|
- Close()方法
File對象的close（）方法刷新緩沖區里任何還沒寫入的信息，並關閉該文件，這之后便不能再進行寫入。
當一個文件對象的引用被重新指定給另一個文件時，Python會關閉之前的文件。用close（）方法關閉文件是一個很好的習慣。
語法：
|
1
|
fileObject.close();
|
例子：
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# 打開一個文件
fo
=
open
(
"foo.txt"
,
"wb"
)
print
"Name of the file: "
, fo.name
# 關閉打開的文件
fo.close()
|
以上實例輸出結果：
|
1
|
Name of the
file
: foo.txt
|
11.4 讀寫文件
file對象提供了一系列方法，能讓我們的文件訪問更輕松。來看看如何使用read()和write()方法來讀取和寫入文件。
- Write()方法
Write()方法可將任何字符串寫入一個打開的文件。需要重點注意的是，Python字符串可以是二進制數據，而不是僅僅是文字。
Write()方法不在字符串的結尾不添加換行符('\n')：
語法：
|
1
|
fileObject.write(string);
|
在這里，被傳遞的參數是要寫入到已打開文件的內容。
例子：
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# 打開一個文件
fo
=
open
(
"/tmp/foo.txt"
,
"wb"
)
fo.write(
"Python is a great language.\nYeah its great!!\n"
);
# 關閉打開的文件
fo.close()
|
上述方法會創建foo.txt文件，並將收到的內容寫入該文件，並最終關閉文件。如果你打開這個文件，將看到以下內容:
|
1
2
|
Python
is
a great language.
Yeah its great!!
|
- read()方法
read（）方法從一個打開的文件中讀取一個字符串。需要重點注意的是，Python字符串可以是二進制數據，而不是僅僅是文字。
語法：
|
1
|
fileObject.read([count]);
|
在這里，被傳遞的參數是要從已打開文件中讀取的字節計數。該方法從文件的開頭開始讀入，如果沒有傳入count，它會嘗試盡可能多地讀取更多的內容，很可能是直到文件的末尾。
例子：
就用我們上面創建的文件foo.txt。
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# 打開一個文件
fo
=
open
(
"/tmp/foo.txt"
,
"r+"
)
str
=
fo.read(
10
);
print
"Read String is : "
,
str
# 關閉打開的文件
fo.close()
|
以上實例輸出結果：
|
1
|
Read String
is
: Python
is
|
- 文件位置
Tell()方法告訴你文件內的當前位置；換句話說，下一次的讀寫會發生在文件開頭這么多字節之后：
seek（offset [,from]）方法改變當前文件的位置。Offset變量表示要移動的字節數。From變量指定開始移動字節的參考位置。
如果from被設為0，這意味着將文件的開頭作為移動字節的參考位置。如果設為1，則使用當前的位置作為參考位置。如果它被設為2，那么該文件的末尾將作為參考位置。
例子：
就用我們上面創建的文件foo.txt。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#!/usr/bin/python
# 打開一個文件
fo
=
open
(
"/tmp/foo.txt"
,
"r+"
)
str
=
fo.read(
10
);
print
"Read String is : "
,
str
# 查找當前位置
position
=
fo.tell();
print
"Current file position : "
, position
# 把指針再次重新定位到文件開頭
position
=
fo.seek(
0
,
0
);
str
=
fo.read(
10
);
print
"Again read String is : "
,
str
# 關閉打開的文件
fo.close()
|
以上實例輸出結果：
|
1
2
3
|
Read String
is
: Python
is
Current
file
position :
10
Again read String
is
: Python
is
|
11.5 重命名和刪除文件
Python的os模塊提供了幫你執行文件處理操作的方法，比如重命名和刪除文件。要使用這個模塊，你必須先導入它，然后可以調用相關的各種功能。
- rename()方法
rename()方法需要兩個參數，當前的文件名和新文件名。
語法：
|
1
|
os.rename(current_file_name, new_file_name)
|
例子：
下例將重命名一個已經存在的文件test1.txt。
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 重命名文件test1.txt到test2.txt。
os.rename(
"test1.txt"
,
"test2.txt"
)
|
- remove()方法
你可以用remove()方法刪除文件，需要提供要刪除的文件名作為參數。
語法：
|
1
|
os.remove(file_name)
|
例子：
下例將刪除一個已經存在的文件test2.txt。
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 刪除一個已經存在的文件test2.txt
os.remove(
"text2.txt"
)
|
11.6 Python里的目錄
- 文件、目錄相關的方法
三個重要的方法來源能對Windows和Unix操作系統上的文件及目錄進行一個廣泛且實用的處理及操控，如下：
- File 對象方法: file對象提供了操作文件的一系列方法。
- OS 對象方法: 提供了處理文件及目錄的一系列方法。
所有文件都包含在各個不同的目錄下，不過Python也能輕松處理。os模塊有許多方法能幫你創建，刪除和更改目錄。
- mkdir()方法——創建新目錄
可以使用os模塊的mkdir()方法在當前目錄下創建新的目錄們。你需要提供一個包含了要創建的目錄名稱的參數。
語法：
|
1
|
os.mkdir(
"newdir"
)
|
例子：
下例將在當前目錄下創建一個新目錄test。
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 創建目錄test
os.mkdir(
"test"
)
|
- chdir()方法
可以用chdir()方法來改變當前的目錄。chdir()方法需要的一個參數是你想設成當前目錄的目錄名稱。
語法：
|
1
|
os.chdir(
"newdir"
)
|
例子：
下例將進入"/home/newdir"目錄。
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 將當前目錄改為"/home/newdir"
os.chdir(
"/home/newdir"
)
|
- getcwd()方法
getcwd()方法顯示當前的工作目錄。
語法：
|
1
|
os.getcwd()
|
例子：
下例給出當前目錄：
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 給出當前的目錄
os.getcwd()
|
- rmdir()方法
rmdir()方法刪除目錄，目錄名稱以參數傳遞。
在刪除這個目錄之前，它的所有內容應該先被清除。
語法：
|
1
|
os.rmdir(
'dirname'
)
|
例子：
以下是刪除" /tmp/test"目錄的例子。目錄的完全合規的名稱必須被給出，否則會在當前目錄下搜索該目錄。
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 刪除”/tmp/test”目錄
os.rmdir(
"/tmp/test"
)
|
12 python 常用庫
12.1GUI 圖形界面
1.wxpython
Python下的GUI編程框架，與MFC的架構相似
下載地址：http://wxpython.org/download.php
2. PyQt
用於Python的QT開發庫
下載地址：http://www.riverbankcomputing.com/software/pyqt/download
12.2 Web框架
1. Django
開源web開發框架，它鼓勵快速開發,並遵循MVC設計
下載地址： http://www.djangoproject.com/
2. web2py
一個小巧靈活的Web框架，雖然簡單但是功能強大
下載地址：http://web2py.com/
12.3 科學計算
1. Matplotlib
用Python實現的類matlab的第三方庫，用以繪制一些高質量的數學二維圖形
下載地址：http://sourceforge.net/projects/matplotlib/files/matplotlib/matplotlib-1.1.0/
2. SciPy
基於Python的matlab實現，旨在實現matlab的所有功能
下載地址：http://pypi.python.org/pypi/scipy/
3. NumPy
基於Python的科學計算第三方庫，提供了矩陣，線性代數，傅立葉變換等等的解決方案
下載地址：http://pypi.python.org/pypi/numpy/
12.4 網頁處理
1. BeautifulSoup，強大的容錯功能
網頁處理非常強大的包：http://www.crummy.com/software/BeautifulSoup/
2. PyQuery，在Python中如網頁的 jQuery一樣處理文檔
下載：https://pypi.python.org/pypi/pyquery
文檔：https://pythonhosted.org/pyquery/
12.5 其他
1. MySQLdb
用於連接MySQL數據庫
下載地址：http://pypi.python.org/pypi/MySQL-python/
2. PIL
基於Python的圖像處理庫，功能強大，對圖形文件的格式支持廣泛
下載地址：http://effbot.org/zone/pil-index.htm
3. PyGame
基於Python的多媒體開發和游戲軟件開發模塊
下載地址：http://www.pygame.org/download.shtml
4 sh 系統管理
sh 可以讓你像執行函數一樣執行shell終端命令
下載地址：https://pypi.python.org/pypi/sh
5. pickle (cPickle)
6. json7. random
8. datetime
12.6 特別介紹
1. cx_Freeze
方便簡潔的打包工具，可跨平台！
下載地址：http://cx-freeze.sourceforge.net/
2. psyco
腳本的執行效率多少有點差強人意，雖然優化起來並不是難事，但如果有簡單的方法，近乎不用修改源代碼，那當然值得去關注一下。psyco 的神奇在於它只需要在代碼的入口處調用短短兩行代碼，性能就能提升 40% 或更多，真可謂是立竿見影！
如果你的客戶覺得你的程序有點慢，敬請不要急着去優化代碼，psyco 或許能讓他立即改變看法。psyco 堪稱 Python 的 jit，有許多潛力可以挖掘，如果剩下來給你優化性能的時間已經不多，請馬上去閱讀它的手冊，有許多招兒輕松優化性能。
以上都是一些常用的第三方庫，更多請點擊：http://pypi.python.org/pypi