day09
问题：
Def mysum（a，b）：
Print（a+b）
r = mysum(100,200)
printr(r) #请问r 绑定的是什么？
让mysum返回一个加法的结果：
def mysum (a,b)
result = a+b
r = mysum(100, 200)
print(result) # 打印错误
函数说明：
函数外部无法访问函数内部的局部变量
函数内部可以访问函数外部的变量，但不能修改函数外部变量的绑定关系
例如：
X = 0
Def myadd （a，b）
X = a + b
Myadd（100,200）
Print（x）#0
Rerurn 语句
语法：
Return [表达式]
注：[]代表内容可省略
作用：
用于函数中，结束当前的函数的执行，返回调用该函数的地方，同时返回表达速度引用关系
说明：
Return语句后跟的表达式可以省略，省略后相当于return
None
如果函数内没有return语句，则函数执行完最后一条语句后返回none（相当于在最后加了一条 return none语句）
示例：
# def say_hello():
# print('1')
# print('1')
# return '您好'
# print('1')
# r = say_hello()
# print(r)
1
1
您好
练习：
1. 写一个函数mymax，实现返回两个数的最大值：
如：
Def mymax（a，b）
Print（mymax（100,200）） #200
Print（mymax（‘ABC’,’ABC’）） #ABC
答案： # def mymax (a,b):
# if a > b:
# return(a)
# else:
# return(b)
# print(mymax(300,200))
# print(mymax('ABC','ACB'))
2. 写一个函数 input_numbr
Def input_numbr():
此函数用来获取用户循环输入的整数，当输入负数时结束输入将用户输入的数字以列表的形式返回，再用内建数max，min，sum求出用户属兔的最大值，最小值和平均值
L = input_numbr( ):
Print（‘用户输入的最大值是:’，max（l））
Print（‘用户输入的最小值是:’，min（l））
Print（‘用户输入的平均值是:’，sum（l））
答案：
# def input_numbr ():
# l = []
# while True:
# a = int(input('请输入一个整数'))
# if 0 > a:
# break
# l.append(a)
# return l
# l = input_numbr()
# print(l)
# print('最大:',max(l),'最小:',min(l),'平均值:',sum(l)/len(l))
函数的参数传递
传递方式：
（1）位置传参
序列传参
（2）关键词传参
字典关键字传参
位置传参：
实际传递参数（一下简称‘实参’）与形式参数（形参）
的对应关系按位置来依次对应
示例：
# def myfun(a,b,c)
"""注意此函数不会变"""
# print('a = ',a)
# print('b = ',b)
# print('c = ',c)
# myfun(1,2,3)
结果：
a = 1
b = 2
c = 3
序列传参：
序列传参是指在函数调用过程中用‘*’将序列拆解后按位置进行传递的传参方式
示例：
def myfun(a,b,c):
#"""注意此函数不会变"""
print('a = ',a)
print('b = ',b)
print('c = ',c)
#myfun(1,2,3)位置传参
s = "ABC"
l = [4,5,6]
t = (1.1,2.2,3.3)
myfun(*s)
myfun(*l)
myfun(*t)
结果：
a = A
b = B
c = C
a = 4
b = 5
c = 6
a = 1.1
b = 2.2
c = 3.3
关键字传参：
关键字传参是指传参时，按着形参的名称给形参赋值
实参和形参按名称进行匹配
示例：
def myfun(a,b,c):
#"""注意此函数不会变"""
print('a = ',a)
print('b = ',b)
print('c = ',c)
myfun(b=2,a=1,c=3)
myfun(c=333,b=222,a=111)
结果：
a = 1
b = 2
c = 3
a = 111
b = 222
c = 333
字典关键字传参：
是指实参为字典，将字典用“*”拆解后进行关键传参的传参方式
示例：
def myfun(a,b,c):
#"""注意此函数不会变"""
print('a = ',a)
print('b = ',b)
print('c = ',c)
d = {'a':111,'b':333,'c':222}
myfun(**d)#d等同于 myfum(a=111,b=222,c=333)
结果：
a = 111
b = 333
c = 222
说明：
字典的键名和形参名必须一致
字典的键名必须为字符串（且必须为标识符的规则）
字典的键名要（）
函数的综合传参：
函数的传参方式在能确定形参能唯一匹配到应实参的情况下可以任意组合
要求；
位置传参在前，关键字传参在后
示例：
def myfun(a,b,c):
#"""注意此函数不会变"""
print('a = ',a)
print('b = ',b)
print('c = ',c)
myfun(1,c=3,b=2)#对的
#myfun(b=2,a=1,3)#错的
myfun(100,*[200,300])
#myfun(*'AB',300错的
myfun(*[100],c=300,b=200)#正确
结果：a = 1
b = 2
c = 3
a = 100
b = 200
c = 300
a = 100
b = 200
c = 300
练习：
1. 利用上题获取用户名的数字列表写一个函数split_number（L）传入得到的列表， 将所有的数字分为奇数和偶数，分别放在两个列表odds和evens中
同时返回这两个列表打印其中的数据
Def split_number（L）
此处自己实现
L = input_number（）# 1，2，3，4，5,6
t =split_number（L）#返回一个元组，元组里放两个列表
odds，evens = t
print（‘所有的奇数是：’，odds） #[1,3,5]
print（‘所有的偶数是：’，evens） #[2,4,6]
def input_number():
答案：
L = [] # 创建一个列表,准备存储数字
# 此处自己实现
while True:
n = int(input("请输入一个正整数"))
if n < 0:
break
L.append(n)
return L
def split_number(L):
L1 = [] # 用来存放奇数
L2 = [] # 创建一个列表,用来存放偶数
for x in L:
if x % 2 == 1:
L1.append(x)
else:
L2.append(x)
return (L1, L2) # 打包成为元组后返回
lst = input_number() # 1, 2, 3, 4, 5, 6
t = split_number(lst) # 返回一个元组,元组里放两个列表
odds, evens = t
print("所有的奇数是:", odds) # [1, 3, 5]
print("所有的偶数是:", evens) # [2, 4, 6]
----------以下讲函数是定义和创建时形参的定义------------------
函数的缺省参数
语法
def 函数名（形参名1=默认实参1，形参名2=默认实参2，..）
示例：
# def info(name,age=1,address='未填写'):
# print(name,'今年',age,'岁','住在:',address)
# info('小李')
# info('tarena',15)
# info('小其',3,'北京市朝阳区')
结果：
小李 今年 1 岁 住在: 未填写
tarena 今年 15 岁 住在: 未填写
小其 今年 3 岁 住在: 北京市朝阳区
说明：
1.缺省参数必须自右向左依次存在，如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数
def fa（a=1, b, c=3）# 是错误
def fd(a, b=10, c): #是错误
2. 缺省参数可以有0个或多个，甚至全部都是缺省出参数
练习：
写一个函数myadd，此函数可以计算两个数的和，可以计算三个数的和
Def myadd(……….)
………..
Print(myadd(10,20)) #30
Print(myadd(100,200,300)) #600
答案：
# def myadd(a=0,b=0,c=0):
# he = a + b + c
# return he
# print('和',he)
# print(myadd(10,20))
# print(myadd(100,200,300))
结果：
30
600
函数形参的定义方式：
位置形参
星号元组形参
命名关键词形参
双星号字典形参
位置形参：
语法：
def 函数名（形参名1，形参名2，….）
语句块
星号元组形参：
语法：
def 函数名（*元组形参名）：
语句块
作用：
收集多余的位置传参
示例：
# def fb(*args):
# print('实参的个数是:',len(args))
# print('args=',args)
# fb()
# fb(1,2,3,4,5)
结果：
实参的个数是: 0
args= ()
实参的个数是: 5
args= (1, 2, 3, 4, 5)
练习：
写一个函数，mysum（可以传如任意个实参，返回所有实参的和）
Def mysum(*srgs):
……….
Print(mysum(1,2,3,4) #10
Print(mysum(5,6,7,8,9,10)) #45
答案：
# def mysum(*srgs):
# return sum (srgs)
# print('实参的和',mysum(1,2,3,4))
# print('实参的和',mysum(5,6,7,8,6,10,11))
结果：
实参的和 10
实参的和 53
命名关键字形参
语法:
Def 函数名（*，命名关键字形参）：
语句块
或
Def 函数名（*args，命名关键字形参）：
语句块
作用：
强制所有的传参都必须用关键字传参
示例：
def fa(a,b,*,c,d):
'''强制c,d必须用关键字传参'''
print(a,b,c,d)
fa(1,2,c=300,d=400)#对的
#fa(1,2,3,4)#错的
def fb(a,b,*args,c,d):
print(a,b,*args,c,d)
fb(1,2,3,4,c=300,d=400)
结果：
1 2 300 400
1 2 3 4 300 400
双星号字典形参
语法：
Def 函数名（**字典形参名）：
语句
作用：
收集多余的关键字传参
示例：
# def fa(**kwargs):
# print('多余的关键字传参的个数是:',len(kwargs))
# print('kwsrgs =',kwargs)
# fa(a=10,b=20,c=30)
结果：
多余的关键字传参的个数是: 3
kwsrgs = {'a': 10, 'b': 20, 'c': 30}
函数的参数说明：；
位置形参，星号元组形参，命名关键字形参，双星号字典形参，缺省参数可以混合使用
函数参数自左至右的顺序依次为：
位置形参
星号元组形参
命名关键字形参
双星号字典形参
示例：
Def fn (a,b,*args,c,d,**kwargs):
Pass
Fn (1,2,3,4, c = 100, d=200, e =300, f=400)
练习：
思考题：
查看：
>>> help(print)
猜想print函数的参数列表是如何定义的？？？
2.写一个myrange函数，参数可以传1~3个，实际意义同range函数规则相同，此函数返回符合range（…）函数规则的列表
如：
# def myrange(start, stop=None, step=1):
# # 调整三个形参的值
# if stop is None:
# stop = start
# start = 0
# return list(range(start, stop, step))
# L = myrange(4)
# print(L) # [0, 1, 2, 3]
# L = myrange(4, 6)
# print(L) # [4, 5]
# L = myrange(1, 10, 3)
# print(L) # [1, 4, 7]
# L = myrange(10, 1, -3)
# print(L)]
练习：
1. 算出100~999之间的水仙花数，水仙花数是指百位的3次方，加上 十位的3次方 加上个位的3次方等于原数的整数
例如：
153等于1**3+5**3+3**3
建议先写一个函数is_narcissistic(n)
来判断n是否为水仙花数，如果是返回True，否则返回False再调用此函数进行判断
2. 求100以内的全部素数（质数）
2 3 5 7 11 ………
建议用函数来做
两个函数：
Def is_prime(x):
#判断是否为素数
Def print_prinmes(n)
#打印小于n的全部素数
3. 求上次学生列表改写为两个函数：
1） def input_studet():
#此函数返回用户输入的学生信息的列表；
#返回的列表的格式与之前完全相同
2） def output_student(L)
…#此函数把传入的列表L打印成为表格…
主程序调用：
Docs = input_studet
Output_student(docs)
Print(‘请再添加几个学生信息’)
Docs += input_studet()
答案：
1. # def is_narcissistic(n):
# l = []
# a = n // 100
# b = (n % 100) // 10
# c = n % 10
# if a**3 + b**3 + c**3 == n:
# return('True')
# else:
# return('False')
# for n in range(100,1000):
# if is_narcissistic(n)== 'True':
# print('100~999水仙花数为:',n)
#2
# def is_prime(x):
# '''判断x是否为素数,如果是素数返回True,
# 否则返回False'''
# if x < 2:
# return False
# # 走到此处时,x 一定大于等于2
# for i in range(2, x):
# if x % i == 0: # 能整除就一定不是素数
# return False
# return True
# def print_primes(n):
# '''此函数打印小于 n的全部素数'''
# for x in range(n):
# if is_prime(x):
# print(x, end=' ')
# print() # 换行
# print_primes(100) # 开始打印....
#3
# print_primes(100) # 开始打印....
# def input_student():
# '''此函数返回用户输入的学生信息的列表
# 返回的列表格式写之前完全相同
# '''
# L = [] # 创建一个列表，用来保存所有学生的字典
# # 读取学生数据放入列表中
# while True:
# n = input("请输入学生姓名: ")
# if not n: # 如果学生姓名为空则结束输入
# break
# a = int(input("请输入学生年龄: "))
# s = int(input("请输入学生成绩: "))
# # 把上述n, a, s 所表示的信息形成字典，并加入到列表
# d = {} # 创建一个新字典，准备存入学生信息数据
# d['name'] = n
# d['age'] = a
# d['score'] = s
# L.append(d) # 把字典存入列表中
# return L
# def output_student(L):
# '''此函数把传入的列表L 打印成为表格'''
# # 第二步，显示所有学生的信息
# print("+---------------+----------+----------+")
# print("| name | age | score |")
# print("+---------------+----------+----------+")
# # 此处打印所有学生的信息
# for d in L: # 把每个学生的数据取出来，用d绑定对应的字典
# center_name = d['name'].center(15)
# str_age = str(d['age']) # 先将年龄转为字符串
# center_age = str_age.center(10) # 生成居中的字符串
# center_score = str(d['score']).center(10)
# line = "|%s|%s|%s|" % (center_name,
# center_age,
# center_score)
# print(line)
# print("+---------------+----------+----------+")
# def main():
# docs = input_student()
# output_student(docs)
# print("请再添加几个学生信息...")
# docs += input_student()
# print("添加之后的学生信息是")
# output_student(docs)
# main()