本节内容：
- 函数的定义、性质与调用
- 函数的参数类型
- 高阶函数
- 全局变量
| 函数的定义、性质与调用 |
什么是函数？
函数是带名字的代码块，用于完成具体的工作。函数能提高应用的模块性，和代码的重复利用率。
在Python中提供了许多内建函数，比如print()。也可以自己创建函数，称为用户自定义函数。
格式
def 函数名(形参表):
函数体语句序列
[return 表达式] #可选项，即有的函数可以没有返回值。
函数调用
函数名(实参表)
定义函数
- 函数代码块以def关键字开头，后接函数标识符和圆括号（）；
- 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数；
- 函数的第一行语句可以选择性地使用文档字符串---用于存放函数说明；
- 函数内容以冒号起始，并且缩进。
- return[表达式]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。
-
说明：
- 函数必须先定义，后使用；
- 函数名与变量名的命名规则相同，只能包含字母，数字和下划线_且不能以数字打头。
函数性质
- 增强代码重用性
- 保持一致性
- 增强可扩展性
语法：
def test(x):
'''该函数是学到的第一个函数，执行参数加1的操作，
最终得到的结果是参数执行加法运算的结果
'''
x+=1
return x
print(test(2222))
#输出结果：2223
例：
# 圆面积
import cmath
def area(radius):
return cmath.pi*radius**2
print(area(5.5))
print(2*(area(3)+area(4)))
#输出结果：
#95.03317777109125
#157.07963267948966
'''显示简单的问候语'''
def greet_user(username):
print("Hello," + username.title() + "!")
greet_user("lizi")
#输出结果：Hello,Lizi!
|
函数的参数类型 |
函数的参数
1.在C、C++中，参数的传递有值传递和引用传递两种方式。Python中任何东西都是对象，所以参数只支持引用传递的方式。
2.Python通过名称绑定的机制，把实际参数的值和形式参数的名称绑定在一起，形式参数和实际参数指向内存中同一个存储空间。
注意：向函数传递参数时，Python采用按引用传递的方式。这意味着当传递参数时，函数将使用新变量名来引用原始值。
例：
'''求两数之和'''
def add(a,b):
return a+b
x,y = 3,4
print(x,"+",y,"=",add(x,y))
#输出结果：
#3 + 4 = 7
实际参数类型（调用函数时）
位置实参，关键字实参，解构实参
- 实际参数，占用内存
- 像上述例子代码greet_user("lizi")中，值“lizi”就是一个实参。
- 实参是调用函数时传递给函数的信息。
形式参数类型（定义函数时）
普通参数，默认值参数，位置参数，关键字参数
- 形式参数，不占用内存。
- 像上述例子函数greet_user()的定义中，变量username就是一个形参。
- 形参是函数完成其工作所需的一项信息。
默认参数
def test(x,y): #x,y:形式参数---形参（不占内存）
print(x)
print(y)
test(1,2) #1,2:实际参数---实参（占用实际内存）
#输出结果：1
#输出结果：2
x，y这两个参数，又叫位置参数（x,y）=（个数，位置）
位置参数调用
必须与形式参数一一对应
def test(x,y):
print(x)
print(y)
test(y=9,x=8)
#位置参数调用：必须与形参一一对应
#关键字参数调用：与形参位置没有关系
#关键字参数不能写在位置参数之后
# test(x=2,6) #错误
test(3,y=9)
# test(9,x=5) #错误,3已默认赋给x，重复赋值，错误
#输出结果：8
#输出结果：9
#输出结果：3
#输出结果：9
默认参数
函数的参数支持默认值。当某个参数没有传递实际的值时，函数将使用默认参数计算。
带默认值的参数不能位于没有默认值的参数前面。
调用函数时，默认参数非必须传递（类似端口）
例：默认值参数示例。
def test(x,y=0):
print(x)
print(y)
test(2,3)
test(2) #此时y默认为0
#输出结果：2
#输出结果：3
#输出结果：2
#输出结果：0
参数组
- 位置可变参数（*）
在形式参数名称前加一个星号*，则代表使用该形式参数可以接收任意多个参数，而且接收的参数将会以元组的方式组织。（参数数目不固定）
例1：只有位置可变参数时
'''简单位置可变参数的实现'''
def test(*args): # 习惯性写args参数
print(args) # args以元组的方式组织传入的实参
test(1,2,3)
#输出结果：(1, 2, 3)
'''简单位置可变参数的实现2'''
def test(*args):
print(args)
test({1:"1",2:"2"},{3:"3"})
#输出结果：({1: '1', 2: '2'}, {3: '3'})
例2：与其他参数连用时：
'''位置可变参数与位置参数连用'''
def test(x,*args): #至少传入一个参数
print(x)
print(args)
test(1,2)
test(1,[1,2,3,4])
#输出结果：1
#输出结果：(2,)
#输出结果：1
#输出结果：([1, 2, 3, 4],)
- 关键字可变参数（**）
在形式参数名称前加两个星号**，则代表使用该形式参数可以接收任意多个传入的键-值对参数(关键字实参)，而且接收的参数将会以字典的方式组织。
例1：只有关键字可变参数
'''简单关键字可变参数的实现'''
def test(**kwargs):
print(kwargs) # kwargs以字典的方式组织传入的关键字实参
test(name="lizi", age=18) # 字典类型
#输出结果：{'name': 'lizi', 'age': 18}
'''简单关键字可变参数的实现2'''
def func(**kwargs):
print(kwargs)
func(name = "yin",age = 18,sex = "girl")
#输出结果：
#{'name': 'yin', 'age': 18, 'sex': 'girl'}
例2：关键字可变参数与其他类型参数连用时
def test(x,**kwargs):
print(x)
print(kwargs)
test("lizi",age = 18,sex = "girl")
#输出结果：lizi
#输出结果：{'age': 18, 'sex': 'girl'}
def test(x,age = 18,**kwargs):
print(x)
print(age)
print(kwargs)
test("lizi",18,sex = "girl")
#输出结果：lizi
#输出结果：18
#输出结果：{'sex': 'girl'}
注意：
- *args与**kwargs是Python中的可变参数。
- *args表示任何多个无名参数，它是一个元组（tuple）；
- **kwargs表示关键字参数，它是一个字典（dict）；
- 同时使用*args与**kwargs时，*args参数必须在**kwargs参数之前。
def test(name,age = 18,*args,**kwargs):
print(name)
print(age)
print(args)
print(kwargs)
test("lizi",18,sex = "girl")
#输出结果：lizi
#输出结果：18
#输出结果：()
#输出结果：{'sex': 'girl'}
- 参数组传入参数，以位置方式；
- 字典传入参数，以关键字方式；
- 参数为参数组，字典参数时，该参数必须放在函数后面。
| 高阶函数 |
局部变量（局部作用域）：
def change(x):
print("before change:",x)
x = "lizi"
print("after change:",x)
name = "QQ"
change(name)
print(name)
#输出结果：before change: QQ
#输出结果：after change: lizi
#输出结果：QQ
全局变量（全局作用域）：
- 数字，字符串的全局变量在局部变量中不能直接修改
- 列表，字典，集合的全局变量在局部可以修改
school = "SX"
def change_school(name):
global school #global:将局部变量修改为全局变量
school = "LG"
print(name)
print(school)
change_school(school)
print(school)
#输出结果：SX
#输出结果：SX
#输出结果：LG
name=[1,2,3,4,5]
def change():
name[2]="00000"
print(name)
change()
print(name)
#输出结果：[1, 2, '00000', 4, 5]
#输出结果：[1, 2, '00000', 4, 5]
递归算法：
下面有两个列子：
def HH(n):
print(n)
if int(n/2)>0:
return HH(int(n/2))
HH(10)
#输出结果：10
#输出结果：5
#输出结果：2
#输出结果：1
#10以内的和
Sum = 0
def ADD(n):
global Sum
Sum += n
if n>0:
return ADD(n-1)
print(Sum)
ADD(10)
#输出结果：55
高阶函数：变量指向函数，函数可以接收参数
def ADD(a,b,f): #a,b相当于f的对象
return f(a)+f(b)
print(ADD(2,3,abs)) #abs绝对值
print(ADD(-2,-3,abs))
#输出结果：5
#输出结果：5
修饰器：
import time
def bar():
time.sleep(3)
print("in the bar")
# "修饰器，修饰bar()函数"
def test(func):
Start_time = time.time()
func()
Stop_time = time.time()
print(Stop_time - Start_time)
return func '''返回func函数本身'''
test(bar)
#输出结果：in the bar
#输出结果：3.0010018348693848
import time
def bar():
time.sleep(3)
print("in the bar")
# "修饰器，修饰bar()函数"
def test(func):
Start_time = time.time()
func()
Stop_time = time.time()
print(Stop_time - Start_time)
# return func #返回func函数本身
return func() '''返回的是func() 执行后的返回值,即bar()函数'''
test(bar)
#输出结果：in the bar
#输出结果：3.0001494884490967
#输出结果：in the bar
PS：注意return func函数与return func()函数的区别
装饰器：
- 为原函数增加功能，但是不能修改原函数；
- 不能修改原函数调用方式。
import time
def timmer(func):
def foo():
Start_time = time.time()
func()
Stop_time = time.time()
print("the func runtime: %s" % (Stop_time - Start_time))
return foo
@timmer #语法糖：完成地址转换 相当于test = timmer(test)
def test():
time.sleep(3)
print("in the test")
test()
#输出结果：in the test
#输出结果：the func runtime: 3.0001003742218018
import time
def timmer(func):
def foo(*args,**kwargs):
Start_time=time.time()
func(*args,**kwargs)
Stop_time=time.time()
print(Stop_time-Start_time)
return foo
@timmer #test=timmer(test)=foo
def test(x,y,z):
time.sleep(3)
print("in the test")
print(x,y,z)
test(2,4,5)
#输出结果：in the test
#输出结果：2 4 5
#输出结果：3.000138998031616
PS：可以利用函数完成登陆窗口的练习。