Python基礎之(五)語句

運算符

算術運算符

前面已經講過了四則運算，其中涉及到一些運算符：加減乘除，對應的符號分別是：+ - * /，此外，還有求餘數的：%。這些都是算術運算符。其實，算術運算符不止這些。根據中學數學的知識，也應該想到，還應該有乘方、開方之類的。

下面列出一個表格，將全部的運算符表現出來。

運算符	描述	實例
+	加 - 兩個對象相加	10+20 輸出結果 30
-	減 - 獲得負數或是一個數減去另外一個數	10-20 輸出結果 -10
*	乘 - 兩個數相乘或是返回一個被重複若干次的字符串	10 * 20 輸出結果 200
/	除 - x除以y	20/10 輸出結果 2
%	取餘 - 返回除法的餘數	20%10 輸出結果 0
**	冪 - 返回x的y次冪	10**2 輸出結果 100
//	取整除 - 返回商的整數部分	9//2 輸出結果 4 , 9.0//2.0 輸出結果 4.0

比較運算符

如下假設a=10，b=20：

運算符	描述	實例
==	等於 - 比較對象是否相等	(a == b) 返回 False。
!=	不等於 - 比較兩個對象是否不相等	(a != b) 返回 True.
>	大於 - 返回x是否大於y	(a > b) 返回 False。
<	小於 - 返回x是否小於y	(a < b) 返回 True。
>=	大於等於 - 返回x是否大於等於y。	(a >= b) 返回 False。
<=	小於等於 - 返回x是否小於等於y。	(a <= b) 返回 True。

邏輯運算符

（假設a=10，b=20）

運算符	描述	實例
and	布爾"與" - 若是x爲False，x and y返回False，不然它返回y的計算值。	(a and b) 返回 20。
or	布爾"或" - 若是x是True，它返回True，不然它返回y的計算值。	(a or b) 返回 10。
not	布爾"非" - 若是x爲True，返回False。若是x爲False，它返回True。	not(a and b) 返回 false。

• and

and，翻譯爲「與」運算，但事實上，這種翻譯容易引發望文生義的理解。

先說一下正確的理解。

A and B，含義是：

首先運算A，若是A的值是True，就計算B，並將B的結果返回作爲最終結果，若是B是False，那麼A and B的最終結果就是False，若是B的結果是True，那麼A and B的結果就是True；

若是A的值是False ，就不計算B了，直接返回A and B的結果爲False.

簡單語句

print

在Python 2中，print是一個語句，可是在Python 3中它是一個函數了。這點請注意。

以Python 2爲例，說明print語句。若是說讀者使用的是Python 3，請自行將print xxx修改成print(xxx)，其它不變。

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

>>> print "hello, world"
hello, world
>>> print "hello","world" //逗號表示打印在同一行
hello world

原本，在print語句中，字符串後面會接一個n符號。即換行。可是，若是要在一個字符串後面跟着逗號，那麼換行就取消了，意味着兩個字符串"hello"，"world"打印在同一行。

可是，在Python 3中狀況有變。默認的end='n'，若是不打算換行，能夠在使用print()函數的時候，修改end這個參數的值。

>>> for i in [1,2,3,4]:
    print(i, end=',')

1,2,3,4,

import

import引入模塊的方法，是Python編程常常用到的。引用方法有以下幾種：

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

這是一種可讀性很是好的引用方式，而且不一樣模塊的同名函數不會產生衝突。

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

這種引用方法，比較適合於引入模塊較少的時候。若是引入模塊多了，可讀性就降低了，會不知道那個函數來自那個模塊。

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

將從某個模塊引入的函數重命名，好比講pow充命名爲pingfang，而後使用pingfang()就至關於在使用pow()了

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

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

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

一下將math中的全部函數都引過來了。不過，這種方式的結果是讓可讀性更下降了。僅適用於模塊中的函數比較少的時候，而且在程序中應用比較頻繁。

事實上，不只函數能夠引入，模塊中還能夠包括常數等，均可以引入。在編程中，模塊中能夠包括各樣的對象，均可以引入。

賦值

a = 3

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

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

原來是將右邊的兩個值裝入了一個元組，而後將元組賦給了變量a。

兩個變量的值對調,python只要一行就完成了:

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

由於我前面已經數次提到的Python中變量和對象的關係。變量至關於貼在對象上的標籤。這個操做只不過是將標籤換個位置，就分別指向了不一樣的數據對象。

還有一種賦值方式，被稱爲「鏈式賦值」

>>> m = n = "I use python"
>>> print m, n            #Python 3：print(m, n)
I use python I use python

用這種方式，實現了一次性對兩個變量賦值，而且值相同。

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

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

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

>>> m is n
True

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

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

這是跟上面鏈式賦值等效的。

可是：

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

>>> a == b
True

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

還有一種賦值形式，若是從數學的角度看，是難以想象的，如：x = x + 1，在數學中，這個等式是不成立的。由於數學中的「=」是等於的含義，可是在編程語言中，它成立，由於"="是賦值的含義，即將變量x增長1以後，再把獲得的結果賦值變量x.

這種變量本身變化以後將結果再賦值給本身的形式，稱之爲「增量賦值」。+、-、*、/、%均可以實現相似這種操做。
爲了讓這個操做寫起來省點事（要寫兩遍一樣一個變量），能夠寫成：x += 1

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

除了數字，字符串進行增量賦值，在實際中也頗有價值。

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

條件語句

if語句

>>> a = 8
>>> if a == 8: //冒號是必須的
...     print a //四個空格的縮進是必須的
...
8
>>>

• 必需要經過縮進方式來表示語句塊的開始和結束

• 縮進用四個空格也是必須的

if...elif...else

#coding:utf-8
print "請輸入一個整數數字:"
number = int(raw_input())

if number == 10:
    print "您輸入的數字是： %d" % number
    print "You are smart"
elif number > 10:
    print "您輸入的數字是： %d" % number
    print "This number is more than 10."
elif number < 10:
    print "您輸入的數字是： %d" % number
    print "This number is less than 10."
else:
    print "Are you a human?"
    
結果打印：

請輸入一個整數數字:
12
您輸入的數字是： 12
This number is more than 10.

請輸入一個整數數字:
10
您輸入的數字是： 10
You are smart

請輸入一個整數數字:
9
您輸入的數字是： 9
This number is less than 10.

三元操做符

>>> name = "liuguoquan" if "deason" else "xiaoniu"
>>> name
'liuguoquan'
>>> name = "liuguoquan" if "" else "xiaoniu"
>>> name
'xiaoniu'
>>> name = "liuguoquan" if "xiaoniu" else ""
>>> name
'liuguoquan'

總結一下：A = Y if X else Z
根據上述例子能夠看出：

• 若是X爲真，那麼就執行A = Y

• 若是X爲假，那麼就執行A = Z

>>> a = "python" if x > y else "java"
>>> a
'java'
>>> a = "python" if x < y else "java"
>>> a
'python'
>>>

for循環

For循環的基本結構是：

for 循環規則： //須要冒號

操做語句        //語句要縮進

簡單的for循環

>>> hello = "liuguoquan"
>>> for i in hello:
...     print i
...
l
i
u
g
u
o
q
u
a
n

or:

>>> for i in range(len(hello)):
...     print i
...
0
1
2
3
4
5
6
7
8
9

range（start,stop,[,step])

range是個內建函數，通常形式是range（start,stop,[,step])

關於range()函數注意一下幾點：

• 該函數能夠建立一個數字元素組成的列表

• 該函數最經常使用於for循環

• 函數的參數必須是整數，默認從0開始

• step默認值是1，不寫就是默認值

• step是正數，返回list最後的值不包含stop的值，即start + step的值小於stop；step是負數，start + step的值大於stop；

• step不能等於0

參數解釋：

• start：開始數值，默認爲0

• stop：結束數值，必需要寫

• step：變化的步長，默認是1，不能爲0

正數

>>> range(9)
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> range(0,9)
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> range(0,9,1)
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> range(1,9)
[1, 2, 3, 4, 5, 6, 7, 8]
>>> range(1,9,2)
[1, 3, 5, 7]

負數

>>> rang(-9)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'rang' is not defined
>>> range(0,-9,-1)
[0, -1, -2, -3, -4, -5, -6, -7, -8]
>>> range(0,-9,-2)
[0, -2, -4, -6, -8]
>>>

獲取列表的索引值組成的列表

>>> lgq = ["I","am","a","Android"]
>>> index = range(len(lgq))
>>> index
[0, 1, 2, 3]
>>>

找出100之內的可以被3整除的正整數

#coding:utf-8
result = []
for n in range(1,100):
    if n % 3 == 0:
        result.append(n)
        
print result

or:

print range(3,100,3)

結果打印：

[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]

for對象

#coding:utf-8

name = "liuguoquan"

print "str"
for i in name:
    print i,

print "list"
name_list = list(name)
print name_list
for i in name_list:
    print i,
    
print "set"
name_set = set(name)
print name_set
for i in name_set:
    print i,
    
print "tuple"
name_tuple = set(name)
print name_tuple
for i in name_tuple:
    print i,
    
print "dict"
name_dict = {"name":"liuguoquan","sex":"male","age":"18"}
print name_dict
for i in name_dict:
    print i,"-->",name_dict[i]
    
 結果打印:
 
str:
l i u g u o q u a n 

list:
['l', 'i', 'u', 'g', 'u', 'o', 'q', 'u', 'a', 'n']
l i u g u o q u a n 

set:
set(['a', 'g', 'i', 'l', 'o', 'n', 'q', 'u'])
a g i l o n q u 

tuple
('l', 'i', 'u', 'g', 'u', 'o', 'q', 'u', 'a', 'n')
l i u g u o q u a n 

dict:
{'age': '18', 'name': 'liuguoquan', 'sex': 'male'}
age --> 18
name --> liuguoquan
sex --> male

字典遍歷的多種寫法

name_dict = {"name":"liuguoquan","sex":"male","age":"18"}
print name_dict
for i in name_dict:
    print i,"-->",name_dict[i]

注意到，上面的循環，實際上是讀取了字典的key。在字典中，有一個方法，dict.keys()，獲得的是字典key列表。

#獲取字典key列表
for k in name_dict.keys():
    print k    #Python 3: print(k)

這種循環方法和上面的循環方法，結果是同樣的，可是，這種方法並不提倡，覺得它在執行速度上表現欠佳。

若是要得到字典的value怎麼辦？不要忘記dict.values()方法

for k,v in name_dict.items():
    print k,"-->",v

用上面的方法，要把全部的內容都讀入內存，內存東西多了，可能會出麻煩。爲此，Python中提供了另外的方法。

for k,v in name_dict.iteritems(): #注意：僅在Python2中可用，Python 3中已經作了優化，d.items()即有同等功能。
    print k,"-->",v

這裏是循環一個迭代器，迭代器在循環中有不少優點。除了剛纔的dict.iteritems()以外，還有dict.itervalues()，dict.iterkeys()供你選用（以上三個dict.iter*都只用在Python 2中，Python 3中已經不須要了）

如何判斷一個對象是不可迭代的？

>>> import collections

引入collections這個標準庫。要判斷數字321是否是可迭代的，能夠這麼作：

>>> isinstance(321, collections.Iterable)
    False

返回了False，說明321這個整數類型的對象，是不可迭代的。再判斷一個列表對象。

>>> isinstance([1,2,3], collections.Iterable)
    True

從返回結果，咱們知道，列表[1,2,3]是可迭代的。

固然，並非要你在使用for循環以前，非要判斷某個對象是否可迭代。由於至此，你已經知道了字符串str、列表list、字典dict、元組tuple、集合set都是可迭代的。

zip()

zip()——一個內建函數,Python 2中，參數是seq1, seq2, ...，意思是序列數據；在Python 3中，參數須要時可迭代對象。這點差異，一般是沒有什麼影響的，由於序列也是可迭代的。值得關注的是返回值，在Python 2中，返回值是一個列表對象，裏面以元組爲元素；而Python 3中返回的是一個zip對象。
經過實驗來理解上面的文檔：

Python 2：
    >>> a = "qiwsir"
    >>> b = "github"
    >>> zip(a, b)
    [('q', 'g'), ('i', 'i'), ('w', 't'), ('s', 'h'), ('i', 'u'), ('r', 'b')]
    
Python 3：
    >>> zip(a, b)
    <zip object at 0x0000000003521D08>
    >>> list(zip(a, b))
    [('q', 'g'), ('i', 'i'), ('w', 't'), ('s', 'h'), ('i', 'u'), ('r', 'b')]

若是序列長度不一樣，那麼就以"the length of the shortest argument sequence"爲準。

>>> c = [1, 2, 3]
>>> d = [9, 8, 7, 6]
>>> zip(c, d)        #這是Python 2的結果，若是是Python 3，請仿照前面的方式顯示查看
[(1, 9), (2, 8), (3, 7)]

>>> s = {"name":"qiwsir"}
>>> t = {"lang":"python"}
>>> zip(s,t)
[('name', 'lang')]

zip是一個內置函數，它的參數必須是序列，若是是字典，那麼鍵視爲序列。而後將序列對應的元素依次組成元組，作爲一個列表的元素。

問題：有兩個列表，分別是：a = [1, 2, 3, 4, 5], b = [9, 8, 7, 6, 5]，要計算這兩個列表中對應元素的和。

• for循環實現

>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> c = []
>>> for i in range(len(a)):
...     c.append(a[i]+b[i])
... 
>>> c
[10, 10, 10, 10, 10]

• zip()實現

>>> d = []
>>> for x,y in zip(a,b):
...     d.append(x+y)
... 
>>> d
[10, 10, 10, 10, 10]

問題：有一個字典，myinfor = {"name":"qiwsir", "site":"qiwsir.github.io", "lang":"python"}，將這個字典變換成：infor = {"qiwsir":"name", "qiwsir.github.io":"site", "python":"lang"}

• for循環

>>> myinfor = {"name":"qiwsir", "site":"qiwsir.github.io", "lang":"python"}
>>> infor = {}
>>> for k,v in myinfor.items():
...     infor[v]=k
... 
>>> infor
{'python': 'lang', 'qiwsir.github.io': 'site', 'qiwsir': 'name'}

• zip()

>>> dict(zip(myinfor.values(), myinfor.keys()))
{'python': 'lang', 'qiwsir.github.io': 'site', 'qiwsir': 'name'}

enumerate()

enumerate()也是內建函數。

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

若是要同時獲得元素索引和元素怎麼辦？

• for循環

week = ["monday","sunday","friday"]
for i in range(len(week)):
    print week[i] + ' is ' + str(i) #注意，i是int類型，若是和前面的用+鏈接，必須是str類型

• enumerate

for (i,day) in enumerate(week):
    print day + " is " + str(i)

問題：將字符串中的某些字符替換爲其它的字符串。原始字符串"Do you love Canglaoshi? Canglaoshi is a good teacher."，請將"Canglaoshi"替換爲"PHP".

raw = "Do you love Canglaoshi? Canglaoshi is a good teacher."
print raw

#1. 先將字符串轉換爲列表
raw_list = raw.split(" ")
print type(raw_list)
print raw_list

#2. 對列表中的字符串進行替換
for i,string in enumerate(raw_list):
    if "Canglaoshi" in string:
        raw_list[i] = "PHP"
        
print raw_list

#3. 將列表轉換爲字符串
print " ".join(raw_list)

列表解析

Python有一個很是強大的功能，就是列表解析，它這樣使用：

>>> squares = [x**2 for x in range(1, 10)]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> mybag = [' glass',' apple','green leaf ']   #有的前面有空格，有的後面有空格
>>> [one.strip() for one in mybag]              #去掉元素先後的空格
['glass', 'apple', 'green leaf']

在不少狀況下，列表解析的執行效率高，代碼簡潔明瞭。是實際寫程序中常常被用到的。
如今Python的兩個版本，對列表解釋上，仍是有一點點差異的，請認真看下面的比較操做。

Python 2:

    >>> i = 1
    >>> [ i for i in range(9)]
    [0, 1, 2, 3, 4, 5, 6, 7, 8]
    >>> i
    8

Python 3:

    >>> i = 1
    >>> [i for i in range(9)]
    [0, 1, 2, 3, 4, 5, 6, 7, 8]
    >>> i
    1

先i = 1，而後是一個列表解析式，很是巧合的是，列表解析式中也用了變量i。這種狀況，在編程中是經常遇到的，咱們一般把i=1中的變量i稱爲處於全局命名空間裏面（命名空間，是一個新詞彙，暫且用起來，後面會講述），而列表解析式中的變量i是在列表解析內，稱爲處在局部命名空間。在Python 3中，for循環裏的變量再也不與全局命名空間的變量有關聯了。

while語句

while

while i< 5:
    print i
    i += 1
print "quit"

0
1
2
3
4
quit

break

i= 10
while i:
    if i % 2 == 0:
        break
    else:
        print "%d is odd number" %i
        i = 0
print "%d is even number" %i

10 is even number

continue

i= 10
while i:
    if i % 2 == 0:
        i -= 1
        continue; # 繼續下一次循環
    else:
        print "%d is odd number" %i
        i -= 1
print "%d is even number" %i

while...else

while...else有點相似if ... else，只須要一個例子就能夠理解。 固然，一遇到else了，就意味着已經不在while循環內了。

count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"
   
執行結果：

    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

for...else

除了有while...else外，還能夠有for...else。這個循環也一般用在當跳出循環以後要作的事情。

from math import sqrt

    for n in range(99, 1, -1):
        root = sqrt(n)
        if root == int(root):
            print n # 知足此條件後,不執行else
            break

    else:
        print "Nothing." # break不執行就會執行else