數(shù)據(jù)類型已經(jīng)學(xué)的差不多了，但是，到現(xiàn)在為止我們還不能真正的寫程序，這就好比小學(xué)生學(xué)習(xí)寫作一樣，到目前為止僅僅學(xué)會了一些詞語，還不知道如何造句子。從現(xiàn)在開始就學(xué)習(xí)如何造句子了。

在編程語言中，句子被稱之為“語句”，

什么是語句

事實上，前面已經(jīng)用過語句了，最典型的那句：print "Hello, World"就是語句。

為了能夠嚴(yán)謹(jǐn)?shù)仃U述這個概念，抄一段維基百科中的詞條：命令式編程

命令式編程（英語：Imperative programming），是一種描述電腦所需作出的行為的編程范型。幾乎所有電腦的硬件工作都是指令式的；幾乎所有電腦的硬件都是設(shè)計來運行機器碼，使用指令式的風(fēng)格來寫的。較高級的指令式編程語言使用變量和更復(fù)雜的語句，但仍依從相同的范型。

運算語句一般來說都表現(xiàn)了在存儲器內(nèi)的數(shù)據(jù)進行運算的行為，然后將結(jié)果存入存儲器中以便日后使用。高級命令式編程語言更能處理復(fù)雜的表達式，可能會產(chǎn)生四則運算和函數(shù)計算的結(jié)合。

一般所有高級語言，都包含如下語句，Python 也不例外：

• 循環(huán)語句:容許一些語句反復(fù)運行數(shù)次。循環(huán)可依據(jù)一個默認(rèn)的數(shù)目來決定運行這些語句的次數(shù)；或反復(fù)運行它們，直至某些條件改變。
• 條件語句:容許僅當(dāng)某些條件成立時才運行某個區(qū)塊。否則，這個區(qū)塊中的語句會略去，然后按區(qū)塊后的語句繼續(xù)運行。
• 無條件分支語句容許運行順序轉(zhuǎn)移到程序的其他部分之中。包括跳躍（在很多語言中稱為 Goto）、副程序和 Procedure 等。

循環(huán)、條件分支和無條件分支都是控制流程。

當(dāng)然，Python 中的語句還是有 Python 特別之處的（別的語言中，也會有自己的特色）。下面就開始娓娓道來。

print

在 Python2.x 中，print 是一個語句，但是在 Python3.x 中它是一個函數(shù)了。這點請注意。不過，這里所使用的還是 Python2.x。

為什么不用 Python3.x？這個問題在開始就回答過。但是還有朋友問。重復(fù)回答：因為現(xiàn)在很多工程項目都是 Python2.x，Python3.x 相對 Python2.x 有不完全兼容的地方。學(xué) Python 的目的就是要在真實的工程項目中使用，理所應(yīng)當(dāng)要學(xué) Python2.x。此外，學(xué)會了 Python2.x，將來過渡到 Python3.x，只需要注意一些細(xì)節(jié)即可。

print 發(fā)起的語句，在程序中主要是將某些東西打印出來，還記得在講解字符串的時候，專門講述了字符串的格式化輸出嗎？那就是用來 print 的。

>>> print "hello, world"
hello, world
>>> print "hello","world"
hello world

請仔細(xì)觀察，上面兩個 print 語句的差別。第一個打印的是"hello, world"，包括其中的逗號和空格，是一個完整的字符串。第二個打印的是兩個字符串，一個是"hello"，另外一個是"world"，兩個字符串之間用逗號分隔。

本來，在 print 語句中，字符串后面會接一個 \n 符號。即換行。但是，如果要在一個字符串后面跟著逗號，那么換行就取消了，意味著兩個字符串"hello"，"world"打印在同一行。

或許現(xiàn)在體現(xiàn)的還不時很明顯，如果換一個方法，就顯示出來了。（下面用到了一個被稱之為循環(huán)的語句，下一節(jié)會重點介紹。

>>> for i in [1,2,3,4,5]:
...     print i
... 
1
2
3
4
5

這個循環(huán)的意思就是要從列表中依次取出每個元素，然后賦值給變量 i，并用 print 語句打印打出來。在變量 i 后面沒有任何符號，每打印一個，就換行，再打印另外一個。

下面的方式就跟上面的有點區(qū)別了。

>>> for i in [1,2,3,4,5]:
...     print i ,
... 
1 2 3 4 5

就是在 print 語句的最后加了一個逗號，打印出來的就在一行了。

print 語句經(jīng)常用在調(diào)試程序的過程，讓我們能夠知道程序在執(zhí)行過程中產(chǎn)生的結(jié)果。

import

在《常用數(shù)學(xué)函數(shù)和運算優(yōu)先級》中，曾經(jīng)用到過一個 math 模塊，它能提供很多數(shù)學(xué)函數(shù)，但是這些函數(shù)不是 Python 的內(nèi)建函數(shù)，是 math 模塊的，所以，要用 import 引用這個模塊。

這種用 import 引入模塊的方法，是 Python 編程經(jīng)常用到的。引用方法有如下幾種：

>>> import math
>>> math.pow(3,2)
9.0

這是常用的一種方式，而且非常明確，math.pow(3,2)就明確顯示了，pow()函數(shù)是 math 模塊里的?？梢哉f這是一種可讀性非常好的引用方式，并且不同模塊的同名函數(shù)不會產(chǎn)生沖突。

>>> from math import pow
>>> pow(3,2)
9.0

這種方法就有點偷懶了，不過也不難理解，從字面意思就知道 pow()函數(shù)來自于 math 模塊。在后續(xù)使用的時候，只需要直接使用 pow()即可，不需要在前面寫上模塊名稱了。這種引用方法，比較適合于引入模塊較少的時候。如果引入模塊多了，可讀性就下降了，會不知道那個函數(shù)來自那個模塊。

>>> from math import pow as pingfang
>>> pingfang(3,2)
9.0

這是在前面那種方式基礎(chǔ)上的發(fā)展，將從某個模塊引入的函數(shù)重命名，比如講 pow 充命名為 pingfang，然后使用 pingfang()就相當(dāng)于在使用 pow()了。

如果要引入多個函數(shù)，可以這樣做：

>>> from math import pow, e, pi
>>> pow(e,pi)
23.140692632779263

引入了 math 模塊里面的 pow,e,pi，pow()是一個乘方函數(shù)，e，就是那個歐拉數(shù)；pi 就是 π.

e，作為數(shù)學(xué)常數(shù)，是自然對數(shù)函數(shù)的底數(shù)。有時稱他為歐拉函數(shù)（Euler's number），以瑞士數(shù)學(xué)家歐拉命名；也有個較鮮見的名字納皮爾常數(shù)，以紀(jì)念蘇格蘭數(shù)學(xué)家約翰·納皮爾引進對數(shù)。它是一個無限不循環(huán)小數(shù)。e = 2.71828182845904523536(《維基百科》)

e 的 π 次方,是一個數(shù)學(xué)常數(shù)。與 e 和 π 一樣，它是一個超越數(shù)。這個常數(shù)在希爾伯特第七問題中曾提到過。(《維基百科》)

from math import * pow(3,2) 9.0 sqrt(9) 3.0

這種引入方式是最貪圖省事的了，一下將 math 中的所有函數(shù)都引過來了。不過，這種方式的結(jié)果是讓可讀性更降低了。僅適用于模塊中的函數(shù)比較少的時候，并且在程序中應(yīng)用比較頻繁。

在這里，我們用 math 模塊為例，引入其中的函數(shù)。事實上，不僅函數(shù)可以引入，模塊中還可以包括常數(shù)等，都可以引入。在編程中，模塊中可以包括各樣的對象，都可以引入。

賦值語句

對于賦值語句，應(yīng)該不陌生，在前面已經(jīng)頻繁使用了，如 a = 3 這樣的，就是將一個整數(shù)賦給了變量。

編程中的“=”和數(shù)學(xué)中的“=”是完全不同的。在編程語言中，“=”表示賦值過程。

除了那種最簡單的賦值之外，還可以這么干：

>>> x, y, z = 1, "python", ["hello", "world"]
>>> x
1
>>> y
'python'
>>> z
['hello', 'world']

這里就一一對應(yīng)賦值了。如果把幾個值賦給一個，可以嗎？

>>> a = "itdiffer.com", "python"

>>> a
('itdiffer.com', 'python')

原來是將右邊的兩個值裝入了一個元組，然后將元組賦給了變量 a。這個 Python 太聰明了。

在 Python 的賦值語句中，還有一個更聰明的，它一出場，簡直是讓一些已經(jīng)學(xué)習(xí)過某種其它語言的人亮瞎眼。

有兩個變量，其中 a = 2,b = 9。現(xiàn)在想讓這兩個變量的值對調(diào)，即最終是 a = 9,b = 2.

這是一個簡單而經(jīng)典的題目。在很多編程語言中，是這么處理的：

temp = a;
a = b;
b = temp;

這么做的那些編程語言，變量就如同一個盒子，值就如同放到盒子里面的東西。如果要實現(xiàn)對調(diào)，必須在找一個盒子，將 a 盒子里面的東西（數(shù)字 2）拿到那個臨時盒子(temp)中，這樣 a 盒子就空了，然后將 b 盒子中的東西拿(數(shù)字 9)拿到 a 盒子中(a = b)，完成這步之后，b 盒子是空的了，最后將臨時盒子里面的那個數(shù)字 2 拿到 b 盒子中。這就實現(xiàn)了兩個變量值得對調(diào)。

太啰嗦了。

Python 只要一行就完成了。

>>> a = 2
>>> b = 9

>>> a, b = b, a

>>> a
9
>>> b
2

a, b = b, a 就實現(xiàn)了數(shù)值對調(diào)，多么神奇。之所以神奇，就是因為我前面已經(jīng)數(shù)次提到的 Python 中變量和數(shù)據(jù)對象的關(guān)系。變量相當(dāng)于貼在對象上的標(biāo)簽。這個操作只不過是將標(biāo)簽換個位置，就分別指向了不同的數(shù)據(jù)對象。

還有一種賦值方式，被稱為“鏈?zhǔn)劫x值”

>>> m = n = "I use python"
>>> print m,n
I use python I use python

用這種方式，實現(xiàn)了一次性對兩個變量賦值，并且值相同。

>>> id(m)
3072659528L
>>> id(n)
3072659528L

用 id()來檢查一下，發(fā)現(xiàn)兩個變量所指向的是同一個對象。

另外，還有一種判斷方法，來檢查兩個變量所指向的值是否是同一個（注意，同一個和相等是有差別的。在編程中，同一個就是 id()的結(jié)果一樣。

>>> m is n
True

這是在檢查 m 和 n 分別指向的對象是否是同一個，True 說明是同一個。

>>> a = "I use python"
>>> b = a
>>> a is b
True

這是跟上面鏈?zhǔn)劫x值等效的。

但是：

>>> b = "I use python"
>>> a is b
False
>>> id(a)
3072659608L
>>> id(b)
3072659568L

>>> a == b
True

看出其中的端倪了嗎？這次 a、b 兩個變量雖然相等，但不是指向同一個對象。

還有一種賦值形式，如果從數(shù)學(xué)的角度看，是不可思議的，如：x = x + 1，在數(shù)學(xué)中，這個等式是不成立的。因為數(shù)學(xué)中的“=”是等于的含義，但是在編程語言中，它成立，因為"="是賦值的含義，即將變量 x 增加 1 之后，再把得到的結(jié)果賦值變量 x.

這種變量自己變化之后將結(jié)果再賦值給自己的形式，稱之為“增量賦值”。+、-、*、/、% 都可以實現(xiàn)這種操作。

為了讓這個操作寫起來省點事（要寫兩遍同樣一個變量），可以寫成：x += 1

>>> x = 9
>>> x += 1
>>> x
10

除了數(shù)字，字符串進行增量賦值，在實際中也很有價值。

>>> m = "py"
>>> m += "th"
>>> m
'pyth'
>>> m += "on"
>>> m
'python'

總目錄   |   上節(jié)：運算符   |   下節(jié)：語句(2)

如果你認(rèn)為有必要打賞我，請通過支付寶：qiwsir@126.com,不勝感激。