Python 09 函数

　函数：

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

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

　　定义函数：

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

　　语法：

def test(x):
    '''该函数是学到的第一个函数，执行参数加1的操作，
    最终得到的结果是参数执行加法运算的结果
    '''
    x+=1
    return x
print(test(2222))

#输出结果：2223

　　函数性质：

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

　　向函数传递信息：

'''显示简单的问候语'''
def greet_user(username):
    print("Hello," + username.title() + "!")
greet_user("lizi")

#输出结果：Hello,Lizi!

　　实参：

实际参数，占用内存
像上述例子代码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)    #错误，此时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

　　参数组：

参数数目不固定

def test(*args):       #习惯性写args参数
    print(args)
test(1,2,3)

#输出结果：(1, 2, 3)

def test(x,*args):       #至少传入一个参数
    print(x)
    print(args)
test(1,2)
test(1,[1,2,3,4])

#输出结果：1
#输出结果：(2,)
#输出结果：1
#输出结果：([1, 2, 3, 4],)

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 test(*args):
    print(args)
test({1:"1",2:"2"},{3:"3"})

def test(**kwargs):
    print(kwargs)
test(name="lizi", age=18)  # 字典类型

#输出结果：({1: '1', 2: '2'}, {3: '3'})
#输出结果：{'name': 'lizi', 'age': 18}

　　局部变量（局部作用域）：

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

猜你喜欢