Python程序设计-AI辅助编程-课件 第7章 函数与模块

第七章

函数与模块Python程序设计本章要点变量的作用域函数的定义，调用与返回值函数的参数传递递归调用内置函数random模块模块化程序设计DeepSeek的使用学习目标了解函数的定义、调用与返回值的基本概念及匿名函数的使用；理解参数传递的不同方式（位置传递、关键字传递、默认值传递、包裹传递及解包裹传递）和变量作用域规则；学习目标掌握递归调用的方法及内置函数、random模块的应用；熟悉模块化程序设计的思想，包括标准库的使用、第三方库的应用，培养良好的代码组织习惯与团队协作精神，增强软件工程规范意识。1函数定义，调用与返回值函数的定义在实际的程序设计过程中，有很多操作是完全相同或非常相似的，可以由一段代码来实现。在需要这个功能的地方复制该代码段就可以实现功能的复制。但从程序设计的角度上讲，这样直接复制代码段并不明智。大量的重复代码不仅会增加程序的代码行数，也会使程序的逻辑变得更加复杂。在面向过程的程序设计方法中，解决这个问题的一个有效方法是设计函数。将可能需要反复执行的代码封装为函数，在需要执行该功能的地方调用该函数，可以实现代码的复用。应用函数的方法也可以保证代码的一致性，对函数的修改可以同时作用到所有调用该函数的位置。函数：用于进行某种计算或具有某种功能的一系列语句的有名称的组合。函数的定义Python程序中函数的使用要遵循先定义后调用的规则。也就是说函数的调用必须位于函数定义之后，一般的作法是将函数的定义放在程序的开头部分，每个函数之间、函数与主程序之间各留一个空行。def函数名([参数列表]):

'''文档注释'''

函数体

return返回值注意01函数体是函数要实现的功能的程序语句，相对于def关键字要缩进一档。函数的定义函数体内尽量写文档注释，方便查看代码功能。文档注释是Python独有的注释方式，用三引号引起来，注释内容可以通过对象的__doc__成员被自动提取，并且被pydoc所用。文档注释的内容主要包括该函数的功能、可接受参数的个数和数据类型、返回值的个数和类型等。文档注释不是必须，但在函数的定义时加上一段用三引号引起来的注释，可以为用户提供更友好的提示和使用帮助。#def开头的是函数的定义，一般放在文件前面，确保函数先定义后调用defadd_number(a,b):#def为定义函数关键字，add_number为函数名"""接收两个参数a和b，计算其加和并输出。"""#以下缩进区域的多条语句为函数体，调用函数时执行的语句result=a+b#处理语句，计算a,b的和print(result)#输出函数处理结果函数的定义函数名称要遵循标识符命名规则，且不能是关键字。通常推荐函数名有一定含义，能简明表达函数功能。例如，“factorial”表示阶乘。函数名一般建议使用小写字母，若包含多个单词，则用下划线隔开以提高可读性。例如：“add_number”“find_number”之类的。函数名后需紧跟一个小括号，括号里为形式参数列表。形参的值在函数调用时传入。参数可以没有、有1个或者多个。形参个数为0的函数称为无参函数；否则称为有参函数。函数体是实现函数功能的程序语句集合，相较于def关键字需缩进一级。定义函数时，如果希望把函数的处理结果返回给调用函数以进行更进一步的处理，可以使用return语句向调用函数提供该函数的处理结果。函数的返回值语句由return关键词开头，返回值没有类型和个数限制，当函数返回值为多个时，会以元组形式返回。当函数无return语句或return不带参数时，函数返回“None”。函数的调用定义好的函数可以通过名字来进行调用，函数的调用方法如下：函数调用时，括号里要给出与函数定义时数量相同的参数，这些参数称为实际参数，实际参数必须具有确定的值，这些值会被传递给函数定义中的形式参数，相当于一个赋值的过程。函数名（参数）#以下为主函数，一般将输入、输出和函数调用放在主函数中m=float(input())

#输入一个浮点数5n=float(input())

#输入一个浮点数7s=add_number(m,n)

#调用函数，实际参数为m,n,函数返回值赋值给sprint(s)

#输出s的值

12.0print(add_number(m,n))

#函数调用语句做print()的参数，直接输出函数返回值12.0函数的返回值一般情况下无返回值的函数其处理结果应该以其他形式呈现，如在add_number(a,b)函数中就用print()直接在本函数内将两参数相加的结果输出，也可能利用绘图语句直接将结果绘制成图形。#def开头的是函数的定义，一般放在文件前面，确保函数先定义后调用defadd_number(a,b):

#def为定义函数关键字，add_number为函数名

"""接收两个参数a和b，计算其加和并输出。"""

#以下缩进区域的多条语句为函数体，调用函数时执行的语句

result=a+b

#处理语句，计算a,b的和

print(result)

#输出函数处理结果函数的返回值函数定义时希望可以将函数的处理结果返回给调用函数，以便更进一步的处理，此时可以使用return语句向调用函数提供该函数的处理结果。函数的返回值语句由return关键词开头，返回值没有类型限制，也没有个数限制，当函数返回值为多个时，以元组形式返回，此时元组可以看成是一个对象。当返回值个数为0时，返回“None”。defadd_number(a,b):

#def为定义函数关键字，add_number为函数名

"""接收两个参数a和b，计算其加和并返回。"""

#以下缩进区域的多条语句为函数体，调用函数时执行的语句

result=a+b

#处理语句，计算a,b的和

returnresult

#返回函数处理结果实例7.1求阶乘函数定义一个计算整数n的阶乘的函数fact(n)，即输入一个正整数，输出其阶乘值。‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬#定义计算整数阶乘的无参函数#在函数内部输入要计算阶乘的整数deffact():"""接收一个非负整数n为参数，返回n的阶乘值"""num=int(input())#输入一个正整数numresult=1#设定初值，n值为0时返回1foriinrange(1,num+1):#n>0时进入循环，计算阶乘result=result*i#每个循环乘上i，计算阶乘returnresult#返回计算结果给函数调用处#函数体外无需输入，直接将函数调用语句作为print()的参数，输出计算结果print(fact())#在输出语句中调用fact()函数，输出阶乘结果无参函数定义函数时，可以将输入置于函数体中，此时不需要外部传入参数，此时定义函数称为无参函数。返回值：None函数的返回值语句return可有可无，无return语句时，可以在函数体内直接用print()函数输出计算结果，此时函数的返回值为None。函数调用时直接用函数名调用即可，不需要再用print()输出。实例7.1阶乘函数调用：#定义计算整数阶乘的有参、有返回值函数deffact(n):"""接收一个非负整数n为参数，返回n的阶乘值"""result=1#设定初值，n值为0时返回1foriinrange(1,n+1):#n>0时进入循环，计算阶乘result=result*i#每个循环乘上i，计算阶乘returnresult#返回计算结果给函数调用处num=int(input())#输入一个正整数numprint(fact(num))#在输出语句中调用fact()函数，调用函数时，把num的值传给n#函数体外无需输入，直接将函数调用语句作为print()的参数，输出计算结果print(fact())#在输出语句中调用fact()函数，输出阶乘结果实例7.1阶乘函数if__name__=='main':的作用就是控制执行过程，该语句下面的代码只有在文件作为脚本直接执行时才会被执行，而当这个文件被其他程序用import导入时，if__name__=='main':下面的代码不被执行。#定义计算整数阶乘的有参、有返回值函数deffact(n):"""接收一个非负整数n为参数，返回n的阶乘值"""result=1#设定初值，n值为0时返回1foriinrange(1,n+1):#n>0时进入循环，计算阶乘result=result*i#每个循环乘上i，计算阶乘returnresult#返回计算结果给函数调用处if__name__=='__main__':num=int(input())#输入一个正整数numprint(fact(num))#在输出语句中调用fact()函数，调用函数时，把num的值传给n实例7.2

素数判定函数定义一个函数，判定传入正整数是否为素数。‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬defis_prime(n):"""判断参数n是否为素数的函数，返回布尔值"""ifn<2:#0和1以及负数都不是素数returnFalse#False为假，代表不是素数

foriinrange(2,int(n**0.5)+1):ifn%i==0:#当存在能整除的数时，不是素数returnFalse#False为假，代表不是素数else:returnTrue#True为真，代表是素数if__name__=='__main__':num=int(input())#输入一个正整数print(is_prime(num))#输出素数函数判定结果素数定义：大于1，除1和自身外不能被其他自然数整除的自然数。素数判定：依据素数的定义，遍历[2,n-1]区间内的整数，若整数n在[2,n-1]内有因子存在，那它不是素数；若在[2,n-1]内找不到因子，则该数仅能被1与它自身整除，是素数。素数判定优化：约数总是成对存在的，由此可将遍历范围缩减至[2,int(n**0.5)+1)，从而提升算法效率。实例7.2

素数判定函数若将素数判定程序代码保存为Prime.py，便可将其作为模块导入到其他需要素数判定的程序中。下面给出回文素数、反素数和哥德巴赫猜想的示例代码。（1）回文素数。回文素数是指一个数既是素数又是回文数。例如，131，既是素数又是回文数。用户输入一个正整数n,在一行内从小到大输出小于n的回文素数，空格分隔。fromPrimeimportis_prime#导入自定义的模块Prime.py中的函数is_prime()

defpalindromic(num):

"""接收一个数字为参数，判定其是否为回文数，返回布尔值。"""

ifstr(num)==str(num)[::-1]:

returnTrue

else:

returnFalse实例7.2

素数判定函数defpalindromic_prime(number):"""接收一个正整数参数number，遍历从0到number之间的所有整数，

若某个数是素数，且转为字符串后是回文字符串，则称其是回文素数。

找出并在同一行中从小到大输出小于number的所有回文素数，每个输出后加一个空格，

函数无返回值。"""foriinrange(number):#遍历小于n的整数ifpalindromic(i)andis_prime(i):print(i,end='')#i为回文素数时输出iif__name__=='__main__':n=int(input())#输入一个正整数，此处以输入200为例palindromic_prime(n)#输出235711101131151181191实例7.2

素数判定函数（2）反素数。反素数（逆向拼写的素数）是指一个将其逆向拼写后也是一个素数，但此数不是回文数。例如：13和31都是素数，且13和31都不是回文数，故13和31是反素数。输入一个正整数n,在一行内从小到大输出小于n的反素数，空格分隔。。fromPrimeimportis_prime#导入自定义的模块Prime.py中的函数is_prime()num=int(input())#输入一个正整数，此处以输入200为例

foriinrange(num):ifis_prime(i)andis_prime(int(str(i)[::-1]))andstr(i)!=str(i)[::-1]:print(i,end='')#输出1317313771737997107113149157167179199实例7.2

素数判定函数（3）“哥德巴赫猜想”。大致意思是：任何一个大于2的偶数总能表示为两个素数之和。例如：24=5+19，其中5和19都是素数。

输入一个大于2的正偶数num，在一行中按照格式“num=p+q”输出num的素数分解，其中p、q均为素数且p≤q。#哥德巴赫猜想

fromPrimeimportis_prime#导入自定义的模块Prime.py中的函数is_prime()num=int(input())#输入一个正整数，此处以输入12为例

foriinrange(num):ifis_prime(i)andis_prime(num-i)andi<num-i:print("{}={}+{}".format(num,i,num-i))#12=5+7实例7.3幂函数定义一个用于计算x的n(n≥0)次方的幂函数。#定义一个函数用于计算x的n次幂

defpower(x,n):#power()函数接受两个参数，其中n为非负整数

result=1foriinrange(n):#循环n次

result=result*xreturnresult#返回计算结果

if__name__=='__main__':a,m=map(int,input().split())#将用空格分隔的输入切分并映射为整数

print(power(a,m))#调用函数计算a的m次幂power()函数定义时要求2个参数，那么调用这个函数时也要按顺序给出2个值，按顺序传递给函数定义中的两个参数。匿名函数匿名函数使用lambda语句简略定义函数。只包含一个表达式，常用于不想定义函数但又需要代码复用的场合[函数名=]

lambda参数列表:表达式（或条件表达式）lambda函数的语法：def函数名(参数列表):return表达式lambda定义中函数名是可以省略的，相当于函数定义：匿名函数分别用标准函数与匿名函数来实现计算两个数的平方和#计算两个数平方和#def语句定义标准函数defadd_fun1(a,b):returna*a+b*b#lambda语句定义匿名函数add_fun2=lambdaa,b:a*a+b*ba,b=4,9#标准函数调用print("{}*{}+{}*{}={}".format(a,a,b,b,add_fun1(a,b)))#输出4*4+9*9=97#匿名函数调用print("{}*{}+{}*{}={}".format(a,a,b,b,add_fun2(a,b)))#输出4*4+9*9=97匿名函数Python提供许多函数式编程特性，如：sorted()、map()、reduce()、filter()等，这些函数都支持函数作为参数，lambda函数可以应用在函数式编程中。ls=['75','85','100','68','9']#读成绩文件中的数据切分为元素为字符串的列表print(sorted(ls))#按字符串升序排序['100','68','75','85','9']print(sorted(ls,key=lambdax:int(x)))#按数值升序['9','68','75','85','100']lambda函数的主体为一个表达式，而非代码块，只能在表达式里封装有限的逻辑，不能包含其他复杂语句。实例7.4

与7相关的数寻找100以内与7相关的数，所谓与7相关的数是指能被7整除或数字里包含“7”的数值。‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬print(*(filter(lambdax:x%7==0orx%10==7orx//10==7,range(100))))filter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素。该函数接收一个函数和一个序列。filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。filter()函数返回的是一个生成器，也就是一个惰性序列，可以用*解包，也可以用list()函数转为列表输出。2函数的参数传递函数的参数传递当函数定义中存在多个参数时，其参数传递形式主要有位置传递、关键字传递、默认值传递、包裹传递、解包裹传递五种。Python中一切皆为对象，数字是对象，列表是对象，函数也是对象。而变量只是对象的标签。函数调用过程中，参数的传递本质上是一种赋值操作，而赋值操作是一种将标签绑定到对象的过程。位置传递位置固定，参数传递时按照形式参数定义的顺序提供实际参数。其优点是使用方便，缺点是当参数数目较多时，函数调用容易混淆。deffun(name,city,hobby):return'我的名字是{}，来自{}，我的爱好是{}。'.format(name,city,hobby)n,c,h=input().split()#将用空格分隔的输入切分开，分别赋值给n,c,hprint(fun(n,c,h))

#根据实参变量n,c,h的顺序传递给形参name,city,hobby

关键字传递在函数调用时，提供实际参数对应的形式参数名称，根据每个参数的名称传递参数，无需要遵守位置对应关系。其优点是明确标示实际参数和形式参数的对应关系，参数书写顺序更灵活。缺点是增加了函数调用时的代码书写量。deffun(name,city,hobby):return'我的名字是{}，来自{}，我的爱好是{}'.format(name,city,hobby)n,c,h=input().split()#将用空格分隔的输入切分开，分别赋值给n,c,hprint(fun(hobby=h,city=c,name=n))#根据关键字name,city,hobby传递参数或值关键字传递关键字传递和位置传递可以混用，但要注意按位置传递的参数要出现在按关键字传递的参数前面，否则，编译器无法明确知道除关键字以外的参数出现的顺序。deffun(name,city,hobby):return'我的名字是{}，来自{}，我的爱好是{}'.format(name,city,hobby)n,c,h=input().split()#将用空格分隔的输入切分开，分别赋值给n,c,hprint(fun(n,hobby=h,city=c))#n是位置传递，对应函数的第一个形参

默认值传递在定义函数的时候，使用形如city='重庆'的方式，给参数赋予默认值。在函数调用时，如果该参数得到传入值，按传入值进行计算，如果没有被传递值，将使用该默认值。函数参数有多个时，默认值参数必须在后面，非默认值参数在前面一旦出现了带默认值的参数，后面的其他参数都必须具有默认值deffun(name,city,hobby):return'我的名字是{}，来自{}，我的爱好是{}'.format(name,city,hobby)n,c,h=input().split()#将用空格分隔的输入切分开，分别赋值给n,c,hprint(fun(n,hobby=h,city=c))#n是位置传递，对应函数的第一个形参deffun(name,city='重庆',hobby='唱歌'):deffun(name='李华',city,hobby='唱歌')默认值传递默认值参数的优点是可以降低调用函数的难度。#定义默认计算平方的幂函数defpower(x,n=2):''' 接收两个非负整数x和n（x，n不能同时为0），返回x的n次幂，当传入参数只有一个时，返回该数的平方'''result=1ifx==0:return1else:foriinrange(n):result=result*xreturnresultif__name__=='__main__':a=int(input())print(power(a))#调用函数时，只传递一个参数，第二个参数用缺省值2默认值传递默认参数关联的是不可变对象，例如整型、字符串、浮点型、数字型（number）、元组等，而非字典型或列表型这类可变对象；否则，可能会产生一些意外的结果。deffun(x,ls=[]):ls.append(x)returnlsprint(fun(1))#输出[1]print(fun(3))#输出[1,3]print(fun(5))#输出[1,3,5]ls关联的默认值对象在函数定义时生成，且只生成一次，后续调用共享同一对象。append()方法不会生成新的列表对象，只是给原列表追加元素。因此每次调用该函数时，始终引用函数定义时生成的列表对象，造成元素不断累积。默认值传递假如默认参数的数据类型必须为可变对象，前面的例子能够进行如下调整。deffun(x,ls=None):#定义函数时将列表ls置为NoneiflsisNone:#若ls值为None，说明是重新调用，将列表置为空ls=[]ls.append(x)returnlsprint(fun(1))#输出[1]print(fun(3))#输出[3]print(fun(5))#输出[5]包裹传递及解包裹传递在定义函数时，若不能确定函数参数个数，此时参数传递可以使用包裹传递及解包裹传递。包裹传递参数的形式：*parameter：

接收多个实参并将它们打包为一个元组，**parameter：将接收多个键值对（关键字传递），并将它们打包为一个字典。deftotal(*a):#参数a个数不确定'''接收一批数据，返回该批数据总和'''sum=0foriina:sum=sum+ireturnsumprint(total(1,2))#输出3print(total(1,3,5))#输出9 包裹传递及解包裹传递解包裹传递的使用方式也是在参数前面加上*或**，但*或**是加在函数调用的实参前面，其作用就是将作为实参的元组或字典解包，使包中每一个元素对应一个形式参数；其中元组类实参解包后按“位置传递”方式传递给形参，而字典类实参解包后按“关键字传递”方式传递给形参。defoutput_fun(p1,p2,p3):#p1,p2,p3是位置参数'''接收三个数据，并向屏幕输出'''print(p1,p2,p3)tuple1=（"x1","x2","x3"）#定义一个元组output_fun(*tuple1)#对元组tuple1解包，将“x1”传给p1,“x2”传给p2,“x3”传给p3#输出x1x2x3 3变量的作用域变量的作用域在Python程序中创建、改变、查找变量名时，都是在一个保存变量名的空间中进行，我们称之为命名空间，也被称之为作用域。Python的作用域是静态的，在源代码中变量被赋值的位置决定了该变量能被访问的范围。即Python变量的作用域由变量所在源代码中的位置决定。在Python中，并非所有语句块都会产生作用域，只有当变量在Module（模块）、Class（类）、def（函数）中定义的时候，才会有作用域的概念。变量的作用域就是指变量的有效范围。全局变量局部变量局部变量局部变量是在函数中定义的变量，包含在def关键字定义的语句块中。局部变量只是暂时存在，依赖创建该变量的函数是否处于活动的状态，函数调用时创建，函数调用结束后销毁该变量并释放内存。defmyName():name='李华'print(name)#输出李华myName()#调用函数myName()print(name)#NameError:name'name'isnotdefined，作为局部变量，函数外无法访问

全局变量全局变量是在模块(文件)层次中定义的变量，每一个模块都是一个全局作用域。也就是说，在模块文件顶层声明的变量都是全局变量，其作用域是当前模块文件内，包括函数外部和函数内部。全局变量在模块文件运行的整个过程会一直存在，占用内存空间，一般建议尽量少使用全局变量。defmyName():print(name)#输出全局变量name的值‘李华’name='李华'#定义全局变量namemyName()#调用函数myName()print(name)#输出全局变量name的值‘李华’全局变量在函数内部，当全局变量名出现在赋值符号右边时，可以直接访问和引用全局变量的值，但不能直接改变全局变量的值。一旦一个全局变量名出现在赋值符号左边，系统会认为这是重新创建了一个同名局部变量，此外，其值变为在函数体内重赋的新值，同时屏蔽外层作用域中的同名变量。defmyName():

name='张明'

print("局部变量的内存地址：{}".format(id(name)))print("局部变量name的值：{}".format(name))#输出局部变量name的值‘张明’name='李华'print("全局变量的内存地址：{}".format(id(name)))myName()#调用函数myName()print("全局变量name的值：{}".format(name))#输出全局变量name的值‘李华’’全局变量当需要在函数体内声明一个可以在函数体外访问的全局变量时，可以使用global关键字来声明变量的作用域为全局。global的作用就是把局部变量提升为全局变量。defmyName():

globalname#声明一个全局变量

name='张明'#为全局变量name赋值print("新全局变量name的内存地址：{}".format(id(name)))print("新全局变量name的值：{}".format(name))#输出局部变量name值‘张明’name='李华'print("原全局变量name的内存地址：{}".format(id(name)))print("原全局变量name的值：{}".format(name))#输出全局变量name的值‘李华’myName()#调用函数myName()print("name的值：{}".format(name))#输出全局变量name的值‘张明’print("name的内存地址：{}".format(id(name)))全局变量当全局变量为列表等可变数据类型，且在函数中只是需要修改其元素的值时，不需要在函数中使用global关键字进行声明，直接可以使用。这是因为修改可变数据类型变量的元素的值，并不会创建新变量。defmyName():

lsx.append(1)#改变全局变量lsx的值，未重新创建对象lsy=[2,3,4]#重新创建对象[2,3,4],赋值给局部变量lsy

print(id(lsx),id(lsy))#输出28053032865362805252817928print(lsx,lsy)#lsx的值为[1]，lsy的值为[2,3,4]lsx=[]#创建对象[]lsy=[]#创建对象[]print(id(lsx),id(lsy))#输出28053032865362805303242376myName()print(lsx,lsy)#lsx的值变为[1]，lsy值仍为[]，未发生变化4递归调用递归调用递归（Recursion），指一个函数、过程或定义在其描述中直接或间接地使用自身的方法。如果一个函数在内部调用函数本身，这个函数就是递归函数。递归的问题是指原问题的解，可以转化规模更小，其他约束一样的子问题来求解的问题。比如阶乘，Fibonacci数列等，用递归方法来解决这类问题，往往几行代码就可以完成。这个解决问题的递归函数必须有明显的结束条件，否则会产生无限递归的情况，让程序无法正常结束。递归调用递归调用以计算5的阶乘为例说明递归的过程deffact(n):ifn==0:#当n=0时return1#返回1，终止函数递归调用returnn*fact(n-1)#每调用一次，问题规模减小1print(fact(5))#调用递归函数，输出结果120求(n)!递归调用递归函数特性①必须有一个明确的递归终止条件。递归在有限次调用后要进行回溯才能得到最终的结果，那么必然应该有一个明确的临界点，程序一旦到达了这个临界点，就不用继续调用函数而开始回溯，该临界点可以防止产生无限递归。②给出递归终止时的处理办法。在递归的临界点应该给出问题为当前规模时的具体求解方案，有时甚而是直接给出当前规模时问题的解。③每次进入更深一层递归时，问题规模相比上次递归都应有所减少或更接近于解。递归调用递归函数特性①递归的优点是定义简单，逻辑清晰。②递归的缺点是效率不高。③在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。④一般默认递归深度在1000左右。5内置函数内置函数Python的内置函数是指在Python解释器启动时自动加载、无需导入任何模块即可直接使用的函数。abs()delattr()hash()memoryview()set()all()dict()help()min()setattr()any()dir()hex()next()slice()ascii()divmod()id()object()sorted()bin()enumerate()input()oct()staticmethod()bool()eval()int()open()str()breakpoint()exec()isinstance()ord()sum()bytearray()filter()issubclass()pow()super()bytes()float()iter()print()tuple()callable()format()len()property()type()chr()frozenset()list()range()vars()classmethod()getattr()locals()repr()zip()compile()globals()map()reversed()import()complex()hasattr()max()round()

Python常用的内置函数内置函数1.help([object])可返回对象的帮助信息，括号中的参数为一个字符串，可以是模块名、函数名、类名、方法名、关键字或文档主题。当参数省略时，进入帮助环境，再输入要查找的对象名，返回该对象的帮助。例如，查看函数id的帮助信息：>>>help(id)Helponbuilt-infunctionidinmodulebuiltins:id(obj,/)Returntheidentityofanobject.Thisisguaranteedtobeuniqueamongsimultaneouslyexistingobjects.(CPythonusestheobject'smemoryaddress.)内置函数2.id(object)id()函数返回括号中对象的内存地址（identity），一个对象的id值在CPython解释器（官方解释器）里就代表它在内存中的地址。对于字符串、整数等类型，变量的id是随着值的改变而改变的。用is判断两个对象是否相同时，依据就是它们的id值是否相同。复合类型的对象(如类、list等)的id值唯一且不变，但在不重合的生命周期里，可能会出现相同的id值。内置函数3.type(object)type()是一个最实用又简单的查看数据类型的函数，其返回值是要查询的对象类型信息。print(type(1),type('1'),type([1,2,3]))#输出<class'int'><class'str'><class'list'>print(type(range(5)))#输出<class'range'>6random模块及其应用random模块及其应用在计算机中，随机数一般是一个稳定算法所得出的稳定结果序列，不是真正意义上的随机数，一般称为伪随机数。Python中使用random模块产生各种分布的伪随机数。“种子”是这个算法开始计算的第一个值，如果随机数种子一样，那么后续所有“随机”结果和顺序也都是完全一致的。当希望得到的随机数据可预测，可以设置用相同的种子，使后续产生的随机数相同。Python与其他语言不同，当不设置随机数种子时，解释器会使用系统时间作为种子，使每次生成的随机数不同。而在其他语言中，当希望得到不同随机数时，必须明确指定不同的随机数种子。random模块及其应用random是一个内置模块，包含了一系列函数，可提供多种形式的随机数序列；使用随机数函数时，直接导入random模块即可，方法：importrandom函数描述示例random.seed(a=None,version=2)使用随机种子初始化随机数生成器，缺省时用系统时间做种子random.seed(10)print(random.random())#输出0.5714025946899135random.randint(a,b)产生[a,b]之间的一个随机整数，包括bprint(random.randint(1,3))#输出3random.random()产生[0.0,1.0)之间的一个随机浮点数print(random.random())#输出0.5310751534247455random.uniform(a,b)产生[a,b)之间的一个随机浮点数print(random.uniform(2.5,10.0))#输出7.6271425563874775random.randrange(stop)random.randrange(start,stop[,step])产生[0-stop）之间的一个随机整数从序列range(start,stop,step)产生一个随机整数print(randrange(10))#输出7print(randrange(0,101,2))#输出26random.choice(seq)从非空序列seq中产生一个随机数，若序列为空时，抛出索引错误print(random.choice(['win','lose','draw']))#输出'draw'random.shuffle(x[,random])将序列顺序打乱deck=['ace','two','three','four']random.shuffle(deck)print(deck)#输出['four','three','ace','two']random.sample(population,k)从列表、元组、字符串、集合、range对象等序列中随机选取k个互不相同的元素，以列表形式返回。print(random.sample([10,20,30,40,50],k=4))#输出[50,40,10,20]实例7.5猜数游戏随机产生一个[1,200]之间的整数，由玩家去猜。玩家有7次机会，如果猜中提示“猜中了！”并结束程序。如果猜的数比设定的小，提示“你猜的数小了!”，如果猜的数比设定的数大，提示“你猜的数大了!”，如果没能在7次之内猜中数字，提示“尝试次数过多!”并结束程序。实例7.5猜数游戏#输入一个整数，猜测这个整数与系统产生的整数的大小，只能猜测7次。importrandomnum=random.randint(1,200)#随机生成一个[1,200]之间的整数foriinrange(7):#限定猜测次数不超过7次number=int(input("请输入你猜的数字:"))ifnum==number:#猜中print("猜中了!")break#提前结束循环elifnumber>num:#猜测的数字比预置的数大print("你猜的数大了!")else:#猜测的数字比预置的数小print("你猜的数小了!")else:#没有在7次以内猜中时执行此分支print("尝试次数过多!")实例7.6模拟校验验证码用户在网络上注册或登录各平台时，经常需要输入验证码。这些验证码采取随机生成的方式产生，包含大小写字母和数字。用户输入验证码时，一般不区分大小写，请编写程序对用户的输入的验证码进行验证。实例7.6模拟校验验证码#验证码校验importrandom#导入随机数模块importstring#导入字符串模块#利用随机数的sample()方法从包含字母与数字的字符串中随机获取6个元素code=random.sample(string.ascii_letters+string.digits,6)vcode=''.join(code)#将列表code中的元素拼接为一个字符串print(vcode)str=input()ifstr.upper()==vcode.upper():#将输入和vcode中的字符全部转为大写print('验证码正确')else:print('验证码错误，请重新输入')7模块化程序设计模块化程序设计缺点2缺点1多次复制相同代码使源码文件变得冗长，不利于阅读和维护当需要修改功能时，每处都要修改，一旦其中一处漏改就容易导致错误产生在编程程序的过程中，很多功能的实现代码相同或相似，经常可以将代码复制到另一个地方使用或稍做修改使用。模块化程序设计在面向过程的程序设计方法里，合理地运用函数能够将程序划分为不同的功能模块，每个模块用不同的函数来实现，通过调用这些函数完成整体功能。因此，面向过程的程序设计其实就是模块化程序设计。在编写复杂软件或较大工程的时候，离不开多个模块的组合运用，其中也不乏模块导入，此时要考虑好模块之间的关系搭建和运用，同时遵循一些基本的思想：①模块耦合度要降到最低，尽量少使用全局变量，它会降低模块的独立性。②最大化模块的黏合性，最小化耦合性，尽可能不依赖外部的变量。③每个模块应该少去修改其他模块的变量。模块化程序设计程序模块化，就是将整个程序，包含该程序需要用到的所有函数、变量、文件、模块等，当作一个整体。只要整个程序内部的相对路径不改变，将程序移植到其他路径执行，也不会报错。Python中除了内置大量的标准库以外，还有十几万第三方库，这些库可以直接使用import导入后调用其中的功能模块，极大的简化编程的难度。许多时候自己定义的函数，需要经常调用时，就可以自己定义一个模块，将常用函数写入模块里，下次使用常用函数时直接导入模块，就可以使用函数了。模块化程序设计引用方法：from目录名

import模块as模块别名当自定义的模块与当前程序文件在相同目录下时，可以省略from关键字。import模块as模块别名自定义模块的方法是把需要反复调用的代码定义为函数，将函数调用和输入、输出放到

if__name__=='__main__':

分支下面。模块化程序设计#定义一个函数，保存为模块my_pow.pydefpower(x,n):po=1foriinrange(n):po=po*xreturnpo#将输入、输出和函数的调用放到if__name__=='__main__':下面的代码块中if__name__=='__main__':x,n=map(int,input().split())print(power(x,n))#x,n由用户从键盘输入，作为函数power的参数调用自定义模块my_pow.pyimportmy_powprint(my_pow.power(3,4))#输出结果为：81，power()函数的参数为3和4实例7.7通讯录查询功能要求：①用字典存储数据，用模块化方法实现一个具有基本功能的通讯录，每个独立的功能用一个函数实现。②查询全部联系人信息；查询、更新、删除联系人信息。③查询联系人，输入姓名，可以查询当前通讯录里面的联系人信息，若联系人存在，则输出联系人信息，若不存在，则输出“联系人不存在”。④插入联系人，可以向通讯录中新建联系人，若联系人已经存在，则询问是否修改联系人信息，若不存在，则新建联系人。⑤删除联系人，可以删除联系人，若联系人不存在，则告知。⑥输入指令，退出通讯录。实例7.7通讯录查询#用字典存储数据，实现一个具有基本功能的通讯录#构建字典，存储联系人信息dict={'李明':'139×××87777','张宏':'138×××68888','吕京':'131×××11234','赵雪':'130×××12222','刘飞':'133×××56655'}

#定义各功能函数#菜单defaddress_book_menu():

print("|---欢迎进入通讯录程序---|")

print("|---1：查询全部联系人---|")

print("|---2：查询特定联系人---|")

print("|---3：更新联系人信息---|")

print("|---4：插入新的联系人---|")

print("|---5：删除已有联系人---|")

print("|---6：清除全部联系人---|")

print("|---7：退出通讯录程序---|")

print()实例7.7通讯录查询#查询所有联系人信息defqueryAll():

ifdict=={}:

print('通讯录无任何联系人信息')

else:

i=1

#定义序号初值1

foritemindict.items():

print("{}姓名：{}，电话号码：{}".format(i,item[0],item[1]))

i=i+1

#查询一个联系人信息defqueryOne():

name=input('请输入要查询的联系人姓名：')

print(name+":"+dict.get(name,'联系人不存在'))

#修改联系人信息defupdate():

name=input('请输入要修改的联系人姓名：')

if(nameindict):

value=input("请输入电话号码：")

dict[name]=value

else:

print("联系人不存在")实例7.7通讯录查询#插入一个新联系人definsertOne():

name=input('请输入要插入的联系人姓名：')

if(nameindict):

print("您输入的姓名在通讯录中已存在"+"-->>"+name+":"+dict[name])

iis=input("输入'YES/Y'将修改用户资料，其他输入将结束插入联系人")

ifiis.upper()in['YES','Y']:

value=input("请输入电话号码：")

dict[name]=value

else:

value=input("请输入电话号码：")

dict[name]=value

#删除一个用户defdeleteOne():

name=input("请输入联系人姓名")

value=dict.pop(name,'联系人不存在')

ifvalue=='联系人不存在':

print("联系人不存在")

else:

print("联系人"+name+"已删除")

#清空通讯录def

clearAll():

cis=input("提示：确定要清空通讯录吗？确认请输入'YES/Y'，其他输入将放弃该操作")

ifcis.upper()in['YES','Y']:

dict.clear()实例7.7通讯录查询#构建无限循环，实现重复操作whileTrue:

address_book_menu()

n=input("请根据菜单输入操作序号：")

if(n=='1'):

queryAll()

elif(n=='2'):

queryOne()

elif(n=='3'):

update()

elif(n=='4'):

insertOne()

elif(n=='5'):

deleteOne()

elif(n=='6'):

clearAll()

elif(n=='7'):

print("|---感谢使用通讯录程序---|")

break

#结束循环，退出程序

print("\n\n")标准库Python内置了很多用C语言编写的内置模块来实现系统级功能，例如文件I/O；此外还有大量以Python编写的模块，提供了日常编程中许多问题的标准解决方案。其中有些模块经过专门设计，将特定平台功能抽象化为平台中立的API，用于加强Python程序的可移植性。这些模块不需要单独安装，只需要用import导入就可以使用。这些模块与内置类型、内置函数、内置常量和内置异常等统称为标准库。第三方库Python除了标准库以外，还有成千上万并且不断增加的其他组件(从单独的程序、模块、软件包直到完整的应用开发框架)，访问Python包索引即可获取这些第三方包。PyPI(ThePythonPackageIndex）是任何人都可以上传软件包的Python编程语言的软件库，目前36万多个项目，一般任务所需的库都能在这里找到。安装第三方库第三方库在使用前需要通过pip命令安装，pip是Python3.4及以上版本内置的一个现代的、通用的Python包管理工具。提供了对Python包的查找、下载、安装、卸载的功能。在Windows命令接口（cmd）中运行“pipinstallsample”命令，其中sample是欲安装的第三方库名称，执行完毕后若得到“Successfullyinstalledsample”类似的提示，表明包已经安装成功。例如安装做数据分析的pandas库，可以命令提示符后输入并运行以下命令：pipinstallpandas[...]Successfullyinstalledpandas-1.4.1安装第三方库默认情况下，pip将从PyPI获取第三方库。这个网站在国外，安装包的过程中可能会因为网络原因导致安装很慢甚至出现超时的问题。为了让国内用户可以更快的获取PyPI上的资源，国内一些高校和公司做了PyPI的镜像源网站（使用“-i”指定使用国内的下载源），常用的有：清华：/simple阿里云：/pypi/simple/中国科技大学：/simple/豆瓣：/simple/pipinstall-i/pypi/simple/numpy安装第三方库在系统配置中把默认的源更换为访问速度最快的国内源。在Linux