第三章 条件 循环和其他语句

3.1

print语句

（1）字符串和数值类型可以直接输出

（2）变量：无论什么类型，数值，布尔，列表，字典都可以直接输出

（3）格式化输出：

1. In [5]: s='hello'

2. In [6]: x=len(s)

3. In [7]: print("The length of %s is %d" %(s,x))

4. The length of hello is 5

%字符：标记转换说明服的开始

转换标志:-表示左对齐；+表示在转换值之前要加上正负号；""（空白字符）表示整数之前保留空格；0表示转换值若位数不够用0补充

最小字段宽度：转换后的字符串至少应该具有该值指定的宽度。如果是*,则宽度会从值元组中读出

点(.)后跟精度：如果转换的是字符串，该数字表示最大的字段宽度

1. In [9]: print("%.3s" %s)

2. hel

（4）如何让print不换行

应该写成print(x,end='')

1. In [10]: for x in range(0,10):

2. ...: print(x,end='')

3. ...:

4. 0123456789

 3.2 

赋值语句

 

运算	解释
spam='Spam'	基本形式
spam,ham = 'yum','YUM'	元组赋值运算（位置性）
[spam,ham]=['yum','YUM']	列表赋值运算（位置性）
a,b,c,d='spam'	序列赋值运算，通用性
a,b,c = [1,2,3]
a,*b = 'spam'	扩展的序列解包（Python3.0）
spam = ham = 'lunch'	多目标赋值运算
spams += 42	增强赋值运算（相当于spams = spams + 42）

-------------------------------------------------------------------------------------------------------------------------------------------------------

序列赋值

 

1. >>> nudge = 1

2. >>> wink =2

3. >>> A,B = nudge,wink

4. >>> A,B

5. (1, 2)

6. >>> [C,D] = [nudge,wink]

7. >>> C,D

8. (1, 2)

1. >>> nudge = 1

2. >>> wink =2

3. >>> nudge,wink = wink,nudge

4. >>> nudge,wink

5. (2, 1)

元组赋值语句可以得到Python中一个常用的编写代码的技巧。
因为语句执行时，Python会建立临时的元组，来存储右侧变量原始的值，分解赋值语句也是一种交换两变量的值，却不需要自行创建临时变量的方式：右侧的元组会自动记住先前的变量的值。

 

事实上，Python中原始的元组和列表赋值语句形式，最后已经被通用化，以接受右侧可以是任何类型的序列，只要长度相等即可。
你可以将含有一些值的元组赋值给含有一些变量的列表，字符串中的字符赋值给含有一些变量的元组。

 

1. >>> [a,b,c]=(1,2,3)

2. >>> a,c

3. (1, 3)

4. >>> (a,b,c)='ABC'

5. >>> a,c

6. ('A', 'C')

-------------------------------------------------------------------------------------------------------------------------------------------------------

高级序列赋值语句模式

可以赋值嵌套序列，而Python会根据其情况分解其组成部分，就像预期的一样：

1. >>> string = 'SPAM'

2. >>> (a,b),c=string[:2],string[2:]

3. >>> a,b,c

4. ('S', 'P', 'AM')

序列解包赋值语句也会产生另一种Python常见用法，也就是赋值一系列整数给一组变量。

1. >>> red,green,blue = range(3)

2. >>> red,blue

3. (0, 2)

另一个会看见元组赋值语句的地方就是，在循环中把序列分割为开头和剩余的两部分，如下：

1. >>> L=[1,2,3,4]

2. >>> while L:

3. front,L = L[0],L[1:]

4. print(front,L)

5.  
6.  

7. 1 [2, 3, 4]

8. 2 [3, 4]

9. 3 [4]

10. 4 []

-------------------------------------------------------------------------------------------------------------------------------------------------------
Python3.0中的扩展序列解包

一个带有单个星号的名称，可以在赋值目标中使用，以指定对于序列的一个更为通用的匹配——一个列表赋给了带星号的名称，该列表收集了序列中没有赋值给其他名称的所有项。对于前面示例中把序列划分为其“前面”和“剩余”部分的常用编码模式，这种方法特别方便。

扩展解包的实际应用：

a匹配序列中的第一项，b匹配剩下的内容：

 

1. >>> seq = [1,2,3,4]

2. >>> a,*b = seq

3. >>> a

4. 1

5. >>> b

6. [2, 3, 4]

b匹配序列的最后一项，a匹配最后一项之前的所有内容：

1. >>> *a,b=seq

2. >>> a

3. [1, 2, 3]

4. >>> b

5. 4

第一项和最后一项分别赋给了a和c，而b获取了二者之间的所有内容：

1. >>> a,*b,c = seq

2. >>> a,

3. (1,)

4. >>> b

5. [2, 3]

6. >>> c

7. 4

更一般的，不管带星号的名称出现在哪里，包含该位置的每个未赋值名称的一个列表都将赋给它：

1. >>> a,b,*c = seq

2. >>> a

3. 1

4. >>> b

5. 2

6. >>> c

7. [3, 4]

和常规的序列赋值一样，扩展的序列解包语法对于任何序列类型都有效，而不只是对列表有效：

1. >>> a,*b = 'spam'

2. >>> a,b

3. ('s', ['p', 'a', 'm'])

1. >>> a,*b,c = 'spam'

2. >>> a,b,c

3. ('s', ['p', 'a'], 'm')

Python3.0有了这一扩展，我们处理前面一个小节最后一个例子的列表变得容易得多了：

1. >>> L=[1,2,3,4]

2. >>> while L:

3. front,*L = L

4. print(front,L)

5.  
6.  

7. 1 [2, 3, 4]

8. 2 [3, 4]

9. 3 [4]

10. 4 []

-------------------------------------------------------------------------------------------------------------------------------------------------------
边界情况

首先，带星号的名称可能只匹配单个的项，但是，总是会向其赋值一个列表：

1. >>> seq

2. [1, 2, 3, 4]

3. >>> a,b,c,*d = seq

4. >>> print(a,b,c,d)

5. 1 2 3 [4]

其次，如果没有剩下的内容可以匹配带星号的名称，它会赋值一个空的列表，不顾该名称出现在哪里。

1. >>> a,b,c,d,*e = seq

2. >>> print(a,b,c,d,e)

3. 1 2 3 4 []

最后，如果有多个带星号的名称，或者如果值少了而没有带星号的名称，以及如果带星号的名称自身没有编写到一个列表中，都会引起错误
-------------------------------------------------------------------------------------------------------------------------------------------------------

一个有用的便利形式：常用的“第一个，其余的”分片编码模式可以用扩展的解包来编写

应用于for循环：

 

1. for(a,*b,c) in [(1,2,3,4),(5,6,7,8)]:

2. ...

当在这种环境中使用的时候，在每次迭代中，Python直接把下一个值得元组分配给名称的元组，例如，在第一次循环中，就好像我们运行如下的赋值语句：

a,*b,c = (1,2,3,4)  # b gets [2,3]

=======================================================================================
多目标赋值语句

 

多目标赋值语句就是直接把所有提供的变量名都赋值给右侧的对象：

 

1. >>> a = b = c = 'spam'

2. >>> a,b,c

3. ('spam', 'spam', 'spam')

4. >>> a is b is c

5. True

其相当于三个赋值语句：

 

1. >>> a = 'spam'

2. >>> b =a

3. >>> c = a

-------------------------------------------------------------------------------------------------------------------------------------------------------
多目标赋值以及共享引用

 

记住，这里只有一个对象，由三个变量共享（全都指向内存内同一对象）。
这种行为对于不可变类型而言并没有问题，但对于可变对象，我们就要小心一点：

 

1. >>> a = b = 0

2. >>> a += 1

3. >>> a,b

4. (1, 0)

1. >>> a = b = []

2. >>> a.append('test')

3. >>> a,b

4. (['test'], ['test'])

上例中，因为a和b引用相同的对象，通过b在原处附加值上去，而我们通过a也会看见所有的效果。

=======================================================================================
增强赋值

 

x+=y
x*=y
x%=y
x&=y
x^=y
x<<=y
x-=y
x/=y
x**=y
x|=y
x>>=y
x//=y

优点：
1.程序员输入减少
2.左侧只需计算一次。在完整形式x = x+y中，x出现两次，必须执行两次。因此，增强赋值语句通常执行得更快。
3.优化技术会自动选择。对于支持在原处修改的对象而言，增强形式会自动执行原处的修改运算，而不是相比来说速度更慢的复制。

3.3

python的代码缩进

要求严格的代码缩进是python语法的一大特色，就像C语言家族（C、C++、Java、C#等等）中的花括号一样重要，在大多数场合还有必要。

在很多代码规范里面也都有要求代码书写按照一定的规则进行换行和代码缩进，但是这些要求只是纯粹是方便人（程序员）来阅读、使用或修改的，对于编译器或者解释器而言，完全是视而不见的。但是对Python解释器而言，每行代码前的缩进都有语法和逻辑上的意义。

在实际情况中，由于代码缩进而出现语法错误或逻辑错误，一是混用tab和空格缩进，二是编辑器对缩进的处理各异。一般认为执行结果应该是显示a，实际是显示a、c，原因很简单，1个tab，python会认为是8个空格。

为了避免因代码缩进而产生不必要的麻烦，写python代码应该，使用唯一的缩进方式（要么tab，要么空格），使用固定和统一的编辑器，此外，还应该利用好编辑器的一些特性。对于notepad++而言，除了上面所说的显示空格和制表符外，还有两个特性可以使用：一是，编辑菜单下的blank operation有两个选项tab to space和space to tab，如果对上图的那段代码做tab to space，代码列对齐基本不变，箭头都变成点，但是执行结果是a；二是，在设置-首选项-语言下可以选上“以空格代替”，这样以后每次按tab键都会自动转换为空格。

3.4

Python 条件语句

由 13676692808 创建，Carrie 最后一次修改 2015-09-22

Python 条件语句

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

可以通过下图来简单了解条件语句的执行过程:

Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false。

Python 编程中 if 语句用于控制程序的执行，基本形式为：

if 判断条件：
    执行语句……
else：
    执行语句……

其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。

else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句，具体例子如下：

# coding=utf8
# 例1：if 基本用法

flag = False
name = 'luren'
if name == 'python':         # 判断变量否为'python'
    flag = True          # 条件成立时设置标志为真
    print 'welcome boss'    # 并输出欢迎信息
else:
    print name              # 条件不成立时输出变量名称

输出结果为：

>>> luren         # 输出结果

if 语句的判断条件可以用>（大于）、=（大于等于）、<=（小于等于）来表示其关系。

当判断条件为多个值是，可以使用以下形式：

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

实例如下：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 例2：elif用法
 
num = 5     
if num == 3:            # 判断num的值
    print 'boss'        
elif num == 2:
    print 'user'
elif num == 1:
    print 'worker'
elif num < 0:           # 值小于零时输出
    print 'error'
else:
    print 'roadman'     # 条件均不成立时输出

输出结果为：

>>> roadman     # 输出结果

由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 例3：if语句多个条件

num = 9
if num >= 0 and num <= 10:    # 判断值是否在0~10之间
    print 'hello'
>>> hello		# 输出结果

num = 10
if num < 0 or num > 10:    # 判断值是否在小于0或大于10
    print 'hello'
else:
	print 'undefine'
>>> undefine		# 输出结果

num = 8
# 判断值是否在0~5或者10~15之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):    
    print 'hello'
else:
    print 'undefine'
>>> undefine		# 输出结果

 

当if有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于>（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。

简单的语句组

你也可以在同一行的位置上使用if条件判断语句，如下实例：

 

#!/usr/bin/python 
# -*- coding: UTF-8 -*-
 
var = 100 
 
if ( var  == 100 ) : print "变量 var 的值为100" 
 
print "Good bye!"

 

以上代码执行输出结果如下：

 

变量 var 的值为100
Good bye!

3.5

Python3 循环语句

本章节将为大家介绍Python循环语句的使用。

Python中的循环语句有 for 和 while。

Python循环语句的控制结构图如下所示：

---

while 循环

Python中while语句的一般形式：

while 判断条件：
    语句

执行 Gif 演示：

同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环。

以下实例使用了 while 来计算 1 到 100 的总和：

实例

#!/usr/bin/env python3 n = 100 sum = 0 counter = 1 while counter <= n: sum = sum + counter counter += 1 print("1 到 %d 之和为: %d" % (n,sum))

执行结果如下：

1 到 100 之和为: 5050

无限循环

我们可以通过设置条件表达式永远不为 false 来实现无限循环，实例如下：

实例

#!/usr/bin/python3 var = 1 while var == 1 : # 表达式永远为 true num = int(input("输入一个数字 :")) print ("你输入的数字是: ", num) print ("Good bye!")

执行以上脚本，输出结果如下：

输入一个数字  :5
你输入的数字是:  5
输入一个数字  :

你可以使用 CTRL+C 来退出当前的无限循环。

无限循环在服务器上客户端的实时请求非常有用。

while 循环使用 else 语句

在 while … else 在条件语句为 false 时执行 else 的语句块：

实例

#!/usr/bin/python3 count = 0 while count < 5: print (count, " 小于 5") count = count + 1 else: print (count, " 大于或等于 5")

执行以上脚本，输出结果如下：

0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5

简单语句组

类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中， 如下所示：

实例

#!/usr/bin/python flag = 1 while (flag): print ('欢迎访问菜鸟教程!') print ("Good bye!")

注意：以上的无限循环你可以使用 CTRL+C 来中断循环。

执行以上脚本，输出结果如下：

欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
……

---

for 语句

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

for循环的一般格式如下：

for <variable> in <sequence>: <statements> else: <statements>

Python loop循环实例：

实例

>>>languages = ["C", "C++", "Perl", "Python"] >>> for x in languages: ... print (x) ... C C++ Perl Python >>>

以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体：

实例

#!/usr/bin/python3 sites = ["Baidu", "Google","Runoob","Taobao"] for site in sites: if site == "Runoob": print("菜鸟教程!") break print("循环数据 " + site) else: print("没有循环数据!") print("完成循环!")

执行脚本后，在循环到 "Runoob"时会跳出循环体：

循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!

---

range()函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

实例

>>>for i in range(5): ... print(i) ... 0 1 2 3 4

你也可以使用range指定区间的值：

实例

>>>for i in range(5,9) : print(i) 5 6 7 8 >>>

也可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长'):

实例

>>>for i in range(0, 10, 3) : print(i) 0 3 6 9 >>>

负数：

实例

>>>for i in range(-10, -100, -30) : print(i) -10 -40 -70 >>>

您可以结合range()和len()函数以遍历一个序列的索引,如下所示:

实例

>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ'] >>> for i in range(len(a)): ... print(i, a[i]) ... 0 Google 1 Baidu 2 Runoob 3 Taobao 4 QQ >>>

还可以使用range()函数来创建一个列表：

实例

>>>list(range(5)) [0, 1, 2, 3, 4] >>>

---

break和continue语句及循环中的else子句

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 实例如下：

实例

#!/usr/bin/python3 for letter in 'Runoob': # 第一个实例 if letter == 'b': break print ('当前字母为 :', letter) var = 10 # 第二个实例 while var > 0: print ('当期变量值为 :', var) var = var -1 if var == 5: break print ("Good bye!")

执行以上脚本输出结果为：

当前字母为 : R
当前字母为 : u
当前字母为 : n
当前字母为 : o
当前字母为 : o
当期变量值为 : 10
当期变量值为 : 9
当期变量值为 : 8
当期变量值为 : 7
当期变量值为 : 6
Good bye!

continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

实例

#!/usr/bin/python3 for letter in 'Runoob': # 第一个实例 if letter == 'o': # 字母为 o 时跳过输出 continue print ('当前字母 :', letter) var = 10 # 第二个实例 while var > 0: var = var -1 if var == 5: # 变量为 5 时跳过输出 continue print ('当前变量值 :', var) print ("Good bye!")

执行以上脚本输出结果为：

当前字母 : R
当前字母 : u
当前字母 : n
当前字母 : b
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
当前变量值 : 4
当前变量值 : 3
当前变量值 : 2
当前变量值 : 1
当前变量值 : 0
Good bye!

循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。

如下实例用于查询质数的循环例子:

实例

#!/usr/bin/python3 for n in range(2, 10): for x in range(2, n): if n % x == 0: print(n, '等于', x, '*', n//x) break else: # 循环中没有找到元素 print(n, ' 是质数')

执行以上脚本输出结果为：

2  是质数
3  是质数
4 等于 2 * 2
5  是质数
6 等于 2 * 3
7  是质数
8 等于 2 * 4
9 等于 3 * 3

---

pass 语句

Python pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句，如下实例

实例

>>>while True: ... pass # 等待键盘中断 (Ctrl+C)

最小的类:

实例

>>>class MyEmptyClass: ... pass

以下实例在字母为 o 时 执行 pass 语句块:

实例

#!/usr/bin/python3 for letter in 'Runoob': if letter == 'o': pass print ('执行 pass 块') print ('当前字母 :', letter) print ("Good bye!")

执行以上脚本输出结果为：

当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye！

转载于:https://my.oschina.net/u/4162318/blog/3080733