资源简介

(共146张PPT)
第13章　Python函数与模块调用
知识与技能要点 考试条目 考试水平(A/B/C/D) 复习建议
函数与模块 自定义函数的定义与调用 C 在职教高考中模块调用及参数传递是所有高级语言的重难点之一,它变化多,应用灵活,对中职生而言必须对照资料把基本概念、基本方法、常见应用场景等在反复练习的基础上方能真正掌握,否则很难做到。一句话,多看、多练、多上机是唯一的捷径。
自定义函数参数传递方式 D
自定义函数的位置参数、关键字参数、默认参数 D
自定义函数可变长参数 D
自定义函数参数传递中的可变参数与不可变参数 D
变量作用域 D
函数的递归调用 C
Python库函数的导入与调用 C
内置函数 C
math模块 C
datetime模块 B
random模块 D
1.Python自定义函数的定义(C)
定义自定义函数需要用 def 关键字实现,具体的语法格式如下。
def函数名(参数列表)：
函数体
[return [返回值]]
考点1
Python自定义函数
备考讲义
其中,各部分参数的含义如下：
函数名：其实就是一个符合 Python 语法的标识符,但不建议读者使用A.B.C这类简单的标识符作为函数名,函数名最好能够体现出该函数的功能。
参数列表：设置该函数可以接收多少个参数,多个参数之间用逗号分隔。
函数体：函数体是实现函数参数功能的代码段。
[return [返回值] ]：整体作为函数的可选参数,用于设置该函数的返回值。也就是说,一个函数,可以用返回值,也可以没有返回值,是否需要根据实际情况而定。
注意,在创建函数时,即使函数不需要参数,也必须保留一对空的“()”,否则 Python 解释器将提示“invaild syntax”错误。另外,如果想定义一个没有任何功能的空函数,可以使用 pass 语句作为占位符。
2.Python自定义函数的调用(C)
调用函数也就是执行函数。
函数调用的基本语法格式如下所示。
函数名([参数表])
其中,函数名即指的是要调用的函数的名称;参数表指的是当初创建函数时要求传入的各个实际参数的值。如果该函数有返回值,我们可以通过一个变量来接收该值,当然也可以不接收。需要注意的是,创建函数有多少个参数,那么调用时就需要传入多少个参数值,且顺序必须和创建函数时一致。即便该函数没有参数,函数名后的小括号也不能省略。
3.Python自定义函数参数传递方式(D)
通常情况下,定义函数时都会选择有参数的函数形式,函数参数的作用是传递数据给函数,令其对接收的数据做具体的操作处理。在使用函数时,经常会用到形式参数(简称“形参”)和实际参数(简称“实参”),二者都叫参数,之间的区别是：
形式参数：在定义函数时,函数名后面括号中的参数就是形式参数,例如：
def demo(obj)： #定义函数时,这里的函数参数 obj 就是形式 参数
print(obj)
实际参数：在调用函数时,函数名后面括号中的参数称为实际参数,也就是函数的调用者给函数的参数。例如：
a=“C语言中文网”
demo(a)　#调用已经定义好的 demo 函数,此时传入的函数参数 a 就是实际参数
实参和形参的区别,就如同剧本选主角,剧本中的角色相当于形参,而演角色的演员就相当于实参。
Python中,根据实际参数的类型不同,函数参数的传递方式可分为 2种,分别为值传递和引用(地址)传递。
值传递：适用于实参类型为不可变类型(字符串、数字、元组)。
引用(地址)传递：适用于实参类型为可变类型(列表,字典)。
值传递和引用传递的区别是,函数参数进行值传递后,若形参的值发生改变,不会影响实参的值;而函数参数继续引用传递后,改变形参的值,实参的值也会一同改变。
4.Python函数返回值详解(D)
Python中,用 def 语句创建函数时,可以用 return 语句指定应该返回的值,该返回值可以是任意类型。需要注意的是,return 语句在同一函数中可以出现多次,但只要有一个得到执行,就会直接结束函数的执行。
函数中,使用 return 语句的语法格式如下。
def函数名(参数列表)：
代码块
return 返回值列表
其中,返回值参数可以指定,也可以省略不写(将返回空值 None)。通过 return 语句指定返回值后,我们在调用函数时,既可以将该函数返回值赋值给一个变量,用变量保存函数的返回值,也可以将函数返回值再作为某个函数的实际参数。
def isGreater0(x)：
　　if x>0：
　　　 return True
　　else：
　　　 return False
print(isGreater0(5))　#运行结果为True
可以看到,函数中可以同时包含多个 return 语句,但需要注意的是,最终真正执行的最多只有 1 个,且一旦执行,函数运行会立即结束。一般情况下,函数只有一个返回值,但Python也支持函数返回多个返回值。
(1)为了返回多个返回值,只需在return关键字后跟多个值(依次用逗号分隔)。
def date()：
　import datetime
　d=datetime.date.today()
　return d.year,d.month,d.day
(2)事实上,当返回值增加时,Python会将返回值包装成元组,然后返回元组。
date()
(2019,9,4)
5.lambda匿名函数(D)
匿名函数lambda：是指一类无需定义标识符(函数名)的函数或子程序。所谓匿名函数,通俗地说就是没有名字的函数,lambda函数没有名字,是一种简单的、在同一行中定义函数的方法。lambda函数一般功能简单。单行expression决定了lambda函数不可能完成复杂的逻辑,只能完成非常简单的功能。由于其实现的功能一目了然,甚至不需要专门的名字来说明,所以lambda函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。lambda表达式只允许包含一个表达式,不能包含复杂语句,该表达式的运算结果就是函数的返回值。lambda函数实际生成了一个lambda对象。lambda表达式的基本语法如下。
lambda arg1,arg2,arg3…：<表达式>
具体应用如下：
lambda x,y： x*y　 # 函数输入是x和y,输出是它们的积
x*y
lambda：None # 函数没有输入参数,输出是None
lambda *args： sum(args) # 输入是任意个数参数,输出是它们 的和(隐性要求输入参数必须能进
行算术运算)
lambda **kwargs： 1 # 输入是任意键值对参数,输出是1
例1　利用函数调用完成一个由”*”组成的九层金字塔图形。
【试题分析】 本题主要考查学生对自定义函数的理解与综合应用能力,间接考查了学生对循环结构的理解与综合应用能力。这道题主程序完成九层基本结构,再利用函数完成每一层的图形输出。
【解析】 根据以上分析,先定义一个自定义函数print_star(函数中利用字符串的重复操作和字符串的对齐操作)完成每一层的图形输出,再设计一个主程序实现对自定义函数print_star的调用(注意实参的变化),即可实现题目要求。
答案：程序如下
def print_star(n)：
　　print((“*”*n).center(70))
for i in range(1,19,2)：
　　print_star(i)
例2　读程序分析,写出程序运行结果。
def a(n)：
　　　　n[2]=100
　　　　print(n)
　　　　return None
def b(n)：
　　　　n+=100
　　　　print(n)
　　　　return None
an=[1,2,3,4,5]
bn=10
print(an)
a(an)
print(an)
print(bn)
b(bn)
print(bn)
运行结果是：
【试题分析】 本题主要考查学生对函数中不可变参数的单向值传递与可变参数的引用传递的理解与应用能力。Python是不允许程序员选择采用值传递还是地址传递的。Python参数传递采用的是“传对象引用”的方式,实际上,这种方式相当于值传递和地址传递的一种综合。如果函数收到的是一个可变对象(比如字典或者列表)的引用,就能修改对象的原始值——相当于地址传递。如果函数收到的是一个不可变对象(比如数字、字符或者元组)的引用,就不能直接修改原始对象——相当于值传递。所以Python的值传递和地址传递是根据传入参数的类型来选择的。
【解析】 在上面的例子中,an是一个list,将其作为实参传入函数a中,a对其第三个元素进行修改。a执行结束后再次打印an,发现里面的元素的确发生变化,这就是地址传递操作。bn代表一个数字,将其传入函数b,并做修改,b执行结束后再次打印bn,没有变化,这是值传递操作。这道题考查的就是学生对参数值传递和地址传递是否真正理解与掌握。
答案：
[1,2,3,4,5]
[1,2,100,4,5]
[1,2,100,4,5]
10
110
10
变式训练1
(1)下面代码的输出结果是______________。
def join(list,sep=None)：
　　return(sep or ',').join(list)
print(join(['a','b','c']))
print(join(['a','b','c'],'：'))
a,b,c a:b:c
【试题分析】 本题主要考查学生对函数调用时参数传递的理解与应用能力,同时也考查了学生对字符串常用处理函数的理解与记忆。print(join(['a','b','c']))调用时,“abc”传给形参list,返回return(sep or ',').join(list),所以输出“a,b,c”。print(join(['a','b','c'],':'))调用时,“abc”传给list,注意调用时指定了间隔符为“:”,返回return(sep or ',').join(list),所以输出“a:b:c”。
【解析】 根据以上分析,可得到上述答案,注意输出结果要分行。
(2)def func()：
　　 Print(“hello world!”)
问type(func),type(func())的运行结果分别是(　　　)
A.,
B.,
C.,
D.,
C
【试题分析】 本题主要考查学生对自定义函数返回类型的理解与掌握,特别要注意细节,type(func)返回类型为,而type(func())返回类型为。
【解析】 根据以上分析,可知答案应为,,可能很多学生以前没有注意,以后要记住。
(3)定义函数如下：
F=lambda x：x+1
f(f(1))代码的运行结果是(　　　)
A.1 B.2
C.3 D.会报错
C
【试题分析】 本题主要考查学生对匿名函数的理解与综合应用,注意本题调用了两次,第二次调用时实参为第一次调用返回的结果。
【解析】 根据以上分析第一次调用返回结果为2,第二次调用返回结果为3。
1.Python的位置参数(D)
位置参数,有时也称必备参数,指的是必须按照正确的顺序将实际参数传到函数中,换句话说,调用函数时传入实际参数的数量和位置都必须和定义函数时保持一致。调用函数时,如果指定的实际参数和形式参数的位置不一致,但它们的数据类型相同,那么程序将不会抛出异常,但导致运行结果和预期不符。
考点2
位置参数、关键字参数、默认参数、可变长参数与可变参数
备考讲义
2.Python函数关键字参数(D)
关键字参数则可以避免牢记参数位置的麻烦,令函数的调用和参数传递更加灵活方便。关键字参数是指使用形式参数的名字来确定输入的参数值。通过此方式指定函数实参时,不再需要与形参的位置完全一致,只要将参数名写正确即可。因此,Python函数的参数名应该具有更好的语义,这样程序可以立刻明确传入函数的每个参数的含义。
例如,在下面的程序中就使用到了关键字参数的形式给函数传参。
def dis_str(str1,str2)：
　　print(“str1：”,str1)
　　print(“str2：”,str2)
#关键字参数
dis_str(“http：//c./Python/”,str2=“http：//c./shell/”)
dis_str(str2=“http：//c./Python/”,str1=“http：//c./shell/”)
可以看到,在调用有参函数时,既可以根据位置参数来调用,也可以使用关键字参数来调用。在使用关键字参数调用时,可以任意调换参数传参的位置。当然,还可以使用位置参数和关键字参数混合传参的方式。但需要注意,混合传参时关键字参数必须位于所有的位置参数之后。
位置参数必须放在关键字参数之前,下面代码错误。
dis_str(str1=“http：//c./Python/”,“http：//c./shell/”)
3.Python函数默认参数(D)
我们知道,在调用函数时如果不指定某个参数,Python 解释器会抛出异常。为了解决这个问题,Python 允许为参数设置默认值,即在定义函数时,直接给形式参数指定一个默认值。这样的话,即便调用函数时没有给拥有默认值的形参传递参数,该参数也可以直接使用定义函数时设置的默认值。Python 定义带有默认值参数的函数,其语法格式如下：
def 函数名(…,形参名,形参名=默认值)：
　　代码块
注意在使用此格式定义函数时,指定有默认值的形式参数必须在所有没默认值参数的最后,否则会产生语法错误。例如：
def dis_str(str1,str2=“http：//c./Python/”)：　#str1没有默认参数,str2有默认参数
　　print(“str1：”,str1)
　　print(“str2：”,str2)
主程序中调用函数语句如下：
dis_str(“http：//c./shell/”)
dis_str(“http：//c./java/”,“http：//c./golang/”)
上面程序中,dis_str() 函数有 2 个参数,其中第 2 个设有默认参数。这意味着,在调用 dis_str() 函数时,我们可以仅传入 1 个参数,此时该参数会传给 str1 参数,而 str2 会使用默认的参数。当然在调用 dis_str() 函数时,也可以给所有的参数传值,这时即便 str2 有默认值,它也会优先使用传递给它的新值。再次强调,当定义一个有默认值参数的函数时,有默认值的参数必须位于所有没默认值参数的后面。
def dis_str(str1=“http：//c./Python/”,str2,str3)：　#错误,str1 有默认值,必须位于 str2 和 str3 这两个位置参数之后
4.可变长参数(D)
(1)一个星号：函数可以接收任意个数的参数,只需要在参数前面加一个*(星号),一个带星号参数的函数会把多个位置参数值当成元组的形式传入,也就是传入的多个参数值可以在函数内部进行元组遍历。
def length_param(a,*args)：
print(“a=”,a)
print(“args=”,args)
for arg in args：
　print(“arg=”,arg)
#主程序
length_param(“zim”,“this”,“is”,“a”,“good”,“thing”)
执行结果：
a=zim
args=(“this”,“is”,“a”,“good”,“thing”)
arg=this
arg=is
arg=a
arg=good
arg=thing
(2)两个星号：参数前面加两个*(星号),注意是两个星号哦,带两个星号形参的函数会把关键字参数值当成字典的形式传入,在函数内部会把关键字参数当成字典在函数内部进行遍历。
def length_param(a,**kwargs)：
print(“a=”,a)
print(“kwargs=”,kwargs)
for kwarg in kwargs.keys()：
　print(“kwarg=”,kwarg)
#主程序
length_param(“zim”,b=“this”,c=“is”,d=“good”)
执行结果：
a=zim
kwargs={“b”：”this”,“c”：”is”,“d”：”good”}
kwarg=b
kwarg=c
kwarg=d
注意：传入可变长参数时,传入关键字参数的key一定不能有冒号,否则会报错。
5.可变参数与不可变参数
(1)可变参数的传递
可变参数有：列表、集合、字典。例如：
def fun(a)：
　　print('传入函数时a的值为：',a)
　　a.insert(2,3) #修改a
　　print('函数改动后a的值为：',a)
#主程序
a=[1]
fun(a) #调用函数
print('调用函数后全局中a的值为：',a)
结果为：
传入函数时a的值为： [1]
函数改动后a的值为： [1,2,3]
调用函数后全局中a的值为： [1,2,3]　#可以看到函数外部a的值被改变了
结论：函数传递可变参数时,会将包括索引在内的整体传递进去,当函数内部对参数进行修改时,函数外部的参数也会被修改。
(2)不可变参数的传递
不可变参数有：数字、字符串、元组。例如：
def fun(a)：
　　print('传入函数时a的值为：',a)
　　a=2　　#这里是通过重新赋值的方法修改,只是为了举例
　　print('函数改动后a的值为：',a)
#主程序
a=1
fun(a)　 #调用函数
print('调用函数后全局中a的值为：',a)
结果为：
传入函数时a的值为： 1
函数改动后a的值为： 2
调用函数后全局中a的值为： 1　#可以看到函数外部a的值并没有改变
结论：函数传递不可变参数时,只传递了值,当函数内部对参数进行修改时,其实只是重新创建了一个同名参数,函数对这个同名参数的操作并不会影响到函数外部的参数。
例3　读程分析运行结果。
def a(n)：
　　n[2]=100
　　print(n)
　　return None
def b(n)：
　　n+=100
　　print(n)
　　return None
an=[1,2,3,4,5]
bn=10
print(an)
a(an)
print(an)
print(bn)
b(bn)
print(bn)
运行结果是：
【试题分析】 本题主要考查学生对Python中参数传递的理解与应用能力。Python是不允许程序员选择采用值传递还是地址传递的。Python参数传递采用的是“传对象引用”的方式,实际上,这种方式相当于值传递和地址传递的一种综合。如果函数收到的是一个可变对象(比如字典或者列表)的引用,就能修改对象的原始值——相当于地址传递。如果函数收到的是一个不可变对象(比如数字、字符或者元组)的引用,就不能直接修改原始对象——相当于值传递。所以Python的值传递和地址传递是根据传入参数的类型来选择的。
【解析】 在这个例子中,an是一个list,将其作为实参传入函数a中,a对其第三个元素进行修改。a执行结束后再次打印an,发现里面的元素的确发生了变化,这就是地址传递操作。bn代表一个数字,将其传入函数b中,并做修改,b执行结束后再次打印bn,没有变化,这是值传递操作。
答案：
[1,2,3,4,5]
[1,2,100,4,5]
[1,2,100,4,5]
10
110
10
变式训练2
(1)读程分析运行结果。
def test1(x,*args)：
　　print(x,args)
test1(1,2,3,4,5)
运行结果是：__________________。
1　(2, 3, 4, 5)
【试题分析】 本题主要考查学生对可变长参数传递的理解与应用能力,特别注意第二个参数返回值的类型为元组。
【解析】 根据以上分析,实参x的值为1,实参arg的值为元组(2,3,4,5),因此运行的结果为1(2, 3, 4, 5)。
(2)读程分析运行结果。
def func(a,b,**kwargs)：
　　print(a,b,kwargs)
func(a=10,b=20,cc=30,dd=40)
运行结果是：__________________________________。
10　20　{'cc': 30, 'dd': 40}
【试题分析】 本题主要考查学生对可变长参数传递的理解与应用能力,注意第二个参数的类型为字典。
【解析】 根据以上分析,实参a的值为10,实参b的值为20,实参kwargs的值为{'cc': 30, 'dd': 40},因此运行的结果为10　20　{'cc': 30, 'dd': 40}。
变量的作用域是程序运行时可被访问的范围。变量的作用域由变量的定义位置决定,在不同位置定义的变量,它的作用域是不一样的。
考点3
变量作用域
备考讲义
1.局部变量(D)
定义在函数内部的变量,它的作用域也仅限于函数内部,出了函数就不能使用了,我们将这样的变量称为局部变量(Local Variable)。要知道,当函数被执行时,Python 会为其分配一块临时的存储空间,所有在函数内部定义的变量,都会存储在这块空间中。而在函数执行完毕后,这块临时存储空间随即会被释放并回收,该空间中存储的变量自然也就无法再被使用。如果试图在函数外部访问其内部定义的变量,Python 解释器会报 NameError 错误,并提示我们没有定义要访问的变量,这也证实了当函数执行完毕后,其内部定义的变量会被销毁并回收。值得一提的是,函数的参数也属于局部变量,在调用函数时会被赋予具体的值,只能在函数内部使用。
2.全局变量(D)
全局变量指在函数之外定义的变量,一般没有缩进,在程序执行的全过程有效。全局变量的默认作用域是整个程序,即全局变量既可以在各个函数的外部使用,也可以在各个函数内部使用。在函数内部,局部变量的优先级大于全局变量。
定义全局变量的方式有以下 2 种：
(1)在函数体外定义的变量,一定是全局变量。
(2)在函数体内定义全局变量。即使用 global 关键字对变量进行修饰后,该变量就会变为全局变量。注意,在使用 global 关键字修饰变量名时,不能直接给变量赋初值,否则会引发语法错误。
例4　读程分析运行结果。
def func()：
　　a.append(10)
a=[1,2,3]
func()
print(a)
运行结果是：
【试题分析】 函数内部可以调用可变数据类型的成员方法对其进行操作,且这个操作是会影响到全局作用域的。
【解析】 根据以上分析可知,a列表,属可变参数,函数内部可以调用可变数据类型的成员方法对其进行操作,且这个操作是会影响到全局作用域的。所以最后的结果是[1,2,3,10]。
例5　读程分析运行结果。
def func1(　　)：
　　a+=[10]
a=[1,2,3]
func()
print(a)
运行结果是：
【试题分析】 自定义函数中的a与主程序的a是两个不同的对象,在自定义函数中不调用global就进行操作仅限于对象的方法,即便是原地操作的“+=”也会报错。
【解析】 根据以上分析可知,自定义函数中少了global a这条语句,不能做全局变量a的修改,且这时a是局部变量没有赋值就参与运算,所以报错。
答案：# 会报错
变式训练3　读程分析运行结果。
a=10
def func()：
　　global a
　　a+=1
　　print(a)
func()　# 11
print(a)　# 11
运行结果是：________。
11
【试题分析】 本题主要考查学生对变量作用域的理解与掌握,默认时自定义函数中的变量是局部变量,但用global a申明后,自定义函数中的a是全局变量。
【解析】 根据以上分析,自定义函数内print(a)输出结果为11,调用结束后返回主程序print(a)的输出结果为11。
递归调用(D)
递归调用是一种特殊的嵌套调用,是指某个函数调用自己或者调用其他函数后再次调用自己。由于不能无限嵌套调用,所以某个递归函数一定存在至少两个分支,一个是退出嵌套,不
考点4
函数的递归调用
备考讲义
再直接或者间接调用自己;另外一个则是继续嵌套。一般通过函数的输入参数来决定走哪个分支,所以递归函数一般都是带有参数的。正确的递归调用有两个基本要求,一是有一个比原始调用规模小的函数副本。二是有递归终止条件。使用递归并不能提高程序的执行效率,反而会因为多次调用和返回降低执行效率,且要求每次调用保存局部变量和返回点等,既费时又费空间。
例6　递归实现求FIBONACCI数列中的第N项。
【试题分析】 本题主要考查学生对递归调用的综合理解与应用能力。递归实现斐波那契数列编程思路：先声明求解函数F,参数为n(表示数列的第N项),再从下标0开始,首先判断输入的n是否大于1,若小于等于1,则直接返回,最后若n大于1,递归计算F(n-1)和F(n-2)的值,并将两个值相加,得到斐波那契数列在位置N的值。
【解析】 根据以上分析可得下面的程序。
答案：
def fib_digui_1(n)：　# 返回第n项裴波那契数列值
　　if n>1：
　　　　return fib_digui_2(n - 1)+fib_digui_2(n - 2)
　　else：
　　　　return n
变式训练4　编程用递归方法实现九九乘法口诀表。
def multiplication(n):
　　if n < 10:　　# 如果n小于10,则进行递归调用
　　　　for m in range(1, n+1):　　# 使用for循环,m的范围是[1,n]
　　　　　　print(f"{m}*{n}={m*n}", end="\\t")　　# 打印m与n的积及格式化后的字符串,末尾以制表符分隔
　　　　print()　　# 一行的m乘以n的结果打印完成,将光标移动到下一行
　　　　multiplication(n+1)　　# 递归调用函数,将n自增1,进行下一次循环
multiplication(1)　　# 调用multiplication函数,n初始化为1
【试题分析】 本题主要考查学生对递归调用的理解与综合应用能力,递归实现乘法口诀的编程思路:先声明求解函数,参数为n(表示乘法口诀表的第N行),再从下标1开始,首先判断输入的n是否小于10,若小于10,则直接返回该行,最后若n大于10,递归调用结束退出。
【解析】 根据以上分析,可得以上程序,注意实参是从1开始,一行一行输出,直到递归调用结束(n=10),直接退出。
1.Python标准库的安装与调用
Python中的函数包括内建函数、标准函数、第三方库和用户自定义函数。前面我们已经学习使用了内建函数、标准函数和用户自定义函数。模块分为标准库模块和自定义模块。
备考讲义
考点5
Python标准库函数的导入与调用
把相关的函数存储到一个模块里,可以让函数更好用,更易懂,能够更有逻辑地组织Python代码。模块可隐藏程序代码细节,程序员在编写程序时,引入该模块,即可调用该模块中的函数,无须关注函数实现过程,进而提升编程效率。Python安装程序包含庞大的Python标准库,标准库内置大量的函数和类,涉及范围十分广泛,常用的标准库见下表。
表13—1　常用标准库
标准库名 描述
math模块 用于数学计算、求最值,求三角函数值等与数学相关的操作
datetime模块 与日期、时间相关功能
random模块 用于生成随机数
string模块 用于处理字符串
Python中有许多标准库,如math模块(数学库)、random模块(随机库)等。除了标注库外,Python的第三方库很多、功能很强大,这是Python的重要特征和优势。一个模块(库)就是一个 Python 文件。多数情况下,一个 Python 文件包含变量、函数和其他的内容,这些内容可以被其他代码使用。模块让你能够有逻辑地组织你的Python 代码段。把相关的代码分配到一个模块里能让你的代码更好用,更易懂。
模块的引入：
(1)import 语句
模块定义好后,我们可以使用 import 语句来引入模块,语法如下。
import　module1[,module2[,…moduleN]]
(2)from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下。
from　modname　 import　name1[,name2[,…nameN]]
(3)from…import * 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的,语法如下。
from　modname　import*
2.Python第三方库(包)的下载、安装与调用
(1)使用pip安装
pip是Python中最常用的包管理工具,也是最常用的在线安装方法。
命令如下：
pip install package_name　# package_name就是你所需要安装的包的名字
(2)在程序中导入并调用第三方库中的函数
命令如下：
from　package_name　import　name1[,name2[,…nameN]]
例7　利用math库中的gcd(m,n)函数求最大公约数。
【试题分析】 本题主要考查学生对库函数的导入及综合应用能力。先导入math库,再调用库中的gcd()函数求最大公约数。
【解析】 根据以上分析,可得到以下所示命令,完成任务。
答案：
import math　#导入标准库math
print(math.gcd(56,64))　#调用gcd()函数,计算最大公约数
变式训练5　导入math库函数,求sin(3)的值。
from math import *　　　#导入标准库math中所有对象
print(math.sin(3))　　　　#求sin(3)的值
【试题分析】 本题主要考查学生对库函数的导入及综合应用能力。先导入math库,再调用库中的sin()函数求正弦值。
【解析】 根据以上分析,可得到以上所示命令,完成任务。
内置函数就是Python提供的,拿来直接用的函数,Python 3.6中有：
abs()　 dict()　　 help()　　　 min()　 setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
备考讲义
考点6
Python内置函数
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() 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()
delattr() hash() memoryview() set()
　　以上这些内置函数绝大多数我们在相关章节都已复习总结过了,下面我们把前面没有讲过并需要大家掌握的几组内置函数帮助大家总结归纳一下。
1.进制转换函数(D)
(1)bin()函数将给的参数转换成二进制,如：
print(bin(10))　# 二进制：0b1010
(2)oct()函数将给的参数转换成八进制,如：
print(oct(10))　# 八进制：0o12
(3)hex()函数将给的参数转换成十六进制,如：
print(hex(10))　# 十六进制：0xa
2.map()函数(D)
map()函数会根据提供的函数对指定序列做映射(lamda)。
语法 ： map(function,iterable)
功能：可以对可迭代对象中的每一个元素进行映射,如：
def f(i)：
　　return i
lst=[1,2,3,4,5,6,7]
it=map(f,lst)
# 把可迭代对象中的每一个元素传递给前面的函数进行处理,处理的结果会返回到迭代器
print(list(it))　#[1,2,3,4,5,6,7]
3.查看内置对象属性(D)
dir()函数： 查看对象的内置属性,访问的是对象中的_dir_()函数
　　print(dir(tuple))　#查看元组的函数
例8　读程分析运行结果。
Import　math
print(math.ceil(6.4),math.ceil(-6.4))
【试题分析】 本题主要考查学生对math库的熟练掌握程度。math.cell(x)将返回数轴上右边离x最近的整数值。
【解析】 根据以上分析可知结果是7　　-6。
例9　读程分析运行结果。
Import　math
print(math.floor(6.4),math.floor(-6.4))
【试题分析】 本题主要考查学生对math库的熟练掌握程度。math.floor(x)将返回数轴上左边离x最近的整数值。
【解析】 根据以上分析可知结果是6　　-7。
变式训练6
(1)hex(10)的返回值是__________,bin(10)的返回值是__________。
'0xa'
'0b1010'
【试题分析】 本题主要考查学生对math库的熟练掌握程度。hex()函数返回的是十六进制数,bin()函数返回的是二进制数。
【解析】 根据以上分析可知hex(10)的返回值为'0xa',bin(10)的返回值为'0b1010',特别注意返回值的类型是字符串,不是数值型数据。
(2)print(oct(10))的结果是__________。
【试题分析】 本题主要考查学生对math库的熟练掌握程度。oct(10)函数返回的是八进制数。
【解析】 根据以上分析可知oct(10)的返回值为'0o12',注意输出字符串时不能有定界符。
0o12
math库(D)
math库是Python的内置库,不需要下载安装,导入即可使用。由于复数类型在一般的计算中并不常见,所以Math的函数并不支持复数类型的数据,仅支持浮点数和整数。常用math库函数如下。
备考讲义
考点7
Python标准math库函数
表13—2　常用math库函数
函数 功能
abs(x) 计算并返回x的绝对值
divmod(x,y) 以二元组的形式返回(x //y,x%y)
pow(x,y) 返回x的y次幂,同x**y
pow(x,y,z) 返回(x**y)% z
math.pi π为圆周率,值为3.1415926……
函数 功能
math.e e为自然对数,值为2.718281……
math.ceil(x) 向上取整,返回不小于x的最小整数
math.floor(x) 向下取整,返回不大于x的最大整数
math.pow(x,y) 返回x的y次幂,即x**y
math.exp(x) 返回e的x次幂,e是自然对数
math.sqrt(x) 返回x的平方根
math.log(x,base) 返回以base为底,x的对数,base为可选参数,若不输入,则默认为自然对数e,即lnx
例10　输入一个五位整数,求它的万位、千位、百位、十位、个位。
【试题分析】 本题重点考查的是学生对math库的熟练掌握程度。利用divmod() 函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b,a % b),前一个是数位,后一个是继续计算的数t,直到算出十位和个位。
【解析】 根据以上分析可知,先输入这个五位数并把它转化为整数,再反复利用divmod()这个函数,直到求出所有的数位为止。
答案：
x=int(input(“请输入一个五位整数”))
ww,t=divmod(x,10000)
qw,t=divmod(x,1000)
bw,t=divmod(t,100)
sw,gw=divmod(t,10)
Print(“万位、千位、百位、十位、个位分别是”,ww,qw,bw,sw,gw)
变式训练7　读程分析运行结果。
x="12345"
a,b,c,d,e=map(int,x)
print(a,b,c,d,e)
运行结果：________________。
1　2　3　4　5
【试题分析】 本题主要考查学生对map()函数的理解与掌握,map() 会根据提供的参数对指定序列做映射(lamda),可以对可迭代对象中的每一个元素进行映射。
【解析】 根据以上分析可知实参x“12345”,先转化为序列1,2,3,4,5,再对序列做一个迭代映射,因此最后的结果为1　2　3　4　5。
1.datetime库概述(B)
datetime库是Python中处理日期和时间的标准库之一,不需要下载安装,导入即可使用。它提供了多种方便的函数和类,能够方便地完成日期和时间的计算和转换等操作。datetime库的基本结构包含三个类：date、time和datetime。其中,date类表示日期,time类表示时间,datetime类表示日期和时间,同时还有一个timedelta类表示时间间隔。
备考讲义
考点8
Python标准datetime库函数
2.date类的创建和使用示例(B)
(1)创建date对象
Import datetime　# 创建一个time对象,表示当前时间
now_time=datetime.datetime.now(　　).time()
print(now_time)　# 输出 13：54：38.123456
some_time=datetime.time(hour=12,minute=30,second=0,microsecond=0)　# 创建一个指定时间的time对象
print(some_time)　# 输出 12：30：00
(2)date对象的使用
import datetime
some_day=datetime.date(2023,07,31)　# 创建一个指定日期的date对象
year=some_day.year
month=some_day.month
day=some_day.day　# 获取年、月、日
print(year,month,day)　# 输出 2023 07 31
previous_day=some_day - datetime.timedelta(days=1)　# 计算某个日期之前或之后的日期
next_day=some_day+datetime.timedelta(days=1)
print(previous_day)　# 输出 2023-07-30
print(next_day)　# 输出 2023-08-01
3.time类(B)
time类表示时间,其中包含时、分、秒、微秒等信息,主要用到的属性有： hour：小时数,minute：分钟数,second：秒数,microsecond：微秒数。
(1)创建time对象
import datetime
now_time=datetime.datetime.now().time()　# 创建一个time对象,表示当前时间
print(now_time)　# 输出 13：54：38.123456
some_time=datetime.time(hour=12,minute=30,second=0,microsecond=0)　# 创建一个指定时间的time对象
(2)time对象的使用
import datetime
some_time=datetime.time(hour=12,minute=30,second=0,microsecond=0)　# 创建一个指定时间的time对象
hour=some_time.hour
minute=some_time.minute
second=some_time.second
microsecond=some_time.microsecond　# 获取小时、分钟、秒、微秒
print(hour,minute,second,microsecond)　# 输出 12 30 0 0
other_time=datetime.time(hour=13,minute=0,second=0,microsecond=0)　# 比较两个时间的先后
if some_time　　print(“some_time is earlier than other_time”)
else：
　　print(“some_time is later than other_time”)
4.datetime类(B)
datetime类表示日期和时间,其中包含年、月、日、小时、分钟、秒、微秒等信息,主要用到的属性有：year：年份,month：月份,day：日期,hour：小时数,minute：分钟数,second：秒数,microsecond：微秒数。
(1)创建datetime对象
import datetime
now_datetime=datetime.datetime.now()　#创建一个datetime对象,表示当前日期和时间
print(now_datetime)　# 输出 2023-07-31 13：59：45.305617
some_datetime=datetime.datetime(2023,07,31,12,0,0)　#创建一个指定日期和时间的datetime对象
print(some_datetime)　# 输出 2023-07-31 12：00：00
(2)datetime对象的使用
import datetime
some_datetime=datetime.datetime(2023,07,31,12,0,0)　year=some_datetime.year
month=some_datetime.month
day=some_datetime.day
hour=some_datetime.hour
minute=some_datetime.minute
second=some_datetime.second
microsecond=some_datetime.microsecond　# 获取年、月、日、小时、分钟、秒、微
print(year,month,day,hour,minute,second,microsecond)　# 输出 2023 07 31 12 0 0 0
previous_datetime=some_datetime - datetime.timedelta(days=1)　# 计算某个日期和时间之前或之后的日期和时间
next_datetime=some_datetime+datetime.timedelta(days=1)
print(previous_datetime)　# 输出 2023-07-30 12：00：00
print(next_datetime)　# 输出 2023-08-01 12：00：00
例11　从给定的日期当中判断是星期几。
【试题分析】 本题主要考查学生对datetime库的理解与综合应用能力,利用datetime.date(yyyy,mm,dd).strftime(“%A”)可以直接获取指定日期是星期几。
【解析】 通过以上分析可知先导入datetime库,再利用datetime.date(yyyy,mm,dd).strftime(“%A”)函数即可获得指定日期是星期几了。
答案：
import datetime
x=datetime.date(2023,8,1).strftime(“%A”)
print(x)
变式训练8　设计程序从当前日期获取年、月、日、小时、分钟。
import datetime
now=datetime.datetime.now()
print(now.year, now.month, now.day, now.hour, now.minute, now.second)
【试题分析】 本题主要考查学生对datetime库的理解与综合应用能力,先把当前的时间值赋给now这个变量,再利用now.year, now.month, now.day, now.hour, now.minute, now.second分别获取当前日期年、月、日、小时、分钟。
【解析】 根据以上分析可得到以上程序,此题的关键是要在理解的基础上记住datetime库的常用方法与函数。
random库(D)
在Python中用于生成随机数的模块是random,在使用前需要import。下面看下它的常见函数用法。注意,随机函数使用前都需要先用import random语句导入random库。
备考讲义
考点9
Python标准random库函数
1.random.random()函数
random.random()函数用于生成一个0到1的随机符点数： 0<=n<1.0。
print (“random 1 ：”,random.random())　# 生成一个随机数
结果： 0.3558774735558118
2.random.uniform()函数
用于生成一个指定范围内的随机浮点数,两个参数其中一个是上限,一个是下限。如果a>b,则生成的随机数b<=n<=a。如果 aprint (random.uniform(1,10))
结果：2.1520386126536115
3.random.randint()函数
random.randint()函数的原型为random.randint(a,b),用于生成一个指定范围内的整数。其中参数a是下限,参数b是上限,生成的随机数a<=n<=b,注意： 下限必须小于上限。
print (random.randint(11,20))　#生成的随机数11<=n<=20
结果：11
4.random.randrange()函数
random.randrange()函数的原型为random.randrange([start],stop[,step]),从指定范围内,按指定基数递增的集合中获取一个随机数。
print (random.randrange(10,18,2))
结果：14
5.random.choice()函数
random.choice()函数的功能是从序列中获取一个随机元素。其函数原型为random.choice(sequence)。参数sequence表示一个有序类型。
print (random.choice(“”))
结果：t
6.random.shuffle()函数
用于将一个序列中的元素打乱。如：
list=[1,2,3,4,5,6,7,8,9,10]
random.shuffle(list)
print (list)
结果：[4,1,9,3,2,7,10,6,8,5]
7.random.sample()函数
从指定序列中随机获取指定长度的片断。但sample函数不会修改原有序列。
list=[1,2,3,4,5,6,7,8,9,10]
slice=random.sample(list,5)　#从list中随机获取5个元素,作为一个片断返回
print (slice)
print (list)　#原有序列不会改变。
结果：[8,2,6,7,9]
[1,2,3,4,5,6,7,8,9,10]
例12　设计程序利用随机函数自动生成随机密码。
【试题分析】 本题主要考查学生对random库及循环结构的理解与综合应用能力,当然也要能熟练掌握字符串的常用操作。可以使用for循环,利用随机函数随机选择字母数字字符来生成密码字符串(这些字符串通常囊括了键盘上的所有字符)。
【解析】 根据以上分析,先导入random、string库,再请用户输入密码长度,接着调用字符串函数建立一个字符串包括键盘上的所有字符,最后利用随机函数随机选择字母数字字符来生成密码字符串并输出结果。
答案：
import random,string
pwd_length=int(input(“请设置密码长度：”))
char=string.ascii_letters+string.digits+string.punctuation
#每组生成五个密码　
for n in range(5)：
　　pwd=""
　　for i in range(pwd_length)：
　　　　pwd=pwd+random.choice(char)
　　print(“密码： {}”.format(pwd))
变式训练9　用蒙特卡诺算法求圆周率。
import random,math
cs=0
for p in range(1000000):
　　x=random.random()
　　y=random.random()
　　r=math.sqrt(x**2+y**2)
　　if r<=1:
　　　　cs+=1
mypi=(cs/p)*4
print(mypi)
【试题分析】 本题主要考查学生对random库及循环结构的理解与综合应用能力,用蒙特卡诺算法求圆周率先调用随机函数生成1000000个点(横坐标、纵坐标都在0至1之间),然后根据点到圆心的距离判断该点是否在圆里面,最后用点在圆内的百分比计算圆周率。
【解析】 根据以上分析可得到以上程序,此题的关键是学生对用蒙特卡诺算法及循环控制结构要熟练掌握。
迭代器和生成器是Python中非常重要的概念。它们都提供了一种高效地处理序列的方式。理解和熟练使用迭代器和生成器,可以帮助你写出更简洁、更高效的Python代码。
备考讲义
考点10
Python迭代器与生成器
1.迭代器(Iterators)(D)
在Python中,迭代器是一个可以记住遍历的位置的对象。迭代器对象从迭代对象的第一项元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。字符串,元组或列表等可迭代对象都可以用于创建迭代器。
迭代器实现了两个基本的方法,分别是 _iter_() 和 next()。
my_tuple=(“apple”,“banana”,“cherry”)
my_iter=iter(my_tuple)
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
这段代码中,首先我们定义了一个元组 my_tuple,然后通过 iter() 函数得到了这个元组的迭代器 my_iter。之后,我们通过 next() 函数来依次访问这个迭代器中的元素。
2.自定义迭代器(B)
我们也可以创建自己的迭代器对象。要创建一个迭代器对象,你需要定义一个类,然后在这个类中实现 _iter_() 和 _next_() 方法。
下面是一个简单的自定义迭代器的例子。
class MyNumbers：
　def _iter_(self)：
　　self.a=1
　　return self
　def _next_(self)：
　　x=self.a
　　self.a+=1
　　return x
my_class=MyNumbers()
my_iter=iter(my_class)
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
在这段代码中,我们定义了一个 MyNumbers 类,这个类实现了_iter_()和_next_()方法,因此它可以被视为一个迭代器类。我们可以创建这个类的对象,并通过 iter() 函数得到它的迭代器。
3.生成器(Generators)(D)
生成器是一种特殊的迭代器,但是不需要去实现类的 _iter_() 和 _next_() 方法。一个函数只要包含了 yield 语句,那么这个函数就是一个生成器。
生成器是一种使用方便的创建迭代器的方法。下面是一个简单的生成器的例子。
def my_gen(　　)：
　n=1
　print('This is printed first')
　yield n

　n+=1
　print('This is printed second')
　yield n
　n+=1
　print('This is printed last')
　yield n
a=my_gen(　　)next(a)next(a)next(a)
在这段代码中,my_gen 是一个生成器函数,它使用了 yield 语句。我们可以直接调用 next() 函数来获取生成器中的下一个值。
4.生成器表达式(B)
生成器表达式是Python的一种高级特性,它是一种非常简洁并且高效地创建生成器的方式。它的语法形式与列表推导式非常相似,只不过把方括号 [] 换成了圆括号()。
下面是一个生成器表达式的例子。
gen=(x**2 for x in range(10))
for value in gen：
　　print(value)
在这个例子中,gen 是一个生成器,它使用了生成器表达式 (x**2 for x in range(10)) 来创建。这个生成器会生成0到9的平方数。然后,我们可以通过for循环来迭代这个生成器,并打印出每个生成的值。与列表推导式相比,生成器表达式的优势在于它不会一次性生成所有的元素,而是在每次迭代时才生成下一个元素。因此,当你需要处理的序列非常大,或者你只需要处理序列的前几个元素时,使用生成器表达式可以节省大量的内存。
5.生成器和迭代器的区别(B)
虽然生成器和迭代器都可以用于for循环的遍历,但是它们之间有明显的不同之处。
(1)实现方式不同
生成器使用了yield语句来实现,而迭代器使用了类的方法_iter_()和_next_()来实现。
(2)生成方式不同
生成器可以逐个生成序列中的值,而迭代器一次性生成整个序列,将其存储在内存中。
(3)执行方式不同
生成器像函数一样调用和执行,可以在每次迭代时产生和恢复值,而迭代器则按照序列的下一个元素依次执行。
(4)功能不同
生成器主要用于生成序列,而迭代器主要用于遍历序列。
例13　创建一个迭代器对象,并用迭代器方法输出对象中的每一个元素。
【试题分析】 本题主要考查Python考纲中最难的一个知识点迭代器与生成器的理解与综合应用能力,当然学生也要初步理解与掌握Python中类的定义与对象的生成。先定义了一个MyNumbers类,这个类中实现了_iter_()和_next_()方法,因此它可以被视为一个迭代器类。然后创建这个类的对象,并通过iter()函数得到它的迭代器。最后用next()方法输出对象中的每一个元素。
【解析】 根据以上分析,先定义一个MyNumbers类,在类中实现_iter_()和_next_()方法,然后用这个类创建一个对象my_class,并通过iter()函数得到它的迭代器。最后用next()方法输出对象中的每一个元素,得到的输出结果是1、2、3、4。
答案：
class MyNumbers：
　def _iter_(self)：
　　self.a=1
　　return self
　def _next_(self)：
　　x=self.a
　　self.a+=1
　　return x
my_class=MyNumbers()
my_iter=iter(my_class)
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
变式训练10　读程分析运行结果。
class CustomContainer：
　　def _init_(self) ->None：
　　　　self.data=[1,2,3,4,5]

　　def _contains_(self,element)：
　　　　if element in self.data：
　　　　　　return True
　　　　else：
　　　　　　return False
if _name_==“_main_”：
　　# test container：
　　container=CustomContainer()
　　print(“1 in container：”)
　　print(1 in container)
　　print(“10 in container：”)
　　print(10 in container)
运行结果：______________
______________
______________
______________。
1 in container:
True
10 in container:
False
【试题分析】 本题主要考查Python考纲中最难的一个知识点迭代器与生成器的理解与综合应用能力,当然学生也要初步理解与掌握Python中类的定义与对象的生成。先定义了一个CustomContainer类,用这个类创建一个container对象,再分别两次调用,第一次调用判断1是否包含在container对象中,第二次调用判断10是否包含在container对象中,因此结果第一次为True,第二次为False。
【解析】 根据以上分析可知结果为第一次为True,第二次为False。
一、单项选择题
1.在 Python中,关于函数的描述,以下选项中正确的是(　　　)
A.函数eval()可以用于数值表达式求值,例如eval(“2*3+1”)
B.Python函数定义中没有对参数指定类型,这说明,参数在函数中可以当作任意类型使用
C.一个函数中只允许有一条return 语句
D.Python中,def和return是函数必须使用的保留字
A
2.在Python中,以下关于函数的描述错误的是哪一项(　　　)
A.在Python中,关键字参数是让调用者通过使用参数名区分参数,在使用时不允许改变参数列表中的参数顺序
B.在Python中,默认参数的值可以修改
C.在Python中,引入了函数式编程的思想,函数本身亦为对象
D.在Python中,函数的return语句可以以元组tuple的方式返回多个值
A
3.关于Python函数参数传递中,形参与实参的描述错误的是
(　　　)
A.实参与形参分别存储在各自的内存空间中,是两个不相关的独立变量
B.Python实行按值传递参数。值传递指调用函数时将常量或变量的值传递给函数的参数
C.实参与形参的名字必须相同
D.在函数内部改变形参的值时,实参的值一般是不会改变的
C
4.以下关于模块的描述中错误的是(　　　)
A.一个完整的Python文件即是一个模块,是增强Python功能的扩展
B.用import导入了模块之后,可以按照“模块.函数”的格式使用这个模块的函数
C.模块中不仅包含函数,还常常包含一些属性和子类
D.Python目前还不支持一次性导入多个模块
D
5.以下关于Python的说法中正确的是哪一项(　　　)
A.Python中函数的返回值如果多于1个,则系统默认将它们处理成一个字典
B.递归调用语句不允许出现在循环结构中
C.在Python中,一个算法的递归实现往往可以用循环实现等价表示,但是大多数情况下递归表达的效率要更高一些
D.可以在函数参数名前面加上星号*,这样用户所有传来的参数都被收集起来然后使用,星号在这里的作用是收集其余的位置参数,这样就实现了变长参数
D
6.假设函数中不包括global 保留字,对于改变参数值的方法,以
下选项中错误的是(　　　)
A.参数是列表类型时,改变原参数的值
B.参数是组合类型(可变对象)时,改变原参数的值
C.参数的值是否改变与函数中对变量的操作有关,与参数类型无关
D.参数是整数类型时,不改变原参数的值
C
二、读程题
7.下面程序运行结果是__________。
def　Test(a,b,c=10,*argc,**kw)：
　　　sum=a+b+c
　　　for d in argc：
　　　　　sum+=d
　　　for v in kw.values()：
　　　　　sum+=v
　　　return sum
print(Test(10,20,30,50,60,aa=70,bb=90,cc=100))
430
8.写出下面程序的功能： ____________________________________________________。
import random
x=[]
for i in range(10)：
　　x.append(random.randint(0,100))
print(x)
for i in range(len(x)-1,-1,-1)：
　　if x[i]%2==1：
　　　　del x[i]
print(x)
生成一个包含10个随机整数的列表,然后删除其中所有奇数。
9.输入任意一个整数,调用prime()函数输出其所有的素数因子,例如输入345,则输出“3 5”,程序允许多次输入。请根据要求完善程序。
from　math　import　sqrt
def　isprime(x)：
　　　　if　x==1：
　　　　　　return　False
　　　　k=int(_①_)
　　　　for　j　in　range(2,_②_)：
　　　　　　　　if　x%j==0：
return　False
　　　　return　True
#主程序
flag='y'
while(flag=='y') ：
　　　　num=eval(input("please　input　a　number ："))
　　　　for　i　in　range(2,num)：
　　　　　　　　if _③_ and _④_
print(_⑤_,end=")
flag=input("\\nIf　you　want to　input　another　number,input y：")
①________________　②________________　
③________________　④________________　
⑤________________
math.sqrt(x)
k+1
isprime(i)
num%i==0　
i
三、编程题
10.随机抽样调查。从全体员工(100人)中随机选10人做抽样调查。注：员工用ID号(1-100)来标识。
解:import random
zg=list(range(1,101))
yb=set()
while len(yb)<10:
k=random.randint(1,100)
yb.add(zg[k])
print(yb)

展开更多......

收起↑