Python 函数

本节内容：

• 函数的定义、性质与调用
• 函数的参数类型
• 高阶函数
• 全局变量

函数的定义、性质与调用

什么是函数？

　　函数是带名字的代码块，用于完成具体的工作。函数能提高应用的模块性，和代码的重复利用率。

　　在Python中提供了许多内建函数，比如print()。也可以自己创建函数，称为用户自定义函数。

格式

　　def 函数名(形参表):

　　函数体语句序列

　　[return 表达式]    #可选项，即有的函数可以没有返回值。

函数调用

　　函数名(实参表)

定义函数

• 函数代码块以def关键字开头，后接函数标识符和圆括号（）；
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数；
• 函数的第一行语句可以选择性地使用文档字符串---用于存放函数说明；
• 函数内容以冒号起始，并且缩进。
• return[表达式]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。

• 说明：

  1. 函数必须先定义，后使用；
  2. 函数名与变量名的命名规则相同，只能包含字母，数字和下划线_且不能以数字打头。

函数性质

• 增强代码重用性
• 保持一致性
• 增强可扩展性

语法：

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：可以利用函数完成登陆窗口的练习。