函数 function
什么是函数：
函数是可以重复执行的语句块，可以重复使用
函数是面向过程编程的最小单位
函数的作用：
1.用于封装语句块，提高代码的重用性
2.定义用户级别的函数
def 语句 （把编码打包） call（调用）
语法：
def函数名（形参列表）：
语句块（代码块）
说明：
1.函数的名字就是语句块的名称
2.函数名的命名规则与变是一名相同（函数名必须为标识符）
3.函数名是一个变量（不要轻易对其赋值）
4.函数有自己的名字空间，在函数外部不可以访问函数内部的变量（注意）在函数内部可以访问函数外部的变量，要让函数处理外部的数据需要传入一些数据
5.函数如果不需要传入参数，则参数列表可以为空
6.语句部分不能为空，如果为空需要填充pass语句
作用：
用于创建函数，用函数名这个变量绑定这个函数
# 示例见： # 此示例示意用def语句定义一个没有参数的函数 def say_hello(): print("hello world!") print("hello china!") print("hello tarena!")
函数的调用表达式：
函数名（实际调用传递参数）
说明：
函数调用是一个表达式
如果没有return语句，函数执行完毕后返回None对象
# 示例见： # 此示例示意用def语句来定义带有参数的函数 # 此函数名为mymax，有两个形式参数a，b 用于接收实参的传递 # 此函数计算两个参数的最大值并打印 def mymax(a,b): print("a=",a) print ("b=",b) if a>b: print(a,"大于",b) else: print(a,"小于",b) mymax(100,200) #函数调用
练习：
# 3 写一个函数myadd，此函数中的参数列表里有两个参数x，y此函数的功能是打印 x+y的和 # 如： # def myadd(...): # ...# ... 部分自己实现 # myadd(100,200) #打印300 # myadd（"ABC","123"） #打印 ABC123 def myadd(x,y): z = x +y print("和是",z) myadd(100,200) # 打印 300 myadd("ABC","123") # 打印ABC123
# 写一个函数print_event,传入一个参数n代表终止的整数，打印0~n 之间所有的偶数 # 如： # def print_event(n): # ....此处自己完成 # print_even(10) # 打印： # 0 2 4 6 8
# 方法1 def print_event(n): for x in range(n): if x % 2==0: print(x) print_event(10)
# 方法2 def print_event(n): for x in range(0,n+1,2): print(x) print_event(10)
return 语句：
语法：
return[表达式]
注：[]代表其中的内容可省略
作用：
用于函数中，结果当前函数的执行，返回到调用该函数的地方，同时返回
一个对象的引用关系
说明：
1.return 语句先执行右侧的表达式，再将表达式的执行结果送回给当前函数的调用者
2.return 语句右侧的表达式可以省略，省略后相当于 return None
3.如果函数内没有return语句，则函数执行完最后一条语句后返回None）
（相当于在最后加了一条return None语句）
# 示例见： # 此示例示意return语句在函数中的应用 def say_hello2(): print("hello aaa") print("hello bbb") #return 1+ 2 #等同于 return None return [1,2,3,4,5] print("hello ccc") v = say_hello2() print("v=",v) v2 = say_hello2() print("v2=",v2)
练习：
# 1.写一个函数mymax，实现返回两个数的最大值： # 如： # def mymax(a,b): # ... # print(mymax(100,200))#200 # print(mymax(100,200))#ABCD # 方法1 def mymax(a,b): s = max(a,b) return s print(mymax(100,200)) print(mymax("ABC","ABCD")) # 方法2 def mymax(a,b): zuida = a if b > zuida: zuida = b return zuida print(mymax(100,200)) print(mymax("ABC","ABCD")) # 2.写一个函数myadd，实现给出两个数，返回这个两个数的和 # 如： # def myadd(x,y): .... # a = int(input("请输入第一个数："） # b = int(input("请输入第二个数："） # print("你输入的两个数的和是：",myadd(a,b)) def myadd(x,y): return x+y a = int(input("请输入第一个数：")) b = int(input("请输入第二个数：")) print("你输入的两个数的和是：",myadd(a,b)) # 3.写一个函数，input_number # def input_number(): # ...# 此处自己实现，此函数返回列表 # 此函数用来获取用户循环输入往返整数，当用户输入负数时结束输入 # 将用户输入的数字以列表的形式返回，再用内建函数max，min，sum # 求出用户输入的最大值，最小值以及和 # L = input_number() # print("用户输入的最大数是：",max(L)) # print("用户输入的最小数是：",min(L)) # print("用户输入的全部数的和是：",sum(L)) def input_number(): # 1.创建空列表 l = [] # 2.循环读取用户输入的正整数，存入在述列表 while True: n = int(input("请输入用户数字：")) if n<0: break# 此处自己实现，此函数返回列表 l.append(n) # 3.返回上述列表的引用关系 return l L = input_number() print("用户输入的最大数是：",max(L)) print("用户输入的最小数是：",min(L)) print("用户输入的全部数的和是：",sum(L))
python函数的参数传递（把数据给函数）
传递方式：
位置传参
序列传参
关键字传参
字典关键字传参
位置传参：
实际参数（实参）的对应关系与形式参数（形参）的对应关系是按位置来依次对应的
示意：
def mymin（a，b，c） pass mymin（1,2,3）
说明：
实际参数和形式参数通过位置进行传递和匹配
实际参数的个数必须与形式参数的个数相同
# 示例： # 此示例示意位置传参 def myfunl(a,b,c): "这是一个函数的传参的示例" print("a的值是：",a) print("b的值是：",b) print("c的值是：",c) myfunl(1,2,3) # 1 --- a 2 ----b 3----c myfunl(4,5,6)
序列传参
序列传参是指在函数调用过程中，用*将序列拆解后按位置进行传递的
传参方式
# 示例见： # 此示例示意序列传参 def myfunl(a,b,c): "这是一个函数的传参的示例" print("a的值是：",a) print("b的值是：",b) print("c的值是：",c) l1=[11,22,33] t2=(100,200,300) s3="ABC" myfunl(l1[0],l1[1],l1[2]) # li[0](将11)---> a, L1[1] myfunl(*l1) # 等同于myfunl(l1[0],l1[1],l1[2]) myfunl(*t2) myfunl(s3[0],s3[1],s3[2]) myfunl(*s3) # 说明： # 序列传参时，序列拆解的位置将与形参一一对应
关键字传参：
关键字传参是指传参时，按着形参的名称给形参赋值
实参和形参按名称进行匹配
# 示例见； # 此示例示意关键字传参 def myfunl(a,b,c): "这是一个函数的传参的示例" print("a的值是：",a) print("b的值是：",b) print("c的值是：",c) myfunl(c=3,a=1,b=2) myfunl(c=33,a=11,b=22+3) # 说明： # 实参和形参接形参名进行匹配，可以不接位置进行匹配
字典关键字传参：
是指实参为字典，将字典用**拆解后进行关键字传参的传参方式
# 示例见； def myfunl(a,b,c): "这是一个函数的传参的示例" print("a的值是：",a) print("b的值是：",b) print("c的值是：",c) d1 = {"c":33,"a":11,"b":22} myfunl(c=d1["c"],a=d1["a"],b=d1["b"]) #33---->c,11---->a myfunl(**d1) #拆解字典，在按关键字传参方式传递 # 说明： # 字典的键名和形参名必须一致 # 字典的键名必须为符合标识符命名规则的字符串 # 字典的键名要在形参中存在
练习：
# 已知有列表： L = [1,2,True,None,3.14] # 调用print函数，打印用“#”号分隔的文字信息到终端上 print(...) #打印 1#2#True#None#3.14 l = [1,2,True,None,3.14] print(*l,sep="#")# 打印 1#2#True#None#3.14
函数的综合传参：
1.函数的传参方式，在能确定形参能唯一匹配到相应实参的情况
下可以任意组合
2.函数的位置传参要先于关键字传参
# 示例： def myfun1(a,b,c) pass myfun1(100,c=300,b=200) #正确 myfun1(c=300,b=200,100) #错的 myfun1(100,*[200,300]) #正确 myfun1(*[100,200],300) #正确 myfun1(100,*[200],300) #正确 myfun1(100,**{"c":300,"b":200}) #正确 myfun1(**{"c":300,"b":200},a=100) #正确 # 可变 和 不可变的类型的容器作为实参传递的区别： # 可变类型的实参作为参数传递时，在函数内部可以改变容器内的数据
# 示例见： # 此示例示意，当函数的实参为可变数据类型时，在函数内部可以改为容器的内容 l = [1,2,3,4] t = (1.1,2.2,3.3,4.4) def append_5(x): # x.append(5) x += (5,)#新的x元组 append_5(l) print(l) append_5(t) #不存在 print(t)
练习
# 写一个函数，此函数读取用户输入的数据，最后保存于全局变量的列表 # l中，当用户输入小于零的数时结束输入 l=[] def input_number(l1): while True: x = int(input("请输入：")) if x<0: break l1.append(x) input_number(l) print(l) input_number(l) print(l)
以下讲函数的定义（创建函数的def语句的形参列表）
# 函数的缺省参数： # 语法： # def 函数名（形参名1 = 默认实参1，形参2=默认实参2，...）： # 语句块 # 示例见： def info(name,age=1,address="不详"): print(name,"今年",age,"岁.家庭住址",address) info("路飞",35,"北京市朝阳区") info("tarena",15) info("小飞")
说明：
缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其
右侧的所有参数都必须有缺省参数，如：
def test_fn(a,b=10,c): 是错的
缺省参数可以有0个，1个或多个，甚至全部都有缺省参数
# 示例： def fn(a,b=10,c):# 错误 pass def fn（a=0,b=10,c=20） # 这是对的 pass
练习：
# 写一个函数myadd，此函数可以计算两个数，三个数及四个数的和 def myadd（...）： .... print(myadd(10,20))#30 print(myadd(100,200,300))#600 print(myadd(1,2,3,4))#10 def myadd(a,b,c=0,d=0): return a + b+ c +d print(myadd(10,20)) print(myadd(100,200,300)) print(myadd(1,2,3,4,))
函数形参的定义方式：
1.位置形参
2.型号的元组形参
3.命名关键字形参
4.双星号字典形参
# 位置形参 # 语法： # def 函数名（形参名1，形参名2...）： # 语句块 # 星号无组形参： # 语法： # def 函数名（*元组形参名）： # 语句块 # 作用： # 收集多余的位置传参 # 说明： # 在一个函数定义中元组形参名最多只能有一个，一般命名为"args" # 示例见： # 此示例示意星号元组形参的定义和使用 def func(*args): print("实参个数是",len(args)) print("args=",args) func(1,2,3,4) func(5,6,7,8,"A","B","C","D") func()
练习：
# 写一个函数 mysun 可以传入任意个数字实参，返回所有实参的和 # def mysum(*args): # ... # print(mysum(1,2,3,4)) # print(mysum(,1,3,5,7,9)) # 方法1 def mysum(*args): s = 0 for x in args: s +=x return s print(mysum(1,2,3,4)) print(mysum(1,3,5,7,9)) # 方法2 def mysum(*args): return sum(args) print(mysum(1,2,3,4)) print(mysum(1,3,5,7,9))
命名关键字形参
# 语法： # def 函数名（*，命名关键字形参1，命名关键字形参2，...）： # 语句块 # 或 # def 函数名（*args，命名关键字形参1，命名关键字形参2，..） # 语句块 # 作用： # 强制所有的参数都必须用关键字传参或字典关键了传参 # 示例见： # named_keyword_args.py # 此示例示意在函数形参中定义命名关键字形参，强制让函数调用使用命名# 关键字传参： def funcl(a,b,*,c,d): print(a,b,c,d) funcl(1,2,3,4) # 报错 funcl(1,2,c=30,d=40) funcl(a=10,b=20,c=30,d=40) def funcl(a,b,*args,c,d): print(a,b,args,c,d) funcl(1,2,3,4) # 报错 funcl(1,2,c=30,d=40) funcl(a=10,b=20,c=30,d=40) funcl(1,2,3,4,d=400,c=300) funcl(*"ABCDEFG",**{"c":999,"d":888})
双星号字典形参
# 语法： # def 函数名（**字典形参名） # 语句块 # 作用： # 收集多余的关键字传参 # 说明： # 字典形参名一般命名"kwargs" # 一个函数内字典形参最多只能有一个 # 示例见： # 此示例示意用双星号字典形参接收多余的关键字传参 def func(**kwargs): print("关键字传参的个数是：",len(kwargs)) print("kwargs=",kwargs) func(name="weimingze",age=35,address="北京时朝阳区") func(a=1,b=2) def func(a,b,**kwargs): print("关键字传参的个数是：",len(kwargs)) print("kwargs=",kwargs) func(a=1,b=2,c=3) # 函数的参数说明： # 位置形参，缺省参数，星号元组形参，双星号字典形参可以混合使用
函数参数自左自右的顺序为：
# 1.位置形参 # 2.星号元组形参 # 3.命名关键字形参 # 4.双星号字典形参 # 示例： def fn(a,b=20,*args,c=30,d=40,**kwargs): pass fn(1) fn(100,200,300,400,c="C",d="D",e="E")
练习：
# 已知内建函数max帮助文档为： # max（...） # max（iterable） -> value # max(arg1,arg2,*args) -> value # 仿造 max写一个mymax函数，功能与max完全相同 #（要求不允许调用max'） # 测试程序如下： # print(mymax([6,8,3,5])) #8 # print(mymax(100,200)) #200 # print(mymax(1,3,5,7,9)） #9 # 方法1 def mymax(*args): if len(args)==1: #判断是否是一个可迭代参数的情况 l = args[0] #一定绑定一个可迭代对象 zuida = l[0] for x in l: if x >zuida: zuida = x return zuida else: #否则有多个参数的情况 zuida = args[0] for x in args: if x>zuida: zuida = x return zuida print(mymax([1,3,5,7,9])) print(mymax(100,200)) print(mymax(6,8,3,5)) # 方法2 def mymax(a,*args): if len(args)==0: #判断是否是一个可迭代参数的情况 l = a #一定绑定一个可迭代对象 zuida = l[0] for x in l: if x >zuida: zuida = x return zuida else: #否则有多个参数的情况 zuida = a for x in args: if x>zuida: zuida = x return zuida
全局变量和局部变量
局部变量：local varible:
定义在函数内部的变量称为局部的变量（函数的形参也是局部变量）
局部变量只能在函数内部使用
局部变量在函数调用时才能够被创建，在函数调用之后会自动销毁
当有同名的全局变量和局部变量时，优先访问局部变量
全局变量：global variable:
定义在函数外部，模块内部的变量称为全局变量
全局变量，所有函数都可以直接访问（但函数内不能将其直接赋值）
局部变量说明：
在函数内部赋值语句不会对全局变量造成影响
局部变量只能在其被声明的函数内部访问，而全局变量可以在整数模块范围内访问
# 示例见： # global_local.py # 此示例示意全局变量的定义和局部变量的定义 a = 100 b = 200 c = 999999 def fx(c): a = 1 # 创建局部变量，并没有改变全局变量 d = 400 print(a,b,c,d) fx(300) print("a=",a) print("b=",b) print("c=",c)
# globals 和 locals 函数： # globals() 返回当前全局作用域内变量的字典 # locals（） 返回当前局部作用域内变量的字典
# 示例见： # globals_and_locals.py # 此示例示意全局变量的定义和局部变量的定义 a = 100 b = 200 c = 999999 def fx(c): a = 1 # 创建局部变量，并没有改变全局变量 d = 400 print(a,b,c,d) fx(300) print("a=",a) print("b=",b) print("c=",c) # 此示例示意globals 和 locals 函数的使用方法 a = 1 b = 2 c = 3 def fn(c,d): e = 300 # 此处有多少个局部变量？ print("locals()返回：",locals()) # 此处有多少个全局变量？ print("locals()返回：",globals()) print(c) print(globals()["c"]) fn (100,200)