條件循環和其餘語句

# coding:utf-8

#----------------------------------------  print和import的更多信息  --------------------------------

#使用逗號輸出

#打印多個表達式也是可行的，只要將它們用逗號隔開就好：

print 'Age:' , 42           #能夠看到，每一個參數之間都插入了一個空格符。

#Age: 42

#若是想要同時輸出文本和變量值，卻不但願使用字符串格式化方法，那這個特性就很是有用：

name = 'Gumby'

salutation = 'Mr.'

greeting = 'Hello,'

print greeting, salutation, name

#Hello, Mr. Gumby

#注意，若是greeting變量裏字符串不帶逗號：

greeting = 'Hello'

#那麼結果中怎麼能獲得逗號呢？

print greeting, ',', salutation, name       #這樣作是不行的，由於語句會在逗號前加入空格。下面是一種解決方案：

#Hello , Mr. Gumby

print greeting + ',', salutation, name

#Hello, Mr. Gumby

#若是在結尾處加上逗號，那麼接下來的語句會與前一條語句在同一行打印。

print 'Hello,',

print 'world!'

#Hello, world!

#把某件事做爲另外一件事導入

#從模塊導入函數時候，一般可使用

#import somemodule

#或者

#from somemodule import somefunction

#或者

#from somemodule import somefumction, anotherfunction, yetanotherfunction

#或者

#from somemodule import *

#只有肯定本身想要從給定的模塊導入全部功能是，才應該使用最後一個版本。

#若是兩個模塊都有open函數，使用以下方法：

#import somemodule

#module1.open(...)

#module2.open(...)

#但還有另外的選擇，能夠在語句末尾增長一個as子句，在該子句後給出想要使用的別名。

import math as foobar       #整個模塊提供別名

print foobar.sqrt(4)

#2.0

from math import sqrt as foobar     #爲函數提供別名

print foobar(4)

#2.0

#對於open函數，能夠像下面這樣使用：

#from module1 import open as open1

#from module2 import open as open2

#------------------------------------------  賦值魔法  -----------------------------------------------------

#序列解包

#將多個值得序列解開，而後放到變量的序列中。

x, y, z = 1, 2, 3

print x, y, z

#1 2 3

#交換兩個（或更多個）變量

x, y = y, x

print x, y, z

#2 1 3

values = 1, 2, 3

print values

#(1, 2, 3)

x, y, z = values

print x

#1

scoundrel = {'name': 'Robin', 'girlfriend': 'Marion'}

key, value = scoundrel.popitem()              #隨機刪除一對鍵和值，而後刪除的鍵和值做爲元組返回，這個元組賦予key和value變量

print key

#girlfriend

print value

#Marion

print scoundrel

#{'name': 'Robin'}

#所解包的序列中的元素數量必須和放置在賦值符號=左邊的變量數量徹底一致，不然會報錯。

#x, y, z = 1, 2             會報錯

#x, y, z = 1, 2, 3, 4       會報錯

#鏈式賦值

#鏈式賦值是將同一個值賦給多個變量的捷徑。

x = y = 1

print x

#1

print y

#1

#效果同上

x = 1

x = y

print x

#1

print y

#1

#注意上面的語句和下面的語句不必定等價：

x = 1

y = 1

#增量賦值

#對於*，/，% 等標準運算符都適用

#增量賦值可讓代碼更加緊湊和簡練，不少狀況下會更易讀。

x = 2

x += 1

print x

#3

x *= 2

print x

#6

#對於其餘數據類型也適用。

fnoed = 'foo'

fnoed += 'bar'

print fnoed

#foobar

fnoed *= 2

print fnoed

#foobarfoobar

#----------------------------------------------  條件和條件語句  --------------------------------------------

#這就是布爾變量的做用

#下面的值在做爲布爾表達式的時候，會被解釋器看做假（false）

#False  None  0  ""  ()  []  {}

#其餘一切都被解釋爲真，包括特殊值True

#標準布爾值爲0表示假，1表示真

print True == 1

#True

print False == 0

#True

print True + False + 42

#43

#bool轉換成布爾值

print bool('I think, therefore I am')

#True

print bool(42)

#True

print bool('')

#False

print bool(0)

#False

#條件執行和if語句

#若是條件（在if和冒號之間的表達式）斷定爲真，那麼後面的語句塊就會被執行。若是條件爲假，語句塊就不會被執行。

#name = raw_input('What is your name? ')

#if name.endswith('Gumby'):               #若是語句結尾是Gumby

#    print 'Hello, Mr. Gumby'

#執行結果：

#What is your name? Gumby

#Hello, Mr. Gumby

#else子句

#name = raw_input('What is your name? ')

#if name.endswith('Gumby'):               #若是語句結尾是Gumby

#    print 'Hello, Mr. Gumby'

#else:

#    print 'Hello, stranger'

#執行結果：

#What is your name? abc

#Hello, stranger

#elif子句

#若是須要檢查多個條件，就可使用elif，它是else if的簡寫，也是if和else子句的聯合使用，也就具備條件的else子句。

#num = input('Enter a number: ')        可使用int(raw_input('Enter a number: ')來替代

#if num > 0:

#    print 'The number is positive'

#elif num < 0:

#    print 'The number is negative'

#else:

#    print 'The number is zero'

#執行結果：

#Enter a number: 1

#The number is positive

#Enter a number: -1

#The number is negative

#Enter a number: 0

#The number is zero

#嵌套代碼塊

#if語句裏面能夠嵌套使用if語句，就像下面這樣：

#name = raw_input('What is your name? ')

#if name.endswith('Gumby'):

#    if name.startswith('Mr. '):

#        print 'Hello,Mr. Gumby'

#    elif name.startswith('Mrs. '):

#        print 'Hello,Mrs. Gumby'

#    else:

#        print 'Hello, Gumby'

#else:

#    print 'Hello stranger'

#執行結果：

#What is your name? Mr. Gumby

#Hello,Mr. Gumby

#What is your name? Mrs. Gumby

#Hello,Mrs. Gumby

#What is your name? Gumby

#Hello, Gumby

#What is your name? abc

#Hello stranger

#更復雜的條件

#比較運算符

# 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 容器（列如，序列）的成員

#注意若是偶然碰見x <> y 這樣的表達式，它的意思其實就是x != y 不建議使用<>運算符，應該儘可能避免使用它。

#在python中比較運算符和賦值運算符同樣能夠鏈接的---幾個運算符能夠連在一塊兒使用，好比：

#0 < age < 100

#相等運算符

#若是想要知道兩個東西是否相等，應該使用相等運算符，即兩個等號==

print "foo" == "foo"

#True

print "foo" == "bar"   #爲什麼用雙等於，一個等因而變量賦值，因此用雙等於

#False

#is:同一性運算符

#判斷是否一個對象，若是值相同，並不必定是一個對象

x = y = [1, 2, 3]                #同一個對象

z = [1, 2, 3]                    #值相同，但和x y 不是一個對象

print x == y

#True

print x == z                    #值相同，因此True

#True

print x is y                    #是一個對象

#True

print x is z                    #不是一個對象，因此False

#False

#另一個例子：

x = [1, 2, 3]

y = [2, 4]

print x is not y

del x[2]

y[1] = 1

y.reverse()         #反向排序

print x

#[1, 2]

print y

#[1, 2]

print x == y

#True

print x is y

#False

#in 成員資格運算符

#name = raw_input('What is your name? ')

#if 's' in name:

#    print 'Your name contains the letter "s".'

#else:

#    print 'Your name does not contain the letter "s".'

#執行結果：

#What is your name? tom

#Your name does not contain the letter "s".

#What is your name? toms

#Your name contains the letter "s".

#字符串和序列比較

#字符串按照字母順序排列

print "alpha" < "beta"

#True

#大寫的話比較會亂，因此先轉換小寫再比較

print 'FnOrD'.lower() == 'Fnord'.lower()

#True

#其餘序列比較，比較的是序列元素

print [1, 2] < [2, 1]

#True

print [2, [1, 4]] < [2,[1,5]]

#True

#布爾運算符

#多個條件寫法：

#number = input('Enter a number between 1 and 10: ')

#if number <= 10:

#    if number >= 1:

#        print 'Great!'

#    else:

#        print 'Wrong!'

#else:

#    print 'Wrong!'

#執行結果：

#Enter a number between 1 and 10: 1

#Great!

#Enter a number between 1 and 10: -1

#Wrong!

#Enter a number between 1 and 10: 11

#Wrong!

#這樣寫沒問題，但方法太笨，簡單方法：

#number = input('Enter a number between 1 and 10: ')

#if number <= 10 and number >= 1:             #and運算符就是所謂的布爾運算符，它鏈接兩個布爾值，而且在二者都爲真時返回真，不然返回假。與它同類還有兩個運算符，or和not。使用這3個運算符就能夠隨意結合真值。

# 還有更簡單的表達式 1<=number<=10

#    print 'Great!'

#else:

#    print 'Wrong!'

#執行結果：

#Enter a number between 1 and 10: 1

#Great!

#Enter a number between 1 and 10: -1

#Wrong!

#Enter a number between 1 and 10: 11

#Wrong!

#短路邏輯惰性求值

#表達式x and y須要兩個變量爲真才爲真，因此若是x爲假，表達式就會馬上返回false，而無論y的值。

#表達式x or y，x爲真時，它直接返回x值（True），不然返回y值（True）

#這有什麼用？它主要是避免了無用的執行代碼，能夠做爲一種技巧使用。假設用戶應該輸入名字，但也能夠選擇什麼都不輸入，這時能夠用默認值'<unknown>'。能夠用if語句但能夠用更簡潔的方式：

#name = raw_input('Please enter your name: ') or '<unknown>'

# assert

#斷言，要求程序代碼中某些條件必須爲真，不然報錯退出，再也不繼續後續代碼執行。用來測試調試程序代碼的輔助條件。

age = 10

assert 0 < age < 100            #條件爲真，不報錯

#age = -1

#assert 0 < age < 100            #不爲真，報錯

#Traceback (most recent call last):

#  File "Z:/CloudStation/***.py", line 96, in <module>

#    assert 0 < age < 100

#AssertionError

#age = -1

#assert 0 < age < 100, 'The age must be realistic'

#條件後面添加字符串，能夠用來註釋解釋錯誤信息。

#Traceback (most recent call last):

#  File "Z:/CloudStation/***.py", line 96, in <module>

#    assert 0 < age < 100, 'The age must be realistic'

#AssertionError: The age must be realistic

#-------------------------------------------  循環  --------------------------------------------------------

#while循環

x = 1

while x <= 100:         #打印1到100

   print x

   x += 1

#name = ''

#while not name:           #若是輸入空格也被接受，防止這種狀況，能夠修改while not name or name.isspace() 或者 while not name.strip()

#    name = raw_input('Please enter your name: ')

#print 'Hello, %s!' % name

#for循環

#爲一個集合每一個元素執行一個代碼塊，好比序列，迭代對象

words = ['this', 'is', 'an', 'ex', 'parrot']

for word in words:

   print word

#this

#is

#an

#ex

#parrot

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for number in numbers:

   print number

#0

#1

#2

#3

#4

#5

#6

#7

#8

#9

print range(0,10)           #range函數，下限默認爲0，不包含上限

#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print range(10)             #默認下限爲0

#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#rang函數一次建立整個序列，xrange一次只建立一個數，當須要一個巨大序列時xrange會更高效

for number in range(1,101):   #打印1到100，它比以前的while更簡潔。

   print number

#若是能使用for，就儘可能不用while

#循環遍歷字典元素

#一個簡單的for語句就能遍歷字典的全部鍵，就像遍歷訪問序列同樣

d = {'x': 1, 'y': 2, 'z': 3}

for key in d:

   print key, 'corresponds to', d[key]

#y corresponds to 2

#x corresponds to 1

#z corresponds to 3

for key, value in d.items():

   print key, 'corresponds to', value

#y corresponds to 2

#x corresponds to 1

#z corresponds to 3

#一些迭代工具

#並行迭代

#程序能夠同時迭代兩個序列

names = ['anne', 'beth', 'george', 'damon']

ages = [12, 45, 32, 102]

#若是想要打印名字和對應的年齡：

for i in range(len(names)):

   print names[i], 'is', ages[i], 'years old'

#anne is 12 years old

#beth is 45 years old

#george is 32 years old

#damon is 102 years old

#zip函數並行迭代，能夠把兩個序列"壓縮"在一塊兒，而後返回一個元組的列表

print zip(names, ages)

#[('anne', 12), ('beth', 45), ('george', 32), ('damon', 102)]

#如今能夠在循環中解包元組

for name, age in zip(names, ages):

   print name, 'is', age, 'years old'

#anne is 12 years old

#beth is 45 years old

#george is 32 years old

#damon is 102 years old

#zip函數也能夠做用於任意多的序列，它能夠做用不等長的序列，最短的序列用完的時候就會中止。

print zip(range(5),xrange(100000))      #不推薦用range替換xrange，range會計算全部的數字，xrange只計算前5個數字

#[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

#按索引迭代

names = ['anne', 'beth', 'anne', 'damon']

ages = [12, 45, 32, 102]

for name, age in zip(names, ages):

   if 'anne' in name:                                #找到索引進行替換

       index = names.index(name)

       names[index] = '[censored]'

       print names

#['[censored]', 'beth', 'anne', 'damon']

#['[censored]', 'beth', '[censored]', 'damon']

names = ['anne', 'beth', 'anne', 'damon']

ages = [12, 45, 32, 102]

index = 0

for name, age in zip(names, ages):

   if 'anne' in name:                              #更好的方法

       names[index] = '[censored]'

       print names

   index += 1

#['[censored]', 'beth', 'anne', 'damon']

#['[censored]', 'beth', '[censored]', 'damon']

#enumerate函數，能夠在提供索引的地方迭代索引--值對

names = ['anne', 'beth', 'anne', 'damon']

ages = [12, 45, 32, 102]

for index, name in enumerate(names):                #更好的方法

   if 'anne' in name:

       names[index] = '[censored]'

       print names

# ['[censored]', 'beth', 'anne', 'damon']

# ['[censored]', 'beth', '[censored]', 'damon']

#翻轉和排序迭代

#reversed和sorted。它同列表的reverse和sort方法相似，但做用於任何序列或可迭代對象上，不是原地修改對象，而是返回翻轉或排序後的版本：

print sorted([4, 3, 6, 8, 3])

#[3, 3, 4, 6, 8]

print sorted('Hello, world!')

#[' ', '!', ',', 'H', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

print list(reversed('Hello, word!'))

#['!', 'd', 'r', 'o', 'w', ' ', ',', 'o', 'l', 'l', 'e', 'H']

print ''.join(reversed('Hello, world!'))

#!dlrow ,olleH

#跳出循環

#break

#結束（跳出）循環可使用break語句。

from math import sqrt

for n in range(99, 0, -1):          # -1是步長，負數是反向迭代

   root = sqrt(n)

   if root == int(root):

       print n

       break                       #跳出循環

#81

#continue

#continue意思是跳過剩餘的循環體，可是不結束循環。當循環體很大並且很複雜的時候，這會頗有用。

#for x in seq:

#   if condition1:continue

#   if condition2:continue

#   if condition2:continue

#   do_something()

#   do_something_else()

#   do_anoter_thing()

#   etc()

#不少時候，只要使用if語句就能夠了：

#for x in seq:

#   if not (condition1 or condition2 or condition3):

#       do_something()

#       do_something_else()

#       do_anoter_thing()

#       etc()

#儘管continue語句很是有用，它卻不是最本質的。應該習慣使用break語句，由於while True語句中會常常用到它。下一節會介紹：

#while True/break習語

while True:             #無限循環

   word = raw_input('Please enter a word: ')

   if not word: break          #知足條件跳出循環

   # 處理word：

   print 'The word was ' + word

#執行結果：

#Please enter a word: first

#The word was first

#Please enter a word: second

#The word was second

#Please enter a word:

#循環中的else子句

#當循環內使用break語句時，一般是由於「找到」了某物或者由於某事「發生」了。在跳出前作一些事情很簡單（好比在break上面加入print n），可是有些時候想要在沒有跳出以前作些事情。

from math import sqrt

for n in range(99, 81, -1):

   root = sqrt(n)

   if root == int(root):

       print n

       break

else:

   print "Didn't find it"

#Didn't find it

#列表推導式-輕量級循環

#列表推導式是利用其它列表建立新列表的一種方法。

print [x*x for x in range(10)]

#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

print [x*x for x in range(10) if x % 3 == 0]

#[0, 9, 36, 81]

print [(x, y) for x in range(3) for y in range(3)]

#[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

#效果同上的for語句寫法

result = []

for x in range(3):

   for y in range(3):

       result.append((x,y))

print result

#[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

girls = ['alice', 'bernic', 'clarice']

boys = ['chris', 'arnold', 'bob']

print [b+'+'+g for b in boys for g in girls if b[0] == g[0]]    #比較第一位相同字母的方式

#['chris+clarice', 'arnold+alice', 'bob+bernic']

#上面例子效果不高，由於它會檢查每一個可能的配對。

#下面例子建立了一個叫作letterGirls的字典，其中每一項都把單字母做爲鍵，以女孩名字組成列表做爲值。在字典創建後，列表推導式循環整個男孩集合，而且查找那些和當前男孩名字首字母相同的女孩集合。

#這樣列表推導式就不用嘗試全部的男孩女孩的組合，檢查首字母是否匹配。

girls = ['alice', 'bernic', 'clarice']

boys = ['chris', 'arnold', 'bob']

letterGirls = {}

for girl in girls:

   letterGirls.setdefault(girl[0], []).append(girl)

   print letterGirls               #打印出來，查看循環狀況

print [b+'+'+g for b in boys for g in letterGirls[b[0]]]

#{'a': ['alice']}

#{'a': ['alice'], 'b': ['bernic']}

#{'a': ['alice'], 'c': ['clarice'], 'b': ['bernic']}

#['chris+clarice', 'arnold+alice', 'bob+bernic']

#------------------------------------------ 三人行  -----------------------------------------------------

#pass

#什麼都沒發生，用於代碼沒寫完，暫時頂替

#name = raw_input('Please enter name: ')

#if name == 'Ralph Auldus Mellish':

#    print 'Welcom!'

#elif name == 'Enid':

   #還沒完...

#    pass                    #沒想到寫什麼，但能夠pass頂替，要否則程序會報錯

#elif name == 'Bill Gates':

#    print 'Access Denied'

#del

#刪除變量名字，值若是沒有python會自動回收

scoundrel = {'age':42, 'first name': 'Robin', 'last name': 'of Locksley'}

robin = scoundrel

print scoundrel

#{'last name': 'of Locksley', 'first name': 'Robin', 'age': 42}

print robin

#{'last name': 'of Locksley', 'first name': 'Robin', 'age': 42}

scoundrel = None        #當設置scoundrel爲None的時候，字典經過robin仍是可用

print scoundrel

#None

print robin

#{'last name': 'of Locksley', 'first name': 'Robin', 'age': 42}

robin = None           #當robin也設置爲None的時候，字典就漂在內存裏面，沒有任何名字綁定在它上面，沒有任何辦法能夠獲取到它。就會被刪除回收。也能夠用None以外的其餘值。一樣會被刪除回收。

print robin

#None

#另外一種方法是del，它會刪除對象引用和名字（但不會刪除值）

x = 1

y = x

del x           #x和y指向一個值，刪除x變量只是名字，因此y的值還在

print y

#1

#使用exec和eval執行和求值字符串

#執行一個字符串的語句時exec

exec "print 'Hello, world!'"

#exec 須要放入到一個命名空間，但這個空間是用戶本身的，並不會影響全局空間

from math import sqrt

scope = {}          #增長scope，起到放置代碼字符串命名空間做用的字典

exec 'sqrt = 1' in scope

print sqrt(4)       #沒有覆蓋sqrt函數

#2.0

print scope['sqrt']     #經過exec賦值的變量sqrt只在它的做用域內有效

#1

#eval

#eval（用於求值）是相似於exec的內建函數。exec語句會執行一系列python語句（不返回值），而eval會計算python表達式（以字符串形式書寫），而且返回結果值。

#print eval (raw_input("Enter an arithmetic expression: "))

#Enter an arithmetic expression: 6 + 18 * 2

#42

#跟exec同樣，eval也可使用命名空間

scope = {}

scope['x'] = 2

scope['y'] = 3

print eval('x * y', scope)

#6

scope = {}

exec 'x = 2' in scope

print eval('x * x', scope)

#4

#涉及函數

#chr(n)                                     當傳入序號n時，返回n所表明的包含一個字符的字符串,（0 <= n < 256）

#eval(source[, globals[, locals]])          將字符串做爲表達式計算，而且返回值

#enumerate(seq)                             產生用於迭代的（索引，值）對

#ord(c)                                     返回單字符字符串的int值

#rang([start,] stop[, step])                建立整數的列表

#reversed(seq)                              產生seq中值的反向版本，用於迭代

#sorted(seq[,cmp][,key][,reverse])          返回seq中值排序後的列表

#xrange([start,]stop[,step])                創造xrange對象用於迭代

#zip(seq1,_seq2...)                         創造用於並行迭代的新序列