Python流程控制

Python 同样提供了现代编程语言都支持的两种基本流程控制结构，分支结构和循环结构：

• 分支结构用于实现根据条件来选择性地执行某段代码；
• 循环结构用于实现根据循环条件重复执行某段代码；

Python 使用 if 语句提供分支支持，提供了 while、 for-in 循环，也提供了 break 和 continue 控制程序的循环结构。

 

if  判断语句：

[root@kube control]# cat demo.py 
#coding:utf-8

s_age = input('you age number:')
age = int(s_age)

if age > 20:           # : 分号表示一个代码块的开始，代码块必须有内容否则报错 
        print('you age > 20,you know')             #缩进是标识python 代码块的非常重要的东西，不能随意缩进
[root@kube control]# py demo.py 
you age number:22
you age > 20,you know
[root@kube control]# py demo.py 
you age number:11
[root@kube control]# 

 

 if else   判断语句：

[root@kube control]# cat demo.py 
#coding:utf-8

s_age = input('you age number:')
age = int(s_age)

if age > 20:
        print('you age > 20,you know')
else:          # else也要用 ： 起始
        print('you age <20 ,you know')

[root@kube control]# py demo.py 
you age number:22
you age > 20,you know
[root@kube control]# py demo.py 
you age number:11
you age <20 ,you know
[root@kube control]# 

 

 

 

if 表达式真假值的判断方法

从前面的示例可以看到，Python 执行 if 语句时，会判断 if 表达式的值是 True 还是 False 。那么是不是只能使用 bool 类型的表达式呢？

不是。表达式可以是任意类型，当下面的值作为 bool 表达式时，会被解释器当作 False 处理：

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

从上面介绍可以看出，除了 False 本身，各种代表“空”的 None、空字符串、空元组、空列表、空字典都会被当成 False 处理。

[root@kube control]# cat demo1.py 
a = ''
if a :
        print('a is not  none string')
else:
        print('a is none string')

b = {}
if b :
        print('b is  not  none string')
else:
        print('b is none string')

[root@kube control]# py demo1.py 
a is none string
b is none string
[root@kube control]# 

 

 

 if 语句嵌套：   

[root@kube control]# cat demo2.py 
#coding:utf-8

num = int(input('you test score:'))

if num > 80:
        print('you Good!!!')
else:
        if 60  < num < 80 :             #if  语句嵌套最重要的就是缩进，确认每个代码块的分界
                print('you Bad!!!!')
        else:
                print('you so bad!!!')

[root@kube control]# py demo2.py 
you test score:88
you Good!!!
[root@kube control]# py demo2.py 
you test score:78
you Bad!!!!
[root@kube control]# py demo2.py 
you test score:56
you so bad!!!
[root@kube control]# 

 

 

 很多程序都提供了“空语句”支持，Python 也不例外，Python 的 pass 语句就是空语句。

有时候程序需要占一个位、放一条语句，但又不希望这条语句做任何事情，此时就可通过 pass 语句来实现。通过使用 pass 语句，可以让程序更完整。

如下程序示范了 pass 作为空语句的用法：

[root@kube control]# cat demo3.py 
#coding:utf-8

num = int(input('you test score:'))

if num > 80 :
        pass
else:
        print('you so bad')
[root@kube control]# py demo3.py 
you test score:88
[root@kube control]# py demo3.py 
you test score:55
you so bad
[root@kube control]# 

 

 

 

Python assert断言函数及用法

assert 断言语句和 if 分支有点类似，它用于对一个 bool 表达式进行断言，如果该 bool 表达式为 True，该程序可以继续向下执行；否则程序会引发 AssertionError 错误。

有读者可能会问，明明 assert 会令程序崩溃，为什么还要使用它呢？这是因为，与其让程序在晚些时候崩溃，不如在错误条件出现时，就直接让程序崩溃。通常，assert 语句用在检查函数参数的属性（是参数是否是按照设想的要求传入），或者作为初期测试和调试过程中的辅助工具。

[root@kube control]# cat demo4.py 
#coding:utf-8

s_age = int(input('you age num:'))

assert  20 < s_age < 80              #assert 的作用就是出现不符合预期的情况就中断程序的执行
print('you age is range 20 - 80')

[root@kube control]# py demo4.py 
you age num:56
you age is range 20 - 80
[root@kube control]# py demo4.py 
you age num:11
Traceback (most recent call last):
  File "demo4.py", line 5, in 
    assert  20 < s_age < 80
AssertionError
[root@kube control]# 

 

 

[root@kube control]# cat demo5.py 
#coding:utf-8


#price 为原价，discount 为折扣力度
def apply_discount(price, discount):         #定义一个价格和折扣力度的函数
    updated_price = price * (1 - discount)    #计算折扣后的价格  
    assert 0 <= updated_price <= price        #assert 判断是否在合理区间，合理就就继续执行，返回折扣价格，不合理就assert 退出
#'折扣价应在 0 和原价之间'
    return updated_price
print(apply_discount(100,0.2))
print(apply_discount(100,1.1))
[root@kube control]# py demo5.py 
80.0
Traceback (most recent call last):
  File "demo5.py", line 11, in 
  File "demo5.py", line 7, in apply_discount
AssertionError
[root@kube control]# 

 

 

 

Python while ，for 循环语句详解

 

Python中for循环和while循环本质上是没有区别的，但是在实际应用上，针对性不太一样。
while循环适用于未知循环次数的循环，for循环适用于已知循环次数的循环 。

while 语句执行的具体流程为：首先判断条件表达式的值，其值为真（True）时，则执行代码块中的语句，当执行完毕后，再回过头来重新判断条件表达式的值是否为真，若仍为真，则继续重新执行代码块...如此循环，直到条件表达式的值为假（False），才终止循环。

 

[root@kube control]# cat demo6.py 
#coding:utf-8

# while  cycle test

num = 1
while num < 10:                     #while 循环要注意循环体的结束，不能无限循环了,给定结束循环的条件，都用: 号开始代码块
        print(num)
        num += 1                      
print('while cycle end!')
[root@kube control]# py demo6.py 
1
2
3
4
5
6
7
8
9
while cycle end!
[root@kube control]# 

[root@kube control]# cat demo6.py 
#coding:utf-8

# while  cycle test

num = 1
while num < 10:
        print(num,'\t',end='|')          #换一个输出方法
        num += 1
print('while cycle end!')
[root@kube control]# py demo6.py 
1       |2      |3      |4      |5      |6      |7      |8      |9      |while cycle end!
[root@kube control]# 

 

 

使用while循环遍历列表和元组

由于列表和元组的元素都是有索引的，因此程序可通过 while 循环、列表或元组的索引来遍历列表和元组中的所有元素。

[root@kube control]# cat demo7.py 
#coding:utf-8

a_tuple = ('tom','jojo','zela','bob')             #定义一个元组

i = 0                                            #定义 i = 0  ，是因为通过索引来获取元素是从0 开始的
print(len(a_tuple))                              #长度为4

while i < len(a_tuple) :                         #获取长度是从1 开始，那么索引0 对应第一个值，索引比len 小1 
        print(a_tuple[i])
        i += 1

print('while cycle end!')
[root@kube control]# py demo7.py 
4
tom
jojo
zela
bob
while cycle end!
[root@kube control]# 

 

 

 

[root@kube control]# cat demo8.py 
#coding:utf-8
#使用了pop() 函数和 append 的函数将匹配的元素添加到新的列表中
src_list = [12, 45, 34,13, 100, 24, 56, 74, 109]
a_list = [] # 定义保存整除3的元素
b_list = [] # 定义保存除以3余1的元素
c_list = [] # 定义保存除以3余2的元素
# 只要src_list还有元素，继续执行循环体
while len(src_list) > 0:
    # 弹出src_list最后一个元素
    ele = src_list.pop()
    # 如果ele % 2不等于0
    if ele % 3 == 0 :
        a_list.append(ele) # 添加元素
    elif ele % 3 == 1:
        b_list.append(ele) # 添加元素
    else:
        c_list.append(ele) # 添加元素
print(" %3:", a_list)
print(" %3 - 1:",b_list)
print(" %3 - 2:",c_list)
[root@kube control]# py demo8.py 
 %3: [24, 45, 12]
 %3 - 1: [109, 100, 13, 34]
 %3 - 2: [74, 56]
[root@kube control]#           

 

Python for循环及用法详解

Python 中的循环语句有 2 种，分别是 while 循环和 for 循环，前面章节已经对 while 做了详细的讲解，本节给大家介绍 for 循环，它常用于遍历字符串、列表、元组、字典、集合等序列类型，逐个获取序列中的各个元素。

for 循环的语法格式如下：
for 迭代变量 in 字符串|列表|元组|字典|集合：
    代码块

[root@kube control]# cat demo10.py 
#coding:utf-8

result = 0

for i in range(101):              #for 循环遍历range 函数的值，使用 += 累加 0-100 的和
        result += i

print('result =',result)
[root@kube control]# py demo10.py 
result = 5050
[root@kube control]# 

Python循环结构中else用法

Python 中，无论是 while 循环还是 for 循环，其后都可以紧跟着一个 else 代码块，它的作用是，当循环条件为 False 跳出循环时，程序会最先执行 else 代码块中的代码。

循环的 else 代码块是 Python 的一个很特殊的语法（其他编程语言通常不支持），else 代码块的主要作用是便于生成更优雅的 Python 代码。

[root@kube control]# cat demo10.py 
#coding:utf-8

result = 0

for i in range(101):
        result += i
else:
        print('result =',result)
[root@kube control]# py demo10.py 
result = 5050
[root@kube control]# 

Python（for和while）循环嵌套及用法

Python 程序中，如果把一个循环放在另一个循环体内，那么就可以形成循环嵌套。循环嵌套既可以是 for 循环嵌套 while 循环，也可以是 while 循环嵌套 for 循环，即各种类型的循环都可以作为外层循环，各种类型的循环也都可以作为内层循环。

当程序遇到循环嵌套时，如果外层循环的循环条件允许，则开始执行外层循环的循环体，而内层循环将被外层循环的循环体来执行（只是内层循环需要反复执行自己的循环体而己）。只有当内层循环执行结束且外层循环的循环体也执行结束时，才会通过判断外层循环的循环条件，决定是否再次开始执行外层循环的循环体。

根据上面分析，假设外层循环的循环次数为 n 次，内层循环的循环次数为 m 次，那么内层循环的循环体实际上需要执行 n × m 次

 

[root@kube control]# cat demo11.py 
#coding:utf-8

for i in range(4):                        
        j = 0        
        while j < 3:                  #嵌套循环需要注意循环退出的条件
                print("i value: %d,j value: %d "  % (i ,j))      #%d  十进制整数格式化
                j += 1

else:
        print("cycle end !")
[root@kube control]# py demo11.py 
i value: 0,j value: 0 
i value: 0,j value: 1 
i value: 0,j value: 2 
i value: 1,j value: 0 
i value: 1,j value: 1 
i value: 1,j value: 2 
i value: 2,j value: 0 
i value: 2,j value: 1 
i value: 2,j value: 2 
i value: 3,j value: 0 
i value: 3,j value: 1 
i value: 3,j value: 2 
cycle end !
[root@kube control]# 

 

  .

Python嵌套循环实现冒泡排序

冒泡排序是数据结构中的经典算法，手动实现冒泡排序，对初学者锻炼自己的编程逻辑有很大帮助，本节就带领大家使用循环结构实现冒泡排序算法。

冒泡排序算法的实现思想遵循以下几步：
比较相邻的元素，如果第一个比第二个大，就交换它们两个。
从最开始的第一对到结尾的最后一对，对每一对相邻元素做步骤 1 所描述的比较工作，并将最大的元素放在后面。这样，当从最开始的第一对到结尾的最后一对都执行完后，整个序列中的最后一个元素便是最大的数。
将循环缩短，除去最后一个数（因为最后一个已经是最大的了），再重复步骤 2 的操作，得到倒数第二大的数。
持续做步骤 3 的操作，每次将循环缩短一位，并得到本次循环中的最大数。直到循环个数缩短为 1，即没有任何一对数字需要比较，此时便得到了一个从小到大排序的序列。

通过分析冒泡排序算法的实现原理，要想实现该算法，需要借助循环结构，更确切地说，需要使用嵌套循环结构，使用 for 循环或者 while 循环都可以。

 

 

[root@kube control]# cat demo12.py 
#coding:utf-8

#Bubbling algorithm test

data = [5,6,3,1,66,44,33,23,23,7]
print(len(data))
for i in range(len(data)-1):              #外层循环控制循环的字数是9 次，一共是10 元素，整体比较9 次就能够完成冒泡
        print(i)
        for j in range(len(data)-i-1):       # 内层循环依次比较相邻两个值大小，循环次数依次递减，第一次循环比较9 次，第二次8 次 ，依次到0 
                print("j value=",j)           
                #print(data[j])　　　　　　　　　　　　　　
                if (data[j]>data[j+1]):　　　　#依次比较两个数的大小，如果索引0 大于索引1 就互换位置，然后让比较索引1和索引2 ，依次
                        data[j],data[j+1] = data[j+1],data[j]

print("num = " ,data)
[root@kube control]# py demo12.py 
10
0                          #外层循环  9 次 ，内层循环从9 次到1 次完整整体的处理
j value= 0
j value= 1
j value= 2
j value= 3
j value= 4
j value= 5
j value= 6
j value= 7
j value= 8
1
j value= 0
j value= 1
j value= 2
j value= 3
j value= 4
j value= 5
j value= 6
j value= 7
2
j value= 0
j value= 1
j value= 2
j value= 3
j value= 4
j value= 5
j value= 6
3
j value= 0
j value= 1
j value= 2
j value= 3
j value= 4
j value= 5
4
j value= 0
j value= 1
j value= 2
j value= 3
j value= 4
5
j value= 0
j value= 1
j value= 2
j value= 3
6
j value= 0
j value= 1
j value= 2
7
j value= 0
j value= 1
8
j value= 0
num =  [1, 3, 5, 6, 7, 23, 23, 33, 44, 66]
[root@kube control]# 

 

可以看到，实现冒泡排序使用了 2 层循环，其中外层循环负责冒泡排序进行的次数，而内层循环负责将列表中相邻的两个元素进行比较，并调整顺序，即将较小的放在前面，较大的放在后面。

 

Python break和  continue 用法详解

我们知道，在执行 while 循环或者 for 循环时，只要循环条件满足，程序将会一直执行循环体，不停地转圈。但在某些场景，我们可能希望在循环结束前就手动离开循环，Python 提供了 2 种强制离开当前循环体的办法：

1. 使用 continue 语句，可以跳过执行本次循环体中剩余的代码，转而执行下一次的循环。
2. 只用 break 语句，可以完全终止当前循环。

本节先讲解 break 的用法，continue 语句放到下节做详细介绍。

在某些场景中，如果需要在某种条件出现时强行中止循环，而不是等到循环条件为 False 时才退出循环，就可以使用 break 来完成这个功能。

break 用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到 break，系统就将完全结束该循环，开始执行循环之后的代码。这就好比在操场上跑步，原计划跑 10 圈，可是当跑到第 2 圈的时候，突然想起有急事要办，于是果断停止跑步并离开操场，这就相当于使用了 break 语句提前终止了循环。

break 语句一般会结合 if 语句进行搭配使用，表示在某种条件下，跳出循环体，如果使用嵌套循环，break 语句将跳出当前的循环体。

[root@kube break]# cat demo.py 
#coding:utf-8

for i in range(3):
        print(i)
        if i == 1:
                break

[root@kube break]# 

 

 

多层循环跳出当前循环体

[root@kube break]# cat demo1.py 
#coding:utf-8

for i in range(3):
        for j in range(4):
                print('i value: %d,j value: %d' % (i,j))
                if j == 2:
                        break

[root@kube break]# py demo1.py 
i value: 0,j value: 0
i value: 0,j value: 1
i value: 0,j value: 2
i value: 1,j value: 0
i value: 1,j value: 1
i value: 1,j value: 2
i value: 2,j value: 0
i value: 2,j value: 1
i value: 2,j value: 2
[root@kube break]# 

 

 

和 break 语句相比，continue 语句的作用则没有那么强大，它只能终止本次循环而继续执行下一次循环。

仍然以在操作跑步为例，原计划跑 10 圈，但是当跑到第 2 圈一半的时候，突然接到一个电话，停止了跑步。等挂断电话后，回到起点直接从第 3 圈继续跑。 

[root@kube break]# cat demo2.py 
#coding:utf-8
i  = 0
while i < 4:
        print(i)
        i += 1
        if i == 2:
                continue
        print('continue is not action')
[root@kube break]# py demo2.py 
0
continue is not action
1
2
continue is not action
3
continue is not action
[root@kube break]# 

解决无限（死）循环的方法只有一个，即确认循环结构中至少有一个位置能让循环条件为 False 或让 break 语句得以执行。 

Python列表推导式

推导式（又称解析器），是 Python 独有的一种特性。使用推导式可以快速生成列表、元组、字典以及集合类型的数据，因此推导式又可细分为列表推导式、元组推导式、字典推导式以及集合推导式。

列表推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的列表。重点是快速生成一个列表

列表推导式的语法格式如下：

[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]

 

 

[root@kube break]# cat demo3.py 
#coding:utf-8

a_list = [ i + 1 for i in range(3)]

print(a_list)
[root@kube break]# py demo3.py 
[1, 2, 3]
[root@kube break]# 

不仅如此，我们还可以在列表推导式中添加 if 条件语句，这样列表推导式将只迭代那些符合条件的元素。例如如下代码：

[root@kube break]# cat demo4.py 
#coding:utf-8

a_list = [ x for x in range(101) if x % 2 == 1 ]            #求  0 到100 的奇数
print(a_list)
[root@kube break]# py demo4.py 
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]
[root@kube break]# 

 

另外，以上所看到的列表推导式都只有一个循环，实际上它可使用多个循环，就像嵌套循环一样。例如如下代码：

[root@kube break]# cat demo5.py 
#coding:utf-8

a = [(x,y) for x in range(5) for y in ['ling','yi','er','san','si']]
print(a)
[root@kube break]# py demo5.py 
[(0, 'ling'), (0, 'yi'), (0, 'er'), (0, 'san'), (0, 'si'), (1, 'ling'), (1, 'yi'), (1, 'er'), (1, 'san'), (1, 'si'), (2, 'ling'), (2, 'yi'), (2, 'er'), (2, 'san'), (2, 'si'), (3, 'ling'), (3, 'yi'), (3, 'er'), (3, 'san'), (3, 'si'), (4, 'ling'), (4, 'yi'), (4, 'er'), (4, 'san'), (4, 'si')]
[root@kube break]# 

Python元组推导式

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式的语法格式如下：

(表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] )

 

其中，用 [] 括起来的部分，可以使用，也可以省略。

通过和列表推导式做对比，你会发现，除了元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是 []，其它完全相同。不仅如此，元组推导式和列表推导式的用法也完全相同。

例如，我们可以使用下面的代码生成一个包含数字 的元组：

[root@kube break]# cat demo6.py 
#coding:utf-8

a = ( x for x in range(10) if x < 5)
print(a)
print(tuple(a))
[root@kube break]# py demo6.py 
 at 0x7f21b4ce4a50>          #使用元组推导式生成的结果并不是一个元组，而是一个生成器对象（后续会介绍），这一点和列表推导式是不同的。
(0, 1, 2, 3, 4)
[root@kube break]#

 

直接使用 for 循环遍历生成器对象，可以获得各个元素

[root@kube break]# cat demo6.py 
#coding:utf-8

a = ( x for x in range(10) if x < 5)
print(a)
#print(tuple(a))
for i in a:
        print(i)
[root@kube break]# py demo6.py 
 at 0x7fa73328da50>
0
1
2
3
4
[root@kube break]# 

使用 __next__() 方法遍历生成器对象，也可以获得各个元素，例如：

[root@kube break]# cat demo6.py 
#coding:utf-8

a = ( x for x in range(10) if x < 5)
print(a)
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
[root@kube break]# py demo6.py 
 at 0x7f8ecf7159d0>
0
1
2
3
4
Traceback (most recent call last):                #由于取不到值报错，定义的a.__next__() 函数超过了 值
  File "demo6.py", line 10, in 
    print(a.__next__())
StopIteration
[root@kube break]# 

 

注意，无论是使用 for 循环遍历生成器对象，还是使用 __next__() 方法遍历生成器对象，遍历后原生成器对象将不复存在，这就是遍历后转换原生成器对象却得到空元组的原因。

[root@kube break]# cat demo6.py 
#coding:utf-8

a = ( x for x in range(10) if x < 5)
print(a)
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(tuple(a))
[root@kube break]# py demo6.py 
 at 0x7f08eba2c9d0>
0
1
2
3
4
()
[root@kube break]# 

 

 

Python字典推导式

Python 中，使用字典推导式可以借助列表、元组、字典、集合以及 range 区间，快速生成符合需求的字典。

字典推导式的语法格式如下：

{表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}

 

其中，用 [] 括起来的部分，可以使用，也可以省略。

可以看到，和其它推导式的语法格式相比，唯一不同在于，字典推导式用的是大括号{}。

[root@kube break]# cat demo7.sh 
#coding:utf-8

listdemo = ['www.baidu.com','www.ali.com','www.test.com' ]

newdict = {key:len(key) for key in listdemo  }

print(newdict)
[root@kube break]# py demo7.sh 
{'www.baidu.com': 13, 'www.ali.com': 11, 'www.test.com': 12}
[root@kube break]# 

 

 

Python集合推导式

Python中，使用集合推导式可以借助列表、元组、字典、集合以及 range 区间，快速生成符合需求的集合。

集合推导式的语法格式和字典推导式完全相同，如下所示：

{ 表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] }

 

其中，用 [] 括起来的部分，可以使用，也可以省略。集合推导式和字典推导式的格式完全相同，那么给定一个类似的推导式，如何判断是哪种推导式呢？最简单直接的方式，就是根据表达式进行判断，如果表达式以键值对（key：value）的形式，则证明此推导式是字典推导式；反之，则是集合推导式。

[root@kube break]# cat demo8.py 
#coding:utf-8

setnew = {i ** 2 for   i  in range(3)}
print(setnew)
[root@kube break]# py demo8.py 
{0, 1, 4}
[root@kube break]# 

Python zip函数及用法

zip() 函数可以把两个列表“压缩”成一个 zip 对象（可迭代对象），这样就可以使用一个循环并行遍历两个列表。为了测试 zip() 函数的功能，我们可以先在交互式解释器中“试验”一下该函数的功能。

zip() 函数压缩得到的可迭代对象所包含的元素是由原列表元素组成的元组。

[root@kube break]# cat demo9.py 
#coding:utf-8

a = ['a','b','c','d']
b = [1,2,3]
newzip = [ x for x in zip(a,b)]
print(newzip)
[root@kube break]# py demo9.py 
[('a', 1), ('b', 2), ('c', 3)]
[root@kube break]# 

从上面代码可以看出，如果 zip() 函数压缩的两个列表长度不相等，那么 zip() 函数将以长度更短的列表为准。

Python reversed函数及用法

有些时候，程序需要进行反向遍历，此时可通过 reversed() 函数，该函数可接收各种序列（元组、列表、区间等）参数，然后返回一个“反序排列”的法代器，该函数对参数本身不会产生任何影响。

在交互式解释器中，测试该函数的过程如下

[root@kube break]# cat demo10.py 
#coding:utf-8

new_reversed = [x for x in reversed(range(10))]
print(new_reversed)
[root@kube break]# py demo10.py 
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[root@kube break]# 

 

Python sorted函数及用法

sorted() 函数与 reversed() 函数类似，该函数接收一个可迭代对象作为参数，返回一个对元素排序的列表。

在调用 sorted() 函数时，还可传入一个 key 参数，该参数可指定一个函数来生成排序的关键值。比如希望根据字符串长度排序，则可为 key 参数传入 len 函数。例如如下运行过程：

[root@kube break]# cat demo11.py 
#coding:utf-8

a = ['fffffa','bb','tom','EEERF']
b = sorted(a,key=len)
print(b)
[root@kube break]# py demo11.py 
['bb', 'tom', 'EEERF', 'fffffa']
[root@kube break]# 

 

 

猜数字游戏

[root@kube random]# cat demo.py 
#coding-utf-8

import random

secretNum = random.randint(1,20)           #每次脚本执行生成随机数
print(secretNum)

countNum = 0                             #计数

while countNum < 5:                      #while  循环体计数五次
        youPut = int(input('you num :'))　　#输入你的数，需要 int() 函数转换数据类型
        if youPut == secretNum:            #下面就是比大小 ，正好就break 返回
                print('you Success')
                break
        elif youPut > secretNum:
                print('tai da le')
        else:
                print('tai xiao le ')
        countNum += 1                       #类加计数
else:

　　　　print('you failurer, correct answer',secretNum)

[root@kube random]#