python保留两位小数_全国青少年软件编程python二级（12.6备考）

数据类型

1.列表(List)

列表的访问

下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符

list1 = ['physics', 'chemistry', 1997, 2000]print ("list1[0]: ", list1[0])#下标从0开始访问，倒序访问从-1开始print ("list1[1:4]: ", list1[1:4])#切片不包括右边端点print("list1[::-1]: ", list1[::])#默认不写从头到尾print("list1[::-1]: ", list1[::-1])print("list1[1:]: ", list1[1:])print("list1[:2]: ", list1[:2])

#结果如下：list1[0]:  physicslist1[1:4]:  ['chemistry', 1997, 2000]list1[::-1]:  ['physics', 'chemistry', 1997, 2000]list1[::-1]:  [2000, 1997, 'chemistry', 'physics']list1[1:]:  ['chemistry', 1997, 2000]list1[:2]:  ['physics', 'chemistry']

更新列表

list = []          ## 空列表list.append('Google')   ## 使用 append() 添加元素list.append('Runoob')print list

#结果如下：['Google', 'Runoob']

删除列表元素

list1 = ['physics', 'chemistry', 1997, 2000]print (list1)del list1[2]print "After deleting value at index 2 : "print (list1)list2=["a","b","c","d"]del list2[2:4]print(list2)

#结果如下：['physics', 'chemistry', 1997, 2000]After deleting value at index 2 :['physics', 'chemistry', 2000]['a', 'b']

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表 中
for x in [1, 2, 3]: print x,	1 2 3	迭代
for i in range(0,len(list1)):print(list1[i])		依次打印访问的元素

Python列表函数&方法

Python包含以下函数:

序号	函数
1	len(list) 列表元素个数
2	max(list) 返回列表元素最大值
3	min(list) 返回列表元素最小值
4	list(seq) 将元组转换为列表，将字符串转列表，将range(1,11)转列表

Python包含以下方法:

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
4	list.insert(index, obj) 将对象插入列表
5	list.pop([index=-1]) 移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
6	list.remove(obj) 移除列表中某个值的第一个匹配项
7	list.reverse() 反向列表中元素
9	list.sort(cmp=None, key=None, reverse=False) 对原列表进行永久性排序，默认从小到大，从大到小可设reverse=True
10	sorted(list, reverse=False)对原列表进行临时性排序，默认从小到大，从大到小可设reverse=True

2.元组(tuple)

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = ('physics', 'chemistry', 1997, 2000)

创建空元组

tup1=()

元组中只包含一个元素时，需要在元素后面添加逗号

tup1=(50,)

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup1 = ('physics', 'chemistry', 1997, 2000)tup2 = (1, 2, 3, 4, 5, 6, 7 ) print "tup1[0]: ", tup1[0]print "tup2[1:5]: ", tup2[1:5]

tup1[0]:  physics
tup2[1:5]:  (2, 3, 4, 5)

tup1 = (12, 34.56)

tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。# tup1[0] = 100 # 创建一个新的元组tup3 = tup1 + tup2

print (tup3)

(12, 34.56, 'abc', 'xyz')

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tup = ('physics', 'chemistry', 1997, 2000)print (tup)

del tup

print( "After deleting tup : ")

print (tup)

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

('physics', 'chemistry', 1997, 2000)After deleting tup :Traceback (most recent call last):File "test.py", line 9, in print tupNameError: name 'tup' is not defined

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print x,	1 2 3	迭代

---

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

L = ('spam', 'Spam', 'SPAM!')

Python 表达式	结果	描述
L[2]	'SPAM!'	读取第三个元素
L[-2]	'Spam'	反向读取，读取倒数第二个元素
L[1:]	('Spam', 'SPAM!')	截取元素

---

无关闭分隔符

任意无符号的对象，以逗号隔开，默认为元组，如下实例：

x, y = 1, 2

print ("Value of x , y : ", x,y)

以上实例运行结果：

Value of x , y : 1 2

---

元组内置函数

Python元组包含了以下内置函数

序号	方法及描述
1	len(tuple) 计算元组元素个数。
2	max(tuple) 返回元组中元素最大值。
3	min(tuple) 返回元组中元素最小值。
4	tuple(seq) 将列表转换为元组,将字符串转元组。

字符串(str)

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "Python Runoob"

---

Python 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号来截取字符串，如下实例：

var1 = 'Hello World!'

var2 = "Python Runoob" 

print ("var1[0]: ", var1[0])

print( "var2[1:5]: ", var2[1:5])

以上实例执行结果：

var1[0]:  H
var2[1:5]:  ytho

---

Python 字符串连接

我们可以对字符串进行截取并与其他字符串进行连接，如下实例：

 var1 = 'Hello World!' 

print ("输出 :- ", var1[:6] + 'Runoob!')

以上实例执行结果

输出 :-  Hello Runoob!

Python字符串运算符

下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：

操作符	描述	实例
+	字符串连接	>>>a + b 'HelloPython'
*	重复输出字符串	>>>a * 2 'HelloHello'
[]	通过索引获取字符串中字符	>>>a[1] 'e'
[ : ]	截取字符串中的一部分	>>>a[1:4] 'ell'
in	成员运算符 - 如果字符串中包含给定的字符返回 True	>>>"H" in a True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	>>>"M" not in a True
%	格式字符串

a = "Hello"

b = "Python"

print ("a + b 输出结果：", a + b )

print ("a * 2 输出结果：", a * 2 )

print ("a[1] 输出结果：", a[1] )

print( "a[1:4] 输出结果：", a[1:4])

if( "H" in a) :    

    print "H 在变量 a 中"

else :    

    print "H 不在变量 a 中" 

if( "M" not in a) :    

    print "M 不在变量 a 中" 

else :    

    print "M 在变量 a 中" 

以上程序执行结果为：

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中

---

Python 字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

如下实例：

print "My name is %s and weight is %d kg!" % ('Zara', 21) 

以上实例输出结果：

My name is Zara and weight is 21 kg!

python 字符串格式化符号:

符   号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数(大写)
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数

---

python的字符串内建函数

字符串方法是从python1.6到2.0慢慢加进来的——它们也被加到了Jython中。

这些方法实现了string模块的大部分方法，如下表所示列出了目前字符串内建支持的方法，所有的方法都包含了对Unicode的支持，有一些甚至是专门用于Unicode的。

方法	描述
string.capitalize()	把字符串的第一个字符大写
string.count(str, beg=0, end=len(string))	返回 str 在 string 里面出现的次数， 如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中， 如果 beg 和 end 指定范围， 则检查是否包含在指定范围内， 如果是返回开始的索引值，否则返回-1
string.format()	格式化字符串
string.index(str, beg=0, end=len(string))	跟find()方法一样， 只不过如果str不在 string中会报一个异常.
string.join(seq)	以 string 作为分隔符， 将 seq 中所有的元素(的字符串表示) 合并为一个新的字符串
string.lower()	转换 string 中所有大写字符为小写.
string.lstrip()	截掉 string 左边的空格
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
string.replace(str1, str2,  num=string.count(str1))	把 string 中的 str1 替换成 str2, 如果 num 指定，则替换不超过 num 次.
string.rstrip()	删除 string 字符串末尾的空格.
string.split(str="", num=string.count(str))	以 str 为分隔符切片 string， 如果 num 有指定值， 则仅分隔 num+ 个子字符串
string.strip([obj])	在 string 上执行 lstrip()和 rstrip()
string.title()	返回"标题化"的 string, 就是说所有单词都是以大写开始， 其余字母均为小写(见 istitle())
string.upper()	转换 string 中的小写字母为大写

 字典(dict)

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

>>> dict = {'a': 1, 'b': 2, 'b': '3'}>>> dict['b']'3'>>> dict{'a': 1, 'b': '3'}

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

也可如此创建字典：

dict1 = { 'abc': 456 }

dict2 = { 'abc': 123, 98.6: 37 }

---

访问字典里的值

把相应的键放入熟悉的方括弧，如下实例:

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} 

print( "dict['Name']: ", dict['Name'])

print ("dict['Age']: ", dict['Age'])

以上实例输出结果：

dict['Name']:  Zara
dict['Age']:  7

如果用字典里没有的键访问数据，会输出错误如下：

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} 

print ("dict['Alice']: ", dict['Alice'])

以上实例输出结果：

dict['Alice']: Traceback (most recent call last):File "test.py", line 5, in print "dict['Alice']: ", dict['Alice']KeyError: 'Alice'

---

修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

 dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} 

dict['Age'] = 8 # 更新

dict['School'] = "RUNOOB" # 添加 

print ("dict['Age']: ", dict['Age'])

print ("dict['School']: ", dict['School'])

以上实例输出结果：

dict['Age']:  8
dict['School']:  RUNOOB

---

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} 

del dict['Name']  # 删除键是'Name'的条目

dict.clear()      # 清空字典所有条目

del dict          # 删除字典 

print ("dict['Age']: ", dict['Age'])

print( "dict['School']: ", dict['School'])

但这会引发一个异常，因为用del后字典不再存在：

dict['Age']:Traceback (most recent call last):File "test.py", line 8, in print "dict['Age']: ", dict['Age'] TypeError: 'type' object is unsubscriptable

注：del()方法后面也会讨论。

字典键的特性

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1)不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'} 

print ("dict['Name']: ", dict['Name'])

以上实例输出结果：

dict['Name']:  Manni

2)键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：

 dict = {['Name']: 'Zara', 'Age': 7} 

print ("dict['Name']: ", dict['Name'])

以上实例输出结果：

Traceback (most recent call last):File "test.py", line 3, in 
    dict = {['Name']: 'Zara', 'Age': 7} TypeError: list objects are unhashable

---

字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述
1	len(dict) 计算字典元素个数，即键的总数。
2	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

Python字典包含了以下内置方法：

序号	函数及描述
1	dict.clear() 删除字典内所有元素
2	dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
3	dict.items() 以列表返回可遍历的(键, 值) 元组数组
4	dict.keys() 以列表返回一个字典所有的键
5	dict.values() 以列表返回字典中的所有值
6	pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
7	popitem() 返回并删除字典中的最后一对键和值。

 集合(set)

集合(set)是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}或者set(value)

实例(Python 3.0+)

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}>>> print(basket)                      # 这里演示的是去重功能{'orange', 'banana', 'pear', 'apple'}>>> 'orange' in basket                 # 快速判断元素是否在集合内True>>> 'crabgrass' in basketFalse>>> # 下面展示两个集合间的运算.
...>>> a = set('abracadabra')>>> b = set('alacazam')>>> a                                  {'a', 'r', 'b', 'c', 'd'}>>> a - b                              # 集合a中包含而集合b中不包含的元素{'r', 'd', 'b'}>>> a | b                              # 集合a或b中包含的所有元素{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}>>> a & b                              # 集合a和b中都包含了的元素{'a', 'c'}>>> a ^ b                              # 不同时包含于a和b的元素{'r', 'd', 'b', 'm', 'z', 'l'}

类似列表推导式，同样集合支持集合推导式(Set comprehension):

实例(Python 3.0+)

>>> a = {x for x in 'abracadabra' if x not in 'abc'}>>> a{'r', 'd'}

---

集合的基本操作

1、添加元素

语法格式如下：

s.add( x )

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.add("Facebook")>>> print(thisset){'Taobao', 'Facebook', 'Google', 'Runoob'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x )

x 可以有多个，用逗号分开。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.update({1,3})>>> print(thisset){1, 3, 'Google', 'Taobao', 'Runoob'}>>> thisset.update([1,4],[5,6])  >>> print(thisset){1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}>>>

2、移除元素

语法格式如下：

s.remove( x )

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.remove("Taobao")>>> print(thisset){'Google', 'Runoob'}>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "", line 1, in <module>KeyError: 'Facebook'>>>

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.discard("Facebook")  # 不存在不会发生错误>>> print(thisset){'Taobao', 'Google', 'Runoob'}

我们也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop() 

脚本模式实例(Python 3.0+)

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()print(x)

输出结果：

$ python3 test.py Runoob

多次执行测试结果都不一样。

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

3、计算集合元素个数

语法格式如下：

len(s)

计算集合 s 元素个数。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> len(thisset)3

4、清空集合

语法格式如下：

s.clear()

清空集合 s。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.clear()>>> print(thisset)set()

5、判断元素是否在集合中存在

语法格式如下：

x in s

判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> "Runoob" in thissetTrue>>> "Facebook" in thissetFalse>>>

集合内置方法完整列表

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
pop()	随机移除元素
remove()	移除指定元素

Python3 条件控制

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

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

代码执行过程：

---

if 语句

Python中if语句的一般形式如下所示：

if condition_1:    

    statement_block_1

elif condition_2:   

     statement_block_2

else:   

     statement_block_3

• 如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句

• 如果 "condition_1" 为False，将判断 "condition_2"

• 如果"condition_2" 为 True 将执行 "statement_block_2" 块语句

• 如果 "condition_2" 为False，将执行"statement_block_3"块语句

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

注意：

• 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。

• 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。

• 3、在Python中没有switch – case语句。

实例

以下是一个简单的 if 实例：

var1 = 100

if var1:  

    print ("1 - if 表达式条件为 true")   

    print (var1) 

var2 = 0

if var2:    

    print ("2 - if 表达式条件为 true")   

    print (var2)

print ("Good bye!")

执行以上代码，输出结果为：

1 - if 表达式条件为 true

100

Good bye!

从结果可以看到由于变量 var2 为 0，所以对应的 if 内的语句没有执行。

以下实例演示了狗的年龄计算判断：

age = int(input("请输入你家狗狗的年龄: "))

print("")

if age <= 0:    

    print("你是在逗我吧!")

elif age == 1:    

    print("相当于 14 岁的人。")

elif age == 2:    

    print("相当于 22 岁的人。")

elif age > 2:    

    human = 22 + (age -2)*5    

    print("对应人类年龄: ", human) ### 退出提示

input("点击 enter 键退出")

将以上脚本保存在dog.py文件中，并执行该脚本：

$ python3 dog.py 

请输入你家狗狗的年龄: 1

相当于 14 岁的人。

点击 enter 键退出

以下为if中常用的操作运算符:

操作符	描述
<	小于
<=	小于或等于
>	大于
>=	大于或等于
==	等于，比较两个值是否相等
!=	不等于

print(5 == 6)# 使用变量

x = 5

y = 8

print(x == y)

以上实例输出结果：

False

False

high_low.py文件演示了数字的比较运算：

 # 该实例演示了数字猜谜游戏

number = 7

guess = -1

print("数字猜谜游戏!")

while guess != number:    

    guess = int(input("请输入你猜的数字："))  

     if guess == number:     

         print("恭喜，你猜对了！")  

     elif guess < number:      

         print("猜的数字小了...")  

     elif guess > number:      

         print("猜的数字大了...")

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

$ python3 high_low.py 

数字猜谜游戏!

请输入你猜的数字：1

猜的数字小了...

请输入你猜的数字：9

猜的数字大了...

请输入你猜的数字：7

恭喜，你猜对了！

---

if 嵌套

在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。

if 表达式1:语句if 表达式2:语句elif 表达式3:语句else:语句elif 表达式4:语句else:语句

num=int(input("输入一个数字："))

if num%2==0:   

    if num%3==0:     

       print ("你输入的数字可以整除 2 和 3")   

     else:       

     print ("你输入的数字可以整除 2，但不能整除 3")

else:    

    if num%3==0:        

        print ("你输入的数字可以整除 3，但不能整除 2")    

    else:       

         print  ("你输入的数字不能整除 2 和 3")

将以上程序保存到 test_if.py 文件中，执行后输出结果为：

$ python3 test.py 

输入一个数字：6

你输入的数字可以整除 2 和 3

Python3 循环语句

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

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

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

---

while 循环

Python 中 while 语句的一般形式：

while 判断条件(condition)：执行语句(statements)……

执行流程图如下：

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

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

 n = 100 

sum = 0

counter = 1

while counter <= n:    

    sum = sum + counter  

     counter += 1

print("1 到 %d 之和为: %d" % (n,sum))

执行结果如下：

1 到 100 之和为: 5050

无限循环

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

var = 1

while var == 1 :  # 表达式永远为 true   

    num = int(input("输入一个数字  :"))   

    print ("你输入的数字是: ", num) 

print ("Good bye!")

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

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

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

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

while 循环使用 else 语句

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

语法格式如下：

while :<statement(s)>else:<additional_statement(s)>

循环输出数字，并判断大小：

count = 0

while count < 5:   

    print (count, " 小于 5")  

    count = count + 1

else:   

print (count, " 大于或等于 5")

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

0  小于 51  小于 52  小于 53  小于 54  小于 55  大于或等于 5

简单语句组

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

 flag = 1 

while (flag): 

    print ('欢迎访问菜鸟教程!')

 print ("Good bye!")

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

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

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

---

for 语句

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

for循环的一般格式如下：

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

流程图：

Python for 循环实例：

实例

>>>languages = ["C", "C++", "Perl", "Python"] 

>>> for x in languages:

...     print (x)... 

C

C++

Perl

Python

>>>

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

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 执行流程图：

continue 执行流程图：

while 语句代码执行过程：

for 语句代码执行过程：

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

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

实例

while 中使用 break：

实例

n = 5while n > 0:
    n -= 1if n == 2:breakprint(n)print('循环结束。')

输出结果为：

43循环结束。

while 中使用 continue：

实例

n = 5while n > 0:
    n -= 1if n == 2:continueprint(n)print('循环结束。')

输出结果为：

4310循环结束。

更多实例如下：

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当期变量值为 : 6Good bye!

以下实例循环字符串 Runoob，碰到字母 o 跳过输出：

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当前变量值 : 0Good bye!

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

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

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 * 25  是质数6 等于 2 * 37  是质数8 等于 2 * 49 等于 3 * 3

---

pass 语句

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

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

实例

>>>while True:

...     pass  # 等待键盘中断 (Ctrl+C)

最小的类:

实例

>>>class MyEmptyClass: ...     pass

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

for letter in 'Runoob': 

  if letter == 'o':      

        pass      

        print ('执行 pass 块')  

    print ('当前字母 :', letter) 

print ("Good bye!")

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

当前字母 : R当前字母 : u当前字母 : n执行 pass 块当前字母 : o执行 pass 块当前字母 : o当前字母 : bGood bye!

format 格式化函数

一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。

实例

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序

'hello world' 

>>> "{0} {1}".format("hello", "world")  # 设置指定位置

'hello world' 

>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置

'world hello world'

也可以设置参数：

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com")) # 通过字典设置参数

site = {"name": "菜鸟教程", "url": "www.runoob.com"}

print("网站名：{name}, 地址 {url}".format(**site)) # 通过列表索引设置参数my_list = ['菜鸟教程', 'www.runoob.com']

print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

输出结果为：

网站名：菜鸟教程, 地址 www.runoob.com网站名：菜鸟教程, 地址 www.runoob.com网站名：菜鸟教程, 地址 www.runoob.com

数字格式化

下表展示了 str.format() 格式化数字的多种方法：

>>> print("{:.2f}".format(3.1415926));3.14

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)
11	'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)	1011 11 13 b 0xb 0XB	进制

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -；  (空格)表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号，如下实例：

print ("{} 对应的位置是 {{0}}".format("runoob"))

输出结果为：

runoob 对应的位置是 {0}