python基礎教程總結4—語句

標籤：

一、print 和 import 的更多資訊

   print 列印多個運算式也是可行的，只要將它們用逗號隔開就好：

1. >>> print(‘Age:‘ , 42)  
2. Age: 42  

   可以看到，每個參數之間都插入了一個空格符。如果想要同時輸出文本和變數值，卻又不希望使用字串格式化的話，那這個特性就非常有用了。

   從模組匯入函數的時候，可以使用

1. import  somemodule  

        或者

1. from  somemodule import  somefunction  

        或者

1. from somemodule import somefunction, anotherfunction, yetanotherfunction 

        或者

1. from somemodule import *  

 

        只有確定自己想要從給定的模組匯入所有功能時，才應該使用最後一個版本。但是如果兩個模組都有 open 函數，那又該怎麼辦？只需使用第一種方式匯入，然後像下面這樣使用函數：

1. module1.open(...)  
2. module2.open(...)  

       還有另外的選擇：可以在語句末尾增加一個 as 子句，在該子句後給出名字，或為整個模組提供別名：

1. >>> import math as foobar  
2. >>> foobar.sqrt(4)  
3. 2.0  

         也可以為函數提供別名：

1. >>> from math import sqrt as foobar  
2. >>> foobar(4)  
3. 2.0   

         對於open函數，可以像下面這樣使用：

1. from module1 import open as open1  
2. from module2 import open as open2  

 

二、賦值

        1. 序列解包

        多個賦值操作可以同時進行：

 

1. >>> x, y, z = 1, 2, 3  
2. >>> print(x, y, z)  
3. 1 2 3  

        用它交換兩個（或更多個）變數：

1. >>> x, y = y, x  
2. >>> print(x, y, z)  
3. 2 1 3  

        事實上，這裡所做的事情叫做序列解包（sequence unpacking）或可選代解包——將多個值的序列解開，然後放到變數的序列中。當函數或者方法返回元組（或者其他序列或可選迭代對象）時，這個特性尤其有用。它允許函數返回一個以上的值並且打包成元組，然後通過一個指派陳述式很容易進行訪問。

 

1. >>> scoundrel = {‘name‘:‘Robin‘, ‘girlfriend‘:‘Marion‘}  
2. >>> key, value = scoundrel.popitem()  
3. >>> key  
4. ‘name‘  
5. >>> value  
6. ‘Robin‘  

        所解包的序列中元素數量必須和放置在賦值符號 = 左邊的變數數量完全一致，否則 Python 會在賦值時引發異常：

 

1. >>> x, y, z = 1, 2  
2. Traceback (most recent call last):  
3.   File "<stdin>", line 1, in <module>  
4. ValueError: need more than 2 values to unpack  
5. >>> x, y, z = 1, 2, 3, 4  
6. Traceback (most recent call last):  
7.   File "<stdin>", line 1, in <module>  
8. ValueError: too many values to unpack (expected 3)  

        Python 3.0中有另外一個解包的特性：可以像在函數的參數列表中一樣使用星號運算子。例如，a, b, *rest = [1, 2, 3, 4]最終會在 a 和 b 都被賦值之後將所有其他的參數都是收集到 rest 中。

 

2. 鏈式賦值

        鏈式賦值（chained assignment）是將同一個賦值給多個變數的捷徑。   x = y = somefunction()   

 

3. 增量賦值

        將運算式運算子(本例中是 + -) 放置在賦值運算子 = 的左邊，寫成 x +=1。這種寫法叫做增量賦值。

 

1. >>> x = 2  
2. >>> x += 1  
3. >>> x *= 2  
4. >>> x  
5. 6  

        對於其他資料類型也適用：

1. >>> fnord = ‘foo‘  
2. >>> fnord += ‘bar‘  
3. >>> fnord *= 2  
4. >>> fnord  
5. ‘foobarfoobar‘  

 

三、語句塊

        語句塊是在條件為真(條件陳述式)時執行或者執行多次（迴圈語句）的一組語句。在代碼前放置空格來縮排語句即可建立語句塊。

        在Python中，冒號(:)用來標識語句塊的開始，塊中的每一個語句都是縮排的(縮排量相同)。當回退到和已經閉合的塊一樣的縮排量時，就表示當前塊已經結束了。

 

四、條件和條件陳述式

        1. 布爾變數

        下面的值在作為布林運算式的時候，會被解譯器看作假（false）：

                 False     None     0     “”     ()      []     {}

        換句話說，也就是標準值 False 和 None、所有類型的數字 0（包括浮點型、長整型和其他類型）、空序列（比如Null 字元串、元組和列表）以及空的字典都為假。其他的一切都被解釋為真，包括特殊值 True。

        布爾值True 和 False 屬於布爾類型，bool函數可以用來（和list、str以及tuple一樣）轉換其他值。 

1. >>> bool(‘I think, therefore I am‘)  
2. True  
3. >>> bool(42)  
4. True  
5. >>> bool(‘‘)  
6. False  
7. >>> bool(0)  
8. False  

        因為所有值都可以用作布爾值，所以幾乎不需要對他們進行顯示轉換（可以說Python會自動轉換這些值）。

 

        2. 條件執行（if / else / elif）

 

1. num = input(‘Enter a number: ‘)  
2. if num > 0:  
3.     print(‘The number is positive‘)  
4. elif num < 0:  
5.     print(‘The number is negative‘)  
6. else:  
7.     print(‘The number is zero‘)  

       3. 嵌套代碼塊

1. name = raw_input(‘What is your name? ‘)  
2. if name.endswith(‘Gumby‘):  
3.     if name.startswith(‘Mr. ‘):  
4.         print(‘Hello, Mr. Gumby‘)  
5.     elif name.startswith(‘Mrs. ‘):  
6.         print(‘Hello, Mrs. Gumby‘)  
7.     else:  
8.         print(‘Hello, Gumby‘)  
9. else:  
10.     print(‘Hello, stranger‘)  

 

       4. 更複雜的條

           4.1 比較子

 

運算式	描述
x==y	x 等於 y
x < y	x 小於 y
x > y	x 大於 y
x >= y	x 大於等於 y
x <= y	x 小於等於 y
x != y	x 不等於 y
x is y	x 和 y 是同一個對象
x is not y	x 和 y 是不同的對象
x in y	x 是 y 容器的成員
x not in y	x 不是 y 容器的成員

           在Python 3.0中，比較不相容類型的對象已經不再可行。

 

           在Python中比較運算和賦值運算一樣是可以串連的——幾個運算子可以連在一起使用，比如：0 < age < 100。

           4.2 相等運算子

           如果想要知道兩個東西是否相等，應該使用相等運算子，即兩個等號 == ：

 

[python] view plaincopy 

1. >>> "foo"=="foo"  
2. True  
3. >>> "foo"=="bar"  
4. False  

 

           4.3 is：同一性運算子

            is 運算子是判定同一性而不是相等性的。

 

[python] view plaincopy 

1. >>> x = y = [1, 2, 3]  
2. >>> z = [1, 2, 3]  
3. >>> x == y  
4. True  
5. >>> x == z  
6. True  
7. >>> x is y  
8. True  
9. >>> x is z  
10. False  

           使用 == 運算子來判定兩個對象是否相等，使用 is 判定兩者是否等同（同一個對象）。

 

           4.4 in：成員資格運算子

           4.5 字串和序列比較

           字串可以按照字母順序排列進行比較。

 

[python] view plaincopy 

1. >>> "alpha" < "beta"  
2. True  

 

           其他的序列也可以用同樣的方式進行比較，不過比較的不是字元而是元素的其他類型。

 

[python] view plaincopy 

1. >>> [1, 2] < [2, 1]  
2. True  

 

           4.6 布林運算子

           and ， or 和 not 運算子就是所謂的布林運算子。

       5. 斷言

python基礎教程總結4—語句