python 作业

Python程序设计第10周实验报告
班级：19数据 成绩：
实验日期： 2020 年 11 13日
实验目的： 体会有难度的Python函数

实验内容：
一、编程题
1、题目要求：

举例说明在函数内部修改形参的值不会影响实参。
程序文件名是 addone.py
程序源代码：
def addone(a):
print(a)
a+=1
print(a)

程序运行结果：

==========

a=3
addone(a)
3
4
a
3

分析：在函数内部修改了形参a的值，但是当函数运行结束时，实参a的值并没有被修改

2、题目要求：
举例说明位置参数。
程序文件名是 girth.py
程序源代码：
def girth(width,height):
return 2*(width+height)
print(girth(3))

程序运行结果：
Traceback (most recent call last):
File “F:\python\19数据班60号庄楠楠第10周实验报告（python)\girth.py”, line 3, in
print(girth(3))
TypeError: girth() missing 1 required positional argument: ‘height’

girth(5,12)
34
============ RESTART: F:\python\19数据班60号庄楠楠第10周实验报告（python)\girth.py ===========
Traceback (most recent call last):
File “F:\python\19数据班60号庄楠楠第10周实验报告（python)\girth.py”, line 3, in
print(girth(“ya”,2))
File “F:\python\19数据班60号庄楠楠第10周实验报告（python)\girth.py”, line 2, in girth
return 2*(width+height)
TypeError: can only concatenate str (not “int”) to str

分析：
没有特殊说明的参数为位置参数，实参按顺序依次传递给形参，要求形参与实参的数量,数据类型和顺序都一致

3、题目要求：
举例说明默认值参数。

程序文件名是 moren.py
程序源代码：
def say(message,times=1):
print((mesage+‘’)*times)

程序运行结果：

say.defaults
(1,)

say(‘holle’,3)
holle holle holle

def f(a=3,b,c=5):

SyntaxError: non-default argument follows default argument
程序文件名是 f1.py
程序源代码：
def f1(a,b,c=5):
print(a,b,c)

程序运行结果：
============= RESTART: F:/python/19数据班60号庄楠楠第10周实验报告（python)/f1.py =============

f(1,2)
1 2 5

============= RESTART: F:/python/19数据班60号庄楠楠第10周实验报告（python)/f1.py =============

f1(2,5,6)
2 5 6

程序文件名是 demo.py
程序源代码：
def demo(newitem,old_list=[]):
old_list.append(newitem)
return old_list
print(demo(‘5’,[1,2,3,4]))
print(demo(‘aaa’,[‘a’,‘b’]))
print(demo(‘a’))
print(demo(‘b’))

程序运行结果：
[1, 2, 3, 4, ‘5’]
[‘a’, ‘b’, ‘aaa’]
[‘a’]
[‘a’, ‘b’]

程序文件名是 demo1.py
程序源代码：
def demo1(newitem,old_list=None):
if old_list is None:
old_list=[]
new_list=old_list[:]
new_list.append(newitem)
return new_list
print(demo1(‘5’,[1,2,3,4]))
print(demo1(‘aaa’,[‘a’,‘b’]))
print(demo1(‘a’))
print(demo1(‘b’))

程序运行结果：

py ===========
None
None
[‘a’]
[‘b’]

分析：

1）“函数名.default” 可以查看函所有默认值参数的当前值，其返回值为一个元组，其中的元素依次表示每个默认值参数的当前值
2）如果只有第一个参数传递实参，那么第二个参数默认值为1 如果第二个参数也传递实参，就调用我们传入的实参
3）调用默认值参数的函数时，默认值参数必须在位置参数的右侧，且默认值参数的右侧不能在出现位置参数
4)默认值参数只在第一次调用时进行解释
4、题目要求：
根据课本例题5-1，编写求正方形面积的函数及主程序。
程序文件名是 area.py
程序源代码：
def area(n):

    if isinstance(n,(int,float)) and n>0:
            s=n*n
            y="边长为",n,"的正方形的面积是",s
            return y
    else:
            z=n,"不能为非正整数"
            return z

print(area(3))
print(area(-3))
print(area(“p”))
程序运行结果：
(‘边长为’, 3, ‘的正方形的面积是’, 9)
(-3, ‘不能为非正整数’)
(‘p’, ‘不能为非正整数’)

分析：
5、题目要求：

根据课本例题5-2，编写返回任意个实数的最大值、最小值、平均值的函数并调用

程序文件名是 num4.py
程序源代码：

def demo(*para):

a=[*para]
for i in range(0,len(para)-1,1):
    for n in range(i+1,len(para),1):
        if a[i]<a[n]:
            a[i],a[n]=a[n],a[i]

print("The max num is",a[0])
print("The min num is",a[len(a)-1])
avg=sum(para)/len(para)
print("avg is",avg)

demo(1,89,32,45)
程序运行结果：

(*para)用于序列解包，将任意个实数传入函数
在用排列的方法将列表里的数字从大到小排列，最大的数在第一位最小的在最后一位然后输出。最大最小数

The num max is 89
The min num is 1
avg is 41.75

分析：

6、题目要求：
编写函数，接收一个字符串，分别统计大写字母，小写字母，数字其他字符的个数

程序文件名是 num.py
程序源代码：
def num(s):
result=[0,0,0,0]
for ch in s:
if ‘a’<=ch<=‘z’:
result[0]+=1
elif ‘A’<=ch<=‘z’:
result[1]+=1
elif ‘0’<=ch<=‘9’:
result[2]+=1
else:
result[3]=(len(s)-result[0]-result[1]-result[2])
return tuple(result)
print(num(‘asdADFD125似懂非懂’))

程序运行结果：
(4, 3, 3, 4)

分析：
定义result接收大写字母，小写字母，数字其他字符的个数，如果字符串里有大写字母result[0]就+1大写字母，小写字母，数字也是如此，其他字符的个数就有字符长度-大小写字母与数字的个数
7、题目要求：
接收包含20个整数的列表lst和一个整数k作为参数，返回新列表处理规则为：将列表Lst中下标k 之前的元素逆序，下标K及k之后的元素逆序，然后将列表lst中所有元素逆序

程序文件名是：5-4 .py
程序源代码：

def demo(lst,k):

x=lst[:]
x[:k]=reversed(x[:k])
x[k:]=reversed(x[k:])
x.reverse()
return x

lst=list(range(1,21))
print(demo(lst,5))

程序运行结果：

============= RESTART: F:/python/19数据班60号庄楠楠第10周实验报告（python)/5-4.py ============
[6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5]

分析：
x=lst[:]为浅复制 将lst[:]复制到x中 截取字符串的全部字符
x[:k]=reversed(x[:k]) 截取从开头0到k之前的全部数 （左开右闭）并且把这些数逆序排列

x[k:]=reversed(x[k:]) 开始位置是从k开始一直到结束
然后把这些数全部逆序
8、题目要求：

调试课本例题5-5，体会reduce的作用。

程序文件名是func.py
程序源代码：
from functools import reduce

def func(factors,x):

    return result

factors=(3,8,5,9,7,1)
print(func(factors,1))

程序运行结果：

============ RESTART: F:/python/19数据班60号庄楠楠第10周实验报告（python)/func.py ============
33

分析：
reduce方法都会调用一次lambda函数
reduce 从factors中取前两个分别给a，b然后计算ax+b将结果看做新a再取factors中的下一个作为b依次类推得到结果

9、题目要求：

修改课本例题5-6，使其在20个随机整数中查找最大值及其出现的索引号
程序文件名是 5-6.py
程序源代码：
import random

def demo(lst):
m=max(lst)
result=(m,)+tuple((index for index,value in enumerate(lst) if value==m))
return result
x=[random.randint(1,20) for i in range(50)]
print(x)
print(demo(x))

程序运行结果：

[1, 15, 14, 16, 9, 20, 3, 14, 16, 3, 5, 17, 6, 10, 3, 18, 5, 15, 2, 9, 14, 1, 7, 12, 4, 4, 12, 11, 20, 8, 10, 5, 5, 7, 19, 9, 2, 19, 7, 16, 12, 4, 6, 9, 12, 14, 7, 18, 19, 16]
(20, 5, 28)

分析： x是1-20的50个可重复的数，把x传入demo()找到lst中的最大数
用max找到lst函数中的最大值，把最大值放在第一位，然后在寻找与最大值相等的数的下标

10、题目要求：
根据课本例题5-7，输出杨辉三角形的前8行数据。

程序文件名是 5-7.py
程序源代码：
def demo(t):
print([1])
print([1,1])
line=[1,1]
for i in range(2,t):
r=[]
for j in range(0,len(line)-1):
r.append(line[j]+line[j+1])
line=[1]+r+[1]
print(line)
demo(8)

程序运行结果：

============= RESTART: F:/python/19数据班60号庄楠楠第10周实验报告（python)/5-7.py ============
[1]
[1, 1]
[1, 2, 1]
[1, 3, 4, 1]
[1, 4, 5, 6, 1]
[1, 5, 6, 7, 8, 1]
[1, 6, 7, 8, 9, 10, 1]
[1, 7, 8, 9, 10, 11, 12, 1]
分析：
先把第一第二行的数确定好[1],[1,1]直接输出
第三行开始在[1] [1]之间增加数 利用双重for循环不断的往r里增加数
当i=2时 len(line)=2 j的范围[0,1）
r.append(line[0]+line[1])
即r=2
此时 line=[1,2,1]
内循环（对j的循环结束）
I+1=3(i是控制line的长度) j是控制r中元素的数字
此时 len(line)=3 j的范围[0,2）
r.append(line[0]+line[1])
即r=3
此时 line=[1,3,1]

接着进行内循环
r.append(line[1]+line[2])

Line=[1,3,4,1]
…….

11、题目要求：
调试课本例题5-8。

程序文件名是 5-8.py
程序源代码：
def IsPrime(n):
m=int(n**0.5)+1
for i in range(2,m):
if n%i0:
return False
return True
def demo(n):
if isinstance(n,int) and n>0 and n%20:
for i in range(3,n//2+1,2):
if IsPrime(i) and IsPrime(n-i):
print(i,‘+’,n-i,‘=’,n)
demo(60)

程序运行结果：

============ RESTART: F:/python/19数据班60号庄楠楠第10周实验报告（python)/5-8.1.py ===========
7 + 53 = 60
13 + 47 = 60
17 + 43 = 60
19 + 41 = 60
23 + 37 = 60
29 + 31 = 60

分析：
判断输入的数是否为正整数，在判断两数相加之和等于该正偶数的两个数是否为素数
12、题目要求：
根据课本例题5-9，编写求两个正整数的最大公约数的函数并调用。

程序文件名是 5-9.py
程序源代码：
def demo(m,n):

    while m!=0:
            r=n%m
            n,m=m,r
    return(n)

print(demo(30,20))

程序运行结果：

：两个整数的最大公约数等于其中较小的那个数和两数相除余数的最大公约数
证明：a可以表示成a = kb + r（a，b，k，r皆为正整数，且r<b），则r = a mod b
假设d是a,b的一个公约数，记作d|a,d|b，即a和b都可以被d整除。
而r = a - kb，两边同时除以d，r/d=a/d-kb/d=m，由等式右边可知m为整数，因此d|r
因此d也是b,a mod b的公约数
假设d是b,a mod b的公约数, 则d|b,d|(a-k*b),k是一个整数。
进而d|a.因此d也是a,b的公约数
因此(a,b)和(b,a mod b)的公约数是一样的，其最大公约数也必然相等，得证

分析：
11、题目要求：
调试课本例题5-10。

程序文件名是 5-10.py
程序源代码：
import random
def demo(x,n):
i=x.index(n) # 获取指定元素在列表里的索引
x[0],x[i]=x[i],x[0] #将指定元素与第0个元素交换
key=x[0]
j=len(x)-1
while i<j:
while i<j and x[j]>=key: #从后向前寻找第一个比指定元素小的元素

                    j-=1
            x[i]=x[j]

            while i<j and x[i]<=key: #从前向后寻找第一个比指定元素小的元素
                    i+=1
            x[j]=x[i]

    x[i]=key

x=list(range(1,10))
random.shuffle(x)
print(x)
demo(x,4)
print(x)

程序运行结果：

[3, 9, 8, 4, 5, 7, 6, 1, 2]
[4, 9, 8, 2, 1, 4, 6, 7, 5]

分析：

先指定一个元素，然后以第i个元素 n为基准 比较元素大小 比第i个元素大的元素放到n的后面 比n小的元素放到n前面

13、题目要求：
调试课本135页修饰器的代码。

程序文件名是 xishiqi.py
程序源代码：
def before(func): #定义修饰器
def wrapper(*args,**kwargs):
print(‘Before function called.’)
return func(*args,**kwargs)
return wrapper
def after(func):
def wrapper(*args,**kwargs):
result=func(*args,**kwargs)
print(‘After function called.’)
return result
return wrapper
@before
@after
def test():
print(3)
test()

程序运行结果：
=========== RESTART: F:/python/19数据班60号庄楠楠第10周实验报告（python)/xishiqi.py ==========
Before function called.
3
After function called.

分析：
在一个函数上面添加修饰符 @另一个函数名 的作用是将这个修饰符下面的函数作为该修饰符函数的参数传入
*args表示任何多个无名参数，它是一个tuple
**kwargs表示关键字参数，它是一个dict

二、>>>状态下调试的语句
1、调试的代码及运行结果：

def modify(v,item):#使用原地操作的append()方法为列表增加元素
v.append(item)

v=[2]
modify(v,3)

v
[2, 3]
def modify(d):
d[‘age’]=38

a={‘name’:‘Dog’,‘age’:37,‘sex’:‘male’}
modify(a)
a
{‘name’: ‘Dog’, ‘age’: 38, ‘sex’: ‘male’}

分析：
如果传递给函数的是Python可变序列（可变数据类型：列表list和字典dict；不可变数据类型：整型int、浮点型float、字符串型string和元组tuple），
不可变数据类型与可变数据类型的不同之处：
补充：不可变数据类型：当不同变量引用同一值时，变量的地址值相同，当在变量里增加值时变量的地址发生改变
可变数据类型：当不同变量引用同一值时，变量的地址值不同，但是往变量里增加元素时，变量的地址不发生改变
并且函数内部使用下标或序列自身原地操作的方法为可变序列增加删除元素或者修改元素值时，修改后的结果是可以反映到函数之外的实参也得到相应的修改

2、调试的代码及运行结果：

def demo(a,b,c=5):
print(a,b,c)

demo(1,2)
1 2 5
demo(c=3,a=8,b=10)
8 10 3

分析：
关键参数： 关键参数主要指调用函数时的参数传递方式，与函数定义无关通过关键函数可以按照参数名字传递值，实参顺序与形参顺序不一致，但是不影响参数值的传递结果，避免了用户牢记参数顺序的麻烦

3、调试的代码及运行结果：

def demo(*p):
print§

demo(1,2,3)
(1, 2, 3)

def demo(**p):
for item in p.items():
print(item)

demo(x=1,y=2,z=3) #关键参数
(‘x’, 1)
(‘y’, 2)
(‘z’, 3)

分析：
第一种形式可变长度参数的用法，无论调用该函数时传递了多少位置的实参，一律将其放在一个元组内
第二种形式可变长度参数的用法：在调用该函数时自动将接收到的关键参数转换为字典

3、调试的代码及运行结果：

def demo(a,b,c):
print(a+b+c)

seq=[1,2,3]
demo(*seq)
6
tup=(1,2,3)
demo(*tup)
6
dic={1:‘a’,2:‘b’,3:‘c’}
demo(*dic)
6
Set={1,2,3}
demo(*Set)
6
set={1,2,3}
demo(*set)
6
demo(*dic.values())
abc

demo(**{‘a’:12,‘b’:45,‘c’:41})
98

分析：
为含有多个形参函数传递参数时，可以使用python列表，元组，集合，字典以及其他可迭代对象作为实参并在实参前加一个星号，python解释器将自动进行解包，然后传递给多个单变量位置形参，如果使用字典对象作为实参，则默认使用字典的“键”，如果要将字典里的“键：值”作为参数则需要使用items()方法，如果需要将字典里的“值”作为参数，则需要调用字典里的values()方法
注：实参元素要与形参个数相等

使用字典作为函数实参，并在前使用两个星号**进行核解包，会把字典解包成关键参数进行传递，字典里的键作为参数名，字典里的‘值’作为参数值

5、调试的代码及运行结果：

def demo():
global x #声明或创建了全局变量
x=3
y=4
print(x,y)

x=5 #在函数外部定义了全局变量的值x
demo()#本次调用修改了全局变量x的值
3 4
x
3
y #局部变量在函数运行结束后自动删除
Traceback (most recent call last):
File “<pyshell#29>”, line 1, in
y #局部变量在函数运行结束后自动删除
NameError: name ‘y’ is not defined
del x #删除了全局变量x

demo() #本次调用创建了全局变量
3 4
x
3
y
Traceback (most recent call last):
File “<pyshell#34>”, line 1, in
y
NameError: name ‘y’ is not defined
‘局部变量在函数调用和执行结束后自动删除，在函数外部不可访问’
‘局部变量在函数调用和执行结束后自动删除，在函数外部不可访问’

x=3
def f():
print(x) #本意是输出全局变量x的值，但是不允许这样做
x=5
print(x)

f()
Traceback (most recent call last):
File “<pyshell#42>”, line 1, in
f()
File “<pyshell#41>”, line 2, in f
print(x) #本意是输出全局变量x的值，但是不允许这样做
UnboundLocalError: local variable ‘x’ referenced before assignment
def demo():
x=3 #创建了局部变量，并自动隐藏了同名的全局变量

x=5
demo()
x
5

分析：
局部变量：只作用函数内部，当函数运行结束时，局部变量被自动删除且不可访问 优点：比全局变量速度快，应优先考虑使用
全局变量：想在函数内部修改一个定义在函数外的变量值，这个变量不能是局部的，其作用域必须是全局，能够作用于函数内外可以用global来声明或定义
在函数内如果只引用某个变量的值而没有为其赋新值，该变量为（隐式的）全局变量，如果在函数内任意位置有为变量赋新值得操作，该变量被认为是（隐式）的局部变量，除非在函数内显示的使用了关键字global进行声明

在函数任意位置只要有为变量赋值的语句 那么在整个函数内该变量是局部变量在这条赋值语句之前不能有引用变量值得操作，否则会报错，除非在函数开始出使用global声明该变量为全局变量
如果局部变量与全局变量有相同的名字，那么该局部变量会在自己的作用域里隐藏同名的全局变量
6、调试的代码及运行结果：

f=lambda x,y,z:x+y+z #可以给lambda起名字

print(f(1,2,3))
6
l=[(lambda x:x2),(lambda y:y3),(lambda z:z**4)]
print(l0,l1,l2)
25 8 81

l=[1,4,6,7]
print(map((lambda x:x+10),l))
<map object at 0x0000014AFCA6BF10>
l
[1, 4, 6, 7]
print(list(map((lambda x:x+10),l)))
[11, 14, 16, 17]

def demo(n):
return n*n

demo(5)
25
a_list=[1,2,3,4,5]
list(map(lambda x:demo(x),a_list))
[1, 4, 9, 16, 25]
“包含函数调用并且没有名字的lambda表达式”
r=[]
for x in range(10):
r.append(lambda:x**2)

r0
81
r2
81

for x in range(10):
r.append(lambda n=x:n**2)
r0

0

r1
1
r5
25
分析：p(function,iterable,…)
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。
把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意，map不改变原list，而是返回一个新list。

print(map((lambda x:x+10),l))
<map object at 0x0000014AFCA6BF10>
这个样子是因为在python3里面，map()的返回值是iterators,而不是list， 所以想要使用，需将iterator 转换成list
修改如下：

print(list(map((lambda x:x+10),l)))

在使用lambda表达式时，要注意变量作用域带来的问题下面代码中变量x是在外部定义域中定义，对lambda表达式而言不是局部变量，从而导致错误
Lambda用来声明匿名函数即没有函数名字的临时使用的小函数只可以包含一个小表达式，不可以有复杂的语句，但是在表达式中可以调用其他函数，并支持默认值参数和关键参数，该表达式计算的参数就是函数的返回值。

Lambda常用于内置函数sorted(),max(),min(),和列表方法sort()的key参数，内置函数map(),filter()和标椎库参数reduce()的一个参数
7、调试的代码及运行结果：

分析：

8、调试的代码及运行结果：

分析：

9、调试的代码及运行结果：

分析：