条件、循环和其他语句

赋值语句

1.序列解包

多个赋值操作可以同时进行

>>> 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
>>> values
(1, 2, 3)
>>> x,y,z=values
>>> x
1

当函数或者方法返回元组时，这个特性就很有用。假设需要获取（和删除）字典中任意的键-值对，可以使用popitem方法，这个方法将键-值作为元组返回

>>> person={'name':'Joe','age':11}
>>> key,value=person.popitem()
>>> key
'age'
>>> value
11
>>> person
{'name': 'Joe'}

2.链式赋值

将同一个值赋值给多个变量的捷径叫链式赋值，有点像并行赋值

x=y=somefunction

>>> x=y=1
>>> x,y
(1, 1)

与下面语句实现的一样

y=somefunctin

x=y

>>> y=1
>>> x=y
>>> x,y
(1, 1)

但上面的语句和下面不一定等价

x=somefunction

y=somefunction

3.增量赋值

将表达式运算符（+ - * / %）放置在赋值运算符（=）的左边，叫增量赋值

>>> x=1
>>> x+=1
>>> x
2
>>> fruit='apple'
>>> fruit+=' banana'
>>> fruit*=2
>>> fruit
'apple bananaapple banana'

语句块：缩排的乐趣

语句块在条件为真时执行的一组语句，在代码前放置空格来缩进语句可创建语句块。在Python中，冒号（：）用来标识语句块的开始，块中每个语句都是缩进的（缩进量相同）。当回到已经闭合的块一样的缩进量时，就表示当前块已经结束。

条件和条件语句

1.布尔变量

真值（也叫布尔值）

作为布尔表达式时，标准值False 和None 、所有类型的数字0（包括浮点型、长整型和其他类型）、空序列（比如空字符串、元组和列表）以及空的字典都为假(false)，即False   None  0   '' ''   ()   [ ]  { }

虽然() [ ] { }都是假值，但并不意味着相等False!=()、[ ]!='' "

其他的都被解释为真，包括特殊值True

标准的布尔值是True(1)和False(0)

布尔值True和False 属于布尔类型，bool函数可以用来准换其他值

>>> True == 0
False
>>> True==1
True
>>> True+False+1
2
>>> bool('I like bananas')
True
>>> bool()
False
>>> bool({})
False
>>> bool({}=='')
False
>>> bool(''!=False)
True

2.条件执行和if语句

if 和冒号之间的表达式为条件。条件为真，就执行语句块

x=1
if x==1:
    print ('Right')

3.else子句

4.elif 子句

elif是else if 缩写

5.嵌套代码块

if 语句里面可以嵌套使用if语句

6.更复杂的条件

(1)比较运算符，Python中比较运算符和赋值运算符一样是可以连接的，几个运算符可以一起使用如0<x<10

表达式	描述
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容器的成员

(2)相等运算符

两个等号x==y判断x和y是否相等

(3) is : 同一性运算符

>>> x=y=[1,2,3]
>>> z=[1,2,3]
>>> x is y
True
>>> x is z
False

x和z相等却不等同，因为is 是判断同一性而不是判断相等性，它们值相等，但是不是同一对象

>>> x=[1,2,3]
>>> y=[0,2]
>>> x is not y
True
>>> y.append(3)
>>> y[0]=1
>>> y
[1, 2, 3]
>>> x is y
False

显然，两个列表值相等但不等同

总结，使用==运算符来判断两个对象是否相等1，使用is 判定两者是否等同（同一对象）

（4）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".')
           

(5)字符串和序列比较

字符串可以按照字母顺序排列进行比较

>>> 'apple'>'banana'
False
>>> "Apple".upper()=="apple".upper()
True
>>> [1,[2,5]]<[1,[4,3]]
True

(6)布尔运算符：and 、not 、 or

它们连接两个布尔值

number=input('Enter a number between 1 and 10: ')
if number <= '10' and number >= '1':
    print ("Right")
else:
    print ("Wrong")

内置表达式 a if b else c

这个语句表示如果，b为真返回a,否则返回c

>>> 'T' if 1==1 else 'F'
'T'

7.断言

如果需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert语句就有用了，它可以在程序中置入检查点，条件后可以添加字符串，用来解释断言

>>> youth_teenager=19
>>> assert 12<=youth_teenager<=18,'The age must be right'
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    assert 12<=youth_teenager<=18,'The age must be right'
AssertionError: The age must be right

循环

1.while 循环

name=''
while not name:
    name=input('Please enter your name: ')
print ('Hello,%s!'%name)

结果呢

Please enter your name:  
Hello, !

输入一个空格，接受了，出现了小bug,将while not name改成while not name or name.isspace(),或者使用while not name.strip()

再输入空格就不会接受了

Please enter your name:  
Please enter your name: Joe
Hello,Joe!

2.for循环

words={'this','is','a', 'lovely','dog'}
for word in words:
    print (word)

lovely
this
dog
a
is

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

for循环比while循环更简洁，如果能用for ，就尽量不用whlie循环

先介绍range函数，再看个实例，迭代（循环另一种说法）某范围的数字很常见，有个内建的范围函数就很方便，如range()函数,range函数包含下限，不包含上限，range(10）相当于range（0，10），会默认下线为0

for number in range(10):
	print (number)

3.循环遍历字典元素

一个简单for语句就能循环遍历字典所有键

d={'x':1,'y':2,'z':3}
for key in d:
    print (key,'correspond to',d[key])
#或者
#for key,value in d.items():
#    print (key,'correspond to',value)

x correspond to 1
y correspond to 2
z correspond to 3

如果只需要值，可以使用d.values();只需要键，可以使用d.keys().d.items()方法会将键—值对作为元组返回。for 循环一大好处就是可以在循环使用中使用序列解包

d={'x':1,'y':2,'z':3}
for value in d.items():
    print (d.values())
    

dict_values([1, 2, 3])
dict_values([1, 2, 3])
dict_values([1, 2, 3])

4.一些迭代工具

（1）并行迭代

程序可以同时迭代两个序列，如下

names = ['Joe','Amy','Kitty']
ages=[10,11,12]
for i in range(len(names)):
    print (names,'is',ages[i],'years old')

i是循环变量标准变量名

['Joe', 'Amy', 'Kitty'] is 10 years old
['Joe', 'Amy', 'Kitty'] is 11 years old
['Joe', 'Amy', 'Kitty'] is 12 years old

内建zip函数可以用来进行并行迭代，把两个序列“压缩”在一起，然后返回一个元组的列表，需要注意的是，zip方法在Python2和Python3中的不同，在Python3中为了减少内存，返回一个对象，zip（）返回的是一个对象。如需展示列表，需手动list()转换：

>>> list(zip(names,ages))
[('Joe', 10), ('Amy', 11), ('Kitty', 12)]

试试在循环中解包元组：

for  name,age in list(zip(names,ages)):
    print (name,'is',age,'years old')

Joe is 10 years old
Amy is 11 years old
Kitty is 12 years old

zip函数可以用于任意多的序列。关于它重要的一点可以处理不等长的序列，当最短的序列“用完”的时候就会停止

（2）按索引迭代

有时想要迭代访问序列中的对象，同时还要获取当前对象的索引。例如在一个字符串列表中替换所有包含‘xxx'的子字符串。使用内建enumerate函数，这个函数在提供索引的地方迭代索引-值对。

（3）翻转和排序迭代

reversed 和sorted函数（sorted和sort使用同样的参数），作用于任何一个更加不可思议的可迭代对象上，不是原地修改对象，而是返回翻转或排序后的版本，具体用法看下面：

>>> sorted([5,2,4,1,3])
[1, 2, 3, 4, 5]
>>> list(reversed('a lovely dog!'))
['!', 'g', 'o', 'd', ' ', 'y', 'l', 'e', 'v', 'o', 'l', ' ', 'a']
>>> list(reversed([1,2,3,4,5]))
[5, 4, 3, 2, 1]
>>> ''.join(reversed('a lovely dog'))
'god ylevol a'

（5）跳出循环

1.break

跳出循环可以使用break语句。假设找100以内的最大平方数，从100往下迭代到0，找到平方数81就不用继续循环了，此时跳出循环

from math import sqrt
for n in range(99,0,-1):#第三个参数表示步长
    root =sqrt(n)
    if(root==int(root)):
        print (n)
        break

2.continue

continue语句只是让当前的循环结束，跳到下一轮循环的开始

3.while True/break习语

word='dummy '
while word :
    word = input("Please enter a word: ")
    print ("The word was "+word)

在进入循环之前需要给word赋一个哑值。使用哑值（dummy value)就是工作没有尽善尽美的标志，尽量避免它：

word=input("Please enter a word: ")
while word :
    print ("The word was "+word)
    word = input("Please enter a word: ")

这样呢，虽没有哑值，但调用两次input.不想这么做，试试 while True/break语句：

while True:
    word = input("Please enter a word: ")
    if not word:break
    print ("The word was "+word)
    

6.循环中的else 子句

当循环内使用break语句时，通常因为“找到”了某物或者因为“某事”发生了。在跳出时做一些事情很简单，比如print (n).但是有时候想要在没有跳出之前做一些事情，怎么判断呢？可以使用布尔变量，在循环前将其设定为Flase,跳出后设定为True,然后使用if语句查看循环是否跳出了：

broke_out=False
for x in seq:
    do_something(x)
    if condition(x):
        broke_out=True
        break
    do_something_else(x)
if not broke_out:
    print "I didn't broke out"

更简单的方式是在循环中加一个else 子句，仅在没有调用break 时执行

from math import sqrt
for n in range(99,0,-1):
    root = sqrt(n)
    if root==int(root):
        print (n)
        break
else :
    print ("Didn't find it")

6.列表推导式--轻量级循环

列表推导式是利用其他列表创建新列表（类似数学术语集合等式）的一种方法，它的工作类似于for循环

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

列表由range(10)中每个x的平方组成，如果只想打印被3整除数，可以使用if

>>> [x*x for x in range(10) if x%3==0]
[0, 9, 36, 81]

可以增加更多for语句部分

>>> [(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 ((x,y))

更多的for语句也可以与if 联合使用

>>> girls=['alice','berry','clarice']
>>> boys=['chris','arnold','bob']
>>> [b+'+'+g for b in boys for g in girls if b[0]==g[0]]
['chris+clarice', 'arnold+alice', 'bob+berry']